sourcecode 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

sourcecode/__init__.py

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

sourcecode/classifier.py

@@ -9,6 +9,7 @@ from sourcecode.schema import EntryPoint, StackDetection
 from sourcecode.tree_utils import flatten_file_tree
 
 _API_FRAMEWORKS = {
+    "ASP.NET Core",
     "FastAPI",
     "Django",
     "Flask",
@@ -22,9 +23,12 @@ _API_FRAMEWORKS = {
     "Quarkus",
     "Laravel",
     "Symfony",
+    "Ktor",
+    "Play",
 }
-_WEB_FRAMEWORKS = {"Next.js", "React", "Vue", "Svelte", "Vite", "Flutter"}
+_WEB_FRAMEWORKS = {"Next.js", "React", "Vue", "Svelte", "Vite", "Flutter", "Phoenix"}
 _CLI_FRAMEWORKS = {"Typer", "Cobra", "Clap"}
+_API_STACKS = {"python", "go", "java", "php", "ruby", "dotnet", "kotlin", "scala"}
 ConfidenceLevel = Literal["high", "medium", "low"]
 
 
@@ -113,8 +117,10 @@ class TypeClassifier:
 
         if stack_names:
             single = next(iter(stack_names))
-            if single in {"python", "go", "java", "php", "ruby"} and framework_names & _API_FRAMEWORKS:
+            if single in _API_STACKS and framework_names & _API_FRAMEWORKS:
                 return "api"
+            if single in {"cpp", "dotnet"} and any(entry.kind == "cli" for entry in entry_points):
+                return "cli"
 
         return "unknown" if stacks else None
 
@@ -125,7 +131,7 @@ class TypeClassifier:
             frameworks = {framework.name for framework in stack.frameworks}
             if frameworks & _WEB_FRAMEWORKS or stack.stack == "nodejs":
                 has_web = True
-            if frameworks & _API_FRAMEWORKS or stack.stack in {"python", "go", "java", "php", "ruby"}:
+            if frameworks & _API_FRAMEWORKS or stack.stack in _API_STACKS:
                 has_api = True
         return has_web and has_api
 
@@ -139,9 +145,9 @@ class TypeClassifier:
             score = {"low": 0, "medium": 1, "high": 2}.get(stack.confidence, 0)
             manifest_weight = 1 if stack.manifests else 0
             priority = 0
-            if project_type in {"webapp", "fullstack"} and stack.stack == "nodejs" or project_type == "api" and stack.stack in {"python", "go", "java", "php", "ruby"} or project_type == "cli" and any(
+            if project_type in {"webapp", "fullstack"} and stack.stack in {"nodejs", "elixir"} or project_type == "api" and stack.stack in _API_STACKS or project_type == "cli" and any(
                 framework.name in _CLI_FRAMEWORKS for framework in stack.frameworks
-            ):
+            ) or project_type == "cli" and stack.stack in {"cpp", "dotnet"}:
                 priority = 3
             return (priority, score, manifest_weight)
 
@@ -157,6 +163,12 @@ class TypeClassifier:
             "php": (".php",),
             "ruby": (".rb",),
             "dart": (".dart",),
+            "dotnet": (".cs", ".fs"),
+            "elixir": (".ex", ".exs"),
+            "kotlin": (".kt", ".kts"),
+            "scala": (".scala",),
+            "terraform": (".tf",),
+            "cpp": (".c", ".cc", ".cpp", ".cxx", ".hpp", ".h"),
         }.get(stack, ())
         return sum(1 for path in flatten_file_tree(file_tree) if path.endswith(extensions))
 

sourcecode/detectors/__init__.py

@@ -8,15 +8,20 @@ from sourcecode.detectors.base import (
     StackDetection,
 )
 from sourcecode.detectors.dart import DartDetector
+from sourcecode.detectors.dotnet import DotnetDetector
+from sourcecode.detectors.elixir import ElixirDetector
 from sourcecode.detectors.go import GoDetector
 from sourcecode.detectors.heuristic import HeuristicDetector
 from sourcecode.detectors.java import JavaDetector
+from sourcecode.detectors.jvm_ext import JvmExtDetector
 from sourcecode.detectors.nodejs import NodejsDetector
 from sourcecode.detectors.php import PhpDetector
 from sourcecode.detectors.project import ProjectDetector
 from sourcecode.detectors.python import PythonDetector
 from sourcecode.detectors.ruby import RubyDetector
 from sourcecode.detectors.rust import RustDetector
