fix: use git ls-files for file discovery, fix layer violations and untracked files (PR #1232)

- Use git ls-files instead of rglob to avoid scanning node_modules/dist
- Fix get_layer() to return None for unknown layers and skip violations
- Include untracked .ts/.tsx files in pre-commit check trigger

Author: karthiknadig

.github/hooks/scripts/stop_hook.py

@@ -32,10 +32,10 @@ def run_command(cmd: List[str], cwd: Optional[Path] = None) -> Tuple[int, str]:
 
 
 def has_uncommitted_changes(repo_root: Path) -> bool:
-    """Check if there are uncommitted changes."""
+    """Check if there are uncommitted changes (tracked files only)."""
     code, output = run_command(["git", "status", "--porcelain"], repo_root)
     if code == 0 and output:
-        # Ignore all untracked files (marked with ??) - only track staged/modified
+        # Filter to only tracked files (staged/modified, not untracked with ??)
         lines = [
             line
             for line in output.split("\n")
@@ -45,6 +45,19 @@ def has_uncommitted_changes(repo_root: Path) -> bool:
     return False
 
 
+def has_untracked_ts_files(repo_root: Path) -> bool:
+    """Check if there are untracked TypeScript files."""
+    code, output = run_command(["git", "status", "--porcelain"], repo_root)
+    if code == 0 and output:
+        for line in output.split("\n"):
+            if line.strip().startswith("??"):
+                # Extract filename from untracked entry (format: "?? path/to/file")
+                filename = line.strip()[3:].strip()
+                if filename.endswith((".ts", ".tsx")):
+                    return True
+    return False
+
+
 def has_staged_changes(repo_root: Path) -> bool:
     """Check if there are staged but uncommitted changes."""
     code, output = run_command(["git", "diff", "--cached", "--name-only"], repo_root)
@@ -88,8 +101,11 @@ def main() -> int:
         print(json.dumps({}))
         return 0
 
-    # Check for uncommitted TypeScript changes
-    if has_uncommitted_changes(repo_root) and check_ts_files_changed(repo_root):
+    # Check for uncommitted TypeScript changes (including new untracked TS files)
+    ts_work_present = (
+        has_uncommitted_changes(repo_root) and check_ts_files_changed(repo_root)
+    ) or has_untracked_ts_files(repo_root)
+    if ts_work_present:
         # There are uncommitted TS changes - remind about pre-commit checks
         response = {
             "hookSpecificOutput": {

analysis/complexity_analysis.py

@@ -5,6 +5,7 @@
 
 import pathlib
 import re
+import subprocess
 from dataclasses import dataclass
 from typing import Dict, List, Optional
 
@@ -108,6 +109,40 @@ def should_analyze_file(
     return True
 
 
+def get_tracked_source_files(
+    repo_root: pathlib.Path, extensions: List[str]
+) -> List[pathlib.Path]:
+    """Get source files tracked by git (respects .gitignore automatically)."""
+    try:
+        result = subprocess.run(
+            ["git", "ls-files", "--cached", "--others", "--exclude-standard"],
+            cwd=repo_root,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        if result.returncode != 0:
+            return []
+
+        files = []
+        for line in result.stdout.splitlines():
+            line = line.strip()
+            if line and any(line.endswith(ext) for ext in extensions):
+                filepath = repo_root / line
+                if filepath.exists():
+                    files.append(filepath)
+        return files
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        # Fall back to rglob if git is not available
+        gitignore = load_gitignore(repo_root)
+        files = []
+        for ext in extensions:
+            for filepath in repo_root.rglob(f"*{ext}"):
+                if should_analyze_file(filepath, repo_root, gitignore):
+                    files.append(filepath)
+        return files
+
+
 def analyze_python_file(
     filepath: pathlib.Path, repo_root: pathlib.Path
 ) -> Optional[FileComplexity]:
@@ -249,16 +284,8 @@ def analyze_typescript_file(
 def find_source_files(
     repo_root: pathlib.Path, extensions: List[str]
 ) -> List[pathlib.Path]:
-    """Find all source files with given extensions."""
-    gitignore = load_gitignore(repo_root)
-    files = []
-
-    for ext in extensions:
-        for filepath in repo_root.rglob(f"*{ext}"):
-            if should_analyze_file(filepath, repo_root, gitignore):
-                files.append(filepath)
-
-    return files
+    """Find all source files with given extensions using git ls-files."""
+    return get_tracked_source_files(repo_root, extensions)
 
 
 def analyze_complexity(repo_root: pathlib.Path) -> dict:

analysis/debt_indicators.py

@@ -9,6 +9,7 @@
 
 import pathlib
 import re
+import subprocess
 from dataclasses import dataclass
 from typing import Dict, List, Optional
 
@@ -128,6 +129,40 @@ def should_analyze_file(
     return True
 
 
+def get_tracked_source_files(
+    repo_root: pathlib.Path, extensions: List[str]
+) -> List[pathlib.Path]:
+    """Get source files tracked by git (respects .gitignore automatically)."""
+    try:
+        result = subprocess.run(
+            ["git", "ls-files", "--cached", "--others", "--exclude-standard"],
+            cwd=repo_root,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        if result.returncode != 0:
+            return []
+
+        files = []
+        for line in result.stdout.splitlines():
+            line = line.strip()
+            if line and any(line.endswith(ext) for ext in extensions):
+                filepath = repo_root / line
+                if filepath.exists():
+                    files.append(filepath)
+        return files
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        # Fall back to rglob if git is not available
+        gitignore = load_gitignore(repo_root)
+        files = []
+        for ext in extensions:
+            for filepath in repo_root.rglob(f"*{ext}"):
+                if should_analyze_file(filepath, repo_root, gitignore):
+                    files.append(filepath)
+        return files
+
+
 def find_debt_markers(
     filepath: pathlib.Path, repo_root: pathlib.Path
 ) -> List[DebtMarker]:
@@ -341,20 +376,13 @@ def analyze_debt(repo_root: pathlib.Path) -> dict:
     Returns:
         Dictionary with all debt indicators
     """
-    gitignore = load_gitignore(repo_root)
-
     all_markers: List[DebtMarker] = []
     large_files: List[LargeFile] = []
     long_functions: List[LongFunction] = []
 
-    # Find all source files
+    # Find all source files using git ls-files (respects .gitignore)
     extensions = [".py", ".ts", ".js", ".tsx", ".jsx"]
-    source_files = []
-
-    for ext in extensions:
-        for filepath in repo_root.rglob(f"*{ext}"):
-            if should_analyze_file(filepath, repo_root, gitignore):
-                source_files.append(filepath)
+    source_files = get_tracked_source_files(repo_root, extensions)
 
     # Analyze each file
     for filepath in source_files:

analysis/dependency_analysis.py

@@ -12,6 +12,7 @@
 
 import pathlib
 import re
+import subprocess
 from dataclasses import dataclass, field
 from typing import Dict, List, Optional, Set
 
@@ -106,6 +107,40 @@ def should_analyze_file(
     return True
 
 
+def get_tracked_source_files(
+    repo_root: pathlib.Path, extensions: List[str]
+) -> List[pathlib.Path]:
+    """Get source files tracked by git (respects .gitignore automatically)."""
+    try:
+        result = subprocess.run(
+            ["git", "ls-files", "--cached", "--others", "--exclude-standard"],
+            cwd=repo_root,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        if result.returncode != 0:
+            return []
+
+        files = []
+        for line in result.stdout.splitlines():
+            line = line.strip()
+            if line and any(line.endswith(ext) for ext in extensions):
+                filepath = repo_root / line
+                if filepath.exists():
+                    files.append(filepath)
+        return files
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        # Fall back to rglob if git is not available
+        gitignore = load_gitignore(repo_root)
+        files = []
+        for ext in extensions:
+            for filepath in repo_root.rglob(f"*{ext}"):
+                if should_analyze_file(filepath, repo_root, gitignore):
+                    files.append(filepath)
+        return files
+
+
 def extract_imports_typescript(
     filepath: pathlib.Path, repo_root: pathlib.Path
 ) -> Set[str]:
@@ -178,17 +213,11 @@ def resolve_import_path(
 
 def build_dependency_graph(repo_root: pathlib.Path) -> Dict[str, ModuleInfo]:
     """Build a dependency graph of all TypeScript modules."""
-    gitignore = load_gitignore(repo_root)
     modules: Dict[str, ModuleInfo] = {}
 
-    # Find all TypeScript/JavaScript files
+    # Find all TypeScript/JavaScript files using git ls-files (respects .gitignore)
     extensions = [".ts", ".tsx", ".js", ".jsx"]
-    source_files = []
-
-    for ext in extensions:
-        for filepath in repo_root.rglob(f"*{ext}"):
-            if should_analyze_file(filepath, repo_root, gitignore):
-                source_files.append(filepath)
+    source_files = get_tracked_source_files(repo_root, extensions)
 
     # First pass: extract imports
     for filepath in source_files:
@@ -303,33 +332,35 @@ def compute_layer_violations(modules: Dict[str, ModuleInfo]) -> List[dict]:
         "managers",
     ]
 
-    def get_layer(path: str) -> int:
-        """Get the layer index for a module path."""
+    def get_layer(path: str) -> Optional[int]:
+        """Get the layer index for a module path. Returns None for unknown layers."""
         parts = path.lower().split("/")
         for i, layer in enumerate(layer_order):
             if layer in parts:
                 return i
-        return len(layer_order)  # Unknown = highest layer
+        return None  # Unknown layer
 
     violations = []
     for module_path, module_info in modules.items():
         module_layer = get_layer(module_path)
+        # Skip modules with unknown layers
+        if module_layer is None:
+            continue
 
         for imported_path in module_info.imports:
             imported_layer = get_layer(imported_path)
+            # Skip imports with unknown layers
+            if imported_layer is None:
+                continue
 
             # Lower layer importing from higher layer is a violation
             if module_layer < imported_layer:
                 violations.append(
                     {
                         "from": module_path,
-                        "from_layer": layer_order[module_layer]
-                        if module_layer < len(layer_order)
-                        else "unknown",
+                        "from_layer": layer_order[module_layer],
                         "imports": imported_path,
-                        "imports_layer": layer_order[imported_layer]
-                        if imported_layer < len(layer_order)
-                        else "unknown",
+                        "imports_layer": layer_order[imported_layer],
                     }
                 )