@orkastery/cli 0.2.0

package/dist/catalogo.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Onde mora o catalogo do produto (bloco B4).
+ *
+ * O `ork` roda de dentro de `core/dist`, de `core/dist-test` e, instalado, de qualquer lugar
+ * do PATH, mas o catalogo de skills, as checklists normativas e os adaptadores de host sao
+ * arquivos do produto, nao codigo compilado. Este modulo resolve essa raiz uma unica vez, em
+ * um lugar so, para nao existirem duas regras de "onde estao as skills" divergindo em
+ * silencio (que e exatamente o defeito que os proprios evals cacam nas skills).
+ */
+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.BUCKETS = void 0;
+exports.raizDoCatalogo = raizDoCatalogo;
+exports.exigirCatalogo = exigirCatalogo;
+exports.skillsDoCatalogo = skillsDoCatalogo;
+exports.referenciasDoCatalogo = referenciasDoCatalogo;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+/** O que precisa existir para um diretorio ser a raiz do catalogo. */
+const MARCAS = ['skills', 'references', 'eval'];
+function ehRaizDoCatalogo(dir) {
+    return MARCAS.every((m) => fs.existsSync(path.join(dir, m)));
+}
+function subirProcurando(inicial) {
+    let atual = path.resolve(inicial);
+    for (;;) {
+        if (ehRaizDoCatalogo(atual))
+            return atual;
+        const pai = path.dirname(atual);
+        if (pai === atual)
+            return null;
+        atual = pai;
+    }
+}
+/**
+ * A raiz do catalogo: o diretorio que tem `skills/`, `references/` e `eval/`.
+ *
+ * Procura a partir do diretorio informado (ou do cwd) e depois a partir do proprio codigo,
+ * que e o caminho que vale quando o `ork` roda instalado, fora do repositorio do produto.
+ */
+function raizDoCatalogo(inicial) {
+    return subirProcurando(inicial ?? process.cwd()) ?? subirProcurando(__dirname);
+}
+/** A raiz do catalogo, com erro tipado quando o `ork` nao consegue achar o produto. */
+function exigirCatalogo(inicial) {
+    const raiz = raizDoCatalogo(inicial);
+    if (!raiz) {
+        throw new Error('catalogo do Orkastery nao encontrado (esperado um diretorio com skills/, references/ e eval/)');
+    }
+    return raiz;
+}
+/** Os buckets do catalogo, na ordem em que o README os apresenta. */
+exports.BUCKETS = [
+    'core',
+    'phases',
+    'reviewers',
+    'governance',
+    'observability',
+];
+/** Todas as skills do catalogo, varridas do disco (nunca de uma lista escrita a mao). */
+function skillsDoCatalogo(raiz) {
+    const achadas = [];
+    for (const bucket of exports.BUCKETS) {
+        const dirBucket = path.join(raiz, 'skills', bucket);
+        if (!fs.existsSync(dirBucket))
+            continue;
+        for (const nome of fs.readdirSync(dirBucket).sort()) {
+            const caminho = path.join(dirBucket, nome, 'SKILL.md');
+            if (!fs.existsSync(caminho))
+                continue;
+            achadas.push({
+                nome,
+                bucket,
+                caminho,
+                relativo: path.join('skills', bucket, nome, 'SKILL.md'),
+            });
+        }
+    }
+    return achadas;
+}
+/** As 5 checklists normativas citaveis por item (`DoD 4`, `SEC 5`). */
+function referenciasDoCatalogo(raiz) {
+    const dir = path.join(raiz, 'references');
+    if (!fs.existsSync(dir))
+        return [];
+    return fs
+        .readdirSync(dir)
+        .filter((a) => a.endsWith('.md'))
+        .sort()
+        .map((a) => path.join(dir, a));
+}

