feat: parser refactoring, Jedi call resolution, and performance optimizations

Major improvements to code-review-graph spanning parser architecture,
call graph accuracy, and build performance.

Parser refactoring:
- Extract 16 per-language handler modules into code_review_graph/lang/
  using a strategy pattern, replacing monolithic conditionals in parser.py
- Thread-safe parser caches with double-check locking

Call graph enrichment:
- Jedi-based Python method call resolution at build time (jedi_resolver.py)
- Pre-scan filtering by project function names (36s to 3s on large repos)
- Typed variable call enrichment (Python, JS/TS, Kotlin/Java)
- Star import resolution, namespace imports, CommonJS require()
- Angular template parsing, JSX handler tracking
- Module-level import tracking and module-qualified call resolution
- Function/class references passed as call arguments

PreToolUse search enrichment:
- New enrich.py module and code-review-graph enrich CLI command
- Injects graph context (callers, flows, community, tests) into agent
  search results passively via hook

Dead code false positive reduction:
- Framework decorators recognized as entry points
- CDK construct methods, abstract overrides excluded
- E2e test directories excluded from dead code detection

Performance:
- Community detection: 48.6s to 2.3s (21x speedup) via bulk node
  loading and adjacency-indexed cohesion computation
- Jedi enrichment: 36s to 3s (12x) via pre-scan filtering
- Batch file storage (50-file transactions)
- Batch risk_index (2 GROUP BY queries replace per-node loops)

