sourcecode 0.1.0__py3-none-any.whl

sourcecode/detectors/rust.py

@@ -0,0 +1,69 @@
+"""Detector de proyectos Rust."""
+from __future__ import annotations
+
+from typing import Any
+
+from sourcecode.detectors.base import (
+    AbstractDetector,
+    DetectionContext,
+    EntryPoint,
+    StackDetection,
+)
+from sourcecode.detectors.parsers import load_toml_file, unique_strings
+from sourcecode.schema import FrameworkDetection
+from sourcecode.tree_utils import path_exists_in_tree
+
+_FRAMEWORK_MAP = {
+    "axum": "Axum",
+    "actix-web": "Actix Web",
+    "rocket": "Rocket",
+    "clap": "Clap",
+}
+
+
+class RustDetector(AbstractDetector):
+    name = "rust"
+    priority = 50
+
+    def can_detect(self, context: DetectionContext) -> bool:
+        return "Cargo.toml" in context.manifests
+
+    def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
+        cargo = load_toml_file(context.root / "Cargo.toml")
+        if cargo is None:
+            return [], []
+
+        dependencies = cargo.get("dependencies", {})
+        frameworks = [
+            FrameworkDetection(name=label, source="Cargo.toml")
+            for package_name, label in _FRAMEWORK_MAP.items()
+            if isinstance(dependencies, dict) and package_name in dependencies
+        ]
+        entry_points = self._collect_entry_points(context, cargo)
+        stack = StackDetection(
+            stack="rust",
+            detection_method="manifest",
+            confidence="high",
+            frameworks=frameworks,
+            manifests=["Cargo.toml"],
+        )
+        return [stack], entry_points
+
+    def _collect_entry_points(self, context: DetectionContext, cargo: dict[str, Any]) -> list[EntryPoint]:
+        candidates: list[str] = []
+        if path_exists_in_tree(context.file_tree, "src/main.rs"):
+            candidates.append("src/main.rs")
+
+        bins = cargo.get("bin", [])
+        if isinstance(bins, list):
+            for item in bins:
+                if isinstance(item, dict):
+                    path = item.get("path")
+                    if isinstance(path, str) and path.strip():
+                        candidates.append(path.strip())
+
+        return [
+            EntryPoint(path=path, stack="rust", kind="binary", source="Cargo.toml")
+            for path in unique_strings(candidates)
+            if path_exists_in_tree(context.file_tree, path)
+        ]

sourcecode/redactor.py

