@orkastery/cli 0.5.3 → 0.6.0

package/dist/intelligence-graph-contexto.js

@@ -3,7 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CONTEXTO_FORA_DO_INDICE = exports.CONTEXTO_POR_ALVO = exports.CONTEXTO_TETO_PADRAO = exports.CONTEXTO_SCHEMA = void 0;
 exports.sementesDaThread = sementesDaThread;
 exports.pacoteDeContexto = pacoteDeContexto;
-/** KG5 fatia 3: composicao pura do contexto da thread. Sem E/S, relogio ou inferencia. */
+/**
+ * KG5: composicao pura do contexto da thread. Sem E/S, relogio ou inferencia.
+ *
+ * KG5 fatia 5 (D5): quem chama passa a situacao das fontes na arvore (o CLI le os bytes); o grupo cuja
+ * origem ou alvo nao confere ganha `arvore: "modificada"`, e o que confere sai sem o campo. Sem a situacao,
+ * ou com a arvore limpa, o pacote e o de antes, byte a byte.
+ */
 const node_crypto_1 = require("node:crypto");
 const intelligence_graph_contract_1 = require("./intelligence-graph-contract");
 const intelligence_graph_query_1 = require("./intelligence-graph-query");
@@ -11,6 +17,7 @@ exports.CONTEXTO_SCHEMA = 'ork.thread-graph-context/v2';
 exports.CONTEXTO_TETO_PADRAO = 32768;
 exports.CONTEXTO_POR_ALVO = 8;
 exports.CONTEXTO_FORA_DO_INDICE = 3;
