@orkastery/cli 0.2.0

package/dist/util.js

@@ -0,0 +1,156 @@
+"use strict";
+/** Utilitarios compartilhados: execucao de processo, arquivos e formatacao do CLI. */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exec = exec;
+exports.noPath = noPath;
+exports.subirAte = subirAte;
+exports.gravar = gravar;
+exports.lerJson = lerJson;
+exports.gravarJson = gravarJson;
+exports.lerJsonl = lerJsonl;
+exports.anexarJsonl = anexarJsonl;
+exports.proximoIdSequencial = proximoIdSequencial;
+exports.agora = agora;
+exports.simbolo = simbolo;
+exports.tabela = tabela;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+/** Executa um comando capturando saida, sem shell (argumentos vao como array). */
+function exec(cmd, args, cwd, timeoutMs = 120000) {
+    const r = (0, node_child_process_1.spawnSync)(cmd, args, {
+        cwd,
+        encoding: 'utf8',
+        timeout: timeoutMs,
+        env: process.env,
+    });
+    return {
+        ok: r.status === 0,
+        code: r.status ?? -1,
+        stdout: (r.stdout ?? '').toString(),
+        stderr: (r.stderr ?? '').toString(),
+    };
+}
+/** O binario esta no PATH? */
+function noPath(bin) {
+    const r = exec('which', [bin]);
+    return r.ok ? r.stdout.trim() : null;
+}
+/** Sobe a arvore de diretorios procurando um arquivo. Retorna o diretorio que o contem. */
+function subirAte(dirInicial, arquivo) {
+    let dir = path.resolve(dirInicial);
+    for (;;) {
+        if (fs.existsSync(path.join(dir, arquivo)))
+            return dir;
+        const pai = path.dirname(dir);
+        if (pai === dir)
+            return null;
+        dir = pai;
+    }
+}
+/** Grava um arquivo criando os diretorios que faltarem. */
+function gravar(destino, conteudo) {
+    fs.mkdirSync(path.dirname(destino), { recursive: true });
+    fs.writeFileSync(destino, conteudo, 'utf8');
+}
+/** Le JSON tipado, com erro claro quando o arquivo esta corrompido. */
+function lerJson(caminho) {
+    const bruto = fs.readFileSync(caminho, 'utf8');
+    try {
+        return JSON.parse(bruto);
+    }
+    catch (e) {
+        throw new Error(`JSON invalido em ${caminho}: ${e.message}`);
+    }
+}
+/** Grava JSON identado e com quebra de linha final. */
+function gravarJson(caminho, valor) {
+    gravar(caminho, JSON.stringify(valor, null, 2) + '\n');
+}
+/**
+ * Le um armazem JSONL append-only em que a ULTIMA gravacao de um id vence.
+ *
+ * E o formato de `claims.jsonl` (bloco B1) e do board de divida (bloco B5): a correcao nao
+ * apaga a linha errada, ela grava a versao nova por cima. Linha corrompida e ignorada sem
+ * invalidar as demais, porque um caractere quebrado no meio do arquivo nao pode apagar o
+ * historico inteiro. A ordenacao e numerica por id (`C2` antes de `C10`).
+ */
+function lerJsonl(caminho) {
+    if (!fs.existsSync(caminho))
+        return [];
+    const porId = new Map();
+    for (const linha of fs.readFileSync(caminho, 'utf8').split('\n')) {
+        if (linha.trim() === '')
+            continue;
+        try {
+            const item = JSON.parse(linha);
+            porId.set(item.id, item);
+        }
+        catch {
+            /* linha corrompida nao invalida as demais */
+        }
+    }
+    return [...porId.values()].sort((a, b) => a.id.localeCompare(b.id, 'en', { numeric: true }));
+}
+/** Anexa um registro ao armazem JSONL, criando o diretorio que faltar. */
+function anexarJsonl(caminho, valor) {
+    fs.mkdirSync(path.dirname(caminho), { recursive: true });
+    fs.appendFileSync(caminho, JSON.stringify(valor) + '\n', 'utf8');
+}
+/** Proximo id sequencial de um armazem (`C1`, `C2`, ... / `F1`, `F2`, ...). */
+function proximoIdSequencial(ids, prefixo) {
+    const regex = new RegExp(`^${prefixo}(\\d+)$`);
+    const maior = ids.reduce((max, id) => Math.max(max, Number((id.match(regex) ?? [])[1] ?? 0)), 0);
+    return `${prefixo}${maior + 1}`;
+}
+/** Carimbo de tempo ISO usado em todo o estado em disco. */
+function agora() {
+    return new Date().toISOString();
+}
+const SIMBOLOS = { ok: '[ok]  ', warn: '[warn]', fail: '[FAIL]' };
+/** Prefixo de nivel usado por `ork doctor` e demais saidas. */
+function simbolo(nivel) {
+    return SIMBOLOS[nivel];
+}
+/** Monta uma tabela de largura fixa a partir de cabecalho e linhas. */
+function tabela(cabecalho, linhas) {
+    const larguras = cabecalho.map((c, i) => Math.max(c.length, ...linhas.map((l) => (l[i] ?? '').length)));
+    const formatar = (cols) => '  ' + cols.map((c, i) => (c ?? '').padEnd(larguras[i])).join('  ').trimEnd();
+    const saida = [formatar(cabecalho), '  ' + larguras.map((w) => '-'.repeat(w)).join('  ')];
+    for (const l of linhas)
+        saida.push(formatar(l));
+    return saida.join('\n');
+}

