@semacode/cli 2.2.0 → 2.3.1

package/dist/discovery/render.js

@@ -0,0 +1,100 @@
+// SEMA-GOVERNED: sema.produto.descoberta_capacidades
+// Descrição: saída humana agrupada, contextual e explícita sobre ausência de execução.
+const KIND_LABELS = {
+    GOVERNANCE_FLOW: "Fluxos de governança",
+    PROFILE_GATE: "Gates por profile",
+    SPECIALIZED_WORKFLOW: "Workflows especializados",
+    ORCHESTRATION_PIPELINE: "Pipelines de orquestração",
+    CAPABILITY_TOKEN: "Capabilities declarativas",
+    GENERATOR: "Geradores",
+    ADAPTER: "Adapters externos",
+};
+const FRONTEIRA = "Nenhuma ação foi executada; o workspace e serviços externos não foram tocados.";
+function linhaComando(entry) {
+    const command = entry.commandTemplates[0]?.command;
+    return command ? `   Comando explícito: ${command}` : "   Comando explícito: não disponível";
+}
+function renderizarCatalogo(payload) {
+    const linhas = [
+        "DESCOBERTA SEMA",
+        `CATÁLOGO · ${payload.entries.length} capacidade(s)`,
+        FRONTEIRA,
+    ];
+    if (payload.entries.length === 0) {
+        linhas.push("", "Nenhuma capacidade corresponde aos filtros informados.");
+        return linhas.join("\n");
+    }
+    for (const kind of Object.keys(KIND_LABELS)) {
+        const entries = payload.entries.filter((entry) => entry.kind === kind);
+        if (entries.length === 0)
+            continue;
+        linhas.push("", `${KIND_LABELS[kind]} (${entries.length})`);
+        for (const entry of entries) {
+            linhas.push(`- ${entry.label} · ${entry.id}`, `   ${entry.summary}`, `   Use quando: ${entry.useWhen[0] ?? "consulte a descrição detalhada"}`, linhaComando(entry));
+        }
+    }
+    return linhas.join("\n");
+}
+function renderizarRanking(payload) {
+    const linhas = [
+        "DESCOBERTA SEMA",
+        `INTENÇÃO · ${payload.intent}`,
+        FRONTEIRA,
+    ];
+    if (payload.noMatch) {
+        linhas.push("", "Sem correspondência segura (o melhor score ficou abaixo de 60/100).");
+    }
+    else if (payload.ambiguity.detected) {
+        linhas.push("", `Ambiguidade detectada entre ${payload.ambiguity.candidates.join(" e ")}.`, "Nenhum comando único foi sugerido; refine a intenção ou escolha uma capacidade explicitamente.");
+    }
+    if (payload.recommendations.length === 0) {
+        linhas.push("", "Nenhuma candidata recebeu sinais positivos.");
+        return linhas.join("\n");
+    }
+    linhas.push("");
+    for (const recommendation of payload.recommendations) {
+        linhas.push(`${recommendation.rank}. ${recommendation.label} · ${recommendation.id} — ${recommendation.score}/100`, `   Motivos: ${recommendation.reasons.join("; ")}`, `   Sinais: ${recommendation.matchedSignals.join(", ") || "nenhum"}`);
+        if (recommendation.missingInputs.length > 0) {
+            linhas.push(`   Entradas ainda necessárias: ${recommendation.missingInputs.join(", ")}`);
+        }
+        if (recommendation.suggestedCommandTemplate) {
+            linhas.push(`   Comando explícito: ${recommendation.suggestedCommandTemplate}`);
+        }
+    }
+    return linhas.join("\n");
+}
+function renderizarExplicacao(payload) {
+    const entry = payload.entry;
+    const linhas = [
+        "DESCOBERTA SEMA",
+        `${entry.label} · ${entry.id}`,
+        `${KIND_LABELS[entry.kind]} · ${entry.domains.join(", ")}`,
+        FRONTEIRA,
+        "",
+        entry.summary,
+        "",
+        "Use quando:",
+        ...entry.useWhen.map((item) => `- ${item}`),
+        "",
+        "Evite quando:",
+        ...entry.avoidWhen.map((item) => `- ${item}`),
+        "",
+        "Comandos explícitos:",
+        ...entry.commandTemplates.map((item) => (`- ${item.command} [${item.effectClass}; muta workspace: ${item.mutatesWorkspace ? "sim" : "não"}; runtime externo: ${item.executesExternalRuntime ? "sim" : "não"}]`)),
+    ];
+    return linhas.join("\n");
+}
+export function renderizarResultadoDescoberta(payload) {
+    if (payload.mode === "catalog")
+        return renderizarCatalogo(payload);
+    if (payload.mode === "ranking")
+        return renderizarRanking(payload);
+    if (payload.mode === "explain")
+        return renderizarExplicacao(payload);
+    return [
+        "DESCOBERTA SEMA · ERRO",
+        payload.error.message,
+        FRONTEIRA,
+    ].join("\n");
+}
+//# sourceMappingURL=render.js.map

