@orkastery/cli 0.5.6 → 0.6.1

package/dist/decisao-autonoma.js

@@ -40,6 +40,7 @@ const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
 const modos_1 = require("./modos");
 const conducao_1 = require("./conducao");
+const locale_1 = require("./locale");
 exports.CONTRATO_DECISAO_AUTONOMA = 'ork.decisao-autonoma/v1';
 /**
  * A sessao de OUTRA thread que registra aqui tambem deixa rastro (S-3 do CHECK 3). So o par que o ledger
@@ -116,7 +117,7 @@ function rastroDaDecisao(e) {
 function registrarDecisao(raiz, threadId, entrada) {
     const t = (0, thread_1.lerThread)(raiz, threadId);
     if (t.status === 'fechada')
-        throw new Error('decisão informada: thread fechada não decide mais nada');
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.threadFechada);
     const quando = entrada.quando ?? new Date().toISOString();
     // I-43: thread em modo aposentado e lida para sempre, mas nao escreve pedido novo.
     const modo = (0, modos_1.exigirModoVivo)(t.modo);
@@ -131,17 +132,17 @@ function registrarDecisao(raiz, threadId, entrada) {
     // R1, camada 1: criterio que aponta para nada vale o mesmo que criterio ausente.
     const { resolve, detalhe } = (0, hitl_gates_1.resolverCriterio)(raiz, pedido);
     if (!resolve)
-        throw new Error(`decisão informada: critério não resolve (${detalhe})`);
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.criterioNaoResolve(detalhe));
     const rastro = { quemDecidiu: entrada.quemDecidiu, evidencia: entrada.evidencia, razao: entrada.razao ?? entrada.porque };
     // O registro confere os tres de novo; conferir aqui evita tomar o lock para recusar.
     (0, ledger_1.exigirRastroDeDecisaoAutonoma)(rastro);
     return (0, hitl_gates_1.comLockHitl)(raiz, t.id, () => {
         const agora = (0, thread_1.lerThread)(raiz, t.id), dir = (0, thread_1.dirThread)(raiz, t.id);
         if (agora.status === 'fechada' || agora.faseAtual !== pedido.fase)
-            throw new Error('decisão informada: a fase mudou enquanto ela era registrada');
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.faseMudou);
         if (entrada.reverte && !(0, ledger_1.lerLedger)(dir).some(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.decisaoAutonoma &&
             e.pedido?.id === entrada.reverte)) {
-            throw new Error('decisão informada: a decisão revertida não existe nesta thread');
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.revertidaNaoExiste);
         }
         const evento = (0, ledger_1.registrar)(dir, t.id, ledger_1.TIPOS_DE_EVENTO.decisaoAutonoma, {
             contratoDecisao: exports.CONTRATO_DECISAO_AUTONOMA, fase: pedido.fase, decisao: pedido.decidido, ...rastro,

package/dist/demo.js

@@ -51,11 +51,12 @@ const manifest_1 = require("./manifest");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
 const verify_1 = require("./verify");
+const locale_1 = require("./locale");
 const PROVA = "node -e \"process.exit(require('./soma').soma(2, 2) === 4 ? 0 : 1)\"";
 function git(dir, args) {
     const r = (0, util_1.exec)('git', args, dir);
     if (!r.ok)
-        throw new Error(`demo: git ${args[0]} falhou: ${r.stderr.trim().split('\n').pop() ?? ''}`);
+        throw new Error((0, locale_1.msg)().operacao.restante.demo.gitFalhou(args[0], r.stderr.trim().split('\n').pop() ?? ''));
 }
 function commit(dir, arquivo, conteudo, mensagem) {
     fs.writeFileSync(path.join(dir, arquivo), conteudo, 'utf8');
@@ -70,7 +71,7 @@ function executarDemo(opcoes = {}) {
     const diga = opcoes.escrever ?? (() => undefined);
     // Diretorio dado por quem roda: so vazio ou inexistente, e nunca e apagado no fim.
     if (opcoes.dir && fs.existsSync(opcoes.dir) && fs.readdirSync(opcoes.dir).length > 0) {
-        throw new Error(`demo: ${opcoes.dir} nao esta vazio; a demo cria o proprio repositorio`);
+        throw new Error((0, locale_1.msg)().operacao.restante.demo.dirNaoVazio(opcoes.dir));
     }
     const temporario = !opcoes.dir;
     const dir = opcoes.dir ? path.resolve(opcoes.dir) : fs.mkdtempSync(path.join(os.tmpdir(), 'ork-demo-'));
@@ -79,6 +80,7 @@ function executarDemo(opcoes = {}) {
     const publicarAntes = process.env.ORK_FABRICA_PUBLICAR;
     process.env.ORK_FABRICA_PUBLICAR = '0';
     try {
+        const m = (0, locale_1.msg)().operacao.restante.demo;
         git(dir, ['init', '-q', '-b', 'main']);
         git(dir, ['config', 'user.name', 'ork demo']);
         git(dir, ['config', 'user.email', 'demo@orkastery.local']);
@@ -87,26 +89,26 @@ function executarDemo(opcoes = {}) {
         (0, init_1.init)(dir, { nome: 'demo', abbrev: 'dmo' });
         const carregado = (0, manifest_1.exigirManifesto)(dir);
         const { thread } = (0, thread_1.novaThread)(carregado, { nome: 'demo', modo: 'auto' });
-        diga('ork demo: a afirmacao do agente contra a prova');
+        diga(m.titulo);
         diga('');
-        diga('  1. O agente entrega soma.js e diz: "soma(2, 2) devolve 4. Pronto."');
+        diga(m.passo1);
         (0, claims_1.adicionarClaim)(dir, thread.id, { arquivo: 'soma.js', alegacao: 'soma(2, 2) devolve 4', verificar: [PROVA] });
-        diga('  2. O ork nao aceita relato: reexecuta a prova no commit real.');
+        diga(m.passo2);
         diga(`       ${PROVA}`);
         const antes = (0, verify_1.verificar)(carregado, thread.id, { soClaims: true });
-        diga(`     Veredito: ${antes.ok ? 'VERDADE SUSTENTADA' : `REPROVADO (${antes.motivos.join(', ')})`}. A funcao faz a - b.`);
-        diga('  3. O agente corrige soma.js e faz commit.');
+        diga(m.vereditoAntes(antes.ok, antes.motivos.join(', ')));
+        diga(m.passo3);
         commit(dir, 'soma.js', '// Soma dois numeros.\nexports.soma = (a, b) => a + b;\n', 'corrige a soma');
-        diga('  4. O ork reexecuta a MESMA prova no commit novo.');
+        diga(m.passo4);
         const depois = (0, verify_1.verificar)(carregado, thread.id, { soClaims: true });
-        diga(`     Veredito: ${depois.ok ? 'VERDADE SUSTENTADA' : `REPROVADO (${depois.motivos.join(', ')})`}.`);
+        diga(m.vereditoDepois(depois.ok, depois.motivos.join(', ')));
         diga('');
-        diga('Nenhuma afirmacao vale sem o comando que a julga, reexecutado no commit real.');
-        diga('No seu projeto: ork init, depois ork thread new "<pedido>" --modo auto.');
+        diga(m.principio);
+        diga(m.proximo);
         const ok = !antes.ok && antes.motivos.includes('claims.failed') && depois.ok;
         const mantido = !temporario || opcoes.manter === true;
         if (mantido)
-            diga(`(o repositorio da demo ficou em ${dir})`);
+            diga(m.mantido(dir));
         return { dir, antes, depois, ok, mantido };
     }
     finally {

package/dist/dependencias-da-worktree.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRAZO_DAS_DEPENDENCIAS_MS = void 0;
+exports.prepararDependencias = prepararDependencias;
+exports.eventoDoPreparo = eventoDoPreparo;
+exports.ultimaLinhaDoPreparo = ultimaLinhaDoPreparo;
+/** O preparo que passa disto (a rede lenta, o cache vazio) estoura, e a worktree fica como o git a deixou. */
+exports.PRAZO_DAS_DEPENDENCIAS_MS = 10 * 60 * 1000;
+/** Roda `comando` dentro de `dir`, a worktree que acabou de nascer. */
+function prepararDependencias(dir, comando, prazoMs = exports.PRAZO_DAS_DEPENDENCIAS_MS, executor) {
+    // Carregado na hora: o verify importa o modulo das threads, que importa este.
+    const { executar } = require('./verify');
+    const r = executor ? executor('dependencias', comando, dir) : executar('dependencias', comando, dir, prazoMs);
+    return { comando, ok: r.ok, code: r.code, causa: r.causa ?? null, prazoMs, duracaoMs: r.duracaoMs ?? 0,
+        trecho: r.ok ? '' : (r.trecho ?? r.resumo) };
+}
+/** O evento `worktree_dependencias` do ledger da thread. */
+function eventoDoPreparo(dir, p) {
+    return { dir, comando: p.comando, ok: p.ok, code: p.code, causa: p.causa, prazoMs: p.prazoMs, duracaoMs: p.duracaoMs,
+        ...(p.ok ? {} : { trecho: p.trecho }), fonte: 'worktree.dependencias do manifesto' };
+}
+/** A ultima linha util da saida de quem falhou, para caber na linha do aviso. */
+function ultimaLinhaDoPreparo(p) {
+    return p.trecho.split('\n').map((l) => l.trim()).filter(Boolean).at(-1)?.slice(0, 240) ?? '';
+}

