fix: code review improvements - Python 3.13 compat, Unicode handling, performance

- Update dependencies for Python 3.13: pathspec>=0.11, pyyaml>=6.0.2
- Handle Unicode line separators (U+2028, U+2029) in YAML output
- Add middle-slash pattern detection for proper gitignore anchoring
- Add BrokenPipeError handling for stdout piping
- Optimize file reading: single binary read instead of double read
- Remove obsolete type ignore comments (pathspec now has types)
- Thread-safe YAML representer registration with Lock
- Use IsADirectoryError and proper PermissionError handling
- Update to Production/Stable status, add Typing::Typed classifier
- Simplify CI matrix: ubuntu-latest instead of ubuntu-22.04/24.04
- Add tests for Unicode, binary boundary, deep nesting, middle-slash

Author: nikolay-e

.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

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]:
@@ -67,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)
 

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,

src/treemapper/tree.py

@@ -3,10 +3,12 @@
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-import pathspec  # type: ignore
+import pathspec
 
 from .ignore import should_ignore
 
+BINARY_DETECTION_SAMPLE_SIZE = 8192
+
 
 @dataclass
 class TreeBuildContext:
@@ -49,7 +51,7 @@ def _process_entry(entry: Path, ctx: TreeBuildContext, current_depth: int) -> Op
     try:
         relative_path = entry.relative_to(ctx.base_dir).as_posix()
         is_dir = entry.is_dir()
-    except OSError as e:
+    except (OSError, ValueError) as e:
         logging.warning(f"Could not process path for entry {entry}: {e}")
         return None
 
@@ -94,11 +96,14 @@ def _read_file_content(file_path: Path, max_file_bytes: Optional[int]) -> str:
             logging.info(f"Skipping large file {file_path.name}: {file_size} bytes > {max_file_bytes} bytes")
             return f"<file too large: {file_size} bytes>\n"
 
-        if _is_binary_file(file_path):
+        with file_path.open("rb") as f:
+            raw_bytes = f.read()
+
+        if b"\x00" in raw_bytes[:BINARY_DETECTION_SAMPLE_SIZE]:
             logging.debug(f"Detected binary file {file_path.name}")
             return f"<binary file: {file_size} bytes>\n"
 
-        content = file_path.read_text(encoding="utf-8")
+        content = raw_bytes.decode("utf-8")
         cleaned = content.replace("\x00", "")
         if cleaned != content:
             logging.warning(f"Removed NULL bytes from content of {file_path.name}")
@@ -114,14 +119,6 @@ def _read_file_content(file_path: Path, max_file_bytes: Optional[int]) -> str:
     except UnicodeDecodeError:
         logging.error(f"Cannot decode {file_path.name} as UTF-8. Marking as unreadable.")
         return "<unreadable content: not utf-8>\n"
-    except IOError as e:
+    except OSError as e:
         logging.error(f"Could not read {file_path.name}: {e}")
         return "<unreadable content>\n"
-
-
-def _is_binary_file(file_path: Path, sample_size: int = 8192) -> bool:
-    try:
-        with file_path.open("rb") as f:
-            return b"\x00" in f.read(sample_size)
-    except (OSError, IOError):
-        return False

src/treemapper/writer.py

@@ -2,11 +2,14 @@
 import json
 import logging
 import sys
+import threading
 from pathlib import Path
 from typing import Any, Dict, Optional, TextIO
 
 import yaml
 
+YAML_PROBLEMATIC_CHARS = frozenset({"\x85", "\u2028", "\u2029"})
+
 
 class LiteralStr(str):
     pass
@@ -16,32 +19,34 @@ class QuotedStr(str):
     pass
 
 
+_yaml_representer_lock = threading.Lock()
 _yaml_representer_registered = False
 
 
 def _ensure_yaml_representer() -> None:
     global _yaml_representer_registered
     if _yaml_representer_registered:
         return
+    with _yaml_representer_lock:
+        if _yaml_representer_registered:
+            return
 
-    def literal_representer(dumper: yaml.SafeDumper, data: LiteralStr) -> yaml.ScalarNode:
-        style = "|" if data and not data.endswith("\n") else "|+"
-        return dumper.represent_scalar("tag:yaml.org,2002:str", data, style=style)
+        def literal_representer(dumper: yaml.SafeDumper, data: LiteralStr) -> yaml.ScalarNode:
+            style = "|+" if data.endswith("\n") else "|"
+            return dumper.represent_scalar("tag:yaml.org,2002:str", data, style=style)
 
