sourcecode 2.5.15__py3-none-any.whl → 2.5.17__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.15"
+__version__ = "2.5.17"

sourcecode/adaptive_scanner.py

@@ -14,12 +14,18 @@ interface, same output format (None = file, dict = directory).
 
 import os
 from pathlib import Path
-from typing import Any, Optional, cast
+from typing import Any, Optional
 
 from pathspec import GitIgnoreSpec
 
 from sourcecode.repo_classifier import RepoTopology
-from sourcecode.scanner import DEFAULT_EXCLUDES, EXCLUDED_FILE_SUFFIXES, MANIFEST_NAMES
+from sourcecode.scanner import (
+    DEFAULT_EXCLUDES,
+    EXCLUDED_FILE_SUFFIXES,
+    find_manifest_paths,
+    get_or_create_tree_node,
+    match_gitignore,
+)
 
 
 class AdaptiveScanner:
@@ -100,9 +106,7 @@ class AdaptiveScanner:
         return self._gitignore_spec
 
     def _is_excluded_by_gitignore(self, rel_path: str, is_dir: bool) -> bool:
-        spec = self._load_gitignore_spec()
-        path_to_match = rel_path + "/" if is_dir else rel_path
-        return spec.match_file(path_to_match)
+        return match_gitignore(self._load_gitignore_spec(), rel_path, is_dir)
 
     # ------------------------------------------------------------------
     # Depth budget computation — the core of adaptive traversal
@@ -224,40 +228,12 @@ class AdaptiveScanner:
     def _get_or_create_node(
         self, tree: dict[str, Any], parts: tuple[str, ...]
     ) -> dict[str, Any]:
-        node = tree
-        for part in parts:
-            if part not in node or node[part] is None:
-                node[part] = {}
-            node = cast(dict[str, Any], node[part])
-        return node
+        return get_or_create_tree_node(tree, parts)
 
     # ------------------------------------------------------------------
     # Manifest discovery — same interface as FileScanner
     # ------------------------------------------------------------------
 
     def find_manifests(self) -> list[str]:
-        """Find manifest files at depth 0-1.
-
-        Identical logic to FileScanner.find_manifests() — depth-0 root
-        manifests plus depth-1 sub-package manifests, hidden dirs excluded.
-        """
-        manifests: list[str] = []
-        for name in MANIFEST_NAMES:
-            candidate = self.root / name
-            if candidate.exists() and not candidate.is_symlink():
-                manifests.append(str(candidate))
-        try:
-            for child in self.root.iterdir():
-                if (
-                    child.is_dir()
-                    and not child.is_symlink()
-                    and child.name not in self._excludes
-                    and not child.name.startswith(".")
-                ):
-                    for name in MANIFEST_NAMES:
-                        candidate = child / name
-                        if candidate.exists() and not candidate.is_symlink():
-                            manifests.append(str(candidate))
-        except PermissionError:
-            pass
-        return manifests
+        """Find manifest files at depth 0-1 (delegates to the shared helper)."""
+        return find_manifest_paths(self.root, self._excludes)

sourcecode/ast_extractor.py

@@ -176,18 +176,10 @@ def _find_child(node: Any, *types: str) -> Optional[Any]:
     return None
 
 
-def _find_all(node: Any, *types: str) -> list[Any]:
-    return [child for child in node.children if child.type in types]
-
-
 def _text(node: Any, src: bytes) -> str:
     return src[node.start_byte:node.end_byte].decode("utf-8", errors="replace")
 
 
-def _named_children(node: Any) -> list[Any]:
-    return [c for c in node.children if c.is_named]
-
-
 # ---------------------------------------------------------------------------
 # Tree-sitter TS/JS extraction
 # ---------------------------------------------------------------------------
