sourcecode 1.31.6__tar.gz → 1.31.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.31.6
+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.6-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.6
+# sourcecode 1.31.8
 ```
 
 ---

{sourcecode-1.31.6 → 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.6-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.6
+# sourcecode 1.31.8
 ```
 
 ---

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

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

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

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

{sourcecode-1.31.6 → 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.6 → 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
@@ -2495,6 +2496,10 @@ def _extract_java_endpoints(root: "Path") -> "dict[str, Any]":
 
     endpoints: list[dict] = []
     seen: set[tuple] = set()
+    # Fix 1: inheritance projection — tracks class data so controllers with ONLY
+    # inherited endpoints (no own @RequestMapping methods) are not silently dropped.
+    _class_info: dict[str, dict] = {}
+    _EXTENDS_RE_LOCAL = _re.compile(r'\bextends\s+(\w+)')
 
     from sourcecode.path_filters import is_test_path as _is_test_path
 
@@ -2579,14 +2584,18 @@ def _extract_java_endpoints(root: "Path") -> "dict[str, Any]":
         # Extract class-level base path and locate class body start
         lines = content.splitlines()
 
-        # First pass: find class/interface declaration line index
+        # First pass: find class/interface declaration line index and extends clause.
         class_body_start = 0
+        extends_class_name: Optional[str] = None
         for i, line in enumerate(lines):
             stripped_l = line.strip()
             if (not stripped_l.startswith("//") and not stripped_l.startswith("*")
                     and ("class " in stripped_l or "interface " in stripped_l)
                     and _CLASS_RE.search(stripped_l)):
                 class_body_start = i + 1
+                _ext_m = _EXTENDS_RE_LOCAL.search(stripped_l)
+                if _ext_m:
+                    extends_class_name = _ext_m.group(1)
                 break
 
         # Second pass: extract class-level @RequestMapping path (only before class body).
@@ -2656,6 +2665,7 @@ def _extract_java_endpoints(root: "Path") -> "dict[str, Any]":
         pending_annotations: list[tuple[str, str]] = []  # (http_verb, path_suffix)
         pending_filtro: Optional[str] = None
         in_block_comment = False
+        file_own_endpoints: list[tuple] = []  # (http_verb, path_suffix, handler, filtro)
 
         for i in range(class_body_start, len(lines)):
             line = lines[i]
@@ -2708,6 +2718,7 @@ def _extract_java_endpoints(root: "Path") -> "dict[str, Any]":
                 handler = mm.group(1) if mm else ""
                 if handler and not handler.startswith("class"):
                     for http_verb, path_suffix in pending_annotations:
+                        file_own_endpoints.append((http_verb, path_suffix, handler, pending_filtro))
                         for _cb in class_bases:  # Bug #1B: one endpoint per class prefix
                             full_path = (_cb + "/" + path_suffix).replace("//", "/").rstrip("/") or "/"
                             if not full_path.startswith("/"):
@@ -2733,6 +2744,50 @@ def _extract_java_endpoints(root: "Path") -> "dict[str, Any]":
                 pending_annotations = []
                 pending_filtro = None
 
+        # Store per-class data for inheritance projection
+        _class_info[class_name] = {
+            "base_paths": class_bases,
+            "extends_class": extends_class_name,
+            "own_endpoints": file_own_endpoints,
+        }
+
+    # Fix 1: Inheritance projection — controllers whose methods are 100% inherited from a
+    # base class emit 0 endpoints above because no method-level annotations exist in their
+    # file. Walk the inheritance chain and project parent suffixes with the child's base path.
+    for _cls, _data in _class_info.items():
+        if _data["own_endpoints"]:
+            continue
+        _bases = _data["base_paths"]
+        if not _bases or _bases == [""]:
+            continue
+        _chain = _data.get("extends_class")
+        _visited: set[str] = {_cls}
+        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, _handler, _filtro in _parent["own_endpoints"]:
+                    for _cb in _bases:
+                        _fp = (_cb + "/" + _suffix).replace("//", "/").rstrip("/") or "/"
+                        if not _fp.startswith("/"):
+                            _fp = "/" + _fp
+                        _key = (_cls, _handler, _verb, _cb)
+                        if _key not in seen:
+                            seen.add(_key)
+                            _entry: dict[str, Any] = {
+                                "method": _verb,
+                                "path": _fp,
+                                "controller": _cls,
+                                "handler": _handler,
+                            }
+                            if _filtro:
+                                _entry["required_permission"] = _filtro
+                            endpoints.append(_entry)
+                break
+            _chain = _parent.get("extends_class")
+
     endpoints.sort(key=lambda e: (e.get("controller", ""), e.get("path", "")))
     undocumented = sum(1 for e in endpoints if "required_permission" not in e)
 

{sourcecode-1.31.6 → 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.6 → sourcecode-1.31.8}/src/sourcecode/repository_ir.py

@@ -178,8 +178,11 @@ _SPRING_OTHER: frozenset[str] = frozenset({
     "@PutMapping", "@DeleteMapping", "@PatchMapping", "@Autowired",
     "@Inject", "@Value", "@Qualifier", "@EnableWebSecurity",
     "@SpringBootApplication", "@EnableAutoConfiguration",
+    "@EventListener", "@Async", "@Scheduled", "@Cacheable", "@CacheEvict",
 })
 
+_PUBLISH_EVENT_RE = re.compile(r'\.publishEvent\s*\(\s*new\s+(\w+)\s*[(\{]')
+
 _HTTP_METHOD_MAP: dict[str, str] = {
     "@GetMapping": "GET",
     "@PostMapping": "POST",
@@ -787,6 +790,33 @@ def _build_relations(
                     evidence={"type": "structural", "value": f"member of {enclosing}"},
                 ))
 
+    # Fix 5: Event flow edges — publishEvent publishers and @EventListener subscribers.
+    # listens_to_event: method with @EventListener → resolved event parameter type(s).
+    for sym in symbols:
+        if sym.type == "method" and "@EventListener" in sym.annotations:
+            for imp_fqn in sym.imports_used:
+                edges.append(RelationEdge(
+                    from_symbol=sym.symbol,
+                    to_symbol=imp_fqn,
+                    type="listens_to_event",
+                    confidence="high",
+                    evidence={"type": "annotation", "value": "@EventListener"},
+                ))
+
+    # publishes_event: class that calls publishEvent(new XxxEvent(...)) → event type FQN.
+    _class_syms = [s for s in symbols if s.type in ("class", "interface") and "#" not in s.symbol]
+    for m in _PUBLISH_EVENT_RE.finditer(source):
+        event_simple = m.group(1)
+        event_fqn = import_map.get(event_simple, event_simple)
+        for cls_sym in _class_syms:
+            edges.append(RelationEdge(
+                from_symbol=cls_sym.symbol,
+                to_symbol=event_fqn,
+                type="publishes_event",
+                confidence="medium",
+                evidence={"type": "method_call", "value": f"publishEvent(new {event_simple})"},
+            ))
+
     seen: set[tuple[str, str, str]] = set()
     unique: list[RelationEdge] = []
     for e in edges:
@@ -1190,6 +1220,8 @@ _EDGE_REASON_TEMPLATES: dict[str, str] = {
     "contained_in": "{from_sym} is a member of {to_sym}",
     "annotated_with": "{from_sym} is annotated with {to_sym}",
     "mapped_to": "Route {to_sym} depends on {from_sym}",
+    "publishes_event": "{from_sym} publishes event {to_sym}",
+    "listens_to_event": "{from_sym} listens for event {to_sym}",
 }
 
 # Edge types to exclude from reverse impact traversal (too noisy / non-dependency semantics)
@@ -1505,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": {
@@ -1526,13 +1570,136 @@ def _assemble(
         },
         "subsystems": subsystems,
         "change_set": change_set_out,
-        "route_surface": route_diffs or [],
+        "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,
         },
     }
 
 