@@ -0,0 +1,81 @@
+"""Redactor de secretos para sourcecode.
+
+Aplica patrones regex sobre los valores de texto del output JSON/YAML.
+Activo por defecto; desactivable con --no-redact.
+
+NOTA (Fase 1): La redaccion actua sobre el OUTPUT (nombres de ficheros, paths,
+metadatos) — no sobre el contenido de ficheros. En Fase 1 el output no incluye
+contenido de ficheros, por lo que la redaccion es principalmente una red de
+seguridad. En Fases 2+ cuando se lean manifiestos, la redaccion sera mas critica.
+"""
+from __future__ import annotations
+
+import re
+from typing import Any
+
+REDACTED = "[REDACTED]"
+
+# Patrones de secretos conocidos (compilados en modulo-load para rendimiento)
+_SECRET_PATTERNS: list[re.Pattern[str]] = [
+    re.compile(r"ghp_[A-Za-z0-9]{36}"),                      # GitHub PAT
+    re.compile(r"sk-proj-[A-Za-z0-9\-_]{50,}"),              # OpenAI project key (mas especifico primero)
+    re.compile(r"sk-[A-Za-z0-9]{48}"),                        # OpenAI legacy key
+    re.compile(r"AKIA[0-9A-Z]{16}"),                          # AWS Access Key ID
+    re.compile(r"Bearer\s+[A-Za-z0-9\-._~+/]+=*"),           # Bearer tokens
+]
+
+# Patrones de nombres de fichero que deben excluirse (SEC-02)
+_EXCLUDE_FILENAME_PATTERNS: list[re.Pattern[str]] = [
+    re.compile(r"^\.env(\..+)?$"),   # .env, .env.local, .env.production, etc.
+    re.compile(r"^.+\.secret$"),     # cualquier fichero *.secret
+]
+
+
+def redact_value(value: str) -> str:
+    """Aplica todos los patrones de secreto sobre un string."""
+    for pattern in _SECRET_PATTERNS:
+        value = pattern.sub(REDACTED, value)
+    return value
+
+
+def redact_dict(data: Any) -> Any:
+    """Redaccion recursiva sobre el dict/list del output.
+
+    - str: aplica patrones
+    - dict: redacta cada valor
+    - list: redacta cada elemento
+    - None, int, float, bool: retorna sin modificar
+    """
+    if isinstance(data, str):
+        return redact_value(data)
+    elif isinstance(data, dict):
+        return {k: redact_dict(v) for k, v in data.items()}
+    elif isinstance(data, list):
+        return [redact_dict(item) for item in data]
+    # None, int, float, bool — sin modificar
+    return data
+
+
+class SecretRedactor:
+    """Redactor configurable de secretos.
+
+    Args:
+        enabled: Si False, redact() retorna los datos sin modificar (--no-redact).
+    """
+
+    def __init__(self, enabled: bool = True) -> None:
+        self.enabled = enabled
+
+    def redact(self, data: Any) -> Any:
+        """Redacta secretos del dict si esta habilitado."""
+        if not self.enabled:
+            return data
+        return redact_dict(data)
+
+    @staticmethod
+    def should_exclude_file(filename: str) -> bool:
+        """Determina si un fichero debe excluirse del analisis de contenido (SEC-02).
+
+        Excluye: .env, .env.*, *.secret
+        """
+        return any(pattern.match(filename) for pattern in _EXCLUDE_FILENAME_PATTERNS)

sourcecode/scanner.py

