terminal-smart-cli 0.32.0

package/lib/tools.js

@@ -0,0 +1,397 @@
+// Ferramentas LOCAIS do agente ts (Fase 2) — executam NA máquina onde o CLI roda.
+// Segurança: comando destrutivo passa por aprovação (e é RECUSADO em --yes).
+// Economia: saída de comando passa pelo compactor (ideia RTK) antes do contexto.
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const compactor = require('./compactor');
+
+// ── SNAPSHOT antes de sobrescrever ──────────────────────────────────────────
+// Toda escrita/edição faz uma cópia do original em ~/.ts/backups/<hash>/<nome>.<ts>.bak
+// ANTES de gravar. Uma edição malfeita do modelo (comum em missão noturna) passa a ser
+// REVERSÍVEL via ferramenta restaurar_arquivo. Best-effort: nunca bloqueia/derruba a escrita.
+const BK_DIR = path.join(os.homedir(), '.ts', 'backups');
+function _bkKey(absPath) { return crypto.createHash('md5').update(String(absPath).toLowerCase()).digest('hex').slice(0, 12); }
+function _snapshot(absPath) {
+  try {
+    if (!fs.existsSync(absPath) || !fs.statSync(absPath).isFile()) return null;
+    if (fs.statSync(absPath).size > 4 * 1024 * 1024) return null; // não versiona binário/enorme
+    const dir = path.join(BK_DIR, _bkKey(absPath));
+    fs.mkdirSync(dir, { recursive: true });
+    // timestamp seguro (ISO com : e . trocados) — ordena lexicograficamente = cronológico
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const dest = path.join(dir, path.basename(absPath) + '.' + stamp + '.bak');
+    fs.copyFileSync(absPath, dest);
+    try { fs.writeFileSync(path.join(dir, '_path.txt'), absPath); } catch (_) {}
+    // poda: mantém os 10 backups mais recentes DESTE arquivo
+    try {
+      const pref = path.basename(absPath) + '.';
+      const baks = fs.readdirSync(dir).filter(f => f.startsWith(pref) && f.endsWith('.bak')).sort();
+      while (baks.length > 10) { try { fs.unlinkSync(path.join(dir, baks.shift())); } catch (_) {} }
+    } catch (_) {}
+    return dest;
+  } catch (_) { return null; }
+}
+
+// Padrões de comando destrutivo/irreversível — SEMPRE pedem aprovação humana.
+const DESTRUCTIVE = [
+  /\brm\s+(-[a-z]*[rf][a-z]*\s+)/i, /\brm\s+.*\*/, /\brmdir\b/i, /\bdel\s+\/[sq]/i, /\brd\s+\/s/i,
+  /\bmkfs\b/i, /\bdd\s+if=/i, /(?:^|[\s&;|])format\s+[a-z]:/i, /\bdiskpart\b/i, /> ?\/dev\/sd/i,
+  /\bshutdown\b/i, /\breboot\b/i, /\bhalt\b/i, /\bpoweroff\b/i,
+  /\bDROP\s+(TABLE|DATABASE)\b/i, /\bTRUNCATE\b/i, /\bDELETE\s+FROM\b[^;]*(;|$)(?![^]*WHERE)/i,
+  /\bchmod\s+(-R\s+)?777\b/i, /\bgit\s+push\s+.*--force(?!-with-lease)/i, /\bgit\s+reset\s+--hard/i,
+  /:\(\)\s*\{/, /\bcurl\b[^|]*\|\s*(sudo\s+)?(ba)?sh/i, /\bwget\b[^|]*\|\s*(sudo\s+)?(ba)?sh/i,
+  /\bkillall\b/i, /\bpkill\b/i, /\buserdel\b/i, /\bpasswd\b/i,
+  /\btaskkill\b.*\/im\b/i, /\btaskkill\b.*\/f\b.*\/im/i, // taskkill /IM mata TODOS os processos daquele nome (ex: node.exe = a própria missão)
+  /\bStop-Process\b[^|;&]*-Name\b/i, /\bGet-Process\b[^|]*\|[^|]*\bStop-Process\b/i, // PowerShell: matar por NOME mata todos (=taskkill /IM); Stop-Process -Id <pid> segue liberado
+  /\bsystemctl\s+(stop|disable|mask)\b/i, /\bdocker\s+(rm|rmi|system\s+prune|volume\s+rm)\b/i,
+];
+function isDestructive(cmd) { return DESTRUCTIVE.some(re => re.test(String(cmd || ''))); }
+
+// Definições no formato OpenAI function-calling — schemas SIMPLES de propósito
+// (Gemini via CDC rejeita propertyNames/additionalProperties; só type/properties/required).
+const DEFS = [
+  { type: 'function', function: { name: 'executar_comando',
+    description: 'Executa um comando de shell NESTA máquina e retorna stdout/stderr/código. Use pra diagnosticar, instalar, construir, testar.',
+    parameters: { type: 'object', properties: {
+      comando: { type: 'string', description: 'o comando completo' },
+      timeout_s: { type: 'number', description: 'timeout em segundos (padrão 60, máx 300)' },
+    }, required: ['comando'] } } },
+  { type: 'function', function: { name: 'ler_arquivo',
+    description: 'Lê um arquivo de TEXTO local. Arquivo grande vem paginado (use inicio/fim pra ler por partes).',
+    parameters: { type: 'object', properties: {
+      caminho: { type: 'string' },
+      inicio: { type: 'number', description: 'linha inicial (1-based, opcional)' },
+      fim: { type: 'number', description: 'linha final (opcional)' },
+    }, required: ['caminho'] } } },
+  { type: 'function', function: { name: 'escrever_arquivo',
+    description: 'Cria ou sobrescreve um arquivo local com o conteúdo dado (cria as pastas se preciso). Para MUDAR UM TRECHO de arquivo que JÁ EXISTE, prefira editar_arquivo (mais barato e preciso).',
+    parameters: { type: 'object', properties: {
+      caminho: { type: 'string' },
+      conteudo: { type: 'string' },
+    }, required: ['caminho', 'conteudo'] } } },
+  { type: 'function', function: { name: 'editar_arquivo',
+    description: 'Edita UM TRECHO de um arquivo existente: acha o texto EXATO de "buscar" e troca por "substituir" — sem reescrever o arquivo inteiro (economia + zero risco de perder o resto). "buscar" deve ser ÚNICO no arquivo (inclua 2-3 linhas de contexto ao redor); se ambíguo/não achado, a ferramenta explica como corrigir.',
+    parameters: { type: 'object', properties: {
+      caminho: { type: 'string' },
+      buscar: { type: 'string', description: 'trecho EXATO atual (com contexto suficiente pra ser único no arquivo)' },
+      substituir: { type: 'string', description: 'novo trecho que substitui o buscado' },
+      todas: { type: 'boolean', description: 'true = substitui TODAS as ocorrências (padrão: exige ocorrência única)' },
+    }, required: ['caminho', 'buscar', 'substituir'] } } },
+  { type: 'function', function: { name: 'restaurar_arquivo',
+    description: 'Desfaz a última escrita/edição de um arquivo, restaurando o backup automático mais recente (feito ANTES de sobrescrever). Use quando uma edição ficou errada e você quer voltar o arquivo ao estado anterior.',
+    parameters: { type: 'object', properties: {
+      caminho: { type: 'string', description: 'o arquivo a restaurar ao estado anterior' },
+    }, required: ['caminho'] } } },
+  { type: 'function', function: { name: 'listar_diretorio',
+    description: 'Lista arquivos e pastas de um diretório local (nome, tipo, tamanho).',
+    parameters: { type: 'object', properties: {
+      caminho: { type: 'string', description: 'padrão: diretório atual' },
+    }, required: [] } } },
+  { type: 'function', function: { name: 'mudar_diretorio',
+    description: 'Muda o DIRETÓRIO DE TRABALHO da sessão (equivale a "cd"). A partir daí, caminhos RELATIVOS (ex: "js/input.js") e comandos de shell rodam a partir desta pasta. Use assim que souber em qual projeto/pasta trabalhar, para não ficar buscando arquivos pela máquina toda.',
+    parameters: { type: 'object', properties: {
+      caminho: { type: 'string', description: 'pasta destino (absoluta ou relativa à pasta atual)' },
+    }, required: ['caminho'] } } },
+  { type: 'function', function: { name: 'buscar_arquivos',
+    description: 'Procura arquivos por nome (parte do nome) a partir de um diretório, recursivo.',
+    parameters: { type: 'object', properties: {
+      padrao: { type: 'string', description: 'trecho do nome do arquivo' },
+      diretorio: { type: 'string', description: 'padrão: diretório atual' },
+    }, required: ['padrao'] } } },
+  { type: 'function', function: { name: 'info_sistema',
+    description: 'Informações desta máquina: SO, memória, CPU, uptime, usuário, diretório atual.',
+    parameters: { type: 'object', properties: {}, required: [] } } },
+  { type: 'function', function: { name: 'conectar_vps',
+    description: 'Loga num SERVIDOR REMOTO por SSH (usa o perfil salvo em ~/.ts/config.json OU host/user/chave passados). Depois disso, use executar_remoto pra rodar comandos NO servidor. Ideal pra encontrar/inspecionar/editar projetos numa VPS.',
+    parameters: { type: 'object', properties: {
+      host: { type: 'string', description: 'IP ou hostname (opcional se já tem perfil salvo)' },
+      usuario: { type: 'string', description: 'ex: ubuntu, root (opcional)' },
+      chave: { type: 'string', description: 'caminho da chave privada .pem (opcional)' },
+    }, required: [] } } },
+  { type: 'function', function: { name: 'executar_remoto',
+    description: 'Executa um comando de shell NO SERVIDOR REMOTO já conectado (via conectar_vps) e retorna stdout/stderr/código. Use pra listar/ler/editar arquivos e diagnosticar na VPS. Comando destrutivo passa por aprovação, igual ao local.',
+    parameters: { type: 'object', properties: {
+      comando: { type: 'string', description: 'o comando completo a rodar no servidor' },
+    }, required: ['comando'] } } },
+  { type: 'function', function: { name: 'preciso_de_voce',
+    description: 'Use APENAS quando estiver bloqueado por uma AÇÃO EXTERNA que SÓ O USUÁRIO pode fazer (criar conta/projeto num site, fornecer uma chave de API/senha, aprovar um pagamento, conectar um aparelho, mexer num painel web). NUNCA use pra coisas que você mesmo consegue (instalar pacote, escrever arquivo, rodar comando). A missão vai PAUSAR e pedir a ação ao usuário; ela retoma quando ele terminar.',
+    parameters: { type: 'object', properties: {
+      motivo: { type: 'string', description: 'por que você está bloqueado (1 linha)' },
+      o_que_fazer: { type: 'string', description: 'o passo a passo EXATO que o usuário precisa fazer' },
+    }, required: ['motivo', 'o_que_fazer'] } } },
+  { type: 'function', function: { name: 'lembrar',
+    description: 'Salva um FATO PERSISTENTE na memória (o usuário e você mesmo verão nas próximas vezes neste projeto). Use pra decisões importantes, armadilhas descobertas, como rodar/testar, escolhas de arquitetura, credenciais NÃO-secretas (ex: porta, nome do banco). NÃO salve segredo/senha/chave. Fato curto e objetivo, 1 linha.',
+    parameters: { type: 'object', properties: {
+      fato: { type: 'string', description: 'o fato a lembrar (1 linha, objetivo)' },
+      global: { type: 'boolean', description: 'true = vale em QUALQUER projeto (preferência do usuário); padrão false = só este projeto' },
+    }, required: ['fato'] } } },
+  { type: 'function', function: { name: 'mapa_projeto',
+    description: 'Devolve o MAPA de dependências do projeto (quais arquivos importam quais) SEM ler todo o código — rápido e barato. Use pra entender a ESTRUTURA de um projeto grande e achar o arquivo certo antes de editar, em vez de abrir vários arquivos.',
+    parameters: { type: 'object', properties: {
+      diretorio: { type: 'string', description: 'raiz do projeto (padrão: diretório atual)' },
+    }, required: [] } } },
+  { type: 'function', function: { name: 'explorar',
+    description: 'Delega uma INVESTIGAÇÃO a um sub-agente SÓ-LEITURA que roda em contexto SEPARADO e devolve APENAS um resumo. Use quando precisar LER/vasculhar VÁRIOS arquivos pra responder algo (ex: "onde está a lógica de login?", "resuma como o projeto trata erros") — o sub-agente faz as leituras pesadas sem poluir o SEU contexto (economia de tokens). Não pode editar nada.',
+    parameters: { type: 'object', properties: {
+      tarefa: { type: 'string', description: 'a pergunta/investigação a delegar (clara e específica)' },
+    }, required: ['tarefa'] } } },
+];
+
+// GRAFO DE IMPORTS (ideia do Graphfy/Knowledge Graph): parser DETERMINÍSTICO — lê só as
+// linhas de import/require/include de cada arquivo (não o código todo) e monta "quem usa quem".
+// Custo ZERO de tokens pra construir; o agente só gasta ao PEDIR o mapa. Suporta js/ts, py, kt/java, dart, go, rb, php.
+const _MAP_SKIP = new Set(['node_modules', '.git', 'build', 'dist', '.gradle', '.dart_tool', 'vendor', '__pycache__', '.next', 'target', 'bin', 'obj', 'coverage']);
+const _CODE_RE = /\.(m?[jt]sx?|py|kt|java|dart|go|rb|php|vue|svelte)$/i;
+function buildProjectMap(root, max = 400) {
+  const files = [];
+  const walk = (d, rel, depth) => {
+    if (depth > 8 || files.length >= max) return;
+    let list; try { list = fs.readdirSync(d, { withFileTypes: true }); } catch (_) { return; }
+    for (const e of list) {
+      if (files.length >= max) return;
+      if (_MAP_SKIP.has(e.name) || e.name.startsWith('.')) continue;
+      const r = rel ? rel + '/' + e.name : e.name;
+      if (e.isDirectory()) walk(path.join(d, e.name), r, depth + 1);
+      else if (_CODE_RE.test(e.name)) files.push({ rel: r.replace(/\\/g, '/'), abs: path.join(d, e.name) });
+    }
+  };
+  try { walk(root, '', 0); } catch (_) {}
+  const importRe = /(?:import\s+(?:.+?\s+from\s+)?|export\s+.*?\s+from\s+|require\s*\(\s*|from\s+|include\s+|__import__\s*\(\s*)['"]([^'"]+)['"]/g;
+  const known = new Set(files.map(f => f.rel));
+  const edges = [];
+  const deg = {}; // in-degree por arquivo (quantos dependem dele)
+  for (const f of files) {
+    let src = ''; try { src = fs.readFileSync(f.abs, 'utf8').slice(0, 40000); } catch (_) { continue; }
+    const heads = src.split('\n').filter(l => /^\s*(import|from|const|let|var|require|export|include|use|package)\b/.test(l) || /require\s*\(/.test(l)).join('\n');
+    const seen = new Set(); let m;
+    while ((m = importRe.exec(heads))) {
+      let spec = m[1];
+      if (/^[a-z@]/i.test(spec) && !spec.startsWith('.') && !spec.startsWith('/')) continue; // pacote externo — ignora
+      // resolve relativo → arquivo conhecido do projeto
+      const base = path.posix.normalize(path.posix.join(path.posix.dirname(f.rel), spec));
+      const cand = [base, base + '.js', base + '.ts', base + '.jsx', base + '.tsx', base + '.py', base + '.dart', base + '/index.js', base + '/index.ts'];
+      const hit = cand.find(c => known.has(c));
+      if (hit && hit !== f.rel && !seen.has(hit)) { seen.add(hit); edges.push([f.rel, hit]); deg[hit] = (deg[hit] || 0) + 1; }
+    }
+  }
+  const hubs = Object.entries(deg).sort((a, b) => b[1] - a[1]).slice(0, 8).map(([f, n]) => `${f} (usado por ${n})`);
+  return { arquivos: files.length, dependencias: edges.length, hubs, edges: edges.slice(0, 200) };
+}
+
+const BIN_RE = /\.(xlsx?|docx?|pptx?|pdf|zip|rar|7z|png|jpe?g|gif|webp|ico|mp3|mp4|avi|exe|dll|bin|db|sqlite|tgz|gz)$/i;
+
+// Resolve um caminho do modelo contra a BASE de trabalho da sessão (o cwd do
+// agente), não contra o process.cwd() do Node. Assim "js/input.js" cai na pasta
+// certa mesmo com o ts iniciado do home. Caminho absoluto é respeitado; "~" expande.
+function _abs(p, base) {
+  let s = String(p == null ? '' : p);
+  if (s === '~' || s.startsWith('~/') || s.startsWith('~\\')) s = path.join(os.homedir(), s.slice(1));
+  return path.resolve(base || process.cwd(), s);
+}
+
+async function execute(name, input, opts = {}) {
+  // BASE de trabalho: cwd da sessão do agente (opts.baseDir) → pasta confinada da
+  // missão (opts.confineDir) → process.cwd(). É a raiz de todo caminho relativo.
+  const baseDir = opts.baseDir || opts.confineDir || process.cwd();
+  try {
+    switch (name) {
+      case 'executar_comando': {
+        const comando = String(input.comando || '');
+        const timeout = Math.min(300, Math.max(5, Number(input.timeout_s) || 60)) * 1000;
+        const cmd = process.platform === 'win32' ? `chcp 65001>nul & ${comando}` : comando;
+        return await new Promise((res) => {
+          require('child_process').exec(cmd, { timeout, shell: true, windowsHide: true, maxBuffer: 4 * 1024 * 1024, cwd: fs.existsSync(baseDir) ? baseDir : undefined }, (e, out, err) => {
+            const c = compactor.compact(comando, out || '', { codigo: e?.code ?? 0 });
+            const r = { stdout: c.out, stderr: compactor.stripAnsi(err || '').slice(0, 1500), codigo: e?.code ?? 0 };
+            if (c.note) r.aviso = c.note;
+            if (!r.stdout.trim() && !r.stderr.trim() && r.codigo === 0 && /python3? -c/.test(comando) && comando.includes('\n'))
+              r.aviso = 'stdout VAZIO: no Windows, python -c multi-linha falha em silêncio. ESCREVA um .py com escrever_arquivo e rode "python arquivo.py".';
+            res(r);
+          });
+        });
+      }
+      case 'conectar_vps': {
+        const ssh = require('./ssh');
+        try {
+          const r = await ssh.connect({ host: input.host, user: input.usuario, keyPath: input.chave });
+          const who = await ssh.exec('echo "$(whoami)@$(hostname) | $(. /etc/os-release 2>/dev/null; echo $PRETTY_NAME) | pwd=$(pwd)"');
+          return { conectado: true, servidor: `${r.user}@${r.host}:${r.port}`, info: (who.stdout || '').trim() };
+        } catch (e) { return { conectado: false, erro: String(e.message).slice(0, 300) + ' — configure com "ts vps set" ou passe host/usuario/chave.' }; }
+      }
+      case 'executar_remoto': {
+        const ssh = require('./ssh');
+        if (!ssh.isConnected()) return { erro: 'Não conectado a nenhum servidor. Chame conectar_vps primeiro.' };
+        const comando = String(input.comando || '');
+        const out = await ssh.exec(comando, { timeoutMs: 180000 });
+        const c = compactor.compact(comando, out.stdout || '', { codigo: out.code });
+        const r = { remoto: (ssh.info() && ssh.info().host) || '', stdout: c.out, stderr: compactor.stripAnsi(out.stderr || '').slice(0, 1500), codigo: out.code };
+        if (c.note) r.aviso = c.note;
+        return r;
+      }
+      case 'ler_arquivo': {
+        const p = _abs(input.caminho, baseDir);
+        if (BIN_RE.test(p)) return { erro: 'Arquivo binário — ler_arquivo só lê texto. Use executar_comando com uma ferramenta adequada.' };
+        const txt = fs.readFileSync(p, 'utf8');
+        const linhas = txt.split('\n'); const total = linhas.length; const MAXL = 400;
+        const ini = parseInt(input.inicio) || 0;
+        if (ini > 0) {
+          const a = Math.max(1, ini) - 1; const b = (parseInt(input.fim) || 0) > 0 ? parseInt(input.fim) : Math.min(total, a + MAXL);
+          return { conteudo: linhas.slice(a, b).join('\n'), linhas_total: total, intervalo: `${a + 1}-${Math.min(b, total)}` };
+        }
+        if (total > MAXL) return { conteudo: linhas.slice(0, MAXL).join('\n'), linhas_total: total, aviso: `Arquivo grande (${total} linhas): mostrando 1-${MAXL}. Chame de novo com inicio/fim.` };
+        return { conteudo: txt, linhas_total: total };
+      }
+      case 'escrever_arquivo': {
+        let p = _abs(input.caminho, baseDir);
+        // Confinamento (missões): modelos fracos inventam pastas absolutas
+        // (AndroidStudioProjects, Sdk/projects…). Em vez de RECUSAR (o que empurra o
+        // modelo a burlar via shell "echo >"), RE-BASEIA silenciosamente pra dentro
+        // do diretório de trabalho, preservando a estrutura do projeto (app/src/…).
+        let _rebased = null;
+        if (opts.confineDir) {
+          const base = path.resolve(opts.confineDir);
+          if (p !== base && !p.startsWith(base + path.sep)) {
+            const parts = p.split(path.sep);
+            const i = parts.findIndex(s => ['app', 'src', 'main', 'gradle'].includes(s.toLowerCase()));
+            const rel = i >= 0 ? parts.slice(i).join(path.sep) : parts[parts.length - 1];
+            p = path.join(base, rel);
+            _rebased = p;
+          }
+        }
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        const existed = fs.existsSync(p);
+        if (existed) _snapshot(p); // backup antes de sobrescrever (reversível via restaurar_arquivo)
+        fs.writeFileSync(p, String(input.conteudo ?? ''), 'utf8');
+        const r = { ok: true, caminho: p, bytes: Buffer.byteLength(String(input.conteudo ?? '')), sobrescreveu: existed };
+        if (_rebased) r.aviso = 'Caminho fora do diretório de trabalho foi RE-BASEADO para dentro dele. Use ESTE caminho a partir de agora: ' + p;
+        return r;
+      }
+      case 'editar_arquivo': {
+        // Edição por ÂNCORA (ideia do hashline do OMYP): troca SÓ o trecho buscado, sem
+        // reescrever o arquivo — modelo barato edita com precisão, gasta menos tokens de
+        // saída e não corre o risco de "perder" o resto do arquivo num rewrite.
+        let p = _abs(input.caminho, baseDir);
+        if (opts.confineDir) { // mesmo confinamento por rebase do escrever_arquivo
+          const base = path.resolve(opts.confineDir);
+          if (p !== base && !p.startsWith(base + path.sep)) {
+            const parts = p.split(path.sep);
+            const i = parts.findIndex(s => ['app', 'src', 'main', 'gradle'].includes(s.toLowerCase()));
+            p = path.join(base, i >= 0 ? parts.slice(i).join(path.sep) : parts[parts.length - 1]);
+          }
+        }
+        if (!fs.existsSync(p)) return { erro: 'Arquivo não existe: ' + p + '. Pra criar arquivo NOVO use escrever_arquivo.' };
+        const orig = fs.readFileSync(p, 'utf8');
+        let buscar = String(input.buscar ?? ''), substituir = String(input.substituir ?? '');
+        if (!buscar) return { erro: 'buscar vazio.' };
+        // tolerância CRLF: o modelo manda \n mas arquivo Windows tem \r\n — normaliza o par
+        if (!orig.includes(buscar) && orig.includes('\r\n')) {
+          const b2 = buscar.replace(/\r?\n/g, '\r\n');
+          if (orig.includes(b2)) { buscar = b2; substituir = substituir.replace(/\r?\n/g, '\r\n'); }
+        }
+        const count = orig.split(buscar).length - 1; // split com string é literal (sem regex)
+        if (count === 0) {
+          const alvo = buscar.split(/\r?\n/)[0].trim().slice(0, 40);
+          const lines = orig.split(/\r?\n/);
+          const idx = alvo ? lines.findIndex(l => l.includes(alvo.slice(0, 25))) : -1;
+          return { erro: 'Trecho de "buscar" NÃO encontrado — tem que ser EXATO (mesmos espaços/indentação). '
+            + (idx >= 0 ? `Linha parecida (linha ${idx + 1}): ${lines[idx].slice(0, 160)} — releia com ler_arquivo e copie exato.` : 'Releia o arquivo com ler_arquivo e copie o trecho exato.') };
+        }
+        if (count > 1 && !input.todas) return { erro: `Trecho AMBÍGUO: ${count} ocorrências. Inclua mais linhas de contexto em "buscar" pra ficar único, ou passe todas:true.` };
+        const novo = input.todas ? orig.split(buscar).join(substituir) : orig.replace(buscar, substituir);
+        _snapshot(p); // backup antes de editar (reversível via restaurar_arquivo)
+        fs.writeFileSync(p, novo, 'utf8');
+        return { ok: true, caminho: p, ocorrencias: input.todas ? count : 1, bytes_antes: Buffer.byteLength(orig), bytes_depois: Buffer.byteLength(novo) };
+      }
+      case 'restaurar_arquivo': {
+        const p = _abs(input.caminho, baseDir);
+        const dir = path.join(BK_DIR, _bkKey(p));
+        let baks = [];
+        try { baks = fs.readdirSync(dir).filter(f => f.endsWith('.bak')).sort(); } catch (_) {}
+        if (!baks.length) return { erro: 'Sem backup automático para ' + p + ' — nada a restaurar (só há backup de arquivos que o agente já sobrescreveu/editou nesta máquina).' };
+        const ultimo = path.join(dir, baks[baks.length - 1]); // mais recente = versão de antes da última escrita
+        _snapshot(p); // guarda o estado ATUAL antes de reverter (permite "refazer")
+        fs.copyFileSync(ultimo, p);
+        return { ok: true, caminho: p, restaurado: true, de_backup: path.basename(ultimo) };
+      }
+      case 'listar_diretorio': {
+        const p = _abs(input.caminho || '.', baseDir);
+        const items = fs.readdirSync(p, { withFileTypes: true }).slice(0, 200).map(d => {
+          let size = null; try { if (d.isFile()) size = fs.statSync(path.join(p, d.name)).size; } catch (_) {}
+          return { nome: d.name, tipo: d.isDirectory() ? 'dir' : 'arquivo', bytes: size };
+        });
+        return { caminho: p, total: items.length, itens: items };
+      }
+      case 'mudar_diretorio': {
+        // Muda o cwd da SESSÃO. O loop do agente lê _setCwd e passa a resolver os
+        // próximos caminhos relativos (e comandos) a partir daqui.
+        const alvo = _abs(input.caminho || input.diretorio || '.', baseDir);
+        let st; try { st = fs.statSync(alvo); } catch (_) { return { erro: 'Pasta não existe: ' + alvo + '. Confira o caminho (use listar_diretorio/buscar_arquivos).' }; }
+        if (!st.isDirectory()) return { erro: 'Não é uma pasta: ' + alvo };
+        return { ok: true, cwd: alvo, _setCwd: alvo };
+      }
+      case 'buscar_arquivos': {
+        const base = _abs(input.diretorio || '.', baseDir);
+        const alvo = String(input.padrao || '').toLowerCase();
+        if (!alvo) return { erro: 'padrao vazio' };
+        const hits = [];
+        const walk = (dir, depth) => {
+          if (depth > 6 || hits.length >= 100) return;
+          let list; try { list = fs.readdirSync(dir, { withFileTypes: true }); } catch (_) { return; }
+          for (const d of list) {
+            if (hits.length >= 100) return;
+            if (d.name === 'node_modules' || d.name === '.git' || d.name.startsWith('$')) continue;
+            const full = path.join(dir, d.name);
+            if (d.name.toLowerCase().includes(alvo)) hits.push(full);
+            if (d.isDirectory()) walk(full, depth + 1);
+          }
+        };
+        walk(base, 0);
+        return { base, total: hits.length, arquivos: hits, ...(hits.length >= 100 ? { aviso: 'parou em 100 resultados' } : {}) };
+      }
+      case 'info_sistema': {
+        return {
+          so: `${process.platform} ${os.release()}`, host: os.hostname(), usuario: os.userInfo().username,
+          diretorio_atual: baseDir, home: os.homedir(),
+          cpus: os.cpus().length, mem_total_gb: +(os.totalmem() / 1e9).toFixed(1), mem_livre_gb: +(os.freemem() / 1e9).toFixed(1),
+          uptime_h: +(os.uptime() / 3600).toFixed(1), node: process.version,
+        };
+      }
+      case 'preciso_de_voce': {
+        // BLOQUEIO DETERMINÍSTICO (não confia no modelo obedecer o prompt): recusa pedidos
+        // que o SISTEMA já resolve — caminho de SDK/Android/Flutter/toolchain, testar/instalar
+        // o app, ou info que o executor deveria pegar do objetivo. Devolve como resultado de
+        // ferramenta (não pausa) → o agente continua na mesma rodada com o que tem.
+        const _m = (String(input.motivo || '') + ' ' + String(input.o_que_fazer || '')).toLowerCase();
+        if (/\bsdk\b|android sdk|flutter|toolchain|caminho.*(sdk|android|flutter|gradle|java|jdk)|gradle|jdk|java.?home|instalar? o app|testar? o app|rodar? o app|emulador/.test(_m)) {
+          return { erro: 'RECUSADO: isso o SISTEMA já resolve sozinho — o SDK/toolchain é provisionado automaticamente pelo build gate (local.properties, gradle, JDK) e o app é compilado/instalado/testado a cada rodada. O caminho do SDK já está no objetivo. NÃO use preciso_de_voce pra isso: CONTINUE o item com o que você tem, apenas escrevendo os arquivos de código. Aja agora.' };
+        }
+        // Sentinela real: o loop do agente detecta e PAUSA a missão pedindo a ação humana.
+        return { _needHuman: true, motivo: String(input.motivo || '').slice(0, 300), o_que_fazer: String(input.o_que_fazer || '').slice(0, 1200) };
+      }
+      case 'lembrar': {
+        // memória de projeto/global — o agente registra fatos que persistem entre execuções
+        const memoria = require('./memoria');
+        const dir = opts.confineDir || opts.baseDir || process.cwd();
+        // guarda leve: não deixa vazar segredo pra memória (a memória não é lugar de senha)
+        if (/senha|password|secret|api[_-]?key|token|sk-[a-z0-9]/i.test(String(input.fato || ''))) {
+          return { erro: 'RECUSADO: isso parece um segredo (senha/chave/token). A memória NÃO guarda segredo. Reformule sem o valor secreto.' };
+        }
+        const f = memoria.append(dir, input.fato, !!input.global);
+        if (!f) return { erro: 'fato vazio.' };
+        return { ok: true, salvo_em: f, escopo: input.global ? 'global' : 'projeto' };
+      }
+      case 'mapa_projeto': {
+        const base = _abs(input.diretorio || '.', baseDir);
+        const m = buildProjectMap(base);
+        if (!m.arquivos) return { aviso: 'Nenhum arquivo de código reconhecido em ' + base + ' (js/ts/py/kt/java/dart/go/rb/php).', arquivos: 0 };
+        return { diretorio: base, arquivos: m.arquivos, dependencias: m.dependencias,
+          hubs: m.hubs, mapa: m.edges.map(([a, b]) => a + ' -> ' + b) };
+      }
+      default: return { erro: 'Ferramenta desconhecida: ' + name };
+    }
+  } catch (e) { return { erro: String((e && e.message) || e).slice(0, 400) }; }
+}
+
+module.exports = { DEFS, execute, isDestructive, buildProjectMap };

package/lib/ui.js

@@ -0,0 +1,106 @@
+// UI do CLI — identidade Terminal Smart no terminal: cyan→indigo, cantos
+// arredondados, spinner braille. Respeita NO_COLOR e saída não-TTY (pipe = texto puro).
+const TTY = !!process.stdout.isTTY && !process.env.NO_COLOR;
+
+const esc = (s) => TTY ? s : '';
+const rgb = (r, g, b) => (s) => TTY ? `\x1b[38;2;${r};${g};${b}m${s}\x1b[39m` : String(s);
+
+const C = {
+  cyan:   rgb(34, 211, 238),
+  indigo: rgb(129, 140, 248),
+  ok:     rgb(52, 211, 153),
+  warn:   rgb(251, 191, 36),
+  err:    rgb(248, 113, 113),
+  bold:   (s) => TTY ? `\x1b[1m${s}\x1b[22m` : String(s),
+  dim:    (s) => TTY ? `\x1b[2m${s}\x1b[22m` : String(s),
+};
+
+// Gradiente cyan→indigo caractere a caractere (a assinatura visual do ts)
+function gradient(text) {
+  if (!TTY) return text;
+  const a = [34, 211, 238], b = [129, 140, 248];
+  const chars = [...text];
+  const n = Math.max(1, chars.length - 1);
+  return chars.map((ch, i) => {
+    const k = i / n;
+    const [r, g, bl] = a.map((v, j) => Math.round(v + (b[j] - v) * k));
+    return `\x1b[38;2;${r};${g};${bl}m${ch}`;
+  }).join('') + '\x1b[39m';
+}
+
+function banner(version, tagline) {
+  const title = 'T E R M I N A L   S M A R T';
+  return `\n  ${C.cyan('⌁')} ${C.bold(gradient(title))}\n  ${gradient('━'.repeat(title.length + 2))}\n  ${C.dim(tagline)}  ${C.dim('· CLI v' + version)}\n`;
+}
+
+const _width = () => Math.min(process.stdout.columns || 80, 96);
+
+// Caixa arredondada com título opcional. lines = strings JÁ coloridas.
+function box(lines, { title = '', color = C.cyan } = {}) {
+  const strip = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, '');
+  const w = Math.min(_width() - 4, Math.max(...lines.map(l => strip(l).length), strip(title).length + 2, 20));
+  const top = title
+    ? color('╭─ ') + C.bold(title) + ' ' + color('─'.repeat(Math.max(0, w - strip(title).length - 1)) + '╮')
+    : color('╭' + '─'.repeat(w + 2) + '╮');
+  const body = lines.map(l => color('│ ') + l + ' '.repeat(Math.max(0, w - strip(l).length)) + color(' │'));
+  return [top, ...body, color('╰' + '─'.repeat(w + 2) + '╯')].join('\n');
+}
+
+// Spinner braille — start/text/stop; em não-TTY vira no-op silencioso.
+function spinner(initial) {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let i = 0, text = initial || '', timer = null;
+  const paint = () => process.stderr.write(`\r\x1b[2K  ${C.cyan(frames[i = (i + 1) % frames.length])} ${C.dim(text)}`);
+  return {
+    start() { if (TTY && !timer) { process.stderr.write(esc('\x1b[?25l')); timer = setInterval(paint, 90); } return this; },
+    text(t) { text = t; return this; },
+    stop(finalLine) {
+      if (timer) { clearInterval(timer); timer = null; process.stderr.write('\r\x1b[2K'); process.stderr.write(esc('\x1b[?25h')); }
+      if (finalLine) process.stderr.write('  ' + finalLine + '\n');
+      return this;
+    },
+  };
+}
+
+// Markdown-lite: negrito, código inline, blocos de código com borda, títulos, listas.
+function md(text) {
+  if (!TTY) return String(text);
+  const out = [];
+  const lines = String(text).split('\n');
+  let inCode = false;
+  for (const line of lines) {
+    if (/^\s*```/.test(line)) { inCode = !inCode; out.push(C.dim('  ' + (inCode ? '╭──' : '╰──'))); continue; }
+    if (inCode) { out.push(C.dim('  │ ') + C.cyan(line)); continue; }
+    let l = line;
+    // [CMD]…[/CMD] é a marcação de comando do chat web (/ia) — aqui vira código destacado
+    l = l.replace(/\[CMD\]\s*([\s\S]*?)\s*\[\/CMD\]/g, (_, c) => C.cyan('$ ' + c));
+    l = l.replace(/\[\/?CMD\]/g, '');
+    l = l.replace(/^#{1,3}\s+(.+)$/, (_, h) => C.bold(C.cyan(h)));
+    l = l.replace(/\*\*([^*]+)\*\*/g, (_, b) => C.bold(b));
+    l = l.replace(/`([^`]+)`/g, (_, c) => C.cyan(c));
+    l = l.replace(/^(\s*)[-*]\s+/, (_, sp) => sp + C.cyan('•') + ' ');
+    out.push(l);
+  }
+  return out.join('\n');
+}
+
+// Barra de progresso ▰▰▰▱▱ (uso de créditos)
+function bar(frac, width = 22) {
+  const n = Math.round(Math.max(0, Math.min(1, frac)) * width);
+  const color = frac >= 0.9 ? C.err : frac >= 0.75 ? C.warn : C.cyan;
+  return color('▰'.repeat(n)) + C.dim('▱'.repeat(width - n));
+}
+
+// Pergunta sim/não no terminal
+function ask(question) {
+  return new Promise((resolve) => {
+    const rl = require('readline').createInterface({ input: process.stdin, output: process.stderr });
+    rl.question('  ' + question, (ans) => { rl.close(); resolve(String(ans || '').trim().toLowerCase()); });
+  });
+}
+
+const okLine  = (s) => '  ' + C.ok('✔') + ' ' + s;
+const errLine = (s) => '  ' + C.err('✖') + ' ' + s;
+const infoLine = (s) => '  ' + C.cyan('⌁') + ' ' + s;
+
+module.exports = { C, TTY, gradient, banner, box, spinner, md, bar, ask, okLine, errLine, infoLine };

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "terminal-smart-cli",
+  "version": "0.32.0",
+  "description": "Terminal Smart no seu terminal — pergunte, analise logs por pipe e orquestre agentes de IA. Comando: ts",
+  "bin": {
+    "ts": "bin/ts.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "devops",
+    "ai",
+    "cli",
+    "terminal",
+    "ssh",
+    "agente"
+  ],
+  "author": "Terminal Smart <contato@terminalsmart.com.br>",
+  "homepage": "https://terminalsmart.com.br/cli",
+  "bugs": {
+    "url": "https://terminalsmart.com.br/cli"
+  },
+  "license": "UNLICENSED",
+  "dependencies": {
+    "puppeteer-core": "^23.11.1",
+    "qrcode-terminal": "^0.12.0",
+    "ssh2": "^1.17.0"
+  }
+}