-    def quoted_representer(dumper: yaml.SafeDumper, data: QuotedStr) -> yaml.ScalarNode:
-        # Use double-quote style to properly escape NEL (U+0085) and other special chars
-        return dumper.represent_scalar("tag:yaml.org,2002:str", str(data), style='"')
+        def quoted_representer(dumper: yaml.SafeDumper, data: QuotedStr) -> yaml.ScalarNode:
+            return dumper.represent_scalar("tag:yaml.org,2002:str", str(data), style='"')
 
-    yaml.add_representer(LiteralStr, literal_representer, Dumper=yaml.SafeDumper)
-    yaml.add_representer(QuotedStr, quoted_representer, Dumper=yaml.SafeDumper)
-    _yaml_representer_registered = True
+        yaml.add_representer(LiteralStr, literal_representer, Dumper=yaml.SafeDumper)
+        yaml.add_representer(QuotedStr, quoted_representer, Dumper=yaml.SafeDumper)
+        _yaml_representer_registered = True
 
 
 def _prepare_tree_for_yaml(node: Dict[str, Any]) -> Dict[str, Any]:
     result: Dict[str, Any] = {}
     for key, value in node.items():
-        if isinstance(value, str) and "\x85" in value:
-            # NEL (U+0085) must be quoted to preserve roundtrip - check FIRST
+        if isinstance(value, str) and any(c in value for c in YAML_PROBLEMATIC_CHARS):
             result[key] = QuotedStr(value)
         elif key == "content" and isinstance(value, str) and "\n" in value:
             result[key] = LiteralStr(value)
@@ -109,16 +114,19 @@ def write_tree_content(f: TextIO) -> None:
         except AttributeError:
             buf = None
 
-        if buf:
-            utf8_stdout = io.TextIOWrapper(buf, encoding="utf-8", newline="")
-            try:
-                write_tree_content(utf8_stdout)
-                utf8_stdout.flush()
-            finally:
-                utf8_stdout.detach()
-        else:
-            write_tree_content(sys.stdout)
-            sys.stdout.flush()
+        try:
+            if buf:
+                utf8_stdout = io.TextIOWrapper(buf, encoding="utf-8", newline="")
+                try:
+                    write_tree_content(utf8_stdout)
+                    utf8_stdout.flush()
+                finally:
+                    utf8_stdout.detach()
+            else:
+                write_tree_content(sys.stdout)
+                sys.stdout.flush()
+        except BrokenPipeError:
+            pass
 
         logging.info(f"Directory tree written to stdout in {output_format} format")
     else:
@@ -127,14 +135,14 @@ def write_tree_content(f: TextIO) -> None:
 
             if output_file.is_dir():
                 logging.error(f"Cannot write to '{output_file}': is a directory")
-                raise IOError(f"Is a directory: {output_file}")
+                raise IsADirectoryError(f"Is a directory: {output_file}")
 
             with output_file.open("w", encoding="utf-8") as f:
                 write_tree_content(f)
             logging.info(f"Directory tree saved to {output_file} in {output_format} format")
-        except PermissionError as e:
+        except PermissionError:
             logging.error(f"Unable to write to file '{output_file}': Permission denied")
-            raise IOError(f"Permission denied: {output_file}") from e
-        except IOError as e:
+            raise
+        except OSError as e:
             logging.error(f"Unable to write to file '{output_file}': {e}")
             raise

tests/test_coverage_gaps.py

@@ -1,6 +1,5 @@
 # tests/test_coverage_gaps.py
 import sys
-from pathlib import Path
 
 import pytest
 
@@ -316,6 +315,51 @@ def test_yaml_with_special_unicode_nel(tmp_path):
     assert parsed is not None
 
 
