code-atlas-forge 1.1.0__py3-none-any.whl

code_atlas/impact/test_selector.py

@@ -0,0 +1,166 @@
+"""Seleção de testes candidatos (Phase 7).
+
+Evidências, em ordem de força:
+1. aresta ``TESTS``/``CALLS``/``IMPORTS`` resolvida de arquivo de teste
+   para símbolo alterado → ``direct``/``verified``;
+2. consumidor transitivo localizado em arquivo de teste → ``transitive``;
+3. convenção de nome no mesmo módulo (``test_foo.py`` p/ ``foo.py``) →
+   ``heuristic`` — nunca declarado como cobertura real.
+
+Comandos de execução são *sugestões* estáticas — nada é executado.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+
+from code_atlas.impact.contracts import (
+    EvidenceStrength,
+    ImpactCandidate,
+    SymbolChange,
+    TestCandidate,
+)
+
+_TEST_SUFFIXES = (
+    ".test.ts", ".spec.ts", ".test.tsx", ".spec.tsx",
+)
+
+# cap default de candidatos — declarado em ``truncation_reasons``
+# quando a saída chega ao limite (lf-0151, convenção at-cap).
+MAX_TEST_CANDIDATES = 50
+
+
+def is_test_path(path: str) -> bool:
+    p = path.replace("\\", "/").lower()
+    name = p.rsplit("/", 1)[-1]
+    return ((name.startswith("test_") and name.endswith(".py"))
+            or name.endswith("_test.py")
+            or any(name.endswith(s) for s in _TEST_SUFFIXES)
+            or "/__tests__/" in p
+            or "/tests/" in p or p.startswith("tests/"))
+
+
+def _edge_candidates(
+    conn: sqlite3.Connection, snapshot_id: int,
+    symbol_changes: tuple[SymbolChange, ...],
+    out: list[TestCandidate], seen: set[str],
+    max_candidates: int,
+    *,
+    occs: set[int] | None = None,
+    revision: str = "target",
+) -> None:
+    """Arestas resolvidas teste→alterado = evidência real de cobertura."""
+    changed_occs = occs if occs is not None else {
+        oid for s in symbol_changes
+        for oid in (s.new_occurrence_id, s.old_occurrence_id) if oid}
+    if not changed_occs:
+        return
+    marks = ",".join("?" for _ in changed_occs)
+    edge_sql = (
+        "SELECT r.from_id, r.type, r.resolution_status"
+        " FROM relations r WHERE r.snapshot_id = ?"
+        f" AND r.to_id IN ({marks})"
+        " ORDER BY r.id LIMIT ?")
+    rows = conn.execute(
+        edge_sql,
+        (snapshot_id, *sorted(changed_occs), max_candidates)
+    ).fetchall()
+    file_of: dict[int, sqlite3.Row | None] = {}
+    for r in rows:
+        fid = int(r["from_id"])
+        if fid not in file_of:
+            file_of[fid] = conn.execute(
+                "SELECT f.relative_path, o.id AS occ FROM"
+                " symbol_occurrences o JOIN source_files f"
+                " ON f.id = o.source_file_id"
+                " WHERE o.id = ?", (fid,)).fetchone()
+        frow = file_of[fid]
+        path = str(frow["relative_path"]) if frow else ""
+        if frow and is_test_path(path) and path not in seen:
+            seen.add(path)
+            out.append(TestCandidate(
+                test_file=path, test_symbol=None,
+                relationship="direct",
+                reason=f"aresta {r['type']}→símbolo alterado",
+                strength=(EvidenceStrength.VERIFIED
+                          if r["resolution_status"] == "resolved"
+                          else EvidenceStrength.POSSIBLE),
+                occurrence_id=int(frow["occ"]),
+                revision=revision))
+
+
+def select(
+    conn: sqlite3.Connection, snapshot_id: int,
+    symbol_changes: tuple[SymbolChange, ...],
+    impacts: tuple[ImpactCandidate, ...],
+    *,
+    base_snapshot_id: int | None = None,
+    max_candidates: int = MAX_TEST_CANDIDATES,
+) -> tuple[TestCandidate, ...]:
+    conn.row_factory = sqlite3.Row
+    out: list[TestCandidate] = []
+    seen: set[str] = set()
+
+    # 0a) arestas resolvidas teste→símbolo-alterado no ALVO.
+    target_occs = {
+        oid for s in symbol_changes
+        for oid in (s.new_occurrence_id,) if oid}
+    _edge_candidates(
+        conn, snapshot_id, symbol_changes, out, seen, max_candidates,
+        occs=target_occs or None, revision="target")
+
+    # 0b) lf-0080: arestas HISTÓRICAS na base — testes que referenciavam
+    # símbolos removidos (ocorrência só existe na base).
+    if base_snapshot_id is not None and base_snapshot_id != snapshot_id:
+        base_occs = {
+            s.old_occurrence_id for s in symbol_changes
+            if s.old_occurrence_id is not None}
+        _edge_candidates(
+            conn, base_snapshot_id, symbol_changes, out, seen,
+            max_candidates, occs=base_occs or None, revision="base")
+
+    # 1) impact candidates que já vivem em arquivos de teste.
+    for c in impacts:
+        if c.source_path and is_test_path(c.source_path):
+            rel = ("direct" if c.path and c.path.hops == 1
+                   else "transitive")
+            if c.source_path not in seen:
+                seen.add(c.source_path)
+                out.append(TestCandidate(
+                    test_file=c.source_path,
+                    test_symbol=c.qualified_name,
+                    relationship=rel,
+                    reason=f"grafo: {c.path.reason if c.path else ''}",
+                    strength=c.strength,
+                    occurrence_id=c.occurrence_id,
+                    revision=("base" if c.consumer_state else "target")))
+
+    # 2) convenção de nome: test_<mod>.py / <mod>.test.ts por arquivo
+    # de origem alterado.
+    changed_paths = {s.new_path or s.old_path for s in symbol_changes}
+    rows = conn.execute(
+        "SELECT DISTINCT f.relative_path, o.id"
+        " FROM symbol_occurrences o"
+        " JOIN source_files f ON f.id = o.source_file_id"
+        " WHERE o.snapshot_id = ? ORDER BY f.relative_path",
+        (snapshot_id,)).fetchall()
+    stems = {p.rsplit("/", 1)[-1].rsplit(".", 1)[0]
+             for p in changed_paths if p}
+    for r in rows:
+        path = str(r["relative_path"])
+        if path in seen or not is_test_path(path):
+            continue
+        name = path.rsplit("/", 1)[-1]
+        stem = name.replace("test_", "").replace("_test", "")
+        stem = stem.split(".")[0]
+        if stem and stem in stems:
+            seen.add(path)
+            out.append(TestCandidate(
+                test_file=path, test_symbol=None,
+                relationship="heuristic",
+                reason="convenção de nome sobre módulo alterado",
+                strength=EvidenceStrength.POSSIBLE,
+                occurrence_id=int(r["id"])))
+        if len(out) >= max_candidates:
+            break
+    return tuple(out[:max_candidates])

code_atlas/indexing/__init__.py

@@ -0,0 +1,5 @@
+"""Coordenação de indexação incremental e publicação atômica de snapshots."""
+
+from code_atlas.indexing.coordinator import IndexCoordinator, IndexOutcome
+
+__all__ = ["IndexCoordinator", "IndexOutcome"]

code_atlas/indexing/cache.py

@@ -0,0 +1,396 @@
+"""Cache versionado de ``ParseResult`` por arquivo (lf-0020).
+
+Store: tabela ``parse_result_cache`` (schema v4) — **mesmo banco** do
+índice, escolhido porque (a) a transação de publicação já cobre o cache
+(rollback de build falho não deixa entradas órfãs novas), (b) zero
+infraestrutura extra, (c) o cache nunca pertence a snapshots — GC não
+pode corromper linhas vivas.
+
+Chave de validade completa (grill): ``(repo_id, path, content_sha256,
+language, parser_version, grammar_version, extractor_version,
+resolver_version, builder_version, config_digest)`` — nunca por path
+sozinho. Valor: ``ParseResult`` serializado em JSON estruturado (sem
+pickle — entrada é disco não-confiável). ``payload_sha256`` verifica
+integridade na leitura: blob corrompido → miss, nunca crash.
+
+GC: ``gc`` remove entradas cujo ``last_used_snapshot_id`` é anterior ao
+N-ésimo READY mais recente do repo, e aplica cap ``MAX_ENTRIES`` por
+repo (eviction por ``last_used_snapshot_id`` mais antigo). Roda dentro
+da transação de publicação → atômica com o build.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import sqlite3
+from dataclasses import dataclass
+from typing import Any
+
+from code_atlas.parsers.contracts import (
+    ExtractedReference,
+    ExtractedRelation,
+    ExtractedSymbol,
+    ParseDiagnostic,
+    ParseResult,
+    SourceSpan,
+)
+
+# Versões de contrato — bump quando a semântica muda (invalida o cache).
+RESOLVER_VERSION = "syntactic/1.0.0"
+BUILDER_VERSION = "graph-builder/1.0.0"
+CACHE_FORMAT_VERSION = 1
+
+# Política de retenção (bounded cache): entradas não usadas pelos
+# últimos ``KEEP_SNAPSHOTS`` READY são removidas; cap global por repo.
+KEEP_SNAPSHOTS = 5
+MAX_ENTRIES = 50_000
+
+
+@dataclass(frozen=True)
+class CacheKey:
+    """Chave de validade completa — qualquer componente novo invalida."""
+
+    path: str
+    content_sha256: str
+    language: str
+    parser_version: str
+    grammar_version: str
+    extractor_version: str
+    config_digest: str
+
+
+# --- codec ParseResult <-> JSON (estruturado, sem pickle) ---------------
+
+
+def _span_to_json(s: SourceSpan | None) -> list[int] | None:
+    if s is None:
+        return None
+    return [s.start_byte, s.end_byte, s.start_line, s.start_col,
+            s.end_line, s.end_col]
+
+
+def _span_from_json(v: Any) -> SourceSpan | None:
+    if v is None:
+        return None
+    return SourceSpan(int(v[0]), int(v[1]), int(v[2]), int(v[3]),
+                      int(v[4]), int(v[5]))
+
+
+def result_to_payload(res: ParseResult) -> str:
+    """Serializa ParseResult em JSON canônico (chaves ordenadas)."""
+    doc = {
+        "format": CACHE_FORMAT_VERSION,
+        "path": res.path,
+        "language": res.language,
+        "parser": res.parser,
+        "parser_version": res.parser_version,
+        "grammar_version": res.grammar_version,
+        "content_hash": res.content_hash,
+        "has_error": res.has_error,
+        "error_node_count": res.error_node_count,
+        "missing_node_count": res.missing_node_count,
+        "node_count": res.node_count,
+        "supported": res.supported,
+        "diagnostics": [
+            {
+                "code": d.code, "severity": d.severity,
+                "message": d.message, "span": _span_to_json(d.span),
+            }
+            for d in res.diagnostics
+        ],
+        "symbols": [
+            {
+                "language": s.language, "kind": s.kind, "name": s.name,
+                "qualified_name": s.qualified_name,
+                "span": _span_to_json(s.span),
+                "name_span": _span_to_json(s.name_span),
+                "scope_path": list(s.scope_path),
+                "signature": s.signature, "params": list(s.params),
+                "docstring": s.docstring, "decorators": list(s.decorators),
+                "bases": list(s.bases), "implements": list(s.implements),
+                "modifiers": list(s.modifiers),
+            }
+            for s in res.symbols
+        ],
+        "references": [
+            {
+                "name": r.name, "context": r.context,
+                "span": _span_to_json(r.span),
+                "scope_path": list(r.scope_path), "target": r.target,
+            }
+            for r in res.references
+        ],
+        "relations": [
+            {
+                "type": r.type, "from_name": r.from_name,
+                "to_name": r.to_name, "span": _span_to_json(r.span),
+                "confidence_class": r.confidence_class,
+                "resolution_status": r.resolution_status,
+            }
+            for r in res.relations
+        ],
+    }
+    return json.dumps(doc, sort_keys=True, separators=(",", ":"))
+
+
+def result_from_payload(payload: str) -> ParseResult:
+    """Desserializa; levanta ValueError em formato/versão inválidos."""
+    doc = json.loads(payload)
+    if not isinstance(doc, dict) or doc.get("format") != CACHE_FORMAT_VERSION:
+        raise ValueError("unsupported cache payload format")
+    return ParseResult(
+        path=str(doc["path"]),
+        language=str(doc["language"]),
+        parser=str(doc["parser"]),
+        parser_version=str(doc["parser_version"]),
+        grammar_version=str(doc["grammar_version"]),
+        content_hash=str(doc["content_hash"]),
+        has_error=bool(doc["has_error"]),
+        error_node_count=int(doc["error_node_count"]),
+        missing_node_count=int(doc["missing_node_count"]),
+        node_count=int(doc["node_count"]),
+        supported=bool(doc["supported"]),
+        diagnostics=tuple(
+            ParseDiagnostic(
+                code=str(d["code"]), severity=str(d["severity"]),
+                message=str(d["message"]),
+                span=_span_from_json(d["span"]),
+            )
+            for d in doc["diagnostics"]
+        ),
+        symbols=tuple(
+            ExtractedSymbol(
+                language=str(s["language"]), kind=str(s["kind"]),
+                name=str(s["name"]),
+                qualified_name=str(s["qualified_name"]),
+                span=_span_from_json(s["span"]) or _ZERO_SPAN,
+                name_span=_span_from_json(s["name_span"]),
+                scope_path=tuple(str(x) for x in s["scope_path"]),
+                signature=s["signature"],
+                params=tuple(str(x) for x in s["params"]),
+                docstring=s["docstring"],
+                decorators=tuple(str(x) for x in s["decorators"]),
+                bases=tuple(str(x) for x in s["bases"]),
+                implements=tuple(str(x) for x in s["implements"]),
+                modifiers=tuple(str(x) for x in s["modifiers"]),
+            )
+            for s in doc["symbols"]
+        ),
+        references=tuple(
+            ExtractedReference(
+                name=str(r["name"]), context=str(r["context"]),
+                span=_span_from_json(r["span"]) or _ZERO_SPAN,
+                scope_path=tuple(str(x) for x in r["scope_path"]),
+                target=str(r["target"]),
+            )
+            for r in doc["references"]
+        ),
+        relations=tuple(
+            ExtractedRelation(
+                type=str(r["type"]), from_name=str(r["from_name"]),
+                to_name=str(r["to_name"]),
+                span=_span_from_json(r["span"]) or _ZERO_SPAN,
+                confidence_class=str(r["confidence_class"]),
+                resolution_status=str(r["resolution_status"]),
+            )
+            for r in doc["relations"]
+        ),
+    )
+
+
+_ZERO_SPAN = SourceSpan(0, 0, 0, 0, 0, 0)
+_BATCH_CHUNK = 400  # bem abaixo do limite de variáveis do SQLite (999)
+
+
+class ParseResultCache:
+    """Store versionado de ParseResult — leitura nunca executa nada."""
+
+    def __init__(self, conn: sqlite3.Connection, repo_id: int) -> None:
+        self._conn = conn
+        self._repo_id = repo_id
+
+    def _key_params(self, key: CacheKey) -> tuple[object, ...]:
+        return (
+            self._repo_id, key.path, key.content_sha256, key.language,
+            key.parser_version, key.grammar_version, key.extractor_version,
+            RESOLVER_VERSION, BUILDER_VERSION, key.config_digest,
+        )
+
+    def get(self, key: CacheKey) -> ParseResult | None:
+        """Retorna o resultado cacheado ou ``None`` (miss/inválido).
+
+        Leitura pura — sem writes, pode rodar fora de transação sob WAL.
+        Integridade: ``payload_sha256`` precisa bater — blob corrompido
+        ou formato desconhecido → miss honesto, nunca exceção.
+        ``mark_used`` (chamado na transação de publicação) registra o
+        hit e o ``last_used_snapshot_id`` para o GC.
+        """
+        row = self._conn.execute(
+            """
+            SELECT id, payload, payload_sha256 FROM parse_result_cache
+             WHERE repository_id = ? AND path = ? AND content_sha256 = ?
+               AND language = ? AND parser_version = ?
+               AND grammar_version = ? AND extractor_version = ?
+               AND resolver_version = ? AND builder_version = ?
+               AND config_digest = ?
+            """,
+            self._key_params(key),
+        ).fetchone()
+        if row is None:
+            return None
+        if hashlib.sha256(row["payload"].encode()).hexdigest() != (
+            row["payload_sha256"]
+        ):
+            return None  # blob corrompido → miss
+        try:
+            return result_from_payload(row["payload"])
+        except (ValueError, KeyError, TypeError, json.JSONDecodeError):
+            return None
+
+    def get_many(
+        self, keys: list[CacheKey]
+    ) -> dict[str, ParseResult]:
+        """Lookup batchado — um ``IN`` por chunk de paths em vez de um
+        SELECT por arquivo (lf-0031: 2019 round-trips → ~5 num corpus
+        2k). Mesmas garantias de ``get``: payload_sha256 verificado,
+        blob inválido/corrompido → ausência (miss honesto)."""
+        wanted: dict[str, CacheKey] = {k.path: k for k in keys}
+        out: dict[str, ParseResult] = {}
+        paths = sorted(wanted)
+        for i in range(0, len(paths), _BATCH_CHUNK):
+            chunk = paths[i:i + _BATCH_CHUNK]
+            # SQL constante (auditoria AST): a lista de paths entra como
+            # UM parâmetro JSON via json_each — sem placeholders
+            # dinâmicos e sem interpolar dados na query.
+            rows = self._conn.execute(
+                """
+                SELECT path, content_sha256, language, parser_version,
+                       grammar_version, extractor_version,
+                       resolver_version, builder_version, config_digest,
+                       payload, payload_sha256
+                  FROM parse_result_cache
+                 WHERE repository_id = ?
+                   AND path IN (SELECT value FROM json_each(?))
+                """,
+                (self._repo_id, json.dumps(chunk)),
+            ).fetchall()
+            for row in rows:
+                res = self._row_result(wanted, row)
+                if res is not None:
+                    out[row["path"]] = res
+        return out
+
+    def _row_result(
+        self, wanted: dict[str, CacheKey], row: sqlite3.Row
+    ) -> ParseResult | None:
+        """Valida a linha contra a CacheKey exata + integridade do blob."""
+        key = wanted.get(row["path"])
+        if key is None:
+            return None
+        params = self._key_params(key)
+        row_key = (
+            self._repo_id, row["path"], row["content_sha256"],
+            row["language"], row["parser_version"],
+            row["grammar_version"], row["extractor_version"],
+            row["resolver_version"], row["builder_version"],
+            row["config_digest"],
+        )
+        if row_key != params:
+            return None  # chave de validade diverge → miss
+        if hashlib.sha256(row["payload"].encode()).hexdigest() != (
+            row["payload_sha256"]
+        ):
+            return None
+        try:
+            return result_from_payload(row["payload"])
+        except (ValueError, KeyError, TypeError, json.JSONDecodeError):
+            return None
+
+    def put(
+        self,
+        key: CacheKey,
+        res: ParseResult,
+        *,
+        snapshot_id: int | None = None,
+    ) -> None:
+        """Insere/substitui o resultado na chave de validade."""
+        payload = result_to_payload(res)
+        digest = hashlib.sha256(payload.encode()).hexdigest()
+        self._conn.execute(
+            """
+            INSERT INTO parse_result_cache (
+                repository_id, path, content_sha256, language,
+                parser_version, grammar_version, extractor_version,
+                resolver_version, builder_version, config_digest,
+                payload, payload_sha256, last_used_snapshot_id
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT (repository_id, path, content_sha256, language,
+                         parser_version, grammar_version,
+                         extractor_version, resolver_version,
+                         builder_version, config_digest)
+            DO UPDATE SET payload = excluded.payload,
+                          payload_sha256 = excluded.payload_sha256,
+                          last_used_snapshot_id =
+                              excluded.last_used_snapshot_id
+            """,
+            (*self._key_params(key), payload, digest, snapshot_id),
+        )
+
+    def mark_used(self, key: CacheKey, snapshot_id: int) -> None:
+        """Marca a entrada como usada pelo snapshot (para o GC)."""
+        self._conn.execute(
+            "UPDATE parse_result_cache SET last_used_snapshot_id = ?,"
+            " hit_count = hit_count + 1 "
+            "WHERE repository_id = ? AND path = ? AND content_sha256 = ?"
+            " AND language = ? AND parser_version = ?"
+            " AND grammar_version = ? AND extractor_version = ?"
+            " AND resolver_version = ? AND builder_version = ?"
+            " AND config_digest = ?",
+            (snapshot_id, *self._key_params(key)),
+        )
+
+    def gc(
+        self,
+        repo_id: int,
+        *,
+        keep_snapshots: int = KEEP_SNAPSHOTS,
+        max_entries: int = MAX_ENTRIES,
+    ) -> int:
+        """Remove entradas frias; retorna quantas foram removidas.
+
+        Política: entradas cujo ``last_used_snapshot_id`` é anterior ao
+        ``keep_snapshots``-ésimo READY mais recente são removidas; além
+        disso o repo fica limitado a ``max_entries`` linhas (eviction
+        das menos recentemente usadas). Linhas de cache nunca pertencem
+        a snapshots — não há risco de remover dado vivo.
+        """
+        recent = self._conn.execute(
+            "SELECT id FROM snapshots WHERE repository_id = ?"
+            " AND status = 'READY' ORDER BY id DESC LIMIT ?",
+            (repo_id, keep_snapshots),
+        ).fetchall()
+        floor = min((int(r["id"]) for r in recent), default=0)
+        cur = self._conn.execute(
+            "DELETE FROM parse_result_cache WHERE repository_id = ?"
+            " AND COALESCE(last_used_snapshot_id, 0) < ?",
+            (repo_id, floor),
+        )
+        removed = cur.rowcount if cur.rowcount else 0
+        # cap global por repo — evict LRU (menor last_used_snapshot_id)
+        over = self._conn.execute(
+            "SELECT COUNT(*) AS c FROM parse_result_cache"
+            " WHERE repository_id = ?",
+            (repo_id,),
+        ).fetchone()["c"] - max_entries
+        if over > 0:
+            cur2 = self._conn.execute(
+                "DELETE FROM parse_result_cache WHERE id IN ("
+                "  SELECT id FROM parse_result_cache"
+                "  WHERE repository_id = ?"
+                "  ORDER BY COALESCE(last_used_snapshot_id, 0), id"
+                "  LIMIT ?)",
+                (repo_id, over),
+            )
+            removed += cur2.rowcount if cur2.rowcount else 0
+        return int(removed)