sourcecode 0.15.1__tar.gz → 0.17.0__tar.gz

{sourcecode-0.15.1 → sourcecode-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 0.15.1
+Version: 0.17.0
 Summary: Genera un mapa de contexto estructurado de proyectos de software para agentes IA
 License: MIT
 Requires-Python: >=3.9

{sourcecode-0.15.1 → sourcecode-0.17.0}/docs/schema.md

@@ -81,7 +81,7 @@ Campos:
 {
   "schema_version": "1.0",
   "generated_at": "2026-04-07T19:41:05.686277+00:00",
-  "sourcecode_version": "0.15.1",
+  "sourcecode_version": "0.17.0",
   "analyzed_path": "/abs/path/to/project"
 }
 ```
@@ -645,7 +645,7 @@ Ejemplo de salida para un monorepo con web Node.js y API Python con `--dependenc
   "metadata": {
     "schema_version": "1.0",
     "generated_at": "2026-04-07T19:41:05.686277+00:00",
-    "sourcecode_version": "0.15.1",
+    "sourcecode_version": "0.17.0",
     "analyzed_path": "/abs/path/to/project"
   },
   "file_tree": {

{sourcecode-0.15.1 → sourcecode-0.17.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sourcecode"
-version = "0.15.1"
+version = "0.17.0"
 description = "Genera un mapa de contexto estructurado de proyectos de software para agentes IA"
 readme = "README.md"
 requires-python = ">=3.9"

{sourcecode-0.15.1 → sourcecode-0.17.0}/src/sourcecode/__init__.py

@@ -1,3 +1,3 @@
 """sourcecode — Genera mapas de contexto estructurado para agentes IA."""
 
-__version__ = "0.15.1"
+__version__ = "0.17.0"

{sourcecode-0.15.1 → sourcecode-0.17.0}/src/sourcecode/architecture_analyzer.py

@@ -33,6 +33,37 @@ _CODE_EXTENSIONS = {
 }
 _GENERIC_NAMES = {"utils", "helpers", "common", "shared", "misc", "core", "root", ""}
 
+_TEST_DIRS: frozenset[str] = frozenset({"tests", "test", "spec", "specs", "__tests__", "e2e"})
+
+# Exact file stems that signal a specific architectural layer
+_LAYER_STEM_EXACT: dict[str, str] = {
+    "cli":      "orchestration",
+    "main":     "orchestration",
+    "app":      "orchestration",
+    "server":   "orchestration",
+    "schema":   "data",
+    "model":    "data",
+    "models":   "data",
+    "config":   "data",
+    "settings": "data",
+    "store":    "data",
+}
+
+# Suffix patterns (stem == suffix OR stem ends with "_" + suffix) → layer
+_LAYER_STEM_SUFFIXES: list[tuple[str, str]] = [
+    ("analyzer",   "processing"),
+    ("processor",  "processing"),
+    ("parser",     "processing"),
+    ("detector",   "processing"),
+    ("scanner",    "processing"),
+    ("handler",    "orchestration"),
+    ("controller", "orchestration"),
+    ("repository", "data"),
+    ("repo",       "data"),
+    ("serializer", "data"),
+    ("formatter",  "data"),
+]
+
 DOMAIN_ROLES: dict[str, str] = {
     "controllers": "HTTP request handlers",
     "handlers":    "HTTP request handlers",
@@ -120,8 +151,9 @@ class ArchitectureAnalyzer:
 
         # Overall confidence
         confidence: Literal["high", "medium", "low"]
-        if len(domains) >= 3 and pattern not in (None, "unknown"):
-            confidence = "high"
+        if pattern not in (None, "unknown", "flat"):
+            # A recognised pattern was detected — at least medium confidence
+            confidence = "high" if len(domains) >= 3 else "medium"
         elif len(domains) >= 1:
             confidence = "medium"
         else:
@@ -165,7 +197,13 @@ class ArchitectureAnalyzer:
         if len(parts) == 1:
             return "root"
         first = parts[0]
-        if first in _SRC_TRANSPARENT and len(parts) >= 3:
+        if first in _SRC_TRANSPARENT:
+            if len(parts) == 2:
+                return "root"
+            if len(parts) >= 4:
+                # src/pkg/subpkg/file.py → subpkg is the meaningful module
+                return parts[2]
+            # src/pkg/file.py → pkg
             return parts[1]
         return first
 
@@ -173,6 +211,8 @@ class ArchitectureAnalyzer:
         groups: dict[str, list[str]] = {}
         for p in paths:
             seg = self._extract_domain_segment(p)
+            if seg.lower() in _TEST_DIRS:
+                continue  # tests are infrastructure, not architecture domains
             groups.setdefault(seg, []).append(p)
 
         domains: list[ArchitectureDomain] = []
@@ -191,12 +231,21 @@ class ArchitectureAnalyzer:
         return domains
 
     def _detect_layers(self, paths: list[str]) -> tuple[str, list[ArchitectureLayer]]:
+        # Exclude test paths so test directories don't skew layer scoring
+        source_paths = [
+            p for p in paths
+            if not any(part.lower() in _TEST_DIRS for part in p.replace("\\", "/").split("/"))
+        ]
+        if not source_paths:
+            return "unknown", []
+
         dir_names: set[str] = set()
-        for p in paths:
+        for p in source_paths:
             parts = p.replace("\\", "/").split("/")
             for part in parts[:-1]:
                 dir_names.add(part.lower())
 
+        # 1. Classical keyword-based pattern matching (MVC, layered, hexagonal, fullstack)
         best_pattern = ""
         best_score = 0
         best_matched: dict[str, list[str]] = {}
@@ -213,34 +262,96 @@ class ArchitectureAnalyzer:
                 best_pattern = pattern_name
                 best_matched = matched
 
-        if best_score < 2:
-            # Check depth for flat vs unknown
-            max_depth = max(
-                len(p.replace("\\", "/").split("/")) - 1
-                for p in paths
-            )
-            flat_pattern = "flat" if max_depth <= 2 else "unknown"
-            return flat_pattern, []
-
-        # Build ArchitectureLayer list
-        layer_confidence: Literal["high", "medium", "low"] = "high" if best_score >= 3 else "medium"
-        layers: list[ArchitectureLayer] = []
-        for layer_key, matched_dirs in best_matched.items():
-            matched_files = [
-                p for p in paths
-                if any(
-                    seg.lower() in matched_dirs
-                    for seg in p.replace("\\", "/").split("/")[:-1]
-                )
+        if best_score >= 2:
+            layer_confidence: Literal["high", "medium", "low"] = "high" if best_score >= 3 else "medium"
+            layers: list[ArchitectureLayer] = []
+            for layer_key, matched_dirs in best_matched.items():
+                matched_files = [
+                    p for p in source_paths
+                    if any(
+                        seg.lower() in matched_dirs
+                        for seg in p.replace("\\", "/").split("/")[:-1]
+                    )
+                ]
+                layers.append(ArchitectureLayer(
+                    name=layer_key,
+                    pattern=best_pattern,
+                    files=matched_files,
+                    confidence=layer_confidence,
+                ))
+            return best_pattern, layers
+
+        # 2. Functional file-naming heuristic: *_analyzer.py, cli.py, schema.py, …
+        func_result = self._detect_layered_functional(source_paths)
+        if func_result is not None:
+            return func_result
+
+        # 3. Modular sub-package heuristic: ≥2 distinct named sub-packages
+        modular_result = self._detect_modular(source_paths)
+        if modular_result is not None:
+            return modular_result
+
+        # 4. Fallback: flat (shallow) vs truly unknown (deep but unrecognised)
+        max_depth = max(
+            (len(p.replace("\\", "/").split("/")) - 1 for p in source_paths),
+            default=0,
+        )
+        return ("flat" if max_depth <= 2 else "unknown"), []
+
+    def _detect_layered_functional(
+        self, paths: list[str]
+    ) -> Optional[tuple[str, list[ArchitectureLayer]]]:
+        """Detect layered architecture from file-naming conventions.
+
+        Recognises three logical layers without requiring classical directory names:
+        - orchestration: cli.py, main.py, *_handler.py, *_controller.py
+        - processing:    *_analyzer.py, *_processor.py, *_parser.py, *_detector.py, *_scanner.py
+        - data:          schema.py, model.py, *_repository.py, *_serializer.py, config.py, …
+        """
+        layer_files: dict[str, list[str]] = {"orchestration": [], "processing": [], "data": []}
+        for p in paths:
+            stem = Path(p.replace("\\", "/").split("/")[-1]).stem.lower()
+            if stem in _LAYER_STEM_EXACT:
+                layer_files[_LAYER_STEM_EXACT[stem]].append(p)
+                continue
+            for suffix, layer in _LAYER_STEM_SUFFIXES:
+                if stem == suffix or stem.endswith("_" + suffix):
+                    layer_files[layer].append(p)
+                    break
+
+        non_empty = {k: v for k, v in layer_files.items() if v}
+        if len(non_empty) >= 2:
+            return "layered", [
+                ArchitectureLayer(name=k, pattern="layered", files=v, confidence="medium")
+                for k, v in non_empty.items()
             ]
-            layers.append(ArchitectureLayer(
-                name=layer_key,
-                pattern=best_pattern,
-                files=matched_files,
-                confidence=layer_confidence,
-            ))
+        return None
+
+    def _detect_modular(
+        self, paths: list[str]
+    ) -> Optional[tuple[str, list[ArchitectureLayer]]]:
+        """Detect modular architecture from ≥2 distinct named sub-packages.
 
-        return best_pattern or "unknown", layers
+        Each top-level (or first non-transparent) directory that is not a test or
+        generic name is treated as a self-contained module.
+        """
+        module_files: dict[str, list[str]] = {}
+        for p in paths:
+            parts = p.replace("\\", "/").split("/")
+            for part in parts[:-1]:
+                if (part not in _SRC_TRANSPARENT
+                        and part.lower() not in _TEST_DIRS
+                        and part.lower() not in _GENERIC_NAMES):
+                    module_files.setdefault(part, []).append(p)
+                    break
+
+        meaningful = {k: v for k, v in module_files.items() if len(v) >= 2}
+        if len(meaningful) >= 2:
+            return "modular", [
+                ArchitectureLayer(name=k, pattern="modular", files=v, confidence="medium")
+                for k, v in meaningful.items()
+            ]
+        return None
 
     def _infer_bounded_contexts(
         self,

{sourcecode-0.15.1 → sourcecode-0.17.0}/src/sourcecode/architecture_summary.py

@@ -12,6 +12,7 @@ _TOOLING_PREFIXES = (".claude/", ".vscode/", "bin/")
 _PYTHON_EXTENSIONS = {".py"}
 _NODE_EXTENSIONS = {".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"}
 _GO_EXTENSIONS = {".go"}
+_JAVA_EXTENSIONS = {".java", ".kt", ".scala"}
 
 
 class ArchitectureSummarizer:
@@ -58,6 +59,8 @@ class ArchitectureSummarizer:
             lines.extend(self._summarize_node_entry(entry_point.path, content))
         elif suffix in _GO_EXTENSIONS:
             lines.extend(self._summarize_go_entry(entry_point.path, content))
+        elif suffix in _JAVA_EXTENSIONS:
+            lines.extend(self._summarize_java_entry(entry_point.path, content, sm.stacks))
         else:
             lines.append("Orquesta modulos internos no detallados por el analisis estatico disponible.")
 
@@ -122,6 +125,21 @@ class ArchitectureSummarizer:
         lines.append("Produce la salida principal del entry point JavaScript/TypeScript detectado.")
         return lines
 
+    def _summarize_java_entry(self, path: str, content: str, stacks: list[StackDetection]) -> list[str]:
+        lines: list[str] = []
+        frameworks = [f.name for stack in stacks for f in stack.frameworks]
+        if frameworks:
+            lines.append(f"Frameworks detectados: {', '.join(frameworks)}.")
+        annotations = re.findall(r"@(SpringBootApplication|QuarkusMain|MicronautApplication|Application)\b", content)
+        if annotations:
+            lines.append(f"Anotacion de arranque: @{annotations[0]}.")
+        # Detect Spring Boot profile hints
+        if "@SpringBootApplication" in content:
+            lines.append("Arranca el contexto de Spring con auto-configuracion y component scan.")
+        elif not lines:
+            lines.append("Orquesta el arranque de la aplicacion JVM.")
+        return lines
+
     def _summarize_go_entry(self, path: str, content: str) -> list[str]:
         imports = re.findall(r'"([^"]+)"', content)
         internal = [module for module in imports if not module.startswith(("fmt", "net/", "os", "context"))]
@@ -196,6 +214,16 @@ class ArchitectureSummarizer:
                         confidence="medium",
                     )
                 )
+            elif path.endswith("Application.java") or path.endswith("Main.java"):
+                candidates.append(
+                    EntryPoint(
+                        path=path,
+                        stack="java",
+                        kind="application",
+                        source="convention",
+                        confidence="medium",
+                    )
+                )
         return candidates
 
     def _fallback_priority(self, path: str) -> tuple[int, int, str]:

{sourcecode-0.15.1 → sourcecode-0.17.0}/src/sourcecode/cli.py

@@ -202,12 +202,26 @@ def main(
         SourceMap,
         StackDetection,
     )
-    from sourcecode.serializer import compact_view, write_output
+    from sourcecode.serializer import compact_view, normalize_source_map, validate_cross_analyzer_consistency, validate_source_map, write_output
     from sourcecode.workspace import WorkspaceAnalyzer
 
     # 1. Escanear el directorio (SCAN-01 a SCAN-05)
     redactor = SecretRedactor(enabled=not no_redact)
-    scanner = FileScanner(target, max_depth=depth)
+
+    # Detectar manifests antes del scan para ajustar depth.
+    # find_manifests() solo mira profundidad 0-1, no necesita el arbol.
+    _pre_scanner = FileScanner(target, max_depth=1)
+    manifests = _pre_scanner.find_manifests()
+
+    # Maven usa src/main/java/<groupId>/<artifactId>/<module>/ (profundidad 7+).
+    # Con depth=4 los ficheros .java son invisibles y todos los analizadores fallan.
+    # Necesitamos al menos 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
+    effective_depth = max(depth, _java_min_depth) if _is_java and depth < _java_min_depth else depth
+
+    scanner = FileScanner(target, max_depth=effective_depth)
     raw_tree = scanner.scan_tree()
 
     # 2. Filtrar del arbol las entradas de .env y *.secret (SEC-02, todos los niveles)
@@ -244,7 +258,6 @@ def main(
         return pruned
 
     file_tree = filter_sensitive_files(raw_tree)
-    manifests = scanner.find_manifests()
     detector = ProjectDetector(build_default_detectors())
     workspace_analysis = WorkspaceAnalyzer().analyze(target, manifests)
     dependency_analyzer = DependencyAnalyzer() if dependencies else None
@@ -557,6 +570,20 @@ def main(
         cn_notes, cn_adrs, cn_summary = CodeNotesAnalyzer().analyze(target)
         sm = replace(sm, code_notes=cn_notes, code_adrs=cn_adrs, code_notes_summary=cn_summary)
 
+    # Normalize optional analyzer outputs → validate schema contracts.
+    # normalize_source_map fills None fields with typed empty defaults so that
+    # consumers never need to null-check architecture or module_graph.
+    # validate_source_map then asserts the contracts hold; it raises here
+    # (pre-serialization) rather than silently producing invalid JSON.
+    sm = normalize_source_map(sm)
+    validate_source_map(sm)
+
+    # Cross-analyzer semantic consistency (non-blocking: warnings to stderr).
+    # strict=False so a mismatched dependency or orphan semantic link never
+    # aborts a run — findings are informational until the team decides to harden.
+    for _finding in validate_cross_analyzer_consistency(sm, strict=False):
+        typer.echo(f"[consistency] {_finding}", err=True)
+
     # 4. Serializar (con o sin modo compact)
     if compact:
         data = compact_view(sm)

{sourcecode-0.15.1 → sourcecode-0.17.0}/src/sourcecode/code_notes_analyzer.py

@@ -5,6 +5,11 @@ from collections import Counter
 from pathlib import Path
 from typing import Optional
 
+# Schema imports are hoisted here (not lazily inside _scan_source_file) so that
+# a stale .pyc / editable-install mismatch is caught at import time rather than
+# silently dropping notes mid-scan on the first failed late-import.
+from sourcecode.schema import AdrRecord, CodeNote, CodeNotesSummary
+
 _MAX_NOTES = 500
 _MAX_NOTES_PER_FILE = 30
 _MAX_ADRS = 50
@@ -103,7 +108,6 @@ def _scan_source_file(
         line_num = content.count("\n", 0, m.start()) + 1
         symbol = _find_nearby_symbol(lines, line_num - 1)
 
-        from sourcecode.schema import CodeNote
         notes.append(CodeNote(
             kind=kind,
             path=rel_path,
@@ -121,8 +125,6 @@ def _parse_adr(path: Path, rel_path: str) -> Optional[object]:
     except OSError:
         return None
 
-    from sourcecode.schema import AdrRecord
-
     title: Optional[str] = None
     status: Optional[str] = None
     summary_lines: list[str] = []
@@ -167,15 +169,13 @@ def _parse_adr(path: Path, rel_path: str) -> Optional[object]:
     if not title:
         title = path.stem
 
-    return AdrRecord(path=rel_path, title=title, status=status, summary=summary)
+    return AdrRecord(path=rel_path, title=title, status=status, summary=summary)  # noqa: RET504
 
 
 class CodeNotesAnalyzer:
     """Extrae notas de código (TODO/FIXME/HACK/etc.) y ADRs del proyecto."""
 
     def analyze(self, root: Path) -> tuple[list, list, object]:
-        from sourcecode.schema import CodeNotesSummary
-
         notes: list = []
         adrs: list = []
         limitations: list[str] = []
@@ -186,9 +186,19 @@ class CodeNotesAnalyzer:
         if total_count[0] >= _MAX_NOTES:
             limitations.append(f"notes_truncated_at:{_MAX_NOTES}")
 
+        # Explicit canonical sort guarantees identical output for identical input
+        # regardless of filesystem traversal order or OS/platform differences.
+        # Without this, output order depended on sorted(Path.iterdir()) which
+        # varies across Python versions, APFS vs ext4, and future walk refactors.
+        notes.sort(key=lambda n: (n.path, n.line))
+        adrs.sort(key=lambda a: a.path)
+
         kind_counts: Counter = Counter(n.kind for n in notes)
         file_counts: Counter = Counter(n.path for n in notes)
-        top_files = [f for f, _ in file_counts.most_common(5)]
+        # Secondary sort by path makes top_files stable when counts are tied.
+        top_files = [
+            f for f, _ in sorted(file_counts.items(), key=lambda x: (-x[1], x[0]))[:5]
+        ]
 
         summary = CodeNotesSummary(
             requested=True,
@@ -211,7 +221,10 @@ class CodeNotesAnalyzer:
     ) -> None:
         try:
             entries = sorted(current.iterdir())
-        except PermissionError:
+        except OSError:
+            # Catches PermissionError, EMFILE (too many open files), and other
+            # OS-level errors that previously aborted the entire walk mid-scan,
+            # returning an empty or partial list depending on when the error hit.
             return
 
         for entry in entries:
@@ -237,5 +250,8 @@ class CodeNotesAnalyzer:
                                 adrs.append(adr)
                         continue
 
-                if suffix in _CODE_EXTENSIONS and total_count[0] < _MAX_NOTES:
+                # The quota check lives inside _scan_source_file; the pre-check
+                # here was redundant and caused files to be silently skipped when
+                # traversal order varied (different files filled the quota first).
+                if suffix in _CODE_EXTENSIONS:
                     _scan_source_file(entry, rel, notes, total_count)

{sourcecode-0.15.1 → sourcecode-0.17.0}/src/sourcecode/dependency_analyzer.py

@@ -33,6 +33,7 @@ class DependencyAnalyzer:
             self._analyze_rust,
             self._analyze_go,
             self._analyze_dotnet,
+            self._analyze_java,
         ):
             handler_records, handler_limitations = handler(root)
             records.extend(replace(record, workspace=workspace) for record in handler_records)
@@ -920,6 +921,50 @@ class DependencyAnalyzer:
                 result.append(resolved)
         return self._dedupe(result)
 
+    def _analyze_java(self, root: Path) -> tuple[list[DependencyRecord], list[str]]:
+        pom = root / "pom.xml"
+        if not pom.exists():
+            return [], []
+        try:
+            tree = ET.parse(pom)
+        except (ET.ParseError, OSError):
+            return [], ["java: error al parsear pom.xml"]
+
+        root_elem = tree.getroot()
+        ns_match = re.match(r"\{[^}]+\}", root_elem.tag)
+        ns = ns_match.group(0) if ns_match else ""
+
+        records: list[DependencyRecord] = []
+        deps_elem = root_elem.find(f"{ns}dependencies")
+        if deps_elem is None:
+            return [], ["java: pom.xml sin bloque <dependencies>"]
+
+        for dep in deps_elem.findall(f"{ns}dependency"):
+            group_id = (dep.findtext(f"{ns}groupId") or "").strip()
+            artifact_id = (dep.findtext(f"{ns}artifactId") or "").strip()
+            if not group_id or not artifact_id:
+                continue
+            version_raw = (dep.findtext(f"{ns}version") or "").strip() or None
+            # Versiones interpoladas con propiedades Maven (${...}) no son resolvibles estáticamente
+            declared = version_raw if version_raw and not version_raw.startswith("${") else None
+            scope_text = (dep.findtext(f"{ns}scope") or "compile").strip().lower()
+            scope = "dev" if scope_text == "test" else "direct"
+            records.append(
+                DependencyRecord(
+                    name=f"{group_id}:{artifact_id}",
+                    ecosystem="java",
+                    scope=scope,
+                    declared_version=declared,
+                    source="manifest",
+                    manifest_path="pom.xml",
+                )
+            )
+
+        limitations: list[str] = []
+        if not records:
+            limitations.append("java: pom.xml sin dependencias parseables (puede usar BOM o propiedades)")
+        return records, limitations
+
     def _load_yaml_file(self, path: Path) -> Optional[dict[str, Any]]:
         if not path.exists():
             return None

{sourcecode-0.15.1 → sourcecode-0.17.0}/src/sourcecode/scanner.py

@@ -128,6 +128,10 @@ class FileScanner:
 
             # Agregar ficheros al nodo (null = fichero segun D-02)
             for fname in filenames:
+                # Skip flag-shaped names (e.g. "-o", "--format") — shell redirect artifacts.
+                # No legitimate source file starts with "-".
+                if fname.startswith("-"):
+                    continue
                 fpath = current / fname
                 # SCAN-03: no incluir symlinks de fichero
                 if fpath.is_symlink():