@@ -967,25 +959,26 @@ def _java_contract_from_graph(rel_path: str, graph: "Any") -> FileContract:
     nodes/edges instead of re-parsing source. Method signatures are the graph's
     canonical compact form (`(Type)->Return`); annotations are node-grounded.
     """
-    file_syms = [s for s in graph.symbols() if s.source_file == rel_path]
+    file_syms = graph.symbols_in_file(rel_path)
     type_syms = [s for s in file_syms if s.kind in ("class", "interface", "enum", "annotation")]
     type_fqns = {s.fqn for s in type_syms}
 
     # extends / implements edges out of this file's types (targets are simple
     # names for out-of-repo supertypes, resolved FQNs for in-repo ones — the
-    # same forms the old regex captured for the unresolved case).
+    # same forms the old regex captured for the unresolved case). Only edges
+    # sourced at this file's types matter, so index straight to them instead of
+    # scanning the whole-repo relation set once per file.
     extends_of: dict[str, list[str]] = {}
     implements_of: dict[str, list[str]] = {}
     import_targets: set[str] = set()
-    for r in graph.relations():
-        if r.source not in type_fqns:
-            continue
-        if r.kind == "extends":
-            extends_of.setdefault(r.source, []).append(r.target)
-        elif r.kind == "implements":
-            implements_of.setdefault(r.source, []).append(r.target)
-        elif r.kind == "imports":
-            import_targets.add(r.target)
+    for fqn in type_fqns:
+        for r in graph.relations_from(fqn):
+            if r.kind == "extends":
+                extends_of.setdefault(r.source, []).append(r.target)
+            elif r.kind == "implements":
+                implements_of.setdefault(r.source, []).append(r.target)
+            elif r.kind == "imports":
+                import_targets.add(r.target)
 
     exports: list[ExportRecord] = []
     types: list[TypeDefinition] = []

sourcecode/cli.py

@@ -15,6 +15,7 @@ from sourcecode import __version__
 from sourcecode.error_schema import INVALID_INPUT_CODE, build_error_envelope
 from sourcecode.entrypoint_classifier import is_production_entry_point, normalize_entry_point
 from sourcecode.progress import Progress
+from sourcecode import perf
 from sourcecode.caller_metrics import CALLER_METRIC_RECONCILIATION
 from sourcecode.repository_ir import extract_java_endpoints as _extract_java_endpoints
 
@@ -1703,6 +1704,7 @@ def main(
     _progress = Progress()
     _progress.start("scanning files")
 
+    _perf_discovery = perf.start()
     scanner = AdaptiveScanner(target, topology=_topology, base_depth=effective_depth,
                                extra_excludes=_extra_excludes)
     raw_tree = scanner.scan_tree()
@@ -1710,6 +1712,8 @@ def main(
     _progress.update("parsing manifests")
     # 2. Filter .env and *.secret entries from file tree (SEC-02, all levels)
     file_tree = filter_sensitive_files(raw_tree, redactor)
+    perf.stop("discovery", _perf_discovery)
+    _perf_detection = perf.start()
     detector = ProjectDetector(build_default_detectors())
     workspace_analysis = WorkspaceAnalyzer().analyze(target, manifests)
 
@@ -1951,6 +1955,8 @@ def main(
         else None
     )
 
+    perf.stop("detection", _perf_detection)
+    _perf_analysis = perf.start()
     # 3. Build schema
     # Compute analyzer fingerprints: short hashes of each analyzer's key rule
     # constants so that a rule change is always visible in the output, regardless
@@ -2411,8 +2417,10 @@ def main(
                     err=True,
                 )
 
+    perf.stop("analysis", _perf_analysis)
     # 4. Serialize
     _progress.update("serializing output")
+    _perf_serialize = perf.start()
     if _is_contract_mode and not agent:
         from sourcecode.serializer import contract_view as _contract_view
         _depth = _CONTRACT_DEPTH.get(mode, "minimal")
@@ -2455,6 +2463,9 @@ def main(
             raw_dict = redact_dict(raw_dict)
         content = _serialize_dict(raw_dict, format)
 
+    perf.stop("serialize", _perf_serialize)
+    perf.flush_recorder()
+
     # 5. Telemetry (fire-and-forget, never blocks)
     try:
         from sourcecode import telemetry as _tel

sourcecode/context_graph.py

@@ -408,6 +408,7 @@ class ContextGraph:
         "_cir", "_nodes_by_fqn", "_nodes", "_build_ms",
         "_body_index", "_literal_index", "_guard_index", "_span_index",
         "_class_type_index", "_relations_all", "_symbols_sorted",
+        "_symbols_by_file", "_relations_by_source",
     )
 
     def __init__(self, cir: CanonicalRepositoryIR, *, build_ms: float = 0.0) -> None:
@@ -439,6 +440,12 @@ class ContextGraph:
         # filtered cheaply thereafter.
         self._relations_all: Optional[tuple[Relation, ...]] = None
         self._symbols_sorted: Optional[tuple[Symbol, ...]] = None
+        # Per-key groupings for per-file consumers (`_java_contract_from_graph`
+        # runs once per file). Without these, each file filtered the whole-repo
+        # symbol/relation set — the residual O(files × total) scan that the
+        # memoized projections above did not remove. Built once, O(1) lookup.
+        self._symbols_by_file: Optional[dict[str, list[Symbol]]] = None
+        self._relations_by_source: Optional[dict[str, list[Relation]]] = None
 
     # -- construction -------------------------------------------------------
 
@@ -518,6 +525,34 @@ class ContextGraph:
             and (name_contains is None or name_contains in s.fqn)
         ]
 
+    def symbols_in_file(self, source_file: str) -> list[Symbol]:
+        """All symbols declared in one file, FQN-sorted — the same order and set
+        a no-filter ``symbols()`` scan filtered to this file would produce, but
+        O(1) after a one-time O(total) grouping instead of O(total) per call.
+        """
+        if self._symbols_by_file is None:
+            if self._symbols_sorted is None:
+                self._symbols_sorted = tuple(sorted(self._nodes, key=lambda s: s.fqn))
+            idx: dict[str, list[Symbol]] = {}
+            for s in self._symbols_sorted:
+                idx.setdefault(s.source_file, []).append(s)
+            self._symbols_by_file = idx
+        return self._symbols_by_file.get(source_file, [])
+
+    def relations_from(self, source_fqn: str) -> list[Relation]:
+        """All relations whose source is ``source_fqn``, in the IR's stable edge
+        order. O(1) after a one-time O(edges) grouping — replaces per-file scans
+        of the whole relation set.
+        """
+        if self._relations_by_source is None:
+            if self._relations_all is None:
+                self._relations_all = tuple(_edge_to_relation(e) for e in self._cir.call_graph)
+            idx: dict[str, list[Relation]] = {}
+            for r in self._relations_all:
+                idx.setdefault(r.source, []).append(r)
+            self._relations_by_source = idx
+        return self._relations_by_source.get(source_fqn, [])
+
     def types(self) -> list[Symbol]:
         """All class/interface/enum/annotation symbols, sorted by FQN."""
         return sorted(

sourcecode/coverage_parser.py

@@ -39,20 +39,6 @@ def _safe_int(value: Optional[str]) -> Optional[int]:
         return None
 
 
-def _decode_numbits(blob: bytes) -> list[int]:
-    """Decodifica bitset little-endian de coverage.py .coverage SQLite.
-
-    Byte i, bit j set => linea (i*8 + j + 1) ejecutada.
-    Ejemplo: bytes([0b00000101]) => [1, 3]
-    """
-    return [
-        i * 8 + j + 1
-        for i, byte in enumerate(blob)
-        for j in range(8)
-        if byte & (1 << j)
-    ]
-
-
 # ---------------------------------------------------------------------------
 # CoverageParser
 # ---------------------------------------------------------------------------

sourcecode/env_analyzer.py

@@ -534,8 +534,3 @@ class EnvAnalyzer:
 def _replace_description(record, description: str):
     from dataclasses import replace
     return replace(record, description=description)
-
-
-def _replace_required(record, required: bool, default: Optional[str]):
-    from dataclasses import replace
-    return replace(record, required=required, default=default if not record.default else record.default)

sourcecode/perf.py

@@ -0,0 +1,268 @@
+"""Performance instrumentation and baseline schema — see ADR-0006.
+
+Two responsibilities, kept separate:
+
+* An **in-process recorder** that times the frozen phase taxonomy (§3). It is
+  *zero-cost when disabled* (ADR-0006 §5.5): with ``SOURCECODE_PERF`` unset,
+  :func:`span` yields without reading a clock, allocating a span, or writing a
+  dict. A production ``ask`` invocation pays nothing for the harness existing.
+
+* **Pure functions** — percentiles and the ``perf-baseline-v1`` cell builder —
+  that the fleet harness (``scripts/perf_harness.py``) uses to turn a set of raw
+  per-run measurements into one frozen-schema artifact.
+
+The phase taxonomy and the output schema are the frozen contract; this module is
+the replaceable collector.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import platform
+import socket
+import sys
+import time
+from contextlib import contextmanager
+from datetime import datetime, timezone
+from typing import Iterator, Mapping, Sequence
+
+# ── Frozen contract constants (ADR-0006) ────────────────────────────────────
+
+SCHEMA_VERSION = "perf-baseline-v1"
+
+#: The frozen phase taxonomy. Order is contractual — see ADR-0006 §3.
+#: These are the pipeline's *measured* contiguous seams, not compiler-shaped
+#: guesses: repo discovery, what-is-this-repo detection+enrichment, model
+#: assembly + semantic/contract extraction, and output rendering.
+PHASES: tuple[str, ...] = ("discovery", "detection", "analysis", "serialize")
+
+#: Env var that arms the in-process recorder.
+ENV_ENABLE = "SOURCECODE_PERF"
+#: Env var naming the JSONL file the recorder appends its phase timings to.
+ENV_LOG = "SOURCECODE_PERF_LOG"
+
+
+# ── In-process recorder (zero-cost when disabled) ───────────────────────────
+
+
+class _Recorder:
+    """Accumulates elapsed milliseconds per named phase for one process."""
+
+    __slots__ = ("_spans",)
+
+    def __init__(self) -> None:
+        self._spans: dict[str, float] = {}
+
+    def add(self, name: str, ms: float) -> None:
+        self._spans[name] = self._spans.get(name, 0.0) + ms
+
+    def as_dict(self) -> dict[str, float]:
+        return dict(self._spans)
+
+    def flush(self, path: str) -> None:
+        """Append the accumulated phase timings as one JSONL record."""
+        with open(path, "a", encoding="utf-8") as fh:
+            fh.write(json.dumps({"phase_ms": self._spans}) + "\n")
+
+
+def _resolve_recorder() -> _Recorder | None:
+    """Return a recorder iff the environment arms it, else ``None``.
+
+    Resolved once and cached. Kept out of :func:`span`'s hot path so the
+    disabled case is a single ``is None`` check.
+    """
+    if _resolve_recorder._cached is not _UNSET:  # type: ignore[attr-defined]
+        return _resolve_recorder._cached  # type: ignore[attr-defined]
+    rec = _Recorder() if os.environ.get(ENV_ENABLE) == "1" else None
+    _resolve_recorder._cached = rec  # type: ignore[attr-defined]
+    return rec
+
+
+_UNSET = object()
+_resolve_recorder._cached = _UNSET  # type: ignore[attr-defined]
+
+
+@contextmanager
+def span(name: str) -> Iterator[None]:
+    """Time a phase region. No-op (and clock-free) when perf is disabled.
+
+    ``name`` should be one of :data:`PHASES`, but any name is accepted so the
+    caller is never coupled to import order; unknown names simply won't map into
+    a baseline cell.
+    """
+    rec = _resolve_recorder()
+    if rec is None:
+        # Zero-cost path: no perf_counter, no object, no dict write.
+        yield
+        return
+    t0 = time.perf_counter()
+    try:
+        yield
+    finally:
+        rec.add(name, (time.perf_counter() - t0) * 1000.0)
+
+
+def start() -> float | None:
+    """Open a phase measurement without indenting the region it spans.
+
+    Pairs with :func:`stop`. Returns a start timestamp, or ``None`` when perf is
+    disabled — in which case no clock is read. Use this instead of :func:`span`
+    to instrument a long, branchy region in place without wrapping it in a
+    ``with`` block (which would force a re-indent of hundreds of lines).
+    """
+    return time.perf_counter() if _resolve_recorder() is not None else None
+
+
+def stop(name: str, t0: float | None) -> None:
+    """Close a :func:`start` measurement, accumulating into phase ``name``.
+
+    A no-op when perf is disabled (``t0 is None``). Because the recorder sums by
+    name, the same phase may be opened and closed at several scattered call
+    sites and the times add up.
+    """
+    if t0 is None:
+        return
+    rec = _resolve_recorder()
+    if rec is not None:
+        rec.add(name, (time.perf_counter() - t0) * 1000.0)
+
+
+def flush_recorder() -> None:
+    """Write accumulated phase timings to ``$SOURCECODE_PERF_LOG`` if armed."""
+    rec = _resolve_recorder()
+    path = os.environ.get(ENV_LOG)
+    if rec is not None and path:
+        rec.flush(path)
+
+
+def _reset_for_tests() -> None:
+    """Clear the cached recorder so tests can re-resolve after mutating env."""
+    _resolve_recorder._cached = _UNSET  # type: ignore[attr-defined]
+
+
+# ── Pure statistics ─────────────────────────────────────────────────────────
+
+
+def percentile(values: Sequence[float], q: float) -> float:
+    """Linear-interpolated percentile, ``q`` in ``[0, 100]``.
+
+    ``percentile(v, 50)`` is the median. Used for both p50 (central tendency —
+    never the mean, ADR-0006 §4) and p95 (tail).
+    """
+    if not values:
+        raise ValueError("percentile of empty sequence")
+    if not 0.0 <= q <= 100.0:
+        raise ValueError(f"q out of range: {q}")
+    s = sorted(values)
+    if len(s) == 1:
+        return float(s[0])
+    rank = (q / 100.0) * (len(s) - 1)
+    lo = int(rank)
+    hi = min(lo + 1, len(s) - 1)
+    frac = rank - lo
+    return float(s[lo] + (s[hi] - s[lo]) * frac)
+
+
+def p50(values: Sequence[float]) -> float:
+    return percentile(values, 50.0)
+
+
+def p95(values: Sequence[float]) -> float:
+    return percentile(values, 95.0)
+
+
+def _stat_block(values: Sequence[float], *, tail: bool = True) -> dict[str, float]:
+    block = {"p50": round(p50(values), 3), "p95": round(p95(values), 3)}
+    if not tail:
+        block.pop("p95")
+    return block
+
+
+# ── Environment fingerprint ─────────────────────────────────────────────────
+
+
+def collect_env() -> dict[str, object]:
+    """Capture the fields that make a baseline comparable only to same-host runs.
+
+    ``hostname_hash`` (not the raw hostname) groups same-machine runs without
+    leaking the machine name. Cross-host absolute numbers are recorded, never
+    diffed (ADR-0006 §5.4).
+    """
+    try:
+        host = socket.gethostname()
+    except OSError:
+        host = "unknown"
+    return {
+        "python": platform.python_version(),
+        "os": sys.platform,
+        "cpu": platform.processor() or platform.machine() or "unknown",
+        "cores": os.cpu_count() or 0,
+        "hostname_hash": hashlib.sha256(host.encode("utf-8")).hexdigest()[:8],
+    }
+
+
+# ── perf-baseline-v1 cell builder ───────────────────────────────────────────
+
+
+def build_baseline_cell(
+    *,
+    tool_version: str,
+    command: str,
+    repo: Mapping[str, object],
+    mode: str,
+    wall_ms_runs: Sequence[float],
+    rss_bytes_runs: Sequence[float],
+    phase_ms_runs: Sequence[Mapping[str, float]] | None = None,
+    env: Mapping[str, object] | None = None,
+    captured_at: str | None = None,
+) -> dict:
+    """Assemble one frozen-schema ``perf-baseline-v1`` cell from raw runs.
+
+    ``wall_ms_runs`` / ``rss_bytes_runs`` hold one value per run. ``phase_ms_runs``
+    is one ``{phase: ms}`` mapping per run; when absent, phase timings are emitted
+    as ``null`` with an honest ``instrumentation: "absent"`` marker rather than a
+    fabricated zero.
+    """
+    if not wall_ms_runs:
+        raise ValueError("wall_ms_runs must be non-empty")
+
+    phase_ms: dict[str, object] = {}
+    if phase_ms_runs:
+        for ph in PHASES:
+            series = [float(r[ph]) for r in phase_ms_runs if ph in r]
+            phase_ms[ph] = _stat_block(series) if series else None
+        # Un-attributed time must stay visible: total minus the sum of phases,
+        # never hidden inside a phase (ADR-0006 §3).
+        unattributed = []
+        for i, wall in enumerate(wall_ms_runs):
+            if i < len(phase_ms_runs):
+                attributed = sum(float(v) for v in phase_ms_runs[i].values())
+                unattributed.append(wall - attributed)
+        phase_ms["unattributed_p50"] = (
+            round(p50(unattributed), 3) if unattributed else None
+        )
+    else:
+        for ph in PHASES:
+            phase_ms[ph] = None
+        phase_ms["instrumentation"] = "absent"
+
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "tool_version": tool_version,
+        "captured_at": captured_at or datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "command": command,
+        "repo": dict(repo),
+        "mode": mode,
+        "runs": len(wall_ms_runs),
+        "wall_ms": {
+            "p50": round(p50(wall_ms_runs), 3),
+            "p95": round(p95(wall_ms_runs), 3),
+            "min": round(float(min(wall_ms_runs)), 3),
+            "max": round(float(max(wall_ms_runs)), 3),
+        },
+        "phase_ms": phase_ms,
+        "rss_peak_bytes": _stat_block(rss_bytes_runs) if rss_bytes_runs else None,
+        "env": dict(env) if env is not None else collect_env(),
+    }

