@orkastery/cli 0.4.3 → 0.5.0

package/dist/intelligence-graph-extract.js

@@ -0,0 +1,369 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textoAceito = exports.LACUNAS_SO_CONTAGEM = exports.EXTENSOES_MD = exports.EXTENSOES_TS = exports.CONFIG_SCHEMA = exports.RELATORIO_SCHEMA = exports.VERSAO_KG2 = exports.EXTRATOR_ARQUIVOS = exports.EXTRATOR_ID = exports.EXTRATOR_MD = exports.EXTRATOR_TS = void 0;
+exports.textoCurto = textoCurto;
+exports.extensaoDe = extensaoDe;
+exports.idDeBlob = idDeBlob;
+exports.decodificarUtf8 = decodificarUtf8;
+exports.extrairGrafo = extrairGrafo;
+/**
+ * RM-031 KG2 (D1, D7 a D10): extracao deterministica do grafo `ork.code-artifact-graph/v1`.
+ *
+ * Modulo puro: recebe os bytes das fontes e o compilador TypeScript por parametro (D1), sem abrir
+ * arquivo, rede ou processo. As fontes sao ordenadas antes de tudo e os IDs saem do contrato
+ * (`derivarIds`), entao a ordem de leitura nao muda o grafo nem o relatorio. O que nenhum extrator
+ * prova vira diagnostico do contrato ou lacuna do relatorio (D7), nunca aresta nem no fabricado.
+ */
+const node_crypto_1 = require("node:crypto");
+const intelligence_graph_contract_1 = require("./intelligence-graph-contract");
+const intelligence_graph_extract_md_1 = require("./intelligence-graph-extract-md");
+const intelligence_graph_extract_ts_1 = require("./intelligence-graph-extract-ts");
+exports.EXTRATOR_TS = 'ork.ts-ast';
+exports.EXTRATOR_MD = 'ork.md-structure';
+exports.EXTRATOR_ID = 'ork.id-mention';
+/** D9: declara o arquivo do manifesto que nenhum extrator leu. */
+exports.EXTRATOR_ARQUIVOS = 'ork.repo-files';
+/** Versao da regra de extracao; a do compilador entra no `extractor_version` do `ork.ts-ast`. */
+exports.VERSAO_KG2 = '1.0.0';
+exports.RELATORIO_SCHEMA = 'ork.graph-extraction-report/v0';
+exports.CONFIG_SCHEMA = 'ork.graph-extraction-config/v0';
+exports.EXTENSOES_TS = ['.cjs', '.cts', '.js', '.jsx', '.mjs', '.mts', '.ts', '.tsx'];
+exports.EXTENSOES_MD = ['.markdown', '.md'];
+/** D7: categorias de lacuna volumosas saem so na contagem; as demais saem tambem listadas. */
+exports.LACUNAS_SO_CONTAGEM = new Set([
+    'chamada-fora-de-simbolo', 'chamada-nao-resolvida', 'chamada-alvo-fora-do-grafo', 'chamada-por-tipo', 'import-sem-simbolo',
+    'id-sem-artefato', 'link-externo',
+]);
+function falha(codigo, onde) {
+    throw new Error(onde ? `${codigo} em ${onde}` : codigo);
+}
+/**
+ * Aninhamento extremo estoura a pilha do compilador ou do analisador (o binder do TypeScript e
+ * recursivo): a extracao falha inteira com erro tipado, nunca com grafo parcial (D10).
+ */
+function semEstouro(extrator, f) {
+    try {
+        return f();
+    }
+    catch (e) {
+        if (e instanceof RangeError && /call stack/i.test(e.message))
+            falha('extracao.limite.pilha', extrator);
+        throw e;
+    }
+}
+/**
+ * Replica da regra de texto do contrato (controles, marcas invisiveis, surrogate isolado), para o
+ * produtor descartar referencia que o contrato recusaria. O corpus do KG1 e a autoridade.
+ */
+const CONTROLE = /[\u0000-\u001f\u007f-\u009f\u00ad\u061c\u180e\u200b\u200e\u200f\u2028\u2029\u202a-\u202e\u2060-\u206f\ufeff\ufff9-\ufffb]/;
+const SURROGATE_ISOLADO = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+const textoAceito = (t) => !CONTROLE.test(t) && !SURROGATE_ISOLADO.test(t);
+exports.textoAceito = textoAceito;
+/** Texto curto que cabe em `reference` ou `fragment`; fora disso, `null` (nunca truncado). */
+function textoCurto(t) {
+    const limpo = t.trim();
+    return limpo.length >= 1 && limpo.length <= intelligence_graph_contract_1.GRAFO_LIMITES.fragmento && (0, exports.textoAceito)(limpo) ? limpo : null;
+}
+/** Extensao do nome do arquivo em minusculas (`.ts`); arquivo oculto sem ponto no meio nao tem. */
+function extensaoDe(caminho) {
+    const nome = caminho.slice(caminho.lastIndexOf('/') + 1), i = nome.lastIndexOf('.');
+    return i <= 0 ? '' : nome.slice(i).toLowerCase();
+}
+/** D8: id de blob do Git, calculado dos bytes; igual ao `git hash-object --no-filters` do arquivo. */
+function idDeBlob(bytes) {
+    return (0, node_crypto_1.createHash)('sha1').update(`blob ${bytes.length}\0`).update(bytes).digest('hex');
+}
+const sha256 = (b) => (0, node_crypto_1.createHash)('sha256').update(b).digest('hex');
+/** UTF-8 estrito, com o BOM preservado para os offsets baterem com os bytes. */
+function decodificarUtf8(bytes) {
+    try {
+        return new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch {
+        return null;
+    }
+}
+/** Converte offset UTF-16 do texto em offset de byte UTF-8 e em linha (1-based). */
+class MapaDoTexto {
+    texto;
+    tamanho;
+    bytes = null;
+    quebras = null;
+    constructor(texto, tamanho) {
+        this.texto = texto;
+        this.tamanho = tamanho;
+    }
+    byte(i) {
+        if (this.tamanho === this.texto.length)
+            return i;
+        if (!this.bytes) {
+            const t = this.texto, acc = new Uint32Array(t.length + 1);
+            for (let j = 0; j < t.length; j++) {
+                const c = t.charCodeAt(j);
+                // Par de surrogates e um code point de 4 bytes; o texto veio de UTF-8 valido, sem surrogate isolado.
+                if (c >= 0xd800 && c <= 0xdbff && j + 1 < t.length) {
+                    acc[j + 1] = acc[j] + 4;
+                    acc[j + 2] = acc[j + 1];
+                    j++;
+                    continue;
+                }
+                acc[j + 1] = acc[j] + (c < 0x80 ? 1 : c < 0x800 ? 2 : 3);
+            }
+            this.bytes = acc;
+        }
+        return this.bytes[i];
+    }
+    linha(i) {
+        if (!this.quebras) {
+            const q = [];
+            for (let j = this.texto.indexOf('\n'); j >= 0; j = this.texto.indexOf('\n', j + 1))
+                q.push(j);
+            this.quebras = q;
+        }
+        let baixo = 0, alto = this.quebras.length;
+        while (baixo < alto) {
+            const meio = (baixo + alto) >> 1;
+            if (this.quebras[meio] < i)
+                baixo = meio + 1;
+            else
+                alto = meio;
+        }
+        return baixo + 1;
+    }
+}
+const chaveDoNo = (r) => (0, intelligence_graph_contract_1.canonico)([r.kind, r.path, r.fragment]);
+const zeros = '0'.repeat(64);
+function contagemVazia(chaves) {
+    return Object.fromEntries(chaves.map((k) => [k, 0]));
+}
+/**
+ * Extrai o grafo das fontes fornecidas. Lanca `extracao.*` para entrada invalida ou teto do
+ * contrato estourado (D10), e `grafo.*` se o resultado violar o contrato (defeito do extrator).
+ */
+function extrairGrafo(entrada, parser) {
+    const { ts, unicode, markdown, javascript } = parser;
+    if (!/^[0-9]+(\.[0-9]+)*$/.test(unicode))
+        falha('extracao.entrada.unicode-invalido');
+    if (!/^[0-9A-Za-z][0-9A-Za-z.-]{0,40}$/.test(markdown.versao) || typeof markdown.analisar !== 'function'
+        || typeof markdown.referencia !== 'function')
+        falha('extracao.entrada.markdown-invalido');
+    if (!javascript || !/^node\.[0-9]+(\.[0-9]+)*$/.test(javascript.versao) || typeof javascript.sintaxe !== 'function') {
+        falha('extracao.entrada.javascript-invalido');
+    }
+    const acl = [...new Set(entrada.acl_refs)].sort(intelligence_graph_contract_1.compararUtf8);
+    const access = { tenant_id: entrada.tenant_id, acl_refs: acl };
+    const authority = `git:${entrada.repository_id}`;
+    const fontes = [...entrada.fontes].sort((a, b) => (0, intelligence_graph_contract_1.compararUtf8)(a.path, b.path));
+    for (let i = 1; i < fontes.length; i++)
+        if (fontes[i - 1].path === fontes[i].path)
+            falha('extracao.entrada.fonte-duplicada');
+    // O contrato recusa o grafo inteiro por um caminho ruim; aqui o caminho sai e fica declarado.
+    const excluidas = (entrada.excluidas ?? []).map((e) => ({ path: e.path, motivo: e.motivo }));
+    const validas = fontes.filter((f) => {
+        const ok = f.path.length <= intelligence_graph_contract_1.GRAFO_LIMITES.caminho && (0, intelligence_graph_contract_1.caminhoValido)(f.path);
+        if (!ok)
+            excluidas.push({ path: f.path, motivo: 'caminho-recusado' });
+        return ok;
+    });
+    const porNfc = new Map();
+    for (const f of validas)
+        porNfc.set(f.path.normalize('NFC'), (porNfc.get(f.path.normalize('NFC')) ?? 0) + 1);
+    const aceitas = validas.filter((f) => {
+        const ok = porNfc.get(f.path.normalize('NFC')) === 1;
+        if (!ok)
+            excluidas.push({ path: f.path, motivo: 'caminho-ambiguo' });
+        return ok;
+    });
+    if (aceitas.length === 0)
+        falha('extracao.entrada.sem-fontes');
+    if (aceitas.length > intelligence_graph_contract_1.GRAFO_LIMITES.manifesto)
+        falha('extracao.limite.manifesto');
+    const manifesto = new Map();
+    for (const f of aceitas) {
+        manifesto.set(f.path, {
+            path: f.path, authority, source_hash: sha256(f.bytes), source_version: idDeBlob(f.bytes), size_bytes: f.bytes.length, access,
+        });
+    }
+    const bytesDe = new Map(aceitas.map((f) => [f.path, f.bytes]));
+    const textos = new Map();
+    const texto = (p) => {
+        if (!textos.has(p)) {
+            const b = bytesDe.get(p);
+            textos.set(p, b ? decodificarUtf8(b) : null);
+        }
+        return textos.get(p) ?? undefined;
+    };
+    const achados = { nos: [], arestas: [], diagnosticos: [], lacunas: [] };
+    // Laco, nao `push(...lista)`: lista grande estouraria a pilha antes do teto tipado do contrato.
+    const juntar = (a) => {
+        for (const x of a.nos)
+            achados.nos.push(x);
+        for (const x of a.arestas)
+            achados.arestas.push(x);
+        for (const x of a.diagnosticos)
+            achados.diagnosticos.push(x);
+        for (const x of a.lacunas)
+            achados.lacunas.push(x);
+    };
+    const caminhos = aceitas.map((f) => f.path);
+    const fontesTs = [], fontesMd = [];
+    for (const p of caminhos) {
+        const ext = extensaoDe(p), ehTs = exports.EXTENSOES_TS.includes(ext), ehMd = exports.EXTENSOES_MD.includes(ext);
+        if (!ehTs && !ehMd) {
+            // D9: o arquivo vira no, e o diagnostico diz que o conteudo dele nao foi lido.
+            achados.diagnosticos.push({ kind: 'unsupported-language', path: p, reference: ext || null, extrator: exports.EXTRATOR_ARQUIVOS });
+            continue;
+        }
+        const t = texto(p);
+        if (t === undefined)
+            achados.lacunas.push({ categoria: 'utf8-invalido', path: p, inicio: null, detalhe: null });
+        else
+            (ehTs ? fontesTs : fontesMd).push({ path: p, texto: t });
+    }
+    const versaoTs = `${exports.VERSAO_KG2}+typescript.${ts.version}+${javascript.versao}`;
+    // B1: a raiz virtual do compilador deriva do manifesto; um caminho do repositorio nao a nomeia.
+    const raiz = `/ork-${(0, intelligence_graph_contract_1.sha256DoCanonico)([...manifesto.values()].map((m) => [m.path, m.source_hash])).slice(0, 32)}`;
+    const aceitaFragmento = (f) => f.length >= 1 && f.length <= intelligence_graph_contract_1.GRAFO_LIMITES.fragmento && (0, exports.textoAceito)(f);
+    juntar(semEstouro(exports.EXTRATOR_TS, () => (0, intelligence_graph_extract_ts_1.extrairTypeScript)({
+        fontes: fontesTs, arquivos: caminhos, texto, raiz, aceitaFragmento, sintaxe: javascript.sintaxe, extrator: exports.EXTRATOR_TS,
+    }, ts)));
+    // B4: chave `caminho#fragmento` como o frontmatter a escreve; duas refs na mesma chave ficam ambiguas.
+    const simbolos = new Map();
+    for (const r of achados.nos.filter((x) => x.kind === 'symbol')) {
+        const chave = `${r.path}#${r.fragment}`, antes = simbolos.get(chave);
+        simbolos.set(chave, antes === undefined || (antes && antes.path === r.path && antes.fragment === r.fragment) ? r : null);
+    }
+    juntar(semEstouro(exports.EXTRATOR_MD, () => (0, intelligence_graph_extract_md_1.extrairMarkdown)({
+        fontes: fontesMd, codigo: fontesTs, arquivos: caminhos, simbolos, aceitaFragmento, analisar: markdown.analisar,
+        referencia: markdown.referencia, extratorMd: exports.EXTRATOR_MD, extratorId: exports.EXTRATOR_ID,
+    })));
+    const extratores = [
+        { extractor_id: exports.EXTRATOR_ARQUIVOS, extractor_version: exports.VERSAO_KG2 },
+        { extractor_id: exports.EXTRATOR_ID, extractor_version: exports.VERSAO_KG2 },
+        { extractor_id: exports.EXTRATOR_MD, extractor_version: `${exports.VERSAO_KG2}+${markdown.versao}+unicode.${unicode}` },
+        { extractor_id: exports.EXTRATOR_TS, extractor_version: versaoTs },
+    ];
+    const versoes = new Map(extratores.map((e) => [e.extractor_id, e.extractor_version]));
+    const versaoDe = (id) => versoes.get(id) ?? falha('extracao.interna.extrator-desconhecido');
+    // Nos: todo arquivo do manifesto e os nos que os extratores provaram.
+    const nos = new Map();
+    for (const p of caminhos)
+        nos.set(chaveDoNo({ kind: 'file', path: p, fragment: null }), { kind: 'file', path: p, fragment: null });
+    for (const r of achados.nos) {
+        if (!manifesto.has(r.path))
+            falha('extracao.interna.no-sem-fonte');
+        if (r.fragment === null || !(0, exports.textoAceito)(r.fragment) || r.fragment.length > intelligence_graph_contract_1.GRAFO_LIMITES.fragmento)
+            falha('extracao.interna.fragmento');
+        nos.set(chaveDoNo(r), r);
+    }
+    if (nos.size > intelligence_graph_contract_1.GRAFO_LIMITES.nos)
+        falha('extracao.limite.nos');
+    const mapas = new Map();
+    const mapaDe = (p) => {
+        let m = mapas.get(p);
+        if (!m) {
+            const t = texto(p);
+            if (t === undefined)
+                falha('extracao.interna.trecho-sem-texto');
+            m = new MapaDoTexto(t, bytesDe.get(p).length);
+            mapas.set(p, m);
+        }
+        return m;
+    };
+    // D10: uma aresta por (tipo, origem, destino), com as evidencias ordenadas por posicao.
+    const arestas = new Map();
+    for (const a of achados.arestas) {
+        const kf = chaveDoNo(a.from), kt = chaveDoNo(a.to);
+        if (!nos.has(kf) || !nos.has(kt))
+            falha('extracao.interna.extremidade-ausente');
+        if (a.trecho.path !== a.from.path)
+            falha('extracao.interna.evidencia-fora-da-origem');
+        if (!(a.trecho.inicio < a.trecho.fim))
+            falha('extracao.interna.trecho-vazio');
+        const m = mapaDe(a.trecho.path), fonte = manifesto.get(a.trecho.path);
+        const e = {
+            snapshot_id: `snap-${zeros}`, path: fonte.path, source_hash: fonte.source_hash, source_version: fonte.source_version, authority,
+            extractor_id: a.extrator, extractor_version: versaoDe(a.extrator), extraction_method: a.metodo, confidence_class: intelligence_graph_contract_1.CLASSE_DE_CONFIANCA,
+            span: { type: 'text', byte_start: m.byte(a.trecho.inicio), byte_end: m.byte(a.trecho.fim), line_start: m.linha(a.trecho.inicio), line_end: m.linha(a.trecho.fim - 1) },
+            access,
+        };
+        const chave = `${a.kind}\u0000${kf}\u0000${kt}`;
+        let atual = arestas.get(chave);
+        if (!atual)
+            arestas.set(chave, (atual = { kind: a.kind, from: a.from, to: a.to, evidencias: new Map() }));
+        atual.evidencias.set((0, intelligence_graph_contract_1.canonico)(e), e);
+    }
+    if (arestas.size > intelligence_graph_contract_1.GRAFO_LIMITES.arestas)
+        falha('extracao.limite.arestas');
+    const idProvisorio = (r) => `node-${(0, intelligence_graph_contract_1.sha256DoCanonico)([r.kind, r.path, r.fragment])}`;
+    let excedentes = 0;
+    const edges = [...arestas.values()].map((a) => {
+        const evidencias = [...a.evidencias.values()].sort((x, y) => (x.span.byte_start - y.span.byte_start) || (x.span.byte_end - y.span.byte_end)
+            || (0, intelligence_graph_contract_1.compararUtf8)(x.extractor_id, y.extractor_id) || (0, intelligence_graph_contract_1.compararUtf8)(x.extraction_method, y.extraction_method));
+        excedentes += Math.max(0, evidencias.length - intelligence_graph_contract_1.GRAFO_LIMITES.evidenciasPorAresta);
+        return {
+            edge_id: `edge-${zeros}`, kind: a.kind, snapshot_id: `snap-${zeros}`, from: idProvisorio(a.from), to: idProvisorio(a.to),
+            evidence: evidencias.slice(0, intelligence_graph_contract_1.GRAFO_LIMITES.evidenciasPorAresta), access,
+        };
+    });
+    const diagnosticos = new Map();
+    for (const d of achados.diagnosticos) {
+        if (!manifesto.has(d.path))
+            falha('extracao.interna.diagnostico-sem-fonte');
+        const reference = d.reference === null ? null : textoCurto(d.reference);
+        const diag = { kind: d.kind, path: d.path, reference, extractor_id: d.extrator, extractor_version: versaoDe(d.extrator), access };
+        diagnosticos.set((0, intelligence_graph_contract_1.canonico)(diag), diag);
+    }
+    if (diagnosticos.size > intelligence_graph_contract_1.GRAFO_LIMITES.diagnosticos)
+        falha('extracao.limite.diagnosticos');
+    const config = {
+        schema: exports.CONFIG_SCHEMA, authority, acl_refs: acl, evidencias_por_aresta: intelligence_graph_contract_1.GRAFO_LIMITES.evidenciasPorAresta,
+        typescript: { extensoes: exports.EXTENSOES_TS, opcoes: intelligence_graph_extract_ts_1.OPCOES_TS_DESCRITAS },
+        markdown: {
+            extensoes: exports.EXTENSOES_MD, ancora: 'github-slug', artefato: intelligence_graph_extract_md_1.PADRAO_DE_ID.source, frontmatter: intelligence_graph_extract_md_1.CHAVES_DO_FRONTMATTER, sem_mencao: intelligence_graph_extract_md_1.TOKENS_SEM_MENCAO,
+        },
+    };
+    const rascunho = {
+        schema: intelligence_graph_contract_1.GRAFO_SCHEMA, tenant_id: entrada.tenant_id, repository_id: entrada.repository_id,
+        snapshot: {
+            snapshot_id: `snap-${zeros}`, revision: entrada.revision, revision_unavailable_reason: entrada.revision_unavailable_reason,
+            source_manifest: [...manifesto.values()], config_hash: (0, intelligence_graph_contract_1.sha256DoCanonico)(config), extractors: extratores, extractors_digest: zeros,
+        },
+        nodes: [...nos.values()].map((r) => ({
+            node_id: idProvisorio(r), kind: r.kind, snapshot_id: `snap-${zeros}`, locator: { path: r.path, fragment: r.fragment },
+            source_hash: manifesto.get(r.path).source_hash, access,
+        })),
+        edges,
+        diagnostics: [...diagnosticos.values()],
+    };
+    const grafo = (0, intelligence_graph_contract_1.validarGrafo)((0, intelligence_graph_contract_1.derivarIds)(rascunho));
+    const digest = (0, intelligence_graph_contract_1.sha256DoCanonico)(grafo);
+    const contagens = {
+        fontes: grafo.snapshot.source_manifest.length, nos: contagemVazia(intelligence_graph_contract_1.TIPOS_DE_NO), arestas: contagemVazia(intelligence_graph_contract_1.TIPOS_DE_ARESTA),
+        diagnosticos: contagemVazia(intelligence_graph_contract_1.TIPOS_DE_DIAGNOSTICO), evidencias: 0,
+    };
+    for (const n of grafo.nodes)
+        contagens.nos[n.kind]++;
+    for (const a of grafo.edges) {
+        contagens.arestas[a.kind]++;
+        contagens.evidencias += a.evidence.length;
+    }
+    for (const d of grafo.diagnostics)
+        contagens.diagnosticos[d.kind]++;
+    const porCategoria = new Map(), listadas = new Map();
+    for (const l of achados.lacunas) {
+        porCategoria.set(l.categoria, (porCategoria.get(l.categoria) ?? 0) + 1);
+        if (exports.LACUNAS_SO_CONTAGEM.has(l.categoria))
+            continue;
+        const linha = l.inicio === null || texto(l.path) === undefined ? null : mapaDe(l.path).linha(l.inicio);
+        const item = { categoria: l.categoria, path: l.path, linha, detalhe: l.detalhe };
+        listadas.set((0, intelligence_graph_contract_1.canonico)(item), item);
+    }
+    const relatorio = {
+        schema: exports.RELATORIO_SCHEMA, snapshot_id: grafo.snapshot.snapshot_id, graph_digest: digest, contagens, evidencias_excedentes: excedentes,
+        excluidas: [...new Map(excluidas.map((e) => [(0, intelligence_graph_contract_1.canonico)(e), e])).entries()].sort((a, b) => (0, intelligence_graph_contract_1.compararUtf8)(a[0], b[0])).map(([, e]) => e),
+        lacunas_por_categoria: Object.fromEntries([...porCategoria.entries()].sort((a, b) => (0, intelligence_graph_contract_1.compararUtf8)(a[0], b[0]))),
+        lacunas: [...listadas.entries()].sort((a, b) => (0, intelligence_graph_contract_1.compararUtf8)(a[0], b[0])).map(([, l]) => l),
+    };
+    return { grafo, digest, relatorio };
+}