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

code_atlas/domains/sql/tokens.py

@@ -0,0 +1,318 @@
+"""Tokenizer SQL em stdlib puro (lf-0111, Cycle 7 Phase 3).
+
+Zero dependências: nenhum ``sqlparse``/``sqlglot`` — o tokenizer emite uma
+sequência plana de ``Token`` que o parser descendente consome. Posições são
+**offsets de caractere** sobre o texto decodificado; a conversão para bytes
+(evidence spans) acontece em ``parser._Src``.
+
+Decisões de honestidade:
+
+- ``{{ }}``, ``{% %}``, ``${ }``, ``@{ }`` e ``<% %>`` viram token
+  ``dynamic`` — marcadores de template/macro que impedem análise estática
+  honesta (dbt/Jinja, Spark ``${var}``, Athena ``@var``);
+- comentários são consumidos (não emitem tokens) mas comentário de bloco
+  não-terminado vira flag — conteúdo perdido é diagnosticado, nunca
+  silenciado;
+- ``-`` vs ``--``: comentário de linha só começa com dois hífens;
+- identificadores entre ``"..."`` e `` `...` `` são ``qident`` —
+  capitalização preservada (política de case do adapter, ADR-0010);
+- palavras NÃO-reservadas comuns em esquemas reais (``date``, ``key``,
+  ``value``, ``type``, ``user``, ``year``…) ficam fora de ``KEYWORDS``
+  para não destruir colrefs legítimos — type-literals como
+  ``DATE '2020'`` são reconhecidos por lookahead no scanner de
+  expressão, não por pertencimento léxico.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+KEYWORDS: frozenset[str] = frozenset(
+    {
+        # consulta / cláusulas
+        "SELECT", "FROM", "WHERE", "GROUP", "BY", "HAVING", "QUALIFY",
+        "ORDER", "LIMIT", "OFFSET", "FETCH", "NEXT", "ROWS", "ONLY",
+        "FIRST", "TOP", "WINDOW",
+        # combinadores e joins
+        "UNION", "INTERSECT", "EXCEPT", "ALL", "DISTINCT", "AS",
+        "JOIN", "INNER", "LEFT", "RIGHT", "FULL", "OUTER", "CROSS",
+        "NATURAL", "SEMI", "ANTI", "ON", "USING",
+        # CTE
+        "WITH", "RECURSIVE", "MATERIALIZED",
+        # expressão
+        "AND", "OR", "NOT", "IN", "IS", "NULL", "NULLS", "LIKE", "ILIKE",
+        "RLIKE", "REGEXP", "BETWEEN", "EXISTS", "CASE", "WHEN", "THEN",
+        "ELSE", "END", "ASC", "DESC",
+        # DML
+        "INSERT", "INTO", "OVERWRITE", "VALUES", "UPDATE", "SET",
+        "DELETE", "MERGE", "MATCHED",
+        # DDL
+        "CREATE", "REPLACE", "TEMP", "TEMPORARY", "GLOBAL", "EXTERNAL",
+        "TRANSIENT", "TABLE", "VIEW", "SCHEMA", "DATABASE", "USE",
+        "DROP", "ALTER", "TRUNCATE", "RENAME", "TO", "ADD", "COLUMN",
+        "COLUMNS", "CONSTRAINT", "PRIMARY", "FOREIGN", "REFERENCES",
+        "UNIQUE", "CHECK", "DEFAULT", "IF",
+        # opções de tabela (Athena/Spark/Hive)
+        "PARTITION", "PARTITIONED", "CLUSTERED", "SORTED", "DISTRIBUTED",
+        "SKEWED", "STORED", "LOCATION", "TBLPROPERTIES", "OPTIONS",
+        "COMMENT", "ROW", "FORMAT", "SERDE", "INPUTFORMAT", "OUTPUTFORMAT",
+        "DELIMITED", "FIELDS", "LINES", "COLLECTION", "MAP", "TERMINATED",
+        "ESCAPED", "DEFINED", "BUCKET", "BUCKETS", "ENGINE", "TABLESPACE",
+        "CHARSET", "COLLATE", "PROPERTIES",
+        # extensões de fonte de dados
+        "LATERAL", "UNNEST", "ORDINALITY", "PIVOT", "TABLESAMPLE",
+        "DISTRIBUTE", "CLUSTER", "SORT",
+        # funções analíticas/agregação com sintaxe especial
+        "OVER", "FILTER", "WITHIN", "GROUPING", "SETS", "ROLLUP", "CUBE",
+        # comandos não-SELECT (parseados como unsupported)
+        "EXPLAIN", "DESCRIBE", "SHOW", "ANALYZE", "MSCK",
+        "REPAIR", "CACHE", "UNCACHE", "REFRESH", "GRANT", "REVOKE",
+        "TRANSACTION", "COMMIT", "ROLLBACK", "BEGIN", "START", "RESET",
+        "EXEC", "EXECUTE", "CALL", "PREPARE", "DEALLOCATE", "IMMEDIATE",
+        "VACUUM", "OPTIMIZE", "LOAD", "DATA", "LOCAL", "INPATH",
+        "DIRECTORY", "EXPORT", "IMPORT", "FUNCTION", "PROCEDURE",
+        "INDEX", "TRIGGER", "SEQUENCE", "JAR", "FILE", "ROLE",
+    }
+)
+
+# Palavras que parecem tipos/literais mas NÃO entram em KEYWORDS porque
+# são nomes de coluna comuns em datasets reais (``date``, ``key``,
+# ``value``, ``user``, ``type``, ``year``…). O scanner de expressão
+# reconhece ``DATE '…'``/``TIMESTAMP '…'`` por lookahead, não por
+# keyword-membership — decisão documentada para não destruir colrefs.
+_TYPE_LITERAL_WORDS: frozenset[str] = frozenset(
+    {"DATE", "TIME", "TIMESTAMP", "DATETIME", "INTERVAL"}
+)
+
+# Palavras-campo dentro de funções especiais (EXTRACT/TRIM) que não são
+# colrefs: ``EXTRACT(YEAR FROM d)``, ``TRIM(BOTH ' ' FROM c)``.
+_SPECIAL_ARG_FNS: frozenset[str] = frozenset(
+    {"EXTRACT", "TRIM", "SUBSTRING", "POSITION", "OVERLAY"}
+)
+
+_MULTI_PUNCT: tuple[str, ...] = ("<=", ">=", "<>", "!=", "||", "::", "->", "=>")
+
+_DYNAMIC_OPEN: dict[str, str] = {
+    "{{": "}}", "{%": "%}", "${": "}", "@{": "}", "<%": "%>",
+}
+
+_STRING_PREFIXES = frozenset("eExXbBnNrR")
+
+
+@dataclass(frozen=True)
+class Token:
+    """Unidade léxica com offsets de caractere (``start``/``end``)."""
+
+    kind: str   # word|qident|number|string|punct|param|dynamic|eof
+    text: str   # fatia crua do texto
+    norm: str   # word→UPPER (match de keyword); qident→miolo; demais→text
+    iname: str  # identidade: word→lower; qident→miolo com case preservado
+    start: int
+    end: int
+
+
+def is_kw(tok: Token, *words: str) -> bool:
+    """True se ``tok`` é palavra não-quotada pertencente a ``words``."""
+    return tok.kind == "word" and tok.norm in words
+
+
+def is_word(tok: Token) -> bool:
+    """Qualquer identificador (quotado ou não), incluindo keywords."""
+    return tok.kind in ("word", "qident")
+
+
+def is_name(tok: Token) -> bool:
+    """Identificador utilizável como nome novo (não-keyword ou quotado)."""
+    return tok.kind == "qident" or (tok.kind == "word" and tok.norm not in KEYWORDS)
+
+
+def _scan_string(text: str, i: int, prefix: bool) -> int:
+    """Consome ``'…'`` com escape ``''``; retorna posição após o fecho.
+
+    ``-1`` quando a string não fecha até o fim do texto.
+    """
+    n = len(text)
+    j = i + 1
+    if prefix:
+        j += 1  # letra de prefixo já incluída pelo caller
+    while j < n:
+        c = text[j]
+        if c == "'":
+            if j + 1 < n and text[j + 1] == "'":
+                j += 2
+                continue
+            return j + 1
+        j += 1
+    return -1
+
+
+def _scan_comment(
+    text: str, i: int, n: int, problems: list[str]
+) -> int | None:
+    """Comentários são consumidos — ``i`` novo ou ``None``."""
+    if text.startswith("--", i):
+        j = text.find("\n", i + 2)
+        return n if j < 0 else j + 1
+    if text.startswith("/*", i):
+        j = text.find("*/", i + 2)
+        if j < 0:
+            problems.append("unterminated-comment")
+            return n
+        return j + 2
+    return None
+
+
+def _scan_dynamic(
+    text: str, i: int, n: int, toks: list[Token]
+) -> int | None:
+    """Marcadores ``${}``/``{{}}``/``{% %}``/``@{}``/``<% %>``."""
+    for op, cl in _DYNAMIC_OPEN.items():
+        if not text.startswith(op, i):
+            continue
+        j = text.find(cl, i + len(op))
+        j = n if j < 0 else j + len(cl)
+        toks.append(Token("dynamic", text[i:j], text[i:j], text[i:j], i, j))
+        return j
+    return None
+
+
+def _scan_string_tok(
+    text: str, i: int, n: int, toks: list[Token], problems: list[str]
+) -> int | None:
+    """``'…'`` com prefixo opcional de 1 letra (``E'x'``, ``N'y'``)."""
+    c = text[i]
+    if c == "'":
+        j = _scan_string(text, i, prefix=False)
+    elif c in _STRING_PREFIXES and text.startswith("'", i + 1):
+        j = _scan_string(text, i, prefix=True)
+    else:
+        return None
+    if j < 0:
+        problems.append("unterminated-string")
+        j = n
+    toks.append(Token("string", text[i:j], text[i:j], text[i:j], i, j))
+    return j
+
+
+def _scan_qident(
+    text: str, i: int, n: int, toks: list[Token], problems: list[str]
+) -> int | None:
+    """``"…"``/````…```` — case preservado, ``""`` é escape interno."""
+    c = text[i]
+    if c not in ('"', "`"):
+        return None
+    j = i + 1
+    closed = False
+    while j < n:
+        if text[j] == c:
+            if j + 1 < n and text[j + 1] == c:
+                j += 2
+                continue
+            closed = True
+            j += 1
+            break
+        j += 1
+    if not closed:
+        problems.append("unterminated-quoted-ident")
+    inner = text[i + 1:j - 1] if closed else text[i + 1:j]
+    inner = inner.replace(c + c, c)
+    toks.append(Token("qident", text[i:j], inner, inner, i, j))
+    return j
+
+
+def _scan_word(
+    text: str, i: int, n: int, toks: list[Token]
+) -> int | None:
+    """Identificadores e keywords — distinção fica para o parser."""
+    c = text[i]
+    if not (c.isalpha() or c == "_"):
+        return None
+    j = i + 1
+    while j < n and (text[j].isalnum() or text[j] in "_$"):
+        j += 1
+    word = text[i:j]
+    toks.append(Token("word", word, word.upper(), word.lower(), i, j))
+    return j
+
+
+def _scan_number(
+    text: str, i: int, n: int, toks: list[Token]
+) -> int | None:
+    """Literais numéricos — aproximação para pular, nunca avaliados."""
+    c = text[i]
+    if not (
+        c.isdigit() or (c == "." and i + 1 < n and text[i + 1].isdigit())
+    ):
+        return None
+    j = i + 1
+    while j < n and (text[j].isalnum() or text[j] in "._+-"):
+        # para em '+'/'-' não-exponenciais
+        if text[j] in "+-" and text[j - 1] not in "eE":
+            break
+        j += 1
+    toks.append(Token("number", text[i:j], text[i:j], text[i:j], i, j))
+    return j
+
+
+def _scan_param(
+    text: str, i: int, n: int, toks: list[Token]
+) -> int | None:
+    """``?``, ``$1``, ``:name`` — parâmetros, nunca colunas."""
+    c = text[i]
+    if c == "?" or (c == "$" and i + 1 < n and text[i + 1].isdigit()):
+        j = i + 1
+        while j < n and text[j].isdigit():
+            j += 1
+        toks.append(Token("param", text[i:j], text[i:j], text[i:j], i, j))
+        return j
+    if c == ":" and not text.startswith("::", i) and i + 1 < n and (
+        text[i + 1].isalpha() or text[i + 1] == "_"
+    ):
+        j = i + 1
+        while j < n and (text[j].isalnum() or text[j] in "_$"):
+            j += 1
+        toks.append(Token("param", text[i:j], text[i:j], text[i:j], i, j))
+        return j
+    return None
+
+
+def _scan_punct(text: str, i: int, toks: list[Token]) -> int:
+    """Pontuação — token de 2 chars quando conhecido (``->``, ``::``…)."""
+    two = text[i:i + 2]
+    if two in _MULTI_PUNCT:
+        toks.append(Token("punct", two, two, two, i, i + 2))
+        return i + 2
+    toks.append(Token("punct", text[i], text[i], text[i], i, i + 1))
+    return i + 1
+
+
+def tokenize(text: str) -> tuple[list[Token], list[str]]:
+    """Tokeniza ``text``; retorna ``(tokens, problemas)``.
+
+    ``problemas`` lista códigos honestos: ``unterminated-comment``,
+    ``unterminated-string``, ``unterminated-quoted-ident``. O token EOF
+    fecha a sequência sempre.
+    """
+    toks: list[Token] = []
+    problems: list[str] = []
+    i, n = 0, len(text)
+    while i < n:
+        if text[i].isspace():
+            i += 1
+            continue
+        nxt = _scan_comment(text, i, n, problems)
+        if nxt is None:
+            nxt = _scan_dynamic(text, i, n, toks)
+        if nxt is None:
+            nxt = _scan_string_tok(text, i, n, toks, problems)
+        if nxt is None:
+            nxt = _scan_qident(text, i, n, toks, problems)
+        if nxt is None:
+            nxt = _scan_word(text, i, n, toks)
+        if nxt is None:
+            nxt = _scan_number(text, i, n, toks)
+        if nxt is None:
+            nxt = _scan_param(text, i, n, toks)
+        i = nxt if nxt is not None else _scan_punct(text, i, toks)
+    toks.append(Token("eof", "", "", "", n, n))
+    return toks, problems

code_atlas/domains/summarize.py

@@ -0,0 +1,126 @@
+"""Resumo textual determinístico de lineage de domínio (lf-0121, Ph13).
+
+Facts only — nenhuma frase vem de LLM: a saída é montada por template
+fixo sobre ``LineageFact`` (relation_type x direção x status), com
+ordenação estável e cap de listagem explícito. Exemplo::
+
+    data_table cat1.analytics.orders: read by 2 (daily_load, etl);
+    writes to 1 (reporting.orders); 1 ambiguous; 1 dynamic
+
+O módulo é puro (sem sqlite/IO) para ficar testável e reusável — o
+builder de context pack traduz rows persistidas em fatos.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
+
+SUMMARIZE_VERSION = 1
+_LIST_CAP = 8
+
+# Verbos relativos à SEED, por relation_type:
+# ``(forma outgoing — "seed VERBO alvo", forma incoming — "seed VERBO")``.
+# Tipos fora do mapa caem no fallback determinístico ``TYPE →`` /
+# ``TYPE ←`` — nunca uma paráfrase inventada.
+_VERBS: Mapping[str, tuple[str, str]] = {
+    "READS_FROM": ("reads", "read by"),
+    "WRITES_TO": ("writes to", "written by"),
+    "TRANSFORMS": ("transforms", "transformed by"),
+    "DERIVES_FROM": ("derives from", "derived by"),
+    "DEPENDS_ON": ("depends on", "depended on by"),
+    "CALLS_ENDPOINT": ("calls", "called by"),
+    "IMPLEMENTS_CONTRACT": ("implements", "implemented by"),
+    "PROVISIONS": ("provisions", "provisioned by"),
+    "USES_RESOURCE": ("uses", "used by"),
+    "ASSUMES_ROLE": ("assumes", "assumed by"),
+    "TRIGGERS": ("triggers", "triggered by"),
+    "DEPLOYS": ("deploys", "deployed by"),
+    "TESTS": ("tests", "tested by"),
+    "REFERENCES": ("references", "referenced by"),
+    # Vocabulário estrutural compartilhado (EdgeKind) — aparece em
+    # domain_relations (CONTAINS módulo→recurso, IMPORTS de módulo tf…).
+    "CONTAINS": ("contains", "contained by"),
+    "DEFINES": ("defines", "defined by"),
+    "IMPORTS": ("imports", "imported by"),
+    "CALLS": ("calls", "called by"),
+    "IMPLEMENTS": ("implements", "implemented by"),
+    "EXTENDS": ("extends", "extended by"),
+    "CONFIGURES": ("configures", "configured by"),
+}
+
+
+@dataclass(frozen=True)
+class LineageFact:
+    """Uma aresta de ``domain_relations`` vista da entidade-semente.
+
+    ``label``: nome estável do vizinho (``qualified_name``) para alvos
+    resolvidos/externos, ou o ``to_unresolved`` textual para pendentes
+    — o texto é o registro honesto, nunca uma paráfrase.
+    ``dynamic``: alvo marcado como dinâmico pelo adapter
+    (``dynamic:``/``${dynamic}``/``environment:``) — honestidade, não
+    pendência; contado à parte de ``unresolved``.
+    """
+
+    relation_type: str
+    direction: str          # "incoming" | "outgoing"
+    label: str
+    resolution_status: str  # resolved|ambiguous|unresolved|external
+    neighbor_kind: str = "" # entity kind do vizinho ("" = alvo textual)
+    dynamic: bool = False
+
+
+def _verb(relation_type: str, direction: str) -> str:
+    pair = _VERBS.get(relation_type)
+    if pair is None:
+        arrow = "\u2190" if direction == "incoming" else "\u2192"
+        return f"{relation_type} {arrow}"
+    return pair[0] if direction == "outgoing" else pair[1]
+
+
+def summarize_lineage(
+    subject: str, facts: Iterable[LineageFact]
+) -> str:
+    """``subject``: rótulo da seed (ex.: ``"data_table a.b.orders"``).
+
+    Saída: ``"<subject>: <frases>"`` — grupos ``resolved``/``external``
+    por (relation_type, direção) com listas capadas (alvos externos
+    marcados ``(external)``); contagens honestas de ``ambiguous``,
+    ``unresolved`` e ``dynamic`` ao final. Sem fatos, declara a
+    ausência — nunca uma frase genérica otimista.
+    """
+    resolved: dict[tuple[str, str], list[str]] = {}
+    n_amb = n_unres = n_dyn = 0
+    for f in facts:
+        if f.dynamic:
+            n_dyn += 1
+            continue
+        if f.resolution_status == "resolved":
+            resolved.setdefault((f.relation_type, f.direction), []).append(
+                f.label
+            )
+        elif f.resolution_status == "ambiguous":
+            n_amb += 1
+        elif f.resolution_status == "external":
+            # alvo conhecido fora do índice — listável mas não vizinho local
+            resolved.setdefault(
+                (f.relation_type, f.direction), []).append(
+                    f"{f.label} (external)")
+        else:
+            n_unres += 1
+    phrases: list[str] = []
+    for key in sorted(resolved):
+        labels = sorted(resolved[key])
+        shown = labels[:_LIST_CAP]
+        more = f", +{len(labels) - _LIST_CAP} more" if len(labels) > _LIST_CAP else ""
+        phrases.append(
+            f"{_verb(*key)} {len(labels)} ({', '.join(shown)}{more})"
+        )
+    if n_amb:
+        phrases.append(f"{n_amb} ambiguous")
+    if n_unres:
+        phrases.append(f"{n_unres} unresolved")
+    if n_dyn:
+        phrases.append(f"{n_dyn} dynamic")
+    body = "; ".join(phrases) if phrases else "no persisted domain relations"
+    return f"{subject}: {body}"

