sourcecode 1.31.7__tar.gz → 1.31.8__tar.gz

{sourcecode-1.31.7 → sourcecode-1.31.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.31.7
+Version: 1.31.8
 Summary: Deterministic codebase context for AI coding agents
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -225,7 +225,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.31.7-blue)
+![Version](https://img.shields.io/badge/version-1.31.8-blue)
 ![Python](https://img.shields.io/badge/python-3.10%2B-green)
 
 ---
@@ -261,7 +261,7 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.31.7
+# sourcecode 1.31.8
 ```
 
 ---

{sourcecode-1.31.7 → sourcecode-1.31.8}/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.31.7-blue)
+![Version](https://img.shields.io/badge/version-1.31.8-blue)
 ![Python](https://img.shields.io/badge/python-3.10%2B-green)
 
 ---
@@ -38,7 +38,7 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.31.7
+# sourcecode 1.31.8
 ```
 
 ---

{sourcecode-1.31.7 → sourcecode-1.31.8}/pyproject.toml

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

{sourcecode-1.31.7 → sourcecode-1.31.8}/src/sourcecode/__init__.py

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

{sourcecode-1.31.7 → sourcecode-1.31.8}/src/sourcecode/architecture_analyzer.py

@@ -330,7 +330,7 @@ class ArchitectureAnalyzer:
                     tentative = True
                 if not _hard_evidence:
                     limitations.append(
-                        "Pattern not confirmed by module import graph; run with --graph-modules for structural validation"
+                        "Pattern inferred from directory structure; import graph not available — structural dependency direction unverified"
                     )
                 if not _hard_evidence:
                     matched_dirs = sorted({

{sourcecode-1.31.7 → sourcecode-1.31.8}/src/sourcecode/cli.py

@@ -836,6 +836,7 @@ def main(
         code_notes = True
         no_tree = True  # agents never need the raw file tree
         architecture = True  # agents need full architectural signal (M4)
+        graph_modules = True  # IC-003: import graph needed for architecture confidence
 
     # ── GAP-9: Cache check — serve from .sourcecode-cache when git SHA unchanged ──
     import hashlib as _hashlib

{sourcecode-1.31.7 → sourcecode-1.31.8}/src/sourcecode/prepare_context.py

@@ -1212,6 +1212,41 @@ class TaskContextBuilder:
                 symptom=symptom if task_name == "fix-bug" else None,
             )
 
+        # ── IC-006: fix-bug suspected_areas — recompute from ranked files + bug notes ──
+        # relevant_files is now ranked by RankingEngine (git churn, fan_in, centrality, notes).
+        # suspected_areas should reflect that ranking, not raw comment count.
+        if task_name == "fix-bug" and relevant_files:
+            _bug_kinds = {"FIXME", "BUG", "HACK", "XXX"}
+            _bug_counts: dict[str, int] = {}
+            for _note in cn_notes_for_ranking:
+                if _note.kind in _bug_kinds:
+                    _bug_counts[_note.path] = _bug_counts.get(_note.path, 0) + 1
+
+            # Primary: top-ranked RelevantFile objects (dataclass, use .path/.reason)
+            _ranked_paths = [rf.path for rf in relevant_files[:30]]
+            _primary: list[str] = []
+            for rf in relevant_files[:30]:
+                p = rf.path
+                if not p:
+                    continue
+                n = _bug_counts.get(p, 0)
+                reason_str = str(rf.reason) if rf.reason else ""
+                note_str = f" ({n} bug annotation{'s' if n > 1 else ''})" if n else ""
+                _primary.append(f"{p}{note_str}" + (f" — {reason_str}" if reason_str else ""))
+                if len(_primary) >= 5:
+                    break
+
+            # Secondary: remaining high-note files not already in primary
+            _ranked_set = set(_ranked_paths[:len(_primary)])
+            _secondary = [
+                f"{p} ({n} annotation{'s' if n > 1 else ''})"
+                for p, n in sorted(_bug_counts.items(), key=lambda x: -x[1])
+                if p not in _ranked_set
+            ][:3]
+
+            if _primary or _secondary:
+                suspected_areas = _primary + _secondary
+
         # ── 6b. review-pr: derive PR-specific impact sections from delta analysis ──
         _pr_security_impact: dict = {}
         _pr_transactional_impact: dict = {}

{sourcecode-1.31.7 → sourcecode-1.31.8}/src/sourcecode/repository_ir.py

@@ -1537,6 +1537,18 @@ def _assemble(
             by_type.setdefault(e.type, []).append(e.from_symbol)
         reverse_graph_out[target] = by_type
 
+    # IC-005: aggregate event flow edges already built in _build_relations
+    _listen_edges = [e for e in sorted_rels if e.type == "listens_to_event"]
+    _publish_edges = [e for e in sorted_rels if e.type == "publishes_event"]
+    _spring_events: Optional[dict] = None
+    if _listen_edges or _publish_edges:
+        _spring_events = {
+            "listeners": sorted({e.from_symbol for e in _listen_edges}),
+            "publishers": sorted({e.from_symbol for e in _publish_edges}),
+            "event_types": sorted({e.to_symbol for e in _listen_edges + _publish_edges}),
+            "flow_count": len(_listen_edges) + len(_publish_edges),
+        }
+
     return {
         "schema_version": "final-v1",
         "graph": {
@@ -1558,7 +1570,11 @@ def _assemble(
         },
         "subsystems": subsystems,
         "change_set": change_set_out,
-        "route_surface": _build_route_surface(sorted_syms, route_diffs),
+        "route_surface": _build_route_surface(sorted_syms, route_diffs, extends_map={
+            e.from_symbol: e.to_symbol.split(".")[-1]
+            for e in sorted_rels if e.type == "extends"
+        }),
+        **({"spring_events": _spring_events} if _spring_events else {}),
         "audit": {
             "dropped_fields": dropped_fields,
         },
@@ -1569,30 +1585,119 @@ def _assemble(
 # Route surface helper (Fix 4)
 # ---------------------------------------------------------------------------
 
-def _build_route_surface(symbols: list[SymbolRecord], route_diffs: Optional[list[dict]]) -> list[dict]:
-    """Return route surface: diffs when --since provided, else static snapshot of all endpoints."""
+def _build_route_surface(
+    symbols: list[SymbolRecord],
+    route_diffs: Optional[list[dict]],
+    extends_map: Optional[dict[str, str]] = None,
+) -> list[dict]:
+    """Return route surface with inheritance projection.
+
+    extends_map: child_fqn → parent_simple_name derived from RelationEdge extends edges.
+    Projects inherited endpoints onto subclasses that have a class-level @RequestMapping
+    prefix but zero own method-level endpoints (IC-001 fix).
+    """
     if route_diffs:
         return route_diffs
+
+    # Phase 1: build per-class metadata (prefix) and own endpoint list
+    class_info: dict[str, dict] = {}  # simple_name → {fqn, prefix, own_endpoints}
+    for sym in symbols:
+        if sym.type not in ("class", "interface"):
+            continue
+        simple = sym.symbol.split(".")[-1]
+        prefix = ""
+        if "@RequestMapping" in sym.annotations:
+            args = sym.annotation_values.get("@RequestMapping", "")
+            prefix = _parse_route_path(args)
+        class_info[simple] = {"fqn": sym.symbol, "prefix": prefix, "own_endpoints": []}
+
     routes: list[dict] = []
+    seen: set[tuple] = set()
+
+    # Phase 2: emit own endpoint symbols and record them per class
     for sym in symbols:
         if sym.symbol_kind != "endpoint":
             continue
         ann_name = next((a for a in sym.annotations if a in _ENDPOINT_ANNOTATIONS), None)
         if not ann_name:
             continue
+        cls_fqn = _enclosing_class(sym.symbol)
+        cls_simple = cls_fqn.split(".")[-1]
         args = sym.annotation_values.get(ann_name, "")
-        path = _parse_route_path(args)
-        method = _parse_route_http_method(ann_name, args)
-        if not path and not method:
-            continue
-        routes.append({
-            "symbol": sym.symbol,
-            "controller": _enclosing_class(sym.symbol),
-            "path": path,
-            "method": method or "GET",
-            "stable_id": sym.stable_id,
-        })
-    return sorted(routes, key=lambda r: (r["controller"], r["path"]))
+        suffix = _parse_route_path(args)
+        method = _parse_route_http_method(ann_name, args) or "GET"
+
+        if cls_simple in class_info:
+            class_info[cls_simple]["own_endpoints"].append(
+                (method, suffix, sym.symbol, sym.stable_id)
+            )
+
+        prefix = class_info.get(cls_simple, {}).get("prefix", "")
+        full_path = (prefix + "/" + suffix).replace("//", "/").rstrip("/") or "/"
+        if not full_path.startswith("/"):
+            full_path = "/" + full_path
+
+        key = (sym.symbol, method, prefix)
+        if key not in seen:
+            seen.add(key)
+            routes.append({
+                "symbol": sym.symbol,
+                "controller": cls_fqn,
+                "declaring_class": cls_fqn,
+                "effective_class": cls_fqn,
+                "path": full_path,
+                "method": method,
+                "stable_id": sym.stable_id,
+                "inheritance_depth": 0,
+            })
+
+    # Phase 3: inheritance projection — subclasses with zero own endpoints
+    # but with a class-level @RequestMapping prefix inherit parent methods.
+    if extends_map:
+        fqn_to_simple: dict[str, str] = {d["fqn"]: s for s, d in class_info.items()}
+        simple_extends: dict[str, str] = {
+            fqn_to_simple.get(child_fqn, child_fqn.split(".")[-1]): parent_simple
+            for child_fqn, parent_simple in extends_map.items()
+        }
+
+        for cls_simple, data in class_info.items():
+            if data["own_endpoints"]:
+                continue
+            if not data["prefix"]:
+                continue
+
+            chain = simple_extends.get(cls_simple)
+            visited: set[str] = {cls_simple}
+            depth = 1
+            while chain and chain not in visited:
+                visited.add(chain)
+                parent = class_info.get(chain)
+                if not parent:
+                    break
+                if parent["own_endpoints"]:
+                    for verb, suffix, declaring_sym, stable_id in parent["own_endpoints"]:
+                        prefix = data["prefix"]
+                        full_path = (prefix + "/" + suffix).replace("//", "/").rstrip("/") or "/"
+                        if not full_path.startswith("/"):
+                            full_path = "/" + full_path
+                        key = (cls_simple, declaring_sym, verb, prefix)
+                        if key not in seen:
+                            seen.add(key)
+                            routes.append({
+                                "symbol": declaring_sym,
+                                "controller": data["fqn"],
+                                "declaring_class": parent["fqn"],
+                                "effective_class": data["fqn"],
+                                "path": full_path,
+                                "method": verb,
+                                "stable_id": stable_id,
+                                "inheritance_depth": depth,
+                            })
+                    break
+                chain = simple_extends.get(chain)
+                depth += 1
+
+    return sorted(routes, key=lambda r: (r["effective_class"], r["path"]))
 
 
 # ---------------------------------------------------------------------------
@@ -1803,7 +1908,7 @@ def apply_ir_size_limits(
 # Convenience: find Java files in a repo
 # ---------------------------------------------------------------------------
 
-def find_java_files(root: Path, *, max_files: int = 500) -> list[str]:
+def find_java_files(root: Path, *, max_files: int = 3000) -> list[str]:
     """Return relative paths to Java files under root, excluding test dirs and vendor."""
     results: list[str] = []
     for p in sorted(root.rglob("*.java")):

{sourcecode-1.31.7 → sourcecode-1.31.8}/src/sourcecode/runtime_classifier.py

@@ -141,6 +141,11 @@ class RuntimeClassifier:
                 raw.append((ws_path, self._load_pkg_json(pkg_root)))
 
         fan_in = self._compute_fan_in(raw)
+        # IC-004: merge Maven pom.xml cross-module fan_in when no JS deps detected
+        maven_fan_in = self._compute_maven_fan_in(root, workspace_paths)
+        for ws_path, count in maven_fan_in.items():
+            fan_in[ws_path] = fan_in.get(ws_path, 0) + count
+
         results: list[MonorepoPackageInfo] = []
 
         for ws_path, pkg_json in raw:
@@ -280,6 +285,9 @@ class RuntimeClassifier:
                 scores["infrastructure_layer"] = scores.get("infrastructure_layer", 0) + fan_boost
 
         if not scores:
+            # IC-004: Java/Maven fallback — no JS signals but module may have a pom.xml
+            if not pkg_json:
+                return self._classify_maven_module(ws_path, name, fan_in)
             return "unknown", signals, "low"
 
         best_role = max(scores, key=lambda r: (scores[r], _ROLE_PRIORITY.get(r, 0)))
@@ -326,6 +334,76 @@ class RuntimeClassifier:
     def _criticality(self, role: str, fan_in: int) -> str:
         if role in {"runtime_core", "plugin_host"}:
             return "high"
-        if role in {"backend_runtime", "frontend_runtime", "composition_layer"} or fan_in >= 3:
+        # IC-004: infrastructure_layer with high fan_in = shared foundation = high criticality
+        if role == "infrastructure_layer" and fan_in >= 3:
+            return "high"
+        if role in {"backend_runtime", "frontend_runtime", "composition_layer",
+                    "infrastructure_layer"} or fan_in >= 3:
             return "medium"
         return "low"
+
+    def _compute_maven_fan_in(self, root: Path, workspace_paths: list[str]) -> dict[str, int]:
+        """IC-004: Compute cross-module fan_in from all pom.xml files under each workspace.
+
+        Scans all pom.xml files (top-level and sub-module) within each workspace path.
+        Counts distinct modules that declare a dependency containing another module's leaf name.
+        Uses 1 hit per source module (not per pom file) to avoid inflation.
+        """
+        fan_in: dict[str, int] = {}
+        leaf_to_path: dict[str, str] = {ws.split("/")[-1]: ws for ws in workspace_paths}
+
+        for ws_path in workspace_paths:
+            ws_dir = root / ws_path
+            if not ws_dir.is_dir():
+                continue
+            deps_found: set[str] = set()
+            for pom in ws_dir.rglob("pom.xml"):
+                if "target/" in str(pom):
+                    continue
+                try:
+                    content = pom.read_text(encoding="utf-8", errors="replace")
+                except OSError:
+                    continue
+                for dep_leaf, target_path in leaf_to_path.items():
+                    if target_path != ws_path and dep_leaf in content:
+                        deps_found.add(target_path)
+            for target_path in deps_found:
+                fan_in[target_path] = fan_in.get(target_path, 0) + 1
+
+        return fan_in
+
+    def _classify_maven_module(
+        self, ws_path: str, name: str, fan_in: int
+    ) -> tuple[str, list[str], str]:
+        """IC-004: Classify a Java/Maven module by path conventions and fan_in.
+
+        Called when no JS signals exist (no package.json). Uses path name patterns
+        and pom fan_in (cross-module dependency count) to determine role/criticality.
+        """
+        signals: list[str] = ["maven:module"]
+        leaf = ws_path.lower().rstrip("/").split("/")[-1]
+
+        if re.search(r"\b(common|shared|util|utils|lib|base|foundation)\b", leaf):
+            signals.append("maven:shared_library")
+            return "infrastructure_layer", signals, "high" if fan_in >= 3 else "medium"
+
+        if re.search(r"\b(integration|it|test|tests|e2e)\b", leaf):
+            signals.append("maven:test_module")
+            return "test_layer", signals, "low"
+
+        if re.search(r"\b(admin|web|api|rest|controller|ui)\b", leaf):
+            signals.append("maven:web_module")
+            return "backend_runtime", signals, "medium"
+
+        if re.search(r"\b(core|framework|domain|service|profile)\b", leaf):
+            signals.append("maven:core_module")
+            return "backend_runtime", signals, "high" if fan_in >= 2 else "medium"
+
+        if fan_in >= 3:
+            signals.append(f"maven:high_fan_in({fan_in})")
+            return "infrastructure_layer", signals, "high"
+        if fan_in >= 1:
+            signals.append(f"maven:fan_in({fan_in})")
+            return "infrastructure_layer", signals, "medium"
+
+        return "unknown", signals, "low"

{sourcecode-1.31.7 → sourcecode-1.31.8}/src/sourcecode/serializer.py

@@ -379,6 +379,59 @@ def _spring_boot_version(sm: "SourceMap") -> "Optional[str]":
     return None
 
 
+def _spring_event_signal(sm: "SourceMap") -> "Optional[dict[str, Any]]":
+    """IC-005: Surface @EventListener and publishEvent from Java source files.
+
+    Scans sm.file_paths for Java files containing Spring event annotations.
+    Only runs on Java/Spring projects. Lightweight — path heuristics first,
+    then targeted content scan on candidate files only.
+    """
+    import re as _re
+    java_paths = [p for p in sm.file_paths if p.endswith(".java") and "target/" not in p]
+    if not java_paths:
+        return None
+    _frameworks = [f.name for s in (sm.stacks or []) for f in s.frameworks]
+    if not any("Spring" in fw for fw in _frameworks):
+        return None
+
+    analyzed_path = getattr(sm.metadata, "analyzed_path", None) if sm.metadata else None
+    root = Path(analyzed_path) if analyzed_path else None
+
+    listeners: list[str] = []
+    publishers: list[str] = []
+    event_types: set[str] = set()
+    _publish_re = _re.compile(r"\.publishEvent\s*\(\s*new\s+(\w+)")
+
+    for rel_path in java_paths:
+        if root is None:
+            break
+        try:
+            content = (root / rel_path).read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+        if "@EventListener" in content:
+            cls_m = _re.search(r"class\s+(\w+)", content)
+            cls_name = cls_m.group(1) if cls_m else Path(rel_path).stem
+            if cls_name not in listeners:
+                listeners.append(cls_name)
+        for m in _publish_re.finditer(content):
+            event_types.add(m.group(1))
+            cls_m = _re.search(r"class\s+(\w+)", content)
+            cls_name = cls_m.group(1) if cls_m else Path(rel_path).stem
+            if cls_name not in publishers:
+                publishers.append(cls_name)
+
+    if not listeners and not publishers:
+        return None
+
+    return {
+        "listeners": sorted(set(listeners))[:10],
+        "publishers": sorted(set(publishers))[:10],
+        "event_types": sorted(event_types)[:10],
+        "flow_count": len(listeners) + len(publishers),
+    }
+
+
 def _spring_profiles_context(sm: "SourceMap") -> "Optional[dict[str, Any]]":
     """Build structured spring_profiles block: detected names + per-profile file variants."""
     # Gather profile names from env_summary (populated by env_analyzer scanning
@@ -1949,6 +2002,11 @@ def agent_view(sm: SourceMap, *, full: bool = False) -> dict[str, Any]:
     if _txn:
         signals["transactional_boundaries"] = _txn
 
+    # IC-005: Spring event flows (@EventListener / publishEvent)
+    _evf = _spring_event_signal(sm)
+    if _evf:
+        signals["event_flows"] = _evf
+
     if signals:
         result["signals"] = signals