+const LIMITE_REJEICOES_SEGUNDO_SALTO = 8;
 const hash = (texto) => (0, node_crypto_1.createHash)('sha256').update(texto).digest('hex');
 /** Caminho relativo do repositorio, nunca caminho de maquina, URL ou estado privado. */
 function caminhoPublico(bruto) {
@@ -63,8 +70,9 @@ function sementesDaThread(entrada, caminhosDoRepositorio = []) {
     return [...mapa].sort(([a], [b]) => (0, intelligence_graph_contract_1.compararUtf8)(a, b))
         .map(([arquivo, origens]) => ({ arquivo, origens: [...origens].sort(intelligence_graph_contract_1.compararUtf8) }));
 }
+const compararTipo = (a, b) => Number(a === 'cites') - Number(b === 'cites') || (0, intelligence_graph_contract_1.compararUtf8)(a, b);
 /** O grafo recebido ja deve estar filtrado pela concessao de quem consulta. */
-function pacoteDeContexto(grafo, indice, entrada, tetoBytes = exports.CONTEXTO_TETO_PADRAO) {
+function pacoteDeContexto(grafo, indice, entrada, tetoBytes = exports.CONTEXTO_TETO_PADRAO, situacao = intelligence_graph_query_1.TUDO_IGUAL) {
     if (!Number.isInteger(tetoBytes) || tetoBytes < 4096 || tetoBytes > 65536)
         throw new intelligence_graph_query_1.ErroDeConsulta('grafo.contexto.teto-invalido', 'teto deve ser inteiro de 4096 a 65536 bytes');
     const porId = new Map(grafo.nodes.map((n) => [n.node_id, n]));
@@ -86,6 +94,7 @@ function pacoteDeContexto(grafo, indice, entrada, tetoBytes = exports.CONTEXTO_T
         adj.get(de).add(para);
         adj.get(para).add(de);
     }
+    const vizinhos = new Set([...alvos].flatMap((p) => [...(adj.get(p) ?? [])]));
     const dist = new Map(diff.filter((p) => arquivos.has(p)).map((p) => [p, 0]));
     const fila = [...dist.keys()];
     for (let i = 0; i < fila.length; i++)
@@ -98,18 +107,24 @@ function pacoteDeContexto(grafo, indice, entrada, tetoBytes = exports.CONTEXTO_T
     const extratores = [...indice.extratores].sort((a, b) => (0, intelligence_graph_contract_1.compararUtf8)((0, intelligence_graph_contract_1.canonico)(a), (0, intelligence_graph_contract_1.canonico)(b)));
     const extratorIds = new Map(extratores.map((e, i) => [(0, intelligence_graph_contract_1.canonico)(e), i]));
     const grupos = new Map();
-    let totalArestas = 0, estruturais = 0, evidenciasAuxiliares = 0;
+    let totalArestas = 0, arestasDiretas = 0, estruturais = 0, evidenciasAuxiliares = 0, auxiliaresDiretas = 0;
     for (const a of grafo.edges) {
         const de = porId.get(a.from), para = porId.get(a.to);
-        if (!alvos.has(de.locator.path) && !alvos.has(para.locator.path))
+        const direto = alvos.has(de.locator.path) || alvos.has(para.locator.path);
+        if (!direto && (de.locator.path === para.locator.path
+            || (!vizinhos.has(de.locator.path) && !vizinhos.has(para.locator.path))))
             continue;
         totalArestas++;
+        if (direto)
+            arestasDiretas++;
         if ((a.kind === 'declares' || a.kind === 'contains') && de.locator.path === para.locator.path && alvos.has(de.locator.path)) {
             estruturais++;
             continue;
         }
         const proprias = a.evidence.filter((e) => e.path === de.locator.path);
         evidenciasAuxiliares += a.evidence.length - proprias.length;
+        if (direto)
+            auxiliaresDiretas += a.evidence.length - proprias.length;
         // Sem evidencia no arquivo de origem, a aresta fica em omitidos.arestas.
         if (!proprias.length)
             continue;
@@ -117,6 +132,7 @@ function pacoteDeContexto(grafo, indice, entrada, tetoBytes = exports.CONTEXTO_T
         const chave = (0, intelligence_graph_contract_1.canonico)([a.kind, destino, de.locator.path]);
         const grupo = grupos.get(chave) ?? { kind: a.kind, origem, destino, alvo: para.node_id, quantidade: 0,
             evidencias: new Map(), entreArquivos: de.locator.path !== para.locator.path,
+            salto: direto ? 1 : 2,
             distancia: Math.min(dist.get(de.locator.path) ?? Infinity, dist.get(para.locator.path) ?? Infinity) };
         grupo.quantidade++;
         for (const e of proprias) {
@@ -131,19 +147,19 @@ function pacoteDeContexto(grafo, indice, entrada, tetoBytes = exports.CONTEXTO_T
         grupos.set(chave, grupo);
     }
     // Entre arquivos > perto do diff > tipo > rotulos; empates independem da ordem do indice.
-    const ordenados = [...grupos.values()].sort((a, b) => Number(b.entreArquivos) - Number(a.entreArquivos)
+    const ordenados = [...grupos.values()].sort((a, b) => a.salto - b.salto || Number(b.entreArquivos) - Number(a.entreArquivos)
         || (a.distancia === b.distancia ? 0 : a.distancia < b.distancia ? -1 : 1)
-        || (0, intelligence_graph_contract_1.compararUtf8)(a.kind, b.kind) || (0, intelligence_graph_contract_1.compararUtf8)(a.destino, b.destino) || (0, intelligence_graph_contract_1.compararUtf8)(a.origem, b.origem));
+        || compararTipo(a.kind, b.kind) || (0, intelligence_graph_contract_1.compararUtf8)(a.destino, b.destino) || (0, intelligence_graph_contract_1.compararUtf8)(a.origem, b.origem));
     // Dentro da mesma prioridade, intercalar tipos impede calls de expulsar imports/references.
     const rodadas = new Map();
     const justos = ordenados.map((g) => {
-        const chave = JSON.stringify([g.alvo, g.entreArquivos, g.distancia, g.kind]);
+        const chave = JSON.stringify([g.salto, g.alvo, g.entreArquivos, g.distancia, g.kind]);
         const rodada = rodadas.get(chave) ?? 0;
         rodadas.set(chave, rodada + 1);
         return { g, rodada };
-    }).sort((a, b) => Number(b.g.entreArquivos) - Number(a.g.entreArquivos)
+    }).sort((a, b) => a.g.salto - b.g.salto || Number(b.g.entreArquivos) - Number(a.g.entreArquivos)
         || (a.g.distancia === b.g.distancia ? 0 : a.g.distancia < b.g.distancia ? -1 : 1)
-        || a.rodada - b.rodada || (0, intelligence_graph_contract_1.compararUtf8)(a.g.kind, b.g.kind)
+        || a.rodada - b.rodada || compararTipo(a.g.kind, b.g.kind)
         || (0, intelligence_graph_contract_1.compararUtf8)(a.g.destino, b.g.destino) || (0, intelligence_graph_contract_1.compararUtf8)(a.g.origem, b.g.origem)).map(({ g }) => g);
     const normalizada = { ...entrada, diff, diffEstado: entrada.diffEstado ?? 'coletado-na-worktree',
         claims: [...entrada.claims].sort((a, b) => (0, intelligence_graph_contract_1.compararUtf8)((0, intelligence_graph_contract_1.canonico)(a), (0, intelligence_graph_contract_1.canonico)(b))) };
@@ -151,10 +167,14 @@ function pacoteDeContexto(grafo, indice, entrada, tetoBytes = exports.CONTEXTO_T
         indice: { ...indice, extratores },
         fontes: { goal: entrada.goal === null ? 'ausente' : hash(entrada.goal), plan: entrada.plan === null ? 'ausente' : hash(entrada.plan),
             diff: normalizada.diffEstado },
-        consulta: { profundidade: 1, sentido: 'ambos', por_alvo: exports.CONTEXTO_POR_ALVO, fora_do_indice: exports.CONTEXTO_FORA_DO_INDICE },
+        consulta: { profundidade: 2, sentido: 'ambos', por_alvo: exports.CONTEXTO_POR_ALVO, fora_do_indice: exports.CONTEXTO_FORA_DO_INDICE },
         total_sementes: sementes.length, sementes_fora_do_indice: ausentes.length, total_arestas: totalArestas,
         total_ligacoes: ordenados.length, resumidas: { estruturais }, parcial: intelligence_graph_query_1.AVISO_DE_PARCIALIDADE };
     const selecionadas = [], ligacoes = [];
+    // D4 e D5: as evidencias do grupo estao no arquivo da origem; o alvo pesa como nas consultas por no.
+    const modificado = (a) => (a.modificada ??= situacao(a.origem.slice(5)) !== 'igual' || situacao(porId.get(a.alvo).locator.path) !== 'igual');
+    const totalDiretas = ordenados.filter((a) => a.salto === 1).length;
+    const totalSegundoSalto = ordenados.length - totalDiretas;
     const montar = () => {
         const caminhos = new Set(selecionadas.filter((s) => s.estado === 'indexado').map((s) => s.arquivo));
         const rotulos = new Set([...caminhos].map((p) => `file ${p}`));
@@ -166,11 +186,15 @@ function pacoteDeContexto(grafo, indice, entrada, tetoBytes = exports.CONTEXTO_T
         }
         const refs = new Map([...rotulos].sort(intelligence_graph_contract_1.compararUtf8).map((r, i) => [r, `n${i + 1}`]));
         const fontes = grafo.snapshot.source_manifest.filter((m) => caminhos.has(m.path)).sort((a, b) => (0, intelligence_graph_contract_1.compararUtf8)(a.path, b.path));
-        const omitidos = { sementes: sementes.length - selecionadas.length, ligacoes: ordenados.length - ligacoes.length,
+        const diretas = ligacoes.filter((a) => a.salto === 1);
+        const omitidos = { sementes: sementes.length - selecionadas.length, ligacoes: totalDiretas - diretas.length,
+            segundo_salto: totalSegundoSalto - (ligacoes.length - diretas.length),
             arestas: totalArestas - estruturais - ligacoes.reduce((s, a) => s + a.quantidade, 0), evidencias_auxiliares: evidenciasAuxiliares };
-        const cortado = omitidos.sementes > 0 || omitidos.ligacoes > 0 || omitidos.arestas > 0 || evidenciasAuxiliares > 0;
+        const diretasOmitidas = arestasDiretas - estruturais - diretas.reduce((s, a) => s + a.quantidade, 0);
+        const cortado = omitidos.sementes > 0 || omitidos.ligacoes > 0 || diretasOmitidas > 0 || auxiliaresDiretas > 0;
         const r = { ...fixo, sementes: selecionadas, nos: Object.fromEntries([...refs].map(([r, ref]) => [ref, r])),
             arestas: ligacoes.map((a) => ({ kind: a.kind, from: refs.get(a.origem), to: refs.get(a.destino), quantidade: a.quantidade,
+                ...(a.salto === 2 ? { salto: 2 } : {}), ...(modificado(a) ? { arvore: 'modificada' } : {}),
                 evidencias: [...a.evidencias].sort(([a], [b]) => (0, intelligence_graph_contract_1.compararUtf8)(a, b)).map(([, e]) => e) })),
             truncado: cortado, omitidos, teto: { bytes: tetoBytes, cortado },
             medida: { pacote_bytes: 0, leitura_crua_bytes: fontes.reduce((s, f) => s + f.size_bytes, 0),
@@ -197,19 +221,34 @@ function pacoteDeContexto(grafo, indice, entrada, tetoBytes = exports.CONTEXTO_T
     for (const s of indexadas)
         tentarSemente(s);
     const porAlvo = new Map();
-    for (const a of justos) {
+    const tentarLigacao = (a) => {
         if ((porAlvo.get(a.alvo) ?? 0) >= exports.CONTEXTO_POR_ALVO)
-            continue;
+            return 'por-alvo';
         ligacoes.push(a);
         const texto = montar();
         if (Buffer.byteLength(texto) <= tetoBytes) {
             melhor = texto;
             porAlvo.set(a.alvo, (porAlvo.get(a.alvo) ?? 0) + 1);
+            return 'incluida';
         }
-        else
-            ligacoes.pop(); // Um hub grande nao impede uma ligacao menor e relevante de entrar.
-    }
+        ligacoes.pop(); // Um hub grande nao impede uma ligacao menor e relevante de entrar.
+        return 'sem-espaco';
+    };
+    for (const a of justos)
+        if (a.salto === 1)
+            tentarLigacao(a);
     for (const s of ausentes.slice(0, exports.CONTEXTO_FORA_DO_INDICE))
         tentarSemente(s);
+    // Expande somente pontes que sobreviveram ao corte direto; a fronteira fica fixa nesta rodada.
+    const pontes = new Set(ligacoes.flatMap((a) => [a.origem.slice(5), porId.get(a.alvo).locator.path]));
+    let rejeicoes = 0;
+    for (const a of justos)
+        if (a.salto === 2 && (pontes.has(a.origem.slice(5)) || pontes.has(porId.get(a.alvo).locator.path))) {
+            const resultado = tentarLigacao(a);
+            if (resultado === 'incluida')
+                rejeicoes = 0;
+            else if (resultado === 'sem-espaco' && ++rejeicoes >= LIMITE_REJEICOES_SEGUNDO_SALTO)
+                break;
+        }
     return melhor;
 }

package/dist/intelligence-graph-contract.js

@@ -29,7 +29,7 @@ exports.GRAFO_LIMITES = Object.freeze({
     extratores: 32, diagnosticos: 100_000, caminho: 1024, fragmento: 512, paginas: 100_000,
 });
 exports.TIPOS_DE_NO = ['file', 'symbol', 'section', 'artifact'];
-exports.TIPOS_DE_ARESTA = ['contains', 'declares', 'imports', 'calls', 'references', 'derived_from'];
+exports.TIPOS_DE_ARESTA = ['contains', 'declares', 'imports', 'calls', 'references', 'derived_from', 'cites'];
 /** D4: so metodo deterministico sustenta aresta. Embedding, similaridade e inferencia ficam fora. */
 exports.METODOS_DE_EXTRACAO = ['ast', 'structured', 'explicit-link', 'text-location'];
 exports.CLASSE_DE_CONFIANCA = 'EXTRACTED';
@@ -45,6 +45,7 @@ exports.MATRIZ_DE_ARESTAS = Object.freeze({
     imports: { file: ['file', 'symbol'], symbol: ['file', 'symbol'], section: nenhum, artifact: nenhum },
     calls: { file: nenhum, symbol: ['symbol'], section: nenhum, artifact: nenhum },
     references: { file: exports.TIPOS_DE_NO, symbol: exports.TIPOS_DE_NO, section: exports.TIPOS_DE_NO, artifact: exports.TIPOS_DE_NO },
+    cites: { file: ['file'], symbol: nenhum, section: ['file'], artifact: nenhum },
     derived_from: { file: nenhum, symbol: nenhum, section: nenhum, artifact: ['file', 'section', 'artifact'] },
 });
 const inteiro = zod_1.z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);

package/dist/intelligence-graph-extract-md.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TETO_DE_LINHAS_DE_TABELA = exports.TOKENS_SEM_MENCAO = exports.CHAVES_DO_FRONTMATTER = exports.PADRAO_DE_ID = void 0;
 exports.slugDeTexto = slugDeTexto;
+exports.caminhoDaCitacao = caminhoDaCitacao;
 exports.estruturarMarkdown = estruturarMarkdown;
 exports.extrairMarkdown = extrairMarkdown;
 exports.ligarMarkdown = ligarMarkdown;
@@ -191,9 +192,10 @@ function estruturar(fonte, aceitaFragmento, analisar, referencia) {
             comDelimitador = true;
     }
     if (linhasDeTabela > exports.TETO_DE_LINHAS_DE_TABELA) {
-        return { fonte, secoes: [], links: [], textoDeMencao: [], frontmatter, frontmatterInvalido, tabelaGrande: true };
+        return { fonte, secoes: [], links: [], citacoes: [], textoDeMencao: [], frontmatter, frontmatterInvalido, tabelaGrande: true };
     }
     const secoes = [], links = [], semMencao = [];
+    const citacoes = [];
     const slug = contadorDeSlugs(), abertos = [];
     // B5: referencia de caractere pelo decodificador do micromark (as entidades do HTML5); a crua fica.
     const decodificada = (i, f) => referencia(corpo.slice(i + 1, f - 1)) ?? corpo.slice(i, f);
@@ -239,6 +241,10 @@ function estruturar(fonte, aceitaFragmento, analisar, referencia) {
                 semMencao.push([e.inicio, e.fim]);
             }
             // Titulo, lido em paralelo: o texto dele junta dado, codigo, escape e entidade.
+            if (e.tipo === 'codeTextData' && !emExcesso)
+                citacoes.push({
+                    destino: corpo.slice(e.inicio, e.fim), inicio: no(e.inicio), fim: no(e.fim),
+                });
             if (e.tipo === 'atxHeading' || e.tipo === 'setextHeading')
                 titulo = { inicio: no(e.inicio), fim: no(e.fim), partes: [], noTexto: 0, foraDoTexto: 0, noCodigo: 0 };
             else if (titulo) {
@@ -304,7 +310,7 @@ function estruturar(fonte, aceitaFragmento, analisar, referencia) {
         }
     }
     const textoDeMencao = linhasDe(apagarTrechos(corpo, semMencao)).map((l) => ({ inicio: no(l.inicio), texto: l.texto }));
-    return { fonte, secoes: secoes.sort((a, b) => a.inicio - b.inicio), links, textoDeMencao, frontmatter, frontmatterInvalido, tabelaGrande: false };
+    return { fonte, secoes: secoes.sort((a, b) => a.inicio - b.inicio), links, citacoes, textoDeMencao, frontmatter, frontmatterInvalido, tabelaGrande: false };
 }
 /** Caminho relativo a raiz a partir do arquivo do link; `null` se sair do repositorio. */
 function resolverCaminho(base, destino) {
@@ -323,6 +329,23 @@ function resolverCaminho(base, destino) {
     }
     return r.join('/');
 }
+/** Citacao nao e resolucao de runtime: so caminho literal dentro do manifesto. */
+function caminhoDaCitacao(base, literal, modulo = false) {
+    if (!literal || /[\s\\:#?%\u0000-\u001f\u007f]/u.test(literal) || literal.startsWith('/') || literal.startsWith('~'))
+        return null;
+    if (literal.split('/').some((p) => p === '.git' || p === '.orkastery'))
+        return null;
+    // Argumento sem prefixo de caminho e nome de pacote, nao candidato local.
+    if (modulo && !/^\.{1,2}\//.test(literal))
+        return null;
+    // Palavras e diretorios nao sao citacoes de arquivo. Modulos podem omitir extensao.
+    if (!modulo && (!literal.includes('/') || !/\.(?:[cm]?[jt]s|[jt]sx|json|md|markdown|ya?ml|toml|py|rs|go|c|h|css|html|svg|png|jpe?g|gif|webp|pdf|txt|sh|sql)$/i.test(literal)))
+        return null;
+    if (['', '.', '..'].includes(literal.split('/').at(-1)))
+        return null;
+    const caminho = literal.startsWith('./') || literal.startsWith('../') ? resolverCaminho(base, literal) : literal;
+    return caminho || null;
+}
 const decodificar = (t) => {
     try {
         return decodeURIComponent(t);
@@ -339,7 +362,7 @@ function estruturarMarkdown(fonte, e) {
             mencoes.push({ inicio: l.inicio + m.index, id: m[0] });
     const d = s.frontmatter?.dados;
     return {
-        path: fonte.path, secoes: s.secoes, links: s.links, mencoes,
+        path: fonte.path, secoes: s.secoes, links: s.links, citacoes: s.citacoes, mencoes,
         frontmatter: s.frontmatter && d
             ? { id: typeof d.id === 'string' ? d.id : null, tipo: typeof d.tipo === 'string' && d.tipo !== '', valores: s.frontmatter.valores }
             : null,
@@ -414,6 +437,13 @@ function ligarMarkdown(e) {
     };
     for (const s of estruturas) {
         const path = s.path, arquivo = { kind: 'file', path, fragment: null };
+        const citar = (alvo, k, metodo) => {
+            if (alvo === null || alvo === path || !arquivos.has(alvo))
+                return false;
+            aresta('cites', secaoEm(s, arquivo, k.inicio), { kind: 'file', path: alvo, fragment: null }, e.extratorMd, metodo, { path, inicio: k.inicio, fim: k.fim });
+            return true;
+        };
+        const linksReferenciados = [];
         for (const x of s.secoes) {
             if (x.slug === null) {
                 lacuna('secao-recusada', path, x.inicio, null);
@@ -438,7 +468,15 @@ function ligarMarkdown(e) {
                 lacuna('link-invalido', path, k.inicio, destino);
                 continue;
             }
-            const alvo = caminhoDecodificado === '' ? path : resolverCaminho(path, caminhoDecodificado);
+            const relativo = caminhoDecodificado === '' ? path : resolverCaminho(path, caminhoDecodificado);
+            // Links seguem o diretorio do documento; a citacao tambem admite caminho desde a raiz.
+            const literal = caminhoDaCitacao(path, caminhoDecodificado);
+            // Uma referencia ao arquivo ou a uma secao ja representa esta ocorrencia do link.
+            if (relativo === null || !arquivos.has(relativo)) {
+                if (citar(literal, k, 'explicit-link'))
+                    linksReferenciados.push(k);
+            }
+            const alvo = relativo;
             if (alvo === null) {
                 lacuna('link-fora-do-repositorio', path, k.inicio, destino);
                 continue;
@@ -450,6 +488,7 @@ function ligarMarkdown(e) {
             const secoesDoAlvo = slugs.get(alvo);
             if (ancora && secoesDoAlvo?.has(ancora)) {
                 aresta('references', origem, { kind: 'section', path: alvo, fragment: ancora }, e.extratorMd, 'explicit-link', t);
+                linksReferenciados.push(k);
                 continue;
             }
             // P6: ancora que nao bate fica declarada; o link ainda prova a referencia ao arquivo.
@@ -458,6 +497,19 @@ function ligarMarkdown(e) {
             if (alvo === path)
                 continue;
             aresta('references', origem, { kind: 'file', path: alvo, fragment: null }, e.extratorMd, 'explicit-link', t);
+            linksReferenciados.push(k);
+        }
+        // Codigo inline no rotulo pertence a mesma ocorrencia do link ja resolvido.
+        // Varredura por spans preserva citacoes independentes, inclusive na mesma linha.
+        linksReferenciados.sort((a, b) => a.inicio - b.inicio || b.fim - a.fim);
+        let link = 0;
+        for (const k of s.citacoes) {
+            while (link < linksReferenciados.length && linksReferenciados[link].fim <= k.inicio)
+                link++;
+            const l = linksReferenciados[link];
+            if (l && l.inicio <= k.inicio && k.fim <= l.fim)
+                continue;
+            citar(caminhoDaCitacao(path, k.destino), k, 'text-location');
         }
         const artefato = s.frontmatter && s.frontmatter.id !== null ? artefatos.get(s.frontmatter.id) : undefined;
         if (artefato && artefato.path === path && s.frontmatter) {

package/dist/intelligence-graph-extract-ts.js

@@ -3,9 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OPCOES_TS_DESCRITAS = void 0;
 exports.casaSonda = casaSonda;
 exports.extrairTypeScript = extrairTypeScript;
+const intelligence_graph_extract_md_1 = require("./intelligence-graph-extract-md");
 /** Extensoes que o extrator TS le; as do `extensaoDe` do KG2. */
 const EXTENSOES_DO_PROGRAMA = ['.cjs', '.cts', '.js', '.jsx', '.mjs', '.mts', '.ts', '.tsx'];
 const DECLARACOES_TS = ['.d.ts', '.d.mts', '.d.cts'];
+/** KG5: candidatos literais; dist -> src e uma convencao de citacao, nunca prova de import. */
+function candidatosDaCitacao(base) {
+    const formas = (p) => {
+        const semJs = p.replace(/\.(?:[cm]?js|jsx)$/, '');
+        if (semJs !== p)
+            return [semJs + '.ts', semJs + '.tsx', semJs + '.mts', semJs + '.cts'];
+        if (/\.[^/]+$/.test(p))
+            return [];
+        return EXTENSOES_DO_PROGRAMA.flatMap((ext) => [p + ext, p + '/index' + ext]);
+    };
+    const grupos = [[base], formas(base)];
+    const fonte = base.replace(/(^|\/)dist\//, '$1src/');
+    if (fonte !== base)
+        grupos.push([fonte], formas(fonte));
+    return grupos;
+}
 /** A base sem a extensao (o TypeScript troca `.js` por `.ts`, e `.d.ts` conta inteira). */
 function semExtensao(base) {
     const nome = base.slice(base.lastIndexOf('/') + 1);
@@ -283,12 +300,19 @@ function extrairTypeScript(e, ts) {
     /** Fonte TypeScript, que o compilador transforma; JavaScript roda como esta. */
     const compiladoEm = (arquivo) => !EXTENSOES_JS.includes(extensao(arquivo));
     /** Chaves de todos os imports dentro de um no. */
-    function especificadoresEm(raiz) {
+    function especificadoresEm(raiz, literais) {
         const r = [], compilado = compiladoEm(raiz.getSourceFile().fileName);
         const coletar = (n) => {
             const chave = chaveDoImport(n, compilado);
-            if (chave !== null)
+            if (chave !== null) {
                 r.push(chave);
+                const esp = ts.isImportDeclaration(n) || ts.isExportDeclaration(n) ? n.moduleSpecifier
+                    : ts.isImportEqualsDeclaration(n) && ts.isExternalModuleReference(n.moduleReference) ? n.moduleReference.expression
+                        : ts.isImportTypeNode(n) && ts.isLiteralTypeNode(n.argument) ? n.argument.literal
+                            : ts.isCallExpression(n) ? n.arguments[0] : undefined;
+                if (esp)
+                    literais?.set(esp, chave);
+            }
             ts.forEachChild(n, coletar);
         };
         coletar(raiz);
@@ -597,13 +621,15 @@ function extrairTypeScript(e, ts) {
     const divergentesGlobais = new Set();
     // KG4 (D3): por fonte, os caminhos a que as referencias de modulo resolvem e as bases das relativas.
     const dependenciasDe = new Map(), sondasDe = new Map();
+    const citacoesDe = new Map();
     for (const fonte of e.fontes) {
         const sf = programa.getSourceFile(absoluto(fonte.path));
         if (!sf || sf.fileName !== absoluto(fonte.path))
             continue;
         const ext = extensao(fonte.path), mapa = new Map();
         const dependencias = new Set(), sondas = new Set();
-        for (const chave of especificadoresEm(sf)) {
+        const literaisDeModulo = new Map();
+        for (const chave of especificadoresEm(sf, literaisDeModulo)) {
             if (mapa.has(chave))
                 continue;
             const esp = especificadorDaChave(chave), doCompilador = resolver(esp, fonte.path);
@@ -632,6 +658,46 @@ function extrairTypeScript(e, ts) {
             if (divergente)
                 divergentesGlobais.add(`${fonte.path}\u0000${chave}`);
         }
+        // Strings so em testes/scripts. Comentarios, interpolacoes e concatenacoes nao sao avaliados.
+        const citacoes = [];
+        if (/(?:^|\/)(?:tests?|__tests__|scripts?)\/|\.(?:test|spec)\.[cm]?[jt]sx?$/.test(fonte.path)) {
+            const citar = (literal, n, modulo = false) => {
+                const base = (0, intelligence_graph_extract_md_1.caminhoDaCitacao)(fonte.path, literal, modulo);
+                if (base === null)
+                    return;
+                const grupos = candidatosDaCitacao(base);
+                // Inclui ausentes e diretorios: a troca para arquivo invalida a unidade incremental.
+                // So arquivos presentes podem virar alvo; diretorios conservam apenas a sonda.
+                for (const grupo of grupos)
+                    for (const p of grupo)
+                        sondas.add(p);
+                for (const grupo of grupos) {
+                    const presentes = grupo.filter((p) => arquivos.has(p));
+                    if (!presentes.length)
+                        continue;
+                    if (presentes.length === 1 && presentes[0] !== fonte.path) {
+                        dependencias.add(presentes[0]);
+                        citacoes.push({ alvo: presentes[0], trecho: { path: fonte.path, inicio: n.getStart(sf), fim: n.getEnd() } });
+                    }
+                    break; // Ambiguidade nao autoriza escolher uma fonte nem tentar outro grupo.
+                }
+            };
+            const literais = (n) => {
+                if (ts.isStringLiteral(n) || ts.isNoSubstitutionTemplateLiteral(n)) {
+                    const chave = literaisDeModulo.get(n);
+                    // O resolver de import ja provou esta ocorrencia; outra string igual ainda pode citar.
+                    if (chave !== undefined && mapa.get(chave)?.alvo != null)
+                        return;
+                    citar(n.text, n, chave !== undefined);
+                    // Codigo citado por fixture: so argumentos literais de require/import dentro da string.
+                    for (const m of n.text.matchAll(/\b(?:require|import)\s*\(\s*(['"])([^'"\r\n]+)\1\s*\)/g))
+                        citar(m[2], n, true);
+                }
+                ts.forEachChild(n, literais);
+            };
+            literais(sf);
+        }
+        citacoesDe.set(fonte.path, citacoes);
         // O que o TypeScript coleta e a varredura nao ve (tipo importado no JSDoc) tambem liga o checker a outro arquivo.
         for (const nome of nomesDeModulo(sf)) {
             sondar(baseDaSonda(fonte.path, nome), sondas);
@@ -739,6 +805,8 @@ function extrairTypeScript(e, ts) {
         const aresta = (kind, from, to, t) => {
             saida.arestas.push({ kind, from, to, extrator: e.extrator, metodo: 'ast', trecho: t });
         };
+        for (const c of citacoesDe.get(fonte.path) ?? [])
+            aresta('cites', arquivo, { kind: 'file', path: c.alvo, fragment: null }, c.trecho);
         const lacuna = (categoria, n, detalhe = null) => {
             saida.lacunas.push({ categoria, path: fonte.path, inicio: n ? n.getStart(sf) : null, detalhe });
         };