@orkastery/cli 0.5.6 → 0.6.0

package/dist/setup.js

@@ -90,6 +90,7 @@ const manifest_1 = require("./manifest");
 const modos_1 = require("./modos");
 const runtimes_1 = require("./runtimes");
 const util_1 = require("./util");
+const locale_1 = require("./locale");
 exports.CONTRATO_DO_SETUP = 'ork.setup/v1';
 exports.NOME_SETUP = 'setup.json';
 /** I-52: o setup versionado, ao lado do `orkastery.yaml`. */
@@ -99,14 +100,14 @@ const MAX_INSTANTE_MS = 8_640_000_000_000_000;
 const CAMPOS_LIMITES = ['duracaoMs', 'maxChildren', 'maxDepth', 'maxRetries'];
 function objeto(valor, campo) {
     if (!valor || typeof valor !== 'object' || Array.isArray(valor)) {
-        throw new Error(`${campo} deve ser objeto`);
+        throw new Error((0, locale_1.msg)().setup.objeto(campo));
     }
     return valor;
 }
 function camposExatos(valor, campos, campo) {
     if (Object.keys(valor).length !== campos.length ||
         campos.some(c => !Object.hasOwn(valor, c))) {
-        throw new Error(`${campo} deve conter somente ${campos.join(', ')}`);
+        throw new Error((0, locale_1.msg)().setup.camposExatos(campo, campos.join(', ')));
     }
 }
 const ENTRADA_DE_FALLBACK = /^([a-z][a-z0-9-]*):([^\s:]+)(?::([a-z]+))?$/;
