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

code_atlas/resolvers/scip/resolver.py

@@ -0,0 +1,289 @@
+"""ScipResolver — resolvedor EvidenceTier.SEMANTIC_INDEX (lf-0017).
+
+Consome um ``ScipIndex`` já importado e validado e resolve
+referências/definições via correlação explícita (``ScipCorrelator``) com
+os nós do grafo Atlas. A proveniência carrega a ferramenta+versão do
+indexer externo; ``confidence_class='resolved'`` só quando a identidade
+do símbolo foi verificada (alvo único no snapshot).
+"""
+
+from __future__ import annotations
+
+from code_atlas.parsers.contracts import SourceSpan
+from code_atlas.resolvers.capabilities import EvidenceTier, ResolverCapability
+from code_atlas.resolvers.contracts import (
+    ResolutionDiagnostic,
+    ResolutionRequest,
+    ResolutionResult,
+    ResolvedDefinition,
+    ResolvedReference,
+    ResolverProvenance,
+)
+from code_atlas.resolvers.scip.importer import (
+    ROLE_DEFINITION,
+    ScipDocument,
+    ScipIndex,
+    ScipOccurrence,
+    ScipRange,
+)
+from code_atlas.resolvers.scip.mapper import ScipCorrelator, parse_symbol
+from code_atlas.resolvers.scip.provenance import IndexProvenance
+from code_atlas.resolvers.syntactic.resolver import ScopeUniverse
+
+RESOLVER_ID = "scip"
+RESOLVER_VERSION = "1.0.0"
+
+
+class ScipResolver:
+    """Resolve pedidos usando ocorrências de um índice SCIP importado."""
+
+    def __init__(
+        self,
+        index: ScipIndex,
+        universe: ScopeUniverse,
+        provenance: IndexProvenance | None = None,
+    ) -> None:
+        self._index = index
+        self._corr = ScipCorrelator(universe)
+        self._docs = {d.relative_path: d for d in index.documents}
+        # lf-0028: sem assessment explícito, o índice é não-verificado —
+        # tratado como degraded (nunca comprovado), nunca como current.
+        self._prov_info = provenance or IndexProvenance(
+            producer_name=index.tool_name,
+            producer_version=index.tool_version,
+            repository_identity=index.project_root,
+            validation_status="degraded",
+            validation_evidence=("no revision assessment",),
+        )
+
+    @property
+    def resolver_id(self) -> str:
+        return RESOLVER_ID
+
+    @property
+    def resolver_version(self) -> str:
+        return RESOLVER_VERSION
+
+    @property
+    def index(self) -> ScipIndex:
+        return self._index
+
+    @property
+    def provenance(self) -> IndexProvenance:
+        return self._prov_info
+
+    def capabilities(self) -> ResolverCapability:
+        return ResolverCapability(
+            resolver_id=RESOLVER_ID,
+            tier=EvidenceTier.SEMANTIC_INDEX,
+            languages=frozenset(),
+            relation_types=frozenset(
+                {"REFERENCES", "CALLS", "EXTENDS", "IMPLEMENTS", "IMPORTS"}
+            ),
+            detail=(
+                f"scip index by {self._index.tool_name}"
+                f" {self._index.tool_version}".strip()
+            ),
+        )
+
+    def _prov(self) -> ResolverProvenance:
+        status = self._prov_info.validation_status
+        detail = (
+            f"{self._index.tool_name} {self._index.tool_version}".strip()
+        )
+        if status != "current":
+            detail = f"{detail} [{status}]".strip()
+        return ResolverProvenance(
+            resolver_id=RESOLVER_ID,
+            resolver_version=RESOLVER_VERSION,
+            evidence_tier=int(EvidenceTier.SEMANTIC_INDEX),
+            detail=detail,
+            index_hash=self._prov_info.index_sha256,
+        )
+
+    def _conf(self, intended: str) -> str:
+        """lf-0028: evidência de índice degraded nunca comprova —
+        confidence capada em ``heuristic``."""
+        if (
+            self._prov_info.validation_status != "current"
+            and intended == "resolved"
+        ):
+            return "heuristic"
+        return intended
+
+    # -- contrato SemanticResolver --------------------------------------
+
+    def resolve(self, request: ResolutionRequest) -> ResolutionResult:
+        # lf-0028: índice rejeitado não produz resolução nenhuma —
+        # incompatível nunca contamina o snapshot.
+        if self._prov_info.validation_status == "rejected":
+            return ResolutionResult(
+                request=request,
+                reference=ResolvedReference(
+                    status="unresolved",
+                    confidence_class="heuristic",
+                    provenance=self._prov(),
+                    target_text=request.name,
+                ),
+                diagnostics=(self._diag(
+                    "index-rejected",
+                    "scip index rejected by revision safety: "
+                    + "; ".join(self._prov_info.validation_evidence[:3]),
+                    "error"),),
+            )
+        doc = self._docs.get(request.path)
+        if doc is None:
+            return ResolutionResult(
+                request=request,
+                diagnostics=(self._diag("document-not-in-index",
+                                        f"no scip document for "
+                                        f"{request.path}", "warning"),),
+            )
+        occ = self._occurrence_at(doc, request)
+        if occ is None:
+            return ResolutionResult(
+                request=request,
+                reference=ResolvedReference(
+                    status="unresolved",
+                    confidence_class="syntactic",
+                    provenance=self._prov(),
+                    target_text=request.name,
+                ),
+                diagnostics=(self._diag("no-occurrence",
+                                        "no scip occurrence at span",
+                                        "info"),),
+            )
+        return self._resolve_symbol(request, occ.symbol,
+                                    is_definition=occ.is_definition)
+
+    # -- resolução por símbolo scip --------------------------------------
+
+    def resolve_symbol(self, request: ResolutionRequest,
+                       scip_symbol: str) -> ResolutionResult:
+        """API direta: resolve uma string de símbolo scip."""
+        return self._resolve_symbol(request, scip_symbol)
+
+    def _resolve_symbol(
+        self,
+        request: ResolutionRequest,
+        scip_symbol: str,
+        *,
+        is_definition: bool = False,
+    ) -> ResolutionResult:
+        sym = parse_symbol(scip_symbol)
+        if sym is None:
+            return ResolutionResult(
+                request=request,
+                reference=ResolvedReference(
+                    status="unresolved",
+                    confidence_class="heuristic",
+                    provenance=self._prov(),
+                    target_text=scip_symbol,
+                ),
+                diagnostics=(self._diag("bad-symbol",
+                                        f"unparseable scip symbol "
+                                        f"{scip_symbol!r}", "warning"),),
+            )
+        path = request.path
+        nid = self._corr.node_for_symbol(scip_symbol, path)
+        if nid is not None:
+            status = "resolved"
+            # identidade verificada — alvo único; índice degraded capa
+            # em heuristic (lf-0028: nunca promove como comprovada).
+            conf = self._conf("resolved")
+        else:
+            cands = self._corr.candidates_for_symbol(scip_symbol)
+            if len(cands) > 1:
+                return ResolutionResult(
+                    request=request,
+                    reference=ResolvedReference(
+                        status="ambiguous",
+                        confidence_class="syntactic",
+                        provenance=self._prov(),
+                        target_text=scip_symbol,
+                        candidates=cands,
+                    ),
+                )
+            # símbolo scip válido fora do snapshot → externo (pacote
+            # de terceiro) ou não correlacionável
+            status = "external" if not sym.is_local else "unresolved"
+            conf = "syntactic"
+        defs = self._definitions_for(scip_symbol) if is_definition else ()
+        return ResolutionResult(
+            request=request,
+            reference=ResolvedReference(
+                status=status,
+                confidence_class=conf,
+                provenance=self._prov(),
+                target_id=nid,
+                target_text=scip_symbol,
+            ),
+            definitions=defs,
+        )
+
+    def _definitions_for(self, scip_symbol: str) -> tuple[ResolvedDefinition, ...]:
+        """Occurrences marcadas como Definition para o símbolo."""
+        out: list[ResolvedDefinition] = []
+        for d in self._index.documents:
+            for occ in d.occurrences:
+                if occ.symbol == scip_symbol and occ.roles & ROLE_DEFINITION:
+                    out.append(
+                        ResolvedDefinition(
+                            symbol=scip_symbol,
+                            path=d.relative_path,
+                            provenance=self._prov(),
+                            span=self._span_of(occ),
+                        )
+                    )
+        return tuple(out)
+
+    # -- helpers ---------------------------------------------------------
+
+    @staticmethod
+    def _span_of(occ: ScipOccurrence) -> SourceSpan | None:
+        rng: ScipRange | None = occ.range
+        if rng is None:
+            return None
+        # scip usa linhas 0-based; Atlas SourceSpan usa 1-based
+        return SourceSpan(
+            start_byte=0, end_byte=0,
+            start_line=rng.start_line + 1, start_col=rng.start_char,
+            end_line=rng.end_line + 1, end_col=rng.end_char,
+        )
+
+    @staticmethod
+    def _occurrence_at(
+        doc: ScipDocument, request: ResolutionRequest
+    ) -> ScipOccurrence | None:
+        """Seleciona a occurrence do documento que casa com o request.
+
+        Preferência: occurrence cobrindo o span do request (convertido
+        de linhas 1-based do Atlas para 0-based do scip); fallback
+        heurístico por símbolo textual (nome no descriptor).
+        """
+        occs = doc.occurrences
+        span = request.span
+        if span is not None:
+            s0 = (span.start_line - 1, span.start_col)
+            e0 = (span.end_line - 1, span.end_col)
+            for occ in occs:
+                r = occ.range
+                if r is None:
+                    continue
+                if (r.start_line, r.start_char) <= s0 and \
+                        (r.end_line, r.end_char) >= e0:
+                    return occ
+            return None
+        # sem span: casa pelo nome do request nos descriptors
+        for occ in occs:
+            sym = parse_symbol(occ.symbol)
+            if sym is not None and sym.descriptors and \
+                    sym.descriptors[-1].name == request.name:
+                return occ
+        return None
+
+    def _diag(self, code: str, message: str, severity: str) -> ResolutionDiagnostic:
+        return ResolutionDiagnostic(
+            code=code, severity=severity, message=message,
+            resolver_id=RESOLVER_ID,
+        )