package/dist/discovery/types.d.ts

@@ -0,0 +1,119 @@
+export declare const DISCOVERY_SCHEMA_VERSION: "sema.discovery/v1";
+export declare const DISCOVERY_KINDS: readonly ["GOVERNANCE_FLOW", "PROFILE_GATE", "SPECIALIZED_WORKFLOW", "ORCHESTRATION_PIPELINE", "CAPABILITY_TOKEN", "GENERATOR", "ADAPTER"];
+export type DiscoveryKind = (typeof DISCOVERY_KINDS)[number];
+export type DiscoveryEffectClass = "READ_ONLY_DISCOVERY" | "READ_ONLY_VALIDATION" | "DECLARATIVE_PLANNING" | "WORKSPACE_BOOTSTRAP" | "WORKSPACE_GENERATION" | "WORKSPACE_VERIFICATION";
+export interface DiscoveryCommandTemplate {
+    readonly id: string;
+    readonly command: string;
+    readonly effectClass: DiscoveryEffectClass;
+    readonly mutatesWorkspace: boolean;
+    readonly executesExternalRuntime: boolean;
+}
+export interface DiscoveryEntry {
+    readonly id: string;
+    readonly kind: DiscoveryKind;
+    readonly domains: readonly string[];
+    readonly label: string;
+    readonly summary: string;
+    readonly useWhen: readonly string[];
+    readonly avoidWhen: readonly string[];
+    readonly intentSignals: readonly string[];
+    readonly negativeSignals: readonly string[];
+    readonly requiredInputs: readonly string[];
+    readonly commandTemplates: readonly DiscoveryCommandTemplate[];
+    readonly related: readonly string[];
+    readonly source: string;
+    readonly extensible: boolean;
+    readonly aliases?: readonly string[];
+}
+export interface DiscoveryExecutionBoundary {
+    readonly executed: false;
+    readonly workspaceMutated: false;
+    readonly externalCalls: false;
+    readonly requiresExplicitRun: true;
+}
+export interface DiscoveryCatalogFilters {
+    readonly kind?: DiscoveryKind | string | null;
+    readonly id?: string | null;
+    readonly domain?: string | null;
+}
+export interface DiscoveryCatalogPayload extends DiscoveryExecutionBoundary {
+    readonly schemaVersion: typeof DISCOVERY_SCHEMA_VERSION;
+    readonly command: "descobrir catalogo" | "descobrir pipeline listar";
+    readonly success: true;
+    readonly mode: "catalog";
+    readonly filters: {
+        readonly kind: DiscoveryKind | null;
+        readonly id: string | null;
+        readonly domain: string | null;
+    };
+    readonly entries: readonly DiscoveryEntry[];
+}
+export interface DiscoveryRecommendation {
+    readonly rank: number;
+    readonly id: string;
+    readonly kind: DiscoveryKind;
+    readonly label: string;
+    readonly score: number;
+    readonly matchedSignals: readonly string[];
+    readonly reasons: readonly string[];
+    readonly missingInputs: readonly string[];
+    readonly suggestedCommandTemplate: string | null;
+}
+export interface DiscoveryAmbiguity {
+    readonly detected: boolean;
+    readonly delta: number | null;
+    readonly candidates: readonly string[];
+}
+export interface DiscoveryRecommendationPayload extends DiscoveryExecutionBoundary {
+    readonly schemaVersion: typeof DISCOVERY_SCHEMA_VERSION;
+    readonly command: "descobrir recomendar";
+    readonly success: true;
+    readonly mode: "ranking";
+    readonly intent: string;
+    readonly recommendations: readonly DiscoveryRecommendation[];
+    readonly ambiguity: DiscoveryAmbiguity;
+    readonly noMatch: boolean;
+}
+export interface DiscoveryExplainPayload extends DiscoveryExecutionBoundary {
+    readonly schemaVersion: typeof DISCOVERY_SCHEMA_VERSION;
+    readonly command: "descobrir explicar" | "descobrir pipeline descrever";
+    readonly success: true;
+    readonly mode: "explain";
+    readonly entry: DiscoveryEntry;
+}
+export interface DiscoveryErrorPayload extends DiscoveryExecutionBoundary {
+    readonly schemaVersion: typeof DISCOVERY_SCHEMA_VERSION;
+    readonly command: "descobrir";
+    readonly success: false;
+    readonly mode: "error";
+    readonly error: {
+        readonly code: string;
+        readonly message: string;
+    };
+}
+export type DiscoveryPayload = DiscoveryCatalogPayload | DiscoveryRecommendationPayload | DiscoveryExplainPayload | DiscoveryErrorPayload;
+export interface DiscoveryCommandResult {
+    readonly exitCode: 0 | 2;
+    readonly payload: DiscoveryPayload;
+    readonly text: string;
+    readonly outputFormat: "json" | "text";
+    readonly executed: false;
+}
+export interface ResumoDescobertaAgentContext {
+    readonly schemaVersion: typeof DISCOVERY_SCHEMA_VERSION;
+    readonly command: "sema descobrir catalogo --json";
+    readonly kinds: readonly DiscoveryKind[];
+    readonly pipelinesPrincipais: readonly {
+        readonly id: string;
+        readonly label: string;
+        readonly command: string;
+    }[];
+    readonly commands: {
+        readonly catalogo: "sema descobrir catalogo --json";
+        readonly recomendar: "sema descobrir recomendar --intencao <texto> --json";
+        readonly explicar: "sema descobrir explicar <id> --json";
+    };
+}
+/** @deprecated Prefira o nome canônico em PT-BR. */
+export type DiscoveryAgentContextSummary = ResumoDescobertaAgentContext;

