@orkastery/cli 0.6.3 → 0.6.5

package/dist/check-selecao.js

@@ -0,0 +1,149 @@
+"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.CONTRATO_DA_SELECAO = void 0;
+exports.comandoDaSelecao = comandoDaSelecao;
+exports.planejarSelecaoNativa = planejarSelecaoNativa;
+/** RM-081 F5: decisão conservadora da seleção nativa por mudanças no Agile. */
+const path = __importStar(require("node:path"));
+const leases_1 = require("./leases");
+const manifest_1 = require("./manifest");
+const util_1 = require("./util");
+exports.CONTRATO_DA_SELECAO = 'ork.check.selecao/v1';
+const LOCKFILES = new Set(['package-lock.json', 'npm-shrinkwrap.json', 'pnpm-lock.yaml', 'yarn.lock', 'poetry.lock',
+    'Pipfile.lock', 'go.mod', 'go.sum', 'Package.resolved']);
+function objeto(v) {
+    return v && typeof v === 'object' && !Array.isArray(v) ? v : null;
+}
+function sha(v) {
+    return typeof v === 'string' && /^[0-9a-f]{40,64}$/i.test(v);
+}
+/** Um argumento shell fechado, como o filtro nominal da F3. */
+function argumento(valor) {
+    return `'${valor.replace(/'/g, `'"'"'`)}'`;
+}
+function comandoDaSelecao(declaracao, base, arquivos) {
+    return declaracao.comando.includes('{base}')
+        ? declaracao.comando.replace('{base}', argumento(base))
+        : declaracao.comando.replace('{arquivos}', arquivos.map(argumento).join(' '));
+}
+function baseAtual(cwd, manifesto, commit) {
+    const r = (0, util_1.exec)('git', ['merge-base', commit, manifesto.worktree.base_branch], cwd);
+    const base = r.stdout.trim();
+    return r.ok && sha(base) ? base : null;
+}
+function arvoreLimpa(cwd) {
+    const r = (0, util_1.exec)('git', ['status', '--porcelain=v1', '-z', '--untracked-files=all', '--', '.', ':(exclude).orkastery'], cwd);
+    return r.ok && r.stdout === '';
+}
+function arquivosMudados(cwd, anterior, atual) {
+    const r = (0, util_1.exec)('git', ['diff', '--name-only', '--no-renames', '-z', anterior, atual, '--', '.', ':(exclude).orkastery'], cwd);
+    if (!r.ok)
+        return null;
+    return [...new Set(r.stdout.split('\0').filter(Boolean).map((arquivo) => arquivo.split(path.sep).join('/')))].sort();
+}
+function lockfile(arquivo) {
+    const nome = path.posix.basename(arquivo);
+    return LOCKFILES.has(nome) || /^requirements(?:\.[^.]+)?\.txt$/.test(nome)
+        || /(?:^|[.-])lock(?:b|\.(?:json|ya?ml|toml))?$/i.test(nome);
+}
+function inteira(motivo, arquivos) {
+    return { modo: 'inteira', motivo, ...(arquivos?.length ? { arquivos } : {}) };
+}
+function todasInteiras(declaracoes, motivo, arquivos) {
+    return Object.fromEntries(Object.keys(declaracoes).map((lane) => [lane, inteira(motivo, arquivos)]));
+}
+/**
+ * Decide uma vez, antes dos comandos. O último `verify_run` é o cache: qualquer forma desconhecida,
+ * veredito vermelho, base diferente ou árvore suja devolve a suíte inteira.
+ */
+function planejarSelecaoNativa(cwd, manifesto, eventos, commit, modo) {
+    const declaracoes = manifesto.check?.agile?.selecao ?? {};
+    if (modo !== 'agile' || Object.keys(declaracoes).length === 0)
+        return { lanes: {}, cache: null };
+    const base = baseAtual(cwd, manifesto, commit);
+    const limpa = arvoreLimpa(cwd);
+    const cache = base && limpa ? { contrato: exports.CONTRATO_DA_SELECAO, base, head: commit } : null;
+    const ultima = [...eventos].reverse().find((evento) => evento.tipo === 'verify_run');
+    if (!ultima)
+        return { lanes: todasInteiras(declaracoes, 'rodada-fria'), cache };
+    const anterior = objeto(ultima.selecao);
+    if (!anterior)
+        return { lanes: todasInteiras(declaracoes, 'cache-ausente'), cache };
+    if (!base || !limpa || ultima.veredito !== 'verdade sustentada' || anterior.contrato !== exports.CONTRATO_DA_SELECAO
+        || !sha(anterior.base) || !sha(anterior.head) || anterior.head !== ultima.commit) {
+        return { lanes: todasInteiras(declaracoes, 'cache-invalido'), cache };
+    }
+    if (anterior.base !== base)
+        return { lanes: todasInteiras(declaracoes, 'base-mudou'), cache };
+    if (!(0, util_1.exec)('git', ['merge-base', '--is-ancestor', anterior.head, commit], cwd).ok) {
+        return { lanes: todasInteiras(declaracoes, 'cache-invalido'), cache };
+    }
+    const mudados = arquivosMudados(cwd, anterior.head, commit);
+    if (!mudados)
+        return { lanes: todasInteiras(declaracoes, 'cache-invalido'), cache };
+    const manifestos = new Set([manifest_1.NOME_MANIFESTO, manifest_1.NOME_MANIFESTO_LEGADO]);
+    const mudancaNoManifesto = mudados.filter((arquivo) => manifestos.has(path.posix.basename(arquivo)));
+    if (mudancaNoManifesto.length)
+        return { lanes: todasInteiras(declaracoes, 'manifesto-mudou', mudancaNoManifesto), cache };
+    const lockfiles = mudados.filter(lockfile);
+    if (lockfiles.length)
+        return { lanes: todasInteiras(declaracoes, 'lockfile-mudou', lockfiles), cache };
+    const lanes = {};
+    for (const [lane, declaracao] of Object.entries(declaracoes)) {
+        if (!declaracao.mapeia.length) {
+            lanes[lane] = inteira('runner-sem-garantia');
+            continue;
+        }
+        const configuracao = mudados.filter((arquivo) => (declaracao.configuracao ?? [])
+            .some((glob) => (0, leases_1.caminhoBateComGlob)(arquivo, glob)));
+        if (configuracao.length) {
+            lanes[lane] = inteira('configuracao-mudou', configuracao);
+            continue;
+        }
+        const fora = mudados.filter((arquivo) => !declaracao.mapeia.some((glob) => (0, leases_1.caminhoBateComGlob)(arquivo, glob)));
+        if (fora.length) {
+            lanes[lane] = inteira('fora-do-mapeamento', fora);
+            continue;
+        }
+        if (!mudados.length) {
+            lanes[lane] = inteira('sem-mudancas');
+            continue;
+        }
+        lanes[lane] = { modo: 'selecionada', motivo: 'selecionada', arquivos: mudados,
+            base: anterior.head, comando: comandoDaSelecao(declaracao, anterior.head, mudados) };
+    }
+    return { lanes, cache };
+}