+def test_yaml_with_unicode_line_separators(tmp_path):
+    import yaml
+
+    project = tmp_path / "project"
+    project.mkdir()
+
+    ls_char = "\u2028"
+    ps_char = "\u2029"
+    (project / "line_sep.txt").write_text(f"line1{ls_char}line2")
+    (project / "para_sep.txt").write_text(f"para1{ps_char}para2")
+
+    tree = map_directory(project)
+    yaml_output = to_yaml(tree)
+
+    parsed = yaml.safe_load(yaml_output)
+    assert parsed is not None
+
+    line_sep_node = find_node_by_path(parsed, ["line_sep.txt"])
+    para_sep_node = find_node_by_path(parsed, ["para_sep.txt"])
+
+    assert line_sep_node is not None
+    assert ls_char in line_sep_node.get("content", "")
+    assert para_sep_node is not None
+    assert ps_char in para_sep_node.get("content", "")
+
+
+def test_yaml_literal_style_without_trailing_newline(tmp_path):
+    project = tmp_path / "project"
+    project.mkdir()
+
+    (project / "no_newline.txt").write_text("content without newline")
+
+    tree = map_directory(project)
+    yaml_output = to_yaml(tree)
+
+    assert "no_newline.txt" in yaml_output
+
+    import yaml
+
+    parsed = yaml.safe_load(yaml_output)
+    node = find_node_by_path(parsed, ["no_newline.txt"])
+    assert node is not None
+    assert "content without newline" in node.get("content", "")
+
+
 def test_empty_directory_handling(tmp_path):
     project = tmp_path / "project"
     project.mkdir()
@@ -363,3 +407,76 @@ def test_all_verbosity_levels(tmp_path):
     finally:
         root_logger.setLevel(original_level)
         root_logger.handlers = original_handlers
+
+
+def test_binary_detection_at_exact_boundary(tmp_path):
+    from treemapper.tree import BINARY_DETECTION_SAMPLE_SIZE
+
+    project = tmp_path / "project"
+    project.mkdir()
+
+    null_at_boundary = project / "null_at_boundary.bin"
+    content = b"x" * (BINARY_DETECTION_SAMPLE_SIZE - 1) + b"\x00" + b"y" * 100
+    null_at_boundary.write_bytes(content)
+
+    null_after_boundary = project / "null_after_boundary.txt"
+    content2 = b"x" * BINARY_DETECTION_SAMPLE_SIZE + b"\x00" + b"y" * 100
+    null_after_boundary.write_bytes(content2)
+
+    tree = map_directory(project)
+
+    boundary_node = find_node_by_path(tree, ["null_at_boundary.bin"])
+    after_node = find_node_by_path(tree, ["null_after_boundary.txt"])
+
+    assert boundary_node is not None
+    assert "<binary file:" in boundary_node.get("content", "")
+
+    assert after_node is not None
+    assert "x" * 100 in after_node.get("content", "")
+
+
+def test_deep_nesting_with_ignore_patterns(tmp_path):
+    project = tmp_path / "project"
+    project.mkdir()
+
+    depth = 12
+    current = project
+    for i in range(depth):
+        current = current / f"level{i}"
+        current.mkdir()
+        (current / f"keep{i}.txt").write_text(f"keep{i}")
+        (current / f"ignore{i}.bak").write_text(f"ignore{i}")
+
+    (project / "level0" / ".gitignore").write_text("*.bak\n")
+
+    tree = map_directory(project)
+    names = get_all_files_in_tree(tree)
+
+    for i in range(depth):
+        assert f"keep{i}.txt" in names
+
+    assert "ignore0.bak" not in names
+    assert "ignore5.bak" not in names
+    assert "ignore11.bak" not in names
+
+
+def test_middle_slash_pattern_is_anchored(tmp_path):
+    project = tmp_path / "project"
+    project.mkdir()
+
+    (project / "subdir").mkdir()
+    (project / "subdir" / "docs").mkdir()
+    (project / "subdir" / "docs" / "api.txt").write_text("should be ignored")
+    (project / "subdir" / "other").mkdir()
+    (project / "subdir" / "other" / "docs").mkdir()
+    (project / "subdir" / "other" / "docs" / "api.txt").write_text("should be kept")
+
+    (project / "subdir" / ".gitignore").write_text("docs/api.txt\n")
+
+    tree = map_directory(project)
+
+    direct_node = find_node_by_path(tree, ["subdir", "docs", "api.txt"])
+    nested_node = find_node_by_path(tree, ["subdir", "other", "docs", "api.txt"])
+
+    assert direct_node is None
+    assert nested_node is not None