package/dist/discovery/types.js

@@ -0,0 +1,13 @@
+// SEMA-GOVERNED: sema.produto.descoberta_capacidades
+// Descrição: tipos públicos e fronteira sem efeitos da descoberta de capacidades.
+export const DISCOVERY_SCHEMA_VERSION = "sema.discovery/v1";
+export const DISCOVERY_KINDS = [
+    "GOVERNANCE_FLOW",
+    "PROFILE_GATE",
+    "SPECIALIZED_WORKFLOW",
+    "ORCHESTRATION_PIPELINE",
+    "CAPABILITY_TOKEN",
+    "GENERATOR",
+    "ADAPTER",
+];
+//# sourceMappingURL=types.js.map

package/dist/drift.part01.d.ts

@@ -1,5 +1,8 @@
 import type { EngineBanco, NivelConfiancaSemantica, NivelRiscoSemantico, TipoRecursoPersistencia } from "@sema/nucleo";
 import type { ContextoProjetoCarregado } from "./projeto.js";
+import type { PoliticaCacheDrift } from "./driftCache.js";
+import type { MetricasCacheIncrementalDrift } from "./driftCacheIncremental.js";
+import type { MetricasCatalogoDrift, ObservadorOperacaoDrift } from "./driftCatalogo.js";
 export type OrigemCodigoDrift = "ts" | "js" | "py" | "dart" | "lua" | "cs" | "java" | "go" | "rust" | "cpp" | "php";
 export type OrigemSimboloDrift = OrigemCodigoDrift | "sql";
 export interface SimboloResolvido {
@@ -31,9 +34,11 @@ export interface OpcoesDriftLegado {
     escopo?: EscopoDriftReal;
     ignorarWorktrees?: boolean;
     ignorarConsumidoresLaterais?: boolean;
+    cache?: PoliticaCacheDrift;
+    observador?: ObservadorOperacaoDrift;
 }
 export interface DiagnosticoDrift {
-    tipo: "impl_quebrado" | "task_sem_impl" | "rota_divergente" | "recurso_divergente" | "vinculo_quebrado" | "seguranca_frouxa" | "pontuacao_semantica_insuficiente" | "contrato_monolitico" | "codigo_monolitico" | "codigo_governado_sem_cabecalho";
+    tipo: "impl_quebrado" | "task_sem_impl" | "rota_divergente" | "recurso_divergente" | "vinculo_quebrado" | "seguranca_frouxa" | "pontuacao_semantica_insuficiente" | "contrato_monolitico" | "codigo_monolitico" | "codigo_governado_sem_cabecalho" | "escopo_estreito_sem_vinculos";
     modulo: string;
     task?: string;
     route?: string;
@@ -159,6 +164,28 @@ export interface ConfiguracaoEscopoDriftAplicada {
     ignorarWorktrees: boolean;
     ignorarConsumidoresLaterais: boolean;
     termosEscopo: string[];
+    estrategia?: "arquivos_vinculados" | "projeto";
+    cobertura?: "completa" | "parcial";
+    arquivosPlanejados?: string[];
+    arquivosDeclarados?: string[];
+    arquivosInferidos?: string[];
+    arquivosAusentes?: string[];
+    bloqueios?: string[];
+    cache?: {
+        politica: PoliticaCacheDrift;
+        origem: "cache" | "calculado" | "nao_aplicavel";
+        chave?: string;
+        incremental?: MetricasCacheIncrementalDrift;
+        fasesMs?: {
+            planejamento: number;
+            catalogacao: number;
+            dependencias: number;
+            assinaturas: number;
+            indexacao: number;
+            total: number;
+        };
+    };
+    catalogo?: MetricasCatalogoDrift;
 }
 export interface RegistroImpactoSemanticoArquivo {
     arquivo: string;
@@ -251,7 +278,10 @@ export declare function obterDiretoriosIgnoradosAtivos(): Set<string>;
 export declare function definirDiretoriosIgnoradosAtivos(diretorios: Set<string>): void;
 export declare function normalizarFragmentoArquivo(valor: string): string;
 export declare function normalizarEscopoDrift(valor?: string): EscopoDriftReal;
-export declare function resolverOpcoesDrift(opcoes?: OpcoesDriftLegado): Required<OpcoesDriftLegado>;
+export type OpcoesDriftLegadoResolvidas = Required<Omit<OpcoesDriftLegado, "observador">> & {
+    observador?: ObservadorOperacaoDrift;
+};
+export declare function resolverOpcoesDrift(opcoes?: OpcoesDriftLegado): OpcoesDriftLegadoResolvidas;
 export declare function resolverDiretoriosIgnoradosAtivos(opcoes?: OpcoesDriftLegado): Set<string>;
 export declare function quebrarTermosEscopo(valor: string): string[];
 export declare function quebrarTermosModuloEscopo(nomeModulo: string): string[];

package/dist/drift.part01.js

@@ -91,6 +91,8 @@ export function resolverOpcoesDrift(opcoes) {
         escopo: normalizarEscopoDrift(opcoes?.escopo),
         ignorarWorktrees: opcoes?.ignorarWorktrees !== false,
         ignorarConsumidoresLaterais: opcoes?.ignorarConsumidoresLaterais !== false,
+        cache: opcoes?.cache === "refresh" || opcoes?.cache === "off" ? opcoes.cache : "auto",
+        observador: opcoes?.observador,
     };
 }
 export function resolverDiretoriosIgnoradosAtivos(opcoes) {

package/dist/drift.part04.d.ts

@@ -2,6 +2,7 @@ import ts from "typescript";
 import type { IrModulo, IrSuperficie, IrTask, IrVinculo, NivelConfiancaSemantica, NivelRiscoSemantico } from "@sema/nucleo";
 import { ResultadoDrift, SimboloResolvido } from "./drift.part01.js";
 import { type PoliticaPontuacaoSemantica } from "./driftScore.js";
+import type { CatalogoDrift } from "./driftCatalogo.js";
 export declare function resolverArquivoOuSimboloAncora(vinculos: IrVinculo[], simbolos: SimboloResolvido[], mapaImpl: Map<string, SimboloResolvido>, arquivos: string[]): {
     arquivo?: string;
     simbolo?: string;
@@ -37,9 +38,9 @@ export declare function lerDecorator(node: ts.Node, nomes: string[]): {
     argumentos: ts.NodeArray<ts.Expression>;
 } | undefined;
 export declare function juntarCaminhoHttp(base: string | undefined, sufixo: string | undefined): string;
-export declare function listarArquivosRecursivos(diretorio: string, extensoes: string[]): Promise<string[]>;
+export declare function listarArquivosRecursivos(diretorio: string, extensoes: string[], catalogo?: CatalogoDrift): Promise<string[]>;
 export declare const EXTENSOES_ARQUIVOS_RASTREAVEIS_DRIFT: string[];
-export declare function indexarArquivosRastreaveis(diretorios: string[]): Promise<string[]>;
+export declare function indexarArquivosRastreaveis(diretorios: string[], catalogo?: CatalogoDrift): Promise<string[]>;
 export declare function caminhosSimbolicos(baseDiretorio: string, arquivo: string): string[];
 export declare function registrarSimboloTypeScript(simbolos: Map<string, SimboloResolvido>, basesSimbolicas: string[], arquivo: string, nome: string, nomeClasse?: string, origem?: "ts" | "js"): void;
 export declare function desembrulharExpressaoTypeScript(expr: ts.Expression): ts.Expression;

package/dist/drift.part04.js

@@ -258,7 +258,10 @@ export function juntarCaminhoHttp(base, sufixo) {
     const caminho = `/${partes.join("/")}`.replace(/\/+/g, "/");
     return caminho === "//" ? "/" : caminho;
 }
-export async function listarArquivosRecursivos(diretorio, extensoes) {
+export async function listarArquivosRecursivos(diretorio, extensoes, catalogo) {
+    if (catalogo) {
+        return catalogo.listarPorRaiz(diretorio, extensoes);
+    }
     let entradas;
     try {
         entradas = await readdir(diretorio, { withFileTypes: true, encoding: "utf8" });
@@ -291,10 +294,10 @@ export const EXTENSOES_ARQUIVOS_RASTREAVEIS_DRIFT = [
     ".yml", ".yaml", ".toml", ".xml", ".html", ".htm", ".css",
     ".Caddyfile", ".caddyfile",
 ];
-export async function indexarArquivosRastreaveis(diretorios) {
+export async function indexarArquivosRastreaveis(diretorios, catalogo) {
     const arquivos = new Set();
     for (const diretorio of diretorios) {
-        for (const arquivo of await listarArquivosRecursivos(diretorio, EXTENSOES_ARQUIVOS_RASTREAVEIS_DRIFT)) {
+        for (const arquivo of await listarArquivosRecursivos(diretorio, EXTENSOES_ARQUIVOS_RASTREAVEIS_DRIFT, catalogo)) {
             arquivos.add(arquivo);
         }
     }

package/dist/drift.part05.d.ts

@@ -1,5 +1,6 @@
 import ts from "typescript";
 import { RegistroConsumerSurfaceDrift, SimboloResolvido } from "./drift.part01.js";
+import type { CatalogoDrift } from "./driftCatalogo.js";
 export declare function registrarMetodoTypeScriptProtoOuObjeto(simbolos: Map<string, SimboloResolvido>, basesSimbolicas: string[], arquivo: string, nomeMetodo: string, nomeClasse?: string, origem?: "ts" | "js"): void;
 export declare function registrarMetodosObjectAssignTypeScript(simbolos: Map<string, SimboloResolvido>, basesSimbolicas: string[], arquivo: string, objeto: ts.ObjectLiteralExpression, sourceFile: ts.SourceFile, nomeClasse?: string, origem?: "ts" | "js"): void;
 export declare function registrarAtribuicaoPrototypeTypeScript(simbolos: Map<string, SimboloResolvido>, basesSimbolicas: string[], arquivo: string, sourceFile: ts.SourceFile, esquerda: ts.Expression, direita: ts.Expression, origem?: "ts" | "js"): void;
@@ -43,5 +44,5 @@ export declare function extrairRotasReactViteConsumer(relacaoArquivo: string, co
 export declare function normalizarRotaDeclaradaFlutter(caminhoCru: string): string;
 export declare function extrairRotasFlutterConsumer(relacaoArquivo: string, codigo: string): RotaFlutterConsumerDrift[];
 export declare function extrairRotasAngularConsumerDiretas(relacaoArquivo: string, codigo: string, prefixo?: string): RotaAngularConsumerDrift[];
-export declare function extrairRotasAngularConsumer(diretorioBase: string, relacaoArquivo: string, prefixo?: string, visitados?: Set<string>): Promise<RotaAngularConsumerDrift[]>;
+export declare function extrairRotasAngularConsumer(diretorioBase: string, relacaoArquivo: string, prefixo?: string, visitados?: Set<string>, catalogo?: CatalogoDrift): Promise<RotaAngularConsumerDrift[]>;
 export declare function simboloEhBridgeConsumer(caminho: string, arquivo: string): boolean;

package/dist/drift.part05.js

@@ -318,7 +318,7 @@ export function extrairRotasAngularConsumerDiretas(relacaoArquivo, codigo, prefi
     }
     return rotas;
 }
-export async function extrairRotasAngularConsumer(diretorioBase, relacaoArquivo, prefixo = "/", visitados = new Set()) {
+export async function extrairRotasAngularConsumer(diretorioBase, relacaoArquivo, prefixo = "/", visitados = new Set(), catalogo) {
     const relacaoNormalizada = normalizarRelacaoConsumer(relacaoArquivo);
     if (visitados.has(relacaoNormalizada)) {
         return [];
@@ -326,7 +326,8 @@ export async function extrairRotasAngularConsumer(diretorioBase, relacaoArquivo,
     visitados.add(relacaoNormalizada);
     let codigo = "";
     try {
-        codigo = await readFile(path.join(diretorioBase, relacaoNormalizada), "utf8");
+        const arquivo = path.join(diretorioBase, relacaoNormalizada);
+        codigo = catalogo ? await catalogo.lerTexto(arquivo) : await readFile(arquivo, "utf8");
     }
     catch {
         return [];
@@ -337,7 +338,7 @@ export async function extrairRotasAngularConsumer(diretorioBase, relacaoArquivo,
         if (!rota.arquivoRotasFilhas) {
             continue;
         }
-        filhas.push(...await extrairRotasAngularConsumer(diretorioBase, rota.arquivoRotasFilhas, rota.rota, visitados));
+        filhas.push(...await extrairRotasAngularConsumer(diretorioBase, rota.arquivoRotasFilhas, rota.rota, visitados, catalogo));
     }
     return [...rotas, ...filhas];
 }

package/dist/drift.part06.d.ts

@@ -1,8 +1,9 @@
 import type { FonteLegado } from "./tipos.js";
 import { ConsumerFramework, RecursoResolvido, RegistroConsumerBridgeDrift, RegistroConsumerSurfaceDrift, RotaResolvida, SimboloResolvido } from "./drift.part01.js";
+import type { CatalogoDrift } from "./driftCatalogo.js";
 export declare function inferirConsumerFrameworkPrincipal(fontesLegado: FonteLegado[], consumerSurfaces: RegistroConsumerSurfaceDrift[], consumerBridges: RegistroConsumerBridgeDrift[]): ConsumerFramework | null;
 export declare function extrairColecoesFirebase(arquivo: string, codigo: string): RecursoResolvido[];
-export declare function indexarTypeScript(diretorios: string[]): Promise<{
+export declare function indexarTypeScript(diretorios: string[], catalogo?: CatalogoDrift): Promise<{
     simbolos: SimboloResolvido[];
     rotas: RotaResolvida[];
     recursos: RecursoResolvido[];

package/dist/drift.part06.js

@@ -126,13 +126,15 @@ function aplicarReexportacoesTypeScript(simbolos, reexportacoes) {
         }
     }
 }
-export async function indexarTypeScript(diretorios) {
+export async function indexarTypeScript(diretorios, catalogo) {
+    catalogo?.emitir("extractor.run");
     const simbolos = new Map();
     const rotas = [];
     const recursos = new Map();
     const consumerSurfaces = new Map();
+    const sourceFiles = new Map();
     for (const diretorio of diretorios) {
-        const arquivos = (await listarArquivosRecursivos(diretorio, [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]))
+        const arquivos = (await listarArquivosRecursivos(diretorio, [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"], catalogo))
             .filter((arquivo) => !arquivo.endsWith(".d.ts")
             && !arquivo.endsWith(".spec.ts")
             && !arquivo.endsWith(".test.ts"));
@@ -144,7 +146,7 @@ export async function indexarTypeScript(diretorios) {
         let encontrouSuperficieAngularPorRotas = false;
         const reexportacoes = [];
         for (const arquivo of arquivos) {
-            const codigo = await readFile(arquivo, "utf8");
+            const codigo = catalogo ? await catalogo.lerTexto(arquivo) : await readFile(arquivo, "utf8");
             const origemArquivo = /\.(?:js|jsx|mjs|cjs)$/i.test(arquivo) ? "js" : "ts";
             const scriptKind = arquivo.endsWith(".tsx")
                 ? ts.ScriptKind.TSX
@@ -153,7 +155,9 @@ export async function indexarTypeScript(diretorios) {
                     : origemArquivo === "js"
                         ? ts.ScriptKind.JS
                         : ts.ScriptKind.TS;
+            catalogo?.emitir("ast.create", arquivo);
             const sourceFile = ts.createSourceFile(arquivo, codigo, ts.ScriptTarget.Latest, true, scriptKind);
+            sourceFiles.set(path.resolve(arquivo), sourceFile);
             const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
             const relacao = path.relative(diretorio, arquivo);
             for (const recurso of extrairRecursosPersistenciaCodigoVivo(arquivo, codigo)) {
@@ -228,7 +232,7 @@ export async function indexarTypeScript(diretorios) {
             }
             if (arquivoEhRotasAngularConsumer(relacao) && (!usarApenasRotasAngularRaiz || arquivosRotasAngularRaiz.has(path.resolve(arquivo)))) {
                 encontrouSuperficieAngularPorRotas = true;
-                for (const rotaAngular of await extrairRotasAngularConsumer(diretorio, relacao)) {
+                for (const rotaAngular of await extrairRotasAngularConsumer(diretorio, relacao, "/", new Set(), catalogo)) {
                     const arquivoRotasAngular = path.join(diretorio, rotaAngular.arquivoRotas);
                     consumerSurfaces.set(`${rotaAngular.rota}:${arquivoRotasAngular}:routes`, {
                         rota: rotaAngular.rota,
@@ -328,7 +332,7 @@ export async function indexarTypeScript(diretorios) {
             }
         }
         if (!encontrouSuperficieAngularPorRotas) {
-            for (const superficie of await coletarSuperficiesAngularStandaloneConsumer(diretorio, arquivos)) {
+            for (const superficie of await coletarSuperficiesAngularStandaloneConsumer(diretorio, arquivos, catalogo ? (arquivo) => catalogo.lerTexto(arquivo) : undefined, sourceFiles)) {
                 const arquivoSuperficie = path.join(diretorio, superficie.arquivo);
                 consumerSurfaces.set(`${superficie.rota}:${arquivoSuperficie}:${superficie.tipoArquivo}`, {
                     rota: superficie.rota,

package/dist/drift.part07.d.ts

@@ -1,51 +1,52 @@
 import type { EngineBanco } from "@sema/nucleo";
 import { OrigemRecursoDrift, RecursoResolvido, RegistroColunaPersistenciaDrift, RegistroConsumerSurfaceDrift, RotaResolvida, SimboloResolvido } from "./drift.part01.js";
-export declare function indexarPython(diretorios: string[]): Promise<{
+import type { CatalogoDrift } from "./driftCatalogo.js";
+export declare function indexarPython(diretorios: string[], catalogo?: CatalogoDrift): Promise<{
     simbolos: SimboloResolvido[];
     rotas: RotaResolvida[];
     recursos: RecursoResolvido[];
 }>;
-export declare function indexarDart(diretorios: string[]): Promise<{
+export declare function indexarDart(diretorios: string[], catalogo?: CatalogoDrift): Promise<{
     simbolos: SimboloResolvido[];
     rotas: RotaResolvida[];
     recursos: RecursoResolvido[];
     consumerSurfaces: RegistroConsumerSurfaceDrift[];
 }>;
 export declare function registrarSimboloGenerico(simbolos: Map<string, SimboloResolvido>, origem: SimboloResolvido["origem"], basesSimbolicas: string[], arquivo: string, simbolo: string): void;
-export declare function indexarDotnet(diretorios: string[]): Promise<{
+export declare function indexarDotnet(diretorios: string[], catalogo?: CatalogoDrift): Promise<{
     simbolos: SimboloResolvido[];
     rotas: RotaResolvida[];
     recursos: RecursoResolvido[];
 }>;
-export declare function indexarJava(diretorios: string[]): Promise<{
+export declare function indexarJava(diretorios: string[], catalogo?: CatalogoDrift): Promise<{
     simbolos: SimboloResolvido[];
     rotas: RotaResolvida[];
     recursos: RecursoResolvido[];
 }>;
-export declare function indexarGo(diretorios: string[]): Promise<{
+export declare function indexarGo(diretorios: string[], catalogo?: CatalogoDrift): Promise<{
     simbolos: SimboloResolvido[];
     rotas: RotaResolvida[];
     recursos: RecursoResolvido[];
 }>;
-export declare function indexarRust(diretorios: string[]): Promise<{
+export declare function indexarRust(diretorios: string[], catalogo?: CatalogoDrift): Promise<{
     simbolos: SimboloResolvido[];
     rotas: RotaResolvida[];
     recursos: RecursoResolvido[];
 }>;
-export declare function indexarCpp(diretorios: string[]): Promise<{
+export declare function indexarCpp(diretorios: string[], catalogo?: CatalogoDrift): Promise<{
     simbolos: SimboloResolvido[];
     recursos: RecursoResolvido[];
 }>;
-export declare function indexarPhp(diretorios: string[]): Promise<{
+export declare function indexarPhp(diretorios: string[], catalogo?: CatalogoDrift): Promise<{
     simbolos: SimboloResolvido[];
     rotas: RotaResolvida[];
     recursos: RecursoResolvido[];
 }>;
-export declare function indexarLua(diretorios: string[]): Promise<{
+export declare function indexarLua(diretorios: string[], catalogo?: CatalogoDrift): Promise<{
     simbolos: SimboloResolvido[];
     recursos: RecursoResolvido[];
 }>;
-export declare function indexarPersistenciaDeclarativa(diretorios: string[]): Promise<{
+export declare function indexarPersistenciaDeclarativa(diretorios: string[], catalogo?: CatalogoDrift): Promise<{
     recursos: RecursoResolvido[];
     simbolos: SimboloResolvido[];
 }>;