sourcecode/repository_ir.py

@@ -807,11 +807,6 @@ def _pop_closed(class_stack: list[tuple[str, int]], depth: int) -> None:
         class_stack.pop()
 
 
-def _resolve_type(simple: str, import_map: dict[str, str]) -> Optional[str]:
-    base = re.sub(r'<.*', '', simple).strip().split('.')[-1]
-    return import_map.get(base)
-
-
 def _resolve_types_from_text(text: str, import_map: dict[str, str]) -> list[str]:
     resolved = []
     for token in re.findall(r'\b([A-Z]\w*)\b', text):
@@ -3597,40 +3592,6 @@ def _build_evidence_bundles(
     return bundles
 
 
-def _common_package_prefix(fqns: list[str]) -> str:
-    """Longest common dot-separated package prefix across a list of FQNs."""
-    if not fqns:
-        return ""
-    # Strip class/method suffix — keep only package parts (lowercase segments)
-    def pkg_parts(fqn: str) -> list[str]:
-        parts = fqn.split(".")
-        # Drop trailing class/method names (PascalCase or after '#')
-        result = []
-        for p in parts:
-            if "#" in p:
-                break
-            if p and p[0].isupper():
-                break
-            result.append(p)
-        return result
-
-    segs = [pkg_parts(f) for f in fqns if pkg_parts(f)]
-    if not segs:
-        return fqns[0].rsplit(".", 1)[0] if "." in fqns[0] else fqns[0]
-    common = segs[0]
-    for s in segs[1:]:
-        new_common = []
-        for a, b in zip(common, s):
-            if a == b:
-                new_common.append(a)
-            else:
-                break
-        common = new_common
-        if not common:
-            break
-    return ".".join(common) if common else fqns[0].rsplit(".", 1)[0]
-
-
 def _subsystem_label(package_prefix: str) -> str:
     """Derive short human label enforcing minimum meaningful depth.
 
@@ -5118,11 +5079,23 @@ def build_repo_ir(
                 _r["security_annotations"] = {"policy": "xml_or_filter_chain"}
 
     # L-6: inject analysis_meta — files_read, lines_read, symbols_analyzed, token_estimate
+    # symbol_kinds is the deterministic per-kind breakdown; classes/methods are the
+    # two rollups the perf harness consumes for cost-per-symbol (ADR-0006). The IR
+    # owns the taxonomy, so the rollup lives here rather than in the harness.
+    _kind_counts: dict[str, int] = {}
+    for _s in all_symbols:
+        _k = _s.symbol_kind or "unknown"
+        _kind_counts[_k] = _kind_counts.get(_k, 0) + 1
+    _TYPE_KINDS = ("class", "interface", "enum", "annotation", "record")
+    _METHOD_KINDS = ("method", "constructor")
     ir["analysis_meta"] = {
         "files_read": _meta_files_read,
         "lines_read": _meta_lines_read,
         "symbols_analyzed": len(all_symbols),
         "token_estimate": _meta_chars_read // 4,  # 4 chars ≈ 1 token (rough approximation)
+        "symbol_kinds": {k: _kind_counts[k] for k in sorted(_kind_counts)},
+        "classes": sum(_kind_counts.get(k, 0) for k in _TYPE_KINDS),
+        "methods": sum(_kind_counts.get(k, 0) for k in _METHOD_KINDS),
     }
     if emit_body_facts:
         # Additive, in-memory only: not a cir_hash input, not serialized by the

sourcecode/scanner.py

@@ -115,6 +115,57 @@ def classify_manifest(manifest_path: str, root: Path) -> str:
     return "auxiliary"
 
 
+# ── Shared scan primitives (used by both FileScanner and AdaptiveScanner) ────
+# AdaptiveScanner was forked from FileScanner and carried byte-identical copies of
+# these three; they live here as the single source of truth, each class method a
+# thin delegate.
+
+def find_manifest_paths(root: Path, excludes: frozenset[str]) -> list[str]:
+    """Manifest files at depth 0–1 (SCAN-04): root manifests plus depth-1
+    sub-package manifests, with hidden/excluded dirs and symlinks skipped."""
+    manifests: list[str] = []
+    # Depth 0: root
+    for name in MANIFEST_NAMES:
+        candidate = root / name
+        if candidate.exists() and not candidate.is_symlink():
+            manifests.append(str(candidate))
+    # Depth 1: first level (hidden dirs excluded — tooling, not project)
+    try:
+        for child in root.iterdir():
+            if (
+                child.is_dir()
+                and not child.is_symlink()
+                and child.name not in excludes
+                and not child.name.startswith(".")
+            ):
+                for name in MANIFEST_NAMES:
+                    candidate = child / name
+                    if candidate.exists() and not candidate.is_symlink():
+                        manifests.append(str(candidate))
+    except PermissionError:
+        pass
+    return manifests
+
+
+def get_or_create_tree_node(
+    tree: dict[str, Any], parts: tuple[str, ...]
+) -> dict[str, Any]:
+    """Navigate/create the nested-dict tree node for a path's parts."""
+    node = tree
+    for part in parts:
+        if part not in node or node[part] is None:
+            node[part] = {}
+        node = cast(dict[str, Any], node[part])
+    return node
+
+
+def match_gitignore(spec: GitIgnoreSpec, rel_path: str, is_dir: bool) -> bool:
+    """True if a root-relative path is excluded by ``spec``. GitIgnoreSpec expects
+    a trailing '/' for directories."""
+    path_to_match = rel_path + "/" if is_dir else rel_path
+    return spec.match_file(path_to_match)
+
+
 class FileScanner:
     """Escanea un directorio de proyecto y produce un arbol de ficheros filtrado.
 
@@ -148,10 +199,7 @@ class FileScanner:
 
     def _is_excluded_by_gitignore(self, rel_path: str, is_dir: bool) -> bool:
         """Comprueba si una ruta relativa (a self.root) esta excluida por .gitignore."""
-        spec = self._load_gitignore_spec()
-        # GitIgnoreSpec espera rutas con / al final para directorios
-        path_to_match = rel_path + "/" if is_dir else rel_path
-        return spec.match_file(path_to_match)
+        return match_gitignore(self._load_gitignore_spec(), rel_path, is_dir)
 
     def scan_tree(self) -> dict[str, Any]:
         """Construye el arbol JSON anidado del proyecto.
@@ -223,38 +271,8 @@ class FileScanner:
         self, tree: dict[str, Any], parts: tuple[str, ...]
     ) -> dict[str, Any]:
         """Navega/crea el nodo del arbol para la ruta indicada."""
