fix: multiple bug fixes

Author: nikolay-e

.github/workflows/cd.yml

@@ -184,7 +184,7 @@ jobs:
           echo "PYTHONPATH: $PYTHONPATH"
 
           # Run PyInstaller with explicit paths
-          python -m PyInstaller --clean -y --dist ./dist/${{ matrix.asset_name }} treemapper.spec
+          python -m PyInstaller --clean -y --distpath "./dist/${{ matrix.asset_name }}" treemapper.spec
 
           # Verify the built executable exists (cross-platform)
           echo "Checking for built executable in: ./dist/${{ matrix.asset_name }}/"

.github/workflows/ci.yml

@@ -86,8 +86,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-22.04, ubuntu-24.04, macos-latest, windows-latest]
-        python-version: [3.9, '3.10', '3.11', '3.12']
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python-version: [3.9, '3.10', '3.11', '3.12', '3.13']
 
     runs-on: ${{ matrix.os }}
 
@@ -137,7 +137,7 @@ jobs:
 
       - name: Upload coverage for SonarCloud
         uses: actions/upload-artifact@v6
-        if: matrix.os == 'ubuntu-22.04' && matrix.python-version == '3.12'
+        if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.12'
         with:
           name: coverage-report
           path: |
@@ -336,7 +336,7 @@ jobs:
           sonar.tests=tests
           sonar.python.coverage.reportPaths=coverage.xml
           sonar.python.xunit.reportPath=test-results.xml
-          sonar.python.version=3.9,3.10,3.11,3.12
+          sonar.python.version=3.9,3.10,3.11,3.12,3.13
           EOF
 
       - name: SonarCloud Scan

.treemapperignore

@@ -0,0 +1 @@
+tests

CLAUDE.md

@@ -41,22 +41,37 @@ children:
 ```bash
 treemapper .                          # YAML to stdout
 treemapper . -o tree.yaml             # save to file
+treemapper . -o -                     # explicit stdout output
 treemapper . --format json            # JSON format
 treemapper . --format text            # tree-style text
 treemapper . --no-content             # structure only (no file contents)
 treemapper . --max-depth 3            # limit directory depth
 treemapper . --max-file-bytes 10000   # skip files larger than 10KB
 treemapper . -i custom.ignore         # custom ignore patterns
+treemapper . --no-default-ignores     # disable .gitignore/.treemapperignore (custom -i still works)
+treemapper . -v 2                     # verbose output (0=ERROR, 1=WARNING, 2=INFO, 3=DEBUG)
+treemapper --version                  # show version
 ```
 
 ## Python API
 
 ```python
 from treemapper import map_directory, to_yaml, to_json, to_text
 
-# Get tree as dict
+# Full function signature
+tree = map_directory(
+    path,                              # directory path (str or Path)
+    max_depth=None,                    # limit traversal depth
+    no_content=False,                  # exclude file contents
+    max_file_bytes=None,               # skip files larger than N bytes
+    ignore_file=None,                  # custom ignore file path
+    no_default_ignores=False,          # disable .gitignore/.treemapperignore
+)
+
+# Examples
 tree = map_directory("./myproject")
 tree = map_directory("./src", max_depth=2, no_content=True)
+tree = map_directory(".", max_file_bytes=50000, ignore_file="custom.ignore")
 
 # Serialize to string
 yaml_str = to_yaml(tree)
@@ -68,6 +83,20 @@ text_str = to_text(tree)
 
 Respects `.gitignore` and `.treemapperignore` automatically. Use `--no-default-ignores` to include everything.
 
+Features:
+- Hierarchical: nested `.gitignore`/`.treemapperignore` files work at each directory level
+- Negation patterns: `!important.log` un-ignores a file
+- Anchored patterns: `/root_only.txt` matches only in root, `*.log` matches everywhere
+- Output file is always auto-ignored (prevents recursive inclusion)
+
+## Content Placeholders
+
+When file content cannot be read normally, placeholders are used:
+- `<file too large: N bytes>` — file exceeds `--max-file-bytes` limit
+- `<binary file: N bytes>` — file detected as binary (contains null bytes)
+- `<unreadable content: not utf-8>` — file is not valid UTF-8
+- `<unreadable content>` — file cannot be read (permission denied, I/O error)
+
 ## Development
 
 ```bash

docs/Clipboard Copy.md

