fix: broken pipe handling, gitignore parsing, PyInstaller flag

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 }}/"

.treemapperignore

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

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
+```

src/treemapper/ignore.py

@@ -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:

src/treemapper/tree.py

@@ -92,11 +92,11 @@ def _read_file_content(file_path: Path, max_file_bytes: Optional[int]) -> str:
 
         if max_file_bytes is not None and file_size > max_file_bytes:
             logging.info(f"Skipping large file {file_path.name}: {file_size} bytes > {max_file_bytes} bytes")
-            return f"<file too large: {file_size} bytes>"
+            return f"<file too large: {file_size} bytes>\n"
 
         if _is_binary_file(file_path):
             logging.debug(f"Detected binary file {file_path.name}")
-            return f"<binary file: {file_size} bytes>"
+            return f"<binary file: {file_size} bytes>\n"
 
         content = file_path.read_text(encoding="utf-8")
         cleaned = content.replace("\x00", "")

src/treemapper/treemapper.py

@@ -1,3 +1,37 @@
+import errno
+import os
+import sys
+from contextlib import contextmanager
+from typing import Generator
+
+
+@contextmanager
+def _handle_broken_pipe() -> Generator[None, None, None]:
+    try:
+        yield
+        sys.stdout.flush()
+    except BrokenPipeError:
+        _suppress_broken_pipe()
+    except ValueError:
+        _suppress_broken_pipe()
+    except OSError as e:
+        if e.errno in (errno.EINVAL, errno.EPIPE):
+            _suppress_broken_pipe()
+        raise
+
+
+def _suppress_broken_pipe() -> None:
+    try:
+        devnull = os.open(os.devnull, os.O_WRONLY)
+        try:
+            os.dup2(devnull, sys.stdout.fileno())
+        finally:
+            os.close(devnull)
+    except Exception:
+        pass
+    sys.exit(0)
+
+
 def main() -> None:
     from .cli import parse_args
     from .ignore import get_ignore_specs
@@ -23,7 +57,11 @@ def main() -> None:
         "children": build_tree(args.root_dir, ctx),
     }
 
-    write_tree_to_file(directory_tree, args.output_file, args.output_format)
+    if args.output_file is None:
+        with _handle_broken_pipe():
+            write_tree_to_file(directory_tree, args.output_file, args.output_format)
+    else:
+        write_tree_to_file(directory_tree, args.output_file, args.output_format)
 
 
 if __name__ == "__main__":