sourcecode 2.5.2__py3-none-any.whl → 2.5.4__py3-none-any.whl

sourcecode/semantic_impact_engine.py

@@ -28,6 +28,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Optional
 
+from sourcecode.repository_ir import _resolve_declared_type
 from sourcecode.semantic_services import SemanticServices
 
 if TYPE_CHECKING:  # avoid import cycle
@@ -236,13 +237,15 @@ class SemanticImpactEngine:
         """(field_name, type_fqn) for fields whose declared type resolves to a role
         in `roles` — the plain setter/XML-injected dependencies the injection graph
         cannot see (e.g. openmrs `private TemplateDAO templateDAO;`). Uses field-type
-        facts (#10) resolved to a concrete type by simple name (unambiguous only)."""
+        facts (#10), which carry the owning file's import-resolved FQN when it had
+        one; a bare simple name still resolves only while unambiguous."""
         by_simple = self.s.types_by_simple()
+        known = {f for fqns in by_simple.values() for f in fqns}
         out: list[tuple[str, str]] = []
-        for fname, tsimple in sorted(self.s.field_types_of(owner_fqn).items()):
-            fqns = by_simple.get(tsimple, [])
-            if len(fqns) == 1 and self._role(fqns[0]) in roles:
-                out.append((fname, fqns[0]))
+        for fname, declared in sorted(self.s.field_types_of(owner_fqn).items()):
+            fqn = _resolve_declared_type(declared, owner_fqn, by_simple, known)
+            if fqn and self._role(fqn) in roles:
+                out.append((fname, fqn))
         return out
 
     def _called_via_receiver(self, owner_fqn: str, receiver: str) -> Optional[str]:

sourcecode/semantic_services.py

@@ -209,9 +209,11 @@ class SemanticServices:
         return self._g.annotation_arg_values_in(fqn)
 
     def field_types_of(self, class_fqn: str) -> dict[str, str]:
-        """{field_name -> declared_type_simple_name} for a class's fields (annotated
-        or plain). Resolves a body invocation's receiver to its typed dependency —
-        the fact injection edges miss for plain setter/XML-injected fields."""
+        """{field_name -> declared_type} for a class's fields (annotated or plain).
+        Resolves a body invocation's receiver to its typed dependency — the fact
+        injection edges miss for plain setter/XML-injected fields. The type is the
+        FQN when the declaring file imported it explicitly, else a simple name;
+        `repository_ir._resolve_declared_type` handles both."""
         return self._g.field_types_in(class_fqn)
 
     def return_type_index(self) -> dict[str, set[str]]:

sourcecode/spring_impact.py

@@ -26,6 +26,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Optional
 
 from sourcecode.fqn_utils import normalize_owner_fqn
+from sourcecode.reconciliation import http_handler_classes, reconcile_impact_evidence
 from sourcecode.spring_findings import SEVERITY_ORDER, SpringFinding
 from sourcecode.spring_model import SpringSemanticModel
 
@@ -340,6 +341,22 @@ def _recover_external_iface_callers(
 # Symbol resolution
 # ---------------------------------------------------------------------------
 
+def _parse_coverage_gap(cir) -> Optional[dict]:
+    """The parse_coverage analysis gap from CIR metadata, if any (P1-E).
+
+    Written by the extraction-time reconciliation rule (reconciliation.py):
+    files that declare a type but produced no symbols. Impact answers built on
+    a graph with invisible files must say so instead of asserting completeness.
+    """
+    try:
+        for g in (getattr(cir, "metadata", None) or {}).get("analysis_gaps") or []:
+            if isinstance(g, dict) and g.get("area") == "parse_coverage":
+                return g
+    except Exception:
+        pass
+    return None
+
+
 def _class_of(fqn: str) -> str:
     """Extract class FQN from a method FQN.  pkg.Class#method → pkg.Class."""
     if "#" in fqn:
