sourcecode 1.45.0__py3-none-any.whl → 1.50.0__py3-none-any.whl

sourcecode/__init__.py

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

sourcecode/mcp/orchestrator.py

@@ -6,29 +6,20 @@ Converts the MCP from a flat tool collection into a guided agent operating syste
 - run_pr_review_flow: auto-chains delta + review_pr + blast radius
 - run_bug_investigation_flow: auto-chains fix_bug + impact + IR context
 - run_feature_flow: auto-chains context + endpoints + delta + structural awareness
-
-TODO — planned high-value Java/Spring flow presets (audit 2026-06-16, repo SAINT):
-  These extend the existing orchestrator; they are NOT yet implemented.
-
-  1. TODO: implement later — run_migrate_flow
-     Preset wrapping `migrate-check`. Primary high-value entry point for
-     Spring Boot 2→3 planning (audit: produces 1,356-file prioritized
-     inventory in ~6s — the strongest determinante win). Should surface
-     readiness_score, blocking count, per-target breakdown (jakarta /
-     spring_security_6 / java_11) and estimated_effort_days.
-
-  2. TODO: implement later — run_security_audit_flow
-     Preset wrapping `spring-audit` + `endpoints`. Auto-handle the
-     config-less case: when no sourcecode.config.json is present and the
-     repo carries custom security annotations, emit a fallback WARNING +
-     hint to add sourcecode.config.json (customAnnotations) rather than
-     returning a misleading 100% none_detected result.
-
-  3. TODO: implement later — extend R2 orchestration rule (apply_orchestration_rules)
-     Inject preset (1)/(2) when detected intent maps to migration or
-     security audit, mirroring the existing R2 java_no_endpoints rule.
-     Requires new INTENT_MIGRATION / INTENT_SECURITY_AUDIT constants +
-     _INTENT_PATTERNS entries + WORKFLOW_SEQUENCES / FLOW_RUNNERS wiring.
+- run_migrate_flow: wraps migrate-check; Spring Boot 2→3 readiness in one call
+- run_security_audit_flow: wraps spring-audit + endpoints; config-less blind-spot warning
+
+High-value Java/Spring flow presets (audit 2026-06-16, repo SAINT) — implemented:
+  1. run_migrate_flow — preset over `migrate-check`, the primary entry point for
+     Spring Boot 2→3 planning. Lifts readiness_score, blocking_count,
+     estimated_effort_days and the per-target breakdown to a top-level headline.
+  2. run_security_audit_flow — preset over `spring-audit` + `endpoints`. Detects the
+     config-less case (no sourcecode.config.json + every endpoint none_detected) and
+     emits a warning plus a ready-to-paste config hint instead of a misleading 100%
+     unsecured surface.
+  3. apply_orchestration_rules R5/R6 — inject these presets when the detected intent
+     maps to migration (INTENT_MIGRATION) or security audit (INTENT_SECURITY_AUDIT),
+     mirroring the existing R2 java_no_endpoints rule.
 """
 from __future__ import annotations
 
@@ -55,6 +46,8 @@ SESSION_READY_FOR_REVIEW = "READY_FOR_REVIEW"  # flow complete
 # ---------------------------------------------------------------------------
 
 INTENT_PR_REVIEW = "pr_review"
+INTENT_MIGRATION = "migration"
+INTENT_SECURITY_AUDIT = "security_audit"
 INTENT_BUG_INVESTIGATION = "bug_investigation"
 INTENT_FEATURE_IMPLEMENTATION = "feature_implementation"
 INTENT_REFACTOR = "refactor"
@@ -67,6 +60,8 @@ INTENT_ORIENTATION = "orientation"
 
 WORKFLOW_SEQUENCES: dict[str, list[str]] = {
     INTENT_PR_REVIEW: ["get_delta", "review_pr_context", "get_impact_context"],
+    INTENT_MIGRATION: ["get_migration_readiness"],
+    INTENT_SECURITY_AUDIT: ["get_spring_audit", "get_endpoints"],
     INTENT_BUG_INVESTIGATION: ["fix_bug_context", "get_impact_context"],
     INTENT_FEATURE_IMPLEMENTATION: ["get_compact_context", "get_endpoints", "get_delta"],
     INTENT_REFACTOR: ["get_agent_context", "modernize_context", "get_ir_summary"],
@@ -76,6 +71,8 @@ WORKFLOW_SEQUENCES: dict[str, list[str]] = {
 
 WORKFLOW_DESCRIPTIONS: dict[str, str] = {
     INTENT_PR_REVIEW: "PR review: delta → execution paths → blast radius of changed classes",
+    INTENT_MIGRATION: "Spring Boot 2→3 migration: readiness score → javax→jakarta blockers → effort estimate",
+    INTENT_SECURITY_AUDIT: "Security audit: Spring TX/security findings → endpoint authorization surface",
     INTENT_BUG_INVESTIGATION: "Bug investigation: risk-ranked files → impact of suspect class",
     INTENT_FEATURE_IMPLEMENTATION: "Feature implementation: context → API surface → recent changes",
     INTENT_REFACTOR: "Refactor: deep context → modernization opportunities → IR coupling",
@@ -85,6 +82,8 @@ WORKFLOW_DESCRIPTIONS: dict[str, str] = {
 
 FLOW_RUNNERS: dict[str, str] = {
     INTENT_PR_REVIEW: "run_pr_review_flow",
+    INTENT_MIGRATION: "run_migrate_flow",
+    INTENT_SECURITY_AUDIT: "run_security_audit_flow",
     INTENT_BUG_INVESTIGATION: "run_bug_investigation_flow",
     INTENT_FEATURE_IMPLEMENTATION: "run_feature_flow",
     INTENT_REFACTOR: "run_feature_flow",
@@ -101,6 +100,16 @@ _INTENT_PATTERNS: list[tuple[str, list[str]]] = [
         r"\bpr\b", r"pull request", r"review pr", r"\bdiff\b", r"merge request",
         r"code review", r"changes in branch", r"review.*branch", r"branch.*review",
     ]),
+    (INTENT_MIGRATION, [
+        r"\bmigrat", r"spring.?boot.?[23]", r"spring boot 2.*3", r"boot 2.*3",
+        r"\bjakarta\b", r"\bjavax\b", r"javax.*jakarta", r"namespace.*(migrat|change)",
+        r"2\s*(?:->|to|→|–|—)\s*3", r"\bupgrade\b.*(spring|boot|jakarta|java)",
+    ]),
+    (INTENT_SECURITY_AUDIT, [
+        r"security audit", r"audit.*security", r"security.*surface",
+        r"\bauthoriz", r"\bpreauthorize\b", r"\bsecured\b", r"access control",
+        r"who can (?:call|access)", r"endpoint.*(secur|auth)", r"(secur|auth).*endpoint",
+    ]),
     (INTENT_BUG_INVESTIGATION, [
         r"\bbug\b", r"\berror\b", r"\bexception\b", r"\bcrash\b", r"\bnpe\b",
         r"\bfix\b", r"\bbroken\b", r"\bfail(s|ing)?\b", r"stack.?trace",
@@ -168,6 +177,9 @@ def apply_orchestration_rules(
       R2 java_no_endpoints → prepend get_endpoints (api_surface must exist first)
       R3 large_repo (>1000) → note RIS path preferred (informational, no seq change)
       R4 no_symptom_bug_flow → quality warning issued by caller (not a seq change)
+      R5 migration_intent (Java) → ensure get_migration_readiness leads the sequence
+      R6 security_audit_intent (Java) → ensure get_endpoints precedes the audit so the
+         authorization surface is available when findings are interpreted
     """
     seq = list(sequence)
     rules: list[str] = []