@@ -0,0 +1,180 @@
+"""Scanner de ficheros para sourcecode.
+
+Construye un arbol JSON anidado del proyecto respetando .gitignore,
+exclusiones por defecto y sin seguir symlinks.
+
+Convencion de nodos (D-01, D-02):
+  - null (None en Python) = fichero
+  - dict = directorio (vacio o con hijos)
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, Optional, cast
+
+from pathspec import GitIgnoreSpec
+
+# Directorios excluidos por defecto (SCAN-02)
+DEFAULT_EXCLUDES: frozenset[str] = frozenset({
+    "node_modules",
+    "__pycache__",
+    ".git",
+    "vendor",
+    "venv",
+    ".venv",
+    "dist",
+    "build",
+    "target",
+})
+
+# Nombres de ficheros de manifiesto conocidos (para find_manifests)
+MANIFEST_NAMES: frozenset[str] = frozenset({
+    "pyproject.toml",
+    "setup.py",
+    "setup.cfg",
+    "requirements.txt",
+    "Pipfile",
+    "uv.lock",
+    "package.json",
+    "go.mod",
+    "Cargo.toml",
+    "pom.xml",
+    "build.gradle",
+    "composer.json",
+    "Gemfile",
+    "pubspec.yaml",
+})
+
+
+class FileScanner:
+    """Escanea un directorio de proyecto y produce un arbol de ficheros filtrado.
+
+    Args:
+        root: Directorio raiz del proyecto a analizar.
+        max_depth: Profundidad maxima del arbol de ficheros (default: 4). (SCAN-05)
+        extra_excludes: Conjunto adicional de nombres de directorio a excluir.
+    """
+
+    def __init__(
+        self,
+        root: Path,
+        max_depth: int = 4,
+        extra_excludes: Optional[frozenset[str]] = None,
+    ) -> None:
+        self.root = root.resolve()
+        self.max_depth = max_depth
+        self._excludes = DEFAULT_EXCLUDES | (extra_excludes or frozenset())
+        self._gitignore_spec: Optional[GitIgnoreSpec] = None
+
+    def _load_gitignore_spec(self) -> GitIgnoreSpec:
+        """Carga .gitignore del proyecto como GitIgnoreSpec (SCAN-01)."""
+        if self._gitignore_spec is None:
+            gitignore = self.root / ".gitignore"
+            if gitignore.exists():
+                lines = gitignore.read_text(encoding="utf-8", errors="replace").splitlines()
+            else:
+                lines = []
+            self._gitignore_spec = GitIgnoreSpec.from_lines(lines)
+        return self._gitignore_spec
+
+    def _is_excluded_by_gitignore(self, rel_path: str, is_dir: bool) -> bool:
+        """Comprueba si una ruta relativa (a self.root) esta excluida por .gitignore."""
+        spec = self._load_gitignore_spec()
+        # GitIgnoreSpec espera rutas con / al final para directorios
+        path_to_match = rel_path + "/" if is_dir else rel_path
+        return spec.match_file(path_to_match)
+
+    def scan_tree(self) -> dict[str, Any]:
+        """Construye el arbol JSON anidado del proyecto.
+
+        Retorna:
+            dict donde None = fichero (D-02) y dict = directorio (D-01).
+        """
+        self._load_gitignore_spec()
+        # Arbol raiz que se va rellenando
+        root_tree: dict[str, Any] = {}
+
+        for dirpath, dirnames, filenames in os.walk(
+            self.root, followlinks=False  # SCAN-03: no seguir symlinks de directorio
+        ):
+            current = Path(dirpath)
+            try:
+                rel = current.relative_to(self.root)
+            except ValueError:
+                continue
+
+            depth = len(rel.parts)
+
+            if depth >= self.max_depth:
+                # No descender mas alla de max_depth (SCAN-05)
+                dirnames.clear()
+                continue
+
+            # Filtrar directorios excluidos in-place (CRITICO: slice assignment) (Trampa 1)
+            dirnames[:] = [
+                d for d in dirnames
+                if d not in self._excludes
+                and not (current / d).is_symlink()  # SCAN-03: symlinks explicito
+                and not self._is_excluded_by_gitignore(
+                    str(rel / d) if rel.parts else d,
+                    is_dir=True,
+                )
+            ]
+
+            # Obtener nodo del arbol correspondiente a este directorio
+            node = self._get_or_create_node(root_tree, rel.parts)
+
+            # Agregar ficheros al nodo (null = fichero segun D-02)
+            for fname in filenames:
+                fpath = current / fname
+                # SCAN-03: no incluir symlinks de fichero
+                if fpath.is_symlink():
+                    continue
+                # Calcular ruta relativa para gitignore (Trampa 2: rutas relativas)
+                rel_file = str(rel / fname) if rel.parts else fname
+                if self._is_excluded_by_gitignore(rel_file, is_dir=False):
+                    continue
+                node[fname] = None  # D-02: null = fichero
+
+            # Asegurar que los subdirectorios aceptados existen como dicts en el nodo
+            for d in dirnames:
+                if d not in node:
+                    node[d] = {}
+
+        return root_tree
+
+    def _get_or_create_node(
+        self, tree: dict[str, Any], parts: tuple[str, ...]
+    ) -> dict[str, Any]:
+        """Navega/crea el nodo del arbol para la ruta indicada."""
+        node = tree
+        for part in parts:
+            if part not in node or node[part] is None:
+                node[part] = {}
+            node = cast(dict[str, Any], node[part])
+        return node
+
+    def find_manifests(self) -> list[str]:
+        """Encuentra ficheros de manifiesto en profundidad 0-1 (SCAN-04).
+
+        Retorna:
+            Lista de paths absolutos de manifiestos encontrados.
+        """
+        manifests: list[str] = []
+        # Profundidad 0: raiz
+        for name in MANIFEST_NAMES:
+            candidate = self.root / name
+            if candidate.exists() and not candidate.is_symlink():
+                manifests.append(str(candidate))
+        # Profundidad 1: primer nivel
+        try:
+            for child in self.root.iterdir():
+                if child.is_dir() and not child.is_symlink() and child.name not in self._excludes:
+                    for name in MANIFEST_NAMES:
+                        candidate = child / name
+                        if candidate.exists() and not candidate.is_symlink():
+                            manifests.append(str(candidate))
+        except PermissionError:
+            pass
+        return manifests

sourcecode/schema.py

@@ -0,0 +1,87 @@
+"""Schema de output v1.0 para sourcecode.
+
+Contrato publico estable — los detectores de Fase 2 escriben en SourceMap.stacks.
+Los campos stacks, project_type y entry_points son vacios/null en Fase 1.
+
+Convencion del arbol de ficheros (D-01, D-02):
+  - None = fichero
+  - dict = directorio (vacio o con hijos)
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Literal, Optional
+
+
+def _now_utc() -> str:
+    """Retorna timestamp ISO 8601 UTC con offset +00:00."""
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _sourcecode_version() -> str:
+    from sourcecode import __version__
+    return __version__
+
+
+@dataclass
+class AnalysisMetadata:
+    """Metadatos del analisis — siempre presentes en el output."""
+
+    schema_version: str = "1.0"
+    generated_at: str = field(default_factory=_now_utc)
+    sourcecode_version: str = field(default_factory=_sourcecode_version)
+    analyzed_path: str = ""
+
+
+@dataclass
+class FrameworkDetection:
+    """Framework detectado dentro de un stack."""
+
+    name: str
+    source: str = "manifest"
+
+
+@dataclass
+class StackDetection:
+    """Deteccion de un stack tecnologico."""
+
+    stack: str
+    detection_method: Literal["manifest", "lockfile", "heuristic"] = "manifest"
+    confidence: Literal["high", "medium", "low"] = "high"
+    frameworks: list[FrameworkDetection] = field(default_factory=list)
+    package_manager: Optional[str] = None
+    manifests: list[str] = field(default_factory=list)
+    primary: bool = False
+    root: Optional[str] = None
+    workspace: Optional[str] = None
+    signals: list[str] = field(default_factory=list)
+
+
+@dataclass
+class EntryPoint:
+    """Punto de entrada detectado del proyecto."""
+
+    path: str
+    stack: str
+    kind: str = "entry"
+    source: str = "manifest"
+
+
+@dataclass
+class SourceMap:
+    """Schema completo del output v1.0.
+
+    Campos de deteccion (stacks, project_type, entry_points) son vacios/null
+    en Fase 1 y se rellenan a partir de Fase 2.
+
+    file_tree sigue la convencion D-01/D-02:
+      - None = fichero
+      - dict = directorio
+    """
+
+    metadata: AnalysisMetadata = field(default_factory=AnalysisMetadata)
+    file_tree: dict[str, Any] = field(default_factory=dict)
+    stacks: list[StackDetection] = field(default_factory=list)
+    project_type: Optional[str] = None                    # relleno en Fase 3
+    entry_points: list[EntryPoint] = field(default_factory=list)

