@orkastery/cli 0.2.0

package/dist/modos.js

@@ -0,0 +1,220 @@
+"use strict";
+/**
+ * Modos de conducao por #TAG (visao unificada, secao 3.5).
+ *
+ * Regra central, nao negociavel: o modo afrouxa a PAUSA, nunca a VERIFICACAO.
+ * Claims, verify, policies e gates tipados rodam identicos em todos os modos;
+ * o que muda e se o veredito espera o humano ou segue sozinho com registro no ledger.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TAG_DE_MODO_DESCONHECIDO = exports.ORDEM_DOS_MODOS = exports.MODOS = exports.INVARIANTES = void 0;
+exports.slugDasFases = slugDasFases;
+exports.parseModo = parseModo;
+exports.extrairTagDoPedido = extrairTagDoPedido;
+exports.tagDoModo = tagDoModo;
+exports.definicaoDoModo = definicaoDoModo;
+exports.pausasDoModo = pausasDoModo;
+exports.blocoDaFase = blocoDaFase;
+exports.fasePausa = fasePausa;
+exports.tabelaDeModos = tabelaDeModos;
+const types_1 = require("./types");
+/** Invariantes que valem em TODOS os modos, inclusive `#Auto`. */
+exports.INVARIANTES = [
+    'Claims, verify e policies rodam identicos em todos os modos.',
+    'Policy `block` pausa qualquer modo, inclusive #Auto.',
+    'Escalacao tipada para humano pausa qualquer modo, inclusive #Auto.',
+    'Um score humano por entrega sempre; nos modos sem pausa de MASTER ele vai para a fila de batch.',
+    'Toda decisao autonoma vai ao ledger com quem decidiu, evidencia e razao.',
+];
+/** Monta a parte 3 do slug para um conjunto de fases (visao, secao 3.4). */
+function slugDasFases(fases) {
+    if (fases.length === 0)
+        throw new Error('bloco de loop sem fases');
+    if (fases.length === types_1.FASES.length)
+        return 'full';
+    if (fases.length === 1)
+        return fases[0].toLowerCase();
+    return 'f' + fases.map((f) => types_1.DIGITO_DA_FASE[f]).join('');
+}
+function bloco(fases, pausaSobre) {
+    return {
+        fases,
+        pausa: pausaSobre.length > 0,
+        pausaSobre,
+        slugFases: slugDasFases(fases),
+    };
+}
+const SEM_PAUSA = '';
+/** A matriz dos 5 modos, do mais HITL ao mais autonomo. */
+exports.MODOS = {
+    look: {
+        modo: 'look',
+        tag: '#Look',
+        blocos: [
+            bloco(['GOAL'], 'objetivo'),
+            bloco(['PLAN'], 'plano'),
+            bloco(['GO'], 'implementacao'),
+            bloco(['CHECK'], 'evidencias'),
+            bloco(['SHIP'], 'push'),
+            bloco(['MASTER'], 'score'),
+        ],
+        pausas: 6,
+        recomendadoPara: 'Risco alto, passos irreversiveis, dominio novo, produto com usuarios reais',
+    },
+    ork: {
+        modo: 'ork',
+        tag: '#Ork',
+        blocos: [
+            bloco(['GOAL', 'PLAN'], 'premissas'),
+            bloco(['GO'], 'implementacao'),
+            bloco(['CHECK'], 'evidencias'),
+            bloco(['SHIP'], 'push'),
+            bloco(['MASTER'], 'score'),
+        ],
+        pausas: 5,
+        recomendadoPara: 'Demandas de produto que pedem veredito separado da execucao e da evidencia',
+    },
+    classic: {
+        modo: 'classic',
+        tag: '#Classic',
+        blocos: [
+            bloco(['GOAL'], 'objetivo'),
+            bloco(['PLAN'], 'plano'),
+            bloco(['GO', 'CHECK'], 'evidencias, com autorizacao antecipada de push'),
+            bloco(['SHIP', 'MASTER'], SEM_PAUSA),
+        ],
+        pausas: 3,
+        recomendadoPara: 'O padrao: premissas delicadas com entrega confiavel; score em batch',
+    },
+    maestro: {
+        modo: 'maestro',
+        tag: '#Maestro',
+        blocos: [
+            bloco(['GOAL', 'PLAN'], 'premissas'),
+            bloco(['GO', 'CHECK', 'SHIP'], SEM_PAUSA),
+            bloco(['MASTER'], SEM_PAUSA),
+        ],
+        pausas: 1,
+        recomendadoPara: 'Solucoes claras e ageis, sem muitos riscos ou tradeoffs; score em batch',
+    },
+    auto: {
+        modo: 'auto',
+        tag: '#Auto',
+        blocos: [bloco([...types_1.FASES], SEM_PAUSA)],
+        pausas: 0,
+        recomendadoPara: 'Solucoes menores, docs, estudos, pesquisas, configuracoes, auditorias, migracoes',
+    },
+};
+/** Todos os modos na ordem do espectro, do mais HITL ao mais autonomo. */
+exports.ORDEM_DOS_MODOS = ['look', 'ork', 'classic', 'maestro', 'auto'];
+/**
+ * Parseia a #TAG de modo de conducao.
+ * Aceita `#Auto`, `auto`, `--modo auto`, com ou sem caixa. Retorna null se nao reconhecer.
+ */
+function parseModo(entrada) {
+    if (!entrada)
+        return null;
+    const limpo = entrada.trim().replace(/^--?modo[= ]/i, '').replace(/^#/, '').toLowerCase();
+    return exports.ORDEM_DOS_MODOS.includes(limpo) ? limpo : null;
+}
+/**
+ * Extrai a primeira #TAG de modo presente no texto livre de um pedido do builder.
+ * E o caminho usado pelos adaptadores de host antes de chamar `ork thread new --modo`.
+ */
+function extrairTagDoPedido(texto) {
+    const achadas = texto.match(/#(look|ork|classic|maestro|auto)\b/gi);
+    if (!achadas || achadas.length === 0)
+        return null;
+    return parseModo(achadas[0]);
+}
+/** Tag mostrada quando a thread em disco nao traz um modo reconhecido. */
+exports.TAG_DE_MODO_DESCONHECIDO = '#?';
+/**
+ * Tag do modo para EXIBICAO, tolerante ao que esta de fato gravado em disco.
+ *
+ * `thread.json` e arquivo, nao tipo: uma thread criada por versao antiga, por outro
+ * perfil de board ou editada a mao pode trazer um `modo` que nao existe na matriz
+ * (ou nao trazer nenhum). Todo `MODOS[thread.modo].tag` nesses casos estourava com
+ * "Cannot read properties of undefined (reading 'tag')" e derrubava o comando INTEIRO,
+ * inclusive `ork board`, `ork thread list` e `ork orquestracao status`.
+ *
+ * A regra aqui e nunca lancar: um comando que so LE o board tem de conseguir mostrar
+ * a thread torta, que e justamente a que o humano precisa ver para consertar. A tag
+ * de fallback carrega o valor cru (`#?default`) para dizer o que arrumar.
+ *
+ * Isto NAO afrouxa a conducao: quem VALIDA modo (criar thread, checar manifesto)
+ * continua usando `definicaoDoModo`, que lanca. Aqui so se decide o que imprimir.
+ */
+function tagDoModo(modo) {
+    if (typeof modo === 'string') {
+        const def = exports.MODOS[modo];
+        if (def)
+            return def.tag;
+        const cru = modo.trim();
+        if (cru.length > 0)
+            return `${exports.TAG_DE_MODO_DESCONHECIDO}${cru.slice(0, 16)}`;
+    }
+    return exports.TAG_DE_MODO_DESCONHECIDO;
+}
+/** Definicao de um modo, com erro tipado quando o modo nao existe. */
+function definicaoDoModo(modo) {
+    const def = exports.MODOS[modo];
+    if (!def)
+        throw new Error(`modo de conducao desconhecido: ${modo}`);
+    return def;
+}
+/** Numero de pausas humanas do modo, derivado dos blocos (nunca hardcoded no consumo). */
+function pausasDoModo(modo) {
+    return definicaoDoModo(modo).blocos.filter((b) => b.pausa).length;
+}
+/** O bloco de loop que conduz a fase informada dentro do modo. */
+function blocoDaFase(modo, fase) {
+    const def = definicaoDoModo(modo);
+    const achado = def.blocos.find((b) => b.fases.includes(fase));
+    if (!achado)
+        throw new Error(`fase ${fase} nao pertence a nenhum bloco do modo ${modo}`);
+    return achado;
+}
+/** A fase pausa para o humano ao fechar seu bloco? */
+function fasePausa(modo, fase) {
+    const b = blocoDaFase(modo, fase);
+    return b.pausa && b.fases[b.fases.length - 1] === fase;
+}
+/** Tabela dos 5 modos em texto, usada por `ork modos`. */
+function tabelaDeModos() {
+    const linhas = [];
+    linhas.push('Modos de conducao (a #TAG vai no proprio pedido ao orquestrador)');
+    linhas.push('');
+    const cab = ['#TAG'.padEnd(10), 'BLOCOS'.padEnd(6), 'PAUSAS'.padEnd(7), 'CICLO'];
+    linhas.push('  ' + cab.join(' '));
+    linhas.push('  ' + '-'.repeat(78));
+    for (const modo of exports.ORDEM_DOS_MODOS) {
+        const def = exports.MODOS[modo];
+        const ciclo = def.blocos
+            .map((b) => b.fases.join('-') + (b.pausa ? ' *' : ''))
+            .join(' / ');
+        linhas.push('  ' +
+            [
+                def.tag.padEnd(10),
+                String(def.blocos.length).padEnd(6),
+                String(pausasDoModo(modo)).padEnd(7),
+                ciclo,
+            ].join(' '));
+    }
+    linhas.push('  ' + '-'.repeat(78));
+    linhas.push('  * = bloco que pausa e espera veredito humano');
+    linhas.push('');
+    linhas.push('Detalhe por modo:');
+    for (const modo of exports.ORDEM_DOS_MODOS) {
+        const def = exports.MODOS[modo];
+        const pausas = def.blocos.filter((b) => b.pausa).map((b) => b.pausaSobre);
+        linhas.push(`  ${def.tag.padEnd(10)} slug das sessoes: ${def.blocos.map((b) => b.slugFases).join(', ')}`);
+        linhas.push(`             pausas: ${pausas.length > 0 ? pausas.join(', ') : 'nenhuma'}`);
+        linhas.push(`             uso: ${def.recomendadoPara}`);
+    }
+    linhas.push('');
+    linhas.push('REGRA CENTRAL: o modo afrouxa a pausa, NUNCA a verificacao.');
+    for (const inv of exports.INVARIANTES)
+        linhas.push('  - ' + inv);
+    return linhas.join('\n');
+}