sourcecode 0.1.0__py3-none-any.whl

sourcecode/detectors/java.py

@@ -0,0 +1,88 @@
+"""Detector de proyectos Java."""
+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

sourcecode/detectors/nodejs.py

@@ -0,0 +1,112 @@
+"""Detector de proyectos Node.js."""
+from __future__ import annotations
+
+from typing import Any
+
+from sourcecode.detectors.base import (
+    AbstractDetector,
+    DetectionContext,
+    EntryPoint,
+    StackDetection,
+)
+from sourcecode.detectors.parsers import load_json_file, unique_strings
+from sourcecode.schema import FrameworkDetection
+from sourcecode.tree_utils import path_exists_in_tree
+
+_FRAMEWORK_MAP = {
+    "next": "Next.js",
+    "express": "Express",
+    "react": "React",
+    "vite": "Vite",
+    "vue": "Vue",
+    "svelte": "Svelte",
+    "@nestjs/core": "NestJS",
+}
+
+
+class NodejsDetector(AbstractDetector):
+    name = "nodejs"
+    priority = 20
+
+    def can_detect(self, context: DetectionContext) -> bool:
+        return "package.json" in context.manifests
+
+    def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
+        package_json = load_json_file(context.root / "package.json")
+        if package_json is None:
+            return [], []
+
+        dependency_names = self._collect_dependency_names(package_json)
+        frameworks = [
+            FrameworkDetection(name=label, source="package.json")
+            for package_name, label in _FRAMEWORK_MAP.items()
+            if package_name in dependency_names
+        ]
+        package_manager = self._detect_package_manager(context)
+        entry_points = self._collect_entry_points(context, package_json)
+
+        stack = StackDetection(
+            stack="nodejs",
+            detection_method="manifest",
+            confidence="high",
+            frameworks=frameworks,
+            package_manager=package_manager,
+            manifests=["package.json"],
+        )
+        return [stack], entry_points
+
+    def _collect_dependency_names(self, package_json: dict[str, Any]) -> set[str]:
+        names: set[str] = set()
+        for field in ("dependencies", "devDependencies", "peerDependencies", "optionalDependencies"):
+            raw = package_json.get(field, {})
+            if isinstance(raw, dict):
+                names.update(str(name) for name in raw)
+        return names
+
+    def _detect_package_manager(self, context: DetectionContext) -> str | None:
+        for filename, package_manager in (
+            ("pnpm-lock.yaml", "pnpm"),
+            ("package-lock.json", "npm"),
+            ("yarn.lock", "yarn"),
+        ):
+            if path_exists_in_tree(context.file_tree, filename):
+                return package_manager
+        return None
+
+    def _collect_entry_points(
+        self, context: DetectionContext, package_json: dict[str, Any]
+    ) -> list[EntryPoint]:
+        candidate_paths: list[str] = []
+        main = package_json.get("main")
+        if isinstance(main, str) and main.strip():
+            candidate_paths.append(main.strip())
+
+        bin_field = package_json.get("bin")
+        if isinstance(bin_field, str) and bin_field.strip():
+            candidate_paths.append(bin_field.strip())
+        elif isinstance(bin_field, dict):
+            candidate_paths.extend(
+                str(value).strip() for value in bin_field.values() if isinstance(value, str) and value.strip()
+            )
+
+        candidate_paths.extend(
+            [
+                "server.js",
+                "src/index.js",
+                "src/index.ts",
+                "src/main.js",
+                "src/main.ts",
+                "src/main.tsx",
+                "app/page.tsx",
+                "pages/index.js",
+            ]
+        )
+
+        entry_points: list[EntryPoint] = []
+        for path in unique_strings(candidate_paths):
+            if path_exists_in_tree(context.file_tree, path):
+                kind = "web" if path.startswith(("app/", "pages/")) else "server"
+                entry_points.append(
+                    EntryPoint(path=path, stack="nodejs", kind=kind, source="package.json")
+                )
+        return entry_points

sourcecode/detectors/parsers.py

