terminal-smart-cli 0.32.0

package/lib/compactor.js

@@ -0,0 +1,152 @@
+// ═══════════════════════════════════════════════════════════════════════════
+// CMD COMPACTOR — compactação DETERMINÍSTICA de saída de comando (código puro,
+// zero IA, zero custo por chamada). Ideia validada pelo RTK (rtk-ai/rtk):
+// 60-90% da saída de comandos comuns é ruído pro modelo — progresso de npm,
+// testes que PASSARAM, listagens gigantes, linhas repetidas de log. Compacta
+// ANTES de entrar no contexto; a saída COMPLETA vai pra um arquivo temp
+// ("tee") que o modelo pode recuperar com ler_arquivo se precisar do detalhe.
+// Regra de ouro: ERRO nunca é descartado — comando que falhou compacta pouco.
+// ═══════════════════════════════════════════════════════════════════════════
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const MAX_OUT = 3500;   // teto de chars da saída compactada (~875 tokens)
+const MAX_FAIL = 6000;  // comando que FALHOU merece mais espaço (diagnóstico)
+const TEE_MIN = 2500;   // só grava tee se a original passar disto E a economia valer
+
+function stripAnsi(s) {
+  // códigos de cor/cursor (\x1b[...m etc) e OSC — lixo puro pro modelo
+  return String(s).replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '').replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?/g, '');
+}
+
+// Linhas consecutivas idênticas viram uma só com contador (logs adoram repetir)
+function dedupeLines(s) {
+  const lines = String(s).split('\n');
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    let j = i;
+    while (j + 1 < lines.length && lines[j + 1] === lines[i] && lines[i].trim()) j++;
+    const reps = j - i + 1;
+    out.push(reps > 2 ? lines[i] + `   [repetida ${reps}x]` : lines[i]);
+    if (reps === 2) out.push(lines[i]);
+    i = j;
+  }
+  return out.join('\n');
+}
+
+function headTail(s, max) {
+  if (s.length <= max) return s;
+  const head = Math.floor(max * 0.6);
+  const tail = max - head - 90;
+  return s.slice(0, head)
+    + `\n… [${s.length - head - tail} chars omitidos — saída completa no arquivo tee, se indicado] …\n`
+    + s.slice(s.length - tail);
+}
+
+function capLines(s, n, rotulo) {
+  const lines = s.split('\n');
+  if (lines.length <= n) return s;
+  return lines.slice(0, n).join('\n') + `\n… +${lines.length - n} ${rotulo || 'linhas'} (total ${lines.length})`;
+}
+
+function lastLines(s, n) {
+  const lines = s.split('\n');
+  if (lines.length <= n) return s;
+  return `[…${lines.length - n} linhas anteriores omitidas — em log, o fim é o que importa]\n` + lines.slice(-n).join('\n');
+}
+
+// ── Filtros por tipo de comando (cada um recebe saída JÁ limpa de ANSI/dupes) ──
+const FILTERS = [
+  {
+    // npm/yarn/pnpm install: só interessa o desfecho e os erros, nunca o progresso
+    re: /\b(npm|pnpm|yarn)\b[^&|;]*\b(install|ci|add|update|audit fix)\b/,
+    fn(s) {
+      const keep = s.split('\n').filter(l =>
+        !/^\s*(npm (WARN|notice)|warning |info |Progress:|\[[\d\/#= .]+\]|⸨|added \d+ packages? in|fetch)/i.test(l) || /ERR|error/i.test(l));
+      const tailBlock = s.split('\n').slice(-6).join('\n'); // resumo final do npm
+      return capLines(keep.join('\n'), 40, 'linhas de instalação') + '\n--- fim ---\n' + tailBlock;
+    },
+  },
+  {
+    // pip install: idem — "Requirement already satisfied" em massa é o pior ofensor
+    re: /\bpip3?\b[^&|;]*\binstall\b/,
+    fn(s) {
+      const keep = s.split('\n').filter(l =>
+        !/^\s*(Requirement already satisfied|Downloading|Using cached|Collecting |Preparing |Installing collected|Attempting |\s*\|)/i.test(l));
+      const ok = s.match(/Successfully installed[^\n]*/);
+      return capLines(keep.join('\n'), 30, 'linhas pip') + (ok ? '\n' + ok[0] : '');
+    },
+  },
+  {
+    // Runners de teste: falhas + resumo; os "passed" individuais são ruído
+    re: /\b(pytest|jest|vitest|mocha|cargo test|go test|phpunit)\b|npm (run )?test\b/,
+    fn(s) {
+      const lines = s.split('\n');
+      const fails = lines.filter(l => /FAIL|ERROR|✕|✗|not ok|AssertionError|Traceback|panic|Exception/i.test(l));
+      const resumo = lines.slice(-12).join('\n');
+      if (!fails.length) return '[todos os testes individuais omitidos — nenhum FALHOU]\n' + resumo;
+      return capLines(fails.join('\n'), 60, 'falhas') + '\n--- resumo ---\n' + resumo;
+    },
+  },
+  {
+    // git diff grande: diffstat + começo (o modelo pede o arquivo específico se precisar)
+    re: /\bgit\b[^&|;]*\bdiff\b/,
+    fn(s) {
+      if (s.split('\n').length <= 150) return s;
+      const files = [...s.matchAll(/^diff --git a\/(.+?) b\//gm)].map(m => m[1]);
+      const stat = files.length ? `[diff em ${files.length} arquivo(s): ${files.slice(0, 20).join(', ')}${files.length > 20 ? '…' : ''}]\n` : '';
+      return stat + capLines(s, 100, 'linhas de diff');
+    },
+  },
+  { re: /\bgit\b[^&|;]*\b(log|status|branch|show)\b/, fn: (s) => capLines(s, 40, 'linhas git') },
+  { re: /\b(ls|dir|find|tree|locate)\b|Get-ChildItem/i, fn: (s) => capLines(s, 80, 'entradas') },
+  { re: /\b(grep|rg|findstr|Select-String)\b/i, fn: (s) => capLines(s, 80, 'ocorrências') },
+  { re: /\b(journalctl|tail|docker logs|pm2 logs)\b|\.log\b/, fn: (s) => lastLines(s, 80) },
+];
+
+// API principal. opts: { codigo (exit code), teeDir }
+function compact(comando, stdout, opts = {}) {
+  const original = String(stdout || '');
+  if (!original) return { out: original };
+  const failed = typeof opts.codigo === 'number' && opts.codigo !== 0;
+  const max = failed ? MAX_FAIL : MAX_OUT;
+
+  let s = dedupeLines(stripAnsi(original));
+  // Filtro específico só quando o comando DEU CERTO — em falha, o detalhe é diagnóstico
+  if (!failed) {
+    const cmd = String(comando || '');
+    for (const f of FILTERS) { if (f.re.test(cmd)) { try { s = f.fn(s); } catch (_) {} break; } }
+  }
+  s = headTail(s, max);
+
+  const saved = original.length - s.length;
+  const r = { out: s };
+  // "tee": guarda a íntegra quando cortamos algo relevante — recuperável, nunca perdido.
+  // noTee: comando rodou em máquina REMOTA (ssh) — um tee local seria ilegível pra sessão;
+  // o marcador de omissão já orienta o modelo a re-rodar com grep/tail focado.
+  if (!opts.noTee && saved > 400 && original.length > TEE_MIN) {
+    try {
+      const dir = opts.teeDir || path.join(os.tmpdir(), 'ts-cmd-out');
+      fs.mkdirSync(dir, { recursive: true });
+      const file = path.join(dir, 'out-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 6) + '.txt');
+      fs.writeFileSync(file, original);
+      r.tee = file;
+      r.note = `Saída compactada (economia de ~${Math.round(saved / 4)} tokens). Íntegra em: ${file} (use ler_arquivo SÓ se precisar do detalhe omitido).`;
+      _gcTee(dir);
+    } catch (_) { /* tee é conveniência — falhou, segue sem */ }
+  }
+  return r;
+}
+
+// Mantém o diretório tee enxuto (máx ~40 arquivos / 24h) — é cache, não histórico
+function _gcTee(dir) {
+  try {
+    const now = Date.now();
+    const files = fs.readdirSync(dir).map(f => path.join(dir, f))
+      .map(p => ({ p, t: fs.statSync(p).mtimeMs })).sort((a, b) => b.t - a.t);
+    files.forEach((f, i) => { if (i >= 40 || now - f.t > 24 * 3600 * 1000) { try { fs.unlinkSync(f.p); } catch (_) {} } });
+  } catch (_) {}
+}
+
+module.exports = { compact, stripAnsi, dedupeLines };

package/lib/config.js

@@ -0,0 +1,20 @@
+// Config do CLI em ~/.ts/config.json — token, idioma, conversa ativa.
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const DIR = path.join(os.homedir(), '.ts');
+const FILE = path.join(DIR, 'config.json');
+
+function load() {
+  try { return JSON.parse(fs.readFileSync(FILE, 'utf8')) || {}; } catch (_) { return {}; }
+}
+function save(patch) {
+  const cfg = Object.assign(load(), patch);
+  for (const k of Object.keys(cfg)) if (cfg[k] === undefined || cfg[k] === null) delete cfg[k];
+  fs.mkdirSync(DIR, { recursive: true });
+  fs.writeFileSync(FILE, JSON.stringify(cfg, null, 2));
+  try { fs.chmodSync(FILE, 0o600); } catch (_) { /* Windows: sem chmod */ }
+  return cfg;
+}
+module.exports = { load, save, FILE };

package/lib/eval.js

@@ -0,0 +1,243 @@
+// lib/eval.js — PIPELINE DE AVALIAÇÃO do agente ts (padrão evals da Anthropic).
+// Roda o agente local em cada CASO de uma suíte, num SANDBOX temporário isolado,
+// coleta EVIDÊNCIA determinística (arquivos criados/alterados + resposta final)
+// e um LLM-JUDGE dá veredito {pass, score, reason}. Relatório com taxa de
+// aprovação, custo (Smart Credits) e tempo.
+//
+// É ferramenta de DEV/CI: custa tokens de propósito (roda o agente de verdade),
+// então NUNCA roda sozinha — só quando o usuário chama `ts eval`.
+//
+// Formato da suíte (JSON): { "name": "...", "cases": [ {
+//   "id":       "criar-readme",              // rótulo (default caso-N)
+//   "task":     "crie um README.md ...",     // tarefa dada ao agente
+//   "expect":   "existe README.md com ...",  // critério de sucesso (o juiz avalia contra isto)
+//   "files":    { "app.js": "console.log(1)" }, // arquivos criados no sandbox ANTES da run
+//   "readonly": false                        // roda em modo --ler (não deve alterar nada)
+// } ] }
+// Também aceita um ARRAY direto de casos no lugar do objeto.
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const { api } = require('./api');
+const agent = require('./agent');
+
+// modelo default do JUIZ: barato e suficiente pra avaliar critério objetivo.
+const DEFAULT_JUDGE = 'deepseek-v4-flash';
+
+// ── suíte ────────────────────────────────────────────────────────────────────
+function loadSuite(p) {
+  const raw = fs.readFileSync(p, 'utf8');
+  let j; try { j = JSON.parse(raw); } catch (e) { throw new Error('suíte inválida (JSON): ' + e.message); }
+  const rawCases = Array.isArray(j) ? j : (j && Array.isArray(j.cases) ? j.cases : null);
+  if (!rawCases) throw new Error('suíte precisa de um array "cases" (ou ser um array de casos)');
+  const cases = normCases(rawCases);
+  if (!cases.length) throw new Error('nenhum caso válido (cada caso precisa de "task" e "expect")');
+  return { name: String((j && j.name) || path.basename(p)), cases };
+}
+
+function normCases(arr) {
+  return arr.map((c, i) => ({
+    id: String((c && c.id) || ('caso-' + (i + 1))).replace(/[^\w.-]/g, '_').slice(0, 60),
+    task: String((c && c.task) || '').trim(),
+    expect: String((c && c.expect) || '').trim(),
+    files: (c && c.files && typeof c.files === 'object' && !Array.isArray(c.files)) ? c.files : {},
+    readonly: !!(c && c.readonly),
+  })).filter(c => c.task && c.expect);
+}
+
+// suíte embutida pro `--smoke` (auto-teste rápido; 3 casos baratos e determinísticos)
+function smokeSuite() {
+  return { name: 'smoke', cases: normCases([
+    { id: 'criar-arquivo', task: "crie um arquivo saudacao.txt cujo conteúdo seja exatamente: oi mundo", expect: "existe um arquivo saudacao.txt e seu conteúdo é exatamente 'oi mundo' (sem outras linhas)" },
+    { id: 'editar-json', task: "no arquivo config.json, troque o valor de \"versao\" de 1 para 2, preservando o resto", expect: 'config.json continua um JSON válido com "versao": 2 e mantém o campo "nome"', files: { 'config.json': '{\n  "nome": "app",\n  "versao": 1\n}\n' } },
+    { id: 'ler-responder', task: "quantas funções (linhas que começam com 'function ') existem em util.js? responda só o número.", expect: 'a resposta final informa 2 funções', files: { 'util.js': 'function a(){}\nconst x=1;\nfunction b(){}\n' }, readonly: true },
+  ]) };
+}
+
+// exemplo pra `ts eval --exemplo` (bootstrap de suíte pro usuário)
+const EXAMPLE = {
+  name: 'minha-suite',
+  cases: [
+    { id: 'criar-readme', task: 'crie um README.md descrevendo um app de lista de tarefas', expect: 'existe README.md não-vazio mencionando "tarefas" ou "todo"' },
+    { id: 'corrigir-bug', task: 'em soma.js a função soma retorna a-b; corrija para retornar a+b', expect: 'soma.js define soma(a,b) retornando a+b', files: { 'soma.js': 'function soma(a,b){ return a-b; }\nmodule.exports = soma;\n' } },
+  ],
+};
+
+// ── sandbox / evidência ──────────────────────────────────────────────────────
+function _snap(dir) {
+  const out = {};
+  const walk = (d, rel) => {
+    let ents = []; try { ents = fs.readdirSync(d, { withFileTypes: true }); } catch (_) { return; }
+    for (const e of ents) {
+      if (e.name === '.git' || e.name === 'node_modules') continue;
+      const full = path.join(d, e.name), r = rel ? rel + '/' + e.name : e.name;
+      if (e.isDirectory()) walk(full, r);
+      else {
+        try { const st = fs.statSync(full); out[r] = st.size > 200000 ? `<binário ${st.size}b>` : fs.readFileSync(full, 'utf8'); }
+        catch (_) { out[r] = '<ilegível>'; }
+      }
+    }
+  };
+  walk(dir, '');
+  return out;
+}
+
+// diff de dois snapshots → { criados:[], alterados:[], removidos:[] } com conteúdo dos 2 primeiros
+function _diff(before, after) {
+  const criados = [], alterados = [], removidos = [];
+  for (const k of Object.keys(after)) {
+    if (!(k in before)) criados.push({ path: k, content: after[k] });
+    else if (before[k] !== after[k]) alterados.push({ path: k, content: after[k] });
+  }
+  for (const k of Object.keys(before)) if (!(k in after)) removidos.push({ path: k });
+  return { criados, alterados, removidos };
+}
+
+// ── juiz ─────────────────────────────────────────────────────────────────────
+function _extractJson(s) {
+  const t = String(s || '').replace(/```(?:json)?/gi, '').trim();
+  if (!t) return null;
+  // 1) o texto inteiro já é JSON? (caminho feliz)
+  try { return JSON.parse(t); } catch (_) {}
+  // 2) varre o 1º objeto {...} BALANCEADO que parseia — respeita strings/escapes, então
+  //    prosa com chaves antes/depois (ex.: 'Resultado {ok}: {"pass":true}') não quebra mais.
+  for (let i = 0; i < t.length; i++) {
+    if (t[i] !== '{') continue;
+    let depth = 0, inStr = false, esc = false;
+    for (let j = i; j < t.length; j++) {
+      const ch = t[j];
+      if (inStr) { if (esc) esc = false; else if (ch === '\\') esc = true; else if (ch === '"') inStr = false; continue; }
+      if (ch === '"') inStr = true;
+      else if (ch === '{') depth++;
+      else if (ch === '}') { if (--depth === 0) { try { return JSON.parse(t.slice(i, j + 1)); } catch (_) {} break; } }
+    }
+  }
+  return null;
+}
+
+async function judge({ key, baseUrl, model, caseObj, evidence }) {
+  const changed = [...evidence.diff.criados, ...evidence.diff.alterados]
+    .map(f => `--- ${f.path} ---\n${String(f.content).slice(0, 4000)}`).join('\n\n') || '(nenhum arquivo criado/alterado)';
+  const removed = evidence.diff.removidos.map(f => f.path).join(', ') || '(nenhum)';
+  const sys = 'Você é um JUIZ rigoroso e imparcial que avalia se um agente de código CUMPRIU um critério de sucesso. '
+    + 'Baseie-se SÓ na evidência (a resposta final do agente e os arquivos do sandbox). Não dê o benefício da dúvida: '
+    + 'pass=true SOMENTE se o critério foi objetivamente satisfeito pela evidência. Responda APENAS com JSON, sem texto fora dele: '
+    + '{"pass": true|false, "score": 0-100, "reason": "uma frase curta e específica"}.';
+  const user = [
+    'TAREFA dada ao agente:\n' + caseObj.task,
+    '\nCRITÉRIO DE SUCESSO (avalie contra isto):\n' + caseObj.expect,
+    caseObj.readonly ? '\n(MODO SÓ-LEITURA: o agente NÃO deveria ter criado/alterado nenhum arquivo.)' : '',
+    '\n=== EVIDÊNCIA ===',
+    'Erro fatal na execução do agente? ' + (evidence.error ? ('SIM — ' + evidence.error) : 'não'),
+    '\nResposta final do agente:\n' + (String(evidence.text || '').slice(0, 4000) || '(vazia)'),
+    '\nArquivos criados/alterados no sandbox:\n' + changed,
+    '\nArquivos removidos: ' + removed,
+  ].join('\n');
+  const r = await agent.llm({ baseUrl, key, model, noTools: true, signalMs: 60000,
+    messages: [{ role: 'system', content: sys }, { role: 'user', content: user }] });
+  const u = r.usage || {};
+  const j = _extractJson(r.msg && r.msg.content) || {};
+  return {
+    pass: j.pass === true,
+    score: Math.max(0, Math.min(100, Number(j.score) || (j.pass === true ? 100 : 0))),
+    reason: String(j.reason || (j.pass === true ? 'critério cumprido' : 'critério não cumprido')).slice(0, 240),
+    _tin: u.prompt_tokens || 0, _tout: u.completion_tokens || 0,
+    _raw: !Object.keys(j).length ? String(r.msg && r.msg.content || '').slice(0, 200) : null,
+  };
+}
+
+// ── runner ───────────────────────────────────────────────────────────────────
+// opts: { token, lang, model (executor), judgeModel, onCase({i,total,id,phase}) }
+// Roda os casos EM SÉRIE (sandbox isolado por caso; evita colisão e rate-limit).
+async function runSuite(suite, opts = {}) {
+  const { token, lang = 'pt', model = null, judgeModel = DEFAULT_JUDGE } = opts;
+  const onCase = opts.onCase || (() => {});
+  // chave sk-hub (mesma do agente) — reusada pra chamar o juiz direto no gateway.
+  const k = await api('/api/ai/key?feature=cli_agent', { token, timeoutMs: 20000 });
+  if (!k || !k.key) { const e = new Error('sem chave de IA'); e.code = 'ai_key'; throw e; }
+
+  const results = [];
+  const total = suite.cases.length;
+  for (let i = 0; i < total; i++) {
+    const c = suite.cases[i];
+    let sandbox = null;
+    let evidence = { text: '', error: null, diff: { criados: [], alterados: [], removidos: [] } };
+    let runCredits = 0, runSteps = 0, verdict = null, judgeTin = 0, judgeTout = 0;
+    const t0 = Date.now();
+    try {
+      // sandbox DENTRO do try: se mkdtempSync falhar (EMFILE/disco cheio/permissão) o caso
+      // REPROVA sozinho, não derruba a suíte inteira.
+      sandbox = fs.mkdtempSync(path.join(os.tmpdir(), 'ts-eval-'));
+      // prepara arquivos de fixture. GUARDA de path traversal: um caminho com "../"
+      // que ESCAPE o sandbox é ignorado (uma suíte compartilhada não deve escrever fora).
+      for (const [rel, content] of Object.entries(c.files)) {
+        const fp = path.resolve(sandbox, rel);
+        if (fp !== sandbox && !fp.startsWith(sandbox + path.sep)) continue;
+        fs.mkdirSync(path.dirname(fp), { recursive: true });
+        fs.writeFileSync(fp, String(content));
+      }
+      const before = _snap(sandbox);
+      onCase({ i, total, id: c.id, phase: 'run' });
+      // roda o agente CONFINADO no sandbox (confineDir), sem hooks de sessão, --yes
+      // (destrutivo é recusado sozinho — eval nunca deve pedir aprovação humana).
+      let out;
+      try {
+        out = await agent.run(c.task, {
+          token, lang, yes: true, model,
+          cwd: sandbox, confineDir: sandbox, readOnly: c.readonly,
+          skipSessionStart: true,
+        });
+      } catch (e) {
+        if (e && (e.code === 'no_credits' || e.status === 402)) throw e; // teto → aborta a suíte
+        evidence.error = String((e && e.message) || e).slice(0, 300);
+        out = null;
+      }
+      if (out) { evidence.text = out.text || ''; runCredits = out.credits || 0; runSteps = out.steps || 0; }
+      const after = _snap(sandbox);
+      evidence.diff = _diff(before, after);
+      // julga (mesmo com erro fatal — o juiz vê o erro e reprova com motivo)
+      onCase({ i, total, id: c.id, phase: 'judge' });
+      try {
+        verdict = await judge({ key: k.key, baseUrl: k.baseUrl, model: judgeModel, caseObj: c, evidence });
+        judgeTin = verdict._tin || 0; judgeTout = verdict._tout || 0;
+      } catch (e) {
+        if (e && (e.code === 'no_credits' || e.status === 402)) throw e;
+        verdict = { pass: false, score: 0, reason: 'juiz falhou: ' + String((e && e.message) || e).slice(0, 120) };
+      }
+    } catch (e) {
+      // teto de IA → aborta a suíte inteira (o finally limpa o sandbox antes de propagar).
+      if (e && (e.code === 'no_credits' || e.status === 402)) throw e;
+      // qualquer outra falha (mkdtemp, fixture inválida, snapshot, etc.) → REPROVA SÓ ESTE
+      // CASO, nunca derruba a suíte toda.
+      evidence.error = evidence.error || String((e && e.message) || e).slice(0, 300);
+      verdict = verdict || { pass: false, score: 0, reason: 'caso falhou: ' + String((e && e.message) || e).slice(0, 120) };
+    } finally {
+      // limpa o sandbox (best-effort; pode ser null se o mkdtemp falhou)
+      if (sandbox) { try { fs.rmSync(sandbox, { recursive: true, force: true }); } catch (_) {} }
+    }
+    if (!verdict) verdict = { pass: false, score: 0, reason: 'sem veredito' };
+    results.push({
+      id: c.id, pass: verdict.pass, score: verdict.score, reason: verdict.reason,
+      error: evidence.error, steps: runSteps, credits: runCredits,
+      changed: evidence.diff.criados.length + evidence.diff.alterados.length,
+      judgeTokens: judgeTin + judgeTout, ms: Date.now() - t0, judgeRaw: verdict._raw || null,
+    });
+    onCase({ i, total, id: c.id, phase: 'done', pass: verdict.pass, score: verdict.score });
+  }
+
+  const passed = results.filter(r => r.pass).length;
+  const summary = {
+    name: suite.name, total, passed, failed: total - passed,
+    passRate: total ? Math.round((100 * passed) / total) : 0,
+    avgScore: total ? Math.round(results.reduce((a, r) => a + r.score, 0) / total) : 0,
+    credits: results.reduce((a, r) => a + (r.credits || 0), 0),
+    // tokens do JUIZ (não são cobrados como Smart Credits, mas consomem o teto sk-hub —
+    // exibidos à parte pra o custo do relatório ser honesto).
+    judgeTokens: results.reduce((a, r) => a + (r.judgeTokens || 0), 0),
+    ms: results.reduce((a, r) => a + (r.ms || 0), 0),
+  };
+  return { summary, results };
+}
+
+module.exports = { loadSuite, normCases, runSuite, judge, smokeSuite, EXAMPLE,
+  _test: { _diff, _snap, _extractJson, normCases } };

package/lib/hooks.js

@@ -0,0 +1,72 @@
+// Hooks de ciclo de vida do agente ts (padrão Claude Code) — DETERMINÍSTICOS, rodam
+// independente do que o modelo decide. Generaliza o gate destrutivo hardcoded.
+//
+// SEGURANÇA: hooks rodam comando de shell. Por isso SÓ carregamos o arquivo GLOBAL
+// ~/.ts/hooks.json (config da própria máquina do usuário = confiável). NÃO lemos
+// .ts-hooks.json de projeto — um repo clonado poderia embutir um hook malicioso (RCE).
+//
+// Formato ~/.ts/hooks.json:
+// {
+//   "PreToolUse":  [{ "match": "escrever_arquivo|editar_arquivo", "command": "meu-script.sh" }],
+//   "PostToolUse": [{ "match": "editar_arquivo", "command": "prettier --write $TS_FILE || true" }],
+//   "SessionStart":[{ "command": "echo contexto extra" }]
+// }
+// Cada hook recebe o PAYLOAD como JSON no stdin. Também expõe env: TS_TOOL, TS_FILE, TS_EVENT.
+// PreToolUse: exit != 0 ⇒ BLOQUEIA (stderr = motivo); ou stdout JSON {"decision":"block","reason":"..."}.
+// PostToolUse/SessionStart: stdout vira FEEDBACK/contexto pro modelo (não bloqueia).
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const FILE = path.join(os.homedir(), '.ts', 'hooks.json');
+const EVENTS = ['PreToolUse', 'PostToolUse', 'SessionStart', 'Stop'];
+
+function load() {
+  const out = { PreToolUse: [], PostToolUse: [], SessionStart: [], Stop: [] };
+  try {
+    const cfg = JSON.parse(fs.readFileSync(FILE, 'utf8'));
+    for (const ev of EVENTS) if (Array.isArray(cfg[ev])) out[ev] = cfg[ev].filter(h => h && typeof h.command === 'string');
+  } catch (_) {}
+  out._any = EVENTS.some(ev => out[ev].length);
+  return out;
+}
+
+// Roda os hooks de um evento que casam com o toolName. NUNCA lança (best-effort).
+// Retorna { block, reason, feedback }.
+function run(hooks, event, payload = {}) {
+  const list = (hooks && hooks[event]) || [];
+  if (!list.length) return { block: false, feedback: '' };
+  // TS_FILE vem do MODELO (caminho que ele passou). Se tiver metacaractere de shell, NÃO exporta
+  // (evita command injection quando o hook do usuário referencia %TS_FILE%/$TS_FILE sem aspas).
+  const _raw = (payload.input && (payload.input.caminho || payload.input.arquivo)) || '';
+  const _tsFile = /[&|<>;$%()`"'\r\n*]/.test(String(_raw)) ? '' : String(_raw);
+  let feedback = '';
+  for (const h of list) {
+    // regex de match inválida → PULA o hook (não roda em tudo por engano — fail-safe, não fail-open)
+    if (h.match) { let re; try { re = new RegExp(h.match); } catch (_) { continue; } if (payload.tool && !re.test(payload.tool)) continue; }
+    const _t = Number(h.timeout);
+    let out = '';
+    try {
+      out = execSync(h.command, {
+        input: JSON.stringify(payload),
+        timeout: Math.min(_t > 0 ? _t : 15000, 60000),
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: Object.assign({}, process.env, { TS_EVENT: event, TS_TOOL: payload.tool || '', TS_FILE: _tsFile }),
+      });
+    } catch (e) {
+      const reason = String((e && (e.stderr || e.stdout || e.message)) || '').slice(0, 600).trim();
+      if (event === 'PreToolUse') return { block: true, reason: reason || `hook bloqueou "${payload.tool}"` };
+      if (reason) feedback += (feedback ? '\n' : '') + reason;
+      continue;
+    }
+    let j = null; try { j = JSON.parse(out); } catch (_) {}
+    if (event === 'PreToolUse' && j && j.decision === 'block') return { block: true, reason: String(j.reason || '').slice(0, 600) || `hook bloqueou "${payload.tool}"` };
+    const fb = (j && (j.feedback || j.reason)) || String(out || '').trim();
+    if (fb) feedback += (feedback ? '\n' : '') + String(fb).slice(0, 600);
+  }
+  return { block: false, feedback };
+}
+
+module.exports = { load, run, FILE };