-        node = tree
-        for part in parts:
-            if part not in node or node[part] is None:
-                node[part] = {}
-            node = cast(dict[str, Any], node[part])
-        return node
+        return get_or_create_tree_node(tree, parts)
 
     def find_manifests(self) -> list[str]:
-        """Encuentra ficheros de manifiesto en profundidad 0-1 (SCAN-04).
-
-        Retorna:
-            Lista de paths absolutos de manifiestos encontrados.
-        """
-        manifests: list[str] = []
-        # Profundidad 0: raiz
-        for name in MANIFEST_NAMES:
-            candidate = self.root / name
-            if candidate.exists() and not candidate.is_symlink():
-                manifests.append(str(candidate))
-        # Profundidad 1: primer nivel (excluir directorios ocultos — son tooling, no proyecto)
-        try:
-            for child in self.root.iterdir():
-                if (
-                    child.is_dir()
-                    and not child.is_symlink()
-                    and child.name not in self._excludes
-                    and not child.name.startswith(".")
-                ):
-                    for name in MANIFEST_NAMES:
-                        candidate = child / name
-                        if candidate.exists() and not candidate.is_symlink():
-                            manifests.append(str(candidate))
-        except PermissionError:
-            pass
-        return manifests
+        """Encuentra ficheros de manifiesto en profundidad 0-1 (SCAN-04)."""
+        return find_manifest_paths(self.root, self._excludes)

