code-review-graph 2.2.2__tar.gz → 2.2.3__tar.gz

{code_review_graph-2.2.2 → code_review_graph-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-review-graph
-Version: 2.2.2
+Version: 2.2.3
 Summary: Persistent incremental knowledge graph for token-efficient, context-aware code reviews with Claude Code
 Project-URL: Homepage, https://code-review-graph.com
 Project-URL: Repository, https://github.com/tirth8205/code-review-graph
@@ -38,8 +38,10 @@ Provides-Extra: communities
 Requires-Dist: igraph>=0.11.0; extra == 'communities'
 Provides-Extra: dev
 Requires-Dist: pytest-asyncio<1,>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov<8,>=4.0; extra == 'dev'
 Requires-Dist: pytest<9,>=8.0; extra == 'dev'
 Requires-Dist: ruff<1,>=0.3.0; extra == 'dev'
+Requires-Dist: tomli>=2.0; (python_version < '3.11') and extra == 'dev'
 Provides-Extra: embeddings
 Requires-Dist: numpy<3,>=1.26; extra == 'embeddings'
 Requires-Dist: sentence-transformers<4,>=3.0.0; extra == 'embeddings'
@@ -90,12 +92,13 @@ code-review-graph build            # parse your codebase
 One command sets up everything. `install` detects which AI coding tools you have, writes the correct MCP configuration for each one, and injects graph-aware instructions into your platform rules. It auto-detects whether you installed via `uvx` or `pip`/`pipx` and generates the right config. Restart your editor/tool after installing.
 
 <p align="center">
-  <img src="diagrams/diagram8_supported_platforms.png" alt="One Install, Every Platform: auto-detects Claude Code, Cursor, Windsurf, Zed, Continue, OpenCode, and Antigravity" width="85%" />
+  <img src="diagrams/diagram8_supported_platforms.png" alt="One Install, Every Platform: auto-detects Codex, Claude Code, Cursor, Windsurf, Zed, Continue, OpenCode, and Antigravity" width="85%" />
 </p>
 
 To target a specific platform:
 
 ```bash
+code-review-graph install --platform codex       # configure only Codex
 code-review-graph install --platform cursor      # configure only Cursor
 code-review-graph install --platform claude-code  # configure only Claude Code
 ```
@@ -341,6 +344,8 @@ vendor/**
 node_modules/**
 ```
 
+Note: in git repos, only tracked files are indexed (`git ls-files`), so gitignored files are skipped automatically. Use `.code-review-graphignore` to exclude tracked files or when git isn't available.
+
 Optional dependency groups:
 
 ```bash
@@ -382,5 +387,5 @@ MIT. See [LICENSE](LICENSE).
 <br>
 <a href="https://code-review-graph.com">code-review-graph.com</a><br><br>
 <code>pip install code-review-graph && code-review-graph install</code><br>
-<sub>Works with Claude Code, Cursor, Windsurf, Zed, Continue, OpenCode, and Antigravity</sub>
+<sub>Works with Codex, Claude Code, Cursor, Windsurf, Zed, Continue, OpenCode, and Antigravity</sub>
 </p>

{code_review_graph-2.2.2 → code_review_graph-2.2.3}/README.md

@@ -36,12 +36,13 @@ code-review-graph build            # parse your codebase
 One command sets up everything. `install` detects which AI coding tools you have, writes the correct MCP configuration for each one, and injects graph-aware instructions into your platform rules. It auto-detects whether you installed via `uvx` or `pip`/`pipx` and generates the right config. Restart your editor/tool after installing.
 
 <p align="center">
-  <img src="diagrams/diagram8_supported_platforms.png" alt="One Install, Every Platform: auto-detects Claude Code, Cursor, Windsurf, Zed, Continue, OpenCode, and Antigravity" width="85%" />
+  <img src="diagrams/diagram8_supported_platforms.png" alt="One Install, Every Platform: auto-detects Codex, Claude Code, Cursor, Windsurf, Zed, Continue, OpenCode, and Antigravity" width="85%" />
 </p>
 
 To target a specific platform:
 
 ```bash
+code-review-graph install --platform codex       # configure only Codex
 code-review-graph install --platform cursor      # configure only Cursor
 code-review-graph install --platform claude-code  # configure only Claude Code
 ```
@@ -287,6 +288,8 @@ vendor/**
 node_modules/**
 ```
 
+Note: in git repos, only tracked files are indexed (`git ls-files`), so gitignored files are skipped automatically. Use `.code-review-graphignore` to exclude tracked files or when git isn't available.
+
 Optional dependency groups:
 
 ```bash
@@ -328,5 +331,5 @@ MIT. See [LICENSE](LICENSE).
 <br>
 <a href="https://code-review-graph.com">code-review-graph.com</a><br><br>
 <code>pip install code-review-graph && code-review-graph install</code><br>
-<sub>Works with Claude Code, Cursor, Windsurf, Zed, Continue, OpenCode, and Antigravity</sub>
+<sub>Works with Codex, Claude Code, Cursor, Windsurf, Zed, Continue, OpenCode, and Antigravity</sub>
 </p>

{code_review_graph-2.2.2 → code_review_graph-2.2.3}/code_review_graph/changes.py

@@ -50,6 +50,8 @@ def parse_git_diff_ranges(
             ["git", "diff", "--unified=0", base, "--"],
             capture_output=True,
             text=True,
+            encoding="utf-8",
+            errors="replace",
             cwd=repo_root,
             timeout=_GIT_TIMEOUT,
         )

{code_review_graph-2.2.2 → code_review_graph-2.2.3}/code_review_graph/cli.py

@@ -96,7 +96,7 @@ def _print_banner() -> None:
 
 def _handle_init(args: argparse.Namespace) -> None:
     """Set up MCP config for detected AI coding platforms."""
-    from .incremental import find_repo_root
+    from .incremental import ensure_repo_gitignore_excludes_crg, find_repo_root
     from .skills import install_platform_configs
 
     repo_root = Path(args.repo) if args.repo else find_repo_root()
@@ -117,9 +117,18 @@ def _handle_init(args: argparse.Namespace) -> None:
         print(f"\nConfigured {len(configured)} platform(s): {', '.join(configured)}")
 
     if dry_run:
+        print("[dry-run] Would ensure .gitignore ignores .code-review-graph/.")
         print("\n[dry-run] No files were modified.")
         return
 
+    gitignore_state = ensure_repo_gitignore_excludes_crg(repo_root)
+    if gitignore_state == "created":
+        print("Created .gitignore and added .code-review-graph/.")
+    elif gitignore_state == "updated":
+        print("Updated .gitignore with .code-review-graph/.")
+    else:
+        print(".gitignore already contains .code-review-graph/.")
+
     # Skills and hooks are installed by default so Claude actually uses the
     # graph tools proactively.  Use --no-skills / --no-hooks to opt out.
     skip_skills = getattr(args, "no_skills", False)
@@ -130,20 +139,25 @@ def _handle_init(args: argparse.Namespace) -> None:
         generate_skills,
         inject_claude_md,
         inject_platform_instructions,
+        install_git_hook,
         install_hooks,
     )
 
     if not skip_skills:
         skills_dir = generate_skills(repo_root)
         print(f"Generated skills in {skills_dir}")
-        inject_claude_md(repo_root)
-        updated = inject_platform_instructions(repo_root)
+        if target in ("claude", "all"):
+            inject_claude_md(repo_root)
+        updated = inject_platform_instructions(repo_root, target=target)
         if updated:
             print(f"Injected graph instructions into: {', '.join(updated)}")
 
-    if not skip_hooks:
+    if not skip_hooks and target in ("claude", "all"):
         install_hooks(repo_root)
         print(f"Installed hooks in {repo_root / '.claude' / 'settings.json'}")
+        git_hook = install_git_hook(repo_root)
+        if git_hook:
+            print(f"Installed git pre-commit hook in {git_hook}")
 
     print()
     print("Next steps:")
@@ -187,7 +201,7 @@ def main() -> None:
     install_cmd.add_argument(
         "--platform",
         choices=[
-            "claude", "claude-code", "cursor", "windsurf", "zed",
+            "codex", "claude", "claude-code", "cursor", "windsurf", "zed",
             "continue", "opencode", "antigravity", "all",
         ],
         default="all",
@@ -217,7 +231,7 @@ def main() -> None:
     init_cmd.add_argument(
         "--platform",
         choices=[
-            "claude", "claude-code", "cursor", "windsurf", "zed",
+            "codex", "claude", "claude-code", "cursor", "windsurf", "zed",
             "continue", "opencode", "antigravity", "all",
         ],
         default="all",

{code_review_graph-2.2.2 → code_review_graph-2.2.3}/code_review_graph/communities.py

@@ -149,24 +149,62 @@ def _to_slug(s: str) -> str:
 # ---------------------------------------------------------------------------
 
 
+def _compute_cohesion_batch(
+    community_member_qns: list[set[str]],
+    all_edges: list[GraphEdge],
+) -> list[float]:
+    """Compute cohesion for multiple communities in a single O(edges) pass.
+
+    Builds a ``qualified_name -> community_index`` reverse map (each node
+    appears in at most one community since all callers produce partitions),
+    then walks every edge exactly once, bucketing it into internal/external
+    counters per community.
+
+    Total work: O(edges + sum(|members|)) instead of
+    O(edges * communities) for naive per-community cohesion.
+
+    Returns a list of cohesion scores aligned with ``community_member_qns``.
+    """
+    qn_to_idx: dict[str, int] = {}
+    for idx, members in enumerate(community_member_qns):
+        for qn in members:
+            qn_to_idx[qn] = idx
+
+    n = len(community_member_qns)
+    internal = [0] * n
+    external = [0] * n
+
+    for e in all_edges:
+        sc = qn_to_idx.get(e.source_qualified)
+        tc = qn_to_idx.get(e.target_qualified)
+        if sc is None and tc is None:
+            continue
+        if sc == tc:
+            # Safe: sc is not None here (sc == tc and not both None).
+            assert sc is not None
+            internal[sc] += 1
+        else:
+            if sc is not None:
+                external[sc] += 1
+            if tc is not None:
+                external[tc] += 1
+
+    results: list[float] = []
+    for i in range(n):
+        total = internal[i] + external[i]
+        results.append(internal[i] / total if total > 0 else 0.0)
+    return results
+
+
 def _compute_cohesion(
     member_qns: set[str], all_edges: list[GraphEdge]
 ) -> float:
-    """Compute cohesion: internal_edges / (internal_edges + external_edges)."""
-    internal = 0
-    external = 0
-    for e in all_edges:
-        src_in = e.source_qualified in member_qns
-        tgt_in = e.target_qualified in member_qns
-        if src_in or tgt_in:
-            if src_in and tgt_in:
-                internal += 1
-            else:
-                external += 1
-    total = internal + external
-    if total == 0:
-        return 0.0
-    return internal / total
+    """Compute cohesion: internal_edges / (internal_edges + external_edges).
+
+    For multiple communities, prefer :func:`_compute_cohesion_batch`, which
+    runs in O(edges) total instead of O(edges) per community.
+    """
+    return _compute_cohesion_batch([member_qns], all_edges)[0]
 
 
 # ---------------------------------------------------------------------------
@@ -177,11 +215,15 @@ def _compute_cohesion(
 def _detect_leiden(
     nodes: list[GraphNode], edges: list[GraphEdge], min_size: int
 ) -> list[dict[str, Any]]:
-    """Detect communities using Leiden algorithm via igraph."""
+    """Detect communities using Leiden algorithm via igraph.
+
+    Caps Leiden at ``n_iterations=2`` (sufficient for code dependency graphs)
+    and skips the recursive sub-community splitting pass that caused
+    exponential blow-up on large repos (>100k nodes).
+    """
     if ig is None:
         return []
 
-    # Build mapping from qualified_name to index
     qn_to_idx: dict[str, int] = {}
     idx_to_node: dict[int, GraphNode] = {}
     for i, node in enumerate(nodes):
@@ -191,7 +233,8 @@ def _detect_leiden(
     if not qn_to_idx:
         return []
 
-    # Build igraph graph (undirected, weighted)
+    logger.info("Building igraph with %d nodes...", len(qn_to_idx))
+
     g = ig.Graph(n=len(qn_to_idx), directed=False)
     edge_list: list[tuple[int, int]] = []
     weights: list[float] = []
@@ -208,20 +251,28 @@ def _detect_leiden(
                 weights.append(EDGE_WEIGHTS.get(e.kind, 0.5))
 
     if not edge_list:
-        # No edges — fall back to file grouping
         return _detect_file_based(nodes, edges, min_size)
 
     g.add_edges(edge_list)
     g.es["weight"] = weights
 
-    # Run Leiden
+    logger.info(
+        "Running Leiden on %d nodes, %d edges...",
+        g.vcount(), g.ecount(),
+    )
+
     partition = g.community_leiden(
         objective_function="modularity",
         weights="weight",
+        n_iterations=2,
     )
 
-    # Build communities from partition
-    communities: list[dict[str, Any]] = []
+    logger.info(
+        "Leiden complete, found %d partitions. Computing cohesion...",
+        len(partition),
+    )
+
+    pending: list[tuple[list[GraphNode], set[str]]] = []
     for cluster_ids in partition:
         if len(cluster_ids) < min_size:
             continue
@@ -229,7 +280,12 @@ def _detect_leiden(
         if len(members) < min_size:
             continue
         member_qns = {m.qualified_name for m in members}
-        cohesion = _compute_cohesion(member_qns, edges)
+        pending.append((members, member_qns))
+
+    cohesions = _compute_cohesion_batch([p[1] for p in pending], edges)
+
+    communities: list[dict[str, Any]] = []
+    for (members, member_qns), cohesion in zip(pending, cohesions):
         lang_counts = Counter(m.language for m in members if m.language)
         dominant_lang = lang_counts.most_common(1)[0][0] if lang_counts else ""
         name = _generate_community_name(members)
@@ -245,94 +301,8 @@ def _detect_leiden(
             "member_qns": member_qns,
         })
 
-    # Second pass: split large communities (>50 nodes)
-    final: list[dict[str, Any]] = []
-    for comm in communities:
-        if comm["size"] > 50:
-            sub_nodes = [n for n in nodes if n.qualified_name in comm["member_qns"]]
-            sub_edges = [
-                e for e in edges
-                if e.source_qualified in comm["member_qns"]
-                and e.target_qualified in comm["member_qns"]
-            ]
-            subs = _detect_leiden_sub(sub_nodes, sub_edges, min_size, parent_name=comm["name"])
-            if len(subs) >= 2:
-                final.extend(subs)
-            else:
-                final.append(comm)
-        else:
-            final.append(comm)
-
-    return final
-
-
-def _detect_leiden_sub(
-    nodes: list[GraphNode],
-    edges: list[GraphEdge],
-    min_size: int,
-    parent_name: str,
-) -> list[dict[str, Any]]:
-    """Second-pass Leiden on a large community for sub-communities."""
-    if ig is None:
-        return []
-
-    qn_to_idx: dict[str, int] = {}
-    idx_to_node: dict[int, GraphNode] = {}
-    for i, node in enumerate(nodes):
-        qn_to_idx[node.qualified_name] = i
-        idx_to_node[i] = node
-
-    g = ig.Graph(n=len(qn_to_idx), directed=False)
-    edge_list: list[tuple[int, int]] = []
-    weights: list[float] = []
-    seen_edges: set[tuple[int, int]] = set()
-
-    for e in edges:
-        src_idx = qn_to_idx.get(e.source_qualified)
-        tgt_idx = qn_to_idx.get(e.target_qualified)
-        if src_idx is not None and tgt_idx is not None and src_idx != tgt_idx:
-            pair = (min(src_idx, tgt_idx), max(src_idx, tgt_idx))
-            if pair not in seen_edges:
-                seen_edges.add(pair)
-                edge_list.append(pair)
-                weights.append(EDGE_WEIGHTS.get(e.kind, 0.5))
-
-    if not edge_list:
-        return []
-
-    g.add_edges(edge_list)
-    g.es["weight"] = weights
-
-    partition = g.community_leiden(
-        objective_function="modularity",
-        weights="weight",
-    )
-
-    subs: list[dict[str, Any]] = []
-    for idx, cluster_ids in enumerate(partition):
-        if len(cluster_ids) < min_size:
-            continue
-        members = [idx_to_node[i] for i in cluster_ids if i in idx_to_node]
-        if len(members) < min_size:
-            continue
-        member_qns = {m.qualified_name for m in members}
-        cohesion = _compute_cohesion(member_qns, edges)
-        lang_counts = Counter(m.language for m in members if m.language)
-        dominant_lang = lang_counts.most_common(1)[0][0] if lang_counts else ""
-        name = _generate_community_name(members)
-
-        subs.append({
-            "name": f"{parent_name}/{name}",
-            "level": 1,
-            "size": len(members),
-            "cohesion": round(cohesion, 4),
-            "dominant_language": dominant_lang,
-            "description": f"Sub-community of {len(members)} nodes within {parent_name}",
-            "members": [m.qualified_name for m in members],
-            "member_qns": member_qns,
-        })
-
-    return subs
+    logger.info("Community detection complete: %d communities", len(communities))
+    return communities
 
 
 # ---------------------------------------------------------------------------
@@ -348,12 +318,21 @@ def _detect_file_based(
     for n in nodes:
         by_file[n.file_path].append(n)
 
-    communities: list[dict[str, Any]] = []
+    # Pre-filter to communities meeting min_size and collect their member
+    # sets so we can batch-compute all cohesions in a single O(edges) pass.
+    # Without this, per-community cohesion is O(edges * files), which makes
+    # community detection effectively hang on large repos.
+    pending: list[tuple[str, list[GraphNode], set[str]]] = []
     for file_path, members in by_file.items():
         if len(members) < min_size:
             continue
         member_qns = {m.qualified_name for m in members}
-        cohesion = _compute_cohesion(member_qns, edges)
+        pending.append((file_path, members, member_qns))
+
+    cohesions = _compute_cohesion_batch([p[2] for p in pending], edges)
+
+    communities: list[dict[str, Any]] = []
+    for (file_path, members, member_qns), cohesion in zip(pending, cohesions):
         lang_counts = Counter(m.language for m in members if m.language)
         dominant_lang = lang_counts.most_common(1)[0][0] if lang_counts else ""
         name = _generate_community_name(members)
@@ -397,6 +376,8 @@ def detect_communities(
     all_edges = store.get_all_edges()
     all_files = store.get_all_files()
 
+    logger.info("Loading nodes from %d files...", len(all_files))
+
     nodes: list[GraphNode] = []
     for fp in all_files:
         nodes.extend(store.get_nodes_by_file(fp))
@@ -416,6 +397,11 @@ def detect_communities(
             seen_qns.add(n.qualified_name)
             unique_nodes.append(n)
 
+    logger.info(
+        "Loaded %d unique nodes, %d edges",
+        len(unique_nodes), len(all_edges),
+    )
+
     if IGRAPH_AVAILABLE:
         logger.info("Detecting communities with Leiden algorithm (igraph)")
         results = _detect_leiden(unique_nodes, all_edges, min_size)
@@ -493,36 +479,44 @@ def store_communities(
     # that are tightly coupled to the DB transaction lifecycle.
     conn = store._conn
 
-    # Clear existing data
-    conn.execute("DELETE FROM communities")
-    conn.execute("UPDATE nodes SET community_id = NULL")
-
-    count = 0
-    for comm in communities:
-        cursor = conn.execute(
-            """INSERT INTO communities (name, level, cohesion, size, dominant_language, description)
-               VALUES (?, ?, ?, ?, ?, ?)""",
-            (
-                comm["name"],
-                comm.get("level", 0),
-                comm.get("cohesion", 0.0),
-                comm["size"],
-                comm.get("dominant_language", ""),
-                comm.get("description", ""),
-            ),
-        )
-        community_id = cursor.lastrowid
-
-        # Update community_id on member nodes
-        member_qns = comm.get("members", [])
-        for qn in member_qns:
-            conn.execute(
-                "UPDATE nodes SET community_id = ? WHERE qualified_name = ?",
-                (community_id, qn),
+    # Wrap in explicit transaction so the DELETE + INSERT + UPDATE
+    # sequence is atomic — no partial community data on crash.
+    conn.execute("BEGIN IMMEDIATE")
+    try:
+        conn.execute("DELETE FROM communities")
+        conn.execute("UPDATE nodes SET community_id = NULL")
+
+        count = 0
+        for comm in communities:
+            cursor = conn.execute(
+                """INSERT INTO communities
+                       (name, level, cohesion, size, dominant_language, description)
+                   VALUES (?, ?, ?, ?, ?, ?)""",
+                (
+                    comm["name"],
+                    comm.get("level", 0),
+                    comm.get("cohesion", 0.0),
+                    comm["size"],
+                    comm.get("dominant_language", ""),
+                    comm.get("description", ""),
+                ),
             )
-        count += 1
-
-    conn.commit()
+            community_id = cursor.lastrowid
+
+            # Batch update community_id on member nodes
+            member_qns = comm.get("members", [])
+            if member_qns:
+                placeholders = ",".join("?" * len(member_qns))
+                conn.execute(
+                    f"UPDATE nodes SET community_id = ? WHERE qualified_name IN ({placeholders})",  # nosec B608
+                    [community_id] + member_qns,
+                )
+            count += 1
+
+        conn.commit()
+    except BaseException:
+        conn.rollback()
+        raise
     return count
 
 

{code_review_graph-2.2.2 → code_review_graph-2.2.3}/code_review_graph/embeddings.py

@@ -366,7 +366,10 @@ class EmbeddingStore:
         self.provider = get_provider(provider, model=model)
         self.available = self.provider is not None
         self.db_path = Path(db_path)
-        self._conn = sqlite3.connect(str(self.db_path), timeout=30, check_same_thread=False)
+        self._conn = sqlite3.connect(
+            str(self.db_path), timeout=30, check_same_thread=False,
+            isolation_level=None,
+        )
         self._conn.row_factory = sqlite3.Row
         self._conn.executescript(_EMBEDDINGS_SCHEMA)
 

{code_review_graph-2.2.2 → code_review_graph-2.2.3}/code_review_graph/flows.py

@@ -314,41 +314,47 @@ def store_flows(store: GraphStore, flows: list[dict]) -> int:
     # tightly coupled to the DB transaction lifecycle.
     conn = store._conn
 
-    # Clear old data.
-    conn.execute("DELETE FROM flow_memberships")
-    conn.execute("DELETE FROM flows")
-
-    count = 0
-    for flow in flows:
-        path_json = json.dumps(flow.get("path", []))
-        conn.execute(
-            """INSERT INTO flows
-               (name, entry_point_id, depth, node_count, file_count,
-                criticality, path_json)
-               VALUES (?, ?, ?, ?, ?, ?, ?)""",
-            (
-                flow["name"],
-                flow["entry_point_id"],
-                flow["depth"],
-                flow["node_count"],
-                flow["file_count"],
-                flow["criticality"],
-                path_json,
-            ),
-        )
-        flow_id = conn.execute("SELECT last_insert_rowid()").fetchone()[0]
-
-        # Insert memberships.
-        node_ids = flow.get("path", [])
-        for position, node_id in enumerate(node_ids):
+    # Wrap the full DELETE + INSERT sequence in an explicit transaction
+    # so partial writes cannot occur if an exception interrupts the loop.
+    conn.execute("BEGIN IMMEDIATE")
+    try:
+        conn.execute("DELETE FROM flow_memberships")
+        conn.execute("DELETE FROM flows")
+
+        count = 0
+        for flow in flows:
+            path_json = json.dumps(flow.get("path", []))
             conn.execute(
-                "INSERT OR IGNORE INTO flow_memberships (flow_id, node_id, position) "
-                "VALUES (?, ?, ?)",
-                (flow_id, node_id, position),
+                """INSERT INTO flows
+                   (name, entry_point_id, depth, node_count, file_count,
+                    criticality, path_json)
+                   VALUES (?, ?, ?, ?, ?, ?, ?)""",
+                (
+                    flow["name"],
+                    flow["entry_point_id"],
+                    flow["depth"],
+                    flow["node_count"],
+                    flow["file_count"],
+                    flow["criticality"],
+                    path_json,
+                ),
             )
-        count += 1
-
-    conn.commit()
+            flow_id = conn.execute("SELECT last_insert_rowid()").fetchone()[0]
+
+            # Insert memberships.
+            node_ids = flow.get("path", [])
+            for position, node_id in enumerate(node_ids):
+                conn.execute(
+                    "INSERT OR IGNORE INTO flow_memberships (flow_id, node_id, position) "
+                    "VALUES (?, ?, ?)",
+                    (flow_id, node_id, position),
+                )
+            count += 1
+
+        conn.commit()
+    except BaseException:
+        conn.rollback()
+        raise
     return count