sourcecode 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

sourcecode/__init__.py

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

sourcecode/architecture_analyzer.py

@@ -176,6 +176,40 @@ class ArchitectureAnalyzer:
 
         # Step 1: filter paths
         filtered = self._filter_paths(sm.file_paths)
+
+        # Step 1b: DDD filesystem detection — runs before the filtered-paths guard
+        # because DDD signals live in directory structure, not just file extensions.
+        ddd_result = self._detect_ddd(sm.file_paths)
+        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 []
+            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,
+                domains=domains_for_ddd,
+                layers=ddd_layers,
+                bounded_contexts=bc_list,
+                ddd_layers_detected=ddd_layer_names,
+                confidence="high",
+                method="filesystem_inference",
+                limitations=[],
+                evidence=[{
+                    "type": "filesystem_naming",
+                    "paths": [f"{ddd_contexts[0]}/" if ddd_contexts else ""],
+                    "reason": (
+                        f"DDD layout detected: {len(ddd_contexts)} modules under common prefix "
+                        "each contain application/, domain/, infrastructure/ subdirectories."
+                    ),
+                    "confidence": "high",
+                }],
+                tentative=False,
+            )
+
         if len(filtered) < 2:
             return ArchitectureAnalysis(
                 requested=True,
@@ -333,6 +367,73 @@ class ArchitectureAnalyzer:
     # Private helpers
     # ------------------------------------------------------------------
 
+    def _detect_ddd(
+        self, paths: list[str]
+    ) -> "Optional[tuple[str, list[ArchitectureLayer], list[str], list[str]]]":
+        """Detect DDD: ≥5 modules under a common prefix each with application/domain/infrastructure."""
+        _DDD_LAYERS = frozenset({"application", "domain", "infrastructure"})
+        _DDD_MIN_MODULES = 5
+
+        # Map (prefix, module) → set of DDD layer names found under that module
+        prefix_module_layers: dict[tuple[str, str], set[str]] = {}
+
+        for p in paths:
+            parts = p.replace("\\", "/").split("/")
+            for i, part in enumerate(parts):
+                if part in _DDD_LAYERS and i >= 2:
+                    module = parts[i - 1]
+                    prefix = "/".join(parts[:i - 1])
+                    key = (prefix, module)
+                    prefix_module_layers.setdefault(key, set()).add(part)
+                    break
+
+        # Group by prefix; find prefixes where ≥5 modules have all 3 DDD layers
+        prefix_modules: dict[str, list[str]] = {}
+        for (prefix, module), layers_found in prefix_module_layers.items():
+            if _DDD_LAYERS <= layers_found:  # module has all 3
+                prefix_modules.setdefault(prefix, []).append(module)
+
+        best_prefix = max(
+            prefix_modules,
+            key=lambda p: len(prefix_modules[p]),
+            default=None,
+        )
+        if best_prefix is None or len(prefix_modules[best_prefix]) < _DDD_MIN_MODULES:
+            return None
+
+        bounded_context_names = sorted(set(prefix_modules[best_prefix]))
+        ddd_layer_names = sorted(_DDD_LAYERS)
+
+        arch_layers: list[ArchitectureLayer] = [
+            ArchitectureLayer(
+                name=layer,
+                pattern="ddd",
+                files=[
+                    p for p in paths
+                    if f"/{layer}/" in p.replace("\\", "/")
+                ],
+                confidence="high",
+            )
+            for layer in ddd_layer_names
+        ]
+        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/architecture_summary.py

@@ -84,6 +84,11 @@ class ArchitectureSummarizer:
                 elif suffix in {".cs", ".fs", ".vb"}:
                     lang_lines = self._summarize_dotnet_entry(sm.stacks)
 
+        # MyBatis XML mapper count line (Java projects)
+        mybatis_line = self._mybatis_summary_line(file_paths)
+        if mybatis_line:
+            lang_lines.append(mybatis_line)
+
         # Merge: rich lines first, stack-specific details appended (deduped)
         lines = rich_lines + [l for l in lang_lines if l not in rich_lines]
 
@@ -296,6 +301,13 @@ class ArchitectureSummarizer:
             lines.append("Orquesta el arranque de la aplicacion JVM.")
         return lines
 
+    def _mybatis_summary_line(self, file_paths: list[str]) -> str | None:
+        """Return a summary line when >5 MyBatis XML mappers are detected."""
+        mapper_xml_count = sum(1 for p in file_paths if p.endswith("Mapper.xml"))
+        if mapper_xml_count > 5:
+            return f"MyBatis XML mappers: {mapper_xml_count} *Mapper.xml detected."
+        return None
+
     def _summarize_dotnet_entry(self, stacks: list[StackDetection]) -> list[str]:
         dotnet_stacks = [s for s in stacks if s.stack == "dotnet"]
         if not dotnet_stacks:

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)
@@ -1376,6 +1376,12 @@ 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")
     if _is_contract_mode:

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/detectors/java.py

