sourcecode 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

sourcecode/__init__.py

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

sourcecode/architecture_analyzer.py

@@ -183,7 +183,11 @@ class ArchitectureAnalyzer:
         if ddd_result is not None:
             ddd_pattern, ddd_layers, ddd_contexts, ddd_layer_names = ddd_result
             domains_for_ddd = self._cluster_domains(filtered) if len(filtered) >= 2 else []
-            bc_list = [BoundedContext(name=n, confidence="high") for n in ddd_contexts]
+            module_files = self._build_ddd_module_files(sm.file_paths, ddd_contexts)
+            bc_list = [
+                BoundedContext(name=n, modules=module_files.get(n, []), confidence="high")
+                for n in ddd_contexts
+            ]
             return ArchitectureAnalysis(
                 requested=True,
                 pattern=ddd_pattern,
@@ -414,6 +418,22 @@ class ArchitectureAnalyzer:
         ]
         return "ddd", arch_layers, bounded_context_names, ddd_layer_names
 
+    def _build_ddd_module_files(
+        self, paths: list[str], bounded_context_names: list[str]
+    ) -> "dict[str, list[str]]":
+        """Build a mapping of DDD module name → list of file paths."""
+        _DDD_LAYERS = frozenset({"application", "domain", "infrastructure"})
+        module_files: dict[str, list[str]] = {}
+        for p in paths:
+            parts = p.replace("\\", "/").split("/")
+            for i, part in enumerate(parts):
+                if part in _DDD_LAYERS and i >= 2:
+                    mod = parts[i - 1]
+                    if mod in bounded_context_names:
+                        module_files.setdefault(mod, []).append(p)
+                    break
+        return module_files
+
     def _is_tooling(self, path: str) -> bool:
         norm = path.replace("\\", "/")
         return any(norm.startswith(p) for p in _TOOLING_PREFIXES)

sourcecode/ast_extractor.py