@@ -186,6 +198,17 @@ def apply_orchestration_rules(
     if repo_class_count > 1000:
         rules.append("R3:large_repo→RIS_path_preferred")
 
+    # R5: migration intent on a Java repo → migration readiness is the entry point.
+    if intent == INTENT_MIGRATION and is_java and "get_migration_readiness" not in seq:
+        seq.insert(0, "get_migration_readiness")
+        rules.append("R5:migration_intent→prepend_migration_readiness")
+
+    # R6: security-audit intent on a Java repo → endpoints surface must precede the
+    # audit (mirrors R2: the authorization surface has to exist first).
+    if intent == INTENT_SECURITY_AUDIT and is_java and "get_endpoints" not in seq:
+        seq.insert(0, "get_endpoints")
+        rules.append("R6:security_audit_intent→prepend_get_endpoints")
+
     return seq, rules
 
 
@@ -729,3 +752,166 @@ def run_feature_flow_impl(repo_path: str, feature_description: str = "") -> dict
             "tools_suggested_to_agent": 0,
         },
     }
+
+
+# ---------------------------------------------------------------------------
+# Flow: Spring Boot 2→3 Migration
+# ---------------------------------------------------------------------------
+
+def run_migrate_flow_impl(repo_path: str, min_severity: str = "low") -> dict[str, Any]:
+    """Migration Flow: Spring Boot 2→3 readiness in one call.
+
+    Primary high-value entry point for migration planning. Wraps ``migrate-check``
+    and lifts the headline numbers (readiness_score, blocking_count,
+    estimated_effort_days, per-target breakdown) to the top level so the agent
+    can plan a 2→3 upgrade without parsing the full report.
+    """
+    t0 = time.monotonic()
+    steps: list[str] = []
+    quality_warnings: list[str] = []
+    output: dict[str, Any] = {}
+
+    if not _is_java_repo(repo_path):
+        quality_warnings.append(
+            "not_a_java_repo: migration analysis targets Spring Boot / Java repos. "
+            "Result will be empty (readiness_score=100, no findings)."
+        )
+
+    report = _exec(["migrate-check", repo_path, "--min-severity", min_severity])
+    steps.append(f"get_migration_readiness(min_severity={min_severity})")
+    headline: dict[str, Any] = {}
+    if "_exec_error" not in report:
+        output["migration_readiness"] = report
+        # Lift the planning-relevant headline numbers to the top level.
+        for key in (
+            "readiness_score", "blocking_count", "estimated_effort_days",
+            "spring_boot_2_detected",
+        ):
+            if key in report:
+                headline[key] = report[key]
+        _summary = report.get("summary", {})
+        if isinstance(_summary, dict):
+            headline["total_findings"] = _summary.get("total_findings")
+            headline["affected_files"] = _summary.get("affected_files")
+            headline["by_severity"] = _summary.get("by_severity")
+            headline["by_target"] = _summary.get("by_target") or _summary.get("by_rule")
+    else:
+        quality_warnings.append(f"migrate_check_failed: {report['_exec_error']}")
+
+    ttfca_ms = int((time.monotonic() - t0) * 1000)
+
+    return {
+        "session_state": SESSION_READY_FOR_REVIEW,
+        "flow": "migration",
+        "min_severity": min_severity,
+        "headline": headline,
+        "steps_executed": steps,
+        "quality_warnings": quality_warnings,
+        "consolidated_output": output,
+        "session_meta": {
+            "ttfca_ms": ttfca_ms,
+            "steps_auto_executed": len(steps),
+            "tools_suggested_to_agent": 0,
+        },
+    }
+
+
+# ---------------------------------------------------------------------------
+# Flow: Security Audit
+# ---------------------------------------------------------------------------
+
+def _endpoint_security_coverage(endpoints: dict[str, Any]) -> tuple[int, int]:
+    """Return (total_endpoints, none_detected) from an endpoints result."""
+    if "_exec_error" in endpoints:
+        return 0, 0
+    data = endpoints.get("data", endpoints) if isinstance(endpoints, dict) else {}
+    total = int(data.get("total", 0) or 0)
+    none_detected = int(data.get("no_security_signal", 0) or 0)
+    return total, none_detected
+
+
+def run_security_audit_flow_impl(repo_path: str, scope: str = "all") -> dict[str, Any]:
+    """Security Audit Flow: Spring findings + endpoint authorization surface.
+
+    Wraps ``spring-audit`` (TX + security findings) and ``endpoints`` (authorization
+    surface) in one call. Auto-handles the config-less case: when no
+    ``sourcecode.config.json`` is present and every endpoint reads as
+    ``none_detected``, the all-zero security surface is almost certainly a
+    custom-annotation blind spot rather than a truly unsecured API — so the flow
+    emits a warning plus a ready-to-paste config hint instead of letting the
+    misleading result stand.
+    """
+    from sourcecode.security_config import CONFIG_FILENAME
+
+    t0 = time.monotonic()
+    steps: list[str] = []
+    quality_warnings: list[str] = []
+    output: dict[str, Any] = {}
+
+    if not _is_java_repo(repo_path):
+        quality_warnings.append(
+            "not_a_java_repo: spring-audit targets Java/Spring repos and will "
+            "report spring_detected=false."
+        )
+
+    # Step 1: Spring semantic audit (TX anomalies + security findings).
+    audit = _exec(["spring-audit", repo_path, "--scope", scope])
+    steps.append(f"get_spring_audit(scope={scope})")
+    if "_exec_error" not in audit:
+        output["spring_audit"] = audit
+    else:
+        quality_warnings.append(f"spring_audit_failed: {audit['_exec_error']}")
+
+    # Step 2: endpoint authorization surface.
+    endpoints = _exec(["endpoints", repo_path])
+    steps.append("get_endpoints")
+    if "_exec_error" not in endpoints:
+        output["endpoint_security_surface"] = endpoints
+    else:
+        quality_warnings.append(f"endpoints_failed: {endpoints['_exec_error']}")
+
+    # Config-less blind-spot detection: no sourcecode.config.json + every endpoint
+    # none_detected → warn rather than report a misleading 100% unsecured surface.
+    has_config = (Path(repo_path) / CONFIG_FILENAME).exists()
+    total, none_detected = _endpoint_security_coverage(endpoints)
+    if not has_config and total > 0 and none_detected == total:
+        quality_warnings.append(
+            "config_less_security_blind_spot: no sourcecode.config.json found and "
+            f"all {total} endpoints report none_detected. If this repo uses a custom "
+            "authorization annotation, the surface is a false negative — add the "
+            "config below and re-run."
+        )
+        output["security_config_hint"] = {
+            "reason": "no_custom_security_annotations_configured",
+            "file": CONFIG_FILENAME,
+            "example": {
+                "customSecurityAnnotations": [
+                    {
+                        "shortName": "YourSecurityAnnotation",
+                        "resourceParam": "resourceName",
+                        "levelParam": "requiredLevel",
+                    }
+                ]
+            },
+        }
+
+    ttfca_ms = int((time.monotonic() - t0) * 1000)
+
+    return {
+        "session_state": SESSION_READY_FOR_REVIEW,
+        "flow": "security_audit",
+        "scope": scope,
+        "endpoint_security_coverage": {
+            "total_endpoints": total,
+            "none_detected": none_detected,
+            "config_present": has_config,
+        },
+        "steps_executed": steps,
+        "quality_warnings": quality_warnings,
+        "consolidated_output": output,
+        "session_meta": {
+            "ttfca_ms": ttfca_ms,
+            "steps_auto_executed": len(steps),
+            "tools_suggested_to_agent": 0,
+        },
+    }