@@ -581,6 +598,32 @@ def _bfs_callers(
     return direct, indirect, was_truncated, self_excluded
 
 
+def _dedupe_caller_granularity(callers: list[str]) -> list[str]:
+    """Drop a class-level caller entry when a method entry of the same class is
+    present in the same list (P1-B3).  Order preserved.
+
+    A static call binds TWO edges: the coarse class-level one from the per-file
+    scan (`X --calls--> T`, which cannot name the callee) and, since P1-B2, the
+    precise method-level one (`X#m --calls--> T#callee`).  They are additive on
+    purpose — a static call in a field initializer or static block produces no
+    body fact, so only the class edge carries it and dropping it erases real
+    coupling (measured: BroadleafCurrencyUtils lost 1325→561 transitive reach and
+    all 20 affected endpoints).  The cost of keeping both is that one caller is
+    reported at two granularities: `X` and `X#m` read as two callers, and
+    `len(direct_callers)` double-counts them into `_compute_risk`.
+
+    Collapsing is safe HERE and only here, because it is a view: the method entry
+    already names the class, so the set of caller *classes* is identical and no
+    edge is deleted.  A class entry with no method sibling (the field-initializer
+    case) has no precise entry to defer to and is kept.  Callers of both
+    granularities remain the input to endpoint and finding mapping — a class node
+    reaches every endpoint of a controller, a method node only its own — so this
+    is applied to the reported/scored lists, never to the reach computation.
+    """
+    classes_with_methods = {_class_of(c) for c in callers if "#" in c}
+    return [c for c in callers if "#" in c or c not in classes_with_methods]
+
+
 # ---------------------------------------------------------------------------
 # Endpoint mapping
 # ---------------------------------------------------------------------------
@@ -744,10 +787,21 @@ def _build_chain_explanation(
     endpoints_affected: int,
     findings: int,
     confidence: str,
+    blind_spot: bool = False,
 ) -> str:
     """Human-readable rationale, phrased to match the `impact` command's
-    explanation so both surfaces read consistently."""
+    explanation so both surfaces read consistently.
+
+    `blind_spot` says a positively-detected gap explains the empty result, so it must
+    not be narrated as an isolated change: the warnings carry the diagnosis, and this
+    sentence is what an agent quotes."""
     if not direct_callers and not indirect_callers and not endpoints_affected:
+        if blind_spot:
+            return (
+                "No callers or endpoints resolved, but this analysis has a known blind "
+                "spot (see analysis_warnings) — an empty result here is NOT evidence of "
+                "an isolated or low-risk change."
+            )
         return "No callers or endpoints found in the impact chain. Low-risk isolated change."
     parts: list[str] = []
     if direct_callers:
@@ -840,10 +894,22 @@ class ImpactOrchestrator:
         warnings.extend(sym_warnings)
 
         if resolution == "not_found" or not seed_fqns:
+            if not warnings:
+                warnings = [f"Symbol '{symbol}' not found in CIR."]
+            # P1-E: a not-found verdict is weaker when files failed extraction —
+            # the queried symbol may be defined in one of them.
+            _nf_gap = _parse_coverage_gap(cir)
+            if _nf_gap:
+                _nf_n = len(_nf_gap.get("files") or [])
+                warnings.append(
+                    f"Parse-coverage gap (P1-E): {_nf_n} Java file(s) declare a type "
+                    "but produced no symbols — the queried symbol may be defined in "
+                    "one of them (see analysis_gaps)."
+                )
             return ImpactChainResult(
                 symbol=symbol,
                 resolution="not_found",
-                analysis_warnings=warnings or [f"Symbol '{symbol}' not found in CIR."],
+                analysis_warnings=warnings,
                 risk_level="unknown",
                 confidence="low",
                 explanation=f"Symbol {symbol!r} not found in the IR.",
@@ -942,10 +1008,17 @@ class ImpactOrchestrator:
                 )
 
         # ── 2. BFS through reverse graph ─────────────────────────────────
-        direct_callers, indirect_callers, truncated, self_excluded = _bfs_callers(
+        direct_callers_raw, indirect_callers_raw, truncated, self_excluded = _bfs_callers(
             seed_fqns, cir.reverse_graph, depth, impl_graph=impl_graph,
             method_scoped=_method_scoped,
         )
+        # P1-B3: the reported/scored caller lists collapse the class-vs-method
+        # granularity duplicate that additive static edges (P1-B2) produce. The RAW
+        # lists stay the input to endpoint/finding mapping below: a class-level node
+        # carries reach a method node does not (all handlers of a controller), so
+        # deduping there would erase endpoints. See _dedupe_caller_granularity.
+        direct_callers = _dedupe_caller_granularity(direct_callers_raw)
+        indirect_callers = _dedupe_caller_granularity(indirect_callers_raw)
         if self_excluded:
             if _method_scoped:
                 warnings.append(
@@ -967,7 +1040,7 @@ class ImpactOrchestrator:
             confidence_reducing = True  # capped traversal → result is incomplete
 
         # ── 3. Endpoints affected ─────────────────────────────────────────
-        all_callers = direct_callers + indirect_callers
+        all_callers = direct_callers_raw + indirect_callers_raw
         endpoints_affected = _collect_endpoints(all_callers, seed_fqns, model)
 
         # ── 4. TX boundary for the target symbol ─────────────────────────
@@ -994,7 +1067,8 @@ class ImpactOrchestrator:
             all_findings = _run_audit_for_chain(cir, model, root)
 
         impact_findings_raw = _filter_findings(
-            all_findings, seed_fqns, direct_callers, indirect_callers, endpoints_affected
+            all_findings, seed_fqns, direct_callers_raw, indirect_callers_raw,
+            endpoints_affected,
         )
         # Sort by severity, then symbol
         impact_findings_raw.sort(
@@ -1041,19 +1115,21 @@ class ImpactOrchestrator:
             )
             di_binding_ambiguous = _max_impl > 1
             # Keep only genuinely new caller classes (not seeds / already found).
-            _known = set(seed_fqns) | set(direct_callers) | set(indirect_callers)
+            _known = set(seed_fqns) | set(direct_callers_raw) | set(indirect_callers_raw)
             di_recovered_callers = [c for c in di_recovered_callers if c not in _known]
 
         di_recovered = bool(di_recovered_callers)
         if di_recovered:
             # Merge recovered wiring sites into the chain and recompute the views
             # that depend on the caller set (endpoints, findings, surfaces, risk).
+            direct_callers_raw = direct_callers_raw + di_recovered_callers
             direct_callers = direct_callers + di_recovered_callers
             empty_blast = False
-            all_callers = direct_callers + indirect_callers
+            all_callers = direct_callers_raw + indirect_callers_raw
             endpoints_affected = _collect_endpoints(all_callers, seed_fqns, model)
             impact_findings_raw = _filter_findings(
-                all_findings, seed_fqns, direct_callers, indirect_callers, endpoints_affected
+                all_findings, seed_fqns, direct_callers_raw, indirect_callers_raw,
+                endpoints_affected,
             )
             impact_findings_raw.sort(
                 key=lambda f: (SEVERITY_ORDER.get(f.severity, 9), f.symbol)
@@ -1130,6 +1206,107 @@ class ImpactOrchestrator:
                     "proof this symbol is unused."
                 )
 
+        # P1-B: every guard above needs a class-level seed, so a `Class#method` query
+        # never reached one — an empty method blast was reported as a high-confidence
+        # "low-risk isolated change" no matter what was known about the class. When the
+        # declaring class has inbound DI/import edges, the class-level query resolves
+        # those callers correctly (they land on the class node), so the tool used to
+        # contradict itself across granularity — "isolated" for the method, "critical"
+        # for its class — with no signal that the narrower, more natural query was the
+        # less trustworthy one. The method may still be genuinely uncalled; what is
+        # unproven is the *emptiness*, so this downgrades confidence and warns rather
+        # than inventing callers.
+        method_scope_blind_spot = False
+        if empty_blast and not class_level_seed and resolution != "not_found":
+            _crev = cir.reverse_graph.get(_class_of(resolved_symbol)) or {}
+            method_scope_inbound = sorted(
+                {c for et in ("injects", "imports") for c in (_crev.get(et) or [])}
+            )
+            if method_scope_inbound:
+                method_scope_blind_spot = True
+                warnings.append(
+                    f"Method-scoped empty blast radius is unproven (P1-B): no call edge "
+                    f"resolves to this method, but {len(method_scope_inbound)} in-repo "
+                    f"class(es) inject or import the declaring class "
+                    f"{_class_of(resolved_symbol)}. The call may travel an edge the "
+                    "graph does not model (wildcard-imported or generic receiver, "
+                    "reflection, method reference, framework callback). 0 callers is "
+                    "NOT proof this method is unused — re-query at class level (drop "
+                    "the '#method') to see the declaring class's callers."
+                )
+
+        # P1-E: an empty blast radius computed over a graph with provably
+        # invisible files is unproven — a caller could live in a file that
+        # declared a type but produced no symbols (parse_coverage gap written by
+        # the extraction-time reconciliation rule). Fires at any seed
+        # granularity: unlike CH-003/CH-005/G-2 (class-level) and P1-B
+        # (method-level), file invisibility undermines both equally.
+        parse_coverage_blind_spot = False
+        if empty_blast:
+            _pc_gap = _parse_coverage_gap(cir)
+            if _pc_gap:
+                parse_coverage_blind_spot = True
+                _pc_n = len(_pc_gap.get("files") or [])
+                warnings.append(
+                    f"Parse-coverage gap (P1-E): {_pc_n} Java file(s) declare a type "
+                    "but produced no symbols — a caller could live in an unmodeled "
+                    "file, so an empty blast radius is NOT proof this symbol is "
+                    "unused (see analysis_gaps for the file list)."
+                )
+
+        # F-1 (Evidence Reconciliation Layer) / SIM-2: the call graph and the
+        # endpoint index are independent evidence views and can contradict each
+        # other. keycloak simulacro: the verified caller chain contained
+        # AuthorizationEndpoint#process while the endpoint index had NO route for
+        # that class (a JAX-RS sub-resource locator chain the route extractor
+        # cannot compose) — "2 endpoints exposed" was narrated at confidence=high
+        # while the real OAuth surface was invisible. Unlike the guards above,
+        # this fires on PARTIAL results, not just empty ones: a chain class that
+        # provably declares HTTP handlers but has no modeled route is a
+        # positively-detected under-report of endpoints_affected.
+        endpoint_coverage_blind_spot = False
+        reconciliation_findings: list[dict] = []
+        try:
+            _chain_classes = frozenset(
+                _class_of(f)
+                for f in set(seed_fqns) | set(direct_callers_raw) | set(indirect_callers_raw)
+            )
+            _rec = reconcile_impact_evidence(
+                chain_classes=_chain_classes,
+                handler_classes=http_handler_classes(cir),
+                modeled_classes=frozenset(model.endpoint_index.controller_fqns),
+            )
+            reconciliation_findings = [f.to_dict() for f in _rec]
+            _unmapped: list[str] = []
+            for _f in _rec:
+                if _f.rule == "endpoint_coverage":
+                    endpoint_coverage_blind_spot = True
+                    _unmapped = list(_f.symbols)
+            if endpoint_coverage_blind_spot:
+                warnings.append(
+                    f"Endpoint-coverage contradiction (evidence reconciliation): {len(_unmapped)} "
+                    "class(es) in the call chain declare HTTP handler methods but the "
+                    "endpoint index has no modeled route for them ["
+                    + ", ".join(_unmapped[:5])
+                    + (", …" if len(_unmapped) > 5 else "")
+                    + "]. endpoints_affected UNDER-REPORTS real HTTP exposure (routes "
+                    "the extractor could not compose, e.g. JAX-RS sub-resource "
+                    "locator chains). Callers remain reliable; verify these classes' "
+                    "exposure before treating the endpoint list as complete."
+                )
+        except Exception:
+            pass
+
+        blind_spots = (
+            # framework_di stops being a blind spot once CH-007 recovers callers
+            (["framework_di"] if framework_di_blind_spot and not di_recovered else [])
+            + (["value_type"] if value_type_blind_spot else [])
+            + (["unresolved_refs"] if unresolved_ref_blind_spot else [])
+            + (["method_scope_unproven"] if method_scope_blind_spot else [])
+            + (["parse_coverage"] if parse_coverage_blind_spot else [])
+            + (["endpoint_coverage_partial"] if endpoint_coverage_blind_spot else [])
+        )
+
         confidence: str
         if resolution == "not_found":
             confidence = "low"
@@ -1137,15 +1314,38 @@ class ImpactOrchestrator:
             # Callers recovered structurally via the external-interface DI bridge.
             # Unambiguous binding (single in-repo impl) → medium; ambiguous → low.
             confidence = "low" if di_binding_ambiguous else "medium"
-        elif framework_di_blind_spot or value_type_blind_spot or unresolved_ref_blind_spot:
+        elif (
+            framework_di_blind_spot
+            or value_type_blind_spot
+            or unresolved_ref_blind_spot
+            or method_scope_blind_spot
+            or parse_coverage_blind_spot
+        ):
             confidence = "low"
-        elif resolution == "partial" or confidence_reducing:
+        elif resolution == "partial" or confidence_reducing or endpoint_coverage_blind_spot:
+            # endpoint_coverage: the callers are still trustworthy — only the
+            # endpoint axis is provably incomplete, so cap at medium, not low.
             confidence = "medium"
         else:
             confidence = "high"
 
         elapsed_ms = round((time.monotonic() - t0) * 1000, 2)
 
+        explanation = _build_chain_explanation(
+            risk_level,
+            len(direct_callers),
+            len(indirect_callers),
+            len(endpoints_affected),
+            len(impact_findings),
+            confidence,
+            blind_spot=bool(blind_spots),
+        )
+        if endpoint_coverage_blind_spot:
+            explanation += (
+                " HTTP exposure is under-reported: handler class(es) in the chain "
+                "have no modeled routes (blind_spots=endpoint_coverage_partial)."
+            )
+
         return ImpactChainResult(
             symbol=resolved_symbol,
             resolution=resolution,
@@ -1161,14 +1361,7 @@ class ImpactOrchestrator:
             risk_level=risk_level,
             risk_score=risk_score,
             confidence=confidence,
-            explanation=_build_chain_explanation(
-                risk_level,
-                len(direct_callers),
-                len(indirect_callers),
-                len(endpoints_affected),
-                len(impact_findings),
-                confidence,
-            ),
+            explanation=explanation,
             metadata={
                 "analysis_depth": depth,
                 "callers_total": len(direct_callers) + len(indirect_callers),
@@ -1177,12 +1370,8 @@ class ImpactOrchestrator:
                 "risk_score": risk_score,
                 "model_build_time_ms": model.build_time_ms,
                 "query_time_ms": elapsed_ms,
-                "blind_spots": (
-                    # framework_di stops being a blind spot once CH-007 recovers callers
-                    (["framework_di"] if framework_di_blind_spot and not di_recovered else [])
-                    + (["value_type"] if value_type_blind_spot else [])
-                    + (["unresolved_refs"] if unresolved_ref_blind_spot else [])
-                ),
+                "blind_spots": blind_spots,
+                "reconciliation": reconciliation_findings,
                 "external_supertypes": external_supertypes,
                 "external_iface_callers_recovered": len(di_recovered_callers),
                 "external_iface_binding_ambiguous": di_binding_ambiguous,

sourcecode/summarizer.py

@@ -8,6 +8,7 @@ No API calls — templates applied directly over SourceMap.
 from pathlib import Path
 from typing import Any
 
+from sourcecode.architecture_analyzer import _LAYER_MIN_SHARE
 from sourcecode.detectors.parsers import load_json_file, load_toml_file
 from sourcecode.tree_utils import safe_read_text
 from sourcecode.entrypoint_classifier import is_production_entry_point
@@ -48,11 +49,15 @@ _ARCH_LAYER_PATTERNS: dict[str, dict[str, list[str]]] = {
         "model": ["models", "entities", "domain"],
         "view": ["views", "templates", "pages", "components"],
     },
+    # P1-D: keep in step with architecture_analyzer.LAYER_PATTERNS — a keyword may
+    # only name a layer it attests. "api" (a public API package, not an HTTP
+    # controller layer), "store" and "db"/"database" are naming conventions that
+    # fabricated the "layered" claim in this very headline for neo4j and openmrs.
     "layered": {
-        "controller": ["controllers", "api", "routes", "handlers", "endpoints"],
+        "controller": ["controllers", "routes", "handlers", "endpoints"],
         "service": ["services", "usecases", "application"],
-        "repository": ["repositories", "repos", "store", "dao"],
-        "infrastructure": ["infra", "infrastructure", "persistence", "db", "database"],
+        "repository": ["repositories", "repos", "dao"],
+        "infrastructure": ["infra", "infrastructure", "persistence"],
     },
     "hexagonal": {
         "port": ["ports", "interfaces"],
@@ -61,7 +66,11 @@ _ARCH_LAYER_PATTERNS: dict[str, dict[str, list[str]]] = {
     },
     "fullstack": {
         "frontend": ["frontend", "client", "web", "ui", "pages", "components"],
-        "backend": ["backend", "server", "api", "services"],
+        # P1-D: "api" dropped — a `foo/api/` package is a public API surface, not
+        # evidence of a backend TIER. With it, openmrs (94.8% `org/openmrs/api/`)
+        # and jobrunr fell straight from a fabricated "layered" into a fabricated
+        # "fullstack" instead. Same conflation, same fix.
+        "backend": ["backend", "server", "services"],
     },
 }
 
@@ -390,20 +399,32 @@ class ProjectSummarizer:
         return ". ".join(parts) + "."
 
     def _detect_architecture_pattern(self, file_paths: list[str]) -> str | None:
-        """Infer architecture pattern from directory names in file paths."""
-        dir_names: set[str] = set()
-        for p in file_paths:
-            norm = p.replace("\\", "/")
-            for seg in norm.split("/")[:-1]:
-                dir_names.add(seg.lower())
+        """Infer architecture pattern from directory names in file paths.
+
+        P1-D: a layer must hold a real share of the code. Scoring on the mere
+        PRESENCE of a directory name meant one incidental dir asserted a whole
+        layer, and the claim landed in the headline: neo4j — a graph engine with no
+        controller, repository or infrastructure directory anywhere — read "Library
+        in Java (JAX-RS), layered". Presence does not scale, so the largest repos
+        were the most confidently mislabelled. Same gate and threshold as
+        ArchitectureAnalyzer, which answers this question for the architecture prose.
+        """
+        dir_files: dict[str, set[int]] = {}
+        for i, p in enumerate(file_paths):
+            for seg in p.replace("\\", "/").split("/")[:-1]:
+                dir_files.setdefault(seg.lower(), set()).add(i)
+        total = len(file_paths)
+
+        def _has_mass(keywords: list[str]) -> bool:
+            files: set[int] = set()
+            for d in keywords:
+                files |= dir_files.get(d, set())
+            return bool(files) and (not total or len(files) / total >= _LAYER_MIN_SHARE)
 
         best_pattern: str | None = None
         best_score = 0
         for pattern_name, layer_keys in _ARCH_LAYER_PATTERNS.items():
-            score = sum(
-                1 for keywords in layer_keys.values()
-                if any(d in keywords for d in dir_names)
-            )
+            score = sum(1 for keywords in layer_keys.values() if _has_mass(keywords))
             if score > best_score:
                 best_score = score
                 best_pattern = pattern_name

{sourcecode-2.5.2.dist-info → sourcecode-2.5.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 2.5.2
+Version: 2.5.4
 Summary: Persistent structural context and ultra-fast repeated analysis for AI coding agents
 License-File: LICENSE
 Keywords: agents,ai,codebase,context,developer-tools,llm

{sourcecode-2.5.2.dist-info → sourcecode-2.5.4.dist-info}/RECORD

@@ -1,15 +1,15 @@
-sourcecode/__init__.py,sha256=nbtWf3A6IYQQ1rNky7L2moDkYZ2Uy7Nj9Mb5R7f2-KQ,308
+sourcecode/__init__.py,sha256=XumauaLNdzXEwNGsJupjZthcLY2Qo8ud3CgsBguv8-o,308
 sourcecode/adaptive_scanner.py,sha256=XffluXKzJUXrMtjEiAOnSNPZnztdIcts17T9ouHeID0,10521
 sourcecode/archetype.py,sha256=d7yoN6Tj4OBj-VgSMPEKg4WF9H8FypnZ5A6AkUh5oIE,34484
-sourcecode/architecture_analyzer.py,sha256=6_wC4TYuBYxaqckZS0I1vBSMRPeH2vzlDB48gXwOOd4,46627
+sourcecode/architecture_analyzer.py,sha256=CoxlEDWn1axufjIT4fpNHd_2HNUKgqBClq9z9k6jp4M,51684
 sourcecode/architecture_summary.py,sha256=pkl6lIOnSy-poa9EzW43U0MkXhx2FDfAFh8pDXLpcTo,26630
 sourcecode/ast_extractor.py,sha256=FEsYTsMCXbJfSYQZRk1k-I-PjUNGnKqO1IxMftsgA5U,51351
 sourcecode/cache.py,sha256=1V3vsaODAa2UBJAC0xpvxpmRdriCezQx5Q8JCcfgziE,31892
 sourcecode/call_surface.py,sha256=fiqYfHooxN1fX9oQoysq1LS3LoZcobhyUNjAGEZKpwk,4148
 sourcecode/caller_metrics.py,sha256=HG8RCOkpzzsEGdnMRob6byrwjoj5__t0TEsBj4yR7ks,2574
-sourcecode/canonical_ir.py,sha256=U69m8Vkr0p407xF1q5y1KguHXWEAubYw8NFHR9hDNJk,29178
+sourcecode/canonical_ir.py,sha256=5hLAhhSpXNOdZAvPt-J-rXccJE6M3A6gVhmhU0Tym6Y,29269
 sourcecode/cir_graphs.py,sha256=9G0HHj1kw2325IDyzo2OpX73BNswEckecf4MZUXB4JM,12078
-sourcecode/classifier.py,sha256=RhLMDR031FAiUcT3bsf2EL3KrFwl7KsWh_wXXR_Bumo,18729
+sourcecode/classifier.py,sha256=9olDN5joeKHcwG9vf73X-t_son16hLVNib0rBbqk1vc,18865
 sourcecode/cli.py,sha256=46Chp0JsEWD_j0HUWOx4tOhrsXSWgWV8JhL5G8SyW4I,322078
 sourcecode/code_notes_analyzer.py,sha256=EJemNCNc9Dn-1RZYu-aNbK0ELzmsyC4s6FdHi3XyNEI,9392
 sourcecode/confidence_analyzer.py,sha256=_jckZSxksV-OU38vbkxfVNBnWCtlCq8Vwfg23x1uspA,19054
@@ -51,11 +51,12 @@ sourcecode/pr_impact.py,sha256=dCDVw83EDbyVf6F9ZmEQmsFz8ruVH7d4mpeKQCIZHM0,16805
 sourcecode/prepare_context.py,sha256=PYygAKL_jwz8gGElgM9mroUSih18UKSSjv08ndfl4aA,222877
 sourcecode/progress.py,sha256=qn30sWaHOkjTgXsSBmiPkz7Rsbwc5oSlIe6JNEMYp_k,3149
 sourcecode/ranking_engine.py,sha256=ZAucq_YX2KkWUuAZf4P0lhtQ_38vEFnUhuGtSZd1S0E,12970
+sourcecode/reconciliation.py,sha256=kW8PyB_R7J2Ig0N_QP9Jdm1fQXM1Ebf3PZbaTc80ULA,7941
 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=bG81ARrPBaPZoGqGT9bXviGCHZ27D7zGli8KShn9-cI,291158
+sourcecode/repository_ir.py,sha256=F6lRgPoP8oTtnGpRgjoLw-dlxZRXH7XOcehtcNwufEY,309550
 sourcecode/ris.py,sha256=aG2D4159gtpg968yD3PylYbIXhGFOwIlFBI0DSr84yY,20412
 sourcecode/runtime_classifier.py,sha256=uTAD6BDCiBLUZEDRfqk718kM4RTT_vAbfkcOI2_Xx58,18432
 sourcecode/scanner.py,sha256=WdOQ78mMzjR1NjmKTlbxdgwinnCTfAhxCVLBEFQiFHU,8899
@@ -63,18 +64,18 @@ sourcecode/schema.py,sha256=aHNXDf8LGyUC8ZDE_VS9kiskC2-Oswhi_WnpdGy6HDw,24897
 sourcecode/security_config.py,sha256=KblMEoRiEjrIE68YsPaUAFebxFp8UM7MS7lAk5CGD8U,3531
 sourcecode/security_posture.py,sha256=CAJw4oJD0aAW2yRewvd_fonkzi9_HpUjBZlIDZle00s,26034
 sourcecode/semantic_analyzer.py,sha256=bpgdC6m0_ftVtRf3rSdwhbhWjnZnGxRXaZVcfe4BbcQ,95414
-sourcecode/semantic_impact_engine.py,sha256=HpgjenY6DLPHPomP7Hw850zA-EBokf1S4O2sh8NegdI,20351
+sourcecode/semantic_impact_engine.py,sha256=t09IirGC3JjQDy33JZd1_WKzQVKXkoNl3-XEUr5kjis,20563
 sourcecode/semantic_integration_engine.py,sha256=rxoCuP-uM_Y4-ELeBN0sz1a88e2eI1XTJDgsS57IOLI,15513
-sourcecode/semantic_services.py,sha256=AO_p7PRfjc-AUh6ThvLMfm4iUGi0issL_frCf8sxGlI,10637
+sourcecode/semantic_services.py,sha256=nbUuPv-F01USTt_9CHT8iy_ucCIw3fz4W3Aquea_pd4,10782
 sourcecode/serializer.py,sha256=FmQo7eojA_z3ptLW-Vgze5mrEJ6FabcZqiwbQWWTgFI,130056
 sourcecode/spring_event_topology.py,sha256=5_ON_21Le5zbG-1GRc5GLIi5HJfy_QjcXLVPC5WeUGQ,18055
 sourcecode/spring_findings.py,sha256=EX7kLZLN74CFyR9iZPm3CI115BfFKNd4WRPuErNljZM,5729
-sourcecode/spring_impact.py,sha256=tjTxKAtmAvBqDVSSsC4ttCzbLaO55Wg4FJdOd_8MtO0,60077
+sourcecode/spring_impact.py,sha256=ayZtHZ2YCRSlZpKBACoM9M7tW0K1W_C0r8SGj3R-4vU,70603
 sourcecode/spring_model.py,sha256=zOAgFmrRbG4a6KLm1TJl55aWMyPNsz3OS3FSczqPG6A,16594
 sourcecode/spring_security_audit.py,sha256=Rk-aSohezdc7YDYbSoJquVnwpkDB8ty1BCD-4Hc4R5A,22832
 sourcecode/spring_semantic.py,sha256=jteQ1PkY9ArFJv0embg_jBIdbOxqrk9mQ2Xz8OF_FKA,14214
 sourcecode/spring_tx_analyzer.py,sha256=QMXkxa_hrqDVN3D8WJsd0nT7vfdZCT1E8ZWNoFFbvgU,34692
-sourcecode/summarizer.py,sha256=ByfFxIGVRrGrf3paQPuDOg1rVj78LyzXN_EXBkfbCLU,23582
+sourcecode/summarizer.py,sha256=BaBO0WKQi4fX2b2Xjip-GLEZwI3PYiV_U9jmBQlrfFI,25060
 sourcecode/tree_utils.py,sha256=8GAkIfQAsvtEudIeW1l4ooH_oRtrWR8cpJQJsEa_Pfw,2093
 sourcecode/type_usage_surface.py,sha256=51IrKRQoIoRnlsiDjHnqpJBn2rc6E59aRhgS0HTzAF0,4428
 sourcecode/validation_inference.py,sha256=UtmYv-d4TEzT1ihGEipAhtXDrwq0XtVtjMpb3i7NsNc,10815
@@ -90,7 +91,7 @@ sourcecode/detectors/elixir.py,sha256=jCpvt5Yi6jvplc80ovRtWh17q-11ZGo9qX7o8b57TJ
 sourcecode/detectors/go.py,sha256=2r66uRQfeTWsqxr4HDhT6vExZErby0t46QXLHVBRv9w,2782
 sourcecode/detectors/heuristic.py,sha256=7cRxrip4yIaggYzZJB6ef8yHKh-gHgiH_pXMFcjlyFU,3723
 sourcecode/detectors/hybrid.py,sha256=IGFRUVsAZ1ooRlFdznCeJAV6vy1yVDx-VyghvLtddXc,9101
-sourcecode/detectors/java.py,sha256=rTeVIKIliElE1yPdIkll1pKqDUzXD1EFFJdXxp24gr4,41005
+sourcecode/detectors/java.py,sha256=ut8czxGzhFUxRAS5LeG78wev8kJolC7LG8IESDJZTNk,42349
 sourcecode/detectors/jvm_ext.py,sha256=EgHJ5W8EE-ZTN9V607mVzohyKgZE8Mc2jCi-DF8RAZU,2616
 sourcecode/detectors/nodejs.py,sha256=Hg3Gmr7yIMJFiLoDwOTk2wtu00wxIs6kZf-oQujTFUA,13187
 sourcecode/detectors/parsers.py,sha256=ug9K31tyHqinmv0HkIVQVjdTZpBv67FYKAEf52YXOSM,3178
@@ -136,8 +137,8 @@ sourcecode/telemetry/consent.py,sha256=LIAO9ohJZF8OuZwM4u1VWtALlYfTCCKq4wV3Vwc7i
 sourcecode/telemetry/events.py,sha256=LtzYfaX9Ilckj5PTvAcTpDa9mLqDsYPDUiDkRa58piY,2580
 sourcecode/telemetry/filters.py,sha256=NHa5T-6DaZduQPFuC34jOqHWQgSizM-Ygq8aZ4j19ng,5834
 sourcecode/telemetry/transport.py,sha256=4gGHsq0WeY9VywEZXA3vUxykfiYnw9uuqfjAAec7F8o,1681
-sourcecode-2.5.2.dist-info/METADATA,sha256=cOmLhyx7sqYDB9m4eU6MkDuV4hfXzK68a2cUC_-N490,10851
-sourcecode-2.5.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-2.5.2.dist-info/entry_points.txt,sha256=-JEAdChrK5We51kZcb7OaDcyil-dHBjBPL-NhuO-QY8,89
-sourcecode-2.5.2.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-2.5.2.dist-info/RECORD,,
+sourcecode-2.5.4.dist-info/METADATA,sha256=vFyQq0a39iemrb04OqC6TwsnM_xA7j6PTBz_lbEccTM,10851
+sourcecode-2.5.4.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-2.5.4.dist-info/entry_points.txt,sha256=-JEAdChrK5We51kZcb7OaDcyil-dHBjBPL-NhuO-QY8,89
+sourcecode-2.5.4.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-2.5.4.dist-info/RECORD,,