sourcecode/serializer.py

@@ -0,0 +1,90 @@
+"""Serializer de sourcecode — JSON canonico, YAML y modo compact.
+
+Patrones criticos:
+  - SIEMPRE pasar por dataclasses.asdict() antes de json.dumps (json no serializa dataclasses)
+  - ruamel.yaml con representer para null canonico (no ~)
+  - compact_view() proyecta solo los campos necesarios (~500 tokens)
+"""
+from __future__ import annotations
+
+import json
+import sys
+from dataclasses import asdict, is_dataclass
+from io import StringIO
+from pathlib import Path
+from typing import Any, Optional
+
+from sourcecode.schema import SourceMap
+
+
+def to_json(sm: SourceMap | dict[str, Any], indent: int = 2) -> str:
+    """Serializa SourceMap o dict a JSON canonico.
+
+    Acepta un SourceMap (dataclass) o un dict ya preparado (e.g. compact_view()).
+    Usa dataclasses.asdict() para convertir dataclasses a dict antes de json.dumps.
+    ensure_ascii=False para preservar UTF-8 en paths.
+    """
+    data = asdict(sm) if is_dataclass(sm) and not isinstance(sm, type) else sm
+    return json.dumps(data, indent=indent, ensure_ascii=False)
+
+
+def to_yaml(sm: SourceMap) -> str:
+    """Serializa SourceMap a YAML usando ruamel.yaml.
+
+    ruamel.yaml preserva el orden de claves y serializa None como null
+    (no como ~) con la configuracion por defecto del dump de dicts.
+    """
+    from ruamel.yaml import YAML
+
+    yaml = YAML()
+    yaml.default_flow_style = False
+    # Asegurar que None se serializa como 'null' y no como '~'
+    yaml.representer.add_representer(
+        type(None),
+        lambda dumper, data: dumper.represent_scalar("tag:yaml.org,2002:null", "null"),
+    )
+    stream = StringIO()
+    yaml.dump(asdict(sm), stream)
+    return stream.getvalue()
+
+
+def compact_view(sm: SourceMap) -> dict[str, Any]:
+    """Proyeccion compacta del SourceMap (~500 tokens).
+
+    Incluye: schema_version, project_type, stacks, entry_points y
+    file_tree_depth1 (solo el primer nivel del arbol de ficheros).
+
+    En Fase 1 stacks/project_type/entry_points estan vacios — el output
+    compact es principalmente el arbol de primer nivel.
+    """
+    depth1: dict[str, Any] = {}
+    for name, value in sm.file_tree.items():
+        if isinstance(value, dict):
+            # Directorio: mostrar como dict vacio en depth1 (solo la entrada raiz)
+            depth1[name] = {}
+        else:
+            # Fichero: mantener null
+            depth1[name] = None
+
+    return {
+        "schema_version": sm.metadata.schema_version,
+        "project_type": sm.project_type,
+        "stacks": [asdict(stack) for stack in sm.stacks],
+        "entry_points": [asdict(entry_point) for entry_point in sm.entry_points],
+        "file_tree_depth1": depth1,
+    }
+
+
+def write_output(content: str, output: Optional[Path]) -> None:
+    """Escribe el contenido a stdout o a un fichero.
+
+    Args:
+        content: String serializado (JSON o YAML).
+        output: Path del fichero destino. None = stdout.
+    """
+    if output is None:
+        sys.stdout.write(content)
+        if not content.endswith("\n"):
+            sys.stdout.write("\n")
+    else:
+        output.write_text(content, encoding="utf-8")

sourcecode/tree_utils.py

@@ -0,0 +1,28 @@
+"""Helpers neutrales para trabajar con el file_tree."""
+from __future__ import annotations
+
+from typing import Any
+
+
+def flatten_file_tree(file_tree: dict[str, Any], prefix: str = "") -> list[str]:
+    """Aplana el file_tree jerarquico a paths relativos."""
+    paths: list[str] = []
+    for name, value in file_tree.items():
+        current = f"{prefix}/{name}" if prefix else name
+        paths.append(current)
+        if isinstance(value, dict):
+            paths.extend(flatten_file_tree(value, current))
+    return paths
+
+
+def path_exists_in_tree(file_tree: dict[str, Any], target: str) -> bool:
+    """Comprueba si un path relativo existe en el file_tree."""
+    normalized = target.strip("/").split("/")
+    node: Any = file_tree
+    for index, part in enumerate(normalized):
+        if not isinstance(node, dict) or part not in node:
+            return False
+        node = node[part]
+        if index < len(normalized) - 1 and node is None:
+            return False
+    return True