sourcecode 1.5.0__tar.gz → 1.6.0__tar.gz

sourcecode-1.6.0/.continue-here.md

@@ -0,0 +1,105 @@
+# Continue Here — sourcecode Java/Spring Enterprise Bug Fixes v1.5.x
+**Created:** 2026-05-08  
+**Session context:** Ad-hoc benchmark-driven bug fixes (not a GSD phase execution)
+
+---
+
+## What Was Done This Session
+
+Applied 5 fixes targeting regressions in v1.5.0 benchmark report on saint-server (3681 .java, 460 *RestController*, 52 *Mapper.xml, Spring Boot 2.7.18 DDD+legacy layout).
+
+### Root Causes Found and Fixed
+
+| ID | File(s) | Root Cause | Fix |
+|----|---------|-----------|-----|
+| N1 | `detectors/java.py` | Scanner `depth >= max_depth=10` cuts `ddd/*/infraestructure/rest/` files silently. Path `src/main/java/com/m3/saint/ddd/domain/infraestructure/rest/` = 10 parts → excluded from file_tree → not in entry_points. | New `_augment_deep_java_controllers()`: direct `os.walk` of `src/main/java/` for `*Controller*.java` files not in file_tree |
+| G3 | `contract_pipeline.py` | Mapper.xml score=0.3 (no `.xml` suffix boost) < Java score=0.4. 3000+ files compete for 2500-file cap — all 52 Mapper.xml cut. | `_is_priority()`: Mapper.xml gets same priority as entry_points in cap sort |
+| T11 | `contract_pipeline.py` | Centrality sort key ignored `is_entrypoint`. REST controllers have low fan_in → ranked below JPA entities. | Added `-c.is_entrypoint` as primary key in centrality sort |
+| P3-B | `cli.py` | Auto-switch to centrality when DDD architecture detected — actively hurt REST controller visibility. | Removed 5-line P3-B block |
+| N2 | `serializer.py` | `hotspots` removed from top-level output in v1.5.0, only in `semantic_summary`. Breaking for consumers using `d["hotspots"]`. | Restore `result["hotspots"]` at top level when `semantic_summary.hotspots` exists |
+
+### Modified Files (uncommitted — user requested no commits)
+
+```
+src/sourcecode/cli.py               # P3-B removed (DDD auto-centrality switch)
+src/sourcecode/contract_pipeline.py # G3: _is_priority() + T11: centrality sort key
+src/sourcecode/detectors/java.py    # N1: _augment_deep_java_controllers() method
+src/sourcecode/serializer.py        # N2: result["hotspots"] top-level restored
+```
+
+### Test Status
+- 651 passed, 3 skipped (subset excluding pre-existing failures) — zero regressions
+
+---
+
+## What Remains
+
+### Not Fixed (deferred)
+
+| ID | Description |
+|----|-------------|
+| M1 | `prepare-context` from monorepo root detects Angular instead of saint-server Java. Requires monorepo subproject routing in `prepare_context.py` → `TaskContextBuilder` / `RepoClassifier`. |
+| M2 | `@M3FiltroSeguridad` custom security annotation not aggregated into security map |
+| M3 | Spring profiles detected but not linked to `application-{profile}.yml` files |
+
+### Verification Commands (run against saint-server after commit)
+
+```bash
+# N1: DDD controllers now captured (need --depth 12+ for tree, augment works at any depth)
+sourcecode saint-server --depth 12 --entrypoints-only --format json | python -c "
+import sys, json
+d = json.load(sys.stdin)
+rest = [x for x in d.get('contracts', []) if 'RestController' in x.get('path','')]
+ddd  = [x for x in rest if '/ddd/' in x['path'] or '/infraestructure/' in x['path']]
+print(f'REST total: {len(rest)} | DDD: {len(ddd)}')"
+
+# G3: MyBatis XML in contracts
+sourcecode saint-server --depth 10 --format json | python -c "
+import sys, json
+d = json.load(sys.stdin)
+xml = [x for x in d.get('contracts', []) if x.get('language') == 'mybatis-xml']
+print(f'MyBatis contracts: {len(xml)}')"
+
+# N2: hotspots at top level restored
+sourcecode saint-server --semantics --format json | python -c "
+import sys, json
+d = json.load(sys.stdin)
+print('top-level hotspots:', len(d.get('hotspots', [])))
+print('semantic_summary.hotspots:', len(d.get('semantic_summary',{}).get('hotspots',[])))"
+
+# T11: centrality now surfaces REST controllers
+sourcecode saint-server --rank-by centrality --depth 10 --format json | python -c "
+import sys, json
+d = json.load(sys.stdin)
+rest = [x for x in d.get('contracts', []) if 'RestController' in x.get('path','')]
+print(f'REST in centrality: {len(rest)}')"
+```
+
+**Note on N1 depth:** `_augment_deep_java_controllers` bypasses the scanner depth limit and always walks `src/main/java/` directly. DDD controllers will be detected as entry_points regardless of `--depth`. However, for these same files to appear in the general file_paths (not just entry_points), the scanner itself needs `--depth >= 11`.
+
+---
+
+## Previous Session Fixes (already committed)
+
+C1/C2/C3/G1/G2/G3 from v1.4.0→v1.5.0:
+- `--mode standard` key `file_contracts` → `contracts`
+- Controller-first scan, cap 500→1000
+- DDD bounded contexts from package structure
+- Maven BOM limitation warning
+- MyBatis XML extractor (code existed but files were cut by cap — fixed in this session)
+
+---
+
+## GSD Project State (unchanged)
+
+All 13 phases complete (see `.planning/STATE.md`). Both sessions were ad-hoc bug work from benchmark reports, not planned phase executions.
+
+---
+
+## Resume Instructions
+
+1. `git diff --stat` — verify 4 uncommitted files
+2. `python -m pytest tests/ --ignore=tests/test_block2_coverage.py --ignore=tests/test_dependency_analyzer_node_python.py --ignore=tests/test_pipeline_integrity.py -q`
+3. Commit the fixes
+4. Run verification commands above against saint-server
+5. If tackling M1, entry point is `prepare_context.py:TaskContextBuilder.build()` + `repo_classifier.py`