@@ -0,0 +1,103 @@
+# Plan: Clipboard Copy Feature
+
+Add `--copy/-c` and `--copy-only` flags to copy output to system clipboard.
+
+## Design
+
+- **No external dependencies** — use native OS tools (pbcopy, xclip, wl-copy)
+- **Error handling** — warning to stderr, exit 0 (non-critical)
+- **Feedback** — `Copied to clipboard (12.5 KB)` to stderr
+
+## Flag Behavior
+
+| Flags | stdout | file | clipboard |
+|-------|--------|------|-----------|
+| (none) | ✓ | - | - |
+| `-o file` | - | ✓ | - |
+| `-c` / `--copy` | ✓ | - | ✓ |
+| `--copy -o file` | - | ✓ | ✓ |
+| `--copy-only` | - | - | ✓ |
+
+## Detection Logic
+
+```
+macOS: pbcopy
+Windows: clip.exe
+Linux (Wayland): wl-copy
+Linux (X11): xclip -selection clipboard
+```
+
+## Implementation
+
+### NEW: `src/treemapper/clipboard.py`
+
+```python
+import os
+import platform
+import shutil
+import subprocess
+
+class ClipboardError(Exception):
+    pass
+
+def detect_clipboard_command() -> list[str] | None:
+    system = platform.system()
+    if system == "Darwin":
+        return ["pbcopy"]
+    if system == "Windows":
+        return ["clip"]
+    if system in ("Linux", "FreeBSD"):
+        if os.environ.get("WAYLAND_DISPLAY") and shutil.which("wl-copy"):
+            return ["wl-copy"]
+        if os.environ.get("DISPLAY") and shutil.which("xclip"):
+            return ["xclip", "-selection", "clipboard"]
+    return None
+
+def copy_to_clipboard(text: str) -> None:
+    cmd = detect_clipboard_command()
+    if cmd is None:
+        raise ClipboardError("No clipboard tool found")
+    proc = subprocess.Popen(cmd, stdin=subprocess.PIPE, stderr=subprocess.PIPE)
+    _, stderr = proc.communicate(input=text.encode("utf-8"), timeout=5)
+    if proc.returncode != 0:
+        raise ClipboardError(stderr.decode())
+
+def clipboard_available() -> bool:
+    return detect_clipboard_command() is not None
+```
+
+### UPDATE: `cli.py`
+
+```python
+# ParsedArgs
+copy: bool
+copy_only: bool
+
+# Arguments
+parser.add_argument("-c", "--copy", action="store_true")
+parser.add_argument("--copy-only", action="store_true")
+```
+
+### UPDATE: `treemapper.py`
+
+```python
+if args.copy:
+    try:
+        copy_to_clipboard(output_content)
+        print(f"Copied to clipboard ({len(output_content) / 1024:.1f} KB)", file=sys.stderr)
+    except ClipboardError as e:
+        logging.warning(f"Clipboard: {e}")
+
+if args.copy_only and args.output_file is None:
+    return
+```
+
+## Testing
+
+Skip clipboard tests in CI (no display):
+
+```python
+@pytest.mark.skipif(os.environ.get("CI") or not os.environ.get("DISPLAY"))
+def test_clipboard_roundtrip():
+    pass
+```

docs/Token Counting.md