package/dist/ciclos.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * Variantes de ciclo (`ork thread new --ciclo`), portadas do Devmaster (bloco B2).
+ *
+ * A variante NAO muda a verificacao nem os gates: ela muda como a thread NASCE.
+ * Ou o desenho dos blocos de loop (`goal-plan` funde GOAL e PLAN; `gap` publica a
+ * lacuna sem GO e sem SHIP), ou a arvore de onde ela parte (`merge-branch` parte de
+ * uma branch que ja existe; `greenfield` exige worktree isolada).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ORDEM_DAS_VARIANTES = exports.VARIANTES = void 0;
+exports.parseVariante = parseVariante;
+exports.definicaoDaVariante = definicaoDaVariante;
+exports.fundirGoalPlan = fundirGoalPlan;
+exports.somenteAnalise = somenteAnalise;
+exports.aplicarVariante = aplicarVariante;
+exports.tabelaDeVariantes = tabelaDeVariantes;
+const modos_1 = require("./modos");
+/** As 5 variantes de ciclo, com o que cada uma muda na criacao da thread. */
+exports.VARIANTES = {
+    greenfield: {
+        variante: 'greenfield',
+        descricao: 'Comeco do zero: worktree isolada obrigatoria, partindo da base do manifesto',
+        exigeBranch: false,
+        exigeWorktree: true,
+        mudaBlocos: false,
+    },
+    'merge-branch': {
+        variante: 'merge-branch',
+        descricao: 'Parte de uma branch que ja existe (`--branch`), sem criar branch nova',
+        exigeBranch: true,
+        exigeWorktree: true,
+        mudaBlocos: false,
+    },
+    'goal-plan': {
+        variante: 'goal-plan',
+        descricao: 'Funde GOAL e PLAN num bloco so: uma pausa a menos quando o modo os separava',
+        exigeBranch: false,
+        exigeWorktree: false,
+        mudaBlocos: true,
+    },
+    gap: {
+        variante: 'gap',
+        descricao: 'Analise de lacuna: sem GO e sem SHIP, a lacuna e publicada como lacuna',
+        exigeBranch: false,
+        exigeWorktree: false,
+        mudaBlocos: true,
+    },
+    'feature-xl-faseada': {
+        variante: 'feature-xl-faseada',
+        descricao: 'Feature grande em fatias: o PLAN se compromete com N fatias verificaveis',
+        exigeBranch: false,
+        exigeWorktree: true,
+        mudaBlocos: false,
+    },
+};
+/** Ordem de apresentacao das variantes no CLI. */
+exports.ORDEM_DAS_VARIANTES = [
+    'greenfield',
+    'merge-branch',
+    'goal-plan',
+    'gap',
+    'feature-xl-faseada',
+];
+/** Parseia `--ciclo`. Retorna null quando a variante nao existe. */
+function parseVariante(bruto) {
+    if (!bruto)
+        return null;
+    const limpo = bruto.trim().toLowerCase();
+    return exports.ORDEM_DAS_VARIANTES.includes(limpo)
+        ? limpo
+        : null;
+}
+/** Definicao de uma variante, com erro claro quando ela nao existe. */
+function definicaoDaVariante(variante) {
+    const def = exports.VARIANTES[variante];
+    if (!def)
+        throw new Error(`variante de ciclo desconhecida: ${variante}`);
+    return def;
+}
+function refazerBloco(fases, pausa, pausaSobre) {
+    return { fases, pausa, pausaSobre, slugFases: (0, modos_1.slugDasFases)(fases) };
+}
+/**
+ * Funde os blocos que conduzem GOAL e PLAN num bloco unico.
+ *
+ * Idempotente: em `#Default`, `#Maestro` e `#Auto` o GOAL e o PLAN ja vivem no mesmo
+ * bloco e nada muda. Em `#Look` e `#Ork` a fusao economiza exatamente uma pausa.
+ */
+function fundirGoalPlan(blocos) {
+    const envolvidos = blocos.filter((b) => b.fases.includes('GOAL') || b.fases.includes('PLAN'));
+    if (envolvidos.length <= 1)
+        return blocos.map((b) => ({ ...b }));
+    const fases = envolvidos.flatMap((b) => b.fases);
+    const pausa = envolvidos.some((b) => b.pausa);
+    const pausaSobre = pausa ? 'premissas' : '';
+    const fundido = refazerBloco(fases, pausa, pausaSobre);
+    const saida = [];
+    let inserido = false;
+    for (const b of blocos) {
+        if (envolvidos.includes(b)) {
+            if (!inserido) {
+                saida.push(fundido);
+                inserido = true;
+            }
+            continue;
+        }
+        saida.push({ ...b });
+    }
+    return saida;
+}
+/** Tira GO e SHIP do ciclo: a thread de gap analisa e publica, nao implementa nem entrega. */
+function somenteAnalise(blocos) {
+    const fora = ['GO', 'SHIP'];
+    const saida = [];
+    for (const b of blocos) {
+        const fases = b.fases.filter((f) => !fora.includes(f));
+        if (fases.length === 0)
+            continue;
+        // A pausa sobrevive so quando a fase que a motivava sobreviveu.
+        const ultima = b.fases[b.fases.length - 1];
+        const pausa = b.pausa && fases.includes(ultima);
+        saida.push(refazerBloco(fases, pausa, pausa ? b.pausaSobre : ''));
+    }
+    if (saida.length === 0)
+        throw new Error('a variante gap removeu todas as fases do ciclo');
+    return saida;
+}
+/** Aplica a variante ao desenho de blocos do modo. Variante nula devolve os blocos como estao. */
+function aplicarVariante(blocos, variante) {
+    if (!variante)
+        return blocos.map((b) => ({ ...b }));
+    if (variante === 'goal-plan')
+        return fundirGoalPlan(blocos);
+    if (variante === 'gap')
+        return somenteAnalise(blocos);
+    return blocos.map((b) => ({ ...b }));
+}
+/** Tabela das variantes de ciclo, usada por `ork ciclos`. */
+function tabelaDeVariantes() {
+    const linhas = ['Variantes de ciclo (`ork thread new --ciclo <variante>`)', ''];
+    for (const v of exports.ORDEM_DAS_VARIANTES) {
+        const def = exports.VARIANTES[v];
+        const exige = [];
+        if (def.exigeBranch)
+            exige.push('--branch <existente>');
+        if (def.exigeWorktree)
+            exige.push('worktree isolada');
+        linhas.push(`  ${v.padEnd(20)} ${def.descricao}`);
+        linhas.push(`  ${''.padEnd(20)} exige: ${exige.join(', ') || 'nada'} | ` +
+            `muda os blocos do modo: ${def.mudaBlocos ? 'sim' : 'nao'}`);
+    }
+    linhas.push('');
+    linhas.push('A variante muda como a thread NASCE. Verificacao e gates nao mudam.');
+    return linhas.join('\n');
+}