{sourcecode-1.5.0 → sourcecode-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.5.0
+Version: 1.6.0
 Summary: Deterministic codebase context for AI coding agents
 License:                                  Apache License
                                    Version 2.0, January 2004

{sourcecode-1.5.0 → sourcecode-1.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sourcecode"
-version = "1.5.0"
+version = "1.6.0"
 description = "Deterministic codebase context for AI coding agents"
 readme = "README.md"
 requires-python = ">=3.9"

{sourcecode-1.5.0 → sourcecode-1.6.0}/src/sourcecode/__init__.py

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

{sourcecode-1.5.0 → sourcecode-1.6.0}/src/sourcecode/cli.py

@@ -1399,12 +1399,6 @@ def main(
                         ))
         sm = _replace(sm, pipeline_trace=_trace.build_trace())
 
-    # P3-B: Auto-switch to centrality ranking when DDD layout detected
-    if (rank_by == "relevance"
-            and sm.architecture is not None
-            and sm.architecture.pattern == "ddd"):
-        rank_by = "centrality"
-
     # Contract pipeline — runs for mode=contract|standard|deep|hybrid (skip for raw)
     _is_contract_mode = mode in ("contract", "standard")
     _pipeline_error = False

{sourcecode-1.5.0 → sourcecode-1.6.0}/src/sourcecode/contract_pipeline.py

@@ -240,10 +240,18 @@ class ContractPipeline:
 
         # Apply max_files cap — bypass when symbol search to ensure defining files are found.
         # A symbol query over a large repo needs all files; result set is small after filtering.
+        # MyBatis Mapper.xml contracts rank below Java files on path score alone (.xml has no
+        # suffix boost). Give them the same priority slot as entry_points so they survive the cap.
+        def _is_priority(p: str) -> bool:
+            if p in entry_paths:
+                return True
+            name = p.rsplit("/", 1)[-1]
+            return name.lower().endswith("mapper.xml")
+
         if symbol is None and len(src_paths) > self.max_files:
             src_paths = sorted(
                 src_paths,
-                key=lambda p: (p in entry_paths, scorer.score(p)),
+                key=lambda p: (_is_priority(p), scorer.score(p)),
                 reverse=True,
             )[:self.max_files]
 
@@ -362,7 +370,9 @@ class ContractPipeline:
 
     def _rank(self, contracts: list[FileContract], rank_by: RankStrategy) -> list[FileContract]:
         if rank_by == "centrality":
-            return sorted(contracts, key=lambda c: (-(c.fan_in + c.fan_out), c.path))
+            # Entrypoints (REST controllers, main classes) surface first even in centrality mode:
+            # they have low fan_in (not imported) but are the primary API surface.
+            return sorted(contracts, key=lambda c: (-c.is_entrypoint, -(c.fan_in + c.fan_out), c.path))
         if rank_by == "git-churn":
             return sorted(contracts, key=lambda c: (-c.is_changed, -c.relevance_score, c.path))
         # Default: relevance — path breaks ties deterministically

{sourcecode-1.5.0 → sourcecode-1.6.0}/src/sourcecode/detectors/java.py

@@ -225,6 +225,12 @@ class JavaDetector(AbstractDetector):
         all_paths = flatten_file_tree(context.file_tree)
         all_java = [p for p in all_paths if p.endswith(".java")]
 
+        # Augment with a direct scan of standard Java source roots for Controller-named
+        # files that the depth-limited file_tree scanner may have missed.
+        # DDD layouts place REST controllers at depth 10+ (e.g.
+        # src/main/java/com/org/app/ddd/domain/infraestructure/rest/XxxRestController.java).
+        self._augment_deep_java_controllers(context, all_java)
+
         # 1. @SpringBootApplication entry: Application.java / Main.java by name
         app_candidates = [
             p for p in all_java
@@ -270,6 +276,40 @@ class JavaDetector(AbstractDetector):
                 unique_eps.append(ep)
         return unique_eps
 
+    def _augment_deep_java_controllers(self, context: DetectionContext, all_java: list[str]) -> None:
+        """Scan standard Java source roots for *Controller*.java files not in all_java.
+
+        The depth-limited file_tree scanner misses files at depth >= max_depth.
+        DDD layouts place REST controllers deep (e.g. depth 10+), so we supplement
+        with a direct filesystem walk scoped to the standard Maven/Gradle source root.
+        """
+        import os as _os
+        existing = set(all_java)
+        # Standard Java source root candidates (Maven first, then Gradle/other)
+        _SRC_ROOTS = ("src/main/java", "src/main/kotlin", "src/java", "src")
+        for src_root_name in _SRC_ROOTS:
+            src_root = context.root / src_root_name
+            if not src_root.is_dir():
+                continue
+            try:
+                for dirpath, _dirs, filenames in _os.walk(str(src_root)):
+                    for fname in filenames:
+                        if "Controller" not in fname or not fname.endswith(".java"):
+                            continue
+                        full = Path(dirpath) / fname
+                        if full.is_symlink():
+                            continue
+                        try:
+                            rel = str(full.relative_to(context.root)).replace("\\", "/")
+                            if rel not in existing:
+                                all_java.append(rel)
+                                existing.add(rel)
+                        except ValueError:
+                            pass
+            except OSError:
+                pass
+            return  # use only first matching source root
+
     def _scan_java_file_for_entry_points(self, abs_path: Path, rel_path: str) -> list[EntryPoint]:
         try:
             if abs_path.stat().st_size > _MAX_FILE_SIZE:

{sourcecode-1.5.0 → sourcecode-1.6.0}/src/sourcecode/serializer.py

@@ -1110,6 +1110,10 @@ def standard_view(sm: SourceMap, *, include_tree: bool = False) -> dict[str, Any
 
     if sm.semantic_summary is not None and sm.semantic_summary.requested:
         result["semantic_summary"] = asdict(sm.semantic_summary)
+        # Backward compat: also emit hotspots at top level (moved to semantic_summary in v1.5.0).
+        # Consumers reading d["hotspots"] directly still work.
+        if sm.semantic_summary.hotspots:
+            result["hotspots"] = sm.semantic_summary.hotspots[:10]
         # Defensive filter: never emit objects with null required fields.
         # A null entry in these arrays is worse than a shorter array — it causes
         # agents to misinterpret the analysis as valid when it is not.