sourcecode 1.35.30__tar.gz → 1.35.32__tar.gz

{sourcecode-1.35.30 → sourcecode-1.35.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.35.30
+Version: 1.35.32
 Summary: Persistent structural context and ultra-fast repeated analysis for AI coding agents
 License-File: LICENSE
 Keywords: agents,ai,codebase,context,developer-tools,llm
@@ -40,7 +40,7 @@ Description-Content-Type: text/markdown
 
 **Persistent structural context and ultra-fast repeated analysis for AI coding agents.**
 
-![Version](https://img.shields.io/badge/version-1.35.30-blue)
+![Version](https://img.shields.io/badge/version-1.35.32-blue)
 ![Python](https://img.shields.io/badge/python-3.10%2B-green)
 
 ---
@@ -114,7 +114,7 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.35.30
+# sourcecode 1.35.32
 
 **v1.35.28** — 7 bug fixes: `rename-class` cross-package disambiguation (BUG-4), `rename-class` collision detection (BUG-2), `find_java_files` false positive on `com/test/` package paths (BUG-1), `cold-start --compact` correct key names (BUG-6), `@EnableMethodSecurity` no longer suppresses SEC-001 (BUG-3), `explain` @Entity stereotype detection (BUG-5), XML+annotation mixed security retagging (BUG-7).
 ```

{sourcecode-1.35.30 → sourcecode-1.35.32}/README.md

@@ -2,7 +2,7 @@
 
 **Persistent structural context and ultra-fast repeated analysis for AI coding agents.**
 
-![Version](https://img.shields.io/badge/version-1.35.30-blue)
+![Version](https://img.shields.io/badge/version-1.35.32-blue)
 ![Python](https://img.shields.io/badge/python-3.10%2B-green)
 
 ---
@@ -76,7 +76,7 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.35.30
+# sourcecode 1.35.32
 
 **v1.35.28** — 7 bug fixes: `rename-class` cross-package disambiguation (BUG-4), `rename-class` collision detection (BUG-2), `find_java_files` false positive on `com/test/` package paths (BUG-1), `cold-start --compact` correct key names (BUG-6), `@EnableMethodSecurity` no longer suppresses SEC-001 (BUG-3), `explain` @Entity stereotype detection (BUG-5), XML+annotation mixed security retagging (BUG-7).
 ```

{sourcecode-1.35.30 → sourcecode-1.35.32}/pyproject.toml

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

{sourcecode-1.35.30 → sourcecode-1.35.32}/src/sourcecode/__init__.py

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

{sourcecode-1.35.30 → sourcecode-1.35.32}/src/sourcecode/file_chunker.py

@@ -94,6 +94,7 @@ _CLASS_RE = re.compile(
 )
 _METHOD_RE = re.compile(
     r'^\s*(?:(?:public|protected|private|static|final|synchronized|abstract|native|default|override)\s+)*'
+    r'(?:@\w+(?:\([^)]*\))?\s+)*'      # optional return-type annotations (e.g. @ResponseBody)
     r'(?:<[^>]+>\s+)?'                  # optional generic return type
     r'(?:[\w<>\[\],?\s]+\s+)?'         # return type (optional for constructors)
     r'(\w+)\s*\('                        # method/constructor name + opening paren
@@ -288,6 +289,8 @@ def chunk_java_file(
     current_method_name = ""
     current_method_type = ""
     method_brace_start_depth = -1
+    # State for multi-line method signatures (name detected, waiting for opening '{')
+    _pending_method: Optional[tuple[str, str]] = None  # (name, type)
 
     for line_no_0, raw_line in enumerate(all_lines):
         line_no = line_no_0 + 1  # 1-based
@@ -315,32 +318,16 @@ def chunk_java_file(
 
         # Check if this line starts a method/constructor AT class_depth+1
         if class_depth >= 0 and depth == class_depth + 1 and not current_method_name:
-            is_method, mname, mtype = _is_method_or_constructor_start(
-                stripped, class_name, depth, class_depth
-            )
-            if is_method and "{" in raw_line:
-                # Flush anything accumulated as field_block / class_header
-                # Include annotation lines in the new method chunk
-                if pending_lines:
-                    # Check if last N pending lines are annotations for this method
-                    # Flush everything up to ann_buffer start
-                    if ann_buffer:
-                        ann_start_line = ann_buffer[0][0]
-                        pre_ann_lines = pending_lines[:ann_start_line - pending_start]
-                        if pre_ann_lines:
-                            _flush_chunk(ann_start_line - 1)
-                        # Move ann_buffer lines into the new method chunk
-                        pending_start = ann_start_line
-                        pending_lines = [al for _, al in ann_buffer]
-                        ann_buffer = []
-                    else:
-                        _flush_chunk(line_no - 1)
-                        pending_start = line_no
-                        pending_lines = []
-
+            # Multi-line signature: we already detected the method name; this line
+            # should contain the opening brace that starts the method body.
+            # Guard: opens > closes ensures a net depth increase (not a balanced
+            # annotation arg like @RequestMapping({"v1","v2"})).
+            if _pending_method and opens > closes:
+                mname, mtype = _pending_method
+                _pending_method = None
                 current_method_name = mname
                 current_method_type = mtype
-                method_brace_start_depth = depth + opens - 1  # depth entering method body
+                method_brace_start_depth = depth + opens - 1
                 pending_type = mtype
                 pending_symbol = f"{class_name}#{mname}" if class_name else mname
                 pending_lines.append(raw_line)
@@ -348,6 +335,49 @@ def chunk_java_file(
                 ann_buffer = []
                 continue
 
+            if not _pending_method:
+                is_method, mname, mtype = _is_method_or_constructor_start(
+                    stripped, class_name, depth, class_depth
+                )
+                if is_method:
+                    # Flush anything accumulated as field_block / class_header
+                    # Include annotation lines in the new method chunk
+                    if pending_lines:
+                        if ann_buffer:
+                            ann_start_line = ann_buffer[0][0]
+                            pre_ann_lines = pending_lines[:ann_start_line - pending_start]
+                            if pre_ann_lines:
+                                _flush_chunk(ann_start_line - 1)
+                            # Move ann_buffer lines into the new method chunk
+                            pending_start = ann_start_line
+                            pending_lines = [al for _, al in ann_buffer]
+                            ann_buffer = []
+                        else:
+                            _flush_chunk(line_no - 1)
+                            pending_start = line_no
+                            pending_lines = []
+
+                    if "{" in raw_line:
+                        # Single-line signature: method body opens on same line
+                        current_method_name = mname
+                        current_method_type = mtype
+                        method_brace_start_depth = depth + opens - 1
+                        pending_type = mtype
+                        pending_symbol = f"{class_name}#{mname}" if class_name else mname
+                        pending_lines.append(raw_line)
+                        depth += opens - closes
+                        ann_buffer = []
+                        continue
+                    else:
+                        # Multi-line signature: record name, wait for '{' on later line
+                        _pending_method = (mname, mtype)
+                        pending_type = mtype
+                        pending_symbol = f"{class_name}#{mname}" if class_name else mname
+                        pending_lines.append(raw_line)
+                        depth += opens - closes
+                        ann_buffer = []
+                        continue
+
         # Update depth
         depth += opens - closes
 

{sourcecode-1.35.30 → sourcecode-1.35.32}/src/sourcecode/repository_ir.py

@@ -2756,8 +2756,8 @@ def _build_route_surface(
                 _route_entry["security_annotations"] = _sec
                 routes.append(_route_entry)
 
-    # Phase 3: inheritance projection — subclasses with zero own endpoints
-    # but with a class-level @RequestMapping prefix inherit parent methods.
+    # Phase 3: inheritance projection — subclasses with a class-level @RequestMapping
+    # prefix inherit parent methods that they do not override (same HTTP verb + path suffix).
     if extends_map:
         fqn_to_simple: dict[str, str] = {d["fqn"]: s for s, d in class_info.items()}
         simple_extends: dict[str, str] = {
@@ -2771,11 +2771,14 @@ def _build_route_surface(
         }
 
         for cls_simple, data in class_info.items():
-            if data["own_endpoints"]:
-                continue
             if not any(data["prefixes"]):
                 continue
 
+            # (verb, suffix) pairs declared on this subclass — these shadow parent methods.
+            own_override_set: set[tuple[str, str]] = {
+                (verb, suffix) for verb, suffix, _, _ in data["own_endpoints"]
+            }
+
             chain = simple_extends.get(cls_simple)
             visited: set[str] = {cls_simple}
             depth = 1
@@ -2786,6 +2789,9 @@ def _build_route_surface(
                     break
                 if parent["own_endpoints"]:
                     for verb, suffix, declaring_sym, stable_id in parent["own_endpoints"]:
+                        # Skip methods the subclass overrides (same verb + path suffix).
+                        if (verb, suffix) in own_override_set:
+                            continue
                         for prefix in data["prefixes"]:
                             # P1 fix: collapse any number of consecutive slashes
                             full_path = re.sub(r"/+", "/", prefix + "/" + suffix).rstrip("/") or "/"
@@ -2903,6 +2909,24 @@ def build_repo_ir(
         # Spring Data
         '@Query', '@NamedQuery',
     )
+    # Pre-pass: collect custom meta-annotation names from @interface definitions
+    # that compose known Spring stereotypes (e.g. @DomainService = @Service + @Transactional).
+    # These names must be added to the marker set so classes using them aren't
+    # filtered out by the fast pre-scan below.
+    _custom_meta_markers: set[str] = set()
+    for _rp in sorted(file_paths):
+        try:
+            _src = (root / _rp).read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+        if "@interface" not in _src:
+            continue
+        if not any(m in _src for m in _ANNOTATION_MARKERS):
+            continue
+        for _m in re.finditer(r'@interface\s+(\w+)', _src):
+            _custom_meta_markers.add(f"@{_m.group(1)}")
+    _effective_markers = _ANNOTATION_MARKERS + tuple(_custom_meta_markers)
+
     _per_file: list[tuple[str, str, str, list[str], list[SymbolRecord]]] = []
     for rel_path in sorted(file_paths):
         abs_path = root / rel_path
@@ -2915,7 +2939,7 @@ def build_repo_ir(
         _meta_chars_read += len(source)
         # Fast pre-scan: if file has no relevant annotations skip full extraction.
         # Still register package/class name for same-package resolution.
-        if not any(marker in source for marker in _ANNOTATION_MARKERS):
+        if not any(marker in source for marker in _effective_markers):
             pkg_m = _PKG_RE.search(source)
             _pkg = pkg_m.group(1) if pkg_m else ""
             # Minimal class-name symbols for same-package map (no methods/fields)
@@ -4232,6 +4256,16 @@ def _resolve_target(
     return "not_found", set()
 
 
+_BLAST_SKIP_EDGE_TYPES: frozenset[str] = frozenset({"contained_in", "imports"})
+# 'contained_in': structural membership (method→enclosing class), not a caller.
+# 'imports':      Java import statements — any class that references the type in
+#                 an import declaration, including those that only use it as a
+#                 method-return type or catch-block type.  Import presence does NOT
+#                 imply a runtime dependency; including it produces false-positive
+#                 callers (e.g. sibling service classes that share a utility interface).
+#                 Consistent with spring_impact._SKIP_EDGE_TYPES.
+
+
 def _all_callers_from_rg(fqn: str, reverse_graph: dict[str, dict[str, list[str]]]) -> list[str]:
     """Return all callers of fqn from the reverse graph (all edge types).
 
@@ -4242,13 +4276,17 @@ def _all_callers_from_rg(fqn: str, reverse_graph: dict[str, dict[str, list[str]]
     CH-002 fix: for 'injects' edges, normalize field/constructor FQNs to their
     enclosing class.  e.g. pkg.ConsolidacionService.calcularField → pkg.ConsolidacionService
     so BFS can continue through DI injection chains and find controllers.
+
+    FP-001 fix: skip 'imports' edges — import declarations are not runtime
+    dependencies and produce false-positive callers (e.g. sibling classes that share
+    a utility interface but don't call the target).
     """
     entry = reverse_graph.get(fqn) or {}
     callers: list[str] = []
     seen: set[str] = set()
     for edge_type, fqn_list in entry.items():
-        if edge_type == "contained_in":
-            continue  # structural membership, not a caller
+        if edge_type in _BLAST_SKIP_EDGE_TYPES:
+            continue
         for c in fqn_list:
             normalized = _normalize_owner_fqn(c) if edge_type == "injects" else c
             if normalized not in seen:

{sourcecode-1.35.30 → sourcecode-1.35.32}/src/sourcecode/spring_impact.py

@@ -570,6 +570,9 @@ class ImpactOrchestrator:
         # When the queried class is an interface, BFS should also start from
         # implementation symbols so TX boundaries and callers on the impl are found.
         impl_graph = getattr(cir, "implementation_graph", None)
+        # Track original seed classes BEFORE CH-001a expansion so CH-001b does not
+        # cascade through interfaces shared by impl classes added here (false positives).
+        original_seed_classes: set[str] = {_class_of(s) for s in seed_fqns}
         if impl_graph is not None:
             seed_classes_ch001 = {_class_of(s) for s in seed_fqns}
             impl_seeds: list[str] = []
@@ -598,11 +601,14 @@ class ImpactOrchestrator:
         # Callers typically inject the interface type, so reverse-graph edges live on
         # the interface node, not on the implementation node.  Without this expansion,
         # querying 'OrderServiceImpl' finds 0 callers even though 36 classes inject it.
+        # IMPORTANT: only expand ORIGINAL user-query seeds, not classes added by CH-001a.
+        # Expanding CH-001a-added impls cascades through shared utility interfaces
+        # (e.g. RefByUuid) and produces false-positive callers from sibling implementors.
         if impl_graph is not None:
             current_seed_classes = {_class_of(s) for s in seed_fqns}
             iface_seeds: list[str] = []
             iface_classes_added: set[str] = set()
-            for seed_class in sorted(current_seed_classes):
+            for seed_class in sorted(original_seed_classes):
                 ifaces = impl_graph.interfaces_of(seed_class)
                 for iface_class in ifaces:
                     if iface_class in iface_classes_added or iface_class in current_seed_classes:

{sourcecode-1.35.30 → sourcecode-1.35.32}/src/sourcecode/spring_model.py

@@ -153,18 +153,45 @@ class BeanGraph:
         raw_ir = getattr(cir, "_raw_ir", {}) or {}
         nodes = (raw_ir.get("graph") or {}).get("nodes") or []
 
+        # Pass 1: build meta-bean-annotation map from annotation-type nodes.
+        # e.g. @DomainService (annotated with @Service) maps "@DomainService" → "service"
+        _meta_bean_stereotype: dict[str, str] = {}
         for node in nodes:
             if not isinstance(node, dict):
                 continue
+            if (node.get("symbol_kind") or node.get("type") or "") != "annotation":
+                continue
+            _ann_set = set(node.get("annotations") or [])
+            _match = _ann_set & _BEAN_ANNOTATIONS
+            if not _match:
+                continue
+            _fqn = node.get("fqn") or ""
+            if not _fqn:
+                continue
+            _simple = "@" + _fqn.split(".")[-1]
+            _bean_ann = next(iter(_match))
+            _meta_bean_stereotype[_simple] = _bean_ann.lstrip("@").lower()
+
+        # Pass 2: collect all bean nodes (direct or via meta-annotation).
+        for node in nodes:
+            if not isinstance(node, dict):
+                continue
+            if (node.get("symbol_kind") or node.get("type") or "") == "annotation":
+                continue  # annotation-type nodes are not beans
             ann_set = set(node.get("annotations") or [])
             match = ann_set & _BEAN_ANNOTATIONS
             if not match:
-                continue
+                meta_match = ann_set & set(_meta_bean_stereotype)
+                if not meta_match:
+                    continue
+                ann = next(iter(meta_match))
+                stereotype = _meta_bean_stereotype[ann]
+            else:
+                ann = next(iter(match))
+                stereotype = ann.lstrip("@").lower()
             fqn = node.get("fqn") or ""
             if not fqn:
                 continue
-            ann = next(iter(match))
-            stereotype = ann.lstrip("@").lower()
             beans[fqn] = BeanNode(
                 fqn=fqn,
                 stereotype=stereotype,

{sourcecode-1.35.30 → sourcecode-1.35.32}/src/sourcecode/spring_semantic.py

@@ -293,26 +293,53 @@ def build_tx_index(cir: "CanonicalRepositoryIR") -> TransactionBoundaryIndex:
         graph = raw_ir.get("graph") or {}
         nodes = graph.get("nodes") or []
 
+        # Pass 1: build meta-@Transactional map from annotation-type nodes.
+        # e.g. @ReadOnlyTransaction (annotated with @Transactional(readOnly=true))
+        # maps "@ReadOnlyTransaction" → "readOnly = true"
+        _meta_tx_args: dict[str, str] = {}
         for node in nodes:
             if not isinstance(node, dict):
                 continue
+            if (node.get("symbol_kind") or node.get("type") or "") != "annotation":
+                continue
+            ann_set = set(node.get("annotations") or [])
+            if "@Transactional" not in ann_set:
+                continue
+            _fqn = node.get("fqn") or node.get("symbol") or ""
+            if not _fqn:
+                continue
+            _simple = "@" + _fqn.split(".")[-1]
+            _av = node.get("annotation_values") or {}
+            _meta_tx_args[_simple] = _av.get("@Transactional", "")
 
-            annotations = node.get("annotations") or []
-            if "@Transactional" not in annotations:
+        # Pass 2: index all @Transactional boundaries (direct or via meta-annotation).
+        for node in nodes:
+            if not isinstance(node, dict):
                 continue
 
+            symbol_kind = node.get("symbol_kind") or node.get("type") or ""
+            if symbol_kind == "annotation":
+                continue  # annotation-type nodes are not TX boundaries
+
+            annotations = node.get("annotations") or []
+            ann_values = node.get("annotation_values") or {}
+
+            if "@Transactional" in annotations:
+                raw_args = ann_values.get("@Transactional", "")
+            else:
+                # Check meta-annotations (composed @Transactional)
+                meta_key = next((a for a in annotations if a in _meta_tx_args), None)
+                if meta_key is None:
+                    continue
+                raw_args = _meta_tx_args[meta_key]
+
             fqn = node.get("fqn") or node.get("symbol") or ""
             if not fqn:
                 continue
 
-            symbol_kind = node.get("symbol_kind") or node.get("type") or ""
             source_file = node.get("source_file") or node.get("declaring_file") or ""
             modifiers = node.get("modifiers") or []
 
-            # annotation_values is stored per-symbol in the graph node
-            ann_values = node.get("annotation_values") or {}
-            raw_args = ann_values.get("@Transactional", "")
-
             # Determine scope: class-level or method-level
             if symbol_kind in ("class", "interface", "enum"):
                 scope = "class"