@@ -79,6 +79,7 @@ _LANGUAGE_MAP: dict[str, str] = {
     ".jsx": "jsx",
     ".mjs": "javascript",
     ".cjs": "javascript",
+    ".java": "java",
 }
 
 _REACT_HOOKS: frozenset[str] = frozenset({
@@ -938,6 +939,92 @@ def _extract_python(path: str, source: str) -> FileContract:
     )
 
 
+# ---------------------------------------------------------------------------
+# Minimal Java extraction (regex-based, no AST)
+# ---------------------------------------------------------------------------
+
+_JAVA_CLASS_DECL_RE = re.compile(
+    r'public\s+(?:(?:abstract|final|static)\s+)*(class|interface|enum)\s+(\w+)'
+    r'(?:\s+extends\s+([\w.]+))?(?:\s+implements\s+([\w.,\s]+?))?(?=\s*[\{<])',
+    re.MULTILINE,
+)
+_JAVA_METHOD_SIG_RE = re.compile(
+    r'^\s{0,12}public\s+[^\{]+\(',
+    re.MULTILINE,
+)
+_JAVA_IMPORT_RE = re.compile(r'^import\s+(?:static\s+)?([^;\s]+)\s*;', re.MULTILINE)
+
+
+def _extract_java(path: str, source: str) -> FileContract:
+    exports: list[ExportRecord] = []
+    types: list[TypeDefinition] = []
+    functions: list[FunctionSignature] = []
+    imports: list[ImportRecord] = []
+
+    # Class / interface / enum declarations
+    for m in _JAVA_CLASS_DECL_RE.finditer(source):
+        name = m.group(2)
+        extends_str = m.group(3)
+        implements_str = m.group(4)
+        all_extends: list[str] = []
+        if extends_str:
+            all_extends.append(extends_str.strip())
+        if implements_str:
+            all_extends.extend(i.strip() for i in implements_str.split(",") if i.strip())
+        types.append(TypeDefinition(name=name, kind="class", fields=[], extends=all_extends))
+        exports.append(ExportRecord(name=name, kind="class"))
+
+    class_names = {t.name for t in types}
+
+    # Public method signatures (one-line heuristic)
+    seen_methods: set[str] = set()
+    for m in _JAVA_METHOD_SIG_RE.finditer(source):
+        sig_text = m.group(0).strip()
+        name_match = re.search(r'(\w+)\s*\($', sig_text)
+        if not name_match:
+            name_match = re.search(r'(\w+)\s*\(', sig_text)
+        if not name_match:
+            continue
+        mname = name_match.group(1)
+        if mname in class_names or mname in seen_methods or mname in {"if", "for", "while", "switch"}:
+            continue
+        seen_methods.add(mname)
+        functions.append(FunctionSignature(
+            name=mname,
+            signature=sig_text,
+            async_=False,
+            exported=True,
+            return_type=None,
+        ))
+
+    # Import statements
+    seen_sources: set[str] = set()
+    for m in _JAVA_IMPORT_RE.finditer(source):
+        full_import = m.group(1).strip()
+        if full_import not in seen_sources:
+            seen_sources.add(full_import)
+            imports.append(ImportRecord(source=full_import, kind="named", symbols=[]))
+
+    # External deps: top-2 package segments, skip java.* / javax.*
+    deps = sorted({
+        ".".join(imp.source.split(".")[:2])
+        for imp in imports
+        if not imp.source.startswith("java.") and not imp.source.startswith("javax.")
+        and len(imp.source.split(".")) >= 2
+    })
+
+    return FileContract(
+        path=path,
+        language="java",
+        exports=exports,
+        imports=sorted(imports, key=lambda i: i.source)[:30],
+        functions=sorted(functions, key=lambda f: f.name)[:20],
+        types=sorted(types, key=lambda t: t.name),
+        dependencies=deps[:20],
+        extraction_method="heuristic",
+    )
+
+
 # ---------------------------------------------------------------------------
 # Role detection
 # ---------------------------------------------------------------------------
@@ -1048,6 +1135,8 @@ class AstExtractor:
 
         if language == "python":
             contract = _extract_python(rel_path, source)
+        elif language == "java":
+            contract = _extract_java(rel_path, source)
         else:
             if self._ensure_ts():
                 lang_obj = _get_ts_lang(language)

sourcecode/cli.py

@@ -790,7 +790,7 @@ def main(
     # Require at least 8: src(1)+main(2)+java(3)+com(4)+co(5)+app(6)+module(7)+file.
     _java_manifest_names = {"pom.xml", "build.gradle", "build.gradle.kts"}
     _is_java = any(Path(m).name in _java_manifest_names for m in manifests)
-    _java_min_depth = 8
+    _java_min_depth = 10
     effective_depth = max(depth, _java_min_depth) if _is_java and depth < _java_min_depth else depth
 
     # --agent: enable signal analyzers; output via agent_view (not compact)
@@ -1270,10 +1270,24 @@ def main(
             and d.scope not in {"dev"}
         ]
 
-        def _dep_sort_key(d: Any) -> tuple[int, int, str]:
+        _JAVA_SEMANTIC_PRIORITY: dict[str, int] = {
+            "spring-boot": 0, "spring-security": 1, "mybatis": 2,
+            "poi": 3, "pdfbox": 4, "jackson": 5, "jjwt": 6,
+        }
+
+        def _java_priority(d: Any) -> int:
+            if d.ecosystem != "java":
+                return 99
+            art = (d.name.split(":")[-1] if ":" in d.name else d.name).lower()
+            for key, pri in _JAVA_SEMANTIC_PRIORITY.items():
+                if key in art:
+                    return pri
+            return 50
+
+        def _dep_sort_key(d: Any) -> tuple[int, int, int, str]:
             role_order = _ROLE_PRIORITY.get(d.role or "runtime", 5)
             eco_order = 0 if d.ecosystem == primary_ecosystem else 1
-            return (role_order, eco_order, d.name.lower())
+            return (role_order, eco_order, _java_priority(d), d.name.lower())
 
         _seen_dep_names: set[str] = set()
         _deduped_deps: list[Any] = []
@@ -1281,7 +1295,7 @@ def main(
             if d.name not in _seen_dep_names:
                 _seen_dep_names.add(d.name)
                 _deduped_deps.append(d)
-        sm.key_dependencies = _deduped_deps[:15]
+        sm.key_dependencies = _deduped_deps  # no cap — all direct deps included
 
     # LQN-02: deterministic NL summary
     sm.project_summary = ProjectSummarizer(target).generate(sm)
@@ -1376,8 +1390,15 @@ 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
     if _is_contract_mode:
         from sourcecode.contract_pipeline import ContractPipeline
         from sourcecode.contract_model import ContractSummary as _ContractSummary
@@ -1402,6 +1423,7 @@ def main(
             )
         except Exception as _exc:
             typer.echo(f"[error] contract pipeline failed: {_exc}", err=True)
+            _pipeline_error = True
             _contracts = []
             _contract_summary = _ContractSummary(
                 mode=mode,
@@ -1512,6 +1534,9 @@ def main(
     # 6. Write output (CLI-04)
     write_output(content, output=output)
 
+    if _pipeline_error:
+        raise typer.Exit(code=2)
+
     # 7. Clipboard copy (--copy / -c)
     if copy and output is None:
         _trimmed = content.strip()

sourcecode/confidence_analyzer.py

@@ -193,6 +193,27 @@ class ConfidenceAnalyzer:
                 impact="low",
             ))
 
+        # ── Java test coverage gap check (P2-A) ──────────────────────────────
+        _java_all = [p for p in sm.file_paths if p.endswith(".java")]
+        _java_tests = [
+            p for p in _java_all
+            if "/test/" in p.replace("\\", "/") or "/tests/" in p.replace("\\", "/")
+            or Path(p).stem.endswith(("Test", "Tests", "IT", "Spec"))
+        ]
+        _java_prod = [p for p in _java_all if p not in set(_java_tests)]
+        if _java_prod and len(_java_prod) >= 10:
+            _ratio = len(_java_tests) / len(_java_prod)
+            if _ratio < 0.05:
+                gaps.append(AnalysisGap(
+                    area="testing",
+                    reason=(
+                        f"Backend test coverage critical: {len(_java_tests)} test files "
+                        f"for {len(_java_prod)} Java files "
+                        f"({_ratio:.1%})"
+                    ),
+                    impact="high",
+                ))
+
         # ── Compute overall confidence ─────────────────────────────────────────
         # Stack: use best manifest-detected stack, fall back to min
         manifest_stacks = [s for s in sm.stacks if s.detection_method != "heuristic"]

sourcecode/contract_pipeline.py

@@ -370,7 +370,15 @@ class ContractPipeline:
         """
         candidates = _find_symbol_files(root, symbol, known_paths, engine)
         if not candidates:
-            return []
+            return [], {
+                "symbol": symbol,
+                "definers_found": 0,
+                "importers_found": 0,
+                "importers_returned": 0,
+                "references_found": 0,
+                "total_returned": 0,
+                "truncated": False,
+            }
 
         extra: list[FileContract] = []
         for rel_path in candidates[:300]:  # cap to prevent excessive extraction
@@ -577,7 +585,7 @@ def _find_symbol_files(
                 "grep", "-rl",
                 "--include=*.ts", "--include=*.tsx",
                 "--include=*.js", "--include=*.jsx",
-                "--include=*.py",
+                "--include=*.py", "--include=*.java",
                 symbol, ".",
             ],
             cwd=str(root),

sourcecode/dependency_analyzer.py

@@ -127,6 +127,22 @@ def _infer_role(name: str, ecosystem: str, scope: str) -> str:
             return "infra"
         return "runtime"
 
+    if ecosystem == "java":
+        artifact = n.split(":")[-1] if ":" in n else n
+        if any(x in artifact for x in ("spring-boot", "spring-security")):
+            return "runtime"
+        if any(x in artifact for x in ("spring-web", "spring-mvc", "spring-core", "spring-context")):
+            return "runtime"
+        if any(x in artifact for x in ("mybatis", "hibernate", "jpa", "druid", "datasource")):
+            return "infra"
+        if any(x in artifact for x in ("jackson", "gson", "fastjson")):
+            return "serialization"
+        if any(x in artifact for x in ("poi", "pdfbox", "itext", "openpdf")):
+            return "parsing"
+        if any(x in artifact for x in ("jjwt", "nimbus-jose")):
+            return "runtime"
+        return "devtool" if is_dev else "runtime"
+
     return "devtool" if is_dev else "runtime"
 
 

sourcecode/detectors/java.py

@@ -25,8 +25,18 @@ _CONTROLLER_ADVICE_RE = re.compile(r'@ControllerAdvice\b')
 _WEB_FILTER_RE = re.compile(r'@WebFilter\b')
 _FILTER_BEAN_RE = re.compile(r'FilterRegistrationBean\b')
 # Extracts path from @RequestMapping("/v1/foo"), @GetMapping("/bar"), etc.
+# Handles attribute order: value= may come after method= in legacy @RequestMapping style.
 _HTTP_PATH_RE = re.compile(
-    r'@(?:Request|Get|Post|Put|Delete|Patch)Mapping\s*\(\s*(?:value\s*=\s*)?["\']([^"\']+)["\']'
+    r'@(?:Request|Get|Post|Put|Delete|Patch)Mapping\s*\([^)]*?(?:value\s*=\s*)?["\']([^"\']+)["\']'
+)
+_REQUEST_METHOD_VERB_RE = re.compile(
+    r'method\s*=\s*RequestMethod\.([A-Z]+)'
+)
+# @M3FiltroSeguridad custom security annotation
+_M3_FILTRO_RE = re.compile(r'@M3FiltroSeguridad\b')
+_M3_FILTRO_PARAMS_RE = re.compile(
+    r'@M3FiltroSeguridad\s*\(\s*(?:nombreRecurso\s*=\s*"([^"]*)")?'
+    r'(?:[^)]*nivelRequerido\s*=\s*(\d+))?'
 )
 
 
@@ -149,16 +159,29 @@ class JavaDetector(AbstractDetector):
 
         # Quick pre-filter before running regexes
         if ("Controller" not in content and "Filter" not in content
-                and "ControllerAdvice" not in content):
+                and "ControllerAdvice" not in content
+                and "M3FiltroSeguridad" not in content):
             return []
 
         if _REST_CONTROLLER_RE.search(content):
             http_path_match = _HTTP_PATH_RE.search(content)
             http_path = http_path_match.group(1) if http_path_match else None
+            verb_match = _REQUEST_METHOD_VERB_RE.search(content)
+            if verb_match and http_path:
+                http_path = f"[{verb_match.group(1)}] {http_path}"
+            elif verb_match:
+                http_path = f"[{verb_match.group(1)}]"
+            security_evidence = None
+            m3_match = _M3_FILTRO_PARAMS_RE.search(content)
+            if m3_match:
+                nombre = m3_match.group(1) or ""
+                nivel = m3_match.group(2) or ""
+                security_evidence = f"@M3FiltroSeguridad(nombreRecurso={nombre!r}, nivelRequerido={nivel})"
             return [EntryPoint(
                 path=rel_path, stack="java", kind="rest_controller",
                 source="annotation", confidence="high",
                 http_path=http_path,
+                evidence=security_evidence,
             )]
         if _CONTROLLER_ADVICE_RE.search(content):
             return [EntryPoint(
@@ -168,10 +191,22 @@ class JavaDetector(AbstractDetector):
         if _MVC_CONTROLLER_RE.search(content) and _REQUEST_MAPPING_RE.search(content):
             http_path_match = _HTTP_PATH_RE.search(content)
             http_path = http_path_match.group(1) if http_path_match else None
+            verb_match = _REQUEST_METHOD_VERB_RE.search(content)
+            if verb_match and http_path:
+                http_path = f"[{verb_match.group(1)}] {http_path}"
+            elif verb_match:
+                http_path = f"[{verb_match.group(1)}]"
+            security_evidence = None
+            m3_match = _M3_FILTRO_PARAMS_RE.search(content)
+            if m3_match:
+                nombre = m3_match.group(1) or ""
+                nivel = m3_match.group(2) or ""
+                security_evidence = f"@M3FiltroSeguridad(nombreRecurso={nombre!r}, nivelRequerido={nivel})"
             return [EntryPoint(
                 path=rel_path, stack="java", kind="mvc_controller",
                 source="annotation", confidence="medium",
                 http_path=http_path,
+                evidence=security_evidence,
             )]
         if _WEB_FILTER_RE.search(content):
             return [EntryPoint(

sourcecode/doc_analyzer.py

@@ -174,6 +174,14 @@ class DocAnalyzer:
                 limitations.extend(file_limitations)
                 if file_records:
                     languages.add(lang)
+            elif suffix == ".java":
+                file_records, file_limitations = self._analyze_java_file(
+                    norm_path, content, depth, workspace, entry_points
+                )
+                records.extend(file_records)
+                limitations.extend(file_limitations)
+                if file_records:
+                    languages.add("java")
             else:
                 # Unsupported language — D-04: no emitir DocRecord, solo registrar limitation
                 limitations.append(f"docs_unavailable:{norm_path}:language={lang}")
@@ -182,7 +190,7 @@ class DocAnalyzer:
                 # NO records.append() here
 
         # Build language_coverage: explicit per-language support status
-        _SUPPORTED_LANGS = {"python", "javascript", "typescript"}
+        _SUPPORTED_LANGS = {"python", "javascript", "typescript", "java"}
         lang_coverage: dict[str, str] = {}
         for lang in languages:
             if lang in _SUPPORTED_LANGS:
@@ -225,6 +233,73 @@ class DocAnalyzer:
         )
         return records, summary
 
+    # Javadoc: /** ... */ block followed by class/method declaration
+    _JAVADOC_RE = re.compile(r'/\*\*(.*?)\*/', re.DOTALL)
+    _JAVA_CLASS_AFTER_RE = re.compile(
+        r'(?:public\s+)?(?:abstract\s+)?(?:final\s+)?(?:class|interface|enum)\s+(\w+)',
+    )
+    _JAVA_METHOD_AFTER_RE = re.compile(
+        r'public\s+[\w<>\[\],\s]+?\s+(\w+)\s*\(',
+    )
+
+    def _clean_javadoc(self, raw: str) -> str:
+        lines = raw.strip().splitlines()
+        cleaned: list[str] = []
+        for line in lines:
+            line = re.sub(r'^\s*\*\s?', '', line).strip()
+            if line.startswith('@'):
+                continue
+            if line:
+                cleaned.append(line)
+        result = ' '.join(cleaned)
+        if len(result) > self._DOCSTRING_MAX_CHARS:
+            result = result[:self._DOCSTRING_MAX_CHARS] + self._TRUNCATION_SUFFIX
+        return result
+
+    def _analyze_java_file(
+        self,
+        path: str,
+        content: str,
+        depth: "DocsDepth",
+        workspace: "str | None",
+        entry_points: "list[str] | None",
+    ) -> "tuple[list[DocRecord], list[str]]":
+        records: list[DocRecord] = []
+        for jd_match in self._JAVADOC_RE.finditer(content):
+            lookahead = content[jd_match.end():jd_match.end() + 400].lstrip()
+            # Class-level Javadoc
+            class_m = self._JAVA_CLASS_AFTER_RE.match(lookahead)
+            if class_m:
+                name = class_m.group(1)
+                doc_text = self._clean_javadoc(jd_match.group(1))
+                records.append(DocRecord(
+                    path=path,
+                    workspace=workspace,
+                    kind="class",
+                    name=name,
+                    doc_text=doc_text,
+                    importance=self._infer_importance(path, "class", entry_points),
+                ))
+                continue
+            # Method-level Javadoc (only when depth != "module")
+            if depth == "module":
+                continue
+            method_m = self._JAVA_METHOD_AFTER_RE.match(lookahead)
+            if method_m:
+                name = method_m.group(1)
+                if name in {"if", "for", "while", "switch", "return", "new"}:
+                    continue
+                doc_text = self._clean_javadoc(jd_match.group(1))
+                records.append(DocRecord(
+                    path=path,
+                    workspace=workspace,
+                    kind="function",
+                    name=name,
+                    doc_text=doc_text,
+                    importance=self._infer_importance(path, "function", entry_points),
+                ))
+        return records, []
+
     def merge_summaries(self, summaries: Iterable[DocSummary]) -> DocSummary:
         """Agrega multiples DocSummary en uno.
 

sourcecode/entrypoint_classifier.py

@@ -67,6 +67,9 @@ def runtime_relevance(ep: EntryPoint, classification: Classification | None = No
     classification = classification or classify_entry_point(ep)
     if classification != "production":
         return "low"
+    # Annotation-detected HTTP controllers are the primary runtime surface
+    if ep.source == "annotation" and ep.kind in {"rest_controller", "mvc_controller"}:
+        return "high"
     reason = (ep.reason or "").lower()
     if ep.source == "package.json#bin" or reason == "bin" or reason in _PRODUCTION_SCRIPT_REASONS:
         return "high"

sourcecode/env_analyzer.py

@@ -27,6 +27,8 @@ _ENV_EXAMPLE_NAMES = {
 
 # Spring Boot application.properties / application.yml and their profile variants
 _SPRING_CONF_BASE = {"application.properties", "application.yml", "application.yaml"}
+# Matches options/{profile}/ in multi-tenant SAS layout paths
+_OPTIONS_PROFILE_PATH_RE = re.compile(r'options/([a-z0-9_-]+)/', re.IGNORECASE)
 _SPRING_CONF_PROFILE_RE = re.compile(r'^application-([a-z0-9_-]+)\.(properties|ya?ml)$', re.IGNORECASE)
 # Matches ${ENV_VAR} or ${ENV_VAR:default} where ENV_VAR is UPPER_SNAKE_CASE.
 # Group 1 = key, Group 2 = default (may be empty string, absent = no default).
@@ -507,6 +509,10 @@ class EnvAnalyzer:
                 # Spring Boot application.properties / application.yml (incl. profiles)
                 if name_lower in _SPRING_CONF_BASE or _SPRING_CONF_PROFILE_RE.match(name_lower):
                     profile = _extract_spring_profile(name)
+                    # Override profile if path contains options/{profile}/ (multi-tenant SAS layout)
+                    path_profile_match = _OPTIONS_PROFILE_PATH_RE.search(rel)
+                    if path_profile_match:
+                        profile = path_profile_match.group(1)
                     if profile and profile not in profiles_scanned:
                         profiles_scanned.append(profile)
                     count = _parse_spring_config(entry, rel, findings, profile)

sourcecode/graph_analyzer.py

@@ -76,7 +76,7 @@ class GraphAnalyzer:
     def __init__(
         self,
         *,
-        max_files: int = 200,
+        max_files: int = 2000,
         max_file_size: int = 200_000,
         max_nodes: int = 1_000,
         max_edges: int = 2_000,

sourcecode/metrics_analyzer.py

@@ -137,7 +137,7 @@ def _mccabe(func_node: ast.FunctionDef | ast.AsyncFunctionDef) -> int:
 class MetricsAnalyzer:
     """Analiza metricas de calidad de codigo: LOC, simbolos y complejidad ciclomatica."""
 
-    _MAX_FILES = 500
+    _MAX_FILES = 2000
     _MAX_FILE_SIZE = 500_000  # bytes
 
     # ---------------------------------------------------------------------------
@@ -159,6 +159,21 @@ class MetricsAnalyzer:
         # Keep only paths that are actual files (not directories)
         file_paths = [p for p in all_paths if (root / p).is_file()]
 
+        # Sort: JVM source first, then other source, then config, then dotfiles
+        # Prevents the 500-file cap from cutting all Java files when dotfiles sort first.
+        def _sort_key(p: str) -> tuple[int, str]:
+            if Path(p).suffix.lower() in {".java", ".kt", ".scala"}:
+                return (0, p)
+            if Path(p).suffix.lower() in {".py", ".go", ".rs", ".ts", ".js", ".tsx", ".jsx"}:
+                return (1, p)
+            if Path(p).suffix.lower() in {".xml", ".yaml", ".yml", ".json", ".toml", ".properties"}:
+                return (2, p)
+            if Path(p).name.startswith("."):
+                return (4, p)
+            return (3, p)
+
+        file_paths.sort(key=_sort_key)
+
         limitations: list[str] = []
 
         # Guard: max files
@@ -229,6 +244,29 @@ class MetricsAnalyzer:
                 "null complexity fields are expected, not an error."
             )
 
+        # P2-C: DDD module metrics — group by module, count files/methods per layer
+        _DDD_LAYERS = {"domain", "application", "infrastructure"}
+        ddd_files = [r for r in records if "/ddd/" in r.path.replace("\\", "/")]
+        if ddd_files:
+            module_layer_data: dict[str, dict[str, dict]] = {}
+            for fm in ddd_files:
+                parts = fm.path.replace("\\", "/").split("/")
+                for i, part in enumerate(parts):
+                    if part in _DDD_LAYERS and i >= 2:
+                        module = parts[i - 1]
+                        layer = part
+                        if module not in module_layer_data:
+                            module_layer_data[module] = {lyr: {"files": 0, "methods": 0} for lyr in _DDD_LAYERS}
+                        module_layer_data[module][layer]["files"] += 1
+                        module_layer_data[module][layer]["methods"] += fm.function_count or 0
+                        break
+            ddd_metrics = [
+                {"module": mod, "layers": layers}
+                for mod, layers in sorted(module_layer_data.items())
+            ]
+        else:
+            ddd_metrics = []
+
         summary = MetricsSummary(
             requested=True,
             file_count=len(records),
@@ -238,6 +276,7 @@ class MetricsAnalyzer:
             coverage_records=coverage_records,
             coverage_sources_found=sorted({r.format for r in coverage_records}),
             limitations=limitations,
+            ddd_module_metrics=ddd_metrics,
         )
         return records, summary
 

sourcecode/prepare_context.py

@@ -760,6 +760,33 @@ class TaskContextBuilder:
             elif self._is_source(path) and not content_reasons:
                 content_boost += 0.5
 
+            # Task-specific boosts for differentiated file weighting
+            path_lower = path.lower()
+            if task_name == "fix-bug":
+                if any(x in path_lower for x in ("exception", "error", "handler", "advice")):
+                    content_boost += 1.5
+                    content_reasons.append("exception handler — high risk area")
+            elif task_name == "generate-tests":
+                stem = Path(path).stem.lower()
+                has_test = any(
+                    stem in Path(tp).stem.lower() or Path(tp).stem.lower() in stem
+                    for tp in test_set
+                )
+                if not has_test and self._is_source(path):
+                    content_boost += 1.0
+                    content_reasons.append("no test pair found")
+            elif task_name == "onboard":
+                if path in runtime_entry_set:
+                    content_boost += 2.0
+                    content_reasons.append("runtime entry point")
+                if any(x in path_lower for x in ("config", "application.yml", "application.properties", "settings", "bootstrap")):
+                    content_boost += 1.0
+                    content_reasons.append("configuration class")
+            elif task_name == "explain":
+                if "controller" in path_lower and path in runtime_entry_set:
+                    content_boost += 1.5
+                    content_reasons.append("DDD module controller")
+
             total = fs.score + content_boost
             if total <= 0:
                 continue

sourcecode/schema.py

@@ -225,6 +225,7 @@ class MetricsSummary:
     coverage_records: list[CoverageRecord] = field(default_factory=list)
     coverage_sources_found: list[str] = field(default_factory=list)
     limitations: list[str] = field(default_factory=list)
+    ddd_module_metrics: list[dict] = field(default_factory=list)
 
 
 @dataclass

sourcecode/semantic_analyzer.py

@@ -40,6 +40,34 @@ _MAX_SYMBOLS = 10_000
 # JS/TS keyword and builtin exclusions (Plan 12-03)
 # ---------------------------------------------------------------------------
 
+# ---------------------------------------------------------------------------
+# Java/JVM heuristic regex constants (module-level for performance)
+# ---------------------------------------------------------------------------
+
+_AUTOWIRED_FIELD_RE = re.compile(
+    r'@Autowired\s+(?:private\s+|protected\s+|public\s+)?([A-Z][A-Za-z0-9_<>]*)\s+(\w+)\s*;'
+)
+_MAPPER_IFACE_RE = re.compile(
+    r'@Mapper\b.*?(?:public\s+)?interface\s+([A-Z][A-Za-z0-9_]*)',
+    re.DOTALL,
+)
+_EXTENDS_RE = re.compile(
+    r'(?:class|interface)\s+([A-Z][A-Za-z0-9_]*)\s+extends\s+([A-Z][A-Za-z0-9_]*)'
+)
+_M3_FILTRO_METHOD_RE = re.compile(
+    r'@M3FiltroSeguridad(?:\([^)]*\))?\s+(?:@[^\s]+\s+)*'
+    r'(?:public|private|protected)\s+\w[\w<>\[\]]*\s+([a-z][A-Za-z0-9_]*)\s*\('
+)
+_LOMBOK_CLASS_RE = re.compile(
+    r'(@(?:Data|Slf4j|Builder|AllArgsConstructor|NoArgsConstructor)(?:\([^)]*\))?\s+)*'
+    r'(?:public\s+)?(?:class|interface)\s+([A-Z][A-Za-z0-9_]*)',
+    re.MULTILINE,
+)
+
+# ---------------------------------------------------------------------------
+# JS/TS keyword and builtin exclusions (Plan 12-03)
+# ---------------------------------------------------------------------------
+
 _JS_KEYWORD_EXCLUSIONS: frozenset[str] = frozenset({
     # JS reserved words
     "if", "else", "for", "while", "do", "switch", "case", "break", "continue",
@@ -645,6 +673,29 @@ class SemanticAnalyzer:
                 ),
             }
 
+            # P1-D: Link @Mapper interfaces to their *Mapper.xml files
+            xml_paths = [p for p in all_paths if p.endswith(("Mapper.xml", "MyBatis.xml"))]
+            mapper_xml_index: dict[str, str] = {}
+            for xp in xml_paths:
+                stem = Path(xp).stem  # e.g. "PacienteMapper"
+                mapper_xml_index[stem] = xp
+
+            for sym in all_symbols:
+                if sym.kind == "mapper_interface" and sym.language == "java":
+                    xml_key = sym.symbol
+                    if xml_key in mapper_xml_index:
+                        xml_path = mapper_xml_index[xml_key]
+                        links.append(SymbolLink(
+                            importer_path=Path(sym.path).as_posix(),
+                            symbol=sym.symbol,
+                            source_path=xml_path,
+                            source_line=None,
+                            is_external=False,
+                            confidence="high",
+                            method="heuristic",
+                            workspace=workspace,
+                        ))
+
         # Determine explicit analysis status — never emit silent empty results.
         # An agent must be able to tell "analysis ran and found nothing" from
         # "analysis failed to run" or "significant coverage gap".
@@ -865,6 +916,8 @@ class SemanticAnalyzer:
         """Heuristic Java/Kotlin: detecta class/method declarations y call sites.
 
         method="heuristic", confidence="low" para todos los edges Java.
+        Includes: Lombok synthetic symbols, @Autowired field edges,
+        @Mapper interface detection, inheritance chains, @M3FiltroSeguridad AOP edges.
         """
         _JAVA_KEYWORDS: frozenset[str] = frozenset({
             "if", "for", "while", "switch", "catch", "super", "this", "new",
@@ -923,6 +976,105 @@ class SemanticAnalyzer:
                     method="heuristic",
                 ))
 
+        # P1-D: @Mapper interface detection — emit as mapper_interface symbol
+        for m in _MAPPER_IFACE_RE.finditer(content):
+            iface_name = m.group(1)
+            line = content[: m.start()].count("\n") + 1
+            symbols.append(SymbolRecord(
+                symbol=iface_name,
+                kind="mapper_interface",
+                language="java",
+                path=rel_path,
+                line=line,
+                exported=True,
+            ))
+
+        # P1-E: Inheritance chain — class X extends Y → edge X→Y
+        for m in _EXTENDS_RE.finditer(content):
+            subclass = m.group(1)
+            superclass = m.group(2)
+            line = content[: m.start()].count("\n") + 1
+            calls.append(CallRecord(
+                caller_path=rel_path,
+                caller_symbol=subclass,
+                callee_path=rel_path,
+                callee_symbol=superclass,
+                call_line=line,
+                confidence="low",
+                method="heuristic",
+            ))
+
+        # P1-F: Lombok annotations — emit synthetic symbols
+        for m in _LOMBOK_CLASS_RE.finditer(content):
+            annotations_block = m.group(0)
+            class_name = m.group(2)
+            line = content[: m.start()].count("\n") + 1
+            if "@Slf4j" in annotations_block:
+                symbols.append(SymbolRecord(
+                    symbol="log",
+                    kind="field",
+                    language="java",
+                    path=rel_path,
+                    line=line,
+                    exported=False,
+                ))
+            if "@Builder" in annotations_block:
+                symbols.append(SymbolRecord(
+                    symbol=f"{class_name}.builder",
+                    kind="function",
+                    language="java",
+                    path=rel_path,
+                    line=line,
+                    exported=True,
+                ))
+            if "@AllArgsConstructor" in annotations_block or "@Data" in annotations_block:
+                symbols.append(SymbolRecord(
+                    symbol=f"{class_name}(allArgs)",
+                    kind="function",
+                    language="java",
+                    path=rel_path,
+                    line=line,
+                    exported=True,
+                ))
+            if "@NoArgsConstructor" in annotations_block:
+                symbols.append(SymbolRecord(
+                    symbol=f"{class_name}()",
+                    kind="function",
+                    language="java",
+                    path=rel_path,
+                    line=line,
+                    exported=True,
+                ))
+
+        # P1-G: @Autowired field injection — emit dependency edges
+        for m in _AUTOWIRED_FIELD_RE.finditer(content):
+            field_type = m.group(1)
+            field_name = m.group(2)
+            line = content[: m.start()].count("\n") + 1
+            calls.append(CallRecord(
+                caller_path=rel_path,
+                caller_symbol=field_name,
+                callee_path=rel_path,
+                callee_symbol=field_type,
+                call_line=line,
+                confidence="medium",
+                method="heuristic",
+            ))
+
+        # P3-C: @M3FiltroSeguridad AOP proxy edges
+        for m in _M3_FILTRO_METHOD_RE.finditer(content):
+            method_name = m.group(1)
+            line = content[: m.start()].count("\n") + 1
+            calls.append(CallRecord(
+                caller_path=rel_path,
+                caller_symbol="M3FiltroSeguridadImpl",
+                callee_path=rel_path,
+                callee_symbol=method_name,
+                call_line=line,
+                confidence="medium",
+                method="heuristic",
+            ))
+
         return symbols, calls
 
     # -----------------------------------------------------------------------

sourcecode/serializer.py

@@ -35,7 +35,7 @@ _FILE_RELEVANCE_MIN_COMBINED = 0.40  # minimum combined score — must earn incl
 _PROD_DEPS_CAP = 10          # max production dependencies shown
 _SECONDARY_DEPS_CAP = 5      # max per dev/test/build dependency group
 _MONOREPO_PKGS_CAP = 8       # max workspace/runtime packages shown
-_KEY_DEPS_CAP = 10           # max key dependencies shown
+_KEY_DEPS_CAP = 50           # max key dependencies shown
 _CODE_NOTES_CAP = 15         # max code notes in default output
 _ENV_MAP_CAP = 15            # max env var entries in default output
 
@@ -223,6 +223,11 @@ def _file_relevance(sm: SourceMap, *, limit: int = _FILE_RELEVANCE_LIMIT) -> lis
                 semantic_hub_scores[p] = h.get("importance_score", 0.0) / max_importance
 
     entry_paths = {ep.path for ep in sm.entry_points}
+    # REST/MVC controllers are HTTP surface — surface before @Transactional services
+    _rest_ctrl_paths = {
+        ep.path for ep in sm.entry_points
+        if getattr(ep, "kind", "") in {"rest_controller", "mvc_controller"}
+    }
     scored: list[tuple[float, dict[str, Any]]] = []
 
     for path in sm.file_paths:
@@ -241,6 +246,9 @@ def _file_relevance(sm: SourceMap, *, limit: int = _FILE_RELEVANCE_LIMIT) -> lis
         # Semantic hub bonus: normalised call-graph centrality adds up to +0.30
         sem_hub = semantic_hub_scores.get(path, 0.0) * 0.30
         combined = fs.score + content_rel + sem_hub
+        # REST controller boost: surface above @Transactional service files
+        if path in _rest_ctrl_paths:
+            combined += 2.0
 
         # Visibility threshold: require meaningful combined signal.
         # Exception: high/medium-confidence files with strong content relevance
@@ -1586,8 +1594,8 @@ def write_output(content: str, output: Optional[Path]) -> None:
         output: Destination file path. None = stdout.
     """
     if output is None:
-        sys.stdout.write(content)
+        sys.stdout.buffer.write(content.encode("utf-8"))
         if not content.endswith("\n"):
-            sys.stdout.write("\n")
+            sys.stdout.buffer.write(b"\n")
     else:
         output.write_text(content, encoding="utf-8")

{sourcecode-1.1.0.dist-info → sourcecode-1.3.0.dist-info}/METADATA

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

{sourcecode-1.1.0.dist-info → sourcecode-1.3.0.dist-info}/RECORD

@@ -1,35 +1,35 @@
-sourcecode/__init__.py,sha256=U4-Ic6jRz9YH4wIYlhtl8YFtDO_yG3OsMIWYQbQ3mKE,102
+sourcecode/__init__.py,sha256=OFSkiae_6W3SLXW8WqBF-PGOUxC4FhKuxuKQDTuCuvc,102
 sourcecode/adaptive_scanner.py,sha256=6dh34C2qZXyRbw-8xBhbEwDdXanM6CRFRWayVoYITnA,10190
-sourcecode/architecture_analyzer.py,sha256=hn2K4c_EknGehXZ3I1KyoJPI-LlBSkphrVGBZMceif4,31249
+sourcecode/architecture_analyzer.py,sha256=qzDW3_lQv__czQ-qs6AqEEoMvTfhfp7M7kNslPuQy7A,32128
 sourcecode/architecture_summary.py,sha256=J9yoLgh8wXwIRrT6q6JooB6PekivbOEYpJz4BUXdalk,20545
-sourcecode/ast_extractor.py,sha256=0OHQwTUBBc9lmqPLryVeB1z8dGIC6NhLlar800CD9oI,41129
+sourcecode/ast_extractor.py,sha256=zvHeO-w0evdS8EAJhwlK7hhrWMGN-lnHm6XFdZlaST8,44389
 sourcecode/classifier.py,sha256=GKTMN8qKZX7ponSwDJfN08RrasI4CVpq1_gFBgEopps,7093
-sourcecode/cli.py,sha256=YusMOF5OfihL3nBw66LcANRFSiVHugPrXE0vPIycjLQ,72016
+sourcecode/cli.py,sha256=0g7U2s1pyoTqFc7ne62Z305bErRKuHuKGyN0VrlsSOk,72971
 sourcecode/code_notes_analyzer.py,sha256=rRd8bFYV0krjlxxQV0wenwE9K7pVpUQSR7KvSvUQKw4,9226
-sourcecode/confidence_analyzer.py,sha256=HxJMPLI5ulqtkncnv98W4iVO6yMbpQo87VuxiuNbDmY,12167
+sourcecode/confidence_analyzer.py,sha256=HcaewB2pZaZ_hfKrZWtr_yPMY2-CxS1zzTUD7c4argc,13188
 sourcecode/context_scorer.py,sha256=QpChSpsmaAYz91rXA4Ue5xzQmNz_ZboZN09YOHScq1U,14679
 sourcecode/context_summarizer.py,sha256=CiQrfBEzun949bWvmLabWoj2HhPn6Lw62ofqnsy0FlQ,6503
 sourcecode/contract_model.py,sha256=gCf9-Kj0G7l0lvRTAcRfFAfMgs1Rpizv4mKovQLYUkw,3434
-sourcecode/contract_pipeline.py,sha256=eann6PZJ8Bg2zavaOhmfN_oy9rMWNSkKPDW68rRZV8E,25686
+sourcecode/contract_pipeline.py,sha256=lDa0MgalW-WPXwbWKX2NB6HWxt_15P6GZNXgAoJeDAE,25985
 sourcecode/coverage_parser.py,sha256=q0LeZJaX1bnntLu-ImksdBsMlpsVmk_iUfSaB4eaJGo,19702
-sourcecode/dependency_analyzer.py,sha256=Exq0BfInvfS5iAg9xAr6WI2uPNuotkIudTKcYJcRhB8,52757
-sourcecode/doc_analyzer.py,sha256=TttdS7mndKQhyJCfJnnAsyGCJrf-TIL7oXxDlTLUFKE,21248
-sourcecode/entrypoint_classifier.py,sha256=a69dMGyxCTd_LOm3oqj-EXWpRmbmeujN7T1mr2eJ1as,3877
-sourcecode/env_analyzer.py,sha256=Ifwst0YLvArHHaRQXlf9DCYGO0MdyQBAMWSyEzfpKZo,21650
+sourcecode/dependency_analyzer.py,sha256=EZyBI1-VkYCmPrcIIIpa7WAp888FF9Ct4nY2ronowUg,53555
+sourcecode/doc_analyzer.py,sha256=a1CIClCNmfYM3ku4bdgwHQpmb6Js4wdJZ1V5EYLo04I,24345
+sourcecode/entrypoint_classifier.py,sha256=gvKgl0f5T8ol1r4JMmkeqGHuZTfZJiOwFOWdc7EYwYw,4061
+sourcecode/env_analyzer.py,sha256=GxCidahAAIptTdDFIlVB6URd4HBnBlIX_SqUov3MBRQ,22076
 sourcecode/file_classifier.py,sha256=48ly5Z6exkzBy8lNy1AkdP4-oJqIA1zT3LZfffuTyDo,11572
 sourcecode/git_analyzer.py,sha256=PD3eNWydznQ6KLNpxGzBqizIHoPIKevfwz9Xyf_pDt4,11600
-sourcecode/graph_analyzer.py,sha256=hMOsLLz9B0UnQ4xwbHdgr3bFvqpw0bQ8kN-xmEn3Krk,64156
-sourcecode/metrics_analyzer.py,sha256=e2cFwB9XubFq_dIVsP2PLjpr4wX0N6ulb3ol3sGDUeo,20777
-sourcecode/prepare_context.py,sha256=FKh-M5B74r-yztuAgfuSE8RjIZvsq9YRwTr74zmldxI,35901
+sourcecode/graph_analyzer.py,sha256=Ko3nJp_wx92jic6AuFbdkOstDjzl-O62g1zazYJjm9w,64157
+sourcecode/metrics_analyzer.py,sha256=m0ENgtqKeBL17kUIK3fmGkgo7UfXBNHxCMj0H_Y5K7c,22750
+sourcecode/prepare_context.py,sha256=LsFDp7HnHdvtwVa46YUD60uMBfwXaVs4suMfBvc8tyI,37357
 sourcecode/ranking_engine.py,sha256=virVglafZufioHpZpwktjMvUiL0TZELWQCQnQNV8dFo,9360
 sourcecode/redactor.py,sha256=xuGcadGEHaPw4qZXlMDvzMCsr4VOkdp3oBQptHyJk8c,2884
 sourcecode/relevance_scorer.py,sha256=MYF4FFkveAQps9SmTeTlh6ODiBz2F--_hWNeHMLtUHQ,8405
 sourcecode/repo_classifier.py,sha256=FG1vaWKdWXsWdl-S8hjVMiTqcwgaRXkDyvK4rPcOGtQ,22681
 sourcecode/runtime_classifier.py,sha256=zWX3r3HCKHc-qtIobErOa8aKMmaoPYREtJKvPcBGPjQ,14792
 sourcecode/scanner.py,sha256=aM3h9-DCQ3xKpeHpHYdo2vX6T5P95HA_YwZbkAVNwmo,8288
-sourcecode/schema.py,sha256=5s9Gtiw2Fk-HEVwVcegl2fy-cyYBwS16WSTS0xIv744,23204
-sourcecode/semantic_analyzer.py,sha256=16EFTgM7ooW0m5gNUKOlTSn7IEMLSzKmzQn-cWaSqjs,82604
-sourcecode/serializer.py,sha256=k-rddaaIlvAA5F2qvizCh_yd4oAlhhsg2obrYoJKtlo,65424
+sourcecode/schema.py,sha256=M0aA3sIIm8QHDIAducZUm5mGpgJ7oXfqtyvoMkLGMac,23270
+sourcecode/semantic_analyzer.py,sha256=12TwXYkYbDcBdu0heX_EmfPM2EkO8a_r5osf0SaeQbs,88956
+sourcecode/serializer.py,sha256=-OFruU8NHsmHR_IKOb11VVl3-WOBXKPhyCtM8NZZtb0,65832
 sourcecode/summarizer.py,sha256=ZuzIdm3t8A-d5MuQL0TSNLrd-L0IQIuguIxeNXMNJf8,16070
 sourcecode/tree_utils.py,sha256=Fj9OIuUksBvgibNd3feog0sMDjVypJzPexp5lvMoYWI,1424
 sourcecode/workspace.py,sha256=X_6NmNnitvT3_38V-JDChydo_sR68s249hLFlrQskU0,8271
@@ -42,7 +42,7 @@ sourcecode/detectors/elixir.py,sha256=jCpvt5Yi6jvplc80ovRtWh17q-11ZGo9qX7o8b57TJ
 sourcecode/detectors/go.py,sha256=2r66uRQfeTWsqxr4HDhT6vExZErby0t46QXLHVBRv9w,2782
 sourcecode/detectors/heuristic.py,sha256=bCqqgbHavl4Sse3dqT8mwmo1wAdgeJr7VyXOmfClLKo,3387
 sourcecode/detectors/hybrid.py,sha256=IGFRUVsAZ1ooRlFdznCeJAV6vy1yVDx-VyghvLtddXc,9101
-sourcecode/detectors/java.py,sha256=H5qicYbpIFqThCuT4Aocn-d2zEZ_6vJc-kLjHZITIBw,9084
+sourcecode/detectors/java.py,sha256=Lv-a1YeXezJYZCJduWfeeLMTUgyPz4lyiYu9Edi8-7E,10821
 sourcecode/detectors/jvm_ext.py,sha256=EgHJ5W8EE-ZTN9V607mVzohyKgZE8Mc2jCi-DF8RAZU,2616
 sourcecode/detectors/nodejs.py,sha256=7fsyAmrGkkguX6U80HUQpIe9MRaYyi_A7zbaRtmFmGc,13097
 sourcecode/detectors/parsers.py,sha256=ugPg8yNUf0Ai1gA7Fnn6wAkYGFjTxRodSP3IeViYJJ4,2290
@@ -60,8 +60,8 @@ sourcecode/telemetry/consent.py,sha256=wLMvGNJeSSyZoNkQXpoUioY6mMv4Qdvuw7S9jAEWn
 sourcecode/telemetry/events.py,sha256=oEvvulfsv5GIDWG2174gSS6tNB95w38AIYiYeifGKlE,2294
 sourcecode/telemetry/filters.py,sha256=Asa71oRl7q3Wt_FMwuufIZJFzSYdgRNKS8LHCIyFeYE,4805
 sourcecode/telemetry/transport.py,sha256=KJeIPCPWMdmbCP3ySGs2iUlia34U6vWne2dZsUezesw,1560
-sourcecode-1.1.0.dist-info/METADATA,sha256=pM02mysiHsgFzu3TzkDPTNX78ts7wt0S4R4We6zDA_w,20411
-sourcecode-1.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-1.1.0.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
-sourcecode-1.1.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-1.1.0.dist-info/RECORD,,
+sourcecode-1.3.0.dist-info/METADATA,sha256=5tHuzUw0xpsY6eeCd81OI_pL_vl-3qaMCU78kExd6WI,20411
+sourcecode-1.3.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-1.3.0.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
+sourcecode-1.3.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-1.3.0.dist-info/RECORD,,