fix: deep audit round 2 — gitignore, git -z, stoplists, dead code

Author: nikolay-e

pyproject.toml

@@ -62,7 +62,6 @@ optional-dependencies.dev = [
   "coverage>=7.0,<8.0",
   "hypothesis>=6.0,<7.0",
   "import-linter>=2.0,<3.0",
-  "isort>=5.12,<9.0",
   "lxml>=5.0,<7.0",
   "mistune>=3.0,<4.0",
   "mutmut>=3.5,<4.0",
@@ -132,10 +131,6 @@ lint.ignore = [ "E501" ]  # Line length handled by black
 lint.per-file-ignores."whitelist_vulture.py" = [ "F401", "F821" ]
 lint.mccabe.max-complexity = 15
 
-[tool.isort]
-profile = "black"
-line_length = 130
-
 [tool.pyproject-fmt]
 column_width = 130
 keep_full_version = true

src/treemapper/diffctx/edges/config/docker.py

@@ -39,9 +39,16 @@ def _resolve_docker_path(base_dir: Path, rel_path: str) -> Path:
     rel_path = rel_path.strip().strip("'\"")
     rel_path = _strip_dot_slash(rel_path)
     normalized = base_dir / rel_path
-    if ".." in normalized.parts:
-        return base_dir
-    return normalized
+    if ".." not in normalized.parts:
+        return normalized
+    try:
+        resolved = normalized.resolve()
+        base_resolved = base_dir.resolve()
+        if resolved.is_relative_to(base_resolved):
+            return resolved
+    except (OSError, ValueError):
+        pass
+    return base_dir
 
 
 def _collect_docker_refs(docker_files: list[Path]) -> set[str]:

src/treemapper/diffctx/edges/config/helm.py

@@ -10,9 +10,6 @@
 _HELM_VALUES_RE = re.compile(r"\{\{-?\s*\.Values\.([a-zA-Z0-9_.]+)")
 _HELM_INCLUDE_RE = re.compile(r'\{\{\s*(?:include|template)\s+"([^"]+)"')
 _HELM_DEFINE_RE = re.compile(r'\{\{-?\s*define\s+"([^"]+)"')
-_HELM_RELEASE_RE = re.compile(r"\{\{\s*\.Release\.(\w+)\s*\}\}")
-_HELM_CHART_RE = re.compile(r"\{\{\s*\.Chart\.(\w+)\s*\}\}")
-_HELM_FILES_RE = re.compile(r'\{\{\s*\.Files\.(?:Get|Glob)\s+"([^"]+)"')
 
 _YAML_KEY_PATH_RE = re.compile(r"^(\s*)([a-zA-Z_][a-zA-Z0-9_-]*):", re.MULTILINE)
 

src/treemapper/diffctx/edges/history/cochange.py

@@ -32,6 +32,8 @@ def build(self, fragments: list[Fragment], repo_root: Path | None = None) -> Edg
             weight = min(self.weight, 0.1 * math.log(1 + count))
             for fid1 in path_to_frags.get(p1, []):
                 for fid2 in path_to_frags.get(p2, []):
+                    if fid1 == fid2:
+                        continue
                     edges[(fid1, fid2)] = max(edges.get((fid1, fid2), 0.0), weight)
                     edges[(fid2, fid1)] = max(edges.get((fid2, fid1), 0.0), weight)
 

src/treemapper/diffctx/edges/semantic/go.py

@@ -46,6 +46,28 @@
     }
 )
 _GO_TYPE_REF_RE = re.compile(r"\*?([A-Z]\w*)\b")
+_GO_COMMON_TYPES = frozenset(
+    {
+        "Bool",
+        "String",
+        "Error",
+        "Reader",
+        "Writer",
+        "Handler",
+        "Server",
+        "Client",
+        "Request",
+        "Response",
+        "Context",
+        "Logger",
+        "Config",
+        "Options",
+        "Result",
+        "Status",
+        "Mutex",
+        "Group",
+    }
+)
 _GO_PKG_CALL_RE = re.compile(r"\b(\w+)\.([A-Z]\w*)")
 _GO_EMBED_RE = re.compile(r"//go:embed\s+(\S+)", re.MULTILINE)
 _GO_PKG_DECL_RE = re.compile(r"^package\s+(\w+)", re.MULTILINE)
