sourcecode 1.31.2__tar.gz → 1.31.4__tar.gz

{sourcecode-1.31.2 → sourcecode-1.31.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.31.2
+Version: 1.31.4
 Summary: Deterministic codebase context for AI coding agents
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -225,7 +225,7 @@ Description-Content-Type: text/markdown
 
 **Deterministic, behavior-aware codebase context for AI agents and PR review.**
 
-![Version](https://img.shields.io/badge/version-1.31.2-blue)
+![Version](https://img.shields.io/badge/version-1.31.4-blue)
 ![Python](https://img.shields.io/badge/python-3.10%2B-green)
 
 ---
@@ -261,7 +261,7 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.31.2
+# sourcecode 1.31.4
 ```
 
 ---

{sourcecode-1.31.2 → sourcecode-1.31.4}/README.md

@@ -2,7 +2,7 @@
 
 **Deterministic, behavior-aware codebase context for AI agents and PR review.**
 
-![Version](https://img.shields.io/badge/version-1.31.2-blue)
+![Version](https://img.shields.io/badge/version-1.31.4-blue)
 ![Python](https://img.shields.io/badge/python-3.10%2B-green)
 
 ---
@@ -38,7 +38,7 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.31.2
+# sourcecode 1.31.4
 ```
 
 ---

{sourcecode-1.31.2 → sourcecode-1.31.4}/pyproject.toml

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

{sourcecode-1.31.2 → sourcecode-1.31.4}/src/sourcecode/__init__.py

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

{sourcecode-1.31.2 → sourcecode-1.31.4}/src/sourcecode/cli.py

@@ -1849,6 +1849,11 @@ def prepare_context_cmd(
         "--include-config",
         help="(generate-tests) Include tooling config files (*.conf.js, .eslintrc*, etc.) in test_gaps. Excluded by default.",
     ),
+    all_gaps: bool = typer.Option(
+        False,
+        "--all",
+        help="(generate-tests) Return the full test_gaps list without truncating to top 20.",
+    ),
 ) -> None:
     """Task-specific context for AI coding agents.
 
@@ -1930,7 +1935,7 @@ def prepare_context_cmd(
             _sys.stderr.flush()
     _t0 = _time.perf_counter()
     try:
-        output = builder.build(task, since=since, symptom=symptom, fast=fast, include_config=include_config)
+        output = builder.build(task, since=since, symptom=symptom, fast=fast, include_config=include_config, all_gaps=all_gaps)
     finally:
         _progress.finish()
     _t_total = (_time.perf_counter() - _t0) * 1000
@@ -1957,8 +1962,8 @@ def prepare_context_cmd(
         },
         "explain": {
             "project_summary": True, "architecture_summary": True,
-            "relevant_files": True, "key_dependencies": True,
-            "gaps": True, "confidence": True,
+            "relevant_files": False, "key_dependencies": True,
+            "gaps": False, "confidence": True,
             "suspected_areas": False, "improvement_opportunities": False,
             "test_gaps": False, "code_notes_summary": False,
             "changed_files": False, "affected_entry_points": False,
@@ -2467,6 +2472,11 @@ def _extract_java_endpoints(root: "Path") -> "dict[str, Any]":
     _CLASS_PATH_RE = _re.compile(
         r'@RequestMapping\s*\(\s*(?:value\s*=\s*)?["\']([^"\']+)["\']',
     )
+    # Handles array syntax: @RequestMapping({"/v1/foo", "/v1/bar"})
+    _CLASS_ARRAY_PATH_RE = _re.compile(r'@RequestMapping\s*\(\s*\{([^}]*)\}')
+    _QUOTED_STR_RE = _re.compile(r'"([^"]+)"')
+    _REQUEST_METHOD_VERB_RE = _re.compile(r'method\s*=\s*RequestMethod\.([A-Z]+)')
+    _VALUE_PATH_RE = _re.compile(r'value\s*=\s*"([^"]+)"')
 
     _HTTP_METHOD_MAP = {
         "Get": "GET", "Post": "POST", "Put": "PUT",
@@ -2502,27 +2512,66 @@ def _extract_java_endpoints(root: "Path") -> "dict[str, Any]":
         cls_m = _CLASS_RE.search(content)
         class_name = cls_m.group(1) if cls_m else java_file.stem
 
-        # Extract class-level base path from @RequestMapping on the class
-        class_base = ""
+        # Extract class-level base path and locate class body start
         lines = content.splitlines()
+
+        # First pass: find class/interface declaration line index
+        class_body_start = 0
         for i, line in enumerate(lines):
-            if "@RequestMapping" in line and i < len(lines) - 1:
-                # Check if next non-blank line is class declaration or it's on same block
-                block = "\n".join(lines[max(0, i - 1): i + 5])
+            stripped_l = line.strip()
+            if (not stripped_l.startswith("//") and not stripped_l.startswith("*")
+                    and ("class " in stripped_l or "interface " in stripped_l)
+                    and _CLASS_RE.search(stripped_l)):
+                class_body_start = i + 1
+                break
+
+        # Second pass: extract class-level @RequestMapping path (only before class body).
+        # Supports both single-string and array syntax (Bug #1B).
+        search_end = class_body_start if class_body_start else len(lines)
+        class_bases: list[str] = [""]  # default: no prefix
+        for i in range(search_end):
+            sl = lines[i].strip()
+            if sl.startswith("//") or sl.startswith("*"):
+                continue
+            if "@RequestMapping" in lines[i]:
+                # Cap block to search_end so method annotations inside the class body
+                # cannot be matched as the class-level prefix (Bug #1B).
+                block = "\n".join(lines[max(0, i - 1): min(i + 5, search_end + 1)])
                 if "class " in block or "interface " in block:
                     path_m = _CLASS_PATH_RE.search(block)
                     if path_m:
-                        class_base = path_m.group(1).rstrip("/")
-                    break
-
-        # Extract method-level endpoints
-        # Parse line-by-line to associate annotations with methods
+                        class_bases = [path_m.group(1).rstrip("/")]
+                    else:
+                        arr_m = _CLASS_ARRAY_PATH_RE.search(block)
+                        if arr_m:
+                            paths = _QUOTED_STR_RE.findall(arr_m.group(1))
+                            if paths:
+                                class_bases = [p.rstrip("/") for p in paths]
+                break
+
+        # Extract method-level endpoints starting from inside class body.
+        # Bug #1A fix: track block comments and skip // lines before annotation checks.
         pending_annotations: list[tuple[str, str]] = []  # (http_verb, path_suffix)
         pending_filtro: Optional[str] = None
+        in_block_comment = False
 
-        for i, line in enumerate(lines):
+        for i in range(class_body_start, len(lines)):
+            line = lines[i]
             stripped = line.strip()
 
+            # Block comment state tracking (Bug #1A)
+            if in_block_comment:
+                if "*/" in stripped:
+                    in_block_comment = False
+                continue
+            if stripped.startswith("/*"):
+                if "*/" not in stripped:
+                    in_block_comment = True
+                continue
+            # Skip line comments (Bug #1A)
+            if stripped.startswith("//"):
+                continue
+
             # Check for @M3FiltroSeguridad
             fm = _FILTRO_RE.search(stripped)
             if fm:
@@ -2535,6 +2584,19 @@ def _extract_java_endpoints(root: "Path") -> "dict[str, Any]":
                 verb_key = hm.group(1)
                 http_verb = _HTTP_METHOD_MAP.get(verb_key, "GET")
                 path_suffix = (hm.group(2) or "").strip()
+
+                # For @RequestMapping: resolve HTTP method from method= attribute
+                if verb_key == "Request":
+                    annotation_block = "\n".join(lines[i:min(i + 5, len(lines))])
+                    vm = _REQUEST_METHOD_VERB_RE.search(annotation_block)
+                    if vm:
+                        http_verb = vm.group(1)
+                    # If path not captured (method= precedes value=), try value= extraction
+                    if not path_suffix:
+                        vp = _VALUE_PATH_RE.search(annotation_block)
+                        if vp:
+                            path_suffix = vp.group(1)
+
                 pending_annotations.append((http_verb, path_suffix))
                 continue
 
@@ -2544,30 +2606,30 @@ def _extract_java_endpoints(root: "Path") -> "dict[str, Any]":
                 handler = mm.group(1) if mm else ""
                 if handler and not handler.startswith("class"):
                     for http_verb, path_suffix in pending_annotations:
-                        full_path = (class_base + "/" + path_suffix).replace("//", "/").rstrip("/") or "/"
-                        if not full_path.startswith("/"):
-                            full_path = "/" + full_path
-                        key = (class_name, handler, http_verb)
-                        if key not in seen:
-                            seen.add(key)
-                            entry: dict[str, Any] = {
-                                "method": http_verb,
-                                "path": full_path,
-                                "controller": class_name,
-                                "handler": handler,
-                            }
-                            if pending_filtro:
-                                entry["required_permission"] = pending_filtro
-                            endpoints.append(entry)
+                        for _cb in class_bases:  # Bug #1B: one endpoint per class prefix
+                            full_path = (_cb + "/" + path_suffix).replace("//", "/").rstrip("/") or "/"
+                            if not full_path.startswith("/"):
+                                full_path = "/" + full_path
+                            key = (class_name, handler, http_verb, _cb)
+                            if key not in seen:
+                                seen.add(key)
+                                entry: dict[str, Any] = {
+                                    "method": http_verb,
+                                    "path": full_path,
+                                    "controller": class_name,
+                                    "handler": handler,
+                                }
+                                if pending_filtro:
+                                    entry["required_permission"] = pending_filtro
+                                endpoints.append(entry)
                     pending_annotations = []
                     pending_filtro = None
                     continue
 
-            # Non-annotation, non-method line — reset if it's a closing brace or blank
-            if stripped in ("}", "{", "") or stripped.startswith("//") or stripped.startswith("*"):
-                if stripped == "}":
-                    pending_annotations = []
-                    pending_filtro = None
+            # Non-annotation, non-method line — reset on closing brace
+            if stripped == "}":
+                pending_annotations = []
+                pending_filtro = None
 
     endpoints.sort(key=lambda e: (e.get("controller", ""), e.get("path", "")))
     undocumented = sum(1 for e in endpoints if "required_permission" not in e)

{sourcecode-1.31.2 → sourcecode-1.31.4}/src/sourcecode/prepare_context.py

@@ -721,7 +721,7 @@ class TaskContextBuilder:
     def __init__(self, root: Path) -> None:
         self.root = root
 
-    def build(self, task_name: str, *, since: Optional[str] = None, symptom: Optional[str] = None, fast: bool = False, include_config: bool = False) -> TaskOutput:
+    def build(self, task_name: str, *, since: Optional[str] = None, symptom: Optional[str] = None, fast: bool = False, include_config: bool = False, all_gaps: bool = False) -> TaskOutput:
         if task_name not in TASKS:
             raise ValueError(
                 f"Unknown task '{task_name}'. Available: {', '.join(TASKS)}"
@@ -1763,14 +1763,18 @@ class TaskContextBuilder:
                         "_rank": _pub_count + _ann_count * 2,
                     })
 
-                _java_candidates.sort(key=lambda x: -x["_rank"])
+                _java_candidates.sort(
+                    key=lambda x: -(x["public_method_count"] * (1.5 if x["has_spring_annotations"] else 1.0))
+                )
+                _top = _java_candidates if all_gaps else _java_candidates[:20]
                 test_gaps = [
                     {
                         "path": c["path"],
                         "public_method_count": c["public_method_count"],
                         "has_spring_annotations": c["has_spring_annotations"],
+                        "rank_score": round(c["public_method_count"] * (1.5 if c["has_spring_annotations"] else 1.0), 1),
                     }
-                    for c in _java_candidates
+                    for c in _top
                 ]
             else:
                 # Non-Java algorithm (unchanged)
@@ -2206,8 +2210,67 @@ class TaskContextBuilder:
                 "refactor": max(15, min(30, _repo_size // 120)),
             }
             _budget = _task_budget.get(task_name, 15)
-            _selected = _ctx.select_subgraph(_ns, contracts=[], budget=_budget, min_score=0.15)
+            _selected = list(_ctx.select_subgraph(_ns, contracts=[], budget=_budget, min_score=0.15))
             _rf_map = {path: rf for _, path, rf in scored}
+
+            # Bug #3: onboard must cover ≥3 arch layers (controllers/services/domain/repositories).
+            if task_name == "onboard":
+                def _arch_layer(p: str) -> str:
+                    n = Path(p).name.lower()
+                    if "controller" in n:
+                        return "controllers"
+                    if "repository" in n or "mapper" in n or "dao" in n:
+                        return "repositories"
+                    if "service" in n:
+                        return "services"
+                    pn = p.replace("\\", "/")
+                    if "entity" in n or "/entity/" in pn or "/domain/" in pn or "/model/" in pn:
+                        return "domain"
+                    return "other"
+
+                _REQUIRED = {"controllers", "services", "repositories", "domain"}
+                _covered = {_arch_layer(p) for p in _selected} & _REQUIRED
+                _missing = _REQUIRED - _covered
+                if len(_covered) < 3 and _missing:
+                    _sel_set = set(_selected)
+                    # First pass: inject from already-scored files
+                    for _, _p, _ in sorted(scored, key=lambda x: -x[0]):
+                        if len(_covered) >= 3:
+                            break
+                        if _p in _sel_set or _p not in _rf_map:
+                            continue
+                        _layer = _arch_layer(_p)
+                        if _layer in _missing:
+                            _selected.append(_p)
+                            _sel_set.add(_p)
+                            _covered.add(_layer)
+                            _missing.discard(_layer)
+                    # Second pass: fallback scan of all_paths when scored files
+                    # don't cover enough layers (e.g. all Java files scored ≤ 0
+                    # due to auxiliary/example package detection).
+                    if len(_covered) < 3 and _missing:
+                        _NON_TEST = ("/test/", "/tests/", "/spec/")
+                        for _p in all_paths:
+                            if len(_covered) >= 3:
+                                break
+                            if _p in _sel_set:
+                                continue
+                            if any(s in _p.replace("\\", "/") for s in _NON_TEST):
+                                continue
+                            _layer = _arch_layer(_p)
+                            if _layer not in _missing:
+                                continue
+                            _rf_map[_p] = RelevantFile(
+                                path=_p,
+                                role="source",
+                                score=0.1,
+                                reason="layer coverage (onboard)",
+                            )
+                            _selected.append(_p)
+                            _sel_set.add(_p)
+                            _covered.add(_layer)
+                            _missing.discard(_layer)
+
             return [_rf_map[p] for p in _selected if p in _rf_map]
         except Exception:
             return [f for _, _, f in scored[:15]]

sourcecode-1.31.4/tests/test_bug_fixes_v1312.py

@@ -0,0 +1,239 @@
+"""Tests for v1.31.2 bug fixes.
+
+  BUG #1  endpoints: class-level @RequestMapping leaked into method loop
+          → all methods showed class path only (or double prefix)
+  BUG #2  endpoints: @RequestMapping(method=RequestMethod.DELETE) resolved as GET
+"""
+from __future__ import annotations
+
+import json
+import textwrap
+from pathlib import Path
+
+import pytest
+from typer.testing import CliRunner
+
+from sourcecode.cli import app, _extract_java_endpoints
+
+runner = CliRunner()
+
+
+# ── helpers ───────────────────────────────────────────────────────────────────
+
+def _write_java(tmp_path: Path, filename: str, source: str) -> Path:
+    f = tmp_path / filename
+    f.write_text(textwrap.dedent(source), encoding="utf-8")
+    return tmp_path
+
+
+# ── BUG #1: path concatenation ─────────────────────────────────────────────
+
+
+def test_acceso_rol_paths_correct(tmp_path):
+    """AccesoRolRestController: each method gets class_base + method_path."""
+    _write_java(tmp_path, "AccesoRolRestController.java", """\
+        @RestController
+        @RequestMapping("/v1/accesoRol")
+        public class AccesoRolRestController {
+
+            @M3FiltroSeguridad("accesoRol")
+            @GetMapping("/list")
+            public ResponseEntity<?> list() { return null; }
+
+            @PostMapping("/create")
+            public ResponseEntity<?> create() { return null; }
+
+            @DeleteMapping("/{id}")
+            public ResponseEntity<?> delete() { return null; }
+        }
+    """)
+    result = _extract_java_endpoints(tmp_path)
+    paths = {e["path"] for e in result["endpoints"]}
+    assert "/v1/accesoRol/list" in paths, f"expected /v1/accesoRol/list, got {paths}"
+    assert "/v1/accesoRol/create" in paths
+    assert "/v1/accesoRol/{id}" in paths
+    # class path alone must NOT appear as a standalone endpoint
+    assert "/v1/accesoRol" not in paths
+    # no double-prefix
+    assert not any("/v1/accesoRol/v1/accesoRol" in p for p in paths)
+
+
+def test_no_double_prefix(tmp_path):
+    """Class path must not be concatenated with itself."""
+    _write_java(tmp_path, "PortalController.java", """\
+        @RestController
+        @RequestMapping("/v1/portal/acreditaciones")
+        public class PortalController {
+
+            @GetMapping("/all")
+            public List<?> getAll() { return null; }
+        }
+    """)
+    result = _extract_java_endpoints(tmp_path)
+    paths = {e["path"] for e in result["endpoints"]}
+    assert "/v1/portal/acreditaciones/all" in paths
+    assert not any("acreditaciones/v1" in p for p in paths)
+
+
+def test_method_count_one_per_handler(tmp_path):
+    """Each handler must produce exactly one endpoint, not two."""
+    _write_java(tmp_path, "FooController.java", """\
+        @RestController
+        @RequestMapping("/api")
+        public class FooController {
+
+            @GetMapping("/items")
+            public List<?> items() { return null; }
+
+            @PostMapping("/items")
+            public void save() { }
+        }
+    """)
+    result = _extract_java_endpoints(tmp_path)
+    assert result["total"] == 2
+    handlers = [e["handler"] for e in result["endpoints"]]
+    assert len(handlers) == len(set(handlers)), "duplicate handlers found"
+
+
+def test_no_class_level_path_in_method_loop(tmp_path):
+    """Class-level @RequestMapping must not pollute method loop."""
+    _write_java(tmp_path, "SimpleController.java", """\
+        @RestController
+        @RequestMapping(value = "/base")
+        public class SimpleController {
+
+            @GetMapping
+            public String root() { return "ok"; }
+        }
+    """)
+    result = _extract_java_endpoints(tmp_path)
+    # root() with @GetMapping (no path) → /base
+    assert result["total"] == 1
+    assert result["endpoints"][0]["path"] == "/base"
+    assert result["endpoints"][0]["handler"] == "root"
+
+
+# ── BUG #2: HTTP method resolution ────────────────────────────────────────────
+
+
+def test_request_mapping_delete_method(tmp_path):
+    """@RequestMapping(method=RequestMethod.DELETE) must resolve to DELETE."""
+    _write_java(tmp_path, "RolController.java", """\
+        @RestController
+        @RequestMapping("/v1/rol")
+        public class RolController {
+
+            @RequestMapping(value = "/borrarMultiple", method = RequestMethod.DELETE)
+            public ResponseEntity<?> borrarMultiple() { return null; }
+        }
+    """)
+    result = _extract_java_endpoints(tmp_path)
+    assert result["total"] == 1
+    ep = result["endpoints"][0]
+    assert ep["method"] == "DELETE", f"expected DELETE, got {ep['method']}"
+    assert ep["handler"] == "borrarMultiple"
+    assert ep["path"] == "/v1/rol/borrarMultiple"
+
+
+def test_request_mapping_post_method(tmp_path):
+    """@RequestMapping(method=RequestMethod.POST) must resolve to POST."""
+    _write_java(tmp_path, "ItemController.java", """\
+        @RestController
+        @RequestMapping("/items")
+        public class ItemController {
+
+            @RequestMapping(value = "/create", method = RequestMethod.POST)
+            public ResponseEntity<?> create() { return null; }
+        }
+    """)
+    result = _extract_java_endpoints(tmp_path)
+    ep = result["endpoints"][0]
+    assert ep["method"] == "POST"
+
+
+def test_request_mapping_no_method_defaults_get(tmp_path):
+    """@RequestMapping without method= defaults to GET."""
+    _write_java(tmp_path, "InfoController.java", """\
+        @RestController
+        public class InfoController {
+
+            @RequestMapping("/health")
+            public String health() { return "ok"; }
+        }
+    """)
+    result = _extract_java_endpoints(tmp_path)
+    assert result["endpoints"][0]["method"] == "GET"
+
+
+def test_request_mapping_method_before_value(tmp_path):
+    """@RequestMapping(method=DELETE, value="/path") — method= before value=."""
+    _write_java(tmp_path, "OrderController.java", """\
+        @RestController
+        @RequestMapping("/orders")
+        public class OrderController {
+
+            @RequestMapping(method = RequestMethod.DELETE, value = "/cancel")
+            public void cancel() { }
+        }
+    """)
+    result = _extract_java_endpoints(tmp_path)
+    ep = result["endpoints"][0]
+    assert ep["method"] == "DELETE"
+    assert ep["path"] == "/orders/cancel"
+
+
+def test_delete_mapping_annotation(tmp_path):
+    """@DeleteMapping must still resolve to DELETE (regression guard)."""
+    _write_java(tmp_path, "TaskController.java", """\
+        @RestController
+        @RequestMapping("/tasks")
+        public class TaskController {
+
+            @DeleteMapping("/{id}")
+            public void remove() { }
+        }
+    """)
+    result = _extract_java_endpoints(tmp_path)
+    assert result["endpoints"][0]["method"] == "DELETE"
+
+
+# ── combined: paths + methods ─────────────────────────────────────────────────
+
+
+def test_mixed_controller(tmp_path):
+    """Full CRUD controller: correct paths and methods for all verbs."""
+    _write_java(tmp_path, "CrudController.java", """\
+        @RestController
+        @RequestMapping("/v1/items")
+        public class CrudController {
+
+            @GetMapping
+            public List<?> getAll() { return null; }
+
+            @GetMapping("/{id}")
+            public Object getById() { return null; }
+
+            @PostMapping
+            public Object create() { return null; }
+
+            @PutMapping("/{id}")
+            public Object update() { return null; }
+
+            @DeleteMapping("/{id}")
+            public void delete() { }
+
+            @RequestMapping(value = "/bulk", method = RequestMethod.DELETE)
+            public void deleteBulk() { }
+        }
+    """)
+    result = _extract_java_endpoints(tmp_path)
+    by_handler = {e["handler"]: e for e in result["endpoints"]}
+
+    assert by_handler["getAll"]["method"] == "GET"
+    assert by_handler["getAll"]["path"] == "/v1/items"
+    assert by_handler["getById"]["path"] == "/v1/items/{id}"
+    assert by_handler["create"]["method"] == "POST"
+    assert by_handler["update"]["method"] == "PUT"
+    assert by_handler["delete"]["method"] == "DELETE"
+    assert by_handler["deleteBulk"]["method"] == "DELETE"
+    assert by_handler["deleteBulk"]["path"] == "/v1/items/bulk"