package/dist/claims.js

@@ -0,0 +1,226 @@
+"use strict";
+/**
+ * Claims: o protocolo de alegacoes verificaveis (bloco B1).
+ *
+ * Uma fase nao "diz" que algo funciona: ela registra uma CLAIM com o comando que a
+ * comprova, e o `ork verify` reexecuta esse comando no HEAD real. Self-report nao vale
+ * como evidencia em nenhum modo de conducao.
+ *
+ * O caso EvoJ6 (alegacao negativa falsa que passou batido) e tratado aqui na origem:
+ * alegacao negativa ou absoluta ("nenhum", "zero", "sempre", "nunca") SEM comando de
+ * verificacao reprova no gate, porque nao existe como comprova-la depois.
+ */
+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.caminhoClaims = caminhoClaims;
+exports.lerClaims = lerClaims;
+exports.proximoIdDeClaim = proximoIdDeClaim;
+exports.ehAlegacaoNegativa = ehAlegacaoNegativa;
+exports.montarClaim = montarClaim;
+exports.gravarClaim = gravarClaim;
+exports.adicionarClaim = adicionarClaim;
+exports.exigirClaim = exigirClaim;
+exports.anexarComando = anexarComando;
+exports.retirarClaim = retirarClaim;
+exports.carimbarEstado = carimbarEstado;
+exports.tabelaDeClaims = tabelaDeClaims;
+const path = __importStar(require("node:path"));
+const ledger_1 = require("./ledger");
+const thread_1 = require("./thread");
+const util_1 = require("./util");
+/** Caminho do `claims.jsonl` da thread (append-only, como o ledger). */
+function caminhoClaims(raiz, threadId) {
+    return path.join((0, thread_1.dirThread)(raiz, threadId), 'claims.jsonl');
+}
+/** Le as claims da thread (armazem JSONL: a ultima gravacao de um id vence). */
+function lerClaims(raiz, threadId) {
+    return (0, util_1.lerJsonl)(caminhoClaims(raiz, threadId));
+}
+/** Proximo id sequencial (`C1`, `C2`, ...) dentro da thread. */
+function proximoIdDeClaim(claims) {
+    return (0, util_1.proximoIdSequencial)(claims.map((c) => c.id), 'C');
+}
+/** Palavras que tornam uma alegacao negativa ou absoluta, portanto nao auditavel a olho. */
+const TERMOS_ABSOLUTOS = [
+    'nenhum',
+    'nenhuma',
+    'nunca',
+    'sempre',
+    'zero',
+    'todos',
+    'todas',
+    'nao ha',
+    'nao existe',
+    'nao resta',
+    'sem nenhum',
+    '100%',
+    'totalmente',
+    'completamente',
+];
+/** A alegacao e negativa/absoluta (exige comando de verificacao)? */
+function ehAlegacaoNegativa(texto) {
+    const normalizado = texto
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase();
+    return TERMOS_ABSOLUTOS.some((t) => normalizado.includes(t));
+}
+/**
+ * Monta a claim a partir dos dados brutos, SEM tocar em disco.
+ *
+ * E aqui que mora a regra de construcao de uma alegacao: quem e negativa/absoluta, e que
+ * uma alegacao sem comando ja nasce `nao-verificavel`. A funcao e pura de proposito: o
+ * auditor periodico do bloco B5 registra achados com esta MESMA regra, sem reimplementa-la
+ * e sem afrouxa-la (o auditor tambem nao tem direito a self-report).
+ */
+function montarClaim(entrada) {
+    const verificar = (entrada.verificar ?? []).filter((c) => c.trim() !== '');
+    return {
+        id: entrada.id,
+        thread: entrada.dono,
+        fase: entrada.fase,
+        arquivo: entrada.arquivo,
+        alegacao: entrada.alegacao.trim(),
+        negativa: ehAlegacaoNegativa(entrada.alegacao),
+        verificar,
+        criadoEm: (0, util_1.agora)(),
+        estado: verificar.length > 0 ? 'pendente' : 'nao-verificavel',
+    };
+}
+/** Grava uma claim no `claims.jsonl` (append-only). */
+function gravarClaim(raiz, claim) {
+    (0, util_1.anexarJsonl)(caminhoClaims(raiz, claim.thread), claim);
+}
+/** `ork claims add`: registra a alegacao e a lista no `thread.json` e no ledger. */
+function adicionarClaim(raiz, threadId, opcoes) {
+    const thread = (0, thread_1.lerThread)(raiz, threadId);
+    const existentes = lerClaims(raiz, threadId);
+    const claim = montarClaim({
+        id: proximoIdDeClaim(existentes),
+        dono: threadId,
+        fase: opcoes.fase ?? thread.faseAtual,
+        arquivo: opcoes.arquivo,
+        alegacao: opcoes.alegacao,
+        verificar: opcoes.verificar,
+    });
+    const negativa = claim.negativa;
+    const verificar = claim.verificar;
+    gravarClaim(raiz, claim);
+    thread.claims = [...new Set([...(thread.claims ?? []), claim.id])];
+    (0, thread_1.gravarThread)(raiz, thread);
+    (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.claimRegistrada, {
+        claim: claim.id,
+        fase: claim.fase,
+        arquivo: claim.arquivo,
+        alegacao: claim.alegacao,
+        negativa,
+        verificar,
+        estado: claim.estado,
+    });
+    return claim;
+}
+/** Acha a claim pelo id, com erro acionavel quando ela nao existe. */
+function exigirClaim(raiz, threadId, claimId) {
+    const claim = lerClaims(raiz, threadId).find((c) => c.id === claimId);
+    if (!claim) {
+        throw new Error(`claim "${claimId}" nao existe na thread ${threadId}`);
+    }
+    return claim;
+}
+/**
+ * Anexa um comando de verificacao a uma claim ja registrada.
+ *
+ * E o caminho de correcao da alegacao negativa sem comando: em vez de apagar a alegacao
+ * do historico, o autor declara COMO ela se comprova, e o append mais novo passa a valer.
+ */
+function anexarComando(raiz, threadId, claimId, comando) {
+    const claim = exigirClaim(raiz, threadId, claimId);
+    const atualizada = {
+        ...claim,
+        verificar: [...claim.verificar, comando],
+        estado: 'pendente',
+    };
+    gravarClaim(raiz, atualizada);
+    (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.claimRegistrada, {
+        claim: claimId,
+        alteracao: 'comando de verificacao anexado',
+        verificar: atualizada.verificar,
+        estado: atualizada.estado,
+    });
+    return atualizada;
+}
+/**
+ * Retira uma claim, com motivo obrigatorio.
+ *
+ * O `claims.jsonl` e append-only: a alegacao errada continua no historico, com a retirada
+ * registrada em cima. `ork verify` para de exigir prova dela, e o ledger guarda o porque.
+ */
+function retirarClaim(raiz, threadId, claimId, motivo) {
+    const claim = exigirClaim(raiz, threadId, claimId);
+    const atualizada = { ...claim, estado: 'retirada', motivoDaRetirada: motivo };
+    gravarClaim(raiz, atualizada);
+    (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.claimRegistrada, {
+        claim: claimId,
+        alteracao: 'claim retirada',
+        alegacao: claim.alegacao,
+        motivoDaRetirada: motivo,
+        estado: 'retirada',
+    });
+    return atualizada;
+}
+/** Regrava a claim com o estado carimbado pelo `ork verify` (o append mais novo vence). */
+function carimbarEstado(raiz, claim, estado) {
+    const atualizada = { ...claim, estado };
+    gravarClaim(raiz, atualizada);
+    return atualizada;
+}
+/** Tabela de `ork claims list`. */
+function tabelaDeClaims(raiz, threadId) {
+    const claims = lerClaims(raiz, threadId);
+    if (claims.length === 0) {
+        return (`Nenhuma claim na thread ${threadId}.\n` +
+            `Registre uma com: ork claims add ${threadId} <arquivo> --claim "<alegacao>" --verificar "<comando>"`);
+    }
+    const linhas = claims.map((c) => [
+        c.id,
+        c.fase ?? '-',
+        c.estado,
+        c.negativa ? 'sim' : 'nao',
+        c.arquivo,
+        c.verificar.join(' && ') || '(sem comando)',
+        c.alegacao,
+    ]);
+    return (0, util_1.tabela)(['ID', 'FASE', 'ESTADO', 'NEGATIVA', 'ARQUIVO', 'VERIFICAR', 'ALEGACAO'], linhas);
+}