sourcecode 1.39.0__tar.gz → 1.42.0__tar.gz

{sourcecode-1.39.0 → sourcecode-1.42.0}/.gitignore

@@ -33,4 +33,7 @@ src/*.egg-info/
 .DS_Store
 Thumbs.db
 
-.planning
+.planning
+
+# Supabase local temp
+supabase/.temp/

sourcecode-1.42.0/CHANGELOG.md

@@ -0,0 +1,157 @@
+# Changelog
+
+## [1.42.0] — 2026-06-16
+
+### Added
+- **Fase 22 — type-usage edges in `impact-chain` (CH-003).** Value/DTO/response
+  types previously had an invisible blast radius: the impact graph modelled call and
+  DI/injection edges but not how a type is wired *by type*. Two new edges close this:
+  - **`returns`** — `method → returnTypeFQN` (method-level). For a `@ResponseBody`
+    handler returning a domain type this is the only link from the type back to its
+    endpoint, so `_collect_endpoints` now surfaces that route precisely.
+  - **`instantiates`** — `class → T` for `new T(...)`, giving build-only value types
+    (commands, receipts) a visible blast radius. Controller-like classes are excluded
+    (already covered precisely by `returns`) to avoid broadening a DTO's impact to
+    every route on the controller.
+
+### Fixed
+- **Inline-annotation method parsing.** `_METHOD_DECL_RE` could not match a
+  modifier-position annotation (`public @ResponseBody Vets foo()`); the whole
+  declaration failed and the method — its endpoint *and* return type — was silently
+  dropped. Inline annotations are now consumed and folded into the method's annotation
+  set. Recovers, e.g., the `GET /vets` handler in spring-petclinic `VetController`.
+
+### Changed
+- **Safety guard for type-usage blind spots (CH-003 Part 1).** A fully empty blast
+  radius on a positively-identified plain value type (node present, `symbol_kind` in
+  class/enum/record, no stereotype annotation, role `other`, not a controller) is no
+  longer reported at `confidence: high` — it drops to `low` with a warning that an
+  empty result is not proof the type is unused. Spine symbols and incomplete-IR cases
+  keep prior behaviour. The guard now stays dormant when real type-usage edges exist.
+
+### Field test (spring-petclinic #2333)
+- `impact-chain Vets`: was `confidence: high` with 0 callers / 0 endpoints (a dangerous
+  false zero) → now `high`, caller `showResourcesVetList`, endpoint `GET /vets`.
+- `impact-chain VetController`: was 1 of 2 endpoints → both (`GET /vets` + `/vets.html`).
+
+## [1.41.0] — 2026-06-16
+
+### Added
+- **Fase 21 — spec-recovered HTTP routes reach `impact-chain`.** In
+  openapi-generator "interface-only" repos (`@RestController implements XxxApi`,
+  mappings on the generated interface under `target/generated-sources`), the HTTP
+  surface is recovered from the OpenAPI spec. That recovery previously lived only in
+  the `endpoints` command path, so `impact-chain` on a repository/service symbol
+  reported `endpoints_affected = 0` even though the route existed. The spec→controller
+  linking is now shared and wired through the impact model end to end.
+- **21-02** — `_recover_openapi_spec_routes` (repository_ir): single shared helper that
+  links spec operations to interface-defined controllers and emits both the
+  `endpoints`-command shape and the `route_surface` shape. `build_repo_ir` merges the
+  spec-sourced `route_surface` entries, so they flow `route_surface → CanonicalRepositoryIR
+  → EndpointIndex → impact-chain`. The `endpoints` command output stays byte-identical.
+- **21-03** — `impact-chain` BFS now crosses the interface DI boundary mid-chain.
+  `_bfs_callers` takes the `ImplementationGraph` and, for each implementation class it
+  reaches, folds in the reverse edges of that class's interfaces (callers inject the
+  interface type, so the `injects` edges sit on the interface node). Closes
+  `repo → serviceImpl → (service interface) → controller` so the spec-recovered endpoint
+  surfaces. CH-001b already did this for the seed; 21-03 extends it to every impl in the
+  traversal.
+
+### Fixed
+- **BUG-PARSER-002 — multi-line constructor/method signatures.** A signature whose
+  parameter list spans several physical lines (the canonical Spring constructor-injection
+  idiom, one param per line) lost its parameters: the per-line decl regex captured `[^)]*`
+  up to end-of-line only, so `param_types` was empty and no `injects` edges were emitted.
+  The pre-join pass now balances parentheses for declaration openers, mirroring the
+  existing multi-line class-declaration join.
+- **BUG-PARSER-003 — wildcard-import dependency resolution.** A dependency type pulled in
+  via `import pkg.*` was never resolved to an FQN (`import_map` skips `.*`), so even a
+  single-line constructor produced no `injects` edge. `_build_relations` now receives the
+  global `{package → {simple → FQN}}` map and resolves wildcard-imported types against it.
+
+### Why
+Field test of spring-petclinic-rest issue #11 (weakness #2): `impact-chain` on a repo or
+service symbol surfaced no affected HTTP endpoints in interface-only openapi-generator
+repos, even though the `endpoints` command listed the routes. The break was structural at
+several layers — the spec→controller linking never reached `route_surface`/the CIR, the DI
+chain dead-ended at the service impl, and (the live-repo blocker) the very first hop
+repo→service was missing because petclinic's `ClinicServiceImpl` uses a multi-line
+constructor with a wildcard repository import. With all four fixes, the live E2E
+`impact-chain VetRepository` on petclinic-rest goes from **0** affected endpoints to the
+full transitive set (**35**, reaching every controller incl. the spec-recovered v2 routes).
+
+## [1.40.0] — 2026-06-16
+
+### Added
+- **CH-001c — interface impact models implementors.** `impact-chain` over an
+  interface or abstract base now resolves its full in-repo descendant set:
+  concrete `implements` classes, `extends` sub-interfaces, and subclasses, traversed
+  transitively. A base interface query reaches impls hidden behind an intermediate
+  sub-interface (e.g. Spring Data repositories: `SpringDataVetRepository extends
+  VetRepository` alongside the JPA/JDBC impls).
+- `ImplementationGraph` gains `subtypes_of()`, `supertypes_of()`, and
+  `all_subtypes_of()` (transitive, cycle-safe). `extends` edges are now captured;
+  `implements`-only indices (`implementations_of`/`primary_implementation`) keep their
+  strict DI-resolution semantics — sub-interfaces are not counted as bean implementations.
+- `ImpactChainResult.implementations`: new output field listing the in-repo subtypes
+  of the queried type, making the implementation blast radius visible (previously the
+  impls were silent BFS seeds).
+
+### Why
+Field test of spring-petclinic-rest issue #11 surfaced the gap: `impact-chain
+VetRepository` returned only the SpringData sub-interface, missing the JPA/JDBC impls —
+exactly the "3 impls" graph the maintainer cared about. Interface impact did not model
+implementors.
+
+## [1.33.0] — 2026-05-29
+
+### Changed
+- **Repositioned product identity** around persistent structural cache and ultra-fast repeated analysis for AI coding agents. Cache is now the central product story, not a performance feature.
+- README rewritten: new intro emphasizing persistent context engine, cache performance benchmarks promoted above quickstart, agent workflow patterns section added, "Java/Spring analysis CLI" framing moved down.
+- `pyproject.toml` description updated: "Persistent structural context and ultra-fast repeated analysis for AI coding agents".
+- CLI `--help` updated: tagline, cold/warm latency numbers, cache commands section added prominently.
+
+## [Unreleased]
+
+### Added
+- `prepare-context generate-tests --include-config`: opt-in flag to include tooling
+  config files (`.eslintrc*`, `karma.conf.js`, `jest.config.js`, etc.) in `test_gaps`.
+  By default these are now excluded (IMP-1).
+
+### Fixed
+- **BUG-1** `repo-ir` stdout: JSON is now written via `stdout.buffer` (UTF-8) so Unicode
+  characters (e.g. `→`) survive on Windows consoles with non-UTF-8 codecs.
+  `main_entry` also calls `stdout.reconfigure(encoding='utf-8')` on startup.
+- **BUG-2** `--exclude` with a space-separated value (`--exclude "a,b"`) was silently
+  consumed as the repository path. Added `--exclude` to the options-with-value registry
+  so its argument is parsed correctly.
+- **BUG-3** `prepare-context onboard --fast` returned only the git-changed file
+  (e.g. `.idea/vcs.xml`). Fast mode for `onboard` now always uses a shallow depth-2
+  scan so manifests and entry points are reliably discovered.
+- **BUG-4** `angular_version: null` when `package.json` has `"dependencies": null`.
+  The merge now uses `or {}` so an explicit `null` key doesn't raise TypeError.
+  Also checks `peerDependencies` as a fallback source.
+- **BUG-5** `lazy_routes_count: 0` in Angular projects. Counting now uses
+  `loadChildren:` and `loadComponent:` (property syntax) instead of the defunct
+  `loadChildren(` call syntax.
+- **BUG-6** Angular `*.component.ts` files classified as Spring `@Service` in
+  `review-pr` and `prepare-context` output on fullstack Java+Angular repos.
+  Root cause: `"component"` was in `_SERVICE_KW` inside `_classify_changed_file`.
+  Fix: Angular detection block (by `.ts` stem suffix) now runs **before** the
+  Java/Spring heuristics. `"component"` removed from `_SERVICE_KW`. Added
+  `ng_component`, `ng_pipe`, `ng_directive`, `ng_guard`, `ng_interceptor`,
+  `ng_resolver`, `ng_service`, `ng_module` to `_ARTIFACT_CHANGE_EFFECT`.
+  `ast_extractor._detect_role` updated with the same Angular stem-suffix map.
+- **BUG-7** `--compact` help text referenced `--slim (when available)` which is
+  not implemented and does not exist as a CLI option, causing user confusion
+  (`Error: No such option '--slim'`). Removed the reference (Option A: remove
+  mention rather than implement the flag this sprint).
+
+### Regression tests added (`tests/test_bug_fixes_v13122.py`)
+- 13 exit-code tests covering all commands reported as EXIT 255 — all verified
+  to return EXIT 0 (BUG-1 through BUG-7 of this audit cycle).
+- 8 Angular classification tests locking `ng_component` / `ng_service` / `ng_*`
+  artifact types and `_ARTIFACT_CHANGE_EFFECT` entries.
+- 3 `--slim` tests verifying the option is absent from help and CLI surface.
+- 6 `angular_version` parsing tests covering `dependencies`, `devDependencies`,
+  `peerDependencies`, `null` JSON values, and version prefix stripping.

{sourcecode-1.39.0 → sourcecode-1.42.0}/PKG-INFO

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

{sourcecode-1.39.0 → sourcecode-1.42.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sourcecode"
-version = "1.39.0"
+version = "1.42.0"
 description = "Persistent structural context and ultra-fast repeated analysis for AI coding agents"
 readme = "README.md"
 requires-python = ">=3.9"

{sourcecode-1.39.0 → sourcecode-1.42.0}/src/sourcecode/__init__.py

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

{sourcecode-1.39.0 → sourcecode-1.42.0}/src/sourcecode/cir_graphs.py

@@ -25,22 +25,67 @@ class ImplementationGraph:
 
     Built from implements edges where BOTH ends are known CIR symbols (internal
     interface/class pairs).  External framework interfaces are excluded.
+
+    Subtype indices (CH-001c): `extends` edges are also captured so that
+    interface-to-interface inheritance (`SubIface extends BaseIface`) and abstract
+    base classes (`SubClass extends BaseClass`) are modeled as descendants of the
+    supertype.  The `implements`-only indices (`_impl_of`/`_ifaces_of`) are kept
+    separate to preserve DI resolution semantics (primary_implementation).
     """
     _impl_of: dict[str, list[str]] = field(default_factory=dict)
     _ifaces_of: dict[str, list[str]] = field(default_factory=dict)
+    # CH-001c: union of implements + extends descendants (impl classes, sub-interfaces,
+    # subclasses) keyed by supertype FQN, and its reverse.
+    _subtype_of: dict[str, list[str]] = field(default_factory=dict)
+    _supertype_of: dict[str, list[str]] = field(default_factory=dict)
 
     # ---------------------------------------------------------------------------
     # Queries
     # ---------------------------------------------------------------------------
 
     def implementations_of(self, interface_fqn: str) -> list[str]:
-        """Return FQNs of classes that implement interface_fqn (in-repo only)."""
+        """Return FQNs of classes that implement interface_fqn (in-repo only).
+
+        Strictly `implements` edges — excludes sub-interfaces/subclasses. Use
+        subtypes_of()/all_subtypes_of() for the full impact-relevant descendant set.
+        """
         return self._impl_of.get(interface_fqn, [])
 
     def interfaces_of(self, class_fqn: str) -> list[str]:
         """Return FQNs of in-repo interfaces implemented by class_fqn."""
         return self._ifaces_of.get(class_fqn, [])
 
+    def subtypes_of(self, type_fqn: str) -> list[str]:
+        """Return direct in-repo subtypes of type_fqn.
+
+        Union of `implements` (concrete impls) and `extends` (sub-interfaces,
+        subclasses) children.  This is the impact-relevant descendant set: a change
+        to type_fqn's contract propagates to all of these.
+        """
+        return self._subtype_of.get(type_fqn, [])
+
+    def supertypes_of(self, type_fqn: str) -> list[str]:
+        """Return direct in-repo supertypes of type_fqn (implemented/extended)."""
+        return self._supertype_of.get(type_fqn, [])
+
+    def all_subtypes_of(self, type_fqn: str) -> list[str]:
+        """Return the transitive closure of in-repo subtypes (BFS, cycle-safe).
+
+        Covers multi-level hierarchies, e.g. a base interface → sub-interface →
+        concrete impl chain.  Order is breadth-first from type_fqn; deduplicated.
+        """
+        seen: set[str] = set()
+        out: list[str] = []
+        queue: list[str] = list(self._subtype_of.get(type_fqn, []))
+        while queue:
+            sub = queue.pop(0)
+            if sub in seen:
+                continue
+            seen.add(sub)
+            out.append(sub)
+            queue.extend(self._subtype_of.get(sub, []))
+        return out
+
     def primary_implementation(self, interface_fqn: str) -> str | None:
         """Return the single implementation if unambiguous, else None.
 
@@ -89,9 +134,14 @@ class ImplementationGraph:
 
         impl_of: dict[str, list[str]] = {}
         ifaces_of: dict[str, list[str]] = {}
+        subtype_of: dict[str, list[str]] = {}
+        supertype_of: dict[str, list[str]] = {}
 
         for edge in dependencies:
-            if edge.get("type") != "implements":
+            etype = edge.get("type")
+            # CH-001c: extends edges (sub-interface / subclass) are subtype relations
+            # too, even though they never feed the implements-only DI indices.
+            if etype not in ("implements", "extends"):
                 continue
             from_fqn = (edge.get("from") or "").strip()
             to_fqn = (edge.get("to") or "").strip()
@@ -110,12 +160,27 @@ class ImplementationGraph:
             if ">" in from_fqn or "<" in from_fqn:
                 continue
 
-            if from_fqn not in impl_of.get(to_fqn, []):
-                impl_of.setdefault(to_fqn, []).append(from_fqn)
-            if to_fqn not in ifaces_of.get(from_fqn, []):
-                ifaces_of.setdefault(from_fqn, []).append(to_fqn)
+            # Subtype indices — both implements and extends contribute descendants.
+            if from_fqn not in subtype_of.get(to_fqn, []):
+                subtype_of.setdefault(to_fqn, []).append(from_fqn)
+            if to_fqn not in supertype_of.get(from_fqn, []):
+                supertype_of.setdefault(from_fqn, []).append(to_fqn)
+
+            # Implements-only indices — preserve DI resolution semantics. Sub-interfaces
+            # and subclasses (extends) must NOT count as "implementations" for
+            # primary_implementation() bean resolution.
+            if etype == "implements":
+                if from_fqn not in impl_of.get(to_fqn, []):
+                    impl_of.setdefault(to_fqn, []).append(from_fqn)
+                if to_fqn not in ifaces_of.get(from_fqn, []):
+                    ifaces_of.setdefault(from_fqn, []).append(to_fqn)
 
-        return cls(_impl_of=impl_of, _ifaces_of=ifaces_of)
+        return cls(
+            _impl_of=impl_of,
+            _ifaces_of=ifaces_of,
+            _subtype_of=subtype_of,
+            _supertype_of=supertype_of,
+        )
 
 
 # ---------------------------------------------------------------------------