package/dist/divida.js

@@ -73,6 +73,7 @@ const claims_1 = require("./claims");
 const manifest_1 = require("./manifest");
 const auditoria_1 = require("./auditoria");
 const util_1 = require("./util");
+const locale_1 = require("./locale");
 /** Diretorio do board de divida do projeto. */
 function dirDivida(raiz) {
     return path.join((0, manifest_1.dirEstado)(raiz), 'divida');
@@ -97,7 +98,7 @@ function gravarAchado(raiz, achado) {
 function exigirAchado(raiz, id) {
     const achado = lerBoard(raiz).find((a) => a.id === id.toUpperCase());
     if (!achado) {
-        throw new Error(`achado "${id}" nao existe no board de divida (${caminhoBoard(raiz)}). Veja: ork audit divida`);
+        throw new Error((0, locale_1.msg)().thread.fromFinding.achadoNaoExiste(id, caminhoBoard(raiz)));
     }
     return achado;
 }
@@ -289,14 +290,13 @@ function parseEstadoDeAchado(bruto) {
 }
 /** Tabela de `ork audit divida`. */
 function tabelaDaDivida(raiz, filtro = {}) {
+    const m = (0, locale_1.msg)().audit.divida;
     const board = lerBoard(raiz);
     const alvo = board
         .filter((a) => (filtro.pack ? a.pack === filtro.pack : true))
         .filter((a) => (filtro.todos ? true : a.estado !== 'descartado' && a.estado !== 'resolvido'));
     if (alvo.length === 0) {
-        return ('Board de divida vazio' +
-            (filtro.pack ? ` para o pack ${filtro.pack}` : '') +
-            `.\nRode uma auditoria: ork audit run <pack>`);
+        return m.vazia(filtro.pack);
     }
     const linhas = alvo.map((a) => [
         a.id,
@@ -306,42 +306,43 @@ function tabelaDaDivida(raiz, filtro = {}) {
         a.claim.estado,
         a.estado,
         a.proposta.estimativa,
-        a.proposta.passoIrreversivel.toLowerCase() === 'nenhum' ? 'nao' : 'SIM',
+        a.proposta.passoIrreversivel.toLowerCase() === 'nenhum' ? m.nao : m.sim,
         `${a.arquivo}${a.linha !== null ? ':' + a.linha : ''}`,
         a.titulo,
     ]);
-    const corpo = (0, util_1.tabela)(['ID', 'PACK', 'REGRA', 'SEVERIDADE', 'CLAIM', 'ESTADO', 'ESTIMATIVA', 'IRREVERSIVEL', 'EVIDENCIA', 'TITULO'], linhas);
+    const corpo = (0, util_1.tabela)([...m.cabecalho], linhas);
     const rec = recorrencias(alvo).filter((r) => r.ocorrencias > 1);
     const linhasRec = rec.length === 0
-        ? ['  (nenhuma regra recorrente ainda)']
-        : rec.map((r) => `  ${r.pack} ${r.regra}: ${r.ocorrencias}x -> promocao proposta: ${r.promocaoProposta} (${r.achados.join(', ')})`);
+        ? [m.nenhuma]
+        : rec.map((r) => m.item(r.pack, r.regra, r.ocorrencias, r.promocaoProposta, r.achados.join(', ')));
     return [
-        `Board de divida do projeto (${caminhoBoard(raiz)})`,
+        m.titulo(caminhoBoard(raiz)),
         '',
         corpo,
         '',
-        'Recorrencia (2 propoem controle, 3 propoem bloqueante; o `ork` nunca promove sozinho):',
+        m.recorrencia,
         ...linhasRec,
         '',
-        `abertos: ${abertos(alvo).length} | total listado: ${alvo.length}`,
-        'Achado vira thread com: ork thread new "<nome>" --from-finding <ID>',
+        m.resumo(abertos(alvo).length, alvo.length),
+        m.thread,
     ].join('\n');
 }
 /** Detalhe de um achado, usado pelo `--from-finding` e por `ork audit show`. */
 function textoDoAchado(a) {
+    const m = (0, locale_1.msg)().thread.fromFinding;
     const linhas = [];
-    linhas.push(`  ${a.id}  [${a.severidade}] ${a.pack}/${a.regra}  ${a.titulo}`);
-    linhas.push(`      evidencia   ${a.arquivo}${a.linha !== null ? ':' + a.linha : ''}`);
+    linhas.push(m.achadoCabecalho(a.id, a.severidade, a.pack, a.regra, a.titulo));
+    linhas.push(m.evidencia(`${a.arquivo}${a.linha !== null ? ':' + a.linha : ''}`));
     if (a.descricao)
-        linhas.push(`      descricao   ${a.descricao}`);
-    linhas.push(`      claim       ${a.claim.id} [${a.claim.estado}] ${a.claim.alegacao}`);
-    linhas.push(`      verificar   ${a.claim.verificar.join(' && ') || '(sem comando: o auditor nao comprovou o achado)'}`);
-    linhas.push(`      impacto     ${a.proposta.impacto}`);
-    linhas.push(`      fix         ${a.proposta.fix}`);
-    linhas.push(`      irreversivel ${a.proposta.passoIrreversivel}`);
-    linhas.push(`      estimativa  ${a.proposta.estimativa}`);
-    linhas.push(`      destino     ${a.proposta.destino} (regime ${a.proposta.regime})`);
-    linhas.push(`      estado      ${a.estado}${a.thread ? ` (thread ${a.thread})` : ''}`);
+        linhas.push(m.descricao(a.descricao));
+    linhas.push(m.claim(a.claim.id, a.claim.estado, a.claim.alegacao));
+    linhas.push(m.verificar(a.claim.verificar.join(' && ') || m.semComando));
+    linhas.push(m.impacto(a.proposta.impacto));
+    linhas.push(m.fix(a.proposta.fix));
+    linhas.push(m.irreversivel(a.proposta.passoIrreversivel));
+    linhas.push(m.estimativa(a.proposta.estimativa));
+    linhas.push(m.destino(a.proposta.destino, a.proposta.regime));
+    linhas.push(m.estado(a.estado, a.thread ?? null));
     return linhas.join('\n');
 }
 /**
@@ -351,23 +352,24 @@ function textoDoAchado(a) {
  * fix proposto, o passo irreversivel e a estimativa que o auditor levantou.
  */
 function pedidoDoAchado(a) {
+    const m = (0, locale_1.msg)().thread.fromFinding;
     return [
-        `Achado de auditoria ${a.id} (pack ${a.pack}, regra ${a.regra}, severidade ${a.severidade}).`,
+        m.pedidoCabecalho(a.id, a.pack, a.regra, a.severidade),
         '',
-        `Titulo: ${a.titulo}`,
-        `Evidencia: ${a.arquivo}${a.linha !== null ? ':' + a.linha : ''}`,
-        a.descricao ? `Descricao: ${a.descricao}` : '',
-        `Alegacao do auditor (claim ${a.claim.id}, estado ${a.claim.estado}): ${a.claim.alegacao}`,
-        `Como reexecutar a evidencia: ${a.claim.verificar.join(' && ') || '(nao declarado pelo auditor)'}`,
+        m.pedidoTitulo(a.titulo),
+        m.pedidoEvidencia(`${a.arquivo}${a.linha !== null ? ':' + a.linha : ''}`),
+        a.descricao ? m.pedidoDescricao(a.descricao) : '',
+        m.pedidoClaim(a.claim.id, a.claim.estado, a.claim.alegacao),
+        m.pedidoVerificar(a.claim.verificar.join(' && ') || m.naoDeclarado),
         '',
-        'Proposta de ajuste levantada pela rodada:',
-        `  impacto       ${a.proposta.impacto}`,
-        `  fix sugerido  ${a.proposta.fix}`,
-        `  irreversivel  ${a.proposta.passoIrreversivel}`,
-        `  estimativa    ${a.proposta.estimativa}`,
+        m.proposta,
+        m.propostaImpacto(a.proposta.impacto),
+        m.propostaFix(a.proposta.fix),
+        m.propostaIrreversivel(a.proposta.passoIrreversivel),
+        m.propostaEstimativa(a.proposta.estimativa),
         '',
-        `Origem: rodada ${a.rodada}, produto ${a.produto}, estagio ${a.estagio}, postura ${a.postura}.`,
-        'O fix acima e proposta do auditor, nao decisao: valide no GOAL antes de implementar.',
+        m.origem(a.rodada, a.produto, a.estagio, a.postura),
+        m.propostaNaoDecisao,
     ]
         .filter((l) => l !== '')
         .join('\n');