+# ---------------------------------------------------------------------------
+# Route surface helper (Fix 4)
+# ---------------------------------------------------------------------------
+
+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, "")
+        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"]))
+
+
 # ---------------------------------------------------------------------------
 # Public API
 # ---------------------------------------------------------------------------
@@ -1675,7 +1842,17 @@ def apply_ir_size_limits(
                 "remove --summary-only to restore full graph"
             ),
         }
-        out["reverse_graph"] = {}
+        # Fix 3: keep bounded reverse graph instead of wiping it.
+        full_rg: dict = ir.get("reverse_graph") or {}
+        if full_rg:
+            _rg_sorted = sorted(
+                full_rg.items(),
+                key=lambda x: sum(len(v) for v in x[1].values()),
+                reverse=True,
+            )
+            out["reverse_graph"] = dict(_rg_sorted[:50])
+        else:
+            out["reverse_graph"] = {}
         out["impact"] = {
             "global_score": (ir.get("impact") or {}).get("global_score", 0),
             "ranked_nodes": ranked[:20],
@@ -1703,10 +1880,19 @@ def apply_ir_size_limits(
 
     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
+            # Fix 2: type-aware priority so semantic edges survive node truncation.
+            # Annotation strings (@Service etc.) and field FQNs are never in kept_fqns,
+            # so "both endpoints kept" drops all injects/annotated_with edges.
+            _SEMANTIC_TYPES = frozenset({"extends", "implements", "injects",
+                                         "publishes_event", "listens_to_event"})
+            _ANNOTATION_TYPES = frozenset({"annotated_with"})
+            tier1 = [e for e in edges if e["from"] in kept_fqns and e["type"] in _SEMANTIC_TYPES]
+            tier2 = [e for e in edges if e["from"] in kept_fqns and e["type"] in _ANNOTATION_TYPES]
+            tier3 = [e for e in edges
+                     if e["from"] in kept_fqns and e["to"] in kept_fqns and e["type"] == "imports"]
+            _seen_e = {(e["from"], e["to"], e["type"]) for e in tier1 + tier2 + tier3}
+            tier4 = [e for e in edges if (e["from"], e["to"], e["type"]) not in _seen_e]
+            edges = tier1 + tier2 + tier3 + tier4
         if max_edges is not None:
             edges = edges[:max_edges]
 
@@ -1722,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.6 → 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.6 → 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