Other:
- Weighted flow risk scoring by criticality
- Transitive TESTED_BY lookup for tests_for and risk scoring
- DB schema v8: composite edge index (v7 reserved by PR #127)
- --quiet and --json CLI flags
- Search query deduplication, test function deprioritization
- New [enrichment] optional dependency group for Jedi
- 829+ tests across 26 test files (up from 615)

Evaluated against Gadgetbridge (41k nodes, 280k edges): 8/10 PASS,
call resolution rate improved from 28% to 39.6%.

Author: gzenz

CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## [Unreleased]
+
+### Added
+- **Parser refactoring**: Extracted 16 per-language handler modules into `code_review_graph/lang/` package using a strategy pattern, replacing monolithic conditionals in `parser.py`
+- **Jedi-based call resolution**: New `jedi_resolver.py` module resolves Python method calls at build time via Jedi static analysis, with pre-scan filtering by project function names (36s to 3s on large repos)
+- **PreToolUse search enrichment**: New `enrich.py` module and `code-review-graph enrich` CLI command inject graph context (callers, callees, flows, community, tests) into agent search results passively
+- **Typed variable call enrichment**: Track constructor-based type inference and instance method calls for Python, JS/TS, and Kotlin/Java
+- **Star import resolution**: Resolve `from module import *` by scanning target module's exported names
+- **Namespace imports**: Track `import * as X from 'module'` and CommonJS `require()` patterns
+- **Angular template parsing**: Extract call targets from Angular component templates
+- **JSX handler tracking**: Detect function/class references passed as JSX event handler props
+- **Framework decorator recognition**: Identify entry points decorated with `@app.route`, `@router.get`, `@cli.command`, etc., reducing dead code false positives
+- **Module-level import tracking**: Track module-qualified call resolution (`module.function()`)
+- **Thread safety**: Double-check locking on parser caches (`_type_sets`, `_get_parser`, `_resolve_module_to_file`, `_get_exported_names`)
+- **Batch file storage**: `store_file_batch()` groups file insertions into 50-file transactions for faster builds
+- **Bulk node loading**: `get_all_nodes()` replaces per-file SQL queries for community detection
+- **Adjacency-indexed cohesion**: Community cohesion computed in O(community-edges) instead of O(all-edges), yielding 21x speedup (48.6s to 2.3s on 41k-node repos)
+- **Phase timing instrumentation**: `time.perf_counter()` timing at INFO level for all build phases
+- **Batch risk_index**: 2 GROUP BY queries replace per-node COUNT loops in risk scoring
+- **Weighted flow risk scoring**: Risk scores weighted by flow criticality instead of flat edge counts
+- **Transitive TESTED_BY lookup**: `tests_for` and risk scoring follow transitive test relationships
+- **DB schema v8**: Composite edge index for upsert performance (v7 reserved by upstream PR #127)
+- **`--quiet` and `--json` CLI flags**: Machine-readable output for `build`, `update`, `status`
+- **829+ tests** across 26 test files (up from 615), including `test_pain_points.py` (1,587 lines TDD suite), `test_hardened.py` (467 lines), `test_enrich.py` (237 lines)
+- **14 new test fixtures**: Kotlin, Java, TypeScript, JSX, Python resolution scenarios
+
+### Changed
+- New `[enrichment]` optional dependency group for Jedi-based Python call resolution
+- Leiden community detection scales resolution parameter with graph size
+- Adaptive directory-based fallback for community detection when Leiden produces poor clusters
+- Search query deduplication and test function deprioritization
+
+### Fixed
+- **Dead code false positives**: Decorators, CDK construct methods, abstract overrides, and overriding methods with called parents no longer flagged as dead
+- **E2e test exclusion**: Playwright/Cypress e2e test directories excluded from dead code detection
+- **Unique-name plausible caller optimization**: Faster dead code analysis via pre-filtered candidate sets
+- **Store cache liveness check**: Cached SQLite connections verified as alive before reuse
+
+### Performance
+- **Community detection**: 48.6s to 2.3s (21x) on Gadgetbridge (41k nodes, 280k edges)
+- **Jedi enrichment**: 36s to 3s (12x) via pre-scan filtering by project function names
+
 ## [2.2.2] - 2026-04-08
 
 ### Added

CLAUDE.md

@@ -46,7 +46,7 @@ When using code-review-graph MCP tools, follow these rules:
 
 ```bash
 # Development
-uv run pytest tests/ --tb=short -q          # Run tests (572 tests)
+uv run pytest tests/ --tb=short -q          # Run tests (609 tests)
 uv run ruff check code_review_graph/        # Lint
 uv run mypy code_review_graph/ --ignore-missing-imports --no-strict-optional
 

README.md

@@ -229,6 +229,7 @@ code-review-graph watch            # Auto-update on file changes
 code-review-graph visualize        # Generate interactive HTML graph
 code-review-graph wiki             # Generate markdown wiki from communities
 code-review-graph detect-changes   # Risk-scored change impact analysis
+code-review-graph enrich           # Enrich search results with graph context
 code-review-graph register <path>  # Register repo in multi-repo registry
 code-review-graph unregister <id>  # Remove repo from registry
 code-review-graph repos            # List registered repositories
@@ -293,6 +294,7 @@ Optional dependency groups:
 pip install code-review-graph[embeddings]          # Local vector embeddings (sentence-transformers)
 pip install code-review-graph[google-embeddings]   # Google Gemini embeddings
 pip install code-review-graph[communities]         # Community detection (igraph)
+pip install code-review-graph[enrichment]          # Jedi-based Python call resolution
 pip install code-review-graph[eval]                # Evaluation benchmarks (matplotlib)
 pip install code-review-graph[wiki]                # Wiki generation with LLM summaries (ollama)
 pip install code-review-graph[all]                 # All optional dependencies
@@ -316,7 +318,7 @@ pytest
 <summary><strong>Adding a new language</strong></summary>
 <br>
 
-Edit `code_review_graph/parser.py` and add your extension to `EXTENSION_TO_LANGUAGE` along with node type mappings in `_CLASS_TYPES`, `_FUNCTION_TYPES`, `_IMPORT_TYPES`, and `_CALL_TYPES`. Include a test fixture and open a PR.
+Edit the appropriate language handler in `code_review_graph/lang/` (e.g., `_python.py`, `_kotlin.py`) or create a new one following `_base.py`. Add your extension to `EXTENSION_TO_LANGUAGE` in `parser.py`, include a test fixture, and open a PR.
 
 </details>
 

code-review-graph-vscode/src/backend/cli.ts

@@ -53,22 +53,14 @@ export class CliWrapper {
     /**
      * Build (or fully rebuild) the graph database for a workspace.
      */
-    async buildGraph(
-        workspaceRoot: string,
-        options?: { fullRebuild?: boolean },
-    ): Promise<CliResult> {
-        const args = ['build'];
-        if (options?.fullRebuild) {
-            args.push('--full');
-        }
-
+    async buildGraph(workspaceRoot: string): Promise<CliResult> {
         return vscode.window.withProgress(
             {
                 location: vscode.ProgressLocation.Notification,
                 title: 'Code Review Graph: Building graph\u2026',
                 cancellable: false,
             },
-            () => this.exec(args, workspaceRoot),
+            () => this.exec(['build'], workspaceRoot),
         );
     }
 

code-review-graph-vscode/src/backend/sqlite.ts

@@ -208,7 +208,7 @@ export class SqliteReader {
         if (row) {
           const version = parseInt(row.value, 10);
           // Must match LATEST_VERSION in code_review_graph/migrations.py
-          const SUPPORTED_SCHEMA_VERSION = 6;
+          const SUPPORTED_SCHEMA_VERSION = 8;
           if (!isNaN(version) && version > SUPPORTED_SCHEMA_VERSION) {
             return `Database was created with a newer version (schema v${version}). Update the extension.`;
           }

code_review_graph/changes.py

@@ -152,15 +152,19 @@ def compute_risk_score(store: GraphStore, node: GraphNode) -> float:
     Scoring factors:
       - Flow participation: 0.05 per flow membership, capped at 0.25
       - Community crossing: 0.05 per caller from a different community, capped at 0.15
-      - Test coverage: 0.30 if no TESTED_BY edges, 0.05 if tested
+      - Test coverage: 0.30 (untested) scaling down to 0.05 (5+ TESTED_BY edges)
       - Security sensitivity: 0.20 if name matches security keywords
       - Caller count: callers / 20, capped at 0.10
     """
     score = 0.0
 
-    # --- Flow participation (cap 0.25) ---
-    flow_count = store.count_flow_memberships(node.id)
-    score += min(flow_count * 0.05, 0.25)
+    # --- Flow participation (cap 0.25), weighted by criticality ---
+    flow_criticalities = store.get_flow_criticalities_for_node(node.id)
+    if flow_criticalities:
+        score += min(sum(flow_criticalities), 0.25)
+    else:
+        flow_count = store.count_flow_memberships(node.id)
+        score += min(flow_count * 0.05, 0.25)
 
     # --- Community crossing (cap 0.15) ---
     callers = store.get_edges_by_target(node.qualified_name)
@@ -177,10 +181,10 @@ def compute_risk_score(store: GraphStore, node: GraphNode) -> float:
                 cross_community += 1
     score += min(cross_community * 0.05, 0.15)
 
-    # --- Test coverage ---
-    tested_edges = store.get_edges_by_target(node.qualified_name)
-    has_test = any(e.kind == "TESTED_BY" for e in tested_edges)
-    score += 0.05 if has_test else 0.30
+    # --- Test coverage (direct + transitive) ---
+    transitive_tests = store.get_transitive_tests(node.qualified_name)
+    test_count = len(transitive_tests)
+    score += 0.30 - (min(test_count / 5.0, 1.0) * 0.25)
 
     # --- Security sensitivity ---
     name_lower = node.name.lower()

code_review_graph/cli.py

@@ -11,6 +11,7 @@
     code-review-graph visualize
     code-review-graph wiki
     code-review-graph detect-changes [--base BASE] [--brief]
+    code-review-graph enrich
     code-review-graph register <path> [--alias name]
     code-review-graph unregister <path_or_alias>
     code-review-graph repos
@@ -151,6 +152,67 @@ def _handle_init(args: argparse.Namespace) -> None:
     print("  2. Restart your AI coding tool to pick up the new config")
 
 
+def _run_post_processing(store, quiet: bool = False) -> None:
+    """Run signatures, FTS, flows, and communities after build/update."""
+    import sqlite3
+
+    # Signatures
+    try:
+        nodes = store._conn.execute(
+            "SELECT id, name, kind, params, return_type FROM nodes "
+            "WHERE kind IN ('Function','Test','Class')"
+        ).fetchall()
+        for row in nodes:
+            node_id, name, kind, params, ret = row
+            if kind in ("Function", "Test"):
+                sig = f"{name}({params or ''})"
+                if ret:
+                    sig += f" -> {ret}"
+            elif kind == "Class":
+                sig = f"class {name}"
+            else:
+                sig = name
+            store.update_node_signature(node_id, sig[:512])
+        store.commit()
+    except (sqlite3.OperationalError, TypeError, KeyError) as e:
+        if not quiet:
+            print(f"Warning: signature computation failed: {e}")
+
+    # FTS index
+    try:
+        from .search import rebuild_fts_index
+        fts_count = rebuild_fts_index(store)
+        if not quiet:
+            print(f"FTS indexed: {fts_count} nodes")
+    except (sqlite3.OperationalError, ImportError) as e:
+        if not quiet:
+            print(f"Warning: FTS index rebuild failed: {e}")
+
+    # Flows
+    try:
+        from .flows import store_flows as _store_flows
+        from .flows import trace_flows as _trace_flows
+        flows = _trace_flows(store)
+        count = _store_flows(store, flows)
+        if not quiet:
+            print(f"Flows detected: {count}")
+    except (sqlite3.OperationalError, ImportError) as e:
+        if not quiet:
+            print(f"Warning: flow detection failed: {e}")
+
+    # Communities
+    try:
+        from .communities import detect_communities as _detect_communities
+        from .communities import store_communities as _store_communities
+        comms = _detect_communities(store)
+        count = _store_communities(store, comms)
+        if not quiet:
+            print(f"Communities detected: {count}")
+    except (sqlite3.OperationalError, ImportError) as e:
+        if not quiet:
+            print(f"Warning: community detection failed: {e}")
+
+
 def main() -> None:
     """Main CLI entry point."""
     ap = argparse.ArgumentParser(
@@ -227,6 +289,7 @@ def main() -> None:
     # build
     build_cmd = sub.add_parser("build", help="Full graph build (re-parse all files)")
     build_cmd.add_argument("--repo", default=None, help="Repository root (auto-detected)")
+    build_cmd.add_argument("-q", "--quiet", action="store_true", help="Suppress output")
     build_cmd.add_argument(
         "--skip-flows", action="store_true",
         help="Skip flow/community detection (signatures + FTS only)",
@@ -240,6 +303,7 @@ def main() -> None:
     update_cmd = sub.add_parser("update", help="Incremental update (only changed files)")
     update_cmd.add_argument("--base", default="HEAD~1", help="Git diff base (default: HEAD~1)")
     update_cmd.add_argument("--repo", default=None, help="Repository root (auto-detected)")
+    update_cmd.add_argument("-q", "--quiet", action="store_true", help="Suppress output")
     update_cmd.add_argument(
         "--skip-flows", action="store_true",
         help="Skip flow/community detection (signatures + FTS only)",
@@ -266,6 +330,11 @@ def main() -> None:
     # status
     status_cmd = sub.add_parser("status", help="Show graph statistics")
     status_cmd.add_argument("--repo", default=None, help="Repository root (auto-detected)")
+    status_cmd.add_argument("-q", "--quiet", action="store_true", help="Suppress output")
+    status_cmd.add_argument(
+        "--json", action="store_true", dest="json_output",
+        help="Output as JSON",
+    )
 
     # visualize
     vis_cmd = sub.add_parser("visualize", help="Generate interactive HTML graph visualization")
@@ -327,6 +396,13 @@ def main() -> None:
     )
     detect_cmd.add_argument("--repo", default=None, help="Repository root (auto-detected)")
 
+    # embed
+    embed_cmd = sub.add_parser("embed", help="Compute vector embeddings for graph nodes")
+    embed_cmd.add_argument("--repo", default=None, help="Repository root (auto-detected)")
+
+    # enrich (PreToolUse hook -- reads hook JSON from stdin)
+    sub.add_parser("enrich", help="Enrich search results with graph context (hook)")
+
     # serve
     serve_cmd = sub.add_parser("serve", help="Start MCP server (stdio transport)")
     serve_cmd.add_argument("--repo", default=None, help="Repository root (auto-detected)")
@@ -346,6 +422,28 @@ def main() -> None:
         serve_main(repo_root=args.repo)
         return
 
+    if args.command == "embed":
+        from .incremental import find_repo_root
+        repo_root = Path(args.repo) if args.repo else find_repo_root()
+        if not repo_root:
+            repo_root = Path.cwd()
+        db_path = repo_root / ".code-review-graph" / "graph.db"
+        if not db_path.exists():
+            print("No graph database found. Run 'code-review-graph build' first.")
+            return
+        from .embeddings import EmbeddingStore, embed_all_nodes
+        from .graph import GraphStore
+        store = GraphStore(str(db_path))
+        emb_store = EmbeddingStore(str(db_path))
+        count = embed_all_nodes(store, emb_store)
+        print(f"Embedded {count} nodes.")
+        return
+
+    if args.command == "enrich":
+        from .enrich import run_hook
+        run_hook()
+        return
+
     if args.command == "eval":
         from .eval.reporter import generate_full_report, generate_readme_tables
         from .eval.runner import run_eval
@@ -485,13 +583,14 @@ def main() -> None:
             parsed = result.get("files_parsed", 0)
             nodes = result.get("total_nodes", 0)
             edges = result.get("total_edges", 0)
-            print(
-                f"Full build: {parsed} files, "
-                f"{nodes} nodes, {edges} edges"
-                f" (postprocess={pp})"
-            )
-            if result.get("errors"):
-                print(f"Errors: {len(result['errors'])}")
+            if not getattr(args, "quiet", False):
+                print(
+                    f"Full build: {parsed} files, "
+                    f"{nodes} nodes, {edges} edges"
+                    f" (postprocess={pp})"
+                )
+                if result.get("errors"):
+                    print(f"Errors: {len(result['errors'])}")
 
         elif args.command == "update":
             pp = "none" if getattr(args, "skip_postprocess", False) else (
@@ -505,35 +604,53 @@ def main() -> None:
             updated = result.get("files_updated", 0)
             nodes = result.get("total_nodes", 0)
             edges = result.get("total_edges", 0)
-            print(
-                f"Incremental: {updated} files updated, "
-                f"{nodes} nodes, {edges} edges"
-                f" (postprocess={pp})"
-            )
+            if not getattr(args, "quiet", False):
+                print(
+                    f"Incremental: {updated} files updated, "
+                    f"{nodes} nodes, {edges} edges"
+                    f" (postprocess={pp})"
+                )
 
         elif args.command == "status":
+            import json as json_mod
             stats = store.get_stats()
-            print(f"Nodes: {stats.total_nodes}")
-            print(f"Edges: {stats.total_edges}")
-            print(f"Files: {stats.files_count}")
-            print(f"Languages: {', '.join(stats.languages)}")
-            print(f"Last updated: {stats.last_updated or 'never'}")
-            # Show branch info and warn if stale
             stored_branch = store.get_metadata("git_branch")
             stored_sha = store.get_metadata("git_head_sha")
-            if stored_branch:
-                print(f"Built on branch: {stored_branch}")
-            if stored_sha:
-                print(f"Built at commit: {stored_sha[:12]}")
             from .incremental import _git_branch_info
             current_branch, current_sha = _git_branch_info(repo_root)
+            stale_warning = None
             if stored_branch and current_branch and stored_branch != current_branch:
-                print(
-                    f"WARNING: Graph was built on '{stored_branch}' "
+                stale_warning = (
+                    f"Graph was built on '{stored_branch}' "
                     f"but you are now on '{current_branch}'. "
                     f"Run 'code-review-graph build' to rebuild."
                 )
 
+            if getattr(args, "json_output", False):
+                data = {
+                    "nodes": stats.total_nodes,
+                    "edges": stats.total_edges,
+                    "files": stats.files_count,
+                    "languages": list(stats.languages),
+                    "last_updated": stats.last_updated,
+                    "branch": stored_branch,
+                    "commit": stored_sha[:12] if stored_sha else None,
+                    "stale": stale_warning,
+                }
+                print(json_mod.dumps(data))
+            elif not args.quiet:
+                print(f"Nodes: {stats.total_nodes}")
+                print(f"Edges: {stats.total_edges}")
+                print(f"Files: {stats.files_count}")
+                print(f"Languages: {', '.join(stats.languages)}")
+                print(f"Last updated: {stats.last_updated or 'never'}")
+                if stored_branch:
+                    print(f"Built on branch: {stored_branch}")
+                if stored_sha:
+                    print(f"Built at commit: {stored_sha[:12]}")
+                if stale_warning:
+                    print(f"WARNING: {stale_warning}")
+
         elif args.command == "watch":
             watch(repo_root, store)