sourcecode/mcp/server.py

@@ -510,6 +510,75 @@ def run_feature_flow(repo_path: str = ".", feature_description: str = "") -> dic
         )
 
 
+@mcp.tool()
+def run_migrate_flow(repo_path: str = ".", min_severity: str = "low") -> dict:
+    """Migration Flow — Spring Boot 2→3 readiness in one call. JAVA/SPRING ONLY.
+
+    Primary high-value entry point for migration planning. Wraps migrate-check and
+    lifts the headline numbers to the top level so the agent can plan a 2→3 upgrade
+    without parsing the full report:
+      - readiness_score (0–100; 100 = ready), blocking_count, estimated_effort_days
+      - by_severity and by_target breakdown (jakarta / spring_security_6 / java_11)
+
+    Use this instead of calling get_migration_readiness and interpreting it by hand.
+    Returns headline + consolidated_output.migration_readiness (full report).
+
+    repo_path: absolute path to the Java repository (default: current working directory).
+    min_severity: "critical" | "high" | "medium" | "low" (default — include everything).
+    """
+    _raw = repo_path
+    try:
+        if not isinstance(repo_path, str):
+            return _err("repo_path must be a string", "INVALID_ARGUMENT")
+        repo_path = _normalize_repo_path(repo_path)
+        _path_err = _check_repo_path(repo_path)
+        if _path_err is not None:
+            return _path_err
+        from sourcecode.mcp.orchestrator import run_migrate_flow_impl
+        return _ok(run_migrate_flow_impl(repo_path, min_severity or "low"))
+    except Exception as exc:
+        return _err(
+            f"Internal error: {type(exc).__name__}: {exc} — repo_path: {_raw}",
+            "INTERNAL_ERROR",
+        )
+
+
+@mcp.tool()
+def run_security_audit_flow(repo_path: str = ".", scope: str = "all") -> dict:
+    """Security Audit Flow — Spring findings + endpoint authorization surface. JAVA/SPRING ONLY.
+
+    Auto-chains in one call:
+      1. get_spring_audit(scope) — TX anomalies + security-surface findings
+      2. get_endpoints — endpoint authorization surface
+
+    Config-less safeguard: when no sourcecode.config.json is present and every
+    endpoint reads none_detected, the flow flags a likely custom-annotation blind
+    spot (quality_warnings) and returns a ready-to-paste security_config_hint —
+    rather than letting a misleading 100% none_detected surface stand.
+
+    Returns endpoint_security_coverage + consolidated_output (spring_audit,
+    endpoint_security_surface, optional security_config_hint).
+
+    repo_path: absolute path to the Java repository (default: current working directory).
+    scope: "all" (default) | "tx" | "security".
+    """
+    _raw = repo_path
+    try:
+        if not isinstance(repo_path, str):
+            return _err("repo_path must be a string", "INVALID_ARGUMENT")
+        repo_path = _normalize_repo_path(repo_path)
+        _path_err = _check_repo_path(repo_path)
+        if _path_err is not None:
+            return _path_err
+        from sourcecode.mcp.orchestrator import run_security_audit_flow_impl
+        return _ok(run_security_audit_flow_impl(repo_path, scope or "all"))
+    except Exception as exc:
+        return _err(
+            f"Internal error: {type(exc).__name__}: {exc} — repo_path: {_raw}",
+            "INTERNAL_ERROR",
+        )
+
+
 @mcp.tool()
 def get_cold_start_context(repo_path: str = ".") -> dict:
     """Instant session bootstrap from persisted Repository Intelligence Snapshot (RIS).
@@ -1333,16 +1402,19 @@ _NATIVE_MCP_TOOLS: frozenset[str] = frozenset({
     "run_pr_review_flow",
     "run_bug_investigation_flow",
     "run_feature_flow",
+    "run_migrate_flow",
+    "run_security_audit_flow",
 })
 
 
 def _finalize_mcp_registry() -> None:
     """Sync the MCP server with the runtime-generated registry.
 
