code-review-graph-codeblackwell 2.4.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

code_review_graph/__init__.py

@@ -8,7 +8,7 @@ from .context_savings import (
     format_context_savings,
 )
 
-__version__ = "2.3.6"
+__version__ = "3.0.0"
 
 __all__ = [
     "__version__",

code_review_graph/changes.py

@@ -167,7 +167,100 @@ def _parse_unified_diff(diff_text: str) -> dict[str, list[tuple[int, int]]]:
 
 
 # ---------------------------------------------------------------------------
-# 2. map_changes_to_nodes
+# 2. compute_file_churn
+# ---------------------------------------------------------------------------
+
+_CHURN_SATURATION = 10.0
+_CHURN_WEIGHT = 0.15
+_NUMSTAT_COUNT = re.compile(r"^(?:\d+|-)$")
+
+
+def _parse_numstat(log_text: str) -> dict[str, int]:
+    """Parse NUL-terminated ``git log --numstat -z`` records.
+
+    NUL termination is required for correctness: Git's default line format
+    quotes unusual paths, while ``-z`` preserves tabs and newlines in file
+    names without making the graph-path lookup ambiguous.
+    """
+    counts: dict[str, int] = {}
+    for record in log_text.split("\0"):
+        if not record:
+            continue
+        fields = record.split("\t", 2)
+        if len(fields) != 3:
+            continue
+        added, deleted, path = fields
+        if (
+            not path
+            or _NUMSTAT_COUNT.fullmatch(added) is None
+            or _NUMSTAT_COUNT.fullmatch(deleted) is None
+        ):
+            continue
+        counts[path] = counts.get(path, 0) + 1
+    return counts
+
+
+def compute_file_churn(
+    repo_root: str,
+    window_days: int | None = None,
+) -> dict[str, int]:
+    """Count commits touching each file over a trailing window.
+
+    Returns an empty mapping when the window is invalid or Git cannot be
+    queried. Renames are deliberately not followed: churn belongs to the path
+    that existed in each commit.
+    """
+    if window_days is None:
+        raw_window = os.environ.get("CRG_CHURN_WINDOW_DAYS", "90")
+        try:
+            window_days = int(raw_window)
+        except ValueError:
+            logger.warning(
+                "Invalid CRG_CHURN_WINDOW_DAYS value %r; churn disabled",
+                raw_window,
+            )
+            return {}
+    if window_days <= 0:
+        return {}
+
+    try:
+        result = subprocess.run(
+            [
+                "git",
+                "-c",
+                "core.quotepath=off",
+                "log",
+                f"--since={window_days}.days.ago",
+                "--numstat",
+                "--no-renames",
+                "--format=",
+                "-z",
+                "--",
+            ],
+            capture_output=True,
+            stdin=subprocess.DEVNULL,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            cwd=repo_root,
+            timeout=_GIT_TIMEOUT,
+        )
+        if result.returncode != 0:
+            logger.warning(
+                "git log failed (rc=%d): %s",
+                result.returncode,
+                result.stderr[:200],
+            )
+            return {}
+    except (OSError, subprocess.SubprocessError) as exc:
+        logger.warning("git log error: %s", exc)
+        return {}
+
+    return _parse_numstat(result.stdout)
+
+
+# ---------------------------------------------------------------------------
+# 3. map_changes_to_nodes
 # ---------------------------------------------------------------------------
 
 
@@ -212,11 +305,15 @@ def map_changes_to_nodes(
 
 
 # ---------------------------------------------------------------------------
-# 3. compute_risk_score
+# 4. compute_risk_score
 # ---------------------------------------------------------------------------
 
 
-def compute_risk_score(store: GraphStore, node: GraphNode) -> float:
+def compute_risk_score(
+    store: GraphStore,
+    node: GraphNode,
+    churn_counts: dict[str, int] | None = None,
+) -> float:
     """Compute a risk score (0.0 - 1.0) for a single node.
 
     Scoring factors:
@@ -225,6 +322,8 @@ def compute_risk_score(store: GraphStore, node: GraphNode) -> float:
       - 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
+      - Change frequency (opt-in): commits touching the file / 10, capped
+        at 0.15
     """
     score = 0.0
 
@@ -266,11 +365,16 @@ def compute_risk_score(store: GraphStore, node: GraphNode) -> float:
     caller_count = len(caller_edges)
     score += min(caller_count / 20.0, 0.10)
 
+    # --- Change frequency (opt-in, cap 0.15) ---
+    if churn_counts and node.file_path:
+        commit_count = churn_counts.get(node.file_path, 0)
+        score += min(commit_count / _CHURN_SATURATION, 1.0) * _CHURN_WEIGHT
+
     return round(min(max(score, 0.0), 1.0), 4)
 
 
 # ---------------------------------------------------------------------------
-# 4. analyze_changes
+# 5. analyze_changes
 # ---------------------------------------------------------------------------
 
 
@@ -280,6 +384,7 @@ def analyze_changes(
     changed_ranges: dict[str, list[tuple[int, int]]] | None = None,
     repo_root: str | None = None,
     base: str = "HEAD~1",
+    include_churn: bool = False,
 ) -> dict[str, Any]:
     """Analyze changes and produce risk-scored review guidance.
 
@@ -291,6 +396,9 @@ def analyze_changes(
             (Git or SVN).
         repo_root: Repository root (for git/svn diff).
         base: Git ref or SVN revision range to diff against.
+        include_churn: Add an opt-in change-frequency term to each node's
+            risk score. The trailing window defaults to 90 days and can be
+            configured with ``CRG_CHURN_WINDOW_DAYS``.
 
     Returns:
         Dict with ``summary``, ``risk_score``, ``changed_functions``,
@@ -320,10 +428,12 @@ def analyze_changes(
         for fp in changed_files:
             changed_nodes.extend(store.get_nodes_by_file(fp))
 
-    # Filter to functions/tests for risk scoring (skip File nodes).
+    # RTL declarations are stored as Function nodes for compatibility but
+    # are not callable/testable functions.
     changed_funcs = [
         n for n in changed_nodes
         if n.kind in ("Function", "Test", "Class")
+        and not n.extra.get("verilog_kind")
     ]
 
     # Cap to prevent O(N*M) query explosion on large PRs.
@@ -332,10 +442,18 @@ def analyze_changes(
     if funcs_truncated:
         changed_funcs = changed_funcs[:_max_funcs]
 
+    churn_counts: dict[str, int] | None = None
+    if include_churn and repo_root is not None:
+        churn_counts = {}
+        root_path = Path(repo_root)
+        for key, count in compute_file_churn(repo_root).items():
+            churn_counts[key] = count
+            churn_counts[str(root_path / key)] = count
+
     # Compute per-node risk scores.
     node_risks: list[dict[str, Any]] = []
     for node in changed_funcs:
-        risk = compute_risk_score(store, node)
+        risk = compute_risk_score(store, node, churn_counts)
         node_risks.append({
             **node_to_dict(node),
             "risk_score": risk,
@@ -352,7 +470,10 @@ def analyze_changes(
     for node in changed_funcs:
         if node.is_test:
             continue
-        tested = store.get_edges_by_target(node.qualified_name)
+        # TESTED_BY edges are stored as source=production, target=test by the
+        # parser, so a changed production function finds its tests by source.
+        # See: #515
+        tested = store.get_edges_by_source(node.qualified_name)
         if not any(e.kind == "TESTED_BY" for e in tested):
             test_gaps.append({
                 "name": _sanitize_name(node.name),