package/dist/codex-task-complete.js

@@ -0,0 +1,95 @@
+"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.taskCompleteFixadoDaFonte = taskCompleteFixadoDaFonte;
+exports.taskCompleteFixadoDaSessao = taskCompleteFixadoDaSessao;
+/** RM-075: prova somente leitura de `task_complete` no rollout já fixado pelo controller. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const codex_controller_sensor_1 = require("./adapters/codex-controller-sensor");
+const codex_events_1 = require("./adapters/codex-events");
+const thread_1 = require("./thread");
+const BLOCO = 256 * 1024;
+const chaveDaFonte = (sessionId, despachoEm) => (0, node_crypto_1.createHash)('sha256').update(sessionId + '|' + despachoEm).digest('hex');
+/** O parser percorre o descritor autenticado inteiro; linha parcial ou corrupção não prova terminal. */
+function taskCompleteFixadoDaFonte(fonte, agoraMs = Date.now()) {
+    return (0, codex_controller_sensor_1.consumirRolloutControllerFixado)(fonte, (fd, tamanho) => {
+        const parser = new codex_events_1.ParserCodex();
+        let terminal = null;
+        for (let offset = 0; offset < tamanho;) {
+            const buffer = Buffer.alloc(Math.min(BLOCO, tamanho - offset));
+            const lidos = fs.readSync(fd, buffer, 0, buffer.length, offset);
+            if (lidos <= 0)
+                break;
+            for (const atual of parser.push(buffer.subarray(0, lidos), agoraMs))
+                terminal = atual;
+            offset += lidos;
+        }
+        if (parser.estado.invalido || parser.bytesPendentes > 0 || parser.estado.turnoAberto ||
+            terminal?.fonte !== 'rollout.task_complete' ||
+            (terminal.numeroTurno ?? 0) < parser.estado.turnos)
+            return null;
+        return { terminal, fonte };
+    });
+}
+/**
+ * Resolve somente a fixação correspondente ao despacho. Sem pin autenticado, controller ou cwd,
+ * devolve `null`: nunca descobre outro rollout para fabricar a prova.
+ */
+function taskCompleteFixadoDaSessao(raiz, thread, sessao, eventos, agoraMs = Date.now()) {
+    if (sessao.runtime !== 'codex')
+        return null;
+    const registro = eventos.filter(e => e.tipo === 'session_sensor_registered' &&
+        e.sessionId === sessao.sessionId && e.despachoEm === sessao.despachadaEm).at(-1);
+    if (typeof registro?.controlador !== 'string')
+        return null;
+    const despacho = eventos.filter(e => e.tipo === 'phase_dispatch' && e.sessionId === sessao.sessionId).at(-1);
+    if (despacho?.controlador !== undefined && despacho.controlador !== registro.controlador)
+        throw new Error('controlador registrado divergente do despacho');
+    const cwd = (despacho?.cwd ?? registro.cwd);
+    if (!cwd)
+        return null;
+    const dir = (0, thread_1.dirThread)(raiz, thread.id);
+    const chave = chaveDaFonte(sessao.sessionId, sessao.despachadaEm);
+    const esperado = {
+        dirSessoes: path.join(dir, 'sessoes'), sessionId: sessao.sessionId, cwd,
+        despachoEm: sessao.despachadaEm, agoraMs,
+        fixacao: path.join(dir, 'sessoes', `watcher-source-${chave}.json`),
+        vinculo: { thread: thread.id, fase: sessao.fase, promptSha256: sessao.promptSha256 },
+    };
+    const fonte = (0, codex_controller_sensor_1.lerFonteControllerFixada)(esperado.fixacao, esperado);
+    return fonte ? taskCompleteFixadoDaFonte(fonte, agoraMs) : null;
+}