primocode 9.8.0-beta.0 → 9.8.0-beta.2

package/lib/codex-engine.js

@@ -0,0 +1,207 @@
+/**
+ * codex-engine.js — motor do agente rodando no Codex da SUA conta.
+ *
+ *   "Você pode usar a barra codex para usar os modelos com a sua conta. No
+ *    Claude ele usa o modelo Opus 5; no Codex ele vai usar o modelo baratinho
+ *    ali."
+ *
+ * ── É UM MOTOR NOVO, NÃO UM PROTOCOLO NOVO ───────────────────────────────
+ * O que ensina um modelo de fora a ser cérebro do PrimoCode — o texto do
+ * protocolo, a leitura do bloco marcado, a volta para consertar o que veio
+ * torto — mora inteiro no claude-engine.js e é IMPORTADO daqui. Copiar
+ * aquilo para cá daria dois protocolos, e o segundo começaria a divergir do
+ * primeiro na primeira correção feita só de um lado — sem erro nenhum
+ * aparecendo, só um dos motores ficando pior que o outro com o tempo.
+ *
+ * O que muda de verdade entre os dois é uma coisa só: qual programa se chama
+ * e com quais argumentos. É isso, e só isso, que este arquivo tem.
+ *
+ * ── POR QUE LER A SAÍDA COMO TEXTO CRU ───────────────────────────────────
+ * O `claude -p` tem `--output-format json` e o formato é estável. O `codex`
+ * mudou de forma mais de uma vez, e amarrar-se ao JSON dele seria escolher
+ * quebrar no dia em que ele mudar de novo — calado, porque a saída
+ * continuaria vindo, só que com outras chaves.
+ *
+ * Então aqui se lê o texto e se procura o bloco marcado nele, que é o que o
+ * `extrairDecisao` já faz: ele varre ruído de terminal e fica com o último
+ * bloco legível. Enquanto o Codex escrever o bloco em algum lugar da saída,
+ * este motor funciona — independente de como ele embrulhe o resto.
+ */
+
+'use strict';
+
+const { execSync, execFileSync } = require('child_process');
+
+/* O MOTOR EXTERNO NÃO APARECE — a mesma regra do claude-engine, e o mesmo
+   comentário longo mora lá. Em resumo: `execFileSync` sem `stdio` HERDA o
+   stderr, e um aviso do Codex cairia no meio da tela do PrimoCode com a cara de
+   outro produto. Capturado, ele some da tela e `e.stderr` passa a existir — o
+   `catch` daqui já lia esse campo e estava lendo `null` desde sempre. */
+const SEM_APARECER = { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true };
+
+const claude = require('./claude-engine');
+
+/**
+ * O modelo barato do Codex.
+ *
+ * O /claude vai no Opus porque ali o que se quer é a decisão mais certa. Aqui
+ * o pedido foi o contrário — "o modelo baratinho" — e faz sentido: quem liga
+ * o /codex está usando a franquia da própria conta, e o motor do PrimoCode dá
+ * muitas voltas por tarefa.
+ *
+ * Vazio manda sem `--model`, e vale o padrão da conta. E se o Codex recusar
+ * este modelo, o motor tenta de novo SEM ele em vez de morrer — ver
+ * `chamarCodex`.
+ */
+const MODELO_CODEX = process.env.PRIMOCODE_CODEX_MODELO !== undefined
+    ? process.env.PRIMOCODE_CODEX_MODELO
+    : 'gpt-5-mini';
+
+/** O programa. Trocável para o teste pôr um de mentira no lugar. */
+const CODEX = process.env.PRIMOCODE_CODEX_BIN || 'codex';
+
+const TEMPO = 180000;
+const BUFFER = 32 * 1024 * 1024;
+
+function temCodex(executor = (cmd) => execSync(cmd, { stdio: ['ignore', 'pipe', 'ignore'] })) {
+    try { executor(`${CODEX} --version`); return true; }
+    catch { return false; }
+}
+
+/**
+ * O que o `codex exec` desta máquina aceita.
+ *
+ * Passar uma opção que a versão instalada não conhece não dá "opção
+ * desconhecida" e pronto: dá uma saída de ajuda no lugar da resposta, e o
+ * motor devolveria "não consegui ler a decisão" em toda rodada — com a
+ * pessoa sem nenhuma pista de que o problema é uma flag.
+ *
+ * Perguntar ao `--help` custa uma chamada por sessão e responde com o que
+ * ESTA versão faz, em vez do que a versão de hoje fazia quando isto foi
+ * escrito.
+ */
+let _ajuda = null;
+function ajudaDoExec(executor) {
+    if (_ajuda !== null) return _ajuda;
+    const rodar = executor || ((args) => execFileSync(CODEX, args,
+        { encoding: 'utf-8', timeout: 20000, ...SEM_APARECER }));
+    try { _ajuda = String(rodar(['exec', '--help']) || ''); }
+    catch { _ajuda = ''; }        // sem ajuda: segue com o mínimo
+    return _ajuda;
+}
+
+function esquecerAjuda() { _ajuda = null; }
+
+/**
+ * Os argumentos da chamada.
+ *
+ * `--skip-git-repo-check` só entra se esta versão o conhecer: sem ele, o
+ * Codex se recusa a rodar fora de um repositório git — e o PrimoCode trabalha
+ * em pasta comum o tempo todo.
+ */
+function argsDoExec({ comModelo = true, ajuda = null } = {}) {
+    const h = ajuda === null ? ajudaDoExec() : ajuda;
+    const args = ['exec'];
+    if (h.includes('--skip-git-repo-check')) args.push('--skip-git-repo-check');
+    // O Codex pede confirmação para agir na máquina. Aqui ele não age: o
+    // protocolo proíbe ferramenta nativa, quem executa é o PrimoCode. A opção
+    // só evita que ele pare esperando uma resposta que ninguém vai dar.
+    if (h.includes('--dangerously-bypass-approvals-and-sandbox')) {
+        args.push('--dangerously-bypass-approvals-and-sandbox');
+    } else if (h.includes('--full-auto')) {
+        args.push('--full-auto');
+    }
+    if (comModelo && MODELO_CODEX) args.push('--model', MODELO_CODEX);
+    // O prompt vai por STDIN: por argumento ele teria limite de tamanho (a
+    // conversa cresce) e qualquer texto começando com traço seria lido como
+    // opção. `-` é como o exec pede para ler da entrada.
+    args.push('-');
+    return args;
+}
+
+/** Um modelo que a conta não tem é o erro mais provável desta chamada — e o
+ *  único que dá para consertar sozinho. */
+function recusouOModelo(texto) {
+    return /model|modelo/i.test(texto)
+        && /not (found|available|supported)|unknown|invalid|does not|inexistente|inválid/i.test(texto);
+}
+
+/**
+ * Chama o Codex e devolve o texto. Se ele recusar o modelo, tenta UMA vez sem
+ * `--model` e avisa — cair para o padrão da conta é melhor que a tarefa
+ * morrer por causa de um nome que mudou de catálogo.
+ */
+function chamarCodex(prompt, { executor, avisar = () => {} } = {}) {
+    // A chave própria da pessoa, quando ela configurou uma. Sem configuração
+    // o ambiente vai INTACTO — passar a variável vazia apagaria a chave que
+    // ela já tem exportada no shell, e o Codex pararia de funcionar por ter
+    // sido "configurado".
+    const rodar = executor || ((args, entrada) => execFileSync(CODEX, args, {
+        encoding: 'utf-8', timeout: TEMPO, input: entrada, maxBuffer: BUFFER,
+        env: process.env, ...SEM_APARECER,
+    }));
+    try {
+        return rodar(argsDoExec(), prompt);
+    } catch (e) {
+        const detalhe = `${e.message || ''}\n${(e.stderr || '')}\n${(e.stdout || '')}`;
+        if (MODELO_CODEX && recusouOModelo(detalhe)) {
+            avisar(`o Codex não aceitou o modelo ${MODELO_CODEX} — indo com o padrão da sua conta`);
+            return rodar(argsDoExec({ comModelo: false }), prompt);
+        }
+        throw new Error(primeiraLinhaUtil(detalhe) || e.message);
+    }
+}
+
+/** A primeira linha que diz alguma coisa. O erro do Codex costuma vir com
+ *  banner, versão e caminho antes do motivo, e jogar tudo isso na tela é
+ *  esconder o motivo no meio. */
+function primeiraLinhaUtil(texto) {
+    for (const linha of String(texto || '').split('\n')) {
+        const l = linha.trim();
+        if (l && !/^(Command failed|codex\b|\s*$)/i.test(l)) return l.slice(0, 300);
+    }
+    return '';
+}
+
+function garantirEngine() {
+    if (!temCodex()) {
+        return {
+            ok: false,
+            error: 'O Codex não está instalado nesta máquina.',
+            comoResolver: 'Instale o Codex CLI da OpenAI, entre na sua conta com `codex login`, '
+                + 'e escolha Codex no /api de novo.',
+        };
+    }
+    return { ok: true, modelo: MODELO_CODEX || '(o padrão da sua conta)' };
+}
+
+/** Mesma forma de api.requestAct(server, payload, onEvent) — é isso que deixa
+ *  o lib/act.js trocar de motor sem saber de nada disto. */
+async function requestAct(server, payload, onEvent) {
+    try {
+        const pronto = garantirEngine();
+        if (!pronto.ok) {
+            onEvent({ erro: `${pronto.error} ${pronto.comoResolver || ''}`.trim() });
+            return;
+        }
+        const prompt = claude.promptDoProtocolo(payload);
+        const saida = chamarCodex(prompt, { avisar: (m) => onEvent({ aviso: m }) });
+
+        // A correção é uma segunda ida ao motor, com o mesmo protocolo e o
+        // diagnóstico do que saiu errado. Barata, e evita que um erro de forma
+        // do motor vire erro na cara de quem pediu a tarefa.
+        const pedirCorrecao = (aviso) => chamarCodex(claude.promptDeCorrecao(aviso));
+
+        await claude.emitirDecisao(saida, onEvent, pedirCorrecao, 0,
+            claude.nomesDasTools(payload));
+    } catch (e) {
+        onEvent({ erro: e.message });
+    }
+}
+
+module.exports = {
+    MODELO_CODEX, CODEX,
+    temCodex, garantirEngine, requestAct,
+    argsDoExec, ajudaDoExec, esquecerAjuda,
+    chamarCodex, recusouOModelo, primeiraLinhaUtil,
+};