neo-skill 0.1.28 → 0.1.29

package/.shared/review-gate/README.md

@@ -69,15 +69,15 @@ python3 .shared/review-gate/scripts/review.py --persist path --path src/domain/u
 
 ## Workflow
 
-1. Creates branch: `review-gate/<YYYYMMDD>-<topic>-<ref>`
+1. Creates branch: `review-gate/<YYYYMMDD-HHMMSS>-<ref>`
 2. (Optional) Runs existing tests baseline
-3. Extracts PR diff changeset
+3. Extracts PR diff changeset (only changed files, no full repo scan)
 4. Builds impacted dependency subgraph
-5. Generates signals (layer/dep/api/pure/complex/etc.)
+5. Generates signals from diff (layer/dep/api/pure/complex/etc.)
 6. Router selects & prioritizes checks
 7. Composer generates findings + report
-8. (Optional) Applies minimal fixes for blockers
-9. (Optional) Reruns tests to ensure green
+8. **Applies auto-fixes for BLOCKER findings**
+9. **Commits fixes to the review branch**
 10. Outputs final report (Markdown + JSON)
 
 ## Domain Reference
@@ -228,10 +228,25 @@ python3 .shared/review-gate/scripts/review.py \
    - Scope: TypeScript/JavaScript imports
 ```
 
+## Auto-Fix Capabilities
+
+The skill now automatically fixes BLOCKER findings when possible:
+
+- **Layer violations**: Adds TODO comments for manual refactoring
+- **Side effect violations**: Adds TODO comments for isolation
+- **API issues**: Requires manual review
+- **Circular dependencies**: Requires manual refactoring
+
+All fixes are:
+- Applied to the review branch
+- Automatically committed with descriptive messages
+- Traceable through git history
+
 ## Notes
 
 - **NOT a linter**: Focus is architecture, not style
 - **Evidence-required**: All findings must have concrete proof
 - **Minimal changes**: Code modifications are scoped and traceable
-- **No new tests**: Only fixes to make existing tests pass
+- **No full repo scan**: Only analyzes files in git diff
+- **Auto-commit**: Fixes are automatically committed to review branch
 - **Deterministic**: Same input always produces same output

package/.shared/review-gate/scripts/engine/__init__.py

@@ -4,5 +4,6 @@ from .router import Router
 from .scorer import Scorer
 from .composer import Composer
 from .persist import PersistManager
+from .auto_fixer import AutoFixer
 
-__all__ = ["Router", "Scorer", "Composer", "PersistManager"]
+__all__ = ["Router", "Scorer", "Composer", "PersistManager", "AutoFixer"]

package/.shared/review-gate/scripts/engine/auto_fixer.py

@@ -0,0 +1,445 @@
+"""Auto-fix module for applying code fixes based on findings."""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+from .scorer import Finding
+
+
+@dataclass
+class FixResult:
+    """Result of applying a fix."""
+    finding_id: str
+    success: bool
+    files_modified: List[str]
+    error: Optional[str] = None
+
+
+class AutoFixer:
+    """Applies automatic fixes for findings."""
+    
+    def __init__(self, repo_path: Path):
+        self.repo_path = repo_path
+    
+    def apply_fixes(self, findings: List[Finding]) -> List[FixResult]:
+        """Apply fixes for all findings.
+
+        Note: not every finding is safely auto-fixable. For those, this method will
+        still return a FixResult with success=False.
+        """
+        results = []
+        
+        for finding in findings:
+            result = self._apply_fix(finding)
+            results.append(result)
+        
+        return results
+    
+    def _apply_fix(self, finding: Finding) -> FixResult:
+        """Apply fix for a single finding."""
+        try:
+            if finding.area == "LAYER":
+                return self._fix_layer_violation(finding)
+            elif finding.area == "DEP":
+                return self._fix_circular_dependency(finding)
+            elif finding.area == "PURE":
+                return self._fix_side_effect_violation(finding)
+            elif finding.area == "API":
+                return self._fix_api_issue(finding)
+            elif finding.area == "COMPLEX":
+                return self._fix_complexity_issue(finding)
+            else:
+                return FixResult(
+                    finding_id=finding.id,
+                    success=False,
+                    files_modified=[],
+                    error=f"No structural auto-fix available for area: {finding.area}",
+                )
+        except Exception as e:
+            return FixResult(
+                finding_id=finding.id,
+                success=False,
+                files_modified=[],
+                error=str(e),
+            )
+
+    def _is_ts_module(self, file_path: str) -> bool:
+        lower = file_path.lower()
+        return lower.endswith((".ts", ".tsx"))
+
+    def _normalize_path(self, path: str) -> str:
+        return path.replace("\\", "/")
+
+    def _resolve_import(self, from_file: str, import_path: str) -> Optional[str]:
+        if not import_path.startswith(".") and not import_path.startswith("@/"):
+            return None
+
+        from_full = self.repo_path / from_file
+        if not from_full.exists():
+            return None
+
+        if import_path.startswith("@/"):
+            base = self.repo_path / "src"
+            rel = import_path[2:]
+        else:
+            base = from_full.parent
+            rel = import_path
+
+        candidates: List[Path] = []
+        base_path = (base / rel)
+        # Try direct and extension variants
+        candidates.append(base_path)
+        candidates.append(base_path.with_suffix(".ts"))
+        candidates.append(base_path.with_suffix(".tsx"))
+        candidates.append(base_path.with_suffix(".js"))
+        candidates.append(base_path.with_suffix(".jsx"))
+        candidates.append(base_path / "index.ts")
+        candidates.append(base_path / "index.tsx")
+        candidates.append(base_path / "index.js")
+        candidates.append(base_path / "index.jsx")
+
+        for cand in candidates:
+            if cand.exists():
+                try:
+                    rel_path = cand.relative_to(self.repo_path)
+                    return self._normalize_path(str(rel_path))
+                except ValueError:
+                    continue
+
+        return None
+
+    def _convert_import_to_type_only(self, importer_file: str, imported_file: str) -> FixResult:
+        importer_file = self._normalize_path(importer_file)
+        imported_file = self._normalize_path(imported_file)
+
+        if not self._is_ts_module(importer_file):
+            return FixResult(
+                finding_id="",
+                success=False,
+                files_modified=[],
+                error=f"Only TypeScript supports import type: {importer_file}",
+            )
+
+        full_path = self.repo_path / importer_file
+        if not full_path.exists():
+            return FixResult(
+                finding_id="",
+                success=False,
+                files_modified=[],
+                error=f"File not found: {importer_file}",
+            )
+
+        content = full_path.read_text(encoding="utf-8")
+        lines = content.split("\n")
+
+        import_re = re.compile(r"^(\s*)import\s+(?!type\b)(.+?)\s+from\s+(['\"])([^'\"]+)\3\s*;?\s*$")
+
+        modified = False
+        for idx, line in enumerate(lines):
+            m = import_re.match(line)
+            if not m:
+                continue
+
+            imp_path = m.group(4)
+            resolved = self._resolve_import(importer_file, imp_path)
+            if resolved != imported_file:
+                continue
+
+            indent = m.group(1)
+            clause = m.group(2)
+            quote = m.group(3)
+            new_line = f"{indent}import type {clause} from {quote}{imp_path}{quote}"
+            lines[idx] = new_line
+            modified = True
+            break
+
+        if not modified:
+            return FixResult(
+                finding_id="",
+                success=False,
+                files_modified=[],
+                error="Could not locate import statement to convert",
+            )
+
+        full_path.write_text("\n".join(lines), encoding="utf-8")
+        return FixResult(
+            finding_id="",
+            success=True,
+            files_modified=[importer_file],
+        )
+
+    def _line_comment_prefix(self, file_path: str) -> Optional[str]:
+        """Return a safe line comment prefix for the given file, or None if unsupported."""
+        lower = file_path.lower()
+        if lower.endswith((".ts", ".tsx", ".js", ".jsx", ".c", ".cc", ".cpp", ".h", ".hpp", ".java", ".cs", ".go", ".rs")):
+            return "//"
+        if lower.endswith((".py", ".sh", ".bash", ".yml", ".yaml", ".toml", ".ini")):
+            return "#"
+        # JSON does not allow comments; markdown/docs are intentionally skipped.
+        return None
+
+    def _safe_insert_leading_comment(self, lines: List[str], comment_line: str) -> List[str]:
+        """Insert a comment near the top without breaking shebang/encoding lines."""
+        if not lines:
+            return [comment_line]
+
+        idx = 0
+
+        # Preserve shebang as first line for scripts.
+        if lines[0].startswith("#!"):
+            idx = 1
+            # Preserve Python encoding declaration if present as second line.
+            if len(lines) > 1 and "coding" in lines[1] and lines[1].lstrip().startswith("#"):
+                idx = 2
+
+        lines.insert(idx, comment_line)
+        return lines
+
+    def _fix_generic_marker(self, finding: Finding) -> FixResult:
+        """Fallback: add a minimal marker to evidence files (when safe) so the issue is visible in code."""
+        files = finding.evidence.get("files", [])
+        if not files:
+            return FixResult(
+                finding_id=finding.id,
+                success=False,
+                files_modified=[],
+                error=f"No evidence files available for area: {finding.area}",
+            )
+
+        modified_files: List[str] = []
+        marker = f"REVIEW-GATE: {finding.id} {finding.title}"
+
+        for file_info in files:
+            file_path = file_info.get("path")
+            if not file_path:
+                continue
+            prefix = self._line_comment_prefix(file_path)
+            if prefix is None:
+                continue
+
+            full_path = self.repo_path / file_path
+            if not full_path.exists():
+                continue
+
+            try:
+                content = full_path.read_text(encoding="utf-8")
+            except Exception:
+                continue
+
+            lines = content.split("\n")
+            # Avoid duplicating marker if already present in the header.
+            header = "\n".join(lines[:5])
+            if marker in header:
+                continue
+
+            insertion = f"{prefix} {marker}"
+            lines = self._safe_insert_leading_comment(lines, insertion)
+            full_path.write_text("\n".join(lines), encoding="utf-8")
+            modified_files.append(file_path)
+
+        if modified_files:
+            return FixResult(
+                finding_id=finding.id,
+                success=True,
+                files_modified=modified_files,
+            )
+
+        return FixResult(
+            finding_id=finding.id,
+            success=False,
+            files_modified=[],
+            error="No safe file types found to apply marker",
+        )
+    
+    def _fix_layer_violation(self, finding: Finding) -> FixResult:
+        """Fix layer dependency violations."""
+        files = finding.evidence.get("files", [])
+        if not files:
+            return FixResult(
+                finding_id=finding.id,
+                success=False,
+                files_modified=[],
+                error="No files in evidence",
+            )
+        
+        file_path = files[0]["path"]
+        
+        dep_trace = finding.evidence.get("dependency_trace", {})
+        chain = dep_trace.get("chain") or []
+        if len(chain) < 2:
+            return FixResult(
+                finding_id=finding.id,
+                success=False,
+                files_modified=[],
+                error="No dependency chain available",
+            )
+
+        imported_file = chain[1]
+        conv = self._convert_import_to_type_only(file_path, imported_file)
+        if conv.success:
+            return FixResult(
+                finding_id=finding.id,
+                success=True,
+                files_modified=conv.files_modified,
+            )
+
+        return FixResult(
+            finding_id=finding.id,
+            success=False,
+            files_modified=[],
+            error=conv.error,
+        )
+    
+    def _fix_circular_dependency(self, finding: Finding) -> FixResult:
+        """Try to break a cycle by converting one edge to a type-only import."""
+        files = finding.evidence.get("files", [])
+        cycle = [f.get("path") for f in files if f.get("path")]
+        cycle = [self._normalize_path(p) for p in cycle]
+        if len(cycle) < 2:
+            return FixResult(
+                finding_id=finding.id,
+                success=False,
+                files_modified=[],
+                error="No cycle file list available",
+            )
+
+        # Attempt to convert each edge a -> b within the cycle
+        for i in range(len(cycle) - 1):
+            a = cycle[i]
+            b = cycle[i + 1]
+            conv = self._convert_import_to_type_only(a, b)
+            if conv.success:
+                return FixResult(
+                    finding_id=finding.id,
+                    success=True,
+                    files_modified=conv.files_modified,
+                )
+
+        return FixResult(
+            finding_id=finding.id,
+            success=False,
+            files_modified=[],
+            error="Could not break cycle with type-only import conversion",
+        )
+    
+    def _fix_side_effect_violation(self, finding: Finding) -> FixResult:
+        """Fix side effect violations."""
+        files = finding.evidence.get("files", [])
+        if not files:
+            return FixResult(
+                finding_id=finding.id,
+                success=False,
+                files_modified=[],
+                error="No files in evidence",
+            )
+        
+        file_path = files[0]["path"]
+        full_path = self.repo_path / file_path
+        
+        if not full_path.exists():
+            return FixResult(
+                finding_id=finding.id,
+                success=False,
+                files_modified=[],
+                error=f"File not found: {file_path}",
+            )
+        
+        prefix = self._line_comment_prefix(file_path)
+        if prefix is None:
+            return FixResult(
+                finding_id=finding.id,
+                success=False,
+                files_modified=[],
+                error=f"Unsupported file type for auto-fix: {file_path}",
+            )
+
+        content = full_path.read_text(encoding="utf-8")
+        lines = content.split("\n")
+        
+        # Add TODO at the top of the file
+        todo_line = f"{prefix} TODO: Isolate side effects - {finding.title}"
+        header = "\n".join(lines[:5])
+        if todo_line not in header:
+            lines = self._safe_insert_leading_comment(lines, todo_line)
+            full_path.write_text("\n".join(lines), encoding="utf-8")
+            return FixResult(
+                finding_id=finding.id,
+                success=True,
+                files_modified=[file_path],
+            )
+        
+        return FixResult(
+            finding_id=finding.id,
+            success=False,
+            files_modified=[],
+            error="TODO already exists",
+        )
+    
+    def _fix_api_issue(self, finding: Finding) -> FixResult:
+        """Fix API design issues."""
+        return FixResult(
+            finding_id=finding.id,
+            success=False,
+            files_modified=[],
+            error="No structural auto-fix available for API issues",
+        )
+
+    def _fix_complexity_issue(self, finding: Finding) -> FixResult:
+        """Complexity refactors are not safely automatable (yet)."""
+        return FixResult(
+            finding_id=finding.id,
+            success=False,
+            files_modified=[],
+            error="No structural auto-fix available for complexity issues",
+        )
+    
+    def commit_fixes(self, results: List[FixResult], branch_name: str) -> bool:
+        """Commit all fixes to git."""
+        modified_files: List[str] = []
+        successful_results: List[FixResult] = []
+        for result in results:
+            if result.success:
+                successful_results.append(result)
+                modified_files.extend(result.files_modified)
+
+        modified_files = sorted(set(modified_files))
+        
+        if not modified_files:
+            return False
+        
+        try:
+            # Stage modified files
+            for file_path in modified_files:
+                subprocess.run(
+                    ["git", "add", file_path],
+                    cwd=self.repo_path,
+                    check=True,
+                )
+            
+            subject = "fix(review-gate): apply auto-fixes"
+            body_lines = [
+                f"Branch: {branch_name}",
+                "",
+                f"Fixed {len(successful_results)} finding(s):",
+            ]
+            for result in successful_results:
+                body_lines.append(f"- {result.finding_id}")
+            body = "\n".join(body_lines)
+
+            subprocess.run(
+                ["git", "commit", "-m", subject, "-m", body],
+                cwd=self.repo_path,
+                check=True,
+            )
+            
+            print(f"✓ Committed {len(modified_files)} file(s)")
+            return True
+            
+        except subprocess.CalledProcessError as e:
+            print(f"⚠ Failed to commit fixes: {e}")
+            return False

package/.shared/review-gate/scripts/review.py

@@ -39,11 +39,12 @@ from signals import (
 from engine import Router, Scorer, Composer, PersistManager
 from engine.scorer import Finding
 from engine.router import Signal
+from engine.auto_fixer import AutoFixer
 
 
 def create_review_branch(base_branch: str, repo_path: Path) -> str:
     """Create review-gate branch."""
-    date_str = datetime.now().strftime("%Y%m%d")
+    timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
     
     try:
         result = subprocess.run(
@@ -57,19 +58,32 @@ def create_review_branch(base_branch: str, repo_path: Path) -> str:
     except subprocess.CalledProcessError:
         ref = "unknown"
     
-    branch_name = f"review-gate/{date_str}-review-{ref}"
+    branch_name = f"review-gate/{timestamp}-{ref}"
     
     try:
         subprocess.run(
             ["git", "checkout", "-b", branch_name],
             cwd=repo_path,
             check=True,
+            capture_output=True,
         )
         print(f"✓ Created branch: {branch_name}")
-    except subprocess.CalledProcessError:
-        print(f"⚠ Could not create branch, continuing on current branch", file=sys.stderr)
-    
-    return branch_name
+        return branch_name
+    except subprocess.CalledProcessError as e:
+        print(f"⚠ Could not create branch: {e}", file=sys.stderr)
+        print("⚠ Continuing on current branch", file=sys.stderr)
+        # Get current branch name
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                cwd=repo_path,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            return result.stdout.strip()
+        except subprocess.CalledProcessError:
+            return "unknown"
 
 
 def collect_signals(
@@ -234,6 +248,14 @@ def generate_findings(
         
         elif signal.type == "circular_dependency":
             finding_counter["DEP"] += 1
+            cycle_files = []
+            if getattr(dep_graph, "cycles", None):
+                try:
+                    first_cycle = dep_graph.cycles[0]
+                    if isinstance(first_cycle, list):
+                        cycle_files = [{"path": p, "diff_hunks": []} for p in first_cycle]
+                except Exception:
+                    cycle_files = []
             findings.append(Finding(
                 id=f"RG-DEP-{finding_counter['DEP']:03d}",
                 severity="BLOCKER",
@@ -243,7 +265,7 @@ def generate_findings(
                 status="OPEN",
                 confidence="HIGH",
                 evidence={
-                    "files": [],
+                    "files": cycle_files,
                     "dependency_trace": {
                         "cycles": signal.value["cycles"],
                     },
@@ -383,6 +405,8 @@ def main() -> None:
     print("║              REVIEW GATE - Architecture Review                ║")
     print("╚════════════════════════════════════════════════════════════════╝")
     
+    print(f"\n📋 Base branch: {args.base_branch}")
+    print("\n🌿 Creating review branch...")
     branch_name = create_review_branch(args.base_branch, repo_path)
     
     signals, changeset, dep_graph, layer_info, api_surface, test_result = collect_signals(
@@ -400,12 +424,13 @@ def main() -> None:
     findings = generate_findings(signals, changeset, dep_graph, layer_info, api_surface)
     
     scorer = Scorer()
-    findings = scorer.prioritize(findings)
-    
+    all_findings = scorer.prioritize(findings)
+
+    findings_for_fix = all_findings
     if args.domain:
-        findings = [f for f in findings if f.area.lower() == args.domain.lower()]
-    
-    findings = findings[:args.max_results]
+        findings_for_fix = [f for f in findings_for_fix if f.area.lower() == args.domain.lower()]
+
+    findings_for_report = findings_for_fix[:args.max_results]
     
     composer = Composer(DATA_DIR / "templates")
     
@@ -416,7 +441,7 @@ def main() -> None:
     }
     
     report = composer.compose_report(
-        findings,
+        findings_for_report,
         changeset_summary,
         branch_name,
         args.base_branch,
@@ -433,7 +458,7 @@ def main() -> None:
     report_file = composer.save_report(report, output_dir, format=args.format)
     print(f"\n✓ Report saved to: {report_file}")
     
-    json_report = composer.compose_report(findings, changeset_summary, branch_name, args.base_branch, format="json")
+    json_report = composer.compose_report(findings_for_report, changeset_summary, branch_name, args.base_branch, format="json")
     json_file = composer.save_report(json_report, output_dir, format="json")
     print(f"✓ JSON report saved to: {json_file}")
     
@@ -441,7 +466,42 @@ def main() -> None:
         persist_mgr = PersistManager(REVIEW_SYSTEM_DIR)
         print(f"\n📝 Persisting {args.persist} overrides...")
     
-    blockers = [f for f in findings if f.severity == "BLOCKER"]
+    blockers = [f for f in findings_for_fix if f.severity == "BLOCKER"]
+
+    print(f"\n🔧 Applying auto-fixes for {len(findings_for_fix)} finding(s)...")
+    auto_fixer = AutoFixer(repo_path)
+    fix_results = auto_fixer.apply_fixes(findings_for_fix)
+
+    successful_fixes = [r for r in fix_results if r.success]
+    failed_fixes = [r for r in fix_results if not r.success]
+
+    if successful_fixes:
+        print(f"  ✓ Applied {len(successful_fixes)} fix(es)")
+        for result in successful_fixes[:20]:
+            files_str = ", ".join(result.files_modified)
+            print(f"    - {result.finding_id}: {files_str}")
+        if len(successful_fixes) > 20:
+            print(f"    ... and {len(successful_fixes) - 20} more")
+
+        print("\n💾 Committing fixes...")
+        if auto_fixer.commit_fixes(fix_results, branch_name):
+            print(f"  ✓ Fixes committed to branch: {branch_name}")
+        else:
+            print("  ⚠ No changes to commit")
+    else:
+        print("  ℹ No auto-fixable issues found")
+
+    if failed_fixes:
+        print(f"\n  ⚠ {len(failed_fixes)} issue(s) were not auto-fixable")
+        for result in failed_fixes[:10]:
+            print(f"    - {result.finding_id}: {result.error}")
+        if len(failed_fixes) > 10:
+            print(f"    ... and {len(failed_fixes) - 10} more")
+
+    print(f"\n📌 Review branch: {branch_name}")
+    print("   Run 'git diff' to see applied fixes")
+    print(f"   Merge with: git checkout {args.base_branch} && git merge {branch_name}")
+
     if blockers:
         print(f"\n⚠️  {len(blockers)} BLOCKER(S) found - review required before merge")
         sys.exit(1)

package/.shared/review-gate/scripts/signals/graph_builder.py

@@ -37,50 +37,64 @@ class GraphBuilder:
     
     def build_impacted_subgraph(self, changed_files: List[str]) -> DependencyGraph:
         """Build subgraph of modules impacted by changed files."""
-        all_nodes = self._scan_all_modules()
-        
+        nodes = self._scan_module_closure(changed_files)
+
         # Mark changed files
         for file_path in changed_files:
             normalized = self._normalize_path(file_path)
-            if normalized in all_nodes:
-                all_nodes[normalized].is_changed = True
-        
-        # Find impacted nodes (transitive closure)
-        impacted = self._find_impacted_nodes(all_nodes, changed_files)
-        
-        # Detect cycles
-        cycles = self._detect_cycles(all_nodes)
-        
+            if normalized in nodes:
+                nodes[normalized].is_changed = True
+
+        # Detect cycles within the scanned subgraph
+        cycles = self._detect_cycles(nodes)
+
+        impacted = set(nodes.keys())
         return DependencyGraph(
-            nodes=all_nodes,
+            nodes=nodes,
             cycles=cycles,
             impacted_nodes=impacted,
         )
     
-    def _scan_all_modules(self) -> Dict[str, DependencyNode]:
-        """Scan all TypeScript/JavaScript modules."""
-        nodes = {}
-        
-        if not self.src_path.exists():
-            return nodes
-        
-        for ext in ["*.ts", "*.tsx", "*.js", "*.jsx"]:
-            for file_path in self.src_path.rglob(ext):
-                if "node_modules" in file_path.parts or ".test." in file_path.name:
-                    continue
-                
-                normalized = self._normalize_path(str(file_path.relative_to(self.repo_path)))
-                imports = self._extract_imports(file_path)
-                
-                node = DependencyNode(path=normalized, imports=imports)
-                nodes[normalized] = node
-        
-        # Build reverse edges
+    def _scan_module_closure(self, entry_files: List[str]) -> Dict[str, DependencyNode]:
+        """Scan only the changed files and their transitive local imports.
+
+        This intentionally avoids scanning the whole repository.
+        """
+        nodes: Dict[str, DependencyNode] = {}
+        queue: List[str] = []
+        visited: Set[str] = set()
+
+        for file_path in entry_files:
+            normalized = self._normalize_path(file_path)
+            queue.append(normalized)
+
+        while queue:
+            current = queue.pop(0)
+            if current in visited:
+                continue
+            visited.add(current)
+
+            full_path = self.repo_path / current
+            if not full_path.exists():
+                continue
+            if "node_modules" in full_path.parts or ".test." in full_path.name:
+                continue
+
+            imports = self._extract_imports(full_path)
+            node = nodes.get(current) or DependencyNode(path=current)
+            node.imports = imports
+            nodes[current] = node
+
+            for imp in imports:
+                if imp not in visited:
+                    queue.append(imp)
+
+        # Build reverse edges for scanned nodes only
         for node in nodes.values():
             for imp in node.imports:
                 if imp in nodes:
                     nodes[imp].imported_by.append(node.path)
-        
+
         return nodes
     
     def _extract_imports(self, file_path: Path) -> List[str]:
@@ -94,6 +108,19 @@ class GraphBuilder:
         
         # Match ES6 imports: import ... from "..."
         for match in re.finditer(r'import\s+.*?\s+from\s+["\']([^"\']+)["\']', content):
+            stmt = match.group(0)
+
+            # Ignore type-only imports (TypeScript): they don't create runtime deps.
+            if re.match(r"^\s*import\s+type\b", stmt):
+                continue
+
+            # Ignore `import { type A, type B } from ...` when *all* specifiers are type-only.
+            if "{" in stmt and "}" in stmt:
+                inner = stmt.split("{", 1)[1].split("}", 1)[0]
+                parts = [p.strip() for p in inner.split(",") if p.strip()]
+                if parts and all(p.startswith("type ") or p.startswith("type\t") for p in parts):
+                    continue
+
             import_path = match.group(1)
             resolved = self._resolve_import(file_path, import_path)
             if resolved:
@@ -143,27 +170,12 @@ class GraphBuilder:
         return path.replace("\\", "/")
     
     def _find_impacted_nodes(self, nodes: Dict[str, DependencyNode], changed_files: List[str]) -> Set[str]:
-        """Find all nodes impacted by changed files (BFS)."""
-        impacted = set()
-        queue = []
-        
+        """Deprecated: kept for backward compatibility."""
+        impacted: Set[str] = set()
         for file_path in changed_files:
             normalized = self._normalize_path(file_path)
             if normalized in nodes:
-                queue.append(normalized)
                 impacted.add(normalized)
-        
-        while queue:
-            current = queue.pop(0)
-            node = nodes.get(current)
-            if not node:
-                continue
-            
-            for dependent in node.imported_by:
-                if dependent not in impacted:
-                    impacted.add(dependent)
-                    queue.append(dependent)
-        
         return impacted
     
     def _detect_cycles(self, nodes: Dict[str, DependencyNode]) -> List[List[str]]:

package/.shared/review-gate/scripts/signals/layer_classifier.py

@@ -83,7 +83,7 @@ class LayerClassifier:
         self.repo_path = repo_path
     
     def classify(self, file_path: str) -> LayerInfo:
-        """Classify a file into a layer."""
+        """Classify a file into a layer based on path only (no content scanning)."""
         normalized = file_path.replace("\\", "/").lower()
         
         # Check explicit layer patterns
@@ -96,61 +96,17 @@ class LayerClassifier:
                         reason=f"Path contains '{pattern}'",
                     )
         
-        # Heuristic: check file content for clues
-        content_layer = self._classify_by_content(file_path)
-        if content_layer:
-            return content_layer
-        
         # Default to shared if uncertain
         return LayerInfo(
             layer="shared",
             confidence="LOW",
-            reason="No clear layer indicators",
+            reason="No clear layer indicators in path",
         )
     
     def classify_batch(self, file_paths: List[str]) -> Dict[str, LayerInfo]:
         """Classify multiple files."""
         return {path: self.classify(path) for path in file_paths}
     
-    def _classify_by_content(self, file_path: str) -> Optional[LayerInfo]:
-        """Classify by analyzing file content."""
-        full_path = self.repo_path / file_path
-        if not full_path.exists():
-            return None
-        
-        try:
-            content = full_path.read_text(encoding="utf-8")
-        except Exception:
-            return None
-        
-        # React component indicators
-        if any(pattern in content for pattern in ["export default function", "export const", "React.FC", "JSX.Element"]):
-            if "useState" in content or "useEffect" in content or "onClick" in content:
-                return LayerInfo(
-                    layer="presentation",
-                    confidence="MEDIUM",
-                    reason="Contains React component patterns",
-                )
-        
-        # Domain model indicators
-        if any(pattern in content for pattern in ["class ", "interface ", "type "]):
-            if not any(pattern in content for pattern in ["fetch(", "axios", "useState", "useEffect"]):
-                return LayerInfo(
-                    layer="domain",
-                    confidence="MEDIUM",
-                    reason="Contains type definitions without side effects",
-                )
-        
-        # Infrastructure indicators
-        if any(pattern in content for pattern in ["fetch(", "axios", "prisma", "db.", "api."]):
-            return LayerInfo(
-                layer="infra",
-                confidence="MEDIUM",
-                reason="Contains external I/O operations",
-            )
-        
-        return None
-    
     def get_layer_hierarchy(self) -> Dict[str, int]:
         """Get layer hierarchy (lower number = lower in stack)."""
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neo-skill",
-  "version": "0.1.28",
+  "version": "0.1.29",
   "description": "A multi-assistant skill generator (Claude/Windsurf/Cursor/GitHub Skills) driven by a canonical SkillSpec.",
   "license": "MIT",
   "bin": {

package/skills/review-gate/references/review-gate.md

@@ -104,12 +104,12 @@ python .shared/review-gate/scripts/review.py --persist path --domain layer
 
 ### 工作流
 
-1. **创建审查分支** → `review-gate/<timestamp>`
+1. **创建审查分支** → `review-gate/<YYYYMMDD-HHMMSS>-<ref>`
 2. **可选：运行测试** → 确保基线通过
-3. **收集信号**：
-   - Diff 变更集
+3. **收集信号**（仅从 git diff）：
+   - Diff 变更集（仅变更文件，不扫描整个仓库）
    - 依赖子图
-   - 层级分类
+   - 层级分类（基于路径，不读取文件内容）
    - API 表面变更
    - 副作用扫描
    - 复杂度扫描
@@ -120,8 +120,8 @@ python .shared/review-gate/scripts/review.py --persist path --domain layer
 5. **生成报告**：
    - Markdown 报告（按领域分组）
    - JSON 结构化输出
-6. **可选：最小化修复** → 自动应用简单修复
-7. **可选：重新测试** → 验证修复未破坏功能
+6. **自动修复 BLOCKER** → 应用可自动化的修复
+7. **提交修复** → 自动提交到审查分支
 
 详细工作流见：[`.shared/review-gate/README.md#workflow`](../../../.shared/review-gate/README.md#workflow)