@@ -0,0 +1,73 @@
+"""Helpers ligeros de parseo para manifests."""
+from __future__ import annotations
+
+import json
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any, Optional
+
+
+def load_json_file(path: Path) -> Optional[dict[str, Any]]:
+    """Carga un fichero JSON sin lanzar si el contenido es invalido."""
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (FileNotFoundError, OSError, UnicodeDecodeError, json.JSONDecodeError):
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def load_toml_file(path: Path) -> Optional[dict[str, Any]]:
+    """Carga un fichero TOML con fallback portable para Python 3.9+."""
+    try:
+        content = path.read_text(encoding="utf-8")
+    except (FileNotFoundError, OSError, UnicodeDecodeError):
+        return None
+
+    try:
+        import tomllib
+    except ModuleNotFoundError:  # pragma: no cover - solo en 3.9/3.10
+        import tomli as tomllib
+
+    try:
+        data = tomllib.loads(content)
+    except Exception:
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def read_text_lines(path: Path) -> list[str]:
+    """Lee un fichero de texto y retorna lineas; si falla, retorna lista vacia."""
+    try:
+        return path.read_text(encoding="utf-8", errors="replace").splitlines()
+    except OSError:
+        return []
+
+
+def find_declared_dependencies(raw: Any) -> list[str]:
+    """Normaliza dependencias declaradas desde listas o mapas simples."""
+    if isinstance(raw, dict):
+        return [str(key).strip() for key in raw if str(key).strip()]
+    if isinstance(raw, (list, tuple, set)):
+        result: list[str] = []
+        for item in raw:
+            if isinstance(item, str):
+                name = item.strip()
+                if name:
+                    result.append(name)
+            elif isinstance(item, dict):
+                result.extend(find_declared_dependencies(item))
+        return result
+    if isinstance(raw, str):
+        return [raw.strip()] if raw.strip() else []
+    return []
+
+
+def unique_strings(values: Iterable[str]) -> list[str]:
+    """Deduplica preservando orden."""
+    seen: set[str] = set()
+    ordered: list[str] = []
+    for value in values:
+        if value not in seen:
+            seen.add(value)
+            ordered.append(value)
+    return ordered

sourcecode/detectors/php.py

@@ -0,0 +1,58 @@
+"""Detector de proyectos PHP."""
+from __future__ import annotations
+
+from sourcecode.detectors.base import (
+    AbstractDetector,
+    DetectionContext,
+    EntryPoint,
+    StackDetection,
+)
+from sourcecode.detectors.parsers import load_json_file
+from sourcecode.schema import FrameworkDetection
+from sourcecode.tree_utils import path_exists_in_tree
+
+_FRAMEWORK_MAP = {
+    "laravel/framework": "Laravel",
+    "symfony/framework-bundle": "Symfony",
+}
+
+
+class PhpDetector(AbstractDetector):
+    name = "php"
+    priority = 70
+
+    def can_detect(self, context: DetectionContext) -> bool:
+        return "composer.json" in context.manifests
+
+    def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
+        composer = load_json_file(context.root / "composer.json")
+        if composer is None:
+            return [], []
+
+        dependencies = {}
+        if isinstance(composer.get("require"), dict):
+            dependencies.update(composer["require"])
+        if isinstance(composer.get("require-dev"), dict):
+            dependencies.update(composer["require-dev"])
+
+        frameworks = [
+            FrameworkDetection(name=label, source="composer.json")
+            for package_name, label in _FRAMEWORK_MAP.items()
+            if package_name in dependencies
+        ]
+        entry_points: list[EntryPoint] = []
+        for path in ("artisan", "public/index.php"):
+            if path_exists_in_tree(context.file_tree, path):
+                entry_points.append(
+                    EntryPoint(path=path, stack="php", kind="application", source="composer.json")
+                )
+
+        stack = StackDetection(
+            stack="php",
+            detection_method="manifest",
+            confidence="high",
+            frameworks=frameworks,
+            package_manager="composer",
+            manifests=["composer.json"],
+        )
+        return [stack], entry_points

sourcecode/detectors/project.py