-    Removes every tool except the 5 native orchestration tools (start_session,
-    analyze_task, flow runners) which are registered via @mcp.tool() in this
-    module and have no backing CLI command. All other tools are rebuilt from the
-    runtime-derived registry (build_mcp_tool_specs).
+    Removes every tool except the native orchestration tools (start_session,
+    analyze_task, and the flow runners — see _NATIVE_MCP_TOOLS) which are
+    registered via @mcp.tool() in this module and have no backing CLI command.
+    All other tools are rebuilt from the runtime-derived registry
+    (build_mcp_tool_specs).
     """
     from sourcecode.mcp.registry import build_mcp_tool_specs, make_tool_callable, validate_registry
 

sourcecode/repository_ir.py

@@ -3829,6 +3829,18 @@ def extract_java_endpoints(root: Path) -> "dict[str, Any]":
     all_symbols: list[SymbolRecord] = []
     extends_map: dict[str, str] = {}
 
+    # F-2: detect WebFlux / functional (RouterFunction) routing. Such routes register
+    # via a fluent DSL (route().GET("/path", handler)) instead of @RequestMapping
+    # annotations, so the annotation-based surface built below does not see them. We
+    # deliberately do NOT synthesize endpoint entries: the literal paths here are
+    # relative (the real path includes nest()/group-version prefixes that cannot be
+    # resolved statically), and emitting partial paths would mislead more than an empty
+    # surface. Instead we count them and surface an honest limitation so a zero/partial
+    # annotation surface is never read as "this app exposes no endpoints".
+    _FN_ROUTE_RE = _re.compile(r'\.(?:GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s*\(\s*"')
+    _fn_route_files: set[str] = set()
+    _fn_route_count = 0
+
     for jf in java_files:
         try:
             source = jf.read_text(encoding="utf-8", errors="replace")
@@ -3838,6 +3850,11 @@ def extract_java_endpoints(root: Path) -> "dict[str, Any]":
             rel = str(jf.relative_to(root)).replace("\\", "/")
         except ValueError:
             rel = str(jf).replace("\\", "/")
+        if "RouterFunction" in source or "RequestPredicates" in source:
+            _fn_hits = len(_FN_ROUTE_RE.findall(source))
+            if _fn_hits:
+                _fn_route_files.add(rel)
+                _fn_route_count += _fn_hits
         _, symbols, _ = _extract_symbols(source, rel, extra_capture=_extra_capture)
         for sym in symbols:
             all_symbols.append(sym)
@@ -4045,6 +4062,26 @@ def extract_java_endpoints(root: Path) -> "dict[str, Any]":
         result["spec_sourced_endpoints"] = len(_spec_endpoints)
         if _openapi_spec_path:
             result["openapi_spec"] = _openapi_spec_path
+    # F-2: surface functional/RouterFunction routing as an honest limitation. Not modeled
+    # in the surface above; counted so an empty/partial annotation surface is not misread.
+    if _fn_route_count:
+        result["functional_routing"] = {
+            "files": len(_fn_route_files),
+            "route_registrations": _fn_route_count,
+            "modeled": False,
+        }
+        _fr_msg = (
+            f"{_fn_route_count} functional route registration(s) across "
+            f"{len(_fn_route_files)} file(s) use WebFlux/RouterFunction routing "
+            f'(route().GET("/path", handler)), which is NOT modeled here — this surface '
+            f"covers annotation-based (@RequestMapping/@GetMapping) endpoints only."
+        )
+        if not endpoints:
+            _fr_msg += (
+                " This surface is EMPTY despite functional routes being present — "
+                "do NOT read it as 'no endpoints'; the app's HTTP surface is unmodeled."
+            )
+        result.setdefault("warnings", []).append(_fr_msg)
     return result
 
 

sourcecode/spring_impact.py

@@ -44,7 +44,18 @@ _SCHEMA_VERSION = "1.0"
 #                Only appears on class nodes, never method nodes. Including it
 #                chains through DTOs and entities that merely reference the service
 #                type, inflating caller counts without semantic value.
-_SKIP_EDGE_TYPES: frozenset[str] = frozenset({"contained_in", "imports"})
+# implements /  — CH-006: structural type declarations, NOT calls. The reverse edge
+# extends        on an interface/base lists its implementors/subclasses; an
+#                implementor does not *call* the interface by virtue of implementing
+#                it. Traversing these attributes every SIBLING implementor of a shared
+#                interface as a "caller". On a high-fanout in-repo hub interface (e.g.
+#                halo's CustomEndpoint, 43 implementors) this turned a leaf endpoint
+#                into 42 false direct callers / risk:high. Interface→impl expansion that
+#                IS wanted (CH-001a/b) flows through ImplementationGraph indices, not
+#                through these reverse-graph edges, so excluding them here is loss-free.
+_SKIP_EDGE_TYPES: frozenset[str] = frozenset(
+    {"contained_in", "imports", "implements", "extends"}
+)
 
 # Max BFS depth guard — caller growth is bounded per _bfs_callers
 _BFS_DEFAULT_DEPTH = 4
@@ -148,6 +159,68 @@ _STEREOTYPE_ANNOTATIONS = frozenset({
 _VALUE_TYPE_KINDS = frozenset({"class", "enum", "record"})
 
 
+# ---------------------------------------------------------------------------
+# CH-005 — framework/external-interface DI blind-spot detection
+# ---------------------------------------------------------------------------
+# When a class implements/extends a type that is NOT an in-repo symbol (a
+# framework or library supertype — e.g. Spring Security's RedirectStrategy, a
+# servlet Filter, a JPA base), the class is typically invoked polymorphically
+# *through that external type* and wired by framework DI/config. No in-repo call
+# edge ever names the impl's own method, and ImplementationGraph.build()
+# deliberately drops external supertypes (cir_graphs: `to_fqn not in
+# known_symbols` → skipped), so CH-001b cannot expand to the interface. Result:
+# impact-chain reports 0 callers / risk:low at confidence=high — a dangerous
+# false negative, since the real blast radius flows through framework wiring the
+# static call-graph never traverses. Detect the external supertype positively,
+# warn, and downgrade confidence (parallel to the CH-003 value-type guard).
+#
+# Inert marker interfaces carry no methods → no polymorphic dispatch → no hidden
+# blast radius, so they are excluded to avoid firing on plain Serializable DTOs.
+_INERT_MARKER_SUPERTYPES = frozenset({
+    "Serializable", "java.io.Serializable",
+    "Cloneable", "java.lang.Cloneable",
+    "Externalizable", "java.io.Externalizable",
+})
+
+
+def _external_supertypes(cir, class_fqn: str) -> list[str]:
+    """Return supertypes of class_fqn that are NOT in-repo symbols.
+
+    Reads raw implements/extends edges from cir.dependencies and keeps only those
+    whose target cannot be resolved to a single in-repo class (i.e. framework /
+    library types). Mirrors ImplementationGraph's resolution rules (exact FQN
+    match, then unambiguous simple-name match) so the internal/external split is
+    identical. Inert marker interfaces are dropped. Order-preserving, deduped.
+    """
+    deps = getattr(cir, "dependencies", None) or []
+    known: set[str] = set(getattr(cir, "symbols", None) or [])
+    simple_to_fqn: dict[str, list[str]] = {}
+    for sym in known:
+        if "#" not in sym and "." in sym:
+            simple_to_fqn.setdefault(sym.rsplit(".", 1)[1], []).append(sym)
+
+    external: list[str] = []
+    for edge in deps:
+        if edge.get("type") not in ("implements", "extends"):
+            continue
+        frm = normalize_owner_fqn((edge.get("from") or "").strip())
+        if frm != class_fqn:
+            continue
+        to = (edge.get("to") or "").strip()
+        if not to or ">" in to or "<" in to:
+            continue
+        simple = to.rsplit(".", 1)[1] if "." in to else to
+        if simple in _INERT_MARKER_SUPERTYPES or to in _INERT_MARKER_SUPERTYPES:
+            continue
+        # Internal if it resolves to exactly one in-repo class (exact or simple-name).
+        if to in known:
+            continue
+        if len(simple_to_fqn.get(simple, [])) == 1:
+            continue
+        external.append(to)
+    return list(dict.fromkeys(external))
+
+
 def _is_unmodeled_value_type(cir, class_fqn: str, model) -> bool:
     """True iff class_fqn is positively a plain value/DTO type whose blast radius
     flows only through type-usage edges the impact graph does not model.
