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

sourcecode/__init__.py

@@ -4,4 +4,4 @@ ASK Engine is the product. ``ask`` is the canonical CLI command; ``sourcecode``
 the legacy compatibility alias and the Python/PyPI package name. See
 docs/PRODUCT_IDENTITY.md (normative)."""
 
-__version__ = "2.5.4"
+__version__ = "2.5.6"

sourcecode/architecture_analyzer.py

@@ -4,6 +4,12 @@ import re
 from pathlib import Path
 from typing import Literal, Optional
 
+from sourcecode.reconciliation import (
+    incoherent_layers,
+    pattern_contradicted,
+    unattested_layers,
+)
+
 from sourcecode.schema import (
     ArchitectureAnalysis,
     ArchitectureDomain,
@@ -39,11 +45,27 @@ _SRC_TRANSPARENT = {
     "src", "lib", "app", "pkg",
     "main", "java", "kotlin", "scala", "groovy",
 }
+
+# `src/main/java17/` is a MULTI-RELEASE source set, as transparent as `java/`
+# — JobRunr's minted a module called "java17".
+_VERSIONED_SRC_RE = re.compile(r"^(?:java|kotlin|scala)\d+$")
+
+
+def _is_transparent_segment(name: str) -> bool:
+    """A path segment that carries no architectural meaning of its own."""
+    low = name.lower()
+    return low in _SRC_TRANSPARENT or bool(_VERSIONED_SRC_RE.match(low))
 _CODE_EXTENSIONS = {
     ".py", ".js", ".ts", ".tsx", ".jsx", ".mjs", ".cjs",
     ".go", ".java", ".kt", ".rs", ".rb",
 }
-_GENERIC_NAMES = {"utils", "helpers", "common", "shared", "misc", "core", "root", ""}
+# Names that never identify a module: generic buckets, and the reverse-DNS
+# package roots every JVM repo starts its namespace with (JobRunr reported a
+# module called "org").
+_GENERIC_NAMES = {
+    "utils", "helpers", "common", "shared", "misc", "core", "root", "",
+    "org", "com", "io", "net",
+}
 
 _TEST_DIRS: frozenset[str] = frozenset({
     "tests", "test", "spec", "specs", "__tests__", "e2e",
@@ -139,8 +161,14 @@ LAYER_PATTERNS: dict[str, dict[str, list[str]]] = {
         "application":    ["application", "usecases", "usecase"],
         "infrastructure": ["infrastructure", "infra", "adapters", "persistence"],
     },
+    # P1-D residue (found by measurement, 2026-07-16): "core" belongs with
+    # "api"/"store"/"db" — it names a module's importance ("the main module"),
+    # never an onion/hexagonal DOMAIN layer, and nearly every large JVM repo has
+    # one. With it, keycloak's `core/` (623 Java files) + a
+    # `representations/adapters/config` package read "Onion Architecture with
+    # domain, adapters layers". Kept are the names that state their role.
     "onion": {
-        "domain":      ["domain", "core"],
+        "domain":      ["domain"],
         "application": ["application", "usecases"],
         "ports":       ["ports", "interfaces"],
         "adapters":    ["adapters", "secondary"],
@@ -173,7 +201,7 @@ LAYER_PATTERNS: dict[str, dict[str, list[str]]] = {
     "hexagonal": {
         "port":    ["port", "ports", "interface", "interfaces"],
         "adapter": ["adapter", "adapters"],
-        "domain":  ["domain", "core", "model", "models"],
+        "domain":  ["domain", "model", "models"],  # "core" dropped — see onion
     },
     "monorepo": {
         "apps":     ["apps", "applications"],
@@ -196,6 +224,13 @@ LAYER_PATTERNS: dict[str, dict[str, list[str]]] = {
 # it; without it the pattern falls through to layered / a weaker match.
 _PATTERN_REQUIRED_KEYS: dict[str, frozenset[str]] = {
     "mvc": frozenset({"view"}),
+    # Same principle as MVC/view — a pattern must show its DEFINING trait, not
+    # just any two of its layers. Hexagonal is literally "Ports and Adapters":
+    # a `models/` package next to an `adapters/` package is not one, and that
+    # pair alone was enough to label keycloak "Hexagonal Architecture". Onion's
+    # defining trait is the domain at the centre.
+    "hexagonal": frozenset({"port", "adapter"}),
+    "onion": frozenset({"domain"}),
 }
 
 # Minimum share of source files a matched layer must hold to count as a LAYER
@@ -646,6 +681,28 @@ class ArchitectureAnalyzer:
                     continue
                 matched[layer_key] = matched_dirs
                 layer_files[layer_key] = files
+
+            # SIM-3: a layer must belong to the same PROGRAM as the rest of the
+            # claim. Directory names are language-blind, so on a polyglot
+            # monorepo one pattern was assembled across two subsystems: keycloak
+            # read "MVC with controller, model, view layers" where `view` was a
+            # React SPA (87 .tsx, zero Java) sitting beside a 1088-file Java
+            # `model`. Mass cannot catch this — the SPA has genuine mass. The
+            # reconciliation rule drops layers owned by a different runtime;
+            # template/asset-only layers are untouched, so a real Spring-MVC
+            # `templates/` view survives.
+            _layer_paths = {k: [source_paths[i] for i in v] for k, v in layer_files.items()}
+            for _bad in incoherent_layers(pattern_name, _layer_paths, source_paths):
+                matched.pop(_bad, None)
+                layer_files.pop(_bad, None)
+
+            # A claim that IS a runtime split must show one: JobRunr, a JVM
+            # library, read "Fullstack with frontend, backend layers" off a
+            # `dashboard/ui/model/` package of 16 Java files. Nothing to prune —
+            # the pattern itself is what the evidence contradicts.
+            if pattern_contradicted(pattern_name, _layer_paths, source_paths):
+                continue
+
             # A pattern with unmet required keys cannot qualify (e.g. mvc needs a view).
             required = _PATTERN_REQUIRED_KEYS.get(pattern_name)
             if required and not required.issubset(matched.keys()):
@@ -809,6 +866,14 @@ class ArchitectureAnalyzer:
             k: v for k, v in layer_files.items()
             if v and (not total or len(v) / total >= _LAYER_MIN_SHARE)
         }
+        # P1-D residue: these stem patterns are Python-shaped (cli.py,
+        # *_analyzer.py, config.py). On a Java repo almost nothing matches, so
+        # the few stray hits are not a layering — petclinic's "Layered
+        # Architecture with orchestration, data layers" rested on ONE directory
+        # entry plus a settings.gradle, with 47 Java files visible and ignored.
+        # A logical code layer that holds no code of this repo is not one.
+        for _bad in unattested_layers(non_empty, paths):
+            non_empty.pop(_bad, None)
         if len(non_empty) >= 2:
             return "layered", [
                 ArchitectureLayer(name=k, pattern="layered", files=v, confidence="low")
@@ -828,13 +893,19 @@ class ArchitectureAnalyzer:
         for p in paths:
             parts = p.replace("\\", "/").split("/")
             for part in parts[:-1]:
-                if (part not in _SRC_TRANSPARENT
+                if (not _is_transparent_segment(part)
                         and part.lower() not in _NON_SOURCE_DIRS
                         and part.lower() not in _GENERIC_NAMES):
                     module_files.setdefault(part, []).append(p)
                     break
 
         meaningful = {k: v for k, v in module_files.items() if len(v) >= 3}
+        # P1-D residue: a MODULE of this repo must hold this repo's code. File
+        # count alone let build and asset directories be reported as modules —
+        # ofbiz "docker, framework, runtime, gradle", neo4j "packaging",
+        # eureka "images" (five PNGs). The real modules survive untouched.
+        for _bad in unattested_layers(meaningful, paths):
+            meaningful.pop(_bad, None)
         if len(meaningful) >= 2:
             return "modular", [
                 ArchitectureLayer(name=k, pattern="modular", files=v, confidence="low")

sourcecode/reconciliation.py

@@ -34,12 +34,21 @@ Rule registry (extraction):
         declarations the regex extractor cannot bind, e.g. `public class\n
         Name` split across lines, Unicode type identifiers).
 
+Rule registry (architecture):
+    layer_language_coherence — a directory-name-matched layer holds NO file in
+        the runtime that carries the rest of the claimed pattern, while being
+        owned by a DIFFERENT runtime. The layer table and the file-language
+        census are contradicting each other: the "architecture" spans two
+        subsystems (SIM-3: keycloak's "MVC … view layer" was a React SPA, zero
+        Java files, sitting beside a 1088-file Java model).
+
 Never raises. Empty evidence → no findings.
 """
 from __future__ import annotations
 
 import re
 from dataclasses import dataclass