code_atlas/resolvers/scip/validation.py

@@ -0,0 +1,101 @@
+"""Validação de índices SCIP contra o workspace Atlas (lf-0017).
+
+Impede associações falsas: um índice produzido para outro repositório ou
+outra revisão NUNCA é correlacionado silenciosamente — a rejeição é
+explícita e diagnosticada.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from code_atlas.resolvers.scip.importer import ScipIndex
+
+
+def _pct_decode(s: str) -> str:
+    """Percent-decode mínimo para paths de file:// (stdlib pura — urllib
+    é banido pelo audit de rede do projeto)."""
+    out = bytearray()
+    i = 0
+    raw = s.encode("utf-8", errors="replace")
+    while i < len(raw):
+        if raw[i:i + 1] == b"%" and i + 2 < len(raw) + 1 and \
+                i + 2 < len(raw) + 1:
+            try:
+                out.append(int(raw[i + 1:i + 3], 16))
+                i += 3
+                continue
+            except ValueError:
+                pass
+        out.append(raw[i])
+        i += 1
+    return out.decode("utf-8", errors="replace")
+
+# limites defensivos — índices externos são untrusted input
+MAX_INDEX_BYTES = 256 * 1024 * 1024      # 256 MiB
+MAX_DOCUMENTS = 200_000
+MAX_OCCURRENCES_PER_DOC = 500_000
+
+
+@dataclass(frozen=True)
+class ScipValidationResult:
+    ok: bool
+    errors: tuple[str, ...] = ()
+    warnings: tuple[str, ...] = ()
+
+
+def validate_index(index: ScipIndex, raw_size: int) -> ScipValidationResult:
+    """Sanidade estrutural do índice decodificado."""
+    errors: list[str] = []
+    warnings: list[str] = []
+    if raw_size > MAX_INDEX_BYTES:
+        errors.append(f"index too large: {raw_size} > {MAX_INDEX_BYTES}")
+    if len(index.documents) > MAX_DOCUMENTS:
+        errors.append(
+            f"too many documents: {len(index.documents)} > {MAX_DOCUMENTS}")
+    seen_paths: set[str] = set()
+    for doc in index.documents:
+        p = doc.relative_path
+        if not p or p.startswith("/") or ".." in p.split("/"):
+            errors.append(f"bad document path: {p!r}")
+        if p in seen_paths:
+            warnings.append(f"duplicate document path: {p}")
+        seen_paths.add(p)
+        if len(doc.occurrences) > MAX_OCCURRENCES_PER_DOC:
+            errors.append(f"doc {p}: occurrences > {MAX_OCCURRENCES_PER_DOC}")
+        for o in doc.occurrences:
+            if not o.symbol:
+                warnings.append(f"doc {p}: occurrence with empty symbol")
+                break
+    if not index.tool_name:
+        warnings.append("metadata.tool_info.name empty")
+    return ScipValidationResult(ok=not errors, errors=tuple(errors),
+                                warnings=tuple(warnings))
+
+
+def project_root_matches(index: ScipIndex, workspace_root: Path) -> bool:
+    """O ``project_root`` do índice precisa apontar para a raiz indexada.
+
+    ``project_root`` é uma URI (file://...) — comparamos o caminho
+    decodificado com o caminho real do workspace.
+    """
+    if not index.project_root:
+        return False
+    uri = index.project_root
+    if uri.startswith("file://"):
+        path = _pct_decode(uri[len("file://"):])
+        # strip host vazio/localhost (file:///x → /x; file://host/x)
+        if not path.startswith("/"):
+            path = "/" + path.split("/", 1)[-1]
+        # file:///C:/x → /C:/x — '/C:' seria diretório literal no
+        # Windows, não o drive C:; remove o separador de host.
+        if len(path) >= 3 and path[0] == "/" and path[1].isalpha() \
+                and path[2] == ":":
+            path = path[1:]
+    else:
+        path = uri
+    try:
+        return Path(path).resolve() == Path(workspace_root).resolve()
+    except OSError:
+        return False

code_atlas/resolvers/syntactic/__init__.py

@@ -0,0 +1,8 @@
+"""Resolvedor sintático — escopo local inequívoco (tier 3)."""
+
+from code_atlas.resolvers.syntactic.resolver import (
+    ScopeUniverse,
+    SyntacticResolver,
+)
+
+__all__ = ["ScopeUniverse", "SyntacticResolver"]

code_atlas/resolvers/syntactic/resolver.py

@@ -0,0 +1,254 @@
+"""Resolvedor sintático (EvidenceTier.SYNTACTIC) — lf-0016.
+
+Encapsula a resolução de escopo do Cycle 2 — a mesma lógica que vivia em
+``graph.builder`` agora atrás do contrato ``SemanticResolver``. O universo
+(``ScopeUniverse``) é montado pelo GraphBuilder durante a construção e
+fornecido ao resolver para a fase de resolução.
+
+Regras inalteradas (regressão garantida pelos testes do Cycle 2):
+
+- ``resolved`` só com alvo único no snapshot — nunca por coincidência.
+- ``obj.attr`` sem tipo conhecido de ``obj`` → ``unresolved``.
+- Alias de import resolve via ``import_targets`` do módulo de origem.
+- Imports sem alvo local distinguem ``external`` (stdlib/site-packages)
+  de ``unresolved`` (relativo/pacote local quebrado).
+"""
+
+from __future__ import annotations
+
+import posixpath
+from dataclasses import dataclass, field
+
+from code_atlas.resolvers.capabilities import EvidenceTier, ResolverCapability
+from code_atlas.resolvers.contracts import (
+    ResolutionDiagnostic,
+    ResolutionRequest,
+    ResolutionResult,
+    ResolvedReference,
+    ResolverProvenance,
+)
+
+RESOLVER_ID = "syntactic"
+RESOLVER_VERSION = "1.0.0"
+
+
+@dataclass
+class ModuleCtx:
+    """Contexto de resolução de um módulo parseado."""
+
+    path: str
+    module_name: str
+    language: str
+    nid: str
+    defines: dict[str, list[str]] = field(default_factory=dict)
+    import_targets: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass
+class ScopeUniverse:
+    """Tabelas de escopo montadas pelo builder para a fase de resolução."""
+
+    modules: dict[str, ModuleCtx] = field(default_factory=dict)
+    by_path: dict[str, str] = field(default_factory=dict)
+    nid_mod: dict[str, ModuleCtx] = field(default_factory=dict)
+    top_packages: set[str] = field(default_factory=set)
+    leaf: dict[str, list[str]] = field(default_factory=dict)
+    qname_nid: dict[str, list[str]] = field(default_factory=dict)
+
+    def ctx_for_path(self, path: str) -> ModuleCtx | None:
+        nid = self.by_path.get(path)
+        return self.nid_mod.get(nid) if nid else None
+
+
+class SyntacticResolver:
+    """Implementa ``SemanticResolver`` sobre o ``ScopeUniverse``."""
+
+    def __init__(self, universe: ScopeUniverse | None = None) -> None:
+        self._universe = universe or ScopeUniverse()
+
+    @property
+    def resolver_id(self) -> str:
+        return RESOLVER_ID
+
+    @property
+    def resolver_version(self) -> str:
+        return RESOLVER_VERSION
+
+    @property
+    def universe(self) -> ScopeUniverse:
+        return self._universe
+
+    def capabilities(self) -> ResolverCapability:
+        return ResolverCapability(
+            resolver_id=RESOLVER_ID,
+            tier=EvidenceTier.SYNTACTIC,
+            languages=frozenset(),      # qualquer linguagem parseada
+            relation_types=frozenset(
+                {"IMPORTS", "CALLS", "REFERENCES", "EXTENDS", "IMPLEMENTS"}
+            ),
+            detail="local scope resolution (no type info)",
+        )
+
+    def _prov(self) -> ResolverProvenance:
+        return ResolverProvenance(
+            resolver_id=RESOLVER_ID,
+            resolver_version=RESOLVER_VERSION,
+            evidence_tier=int(EvidenceTier.SYNTACTIC),
+        )
+
+    # -- contrato SemanticResolver --------------------------------------
+
+    def resolve(self, request: ResolutionRequest) -> ResolutionResult:
+        ctx = self._universe.ctx_for_path(request.path)
+        if ctx is None:
+            return ResolutionResult(
+                request=request,
+                diagnostics=(
+                    ResolutionDiagnostic(
+                        code="module-not-indexed",
+                        severity="warning",
+                        message=f"no module context for {request.path}",
+                        resolver_id=RESOLVER_ID,
+                    ),
+                ),
+            )
+        if request.kind == "import":
+            nid, status = self.resolve_import(ctx, request.name)
+        else:
+            nid, status = self.resolve_name(ctx, request.name)
+        conf = "resolved" if status == "resolved" else "syntactic"
+        return ResolutionResult(
+            request=request,
+            reference=ResolvedReference(
+                status=status,
+                confidence_class=conf,
+                provenance=self._prov(),
+                target_id=nid,
+                target_text=request.name,
+            ),
+        )
+
+    # -- primitivas de resolução (extraídas de graph.builder) ------------
+
+    def scope_nid(
+        self, ctx: ModuleCtx, scope_path: tuple[str, ...]
+    ) -> str | None:
+        qname = ".".join((ctx.module_name, *scope_path))
+        nids = self._universe.qname_nid.get(qname)
+        return nids[0] if nids else ctx.nid
+
+    def by_qname_or_module(self, ctx: ModuleCtx, qname: str) -> str | None:
+        nids = self._universe.qname_nid.get(qname)
+        if nids:
+            return nids[0]
+        # adapters podem reportar from_name sem prefixo de módulo
+        nids = self._universe.qname_nid.get(f"{ctx.module_name}.{qname}")
+        if nids:
+            return nids[0]
+        return ctx.nid  # fallback: origem = módulo
+
+    def resolve_import(
+        self, ctx: ModuleCtx, target: str
+    ) -> tuple[str | None, str]:
+        """IMPORTS: módulo local → resolved; relativo/path falho →
+        unresolved; stdlib/site-packages → external."""
+        mod, _rest = self.locate(ctx, target)
+        if mod is not None:
+            return mod.nid, "resolved"
+        if target.startswith(".") or (
+            target.rsplit(".", 1)[0] in self._universe.top_packages
+        ):
+            return None, "unresolved"
+        return None, "external"
+
+    def locate(
+        self, ctx: ModuleCtx, target: str
+    ) -> tuple[ModuleCtx | None, list[str]]:
+        """Alvo dotted/pathed → (ctx do módulo, segmentos-membro restantes).
+
+        Cobre: python absoluto (``pkg.util``), python relativo (``.util``),
+        TS relativo (``./util``, ``../x``).
+        """
+        if target.startswith(("./", "../")):
+            base, _, member = target.rpartition(".")
+            nid = self.resolve_ts_relative(ctx, base)
+            rest = [member] if member and member != "*" else []
+            if nid is None:  # último segmento era do path, não member
+                nid = self.resolve_ts_relative(ctx, target)
+                rest = []
+            mod = self._universe.nid_mod.get(nid) if nid else None
+            return mod, rest
+        cand = target
+        if target.startswith("."):  # python relativo
+            dots = len(target) - len(target.lstrip("."))
+            rest_txt = target.lstrip(".")
+            parts = ctx.module_name.split(".")
+            # lf-0130: `pkg/__init__.py` É o pacote `pkg` — `.` já resolve
+            # para o módulo inteiro, não para o pai dele (`from .api
+            # import x` no __init__ → ``pkg.api.x``, não ``api.x``).
+            if posixpath.basename(ctx.path) == "__init__.py":
+                dots -= 1
+            pkg_parts = parts[: max(len(parts) - dots, 0)]
+            cand = ".".join([*pkg_parts, rest_txt]) if rest_txt else ".".join(
+                pkg_parts
+            )
+        segs = cand.split(".")
+        for i in range(len(segs), 0, -1):
+            mod = self._universe.modules.get(".".join(segs[:i]))
+            if mod is not None:
+                return mod, segs[i:]
+        return None, segs
+
+    def resolve_ts_relative(self, ctx: ModuleCtx, target: str) -> str | None:
+        """TS: ``./util`` → path relativo ao diretório do arquivo."""
+        if not target.startswith(("./", "../")):
+            return None
+        base_dir = posixpath.dirname(ctx.path)
+        norm = posixpath.normpath(posixpath.join(base_dir, target))
+        # lf-0130: .d.mts/.d.cts e index.d.ts cobertos — mesma família de
+        # extensões que o adapter TypeScript registra.
+        for ext in (".ts", ".tsx", ".d.ts", ".mts", ".cts",
+                    ".d.mts", ".d.cts",
+                    "/index.ts", "/index.tsx", "/index.d.ts"):
+            nid = self._universe.by_path.get(norm + ext)
+            if nid:
+                return nid
+        return self._universe.by_path.get(norm)
+
+    def resolve_name(
+        self, ctx: ModuleCtx, name: str
+    ) -> tuple[str | None, str]:
+        """Nome bare/dotted → nó local único, senão status defensável."""
+        head, _, tail = name.partition(".")
+        if not tail and name in ctx.defines and name in ctx.import_targets:
+            # def local + binding de import competem pelo mesmo nome —
+            # sem ordem textual o desfecho honesto é ambiguous, nunca
+            # um "resolved" para o alvo plausível-mas-errado (lf-0024).
+            return None, "ambiguous"
+        if head in ctx.import_targets:
+            mod, rest = self.locate(ctx, ctx.import_targets[head])
+            if mod is None:
+                return None, "external"
+            chain = [s for s in (*rest, tail) if s and s != "*"]
+            if not chain:
+                return mod.nid, "resolved"
+            hits = sorted(set(mod.defines.get(chain[0], [])))
+            if len(hits) == 1:
+                return hits[0], "resolved"
+            if hits:
+                return None, "ambiguous"
+            return None, "unresolved"
+        if tail:
+            # `obj.attr` sem tipo de obj — nunca resolve por coincidência
+            return None, "unresolved"
+        local = sorted(set(ctx.defines.get(name, [])))
+        if len(local) == 1:
+            return local[0], "resolved"
+        if len(local) > 1:
+            return None, "ambiguous"
+        return None, "unresolved"
+
+    def resolve_call(
+        self, ctx: ModuleCtx, callee: str
+    ) -> tuple[str | None, str]:
+        return self.resolve_name(ctx, callee)

code_atlas/search/__init__.py

@@ -0,0 +1,32 @@
+"""Subsistema de busca (Cycle 2 Phase 6 + Cycle 4 lf-0036).
+
+lf-0119: a faceta de domínio (``DomainSearchHit``/``DomainEntitySearch``)
+e a busca federada (``code_atlas.search.federated`` — importada pelas
+superfícies, não reexportada aqui para não puxar ``code_atlas.federation``
+em todo consumidor do engine).
+"""
+
+from code_atlas.search.contracts import (
+    DomainSearchHit,
+    SearchCapability,
+    SearchDiagnostic,
+    SearchHit,
+    SearchRequest,
+    SearchResult,
+)
+from code_atlas.search.domain import DomainEntitySearch
+from code_atlas.search.engine import SearchEngine
+from code_atlas.search.structural import SearchFilters, StructuralSearch
+
+__all__ = [
+    "DomainEntitySearch",
+    "DomainSearchHit",
+    "SearchCapability",
+    "SearchDiagnostic",
+    "SearchEngine",
+    "SearchFilters",
+    "SearchHit",
+    "SearchRequest",
+    "SearchResult",
+    "StructuralSearch",
+]