@@ -605,6 +678,12 @@ class ImpactOrchestrator:
         t0 = time.monotonic()
         depth = max(1, min(depth, _BFS_HARD_LIMIT))
         warnings: list[str] = []
+        # F-1: not every warning degrades confidence. The CH-001a/b interface↔impl
+        # expansion notices are INFORMATIONAL (they describe normal, correct operation)
+        # and previously forced every Spring interface/impl query — the common case — down
+        # to confidence=medium permanently. Only genuinely degrading conditions (capped
+        # traversal) set this flag; resolution=="partial" is handled separately below.
+        confidence_reducing = False
 
         # ── 1. Resolve symbol ─────────────────────────────────────────────
         resolution, seed_fqns, sym_warnings = _resolve_symbol(symbol, cir.symbols)
@@ -702,6 +781,7 @@ class ImpactOrchestrator:
                 "Hub-class guard active: symbol has > 500 direct callers — "
                 "indirect caller traversal capped at depth=1."
             )
+            confidence_reducing = True  # capped traversal → result is incomplete
 
         # ── 3. Endpoints affected ─────────────────────────────────────────
         all_callers = direct_callers + indirect_callers
@@ -750,16 +830,38 @@ class ImpactOrchestrator:
             impact_findings_raw,
         )
 
-        # CH-003: empty blast radius on a positively-identified value/DTO type is a
-        # type-usage blind spot, not proof of dead code — warn + drop confidence.
+        # Empty blast radius is ambiguous: genuinely-unused code OR an unmodeled-edge
+        # blind spot. Two positively-detected blind spots reclassify it from a
+        # high-confidence "safe to change" into a low-confidence "look further".
         empty_blast = (
             not direct_callers and not indirect_callers
             and not endpoints_affected and not subtype_classes_added
         )