@@ -0,0 +1,129 @@
+"""Orquestador de detectores para sourcecode."""
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+from pathlib import Path
+from typing import Any
+
+from sourcecode.classifier import TypeClassifier
+from sourcecode.detectors.base import AbstractDetector, DetectionContext
+from sourcecode.schema import EntryPoint, FrameworkDetection, StackDetection
+
+_CONFIDENCE_RANK = {"low": 0, "medium": 1, "high": 2}
+
+
+class ProjectDetector:
+    """Ejecuta detectores y fusiona resultados de forma determinista."""
+
+    def __init__(
+        self,
+        detectors: Sequence[AbstractDetector],
+        classifier: TypeClassifier | None = None,
+    ) -> None:
+        self.detectors = sorted(detectors, key=lambda detector: detector.priority)
+        self.classifier = classifier or TypeClassifier()
+
+    def detect(
+        self,
+        root: Path,
+        file_tree: dict[str, Any],
+        manifests: Sequence[str],
+    ) -> tuple[list[StackDetection], list[EntryPoint], str | None]:
+        manifest_names = [Path(manifest).name for manifest in manifests]
+        context = DetectionContext(root=root, file_tree=file_tree, manifests=manifest_names)
+        merged_stacks: dict[str, StackDetection] = {}
+        merged_entry_points: dict[str, EntryPoint] = {}
+
+        for detector in self.detectors:
+            if not detector.can_detect(context):
+                continue
+
+            stacks, entry_points = detector.detect(context)
+            for stack in stacks:
+                existing = merged_stacks.get(stack.stack)
+                if existing is None:
+                    copied = self._copy_stack(stack)
+                    if copied.root is None:
+                        copied.root = "."
+                    merged_stacks[stack.stack] = copied
+                    continue
+                merged_stacks[stack.stack] = self._merge_stack(existing, stack)
+
+            detected_stack_names = set(merged_stacks.keys())
+            for entry_point in entry_points:
+                if entry_point.stack not in detected_stack_names:
+                    continue
+                merged_entry_points.setdefault(entry_point.path, entry_point)
+
+        enriched_stacks, project_type = self.classify_results(
+            file_tree,
+            list(merged_stacks.values()),
+            list(merged_entry_points.values()),
+        )
+        return enriched_stacks, list(merged_entry_points.values()), project_type
+
+    def classify_results(
+        self,
+        file_tree: dict[str, Any],
+        stacks: Sequence[StackDetection],
+        entry_points: Sequence[EntryPoint],
+        *,
+        project_type_override: str | None = None,
+    ) -> tuple[list[StackDetection], str | None]:
+        enriched_stacks, project_type = self.classifier.enrich(file_tree, stacks, entry_points)
+        return enriched_stacks, project_type_override or project_type
+
+    def _copy_stack(self, stack: StackDetection) -> StackDetection:
+        return StackDetection(
+            stack=stack.stack,
+            detection_method=stack.detection_method,
+            confidence=stack.confidence,
+            frameworks=[
+                FrameworkDetection(name=framework.name, source=framework.source)
+                for framework in stack.frameworks
+            ],
+            package_manager=stack.package_manager,
+            manifests=list(stack.manifests),
+            primary=stack.primary,
+            root=stack.root,
+            workspace=stack.workspace,
+            signals=list(stack.signals),
+        )
+
+    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)
+        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):
+            current.confidence = incoming.confidence
+            current.detection_method = incoming.detection_method
+        elif self._confidence_rank(incoming.confidence) == self._confidence_rank(current.confidence):
+            if current.detection_method == "heuristic" and incoming.detection_method != "heuristic":
+                current.detection_method = incoming.detection_method
+        return current
+
+    def _merge_frameworks(
+        self,
+        current: Iterable[FrameworkDetection],
+        incoming: Iterable[FrameworkDetection],
+    ) -> list[FrameworkDetection]:
+        merged: dict[str, FrameworkDetection] = {}
+        for framework in list(current) + list(incoming):
+            merged.setdefault(
+                framework.name,
+                FrameworkDetection(name=framework.name, source=framework.source),
+            )
+        return list(merged.values())
+
+    def _merge_manifests(self, current: Iterable[str], incoming: Iterable[str]) -> list[str]:
+        merged: list[str] = []
+        seen: set[str] = set()
+        for manifest in list(current) + list(incoming):
+            if manifest not in seen:
+                seen.add(manifest)
+                merged.append(manifest)
+        return merged
+
+    def _confidence_rank(self, confidence: str) -> int:
+        return _CONFIDENCE_RANK.get(confidence, -1)

sourcecode/detectors/python.py

