sourcecode 1.30.20__tar.gz → 1.30.22__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.30.20
+Version: 1.30.22
 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.20-blue)
+![Version](https://img.shields.io/badge/version-1.30.22-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.20
+# sourcecode 1.30.22
 ```
 
 ---

{sourcecode-1.30.20 → sourcecode-1.30.22}/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.20-blue)
+![Version](https://img.shields.io/badge/version-1.30.22-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.20
+# sourcecode 1.30.22
 ```
 
 ---

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

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

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

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

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

@@ -1596,6 +1596,86 @@ def main(
                 typer.echo("✓ copied to clipboard", err=True)
 
 
+# ── prepare-context output helpers ────────────────────────────────────────────
+
+def _make_explanation(reason: str, why: str) -> str:
+    """Merge reason+why into one human string. Drop internal pipe-format jargon."""
+    if why and not why.startswith("artifact_type:"):
+        return why
+    return reason
+
+
+def _serialize_relevant_file(f: Any) -> dict:
+    from dataclasses import asdict as _asdict
+    d = {k: v for k, v in _asdict(f).items() if v != "" and v is not None}
+    reason = d.pop("reason", "") or ""
+    why = d.pop("why", "") or ""
+    d.pop("score", None)  # score removed from public output (internal ranking only)
+    explanation = _make_explanation(reason, why)
+    if explanation:
+        d["explanation"] = explanation
+    return d
+
+
+def _transform_impact_scores(scores: dict) -> dict:
+    """Convert internal impact_score_per_file to human-readable review signals."""
+    _THRESHOLDS = [(0.60, "high"), (0.40, "medium")]
+    _CT_LABELS: dict[str, str] = {
+        "security_change":    "security-sensitive change",
+        "behavioral_change":  "behavioral change",
+        "structural_change":  "structural modification",
+        "configuration_change": "configuration change",
+        "dependency_change":  "dependency update",
+        "ui_change":          "UI change",
+    }
+    result: dict = {}
+    for path, entry in scores.items():
+        raw = entry.get("_rank_score", 0.0)
+        priority = next((p for thresh, p in _THRESHOLDS if raw >= thresh), "low")
+        signals: list[str] = [
+            _CT_LABELS[ct] for ct in entry.get("change_types", []) if ct in _CT_LABELS
+        ]
+        ev = entry.get("evidence", {})
+        callers = ev.get("reverse_edge_count", 0)
+        if callers:
+            signals.append(f"imported by {callers} other file{'s' if callers > 1 else ''}")
+        out_entry: dict = {"review_priority": priority}
+        if signals:
+            out_entry["signals"] = signals
+        result[path] = out_entry
+    return result
+
+
+def _clean_system_impact(si: dict) -> dict:
+    """Remove empty lists/dicts from system_impact — only emit positive signals."""
+    return {k: v for k, v in si.items() if v}
+
+
+def _build_human_summary(output: Any) -> dict:
+    """Human-readable summary block for delta/review-pr output."""
+    concerns: list[str] = []
+    si = getattr(output, "system_impact", {}) or {}
+    for ri in si.get("runtime_impact", []):
+        sig = ri.get("signal", "")
+        if sig:
+            concerns.append(sig)
+    for bc in si.get("behavioral_changes", []):
+        stmt = bc.get("statement", "")
+        if stmt:
+            concerns.append(stmt)
+    cov = getattr(output, "test_coverage_risk", {}) or {}
+    missing = cov.get("changed_files_without_tests", [])
+    if missing:
+        concerns.append(f"{len(missing)} changed file(s) without test coverage detected")
+    summary: dict = {}
+    if getattr(output, "impact_summary", None):
+        summary["description"] = output.impact_summary
+    if concerns:
+        summary["review_concerns"] = concerns[:6]
+    summary["confidence"] = (getattr(output, "confidence", None) or "medium").upper()
+    return summary
+
+
 @app.command("prepare-context")
 def prepare_context_cmd(
     task: Optional[str] = typer.Argument(
@@ -1801,9 +1881,14 @@ def prepare_context_cmd(
     def _task_include(field: str) -> bool:
         return _content_filter.get(field, True)
 
+    _run_id = hashlib.sha256(
+        f"{task}:{target}:{since or ''}:{format or ''}:{symptom or ''}".encode()
+    ).hexdigest()[:16]
+
     out: dict[str, Any] = {
         "task": output.task,
         "goal": output.goal,
+        "run_id": _run_id,
     }
     if _task_include("project_summary"):
         out["project_summary"] = output.project_summary
@@ -1813,7 +1898,7 @@ def prepare_context_cmd(
         out["confidence"] = output.confidence
     if task != "review-pr" and _task_include("relevant_files"):
         out["relevant_files"] = [
-            {k: v for k, v in asdict(f).items() if v != ""}
+            _serialize_relevant_file(f)
             for f in output.relevant_files
         ]
     if _task_include("key_dependencies") and output.key_dependencies:
@@ -1854,6 +1939,30 @@ def prepare_context_cmd(
                 _sys.stdout.buffer.write(b"\n")
                 _sys.stdout.buffer.flush()
             raise typer.Exit(code=1)
+        if output.ci_decision == "no_changes":
+            # Early exit: no diff — emit minimal JSON without any analysis fields.
+            # Prevents no_changes from ever being serialized alongside relevant_files > 0.
+            _nc_out: dict[str, Any] = {
+                "task": output.task,
+                "ci_decision": "no_changes",
+                "summary": "No changes detected",
+            }
+            if output.since:
+                _nc_out["since"] = output.since
+            if output.analysis_scope:
+                _nc_out["analysis_scope"] = output.analysis_scope
+            _nc_json = json.dumps(_nc_out, indent=2, ensure_ascii=False)
+            if output_path is not None:
+                output_path.write_text(_nc_json, encoding="utf-8")
+            else:
+                import sys as _sys
+                _sys.stdout.buffer.write(_nc_json.encode("utf-8"))
+                _sys.stdout.buffer.write(b"\n")
+                _sys.stdout.buffer.flush()
+            if copy:
+                _copy_to_clipboard(_nc_json)
+                typer.echo("✓ copied to clipboard", err=True)
+            raise typer.Exit()
         if output.ci_decision:
             out["ci_decision"] = output.ci_decision
         if output.since:
@@ -1864,16 +1973,19 @@ def prepare_context_cmd(
             out["affected_modules"] = output.affected_modules
         if output.risk_areas:
             out["risk_areas"] = output.risk_areas
-        if output.why_these_files:
-            out["reasoning"] = output.why_these_files
         if output.change_type:
             out["change_type"] = output.change_type
         if output.system_impact:
-            out["system_impact"] = output.system_impact
+            _si = _clean_system_impact(output.system_impact)
+            if _si:
+                out["system_impact"] = _si
         if output.dependency_graph_summary:
-            out["dependency_graph_summary"] = output.dependency_graph_summary
+            _dgraph = {k: v for k, v in output.dependency_graph_summary.items() if v is not None}
+            if _dgraph:
+                out["dependency_graph_summary"] = _dgraph
         if output.impact_score_per_file:
-            out["impact_score_per_file"] = output.impact_score_per_file
+            out["impact_score_per_file"] = _transform_impact_scores(output.impact_score_per_file)
+        out["summary"] = _build_human_summary(output)
     # review-pr specific fields
     if task == "review-pr":
         if output.error_code:
@@ -1928,8 +2040,7 @@ def prepare_context_cmd(
             out["behavioral_impact"] = output.behavioral_impact
         if output.impact_summary:
             out["impact_summary"] = output.impact_summary
-        if output.why_these_files:
-            out["reasoning"] = output.why_these_files
+        out["summary"] = _build_human_summary(output)
         # git-first scope metadata
         out["scope"] = {
             "source": output.scope_source or "git_diff",

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

@@ -377,6 +377,25 @@ class TaskOutput:
     analysis_scope: dict = field(default_factory=dict)
 
 
+@dataclass
+class CanonicalAnalysisIR:
+    """Shared intermediate representation produced by _build_delta_impact.
+
+    Both delta and review-pr derive their task-specific output from this IR.
+    Never recalculate logic per command — render views from this single object.
+    """
+    relevant_files: list[RelevantFile]
+    impact_summary: str
+    affected_modules: list[str]
+    risk_areas: list[dict]
+    why_these_files: dict[str, str]
+    analysis_gaps: list[str]
+    system_impact: dict
+    change_type: list[str]
+    dependency_graph_summary: dict
+    impact_score_per_file: dict
+
+
 # ─────────────────────────────────────────────────────────────────────────────
 # Builder
 # ─────────────────────────────────────────────────────────────────────────────
@@ -556,7 +575,7 @@ _ARTIFACT_CHANGE_EFFECT: dict[str, str] = {
     "test":           "test file (no production code modified)",
     "documentation":  "documentation file (no runtime impact)",
     "ide_noise":      "IDE/tooling artifact (no application impact)",
-    "source":         "application source (artifact role requires annotation inspection)",
+    "source":         "application source file (role could not be confirmed from code signals)",
 }
 
 # Maps frontend symptom keywords → backend terms likely to contain the root cause.
@@ -934,7 +953,8 @@ class TaskContextBuilder:
         test_set = {p for p in all_paths if self._is_test(p)}
         source_set = {p for p in all_paths if not self._is_test(p) and self._is_source(p)}
 
-        # Delta uses a dedicated impact-analysis path — never the generic ranker.
+        # Delta and review-pr share CanonicalAnalysisIR — computed once, rendered per task.
+        _ir: Optional[CanonicalAnalysisIR] = None
         _delta_impact_summary: Optional[str] = None
         _delta_affected_modules: list[str] = []
         _delta_risk_areas: list[dict] = []
@@ -947,23 +967,22 @@ class TaskContextBuilder:
 
         if task_name in ("delta", "review-pr"):
             _delta_changed_list: list[str] = sorted(_delta_files) if _delta_files else []
-            (
-                relevant_files,
-                _delta_impact_summary,
-                _delta_affected_modules,
-                _delta_risk_areas,
-                _delta_why,
-                _delta_analysis_gaps,
-                _delta_system_impact,
-                _delta_change_type,
-                _delta_dep_graph_summary,
-                _delta_impact_score_per_file,
-            ) = self._build_delta_impact(
+            _ir = self._build_delta_impact(
                 changed_files=_delta_changed_list,
                 all_paths=all_paths,
                 entry_points=entry_points,
                 since=since,
             )
+            relevant_files = _ir.relevant_files
+            _delta_impact_summary = _ir.impact_summary
+            _delta_affected_modules = _ir.affected_modules
+            _delta_risk_areas = _ir.risk_areas
+            _delta_why = _ir.why_these_files
+            _delta_analysis_gaps = _ir.analysis_gaps
+            _delta_system_impact = _ir.system_impact
+            _delta_change_type = _ir.change_type
+            _delta_dep_graph_summary = _ir.dependency_graph_summary
+            _delta_impact_score_per_file = _ir.impact_score_per_file
         else:
             relevant_files = self._rank_files(
                 task_name, spec, all_paths, entry_set, test_set,
@@ -1156,22 +1175,24 @@ class TaskContextBuilder:
                     else "unknown"
                 )
                 _impact_entry = _delta_impact_score_per_file.get(_f) or {}
-                _entry = {
+                _ev_complete = {k: v for k, v in _impact_entry.get("evidence", {}).items() if v}
+                _entry: dict = {
                     "path": _f,
                     "diff_source": _diff_source,
                     "role": _role_obj,
                     "artifact_type": _f_atype,
                     "evidence": _evidence,
                     "change_effect": {
-                        "statement": _ARTIFACT_CHANGE_EFFECT.get(_f_atype, "application source (artifact role requires annotation inspection)"),
+                        "statement": _ARTIFACT_CHANGE_EFFECT.get(_f_atype, "application source file (role could not be confirmed)"),
                         "classification_method": _f_cls.get("confidence", "low"),
                         "epistemic_level": (
                             "STRUCTURAL SIGNAL" if _f_cls.get("confidence", "low") == "high"
                             else "INFERRED (LOW CONFIDENCE)"
                         ),
                     },
-                    "evidence_completeness": _impact_entry.get("evidence", {}),
                 }
+                if _ev_complete:
+                    _entry["evidence_completeness"] = _ev_complete
                 _pr_runtime_changes.append(_entry)
                 # Split committed vs uncommitted — never merged
                 if _f in _committed_set:
@@ -2295,13 +2316,10 @@ class TaskContextBuilder:
         all_paths: list[str],
         entry_points: list,
         since: Optional[str],
-    ) -> tuple[list[RelevantFile], str, list[str], list[dict[str, Any]], dict[str, str], list[str]]:
+    ) -> "CanonicalAnalysisIR":
         """Build incremental impact analysis for changed files.
 
-        Returns:
-            (relevant_files, impact_summary, affected_modules, risk_areas,
-             why_these_files, analysis_gaps)
-
+        Returns CanonicalAnalysisIR — the shared IR consumed by delta and review-pr views.
         Changed files are always included in relevant_files (never dropped by score).
         Related files are expanded type-aware: controller→service→repository→mapper chain.
         Scoring is hierarchical by artifact_type, not by heuristic impact_level.
@@ -2469,6 +2487,18 @@ class TaskContextBuilder:
                 return "data_access"
             if atype == "service":
                 return "service"   # annotation-confirmed — not "core_service" (overclaim)
+            # Name-pattern heuristics — only when atype alone gave no verdict.
+            # These are INFERRED (LOW CONFIDENCE) — stem match, not annotation evidence.
+            if any(kw in stem_lower for kw in ("validator", "validation")):
+                return "validation_component"
+            if any(kw in stem_lower for kw in ("controller", "resource", "endpoint", "rest")):
+                return "external_interface"
+            if any(kw in stem_lower for kw in ("service", "svc", "usecase", "facade")):
+                return "service"
+            if any(kw in stem_lower for kw in ("repository", "repo", "dao", "store")):
+                return "data_access"
+            if any(kw in stem_lower for kw in ("config", "configuration", "settings", "properties")):
+                return "configuration"
             return "unclassified"   # no role claim without evidence
 
         def _structured_why(path: str, atype: str, module: str, role: str, risk_areas: list[str], cls_confidence: str = "low") -> str:
@@ -2489,17 +2519,17 @@ class TaskContextBuilder:
             return " | ".join(parts)
 
         if not changed_files:
-            return (
-                [],
-                "No changes detected — verify the git ref passed to --since",
-                [],
-                [],
-                {},
-                ["No changed files found. Check that --since ref exists and the diff is non-empty."],
-                {},   # system_impact
-                [],   # change_type
-                {"edges": [], "propagation_depth": 0},  # dependency_graph_summary
-                {},   # impact_score_per_file
+            return CanonicalAnalysisIR(
+                relevant_files=[],
+                impact_summary="No changes detected — verify the git ref passed to --since",
+                affected_modules=[],
+                risk_areas=[],
+                why_these_files={},
+                analysis_gaps=["No changed files found. Check that --since ref exists and the diff is non-empty."],
+                system_impact={},
+                change_type=[],
+                dependency_graph_summary={"edges": [], "propagation_depth": 0},
+                impact_score_per_file={},
             )
 
         ep_paths = {ep.path for ep in entry_points}
@@ -2992,12 +3022,12 @@ class TaskContextBuilder:
 
         # ── Step 6: analysis gaps ──────────────────────────────────────────────
         _bfs_note = (
-            f"BFS multi-hop import propagation repo-wide (propagation_depth={_max_hop})"
+            f"multi-hop import tracing performed (depth {_max_hop})"
             if _max_hop >= 1
-            else "no import-link propagation (no scannable changed files)"
+            else "no downstream dependencies could be verified"
         )
         analysis_gaps: list[str] = [
-            f"Related file expansion: type-aware chain expansion + {_bfs_note} + module/directory heuristics",
+            f"Related file expansion via import analysis and directory proximity ({_bfs_note})",
         ]
         if _expansion_truncated:
             analysis_gaps.insert(0,
@@ -3015,10 +3045,8 @@ class TaskContextBuilder:
         low_confidence = [f for f, cls in classifications.items() if cls.get("confidence") == "low" and not cls["is_noise"]]
         if low_confidence:
             analysis_gaps.append(
-                f"{len(low_confidence)} file(s) classified with low confidence"
-                " (artifact type inferred from extension only)"
-                " — consider adding stem patterns to _classify_changed_file: "
-                + ", ".join(Path(f).name for f in low_confidence[:3])
+                f"{len(low_confidence)} file(s) role inferred from filename only"
+                f" (no code signal found): {', '.join(Path(f).name for f in low_confidence[:3])}"
             )
         if not affected_modules_set and any(not cls["is_noise"] for cls in classifications.values()):
             analysis_gaps.append(
@@ -3026,17 +3054,17 @@ class TaskContextBuilder:
                 " — related file expansion uses directory proximity only"
             )
 
-        return (
-            relevant,
-            impact_summary,
-            sorted(affected_modules_set),
-            risk_areas_out,
-            why,
-            analysis_gaps,
-            system_impact,
-            aggregate_change_type,
-            dependency_graph_summary,
-            impact_score_per_file,
+        return CanonicalAnalysisIR(
+            relevant_files=relevant,
+            impact_summary=impact_summary,
+            affected_modules=sorted(affected_modules_set),
+            risk_areas=risk_areas_out,
+            why_these_files=why,
+            analysis_gaps=analysis_gaps,
+            system_impact=system_impact,
+            change_type=aggregate_change_type,
+            dependency_graph_summary=dependency_graph_summary,
+            impact_score_per_file=impact_score_per_file,
         )
 
     def _resolve_git_baseline(self, since: Optional[str]) -> dict[str, Any]: