@orkastery/cli 0.5.6 → 0.6.0

package/dist/retomada-checkpoint.js

@@ -0,0 +1,101 @@
+"use strict";
+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.derivarPontoDeParada = derivarPontoDeParada;
+exports.prepararPromptDeRetomada = prepararPromptDeRetomada;
+/** RM-064 T3: checkpoint determinístico para continuar um bloco sem recomeçar GOAL/PLAN. */
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const claims_1 = require("./claims");
+const ledger_1 = require("./ledger");
+const procedencia_1 = require("./procedencia");
+const thread_1 = require("./thread");
+const trabalho_thread_1 = require("./trabalho-thread");
+const util_1 = require("./util");
+const hash = (texto) => (0, node_crypto_1.createHash)('sha256').update(texto, 'utf8').digest('hex');
+const SHA = /^[a-f0-9]{40}$/;
+function numero(e) {
+    return typeof e.rodada === 'number' && Number.isSafeInteger(e.rodada) && e.rodada > 0 ? e.rodada : null;
+}
+function derivarPontoDeParada(raiz, thread, fase, eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread.id))) {
+    const cwdBruto = (0, procedencia_1.diretorioDaThread)(raiz, thread);
+    const cwd = (0, procedencia_1.cwdLocalOuNulo)(raiz, thread.id, cwdBruto, 'thread');
+    const head = cwd ? (0, util_1.exec)('git', ['rev-parse', '--verify', 'HEAD^{commit}'], cwd, 30_000) : null;
+    const ultimoCommit = head?.ok && SHA.test(head.stdout.trim()) ? head.stdout.trim() : null;
+    const status = cwd ? (0, util_1.exec)('git', ['status', '--porcelain=v1', '--untracked-files=normal'], cwd, 30_000) : null;
+    const gitStatus = status?.ok ? status.stdout.split('\n').filter(Boolean).slice(0, 100) : ['git status indisponível'];
+    const claimsPendentes = (0, claims_1.lerClaims)(raiz, thread.id).filter((c) => !['verificado', 'retirada'].includes(c.estado)).map((c) => c.id);
+    const rodadaCheck = eventos.filter((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.verificacao || e.tipo === ledger_1.TIPOS_DE_EVENTO.reverifyConcluido).length;
+    const abertas = eventos.filter((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.fixAberto).map(numero).filter((n) => n !== null);
+    const fechadas = new Set(eventos.filter((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.reverifyConcluido).map(numero).filter((n) => n !== null));
+    const goFixEmCurso = abertas.filter((r) => !fechadas.has(r)).at(-1) ?? null;
+    const trabalho = (0, trabalho_thread_1.resumirTrabalhoDaThread)(raiz, thread.id);
+    return { fase, ultimoCommit, gitStatus, claimsPendentes, rodadaCheck, goFixEmCurso, trabalho };
+}
+function secao(p, originalSha) {
+    const status = p.gitStatus.length ? p.gitStatus.map((l) => `  ${l}`).join('\n') : '  (limpa)';
+    return `## Ponto de parada\n\n` +
+        `Esta sessão retoma uma interrupção por cota. Continue da fase \`${p.fase}\`; não repita GOAL nem PLAN.\n\n` +
+        `- Prompt original: \`${originalSha}\`\n` +
+        `- Fase: \`${p.fase}\`\n` +
+        `- Último commit: ${p.ultimoCommit ? `\`${p.ultimoCommit}\`` : '(indisponível)'}\n` +
+        `- Claims pendentes: ${p.claimsPendentes.length ? p.claimsPendentes.map((c) => `\`${c}\``).join(', ') : '(nenhuma)'}\n` +
+        `- Rodadas de CHECK observadas: ${p.rodadaCheck}\n` +
+        `- GO-FIX em curso: ${p.goFixEmCurso === null ? '(nenhum)' : `rodada ${p.goFixEmCurso}`}\n` +
+        `- Trabalho retomável: \`${p.trabalho.caminho}\`\n` +
+        `${(0, trabalho_thread_1.formatarResumoDoTrabalho)(p.trabalho)}\n` +
+        `- \`git status --porcelain\`:\n\n\`\`\`text\n${status}\n\`\`\`\n\n`;
+}
+/** O original é conferido pelo chamador; este escritor só cria o derivado e nunca o altera. */
+function prepararPromptDeRetomada(raiz, thread, fase, original, gravar = true) {
+    const ponto = derivarPontoDeParada(raiz, thread, fase);
+    const prompt = `${secao(ponto, original.promptSha256)}${original.prompt}`;
+    const promptSha256 = hash(prompt);
+    const pasta = path.join((0, thread_1.dirThread)(raiz, thread.id), 'prompts');
+    const promptPath = path.join(pasta, `retomada-${fase.toLowerCase()}-${promptSha256.slice(0, 12)}.md`);
+    if (gravar) {
+        fs.mkdirSync(pasta, { recursive: true });
+        try {
+            fs.writeFileSync(promptPath, prompt, { flag: 'wx', mode: 0o600 });
+        }
+        catch (e) {
+            if (e.code !== 'EEXIST' || hash(fs.readFileSync(promptPath, 'utf8')) !== promptSha256)
+                throw e;
+        }
+    }
+    return { prompt, promptPath, promptSha256, promptOriginalPath: original.promptPath,
+        promptOriginalSha256: original.promptSha256, ponto };
+}