@@ -15,12 +15,29 @@ from sourcecode.schema import FrameworkDetection
 from sourcecode.tree_utils import flatten_file_tree
 
 _MAX_FILE_SIZE = 256 * 1024  # 256 KB
-_MAX_JAVA_ENTRY_SCAN = 200
-_MAX_ANNOTATION_ENTRY_POINTS = 20
+_MAX_JAVA_ENTRY_SCAN = 1000
+_MAX_ANNOTATION_ENTRY_POINTS = 500
 
-_REST_CONTROLLER_RE = re.compile(r'@(?:Rest)?Controller\b')
+_REST_CONTROLLER_RE = re.compile(r'@RestController\b')
+_MVC_CONTROLLER_RE = re.compile(r'@Controller\b')
+_REQUEST_MAPPING_RE = re.compile(r'@RequestMapping\b')
+_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*\([^)]*?(?: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+))?'
+)
 
 
 class JavaDetector(AbstractDetector):
@@ -81,6 +98,8 @@ class JavaDetector(AbstractDetector):
             frameworks.append(FrameworkDetection(name="Vert.x", source=source))
         if "jakarta.ee" in text or "javax.ws.rs" in text:
             frameworks.append(FrameworkDetection(name="Jakarta EE", source=source))
+        if "mybatis" in text:
+            frameworks.append(FrameworkDetection(name="MyBatis", source=source))
         return frameworks
 
     def _collect_entry_points(self, context: DetectionContext) -> list[EntryPoint]:
@@ -139,13 +158,55 @@ class JavaDetector(AbstractDetector):
             return []
 
         # Quick pre-filter before running regexes
-        if "Controller" not in content and "Filter" not in content:
+        if ("Controller" not in content and "Filter" 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="http_handler",
+                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(
+                path=rel_path, stack="java", kind="exception_handler",
+                source="annotation", confidence="medium",
+            )]
+        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/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).
@@ -35,6 +37,15 @@ _SPRING_ENV_VAR_RE = re.compile(r'\$\{([A-Z][A-Z0-9_]*)(?::([^}]*))?\}')
 # These are internal property cross-references, not OS env vars, but still config signals.
 _SPRING_PROP_REF_RE = re.compile(r'\$\{([a-z][a-z0-9]*(?:\.[a-z][a-z0-9_-]*)*)(?::([^}]*))?\}')
 
+# Known Spring-internal namespaces — NOT emitted as custom application properties.
+_SPRING_BUILTIN_NAMESPACES: frozenset[str] = frozenset({
+    "spring", "logging", "management", "server", "info", "debug",
+    "endpoints", "security", "eureka", "feign", "ribbon", "hystrix",
+    "zuul", "cloud", "flyway", "liquibase", "jpa", "datasource",
+    "kafka", "rabbitmq", "redis", "mail", "thymeleaf", "mvc",
+    "web", "actuator", "metrics", "tracing",
+})
+
 # Patterns where absence of the variable causes a hard runtime error (not just None/null).
 # py_environ_bracket → os.environ["KEY"] raises KeyError
 # java_spring_value   → Spring fails to start if ${KEY} has no default
@@ -223,6 +234,66 @@ def _extract_spring_profile(filename: str) -> Optional[str]:
     return None
 
 
