primocode 10.17.1 → 11.0.0

package/lib/team.js

@@ -0,0 +1,317 @@
+/**
+ * team.js — o PrimoCode trabalha junto com as IAs de código que a pessoa já tem (26/10).
+ *
+ * "Um faz, o outro revisa." A pessoa já pagou o Claude Code, o Codex, o
+ * Gemini, o Antigravity ou o OpenCode: o `/team claude` liga um deles como
+ * parceiro. O PrimoCode faz a mudança e o parceiro revisa, só lendo; ou o
+ * parceiro faz (`/team claude faz <pedido>`) numa cópia do projeto e o
+ * PrimoCode mostra o que mudou antes de aplicar.
+ *
+ * As opções de cada um foram conferidas no `--help` de verdade (26/10), e
+ * conferidas de novo na hora de rodar (`precisa`): versão que não tem a opção
+ * não roda, em vez de rodar com uma opção adivinhada. Nenhum parceiro roda
+ * com a opção que pula as permissões dele.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/*
+ * `revisar` só lê; `fazer` edita a pasta onde roda (que é sempre uma cópia).
+ * `prompt` vai pelo stdin quando `stdin: true` (o `--tools` do claude engole o
+ * que vem depois). Conferido no `--help` em 26/10: claude 2.x, agy, opencode
+ * 1.x. O codex e o gemini não estão nesta máquina: as opções são as da
+ * documentação deles, e só rodam se o `--help` da versão instalada tiver todas.
+ */
+const PARCEIROS = {
+    claude: {
+        titulo: 'Claude Code', bin: 'claude', instalar: 'npm install -g @anthropic-ai/claude-code',
+        ajuda: ['--help'], precisa: ['--print', '--permission-mode', 'plan', 'acceptEdits', 'stream-json'],
+        stdin: true, formato: 'stream-json',
+        revisar: () => ['-p', '--permission-mode', 'plan', '--output-format', 'stream-json', '--verbose'],
+        fazer: () => ['-p', '--permission-mode', 'acceptEdits', '--output-format', 'stream-json', '--verbose'],
+    },
+    codex: {
+        titulo: 'Codex', bin: 'codex', instalar: 'npm install -g @openai/codex',
+        ajuda: ['exec', '--help'], precisa: ['--sandbox', 'read-only', 'workspace-write'],
+        revisar: (p) => ['exec', '--sandbox', 'read-only', p],
+        fazer: (p) => ['exec', '--sandbox', 'workspace-write', p],
+    },
+    gemini: {
+        titulo: 'Gemini CLI', bin: 'gemini', instalar: 'npm install -g @google/gemini-cli',
+        ajuda: ['--help'], precisa: ['--prompt', '--approval-mode', 'auto_edit'],
+        revisar: (p) => ['--approval-mode', 'default', '-p', p],
+        fazer: (p) => ['--approval-mode', 'auto_edit', '-p', p],
+    },
+    agy: {
+        titulo: 'Antigravity', bin: 'agy', instalar: 'baixe em antigravity.google',
+        ajuda: ['--help'], precisa: ['--print', '--mode', 'accept-edits'],
+        revisar: (p) => ['--print', p, '--mode', 'plan'],
+        fazer: (p) => ['--print', p, '--mode', 'accept-edits'],
+    },
+    opencode: {
+        titulo: 'OpenCode', bin: 'opencode', instalar: 'npm install -g opencode-ai',
+        ajuda: ['run', '--help'], precisa: ['--dir', '--agent'],
+        revisar: (p, dir) => ['run', '--dir', dir, '--agent', 'plan', p],
+        fazer: (p, dir) => ['run', '--dir', dir, p],
+    },
+};
+const NOMES = Object.keys(PARCEIROS);
+
+// As opções que tiram a trava do parceiro. Nunca entram (o teste confere).
+const PULA_PERMISSAO = /^(--dangerously-skip-permissions|--dangerously-bypass-approvals-and-sandbox|--yolo|-y|--auto|--full-auto|bypassPermissions|yolo|danger-full-access)$/;
+
+/** O caminho do programa no PATH, ou null. Sem rodar nada. */
+function achar(bin, { PATH = process.env.PATH || '', plataforma = process.platform, existe = fs.existsSync } = {}) {
+    const exts = plataforma === 'win32' ? ['.cmd', '.exe', '.bat', ''] : [''];
+    for (const pasta of PATH.split(path.delimiter).filter(Boolean)) {
+        for (const ext of exts) {
+            const p = path.join(pasta, bin + ext);
+            if (existe(p)) return p;
+        }
+    }
+    return null;
+}
+
+/** Os parceiros instalados: [{ nome, titulo, caminho }]. */
+function instalados(opts) {
+    return NOMES.map((nome) => ({ nome, titulo: PARCEIROS[nome].titulo, caminho: achar(PARCEIROS[nome].bin, opts) }))
+        .filter((x) => x.caminho);
+}
+
+/** `/team <arg>` → { acao: 'status' | 'ligar' | 'desligar' | 'fazer', nome?, pedido?, erro? }. */
+function entender(arg, achados) {
+    const t = String(arg || '').trim();
+    if (!t) return { acao: 'status' };
+    if (/^(off|desliga|desligar|sozinho|nenhum)$/i.test(t)) return { acao: 'desligar' };
+    const [primeira, ...resto] = t.split(/\s+/);
+    const nome = primeira.toLowerCase();
+    if (!PARCEIROS[nome]) return { erro: `Não conheço "${primeira}". Os parceiros são: ${NOMES.join(', ')}.` };
+    if (!achados.some((x) => x.nome === nome)) {
+        return { erro: `O ${PARCEIROS[nome].titulo} não está instalado neste computador. Pra instalar: ${PARCEIROS[nome].instalar}` };
+    }
+    if (!resto.length) return { acao: 'ligar', nome };
+    if (/^(faz|faça|faca|fazer|do)$/i.test(resto[0]) && resto.length > 1) return { acao: 'fazer', nome, pedido: resto.slice(1).join(' ') };
+    return { erro: `Não entendi "${resto.join(' ')}". Use /team ${nome} pra ligar, /team ${nome} faz <pedido>, ou /team off.` };
+}
+
+/** As linhas do `/team` sozinho. */
+function status(achados, ligado) {
+    if (!achados.length) {
+        return ['Nenhuma outra IA de código instalada: o PrimoCode trabalha sozinho, e dá conta.',
+            'Pra trabalhar em dupla, instale uma delas e digite /team <nome>:',
+            ...NOMES.map((n) => `  ${n} — ${PARCEIROS[n].instalar}`)];
+    }
+    const linhas = ['Parceiros instalados:'];
+    for (const x of achados) linhas.push(`  ${x.nome === ligado ? '●' : '○'} ${x.nome} (${x.titulo})${x.nome === ligado ? ' — ligado' : ''}`);
+    linhas.push(ligado
+        ? `Com o ${ligado} ligado: o PrimoCode faz e ele revisa. /team ${ligado} faz <pedido> deixa ele fazer · /team off desliga.`
+        : 'Nenhum ligado. /team <nome> liga: o PrimoCode faz e ele revisa.');
+    return linhas;
+}
+
+/* ── RODAR O PARCEIRO ──────────────────────────────────────────────── */
+
+const PRAZO = { revisar: Number(process.env.PRIMOCODE_TEAM_PRAZO || 5 * 60 * 1000), fazer: Number(process.env.PRIMOCODE_TEAM_PRAZO_FAZER || 15 * 60 * 1000) };
+const MAX_DIFF = 60000;
+
+// Segredo nunca vai no pedido: o arquivo inteiro (.env, chave) fica de fora, e o que parece chave vira "[segredo tirado]".
+const ARQUIVO_SECRETO = /(^|[/\\])(\.env(\..*)?|[^/\\]*\.(pem|key|p12|pfx)|id_rsa[^/\\]*|\.npmrc|\.netrc|credentials[^/\\]*)$/i;
+function semSegredo(texto) {
+    let t = String(texto || '');
+    for (const [, re] of require('./chave-exposta.js').TIPOS) t = t.replace(new RegExp(re.source, re.flags.replace('g', '') + 'g'), '[segredo tirado]');
+    return t;
+}
+
+const git = (dir, args, opts = {}) => require('child_process').execFileSync('git', args, { cwd: dir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'], maxBuffer: 32 * 1024 * 1024, ...opts });
+function ehGit(dir) { try { return git(dir, ['rev-parse', '--is-inside-work-tree']).trim() === 'true'; } catch { return false; } }
+
+/** O que o pedido mudou, como diff (git) ou como ficou cada arquivo (sem git). Sem segredo. '' = nada a revisar. */
+function diffDaVez(dir, arquivos) {
+    const rels = [...new Set(arquivos.map((a) => path.relative(dir, path.resolve(dir, String(a)))))]
+        .filter((r) => r && !r.startsWith('..') && !path.isAbsolute(r) && !ARQUIVO_SECRETO.test(r));
+    if (!rels.length) return '';
+    let texto = '';
+    if (ehGit(dir)) {
+        try { texto = git(dir, ['diff', 'HEAD', '--', ...rels]); } catch { texto = ''; }
+        let novos = [];
+        try { novos = git(dir, ['ls-files', '--others', '--exclude-standard', '--', ...rels]).split('\n').filter(Boolean); } catch { novos = []; }
+        for (const r of novos) texto += `\n--- /dev/null\n+++ b/${r}\n` + lerTexto(path.join(dir, r)).split('\n').map((l) => `+${l}`).join('\n');
+    } else {
+        for (const r of rels) if (fs.existsSync(path.join(dir, r))) texto += `\n=== ${r} (como ficou) ===\n${lerTexto(path.join(dir, r))}`;
+    }
+    texto = texto.trim();
+    if (texto.length > MAX_DIFF) texto = `${texto.slice(0, MAX_DIFF)}\n[… cortado: a mudança passa de ${Math.round(MAX_DIFF / 1000)} mil caracteres]`;
+    return semSegredo(texto);
+}
+function lerTexto(p) {
+    try { const b = fs.readFileSync(p); return b.includes(0) ? '[arquivo binário]' : b.toString('utf8'); } catch { return ''; }
+}
+
+function pedidoDeRevisao({ pedido, diff }) {
+    return 'Você é o revisor. Outra IA de código (o PrimoCode) acabou de fazer a mudança abaixo para o pedido da pessoa. '
+        + 'Revise SÓ LENDO: não edite arquivo e não rode nada que mude o projeto. '
+        + 'Procure bug, o que o pedido pediu e ficou faltando, e risco (segurança, dado perdido). '
+        + 'Responda em português do Brasil, simples, pra quem nunca programou: uma lista curta, do mais grave ao menos grave, '
+        + 'com o arquivo (e a linha, quando der). Se estiver tudo certo, responda só: NADA A CORRIGIR.\n\n'
+        + `PEDIDO DA PESSOA:\n${semSegredo(pedido)}\n\nA MUDANÇA:\n${diff}`;
+}
+const semProblema = (texto) => /NADA A CORRIGIR/i.test(texto) && String(texto).trim().length < 200;
+const pedidoDeConserto = (nome, revisao) => `A revisão do ${nome} achou isto no que você acabou de fazer. `
+    + `Corrija só o que for problema de verdade; o que não for, diga em uma frase por quê.\n\n${revisao}`;
+
+// As opções conferidas no --help da versão instalada, uma vez por sessão.
+const conferidas = new Map();
+function conferirOpcoes(nome, { caminho, rodar = require('child_process').spawnSync } = {}) {
+    if (conferidas.has(nome)) return conferidas.get(nome);
+    const p = PARCEIROS[nome];
+    const r = rodar(caminho || p.bin, p.ajuda, { encoding: 'utf8', timeout: 20000, env: ambiente() });
+    const ajuda = `${r.stdout || ''}${r.stderr || ''}`;
+    const falta = p.precisa.filter((x) => !ajuda.includes(x));
+    const erro = falta.length ? `O ${p.titulo} instalado não tem ${falta.join(', ')} no --help, e eu não rodo com opção adivinhada. Atualize ele (${p.instalar}).` : null;
+    conferidas.set(nome, erro);
+    return erro;
+}
+
+/** O ambiente do parceiro: o da pessoa, sem as variáveis do PrimoCode (o token da conta não sai daqui). */
+function ambiente() {
+    const env = { ...process.env };
+    for (const k of Object.keys(env)) if (/^PRIMOCODE_/.test(k)) delete env[k];
+    return env;
+}
+
+/* Uma linha do stream-json do claude → o que mostrar ao vivo, e o resultado final. */
+function lerEvento(linha) {
+    let ev;
+    try { ev = JSON.parse(linha); } catch { return { mostrar: linha }; }
+    if (ev.type === 'result') return { fim: String(ev.result || '') };
+    if (ev.type !== 'assistant' || !ev.message || !Array.isArray(ev.message.content)) return {};
+    const partes = ev.message.content.map((b) => (b.type === 'text' ? b.text
+        : b.type === 'tool_use' ? `${b.name} ${(b.input && (b.input.file_path || b.input.pattern || b.input.command || b.input.path)) || ''}`.trim() : '')).filter(Boolean);
+    return { mostrar: partes.join(' ') };
+}
+
+/**
+ * Roda o parceiro sem tela, na pasta `dir`, com prazo. As linhas dele saem ao
+ * vivo por `linha`. → { ok, texto } ou { ok: false, erro }.
+ */
+function rodar(nome, modo, { prompt, dir, linha = () => {}, prazo = PRAZO[modo], spawn = require('child_process').spawn, caminho, conferir = conferirOpcoes } = {}) {
+    const p = PARCEIROS[nome];
+    const args = p[modo](prompt, dir);
+    if (args.some((a) => PULA_PERMISSAO.test(a))) return Promise.resolve({ ok: false, erro: 'opção que pula a permissão do parceiro: recusado' });
+    const semOpcao = conferir(nome, { caminho });
+    if (semOpcao) return Promise.resolve({ ok: false, erro: semOpcao });
+    return new Promise((resolve) => {
+        let filho;
+        try {
+            filho = spawn(caminho || p.bin, args, { cwd: dir, env: ambiente(), stdio: [p.stdin ? 'pipe' : 'ignore', 'pipe', 'pipe'], shell: process.platform === 'win32' });
+        } catch (e) { resolve({ ok: false, erro: `Não consegui abrir o ${p.titulo}: ${e.message}` }); return; }
+        let saida = '', final = null, resto = '', ultimoErro = '', estourou = false;
+        const relogio = setTimeout(() => { estourou = true; try { filho.kill('SIGTERM'); } catch { /* já saiu */ } }, prazo);
+        const mostrar = (t) => { for (const l of String(t || '').split('\n')) if (l.trim()) linha(require('./ui').stripAnsi(l).slice(0, 200)); };
+        filho.stdout.on('data', (d) => {
+            resto += d.toString();
+            const linhas = resto.split('\n');
+            resto = linhas.pop();
+            for (const l of linhas) {
+                if (p.formato === 'stream-json') { const ev = lerEvento(l); if (ev.fim !== undefined) final = ev.fim; mostrar(ev.mostrar); } else { saida += `${l}\n`; mostrar(l); }
+            }
+        });
+        filho.stderr.on('data', (d) => { const t = d.toString().trim(); if (t) { ultimoErro = t.split('\n').pop(); mostrar(t); } });
+        if (p.stdin) filho.stdin.end(prompt);
+        filho.on('error', (e) => { clearTimeout(relogio); resolve({ ok: false, erro: `Não consegui abrir o ${p.titulo}: ${e.message}` }); });
+        filho.on('close', (codigo) => {
+            clearTimeout(relogio);
+            if (resto) { if (p.formato === 'stream-json') { const ev = lerEvento(resto); if (ev.fim !== undefined) final = ev.fim; } else saida += resto; }
+            if (estourou) return resolve({ ok: false, erro: `O ${p.titulo} passou de ${Math.round(prazo / 60000)} min e eu parei ele.` });
+            const texto = require('./ui').stripAnsi(final !== null ? final : saida).trim();
+            if (codigo !== 0 && !texto) return resolve({ ok: false, erro: `O ${p.titulo} saiu com erro (código ${codigo})${ultimoErro ? `: ${ultimoErro.slice(0, 160)}` : ''}.` });
+            resolve({ ok: true, texto });
+        });
+    });
+}
+
+/* ── O PARCEIRO FAZ, NUMA CÓPIA ──────────────────────────────────────
+ * `/team claude faz <pedido>`: o parceiro trabalha numa cópia do projeto (um
+ * git worktree, quando é git; senão uma cópia da pasta), nunca no projeto. O
+ * PrimoCode mede o que mudou, mostra, passa cada arquivo pelo portão dele
+ * (lib/perigo.js) e só aplica com o "sim" da pessoa. O .env não vai pra cópia. */
+
+const IDENTIDADE = ['-c', 'user.name=PrimoCode', '-c', 'user.email=primocode@local'];
+const FORA_DA_COPIA = /(^|[/\\])(node_modules|\.git)([/\\]|$)/;
+
+const real = (p) => { try { return fs.realpathSync(p); } catch { return path.resolve(p); } };
+
+function copiarArquivo(de, para) {
+    fs.mkdirSync(path.dirname(para), { recursive: true });
+    fs.copyFileSync(de, para);
+}
+
+/** → { pasta (onde o parceiro roda), raizCopia, aplicarEm, base (a árvore de antes), git, limpar() } */
+function prepararCopia(pastaDoProjeto) {
+    const dir = real(pastaDoProjeto);   // o git devolve o caminho real (/private/var no macOS)
+    const raizCopia = fs.mkdtempSync(path.join(require('os').tmpdir(), 'primocode-team-'));
+    if (ehGit(dir)) {
+        const raiz = git(dir, ['rev-parse', '--show-toplevel']).trim();
+        git(raiz, ['worktree', 'add', '--detach', raizCopia, 'HEAD']);
+        const limpar = () => { try { git(raiz, ['worktree', 'remove', '--force', raizCopia]); } catch { fs.rmSync(raizCopia, { recursive: true, force: true }); } };
+        try {
+            // O que ainda não tem commit também é do projeto: entra na cópia.
+            const sujo = git(raiz, ['diff', 'HEAD', '--binary']);
+            if (sujo.trim()) git(raizCopia, ['apply', '--binary', '-'], { input: sujo });
+            for (const r of git(raiz, ['ls-files', '--others', '--exclude-standard', '-z']).split('\0').filter(Boolean)) {
+                if (!ARQUIVO_SECRETO.test(r)) copiarArquivo(path.join(raiz, r), path.join(raizCopia, r));
+            }
+            git(raizCopia, ['add', '-A']);
+            const base = git(raizCopia, ['write-tree']).trim();
+            return { pasta: path.join(raizCopia, path.relative(raiz, dir)), raizCopia, aplicarEm: raiz, base, git: true, limpar };
+        } catch (e) { limpar(); throw e; }
+    }
+    fs.cpSync(dir, raizCopia, { recursive: true, filter: (src) => { const r = path.relative(dir, src); return !FORA_DA_COPIA.test(r) && !ARQUIVO_SECRETO.test(r); } });
+    git(raizCopia, ['init', '-q']);
+    git(raizCopia, ['add', '-A']);
+    const base = git(raizCopia, ['write-tree']).trim();
+    return { pasta: raizCopia, raizCopia, aplicarEm: dir, base, git: false, limpar: () => fs.rmSync(raizCopia, { recursive: true, force: true }) };
+}
+
+/** O que o parceiro mudou na cópia: { patch, arquivos: [{ status: 'A' | 'M' | 'D', caminho }] }. */
+function mudancasDaCopia(copia) {
+    git(copia.raizCopia, ['add', '-A']);
+    const patch = git(copia.raizCopia, ['diff', '--cached', '--binary', '--no-renames', copia.base]);
+    const arquivos = git(copia.raizCopia, ['diff', '--cached', '--name-status', '--no-renames', copia.base]).split('\n').filter(Boolean)
+        .map((l) => { const [st, caminho] = l.split('\t'); return { status: st[0], caminho }; });
+    return { patch, arquivos };
+}
+
+/** Cada arquivo passa pelo portão, como se o PrimoCode fosse escrever (ou apagar). → as recusas, [] = pode. */
+async function passarPeloPortao(arquivos, { projectDir: pasta, aplicarEm, modo, estado, perguntar }) {
+    const perigo = require('./perigo.js');
+    const projectDir = real(pasta);
+    const recusas = [];
+    for (const a of arquivos) {
+        const rel = path.relative(projectDir, path.join(aplicarEm, a.caminho));
+        const [nome, args] = a.status === 'D' ? ['run_shell', { command: `rm ${JSON.stringify(rel)}` }] : ['write_file', { path: rel }];
+        const r = await perigo.portao(estado, { modo, nome, args, projectDir, perguntar });
+        if (!r.ok) recusas.push(`${a.caminho}: ${r.motivo || r.error}`);
+    }
+    return recusas;
+}
+
+/** Aplica o patch no projeto. Confere antes: patch que não encaixa não mexe em nada. */
+function aplicar(copia, patch) {
+    try {
+        git(copia.aplicarEm, ['apply', '--check', '--binary', '-'], { input: patch });
+        git(copia.aplicarEm, ['apply', '--binary', '-'], { input: patch });
+        return { ok: true };
+    } catch (e) { return { ok: false, erro: 'a mudança não encaixa no projeto como ele está agora (alguém mexeu nele no meio). Nada foi aplicado.' }; }
+}
+
+const pedidoDeFazer = (pedido) => 'Faça o pedido abaixo nesta pasta. Ela é uma cópia do projeto: o PrimoCode mostra o que você mudou '
+    + 'antes de aplicar. Não faça commit, não instale nada fora desta pasta e não mexa fora dela. '
+    + `No fim, diga em português do Brasil, em poucas frases, o que fez.\n\nPEDIDO:\n${semSegredo(pedido)}`;
+
+module.exports = { PARCEIROS, NOMES, PULA_PERMISSAO, achar, instalados, entender, status,
+    semSegredo, ehGit, diffDaVez, pedidoDeRevisao, semProblema, pedidoDeConserto, conferirOpcoes, lerEvento, rodar, PRAZO,
+    prepararCopia, mudancasDaCopia, passarPeloPortao, aplicar, pedidoDeFazer };

package/lib/tool/diagnostico.js

@@ -0,0 +1,100 @@
+/**
+ * diagnostico.js — depois que edit_file/write_file/multi_edit mexe num arquivo, roda o verificador
+ * mais barato da linguagem e devolve os erros (com teto) pra irem no resultado da ferramenta.
+ * O modelo vê o erro na MESMA volta, em vez de descobrir só no fim. (Ideia: diagnósticos do OpenCode.)
+ *
+ *   .js .mjs .cjs → node --check (+ eslint se o projeto configurou e instalou)
+ *   .py → compile() do python3     .ts .tsx → tsc local, se há tsconfig.json
+ *   .json → JSON.parse             .sh → bash -n
+ * Sem verificador, ferramenta ausente ou timeout → null (nunca atrapalha a edição).
+ * PRIMOCODE_SEM_DIAGNOSTICO=1 desliga.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const TETO_CHARS = 1500;
+const TETO_LINHAS = 12;
+const PRAZO_MS = 8000;
+
+function rodar(cmd, args, cwd, prazo = PRAZO_MS) {
+    const r = spawnSync(cmd, args, { cwd, encoding: 'utf-8', timeout: prazo, maxBuffer: 2 * 1024 * 1024 });
+    if (r.error) return null; // ferramenta ausente ou estourou o prazo: sem diagnóstico
+    return { code: r.status, out: `${r.stdout || ''}\n${r.stderr || ''}`.trim() };
+}
+
+function achar(dir, nome, ate) {
+    for (let d = dir; ; d = path.dirname(d)) {
+        if (fs.existsSync(path.join(d, nome))) return d;
+        if (d === ate || d === path.dirname(d)) return null;
+    }
+}
+
+function cortar(texto, arquivo) {
+    const linhas = String(texto).split('\n').map((l) => l.trimEnd()).filter(Boolean);
+    let s = linhas.slice(0, TETO_LINHAS).join('\n');
+    if (s.length > TETO_CHARS) s = s.slice(0, TETO_CHARS) + '…';
+    if (linhas.length > TETO_LINHAS) s += `\n… e mais ${linhas.length - TETO_LINHAS} linhas`;
+    return s.split(arquivo).join(path.basename(arquivo));
+}
+
+function eslintConfigurado(raiz) {
+    if (!raiz) return false;
+    const tem = fs.readdirSync(raiz).some((f) => /^(\.eslintrc(\..+)?|eslint\.config\.(js|mjs|cjs|ts))$/.test(f));
+    return tem && fs.existsSync(path.join(raiz, 'node_modules', '.bin', 'eslint'));
+}
+
+/** @returns {{verificador:string, erros:string}|null}  null = sem verificador ou sem erro */
+function diagnosticar(arquivo, projectDir) {
+    try {
+        if (process.env.PRIMOCODE_SEM_DIAGNOSTICO === '1') return null;
+        if (!fs.existsSync(arquivo) || fs.statSync(arquivo).size > 2 * 1024 * 1024) return null;
+        const ext = path.extname(arquivo).toLowerCase();
+        const dir = path.dirname(arquivo);
+        let r = null; let nome = '';
+        if (['.js', '.mjs', '.cjs'].includes(ext)) {
+            nome = 'node --check'; r = rodar(process.execPath, ['--check', arquivo], dir);
+            if (r && r.code === 0) {
+                const raiz = achar(dir, 'package.json', projectDir);
+                if (eslintConfigurado(raiz)) {
+                    nome = 'eslint';
+                    r = rodar(path.join(raiz, 'node_modules', '.bin', 'eslint'), ['--no-warn-ignored', '-f', 'unix', arquivo], raiz, 15000);
+                }
+            }
+        } else if (ext === '.py') {
+            nome = 'python compile';
+            r = rodar('python3', ['-c', 'import sys;compile(open(sys.argv[1],encoding="utf-8").read(),sys.argv[1],"exec")', arquivo], dir);
+        } else if (ext === '.ts' || ext === '.tsx') {
+            const raiz = achar(dir, 'tsconfig.json', projectDir);
+            const tsc = raiz && path.join(raiz, 'node_modules', '.bin', 'tsc');
+            if (!tsc || !fs.existsSync(tsc)) return null;
+            nome = 'tsc';
+            r = rodar(tsc, ['--noEmit', '-p', raiz, '--pretty', 'false'], raiz, 30000);
+            if (r && r.code !== 0) { // só os erros deste arquivo
+                const rel = path.relative(raiz, arquivo).replace(/\\/g, '/');
+                r.out = r.out.split('\n').filter((l) => l.startsWith(rel)).join('\n');
+                if (!r.out) return null;
+            }
+        } else if (ext === '.json') {
+            nome = 'JSON.parse';
+            try { JSON.parse(fs.readFileSync(arquivo, 'utf-8')); return null; } catch (e) { return { verificador: nome, erros: String(e.message).slice(0, 300) }; }
+        } else if (ext === '.sh') {
+            nome = 'bash -n'; r = rodar('bash', ['-n', arquivo], dir);
+        }
+        if (!r || r.code === 0 || !r.out) return null;
+        return { verificador: nome, erros: cortar(r.out, arquivo) };
+    } catch { return null; }
+}
+
+/** Anexa `diagnosticos` ao resultado de uma ferramenta de escrita. Não mexe no que não for ok. */
+function anexar(resultado, projectDir) {
+    if (!resultado || resultado.ok !== true || !resultado.path) return resultado;
+    const d = diagnosticar(path.resolve(projectDir, resultado.path), projectDir);
+    if (!d) return resultado;
+    return { ...resultado, diagnosticos: `${d.verificador} achou erro neste arquivo depois da edição:\n${d.erros}`,
+        comoCorrigir: 'Corrija o erro acima com edit_file antes de seguir. Não diga que terminou com o arquivo quebrado.' };
+}
+
+module.exports = { diagnosticar, anexar };

package/lib/tool/perguntar.js

@@ -0,0 +1,60 @@
+/**
+ * perguntar.js — a ferramenta `perguntar`: pergunta + 2 a 4 opções (+ texto livre).
+ * Só pra quando o agente está BLOQUEADO (duas saídas razoáveis, não dá pra escolher sozinho).
+ *
+ * Quem desenha na tela é o terminal (ctx.escolher, vem do bin/primocode.js). Sem terminal
+ * (primocode -p, pipe, subagente) devolve a PRIMEIRA opção e registra no log — nunca trava esperando.
+ */
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const LOG = () => path.join(process.env.PRIMOCODE_HOME || path.join(os.homedir(), '.primocode'), 'perguntas-automaticas.log');
+
+function limparOpcoes(opcoes) {
+    let o = opcoes;
+    if (typeof o === 'string') { try { o = JSON.parse(o); } catch { o = o.split(/\n|;|\|/); } }
+    if (!Array.isArray(o)) return [];
+    return o.map((x) => String(x && (x.label || x.texto || x.opcao) || x || '').trim()).filter(Boolean).slice(0, 4);
+}
+
+async function perguntar(args, ctx = {}) {
+    const pergunta = String((args && (args.pergunta || args.question)) || '').trim();
+    const opcoes = limparOpcoes(args && (args.opcoes || args.options));
+    if (!pergunta) return { ok: false, error: 'faltou "pergunta".' };
+    if (opcoes.length < 2) return { ok: false, error: 'passe de 2 a 4 "opcoes" (lista de textos curtos).', comoResolver: 'perguntar pergunta:"...", opcoes:["A","B"]. Se não está bloqueado, escolha você e siga.' };
+    const livre = args.texto_livre !== false && args.texto_livre !== 'false';
+
+    if (typeof ctx.escolher !== 'function') {
+        const escolha = opcoes[0];
+        try {
+            fs.mkdirSync(path.dirname(LOG()), { recursive: true });
+            fs.appendFileSync(LOG(), `${new Date().toISOString()}\t${pergunta}\t[${opcoes.join(' | ')}]\t=> ${escolha}\n`);
+        } catch { /* log é só rastro */ }
+        return { ok: true, escolha, indice: 0, automatico: true,
+            aviso: 'Sem terminal: ninguém pode responder, então valeu a primeira opção. Siga com ela e diga isso no fim.' };
+    }
+    const r = await ctx.escolher(pergunta, opcoes, { livre });
+    if (r == null) return { ok: true, escolha: opcoes[0], indice: 0, automatico: true, aviso: 'A pessoa não respondeu; valeu a primeira opção.' };
+    if (typeof r === 'number') return { ok: true, escolha: opcoes[r] || opcoes[0], indice: opcoes[r] ? r : 0 };
+    return { ok: true, escolha: String(r), indice: -1, texto_livre: true };
+}
+
+/** O desenho no terminal: lista numerada + "ou escreva". `ask(prompt) → Promise<string>`. Enter = opção 1. */
+async function escolherNoTerminal(ask, c, pergunta, opcoes, { livre = true } = {}) {
+    console.log('');
+    console.log('  ' + c.brand('?') + ' ' + c.bold(c.white(pergunta)));
+    opcoes.forEach((o, i) => console.log('  ' + c.brand(String(i + 1)) + c.muted(' › ') + c.white(o)));
+    console.log('  ' + c.dim(livre ? `Enter = 1 · ou escreva a sua resposta` : 'Enter = 1'));
+    const dito = String(await ask('  ' + c.brand('❯ ') + c.muted(`1-${opcoes.length} `))).trim();
+    if (!dito) return 0;
+    const n = Number(dito);
+    if (Number.isInteger(n) && n >= 1 && n <= opcoes.length) return n - 1;
+    const igual = opcoes.findIndex((o) => o.toLowerCase() === dito.toLowerCase());
+    if (igual >= 0) return igual;
+    return livre ? dito : 0;
+}
+
+module.exports = { perguntar, escolherNoTerminal, limparOpcoes };

package/lib/tool/reparar-entrada.js

@@ -0,0 +1,66 @@
+/**
+ * reparar-entrada.js — conserta o argumento da ferramenta que o modelo grátis mandou com o TIPO errado.
+ *
+ * Modelo pequeno manda {"limit":"20"}, {"replace_all":"false"}, {"edits":"[...]"} ou {"offset":null}.
+ * Sem reparo, a ferramenta recusa e o modelo gasta uma volta inteira só pra trocar aspas.
+ * Ideia e regras portadas do ToolInputRepairPlugin do OpenCode (MIT, ver LICENSES/opencode-MIT.txt);
+ * código reescrito em JS, sobre um schema simples ({ campo: 'number'|'boolean'|'array'|'object'|'string' }).
+ *
+ * Regra de ouro (a mesma do casar.js): só repara quando o schema deixa claro. Na dúvida, devolve como veio.
+ *
+ *   reparar(args, schema)  → novo objeto (puro, não muda o original)
+ *   SCHEMAS                → tipos dos campos das ferramentas do agente
+ */
+
+'use strict';
+
+const SCHEMAS = {
+    read_file: { offset: 'number', limit: 'number' },
+    edit_file: { replace_all: 'boolean' },
+    multi_edit: { edits: 'array' },
+    write_todos: { todos: 'array' },
+    glob: { limit: 'number' },
+    run_shell: { timeout_ms: 'number', em_segundo_plano: 'boolean' },
+    perguntar: { opcoes: 'array', texto_livre: 'boolean' },
+    buscar_web: { limite: 'number' },
+    ler_url: { max_chars: 'number', desde: 'number' },
+    grep: { limit: 'number', context: 'number', ignore_case: 'boolean' },
+};
+
+function jsonOuNada(s) {
+    try { return { ok: true, v: JSON.parse(s) }; } catch { return { ok: false }; }
+}
+
+function converter(valor, tipo) {
+    if (valor === null) return undefined; // opcional com null → como se não tivesse vindo
+    if (typeof valor === 'string') {
+        const t = valor.trim();
+        if (tipo === 'number' && /^-?\d+(\.\d+)?$/.test(t)) return Number(t);
+        if (tipo === 'boolean' && /^(true|false)$/i.test(t)) return t.toLowerCase() === 'true';
+        if (tipo === 'array' || tipo === 'object') {
+            const j = jsonOuNada(t);
+            if (j.ok && (tipo === 'array' ? Array.isArray(j.v) : j.v && typeof j.v === 'object' && !Array.isArray(j.v))) return j.v;
+        }
+    }
+    return valor;
+}
+
+function reparar(args, schema) {
+    let a = args;
+    if (typeof a === 'string') { // objeto inteiro virou texto: '{"limit":"20"}'
+        const j = jsonOuNada(a);
+        if (!j.ok || !j.v || typeof j.v !== 'object' || Array.isArray(j.v)) return args;
+        a = j.v;
+    }
+    if (!a || typeof a !== 'object' || !schema) return a;
+    const out = { ...a };
+    for (const [campo, tipo] of Object.entries(schema)) {
+        if (!(campo in out)) continue;
+        const v = converter(out[campo], tipo);
+        if (v === undefined) delete out[campo];
+        else out[campo] = v;
+    }
+    return out;
+}
+
+module.exports = { reparar, SCHEMAS };

package/lib/tool/web.js

@@ -0,0 +1,102 @@
+/**
+ * web.js — buscar_web e ler_url (ideia: websearch/webfetch do OpenCode, MIT).
+ *
+ * Reaproveita lib/referencia.js: pegar() (UA de navegador, redirect, prazo, bloqueio de SSRF)
+ * e buscar() (Bing/Yahoo/DDG/Wikipedia, sem chave). Aqui só ficam a forma da resposta (curta,
+ * pra modelo pequeno) e o html → markdown simples, com teto de tamanho.
+ *
+ * Backend de busca é plugável: registrarBackend(nome, async (consulta, limite) => [{titulo,url,trecho?}]).
+ * Os registrados rodam ANTES dos padrões (ex.: um SearxNG próprio, uma API paga por config).
+ */
+'use strict';
+
+const referencia = require('../referencia');
+
+const TETO_PADRAO = 12000;
+const TETO_MAXIMO = 40000;
+const backends = [];
+
+function registrarBackend(nome, fn) {
+    const i = backends.findIndex((b) => b.nome === nome);
+    if (i >= 0) backends.splice(i, 1);
+    backends.unshift({ nome, fn });
+}
+function limparBackends() { backends.length = 0; }
+
+/** DuckDuckGo HTML com trecho (snippet). Grátis, sem chave. */
+async function ddgHtml(consulta, limite, pegar = referencia.pegar) {
+    const html = await pegar(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(consulta)}`, { timeout: 8000 });
+    if (!html) return [];
+    const out = [];
+    const re = /<a[^>]+class="[^"]*result__a[^"]*"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>([\s\S]*?)(?=<a[^>]+class="[^"]*result__a|$)/gi;
+    let m;
+    while ((m = re.exec(html)) && out.length < limite) {
+        let href = m[1];
+        const emb = href.match(/[?&]uddg=([^&]+)/);
+        if (emb) href = decodeURIComponent(emb[1]);
+        if (!/^https?:\/\//i.test(href)) continue;
+        const sn = m[3].match(/class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/(?:a|td|div)>/i);
+        out.push({ titulo: referencia.textoDe(m[2]).slice(0, 140), url: href, trecho: sn ? referencia.textoDe(sn[1]).slice(0, 240) : '' });
+    }
+    return out;
+}
+
+async function buscarWeb({ consulta, query, limite } = {}, { pegar } = {}) {
+    const q = String(consulta || query || '').trim();
+    if (!q) return { ok: false, error: 'faltou "consulta": o que buscar na web.' };
+    const n = Math.max(1, Math.min(10, Number(limite) || 6));
+    const lista = [...backends, { nome: 'duckduckgo', fn: (c, l) => ddgHtml(c, l, pegar) },
+        { nome: 'multi', fn: (c, l) => referencia.buscar(c, l) }];
+    for (const b of lista) {
+        let r = [];
+        try { r = await b.fn(q, n); } catch { r = []; }
+        if (r && r.length) {
+            return { ok: true, consulta: q, fonte: b.nome, resultados: r.slice(0, n),
+                proximoPasso: 'Escolha 1 ou 2 links e chame ler_url com a url pra ler a página. Não responda só com os títulos.' };
+        }
+    }
+    return { ok: false, error: `nada encontrado para "${q}" (sem internet ou buscadores bloqueados).`,
+        comoResolver: 'tente outras palavras, mais curtas, ou use ler_url se já souber o link.' };
+}
+
+/** HTML → markdown simples: título, cabeçalhos, links, listas, código. */
+function htmlParaMarkdown(html) {
+    let h = String(html || '');
+    const titulo = (h.match(/<title[^>]*>([\s\S]*?)<\/title>/i) || [])[1] || '';
+    h = h.replace(/<(script|style|noscript|svg|nav|footer|header|aside|form)[\s\S]*?<\/\1>/gi, ' ')
+        .replace(/<!--[\s\S]*?-->/g, ' ');
+    const principal = h.match(/<(main|article)[^>]*>([\s\S]*?)<\/\1>/i);
+    if (principal) h = principal[2];
+    h = h.replace(/<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi, (_, n, t) => `\n\n${'#'.repeat(Number(n))} ${t.replace(/<[^>]+>/g, '')}\n\n`)
+        .replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, (_, t) => `\n\n\`\`\`\n${t.replace(/<[^>]+>/g, '')}\n\`\`\`\n\n`)
+        .replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, (_, t) => `\`${t.replace(/<[^>]+>/g, '')}\``)
+        .replace(/<a[^>]+href="([^"#][^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, (_, u, t) => {
+            const tx = t.replace(/<[^>]+>/g, '').trim();
+            return tx && /^https?:/i.test(u) ? `[${tx}](${u})` : tx;
+        })
+        .replace(/<li[^>]*>/gi, '\n- ')
+        .replace(/<(br|\/p|\/div|\/tr|\/ul|\/ol)\b[^>]*>/gi, '\n')
+        .replace(/<[^>]+>/g, '');
+    h = h.replace(/&nbsp;/g, ' ').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'").replace(/&amp;/g, '&')
+        .replace(/[ \t]+/g, ' ').replace(/ *\n */g, '\n').replace(/\n{3,}/g, '\n\n').trim();
+    return { titulo: referencia.textoDe(titulo).slice(0, 160), markdown: h };
+}
+
+async function lerUrl({ url, max_chars, desde } = {}, { pegar = referencia.pegar } = {}) {
+    const u = String(url || '').trim();
+    if (!/^https?:\/\//i.test(u)) return { ok: false, error: 'faltou "url" completa, começando com http:// ou https://.' };
+    const teto = Math.max(500, Math.min(TETO_MAXIMO, Number(max_chars) || TETO_PADRAO));
+    const bruto = await pegar(u, { timeout: 12000 });
+    if (!bruto) return { ok: false, error: `não consegui abrir ${u} (fora do ar, bloqueado ou endereço interno).` };
+    const texto = String(bruto);
+    const ehHtml = /<(html|body|p|div|h1)\b/i.test(texto.slice(0, 4000));
+    const { titulo, markdown } = ehHtml ? htmlParaMarkdown(texto) : { titulo: '', markdown: texto.trim() };
+    const ini = Math.max(0, Number(desde) || 0);
+    const fatia = markdown.slice(ini, ini + teto);
+    const sobrou = markdown.length - (ini + fatia.length);
+    return { ok: true, url: u, titulo, texto: fatia, caracteres: fatia.length,
+        ...(sobrou > 0 ? { cortado: sobrou, dica: `Faltam ${sobrou} caracteres. Chame ler_url de novo com desde:${ini + fatia.length} se precisar.` } : {}) };
+}
+
+module.exports = { buscarWeb, lerUrl, htmlParaMarkdown, registrarBackend, limparBackends, ddgHtml };