code_atlas/domains/terraform/__init__.py

@@ -0,0 +1,20 @@
+"""Adapter de domínio Terraform (lf-0115, Cycle 7 Phase 7).
+
+Extrai ``TERRAFORM_RESOURCE``/``TERRAFORM_MODULE``/``IAM_ROLE`` de
+``.tf`` (HCL hand-rolled), ``.tf.json`` e ``.tfvars`` — estático puro:
+nenhuma execução de ``terraform``, state, plan ou apply; nenhuma
+conexão externa; segredos redigidos; ``${…}`` vira ``${dynamic}``;
+``count``/``for_each`` declarados como ``dynamic``, sem expansão.
+"""
+
+from code_atlas.domains.terraform.adapter import (
+    ADAPTER_VERSION,
+    TerraformAdapter,
+)
+from code_atlas.domains.terraform.extract import DOMAIN_ID
+
+__all__ = [
+    "ADAPTER_VERSION",
+    "DOMAIN_ID",
+    "TerraformAdapter",
+]

code_atlas/domains/terraform/adapter.py

@@ -0,0 +1,127 @@
+"""``TerraformAdapter`` — adapter de domínio Terraform (lf-0115).
+
+Implementa ``DomainAdapter`` sobre o núcleo de ``extract.py``:
+
+- lê **somente** os artefatos do ``DomainExtractionRequest``,
+  resolvidos contra ``base_path`` (raiz on-disk do recorte) —
+  nunca lê disco fora do request, nunca abre rede, nunca executa
+  ``terraform``/state/plan/apply;
+- ``extract`` nunca levanta para conteúdo ruim — falhas viram
+  ``DomainDiagnostic``;
+- teto de confiança ``syntactic``: resolução de identidades é por
+  chave canônica dentro do snapshot; o que é externo ao recorte sai
+  como ``external``/``unresolved`` — nunca promovido.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from code_atlas.contracts.enums import ConfidenceClass
+from code_atlas.domains.contracts import (
+    ArtifactSupport,
+    ConfidenceModel,
+    DiscoveryRule,
+    DomainDiagnostic,
+    DomainExtractionRequest,
+    DomainExtractionResult,
+)
+from code_atlas.domains.model import DomainEntityKind, DomainRelationKind
+from code_atlas.domains.terraform.extract import DOMAIN_ID, extract
+
+ADAPTER_VERSION = "0.1.0"
+
+
+class TerraformAdapter:
+    """Adapter ``terraform`` — recursos, módulos e IAM de ``.tf``/``.tf.json``.
+
+    ``base_path``: raiz on-disk que resolve os paths relativos de
+    ``DiscoveredArtifact``; ``None`` trata os paths como estão
+    (absolutos ou relativos ao cwd do caller).
+    """
+
+    def __init__(self, base_path: str | Path | None = None) -> None:
+        self._base = Path(base_path) if base_path is not None else None
+
+    @property
+    def domain_id(self) -> str:
+        return DOMAIN_ID
+
+    @property
+    def adapter_version(self) -> str:
+        return ADAPTER_VERSION
+
+    def supported_artifacts(self) -> ArtifactSupport:
+        return ArtifactSupport(
+            extensions=frozenset({".tf", ".tfvars"}),
+            globs=("*.tf.json", "*.tfvars.json"),
+        )
+
+    def entity_kinds(self) -> frozenset[DomainEntityKind]:
+        return frozenset(
+            {
+                DomainEntityKind.TERRAFORM_RESOURCE,
+                DomainEntityKind.TERRAFORM_MODULE,
+                DomainEntityKind.IAM_ROLE,
+            }
+        )
+
+    def relation_kinds(self) -> frozenset[str]:
+        return frozenset(
+            {
+                str(DomainRelationKind.DEPENDS_ON),
+                str(DomainRelationKind.PROVISIONS),
+                str(DomainRelationKind.USES_RESOURCE),
+                str(DomainRelationKind.ASSUMES_ROLE),
+                str(DomainRelationKind.REFERENCES),
+            }
+        )
+
+    def confidence_model(self) -> ConfidenceModel:
+        # Extração estritamente evidence-first: sem inferência — o que
+        # não está no snapshot sai unresolved/external, nunca inventado.
+        return ConfidenceModel(
+            ceiling=ConfidenceClass.SYNTACTIC,
+            default=ConfidenceClass.SYNTACTIC,
+            allows_inferred=False,
+            notes="static HCL/JSON structural extraction only",
+        )
+
+    def discovery_rules(self) -> tuple[DiscoveryRule, ...]:
+        return (
+            DiscoveryRule(
+                glob="*.tf", artifact_kind="tf-configuration",
+                notes="HCL configuration files (any depth)",
+            ),
+            DiscoveryRule(
+                glob="*.tf.json", artifact_kind="tf-json",
+                notes="JSON-flavoured Terraform configuration",
+            ),
+            DiscoveryRule(
+                glob="*.tfvars", artifact_kind="tf-vars",
+                notes="variable assignments — secrets never surfaced",
+            ),
+            DiscoveryRule(
+                glob="*.tfvars.json", artifact_kind="tf-vars-json",
+                notes="JSON variable assignments",
+            ),
+        )
+
+    def extract(
+        self, request: DomainExtractionRequest
+    ) -> DomainExtractionResult:
+        try:
+            return extract(request, self.adapter_version, self._base)
+        except Exception as exc:  # última linha de defesa — nunca levanta
+            return DomainExtractionResult(
+                domain_id=self.domain_id,
+                adapter_version=self.adapter_version,
+                diagnostics=(
+                    DomainDiagnostic(
+                        code="adapter-failure",
+                        severity="error",
+                        message=f"terraform adapter failure: {exc!r}",
+                        adapter_id=self.domain_id,
+                    ),
+                ),
+            )

code_atlas/domains/terraform/catalog.py

@@ -0,0 +1,43 @@
+"""Catálogo **fechado** de classes de recurso Terraform (lf-0115).
+
+O prompt Cycle 7 Phase 7 delimita as classes reconhecidas:
+Glue, S3, IAM, EMR, Lake Formation, Lambda, API Gateway,
+Step Functions, CloudWatch. Todo tipo fora do catálogo é extraído
+como ``TERRAFORM_RESOURCE`` genérico com ``resource_class="other"``
+— nada é descartado, nada é inventado.
+"""
+
+from __future__ import annotations
+
+# resource_class → prefixos de tipo (lowercase). Catálogo delimitado
+# pelo prompt: ampliar exige spec + ADR (mesmo regime do vocabulário).
+_RESOURCE_CLASS_PREFIXES: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("glue", ("aws_glue_",)),
+    ("s3", ("aws_s3_",)),
+    ("iam", ("aws_iam_",)),
+    ("emr", ("aws_emr_",)),
+    ("lakeformation", ("aws_lakeformation_",)),
+    ("lambda", ("aws_lambda_",)),
+    ("apigateway", ("aws_api_gateway_", "aws_apigatewayv2_")),
+    ("stepfunctions", ("aws_sfn_",)),
+    ("cloudwatch", ("aws_cloudwatch_",)),
+)
+
+RESOURCE_CLASSES: frozenset[str] = frozenset(
+    cls for cls, _ in _RESOURCE_CLASS_PREFIXES
+) | {"other"}
+
+
+def provider_of(resource_type: str) -> str:
+    """Prefixo de provider do tipo (``aws_s3_bucket`` → ``aws``)."""
+    head, sep, _ = resource_type.partition("_")
+    return head if sep else resource_type
+
+
+def resource_class(resource_type: str) -> str:
+    """Classe declarada do tipo — ``other`` para fora do catálogo."""
+    t = resource_type.lower()
+    for cls, prefixes in _RESOURCE_CLASS_PREFIXES:
+        if t.startswith(prefixes):
+            return cls
+    return "other"