primocode 7.2.0 → 7.4.0

package/lib/tools.js

@@ -1,147 +1,456 @@
-/**
- * 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 browser = require('./browser');
+const desktop = require('./desktop');
+
+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();
+    // Letra de drive (C:\, D:/) é sempre absoluta — mesmo no Linux, onde o
+    // path.resolve a trataria como nome relativo e deixaria escapar da pasta.
+    if (/^[a-zA-Z]:[\\/]/.test(String(rawPath || ''))) {
+        throw new Error(`Caminho fora da pasta de trabalho: ${rawPath}`);
+    }
+    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 };
+}
+
+// ── multi_edit: várias trocas no mesmo arquivo, em ordem, tudo-ou-nada ────
+function multiEdit({ path: rawPath, edits }, projectDir) {
+    const filePath = resolveInProject(rawPath, projectDir);
+    if (!fs.existsSync(filePath)) return { ok: false, error: `Arquivo não existe: ${rawPath}` };
+    if (!Array.isArray(edits) || !edits.length) return { ok: false, error: 'edits (lista) é obrigatório' };
+
+    let conteudo = fs.readFileSync(filePath, 'utf-8');
+    const linhasAntes = conteudo.split('\n').length;
+    let substituicoes = 0;
+
+    for (let i = 0; i < edits.length; i++) {
+        const { old_string, new_string, replace_all } = edits[i] || {};
+        if (typeof old_string !== 'string' || !old_string) return { ok: false, error: `edit ${i + 1}: old_string é obrigatório` };
+        if (old_string === new_string) return { ok: false, error: `edit ${i + 1}: old_string e new_string são iguais` };
+        const ocorrencias = conteudo.split(old_string).length - 1;
+        if (ocorrencias === 0) {
+            return { ok: false, error: `edit ${i + 1}: trecho não encontrado`, trechosParecidos: trechosParecidos(conteudo, old_string) };
+        }
+        if (ocorrencias > 1 && !replace_all) {
+            return { ok: false, error: `edit ${i + 1}: trecho aparece ${ocorrencias}x — use replace_all ou inclua mais contexto para torná-lo único` };
+        }
+        conteudo = replace_all ? conteudo.split(old_string).join(new_string) : conteudo.replace(old_string, new_string);
+        substituicoes++;
+    }
+
+    fs.writeFileSync(filePath, conteudo, 'utf-8');
+    return {
+        ok: true,
+        path: path.relative(projectDir, filePath).replace(/\\/g, '/'),
+        substituicoes,
+        linhasAntes,
+        linhasDepois: conteudo.split('\n').length,
+    };
+}
+
+// ── write_todos: lista de tarefas da sessão (estilo Claude Code) ──────────
+// Só estado + exibição — não chama nada externo. O agente planeja em voz alta
+// e o usuário acompanha o progresso.
+let TODOS = [];
+function writeTodos({ todos }) {
+    if (!Array.isArray(todos)) return { ok: false, error: 'todos (lista) é obrigatório' };
+    const status = new Set(['pending', 'in_progress', 'completed']);
+    TODOS = todos.map((t) => ({
+        content: String((t && (t.content || t.task || t.text)) || '').trim(),
+        status: status.has(t && t.status) ? t.status : 'pending',
+    })).filter((t) => t.content);
+    const feitos = TODOS.filter((t) => t.status === 'completed').length;
+    return { ok: true, todos: TODOS, total: TODOS.length, feitos };
+}
+function getTodos() { return TODOS; }
+
+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);
+            }
+            case 'multi_edit':
+                return multiEdit(args, projectDir);
+            case 'write_todos':
+                return writeTodos(args);
+
+            // ── Navegador controlado (CDP) — o agente age numa página real ──
+            case 'browser_open': {
+                const alvo = /^https?:\/\//i.test(args.url || '')
+                    ? args.url
+                    : 'file://' + resolveInProject(args.url, projectDir);
+                return browser.open(alvo);
+            }
+            case 'browser_click':
+                if (args.selector) return browser.clickSelector(args.selector);
+                if (args.text) return browser.clickText(args.text);
+                if (args.x != null && args.y != null) return browser.click(args.x, args.y);
+                return { ok: false, error: 'browser_click precisa de selector, text ou x/y' };
+            case 'browser_type':
+                if (args.selector) return browser.typeInSelector(args.selector, args.text || '', args.clear !== false);
+                return browser.type(args.text || '');
+            case 'browser_key':
+                return browser.key(args.key);
+            case 'browser_read': {
+                const sel = args.selector ? `document.querySelector(${JSON.stringify(args.selector)})` : 'document.body';
+                const texto = await browser.evaluate(`(function(){const e=${sel};return e?e.innerText.slice(0,6000):null;})()`);
+                return texto == null ? { ok: false, error: 'nada na página (ou seletor não encontrado)' } : { ok: true, text: texto };
+            }
+            case 'browser_screenshot':
+                return browser.screenshot(args.path ? resolveInProject(args.path, projectDir) : undefined);
+            case 'browser_scroll':
+                return browser.scroll(args.dy != null ? args.dy : 600);
+            case 'browser_wait':
+                return browser.waitFor(args.selector, args.timeout_ms || 15000);
+            case 'browser_eval':
+                return { ok: true, value: await browser.evaluate(args.js || 'null') };
+
+            // ── Desktop físico — mouse, teclado e tela do usuário ───────────
+            case 'desktop_screenshot':
+                return desktop.screenshot(args.path ? resolveInProject(args.path, projectDir) : undefined);
+            case 'desktop_click':
+                return desktop.click(args.x, args.y, args.button || 'left');
+            case 'desktop_move':
+                return desktop.move(args.x, args.y);
+            case 'desktop_drag':
+                return desktop.drag(args.from_x, args.from_y, args.to_x, args.to_y);
+            case 'desktop_type':
+                return desktop.type(args.text || '');
+            case 'desktop_key':
+                return desktop.key(args.key);
+            case 'desktop_scroll':
+                return desktop.scroll(args.dy != null ? args.dy : 300);
+            case 'desktop_size':
+                return desktop.getScreenSize();
+
+            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,
+    multiEdit, writeTodos, getTodos,
+};