primocode 9.8.0-beta.1 → 9.8.0-beta.3

package/lib/act.js

@@ -21,7 +21,9 @@ const repeticao = require('./repeticao');
 const diff = require('./diff');
 const registro = require('./registro');
 const permissao = require('./permissao');
+const perigo = require('./perigo');
 const skills = require('./skills');
+const checkpoint = require('./checkpoint');
 
 // 40, não 15: com o freio de repetição (repeticao.js) e o de rodada parada,
 // volta a mais não é volta em círculo — é trabalho. Quinze acabavam no meio
@@ -475,6 +477,11 @@ function mapaDoProjeto(dir, limite = 80) {
 
 function buildMemoryContext(projectDir, projectName) {
     const parts = [];
+    // As instruções vêm primeiro: são regra de quem manda no projeto, e a
+    // memória é o que o agente anotou. Entram aqui (e não no bin) para valer
+    // igual no terminal, no modo voz e em cada passo de um plano.
+    const instrucoes = require('./mencoes.js').instrucoesDoProjeto(projectDir);
+    if (instrucoes) parts.push(instrucoes);
     const geral = cfg.readGeneralMemory();
     if (geral.trim()) parts.push(`[memory-geral.md]\n${geral}`);
     const projeto = cfg.readProjectMemory(projectDir);
@@ -493,6 +500,10 @@ async function runAct(userPrompt, opts) {
            quem sabe lembrar é a SESSÃO — um subagente não pode começar do
            zero e pedir de novo o que já foi autorizado. */
         autorizar = null, controle = null,
+        /* O modo do /permissoes (auto · perguntar · livre). Vem da config pela
+           CLI e desce para os subagentes pelo ctx: eles recusam o perigoso,
+           mas só sabem que é "livre" se alguém disser. */
+        permissoes = 'auto',
         /* O cliente HTTP, injetável. NÃO é mais um comutador de motor — o
            PrimoCode tem um motor só, o do servidor, e não há provedor para o
            usuário escolher. Continua um parâmetro porque é por aqui que o
@@ -962,7 +973,7 @@ async function runAct(userPrompt, opts) {
             fala.paralelo(juntos.length, profundidade);
             const rs = await Promise.all(juntos.map((tc) =>
                 runSubagent(tc.arguments || {}, {
-                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
                 }).catch((e) => `Subagente falhou: ${e && e.message}`)));
             juntos.forEach((tc, i) => resultadosSpawn.set(tc.id, rs[i]));
         }
@@ -1005,7 +1016,7 @@ async function runAct(userPrompt, opts) {
                 const r = resultadosSpawn.has(tc.id)
                     ? resultadosSpawn.get(tc.id)
                     : await runSubagent(tc.arguments || {}, {
-                        server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
+                        server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
                     });
                 repeticao.executou(jaChamado, tc.name, tc.arguments);
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: r });
@@ -1018,7 +1029,7 @@ async function runAct(userPrompt, opts) {
                 algoRodou = true;
                 fala.acao(tc.name, tc.arguments, profundidade);
                 const r = await rodarDiretor(tc.arguments || {}, {
-                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
                 });
                 logResult(tc.name, r, profundidade);
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(r) });
@@ -1036,7 +1047,7 @@ async function runAct(userPrompt, opts) {
                 garantirPasta();
                 fala.acao(tc.name, tc.arguments, profundidade);
                 const r = await rodarPipeline(tc.arguments || {}, {
-                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, livro, autorizar, controle: portaoControle,
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes, livro, autorizar, controle: portaoControle,
                 });
                 logResult(tc.name, r, profundidade);
                 repeticao.executou(jaChamado, tc.name, tc.arguments);
@@ -1087,9 +1098,30 @@ async function runAct(userPrompt, opts) {
                 }
             }
 
+            /* O PORTÃO do que não tem volta (lib/perigo.js). No mesmo lugar do
+               portão do desktop e pelo mesmo motivo: antes, não depois. A
+               resposta mora no mesmo objeto da sessão — quem lembra é ela. */
+            if (!portaoControle.perigo) portaoControle.perigo = perigo.novo();
+            const risco = await perigo.portao(portaoControle.perigo, {
+                modo: permissoes, nome: tc.name, args: tc.arguments,
+                projectDir: pastaAtual, subagent, perguntar: autorizar,
+            });
+            if (!risco.ok) {
+                fala.acao(tc.name, tc.arguments, profundidade);
+                console.log(fala.resultado(profundidade) + c.warn(`não autorizado — ${risco.motivo}`));
+                registro.anotar(livro, tc.name, tc.arguments, { ok: false, error: risco.error });
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({ ok: false, error: risco.error }) });
+                continue;
+            }
+
             algoRodou = true;
             rodouTool = true;
             fala.acao(tc.name, tc.arguments, profundidade);
+            /* Antes de mexer no arquivo, guarda o original — é o que o /desfazer
+               devolve. Caminho inválido não é problema nosso: a tool recusa. */
+            if (checkpoint.MUDAM_ARQUIVO.has(tc.name)) {
+                try { checkpoint.antesDeMudar(tools.resolveInProject(tc.arguments && tc.arguments.path, pastaAtual), pastaAtual); } catch {}
+            }
             const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual });
             logResult(tc.name, result, profundidade);
             repeticao.executou(jaChamado, tc.name, tc.arguments);
