codegraph-brain 0.25.4__py3-none-any.whl → 0.26.0__py3-none-any.whl

cgis/api/mcp_server.py

@@ -952,12 +952,28 @@ def cgis_metrics(
 ) -> str:
     """Whole-graph architectural metrics — coupling bottlenecks, God classes, PageRank.
 
-    Returns JSON ``{bottlenecks, god_classes, critical}`` computed with vectorized
-    DuckDB aggregations over the whole graph (fan-in/fan-out coupling,
-    declared-member counts, PageRank) — the global "what are the hotspots?" view
-    that complements the node-local trace/impact/context tools. Requires the
-    optional ``duckdb`` extra; an unavailable dependency is reported as a normal
-    ❌ message.
+    Returns JSON ``{bottlenecks, god_classes, critical, file_coupling, class_cohesion,
+    resolution}``
+    computed with vectorized DuckDB aggregations over the whole graph (fan-in/fan-out
+    coupling, declared-member counts, PageRank, per-file Ca/Ce/instability) — the
+    global "what are the hotspots?" view that complements the node-local
+    trace/impact/context tools. Requires the optional ``duckdb`` extra; an
+    unavailable dependency is reported as a normal ❌ message.
+
+    ``file_coupling`` counts *files*, not calls: Ca is how many other files
+    depend on a file (by IMPORTS or CALLS), Ce how many it depends on, and
+    instability ``I = Ce / (Ca + Ce)`` runs from 0 (stable, expensive to change)
+    to 1 (volatile); it is null for a file linked to no other.
+
+    ``class_cohesion`` ranks classes by LCOM4: the number of groups their instance
+    methods fall into when linked by a shared ``self`` attribute or a call. 1 is
+    cohesive; 2+ is a class doing unrelated jobs. Dunders (``__init__`` above
+    all), abstract, static and class methods are not counted.
+
+    ``resolution`` is the share of edges the resolver could not place, by the
+    same rule as ``cgis validate``. Read the rankings through it: a node whose
+    calls are mostly unresolved looks uncoupled because its edges point nowhere.
+    Under ``scope``/``exclude`` it counts the edges the selected code *emits*.
 
     ``exclude`` drops any node whose FQN contains one of the given dot-segments
     (e.g. ``["tests"]`` removes both ``tests.*`` and ``domains.*.tests.*``) so
@@ -981,6 +997,8 @@ def cgis_metrics(
                 bottleneck_limit=limit,
                 god_limit=limit,
                 critical_limit=limit,
+                file_limit=limit,
+                cohesion_limit=limit,
                 exclude=exclude or [],
                 scope=scope or [],
             )

cgis/cli.py

@@ -1365,7 +1365,7 @@ def context(
 
 
 def _render_metrics(report: ArchitectureReport) -> None:
-    """Print the architecture report as two Rich tables (bottlenecks + God classes)."""
+    """Print the architecture report: five Rich tables, then the unresolved share."""
     bottlenecks = Table(title="🔌 Coupling bottlenecks (top by fan-in + fan-out)")
     bottlenecks.add_column("Node", style="cyan")
     bottlenecks.add_column("Type", style="magenta")
@@ -1402,6 +1402,37 @@ def _render_metrics(report: ArchitectureReport) -> None:
         )
     console.print(critical)
 
+    files = Table(title="📄 File coupling (top by Ca + Ce)")
+    files.add_column("Module", style="cyan")
+    files.add_column("Ca", justify="right", style="green")
+    files.add_column("Ce", justify="right", style="yellow")
+    files.add_column("I", justify="right", style="magenta")
+    for f in report.file_coupling:
+        # I is undefined, not zero, for a file linked to no other.
+        files.add_row(
+            escape(f.module),
+            str(f.afferent),
+            str(f.efferent),
+            "—" if f.instability is None else f"{f.instability:.2f}",
+        )
+    console.print(files)
+
+    cohesion = Table(title="🧩 Class cohesion (top by LCOM4 — groups that share nothing)")
+    cohesion.add_column("Class", style="cyan")
+    cohesion.add_column("LCOM4", justify="right", style="red")
+    cohesion.add_column("Methods", justify="right", style="dim")
+    for c in report.class_cohesion:
+        cohesion.add_row(escape(c.class_id), str(c.lcom4), str(c.methods))
+    console.print(cohesion)
+
+    # Under the rankings, because it qualifies them: a module whose calls are
+    # mostly unresolved looks uncoupled only because its edges point nowhere (#451).
+    res = report.resolution
+    console.print(
+        f"🧩 Unresolved edges: {res.unresolved_edges} of {res.total_edges} "
+        f"({res.unresolved_ratio * 100:.1f}%) — `cgis validate` lists them"
+    )
+
 
 @app.command()
 def metrics(
@@ -1456,6 +1487,8 @@ def metrics(
                 bottleneck_limit=limit,
                 god_limit=limit,
                 critical_limit=limit,
+                file_limit=limit,
+                cohesion_limit=limit,
                 exclude=exclude,
                 scope=scope,
             )

cgis/extractors/_python_functions.py

@@ -91,6 +91,11 @@ class FunctionHandler:
             d == "abstractmethod" or d.endswith(".abstractmethod") for d in decorators
         ):
             metadata["is_abstract"] = True
+        if node_type == NodeType.METHOD:
+            # Always written for a method, even empty: its absence then means "a
+            # graph built before this existed", which LCOM4 must skip rather
+            # than read as a method touching no state (#451).
+            metadata["self_attrs"] = receiver_attribute_names(node, code_bytes, decorators)
 
         func_node = Node(
             id=node_id,
@@ -402,6 +407,93 @@ class FunctionHandler:
             acc.setdefault(class_fqn, {})[attr_name] = resolved
 
 
+#: Decorators after which a method's first parameter is not the instance.
+_NO_RECEIVER_DECORATORS = frozenset({"staticmethod"})
+
+
+def _receiver_name(node: BaseNode, code_bytes: bytes, decorators: list[str] | None) -> str | None:
+    """The name a method's first parameter binds the receiver to, or None if it has none.
+
+    None for a staticmethod, whose first parameter is an ordinary argument, and
+    for a method declared with no parameters at all.
+    """
+    if decorators and any(d.rsplit(".", 1)[-1] in _NO_RECEIVER_DECORATORS for d in decorators):
+        return None
+    names = _parameter_names(node, code_bytes)
+    return names[0] if names else None
+
+
+def _parameter_names(node: BaseNode, code_bytes: bytes) -> list[str]:
+    """The names a function or lambda binds as parameters, in order.
+
+    Covers plain, typed and defaulted parameters (`self`, `self: A`,
+    `n: int = 1`); `*args`/`**kw` splats are skipped, being no receiver.
+    """
+    params = node.child_by_field_name("parameters")
+    names: list[str] = []
+    for param in params.named_children if params is not None else []:
+        if param.type in _SPLAT_PARAMETERS:
+            continue
+        ident = param if param.type == "identifier" else param.child_by_field_name("name")
+        if ident is None and param.named_children:
+            ident = param.named_children[0]
+        if ident is not None and ident.type == "identifier":
+            names.append(get_identifier(ident, code_bytes))
+    return names
+
+
+#: `*args` / `**kw`: they bind a tuple or dict, never the receiver (#521 review).
+_SPLAT_PARAMETERS = frozenset({"list_splat_pattern", "dictionary_splat_pattern"})
+
+#: Scopes whose parameters can rebind the receiver's name inside a method body.
+_REBINDING_SCOPES = frozenset({"function_definition", "lambda"})
+
+
+def _receiver_attribute(node: BaseNode, code_bytes: bytes, receiver: str) -> str | None:
+    """The attribute name when `node` is `<receiver>.<attribute>`, else None."""
+    if node.type != "attribute":
+        return None
+    obj = node.child_by_field_name("object")
+    attr = node.child_by_field_name("attribute")
+    if obj is None or attr is None or obj.type != "identifier":
+        return None
+    return get_identifier(attr, code_bytes) if get_identifier(obj, code_bytes) == receiver else None
+
+
+def receiver_attribute_names(
+    node: BaseNode, code_bytes: bytes, decorators: list[str] | None = None
+) -> list[str]:
+    """The attributes a method reads or writes through its first parameter, sorted (#451).
+
+    `def save(self): self._conn.commit(); self.flush()` gives `["_conn", "flush"]`
+    — fields and methods alike, since LCOM4 links two methods that share either.
+    The receiver is whatever the first parameter is named, so `cls` in a
+    classmethod counts too; a staticmethod has none and gives `[]`.
+
+    A nested class is not walked: its own methods' `self` is another object. A
+    nested function or lambda is, because a closure over `self` uses the same
+    state — unless one of its parameters takes the receiver's name, after which
+    that name means something else inside it (#521 review).
+    """
+    receiver = _receiver_name(node, code_bytes, decorators)
+    body = node.child_by_field_name("body")
+    if receiver is None or body is None:
+        return []
+    names: set[str] = set()
+    stack = [body]
+    while stack:
+        current = stack.pop()
+        if current.type == "class_definition" or (
+            current.type in _REBINDING_SCOPES and receiver in _parameter_names(current, code_bytes)
+        ):
+            continue
+        name = _receiver_attribute(current, code_bytes, receiver)
+        if name is not None:
+            names.add(name)
+        stack.extend(current.children)
+    return sorted(names)
+
+
 def emit_annotation_edges(
     type_node: BaseNode,
     code_bytes: bytes,

cgis/extractors/registry.py

@@ -5,7 +5,7 @@ did not: `cli.py` registered the extractors, `ContextCollector` filtered changed
 files by `.py`, fenced every file as ```python, and derived FQNs with the
 *Python* helper. The last of those is the one that bites — the Python helper
 strips `.py` and collapses `/__init__`, so handing it `src/app/foo.ts` yields
-`src.app.foo.ts`, an id no extractor ever emitted. `_graph_sections` then finds
+`src.app.foo.ts`, an id no extractor ever emitted. `GraphContextCollector.sections` then finds
 nothing, logs at debug, and the review completes looking normal with no graph
 context at all.
 

cgis/extractors/typescript_extractor.py

@@ -9,6 +9,9 @@ from cgis.extractors._typescript_bindings import shadowed_globals
 from cgis.extractors.base import BaseExtractor
 
 _RAW_CALL_PREFIX = "raw_call:"
+#: `Node.language` for everything this extractor emits, `.ts` and `.tsx` alike;
+#: the field defaults to "python", which every TS node used to be stored as (#504).
+TYPESCRIPT_LANG = "typescript"
 _EXPORT_UNWRAP_TYPES = frozenset(
     {
         "class_declaration",
@@ -78,6 +81,7 @@ def _make_node(fqn: str, name: str, node_type: NodeType, file_path: str, ts_node
         file_path=file_path,
         start_line=ts_node.start_point[0] + 1,
         end_line=ts_node.end_point[0] + 1,
+        language=TYPESCRIPT_LANG,
         namespace=NodeNamespace.INTERNAL,
     )
 
@@ -135,6 +139,7 @@ class TypeScriptExtractor(BaseExtractor):
             file_path=file_path,
             start_line=1,
             end_line=tree.root_node.end_point[0] + 1,
+            language=TYPESCRIPT_LANG,
             namespace=NodeNamespace.INTERNAL,
         )
         shadowed = shadowed_globals(tree.root_node)

cgis/guardian/axes.py

@@ -121,7 +121,7 @@ async def run_axis_review(
         merged.findings,
         context.get("diff", ""),
         concurrency,
-        evidence=await evidence_for(collector, os.environ),
+        evidence=await evidence_for(collector.source, os.environ),
     )
     judged = sum(1 for j in judgements if j is not None)
     if judged == 0:

cgis/guardian/chunked.py

@@ -121,12 +121,12 @@ async def run_chunked_review(
     result only when EVERY chunk failed; skeptic failure returns the merged
     findings unverified.
     """
-    diff = collector.get_git_diff()
-    if collector.db_path is None:  # routed guard (§4.1) — belt and braces
+    diff = collector.source.get_git_diff()
+    if not collector.graph.has_db():  # routed guard (§4.1) — belt and braces
         _msg = "run_chunked_review requires a graph DB"
         raise RuntimeError(_msg)
-    with SQLiteStore(str(collector.db_path)) as store:
-        chunks = build_chunks(diff, store, source_root=collector.source_root)
+    with SQLiteStore(str(collector.graph.db_path)) as store:
+        chunks = build_chunks(diff, store, source_root=collector.graph.source_root)
     if not chunks:
         if not split_diff_by_file(diff):
             return RoutedReview(
@@ -189,7 +189,7 @@ async def run_chunked_review(
         skeptic_provider,
         merged.findings,
         skeptic_context["diff"],
-        evidence=await evidence_for(collector, os.environ),
+        evidence=await evidence_for(collector.source, os.environ),
     )
     judged = sum(1 for j in judgements if j is not None)
     if judged == 0:
@@ -231,7 +231,7 @@ async def run_review_routed(
         )
 
     chunked = "chunked" in collector.features
-    if chunked and (collector.db_path is None or not collector.db_path.exists()):
+    if chunked and not collector.graph.has_db():
         log.warning("chunked requested but no graph DB; falling back to single pass.")
         chunked = False
     if not chunked:

cgis/guardian/collector.py

@@ -1,7 +1,15 @@
-"""Gathers git diff and project files needed for Guardian review context."""
+"""Gathers git diff and project files needed for Guardian review context.
+
+Three classes, split along their dependencies (#215): `SourceCollector` reads git
+and the working tree, `GraphContextCollector` reads graph.db and the ontology, and
+`ContextCollector` composes the two into a review's context sections. The first
+two know nothing of features or of each other.
+"""
 
 import subprocess
+from collections.abc import Mapping
 from pathlib import Path
+from typing import Literal
 
 import structlog
 
@@ -9,7 +17,7 @@ from cgis.extractors.registry import is_supported, language_for
 from cgis.guardian.chunker import Chunk
 from cgis.query.drift.drift import DriftScorer
 from cgis.query.drift.fingerprint import FingerprintExtractor
-from cgis.query.drift.quotient import build_quotient
+from cgis.query.drift.quotient import build_quotient, quotient_call_tally
 from cgis.query.engine import QueryEngine
 from cgis.query.render.mermaid import MermaidCompiler
 from cgis.storage.sqlite_store import SQLiteStore
@@ -36,42 +44,40 @@ def parse_features(raw: str) -> frozenset[str]:
     return frozenset(items)
 
 
-class ContextCollector:
-    """Gathers all necessary context for the review."""
+#: How a review's feature set came to be (#505). "env" — GUARDIAN_FEATURES was
+#: set, possibly to nothing; "default" — it was unset or blank, so the review ran
+#: with no optional section. Recorded beside the set rather than inferred from
+#: it: an empty set is what both an unset variable and `GUARDIAN_FEATURES=,`
+#: produce, and only one of them was a choice.
+FeaturesSource = Literal["env", "default"]
 
-    def __init__(
-        self,
-        project_root: Path,
-        base_branch: str = "main",
-        db_path: Path | None = None,
-        base_ref: str | None = None,
-        source_root: str = "src",
-        features: frozenset[str] = frozenset(),
-        include_graph: bool = True,
-    ) -> None:
-        """Set project root, diff base (branch or explicit ref), and optional graph DB.
 
-        base_ref, when given, is used verbatim (e.g. a SHA for benchmark
-        replays); otherwise the diff base is origin/<base_branch>.
+def features_setting(env: Mapping[str, str]) -> tuple[frozenset[str], FeaturesSource]:
+    """The context sections a review gets, and how that came to be, from one read (#505).
 
-        source_root must match the ingest root used to build the graph DB
-        (CI runs `cgis ingest ./src`): node FQNs are relative to that root,
-        so changed-file paths are stripped of it before lookup.
+    One call for both halves, like `temperature_setting` (#393): reading the
+    variable twice is how a record comes to describe a prompt it did not have.
+    An unknown name still raises, through `parse_features`.
+    """
+    raw = (env.get("GUARDIAN_FEATURES") or "").strip()
+    if not raw:
+        return frozenset(), "default"
+    return parse_features(raw), "env"
 
-        features gates the optional context sections (spec §4): "full_files", "flow", "drift".
 
-        include_graph=False drops the impact-graph Mermaid section — a "diff-only"
-        prompt that fits a smaller context window (e.g. a local Ollama model whose
-        window is exceeded once the graph is appended).
+class SourceCollector:
+    """What the PR changed and what its files say: git and the working tree."""
+
+    def __init__(
+        self, project_root: Path, base_branch: str = "main", base_ref: str | None = None
+    ) -> None:
+        """Set project root and diff base (an explicit ref, else origin/<base_branch>).
+
+        base_ref, when given, is used verbatim (e.g. a SHA for benchmark replays).
         """
         self.project_root = project_root
         self.base_branch = base_branch
-        self.db_path = db_path
         self.base_ref = base_ref
-        self.source_root = source_root
-        self.features = features
-        self.include_graph = include_graph
-        self.graph_stats: dict[str, int] = {"total": 0, "with_graph": 0, "flow_fallback": 0}
         self._diff_cache: str | None = None
 
     def _diff_range(self) -> str:
@@ -171,16 +177,33 @@ class ContextCollector:
             sections.append(f"#### `{rel_path}`\n```{fence}\n{text}\n```")
         return "\n\n".join(sections + omitted)
 
-    def _graph_sections(
-        self, changed_files: list[str], *, flow: bool
-    ) -> tuple[list[str], dict[str, int]]:
-        """Impact-graph Mermaid sections + local stats for the given files.
 
-        Pure with respect to self.graph_stats — callers decide whether to
-        overwrite (global path) or accumulate (per-chunk path).
+class GraphContextCollector:
+    """What graph.db says about the changed files: impact graphs and drift."""
+
+    def __init__(self, project_root: Path, db_path: Path | None, source_root: str = "src") -> None:
+        """Set the graph DB, the ingest root its FQNs are relative to, and the project root.
+
+        source_root must match the ingest root used to build the graph DB (CI
+        runs `cgis ingest ./src`): changed-file paths are stripped of it before
+        lookup. project_root locates docs/ontology/patterns.yaml for drift.
+        """
+        self.project_root = project_root
+        self.db_path = db_path
+        self.source_root = source_root
+
+    def has_db(self) -> bool:
+        """Whether a graph DB was given and exists on disk."""
+        return self.db_path is not None and self.db_path.exists()
+
+    def sections(self, changed_files: list[str], *, flow: bool) -> tuple[list[str], dict[str, int]]:
+        """Impact-graph Mermaid sections + their stats for the given files.
+
+        Holds no stats of its own — the caller decides whether to overwrite
+        (global path) or accumulate (per-chunk path).
         """
         stats = {"total": 0, "with_graph": 0, "flow_fallback": 0}
-        if self.db_path is None or not self.db_path.exists() or not changed_files:
+        if not self.has_db() or not changed_files:
             return [], stats
         stats["total"] = len(changed_files)
         compiler = MermaidCompiler()
@@ -210,32 +233,13 @@ class ContextCollector:
         stats["with_graph"] = len(sections)
         return sections, stats
 
-    def collect_graph_context(self) -> str:
-        """Query graph.db for impact graphs of changed files; return Mermaid blocks."""
-        if not self.include_graph:
-            return ""  # diff-only prompt (fits a smaller context window)
-        if self.db_path is None or not self.db_path.exists():
-            return ""
-        changed_files = self.get_changed_source_files()
-        if not changed_files:
-            return ""
-        sections, stats = self._graph_sections(changed_files, flow="flow" in self.features)
-        self.graph_stats = stats
-        if stats["total"] > 0 and stats["with_graph"] == 0:
-            log.warning(
-                "No graph context found for any changed file.",
-                changed_files=stats["total"],
-                project_root=str(self.project_root),
-            )
-        return "\n\n".join(sections)
-
     def collect_drift(self) -> str:
         """Compact per-domain drift table + quotient k=1 lines (spec §4.3).
 
         First real consumer of drift v2 outside tests — the soft enforcement
         channel deferred in #146/#151. Any failure degrades to an empty section.
         """
-        if self.db_path is None or not self.db_path.exists():
+        if not self.has_db():
             return ""
         patterns = self.project_root / "docs" / "ontology" / "patterns.yaml"
         if not patterns.exists():
@@ -251,10 +255,11 @@ class ContextCollector:
                 reports = [scorer.score(extractor.extract(d.fqn_prefix), d) for d in domains]
                 level = scorer.load_project_level()
                 if level:
-                    qnodes, qedges = build_quotient(
-                        store.get_all_nodes(), store.get_all_edges(), domains
+                    all_nodes, all_edges = store.get_all_nodes(), store.get_all_edges()
+                    qnodes, qedges = build_quotient(all_nodes, all_edges, domains)
+                    q_extractor = FingerprintExtractor.from_graph(
+                        qnodes, qedges, quotient_call_tally(all_nodes, all_edges, domains)
                     )
-                    q_extractor = FingerprintExtractor.from_graph(qnodes, qedges)
                     quotient_lines = [
                         f"Quotient k=1 [{b.name}] vs {qr.expected_pattern}: "
                         f"drift={qr.drift_score:.2f} (observe-only)"
@@ -280,22 +285,72 @@ class ContextCollector:
             table + "\n".join(rows) + ("\n" + "\n".join(quotient_lines) if quotient_lines else "")
         )
 
+
+class ContextCollector:
+    """Composes a review's context sections from its source and graph collaborators."""
+
+    def __init__(
+        self,
+        project_root: Path,
+        base_branch: str = "main",
+        db_path: Path | None = None,
+        base_ref: str | None = None,
+        source_root: str = "src",
+        features: frozenset[str] = frozenset(),
+        include_graph: bool = True,
+    ) -> None:
+        """Build the source and graph collaborators and set what the review asks for.
+
+        project_root, base_branch and base_ref go to `source`; db_path and
+        source_root to `graph` (see each for their meaning).
+
+        features gates the optional context sections (spec §4): "full_files", "flow", "drift".
+
+        include_graph=False drops the impact-graph Mermaid section — a "diff-only"
+        prompt that fits a smaller context window (e.g. a local Ollama model whose
+        window is exceeded once the graph is appended).
+        """
+        self.source = SourceCollector(project_root, base_branch, base_ref)
+        self.graph = GraphContextCollector(project_root, db_path, source_root)
+        self.features = features
+        self.include_graph = include_graph
+        self.graph_stats: dict[str, int] = {"total": 0, "with_graph": 0, "flow_fallback": 0}
+
+    def collect_graph_context(self) -> str:
+        """Impact graphs of the changed files as Mermaid blocks; records graph_stats."""
+        if not self.include_graph:
+            return ""  # diff-only prompt (fits a smaller context window)
+        if not self.graph.has_db():
+            return ""
+        changed_files = self.source.get_changed_source_files()
+        if not changed_files:
+            return ""
+        sections, stats = self.graph.sections(changed_files, flow="flow" in self.features)
+        self.graph_stats = stats
+        if stats["total"] > 0 and stats["with_graph"] == 0:
+            log.warning(
+                "No graph context found for any changed file.",
+                changed_files=stats["total"],
+                project_root=str(self.source.project_root),
+            )
+        return "\n\n".join(sections)
+
     def collect_all(self) -> dict[str, str]:
         """Collects all relevant files, git diff, and optional graph context."""
         context: dict[str, str] = {
-            "diff": self.get_git_diff(),
-            "contributing": self.read_file("CONTRIBUTING.md"),
-            "ontology": self.read_file("docs/ontology/core.yaml"),
+            "diff": self.source.get_git_diff(),
+            "contributing": self.source.read_file("CONTRIBUTING.md"),
+            "ontology": self.source.read_file("docs/ontology/core.yaml"),
         }
         graph_context = self.collect_graph_context()
         if graph_context:
             context["graph_context"] = graph_context
         if "full_files" in self.features:
-            full_files = self.collect_full_files()
+            full_files = self.source.collect_full_files()
             if full_files:
                 context["full_files"] = full_files
         if "drift" in self.features:
-            drift = self.collect_drift()
+            drift = self.graph.collect_drift()
             if drift:
                 context["drift"] = drift
         return context
@@ -310,15 +365,15 @@ class ContextCollector:
         source_files = [f for f in chunk.files if is_supported(f)]
         context: dict[str, str] = {
             "diff": chunk.diff,
-            "contributing": self.read_file("CONTRIBUTING.md"),
-            "ontology": self.read_file("docs/ontology/core.yaml"),
+            "contributing": self.source.read_file("CONTRIBUTING.md"),
+            "ontology": self.source.read_file("docs/ontology/core.yaml"),
         }
-        sections, stats = self._graph_sections(source_files, flow=True)
+        sections, stats = self.graph.sections(source_files, flow=True)
         for key, value in stats.items():
             self.graph_stats[key] = self.graph_stats.get(key, 0) + value
         if sections:
             context["graph_context"] = "\n\n".join(sections)
-        full_files = self.collect_full_files(source_files)
+        full_files = self.source.collect_full_files(source_files)
         if full_files:
             context["full_files"] = full_files
         return context

cgis/guardian/core.py

@@ -138,7 +138,7 @@ class GuardianReviewer:
             result.findings,
             context.get("diff", ""),
             self.concurrency,
-            evidence=await evidence_for(self.context_collector, os.environ),
+            evidence=await evidence_for(self.context_collector.source, os.environ),
         )
         judged = sum(1 for j in judgements if j is not None)
         if judged == 0:

cgis/guardian/evidence.py

@@ -35,7 +35,7 @@ import structlog
 from pydantic import BaseModel
 
 if TYPE_CHECKING:  # pragma: no cover
-    from cgis.guardian.collector import ContextCollector
+    from cgis.guardian.collector import SourceCollector
 
 log = structlog.getLogger(__name__)
 
@@ -210,7 +210,7 @@ def collect_evidence(project_root: Path, changed_files: tuple[str, ...]) -> Evid
 EVIDENCE_FLAG = "GUARDIAN_EVIDENCE"
 
 
-async def evidence_for(collector: "ContextCollector", env: Mapping[str, str]) -> Evidence | None:
+async def evidence_for(collector: "SourceCollector", env: Mapping[str, str]) -> Evidence | None:
     """Evidence for a review, or None when it is switched off or unavailable.
 
     The single seam every caller uses, so "is the flag on" is decided in one