+def _parse_yaml_custom_properties(
+    content: str,
+    rel_path: str,
+    profile: Optional[str],
+    findings: dict,
+) -> None:
+    """Extract custom namespace leaf properties from YAML (e.g. saint.ldap.url).
+
+    Builds dotted key paths by tracking indentation levels. Emits only properties
+    whose top-level namespace is NOT a well-known Spring built-in namespace.
+    """
+    # Stack of (indent, key_segment)
+    key_stack: list[tuple[int, str]] = []
+
+    for line in content.splitlines():
+        stripped = line.lstrip()
+        if not stripped or stripped.startswith('#'):
+            continue
+        if ':' not in stripped:
+            continue
+
+        indent = len(line) - len(stripped)
+        colon_idx = stripped.index(':')
+        key_part = stripped[:colon_idx].strip()
+        value_part = stripped[colon_idx + 1:].strip() if colon_idx + 1 < len(stripped) else ""
+
+        # Only plain identifiers (no special chars)
+        if not re.match(r'^[a-zA-Z][a-zA-Z0-9_-]*$', key_part):
+            continue
+
+        # Pop stack entries at same or deeper indent
+        while key_stack and key_stack[-1][0] >= indent:
+            key_stack.pop()
+
+        key_stack.append((indent, key_part))
+
+        # Only emit leaf values (non-empty, not a nested mapping start)
+        if not value_part or value_part.startswith('{') or value_part.startswith('['):
+            continue
+
+        # Reconstruct full dotted key
+        full_key = '.'.join(seg for _, seg in key_stack)
+        top_ns = key_stack[0][1].lower()
+
+        # Skip Spring built-in namespaces
+        if top_ns in _SPRING_BUILTIN_NAMESPACES:
+            continue
+
+        # Skip entries that look like ${...} references (already handled elsewhere)
+        if value_part.startswith('${'):
+            continue
+
+        # Strip inline YAML comments
+        clean_value = value_part.split('#')[0].strip()
+        if not clean_value:
+            continue
+
+        findings[full_key].append((rel_path, clean_value, False, profile))
+
+
 def _parse_spring_config(
     path: Path,
     rel_path: str,
@@ -234,6 +305,7 @@ def _parse_spring_config(
     Returns the total number of ${...} placeholders found (candidates).
     Captures default values from ${VAR:default} syntax.
     Marks vars without defaults as hard-required (Spring fails to start if missing).
+    Also extracts custom namespace properties (saint.*, app.*, etc.) as yml_property entries.
     """
     try:
         content = path.read_text(encoding="utf-8", errors="replace")
@@ -267,6 +339,10 @@ def _parse_spring_config(
         findings[key].append((f"{rel_path}:{line_num}", default, False, profile))
         candidates += 1
 
+    # 3. Custom YAML namespace properties (YAML/YML files only)
+    if rel_path.endswith((".yml", ".yaml")):
+        _parse_yaml_custom_properties(content, rel_path, profile, findings)
+
     return candidates
 
 
@@ -320,14 +396,17 @@ class EnvAnalyzer:
                     first_profile = prof
                 if len(unique_files) >= _MAX_FILES_PER_KEY:
                     break
+            # Custom YAML properties use lowercase.dotted keys and category "application"
+            is_yml_prop = '.' in key and key[0].islower()
             records[key] = EnvVarRecord(
                 key=key,
                 required=required,
                 default=default_val,
                 type_hint=_infer_type_hint(key),
-                category=_infer_category(key),
+                category="application" if is_yml_prop else _infer_category(key),
                 files=unique_files,
                 profile=first_profile,
+                source="yml_property" if is_yml_prop else None,
             )
 
         # 2. Supplement with .env.example entries (fill description + add missing keys)
@@ -372,6 +451,8 @@ class EnvAnalyzer:
                     "extracted. Duplicates across profiles collapsed."
                 )
 
+        # spring_profiles: named profiles only (exclude "default")
+        _named_profiles = sorted({p for p in profiles_scanned if p != "default"})
         summary = EnvSummary(
             requested=True,
             total=len(sorted_records),
@@ -383,6 +464,7 @@ class EnvAnalyzer:
             profiles_scanned=sorted(set(profiles_scanned)),
             spring_candidates=spring_candidates,
             coverage_note=coverage_note,
+            spring_profiles=_named_profiles,
         )
 
         return sorted_records, summary
@@ -427,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/file_classifier.py

@@ -78,6 +78,29 @@ _IMPORT_RE = re.compile(
 )
 _DEF_RE = re.compile(r"\b(class|def|function|const|export\s+class|interface|type)\s+[A-Za-z_]", re.MULTILINE)
 
+# Java Spring stereotype annotation detection
+_JAVA_ANNOTATION_RE = re.compile(r'@(RestController|Controller|Service|Repository|Mapper|Entity|Data|Configuration|EnableWebSecurity|ControllerAdvice|Transactional)\b')
+
+# (annotation_set, category, relevance, why_template)
+# Checked in priority order; first match wins.
+_JAVA_STEREOTYPE_RULES: list[tuple[frozenset, str, float, str]] = [
+    (frozenset({"EnableWebSecurity"}),               "security",        0.85, "Spring Security configuration"),
+    (frozenset({"RestController"}),                  "api_endpoint",    0.90, "Spring REST controller — defines HTTP API surface"),
+    (frozenset({"Controller", "RequestMapping"}),    "api_endpoint",    0.80, "Spring MVC controller"),
+    (frozenset({"Service", "Transactional"}),        "business_logic",  0.75, "Transactional service — business logic boundary"),
+    (frozenset({"Service"}),                         "business_logic",  0.65, "Spring service component"),
+    (frozenset({"Repository"}),                      "data_access",     0.65, "Spring repository — data access layer"),
+    (frozenset({"Mapper"}),                          "data_access",     0.65, "MyBatis mapper — SQL data access"),
+    (frozenset({"Configuration"}),                   "configuration",   0.70, "Spring configuration class"),
+    (frozenset({"Entity"}),                          "domain_model",    0.50, "JPA entity — domain model"),
+    (frozenset({"Data"}),                            "dto",             0.40, "Lombok DTO"),
+]
+
+# Categories produced by Java stereotype detection — used downstream to apply direct relevance
+JAVA_STEREOTYPE_CATEGORIES: frozenset[str] = frozenset(
+    cat for _, cat, _, _ in _JAVA_STEREOTYPE_RULES
+)
+
 
 class FileClassifier:
     def __init__(
@@ -138,6 +161,12 @@ class FileClassifier:
         if norm in self.production_entry_paths:
             return FileClassification(norm, "runtime_core", "high", 0.95, "declared production runtime entrypoint", ["entry_points"])
 
+        # Java Spring stereotype detection (Java/Kotlin files only)
+        if suffix in {".java", ".kt"}:
+            java_class = self._classify_java_stereotype(norm, content)
+            if java_class is not None:
+                return java_class
+
         if self._has_any_import(imports, _API_IMPORTS):
             evidence = self._matched_imports(imports, _API_IMPORTS)
             return FileClassification(norm, "api_layer", "high", 0.82, "imports API/server framework", evidence)
@@ -213,3 +242,21 @@ class FileClassifier:
     def _sample(self, imports: list[str]) -> list[str]:
         return [f"import:{imp}" for imp in imports[:4]]
 
+    def _classify_java_stereotype(self, path: str, content: str) -> "FileClassification | None":
+        """Classify Java file by Spring/JPA/MyBatis annotation stereotypes."""
+        if not content:
+            return None
+        found = frozenset(m.group(1) for m in _JAVA_ANNOTATION_RE.finditer(content))
+        if not found:
+            return None
+        for required_annotations, category, relevance, why in _JAVA_STEREOTYPE_RULES:
+            # For @Data DTO: must have @Data but NOT @Entity
+            if required_annotations == frozenset({"Data"}):
+                if "Data" in found and "Entity" not in found:
+                    return FileClassification(path, category, "high", relevance, why, list(found))
+                continue
+            # For compound rules (Service+Transactional, Controller+RequestMapping): all required
+            if required_annotations <= found:
+                return FileClassification(path, category, "high", relevance, why, list(found))
+        return None
+

sourcecode/metrics_analyzer.py

@@ -229,6 +229,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 +261,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

@@ -332,6 +332,50 @@ _SOURCE_EXTENSIONS: frozenset[str] = frozenset({
     ".go", ".rs", ".rb", ".php", ".cs", ".dart",
 })
 
+
+def _extract_ddd_domain(path: str) -> str:
+    """Extract domain name from DDD package path.
+
+    For m3informatica.saint.ddd.{domain}.infrastructure.rest.*RestController
+    the domain is the segment just before application/ domain/ or infrastructure/.
+    """
+    parts = path.replace("\\", "/").split("/")
+    _DDD_LAYERS = {"application", "domain", "infrastructure"}
+    for i, part in enumerate(parts):
+        if part in _DDD_LAYERS and i >= 1:
+            return parts[i - 1]
+    # Fallback: penultimate directory segment
+    if len(parts) >= 2:
+        return parts[-2]
+    return ""
+
+
+def _java_why(path: str, file_class: "Optional[object]") -> str:
+    """Generate why string for Java files based on stereotype classification."""
+    if file_class is None:
+        return ""
+    from sourcecode.file_classifier import JAVA_STEREOTYPE_CATEGORIES
+    category = getattr(file_class, "category", "")
+    if category not in JAVA_STEREOTYPE_CATEGORIES:
+        return ""
+    domain = _extract_ddd_domain(path)
+    class_name = Path(path).stem
+    if category == "api_endpoint":
+        return f"Defines HTTP endpoints for the {domain} domain" if domain else "Defines HTTP API endpoints"
+    if category == "business_logic":
+        return f"Orchestrates {domain} business logic" if domain else "Business logic service"
+    if category == "data_access":
+        return f"SQL queries for {domain} data access" if domain else "Data access layer"
+    if category == "domain_model":
+        return f"JPA entity for {class_name} persistence"
+    if category == "configuration":
+        return getattr(file_class, "reason", "Spring configuration class")
+    if category == "security":
+        return getattr(file_class, "reason", "Spring Security configuration")
+    if category == "dto":
+        return f"Lombok DTO — {class_name}"
+    return getattr(file_class, "reason", "")
+
 _ALL_EXTENSIONS: frozenset[str] = _SOURCE_EXTENSIONS | frozenset({
     ".md", ".toml", ".yaml", ".yml", ".json", ".xml",
 })
@@ -726,12 +770,14 @@ class TaskContextBuilder:
             )
             all_reasons = [r for r in fs.reasons if r != "source file"] + content_reasons
             reason_str = ", ".join(all_reasons) if all_reasons else "source file"
+            why_str = _java_why(path, file_class)
 
             scored.append((total, path, RelevantFile(
                 path=path,
                 role=role,
                 score=round(min(total / 3.0, 1.0), 2),
                 reason=reason_str,
+                why=why_str,
             )))
 
         # Deterministic: score desc, then path asc as tiebreaker

sourcecode/schema.py

@@ -79,6 +79,7 @@ class EntryPoint:
     classification: Optional[Literal["production", "development", "auxiliary"]] = None
     runtime_relevance: Optional[Literal["high", "medium", "low"]] = None
     produced_by: Optional[str] = None  # which detector emitted this
+    http_path: Optional[str] = None  # extracted from @RequestMapping / @GetMapping (Java REST controllers)
 
 
 @dataclass
@@ -224,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
@@ -413,6 +415,7 @@ class ArchitectureAnalysis:
     # True when pattern is inferred from weak signals (e.g. directory names only).
     # Agents must not treat tentative patterns as confirmed facts.
     tentative: bool = False
+    ddd_layers_detected: list[str] = field(default_factory=list)  # e.g. ["application", "domain", "infrastructure"]
 
 
 # --- Env Map ---
@@ -425,10 +428,11 @@ class EnvVarRecord:
     required: bool = True
     default: Optional[str] = None
     type_hint: Optional[str] = None   # string | int | bool | url | path | enum
-    category: Optional[str] = None    # database | cache | storage | auth | service | observability | feature_flag | server | general
+    category: Optional[str] = None    # database | cache | storage | auth | service | observability | feature_flag | server | general | application
     description: Optional[str] = None
     files: list[str] = field(default_factory=list)  # "path:line"
     profile: Optional[str] = None     # Spring profile if first occurrence is in application-{profile}.yml
+    source: Optional[str] = None      # yml_property | env_var | source_code
 
 
 @dataclass
@@ -446,6 +450,7 @@ class EnvSummary:
     profiles_scanned: list[str] = field(default_factory=list)
     spring_candidates: int = 0   # total ${VAR} refs found across Spring config files
     coverage_note: Optional[str] = None  # explicit note about partial coverage
+    spring_profiles: list[str] = field(default_factory=list)  # canonical list: profile names from application-{profile}.yml
 
 
 # --- Code Notes ---