sourcecode 1.30.18__tar.gz → 1.30.20__tar.gz

{sourcecode-1.30.18 → sourcecode-1.30.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.30.18
+Version: 1.30.20
 Summary: Deterministic codebase context for AI coding agents
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -221,7 +221,7 @@ Description-Content-Type: text/markdown
 
 **Deterministic, behavior-aware codebase context for AI agents and PR review.**
 
-![Version](https://img.shields.io/badge/version-1.30.18-blue)
+![Version](https://img.shields.io/badge/version-1.30.20-blue)
 ![Python](https://img.shields.io/badge/python-3.10%2B-green)
 
 ---
@@ -257,7 +257,7 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.30.18
+# sourcecode 1.30.20
 ```
 
 ---

{sourcecode-1.30.18 → sourcecode-1.30.20}/README.md

@@ -2,7 +2,7 @@
 
 **Deterministic, behavior-aware codebase context for AI agents and PR review.**
 
-![Version](https://img.shields.io/badge/version-1.30.18-blue)
+![Version](https://img.shields.io/badge/version-1.30.20-blue)
 ![Python](https://img.shields.io/badge/python-3.10%2B-green)
 
 ---
@@ -38,7 +38,7 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.30.18
+# sourcecode 1.30.20
 ```
 
 ---

{sourcecode-1.30.18 → sourcecode-1.30.20}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sourcecode"
-version = "1.30.18"
+version = "1.30.20"
 description = "Deterministic codebase context for AI coding agents"
 readme = "README.md"
 requires-python = ">=3.9"

{sourcecode-1.30.18 → sourcecode-1.30.20}/src/sourcecode/__init__.py

@@ -1,3 +1,3 @@
 """sourcecode — Deterministic codebase context maps for AI coding agents."""
 
-__version__ = "1.30.18"
+__version__ = "1.30.20"

{sourcecode-1.30.18 → sourcecode-1.30.20}/src/sourcecode/cli.py

@@ -1648,6 +1648,12 @@ def prepare_context_cmd(
         "--format",
         help="Output format: json (default) | github-comment (Markdown PR comment for review-pr task)",
     ),
+    debug_perf: bool = typer.Option(
+        False,
+        "--debug-perf",
+        help="Emit per-phase timing to stderr (git scan ms, symptom scoring ms, total ms)",
+        hidden=True,
+    ),
 ) -> None:
     """Task-specific context for AI coding agents.
 
@@ -1714,9 +1720,29 @@ def prepare_context_cmd(
         raise typer.Exit()
 
     from dataclasses import asdict
+    import time as _time
 
     builder = TaskContextBuilder(target)
-    output = builder.build(task, since=since, symptom=symptom)
+    _progress = Progress()
+    _phase = f"analyzing ({task})"
+    if since:
+        _phase += f" since {since}"
+    _progress.start(_phase)
+    _t0 = _time.perf_counter()
+    try:
+        output = builder.build(task, since=since, symptom=symptom)
+    finally:
+        _progress.finish()
+    _t_total = (_time.perf_counter() - _t0) * 1000
+
+    if debug_perf:
+        _perf = getattr(output, "_perf_ms", {}) or {}
+        typer.echo(
+            f"[debug-perf] total={_t_total:.0f}ms"
+            + (f"  git_scan={_perf.get('git_scan_ms', '?')}ms" if "git_scan_ms" in _perf else "")
+            + (f"  symptom={_perf.get('symptom_ms', '?')}ms" if "symptom_ms" in _perf else ""),
+            err=True,
+        )
 
     # Task-specific content-filter: each task emphasizes different output fields.
     # Fields marked False are suppressed from this task's output to reduce noise.
@@ -1918,6 +1944,8 @@ def prepare_context_cmd(
         out["related_notes"] = output.related_notes
     if output.symptom_note:
         out["symptom_note"] = output.symptom_note
+    if output.symptom_explain:
+        out["symptom_explain"] = output.symptom_explain
     if llm_prompt:
         out["llm_prompt"] = builder.render_prompt(output)
 
@@ -2012,12 +2040,33 @@ def repo_ir_cmd(
         "--include-tests",
         help="Include test files in analysis (excluded by default)",
     ),
+    max_nodes: Optional[int] = typer.Option(
+        None,
+        "--max-nodes",
+        help="Limit graph.nodes to top N by impact score (reduces output size)",
+    ),
+    max_edges: Optional[int] = typer.Option(
+        None,
+        "--max-edges",
+        help="Limit graph.edges to N (priority: edges between kept nodes)",
+    ),
+    summary_only: bool = typer.Option(
+        False,
+        "--summary-only",
+        help="Omit full graph.nodes/edges; keep analysis summary, impact, and change_set (<300KB typical)",
+    ),
 ) -> None:
     """Deterministic symbol-level IR for Java repositories.
 
     \b
     Extracts symbols, relations, Spring roles, and (with --since) symbol-level diffs.
-    Output is JSON: symbols[], relations[], changed_symbols[], spring_summary, graph_metadata.
+    Output is JSON: graph{nodes,edges}, analysis, impact, subsystems, change_set.
+
+    \b
+    Size control:
+      --summary-only          Omit full graph; keep analysis + impact (smallest output)
+      --max-nodes N           Keep top N nodes by score
+      --max-edges N           Keep top N edges (priority: both endpoints kept)
 
     \b
     Examples:
@@ -2025,11 +2074,13 @@ def repo_ir_cmd(
       sourcecode repo-ir /path/to/repo --since HEAD~1
       sourcecode repo-ir --files src/main/java/UserService.java
       sourcecode repo-ir --since main --output ir.json
+      sourcecode repo-ir --since HEAD~3 --summary-only --output ir-small.json
+      sourcecode repo-ir --max-nodes 200 --max-edges 500
     """
     import json as _json
     import sys as _sys
 
-    from sourcecode.repository_ir import build_repo_ir, find_java_files
+    from sourcecode.repository_ir import apply_ir_size_limits, build_repo_ir, find_java_files
 
     root = path.resolve()
     if not root.is_dir():
@@ -2062,12 +2113,33 @@ def repo_ir_cmd(
         )
         return
 
-    ir = build_repo_ir(file_list, root, since=since)
+    _ir_phase = f"extracting IR ({len(file_list)} files)"
+    if since:
+        _ir_phase += f" since {since}"
+    _ir_progress = Progress()
+    _ir_progress.start(_ir_phase)
+    try:
+        ir = build_repo_ir(file_list, root, since=since)
+    finally:
+        _ir_progress.finish()
+    ir = apply_ir_size_limits(
+        ir,
+        max_nodes=max_nodes,
+        max_edges=max_edges,
+        summary_only=summary_only,
+    )
     output = _json.dumps(ir, indent=2, ensure_ascii=False)
 
     if output_path:
         output_path.write_text(output, encoding="utf-8")
-        typer.echo(f"IR written to {output_path}", err=True)
+        n_nodes = len((ir.get("graph") or {}).get("nodes") or [])
+        n_edges = len((ir.get("graph") or {}).get("edges") or [])
+        size_kb = len(output.encode("utf-8")) // 1024
+        typer.echo(
+            f"IR written to {output_path} "
+            f"({size_kb}KB, {n_nodes} nodes, {n_edges} edges)",
+            err=True,
+        )
     else:
         _sys.stdout.write(output)
         _sys.stdout.write("\n")

{sourcecode-1.30.18 → sourcecode-1.30.20}/src/sourcecode/git_analyzer.py

@@ -52,8 +52,15 @@ _HOTSPOT_AUX_DIRS: frozenset[str] = frozenset({
     "sandbox", "sandboxes",
     "ci", "translations", "locales", "locale", "i18n", "l10n",
     ".planning",
+    # vendor / build dirs: high path count, zero operational signal
+    "vendor", "node_modules", "dist", "target", "build",
+    ".gradle", ".mvn", "generated-sources", "generated-resources",
 })
 
+# When git diff returns more changed files than this, degrade gracefully:
+# truncate hotspot analysis depth and emit a structured warning.
+_CHANGED_FILES_DEGRADATION_THRESHOLD = 200
+
 
 def _run_git(args: list[str], cwd: Path, timeout: int = 15) -> tuple[str, int]:
     result = subprocess.run(

{sourcecode-1.30.18 → sourcecode-1.30.20}/src/sourcecode/prepare_context.py

@@ -333,6 +333,7 @@ class TaskOutput:
     symptom: Optional[str] = None                                  # fix-bug only
     related_notes: list[dict] = field(default_factory=list)        # fix-bug + symptom only
     symptom_note: Optional[str] = None                             # fix-bug: cross-layer synonym note
+    symptom_explain: Optional[dict] = None                         # fix-bug: structured evidence breakdown
     # delta-specific impact fields
     impact_summary: Optional[str] = None
     affected_modules: list[str] = field(default_factory=list)
@@ -818,7 +819,7 @@ class TaskContextBuilder:
                         if not self._is_source(_p) or self._is_test(_p):
                             continue
                         try:
-                            _loc = len((self.root / _p).read_text(errors="replace").splitlines())
+                            _loc = len((self.root / _p).read_text(encoding="utf-8", errors="replace").splitlines())
                             if _loc > 200:
                                 _large.append((_loc, _p))
                         except OSError:
@@ -1207,6 +1208,7 @@ class TaskContextBuilder:
         symptom_keywords: list[str] = []
         related_notes: list[dict] = []
         symptom_note: Optional[str] = None
+        symptom_explain: Optional[dict] = None
         if task_name == "fix-bug" and symptom:
             import re as _re
             _camel_expanded = _re.sub(r'([a-z])([A-Z])', r'\1 \2', symptom)
@@ -1216,12 +1218,24 @@ class TaskContextBuilder:
                 if len(w) > 2
             ]
             if symptom_keywords:
+                # Pre-compile combined keyword pattern for fast content scanning
+                _kw_re = _re.compile(
+                    "|".join(_re.escape(kw) for kw in symptom_keywords),
+                    _re.IGNORECASE,
+                )
+
+                # Structured evidence collectors for symptom_explain
+                _sx_direct_path: list[str] = []
+                _sx_content: list[str] = []
+                _sx_commits: list[dict] = []
+                _sx_synonyms: list[str] = []
+                _sx_boosts: list[dict] = []
+
                 # Pass 1: surface code notes whose text contains any keyword
-                # Also track which file paths have matching notes (for score boost below).
                 _note_matched_paths: dict[str, int] = {}  # path → count of matching notes
                 for _n in cn_notes_for_ranking:
                     _text = (getattr(_n, "text", "") or "").lower()
-                    if any(kw in _text for kw in symptom_keywords):
+                    if _kw_re.search(_text):
                         _np = getattr(_n, "path", "")
                         related_notes.append({
                             "kind": getattr(_n, "kind", ""),
@@ -1231,17 +1245,22 @@ class TaskContextBuilder:
                         })
                         _note_matched_paths[_np] = _note_matched_paths.get(_np, 0) + 1
 
-                # Pass 2: build commit message index — files touched in commits whose
-                # message matches a symptom keyword get a strong recency signal.
-                # This is the primary signal for functional keywords like "sesiones"
-                # that don't appear in file paths but do appear in commit messages.
+                # Pass 2: build commit message index — cap at 60 most-recent commits.
+                # Files touched in commits whose message matches a symptom keyword get
+                # a strong recency signal. Primary signal for domain keywords ("sesiones")
+                # that appear in commit messages but not file paths.
                 _commit_file_hits: dict[str, int] = {}  # path → n matching commits
-                for _cr in _recent_commits_for_symptom:
+                _commits_scanned = _recent_commits_for_symptom[:60]
+                for _cr in _commits_scanned:
                     _msg_lower = (_cr.message or "").lower()
-                    if any(kw in _msg_lower for kw in symptom_keywords):
+                    if _kw_re.search(_msg_lower):
                         for _cf in (_cr.files_changed or []):
                             _cf_norm = _cf.replace("\\", "/")
                             _commit_file_hits[_cf_norm] = _commit_file_hits.get(_cf_norm, 0) + 1
+                        _sx_commits.append({
+                            "message": (_cr.message or "")[:80],
+                            "files": list((_cr.files_changed or [])[:5]),
+                        })
 
                 # Pass 3: inject files from commit index not yet in candidate pool
                 _existing_paths = {rf.path for rf in relevant_files}
@@ -1261,7 +1280,6 @@ class TaskContextBuilder:
                     _existing_paths.add(_cp)
 
                 # Pass 4: inject files whose path matches symptom keywords
-                # but weren't in the candidate pool (no structural/git signals).
                 for _p in all_paths:
                     if _p in _existing_paths:
                         continue
@@ -1282,13 +1300,29 @@ class TaskContextBuilder:
                         why=f"symptom injection: {', '.join(_matching_kws)}",
                     ))
                     _existing_paths.add(_p)
+                    _sx_direct_path.append(_p)
 
-                # Pass 5: multi-signal boost — apply commit, note, content, and path
-                # signals in one pass to avoid redundant file reads.
+                # Pass 5+6 combined: single file read per candidate.
+                # Limit content scan to top 80 candidates by current score to bound I/O.
                 _src_exts = frozenset({".java", ".py", ".ts", ".js", ".kt", ".go"})
+                _frontend_kws = [kw for kw in symptom_keywords if kw in _FRONTEND_SYMPTOM_MAP]
+                _backend_terms_set: list[str] = []
+                if _frontend_kws:
+                    _bt: list[str] = []
+                    for _fkw in _frontend_kws:
+                        _bt.extend(_FRONTEND_SYMPTOM_MAP[_fkw])
+                    _backend_terms_set = list(dict.fromkeys(_bt))
+
+                # Sort before content scan so top candidates get read first
+                relevant_files = sorted(relevant_files, key=lambda rf: -rf.score)
+                _CONTENT_SCAN_LIMIT = 80
+                _scan_candidates = relevant_files[:_CONTENT_SCAN_LIMIT]
+                _no_scan_candidates = relevant_files[_CONTENT_SCAN_LIMIT:]
+
                 _boosted: list[RelevantFile] = []
-                for _rf in relevant_files:
+                for _rf in _scan_candidates:
                     _extra = 0.0
+                    _extra_syn = 0.0
                     _reasons: list[str] = []
                     _p_lower = _rf.path.lower()
 
@@ -1298,6 +1332,7 @@ class TaskContextBuilder:
                         _cb = min(0.40, _c_hits * 0.25)
                         _extra += _cb
                         _reasons.append(f"commit-msg symptom ×{_c_hits} (+{_cb:.2f})")
+                        _sx_boosts.append({"type": "commit_message", "value": round(_cb, 3), "evidence": _rf.path})
 
                     # Code note boost: +0.20/note, cap +0.30
                     _n_hits = _note_matched_paths.get(_rf.path, 0)
@@ -1305,77 +1340,94 @@ class TaskContextBuilder:
                         _nb = min(0.30, _n_hits * 0.20)
                         _extra += _nb
                         _reasons.append(f"note-match symptom ×{_n_hits} (+{_nb:.2f})")
+                        _sx_boosts.append({"type": "code_note", "value": round(_nb, 3), "evidence": _rf.path})
 
-                    # Path keyword boost: +0.20/keyword already in score for injected
-                    # files; re-apply for pre-existing candidates whose path matches.
+                    # Path keyword boost for pre-existing candidates
                     _path_kws = [kw for kw in symptom_keywords if kw in _p_lower]
                     if _path_kws and _rf.role != "symptom_match":
                         _pb = 0.20 * len(_path_kws)
                         _extra += _pb
                         _reasons.append(f"path-kw symptom ({', '.join(_path_kws)}) (+{_pb:.2f})")
+                        _sx_boosts.append({"type": "path_match", "value": round(_pb, 3), "evidence": _rf.path})
 
-                    # Content scan boost: +0.05/hit, cap +0.50 (was +0.02, cap +0.30)
+                    # Single file read — covers both content scan and synonym scan
+                    _body_lower = ""
                     if Path(_rf.path).suffix.lower() in _src_exts:
                         try:
-                            _lines = (self.root / _rf.path).read_text(
+                            _body_lower = (self.root / _rf.path).read_text(
                                 encoding="utf-8", errors="replace"
-                            ).splitlines()[:300]
-                            _body = "\n".join(_lines).lower()
-                            _hits = sum(_body.count(kw) for kw in symptom_keywords)
-                            _content_b = min(0.50, _hits * 0.05)
-                            if _content_b > 0:
-                                _extra += _content_b
-                                _reasons.append(f"content-match symptom ×{_hits} (+{_content_b:.2f})")
+                            )[:12000].lower()  # ~300 lines avg
                         except OSError:
                             pass
 
+                    # Content scan boost: +0.05/hit, cap +0.50
+                    if _body_lower:
+                        _hits = len(_kw_re.findall(_body_lower))
+                        _content_b = min(0.50, _hits * 0.05)
+                        if _content_b > 0:
+                            _extra += _content_b
+                            _reasons.append(f"content-match symptom ×{_hits} (+{_content_b:.2f})")
+                            _sx_boosts.append({"type": "content_match", "value": round(_content_b, 3), "evidence": _rf.path})
+                            _sx_content.append(_rf.path)
+
+                    # Synonym scan (Pass 6): only apply when file has prior non-synonym
+                    # evidence (commit hit, note, path, or content) — prevents boosting
+                    # arbitrary interceptors/configs with no other signal.
+                    if _backend_terms_set and _body_lower:
+                        _prior_boost = _extra  # boost accumulated before synonym
+                        if _prior_boost >= 0.10:  # min threshold: must have real prior signal
+                            _hits_syn = sum(_body_lower.count(t) for t in _backend_terms_set)
+                            _extra_syn = min(0.20, _hits_syn * 0.02)
+                            if _extra_syn > 0:
+                                _sx_synonyms.append(_rf.path)
+                                _sx_boosts.append({"type": "synonym_match", "value": round(_extra_syn, 3), "evidence": _rf.path})
+
+                    _total_extra = _extra + _extra_syn
                     _new_reason = _rf.reason
                     if _reasons:
-                        _new_reason = _rf.reason + ", " + ", ".join(_reasons)
+                        _syn_suffix = f", synonym-match backend (+{_extra_syn:.2f})" if _extra_syn > 0 else ""
+                        _new_reason = _rf.reason + ", " + ", ".join(_reasons) + _syn_suffix
+                    elif _extra_syn > 0:
+                        _new_reason = _rf.reason + f", synonym-match backend (+{_extra_syn:.2f})"
+
                     _boosted.append(RelevantFile(
                         path=_rf.path,
                         role=_rf.role,
-                        score=round(min(_rf.score + _extra, 1.0), 2),
+                        score=round(min(_rf.score + _total_extra, 1.0), 2),
                         reason=_new_reason,
                         why=_rf.why,
                     ))
-                relevant_files = sorted(_boosted, key=lambda rf: -rf.score)
 
-                # Pass 6: cross-layer synonym boost — frontend keywords → backend equivalents
-                _synonym_note: Optional[str] = None
-                _frontend_kws = [kw for kw in symptom_keywords if kw in _FRONTEND_SYMPTOM_MAP]
-                if _frontend_kws:
-                    _backend_terms: list[str] = []
-                    for _fkw in _frontend_kws:
-                        _backend_terms.extend(_FRONTEND_SYMPTOM_MAP[_fkw])
-                    _backend_terms_set = list(dict.fromkeys(_backend_terms))
-                    _synonym_boosted: list[RelevantFile] = []
-                    for _rf in relevant_files:
-                        _extra_syn = 0.0
-                        if Path(_rf.path).suffix.lower() in _src_exts:
-                            try:
-                                _lines_syn = (self.root / _rf.path).read_text(
-                                    encoding="utf-8", errors="replace"
-                                ).splitlines()[:300]
-                                _body_syn = "\n".join(_lines_syn).lower()
-                                _hits_syn = sum(_body_syn.count(t) for t in _backend_terms_set)
-                                _extra_syn = min(0.20, _hits_syn * 0.02)
-                            except OSError:
-                                pass
-                        _synonym_boosted.append(RelevantFile(
-                            path=_rf.path,
-                            role=_rf.role,
-                            score=round(min(_rf.score + _extra_syn, 1.0), 2),
-                            reason=_rf.reason + (f", synonym-match backend (+{_extra_syn:.2f})" if _extra_syn > 0 else ""),
-                            why=_rf.why,
-                        ))
-                    relevant_files = sorted(_synonym_boosted, key=lambda rf: -rf.score)
-                    _synonym_note = (
+                relevant_files = sorted(_boosted + _no_scan_candidates, key=lambda rf: -rf.score)
+
+                # Synonym note (only when synonyms actually fired)
+                if _frontend_kws and _sx_synonyms:
+                    symptom_note = (
                         f"Frontend concept detected ({', '.join(_frontend_kws)}). "
-                        "Backend service-layer and interceptor files boosted by symptom keyword match "
+                        "Backend service-layer files boosted by synonym match "
                         "[INFERRED (LOW CONFIDENCE) — pattern heuristic, not structural proof]."
                     )
-                    symptom_note = _synonym_note
+
+                # Confidence: based on richest signal type present
+                if _commit_file_hits:
+                    _sx_confidence = "HIGH"
+                elif _sx_direct_path or _sx_content:
+                    _sx_confidence = "MEDIUM"
+                else:
+                    _sx_confidence = "LOW"
+
+                symptom_explain = {
+                    "keywords": symptom_keywords,
+                    "confidence": _sx_confidence,
+                    "direct_path_matches": _sx_direct_path[:10],
+                    "content_matches": _sx_content[:10],
+                    "commit_matches": _sx_commits[:10],
+                    "synonym_matches": _sx_synonyms[:10],
+                    "boosts": _sx_boosts[:30],
+                    "final_boost": round(
+                        sum(b["value"] for b in _sx_boosts), 3
+                    ),
+                }
 
         # ── 7. Test gaps (generate-tests only) ────────────────────────────
         test_gaps: list[str] = []
@@ -1474,6 +1526,7 @@ class TaskContextBuilder:
             symptom=symptom if task_name == "fix-bug" and symptom else None,
             related_notes=related_notes,
             symptom_note=symptom_note,
+            symptom_explain=symptom_explain if task_name == "fix-bug" else None,
             impact_summary=_delta_impact_summary,
             affected_modules=_delta_affected_modules,
             risk_areas=_delta_risk_areas,

{sourcecode-1.30.18 → sourcecode-1.30.20}/src/sourcecode/repository_ir.py

@@ -1544,12 +1544,99 @@ def build_repo_ir(
     return _assemble(all_symbols, unique_relations, all_changed, spring_summary, all_route_diffs_sorted)
 
 
+# ---------------------------------------------------------------------------
+# Output size limits
+# ---------------------------------------------------------------------------
+
+# Vendor/generated dirs to skip when finding Java files and in git analysis.
+_VENDOR_DIRS: frozenset[str] = frozenset({
+    "vendor", "node_modules", "dist", "target", "build",
+    ".gradle", ".mvn", "generated", "generated-sources",
+    "generated-resources",
+})
+
+
+def apply_ir_size_limits(
+    ir: dict,
+    *,
+    max_nodes: Optional[int] = None,
+    max_edges: Optional[int] = None,
+    summary_only: bool = False,
+) -> dict:
+    """Apply size limits to a repo-ir output dict. Non-destructive: returns new dict.
+
+    Node ordering: top-ranked (by impact score) nodes are kept first.
+    Edge priority: edges connecting two kept nodes over cross-boundary edges.
+    """
+    if not max_nodes and not max_edges and not summary_only:
+        return ir
+
+    out = dict(ir)
+    graph = ir.get("graph") or {}
+    nodes: list[dict] = list(graph.get("nodes") or [])
+    edges: list[dict] = list(graph.get("edges") or [])
+    ranked: list[dict] = list((ir.get("impact") or {}).get("ranked_nodes") or [])
+    analysis: dict = ir.get("analysis") or {}
+
+    if summary_only:
+        n_nodes, n_edges = len(nodes), len(edges)
+        out["graph"] = {
+            "nodes": [],
+            "edges": [],
+            "_omitted": (
+                f"{n_nodes} nodes and {n_edges} edges omitted — "
+                "remove --summary-only to restore full graph"
+            ),
+        }
+        out["reverse_graph"] = {}
+        out["impact"] = {
+            "global_score": (ir.get("impact") or {}).get("global_score", 0),
+            "ranked_nodes": ranked[:20],
+        }
+        out["analysis"] = {
+            "changed_entities": analysis.get("changed_entities") or [],
+            "impacted_entities": (analysis.get("impacted_entities") or [])[:20],
+            "isolated_changes": analysis.get("isolated_changes") or [],
+            "validated_changes": analysis.get("validated_changes") or [],
+        }
+        return out
+
+    # Build score map from ranked_nodes (already sorted -score, fqn)
+    score_map: dict[str, float] = {rn["entity"]: rn["score"] for rn in ranked}
+    kept_fqns: Optional[set[str]] = None
+
+    if max_nodes is not None and len(nodes) > max_nodes:
+        nodes_sorted = sorted(
+            nodes,
+            key=lambda n: (-score_map.get(n["fqn"], 0.0), n["fqn"]),
+        )
+        nodes = nodes_sorted[:max_nodes]
+        kept_fqns = {n["fqn"] for n in nodes}
+        ranked = [rn for rn in ranked if rn["entity"] in kept_fqns]
+
+    if kept_fqns is not None or max_edges is not None:
+        if kept_fqns is not None:
+            # Priority: edges where both endpoints are kept nodes
+            priority = [e for e in edges if e["from"] in kept_fqns and e["to"] in kept_fqns]
+            rest = [e for e in edges if not (e["from"] in kept_fqns and e["to"] in kept_fqns)]
+            edges = priority + rest
+        if max_edges is not None:
+            edges = edges[:max_edges]
+
+    out["graph"] = {"nodes": nodes, "edges": edges}
+    out["impact"] = {
+        "global_score": (ir.get("impact") or {}).get("global_score", 0),
+        "ranked_nodes": ranked,
+    }
+    return out
+
+
 # ---------------------------------------------------------------------------
 # Convenience: find Java files in a repo
 # ---------------------------------------------------------------------------
 
 def find_java_files(root: Path, *, max_files: int = 500) -> list[str]:
-    """Return relative paths to Java files under root, excluding test dirs."""
+    """Return relative paths to Java files under root, excluding test dirs and vendor."""
     results: list[str] = []
     for p in sorted(root.rglob("*.java")):
         if len(results) >= max_files:
@@ -1558,7 +1645,12 @@ def find_java_files(root: Path, *, max_files: int = 500) -> list[str]:
             rel = str(p.relative_to(root)).replace("\\", "/")
         except ValueError:
             continue
+        parts = rel.split("/")
+        # Skip test dirs
         if "/test/" in rel or "/tests/" in rel or rel.startswith("test/"):
             continue
+        # Skip vendor/generated/build dirs
+        if any(part in _VENDOR_DIRS for part in parts[:-1]):
+            continue
         results.append(rel)
     return results