@@ -116,11 +117,11 @@ function validarFallback(lista, principal) {
     return lista.map((item) => {
         const m = ENTRADA_DE_FALLBACK.exec(item.trim());
         if (!m)
-            throw new Error(`fallback invalido: "${item}" (use runtime:modelo[:esforco], por exemplo codex:gpt-5.5)`);
+            throw new Error((0, locale_1.msg)().setup.fallbackInvalido(item));
         if (!(0, runtimes_1.runtimeConhecido)(m[1]))
-            throw new Error(`fallback com runtime desconhecido: "${m[1]}" (homologados: ${runtimes_1.ORDEM_DOS_RUNTIMES.join(', ')})`);
+            throw new Error((0, locale_1.msg)().setup.fallbackDesconhecido(m[1], runtimes_1.ORDEM_DOS_RUNTIMES.join(', ')));
         if (vistos.has(m[1]))
-            throw new Error(`fallback repete o runtime ${m[1]} (o runtime do bloco e cada fallback aparecem uma vez)`);
+            throw new Error((0, locale_1.msg)().setup.fallbackRepetido(m[1]));
         vistos.add(m[1]);
         return item.trim();
     });
@@ -164,7 +165,7 @@ function validarLimitesDeBloco(valor) {
         const n = limites[campo];
         if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < (campo === 'duracaoMs' ? 1 : 0) ||
             (campo === 'duracaoMs' && n > MAX_INSTANTE_MS)) {
-            throw new Error(`limites.${campo} deve ser inteiro ${campo === 'duracaoMs' ? 'positivo' : 'nao negativo'}, finito e representavel`);
+            throw new Error((0, locale_1.msg)().setup.limiteInvalido(campo, campo === 'duracaoMs'));
         }
     }
     return {
@@ -179,14 +180,14 @@ function validarConfigComLimites(config) {
     if (typeof config.runtime !== 'string' || !(0, runtimes_1.runtimeConhecido)(config.runtime) ||
         typeof config.model !== 'string' || config.model.trim() === '' ||
         typeof config.effort !== 'string' || config.effort.trim() === '') {
-        throw new Error('bloco com limites exige runtime conhecido, model e effort explicitos validos');
+        throw new Error((0, locale_1.msg)().setup.blocoComLimites);
     }
 }
 /** Valida tambem entradas que a normalizacao antiga descartaria. */
 function validarEstruturaSetup(valor) {
     const setup = objeto(valor, 'setup');
     if (setup.contrato !== undefined && setup.contrato !== exports.CONTRATO_DO_SETUP) {
-        throw new Error('contrato de setup incompativel');
+        throw new Error((0, locale_1.msg)().setup.contratoIncompativel);
     }
     if (setup.modos === undefined)
         return;
@@ -195,13 +196,13 @@ function validarEstruturaSetup(valor) {
         if (configModo.blocos === undefined)
             continue;
         if (!Array.isArray(configModo.blocos))
-            throw new Error(`blocos de ${modo} devem ser array`);
+            throw new Error((0, locale_1.msg)().setup.blocosArray(modo));
         for (const [i, valorBloco] of configModo.blocos.entries()) {
             const config = objeto(valorBloco, `bloco ${modo}/${i + 1}`);
             validarConfigComLimites(config);
             if (Object.hasOwn(config, 'limites') && (setup.contrato !== exports.CONTRATO_DO_SETUP ||
                 !modos_1.ORDEM_DOS_MODOS.includes(modo) || i >= modos_1.MODOS[modo].blocos.length)) {
-                throw new Error('limites exigem contrato e bloco de modo conhecidos');
+                throw new Error((0, locale_1.msg)().setup.limitesConhecidos);
             }
         }
     }
@@ -273,7 +274,7 @@ function lerSetup(raiz) {
         bruto = (0, util_1.lerJson)(caminho);
     }
     catch (e) {
-        throw new Error(`setup invalido (${caminho}): ${e.message}`);
+        throw new Error((0, locale_1.msg)().setup.setupInvalido(caminho, e.message));
     }
     validarEstruturaSetup(bruto);
     const modosBrutos = (bruto.modos ?? {});
@@ -324,7 +325,7 @@ function gravarSetup(raiz, setup) {
 function versionarSetup(raiz, por = 'owner') {
     const caminho = caminhoSetupVersionado(raiz);
     if (fs.existsSync(caminho))
-        throw new Error(`setup.versionado: ${exports.NOME_SETUP_VERSIONADO} ja existe neste checkout; edite com ork setup <modo> --bloco N`);
+        throw new Error((0, locale_1.msg)().setup.versionadoExiste(exports.NOME_SETUP_VERSIONADO));
     const origem = origemDoSetup(raiz);
     const setup = lerSetup(raiz);
     validarEstruturaSetup(setup);
@@ -358,12 +359,12 @@ function limitesDoBloco(manifesto, setup, modo, fase) {
     if (!Array.isArray(permitidos) || permitidos.length === 0 ||
         permitidos.some(m => !modos_1.ORDEM_DOS_MODOS.includes(m)) ||
         !permitidos.includes(modo)) {
-        throw new Error('playbook ativo exige modo permitido valido');
+        throw new Error((0, locale_1.msg)().setup.playbookModo);
     }
     for (const permitido of permitidos) {
         const blocos = setup.modos?.[permitido]?.blocos;
         if (!blocos || blocos.length !== modos_1.MODOS[permitido].blocos.length) {
-            throw new Error(`playbook ativo exige todos os blocos de ${permitido}`);
+            throw new Error((0, locale_1.msg)().setup.playbookBlocos(permitido));
         }
         for (const config of blocos) {
             validarConfigComLimites(objeto(config, 'config do bloco'));
@@ -372,12 +373,12 @@ function limitesDoBloco(manifesto, setup, modo, fase) {
     }
     const config = configDoBloco(setup, modo, fase);
     if (!config)
-        throw new Error(`fase ${fase} fora do modo ${modo}`);
+        throw new Error((0, locale_1.msg)().setup.faseFora(fase, modo));
     return validarLimitesDeBloco(config.limites);
 }
 function instante(valor, campo) {
     if (typeof valor !== 'number' || !Number.isSafeInteger(valor) || valor < 0 || valor > MAX_INSTANTE_MS) {
-        throw new Error(`${campo} deve ser instante inteiro nao negativo e representavel`);
+        throw new Error((0, locale_1.msg)().setup.instante(campo));
     }
     return valor;
 }
@@ -389,20 +390,20 @@ function validarIdentidade(valor) {
     camposExatos(id, ['threadId', 'execucaoId', 'modo', 'bloco'], 'identidade');
     for (const campo of ['threadId', 'execucaoId']) {
         if (typeof id[campo] !== 'string' || id[campo].trim() === '') {
-            throw new Error(`identidade.${campo} deve ser texto nao vazio`);
+            throw new Error((0, locale_1.msg)().setup.identidadeTexto(campo));
         }
     }
     if (!modos_1.ORDEM_DOS_MODOS.includes(id.modo) ||
         typeof id.bloco !== 'number' || !Number.isSafeInteger(id.bloco) ||
         id.bloco < 1 || id.bloco > modos_1.MODOS[id.modo].blocos.length) {
-        throw new Error('identidade de modo/bloco invalida');
+        throw new Error((0, locale_1.msg)().setup.identidadeModo);
     }
     return { threadId: id.threadId, execucaoId: id.execucaoId, modo: id.modo, bloco: id.bloco };
 }
 function semAmpliacao(limites, origem) {
     for (const campo of CAMPOS_LIMITES) {
         if (limites[campo] > origem[campo])
-            throw new Error(`heranca nao pode ampliar limites.${campo}`);
+            throw new Error((0, locale_1.msg)().setup.herancaAmplia(campo));
     }
 }
 /**
@@ -415,7 +416,7 @@ function iniciarPrazoDoBloco(manifesto, setup, identidade, fase, agoraMs) {
         return null;
     const id = validarIdentidade(identidade);
     if (!modos_1.MODOS[id.modo].blocos[id.bloco - 1].fases.includes(fase)) {
-        throw new Error('identidade do bloco diverge da fase selecionada');
+        throw new Error((0, locale_1.msg)().setup.identidadeFase);
     }
     const inicio = instante(agoraMs, 'iniciadaEmMs');
     const deadline = somarPrazo(inicio, limites.duracaoMs);
@@ -429,11 +430,11 @@ function validarPrazo(valor, esperada) {
     camposExatos(p, ['versao', 'identidade', 'iniciadaEmMs', 'deadlineOriginalMs',
         'limitesOriginais', 'deadlineMs', 'limites', 'observadoEmMs'], 'prazo');
     if (p.versao !== 1)
-        throw new Error('versao de prazo incompativel');
+        throw new Error((0, locale_1.msg)().setup.prazoVersao);
     const identidade = validarIdentidade(p.identidade);
     const idEsperada = validarIdentidade(esperada);
     if (Object.keys(identidade).some(c => identidade[c] !== idEsperada[c])) {
-        throw new Error('identidade da execucao divergente');
+        throw new Error((0, locale_1.msg)().setup.identidadeDivergente);
     }
     const limitesOriginais = validarLimitesDeBloco(p.limitesOriginais);
     const limites = validarLimitesDeBloco(p.limites);
@@ -444,7 +445,7 @@ function validarPrazo(valor, esperada) {
     const deadlineMs = instante(p.deadlineMs, 'deadlineMs');
     if (deadlineOriginalMs !== somarPrazo(iniciadaEmMs, limitesOriginais.duracaoMs) ||
         deadlineMs !== somarPrazo(iniciadaEmMs, limites.duracaoMs) || observadoEmMs < iniciadaEmMs) {
-        throw new Error('origem/deadline do prazo inconsistente');
+        throw new Error((0, locale_1.msg)().setup.prazoInconsistente);
     }
     return { versao: 1, identidade, iniciadaEmMs, deadlineOriginalMs, limitesOriginais, deadlineMs, limites, observadoEmMs };
 }
@@ -457,7 +458,7 @@ function consumirPrazoDoBloco(snapshot, identidadeEsperada, agoraMs, atividade =
     const prazo = validarPrazo(snapshot, identidadeEsperada);
     const agoraValidado = instante(agoraMs, 'agoraMs');
     if (agoraValidado < prazo.observadoEmMs)
-        throw new Error('relogio regressivo no prazo');
+        throw new Error((0, locale_1.msg)().setup.relogioRegressivo);
     const a = objeto(atividade, 'atividade');
     if (a.tipo === 'trabalho') {
         camposExatos(a, ['tipo'], 'atividade');
@@ -465,10 +466,10 @@ function consumirPrazoDoBloco(snapshot, identidadeEsperada, agoraMs, atividade =
     else if (a.tipo === 'espera_lease' || a.tipo === 'espera_score') {
         camposExatos(a, ['tipo', 'processosAtivos'], 'atividade');
         if (a.processosAtivos !== 0)
-            throw new Error('espera exige ausencia comprovada de processos ativos');
+            throw new Error((0, locale_1.msg)().setup.esperaComProcesso);
     }
     else {
-        throw new Error('atividade de prazo desconhecida');
+        throw new Error((0, locale_1.msg)().setup.atividadeDesconhecida);
     }
     prazo.observadoEmMs = agoraValidado;
     const restanteMs = Math.max(0, prazo.deadlineMs - agoraValidado);
@@ -481,13 +482,13 @@ function consumirPrazoDoBloco(snapshot, identidadeEsperada, agoraMs, atividade =
 function herdarPrazoDoBloco(origem, identidadeEsperada, agoraMs, limitesSolicitados) {
     const consumo = consumirPrazoDoBloco(origem, identidadeEsperada, agoraMs);
     if (consumo.estado !== 'ativo')
-        throw new Error('prazo expirado: heranca recusada');
+        throw new Error((0, locale_1.msg)().setup.prazoExpirado);
     const prazo = consumo.prazo;
     const limites = validarLimitesDeBloco(limitesSolicitados === undefined ? prazo.limites : limitesSolicitados);
     semAmpliacao(limites, prazo.limites);
     const deadlineMs = somarPrazo(prazo.iniciadaEmMs, limites.duracaoMs);
     if (deadlineMs <= agoraMs)
-        throw new Error('prazo reduzido ja expirado');
+        throw new Error((0, locale_1.msg)().setup.prazoReduzido);
     return { ...prazo, limites, deadlineMs };
 }
 /** A config do bloco e o default pos-instalacao? */
@@ -525,20 +526,20 @@ function editarBloco(raiz, modo, bloco, edicao, por = 'owner') {
     if (!Number.isInteger(bloco) || bloco < 1 || bloco > def.blocos.length) {
         return {
             ...base,
-            erro: `bloco ${bloco} nao existe no modo ${def.tag}: ele tem ${def.blocos.length} bloco(s)`,
+            erro: (0, locale_1.msg)().setup.blocoInexistente(bloco, def.tag, def.blocos.length),
         };
     }
     if (edicao.runtime !== undefined && !(0, runtimes_1.runtimeConhecido)(edicao.runtime)) {
         return {
             ...base,
-            erro: `runtime desconhecido: "${edicao.runtime}" (homologados: ${runtimes_1.ORDEM_DOS_RUNTIMES.join(', ')})`,
+            erro: (0, locale_1.msg)().setup.runtimeDesconhecido(edicao.runtime, runtimes_1.ORDEM_DOS_RUNTIMES.join(', ')),
         };
     }
     const atual = setup.modos[modo].blocos[bloco - 1];
     if (edicao.runtime !== undefined && edicao.runtime !== atual.runtime && !edicao.model?.trim())
-        return { ...base, erro: 'setup.model.required: para mudar o runtime do bloco, informe --runtime e --model juntos; nenhuma configuracao foi gravada.' };
+        return { ...base, erro: (0, locale_1.msg)().setup.modeloComRuntime };
     if (!(edicao.model ?? atual.model).trim())
-        return { ...base, erro: 'setup.model.required: modelo pendente neste bloco; informe --model antes de salvar.' };
+        return { ...base, erro: (0, locale_1.msg)().setup.modeloPendente };
     const de = { ...atual };
     const runtimeNovo = edicao.runtime ?? atual.runtime;
     let fallback;
@@ -613,15 +614,15 @@ function registrarSetupNoLedger(raiz, dados) {
 function linhaDaOrigemDoSetup(raiz) {
     const origem = origemDoSetup(raiz);
     if (origem === 'versionado') {
-        return `Setup versionado em ${exports.NOME_SETUP_VERSIONADO}: vale para todas as maquinas e muda por PR.` +
-            (fs.existsSync(caminhoSetupLocal(raiz)) ? ' O .orkastery/setup.json local desta maquina fica ignorado.' : '');
+        return (0, locale_1.msg)().setup.origem.versionado(exports.NOME_SETUP_VERSIONADO, fs.existsSync(caminhoSetupLocal(raiz)));
     }
     if (origem === 'local')
-        return 'Setup local desta maquina (.orkastery/setup.json). Para valer em todas: ork setup versionar.';
-    return 'Nenhum setup gravado: vale o default. Para valer em todas as maquinas: ork setup versionar.';
+        return (0, locale_1.msg)().setup.origem.local;
+    return (0, locale_1.msg)().setup.origem.padrao;
 }
 /** Tabela de um modo: cada bloco com sua config e a marca do que saiu do default. */
 function textoDoSetup(raiz, modo) {
+    const m = (0, locale_1.msg)().setup.tabela;
     const def = (0, modos_1.definicaoDoModo)(modo);
     const setup = lerSetup(raiz);
     const linhas = def.blocos.map((b, i) => {
@@ -630,22 +631,22 @@ function textoDoSetup(raiz, modo) {
             String(i + 1),
             b.fases.join('-'),
             cfg.runtime,
-            cfg.model || '(modelo pendente)',
+            cfg.model || m.modeloPendente,
             cfg.effort,
             cfg.fallback?.join(', ') || '-',
-            ehPadrao(cfg, modo) ? 'default' : 'customizado',
+            ehPadrao(cfg, modo) ? m.default : m.customizado,
         ];
     });
     const saida = [];
-    saida.push(`Setup do modo ${def.tag} (${def.blocos.length} bloco(s), ${def.pausas} pausa(s))`);
+    saida.push(m.titulo(def.tag, def.blocos.length, def.pausas));
     saida.push('');
-    saida.push((0, util_1.tabela)(['BLOCO', 'FASES', 'RUNTIME', 'MODEL', 'EFFORT', 'FALLBACK', 'ORIGEM'], linhas));
+    saida.push((0, util_1.tabela)([...m.cabecalho], linhas));
     saida.push('');
-    saida.push(`Editar:  ork setup ${modo} --bloco N --runtime R --model M --effort E`);
-    saida.push(`Fallback: ork setup ${modo} --bloco N --fallback runtime:modelo[:esforco],...   (--fallback "" remove)`);
+    saida.push(m.editar(modo));
+    saida.push(m.fallback(modo));
     const padrao = blocoPadraoDoModo(modo);
-    saida.push(`Resetar: ork setup ${modo} --reset   (volta para ${padrao.runtime}/${padrao.model}/${padrao.effort})`);
-    saida.push(`Runtimes homologados: ${runtimes_1.ORDEM_DOS_RUNTIMES.join(', ')}`);
+    saida.push(m.resetar(modo, `${padrao.runtime}/${padrao.model}/${padrao.effort}`));
+    saida.push(m.runtimes(runtimes_1.ORDEM_DOS_RUNTIMES.join(', ')));
     saida.push('');
     saida.push(linhaDaOrigemDoSetup(raiz));
     return saida.join('\n');
@@ -658,33 +659,33 @@ function textoDoSetup(raiz, modo) {
  * o owner disser que concluiu, e todo bloco nao respondido fica no default.
  */
 function textoDaEntrevista(raiz) {
+    const m = (0, locale_1.msg)().setup.entrevista;
     const setup = lerSetup(raiz);
     const saida = [];
-    saida.push('Entrevista #setup: runtime + modelo + esforco por bloco de cada modo');
+    saida.push(m.titulo);
     saida.push('');
-    saida.push(`Ordem das perguntas: ${modos_1.ORDEM_DOS_MODOS.map((m) => modos_1.MODOS[m].tag).join(' -> ')}.`);
-    saida.push('A entrevista termina quando todos os modos forem cobertos OU quando o owner');
-    saida.push('disser que concluiu: o que nao for respondido fica no default.');
+    saida.push(m.ordem(modos_1.ORDEM_DOS_MODOS.map((modo) => modos_1.MODOS[modo].tag).join(' -> ')));
+    saida.push(m.termina1);
+    saida.push(m.termina2);
     const proprios = modos_1.ORDEM_DOS_MODOS.filter((m) => !ehPadrao(blocoPadraoDoModo(m)));
-    saida.push(`Default pos-instalacao: ${exports.BLOCO_PADRAO.runtime}/${exports.BLOCO_PADRAO.model}/${exports.BLOCO_PADRAO.effort} em todos os blocos` +
-        (proprios.length ? `, menos ${proprios.map((m) => {
-            const b = blocoPadraoDoModo(m);
-            return `${modos_1.MODOS[m].tag} (${b.runtime}/${b.model}/${b.effort}${b.fallback?.length ? `, fallback ${b.fallback.join(', ')}` : ''})`;
-        }).join(', ')}.` : '.'));
+    saida.push(m.default(`${exports.BLOCO_PADRAO.runtime}/${exports.BLOCO_PADRAO.model}/${exports.BLOCO_PADRAO.effort}`, proprios.length ? m.excecoes(proprios.map((modo) => {
+        const b = blocoPadraoDoModo(modo);
+        return `${modos_1.MODOS[modo].tag} (${b.runtime}/${b.model}/${b.effort}${b.fallback?.length ? `, fallback ${b.fallback.join(', ')}` : ''})`;
+    }).join(', ')) : '.'));
     saida.push('');
     for (const modo of modos_1.ORDEM_DOS_MODOS) {
         const def = modos_1.MODOS[modo];
         saida.push(`${def.tag}`);
         def.blocos.forEach((b, i) => {
             const cfg = setup.modos[modo].blocos[i];
-            const marca = ehPadrao(cfg, modo) ? '' : '  <- customizado';
-            saida.push(`  bloco ${i + 1}: ${b.fases.join('-')}  [${cfg.runtime}/${cfg.model || '(modelo pendente)'}/${cfg.effort}]${marca}`);
+            const marca = ehPadrao(cfg, modo) ? '' : m.customizado;
+            saida.push(m.bloco(i + 1, b.fases.join('-'), `${cfg.runtime}/${cfg.model || m.modeloPendente}/${cfg.effort}`, marca));
         });
     }
     saida.push('');
-    saida.push('Ver um modo:  ork setup <modo>');
-    saida.push('Editar bloco: ork setup <modo> --bloco N --runtime R --model M --effort E');
-    saida.push('Resetar tudo: ork setup --reset');
+    saida.push(m.ver);
+    saida.push(m.editar);
+    saida.push(m.resetar);
     saida.push('');
     saida.push(linhaDaOrigemDoSetup(raiz));
     return saida.join('\n');