+from pathlib import Path
 
 
 @dataclass(frozen=True)
@@ -182,6 +191,253 @@ def _rule_parse_coverage(
     ]
 
 
+# ---------------------------------------------------------------------------
+# Architecture reconciliation (layer table × file-language census)
+# ---------------------------------------------------------------------------
+
+# Source extension → RUNTIME FAMILY. Grouping by runtime, not by extension, is
+# what makes the rule correct: a Kotlin `view/` beside Java `model/` is ONE
+# system (same runtime, direct interop) and must not be called a contradiction,
+# while a TypeScript `view/` beside them is a separate program. Extensions
+# absent here (.html/.ftl/.jsp/.css/.xml …) are deliberately unmapped: a
+# template or asset carries no runtime of its own, so it can never contradict a
+# claim — that carve-out is what keeps a genuine Spring-MVC `templates/` view
+# layer intact.
+_RUNTIME_FAMILY: dict[str, str] = {
+    ".java": "jvm", ".kt": "jvm", ".kts": "jvm", ".scala": "jvm", ".groovy": "jvm",
+    ".js": "js", ".jsx": "js", ".ts": "js", ".tsx": "js", ".mjs": "js", ".cjs": "js",
+    ".py": "python",
+    ".go": "go",
+    ".rs": "rust",
+    ".rb": "ruby",
+    ".cs": "dotnet",
+    ".php": "php",
+    ".swift": "swift",
+}
+
+# Patterns that describe REPO COMPOSITION rather than one program's internal
+# architecture — their layers are SUPPOSED to span runtimes, so the coherence
+# rule must never fire on them. (mvc/layered/onion/hexagonal/clean are claims
+# about a single program and must hold together in one runtime.)
+_CROSS_RUNTIME_PATTERNS: frozenset[str] = frozenset({
+    "fullstack", "microservices", "monorepo",
+})
+
+# Patterns whose meaning IS the runtime split — a "fullstack" repo names a
+# frontend TIER and a backend TIER. If every layer runs on the same runtime
+# there is no split, and the claim is a directory-name coincidence: JobRunr, a
+# JVM library, read "Fullstack with frontend, backend layers" off a
+# `dashboard/ui/model/` package holding 16 JAVA files. (Not monorepo or
+# microservices: an all-TypeScript monorepo, or same-runtime services, are
+# perfectly real.)
+_SPLIT_REQUIRED_PATTERNS: frozenset[str] = frozenset({"fullstack"})
+
+
+def runtime_census(layer_files: dict[str, list[str]]) -> dict[str, dict[str, int]]:
+    """{layer -> {runtime_family -> file count}} — the language evidence view.
+
+    Files whose extension carries no runtime (templates, assets, config) are
+    simply absent from the census; a layer made only of them yields {}.
+    """
+    out: dict[str, dict[str, int]] = {}
+    for layer, files in layer_files.items():
+        counts: dict[str, int] = {}
+        for f in files:
+            fam = _RUNTIME_FAMILY.get(Path(str(f)).suffix.lower())
+            if fam:
+                counts[fam] = counts.get(fam, 0) + 1
+        out[layer] = counts
+    return out
+
+
+def _rule_layer_language_coherence(
+    pattern: str,
+    census: dict[str, dict[str, int]],
+    repo_runtimes: dict[str, int],
+) -> list[ReconciliationFinding]:
+    """A claimed layer is owned by a different runtime than the repo it describes.
+
+    The dominant runtime is taken from the WHOLE repo, not from the matched
+    layers: which directories happen to match a keyword table is exactly the
+    thing under suspicion, so it cannot also be the arbiter. (Measured: on a
+    Java backend beside a React SPA, layer-local dominance can invert — the SPA
+    out-matches the backend's one matched layer and the JAVA layer gets flagged.)
+
+    A layer is INCOHERENT iff it holds ZERO files of the repo's runtime AND at
+    least one file of another — it is a different program, not a facet of this
+    one. A layer with no runtime files at all (templates, assets) is never
+    flagged: it does not contradict, it just does not attest.
+
+    Silent for cross-runtime patterns, whose layers are meant to span runtimes.
+    """
+    if pattern in _CROSS_RUNTIME_PATTERNS or len(census) < 2:
+        return []
+    if len(repo_runtimes) < 2:
+        return []  # single-runtime repo — nothing to contradict
+
+    dominant = max(sorted(repo_runtimes), key=lambda f: repo_runtimes[f])
+
+    incoherent = sorted(
+        layer for layer, counts in census.items()
+        if not counts.get(dominant) and any(counts.values())
+    )
+    if not incoherent:
+        return []
+    return [
+        ReconciliationFinding(
+            rule="layer_language_coherence",
+            symbols=tuple(incoherent),
+            detail=(
+                f"{len(incoherent)} layer(s) of the '{pattern}' claim hold no "
+                f"{dominant} file while the rest of the pattern is {dominant} — "
+                "the claim spans two separate programs, so it does not describe "
+                "one architecture."
+            ),
+        )
+    ]
+
+
+def _rule_layer_code_attestation(
+    census: dict[str, dict[str, int]],
+    repo_runtimes: dict[str, int],
+) -> list[ReconciliationFinding]:
+    """A claimed code module holds no code of the repo's runtime.
+
+    Stricter sibling of `layer_language_coherence`, for claims whose layers are
+    modules or logical code layers — their whole role is to hold code, so a
+    directory with none is not one of them. (`layer_language_coherence` cannot
+    serve here: it deliberately ignores layers with no runtime files at all, so
+    that a real Spring-MVC `templates/` view survives. A view may be templates;
+    a MODULE may not.)
+
+    Measured on the field-test repos: ofbiz's "modular architecture" listed
+    `docker`, `gradle`, `runtime` and `themes` (shell scripts, wrapper jars, a
+    .gitignore, images — zero Java); neo4j listed `packaging`; eureka listed
+    `images` (five PNGs); petclinic's whole "Layered Architecture with
+    orchestration, data layers" rested on one directory entry and a
+    settings.gradle.
+    """
+    if not repo_runtimes:
+        return []
+    dominant = max(sorted(repo_runtimes), key=lambda f: repo_runtimes[f])
+    unattested = sorted(
+        layer for layer, counts in census.items() if not counts.get(dominant)
+    )
+    if not unattested:
+        return []
+    return [
+        ReconciliationFinding(
+            rule="layer_code_attestation",
+            symbols=tuple(unattested),
+            detail=(
+                f"{len(unattested)} claimed layer(s) hold no {dominant} code — "
+                "a directory without the repo's code is not a module of it."
+            ),
+        )
+    ]
+
+
+def _rule_composition_runtime_split(
+    pattern: str,
+    census: dict[str, dict[str, int]],
+) -> list[ReconciliationFinding]:
+    """A pattern that names a runtime split shows none.
+
+    The mirror image of `layer_language_coherence`: a claim about one program
+    must NOT span runtimes; a claim that IS the split must show it. Silent
+    unless the pattern's layers carry runtime evidence at all.
+    """
+    if pattern not in _SPLIT_REQUIRED_PATTERNS or len(census) < 2:
+        return []
+    families = {fam for counts in census.values() for fam in counts}
+    if len(families) != 1:
+        return []  # a real split, or no runtime evidence to judge
+    only = next(iter(families))
+    return [
+        ReconciliationFinding(
+            rule="composition_runtime_split",
+            symbols=tuple(sorted(census)),
+            detail=(
+                f"the '{pattern}' claim names a runtime split but every layer is "
+                f"{only} — the layer names are a coincidence, not two tiers."
+            ),
+        )
+    ]
+
+
+def unattested_layers(
+    layer_files: dict[str, list[str]], repo_files: "list[str]"
+) -> frozenset[str]:
+    """Layers holding no code of the repo's runtime (convenience view).
+
+    For consumers claiming code modules / logical code layers. Never raises.
+    """
+    try:
+        repo_runtimes = runtime_census({"_repo": list(repo_files)})["_repo"]
+        out: set[str] = set()
+        for f in _rule_layer_code_attestation(runtime_census(layer_files), repo_runtimes):
+            out.update(f.symbols)
+        return frozenset(out)
+    except Exception:
+        return frozenset()
+
+
+def reconcile_architecture_evidence(
+    *,
+    pattern: str,
+    layer_files: dict[str, list[str]],
+    repo_files: "list[str]",
+) -> list[ReconciliationFinding]:
+    """Run architecture reconciliation rules. Never raises.
+
+    Args:
+        pattern:     candidate pattern name (e.g. "mvc").
+        layer_files: {layer -> files matched for that layer}.
+        repo_files:  every source file considered — supplies the repo's own
+                     runtime, the arbiter of which layers belong to the claim.
+    """
+    findings: list[ReconciliationFinding] = []
+    try:
+        census = runtime_census(layer_files)
+        repo_runtimes = runtime_census({"_repo": list(repo_files)})["_repo"]
+        findings.extend(
+            _rule_layer_language_coherence(pattern, census, repo_runtimes)
+        )
+        findings.extend(_rule_composition_runtime_split(pattern, census))
+    except Exception:
+        pass
+    return findings
+
+
+def pattern_contradicted(
+    pattern: str, layer_files: dict[str, list[str]], repo_files: "list[str]"
+) -> bool:
+    """True when a rule rejects the PATTERN itself, not just some of its layers.
+
+    `incoherent_layers` prunes layers and lets the pattern re-qualify on what
+    is left; a split-less "fullstack" has nothing to re-qualify with — the
+    claim as a whole is the thing contradicted.
+    """
+    return any(
+        f.rule == "composition_runtime_split"
+        for f in reconcile_architecture_evidence(
+            pattern=pattern, layer_files=layer_files, repo_files=repo_files
+        )
+    )
+
+
+def incoherent_layers(
+    pattern: str, layer_files: dict[str, list[str]], repo_files: "list[str]"
+) -> frozenset[str]:
+    """Layer names the coherence rule rejects for `pattern` (convenience view)."""
+    out: set[str] = set()
+    for f in reconcile_architecture_evidence(
+        pattern=pattern, layer_files=layer_files, repo_files=repo_files
+    ):
+        out.update(f.symbols)
+    return frozenset(out)
+
+
 def reconcile_extraction_evidence(
     *,
     type_decl_files: frozenset[str],

sourcecode/summarizer.py

@@ -8,7 +8,8 @@ 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.architecture_analyzer import _LAYER_MIN_SHARE, _PATTERN_REQUIRED_KEYS
+from sourcecode.reconciliation import incoherent_layers, pattern_contradicted
 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
@@ -62,7 +63,9 @@ _ARCH_LAYER_PATTERNS: dict[str, dict[str, list[str]]] = {
     "hexagonal": {
         "port": ["ports", "interfaces"],
         "adapter": ["adapters"],
-        "domain": ["domain", "core", "models"],
+        # P1-D residue: "core" names a module's importance, not a domain layer
+        # (keycloak `core/` = 623 Java files). Keep in step with the analyzer.
+        "domain": ["domain", "models"],
     },
     "fullstack": {
         "frontend": ["frontend", "client", "web", "ui", "pages", "components"],
@@ -415,16 +418,35 @@ class ProjectSummarizer:
                 dir_files.setdefault(seg.lower(), set()).add(i)
         total = len(file_paths)
 
-        def _has_mass(keywords: list[str]) -> bool:
+        def _layer_paths(keywords: list[str]) -> list[str]:
             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)
+            if not files or (total and len(files) / total < _LAYER_MIN_SHARE):
+                return []
+            return [file_paths[i] for i in sorted(files)]
 
         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 _has_mass(keywords))
+            layer_files: dict[str, list[str]] = {}
+            for layer, keywords in layer_keys.items():
+                paths = _layer_paths(keywords)
+                if paths:
+                    layer_files[layer] = paths
+            # SIM-3: same coherence rule the architecture prose applies — this
+            # table is the headline's copy, and a fix applied to only one of the
+            # two duplicated tables leaves the other one lying.
+            for _bad in incoherent_layers(pattern_name, layer_files, file_paths):
+                layer_files.pop(_bad, None)
+            if pattern_contradicted(pattern_name, layer_files, file_paths):
+                continue
+            # A pattern must show its defining trait here too, or the headline
+            # contradicts the architecture prose that already enforces this.
+            required = _PATTERN_REQUIRED_KEYS.get(pattern_name)
+            if required and not required.issubset(layer_files.keys()):
+                continue
+            score = len(layer_files)
             if score > best_score:
                 best_score = score
                 best_pattern = pattern_name

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 2.5.4
+Version: 2.5.6
 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.4.dist-info → sourcecode-2.5.6.dist-info}/RECORD

