primocode 7.2.0 → 7.3.0

package/README.md

@@ -61,6 +61,66 @@ fim. É por isso que a IA não esquece o projeto entre sessões.
 
 Alterne com `/mode primocode` ou `/mode chat`.
 
+## Ferramentas do agente
+
+| Tool | Para quê |
+|---|---|
+| `write_file` | Cria arquivo novo ou reescreve inteiro |
+| `edit_file` | **Troca um trecho exato.** É o que evita reescrever 800 linhas pra mudar uma |
+| `read_file` | Lê o arquivo, com `offset`/`limit` para os grandes |
+| `glob` | Acha arquivos por padrão: `**/*.js`, `src/**/*.{ts,tsx}` |
+| `grep` | Procura texto/regex **dentro** dos arquivos, com arquivo e linha |
+| `list_dir` | Árvore de arquivos |
+| `run_shell` | Roda comando na pasta do projeto |
+| `open_in_browser` | Abre HTML ou URL |
+| `spawn_agent` | Delega uma sub-tarefa a outro agente |
+
+O `edit_file` é rigoroso de propósito: se o trecho não existe, ou aparece mais
+de uma vez sem `replace_all`, ele **recusa** e devolve as linhas reais do
+arquivo — em vez de editar o lugar errado.
+
+## Subagentes
+
+Para tarefas com partes independentes, o agente delega:
+
+```
+Primo Code site ❯ crie o visual do site
+
+  ◆ Agente criar o CSS
+      ⎿ Write style.css
+      ⎿ criado · 40 B
+  ◆ Criei style.css com fundo #111
+
+Pronto: CSS delegado e criado
+```
+
+O subagente tem conversa própria — **não vê o seu diálogo** — e devolve só o
+resumo final. Ele não pode criar outro subagente, então a árvore nunca cresce
+sem controle.
+
+## Nunca "pronto!" falso
+
+Se uma ferramenta falha e o agente tenta encerrar dizendo que deu certo, o
+PrimoCode barra e devolve a tarefa para ele:
+
+```
+⎿ Edit app.js
+⎿ Trecho não encontrado
+    → agente tenta finish("Porta alterada")
+    → BARRADO: "NÃO terminou. Estas tools falharam..."
+⎿ Edit app.js
+⎿ 1 troca · ±0 linhas          ← agora foi de verdade
+```
+
+## Testes
+
+```bash
+npm test
+```
+
+25 verificações sobre glob, grep, edit_file, leitura por partes e bloqueio de
+caminho fora do projeto.
+
 ## Uso
 
 ```bash

package/lib/act.js

@@ -1,9 +1,12 @@
 // Loop do agente autônomo — streaming via /api/act/stream.
 //
 // O contrato com o servidor é uma conversa completa (`messages`, estilo OpenAI).
-// Cada volta do loop: o servidor devolve tool_calls -> executamos AQUI, com await,
-// e devolvemos o resultado na próxima volta. Sem isso o modelo fica cego e repete
-// a mesma tool até estourar o limite.
+// Cada volta: o servidor devolve tool_calls -> executamos AQUI, com await, e
+// devolvemos o resultado na volta seguinte. Sem isso o modelo fica cego e
+// repete a mesma tool até estourar o limite.
+//
+// spawn_agent roda este mesmo loop recursivamente, com conversa própria: o
+// subagente não enxerga o diálogo do usuário e devolve só o resumo final.
 
 'use strict';
 
@@ -13,40 +16,69 @@ const api = require('./api');
 const cfg = require('./config');
 
 const MAX_ITERATIONS = 15;
+const MAX_PROFUNDIDADE = 2; // principal + 1 nível de subagente
+
+function ident(profundidade) {
+    return '  '.repeat(profundidade);
+}
 
-function logResult(kind, result) {
-    const prefix = c.muted('  ⎿ ');
+function logResult(kind, result, profundidade) {
+    const p = ident(profundidade) + c.muted('  ⎿ ');
     if (!result) return;
-    if (result.ok === false) { console.log(prefix + c.err(result.error || `exit ${result.code ?? 'erro'}`)); return; }
+    if (result.ok === false) { console.log(p + c.err(result.error || `exit ${result.code ?? 'erro'}`)); return; }
 
     switch (kind) {
         case 'write_file':
-            console.log(prefix + c.muted(`${result.created ? 'created' : 'updated'} · ${tools.fmtBytes(result.bytes)}`));
+            console.log(p + c.muted(`${result.created ? 'criado' : 'atualizado'} · ${tools.fmtBytes(result.bytes)}`));
+            return;
+        case 'edit_file': {
+            const delta = result.linhasDepois - result.linhasAntes;
+            const sinal = delta > 0 ? c.ok(`+${delta}`) : delta < 0 ? c.err(`${delta}`) : c.muted('±0');
+            console.log(p + c.muted(`${result.substituicoes} troca${result.substituicoes > 1 ? 's' : ''} · `) + sinal + c.muted(' linhas'));
             return;
+        }
         case 'read_file':
-            console.log(prefix + c.muted(`${tools.fmtBytes(result.bytes || 0)}${result.truncated ? ' (truncated)' : ''}`));
+            console.log(p + c.muted(result.de
+                ? `linhas ${result.de}–${result.ate} de ${result.linhas}`
+                : `${result.linhas} linhas · ${tools.fmtBytes(result.bytes || 0)}${result.truncado ? ' (cortado)' : ''}`));
             return;
         case 'list_dir': {
-            const lines = (result.tree || '').split('\n').filter(Boolean);
-            for (const l of lines.slice(0, 8)) console.log(prefix + c.muted(l));
-            if (lines.length > 8) console.log(prefix + c.muted(`… +${lines.length - 8}`));
+            const linhas = (result.tree || '').split('\n').filter(Boolean);
+            for (const l of linhas.slice(0, 8)) console.log(p + c.muted(l));
+            if (linhas.length > 8) console.log(p + c.muted(`… +${linhas.length - 8}`));
+            return;
+        }
+        case 'glob':
+            console.log(p + c.muted(`${result.total} arquivo${result.total === 1 ? '' : 's'}`));
+            for (const f of (result.arquivos || []).slice(0, 5)) console.log(p + c.dim(f));
+            if ((result.arquivos || []).length > 5) console.log(p + c.dim(`… +${result.arquivos.length - 5}`));
+            return;
+        case 'grep': {
+            console.log(p + c.muted(`${result.total} ocorrência${result.total === 1 ? '' : 's'} em ${result.arquivosVistos} arquivos`));
+            for (const r of (result.resultados || []).slice(0, 5)) {
+                console.log(p + c.dim(`${r.arquivo}:${r.linha}`));
+            }
+            if ((result.resultados || []).length > 5) console.log(p + c.dim(`… +${result.resultados.length - 5}`));
             return;
         }
-        case 'run_shell':
-            console.log(prefix + c.ok('exit 0'));
+        case 'run_shell': {
+            const saida = (result.stdout || '').trim().split('\n').filter(Boolean);
+            for (const l of saida.slice(0, 6)) console.log(p + c.muted(l.slice(0, 160)));
+            if (saida.length > 6) console.log(p + c.muted(`… +${saida.length - 6} linhas`));
+            if (!saida.length) console.log(p + c.ok('exit 0'));
             return;
+        }
         case 'open_in_browser':
-        case 'run_in_new_terminal':
-            console.log(prefix + c.muted(result.opener || 'ok'));
+            console.log(p + c.muted(result.opener || 'aberto'));
             return;
     }
 }
 
-// O que mandamos de volta ao modelo. Cortamos saídas gigantes para não
-// estourar a janela de contexto na iteração seguinte.
+// O que volta para o modelo. Cortamos saídas gigantes para não estourar a
+// janela de contexto na iteração seguinte.
 function summarizeForModel(result) {
     const json = JSON.stringify(result);
-    return json.length > 4000 ? json.slice(0, 4000) + '…(truncado)' : json;
+    return json.length > 6000 ? json.slice(0, 6000) + '…(truncado)' : json;
 }
 
 function buildMemoryContext(projectDir, projectName) {
@@ -59,24 +91,31 @@ function buildMemoryContext(projectDir, projectName) {
 }
 
 async function runAct(userPrompt, opts) {
-    const { server, model, token, history, projectDir, projectName, ensureWorkDir } = opts || {};
+    const {
+        server, model, token, history, projectDir, projectName,
+        ensureWorkDir, profundidade = 0, subagent = false,
+    } = opts || {};
+
     // A pasta só nasce quando o agente for mesmo mexer em arquivo. Um "oi"
     // não deve deixar diretório vazio espalhado pelo disco.
     let workDirReady = !ensureWorkDir;
+    const falhasPendentes = [];
+    let tentativasDeEncerrar = 0;
 
-    // Conversa completa desta tarefa: histórico recente + memória + pedido.
     const messages = [];
-    const memory = buildMemoryContext(projectDir, projectName);
-    if (memory) messages.push({ role: 'system', content: `Memória persistente:\n\n${memory}` });
-    for (const m of (history || []).slice(-20)) {
-        if (m && m.role && m.content) messages.push({ role: m.role, content: m.content });
+    if (!subagent) {
+        const memory = buildMemoryContext(projectDir, projectName);
+        if (memory) messages.push({ role: 'system', content: `Memória persistente:\n\n${memory}` });
+        for (const m of (history || []).slice(-20)) {
+            if (m && m.role && m.content) messages.push({ role: m.role, content: m.content });
+        }
     }
     messages.push({ role: 'user', content: userPrompt });
 
     let finalText = '';
 
     for (let iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
-        const sp = new Spinner('Primo Code pensando').start();
+        const sp = new Spinner(subagent ? 'subagente trabalhando' : 'Primo Code pensando').start();
 
         const toolCalls = [];
         let assistantText = '';
@@ -84,24 +123,26 @@ async function runAct(userPrompt, opts) {
         let streaming = false;
 
         try {
-            await api.requestAct(server, { messages, model, token, projectDir, projectName }, (evt) => {
+            await api.requestAct(server, { messages, model, token, projectDir, projectName, subagent }, (evt) => {
                 if (evt.erro) { streamError = evt.erro; return; }
                 if (evt.tool_call) { toolCalls.push(evt.tool_call); return; }
                 if (evt.delta) {
                     if (!streaming) { sp.stop(); streaming = true; }
                     assistantText += evt.delta;
-                    process.stdout.write(c.white(evt.delta));
+                    if (!subagent) process.stdout.write(c.white(evt.delta));
                 }
                 if (evt.assistant_message) assistantText = evt.assistant_message.content || assistantText;
             });
         } catch (e) {
             sp.stop();
+            if (subagent) return { assistantMessage: { role: 'assistant', content: `Subagente falhou: ${e.message || e}` } };
             console.log(c.err(`\nErro: ${e.message || e}`));
             throw e;
         }
         sp.stop();
 
         if (streamError) {
+            if (subagent) return { assistantMessage: { role: 'assistant', content: `Subagente falhou: ${streamError}` } };
             console.log(c.err(`\nErro: ${streamError}`));
             return { assistantMessage: { role: 'assistant', content: `Erro: ${streamError}` } };
         }
@@ -109,15 +150,17 @@ async function runAct(userPrompt, opts) {
         // Sem tool_calls: o modelo respondeu e acabou.
         if (!toolCalls.length) {
             finalText = assistantText.trim();
-            if (finalText && !streaming) console.log('\n' + c.white(finalText));
-            else if (streaming) process.stdout.write('\n');
+            if (!subagent) {
+                if (finalText && !streaming) console.log('\n' + c.white(finalText));
+                else if (streaming) process.stdout.write('\n');
+            }
             break;
         }
 
-        if (streaming) process.stdout.write('\n');
+        if (streaming && !subagent) process.stdout.write('\n');
 
-        // Registra na conversa o turno do assistente COM os tool_calls.
-        // A API exige que cada mensagem role:'tool' venha depois deste turno.
+        // Registra o turno do assistente COM os tool_calls. A API exige que
+        // cada mensagem role:'tool' venha logo depois deste turno.
         messages.push({
             role: 'assistant',
             content: assistantText || null,
@@ -131,26 +174,55 @@ async function runAct(userPrompt, opts) {
         let finished = null;
         for (const tc of toolCalls) {
             if (tc.name === 'finish') {
+                // Encerrar com falha pendente é como o agente dizia "pronto!"
+                // sem ter mudado nada. Devolvemos a tarefa para ele.
+                if (falhasPendentes.length && tentativasDeEncerrar < 2) {
+                    tentativasDeEncerrar++;
+                    messages.push({
+                        role: 'tool',
+                        tool_call_id: tc.id,
+                        content: `NÃO terminou. Estas tools falharam e você não corrigiu: ${falhasPendentes.join('; ')}. `
+                            + 'Conserte agora (leia o arquivo antes de editar) ou, se for impossível, diga claramente ao usuário o que falhou.',
+                    });
+                    continue;
+                }
                 finished = (tc.arguments && tc.arguments.summary) || 'Concluído.';
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: 'ok' });
                 continue;
             }
 
+            if (tc.name === 'spawn_agent') {
+                const r = await runSubagent(tc.arguments || {}, {
+                    server, model, token, projectDir, projectName, profundidade,
+                });
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: r });
+                continue;
+            }
+
             if (!workDirReady) { ensureWorkDir(); workDirReady = true; }
 
-            console.log(actionHeader(tc.name, tc.arguments));
+            console.log(ident(profundidade) + actionHeader(tc.name, tc.arguments));
             const result = await tools.execute(tc.name, tc.arguments, { projectDir });
-            logResult(tc.name, result);
+            logResult(tc.name, result, profundidade);
+
+            // Uma escrita bem-sucedida limpa a dívida: o agente se corrigiu.
+            if (result && result.ok === false) falhasPendentes.push(`${tc.name}(${tc.arguments?.path || ''}): ${result.error}`);
+            else if (['write_file', 'edit_file'].includes(tc.name)) falhasPendentes.length = 0;
+
             messages.push({ role: 'tool', tool_call_id: tc.id, content: summarizeForModel(result) });
         }
 
-        if (finished) { finalText = finished; console.log('\n' + c.white(finished)); break; }
+        if (finished) {
+            finalText = finished;
+            if (!subagent) console.log('\n' + c.white(finished));
+            break;
+        }
     }
 
     if (!finalText) finalText = 'Cheguei ao limite de passos sem concluir. Refaça o pedido em partes menores.';
 
     // Nada de arquivo mexido = nada para lembrar.
-    if (projectName && workDirReady) {
+    if (!subagent && projectName && workDirReady) {
         cfg.appendProjectMemory(projectDir, `**Pedido:** ${userPrompt.slice(0, 300)}\n**Resultado:** ${finalText.slice(0, 500)}`);
     }
 
@@ -160,4 +232,27 @@ async function runAct(userPrompt, opts) {
     };
 }
 
+async function runSubagent(args, ctx) {
+    const { server, model, token, projectDir, projectName, profundidade } = ctx;
+    const descricao = args.description || 'sub-tarefa';
+
+    if (profundidade + 1 >= MAX_PROFUNDIDADE) {
+        return 'Recusado: subagente não pode criar outro subagente. Faça você mesmo.';
+    }
+    if (!args.prompt) return 'Recusado: prompt do subagente vazio.';
+
+    console.log(ident(profundidade) + `  ${c.magenta('◆')} ${c.bold(c.magenta('Agente'))} ${c.muted(descricao)}`);
+
+    const r = await runAct(args.prompt, {
+        server, model, token, projectDir, projectName,
+        history: [],
+        profundidade: profundidade + 1,
+        subagent: true,
+    });
+
+    const resumo = r.assistantMessage.content || 'sem resultado';
+    console.log(ident(profundidade) + `  ${c.magenta('◆')} ${c.muted(resumo.slice(0, 120))}`);
+    return resumo;
+}
+
 module.exports = { runAct };

package/lib/tools.js

@@ -1,147 +1,343 @@
-/**
- * Ferramentas de arquivo, shell e browser para o modo Act.
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { exec } = require('child_process');
-const os = require('os');
-
-function fmtBytes(n) { if (n<1024) return `${n} B`; if (n<1024*1024) return `${(n/1024).toFixed(1)} KB`; return `${(n/(1024*1024)).toFixed(1)} MB`; }
-
-function treeDir(dir, maxDepth=2, currentDepth=0, prefix='') {
-    if (currentDepth>maxDepth) return '';
-    let result='';
-    try { const items=fs.readdirSync(dir); const dirs=[], files=[]; for (const item of items) { if (item.startsWith('.') && item!=='.env') continue; const fullPath=path.join(dir,item); const stat=fs.statSync(fullPath); if (stat.isDirectory()) dirs.push(item); else files.push(item); } dirs.sort(); files.sort(); const all=[...dirs,...files]; for (let i=0;i<all.length;i++) { const item=all[i]; const isLast=i===all.length-1; const connector=isLast?'└── ':'├── '; result+=prefix+connector+item+'\n'; const fullPath=path.join(dir,item); if (fs.statSync(fullPath).isDirectory() && currentDepth<maxDepth) { const newPrefix=prefix+(isLast?'    ':'│   '); result+=treeDir(fullPath,maxDepth,currentDepth+1,newPrefix); } } } catch { return ''; }
-    return result;
-}
-
-function applyCodeBlocks(response) {
-    const regex = /```[\w]*\n([\s\S]*?)```/g;
-    const applied = [];
-    let match;
-    while ((match = regex.exec(response)) !== null) {
-        const block = match[1];
-        const filenameMatch = block.match(/\/\/\s*filename:\s*(.+)/);
-        if (filenameMatch) { const filename=filenameMatch[1].trim(); const content=block.replace(/\/\/\s*filename:.+\n?/,''); const created=!fs.existsSync(filename); fs.mkdirSync(path.dirname(filename),{recursive:true}); fs.writeFileSync(filename,content,'utf-8'); applied.push({path:filename,created}); }
-    }
-    return applied;
-}
-
-async function runShell(command, timeout=60000, cwd) {
-    return new Promise((resolve) => {
-        const child = exec(command, {timeout, cwd: cwd || process.cwd()}, (error, stdout, stderr) => {
-            if (error) resolve({ok:false, code:error.code, stdout, stderr, killed:error.killed});
-            else resolve({ok:true, code:0, stdout, stderr});
-        });
-    });
-}
-
-async function openInBrowser(target) {
-    const platform=os.platform(); let cmd;
-    if (platform==='darwin') cmd=`open "${target}"`;
-    else if (platform==='win32') cmd=`start "" "${target}"`;
-    else cmd=`xdg-open "${target}"`;
-    try { await runShell(cmd); return {ok:true, opener:cmd.split(' ')[0]}; } catch (e) { return {ok:false, error:e.message}; }
-}
-
-async function runInNewTerminal(command, cwd) {
-    const platform=os.platform(); let cmd;
-    if (platform==='darwin') cmd=`osascript -e 'tell application "Terminal" to do script "cd ${cwd||'.'} && ${command}"'`;
-    else if (platform==='win32') cmd=`start cmd /k "cd ${cwd||'.'} && ${command}"`;
-    else { const terminals=['gnome-terminal','konsole','xterm','terminator']; let term='xterm'; for (const t of terminals) { try { require('child_process').execSync(`which ${t}`,{stdio:'ignore'}); term=t; break; } catch {} } cmd=`${term} -e "bash -c 'cd ${cwd||'.'} && ${command}; exec bash'"`; }
-    try { await runShell(cmd); return {ok:true, opener:cmd.split(' ')[0]}; } catch (e) { return {ok:false, error:e.message}; }
-}
-
-// Todo caminho vindo do modelo é resolvido DENTRO da pasta do projeto.
-// Sem isso o agente espalha arquivo por qualquer lugar do disco — e um
-// "../../.." no path viraria escrita fora da área de trabalho.
-function resolveInProject(rawPath, projectDir) {
-    const base = projectDir || process.cwd();
-    const target = path.resolve(base, rawPath || '.');
-    const rel = path.relative(base, target);
-    if (rel.startsWith('..') || path.isAbsolute(rel)) {
-        throw new Error(`Caminho fora do projeto: ${rawPath}`);
-    }
-    return target;
-}
-
-async function execute(name, args, ctx) {
-    const projectDir = (ctx && ctx.projectDir) || process.cwd();
-    args = args || {};
-
-    try {
-        switch (name) {
-            case 'write_file': {
-                const filePath = resolveInProject(args.path, projectDir);
-                const content = args.content || '';
-                const created = !fs.existsSync(filePath);
-                fs.mkdirSync(path.dirname(filePath), { recursive: true });
-                fs.writeFileSync(filePath, content, 'utf-8');
-                return { ok: true, created, path: path.relative(projectDir, filePath), bytes: content.length };
-            }
-            case 'read_file': {
-                const filePath = resolveInProject(args.path, projectDir);
-                const content = fs.readFileSync(filePath, 'utf-8');
-                const truncated = content.length > 10000;
-                return { ok: true, content: truncated ? content.slice(0, 10000) : content, bytes: content.length, truncated };
-            }
-            case 'list_dir': {
-                const dirPath = resolveInProject(args.path, projectDir);
-                return { ok: true, tree: treeDir(dirPath, 2) };
-            }
-            case 'run_shell':
-                return runShell(args.command, args.timeout_ms || 60000, projectDir);
-            case 'run_in_new_terminal':
-                return runInNewTerminal(args.command, args.cwd || projectDir);
-            case 'open_in_browser': {
-                const target = /^https?:\/\//i.test(args.target || '')
-                    ? args.target
-                    : resolveInProject(args.target, projectDir);
-                return openInBrowser(target);
-            }
-            default:
-                return { ok: false, error: `Tool não implementada: ${name}` };
-        }
-    } catch (e) {
-        return { ok: false, error: e.message };
-    }
-}
-
-async function uninstall() {
-    const os = require('os');
-    const path = require('path');
-    const { execSync } = require('child_process');
-    const fs = require('fs');
-
-    const home = os.homedir();
-    const configDir = path.join(home, '.primocode');
-
-    console.log('🗑️  Removendo PrimoCode...');
-
-    // Remover configurações
-    try {
-        if (fs.existsSync(configDir)) {
-            fs.rmSync(configDir, { recursive: true, force: true });
-            console.log('   ✅ Configurações removidas');
-        }
-    } catch (e) {
-        console.log('   ⚠️  Não foi possível remover configurações:', e.message);
-    }
-
-    // Remover link global npm
-    try {
-        execSync('npm unlink -g primocode', { stdio: 'ignore' });
-        console.log('   ✅ Link global removido');
-    } catch {
-        // ignora se não estava linkado
-    }
-
-    console.log('\n✅ PrimoCode removido com sucesso.');
-    console.log('   Para reinstalar: npm install -g primocode');
-    process.exit(0);
-}
-
-module.exports = { fmtBytes, treeDir, applyCodeBlocks, runShell, openInBrowser, runInNewTerminal, execute, uninstall };
+/**
+ * Ferramentas locais do agente.
+ *
+ * Tudo roda na máquina do usuário — o servidor só decide o que chamar.
+ * Todo caminho é resolvido dentro da pasta de trabalho da sessão.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { exec } = require('child_process');
+
+const IGNORAR = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'coverage', '.cache', 'vendor']);
+const MAX_ARQUIVOS_VARREDURA = 5000;
+
+function fmtBytes(n) {
+    if (n < 1024) return `${n} B`;
+    if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+    return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// Todo caminho vindo do modelo é resolvido DENTRO da pasta de trabalho.
+// Sem isso o agente espalha arquivo por qualquer lugar do disco — e um
+// "../../.." viraria escrita fora da área do projeto.
+function resolveInProject(rawPath, projectDir) {
+    const base = projectDir || process.cwd();
+    const target = path.resolve(base, rawPath || '.');
+    const rel = path.relative(base, target);
+    if (rel.startsWith('..') || path.isAbsolute(rel)) {
+        throw new Error(`Caminho fora da pasta de trabalho: ${rawPath}`);
+    }
+    return target;
+}
+
+function treeDir(dir, maxDepth = 2, currentDepth = 0, prefix = '') {
+    if (currentDepth > maxDepth) return '';
+    let result = '';
+    try {
+        const items = fs.readdirSync(dir);
+        const dirs = [], files = [];
+        for (const item of items) {
+            if (item.startsWith('.') && item !== '.env') continue;
+            if (IGNORAR.has(item)) continue;
+            (fs.statSync(path.join(dir, item)).isDirectory() ? dirs : files).push(item);
+        }
+        dirs.sort(); files.sort();
+        const all = [...dirs, ...files];
+        for (let i = 0; i < all.length; i++) {
+            const item = all[i];
+            const isLast = i === all.length - 1;
+            result += prefix + (isLast ? '└── ' : '├── ') + item + '\n';
+            const full = path.join(dir, item);
+            if (fs.statSync(full).isDirectory() && currentDepth < maxDepth) {
+                result += treeDir(full, maxDepth, currentDepth + 1, prefix + (isLast ? '    ' : '│   '));
+            }
+        }
+    } catch { return ''; }
+    return result;
+}
+
+// Percorre a árvore uma vez só; grep e glob se apoiam nisto.
+function* walk(dir, base, profundidade = 0) {
+    if (profundidade > 12) return;
+    let entradas;
+    try { entradas = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entradas) {
+        if (IGNORAR.has(e.name)) continue;
+        if (e.name.startsWith('.') && e.name !== '.env') continue;
+        const full = path.join(dir, e.name);
+        if (e.isDirectory()) yield* walk(full, base, profundidade + 1);
+        else yield path.relative(base, full).replace(/\\/g, '/');
+    }
+}
+
+// Glob sem dependência externa: **, *, ? e {a,b}.
+function globToRegex(pattern) {
+    let re = '';
+    for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (ch === '*') {
+            if (pattern[i + 1] === '*') {
+                // **/ some caminho inteiro, inclusive "nenhuma pasta"
+                if (pattern[i + 2] === '/') { re += '(?:.*/)?'; i += 2; }
+                else { re += '.*'; i += 1; }
+            } else re += '[^/]*';
+        } else if (ch === '?') re += '[^/]';
+        else if (ch === '{') {
+            const fim = pattern.indexOf('}', i);
+            if (fim === -1) re += '\\{';
+            else {
+                re += '(?:' + pattern.slice(i + 1, fim).split(',').map((s) => s.replace(/[.+^${}()|[\]\\]/g, '\\$&')).join('|') + ')';
+                i = fim;
+            }
+        } else re += ch.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    }
+    return new RegExp(`^${re}$`, 'i');
+}
+
+function globFiles(pattern, projectDir) {
+    const re = globToRegex(pattern);
+    const achados = [];
+    for (const rel of walk(projectDir, projectDir)) {
+        if (achados.length >= MAX_ARQUIVOS_VARREDURA) break;
+        if (re.test(rel)) achados.push(rel);
+    }
+    return achados.sort();
+}
+
+function pareceBinario(buf) {
+    const amostra = buf.slice(0, 1024);
+    for (let i = 0; i < amostra.length; i++) if (amostra[i] === 0) return true;
+    return false;
+}
+
+function grepFiles({ pattern, glob, ignoreCase, contexto = 0, maxResultados = 100 }, projectDir) {
+    let re;
+    try { re = new RegExp(pattern, ignoreCase ? 'i' : ''); }
+    catch (e) { return { ok: false, error: `Regex inválida: ${e.message}` }; }
+
+    const filtro = glob ? globToRegex(glob) : null;
+    const resultados = [];
+    let arquivosVistos = 0;
+
+    for (const rel of walk(projectDir, projectDir)) {
+        if (resultados.length >= maxResultados) break;
+        if (filtro && !filtro.test(rel)) continue;
+        arquivosVistos++;
+
+        let buf;
+        try { buf = fs.readFileSync(path.join(projectDir, rel)); } catch { continue; }
+        if (buf.length > 2 * 1024 * 1024 || pareceBinario(buf)) continue;
+
+        const linhas = buf.toString('utf-8').split('\n');
+        for (let i = 0; i < linhas.length && resultados.length < maxResultados; i++) {
+            if (!re.test(linhas[i])) continue;
+            const de = Math.max(0, i - contexto);
+            const ate = Math.min(linhas.length - 1, i + contexto);
+            const trecho = [];
+            for (let j = de; j <= ate; j++) trecho.push(`${j + 1}${j === i ? ':' : '-'}${linhas[j]}`.slice(0, 300));
+            resultados.push({ arquivo: rel, linha: i + 1, trecho: trecho.join('\n') });
+        }
+    }
+
+    return { ok: true, arquivosVistos, total: resultados.length, resultados, truncado: resultados.length >= maxResultados };
+}
+
+async function runShell(command, timeout = 60000, cwd) {
+    return new Promise((resolve) => {
+        exec(command, { timeout, cwd: cwd || process.cwd(), maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+            if (error) resolve({ ok: false, code: error.code ?? 1, stdout, stderr, killed: error.killed });
+            else resolve({ ok: true, code: 0, stdout, stderr });
+        });
+    });
+}
+
+async function openInBrowser(target) {
+    const p = os.platform();
+    const cmd = p === 'darwin' ? `open "${target}"` : p === 'win32' ? `start "" "${target}"` : `xdg-open "${target}"`;
+    const r = await runShell(cmd);
+    return r.ok ? { ok: true, opener: cmd.split(' ')[0] } : { ok: false, error: r.stderr || 'falhou ao abrir' };
+}
+
+async function runInNewTerminal(command, cwd) {
+    const p = os.platform();
+    let cmd;
+    if (p === 'darwin') cmd = `osascript -e 'tell application "Terminal" to do script "cd ${cwd || '.'} && ${command}"'`;
+    else if (p === 'win32') cmd = `start cmd /k "cd /d ${cwd || '.'} && ${command}"`;
+    else cmd = `x-terminal-emulator -e "bash -c 'cd ${cwd || '.'} && ${command}; exec bash'"`;
+    const r = await runShell(cmd);
+    return r.ok ? { ok: true, opener: cmd.split(' ')[0] } : { ok: false, error: r.stderr || 'falhou' };
+}
+
+// Quando o old_string não bate, mostra as linhas do arquivo mais parecidas —
+// com número — para o modelo copiar o texto certo em vez de chutar de novo.
+function trechosParecidos(conteudo, alvo, quantas = 8) {
+    const termos = alvo
+        .split(/[\s{}();,=]+/)
+        .map((t) => t.trim().toLowerCase())
+        .filter((t) => t.length > 2);
+    if (!termos.length) return conteudo.split('\n').slice(0, quantas).map((l, i) => `${i + 1}\t${l}`);
+
+    const linhas = conteudo.split('\n');
+    const pontuadas = linhas.map((linha, i) => {
+        const baixa = linha.toLowerCase();
+        let pontos = 0;
+        for (const t of termos) if (baixa.includes(t)) pontos++;
+        return { i, linha, pontos };
+    }).filter((x) => x.pontos > 0);
+
+    pontuadas.sort((a, b) => b.pontos - a.pontos || a.i - b.i);
+    return pontuadas
+        .slice(0, quantas)
+        .sort((a, b) => a.i - b.i)
+        .map((x) => `${x.i + 1}\t${x.linha.slice(0, 200)}`);
+}
+
+// Edição cirúrgica: troca um trecho exato em vez de reescrever o arquivo.
+// É o que impede o agente de reescrever 800 linhas para mudar uma.
+function editFile({ path: rawPath, old_string, new_string, replace_all }, projectDir) {
+    const filePath = resolveInProject(rawPath, projectDir);
+    if (!fs.existsSync(filePath)) return { ok: false, error: `Arquivo não existe: ${rawPath}` };
+    if (typeof old_string !== 'string' || !old_string) return { ok: false, error: 'old_string é obrigatório' };
+    if (old_string === new_string) return { ok: false, error: 'old_string e new_string são iguais' };
+
+    const original = fs.readFileSync(filePath, 'utf-8');
+    const ocorrencias = original.split(old_string).length - 1;
+
+    if (ocorrencias === 0) {
+        // Erro seco faz o modelo chutar de novo. Devolvendo o que EXISTE no
+        // arquivo, ele acerta na segunda tentativa.
+        return {
+            ok: false,
+            error: 'Trecho não encontrado — o arquivo não contém esse texto exato.',
+            comoCorrigir: 'Copie o old_string LITERALMENTE de "trechosParecidos" abaixo, com a mesma indentação.',
+            trechosParecidos: trechosParecidos(original, old_string),
+        };
+    }
+    if (ocorrencias > 1 && !replace_all) {
+        return { ok: false, error: `Trecho aparece ${ocorrencias} vezes. Inclua mais linhas em volta para ficar único, ou use replace_all.` };
+    }
+
+    const atualizado = replace_all
+        ? original.split(old_string).join(new_string ?? '')
+        : original.replace(old_string, new_string ?? '');
+
+    fs.writeFileSync(filePath, atualizado, 'utf-8');
+    return {
+        ok: true,
+        path: path.relative(projectDir, filePath).replace(/\\/g, '/'),
+        substituicoes: replace_all ? ocorrencias : 1,
+        linhasAntes: original.split('\n').length,
+        linhasDepois: atualizado.split('\n').length,
+    };
+}
+
+function readFile({ path: rawPath, offset, limit }, projectDir) {
+    const filePath = resolveInProject(rawPath, projectDir);
+    const bruto = fs.readFileSync(filePath, 'utf-8');
+    const todas = bruto.split('\n');
+
+    // Sem recorte pedido: devolve o começo, avisando que cortou.
+    if (offset == null && limit == null) {
+        const truncado = bruto.length > 40000;
+        return {
+            ok: true,
+            content: truncado ? bruto.slice(0, 40000) : bruto,
+            linhas: todas.length,
+            bytes: bruto.length,
+            truncado,
+            dica: truncado ? 'Use offset/limit para ler o resto.' : undefined,
+        };
+    }
+
+    const inicio = Math.max(0, (offset || 1) - 1);
+    const fim = Math.min(todas.length, inicio + (limit || 200));
+    const recorte = todas.slice(inicio, fim).map((l, i) => `${inicio + i + 1}\t${l}`).join('\n');
+    return { ok: true, content: recorte, linhas: todas.length, de: inicio + 1, ate: fim, bytes: bruto.length };
+}
+
+async function execute(name, args, ctx) {
+    const projectDir = (ctx && ctx.projectDir) || process.cwd();
+    args = args || {};
+
+    try {
+        switch (name) {
+            case 'write_file': {
+                const filePath = resolveInProject(args.path, projectDir);
+                const content = args.content || '';
+                const created = !fs.existsSync(filePath);
+                fs.mkdirSync(path.dirname(filePath), { recursive: true });
+                fs.writeFileSync(filePath, content, 'utf-8');
+                return { ok: true, created, path: path.relative(projectDir, filePath).replace(/\\/g, '/'), bytes: content.length };
+            }
+            case 'edit_file':
+                return editFile(args, projectDir);
+            case 'read_file':
+                return readFile(args, projectDir);
+            case 'list_dir':
+                return { ok: true, tree: treeDir(resolveInProject(args.path, projectDir), args.depth || 2) };
+            case 'glob': {
+                const arquivos = globFiles(args.pattern || '**/*', projectDir);
+                return { ok: true, total: arquivos.length, arquivos: arquivos.slice(0, 200) };
+            }
+            case 'grep':
+                return grepFiles(args, projectDir);
+            case 'run_shell':
+                return runShell(args.command, args.timeout_ms || 60000, projectDir);
+            case 'run_in_new_terminal':
+                return runInNewTerminal(args.command, args.cwd || projectDir);
+            case 'open_in_browser': {
+                const alvo = /^https?:\/\//i.test(args.target || '')
+                    ? args.target
+                    : resolveInProject(args.target, projectDir);
+                return openInBrowser(alvo);
+            }
+            default:
+                return { ok: false, error: `Tool não implementada: ${name}` };
+        }
+    } catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
+
+function applyCodeBlocks(response) {
+    const regex = /```[\w]*\n([\s\S]*?)```/g;
+    const applied = [];
+    let match;
+    while ((match = regex.exec(response || '')) !== null) {
+        const block = match[1];
+        const nome = block.match(/\/\/\s*filename:\s*(.+)/);
+        if (!nome) continue;
+        const filename = nome[1].trim();
+        const content = block.replace(/\/\/\s*filename:.+\n?/, '');
+        const created = !fs.existsSync(filename);
+        fs.mkdirSync(path.dirname(filename), { recursive: true });
+        fs.writeFileSync(filename, content, 'utf-8');
+        applied.push({ path: filename, created });
+    }
+    return applied;
+}
+
+async function uninstall() {
+    const configDir = path.join(os.homedir(), '.primocode');
+    console.log('Removendo PrimoCode…');
+    try {
+        if (fs.existsSync(configDir)) {
+            fs.rmSync(configDir, { recursive: true, force: true });
+            console.log('   configurações removidas');
+        }
+    } catch (e) {
+        console.log('   não consegui remover as configurações:', e.message);
+    }
+    const r = await runShell('npm uninstall -g primocode');
+    console.log(r.ok ? '   pacote global removido' : '   remova com: npm uninstall -g primocode');
+    console.log('\nSeus projetos em ~/primocode continuam lá.');
+}
+
+module.exports = {
+    fmtBytes, treeDir, applyCodeBlocks, runShell, openInBrowser, runInNewTerminal,
+    execute, uninstall, resolveInProject, globToRegex, globFiles, grepFiles, editFile,
+};

package/lib/ui.js

@@ -119,19 +119,13 @@ class ProgressBar {
 }
 
 function actionHeader(name, args) {
-    const nice = {
-        read_file:'Read', write_file:'Write', list_dir:'List', run_shell:'Bash',
-        run_in_new_terminal:'Terminal', open_in_browser:'Open', browser_open:'Browser',
-        browser_navigate:'Navigate', browser_click:'Click', browser_type:'Type',
-        browser_key:'Key', browser_wait_for:'Wait', browser_wait:'Wait',
-        browser_screenshot:'Screenshot', browser_eval:'Eval', browser_scroll:'Scroll',
-        browser_url:'URL', finish:'Finish',
-        desktop_click:'Click', desktop_move:'Move', desktop_drag:'Drag',
-        desktop_type:'Type', desktop_key:'Key', desktop_scroll:'Scroll',
-        desktop_screenshot:'Screenshot', desktop_screen_size:'Screen',
+    const nice = {
+        read_file:'Read', write_file:'Write', edit_file:'Edit', list_dir:'List',
+        glob:'Glob', grep:'Grep', run_shell:'Bash', run_in_new_terminal:'Terminal',
+        open_in_browser:'Open', spawn_agent:'Agent', finish:'Finish',
     };
     const label = nice[name] || name;
-    const argStr = args ? (args.path || args.command || args.target || args.url || args.selector || JSON.stringify(args).slice(0,60)) : '';
+    const argStr = args ? (args.path || args.pattern || args.command || args.target || args.description || JSON.stringify(args).slice(0,60)) : '';
     return `  ${c.dim('⎿')} ${c.brand(label)}${argStr ? ' '+c.muted(argStr) : ''}`;
 }
 

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "primocode",
-  "version": "7.2.0",
+  "version": "7.3.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Modo primocode cria arquivos, controla o desktop e navegador. Modo chat é conversa pura.",
   "main": "bin/primocode.js",
   "bin": {
     "primocode": "bin/primocode.js"
   },
   "scripts": {
-    "start": "node bin/primocode.js"
+    "start": "node bin/primocode.js",
+    "test": "node test/tools.test.js"
   },
   "engines": {
     "node": ">=18.17.0"