@@ -0,0 +1,120 @@
+"""Detector de proyectos Python."""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+from sourcecode.detectors.base import (
+    AbstractDetector,
+    DetectionContext,
+    EntryPoint,
+    StackDetection,
+)
+from sourcecode.detectors.parsers import load_toml_file, read_text_lines, unique_strings
+from sourcecode.schema import FrameworkDetection
+from sourcecode.tree_utils import path_exists_in_tree
+
+_FRAMEWORK_MAP = {
+    "fastapi": "FastAPI",
+    "django": "Django",
+    "flask": "Flask",
+    "typer": "Typer",
+}
+
+
+class PythonDetector(AbstractDetector):
+    name = "python"
+    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)
+
+    def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
+        dependencies = self._collect_dependencies(context)
+        frameworks = [
+            FrameworkDetection(name=label, source="manifest")
+            for package_name, label in _FRAMEWORK_MAP.items()
+            if package_name in dependencies
+        ]
+        entry_points = self._collect_entry_points(context)
+
+        manifests = [
+            manifest
+            for manifest in ("pyproject.toml", "requirements.txt", "setup.py", "Pipfile", "uv.lock")
+            if manifest in context.manifests
+        ]
+        stack = StackDetection(
+            stack="python",
+            detection_method="manifest",
+            confidence="high" if "pyproject.toml" in manifests else "medium",
+            frameworks=frameworks,
+            package_manager="pip",
+            manifests=manifests,
+        )
+        return [stack], entry_points
+
+    def _collect_dependencies(self, context: DetectionContext) -> set[str]:
+        deps: set[str] = set()
+        pyproject = load_toml_file(context.root / "pyproject.toml")
+        if pyproject:
+            project = pyproject.get("project", {})
+            if isinstance(project, dict):
+                deps.update(self._normalize_requirement(dep) for dep in project.get("dependencies", []))
+                optional = project.get("optional-dependencies", {})
+                if isinstance(optional, dict):
+                    for group in optional.values():
+                        if isinstance(group, list):
+                            deps.update(self._normalize_requirement(dep) for dep in group)
+
+        deps.update(self._read_requirements(context.root / "requirements.txt"))
+        deps.update(self._read_requirements(context.root / "Pipfile"))
+        deps.update(self._read_setup_py(context.root / "setup.py"))
+        return {dep for dep in deps if dep}
+
+    def _normalize_requirement(self, requirement: Any) -> str:
+        if not isinstance(requirement, str):
+            return ""
+        normalized = requirement.strip().lower()
+        normalized = re.split(r"[<>=!~\[\s]", normalized, maxsplit=1)[0]
+        return normalized
+
+    def _read_requirements(self, path: Path) -> set[str]:
+        result: set[str] = set()
+        for line in read_text_lines(path):
+            stripped = line.strip()
+            if not stripped or stripped.startswith(("#", "[")):
+                continue
+            result.add(self._normalize_requirement(stripped))
+        return result
+
+    def _read_setup_py(self, path: Path) -> set[str]:
+        content = "\n".join(read_text_lines(path))
+        if not content:
+            return set()
+        matches = re.findall(r"['\"]([A-Za-z0-9_.-]+)(?:[<>=!~].*?)?['\"]", content)
+        return {match.lower() for match in matches}
+
+    def _collect_entry_points(self, context: DetectionContext) -> list[EntryPoint]:
+        candidates: list[str] = []
+        pyproject = load_toml_file(context.root / "pyproject.toml")
+        if pyproject:
+            project = pyproject.get("project", {})
+            if isinstance(project, dict):
+                scripts = project.get("scripts", {})
+                if isinstance(scripts, dict):
+                    for value in scripts.values():
+                        if isinstance(value, str) and ":" in value:
+                            module, _callable = value.split(":", 1)
+                            candidates.append(module.replace(".", "/") + ".py")
+
+        candidates.extend(["__main__.py", "main.py", "app.py", "manage.py", "src/main.py"])
+        entry_points: list[EntryPoint] = []
+        for path in unique_strings(candidates):
+            if path_exists_in_tree(context.file_tree, path):
+                kind = "cli" if path.endswith(("__main__.py", "main.py")) else "app"
+                entry_points.append(
+                    EntryPoint(path=path, stack="python", kind=kind, source="manifest")
+                )
+        return entry_points

sourcecode/detectors/ruby.py

@@ -0,0 +1,44 @@
+"""Detector de proyectos Ruby."""
+from __future__ import annotations
+
+from sourcecode.detectors.base import (
+    AbstractDetector,
+    DetectionContext,
+    EntryPoint,
+    StackDetection,
+)
+from sourcecode.detectors.parsers import read_text_lines
+from sourcecode.schema import FrameworkDetection
+from sourcecode.tree_utils import path_exists_in_tree
+
+
+class RubyDetector(AbstractDetector):
+    name = "ruby"
+    priority = 80
+
+    def can_detect(self, context: DetectionContext) -> bool:
+        return "Gemfile" in context.manifests
+
+    def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
+        content = "\n".join(read_text_lines(context.root / "Gemfile")).lower()
+        frameworks: list[FrameworkDetection] = []
+        if "gem 'rails'" in content or 'gem "rails"' in content:
+            frameworks.append(FrameworkDetection(name="Rails", source="Gemfile"))
+        if "gem 'sinatra'" in content or 'gem "sinatra"' in content:
+            frameworks.append(FrameworkDetection(name="Sinatra", source="Gemfile"))
+
+        entry_points: list[EntryPoint] = []
+        for path in ("bin/rails", "config.ru", "app.rb"):
+            if path_exists_in_tree(context.file_tree, path):
+                entry_points.append(
+                    EntryPoint(path=path, stack="ruby", kind="application", source="Gemfile")
+                )
+
+        stack = StackDetection(
+            stack="ruby",
+            detection_method="manifest",
+            confidence="high",
+            frameworks=frameworks,
+            manifests=["Gemfile"],
+        )
+        return [stack], entry_points