@@ -1,7 +1,7 @@
-sourcecode/__init__.py,sha256=XumauaLNdzXEwNGsJupjZthcLY2Qo8ud3CgsBguv8-o,308
+sourcecode/__init__.py,sha256=vjtgJnZwnfESbFdca_Oeq9DtPkuQkSn7b-N3LsiDp78,308
 sourcecode/adaptive_scanner.py,sha256=XffluXKzJUXrMtjEiAOnSNPZnztdIcts17T9ouHeID0,10521
 sourcecode/archetype.py,sha256=d7yoN6Tj4OBj-VgSMPEKg4WF9H8FypnZ5A6AkUh5oIE,34484
-sourcecode/architecture_analyzer.py,sha256=CoxlEDWn1axufjIT4fpNHd_2HNUKgqBClq9z9k6jp4M,51684
+sourcecode/architecture_analyzer.py,sha256=1CEIeFtuxdzeFaeUtA5QuDmFkb5eilUK8zRmk9tcDxc,55644
 sourcecode/architecture_summary.py,sha256=pkl6lIOnSy-poa9EzW43U0MkXhx2FDfAFh8pDXLpcTo,26630
 sourcecode/ast_extractor.py,sha256=FEsYTsMCXbJfSYQZRk1k-I-PjUNGnKqO1IxMftsgA5U,51351
 sourcecode/cache.py,sha256=1V3vsaODAa2UBJAC0xpvxpmRdriCezQx5Q8JCcfgziE,31892
@@ -51,7 +51,7 @@ 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/reconciliation.py,sha256=j3PctM_9FlaAV_OQ5_LjNhuZCehJ-XIwLo_iQbRQKTo,18335
 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
@@ -75,7 +75,7 @@ sourcecode/spring_model.py,sha256=zOAgFmrRbG4a6KLm1TJl55aWMyPNsz3OS3FSczqPG6A,16
 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=BaBO0WKQi4fX2b2Xjip-GLEZwI3PYiV_U9jmBQlrfFI,25060
+sourcecode/summarizer.py,sha256=E70QILQ8cCNIH485c7lVMv5dXOpUn8qx1habi1_cn6o,26340
 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
@@ -137,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.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,,
+sourcecode-2.5.6.dist-info/METADATA,sha256=MW8dYaMUIriCSIBFCDunGYxcxAK0p_0WF1fQHY4jidE,10851
+sourcecode-2.5.6.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-2.5.6.dist-info/entry_points.txt,sha256=-JEAdChrK5We51kZcb7OaDcyil-dHBjBPL-NhuO-QY8,89
+sourcecode-2.5.6.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-2.5.6.dist-info/RECORD,,