+        class_level_seed = "#" not in resolved_symbol and resolution != "not_found"
+
+        # CH-005: framework/external-interface DI blind spot. Checked first because
+        # its diagnosis (polymorphic invocation via an external supertype + framework
+        # wiring) is more specific than the value-type fallback for the same symbol.
+        external_supertypes: list[str] = []
+        if empty_blast and class_level_seed:
+            external_supertypes = _external_supertypes(cir, resolved_symbol)
+        framework_di_blind_spot = bool(external_supertypes)
+        if framework_di_blind_spot:
+            warnings.append(
+                "Framework/external-interface DI blind spot (CH-005): this class "
+                "implements/extends external type(s) [" + ", ".join(external_supertypes)
+                + "] and is likely invoked polymorphically through them and wired by "
+                "framework DI/config. The static call-graph has no in-repo edge naming "
+                "this class's methods, so 0 callers is NOT proof it is unused — search "
+                "DI/security/config wiring for the supertype to find the real callers."
+            )
+
+        # CH-003: empty blast radius on a positively-identified value/DTO type is a
+        # type-usage blind spot, not proof of dead code — warn + drop confidence.
         value_type_blind_spot = (
             empty_blast
-            and "#" not in resolved_symbol
-            and resolution != "not_found"
+            and class_level_seed
+            and not framework_di_blind_spot
             and _is_unmodeled_value_type(cir, resolved_symbol, model)
         )
         if value_type_blind_spot:
@@ -773,9 +875,9 @@ class ImpactOrchestrator:
         confidence: str
         if resolution == "not_found":
             confidence = "low"
-        elif value_type_blind_spot:
+        elif framework_di_blind_spot or value_type_blind_spot:
             confidence = "low"
-        elif resolution == "partial" or warnings:
+        elif resolution == "partial" or confidence_reducing:
             confidence = "medium"
         else:
             confidence = "high"
@@ -803,6 +905,11 @@ class ImpactOrchestrator:
                 "risk_score": risk_score,
                 "model_build_time_ms": model.build_time_ms,
                 "query_time_ms": elapsed_ms,
+                "blind_spots": (
+                    (["framework_di"] if framework_di_blind_spot else [])
+                    + (["value_type"] if value_type_blind_spot else [])
+                ),
+                "external_supertypes": external_supertypes,
             },
         )
 

