terminal-smart-cli 0.64.0 → 0.65.0

package/bin/ts.js

@@ -1671,6 +1671,49 @@ function buscarCmd(args) {
   ], { title: 'ts buscar' }));
 }
 
+// ── ts verificar — PROVA determinística de que a tarefa terminou (verificadores) ──
+async function verificarCmd(args) {
+  const en = (cfg.lang === 'en');
+  const _fs = require('fs');
+  const verify = require('../lib/verify');
+  const _val = (names) => { const i = rawArgs.findIndex(a => names.includes(a)); return i >= 0 ? rawArgs[i + 1] : null; };
+  const cwd = process.cwd();
+
+  // 1) arquivo de critérios (JSON: array ou {criteria:[...]}) OU 2) critérios inline via flags
+  let criteria = [];
+  const file = (args || []).find(a => !a.startsWith('-') && /\.json$/i.test(a));
+  if (file) {
+    try { const j = JSON.parse(_fs.readFileSync(file, 'utf8')); criteria = Array.isArray(j) ? j : (j.criteria || []); }
+    catch (e) { console.log(ui.errLine((en ? 'could not read criteria file: ' : 'não deu pra ler o arquivo de critérios: ') + (e.message || e))); process.exit(2); }
+  } else {
+    const cmd = _val(['--cmd', '--comando']); if (cmd) criteria.push({ type: 'command', cmd, exit: Number(_val(['--exit', '--codigo'])) || 0 });
+    const ex = _val(['--existe', '--exists']); if (ex) criteria.push({ type: 'file_exists', path: ex });
+    const arq = _val(['--arquivo', '--file']); const cont = _val(['--contem', '--contains']);
+    if (arq && cont != null) criteria.push({ type: 'file_contains', path: arq, text: cont });
+    const url = _val(['--url']); if (url) criteria.push({ type: 'http', url, status: Number(_val(['--status'])) || 200, ...(cont != null && !arq ? { contains: cont } : {}) });
+    const porta = _val(['--porta', '--port']); if (porta) criteria.push({ type: 'port', port: Number(porta) });
+  }
+  if (!criteria.length) {
+    console.log(ui.infoLine(en
+      ? 'usage: ts verificar criterios.json  OR  ts verificar --cmd "npm test" --url http://localhost:3000/health --status 200 --porta 3000 --existe dist/app.js'
+      : 'uso: ts verificar criterios.json  OU  ts verificar --cmd "npm test" --url http://localhost:3000/health --status 200 --porta 3000 --existe dist/app.js'));
+    return;
+  }
+
+  if (!JSON_OUT) console.log('\n' + C.dim(en ? 'proving completion — ' : 'provando conclusão — ') + criteria.length + (en ? ' criterion(s)…' : ' critério(s)…'));
+  const rep = await verify.runAll(criteria, { cwd });
+  if (JSON_OUT) { console.log(JSON.stringify(rep)); process.exit(rep.allOk ? 0 : 1); }
+
+  for (const r of rep.results) {
+    const mark = r.ok ? C.ok('✔') : C.err('✗');
+    console.log('  ' + mark + ' ' + C.bold(r.label || r.type) + C.dim('  ' + (r.detail || '')) + (r.errorClass ? C.dim('  [' + r.errorClass + ']') : ''));
+    if (!r.ok && r.evidence) console.log('    ' + C.dim('┄ ' + String(r.evidence).slice(0, 120)));
+  }
+  console.log('\n' + (rep.allOk ? ui.okLine : ui.errLine)(
+    (rep.allOk ? (en ? 'VERIFIED' : 'VERIFICADO') : (en ? 'NOT verified' : 'NÃO verificado')) + C.dim(`  ${rep.passed}/${rep.total} ` + (en ? 'passed' : 'ok'))));
+  process.exit(rep.allOk ? 0 : 1);
+}
+
 // ── ts perfil — personas com COFRE DE MEMÓRIA isolado (Mempalace/Hermes) ──────
 function perfilCmd(args) {
   const en = (cfg.lang === 'en');
@@ -1933,6 +1976,7 @@ function recallCmd(args) {
     case 'indexar': case 'index': return indexarCmd();
     case 'buscar': case 'search': case 'procurar': return buscarCmd(POS.slice(1));
     case 'perfil': case 'persona': case 'profile': return perfilCmd(POS.slice(1));
+    case 'verificar': case 'verify': case 'provar': return verificarCmd(POS.slice(1));
     case 'meta': case 'missao': case 'mission': return metaCmd();
     case 'runs':   return runsCmd();
     case 'status': return statusCmd(POS[1]);

package/lib/i18n.js

@@ -45,6 +45,7 @@ const STR = {
         ['ts meta "objetivo grande"', 'MISSÃO: checklist + rodadas até terminar (noturno)'],
         ['ts meta --status', 'estado da missão deste diretório'],
         ['ts eval suite.json', 'avalia o agente numa suíte de casos (juiz de IA + nota)'],
+        ['ts verificar --cmd "npm test" --url ... --porta N', 'PROVA determinística de conclusão (build/http/porta/arquivo); exit 1 pra CI'],
         ['ts acp', 'servidor Agent Client Protocol (conecta o ts a editores tipo Zed)'],
         ['ts mcp', 'servidores MCP: as ferramentas deles entram no agente'],
       ] },

package/lib/verify.js

@@ -0,0 +1,104 @@
+// VERIFICADORES POR DOMÍNIO — a PROVA determinística de que uma tarefa terminou.
+// Insight das análises externas (GPT): "o modelo propõe; o harness observa e COMPROVA".
+// Cada critério é EXECUTÁVEL e checado por código (não pela narrativa do modelo nem por um
+// LLM-judge). É a base do TaskSpec (critérios executáveis) e do Evidence Ledger, e o motor
+// do comando `ts verificar` (o "Prove que terminou"). Usa o classificador de erro do core.
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const net = require('net');
+const { execSync } = require('child_process');
+const core = require('./core');
+
+// ── verificadores individuais (cada um devolve { ok, detail }) ───────────────
+function _abs(cwd, p) { return path.isAbsolute(p) ? p : path.join(cwd || process.cwd(), p); }
+
+function vCommand(c, cwd) {
+  const want = c.exit != null ? Number(c.exit) : 0;
+  try {
+    const out = execSync(c.cmd, { cwd, encoding: 'utf8', timeout: (c.timeout_s || 120) * 1000, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+    const ok = want === 0;
+    return { ok, detail: ok ? 'exit 0' : `exit 0 mas esperava ${want}`, evidence: String(out).slice(-200).replace(/\s+/g, ' ') };
+  } catch (e) {
+    const code = typeof e.status === 'number' ? e.status : 1;
+    const ok = code === want;
+    const cls = core.classifyError(e.stderr || e.stdout || e.message);
+    return { ok, detail: ok ? `exit ${code} (esperado)` : `exit ${code} (esperava ${want})`, errorClass: ok ? null : cls, evidence: String(e.stderr || e.stdout || e.message || '').slice(-200).replace(/\s+/g, ' ') };
+  }
+}
+function vFileExists(c, cwd) { const p = _abs(cwd, c.path); const ok = fs.existsSync(p); return { ok, detail: ok ? 'existe' : 'não existe: ' + c.path }; }
+function vFileAbsent(c, cwd) { const p = _abs(cwd, c.path); const ok = !fs.existsSync(p); return { ok, detail: ok ? 'ausente (ok)' : 'existe (não deveria): ' + c.path }; }
+function vFileContains(c, cwd) {
+  const p = _abs(cwd, c.path);
+  let src = null; try { src = fs.readFileSync(p, 'utf8'); } catch (_) { return { ok: false, detail: 'não deu pra ler: ' + c.path }; }
+  const hit = c.regex ? new RegExp(c.text, c.flags || '').test(src) : src.includes(c.text);
+  const want = c.absent ? !hit : hit;
+  return { ok: want, detail: want ? 'ok' : (c.absent ? `contém "${c.text}" (não deveria)` : `NÃO contém "${c.text}"`) };
+}
+async function vHttp(c) {
+  const want = c.status != null ? Number(c.status) : 200;
+  const ctrl = new AbortController(); const t = setTimeout(() => ctrl.abort(), (c.timeout_s || 15) * 1000);
+  try {
+    const res = await fetch(c.url, { method: c.method || 'GET', signal: ctrl.signal, headers: c.headers || {}, ...(c.body ? { body: typeof c.body === 'string' ? c.body : JSON.stringify(c.body) } : {}) });
+    let body = ''; try { body = await res.text(); } catch (_) {}
+    const statusOk = res.status === want;
+    const containsOk = c.contains ? body.includes(c.contains) : true;
+    const ok = statusOk && containsOk;
+    return { ok, detail: ok ? `HTTP ${res.status}` : (!statusOk ? `HTTP ${res.status} (esperava ${want})` : `HTTP ${res.status} mas sem "${c.contains}"`), evidence: body.slice(0, 160).replace(/\s+/g, ' ') };
+  } catch (e) { return { ok: false, detail: 'sem resposta: ' + (e.message || e), errorClass: 'network' }; }
+  finally { clearTimeout(t); }
+}
+function vPort(c) {
+  return new Promise((resolve) => {
+    const host = c.host || '127.0.0.1'; const port = Number(c.port);
+    const sock = new net.Socket(); let done = false;
+    const finish = (ok, detail) => { if (done) return; done = true; try { sock.destroy(); } catch (_) {} resolve({ ok, detail }); };
+    sock.setTimeout((c.timeout_s || 5) * 1000);
+    sock.once('connect', () => finish(true, `porta ${port} escutando`));
+    sock.once('timeout', () => finish(false, `porta ${port} sem resposta (timeout)`));
+    sock.once('error', () => finish(false, `porta ${port} fechada/recusada`));
+    sock.connect(port, host);
+  });
+}
+
+const VERIFIERS = {
+  command: (c, cwd) => vCommand(c, cwd),
+  file_exists: (c, cwd) => vFileExists(c, cwd),
+  file_absent: (c, cwd) => vFileAbsent(c, cwd),
+  file_contains: (c, cwd) => vFileContains(c, cwd),
+  http: (c) => vHttp(c),
+  port: (c) => vPort(c),
+};
+const VERIFIER_TYPES = Object.keys(VERIFIERS);
+
+// Roda UM critério. Sempre resolve { ok, type, detail, ... } — nunca lança.
+async function runCriterion(c, opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  const type = c && c.type;
+  const fn = VERIFIERS[type];
+  if (!fn) return { ok: false, type: type || '?', detail: 'tipo de critério desconhecido: ' + type, unknown: true };
+  try { const r = await fn(c, cwd); return Object.assign({ type, label: c.label || _labelFor(c) }, r); }
+  catch (e) { return { ok: false, type, label: c.label || _labelFor(c), detail: 'erro no verificador: ' + (e.message || e) }; }
+}
+function _labelFor(c) {
+  switch (c.type) {
+    case 'command': return '`' + String(c.cmd).slice(0, 50) + '` → exit ' + (c.exit != null ? c.exit : 0);
+    case 'file_exists': return 'existe ' + c.path;
+    case 'file_absent': return 'ausente ' + c.path;
+    case 'file_contains': return c.path + (c.absent ? ' SEM ' : ' contém ') + '"' + String(c.text).slice(0, 30) + '"';
+    case 'http': return (c.method || 'GET') + ' ' + c.url + ' → ' + (c.status || 200);
+    case 'port': return 'porta ' + c.port + ' escutando';
+    default: return c.type || '?';
+  }
+}
+
+// Roda uma LISTA de critérios. Retorna resumo + resultados (o Evidence Ledger mínimo).
+async function runAll(criteria, opts = {}) {
+  const list = Array.isArray(criteria) ? criteria : (criteria && Array.isArray(criteria.criteria) ? criteria.criteria : []);
+  const results = [];
+  for (const c of list) results.push(await runCriterion(c, opts));
+  const passed = results.filter(r => r.ok).length;
+  return { allOk: results.length > 0 && passed === results.length, passed, total: results.length, results };
+}
+
+module.exports = { runCriterion, runAll, VERIFIERS, VERIFIER_TYPES, _labelFor };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terminal-smart-cli",
-  "version": "0.64.0",
+  "version": "0.65.0",
   "description": "Terminal Smart no seu terminal — pergunte, analise logs por pipe e orquestre agentes de IA. Comando: ts",
   "bin": {
     "ts": "bin/ts.js"