sourcecode/serializer.py

@@ -913,67 +913,6 @@ def _jndi_datasources(sm: "SourceMap") -> "Optional[list[dict[str, Any]]]":
     return datasources
 
 
-def _tiered_display_score(
-    pre_bonus_combined: float,
-    file_class: Any,
-    path: str,
-    entry_paths: set,
-    has_structural_signals: bool = False,
-) -> float:
-    """Evidence-tiered display score [0.0, 1.0].
-
-    Tiers enforce: strong evidence > medium evidence > filesystem/path only.
-    M3 sort bonuses must NOT be included in pre_bonus_combined — they are for
-    ordering only and must not inflate the displayed score.
-
-    Tier ceilings:
-      T1  confirmed production entrypoint           0.92–1.00
-      T2  entrypoint (weaker category)              0.80–0.91
-      T3  annotation-confirmed stereotype           0.40–0.90  (table-calibrated)
-      T4  framework import evidence                 0.55–0.79
-      T5  code definitions + imports                0.38–0.54
-      T6  build manifest / tooling / test           0.25–0.45
-      T7  path/filesystem signal only               0.10–0.39
-    """
-    from sourcecode.file_classifier import JAVA_STEREOTYPE_CATEGORIES
-
-    cat = file_class.category if file_class else None
-    base_rel = file_class.relevance if file_class else 0.0
-
-    # T1: confirmed production entrypoint
-    if path in entry_paths and cat in ("runtime_core", "cli_entrypoint"):
-        return round(min(1.0, max(0.92, base_rel)), 3)
-
-    # T2: in entry_paths but weaker evidence category
-    if path in entry_paths:
-        return round(min(0.91, max(0.80, pre_bonus_combined / 2.0)), 3)
-
-    # T3: annotation-confirmed stereotype — table values are already calibrated
-    if file_class and cat in JAVA_STEREOTYPE_CATEGORIES:
-        return round(base_rel, 3)
-
-    # T4: framework import evidence (medium strength)
-    if cat in ("api_layer", "database_layer", "infrastructure"):
-        return round(min(0.79, max(0.55, pre_bonus_combined / 2.0)), 3)
-
-    # T5: code definitions with imports (medium-low)
-    if cat in ("application_logic", "domain_model"):
-        return round(min(0.54, max(0.38, pre_bonus_combined / 2.0)), 3)
-
-    # T6: build manifest / tooling / test
-    if cat == "build_system":
-        return round(min(0.45, base_rel), 3)
-    if cat in ("tests", "tooling"):
-        return round(min(0.35, base_rel), 3)
-
-    # T7: no content classification — filesystem/structural signals only
-    # has_structural_signals: fan_in, churn, export — allows up to 0.54
-    # pure path/filename only — hard cap 0.39
-    if has_structural_signals:
-        return round(min(0.54, max(0.10, pre_bonus_combined / 2.0)), 3)
-    return round(min(0.39, max(0.10, pre_bonus_combined / 2.0)), 3)
-
-
 def _build_file_signals(
     file_class: Any,
     path: str,

sourcecode/spring_tx_analyzer.py

@@ -112,30 +112,6 @@ def _caught_types(catch_header_inner: str) -> list[str]:
     return types
 
 
-def _extract_method_body(source: str, method_name: str) -> str:
-    """Extract the first method body matching method_name using brace counting.
-
-    Returns the text from '{' to the matching '}', or empty string if not found.
-    Needed to scope TX-005 regex to the specific method instead of the whole file.
-    """
-    pattern = re.compile(r'\b' + re.escape(method_name) + r'\s*\(')
-    for m in pattern.finditer(source):
-        brace_pos = source.find('{', m.end())
-        if brace_pos < 0:
-            continue
-        depth = 1
-        i = brace_pos + 1
-        while i < len(source) and depth > 0:
-            c = source[i]
-            if c == '{':
-                depth += 1
-            elif c == '}':
-                depth -= 1
-            i += 1
-        return source[brace_pos:i]
-    return ""
-
-
 # ---------------------------------------------------------------------------
 # Pattern protocol
 # ---------------------------------------------------------------------------

{sourcecode-2.5.15.dist-info → sourcecode-2.5.17.dist-info}/METADATA

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

@@ -1,32 +1,32 @@
-sourcecode/__init__.py,sha256=TA67wvVQzG1GVLowfrLngK0bKQZu-eJyvWrAm5PiAdg,309
-sourcecode/adaptive_scanner.py,sha256=XffluXKzJUXrMtjEiAOnSNPZnztdIcts17T9ouHeID0,10521
+sourcecode/__init__.py,sha256=Ao5tzW0DQ-NV-o4Yno0H_QEOlx1oyQh_ih-rdREfXDs,309
+sourcecode/adaptive_scanner.py,sha256=yJBKjNpkY6bpueYJ2YnRezen3sYZDecEt7WaaNWdqug,9466
 sourcecode/archetype.py,sha256=d7yoN6Tj4OBj-VgSMPEKg4WF9H8FypnZ5A6AkUh5oIE,34484
 sourcecode/architecture_analyzer.py,sha256=GFc4ek-s1IHWM7pl-0L32WahZ93AmDgrAMcOuBKA5Dk,61463
 sourcecode/architecture_summary.py,sha256=BVVRHd952cjRhjHnR6CPrvKgaa-tdM16l-pBi1yDCPs,32395
-sourcecode/ast_extractor.py,sha256=FEsYTsMCXbJfSYQZRk1k-I-PjUNGnKqO1IxMftsgA5U,51351
+sourcecode/ast_extractor.py,sha256=ZwHN3Y0iRp2gpv3t5Nm5uvX7Xw1KtULCJPZqKpZQRAE,51255
 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=LdP_Ri3rl0M5p-MY0ypVvQwhq1WuUF1FmaHid7zyzEg,29807
 sourcecode/cir_graphs.py,sha256=9G0HHj1kw2325IDyzo2OpX73BNswEckecf4MZUXB4JM,12078
 sourcecode/classifier.py,sha256=JBzPwSSrDG-tUHAbcKB678HRbjLpD-ohzbzzO62mgpo,20114
-sourcecode/cli.py,sha256=LKK4czUeENVlcxHpSd5xao2HnAgtbRSYo8OoSwcZeZg,324334
+sourcecode/cli.py,sha256=QH7K8Uw19z5o7eXFPvVcC8ZA1KNUHS0bVL_IdOYC2CQ,324702
 sourcecode/code_notes_analyzer.py,sha256=EJemNCNc9Dn-1RZYu-aNbK0ELzmsyC4s6FdHi3XyNEI,9392
 sourcecode/confidence_analyzer.py,sha256=vnbPI-20FnHdjO6STxHW8fbaxmB4A7y58io63ibFZjc,21586
 sourcecode/context_cache.py,sha256=maws79rLKDwyZ7c9Q2LwlIxqZHRFlaKzErtO3mglWoA,25036
-sourcecode/context_graph.py,sha256=WFtUvfxoE8XtQxtRJLvaF4SJuS00ICjNoTk0sH2_V5U,44454
+sourcecode/context_graph.py,sha256=i2kOX3XiaCqcR20ojbUnqoX-hJbMyLNYc7rl-n15bwE,46426
 sourcecode/context_scorer.py,sha256=QpChSpsmaAYz91rXA4Ue5xzQmNz_ZboZN09YOHScq1U,14679
 sourcecode/context_summarizer.py,sha256=cI2TZMvEhl0BEma12VtPaX6z03ZVBAetVzuK5GaCOvg,6852
 sourcecode/contract_model.py,sha256=nRxJKPMs1VHwFTa8AVXhGmaLjti3Lr2sjHDpWgv1bfE,3917
 sourcecode/contract_pipeline.py,sha256=KfSgNkebcL5bYx3TDzEnvPLcTgm_JifJOAqqR8-0zb4,29774
-sourcecode/coverage_parser.py,sha256=q0LeZJaX1bnntLu-ImksdBsMlpsVmk_iUfSaB4eaJGo,19702
+sourcecode/coverage_parser.py,sha256=X9scuUWxacahYTrTBGea2Ku-sf-WCVcnc9OEB35_3IU,19340
 sourcecode/dependency_analyzer.py,sha256=fQCaWQ7_BNcVgZv8gweJCwJ1CGlXsz8nw_tqN3aHJNE,63952
 sourcecode/doc_analyzer.py,sha256=05bjTUbDbmnbajD_cgRnACzS8T7xxBKVX4CjkJlhZg8,24411
 sourcecode/dynamic_argument_surface.py,sha256=iRzrJhs57UXrGvLhNPiTA-e_sdO6ka-wNqc0wIiegiM,2554
 sourcecode/endpoint_literals.py,sha256=Qf4gTZzvNSFDGDuOvF0YRL9NvaYKKj24klhR5LIOaXc,3263
 sourcecode/endpoint_metrics.py,sha256=sLSLUIgiIyvNdOynaxVgHd9SjRF_DbN3QxevaquykaU,2840
 sourcecode/entrypoint_classifier.py,sha256=jhTYlyqDJH2AtdEcLVaRU3lYRTJuF8DkxVzl4-W3zWE,5322
-sourcecode/env_analyzer.py,sha256=aNTyYgQk5noJDfJU6FmasmESOHfiomyJw5EvZqjy6qc,22213
+sourcecode/env_analyzer.py,sha256=oLz4gDUE3BHlRRn6Qj4rnbjwyYjIZ0nlqO_SBQwL_H8,21999
 sourcecode/error_schema.py,sha256=uwosfNaSujtYm11_732Hu92z5ITV040fQDaIyefSvR4,1683
 sourcecode/evidence_provider.py,sha256=GSSL44JEaouO5AHks2sB3d1YvC9xIKIld1yBYxZpXxo,4277
 sourcecode/explain.py,sha256=HnHWVTNNf9fzeR3FP-A-eXKeKZvBcUEuODgIO3rJQkQ,22312
@@ -46,6 +46,7 @@ sourcecode/migrate_check.py,sha256=HJhvHuvXDGTJSRQU9_AMx0L94h2TImC1DCGs3m3RTu0,1
 sourcecode/openapi_surface.py,sha256=BTt0K-woZbkbWTN77IkqeBm_Okag9owR0848fmot8sk,16207
 sourcecode/output_budget.py,sha256=Js9yUlfQtPhqBl9R6wn_9UHVjjJc3GtLcqyfjf5t50Q,9869
 sourcecode/path_filters.py,sha256=qPKO7kRmVp2y9zjLNSuAVCbcpZrIInHE4QulLUlzPFI,10412
+sourcecode/perf.py,sha256=GAcEoouPIlPMCQIcHNToxK6K3WdIR-lj9aFg4prOYJI,9743
 sourcecode/pr_comment_renderer.py,sha256=KmcjMruhR44gjzMDJwjBSkWP9QEvh8xWBLyxzxoRbj0,14542
 sourcecode/pr_impact.py,sha256=dCDVw83EDbyVf6F9ZmEQmsFz8ruVH7d4mpeKQCIZHM0,16805
 sourcecode/prepare_context.py,sha256=-Xu33qCETuqw-OFfT3ukvAtxde7krCjQpn7wR3pbdOg,224290
@@ -56,10 +57,10 @@ 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=3hpxzOrudflSteYDLMQHK7KWdXg6mhhVwG94JSn7FHY,312825
+sourcecode/repository_ir.py,sha256=Q2lMpm5x8ZAIY4MVKWEcLZ-BP26kUoP1dRfdER6gSbo,312316
 sourcecode/ris.py,sha256=Hw8TakTQ6hku-Abf2k8954NwkrH_sP73_8wVH8x5khc,22079
 sourcecode/runtime_classifier.py,sha256=uTAD6BDCiBLUZEDRfqk718kM4RTT_vAbfkcOI2_Xx58,18432
-sourcecode/scanner.py,sha256=WdOQ78mMzjR1NjmKTlbxdgwinnCTfAhxCVLBEFQiFHU,8899
+sourcecode/scanner.py,sha256=z3CV0rcGunu0Y8mpNgp07wI7nxT0pxw1BkXRRtI0Rpo,9609
 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
@@ -67,14 +68,14 @@ sourcecode/semantic_analyzer.py,sha256=bpgdC6m0_ftVtRf3rSdwhbhWjnZnGxRXaZVcfe4Bb
 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=nbUuPv-F01USTt_9CHT8iy_ucCIw3fz4W3Aquea_pd4,10782
-sourcecode/serializer.py,sha256=UCGwxPZw9jS_amhU4om9a4Z6VOGOpttNuPpLuhGnuuU,132052
+sourcecode/serializer.py,sha256=zmN3pOcfxaQdxCE-jKoKudFjof9Sc_q7jpcBzNIA0EY,129493
 sourcecode/spring_event_topology.py,sha256=5_ON_21Le5zbG-1GRc5GLIi5HJfy_QjcXLVPC5WeUGQ,18055
 sourcecode/spring_findings.py,sha256=EX7kLZLN74CFyR9iZPm3CI115BfFKNd4WRPuErNljZM,5729
 sourcecode/spring_impact.py,sha256=MkUI27OCOhkjvBoA4f9X1eDBIY0SmyPuLVCWIfZgOcE,72430
 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/spring_tx_analyzer.py,sha256=7qXwQR9QbpVxbxJC-mawBMXM9xzydtZeq5L18cP_6GE,33884
 sourcecode/summarizer.py,sha256=sr0-tfecFKCr-fSkPPWbl-t9HC7SY2ZxkjnnXX8DB2A,26621
 sourcecode/tree_utils.py,sha256=8GAkIfQAsvtEudIeW1l4ooH_oRtrWR8cpJQJsEa_Pfw,2093
 sourcecode/type_usage_surface.py,sha256=51IrKRQoIoRnlsiDjHnqpJBn2rc6E59aRhgS0HTzAF0,4428
@@ -137,8 +138,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.15.dist-info/METADATA,sha256=lClKdlUiQRzl134vAQzx_Nvdk0pfm5mGK0pfIT0FIxs,10852
-sourcecode-2.5.15.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-2.5.15.dist-info/entry_points.txt,sha256=-JEAdChrK5We51kZcb7OaDcyil-dHBjBPL-NhuO-QY8,89
-sourcecode-2.5.15.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-2.5.15.dist-info/RECORD,,
+sourcecode-2.5.17.dist-info/METADATA,sha256=Pp6k3FfuZdHiohzyuajk3p9MPq7gTCOecNy-m3iBI98,10852
+sourcecode-2.5.17.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-2.5.17.dist-info/entry_points.txt,sha256=-JEAdChrK5We51kZcb7OaDcyil-dHBjBPL-NhuO-QY8,89
+sourcecode-2.5.17.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-2.5.17.dist-info/RECORD,,