{sourcecode-1.45.0.dist-info → sourcecode-1.50.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.45.0
+Version: 1.50.0
 Summary: Persistent structural context and ultra-fast repeated analysis for AI coding agents
 License-File: LICENSE
 Keywords: agents,ai,codebase,context,developer-tools,llm
@@ -40,7 +40,7 @@ Description-Content-Type: text/markdown
 
 **Persistent structural context and ultra-fast repeated analysis for AI coding agents.**
 
-![Version](https://img.shields.io/badge/version-1.45.0-blue)
+![Version](https://img.shields.io/badge/version-1.50.0-blue)
 ![Python](https://img.shields.io/badge/python-3.9%2B-green)
 
 ---
@@ -368,6 +368,8 @@ sourcecode endpoints /path/to/repo --output endpoints.json
 
 Extracts all Spring MVC (`@GetMapping`, `@PostMapping`, `@RequestMapping`, etc.) and JAX-RS (`@GET`, `@POST`, `@Path`) endpoint methods. Returns HTTP method, path, controller class, and handler method.
 
+**Functional / WebFlux routing (honest limitation).** Routes registered via the functional DSL — `route().GET("/path", handler)` / `RouterFunction` / `CustomEndpoint`, common in reactive Spring apps — are **not** modeled (their real paths depend on `nest()`/group-version prefixes that can't be resolved statically). Rather than emit partial paths that would mislead, the output reports a `functional_routing` block (`files`, `route_registrations`, `modeled: false`) plus a warning. When the annotation surface is empty but functional routes exist, the warning explicitly tells you not to read it as "no endpoints". Annotation-based (MVC/JAX-RS) repos are unaffected.
+
 **Custom security annotations.** Enterprise repos often guard endpoints with a bespoke annotation instead of `@PreAuthorize`/`@Secured`. Drop a `sourcecode.config.json` at the repo root to teach the scanner about it — otherwise those endpoints report `policy: "none_detected"`:
 
 ```json
@@ -435,6 +437,12 @@ Unlike `impact` (which traces the caller graph), `impact-chain` builds on the Sp
 | `security_surfaces` | Per-endpoint security policy + SEC finding IDs |
 | `impact_findings` | TX-001..005 and SEC-001..003 findings that touch the call chain |
 | `risk_level` | `critical` \| `high` \| `medium` \| `low` |
+| `confidence` | `high` \| `medium` \| `low` — `low` on a detected blind spot, `medium` on partial resolution or capped traversal. Informational interface↔impl expansion notices do **not** lower it, so a clean resolved query stays `high`. |
+| `metadata.blind_spots` | `framework_di` and/or `value_type` when an empty result is unmodeled-edge driven, not real dead code |
+
+**Framework/DI blind spot (CH-005).** An empty blast radius is ambiguous: genuinely unused, or invoked through an edge the static graph does not model. When the target class implements/extends an **external** framework type (e.g. Spring Security's `RedirectStrategy`, a servlet `Filter`) it is typically wired by framework DI/config and invoked polymorphically — no in-repo edge names its methods, so `direct_callers` is `0`. Rather than report that as `risk:low` at high confidence (a dangerous false negative that reads as "safe to change"), `impact-chain` detects the external supertype, drops `confidence` to `low`, lists it in `metadata.external_supertypes`, and emits a `CH-005` warning telling you to search the DI/security/config wiring for the supertype. Inert markers (`Serializable`, `Cloneable`) are excluded.
+
+**Caller precision (CH-006).** `implements`/`extends` are structural type declarations, not calls — so they are excluded from the caller graph. Querying a class that implements a high-fanout interface (e.g. a 40-implementor `CustomEndpoint` or a shared `Mapper<E,D>` base) does **not** report its sibling implementors as callers; only real `injects`/`calls` edges count. This prevents a leaf class from being inflated to a large false blast radius.
 
 **Event topology** — query the publisher/consumer graph for a Spring event class:
 

{sourcecode-1.45.0.dist-info → sourcecode-1.50.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sourcecode/__init__.py,sha256=r64WSv9Pulq3yQh1i31dLAG4Q5FJDkTYFw7e54HHTsc,103
+sourcecode/__init__.py,sha256=pCkOXPgXyXxjAbBGF1i4NrzrWef2vm102RXTjjOE8go,103
 sourcecode/adaptive_scanner.py,sha256=XffluXKzJUXrMtjEiAOnSNPZnztdIcts17T9ouHeID0,10521
 sourcecode/architecture_analyzer.py,sha256=liCwQmLgb5vplohy8arjYxs_HOIv5C9MjLh_gY6bc5Q,44115
 sourcecode/architecture_summary.py,sha256=z34_6v7cSwy98cof2UVciGho7SCrZ93tiqMmq5WNzRQ,20405
@@ -44,7 +44,7 @@ sourcecode/redactor.py,sha256=SB4hwIvg8h-hvcqKcDWaZvA-aSyn-at-BIRwa0tUv5E,3227
 sourcecode/relevance_scorer.py,sha256=0AgEt4KrV73nioMqBgjhGjtY7L2C7L7cSyKtj3IKcrw,9408
 sourcecode/rename_refactor.py,sha256=h6dNFlB9aZ_3q6heeHBkgXQeXaT03nvPSsYH6P8qxFg,12965
 sourcecode/repo_classifier.py,sha256=FG1vaWKdWXsWdl-S8hjVMiTqcwgaRXkDyvK4rPcOGtQ,22681
-sourcecode/repository_ir.py,sha256=WjDYwbBm-eWp-k6aSdBrgO_XcRGuP-Llp0TZHBhq8bY,208237
+sourcecode/repository_ir.py,sha256=eBC8Jh1rBH8xE46atHmdGNQxcjuROyUCr0iCuhqviUc,210340
 sourcecode/ris.py,sha256=RcqLVwC-doFcKKViYDkCjZLBqf_wzLES7-F6vHEeWzE,20419
 sourcecode/runtime_classifier.py,sha256=uTAD6BDCiBLUZEDRfqk718kM4RTT_vAbfkcOI2_Xx58,18432
 sourcecode/scanner.py,sha256=WdOQ78mMzjR1NjmKTlbxdgwinnCTfAhxCVLBEFQiFHU,8899
@@ -54,7 +54,7 @@ sourcecode/semantic_analyzer.py,sha256=4OdG6tTSnTvq3_dSWMbQu8Ad1ndSCKeG-b9qM4hIx
 sourcecode/serializer.py,sha256=TGzftrSKitZrtl6Hh-R05s4KdTOxwTmph_lGDbo2Wzg,125015
 sourcecode/spring_event_topology.py,sha256=5_ON_21Le5zbG-1GRc5GLIi5HJfy_QjcXLVPC5WeUGQ,18055
 sourcecode/spring_findings.py,sha256=G7Or2lKBUQbcTDqudLvSs9XvNg_YoAa-_lBOG_ULs8E,5457
-sourcecode/spring_impact.py,sha256=rUKSiCfXh9NpC9a97KvjCu6Kn8bYezTnMDY3F7sgtCI,38737
+sourcecode/spring_impact.py,sha256=WUbBw6Ne9esN_KczIs9BCJdRAmjDKtU6E2_auo-771s,44865
 sourcecode/spring_model.py,sha256=zOAgFmrRbG4a6KLm1TJl55aWMyPNsz3OS3FSczqPG6A,16594
 sourcecode/spring_security_audit.py,sha256=XtPJ1SXlZJ8k6VYmaWuAp7Bbir4UmreAL7doIGQ5I7o,20595
 sourcecode/spring_semantic.py,sha256=O1nKSGVzlukuxLHQVuCPxc-XrcrMFxwlHA20_dmEGgM,13307
@@ -86,10 +86,10 @@ sourcecode/detectors/systems.py,sha256=nYaKbGDFu0EOXFcd_1doWFT3tTUdkbxc2DjHUF5Tc
 sourcecode/detectors/terraform.py,sha256=cxORPR_zVLOJpHlh4e9JnFpkQsn_UnqMMom5yG65hZ4,1693
 sourcecode/detectors/tooling.py,sha256=8CKbtxwQoABP-WyBRNmdAmHDOvAH57AR1cF4UKuWEdQ,2074
 sourcecode/mcp/__init__.py,sha256=XU4HfRGbdid8wdUA0x_4f7uKZD1z3mv_XUY_WU_T9Mw,179
-sourcecode/mcp/orchestrator.py,sha256=luOglUaKPaMnsq9j3XI3D-P68ABURYpiP1fojK5LDi4,28177
+sourcecode/mcp/orchestrator.py,sha256=kT7IssYNyQXVtDf2Q69qrMSTuyJlJ1Rhkp6_EHqc_38,36520
 sourcecode/mcp/registry.py,sha256=8LxxalpJy1L_BrEfwiVfywFVOcJJMXLGusJaUGGH7Y4,65663
 sourcecode/mcp/runner.py,sha256=-Dp2qPGRkfNTVen6bKh7WtzQqpcEtsrXoiuajvshlKk,2866
-sourcecode/mcp/server.py,sha256=f4-k-nx2amhSghlM7EBeZWyqCMEAGodOgrYPdbIUK08,59891
+sourcecode/mcp/server.py,sha256=6Q98B1JkgBR5pZx3JyyXZosazpPX7FSBDqfG9nlZaII,63114
 sourcecode/mcp/onboarding/__init__.py,sha256=sj2PWqEBmMc4zBNkomg89WtL0M6S7A9yb7_wAuSWNP4,66
 sourcecode/mcp/onboarding/applier.py,sha256=B9CneieWTpaDSDIyW3S5nrlRlBpvfqUcgi93-mm_ApQ,2135
 sourcecode/mcp/onboarding/backup.py,sha256=ihqGOR8QTX8HASRSEDyfFyXr5bkXrygPHamv4p9KTmk,1452
@@ -101,8 +101,8 @@ sourcecode/telemetry/consent.py,sha256=wLMvGNJeSSyZoNkQXpoUioY6mMv4Qdvuw7S9jAEWn
 sourcecode/telemetry/events.py,sha256=LtzYfaX9Ilckj5PTvAcTpDa9mLqDsYPDUiDkRa58piY,2580
 sourcecode/telemetry/filters.py,sha256=NHa5T-6DaZduQPFuC34jOqHWQgSizM-Ygq8aZ4j19ng,5834
 sourcecode/telemetry/transport.py,sha256=4gGHsq0WeY9VywEZXA3vUxykfiYnw9uuqfjAAec7F8o,1681
-sourcecode-1.45.0.dist-info/METADATA,sha256=24sPQbi_FdplZlmfRZ1zc3_gQPZEYwbs0HGCY4A59j8,32359
-sourcecode-1.45.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-1.45.0.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
-sourcecode-1.45.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-1.45.0.dist-info/RECORD,,
+sourcecode-1.50.0.dist-info/METADATA,sha256=AMKgfVLsoGpmtnK3Vk75eHizMToSqxiiPsoMzTA-res,34684
+sourcecode-1.50.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-1.50.0.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
+sourcecode-1.50.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-1.50.0.dist-info/RECORD,,