+from sourcecode.detectors.systems import SystemsDetector
+from sourcecode.detectors.terraform import TerraformDetector
 
 
 def build_default_detectors() -> list[AbstractDetector]:
@@ -27,9 +32,14 @@ def build_default_detectors() -> list[AbstractDetector]:
         GoDetector(),
         RustDetector(),
         JavaDetector(),
+        DotnetDetector(),
+        ElixirDetector(),
+        JvmExtDetector(),
         PhpDetector(),
         RubyDetector(),
         DartDetector(),
+        TerraformDetector(),
+        SystemsDetector(),
         HeuristicDetector(),
     ]
 
@@ -39,11 +49,14 @@ __all__ = [
     "build_default_detectors",
     "DartDetector",
     "DetectionContext",
+    "DotnetDetector",
+    "ElixirDetector",
     "EntryPoint",
     "FrameworkDetection",
     "GoDetector",
     "HeuristicDetector",
     "JavaDetector",
+    "JvmExtDetector",
     "NodejsDetector",
     "PhpDetector",
     "PythonDetector",
@@ -51,4 +64,6 @@ __all__ = [
     "RubyDetector",
     "RustDetector",
     "StackDetection",
+    "SystemsDetector",
+    "TerraformDetector",
 ]

sourcecode/detectors/dotnet.py

@@ -0,0 +1,58 @@
+"""Detector de proyectos .NET / C#."""
+from __future__ import annotations
+
+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, path_exists_in_tree
+
+
+class DotnetDetector(AbstractDetector):
+    name = "dotnet"
+    priority = 32
+
+    def can_detect(self, context: DetectionContext) -> bool:
+        return any(
+            path.endswith((".csproj", ".sln"))
+            for path in flatten_file_tree(context.file_tree)
+        )
+
+    def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
+        manifests = [
+            path
+            for path in flatten_file_tree(context.file_tree)
+            if path.endswith((".csproj", ".sln"))
+        ]
+        content = "\n".join(
+            "\n".join(read_text_lines(context.root / manifest))
+            for manifest in manifests
+        ).lower()
+
+        frameworks: list[FrameworkDetection] = []
+        if "microsoft.net.sdk.web" in content or "microsoft.aspnetcore" in content:
+            frameworks.append(FrameworkDetection(name="ASP.NET Core", source="manifest"))
+
+        entry_points: list[EntryPoint] = []
+        for path in unique_strings(
+            ["Program.cs", "src/Program.cs", "Program.fs", "src/Program.fs"]
+        ):
+            if path_exists_in_tree(context.file_tree, path):
+                kind = "api" if frameworks else "cli"
+                entry_points.append(
+                    EntryPoint(path=path, stack="dotnet", kind=kind, source="manifest")
+                )
+
+        stack = StackDetection(
+            stack="dotnet",
+            detection_method="manifest",
+            confidence="high",
+            frameworks=frameworks,
+            package_manager="nuget",
+            manifests=manifests,
+        )
+        return [stack], entry_points

sourcecode/detectors/elixir.py

@@ -0,0 +1,49 @@
+"""Detector de proyectos Elixir / Phoenix."""
+from __future__ import annotations
+
+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, path_exists_in_tree
+
+
+class ElixirDetector(AbstractDetector):
+    name = "elixir"
+    priority = 33
+
+    def can_detect(self, context: DetectionContext) -> bool:
+        return path_exists_in_tree(context.file_tree, "mix.exs")
+
+    def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
+        content = "\n".join(read_text_lines(context.root / "mix.exs")).lower()
+        frameworks: list[FrameworkDetection] = []
+        if "phoenix" in content:
+            frameworks.append(FrameworkDetection(name="Phoenix", source="mix.exs"))
+
+        candidates = [
+            path
+            for path in flatten_file_tree(context.file_tree)
+            if path.endswith("/application.ex")
+        ]
+        entry_points: list[EntryPoint] = []
+        for path in unique_strings(candidates + ["mix.exs"]):
+            if path_exists_in_tree(context.file_tree, path):
+                kind = "web" if frameworks else "app"
+                entry_points.append(
+                    EntryPoint(path=path, stack="elixir", kind=kind, source="mix.exs")
+                )
+
+        stack = StackDetection(
+            stack="elixir",
+            detection_method="manifest",
+            confidence="high",
+            frameworks=frameworks,
+            package_manager="mix",
+            manifests=["mix.exs"],
+        )
+        return [stack], entry_points

sourcecode/detectors/jvm_ext.py

@@ -0,0 +1,69 @@
+"""Detector JVM ampliado para Kotlin y Scala."""
+from __future__ import annotations
+
+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, path_exists_in_tree
+
+
+class JvmExtDetector(AbstractDetector):
+    name = "jvm_ext"
+    priority = 36
+
+    def can_detect(self, context: DetectionContext) -> bool:
+        flat_paths = flatten_file_tree(context.file_tree)
+        return any(
+            path in {"build.gradle.kts", "settings.gradle.kts", "build.sbt"}
+            for path in flat_paths
+        )
+
+    def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
+        flat_paths = flatten_file_tree(context.file_tree)
+        manifests = [
+            path
+            for path in flat_paths
+            if path in {"build.gradle.kts", "settings.gradle.kts", "build.sbt"}
+        ]
+        content = "\n".join(
+            "\n".join(read_text_lines(context.root / manifest))
+            for manifest in manifests
+        ).lower()
+
+        stack_name = "scala" if "build.sbt" in manifests or any(path.endswith(".scala") for path in flat_paths) else "kotlin"
+        frameworks: list[FrameworkDetection] = []
+        if "spring-boot" in content:
+            frameworks.append(FrameworkDetection(name="Spring Boot", source="manifest"))
+        if "ktor" in content:
+            frameworks.append(FrameworkDetection(name="Ktor", source="manifest"))
+        if "play" in content and stack_name == "scala":
+            frameworks.append(FrameworkDetection(name="Play", source="manifest"))
+
+        entry_candidates = [
+            "src/main/kotlin/Application.kt",
+            "src/main/kotlin/Main.kt",
+            "src/main/scala/Main.scala",
+            "src/main/scala/Application.scala",
+        ]
+        entry_points: list[EntryPoint] = []
+        for path in unique_strings(entry_candidates):
+            if path_exists_in_tree(context.file_tree, path):
+                kind = "api" if frameworks else "app"
+                entry_points.append(
+                    EntryPoint(path=path, stack=stack_name, kind=kind, source="manifest")
+                )
+
+        stack = StackDetection(
+            stack=stack_name,
+            detection_method="manifest",
+            confidence="high",
+            frameworks=frameworks,
+            package_manager="gradle" if stack_name == "kotlin" else "sbt",
+            manifests=manifests,
+        )
+        return [stack], entry_points

sourcecode/detectors/nodejs.py

@@ -65,6 +65,7 @@ class NodejsDetector(AbstractDetector):
 
     def _detect_package_manager(self, context: DetectionContext) -> str | None:
         for filename, package_manager in (
+            ("bun.lockb", "bun"),
             ("pnpm-lock.yaml", "pnpm"),
             ("package-lock.json", "npm"),
             ("yarn.lock", "yarn"),

sourcecode/detectors/project.py

@@ -7,6 +7,7 @@ from typing import Any
 
 from sourcecode.classifier import TypeClassifier
 from sourcecode.detectors.base import AbstractDetector, DetectionContext
+from sourcecode.detectors.tooling import collect_tooling_signals, infer_package_manager
 from sourcecode.schema import EntryPoint, FrameworkDetection, StackDetection
 
 _CONFIDENCE_RANK = {"low": 0, "medium": 1, "high": 2}
@@ -45,6 +46,12 @@ class ProjectDetector:
                     copied = self._copy_stack(stack)
                     if copied.root is None:
                         copied.root = "."
+                    copied.signals = self._merge_values(
+                        copied.signals,
+                        collect_tooling_signals(file_tree),
+                    )
+                    if copied.package_manager is None:
+                        copied.package_manager = infer_package_manager(copied.stack, file_tree)
                     merged_stacks[stack.stack] = copied
                     continue
                 merged_stacks[stack.stack] = self._merge_stack(existing, stack)
@@ -93,6 +100,7 @@ class ProjectDetector:
     def _merge_stack(self, current: StackDetection, incoming: StackDetection) -> StackDetection:
         current.frameworks = self._merge_frameworks(current.frameworks, incoming.frameworks)
         current.manifests = self._merge_manifests(current.manifests, incoming.manifests)
+        current.signals = self._merge_values(current.signals, incoming.signals)
         if incoming.package_manager and not current.package_manager:
             current.package_manager = incoming.package_manager
         if self._confidence_rank(incoming.confidence) > self._confidence_rank(current.confidence):
@@ -117,6 +125,9 @@ class ProjectDetector:
         return list(merged.values())
 
     def _merge_manifests(self, current: Iterable[str], incoming: Iterable[str]) -> list[str]:
+        return self._merge_values(current, incoming)
+
+    def _merge_values(self, current: Iterable[str], incoming: Iterable[str]) -> list[str]:
         merged: list[str] = []
         seen: set[str] = set()
         for manifest in list(current) + list(incoming):

sourcecode/detectors/python.py

@@ -28,8 +28,19 @@ class PythonDetector(AbstractDetector):
     priority = 30
 
     def can_detect(self, context: DetectionContext) -> bool:
-        supported = {"pyproject.toml", "requirements.txt", "setup.py", "Pipfile", "uv.lock"}
-        return any(manifest in supported for manifest in context.manifests)
+        supported = {
+            "pyproject.toml",
+            "requirements.txt",
+            "setup.py",
+            "Pipfile",
+            "Pipfile.lock",
+            "uv.lock",
+            "poetry.lock",
+        }
+        return any(manifest in supported for manifest in context.manifests) or any(
+            path_exists_in_tree(context.file_tree, path)
+            for path in ("poetry.lock", "Pipfile.lock")
+        )
 
     def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
         dependencies = self._collect_dependencies(context)
@@ -42,15 +53,23 @@ class PythonDetector(AbstractDetector):
 
         manifests = [
             manifest
-            for manifest in ("pyproject.toml", "requirements.txt", "setup.py", "Pipfile", "uv.lock")
-            if manifest in context.manifests
+            for manifest in (
+                "pyproject.toml",
+                "requirements.txt",
+                "setup.py",
+                "Pipfile",
+                "Pipfile.lock",
+                "uv.lock",
+                "poetry.lock",
+            )
+            if manifest in context.manifests or path_exists_in_tree(context.file_tree, manifest)
         ]
         stack = StackDetection(
             stack="python",
             detection_method="manifest",
             confidence="high" if "pyproject.toml" in manifests else "medium",
             frameworks=frameworks,
-            package_manager="pip",
+            package_manager=self._detect_package_manager(context, pyproject=load_toml_file(context.root / "pyproject.toml")),
             manifests=manifests,
         )
         return [stack], entry_points
@@ -67,6 +86,22 @@ class PythonDetector(AbstractDetector):
                     for group in optional.values():
                         if isinstance(group, list):
                             deps.update(self._normalize_requirement(dep) for dep in group)
+            tool = pyproject.get("tool", {})
+            if isinstance(tool, dict):
+                poetry = tool.get("poetry", {})
+                if isinstance(poetry, dict):
+                    deps.update(
+                        self._normalize_requirement(dep_name)
+                        for dep_name in poetry.get("dependencies", {})
+                    )
+                    groups = poetry.get("group", {})
+                    if isinstance(groups, dict):
+                        for group in groups.values():
+                            if isinstance(group, dict):
+                                deps.update(
+                                    self._normalize_requirement(dep_name)
+                                    for dep_name in group.get("dependencies", {})
+                                )
 
         deps.update(self._read_requirements(context.root / "requirements.txt"))
         deps.update(self._read_requirements(context.root / "Pipfile"))
@@ -118,3 +153,20 @@ class PythonDetector(AbstractDetector):
                     EntryPoint(path=path, stack="python", kind=kind, source="manifest")
                 )
         return entry_points
+
+    def _detect_package_manager(
+        self, context: DetectionContext, *, pyproject: dict[str, Any] | None
+    ) -> str:
+        if path_exists_in_tree(context.file_tree, "poetry.lock"):
+            return "poetry"
+        if path_exists_in_tree(context.file_tree, "Pipfile.lock") or path_exists_in_tree(
+            context.file_tree, "Pipfile"
+        ):
+            return "pipenv"
+        if path_exists_in_tree(context.file_tree, "uv.lock"):
+            return "uv"
+        if pyproject:
+            tool = pyproject.get("tool", {})
+            if isinstance(tool, dict) and "poetry" in tool:
+                return "poetry"
+        return "pip"

sourcecode/detectors/systems.py

@@ -0,0 +1,41 @@
+"""Detector de proyectos C / C++ y build systems asociados."""
+from __future__ import annotations
+
+from sourcecode.detectors.base import (
+    AbstractDetector,
+    DetectionContext,
+    EntryPoint,
+    StackDetection,
+)
+from sourcecode.detectors.parsers import unique_strings
+from sourcecode.tree_utils import flatten_file_tree, path_exists_in_tree
+
+
+class SystemsDetector(AbstractDetector):
+    name = "systems"
+    priority = 45
+
+    def can_detect(self, context: DetectionContext) -> bool:
+        flat_paths = flatten_file_tree(context.file_tree)
+        has_code = any(path.endswith((".c", ".cc", ".cpp", ".cxx", ".hpp", ".h")) for path in flat_paths)
+        has_build = any(path in {"CMakeLists.txt", "Makefile", "meson.build"} for path in flat_paths)
+        return has_code and has_build
+
+    def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
+        flat_paths = flatten_file_tree(context.file_tree)
+        manifests = [path for path in flat_paths if path in {"CMakeLists.txt", "Makefile", "meson.build"}]
+        entry_points: list[EntryPoint] = []
+        for path in unique_strings(["main.c", "main.cpp", "src/main.c", "src/main.cpp"]):
+            if path_exists_in_tree(context.file_tree, path):
+                entry_points.append(
+                    EntryPoint(path=path, stack="cpp", kind="cli", source="manifest")
+                )
+
+        stack = StackDetection(
+            stack="cpp",
+            detection_method="manifest",
+            confidence="medium",
+            package_manager="cmake" if "CMakeLists.txt" in manifests else None,
+            manifests=manifests,
+        )
+        return [stack], entry_points

sourcecode/detectors/terraform.py

@@ -0,0 +1,47 @@
+"""Detector de proyectos Terraform."""
+from __future__ import annotations
+
+from sourcecode.detectors.base import (
+    AbstractDetector,
+    DetectionContext,
+    EntryPoint,
+    StackDetection,
+)
+from sourcecode.detectors.parsers import read_text_lines
+from sourcecode.tree_utils import flatten_file_tree, path_exists_in_tree
+
+
+class TerraformDetector(AbstractDetector):
+    name = "terraform"
+    priority = 40
+
+    def can_detect(self, context: DetectionContext) -> bool:
+        return any(path.endswith(".tf") for path in flatten_file_tree(context.file_tree))
+
+    def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
+        manifests = [path for path in flatten_file_tree(context.file_tree) if path.endswith(".tf")]
+        signals: list[str] = []
+        for manifest in manifests:
+            content = "\n".join(read_text_lines(context.root / manifest)).lower()
+            if 'provider "aws"' in content:
+                signals.append("provider:aws")
+            if 'provider "azurerm"' in content:
+                signals.append("provider:azure")
+            if 'provider "google"' in content:
+                signals.append("provider:gcp")
+
+        entry_points: list[EntryPoint] = []
+        if path_exists_in_tree(context.file_tree, "main.tf"):
+            entry_points.append(
+                EntryPoint(path="main.tf", stack="terraform", kind="infra", source="manifest")
+            )
+
+        stack = StackDetection(
+            stack="terraform",
+            detection_method="manifest",
+            confidence="medium",
+            package_manager="terraform",
+            manifests=manifests,
+            signals=signals,
+        )
+        return [stack], entry_points

sourcecode/detectors/tooling.py

@@ -0,0 +1,53 @@
+"""Senales universales de tooling y helpers transversales."""
+from __future__ import annotations
+
+from sourcecode.tree_utils import flatten_file_tree
+
+
+def collect_tooling_signals(file_tree: dict[str, object]) -> list[str]:
+    """Recolecta senales operativas reutilizables sin crear stacks por si solas."""
+    flat_paths = set(flatten_file_tree(file_tree))
+    signals: list[str] = []
+    for path, label in (
+        ("Dockerfile", "tooling:docker"),
+        ("docker-compose.yml", "tooling:docker-compose"),
+        ("docker-compose.yaml", "tooling:docker-compose"),
+        ("Taskfile.yml", "tooling:taskfile"),
+        ("Taskfile.yaml", "tooling:taskfile"),
+        ("justfile", "tooling:just"),
+        ("Procfile", "tooling:procfile"),
+        ("Makefile", "tooling:make"),
+    ):
+        if path in flat_paths:
+            signals.append(label)
+    return signals
+
+
+def infer_package_manager(stack: str, file_tree: dict[str, object]) -> str | None:
+    """Infiera package manager por lockfiles o tooling conocido."""
+    flat_paths = set(flatten_file_tree(file_tree))
+    if stack == "nodejs":
+        for path, manager in (
+            ("bun.lockb", "bun"),
+            ("pnpm-lock.yaml", "pnpm"),
+            ("package-lock.json", "npm"),
+            ("yarn.lock", "yarn"),
+        ):
+            if path in flat_paths:
+                return manager
+    if stack == "python":
+        for path, manager in (
+            ("poetry.lock", "poetry"),
+            ("Pipfile.lock", "pipenv"),
+            ("uv.lock", "uv"),
+            ("requirements.txt", "pip"),
+        ):
+            if path in flat_paths:
+                return manager
+    if stack == "php" and "composer.lock" in flat_paths:
+        return "composer"
+    if stack == "ruby" and "Gemfile.lock" in flat_paths:
+        return "bundler"
+    if stack == "terraform" and any(path.endswith(".tf") for path in flat_paths):
+        return "terraform"
+    return None

{sourcecode-0.1.0.dist-info → sourcecode-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 0.1.0
+Version: 0.2.0
 Summary: Genera un mapa de contexto estructurado de proyectos de software para agentes IA
 License: MIT
 Requires-Python: >=3.9
@@ -16,61 +16,61 @@ Description-Content-Type: text/markdown
 
 # sourcecode
 
-`sourcecode` genera un mapa de contexto estructurado de un proyecto de software para que un agente pueda entender rapido su stack, puntos de entrada y forma del repositorio.
+`sourcecode` generates a structured project context map so an agent can quickly understand a repository's stack, entry points, and overall shape.
 
-## Instalacion
+## Installation
 
 ```bash
 pip install sourcecode
 ```
 
-Requiere Python `3.9+`.
+Requires Python `3.9+`.
 
-## Uso rapido
+## Quick Start
 
-Analizar el directorio actual en JSON:
+Analyze the current directory as JSON:
 
 ```bash
 sourcecode .
 ```
 
-Generar una vista compacta para prompts o handoff:
+Generate a compact view for prompts or handoff:
 
 ```bash
 sourcecode --compact .
 ```
 
-Analizar otro directorio y escribir YAML a fichero:
+Analyze another directory and write YAML to a file:
 
 ```bash
-sourcecode --format yaml --output sourcecode.yaml /ruta/al/proyecto
+sourcecode --format yaml --output sourcecode.yaml /path/to/project
 ```
 
-Mostrar version:
+Show the version:
 
 ```bash
 sourcecode --version
 ```
 
-Opciones principales:
+Main options:
 
-- `--format json|yaml`: formato de salida.
-- `--output PATH`: escribe a fichero en vez de `stdout`.
-- `--compact`: devuelve una vista reducida con `schema_version`, `project_type`, `stacks`, `entry_points` y `file_tree_depth1`.
-- `--depth INTEGER`: profundidad maxima del arbol de ficheros.
-- `--no-redact`: desactiva la redaccion de secretos.
+- `--format json|yaml`: output format.
+- `--output PATH`: write to a file instead of `stdout`.
+- `--compact`: return a reduced view with `schema_version`, `project_type`, `stacks`, `entry_points`, and `file_tree_depth1`.
+- `--depth INTEGER`: maximum file tree depth.
+- `--no-redact`: disable secret redaction.
 
-## Que detecta
+## What It Detects
 
-- Stacks: Node.js, Python, Go, Rust, Java, PHP, Ruby y Dart.
-- Frameworks asociados al stack cuando hay senales suficientes.
-- `project_type`: `webapp`, `api`, `library`, `cli`, `fullstack`, `monorepo` o `unknown`.
-- `entry_points` relevantes, como `main.py`, `cmd/api/main.go` o `app/page.tsx`.
-- Workspaces y roots por stack en repos multi-stack o monorepo.
+- Stacks: Node.js, Python, Go, Rust, Java, PHP, Ruby, and Dart.
+- Frameworks associated with each stack when enough signals are present.
+- `project_type`: `webapp`, `api`, `library`, `cli`, `fullstack`, `monorepo`, or `unknown`.
+- Relevant `entry_points`, such as `main.py`, `cmd/api/main.go`, or `app/page.tsx`.
+- Workspace roots in multi-stack or monorepo repositories.
 
-## Ejemplo compacto
+## Compact Example
 
-Salida real de un fixture Next.js:
+Real output from a Next.js fixture:
 
 ```json
 {
@@ -115,9 +115,9 @@ Salida real de un fixture Next.js:
 }
 ```
 
-## Ejemplo monorepo
+## Monorepo Example
 
-En un monorepo, cada stack incluye su `root` y `workspace`, y uno de ellos queda marcado como `primary`.
+In a monorepo, each stack includes its own `root` and `workspace`, and one of them is marked as `primary`.
 
 ```json
 {
@@ -145,25 +145,25 @@ En un monorepo, cada stack incluye su `root` y `workspace`, y uno de ellos queda
 
 ## Output
 
-El schema completo incluye:
+The full schema includes:
 
-- `metadata`: version de schema, timestamp, version de `sourcecode` y ruta analizada.
-- `file_tree`: arbol del repositorio donde `null` representa un fichero y un objeto representa un directorio.
-- `stacks`: detecciones por ecosistema con confianza, frameworks, manifests, `primary`, `root`, `workspace` y `signals`.
-- `project_type`: clasificacion general del proyecto.
-- `entry_points`: entradas detectadas por stack.
+- `metadata`: schema version, timestamp, `sourcecode` version, and analyzed path.
+- `file_tree`: repository tree where `null` represents a file and an object represents a directory.
+- `stacks`: stack detections with confidence, frameworks, manifests, `primary`, `root`, `workspace`, and `signals`.
+- `project_type`: overall project classification.
+- `entry_points`: detected entry points by stack.
 
-La referencia detallada esta en [docs/schema.md](/Users/user/Documents/workspace/atlas/atlas-cli/docs/schema.md).
+Detailed reference: [docs/schema.md](/Users/user/Documents/workspace/atlas/atlas-cli/docs/schema.md).
 
-## Desarrollo
+## Development
 
-Instalacion editable con dependencias de desarrollo:
+Editable install with development dependencies:
 
 ```bash
 pip install -e ".[dev]"
 ```
 
-Validacion local:
+Local validation:
 
 ```bash
 ruff check src tests

{sourcecode-0.1.0.dist-info → sourcecode-0.2.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-sourcecode/__init__.py,sha256=zFh8ACgMMXbAd5f8rHwMQHBQ6irzFx0iQ1NkQc34ff8,99
-sourcecode/classifier.py,sha256=GgJE9DjsMkXgK8DIprr1cfa_FiQBZsd_4ZxzyGYw1b8,6405
+sourcecode/__init__.py,sha256=kSF53Kglqc3H1-xnzSg40MVrMtrK-Fq-mxBVtQDGJig,99
+sourcecode/classifier.py,sha256=7ubGTn5vfw9z-9eosLIYDtQUu7d8dvB4XKKDxysUVSM,6910
 sourcecode/cli.py,sha256=sf1nf-BmPWzscFvoScNkKIlfU10wepOgTfFE-lf4NO4,6962
 sourcecode/redactor.py,sha256=abSf5jH_IzYzpjF3lEN6hCwdXxvmyHs-3DHz9fd8Mic,2883
 sourcecode/scanner.py,sha256=TvcuD77m_NF8OlTj3XH1b_jO0qrto8c90fND96ecqb0,6182
@@ -7,20 +7,26 @@ sourcecode/schema.py,sha256=E2_EnuYWHWZOLarxENvL5S66QBkZIpyV1BzKetCJWIY,2487
 sourcecode/serializer.py,sha256=hezTYOAAvZ2yPn7Te7Eu42ajbMhVCsUkuUZtqx4wjAs,3085
 sourcecode/tree_utils.py,sha256=5WHQc2L-AGqxKFfYYcQftE6hETxgUxP9MWDuaThcAUw,991
 sourcecode/workspace.py,sha256=1L4xH38gU89fLeMYSuF3ft7lSdCyTfMfJ9NQt5q4Ric,6904
-sourcecode/detectors/__init__.py,sha256=RMSr1E3uIK7MvfAQdVo4lfkcDptW3tBzLPFZwQju6C4,1455
+sourcecode/detectors/__init__.py,sha256=A0AACJFF6HWf_RgatNtWu3PUzstcKtIGM9f1PoFcJug,1987
 sourcecode/detectors/base.py,sha256=mLqDNil8VkFRNbzwO2wPbmw_aaVg3WR_WzzRjU58xbU,1070
 sourcecode/detectors/dart.py,sha256=77KDgBY-xkbzLjs0Emw6c0NuQY-tQZR5PCHa9r0t2OE,1476
+sourcecode/detectors/dotnet.py,sha256=BofpMPVOJmiUpCFpkd0y7zSzzBj4jeXZkZR5AksBg8w,2017
+sourcecode/detectors/elixir.py,sha256=Aurq99BvJvZ1k9lNBiI-RGOJzi8e7maQd225IG128PE,1759
 sourcecode/detectors/go.py,sha256=oifvbih6i4yrUO2zQs3kVXEdirr6jVriiV1fJ_-NF2I,1748
 sourcecode/detectors/heuristic.py,sha256=Phimturkvi5ZwNdt005TizYTrllZk1pqHpfXOkFZJbc,1943
 sourcecode/detectors/java.py,sha256=XdONBlcBb0Vo-2hvG77Fw00X41d2KlHFCPXJCuzwAl0,3547
-sourcecode/detectors/nodejs.py,sha256=2LDNoqrQcOm_ne66PKdIDBJR_7XEFTfB42Luhz2IoEg,3885
+sourcecode/detectors/jvm_ext.py,sha256=ViHKwUzlKXjpjNNB6_wK0XptR29VUsdLobW2U-mS5BM,2665
+sourcecode/detectors/nodejs.py,sha256=rfUG2oT5SsV5nMCuXY4v99IrAWF0lL5i47m9RHOM2mM,3919
 sourcecode/detectors/parsers.py,sha256=CQhhFGk8lSXruIfLe571-1HOId3W0ssnY2ioHMGtOrg,2338
 sourcecode/detectors/php.py,sha256=6l5pFlUuKrrC6XlWPSgYTEnnPm3hoFxMM4DRAnjL4nM,1920
-sourcecode/detectors/project.py,sha256=Fu3N_5ZKtv5b0F7i8Om36k_SZKvm24nRURkHyLogp6Q,5379
-sourcecode/detectors/python.py,sha256=DMrlKXapsaRu8jVmO-w-FfnFVXTmQnmpQTaV2PBvIZA,4875
+sourcecode/detectors/project.py,sha256=QOTt2p55Wt6FNUSo0_1P7iojM_CsVevvQqHQmLqVxYk,6022
+sourcecode/detectors/python.py,sha256=UVB5M_B8t-zQkSrIqmNQR5KD7RqDHzT8C3CcazgxEi8,6900
 sourcecode/detectors/ruby.py,sha256=3_Hd5YqlErpTtyTRcUTPnMp1TF92hT-TnYYeclLbF1c,1625
 sourcecode/detectors/rust.py,sha256=iUz9lE4HfBy8CBaDwGhfh6kLsNIovrH2ay2v3y6qNDc,2298
-sourcecode-0.1.0.dist-info/METADATA,sha256=vCBUxFWpWLh7zfzltWS3LzBsT019LuhlNz89Lr-15aI,4179
-sourcecode-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-0.1.0.dist-info/entry_points.txt,sha256=voDtdlGU2-jR3wCZpQoOls_0eUKaDVCKIfajGHFDATs,50
-sourcecode-0.1.0.dist-info/RECORD,,
+sourcecode/detectors/systems.py,sha256=qf5M9tio1H6XDorSstTWIxKe0xVLR_QGTJpFGyhDz4A,1690
+sourcecode/detectors/terraform.py,sha256=5EOKQtTViWo7u3tFK0h45YD8GQPwhrww0cOicxGPPn4,1732
+sourcecode/detectors/tooling.py,sha256=wPvudLCJZ8_cr9GIx44C8jkLAlEN9uTUZcJsP7eVYnQ,1937
+sourcecode-0.2.0.dist-info/METADATA,sha256=kfVit3IrZnWnPAtbKcLjMK3SXCfHbNlSP8JrxB6zI0o,4086
+sourcecode-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-0.2.0.dist-info/entry_points.txt,sha256=voDtdlGU2-jR3wCZpQoOls_0eUKaDVCKIfajGHFDATs,50
+sourcecode-0.2.0.dist-info/RECORD,,