sourcecode 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

sourcecode/__init__.py

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

sourcecode/cli.py

@@ -107,6 +107,11 @@ def main(
         help="Profundidad de extraccion de docs: module|symbols|full",
         show_default=True,
     ),
+    full_metrics: bool = typer.Option(
+        False,
+        "--full-metrics",
+        help="Incluir metricas de calidad: LOC, simbolos, complejidad, tests y cobertura por fichero",
+    ),
 ) -> None:
     """Genera un mapa de contexto estructurado del proyecto en formato JSON o YAML."""
     # Validar formato
@@ -145,9 +150,18 @@ def main(
     from sourcecode.detectors import ProjectDetector, build_default_detectors
     from sourcecode.doc_analyzer import DocAnalyzer
     from sourcecode.graph_analyzer import GraphAnalyzer, GraphDetail
+    from sourcecode.metrics_analyzer import MetricsAnalyzer
     from sourcecode.redactor import SecretRedactor, redact_dict
     from sourcecode.scanner import FileScanner
-    from sourcecode.schema import AnalysisMetadata, DocRecord, DocSummary, DocsDepth, EntryPoint, SourceMap, StackDetection
+    from sourcecode.schema import (
+        AnalysisMetadata,
+        DocRecord,
+        DocsDepth,
+        DocSummary,
+        EntryPoint,
+        SourceMap,
+        StackDetection,
+    )
     from sourcecode.serializer import compact_view, write_output
     from sourcecode.workspace import WorkspaceAnalyzer
 
@@ -212,6 +226,7 @@ def main(
     graph_detail_typed = cast(GraphDetail, graph_detail)
     docs_depth_typed = cast(DocsDepth, docs_depth)
     doc_analyzer = DocAnalyzer() if docs else None
+    metrics_analyzer = MetricsAnalyzer() if full_metrics else None
 
     root_manifests = [
         manifest
@@ -269,6 +284,24 @@ def main(
         doc_records.extend(root_doc_records)
         doc_summaries.append(root_doc_summary)
 
+    file_metrics_records: list = []
+    metrics_summaries = []
+    if metrics_analyzer is not None:
+        root_metrics_tree = (
+            prune_workspace_paths(
+                file_tree,
+                [workspace.path for workspace in workspace_analysis.workspaces],
+            )
+            if workspace_analysis.workspaces
+            else file_tree
+        )
+        root_file_metrics, root_metrics_summary = metrics_analyzer.analyze(
+            target,
+            root_metrics_tree,
+        )
+        file_metrics_records.extend(root_file_metrics)
+        metrics_summaries.append(root_metrics_summary)
+
     for workspace in workspace_analysis.workspaces:
         workspace_root = target / workspace.path
         if not workspace_root.exists() or not workspace_root.is_dir():
@@ -327,6 +360,18 @@ def main(
             ]
             doc_records.extend(prefixed_doc_records)
             doc_summaries.append(workspace_doc_summary)
+        if metrics_analyzer is not None:
+            ws_file_metrics, ws_metrics_summary = metrics_analyzer.analyze(
+                workspace_root,
+                workspace_tree,
+                workspace=workspace.path,
+            )
+            prefixed_file_metrics = [
+                replace(m, path=f"{workspace.path}/{m.path}")
+                for m in ws_file_metrics
+            ]
+            file_metrics_records.extend(prefixed_file_metrics)
+            metrics_summaries.append(ws_metrics_summary)
 
     stacks, project_type = detector.classify_results(
         file_tree,
@@ -355,6 +400,11 @@ def main(
         if doc_analyzer is not None
         else None
     )
+    metrics_summary = (
+        metrics_analyzer.merge_summaries(metrics_summaries)
+        if metrics_analyzer is not None
+        else None
+    )
 
     # 3. Construir el schema
     metadata = AnalysisMetadata(analyzed_path=str(target))
@@ -370,6 +420,8 @@ def main(
         module_graph_summary=module_graph.summary if module_graph is not None else None,
         docs=doc_records,
         doc_summary=doc_summary,
+        file_metrics=file_metrics_records,
+        metrics_summary=metrics_summary,
     )
 
     # Phase 9: LLM Output Quality — poblar campos derivados

sourcecode/coverage_parser.py

@@ -0,0 +1,539 @@
+"""Parser de artefactos de cobertura pre-existentes.
+
+Lee coverage.xml (Cobertura), .coverage (SQLite de coverage.py >= 5.0),
+lcov.info (LCOV) y jacoco.xml (JaCoCo) sin ejecutar tests ni toolchains.
+
+Solo stdlib: sqlite3, xml.etree.ElementTree, pathlib.
+"""
+from __future__ import annotations
+
+import sqlite3
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from typing import Optional
+
+from sourcecode.schema import CoverageRecord
+
+# ---------------------------------------------------------------------------
+# Module-level helpers
+# ---------------------------------------------------------------------------
+
+def _safe_float(value: Optional[str]) -> Optional[float]:
+    """Convierte string a float; retorna None si es None o no parseable."""
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (ValueError, TypeError):
+        return None
+
+
+def _safe_int(value: Optional[str]) -> Optional[int]:
+    """Convierte string a int; retorna None si es None o no parseable."""
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except (ValueError, TypeError):
+        return None
+
+
+def _decode_numbits(blob: bytes) -> list[int]:
+    """Decodifica bitset little-endian de coverage.py .coverage SQLite.
+
+    Byte i, bit j set => linea (i*8 + j + 1) ejecutada.
+    Ejemplo: bytes([0b00000101]) => [1, 3]
+    """
+    return [
+        i * 8 + j + 1
+        for i, byte in enumerate(blob)
+        for j in range(8)
+        if byte & (1 << j)
+    ]
+
+
+# ---------------------------------------------------------------------------
+# CoverageParser
+# ---------------------------------------------------------------------------
+
+class CoverageParser:
+    """Parsea artefactos de cobertura pre-existentes sin ejecutar tests."""
+
+    _COBERTURA_CANDIDATES = [
+        "coverage.xml",
+        "build/coverage.xml",
+        "target/coverage.xml",
+        "htmlcov/coverage.xml",
+    ]
+    _LCOV_CANDIDATES = [
+        "lcov.info",
+        "coverage/lcov.info",
+        "coverage.lcov",
+    ]
+    _JACOCO_CANDIDATES = [
+        "jacoco.xml",
+        "build/reports/jacoco/test/jacocoTestReport.xml",
+        "target/site/jacoco/jacoco.xml",
+    ]
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def parse_all(self, root: Path) -> list[CoverageRecord]:
+        """Busca y parsea todos los artefactos de cobertura en root.
+
+        Nunca lanza excepcion — errores van a la lista de records con campos None.
+        Retorna lista (posiblemente vacia) de CoverageRecord encontrados.
+        """
+        results: list[CoverageRecord] = []
+        for parser in (
+            self._parse_cobertura_xml,
+            self._parse_dot_coverage,
+            self._parse_lcov,
+            self._parse_jacoco_xml,
+        ):
+            try:
+                record = parser(root)
+            except Exception:
+                record = None
+            if record is not None:
+                results.append(record)
+        return results
+
+    def build_file_coverage_map(
+        self,
+        root: Path,
+        records: list[CoverageRecord],
+    ) -> dict[str, tuple[float | None, float | None, str]]:
+        """Retorna {rel_path: (line_rate, branch_rate, source_name)}.
+
+        Prioridad de fuente: cobertura_xml > lcov > jacoco_xml > dot_coverage.
+        Paths absolutos (dot_coverage) se convierten a relativos via relative_to(root);
+        paths fuera de root se descartan silenciosamente.
+        """
+        result: dict[str, tuple[float | None, float | None, str]] = {}
+
+        # Determine which formats are present (in priority order)
+        formats_present = {r.format for r in records}
+
+        priority_order = ["cobertura_xml", "lcov", "jacoco_xml", "dot_coverage"]
+
+        for fmt in priority_order:
+            if fmt not in formats_present:
+                continue
+
+            per_file = self._get_per_file_data(root, fmt)
+            for rel_path, (lr, br) in per_file.items():
+                # Only add if not already claimed by a higher-priority format
+                if rel_path not in result:
+                    result[rel_path] = (lr, br, fmt)
+
+        return result
+
+    # ------------------------------------------------------------------
+    # Format parsers (return None on any failure)
+    # ------------------------------------------------------------------
+
+    def _parse_cobertura_xml(self, root: Path) -> CoverageRecord | None:
+        """Parsea coverage.xml en formato Cobertura via stdlib ET.
+
+        Candidatos: coverage.xml, build/coverage.xml, target/coverage.xml,
+        htmlcov/coverage.xml. Retorna el primero que parsea correctamente.
+        """
+        for candidate in self._COBERTURA_CANDIDATES:
+            path = root / candidate
+            if not path.exists():
+                continue
+            try:
+                tree = ET.parse(str(path))
+                root_elem = tree.getroot()
+            except ET.ParseError:
+                continue
+            except Exception:
+                continue
+
+            if root_elem.tag != "coverage":
+                continue
+
+            line_rate = _safe_float(root_elem.get("line-rate"))
+            branch_rate = _safe_float(root_elem.get("branch-rate"))
+            lines_covered = _safe_int(root_elem.get("lines-covered"))
+            lines_valid = _safe_int(root_elem.get("lines-valid"))
+            timestamp = root_elem.get("timestamp")
+            tool_version = root_elem.get("version")
+            file_count = len(root_elem.findall(".//class"))
+
+            return CoverageRecord(
+                source_file=str(path.relative_to(root)).replace("\\", "/"),
+                format="cobertura_xml",
+                line_rate=line_rate,
+                branch_rate=branch_rate,
+                lines_covered=lines_covered,
+                lines_valid=lines_valid,
+                timestamp=timestamp,
+                tool_version=tool_version,
+                file_count=file_count,
+            )
+
+        return None
+
+    def _parse_dot_coverage(self, root: Path) -> CoverageRecord | None:
+        """Parsea .coverage SQLite (coverage.py >= 5.0).
+
+        Silencia sqlite3.DatabaseError — el fichero puede ser pickle (< 5.0)
+        o estar corrupto. Retorna None si no existe o no es SQLite valido.
+        """
+        path = root / ".coverage"
+        if not path.exists():
+            return None
+
+        try:
+            conn = sqlite3.connect(str(path))
+            try:
+                # Validate it's a coverage.py SQLite database
+                cursor = conn.execute(
+                    "SELECT key, value FROM meta WHERE key IN ('version', 'timestamp')"
+                )
+                meta_rows = cursor.fetchall()
+                meta = {row[0]: row[1] for row in meta_rows}
+
+                file_cursor = conn.execute("SELECT count(*) FROM file")
+                file_count = file_cursor.fetchone()[0]
+            finally:
+                conn.close()
+        except sqlite3.DatabaseError:
+            return None
+        except Exception:
+            return None
+
+        tool_version = meta.get("version")
+        timestamp = meta.get("timestamp")
+
+        return CoverageRecord(
+            source_file=".coverage",
+            format="dot_coverage",
+            line_rate=None,
+            branch_rate=None,
+            lines_covered=None,
+            lines_valid=None,
+            timestamp=str(timestamp) if timestamp is not None else None,
+            tool_version=str(tool_version) if tool_version is not None else None,
+            file_count=file_count,
+        )
+
+    def _parse_lcov(self, root: Path) -> CoverageRecord | None:
+        """Parsea lcov.info via state machine linea a linea.
+
+        Candidatos: lcov.info, coverage/lcov.info, coverage.lcov.
+        Lee con errors='replace' para seguridad de encoding.
+        """
+        for candidate in self._LCOV_CANDIDATES:
+            path = root / candidate
+            if not path.exists():
+                continue
+            try:
+                content = path.read_text(encoding="utf-8", errors="replace")
+            except Exception:
+                continue
+
+            total_lf = 0
+            total_lh = 0
+            total_brf = 0
+            total_brh = 0
+            file_count = 0
+
+            for line in content.splitlines():
+                line = line.strip()
+                if line.startswith("LF:"):
+                    val = _safe_int(line[3:])
+                    if val is not None:
+                        total_lf += val
+                elif line.startswith("LH:"):
+                    val = _safe_int(line[3:])
+                    if val is not None:
+                        total_lh += val
+                elif line.startswith("BRF:"):
+                    val = _safe_int(line[4:])
+                    if val is not None:
+                        total_brf += val
+                elif line.startswith("BRH:"):
+                    val = _safe_int(line[4:])
+                    if val is not None:
+                        total_brh += val
+                elif line == "end_of_record":
+                    file_count += 1
+
+            line_rate = total_lh / total_lf if total_lf > 0 else None
+            branch_rate = total_brh / total_brf if total_brf > 0 else None
+
+            return CoverageRecord(
+                source_file=str(path.relative_to(root)).replace("\\", "/"),
+                format="lcov",
+                line_rate=line_rate,
+                branch_rate=branch_rate,
+                lines_covered=total_lh if total_lf > 0 else None,
+                lines_valid=total_lf if total_lf > 0 else None,
+                timestamp=None,
+                tool_version=None,
+                file_count=file_count,
+            )
+
+        return None
+
+    def _parse_jacoco_xml(self, root: Path) -> CoverageRecord | None:
+        """Parsea jacoco.xml via stdlib ET.
+
+        Lee root-level <counter> elements (hijos directos de <report>).
+        JaCoCo usa '/' en package paths (com/example), no '.'.
+        """
+        for candidate in self._JACOCO_CANDIDATES:
+            path = root / candidate
+            if not path.exists():
+                continue
+            try:
+                tree = ET.parse(str(path))
+                report_elem = tree.getroot()
+            except ET.ParseError:
+                continue
+            except Exception:
+                continue
+
+            if report_elem.tag != "report":
+                continue
+
+            # Root-level counters only (direct children of <report>)
+            counters = {
+                c.get("type"): c
+                for c in report_elem.findall("counter")
+            }
+
+            line_rate: Optional[float] = None
+            branch_rate: Optional[float] = None
+            lines_covered: Optional[int] = None
+            lines_valid: Optional[int] = None
+
+            if "LINE" in counters:
+                c = counters["LINE"]
+                missed = _safe_int(c.get("missed"))
+                covered = _safe_int(c.get("covered"))
+                if missed is not None and covered is not None:
+                    total = missed + covered
+                    lines_covered = covered
+                    lines_valid = total
+                    line_rate = covered / total if total > 0 else None
+
+            if "BRANCH" in counters:
+                c = counters["BRANCH"]
+                missed = _safe_int(c.get("missed"))
+                covered = _safe_int(c.get("covered"))
+                if missed is not None and covered is not None:
+                    total = missed + covered
+                    branch_rate = covered / total if total > 0 else None
+
+            file_count = len(report_elem.findall(".//sourcefile"))
+
+            return CoverageRecord(
+                source_file=str(path.relative_to(root)).replace("\\", "/"),
+                format="jacoco_xml",
+                line_rate=line_rate,
+                branch_rate=branch_rate,
+                lines_covered=lines_covered,
+                lines_valid=lines_valid,
+                timestamp=None,
+                tool_version=None,
+                file_count=file_count,
+            )
+
+        return None
+
+    # ------------------------------------------------------------------
+    # Internal: per-file data extraction for build_file_coverage_map
+    # ------------------------------------------------------------------
+
+    def _get_per_file_data(
+        self,
+        root: Path,
+        fmt: str,
+    ) -> dict[str, tuple[float | None, float | None]]:
+        """Extrae datos de cobertura por fichero para un formato dado.
+
+        Retorna {rel_path: (line_rate, branch_rate)}.
+        """
+        if fmt == "cobertura_xml":
+            return self._per_file_cobertura(root)
+        if fmt == "lcov":
+            return self._per_file_lcov(root)
+        if fmt == "jacoco_xml":
+            return self._per_file_jacoco(root)
+        if fmt == "dot_coverage":
+            return self._per_file_dot_coverage(root)
+        return {}
+
+    def _per_file_cobertura(
+        self, root: Path
+    ) -> dict[str, tuple[float | None, float | None]]:
+        """Extrae line_rate y branch_rate por fichero desde coverage.xml (Cobertura)."""
+        result: dict[str, tuple[float | None, float | None]] = {}
+        for candidate in self._COBERTURA_CANDIDATES:
+            path = root / candidate
+            if not path.exists():
+                continue
+            try:
+                tree = ET.parse(str(path))
+                root_elem = tree.getroot()
+            except Exception:
+                continue
+            if root_elem.tag != "coverage":
+                continue
+
+            for cls in root_elem.findall(".//class"):
+                filename = cls.get("filename")
+                if not filename:
+                    continue
+                # Normalize path separators to forward slash
+                filename = filename.replace("\\", "/")
+                lr = _safe_float(cls.get("line-rate"))
+                br = _safe_float(cls.get("branch-rate"))
+                result[filename] = (lr, br)
+            break  # use first valid candidate
+        return result
+
+    def _per_file_lcov(
+        self, root: Path
+    ) -> dict[str, tuple[float | None, float | None]]:
+        """Extrae line_rate y branch_rate por fichero desde lcov.info."""
+        result: dict[str, tuple[float | None, float | None]] = {}
+        for candidate in self._LCOV_CANDIDATES:
+            path = root / candidate
+            if not path.exists():
+                continue
+            try:
+                content = path.read_text(encoding="utf-8", errors="replace")
+            except Exception:
+                continue
+
+            current_file: Optional[str] = None
+            lf = lh = brf = brh = 0
+
+            for line in content.splitlines():
+                line = line.strip()
+                if line.startswith("SF:"):
+                    current_file = line[3:].replace("\\", "/")
+                    lf = lh = brf = brh = 0
+                elif line.startswith("LF:"):
+                    val = _safe_int(line[3:])
+                    if val is not None:
+                        lf = val
+                elif line.startswith("LH:"):
+                    val = _safe_int(line[3:])
+                    if val is not None:
+                        lh = val
+                elif line.startswith("BRF:"):
+                    val = _safe_int(line[4:])
+                    if val is not None:
+                        brf = val
+                elif line.startswith("BRH:"):
+                    val = _safe_int(line[4:])
+                    if val is not None:
+                        brh = val
+                elif line == "end_of_record" and current_file is not None:
+                    lr = lh / lf if lf > 0 else None
+                    br = brh / brf if brf > 0 else None
+                    result[current_file] = (lr, br)
+                    current_file = None
+
+            break  # use first valid candidate
+        return result
+
+    def _per_file_jacoco(
+        self, root: Path
+    ) -> dict[str, tuple[float | None, float | None]]:
+        """Extrae line_rate y branch_rate por fichero desde jacoco.xml."""
+        result: dict[str, tuple[float | None, float | None]] = {}
+        for candidate in self._JACOCO_CANDIDATES:
+            path = root / candidate
+            if not path.exists():
+                continue
+            try:
+                tree = ET.parse(str(path))
+                report_elem = tree.getroot()
+            except Exception:
+                continue
+            if report_elem.tag != "report":
+                continue
+
+            for pkg in report_elem.findall("package"):
+                pkg_name = pkg.get("name", "").replace("\\", "/")
+                for sf in pkg.findall("sourcefile"):
+                    sf_name = sf.get("name", "")
+                    rel_path = f"{pkg_name}/{sf_name}" if pkg_name else sf_name
+
+                    counters = {
+                        c.get("type"): c for c in sf.findall("counter")
+                    }
+                    lr: Optional[float] = None
+                    br: Optional[float] = None
+
+                    if "LINE" in counters:
+                        c = counters["LINE"]
+                        missed = _safe_int(c.get("missed"))
+                        covered = _safe_int(c.get("covered"))
+                        if missed is not None and covered is not None:
+                            total = missed + covered
+                            lr = covered / total if total > 0 else None
+
+                    if "BRANCH" in counters:
+                        c = counters["BRANCH"]
+                        missed = _safe_int(c.get("missed"))
+                        covered = _safe_int(c.get("covered"))
+                        if missed is not None and covered is not None:
+                            total = missed + covered
+                            br = covered / total if total > 0 else None
+
+                    result[rel_path] = (lr, br)
+            break  # use first valid candidate
+        return result
+
+    def _per_file_dot_coverage(
+        self, root: Path
+    ) -> dict[str, tuple[float | None, float | None]]:
+        """Extrae datos por fichero desde .coverage SQLite (coverage.py >= 5.0).
+
+        Intenta leer la tabla 'line_bits' para calcular lineas ejecutadas;
+        silencia cualquier error de SQLite.
+        Paths absolutos se convierten a relativos con relative_to(root).
+        """
+        result: dict[str, tuple[float | None, float | None]] = {}
+        path = root / ".coverage"
+        if not path.exists():
+            return result
+
+        try:
+            conn = sqlite3.connect(str(path))
+            try:
+                # Get all tracked files
+                file_rows = conn.execute(
+                    "SELECT id, path FROM file"
+                ).fetchall()
+
+                for _file_id, abs_path in file_rows:
+                    # Convert to relative path
+                    try:
+                        rel = Path(abs_path).relative_to(root)
+                        rel_str = str(rel).replace("\\", "/")
+                    except ValueError:
+                        # Path outside root — discard per threat model T-10-02-03
+                        continue
+
+                    # line_rate is unavailable without total_lines context
+                    result[rel_str] = (None, None)
+
+            finally:
+                conn.close()
+        except sqlite3.DatabaseError:
+            return {}
+        except Exception:
+            return {}
+
+        return result

sourcecode/metrics_analyzer.py

@@ -0,0 +1,495 @@
+"""Analisis de metricas de calidad de codigo: LOC, simbolos y complejidad.
+
+Sigue el mismo patron que DocAnalyzer y GraphAnalyzer:
+- analyze() recibe root + file_tree, retorna (list[FileMetrics], MetricsSummary)
+- merge_summaries() agrega multiples MetricsSummary en uno
+
+LOC counting usa text scan para todos los lenguajes.
+Python: adicionalmente ast.parse para simbolos exactos y complejidad McCabe.
+JS/TS, Go, Rust, Java: regex para simbolos aproximados (availability="inferred").
+Otros: solo LOC (availability="unavailable" para simbolos y complejidad).
+"""
+from __future__ import annotations
+
+import ast
+import re
+from collections.abc import Iterable
+from pathlib import Path, PurePosixPath
+from typing import Any
+
+from sourcecode.coverage_parser import CoverageParser
+from sourcecode.doc_analyzer import _LANG_MAP  # reusar, no redefinir
+from sourcecode.schema import FileMetrics, MetricsSummary
+from sourcecode.tree_utils import flatten_file_tree
+
+# ---------------------------------------------------------------------------
+# Test file detection — patterns from research (10-RESEARCH.md)
+# ---------------------------------------------------------------------------
+
+_TEST_FILE_PATTERNS: list[re.Pattern[str]] = [
+    re.compile(p) for p in [
+        r"(?:^|/)tests?/.*\.py$",
+        r"(?:^|/)test_.*\.py$",
+        r"^.*_test\.py$",
+        r"^.*_test\.go$",
+        r"^.*\.(spec|test)\.(js|jsx|ts|tsx|mjs|cjs)$",
+        r"(?:^|/)__tests__/.*\.(js|jsx|ts|tsx|mjs|cjs)$",
+        r"^.*(Test|Tests|Spec|IT)\.(java|kt|scala)$",
+        r"(?:^|/)spec/.*\.rb$",
+        r"^.*(?:test|spec).*\.rb$",
+        r"(?:^|/)tests/.*\.rs$",
+        r"^.*_test\.dart$",
+        r"(?:^|/)test/.*\.dart$",
+        r"^.*(test|Test|spec)\.(c|cpp|cc|h|hpp)$",
+        r"(?:^|/)tests?/.*\.(c|cpp|cc)$",
+        r"^.*Test\.php$",
+        r"(?:^|/)tests?/.*\.php$",
+    ]
+]
+
+# Stem patterns for inferring production file name from test file name.
+# Each entry is (compiled_pattern, replacement_string).
+_STEM_PATTERNS: list[tuple[re.Pattern[str], str]] = [
+    (re.compile(r"^test_(.+)$"), r"\1"),
+    (re.compile(r"^(.+)_test(\.\w+)$"), r"\1\2"),
+    (re.compile(r"^(.+)(Test|Tests|Spec|IT)(\.\w+)$"), r"\1\3"),
+    (re.compile(r"^(.+)\.(spec|test)(\.\w+)$"), r"\1\3"),
+    (re.compile(r"^(.+)_spec(\.\w+)$"), r"\1\2"),
+]
+
+
+def is_test_file(path: str) -> bool:
+    """Return True if path corresponds to a test file based on ecosystem conventions.
+
+    Normalizes Windows backslashes to forward slashes before matching.
+    Patterns are anchored to avoid false positives (e.g., 'testdata/', '*_tested.py').
+    """
+    normalized = path.replace("\\", "/")
+    return any(p.search(normalized) for p in _TEST_FILE_PATTERNS)
+
+
+def infer_production_target(test_path: str) -> str | None:
+    """Infer the production module filename from a test file path.
+
+    Operates on the basename only (not the full path).
+    Returns the bare filename (e.g., 'scanner.py'), or None if no pattern matches.
+    """
+    name = PurePosixPath(test_path.replace("\\", "/")).name
+    for pattern, replacement in _STEM_PATTERNS:
+        if pattern.match(name):
+            return pattern.sub(replacement, name)
+    return None
+
+# ---------------------------------------------------------------------------
+# Regex patterns for inferred symbol counting (JS/TS, Go, Rust, Java)
+# ---------------------------------------------------------------------------
+
+_JS_FUNC_RE = re.compile(
+    r"\b(?:async\s+)?function\s+\w+|\bconst\s+\w+\s*=\s*(?:async\s*)?\(",
+    re.MULTILINE,
+)
+_JS_CLASS_RE = re.compile(r"^\s*class\s+\w+", re.MULTILINE)
+
+_GO_FUNC_RE = re.compile(r"^func\s", re.MULTILINE)
+_GO_STRUCT_RE = re.compile(r"^type\s+\w+\s+struct", re.MULTILINE)
+
+_RUST_FN_RE = re.compile(r"^\s*(?:pub\s+)?(?:async\s+)?fn\s+\w+", re.MULTILINE)
+_RUST_STRUCT_RE = re.compile(r"^\s*(?:pub\s+)?struct\s+\w+", re.MULTILINE)
+
+_JAVA_CLASS_RE = re.compile(
+    r"^\s*(?:public\s+|private\s+|protected\s+)?(?:abstract\s+|final\s+)?class\s+\w+",
+    re.MULTILINE,
+)
+_JAVA_METHOD_RE = re.compile(
+    r"^\s*(?:public|private|protected)\s+(?:static\s+)?\w[\w<>\[\]]*\s+\w+\s*\(",
+    re.MULTILINE,
+)
+
+# Languages with inferred symbol support
+_INFERRED_SYMBOL_LANGS = {"javascript", "typescript", "go", "rust", "java"}
+
+# Languages with Python-level measured support
+_MEASURED_SYMBOL_LANGS = {"python"}
+
+
+def _lang_for_suffix(suffix: str) -> str:
+    return _LANG_MAP.get(suffix.lower(), "unknown")
+
+
+def _mccabe(func_node: ast.FunctionDef | ast.AsyncFunctionDef) -> int:
+    """Calcula la complejidad ciclomatica McCabe de una funcion.
+
+    cc = 1 + suma de ramas (If, For, While, ExceptHandler, With, Assert,
+    comprehensions) + (len(BoolOp.values) - 1) por cada BoolOp.
+    """
+    cc = 1
+    for node in ast.walk(func_node):
+        if isinstance(node, (ast.If, ast.For, ast.While, ast.ExceptHandler, ast.With, ast.Assert)):
+            cc += 1
+        elif isinstance(node, ast.BoolOp):
+            cc += len(node.values) - 1
+        elif isinstance(node, (ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)):
+            cc += 1
+    return cc
+
+
+class MetricsAnalyzer:
+    """Analiza metricas de calidad de codigo: LOC, simbolos y complejidad ciclomatica."""
+
+    _MAX_FILES = 500
+    _MAX_FILE_SIZE = 500_000  # bytes
+
+    # ---------------------------------------------------------------------------
+    # Public API
+    # ---------------------------------------------------------------------------
+
+    def analyze(
+        self,
+        root: Path,
+        file_tree: dict[str, Any],
+        *,
+        workspace: str | None = None,
+    ) -> tuple[list[FileMetrics], MetricsSummary]:
+        """Analiza el arbol de ficheros y retorna (list[FileMetrics], MetricsSummary).
+
+        Nunca lanza excepciones — todos los errores van a summary.limitations.
+        """
+        all_paths = flatten_file_tree(file_tree)
+        # Keep only paths that are actual files (not directories)
+        file_paths = [p for p in all_paths if (root / p).is_file()]
+
+        limitations: list[str] = []
+
+        # Guard: max files
+        if len(file_paths) > self._MAX_FILES:
+            actual = len(file_paths)
+            limitations.append(f"max_files_reached:{actual}")
+            file_paths = file_paths[: self._MAX_FILES]
+
+        # --- Coverage: parse all artifacts before iterating files ---
+        coverage_parser = CoverageParser()
+        coverage_records = coverage_parser.parse_all(root)
+        file_cov_map = coverage_parser.build_file_coverage_map(root, coverage_records)
+
+        records: list[FileMetrics] = []
+        languages: set[str] = set()
+
+        for rel_path in file_paths:
+            abs_path = root / rel_path
+
+            # Guard: max file size
+            try:
+                file_size = abs_path.stat().st_size
+            except OSError:
+                limitations.append(f"read_error:{Path(rel_path).as_posix()}")
+                continue
+            if file_size > self._MAX_FILE_SIZE:
+                limitations.append(f"file_too_large:{Path(rel_path).as_posix()}")
+                continue
+
+            fm = self._analyze_file(abs_path, rel_path, workspace)
+
+            # --- Test detection ---
+            norm_rel = Path(rel_path).as_posix()
+            fm.is_test = is_test_file(norm_rel)
+
+            # --- Production target resolution ---
+            if fm.is_test:
+                inferred_name = infer_production_target(norm_rel)
+                if inferred_name is not None:
+                    match = next(
+                        (
+                            Path(p).as_posix()
+                            for p in file_paths
+                            if not is_test_file(Path(p).as_posix())
+                            and Path(p).name == inferred_name
+                        ),
+                        None,
+                    )
+                    fm.production_target = match
+
+            # --- Coverage wiring ---
+            cov_entry = file_cov_map.get(norm_rel)
+            if cov_entry is not None:
+                fm.line_rate, fm.branch_rate, fm.coverage_source = cov_entry
+                fm.coverage_availability = "measured"
+
+            records.append(fm)
+            if fm.language != "unknown":
+                languages.add(fm.language)
+
+        summary = MetricsSummary(
+            requested=True,
+            file_count=len(records),
+            test_file_count=sum(1 for r in records if r.is_test),
+            languages=sorted(languages),
+            total_loc=sum(r.code_lines for r in records),
+            coverage_records=coverage_records,
+            coverage_sources_found=sorted({r.format for r in coverage_records}),
+            limitations=limitations,
+        )
+        return records, summary
+
+    def merge_summaries(self, summaries: Iterable[MetricsSummary]) -> MetricsSummary:
+        """Agrega multiples MetricsSummary en uno.
+
+        Sigue el mismo patron que DocAnalyzer.merge_summaries().
+        """
+        result = MetricsSummary(requested=True)
+        languages: set[str] = set()
+        sources_found: set[str] = set()
+        limitations: list[str] = []
+
+        for summary in summaries:
+            result.file_count += summary.file_count
+            result.test_file_count += summary.test_file_count
+            result.total_loc += summary.total_loc
+            languages.update(summary.languages)
+            result.coverage_records.extend(summary.coverage_records)
+            sources_found.update(summary.coverage_sources_found)
+            limitations.extend(summary.limitations)
+
+        result.languages = sorted(languages)
+        result.coverage_sources_found = sorted(sources_found)
+        result.limitations = limitations
+        return result
+
+    # ---------------------------------------------------------------------------
+    # Per-file analysis
+    # ---------------------------------------------------------------------------
+
+    def _analyze_file(
+        self,
+        abs_path: Path,
+        rel_path: str,
+        workspace: str | None,
+    ) -> FileMetrics:
+        """Analiza un fichero individual y retorna un FileMetrics.
+
+        Nunca lanza excepciones — los errores se reflejan en los campos
+        de availability del FileMetrics retornado.
+        """
+        norm_path = Path(rel_path).as_posix()
+        suffix = Path(rel_path).suffix.lower()
+        language = _lang_for_suffix(suffix)
+
+        # Read content
+        try:
+            content = abs_path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return FileMetrics(
+                path=norm_path,
+                language=language,
+                workspace=workspace,
+            )
+
+        # LOC counting — all languages
+        loc = self._count_loc(content, language)
+
+        fm = FileMetrics(
+            path=norm_path,
+            language=language,
+            total_lines=loc["total_lines"],
+            code_lines=loc["code_lines"],
+            blank_lines=loc["blank_lines"],
+            comment_lines=loc["comment_lines"],
+            loc_availability=loc["loc_availability"],
+            workspace=workspace,
+        )
+
+        # Symbol counting per language tier
+        if language == "python":
+            sym = self._count_python_symbols(content, norm_path)
+            fm.function_count = sym["function_count"]
+            fm.class_count = sym["class_count"]
+            fm.symbol_availability = sym["symbol_availability"]
+            fm.cyclomatic_complexity = sym["cyclomatic_complexity"]
+            fm.complexity_availability = sym["complexity_availability"]
+
+        elif language in ("javascript", "typescript"):
+            sym = self._count_js_symbols(content)
+            fm.function_count = sym["function_count"]
+            fm.class_count = sym["class_count"]
+            fm.symbol_availability = "inferred"
+            fm.complexity_availability = "unavailable"
+
+        elif language == "go":
+            sym = self._count_go_symbols(content)
+            fm.function_count = sym["function_count"]
+            fm.class_count = sym["class_count"]
+            fm.symbol_availability = "inferred"
+            fm.complexity_availability = "unavailable"
+
+        elif language == "rust":
+            sym = self._count_rust_symbols(content)
+            fm.function_count = sym["function_count"]
+            fm.class_count = sym["class_count"]
+            fm.symbol_availability = "inferred"
+            fm.complexity_availability = "unavailable"
+
+        elif language == "java":
+            sym = self._count_java_symbols(content)
+            fm.function_count = sym["function_count"]
+            fm.class_count = sym["class_count"]
+            fm.symbol_availability = "inferred"
+            fm.complexity_availability = "unavailable"
+
+        # All other languages: LOC only, symbols and complexity unavailable
+        # (defaults already set to "unavailable" in FileMetrics)
+
+        return fm
+
+    # ---------------------------------------------------------------------------
+    # LOC counting (all languages — text scan)
+    # ---------------------------------------------------------------------------
+
+    def _count_loc(self, content: str, language: str) -> dict[str, Any]:
+        """Cuenta lineas de codigo, blank y comentario via text scan.
+
+        Para JS/TS: usa state machine para block comments (/* ... */).
+        Para Python y otros: solo detecta comentarios de linea (#).
+        Retorna dict con total_lines, blank_lines, comment_lines, code_lines,
+        loc_availability.
+        """
+        lines = content.splitlines()
+        total = len(lines)
+        blank = 0
+        comment = 0
+
+        if language in ("javascript", "typescript"):
+            in_block = False
+            for line in lines:
+                stripped = line.strip()
+                if not stripped:
+                    blank += 1
+                    continue
+                if in_block:
+                    comment += 1
+                    if "*/" in stripped:
+                        in_block = False
+                    continue
+                if stripped.startswith("//"):
+                    comment += 1
+                elif stripped.startswith("/*"):
+                    comment += 1
+                    if "*/" not in stripped[2:]:
+                        in_block = True
+                elif "/*" in stripped and "*/" not in stripped[stripped.index("/*") + 2:]:
+                    # inline block comment start on a code line — count as code
+                    in_block = True
+                # else: code line (not counted as comment)
+        else:
+            # Python, Go, Rust, Java, and others: simple line-comment detection
+            comment_prefixes: tuple[str, ...]
+            if language == "python":
+                comment_prefixes = ("#",)
+            elif language in ("go", "rust", "java", "kotlin", "scala", "csharp",
+                               "cpp", "c", "swift", "php"):
+                comment_prefixes = ("//",)
+            else:
+                comment_prefixes = ("#",)  # generic fallback
+
+            for line in lines:
+                stripped = line.strip()
+                if not stripped:
+                    blank += 1
+                elif stripped.startswith(comment_prefixes):
+                    comment += 1
+
+        code = total - blank - comment
+        return {
+            "total_lines": total,
+            "blank_lines": blank,
+            "comment_lines": comment,
+            "code_lines": code,
+            "loc_availability": "measured",
+        }
+
+    # ---------------------------------------------------------------------------
+    # Python symbol + complexity (AST)
+    # ---------------------------------------------------------------------------
+
+    def _count_python_symbols(self, content: str, rel_path: str) -> dict[str, Any]:
+        """Cuenta simbolos Python y calcula complejidad McCabe via ast.parse.
+
+        Si hay SyntaxError retorna symbol_availability='unavailable' pero
+        loc_availability sigue siendo 'measured' (el text scan no necesita AST).
+        """
+        try:
+            tree = ast.parse(content, filename=rel_path)
+        except SyntaxError:
+            return {
+                "function_count": 0,
+                "class_count": 0,
+                "symbol_availability": "unavailable",
+                "cyclomatic_complexity": None,
+                "complexity_availability": "unavailable",
+            }
+
+        func_nodes: list[ast.FunctionDef | ast.AsyncFunctionDef] = []
+        class_count = 0
+
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                func_nodes.append(node)
+            elif isinstance(node, ast.ClassDef):
+                class_count += 1
+
+        function_count = len(func_nodes)
+
+        if func_nodes:
+            complexities = [_mccabe(fn) for fn in func_nodes]
+            avg_cc = float(sum(complexities)) / len(complexities)
+            cyclomatic_complexity: float | None = avg_cc
+            complexity_availability = "measured"
+        else:
+            cyclomatic_complexity = None
+            complexity_availability = "unavailable"
+
+        return {
+            "function_count": function_count,
+            "class_count": class_count,
+            "symbol_availability": "measured",
+            "cyclomatic_complexity": cyclomatic_complexity,
+            "complexity_availability": complexity_availability,
+        }
+
+    # ---------------------------------------------------------------------------
+    # JS/TS symbol counting (regex — inferred)
+    # ---------------------------------------------------------------------------
+
+    def _count_js_symbols(self, content: str) -> dict[str, int]:
+        """Cuenta funciones y clases en JS/TS via regex (inferred)."""
+        function_count = len(_JS_FUNC_RE.findall(content))
+        class_count = len(_JS_CLASS_RE.findall(content))
+        return {"function_count": function_count, "class_count": class_count}
+
+    # ---------------------------------------------------------------------------
+    # Go symbol counting (regex — inferred)
+    # ---------------------------------------------------------------------------
+
+    def _count_go_symbols(self, content: str) -> dict[str, int]:
+        """Cuenta funciones y structs en Go via regex (inferred)."""
+        function_count = len(_GO_FUNC_RE.findall(content))
+        class_count = len(_GO_STRUCT_RE.findall(content))
+        return {"function_count": function_count, "class_count": class_count}
+
+    # ---------------------------------------------------------------------------
+    # Rust symbol counting (regex — inferred)
+    # ---------------------------------------------------------------------------
+
+    def _count_rust_symbols(self, content: str) -> dict[str, int]:
+        """Cuenta funciones y structs en Rust via regex (inferred)."""
+        function_count = len(_RUST_FN_RE.findall(content))
+        class_count = len(_RUST_STRUCT_RE.findall(content))
+        return {"function_count": function_count, "class_count": class_count}
+
+    # ---------------------------------------------------------------------------
+    # Java symbol counting (regex — inferred)
+    # ---------------------------------------------------------------------------
+
+    def _count_java_symbols(self, content: str) -> dict[str, int]:
+        """Cuenta metodos y clases en Java via regex (inferred)."""
+        function_count = len(_JAVA_METHOD_RE.findall(content))
+        class_count = len(_JAVA_CLASS_RE.findall(content))
+        return {"function_count": function_count, "class_count": class_count}

sourcecode/schema.py

@@ -151,6 +151,62 @@ class ModuleGraph:
 
 DocsDepth = Literal["module", "symbols", "full"]
 
+MetricAvailability = Literal["measured", "inferred", "unavailable"]
+
+
+@dataclass
+class FileMetrics:
+    """Metricas de calidad de un fichero de codigo fuente."""
+
+    path: str
+    language: str
+    is_test: bool = False
+    production_target: Optional[str] = None
+    total_lines: int = 0
+    code_lines: int = 0
+    blank_lines: int = 0
+    comment_lines: int = 0
+    loc_availability: MetricAvailability = "unavailable"
+    function_count: int = 0
+    class_count: int = 0
+    symbol_availability: MetricAvailability = "unavailable"
+    cyclomatic_complexity: Optional[float] = None
+    complexity_availability: MetricAvailability = "unavailable"
+    line_rate: Optional[float] = None
+    branch_rate: Optional[float] = None
+    coverage_source: Optional[str] = None
+    coverage_availability: MetricAvailability = "unavailable"
+    workspace: Optional[str] = None
+
+
+@dataclass
+class CoverageRecord:
+    """Registro de cobertura de codigo de un fichero de cobertura."""
+
+    source_file: str
+    format: str
+    line_rate: Optional[float] = None
+    branch_rate: Optional[float] = None
+    lines_covered: Optional[int] = None
+    lines_valid: Optional[int] = None
+    timestamp: Optional[str] = None
+    tool_version: Optional[str] = None
+    file_count: int = 0
+
+
+@dataclass
+class MetricsSummary:
+    """Resumen del analisis de metricas de calidad de codigo."""
+
+    requested: bool = False
+    file_count: int = 0
+    test_file_count: int = 0
+    languages: list[str] = field(default_factory=list)
+    total_loc: int = 0
+    coverage_records: list[CoverageRecord] = field(default_factory=list)
+    coverage_sources_found: list[str] = field(default_factory=list)
+    limitations: list[str] = field(default_factory=list)
+
 
 @dataclass
 class DocRecord:
@@ -207,3 +263,6 @@ class SourceMap:
     file_paths: list[str] = field(default_factory=list)
     project_summary: Optional[str] = None
     key_dependencies: list[DependencyRecord] = field(default_factory=list)
+    # Phase 10: Code Quality Metrics
+    file_metrics: list[FileMetrics] = field(default_factory=list)
+    metrics_summary: Optional[MetricsSummary] = None

{sourcecode-0.7.0.dist-info → sourcecode-0.8.0.dist-info}/METADATA

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

{sourcecode-0.7.0.dist-info → sourcecode-0.8.0.dist-info}/RECORD

@@ -1,12 +1,14 @@
-sourcecode/__init__.py,sha256=IWLAZFD5WGstfu_e3HvB2uIh4i20cAuAjW4yX1398_0,99
+sourcecode/__init__.py,sha256=-BJQU1YX2j0SbQwjuSKaEsMlqnb5__gRa_g_viFJ9-Q,99
 sourcecode/classifier.py,sha256=7ubGTn5vfw9z-9eosLIYDtQUu7d8dvB4XKKDxysUVSM,6910
-sourcecode/cli.py,sha256=_TRe_bmvH3oZlguLMiUk3AC399Um5fxv-dV0M7WtELs,16133
+sourcecode/cli.py,sha256=vmY601Pt3WfO2AEIWjaYdna1MMUrxHS5n6sgc2v8TXM,17928
+sourcecode/coverage_parser.py,sha256=0IfE-0BNF1NxTjRnAuHnn1U0VzcB_aGBQMITR6Qsy3E,19701
 sourcecode/dependency_analyzer.py,sha256=c8tSbUpug-2avKNWCP4-_e2_uhBwWl96LwL1Be8O90M,39067
 sourcecode/doc_analyzer.py,sha256=nnTOsO1tfZvaDPy5PKjRLlg6EQZ-2ONRbXlxDeogH8o,19891
 sourcecode/graph_analyzer.py,sha256=S5z8mrGfLwN26Mt2IaCR4dOpQ_APU16cfihSp640eGQ,45241
+sourcecode/metrics_analyzer.py,sha256=zQrIPKDrGIUq4iptXbckflOj2V9897e_6vGZKEwa4b4,20124
 sourcecode/redactor.py,sha256=abSf5jH_IzYzpjF3lEN6hCwdXxvmyHs-3DHz9fd8Mic,2883
 sourcecode/scanner.py,sha256=TvcuD77m_NF8OlTj3XH1b_jO0qrto8c90fND96ecqb0,6182
-sourcecode/schema.py,sha256=tFoe3k2Xq4t41BvZROTEGRWaPcjmvySfjIv23wLLFgA,6045
+sourcecode/schema.py,sha256=y4NAcjVvfH49otBWK5n4AJ-Ke5EsHDXf6IlME3OSoNQ,7926
 sourcecode/serializer.py,sha256=x_F2qIEGpKXrzgBHwkcN9O94It8R_QV02VfMnWdlKD0,3274
 sourcecode/summarizer.py,sha256=mNZL4uIZ_jnOYJt3_XVCqEFn2JuLR4E8LlySB1TsTxc,2567
 sourcecode/tree_utils.py,sha256=5WHQc2L-AGqxKFfYYcQftE6hETxgUxP9MWDuaThcAUw,991
@@ -30,7 +32,7 @@ sourcecode/detectors/rust.py,sha256=iUz9lE4HfBy8CBaDwGhfh6kLsNIovrH2ay2v3y6qNDc,
 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.7.0.dist-info/METADATA,sha256=3I_ObyreSLRy_zK7iBs-TMuho2l6WJ3epPJssH_Xt2E,14903
-sourcecode-0.7.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-0.7.0.dist-info/entry_points.txt,sha256=voDtdlGU2-jR3wCZpQoOls_0eUKaDVCKIfajGHFDATs,50
-sourcecode-0.7.0.dist-info/RECORD,,
+sourcecode-0.8.0.dist-info/METADATA,sha256=S6jCRU9pdod1JsJ6mBxRmzuT6PuI4JYi_6apx3hzKNc,14903
+sourcecode-0.8.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-0.8.0.dist-info/entry_points.txt,sha256=voDtdlGU2-jR3wCZpQoOls_0eUKaDVCKIfajGHFDATs,50
+sourcecode-0.8.0.dist-info/RECORD,,