sourcecode 0.1.0__py3-none-any.whl

sourcecode/__init__.py

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

sourcecode/classifier.py

@@ -0,0 +1,177 @@
+"""Clasificacion de tipo de proyecto y scoring de confianza."""
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+from dataclasses import replace
+from typing import Any, Literal
+
+from sourcecode.schema import EntryPoint, StackDetection
+from sourcecode.tree_utils import flatten_file_tree
+
+_API_FRAMEWORKS = {
+    "FastAPI",
+    "Django",
+    "Flask",
+    "Express",
+    "Gin",
+    "Echo",
+    "Axum",
+    "Actix Web",
+    "Rocket",
+    "Spring Boot",
+    "Quarkus",
+    "Laravel",
+    "Symfony",
+}
+_WEB_FRAMEWORKS = {"Next.js", "React", "Vue", "Svelte", "Vite", "Flutter"}
+_CLI_FRAMEWORKS = {"Typer", "Cobra", "Clap"}
+ConfidenceLevel = Literal["high", "medium", "low"]
+
+
+class TypeClassifier:
+    """Clasifica project_type y enriquece stacks con confianza/primary."""
+
+    def enrich(
+        self,
+        file_tree: dict[str, Any],
+        stacks: Sequence[StackDetection],
+        entry_points: Sequence[EntryPoint],
+    ) -> tuple[list[StackDetection], str | None]:
+        enriched = [self._enrich_stack(file_tree, stack, entry_points) for stack in stacks]
+        project_type = self._classify_project_type(file_tree, enriched, entry_points)
+        primary_stack = self._select_primary_stack(enriched, project_type)
+
+        final_stacks: list[StackDetection] = []
+        for stack in enriched:
+            final_stacks.append(replace(stack, primary=(stack.stack == primary_stack)))
+        return final_stacks, project_type
+
+    def _enrich_stack(
+        self,
+        file_tree: dict[str, Any],
+        stack: StackDetection,
+        entry_points: Sequence[EntryPoint],
+    ) -> StackDetection:
+        signals = list(stack.signals)
+        score = 0
+
+        if stack.manifests:
+            score += 4
+            signals.extend(f"manifest:{manifest}" for manifest in stack.manifests)
+        if stack.frameworks:
+            score += 2
+            signals.extend(f"framework:{framework.name}" for framework in stack.frameworks)
+        if stack.package_manager:
+            score += 2
+            signals.append(f"package_manager:{stack.package_manager}")
+
+        matching_entry_points = [entry for entry in entry_points if entry.stack == stack.stack]
+        if matching_entry_points:
+            score += 2
+            signals.extend(f"entry:{entry.path}" for entry in matching_entry_points)
+
+        extension_hits = self._count_extension_hits(file_tree, stack.stack)
+        if extension_hits >= 2:
+            score += 1
+            signals.append(f"extensions:{extension_hits}")
+
+        if stack.detection_method == "heuristic":
+            score -= 2
+            signals.append("method:heuristic")
+
+        confidence = self._score_to_confidence(score)
+        return replace(stack, confidence=confidence, signals=self._unique(signals))
+
+    def _classify_project_type(
+        self,
+        file_tree: dict[str, Any],
+        stacks: Sequence[StackDetection],
+        entry_points: Sequence[EntryPoint],
+    ) -> str | None:
+        flat_paths = set(flatten_file_tree(file_tree))
+        stack_names = {stack.stack for stack in stacks}
+        framework_names = {framework.name for stack in stacks for framework in stack.frameworks}
+
+        if len(stack_names) >= 2 and self._is_fullstack(stacks):
+            return "fullstack"
+
+        if "src/lib.rs" in flat_paths and not any(path.endswith("main.rs") for path in flat_paths):
+            return "library"
+
+        if framework_names & _WEB_FRAMEWORKS or any(
+            path.startswith(("app/", "pages/", "components/")) for path in flat_paths
+        ):
+            return "webapp"
+
+        if framework_names & _API_FRAMEWORKS:
+            return "api"
+
+        if framework_names & _CLI_FRAMEWORKS or any(
+            entry.kind == "cli" for entry in entry_points
+        ) or any(path.startswith("bin/") for path in flat_paths):
+            return "cli"
+
+        if stack_names:
+            single = next(iter(stack_names))
+            if single in {"python", "go", "java", "php", "ruby"} and framework_names & _API_FRAMEWORKS:
+                return "api"
+
+        return "unknown" if stacks else None
+
+    def _is_fullstack(self, stacks: Sequence[StackDetection]) -> bool:
+        has_web = False
+        has_api = False
+        for stack in stacks:
+            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"}:
+                has_api = True
+        return has_web and has_api
+
+    def _select_primary_stack(
+        self, stacks: Sequence[StackDetection], project_type: str | None
+    ) -> str | None:
+        if not stacks:
+            return None
+
+        def sort_key(stack: StackDetection) -> tuple[int, int, int]:
+            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(
+                framework.name in _CLI_FRAMEWORKS for framework in stack.frameworks
+            ):
+                priority = 3
+            return (priority, score, manifest_weight)
+
+        return max(stacks, key=sort_key).stack
+
+    def _count_extension_hits(self, file_tree: dict[str, Any], stack: str) -> int:
+        extensions = {
+            "python": (".py",),
+            "nodejs": (".js", ".ts", ".tsx"),
+            "go": (".go",),
+            "rust": (".rs",),
+            "java": (".java",),
+            "php": (".php",),
+            "ruby": (".rb",),
+            "dart": (".dart",),
+        }.get(stack, ())
+        return sum(1 for path in flatten_file_tree(file_tree) if path.endswith(extensions))
+
+    def _score_to_confidence(self, score: int) -> ConfidenceLevel:
+        if score >= 6:
+            return "high"
+        if score >= 3:
+            return "medium"
+        return "low"
+
+    def _unique(self, values: Iterable[str]) -> list[str]:
+        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/cli.py

