sourcecode 2.5.4__py3-none-any.whl → 2.5.5__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.5"

sourcecode/architecture_analyzer.py

@@ -4,6 +4,8 @@ import re
 from pathlib import Path
 from typing import Literal, Optional
 
+from sourcecode.reconciliation import incoherent_layers
+
 from sourcecode.schema import (
     ArchitectureAnalysis,
     ArchitectureDomain,
@@ -139,8 +141,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 +181,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 +204,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 +661,24 @@ 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.
+            for _bad in incoherent_layers(
+                pattern_name,
+                {k: [source_paths[i] for i in v] for k, v in layer_files.items()},
+                source_paths,
+            ):
+                matched.pop(_bad, None)
+                layer_files.pop(_bad, None)
+
             # 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()):

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,142 @@ 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",
+})
+
+
+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 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:
+        repo_runtimes = runtime_census({"_repo": list(repo_files)})["_repo"]
+        findings.extend(
+            _rule_layer_language_coherence(
+                pattern, runtime_census(layer_files), repo_runtimes
+            )
+        )
+    except Exception:
+        pass
+    return findings
+
+
+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
 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,33 @@ 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)
+            # 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.5.dist-info}/METADATA

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

@@ -1,7 +1,7 @@
-sourcecode/__init__.py,sha256=XumauaLNdzXEwNGsJupjZthcLY2Qo8ud3CgsBguv8-o,308
+sourcecode/__init__.py,sha256=RsMXFkrSEd5UuAhMfPgfXfYvqM0A43vYcSfn086K17s,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=vQQzcvmniq4go4bWNB2Xm5HlyIoW65cU7ktJqHIfDpU,53614
 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=L4r_k6c768yq4GSzSOsJHxot2y8bHREA6up68CUkzo4,13853
 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=4IPhFg3Anrqa9U17i_bBKq70Q7eVefsCEK3idFC4VsY,26217
 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.5.dist-info/METADATA,sha256=jTeYMssrsUEZUxEVu8WAQq0ihp7c8FtWCT27m2eNeXo,10851
+sourcecode-2.5.5.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-2.5.5.dist-info/entry_points.txt,sha256=-JEAdChrK5We51kZcb7OaDcyil-dHBjBPL-NhuO-QY8,89
+sourcecode-2.5.5.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-2.5.5.dist-info/RECORD,,