@@ -73,7 +95,9 @@ def _extract_definitions(content: str) -> tuple[set[str], set[str]]:
 
 def _extract_references(content: str) -> tuple[set[str], set[str], set[tuple[str, str]]]:
     func_calls = {m.group(1) for m in _GO_FUNC_CALL_RE.finditer(content) if m.group(1) not in _GO_KEYWORDS}
-    type_refs = {m.group(1) for m in _GO_TYPE_REF_RE.finditer(content) if m.group(1)[0].isupper()}
+    type_refs = {
+        m.group(1) for m in _GO_TYPE_REF_RE.finditer(content) if m.group(1)[0].isupper() and m.group(1) not in _GO_COMMON_TYPES
+    }
     pkg_calls = {(m.group(1), m.group(2)) for m in _GO_PKG_CALL_RE.finditer(content)}
     return func_calls, type_refs, pkg_calls
 

src/treemapper/diffctx/edges/semantic/rust.py

@@ -11,7 +11,6 @@
 _RUST_USE_RE = re.compile(r"^\s*use\s+(?:crate::)?([a-zA-Z_]\w*(?:::[a-zA-Z_]\w*)*)", re.MULTILINE)
 _RUST_USE_BRACED_RE = re.compile(r"use\s+(?:crate::)?([\w:]+)::\{([^}]+)\}", re.MULTILINE)
 _RUST_MOD_RE = re.compile(r"^\s*(?:pub(?:\([^)]*\))?\s+)?mod\s+([a-z_][a-z0-9_]*)\s*[;{]", re.MULTILINE)
-_RUST_EXTERN_CRATE_RE = re.compile(r"^\s*extern\s+crate\s+([a-z_][a-z0-9_]*)", re.MULTILINE)
 
 _RUST_FN_RE = re.compile(r"^\s*(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?fn\s+([a-z_][a-z0-9_]*)", re.MULTILINE)
 _RUST_STRUCT_RE = re.compile(r"^\s*(?:pub(?:\([^)]*\))?\s+)?struct\s+([A-Z]\w*)", re.MULTILINE)
@@ -24,6 +23,63 @@
 _RUST_FN_CALL_RE = re.compile(r"(?<!\w)([a-z_][a-z0-9_]*)\s?!?\s?\(")
 _RUST_PATH_CALL_RE = re.compile(r"([a-z_][a-z0-9_]*)::([a-z_][a-z0-9_]*|[A-Z]\w*)")
 
