sourcecode 0.17.0__tar.gz → 0.19.0__tar.gz

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

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

{sourcecode-0.17.0 → sourcecode-0.19.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.17.0",
+  "sourcecode_version": "0.19.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.17.0",
+    "sourcecode_version": "0.19.0",
     "analyzed_path": "/abs/path/to/project"
   },
   "file_tree": {

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

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

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

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

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

@@ -260,6 +260,14 @@ def main(
     file_tree = filter_sensitive_files(raw_tree)
     detector = ProjectDetector(build_default_detectors())
     workspace_analysis = WorkspaceAnalyzer().analyze(target, manifests)
+
+    # --compact implicitly enables lightweight analysis passes so that
+    # dependency_summary, env_summary and code_notes_summary are never null.
+    if compact:
+        dependencies = True
+        env_map = True
+        code_notes = True
+
     dependency_analyzer = DependencyAnalyzer() if dependencies else None
     graph_analyzer = GraphAnalyzer() if graph_modules else None
     parsed_graph_edges = (

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

@@ -47,6 +47,7 @@ class DependencyAnalyzer:
         ecosystems: set[str] = set()
         sources: set[str] = set()
         limitations: list[str] = []
+        all_dependencies: list[DependencyRecord] = []
         for summary in summaries:
             result.total_count += summary.total_count
             result.direct_count += summary.direct_count
@@ -56,9 +57,11 @@ class DependencyAnalyzer:
             for limitation in summary.limitations:
                 if limitation not in limitations:
                     limitations.append(limitation)
+            all_dependencies.extend(summary.dependencies)
         result.ecosystems = sorted(ecosystems)
         result.sources = sorted(sources)
         result.limitations = limitations
+        result.dependencies = all_dependencies
         return result
 
     def _build_summary(
@@ -80,6 +83,7 @@ class DependencyAnalyzer:
             ecosystems=ecosystems,
             sources=sources,
             limitations=unique_limitations,
+            dependencies=list(records),
         )
 
     def _dedupe(self, records: Iterable[DependencyRecord]) -> list[DependencyRecord]:

sourcecode-0.19.0/src/sourcecode/detectors/java.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from xml.etree import ElementTree
+
+from sourcecode.detectors.base import (
+    AbstractDetector,
+    DetectionContext,
+    EntryPoint,
+    StackDetection,
+)
+from sourcecode.detectors.parsers import read_text_lines, unique_strings
+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
+
+_REST_CONTROLLER_RE = re.compile(r'@(?:Rest)?Controller\b')
+_WEB_FILTER_RE = re.compile(r'@WebFilter\b')
+_FILTER_BEAN_RE = re.compile(r'FilterRegistrationBean\b')
+
+
+class JavaDetector(AbstractDetector):
+    name = "java"
+    priority = 60
+
+    def can_detect(self, context: DetectionContext) -> bool:
+        return any(manifest in context.manifests for manifest in ("pom.xml", "build.gradle"))
+
+    def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
+        frameworks: list[FrameworkDetection] = []
+        manifests: list[str] = []
+
+        if "pom.xml" in context.manifests:
+            manifests.append("pom.xml")
+            frameworks.extend(self._frameworks_from_pom(context.root / "pom.xml"))
+        if "build.gradle" in context.manifests:
+            manifests.append("build.gradle")
+            frameworks.extend(self._frameworks_from_gradle(context.root / "build.gradle"))
+
+        entry_points = self._collect_entry_points(context)
+        stack = StackDetection(
+            stack="java",
+            detection_method="manifest",
+            confidence="high",
+            frameworks=self._dedupe_frameworks(frameworks),
+            manifests=manifests,
+        )
+        return [stack], entry_points
+
+    def _frameworks_from_pom(self, path: Path) -> list[FrameworkDetection]:
+        try:
+            tree = ElementTree.parse(path)
+        except (OSError, ElementTree.ParseError):
+            return []
+        text = ElementTree.tostring(tree.getroot(), encoding="unicode").lower()
+        frameworks: list[FrameworkDetection] = []
+        if "spring-boot" in text:
+            frameworks.append(FrameworkDetection(name="Spring Boot", source="pom.xml"))
+        if "quarkus" in text:
+            frameworks.append(FrameworkDetection(name="Quarkus", source="pom.xml"))
+        return frameworks
+
+    def _frameworks_from_gradle(self, path: Path) -> list[FrameworkDetection]:
+        content = "\n".join(read_text_lines(path)).lower()
+        frameworks: list[FrameworkDetection] = []
+        if "com.android.application" in content or "com.android.library" in content:
+            frameworks.append(FrameworkDetection(name="Android", source="build.gradle"))
+        if "spring-boot" in content:
+            frameworks.append(FrameworkDetection(name="Spring Boot", source="build.gradle"))
+        if "quarkus" in content:
+            frameworks.append(FrameworkDetection(name="Quarkus", source="build.gradle"))
+        return frameworks
+
+    def _collect_entry_points(self, context: DetectionContext) -> list[EntryPoint]:
+        all_paths = flatten_file_tree(context.file_tree)
+        all_java = [p for p in all_paths if p.endswith(".java")]
+
+        # 1. @SpringBootApplication entry: Application.java / Main.java by name
+        app_candidates = [
+            p for p in all_java
+            if p.endswith(("Application.java", "Main.java"))
+        ]
+        entry_points: list[EntryPoint] = [
+            EntryPoint(path=p, stack="java", kind="application", source="manifest")
+            for p in unique_strings(app_candidates)
+        ]
+
+        # 2. Annotation-based scan: @RestController, @WebFilter, FilterRegistrationBean
+        scan_candidates = [
+            p for p in all_java
+            if "/test/" not in p and "/tests/" not in p
+        ][:_MAX_JAVA_ENTRY_SCAN]
+
+        annotation_eps: list[EntryPoint] = []
+        for rel_path in scan_candidates:
+            if len(annotation_eps) >= _MAX_ANNOTATION_ENTRY_POINTS:
+                break
+            abs_path = context.root / rel_path
+            annotation_eps.extend(self._scan_java_file_for_entry_points(abs_path, rel_path))
+        entry_points.extend(annotation_eps)
+
+        # 3. web.xml servlet/filter declarations
+        web_xml_paths = [
+            p for p in all_paths
+            if p.endswith("web.xml") and "WEB-INF" in p
+        ]
+        for rel_path in web_xml_paths[:1]:
+            abs_path = context.root / rel_path
+            entry_points.extend(self._parse_web_xml(abs_path, rel_path))
+
+        # Deduplicate by (path, kind)
+        seen: set[tuple[str, str]] = set()
+        unique_eps: list[EntryPoint] = []
+        for ep in entry_points:
+            key = (ep.path, ep.kind)
+            if key not in seen:
+                seen.add(key)
+                unique_eps.append(ep)
+        return unique_eps
+
+    def _scan_java_file_for_entry_points(self, abs_path: Path, rel_path: str) -> list[EntryPoint]:
+        try:
+            if abs_path.stat().st_size > _MAX_FILE_SIZE:
+                return []
+            content = abs_path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return []
+
+        # Quick pre-filter before running regexes
+        if "Controller" not in content and "Filter" not in content:
+            return []
+
+        if _REST_CONTROLLER_RE.search(content):
+            return [EntryPoint(
+                path=rel_path, stack="java", kind="http_handler",
+                source="annotation", confidence="high",
+            )]
+        if _WEB_FILTER_RE.search(content):
+            return [EntryPoint(
+                path=rel_path, stack="java", kind="filter",
+                source="annotation", confidence="high",
+            )]
+        if _FILTER_BEAN_RE.search(content):
+            return [EntryPoint(
+                path=rel_path, stack="java", kind="filter",
+                source="annotation", confidence="medium",
+            )]
+        return []
+
+    def _parse_web_xml(self, abs_path: Path, rel_path: str) -> list[EntryPoint]:
+        try:
+            tree = ElementTree.parse(abs_path)
+        except (OSError, ElementTree.ParseError):
+            return []
+
+        root = tree.getroot()
+        ns_match = re.match(r"\{[^}]+\}", root.tag)
+        ns = ns_match.group(0) if ns_match else ""
+
+        results: list[EntryPoint] = []
+        if root.findall(f".//{ns}servlet-class"):
+            results.append(EntryPoint(
+                path=rel_path, stack="java", kind="servlet",
+                source="xml_config", confidence="high",
+            ))
+        if root.findall(f".//{ns}filter-class"):
+            results.append(EntryPoint(
+                path=rel_path, stack="java", kind="filter",
+                source="xml_config", confidence="high",
+            ))
+        return results
+
+    def _dedupe_frameworks(self, frameworks: list[FrameworkDetection]) -> list[FrameworkDetection]:
+        seen: set[str] = set()
+        result: list[FrameworkDetection] = []
+        for framework in frameworks:
+            if framework.name not in seen:
+                seen.add(framework.name)
+                result.append(framework)
+        return result

{sourcecode-0.17.0 → sourcecode-0.19.0}/src/sourcecode/env_analyzer.py

@@ -25,6 +25,12 @@ _ENV_EXAMPLE_NAMES = {
     "example.env", "sample.env",
 }
 
+# Spring Boot application.properties / application.yml and their profile variants
+_SPRING_CONF_BASE = {"application.properties", "application.yml", "application.yaml"}
+_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
+_SPRING_ENV_REF_RE = re.compile(r'\$\{([A-Z][A-Z0-9_]*)(?::[^}]*)?\}')
+
 # (pattern_id, compiled_regex)
 # Grupos de captura: group(1)=key, group(2)=default si existe
 _PATTERNS: list[tuple[str, re.Pattern]] = [
@@ -55,6 +61,9 @@ _PATTERNS: list[tuple[str, re.Pattern]] = [
     ("java_getenv", re.compile(
         r"""System\.getenv\(\s*["']([A-Z][A-Z0-9_]*)["']\s*\)"""
     )),
+    ("java_spring_value", re.compile(
+        r"""@Value\(\s*["']\$\{([A-Z][A-Z0-9_]*)(?::[^}]*)?\}["']\s*\)"""
+    )),
     ("php_getenv", re.compile(
         r"""getenv\(\s*["']([A-Z][A-Z0-9_]*)["']\s*\)"""
     )),
@@ -188,6 +197,23 @@ def _parse_env_example(
     return results
 
 
+def _parse_spring_config(
+    path: Path,
+    rel_path: str,
+    findings: dict,
+) -> None:
+    """Parse application.properties / application.yml looking for ${ENV_VAR} refs."""
+    try:
+        content = path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return
+
+    for m in _SPRING_ENV_REF_RE.finditer(content):
+        key = m.group(1)
+        line_num = content.count("\n", 0, m.start()) + 1
+        findings[key].append((f"{rel_path}:{line_num}", None))
+
+
 class EnvAnalyzer:
     """Extrae el mapa de variables de entorno del proyecto."""
 
@@ -298,11 +324,16 @@ class EnvAnalyzer:
                 self._walk(root, entry, findings, example_entries, example_files_found, limitations)
             elif entry.is_file():
                 rel = entry.relative_to(root).as_posix()
+                name_lower = name.lower()
                 # .env.example and similar
                 if name in _ENV_EXAMPLE_NAMES:
                     example_files_found.append(rel)
                     example_entries.extend(_parse_env_example(entry, rel))
                     continue
+                # Spring Boot application.properties / application.yml (incl. profiles)
+                if name_lower in _SPRING_CONF_BASE or _SPRING_CONF_PROFILE_RE.match(name_lower):
+                    _parse_spring_config(entry, rel, findings)
+                    continue
                 # Source code files
                 suffix = entry.suffix.lower()
                 if suffix in _CODE_EXTENSIONS:

{sourcecode-0.17.0 → sourcecode-0.19.0}/src/sourcecode/schema.py

@@ -96,6 +96,7 @@ class DependencySummary:
     ecosystems: list[str] = field(default_factory=list)
     sources: list[str] = field(default_factory=list)
     limitations: list[str] = field(default_factory=list)
+    dependencies: list["DependencyRecord"] = field(default_factory=list)
 
 
 @dataclass

{sourcecode-0.17.0 → sourcecode-0.19.0}/src/sourcecode/serializer.py

@@ -74,6 +74,7 @@ def compact_view(sm: SourceMap) -> dict[str, Any]:
     dep_summary_dict: Any = None
     if sm.dependency_summary is not None and sm.dependency_summary.requested:
         dep_summary_dict = asdict(sm.dependency_summary)
+        dep_summary_dict.pop("dependencies", None)
 
     env_summary_dict: Any = None
     if sm.env_summary is not None and sm.env_summary.requested:

{sourcecode-0.17.0 → sourcecode-0.19.0}/tests/test_dependency_analyzer_node_python.py

@@ -99,13 +99,13 @@ version = "0.38.6"
 
 
 def test_python_requirements_without_lockfile_keeps_declared_versions(tmp_path: Path) -> None:
-    (tmp_path / "requirements.txt").write_text("typer==0.17.0\nrich>=13.0\n")
+    (tmp_path / "requirements.txt").write_text("typer==0.18.0\nrich>=13.0\n")
 
     records, summary = DependencyAnalyzer().analyze(tmp_path)
 
     assert summary.direct_count == 2
     typer_dep = next(record for record in records if record.name == "typer")
     rich_dep = next(record for record in records if record.name == "rich")
-    assert typer_dep.declared_version == "==0.17.0"
+    assert typer_dep.declared_version == "==0.19.0"
     assert typer_dep.resolved_version is None
     assert rich_dep.declared_version == ">=13.0"

{sourcecode-0.17.0 → sourcecode-0.19.0}/tests/test_dependency_analyzer_polyglot.py

@@ -139,3 +139,79 @@ require github.com/gin-gonic/gin v1.10.0
     assert json_dep.resolved_version == "13.0.3"
     assert transitive_dotnet.scope == "transitive"
     assert "dotnet" in dotnet_summary.ecosystems
+
+
+def test_java_pom_dependencies_listed_in_summary(tmp_path: Path) -> None:
+    (tmp_path / "pom.xml").write_text(
+        """<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>com.example</groupId>
+  <artifactId>demo</artifactId>
+  <version>1.0.0</version>
+  <dependencies>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-web</artifactId>
+      <version>3.2.0</version>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-test</artifactId>
+      <version>3.2.0</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>2.15.0</version>
+    </dependency>
+  </dependencies>
+</project>"""
+    )
+
+    records, summary = DependencyAnalyzer().analyze(tmp_path)
+
+    assert summary.total_count == 3
+    assert len(summary.dependencies) == 3
+    assert summary.dependencies == records
+
+    names = {r.name for r in summary.dependencies}
+    assert "org.springframework.boot:spring-boot-starter-web" in names
+    assert "org.springframework.boot:spring-boot-starter-test" in names
+    assert "com.fasterxml.jackson.core:jackson-databind" in names
+
+    web = next(r for r in summary.dependencies if "starter-web" in r.name)
+    assert web.declared_version == "3.2.0"
+    assert web.scope == "direct"
+    assert web.ecosystem == "java"
+
+    test_dep = next(r for r in summary.dependencies if "starter-test" in r.name)
+    assert test_dep.scope == "dev"
+
+
+def test_java_dependency_summary_excluded_from_compact_view(tmp_path: Path) -> None:
+    import json
+    from typer.testing import CliRunner
+    from sourcecode.cli import app
+
+    (tmp_path / "pom.xml").write_text(
+        """<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>com.example</groupId><artifactId>demo</artifactId><version>1.0.0</version>
+  <dependencies>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-web</artifactId>
+      <version>3.2.0</version>
+    </dependency>
+  </dependencies>
+</project>"""
+    )
+
+    runner = CliRunner()
+    result = runner.invoke(app, ["--compact", str(tmp_path)])
+    assert result.exit_code == 0, result.output
+    data = json.loads(result.output)
+    assert "dependencies" not in data["dependency_summary"]

{sourcecode-0.17.0 → sourcecode-0.19.0}/tests/test_integration_dependencies.py

@@ -34,7 +34,7 @@ def test_cli_dependencies_flag_enables_dependency_block(tmp_path: Path) -> None:
 
 
 def test_cli_without_dependencies_flag_keeps_block_disabled(tmp_path: Path) -> None:
-    (tmp_path / "requirements.txt").write_text("typer==0.17.0\n")
+    (tmp_path / "requirements.txt").write_text("typer==0.19.0\n")
 
     result = runner.invoke(app, [str(tmp_path)])
 

{sourcecode-0.17.0 → sourcecode-0.19.0}/tests/test_integration_lqn.py

@@ -184,18 +184,20 @@ def test_lqn06_compact_with_dependencies() -> None:
 
 
 # ---------------------------------------------------------------------------
-# LQN-06c: compact without --dependencies -> dependency_summary is None
+# LQN-06c: compact auto-enables dependency analysis -> dependency_summary populated
 # ---------------------------------------------------------------------------
 
 
-def test_lqn06_compact_no_dep_summary_without_flag() -> None:
-    """LQN-06c: sourcecode . --compact (no --dependencies) -> dependency_summary is None."""
+def test_lqn06_compact_auto_populates_dep_summary() -> None:
+    """LQN-06c: sourcecode . --compact auto-enables dependency analysis so dependency_summary is populated."""
     compact = _invoke_json("--compact")
 
     dep_sum = compact.get("dependency_summary")
-    assert dep_sum is None, (
-        f"LQN-06c: compact without --dependencies should have dependency_summary=None, "
-        f"got {dep_sum!r}"
+    assert dep_sum is not None, (
+        "LQN-06c: --compact must auto-enable dependency analysis; dependency_summary should be populated"
+    )
+    assert dep_sum["requested"] is True, (
+        f"LQN-06c: dependency_summary.requested must be True when --compact is used, got {dep_sum['requested']}"
     )
 
 

sourcecode-0.17.0/src/sourcecode/detectors/java.py

@@ -1,87 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from xml.etree import ElementTree
-
-from sourcecode.detectors.base import (
-    AbstractDetector,
-    DetectionContext,
-    EntryPoint,
-    StackDetection,
-)
-from sourcecode.detectors.parsers import read_text_lines, unique_strings
-from sourcecode.schema import FrameworkDetection
-from sourcecode.tree_utils import flatten_file_tree
-
-
-class JavaDetector(AbstractDetector):
-    name = "java"
-    priority = 60
-
-    def can_detect(self, context: DetectionContext) -> bool:
-        return any(manifest in context.manifests for manifest in ("pom.xml", "build.gradle"))
-
-    def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
-        frameworks: list[FrameworkDetection] = []
-        manifests: list[str] = []
-
-        if "pom.xml" in context.manifests:
-            manifests.append("pom.xml")
-            frameworks.extend(self._frameworks_from_pom(context.root / "pom.xml"))
-        if "build.gradle" in context.manifests:
-            manifests.append("build.gradle")
-            frameworks.extend(self._frameworks_from_gradle(context.root / "build.gradle"))
-
-        entry_points = self._collect_entry_points(context)
-        stack = StackDetection(
-            stack="java",
-            detection_method="manifest",
-            confidence="high",
-            frameworks=self._dedupe_frameworks(frameworks),
-            manifests=manifests,
-        )
-        return [stack], entry_points
-
-    def _frameworks_from_pom(self, path: Path) -> list[FrameworkDetection]:
-        try:
-            tree = ElementTree.parse(path)
-        except (OSError, ElementTree.ParseError):
-            return []
-        text = ElementTree.tostring(tree.getroot(), encoding="unicode").lower()
-        frameworks: list[FrameworkDetection] = []
-        if "spring-boot" in text:
-            frameworks.append(FrameworkDetection(name="Spring Boot", source="pom.xml"))
-        if "quarkus" in text:
-            frameworks.append(FrameworkDetection(name="Quarkus", source="pom.xml"))
-        return frameworks
-
-    def _frameworks_from_gradle(self, path: Path) -> list[FrameworkDetection]:
-        content = "\n".join(read_text_lines(path)).lower()
-        frameworks: list[FrameworkDetection] = []
-        if "com.android.application" in content or "com.android.library" in content:
-            frameworks.append(FrameworkDetection(name="Android", source="build.gradle"))
-        if "spring-boot" in content:
-            frameworks.append(FrameworkDetection(name="Spring Boot", source="build.gradle"))
-        if "quarkus" in content:
-            frameworks.append(FrameworkDetection(name="Quarkus", source="build.gradle"))
-        return frameworks
-
-    def _collect_entry_points(self, context: DetectionContext) -> list[EntryPoint]:
-        candidates = [
-            path
-            for path in flatten_file_tree(context.file_tree)
-            if path.endswith(("Application.java", "Main.java"))
-        ]
-        return [
-            EntryPoint(path=path, stack="java", kind="application", source="manifest")
-            for path in unique_strings(candidates)
-        ]
-
-    def _dedupe_frameworks(self, frameworks: list[FrameworkDetection]) -> list[FrameworkDetection]:
-        seen: set[str] = set()
-        result: list[FrameworkDetection] = []
-        for framework in frameworks:
-            if framework.name not in seen:
-                seen.add(framework.name)
-                result.append(framework)
-        return result