@@ -0,0 +1,208 @@
+"""CLI de sourcecode — interfaz de linea de comandos principal."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Optional
+
+import typer
+
+from sourcecode import __version__
+
+app = typer.Typer(
+    name="sourcecode",
+    help="Genera un mapa de contexto estructurado del proyecto para agentes IA.",
+    add_completion=False,
+)
+
+FORMAT_CHOICES = ["json", "yaml"]
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"sourcecode {__version__}")
+        raise typer.Exit()
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    path: Path = typer.Argument(Path("."), help="Directorio a analizar (default: directorio actual)"),
+    format: str = typer.Option(
+        "json",
+        "--format",
+        "-f",
+        help="Formato de salida: json|yaml",
+        show_default=True,
+    ),
+    output: Optional[Path] = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Fichero de salida (default: stdout)",
+    ),
+    compact: bool = typer.Option(
+        False,
+        "--compact",
+        help="Output reducido (~500 tokens): tipo de proyecto, stacks, entradas y arbol nivel 1",
+    ),
+    no_redact: bool = typer.Option(
+        False,
+        "--no-redact",
+        help="Desactivar redaccion de secretos (activa por defecto)",
+    ),
+    version: Optional[bool] = typer.Option(
+        None,
+        "--version",
+        "-v",
+        callback=version_callback,
+        is_eager=True,
+        help="Mostrar version y salir",
+    ),
+    depth: int = typer.Option(
+        4,
+        "--depth",
+        help="Profundidad maxima del arbol de ficheros (default: 4)",
+        min=1,
+        max=20,
+    ),
+) -> None:
+    """Genera un mapa de contexto estructurado del proyecto en formato JSON o YAML."""
+    # Validar formato
+    if format not in FORMAT_CHOICES:
+        typer.echo(
+            f"Error: valor invalido '{format}' para --format. Opciones: {', '.join(FORMAT_CHOICES)}",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    # Resolver y validar path
+    target = path.resolve()
+    if not target.exists():
+        typer.echo(f"Error: el directorio '{target}' no existe.", err=True)
+        raise typer.Exit(code=1)
+    if not target.is_dir():
+        typer.echo(f"Error: '{target}' no es un directorio.", err=True)
+        raise typer.Exit(code=1)
+
+    # --- Importar modulos de logica ---
+    from dataclasses import asdict, replace
+
+    from sourcecode.detectors import ProjectDetector, build_default_detectors
+    from sourcecode.redactor import SecretRedactor, redact_dict
+    from sourcecode.scanner import FileScanner
+    from sourcecode.schema import AnalysisMetadata, EntryPoint, SourceMap, StackDetection
+    from sourcecode.serializer import compact_view, write_output
+    from sourcecode.workspace import WorkspaceAnalyzer
+
+    # 1. Escanear el directorio (SCAN-01 a SCAN-05)
+    redactor = SecretRedactor(enabled=not no_redact)
+    scanner = FileScanner(target, max_depth=depth)
+    raw_tree = scanner.scan_tree()
+
+    # 2. Filtrar del arbol las entradas de .env y *.secret (SEC-02, todos los niveles)
+    def filter_sensitive_files(tree: dict[str, Any]) -> dict[str, Any]:
+        filtered: dict[str, Any] = {}
+        for name, value in tree.items():
+            if redactor.should_exclude_file(name):
+                continue  # excluir .env, *.secret del arbol
+            if isinstance(value, dict):
+                filtered[name] = filter_sensitive_files(value)
+            else:
+                filtered[name] = value
+        return filtered
+
+    file_tree = filter_sensitive_files(raw_tree)
+    manifests = scanner.find_manifests()
+    detector = ProjectDetector(build_default_detectors())
+    workspace_analysis = WorkspaceAnalyzer().analyze(target, manifests)
+
+    root_manifests = [
+        manifest
+        for manifest in manifests
+        if Path(manifest).resolve().parent == target
+    ]
+    detection_manifests = root_manifests if workspace_analysis.workspaces else manifests
+    if workspace_analysis.is_monorepo and not root_manifests:
+        stacks: list[StackDetection] = []
+        entry_points: list[EntryPoint] = []
+    else:
+        stacks, entry_points, _project_type = detector.detect(target, file_tree, detection_manifests)
+
+    for workspace in workspace_analysis.workspaces:
+        workspace_root = target / workspace.path
+        if not workspace_root.exists() or not workspace_root.is_dir():
+            continue
+        workspace_scanner = FileScanner(workspace_root, max_depth=depth)
+        workspace_tree = filter_sensitive_files(workspace_scanner.scan_tree())
+        workspace_manifests = workspace_scanner.find_manifests()
+        workspace_stacks, workspace_entry_points, _ = detector.detect(
+            workspace_root,
+            workspace_tree,
+            workspace_manifests,
+        )
+
+        stacks.extend(
+            replace(stack, root=workspace.path, workspace=workspace.path, primary=False)
+            for stack in workspace_stacks
+        )
+        entry_points.extend(
+            replace(
+                entry_point,
+                path=f"{workspace.path}/{entry_point.path}",
+            )
+            for entry_point in workspace_entry_points
+        )
+
+    stacks, project_type = detector.classify_results(
+        file_tree,
+        stacks,
+        entry_points,
+        project_type_override="monorepo" if workspace_analysis.is_monorepo else None,
+    )
+
+    # 3. Construir el schema
+    metadata = AnalysisMetadata(analyzed_path=str(target))
+    sm = SourceMap(
+        metadata=metadata,
+        file_tree=file_tree,
+        stacks=stacks,
+        project_type=project_type,
+        entry_points=entry_points,
+    )
+
+    # 4. Serializar (con o sin modo compact)
+    if compact:
+        data = compact_view(sm)
+        # Aplicar redaccion sobre el dict del compact view
+        if not no_redact:
+            data = redact_dict(data)
+        content = json.dumps(data, indent=2, ensure_ascii=False)
+    else:
+        # Redactar sobre el dict serializado (SEC-01, SEC-03)
+        raw_dict = asdict(sm)
+        if not no_redact:
+            raw_dict = redact_dict(raw_dict)
+
+        if format == "yaml":
+            # Para YAML, serializar el dict directamente con ruamel.yaml
+            from io import StringIO
+
+            from ruamel.yaml import YAML
+
+            yaml = YAML()
+            yaml.default_flow_style = False
+            yaml.representer.add_representer(
+                type(None),
+                lambda dumper, data_val: dumper.represent_scalar(
+                    "tag:yaml.org,2002:null", "null"
+                ),
+            )
+            stream = StringIO()
+            yaml.dump(raw_dict, stream)
+            content = stream.getvalue()
+        else:
+            content = json.dumps(raw_dict, indent=2, ensure_ascii=False)
+
+    # 5. Escribir output (CLI-04)
+    write_output(content, output=output)

sourcecode/detectors/__init__.py

@@ -0,0 +1,54 @@
+"""Infraestructura de deteccion para sourcecode."""
+
+from sourcecode.detectors.base import (
+    AbstractDetector,
+    DetectionContext,
+    EntryPoint,
+    FrameworkDetection,
+    StackDetection,
+)
+from sourcecode.detectors.dart import DartDetector
+from sourcecode.detectors.go import GoDetector
+from sourcecode.detectors.heuristic import HeuristicDetector
+from sourcecode.detectors.java import JavaDetector
+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
+
+
+def build_default_detectors() -> list[AbstractDetector]:
+    """Registro por defecto de detectores para la CLI."""
+    return [
+        NodejsDetector(),
+        PythonDetector(),
+        GoDetector(),
+        RustDetector(),
+        JavaDetector(),
+        PhpDetector(),
+        RubyDetector(),
+        DartDetector(),
+        HeuristicDetector(),
+    ]
+
+
+__all__ = [
+    "AbstractDetector",
+    "build_default_detectors",
+    "DartDetector",
+    "DetectionContext",
+    "EntryPoint",
+    "FrameworkDetection",
+    "GoDetector",
+    "HeuristicDetector",
+    "JavaDetector",
+    "NodejsDetector",
+    "PhpDetector",
+    "PythonDetector",
+    "ProjectDetector",
+    "RubyDetector",
+    "RustDetector",
+    "StackDetection",
+]

sourcecode/detectors/base.py

@@ -0,0 +1,42 @@
+"""Contratos base de deteccion para sourcecode."""
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from sourcecode.schema import EntryPoint, FrameworkDetection, StackDetection
+
+
+@dataclass
+class DetectionContext:
+    """Contexto comun que reciben todos los detectores."""
+
+    root: Path
+    file_tree: dict[str, Any]
+    manifests: list[str] = field(default_factory=list)
+
+
+class AbstractDetector(ABC):
+    """Contrato base para detectores de stack."""
+
+    name: str = "abstract"
+    priority: int = 100
+
+    @abstractmethod
+    def can_detect(self, context: DetectionContext) -> bool:
+        """Indica si este detector aplica al proyecto dado."""
+
+    @abstractmethod
+    def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
+        """Produce stacks y entry points detectados."""
+
+
+__all__ = [
+    "AbstractDetector",
+    "DetectionContext",
+    "EntryPoint",
+    "FrameworkDetection",
+    "StackDetection",
+]

sourcecode/detectors/dart.py

@@ -0,0 +1,42 @@
+"""Detector de proyectos Dart y Flutter."""
+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 DartDetector(AbstractDetector):
+    name = "dart"
+    priority = 90
+
+    def can_detect(self, context: DetectionContext) -> bool:
+        return "pubspec.yaml" in context.manifests
+
+    def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
+        content = "\n".join(read_text_lines(context.root / "pubspec.yaml")).lower()
+        frameworks: list[FrameworkDetection] = []
+        if "flutter:" in content:
+            frameworks.append(FrameworkDetection(name="Flutter", source="pubspec.yaml"))
+
+        entry_points: list[EntryPoint] = []
+        for path in ("lib/main.dart", "bin/main.dart"):
+            if path_exists_in_tree(context.file_tree, path):
+                entry_points.append(
+                    EntryPoint(path=path, stack="dart", kind="application", source="pubspec.yaml")
+                )
+
+        stack = StackDetection(
+            stack="dart",
+            detection_method="manifest",
+            confidence="high",
+            frameworks=frameworks,
+            manifests=["pubspec.yaml"],
+        )
+        return [stack], entry_points

sourcecode/detectors/go.py

@@ -0,0 +1,52 @@
+"""Detector de proyectos Go."""
+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
+
+_FRAMEWORK_MAP = {
+    "github.com/gin-gonic/gin": "Gin",
+    "github.com/labstack/echo": "Echo",
+    "github.com/spf13/cobra": "Cobra",
+    "github.com/gofiber/fiber": "Fiber",
+}
+
+
+class GoDetector(AbstractDetector):
+    name = "go"
+    priority = 40
+
+    def can_detect(self, context: DetectionContext) -> bool:
+        return "go.mod" in context.manifests
+
+    def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
+        lines = read_text_lines(context.root / "go.mod")
+        content = "\n".join(lines)
+        frameworks = [
+            FrameworkDetection(name=label, source="go.mod")
+            for dependency, label in _FRAMEWORK_MAP.items()
+            if dependency in content
+        ]
+        entry_candidates = [
+            path for path in flatten_file_tree(context.file_tree) if path.endswith("main.go")
+        ]
+        preferred = [path for path in entry_candidates if path.startswith("cmd/")] or entry_candidates
+        entry_points = [
+            EntryPoint(path=path, stack="go", kind="binary", source="go.mod")
+            for path in unique_strings(preferred)
+        ]
+        stack = StackDetection(
+            stack="go",
+            detection_method="manifest",
+            confidence="high",
+            frameworks=frameworks,
+            manifests=["go.mod"],
+        )
+        return [stack], entry_points

sourcecode/detectors/heuristic.py

@@ -0,0 +1,70 @@
+"""Fallback heuristico por extension de fichero."""
+from __future__ import annotations
+
+from collections import Counter
+
+from sourcecode.detectors.base import (
+    AbstractDetector,
+    DetectionContext,
+    EntryPoint,
+    StackDetection,
+)
+from sourcecode.tree_utils import flatten_file_tree
+
+_EXTENSION_MAP = {
+    ".py": "python",
+    ".js": "nodejs",
+    ".ts": "nodejs",
+    ".tsx": "nodejs",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".php": "php",
+    ".rb": "ruby",
+    ".dart": "dart",
+}
+
+_ENTRYPOINT_NAMES = {
+    "main.py": ("python", "script"),
+    "app.py": ("python", "app"),
+    "index.js": ("nodejs", "server"),
+    "main.go": ("go", "binary"),
+    "main.rs": ("rust", "binary"),
+}
+
+
+class HeuristicDetector(AbstractDetector):
+    name = "heuristic"
+    priority = 999
+
+    def can_detect(self, context: DetectionContext) -> bool:
+        return True
+
+    def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
+        paths = flatten_file_tree(context.file_tree)
+        counts: Counter[str] = Counter()
+        for path in paths:
+            for extension, stack in _EXTENSION_MAP.items():
+                if path.endswith(extension):
+                    counts[stack] += 1
+                    break
+
+        stacks = [
+            StackDetection(
+                stack=stack,
+                detection_method="heuristic",
+                confidence="low",
+                manifests=[],
+            )
+            for stack, _count in counts.most_common()
+        ]
+
+        entry_points: list[EntryPoint] = []
+        for path in paths:
+            filename = path.rsplit("/", 1)[-1]
+            if filename in _ENTRYPOINT_NAMES:
+                stack, kind = _ENTRYPOINT_NAMES[filename]
+                entry_points.append(
+                    EntryPoint(path=path, stack=stack, kind=kind, source="heuristic")
+                )
+        return stacks, entry_points