+_RUST_COMMON_TYPES = frozenset(
+    {
+        "String",
+        "Vec",
+        "Option",
+        "Result",
+        "Box",
+        "Arc",
+        "Rc",
+        "Some",
+        "None",
+        "Ok",
+        "Err",
+        "Self",
+        "HashMap",
+        "HashSet",
+        "BTreeMap",
+        "BTreeSet",
+        "Cow",
+        "Pin",
+        "PhantomData",
+    }
+)
+
+_RUST_BUILTIN_MACROS = frozenset(
+    {
+        "println",
+        "print",
+        "eprintln",
+        "eprint",
+        "format",
+        "vec",
+        "assert",
+        "assert_eq",
+        "assert_ne",
+        "debug_assert",
+        "debug_assert_eq",
+        "debug_assert_ne",
+        "panic",
+        "todo",
+        "unimplemented",
+        "unreachable",
+        "cfg",
+        "env",
+        "file",
+        "line",
+        "column",
+        "stringify",
+        "concat",
+        "include",
+        "include_str",
+        "include_bytes",
+        "write",
+        "writeln",
+    }
+)
+
 _RUST_KEYWORDS = frozenset(
     {
         "if",
@@ -109,8 +165,12 @@ def _extract_definitions(content: str) -> tuple[set[str], set[str]]:
 
 
 def _extract_references(content: str) -> tuple[set[str], set[str], set[tuple[str, str]]]:
-    type_refs = {m.group(1) for m in _RUST_TYPE_REF_RE.finditer(content)}
-    fn_calls = {m.group(1) for m in _RUST_FN_CALL_RE.finditer(content) if m.group(1) not in _RUST_KEYWORDS}
+    type_refs = {m.group(1) for m in _RUST_TYPE_REF_RE.finditer(content) if m.group(1) not in _RUST_COMMON_TYPES}
+    fn_calls = {
+        m.group(1)
+        for m in _RUST_FN_CALL_RE.finditer(content)
+        if m.group(1) not in _RUST_KEYWORDS and m.group(1) not in _RUST_BUILTIN_MACROS
+    }
     path_calls = {(m.group(1), m.group(2)) for m in _RUST_PATH_CALL_RE.finditer(content)}
     return type_refs, fn_calls, path_calls
 
@@ -204,10 +264,12 @@ def _link_fragment(
     ) -> None:
         name_to_frags, mod_to_frags, type_defs, fn_defs = indices
 
+        type_refs, fn_calls, path_calls = _extract_references(rf.content)
+
         self._link_uses(rf, mod_to_frags, name_to_frags, edges)
         self._link_declared_mods(rf, name_to_frags, edges)
-        self._link_refs(rf, type_defs, fn_defs, edges)
-        self._link_path_calls(rf, mod_to_frags, edges)
+        self._link_refs(rf, type_refs, fn_calls, type_defs, fn_defs, edges)
+        self._link_path_calls(rf, path_calls, mod_to_frags, edges)
         self._link_same_crate(rf, rust_frags, edges)
 
     def _link_uses(
@@ -247,12 +309,12 @@ def _link_declared_mods(
     def _link_refs(
         self,
         rf: Fragment,
+        type_refs: set[str],
+        fn_calls: set[str],
         type_defs: dict[str, list[FragmentId]],
         fn_defs: dict[str, list[FragmentId]],
         edges: EdgeDict,
     ) -> None:
-        type_refs, fn_calls, _ = _extract_references(rf.content)
-
         for type_ref in type_refs:
             for fid in type_defs.get(type_ref.lower(), []):
                 if fid != rf.id:
@@ -266,10 +328,10 @@ def _link_refs(
     def _link_path_calls(
         self,
         rf: Fragment,
+        path_calls: set[tuple[str, str]],
         mod_to_frags: dict[str, list[FragmentId]],
         edges: EdgeDict,
     ) -> None:
-        _, _, path_calls = _extract_references(rf.content)
         for mod_name, _symbol in path_calls:
             for fid in mod_to_frags.get(mod_name.lower(), []):
                 if fid != rf.id:

src/treemapper/diffctx/fragments.py

@@ -21,7 +21,6 @@
     GENERIC_MAX_LINES,
     INDENT_EXTENSIONS,
     MIN_FRAGMENT_LINES,
-    MIN_FRAGMENT_WORDS,
     YAML_EXTENSIONS,
 )
 from .parsers.base import compute_bracket_balance as _compute_bracket_balance  # noqa: F401
@@ -38,7 +37,6 @@
     "GENERIC_MAX_LINES",
     "INDENT_EXTENSIONS",
     "MIN_FRAGMENT_LINES",
-    "MIN_FRAGMENT_WORDS",
     "YAML_EXTENSIONS",
     "_compute_bracket_balance",
     "_find_balanced_end_line",

src/treemapper/diffctx/git.py

@@ -7,7 +7,7 @@
 from .types import DiffHunk
 
 _HUNK_RE = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
-_RANGE_RE = re.compile(r"^\s*(\S+?)(\.\.\.?)(\S+?)\s*$")  # NOSONAR(S5852)
+_RANGE_RE = re.compile(r"^\s*(\S+?)(\.\.\.?)(\S*?)\s*$")  # NOSONAR(S5852)
 
 
 class GitError(Exception):
@@ -96,14 +96,13 @@ def parse_diff(repo_root: Path, diff_range: str) -> list[DiffHunk]:
     return hunks
 
 
+def _run_git_z(repo_root: Path, args: list[str]) -> list[str]:
+    output = run_git(repo_root, args)
+    return [p for p in output.split("\0") if p]
+
+
 def get_changed_files(repo_root: Path, diff_range: str) -> list[Path]:
-    output = run_git(repo_root, ["diff", "--name-only", "-M", diff_range])
-    files: list[Path] = []
-    for line in output.splitlines():
-        line = line.strip()
-        if line:
-            files.append(repo_root / line)
-    return files
+    return [repo_root / p for p in _run_git_z(repo_root, ["diff", "--name-only", "-M", "-z", diff_range])]
 
 
 def split_diff_range(diff_range: str) -> tuple[str | None, str | None]:
@@ -121,17 +120,24 @@ def get_untracked_files(repo_root: Path) -> list[Path]:
 
 
 def get_deleted_files(repo_root: Path, diff_range: str) -> set[Path]:
-    output = run_git(repo_root, ["diff", "--diff-filter=D", "--name-only", "-M", diff_range])
-    return {(repo_root / line.strip()).resolve() for line in output.splitlines() if line.strip()}
+    return {
+        (repo_root / p).resolve()
+        for p in _run_git_z(repo_root, ["diff", "--diff-filter=D", "--name-only", "-M", "-z", diff_range])
+    }
 
 
 def get_renamed_old_paths(repo_root: Path, diff_range: str) -> set[Path]:
-    output = run_git(repo_root, ["diff", "--diff-filter=R", "--name-status", "-M", diff_range])
+    output = run_git(repo_root, ["diff", "--diff-filter=R", "--name-status", "-M", "-z", diff_range])
+    parts = output.split("\0")
     old_paths: set[Path] = set()
-    for line in output.splitlines():
-        parts = line.strip().split("\t")
-        if len(parts) >= 3 and parts[0].startswith("R"):
-            old_paths.add((repo_root / parts[1]).resolve())
+    i = 0
+    while i < len(parts):
+        if parts[i].startswith("R"):
+            if i + 2 < len(parts) and parts[i + 1]:
+                old_paths.add((repo_root / parts[i + 1]).resolve())
+            i += 3
+        else:
+            i += 1
     return old_paths
 
 

src/treemapper/diffctx/parsers/base.py

@@ -12,8 +12,6 @@
 _GENERIC_MAX_LINES = 200
 GENERIC_MAX_LINES = _GENERIC_MAX_LINES
 _GENERIC_MAX_EXTENSION = 100
-_MIN_FRAGMENT_WORDS = 10
-MIN_FRAGMENT_WORDS = _MIN_FRAGMENT_WORDS
 
 _BRACKET_PAIRS = {"{": "}", "[": "]", "(": ")"}
 
@@ -91,8 +89,7 @@ def _is_comment_or_blank(line: str) -> bool:
 
 
 def _is_top_level_close(line: str) -> bool:
-    stripped = line.strip()
-    return stripped == "}" or stripped == "};" or stripped.startswith("}")
+    return line.strip().startswith("}")
 
 
 def _find_first_balanced_point(lines: list[str], start_idx: int, target_end_idx: int) -> int | None:

src/treemapper/diffctx/parsers/markdown.py

@@ -57,7 +57,7 @@ def fragment(self, path: Path, content: str) -> list[Fragment]:
                 if frag:
                     fragments.append(frag)
 
-        return fragments if fragments else []
+        return fragments
 
     def _find_all_headings(self, lines: list[str]) -> list[tuple[int, int]]:
         headings: list[tuple[int, int]] = []