package/dist/verify.js

@@ -0,0 +1,262 @@
+"use strict";
+/**
+ * `ork verify` e `ork verify --baseline` (bloco B1).
+ *
+ * Duas verdades diferentes, ambas reexecutadas no HEAD REAL, nunca lidas de relatorio:
+ *
+ *   1. CLAIMS: cada alegacao registrada tem o seu comando reexecutado agora. Passou =
+ *      `verificado: sim`. Falhou = `claims.failed`. Alegacao negativa sem comando
+ *      tambem reprova: e o caso EvoJ6, em que a frase absoluta falsa passou batido.
+ *   2. BASELINE: os comandos de `verify:` do manifesto rodam antes do GO e ficam
+ *      gravados. No CHECK eles rodam de novo, e a diferenca separa REGRESSAO (passava e
+ *      agora falha) de DIVIDA PRE-EXISTENTE (ja falhava). Sem baseline, a falha e
+ *      declarada como `verify.failed`, e nao como regressao que nao da para provar.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIMEOUT_VERIFY_MS = void 0;
+exports.executar = executar;
+exports.comandosDoManifesto = comandosDoManifesto;
+exports.cwdDaThread = cwdDaThread;
+exports.commitReal = commitReal;
+exports.gravarBaseline = gravarBaseline;
+exports.verificarClaim = verificarClaim;
+exports.verificar = verificar;
+exports.textoDoVerify = textoDoVerify;
+const claims_1 = require("./claims");
+const gates_1 = require("./gates");
+const ledger_1 = require("./ledger");
+const thread_1 = require("./thread");
+const util_1 = require("./util");
+/** Teto de tempo de um comando de verificacao (build e suite completa cabem). */
+exports.TIMEOUT_VERIFY_MS = 10 * 60 * 1000;
+/** Ultimas linhas da saida real, o suficiente para servir de evidencia no ledger. */
+function resumirSaida(stdout, stderr) {
+    const bruto = (stdout + (stderr ? '\n' + stderr : '')).trim();
+    const linhas = bruto.split('\n').filter((l) => l.trim() !== '');
+    return linhas.slice(-10).join('\n').slice(-800);
+}
+/** Executa um comando de verificacao pelo shell, no diretorio de trabalho da thread. */
+function executar(nome, comando, cwd) {
+    const r = (0, util_1.exec)('bash', ['-c', comando], cwd, exports.TIMEOUT_VERIFY_MS);
+    return {
+        nome,
+        comando,
+        ok: r.ok,
+        code: r.code,
+        resumo: resumirSaida(r.stdout, r.stderr),
+    };
+}
+/** Comandos declarados em `verify:` no manifesto, na ordem canonica. */
+function comandosDoManifesto(manifesto) {
+    const lista = [];
+    for (const nome of ['typecheck', 'build', 'test']) {
+        const comando = manifesto.verify[nome];
+        if (comando && comando.trim() !== '')
+            lista.push({ nome, comando });
+    }
+    return lista;
+}
+/** Diretorio onde a verificacao roda: a worktree da thread, ou a raiz do projeto. */
+function cwdDaThread(raiz, thread) {
+    return thread.worktree ?? raiz;
+}
+/** HEAD real do diretorio de trabalho, carimbado em toda verificacao. */
+function commitReal(cwd) {
+    const r = (0, util_1.exec)('git', ['rev-parse', 'HEAD'], cwd);
+    return r.ok ? r.stdout.trim() : 'desconhecido';
+}
+/** `ork verify --baseline`: grava o estado do mundo ANTES do GO. */
+function gravarBaseline(carregado, threadId) {
+    const { raiz, manifesto } = carregado;
+    const thread = (0, thread_1.lerThread)(raiz, threadId);
+    const cwd = cwdDaThread(raiz, thread);
+    const comandos = comandosDoManifesto(manifesto).map((c) => executar(c.nome, c.comando, cwd));
+    const baseline = { commit: commitReal(cwd), gravadaEm: (0, util_1.agora)(), comandos };
+    thread.baseline = baseline;
+    (0, thread_1.gravarThread)(raiz, thread);
+    (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.baselineGravada, {
+        commit: baseline.commit,
+        cwd,
+        comandos: comandos.map((c) => ({ nome: c.nome, comando: c.comando, ok: c.ok, code: c.code })),
+        fonte: 'execucao real no HEAD, nao relatorio de fase',
+    });
+    return baseline;
+}
+/**
+ * Reexecuta a claim no HEAD real e devolve o veredito com o motivo tipado.
+ *
+ * Exportada para o bloco B5: as claims dos ACHADOS de auditoria passam por este mesmo
+ * julgamento, sem uma segunda regra paralela que pudesse ser mais frouxa.
+ */
+function verificarClaim(claim, cwd) {
+    if (claim.verificar.length === 0) {
+        const negativa = claim.negativa;
+        return {
+            claim,
+            verificado: false,
+            // Alegacao negativa sem comando e reprovacao (caso EvoJ6); positiva e aviso.
+            motivo: negativa ? 'claims.failed' : 'claims.unverifiable',
+            detalhe: negativa
+                ? 'alegacao negativa/absoluta sem comando de verificacao: nao ha como comprova-la'
+                : 'sem comando de verificacao declarado',
+            execucoes: [],
+        };
+    }
+    const execucoes = claim.verificar.map((c, i) => executar(`${claim.id}.${i + 1}`, c, cwd));
+    const falhou = execucoes.find((e) => !e.ok);
+    return {
+        claim,
+        verificado: !falhou,
+        motivo: falhou ? 'claims.failed' : null,
+        detalhe: falhou
+            ? `comando "${falhou.comando}" saiu com codigo ${falhou.code}`
+            : `${execucoes.length} comando(s) reexecutado(s) com sucesso`,
+        execucoes,
+    };
+}
+/**
+ * `ork verify`: reexecuta claims e comandos do manifesto e classifica cada falha.
+ * Nao decide pausa, decide VERDADE: quem pausa e o gate do modo de conducao.
+ */
+function verificar(carregado, threadId, opcoes = {}) {
+    const { raiz, manifesto } = carregado;
+    const thread = (0, thread_1.lerThread)(raiz, threadId);
+    const cwd = cwdDaThread(raiz, thread);
+    const commit = commitReal(cwd);
+    const dir = (0, thread_1.dirThread)(raiz, threadId);
+    // Claim retirada sai do gate: o historico guarda a alegacao e o motivo da retirada.
+    const claims = (0, claims_1.lerClaims)(raiz, threadId)
+        .filter((c) => c.estado !== 'retirada')
+        .map((c) => verificarClaim(c, cwd));
+    for (const r of claims) {
+        const estado = r.verificado
+            ? 'verificado'
+            : r.motivo === 'claims.unverifiable'
+                ? 'nao-verificavel'
+                : 'reprovado';
+        if (r.claim.estado !== estado)
+            (0, claims_1.carimbarEstado)(raiz, r.claim, estado);
+    }
+    const comandos = opcoes.soClaims
+        ? []
+        : comandosDoManifesto(manifesto).map((c) => executar(c.nome, c.comando, cwd));
+    const baseline = thread.baseline ?? null;
+    const regressoes = [];
+    const preExistentes = [];
+    const falhasSemBaseline = [];
+    for (const atual of comandos) {
+        if (atual.ok)
+            continue;
+        const antes = baseline?.comandos.find((c) => c.nome === atual.nome);
+        if (!antes)
+            falhasSemBaseline.push(atual);
+        else if (antes.ok)
+            regressoes.push(atual);
+        else
+            preExistentes.push(atual);
+    }
+    const motivos = [];
+    if (claims.some((c) => c.motivo === 'claims.failed'))
+        motivos.push('claims.failed');
+    if (claims.some((c) => c.motivo === 'claims.unverifiable'))
+        motivos.push('claims.unverifiable');
+    if (regressoes.length > 0)
+        motivos.push('verify.regression');
+    if (falhasSemBaseline.length > 0)
+        motivos.push('verify.failed');
+    const bloqueantes = motivos.filter((m) => m !== 'claims.unverifiable');
+    const ok = bloqueantes.length === 0;
+    (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.verificacao, {
+        commit,
+        cwd,
+        claims: claims.map((c) => ({
+            id: c.claim.id,
+            verificado: c.verificado,
+            motivo: c.motivo,
+            detalhe: c.detalhe,
+        })),
+        comandos: comandos.map((c) => ({ nome: c.nome, ok: c.ok, code: c.code })),
+        baseline: baseline ? { commit: baseline.commit, gravadaEm: baseline.gravadaEm } : null,
+        regressoes: regressoes.map((r) => r.nome),
+        preExistentes: preExistentes.map((r) => r.nome),
+        falhasSemBaseline: falhasSemBaseline.map((r) => r.nome),
+        motivos,
+        veredito: ok ? 'verdade sustentada' : 'reprovado',
+    });
+    for (const motivo of bloqueantes) {
+        (0, gates_1.registrarGateBloqueado)(dir, threadId, {
+            gate: 'verify',
+            motivo,
+            modo: thread.modo,
+            detalhe: motivo === 'claims.failed'
+                ? claims
+                    .filter((c) => c.motivo === 'claims.failed')
+                    .map((c) => `${c.claim.id}: ${c.detalhe}`)
+                    .join('; ')
+                : motivo === 'verify.regression'
+                    ? `regressao em: ${regressoes.map((r) => r.nome).join(', ')}`
+                    : `falha sem baseline em: ${falhasSemBaseline.map((r) => r.nome).join(', ')}`,
+            evidencia: `reexecucao no HEAD ${commit} em ${cwd}`,
+            correcao: motivo === 'claims.failed'
+                ? 'corrija o artefato ou a alegacao e rode `ork verify` de novo'
+                : 'corrija a regressao, ou grave a baseline antes do GO com `ork verify <thread> --baseline`',
+        });
+    }
+    return {
+        thread: threadId,
+        commit,
+        cwd,
+        claims,
+        comandos,
+        baseline,
+        regressoes,
+        preExistentes,
+        falhasSemBaseline,
+        motivos,
+        ok,
+    };
+}
+/** Texto de `ork verify`. */
+function textoDoVerify(r) {
+    const linhas = [];
+    linhas.push(`ork verify da thread ${r.thread}`);
+    linhas.push(`  HEAD real   ${r.commit}`);
+    linhas.push(`  diretorio   ${r.cwd}`);
+    linhas.push(`  baseline    ${r.baseline ? `${r.baseline.commit.slice(0, 8)} de ${r.baseline.gravadaEm}` : '(nao gravada: falha nao pode ser chamada de regressao)'}`);
+    linhas.push('');
+    linhas.push('Claims reexecutadas no HEAD real:');
+    if (r.claims.length === 0) {
+        linhas.push('  (nenhuma claim registrada nesta thread)');
+    }
+    for (const c of r.claims) {
+        linhas.push(`  ${c.claim.id}  verificado: ${c.verificado ? 'sim' : 'NAO'}  ${c.claim.alegacao}`);
+        linhas.push(`      arquivo: ${c.claim.arquivo}`);
+        linhas.push(`      ${c.claim.verificar.length > 0 ? `comando(s): ${c.claim.verificar.join(' && ')}` : 'sem comando de verificacao'}`);
+        if (!c.verificado)
+            linhas.push(`      motivo tipado: ${c.motivo} (${c.detalhe})`);
+    }
+    if (r.comandos.length > 0) {
+        linhas.push('');
+        linhas.push('Comandos de verify do manifesto:');
+        for (const c of r.comandos) {
+            linhas.push(`  ${c.nome.padEnd(10)} ${c.ok ? 'ok' : `FALHOU (codigo ${c.code})`}  ${c.comando}`);
+        }
+    }
+    if (r.regressoes.length > 0 || r.preExistentes.length > 0 || r.falhasSemBaseline.length > 0) {
+        linhas.push('');
+        linhas.push(`Classificacao: ${r.regressoes.length} regressao(oes), ` +
+            `${r.preExistentes.length} pre-existente(s), ` +
+            `${r.falhasSemBaseline.length} falha(s) sem baseline`);
+        for (const c of r.regressoes)
+            linhas.push(`  regressao      ${c.nome}: ${c.comando}`);
+        for (const c of r.preExistentes)
+            linhas.push(`  pre-existente  ${c.nome}: ${c.comando}`);
+        for (const c of r.falhasSemBaseline)
+            linhas.push(`  sem baseline   ${c.nome}: ${c.comando}`);
+    }
+    linhas.push('');
+    linhas.push(r.ok
+        ? 'Veredito: VERDADE SUSTENTADA (nenhum motivo bloqueante).'
+        : `Veredito: REPROVADO. Motivos tipados: ${r.motivos.join(', ')}`);
+    return linhas.join('\n');
+}