@@ -0,0 +1,81 @@
+# Plan: Token Counting Feature
+
+Add `--tokens` flag to show token count for LLM context planning.
+
+## Design
+
+- **tiktoken** as optional dependency with fallback to `chars / 4`
+- **o200k_base** encoding (GPT-4o default)
+- Output to stderr only when TTY (don't break pipes)
+
+## Implementation
+
+### UPDATE: `pyproject.toml`
+
+```toml
+[project.optional-dependencies]
+tokens = ["tiktoken>=0.7,<1.0"]
+```
+
+### NEW: `src/treemapper/tokens.py`
+
+```python
+import sys
+from dataclasses import dataclass
+from functools import lru_cache
+
+@dataclass
+class TokenCountResult:
+    count: int
+    is_exact: bool
+    encoding: str
+
+@lru_cache(maxsize=4)
+def _get_encoder(encoding: str):
+    try:
+        import tiktoken
+        return tiktoken.get_encoding(encoding)
+    except (ImportError, Exception):
+        return None
+
+def count_tokens(text: str, encoding: str = "o200k_base") -> TokenCountResult:
+    encoder = _get_encoder(encoding)
+    if encoder:
+        return TokenCountResult(len(encoder.encode(text)), True, encoding)
+    return TokenCountResult(len(text) // 4, False, "approximation")
+
+def print_token_summary(text: str, encoding: str = "o200k_base") -> None:
+    if not sys.stderr.isatty():
+        return
+    result = count_tokens(text, encoding)
+    prefix = "" if result.is_exact else "~"
+    print(f"{prefix}{result.count:,} tokens ({result.encoding})", file=sys.stderr)
+```
+
+### UPDATE: `cli.py`
+
+```python
+# ParsedArgs
+show_tokens: bool
+token_encoding: str
+
+# Arguments
+parser.add_argument("--tokens", action="store_true")
+parser.add_argument("--token-encoding", choices=["o200k_base", "cl100k_base"], default="o200k_base")
+```
+
+### UPDATE: `treemapper.py`
+
+```python
+if args.show_tokens:
+    print_token_summary(output_content, args.token_encoding)
+```
+
+## Usage
+
+```bash
+treemapper . --tokens                    # 12,847 tokens (o200k_base)
+treemapper . --tokens --copy             # tokens + clipboard
+
+pip install treemapper[tokens]           # exact counts with tiktoken
+```

pyproject.toml

@@ -21,14 +21,26 @@ description = "Export codebase structure and contents for AI/LLM context"
 readme = "README.md"
 requires-python = ">=3.9"
 license = { file = "LICENSE" }
+keywords = ["code-analysis", "directory-tree", "yaml", "json", "llm", "ai", "codebase", "context", "chatgpt", "claude", "code-context", "export", "tree"]
 classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
     "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "License :: OSI Approved :: Apache Software License",
     "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Utilities",
+    "Typing :: Typed",
 ]
 dependencies = [
-    "pathspec>=0.9,<1.0",
-    "pyyaml>=5.4,<7.0",
+    "pathspec>=0.11,<2.0",
+    "pyyaml>=6.0.2,<8.0",
 ]
 
 [project.urls]

src/treemapper/ignore.py

@@ -3,7 +3,7 @@
 from pathlib import Path
 from typing import List, Optional
 
-import pathspec  # type: ignore
+import pathspec
 
 
 def read_ignore_file(file_path: Path) -> List[str]:
@@ -13,7 +13,13 @@ def read_ignore_file(file_path: Path) -> List[str]:
 
     try:
         with file_path.open("r", encoding="utf-8") as f:
-            ignore_patterns = [line.strip() for line in f if line.strip() and not line.startswith("#")]
+            for line in f:
+                stripped = line.rstrip("\n\r")
+                if not stripped.strip():
+                    continue
+                if stripped.startswith("#"):
+                    continue
+                ignore_patterns.append(stripped.rstrip())
         logging.info(f"Using ignore patterns from {file_path}")
         logging.debug(f"Read ignore patterns from {file_path}: {ignore_patterns}")
     except PermissionError:
@@ -61,10 +67,13 @@ def _aggregate_ignore_patterns(root: Path, ignore_filename: str) -> List[str]:
             neg = line.startswith("!")
             pat = line[1:] if neg else line
 
-            if pat.startswith("/"):
-                full = f"/{rel}{pat}" if rel else pat
+            if pat.startswith("/") or "/" in pat:
+                anchored_pat = pat.lstrip("/")
+                full = f"/{rel}/{anchored_pat}" if rel else f"/{anchored_pat}"
+            elif rel:
+                full = f"{rel}/**/{pat}"
             else:
-                full = f"{rel}/{pat}" if rel else pat
+                full = pat
 
             out.append(("!" + full) if neg else full)
 
@@ -123,8 +132,8 @@ def get_ignore_specs(
 
     if not no_default_ignores:
         patterns.extend(DEFAULT_IGNORE_PATTERNS)
-        patterns.extend(_aggregate_ignore_patterns(root_dir, ".treemapperignore"))
         patterns.extend(_aggregate_ignore_patterns(root_dir, ".gitignore"))
+        patterns.extend(_aggregate_ignore_patterns(root_dir, ".treemapperignore"))
 
     if custom_ignore_file:
         patterns.extend(read_ignore_file(custom_ignore_file))

src/treemapper/logger.py

@@ -2,7 +2,6 @@
 
 
 def setup_logging(verbosity: int) -> None:
-    """Configure the logging level based on verbosity."""
     level_map = {
         0: logging.ERROR,
         1: logging.WARNING,