sourcecode 0.1.1__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.1.dist-info → sourcecode-0.2.0.dist-info}/METADATA

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

{sourcecode-0.1.1.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.1.dist-info/METADATA,sha256=YqiDeYoUkKdnYy8NWiJgGLBiiCKta1P8FP2qWTO0pBg,4086
-sourcecode-0.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-0.1.1.dist-info/entry_points.txt,sha256=voDtdlGU2-jR3wCZpQoOls_0eUKaDVCKIfajGHFDATs,50
-sourcecode-0.1.1.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,,