@@ -1232,7 +1264,7 @@ async function runAct(userPrompt, opts) {
 }
 
 async function runSubagent(args, ctx) {
-    const { server, model, token, projectDir, projectName, profundidade, motor } = ctx;
+    const { server, model, token, projectDir, projectName, profundidade, motor, permissoes } = ctx;
     const descricao = args.description || 'sub-tarefa';
 
     if (profundidade + 1 >= MAX_PROFUNDIDADE) {
@@ -1251,6 +1283,7 @@ async function runSubagent(args, ctx) {
         profundidade: profundidade + 1,
         subagent: true,
         motor,
+        permissoes,
         autorizar: ctx.autorizar,
         controle: ctx.controle,   // o mesmo objeto: a resposta vale para todos
     });
@@ -1294,7 +1327,7 @@ async function runSubagent(args, ctx) {
  * inventar — e inventar é onde ele erra.
  */
 async function rodarDiretor(args, ctx) {
-    const { server, model, token, projectDir, projectName, profundidade, motor } = ctx;
+    const { server, model, token, projectDir, projectName, profundidade, motor, permissoes } = ctx;
     if (profundidade > 0) {
         return { ok: false, error: 'Recusado: o diretor não roda dentro de um subagente. '
             + 'Produza com o plano que você já recebeu.' };
@@ -1305,7 +1338,7 @@ async function rodarDiretor(args, ctx) {
         fala.agente('Diretor', rotulo, profundidade);
         const r = await runAct(prompt, {
             server, model, token, projectDir, projectName,
-            history: [], profundidade: profundidade + 1, subagent: true, motor,
+            history: [], profundidade: profundidade + 1, subagent: true, motor, permissoes,
         });
         return (r && r.assistantMessage && r.assistantMessage.content) || '';
     };
@@ -1338,7 +1371,7 @@ async function rodarDiretor(args, ctx) {
 }
 
 async function rodarPipeline(args, ctx) {
-    const { server, model, token, projectDir, projectName, profundidade, motor } = ctx;
+    const { server, model, token, projectDir, projectName, profundidade, motor, permissoes } = ctx;
     if (profundidade > 0) {
         return { ok: false, error: 'Recusado: o pipeline não roda dentro de um subagente — '
             + 'os papéis dele já são subagentes. Faça a parte que te cabe.' };
@@ -1361,7 +1394,7 @@ async function rodarPipeline(args, ctx) {
         fala.agente('Agente', rotulo, profundidade);
         const r = await runAct(prompt, {
             server, model, token, projectDir: pasta, projectName,
-            history: [], profundidade: profundidade + 1, subagent: true, motor,
+            history: [], profundidade: profundidade + 1, subagent: true, motor, permissoes,
         });
         return (r && r.assistantMessage && r.assistantMessage.content) || '';
     };
@@ -1376,5 +1409,5 @@ async function rodarPipeline(args, ctx) {
     });
 }
 
-module.exports = { runAct, interromper, compactar, motivoDaParada, pareceParadaNoMeio, ehTetoDeToken, ehTransitorio, esperaDoErro,
+module.exports = { runAct, buildMemoryContext, interromper, compactar, motivoDaParada, pareceParadaNoMeio, ehTetoDeToken, ehTransitorio, esperaDoErro,
     anotacaoDoQueJaFoi, encolherParaContinuar, MAX_ITERATIONS };

package/lib/api.js

@@ -206,8 +206,11 @@ function requestStream(serverUrl, endpoint, payload, onEvent, token, sinal) {
    O resto (login, transcrição, conectores) continua no servidor. */
 function local() {
     try {
-        const motor = require('./local/motor.js');
-        return motor.ativo() ? motor : null;
+        const atual = require('./local/provedor.js').atual();
+        if (!atual) return null;
+        // Claude Code e Codex: a ferramenta de fora é o cérebro.
+        if (atual.cli) return require('./local/motor-cli.js').criar(atual.id);
+        return require('./local/motor.js');
     } catch { return null; }
 }
 

package/lib/checkpoint.js

@@ -0,0 +1,134 @@
+/**
+ * checkpoint.js — toda mudança do agente num arquivo tem volta.
+ *
+ * Quem usa o PrimoCode quase nunca sabe git. Uma edição ruim ("ele apagou
+ * metade do meu site") não pode ser o fim da história: antes de o agente
+ * escrever, editar ou apagar um arquivo, guardamos o conteúdo ORIGINAL dele,
+ * uma vez por pedido. O `/desfazer` devolve tudo como estava.
+ *
+ * Por que o checkpoint é do PEDIDO e não do passo: um pedido vira vários
+ * runAct (passos do plano, continuações, subagentes). Para a pessoa, "desfaz"
+ * quer dizer "desfaz o que eu pedi", não "desfaz o terceiro passo interno".
+ * Por isso o CLI chama `iniciar(pedido)` antes do laço de passos, e o loop do
+ * agente só avisa `antesDeMudar(arquivo, pasta)` — o estado fica aqui, no
+ * módulo, e o subagente (mesmo processo) cai no mesmo checkpoint.
+ *
+ * Onde fica: ~/.primocode/checkpoints/<projeto>-<hash>/<id>/
+ *   manifest.json   o pedido, a hora e cada arquivo (existia ou não)
+ *   0, 1, 2…        a cópia original de cada arquivo que existia
+ * Só os últimos MAXIMO por projeto: é rede de segurança, não arquivo morto.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+
+const MAXIMO = 20;
+/** As tools de arquivo que mudam o disco. run_shell fica de fora: não dá para
+    saber, antes de rodar, que arquivos um comando vai tocar. */
+const MUDAM_ARQUIVO = new Set(['write_file', 'edit_file', 'multi_edit']);
+
+let atual = null;   // o pedido em andamento: { pedido, dir, manifest }
+
+/* os.homedir() lido na hora, não no require: o teste troca o HOME. */
+function raiz() { return path.join(os.homedir(), '.primocode', 'checkpoints'); }
+
+/** Uma pasta por projeto: o nome para a pessoa reconhecer, o hash para dois
+    projetos "site" em lugares diferentes não se misturarem. */
+function pastaDoProjeto(projectDir) {
+    const abs = path.resolve(projectDir);
+    const nome = path.basename(abs).replace(/[^\w.-]+/g, '-').slice(0, 40) || 'raiz';
+    const hash = crypto.createHash('sha1').update(abs).digest('hex').slice(0, 8);
+    return path.join(raiz(), `${nome}-${hash}`);
+}
+
+/** Começa o checkpoint de um pedido. Nada vai ao disco ainda: pedido que não
+    mexe em arquivo (uma pergunta, uma pesquisa) não deixa checkpoint vazio. */
+function iniciar(pedido) {
+    atual = { pedido: String(pedido || '').replace(/\s+/g, ' ').trim(), dir: null, manifest: null };
+}
+
+function encerrar() { atual = null; }
+
+function gravarManifest() {
+    fs.writeFileSync(path.join(atual.dir, 'manifest.json'), JSON.stringify(atual.manifest, null, 2));
+}
+
+/** Chamado pelo loop ANTES de uma tool de arquivo rodar. Guarda o original só
+    na primeira vez que o arquivo é tocado no pedido — a segunda edição do
+    mesmo arquivo não pode sobrescrever o original com a versão já editada. */
+function antesDeMudar(caminhoAbs, projectDir) {
+    if (!atual || !caminhoAbs) return;
+    try {
+        if (!atual.dir) {
+            const base = pastaDoProjeto(projectDir);
+            fs.mkdirSync(base, { recursive: true });
+            // Sempre maior que o anterior: a ordem dos ids É a ordem dos pedidos.
+            const ultimo = fs.readdirSync(base).filter((n) => /^\d+$/.test(n)).reduce((m, n) => Math.max(m, Number(n)), 0);
+            const id = String(Math.max(Date.now(), ultimo + 1));
+            atual.dir = path.join(base, id);
+            fs.mkdirSync(atual.dir);
+            atual.manifest = { pedido: atual.pedido, quando: new Date().toISOString(),
+                projectDir: path.resolve(projectDir), arquivos: [] };
+            podar(base);
+        }
+        const abs = path.resolve(caminhoAbs);
+        if (atual.manifest.arquivos.some((a) => a.caminho === abs)) return;
+        const existia = fs.existsSync(abs) && fs.statSync(abs).isFile();
+        const item = { caminho: abs, existia };
+        if (existia) {
+            item.copia = String(atual.manifest.arquivos.length);
+            fs.copyFileSync(abs, path.join(atual.dir, item.copia));
+        }
+        atual.manifest.arquivos.push(item);
+        gravarManifest();
+    } catch { /* checkpoint nunca derruba o trabalho do agente */ }
+}
+
+function podar(base) {
+    const ids = fs.readdirSync(base).filter((n) => /^\d+$/.test(n)).sort((a, b) => Number(b) - Number(a));
+    for (const velho of ids.slice(MAXIMO)) fs.rmSync(path.join(base, velho), { recursive: true, force: true });
+}
+
+/** Os checkpoints do projeto, o mais novo primeiro. */
+function lista(projectDir) {
+    const base = pastaDoProjeto(projectDir);
+    let ids = [];
+    try { ids = fs.readdirSync(base).filter((n) => /^\d+$/.test(n)); } catch { return []; }
+    return ids.sort((a, b) => Number(b) - Number(a)).map((id) => {
+        try {
+            const m = JSON.parse(fs.readFileSync(path.join(base, id, 'manifest.json'), 'utf8'));
+            return { id, dir: path.join(base, id), ...m };
+        } catch { return null; }
+    }).filter(Boolean);
+}
+
+/** Desfaz os N pedidos mais recentes, do mais novo para o mais velho — assim,
+    se dois pedidos mexeram no mesmo arquivo, o que sobra é o original do mais
+    antigo. Cada checkpoint desfeito é apagado: o próximo /desfazer volta mais
+    um pedido, em vez de repetir o mesmo. */
+function desfazer(projectDir, n = 1) {
+    const feitos = [];
+    for (const cp of lista(projectDir).slice(0, Math.max(1, n))) {
+        for (const a of cp.arquivos) {
+            try {
+                if (a.existia) {
+                    fs.mkdirSync(path.dirname(a.caminho), { recursive: true });
+                    fs.copyFileSync(path.join(cp.dir, a.copia), a.caminho);
+                    feitos.push({ caminho: a.caminho, acao: 'restaurado' });
+                } else {
+                    fs.rmSync(a.caminho, { force: true });
+                    feitos.push({ caminho: a.caminho, acao: 'apagado' });
+                }
+            } catch (e) { feitos.push({ caminho: a.caminho, acao: 'falhou', erro: e.message }); }
+        }
+        fs.rmSync(cp.dir, { recursive: true, force: true });
+        if (atual && atual.dir === cp.dir) atual = null;
+    }
+    return feitos;
+}
+
+module.exports = { MAXIMO, MUDAM_ARQUIVO, iniciar, encerrar, antesDeMudar, lista, desfazer, pastaDoProjeto };