@fefsbenson/jarvis 1.1.0 → 1.2.0

package/bin/cli.js

@@ -12,7 +12,9 @@
  *
  * JARVIS · PRAGMA · by Felipe Brandão
  */
-import { createWriteStream, existsSync, mkdirSync, readdirSync, statSync } from 'node:fs';
+import { createWriteStream, existsSync, mkdirSync, readdirSync, statSync,
+         readFileSync, writeFileSync, copyFileSync, rmSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { spawn, spawnSync } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { tmpdir } from 'node:os';
@@ -323,11 +325,368 @@ async function instalar(args) {
   return r.status ?? 0;
 }
 
+// ══════════════════════════════════════════════════════════════════
+//  UPDATE — traz a versão nova sem apagar o que o dono fez
+// ══════════════════════════════════════════════════════════════════
+
+/**
+ * O manifesto que a instalação grava: hash de cada arquivo COMO SAIU do
+ * pacote. É ele que torna a atualização possível sem escolher entre duas
+ * coisas ruins — apagar o trabalho do dono, ou nunca entregar correção.
+ *
+ * Sem manifesto (instalação anterior à v1.1.7) o update ainda funciona,
+ * mas não sabe o que foi alterado: aí ele preserva por precaução tudo que
+ * difere do pacote novo, e diz isso na tela.
+ */
+function lerManifesto(raiz) {
+  const f = join(raiz, '.claude', 'jarvis', 'instalacao-original.json');
+  if (!existsSync(f)) return null;
+  try {
+    const d = JSON.parse(readFileSync(f, 'utf8'));
+    return (d && d.arquivos) ? d : null;
+  } catch { return null; }
+}
+
+function hashDe(caminho) {
+  try {
+    return createHash('sha256').update(readFileSync(caminho)).digest('hex');
+  } catch { return null; }
+}
+
+/**
+ * Pastas que NUNCA se sobrescreve, porque são do dono por natureza:
+ * credenciais, memória do sistema, o trabalho dele, estado e registros.
+ * Isto não depende do manifesto — é contrato, e vale mesmo sem ele.
+ */
+const INTOCAVEIS = [
+  '.env', '.venv', 'node_modules', '.git',
+  'jarvis.config.yaml',
+  '.claude/settings.local.json',
+  '.claude/jarvis/',          // memória, estado, ponteiros
+  '.claude/sessions/',        // histórico de sessões
+  'workspace/',               // o negócio do dono
+  'knowledge/business/', 'knowledge/personal/',
+  'logs/', '.data/', 'artifacts/', 'processing/',
+];
+
+/**
+ * Exceções DENTRO de pasta protegida: arquivos que o sistema mantém e o dono
+ * não escreve. Sem esta lista, `.claude/jarvis/` inteiro fica congelado — e o
+ * manifesto nunca se renova, então uma instalação antiga seguiria para sempre
+ * sem saber o que o dono alterou.
+ */
+const SEMPRE_ATUALIZA = ['VERSION', 'MANIFESTO-PACOTE.json', 'LICENSE'];
+
+const EXCECOES = [
+  '.claude/jarvis/instalacao-original.json',
+];
+
+function ehIntocavel(rel) {
+  const n = rel.split('\\').join('/');
+  if (EXCECOES.includes(n)) return false;
+  return INTOCAVEIS.some(i => i.endsWith('/') ? n.startsWith(i) : n === i);
+}
+
+function listar(dir, base = dir, saida = []) {
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    if (e.name === 'node_modules' || e.name === '.git' ||
+        e.name === '__pycache__' || e.name === '.venv') continue;
+    const cheio = join(dir, e.name);
+    const rel = cheio.slice(base.length + 1).split('\\').join('/');
+    if (e.isDirectory()) listar(cheio, base, saida);
+    else saida.push(rel);
+  }
+  return saida;
+}
+
+/**
+ * Compara a instalação atual com o pacote novo e classifica cada arquivo.
+ *
+ * Os quatro casos, e por que cada um se resolve assim:
+ *
+ *   novo       — não existe aqui: entra.
+ *   igual      — o dono não mexeu E o pacote não mudou: nada a fazer.
+ *   atualiza   — o dono não mexeu e o pacote mudou: entra (é a correção).
+ *   preserva   — o dono MEXEU: fica o dele. É o ponto todo do manifesto;
+ *                sem ele, "atualizar" seria apagar o trabalho de alguém.
+ */
+/**
+ * O "motor": o que faz o sistema funcionar, por oposição ao que ele guarda.
+ * Numa instalação sem manifesto é a única forma de distinguir a correção
+ * chegando de uma edição do dono — e a chance de alguém ter editado um hook
+ * à mão é muito menor que a de ficar sem o conserto.
+ */
+function ehDoMotor(rel) {
+  const n = rel.split('\\').join('/');
+  return n.startsWith('.claude/hooks/') ||
+         n.startsWith('.claude/scripts/') ||
+         n.startsWith('core/') ||
+         n.startsWith('bin/') ||
+         n === 'install.py' ||
+         n === 'requirements.txt' ||
+         n === 'requirements-opcional.txt';
+}
+
+function planejar(raizAtual, raizNova, manifesto) {
+  const orig = manifesto ? manifesto.arquivos : null;
+  const plano = { novo: [], atualiza: [], preserva: [], igual: [], protegido: [] };
+
+  for (const rel of listar(raizNova)) {
+    if (ehIntocavel(rel)) { plano.protegido.push(rel); continue; }
+
+    const aqui = join(raizAtual, rel);
+    if (!existsSync(aqui)) { plano.novo.push(rel); continue; }
+
+    const hAqui = hashDe(aqui);
+    const hNovo = hashDe(join(raizNova, rel));
+    if (hAqui === hNovo) { plano.igual.push(rel); continue; }
+
+    // difere do pacote novo. Foi o dono que mexeu, ou é a correção chegando?
+    // Metadados do pacote são do sistema por definição — o dono nunca os
+    // edita. Preservar o VERSION deixaria o update dizendo "já está na versão
+    // mais recente" para sempre numa instalação sem manifesto.
+    if (SEMPRE_ATUALIZA.includes(rel)) { plano.atualiza.push(rel); continue; }
+
+    if (orig) {
+      const hOrig = orig[rel];
+      // sem registro de origem = arquivo que o dono criou depois: preserva
+      if (!hOrig) { plano.preserva.push(rel); continue; }
+      // igual ao que foi instalado = intocado pelo dono: pode atualizar
+      if (hAqui === hOrig) { plano.atualiza.push(rel); continue; }
+      plano.preserva.push(rel);
+    } else {
+      // Sem manifesto não dá para saber quem alterou o quê. Preservar TUDO
+      // parece seguro, mas trava o update onde ele mais importa: numa
+      // instalação antiga, os arquivos do MOTOR (scripts, hooks, instalador)
+      // são exatamente os que carregam a correção — e quase nunca são
+      // editados pelo dono. Preservá-los entregaria um update que não
+      // atualiza nada, com um .novo inerte ao lado.
+      //
+      // Então: motor atualiza, conteúdo preserva. E o que for sobrescrito
+      // ganha backup .antigo, para nada ser perdido sem volta.
+      plano[ehDoMotor(rel) ? 'atualiza' : 'preserva'].push(rel);
+    }
+  }
+  return plano;
+}
+
+function mostrarPlano(plano, semManifesto) {
+  const l = (rot, arr, cor) => {
+    if (!arr.length) return;
+    console.log(`  ${cor(String(arr.length).padStart(5))}  ${branco(rot)}`);
+  };
+  console.log();
+  console.log(`  ${branco(neg('O que vai acontecer'))}`);
+  console.log();
+  l('arquivos novos', plano.novo, verde);
+  l('atualizados', plano.atualiza, verde);
+  l('preservados (você alterou)', plano.preserva, laranja);
+  l('já estavam iguais', plano.igual, fraco);
+  l('protegidos (memória, workspace, .env)', plano.protegido, cinza);
+  console.log();
+
+  if (plano.preserva.length) {
+    const amostra = plano.preserva.slice(0, 6);
+    console.log(`  ${laranja('Preservados')} ${fraco('— fica a SUA versão, e guardo a nova ao lado como .novo')}`);
+    for (const a of amostra) console.log(`    ${fraco('·')} ${cinza(a)}`);
+    if (plano.preserva.length > amostra.length) {
+      console.log(`    ${fraco(`· e mais ${plano.preserva.length - amostra.length}`)}`);
+    }
+    console.log();
+  }
+
+  if (semManifesto) {
+    console.log(`  ${laranja('!')}  ${cinza('Sua instalação é anterior ao registro de arquivos.')}`);
+    console.log(`     ${fraco('Sem ele não sei o que você alterou. Então atualizo o motor do sistema')}`);
+    console.log(`     ${fraco('(hooks, scripts, instalador) — é onde a correção vem — e preservo o')}`);
+    console.log(`     ${fraco('resto. O que for sobrescrito fica salvo como .antigo, e dá para voltar.')}`);
+    console.log(`     ${fraco('A partir desta atualização, o registro passa a existir.')}`);
+    console.log();
+  }
+}
+
+function aplicar(raizAtual, raizNova, plano) {
+  let n = 0;
+  for (const rel of [...plano.novo, ...plano.atualiza]) {
+    const destino = join(raizAtual, rel);
+    mkdirSync(join(destino, '..'), { recursive: true });
+    // guarda o anterior quando o conteúdo difere: sem manifesto a decisão de
+    // atualizar é uma aposta informada, e aposta precisa ter volta.
+    if (existsSync(destino) && hashDe(destino) !== hashDe(join(raizNova, rel))) {
+      try { copyFileSync(destino, destino + '.antigo'); } catch {}
+    }
+    copyFileSync(join(raizNova, rel), destino);
+    n++;
+  }
+  // o que o dono alterou fica intacto; a versão nova vai ao lado, para ele ver
+  for (const rel of plano.preserva) {
+    copyFileSync(join(raizNova, rel), join(raizAtual, rel + '.novo'));
+  }
+  return n;
+}
+
+async function atualizar(args) {
+  abertura();
+
+  const raiz = resolve(process.cwd(), args[0] || '.');
+  const marca = join(raiz, '.claude', 'hooks');
+  if (!existsSync(marca)) {
+    console.log(`  ${vermelho(neg('Não encontrei um JARVIS aqui.'))}`);
+    console.log(`  ${cinza('Rode este comando DENTRO da pasta do JARVIS, ou passe o caminho:')}`);
+    console.log(`      ${fraco('npx @fefsbenson/jarvis update C:\\Users\\voce\\jarvis')}`);
+    console.log();
+    return 1;
+  }
+
+  const versaoAtual = existsSync(join(raiz, 'VERSION'))
+    ? readFileSync(join(raiz, 'VERSION'), 'utf8').trim() : '?';
+
+  const py = acharPython();
+  const plataforma = existsSync(join(raiz, '.claude', 'hooks', 'pyrun.py'))
+    ? 'windows' : 'linux';
+
+  console.log(`  ${verde('✓')}  ${branco('JARVIS encontrado')}  ${fraco(raiz)}`);
+  console.log(`  ${verde('✓')}  ${branco('Versão atual')}  ${cinza('v' + versaoAtual)}` +
+              `   ${fraco('edição ' + PLATAFORMAS[plataforma].rotulo)}`);
+  console.log();
+  console.log(`  ${cinza('Vou baixar a versão mais recente e trazer só o que mudou.')}`);
+  console.log(`  ${cinza('O que você alterou fica como está — nada seu é sobrescrito.')}`);
+  console.log();
+
+  const token = process.env.JARVIS_TOKEN || await perguntar('Token:', true);
+  if (!token) {
+    console.log(`\n  ${fraco('Sem token, não há o que baixar. Cancelado.')}\n`);
+    return 130;
+  }
+
+  const tmp = join(tmpdir(), `jarvis-update-${Date.now()}`);
+  console.log();
+  try {
+    await baixar(token, tmp, plataforma);
+  } catch (e) {
+    if (e.message === 'TOKEN_INVALIDO' || e.message === 'SEM_ACESSO') erroDeAcesso(e.message);
+    else {
+      console.log(`\n  ${vermelho(neg('Não consegui baixar.'))}`);
+      console.log(`  ${cinza(e.message)}\n`);
+    }
+    return 1;
+  }
+
+  const versaoNova = existsSync(join(tmp, 'VERSION'))
+    ? readFileSync(join(tmp, 'VERSION'), 'utf8').trim() : '?';
+
+  if (versaoNova === versaoAtual) {
+    console.log();
+    console.log(`  ${verde('✓')}  ${branco('Você já está na versão mais recente')} ${cinza('(v' + versaoNova + ')')}`);
+    console.log();
+    rmSync(tmp, { recursive: true, force: true });
+    return 0;
+  }
+
+  // Sanidade do que foi baixado, ANTES de encostar na pasta do dono.
+  // Um pacote que extrai pela metade (rede caindo, disco cheio) não faz o tar
+  // falhar necessariamente — e aplicar um pacote incompleto por cima de uma
+  // instalação boa é exatamente o estrago que este comando não pode causar.
+  const marcasEsperadas = ['.claude/hooks', '.claude/scripts', 'VERSION', 'install.py'];
+  const faltando = marcasEsperadas.filter(m => !existsSync(join(tmp, m)));
+  const totalBaixado = listar(tmp).length;
+  if (faltando.length || totalBaixado < 500) {
+    console.log();
+    console.log(`  ${vermelho(neg('O pacote baixado veio incompleto.'))}`);
+    console.log(`  ${cinza(faltando.length ? 'falta: ' + faltando.join(', ')
+                                            : `só ${totalBaixado} arquivos`)}`);
+    console.log();
+    console.log(`  ${branco('Sua instalação NÃO foi tocada.')} ${fraco('Tente de novo.')}`);
+    console.log();
+    rmSync(tmp, { recursive: true, force: true });
+    return 1;
+  }
+
+  const manifesto = lerManifesto(raiz);
+  const plano = planejar(raiz, tmp, manifesto);
+
+  console.log();
+  console.log(`  ${branco(neg(`v${versaoAtual}`))} ${fraco('→')} ${verde(neg(`v${versaoNova}`))}`);
+  mostrarPlano(plano, !manifesto);
+
+  if (!plano.novo.length && !plano.atualiza.length) {
+    console.log(`  ${verde('✓')}  ${branco('Nada a mudar nos arquivos do sistema.')}`);
+    console.log();
+    rmSync(tmp, { recursive: true, force: true });
+    return 0;
+  }
+
+  const ok = (await perguntar(`Aplicar? ${fraco('(enter = sim, n = cancelar)')}`)).trim().toLowerCase();
+  if (ok === 'n' || ok === 'nao' || ok === 'não') {
+    console.log(`\n  ${fraco('Cancelado. Nada foi alterado.')}\n`);
+    rmSync(tmp, { recursive: true, force: true });
+    return 130;
+  }
+
+  console.log();
+  const n = aplicar(raiz, tmp, plano);
+  console.log(`  ${verde('✓')}  ${branco('Aplicado')}  ${fraco(n.toLocaleString('pt-BR') + ' arquivo(s)')}`);
+  rmSync(tmp, { recursive: true, force: true });
+
+  // O settings.json que veio no pacote traz o caminho como `$CLAUDE_PROJECT_DIR`
+  // — sintaxe POSIX. Precisa virar o caminho ABSOLUTO desta máquina, senão no
+  // Windows os 105 hooks morrem (foi o defeito que quebrou a instalação de um
+  // aluno em 24/08).
+  //
+  // Chamar o médico com --fix NÃO basta: em Linux o exame passa (lá a variável
+  // expande), então o conserto nem é acionado e o marcador fica. Por isso a
+  // regravação é INCONDICIONAL — o install.py sabe fazê-la, e é a mesma função
+  // que roda em toda instalação.
+  if (py) {
+    console.log();
+    console.log(`  ${cinza('Ajustando os caminhos para esta máquina...')}`);
+    const fix = spawnSync(py.cmd, [...(py.args || []), '-c',
+      'import sys;sys.path.insert(0,sys.argv[1]);import install;' +
+      'r=install.fixar_launcher_dos_hooks();print(r[0],r[1])', raiz],
+      { encoding: 'utf8', cwd: raiz });
+    if (fix.status === 0) {
+      console.log(`  ${verde('✓')}  ${branco('Caminhos e launcher gravados')} ${fraco((fix.stdout || '').trim())}`);
+    } else {
+      console.log(`  ${laranja('!')}  ${cinza('Não consegui regravar os caminhos automaticamente.')}`);
+      console.log(`     ${fraco('Rode: ' + py.cmd + ' .claude/scripts/jarvis_doctor.py --fix')}`);
+    }
+
+    // e o registro de arquivos precisa refletir a versão que acabou de entrar,
+    // senão a PRÓXIMA atualização compara contra a versão errada
+    spawnSync(py.cmd, [...(py.args || []), '-c',
+      'import sys;sys.path.insert(0,sys.argv[1]);import install;install.gravar_impressao_digital()', raiz],
+      { encoding: 'utf8', cwd: raiz });
+
+    console.log();
+    console.log(`  ${cinza('Conferindo a instalação...')}`);
+    console.log();
+    const r = spawnSync(py.cmd, [...(py.args || []),
+                                 join(raiz, '.claude', 'scripts', 'jarvis_doctor.py')],
+                        { stdio: 'inherit', cwd: raiz });
+    if (r.status !== 0) {
+      console.log();
+      console.log(`  ${laranja('!')}  ${cinza('O médico apontou algo. Veja acima o que ficou pendente.')}`);
+    }
+  }
+
+  console.log();
+  console.log(`  ${verde(neg('Atualizado para v' + versaoNova + '.'))}`);
+  if (plano.preserva.length) {
+    console.log(`  ${fraco('Seus arquivos alterados continuam lá; a versão nova de cada um está como *.novo')}`);
+  }
+  console.log();
+  return 0;
+}
+
 function ajuda() {
   abertura();
   console.log(`  ${branco('npx @fefsbenson/jarvis install')}          ${fraco('baixa e instala em ./jarvis')}`);
   console.log(`  ${branco('npx @fefsbenson/jarvis install PASTA')}    ${fraco('instala na pasta que você escolher')}`);
   console.log();
+  console.log(`  ${branco('npx @fefsbenson/jarvis update')}           ${fraco('atualiza o JARVIS desta pasta')}`);
+  console.log(`  ${branco('npx @fefsbenson/jarvis update PASTA')}     ${fraco('atualiza o de outra pasta')}`);
+  console.log(`  ${fraco('       o update preserva o que você alterou — nada seu é sobrescrito')}`);
+  console.log();
   console.log(`  ${fraco('Precisa de: Node 18+, Python 3.10+ e o token de acesso.')}`);
   console.log(`  ${fraco('O token também pode vir da variável JARVIS_TOKEN.')}`);
   console.log();
@@ -336,6 +695,8 @@ function ajuda() {
 const [, , comando, ...resto] = process.argv;
 if (comando === 'install') {
   instalar(resto).then(cod => process.exit(cod));
+} else if (comando === 'update' || comando === 'atualizar') {
+  atualizar(resto).then(cod => process.exit(cod));
 } else {
   ajuda();
   process.exit(comando ? 1 : 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fefsbenson/jarvis",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "JARVIS — sistema operacional de conhecimento e agentes para Claude Code (Windows e Linux)",
   "bin": {
     "jarvis": "bin/cli.js"

package/bin/cli.js.bak-antes-windows

@@ -1,297 +0,0 @@
-#!/usr/bin/env node
-/**
- * JARVIS — baixador.
- *
- * Este pacote npm é SÓ o transporte (~20 KB). O sistema em si (108 MB, com
- * conhecimento destilado de material de terceiros) vive num Release PRIVADO
- * do GitHub e exige token de acesso — a licença proíbe distribuição pública.
- *
- *     npx @fefsbenson/jarvis install
- *
- * Só Node built-in: precisa rodar antes de qualquer dependência existir.
- *
- * JARVIS · PRAGMA · by Felipe Brandão
- */
-import { createWriteStream, existsSync, mkdirSync, readdirSync, statSync } from 'node:fs';
-import { spawn, spawnSync } from 'node:child_process';
-import { createInterface } from 'node:readline';
-import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { pipeline } from 'node:stream/promises';
-import { Readable } from 'node:stream';
-
-const REPO = 'fefsbenson/jarvis-entrega';
-const PASTA_PADRAO = 'jarvis';
-
-// ── cores (somem se o terminal não suportar) ─────────────────────────
-const tty = process.stdout.isTTY && !process.env.NO_COLOR;
-const c = (t, k) => (tty ? `\x1b[${k}m${t}\x1b[0m` : t);
-const laranja = t => c(t, '38;5;208');
-const branco = t => c(t, '38;5;255');
-const cinza = t => c(t, '38;5;250');
-const fraco = t => c(t, '38;5;240');
-const verde = t => c(t, '38;5;71');
-const vermelho = t => c(t, '38;5;167');
-const neg = t => c(t, '1');
-
-const LOGO = [
-  '     ██  █████  ██████  ██    ██ ██ ███████',
-  '     ██ ██   ██ ██   ██ ██    ██ ██ ██',
-  '     ██ ███████ ██████  ██    ██ ██ ███████',
-  '██   ██ ██   ██ ██   ██  ██  ██  ██      ██',
-  ' █████  ██   ██ ██   ██   ████   ██ ███████',
-];
-
-function abertura() {
-  console.log();
-  for (const l of LOGO) console.log('  ' + laranja(neg(l)));
-  console.log();
-  console.log(`     ${cinza('Sistema operacional de conhecimento e agentes')}`);
-  console.log(`     ${fraco('PRAGMA  ·  by Felipe Brandão')}`);
-  console.log();
-  console.log('  ' + fraco('─'.repeat(66)));
-  console.log();
-}
-
-function perguntar(texto, oculto = false) {
-  return new Promise(res => {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    if (oculto && process.stdin.isTTY) {
-      // não ecoa o token na tela nem deixa no scrollback
-      const escrever = rl._writeToOutput.bind(rl);
-      rl._writeToOutput = function (s) {
-        if (s.includes(texto)) escrever(s);
-        else escrever('*');
-      };
-    }
-    rl.question(`  ${laranja('▸')} ${texto} `, r => { rl.close(); if (oculto) console.log(); res(r.trim()); });
-  });
-}
-
-/**
- * Precisa de Python — o instalador de verdade é ele.
- *
- * ARMADILHA DO WINDOWS: `python3.exe` em WindowsApps é um STUB da Microsoft
- * Store. Ele imprime "Python não foi encontrado" e sai com código 0 — passa
- * por qualquer teste ingênuo de status. O jeito confiável é validar a SAÍDA,
- * e tentar o `py` launcher, que é o padrão no Windows.
- * (o pyrun.sh do harness já sabia disso; eu não tinha reusado a lição)
- */
-function acharPython() {
-  const tentativas = [
-    ['py', ['-3']],       // launcher oficial do Windows — o mais confiável lá
-    ['python3', []],
-    ['python', []],
-  ];
-  for (const [cmd, pre] of tentativas) {
-    const r = spawnSync(cmd, [...pre, '-c', 'import sys;print(sys.version_info[:2])'],
-                        { encoding: 'utf8' });
-    const saida = (r.stdout || '') + (r.stderr || '');
-    // o stub da Store não imprime tupla nenhuma — só o texto da propaganda
-    if (/n.o foi encontrado|not found|Microsoft Store/i.test(saida)) continue;
-    const m = saida.match(/\((\d+),\s*(\d+)\)/);
-    if (r.status === 0 && m && (+m[1] > 3 || (+m[1] === 3 && +m[2] >= 10))) {
-      return { cmd, args: pre, versao: `${m[1]}.${m[2]}` };
-    }
-  }
-  return null;
-}
-
-async function api(caminho, token, aceitar = 'application/vnd.github+json') {
-  const r = await fetch(`https://api.github.com${caminho}`, {
-    headers: {
-      Authorization: `Bearer ${token}`,
-      Accept: aceitar,
-      'User-Agent': 'jarvis-installer',
-      'X-GitHub-Api-Version': '2022-11-28',
-    },
-    redirect: 'follow',
-  });
-  return r;
-}
-
-function barra(feito, total) {
-  const largura = 28;
-  const pct = total ? feito / total : 0;
-  const cheio = Math.round(pct * largura);
-  return `  ${laranja('█'.repeat(cheio))}${fraco('░'.repeat(largura - cheio))}  ${cinza(`${Math.round(pct * 100)}%`)}`;
-}
-
-async function baixar(token, destino) {
-  // 1. qual é a versão mais recente
-  const rel = await api(`/repos/${REPO}/releases/latest`, token);
-  if (rel.status === 401) throw new Error('TOKEN_INVALIDO');
-  if (rel.status === 404) throw new Error('SEM_ACESSO');
-  if (!rel.ok) throw new Error(`GitHub respondeu ${rel.status}`);
-  const dados = await rel.json();
-
-  const asset = (dados.assets || []).find(a => a.name.endsWith('.tar.gz'));
-  if (!asset) throw new Error('Release sem pacote .tar.gz');
-
-  console.log(`  ${verde('✓')}  ${branco('Versão')} ${cinza(dados.tag_name)}  ${fraco((asset.size / 1048576).toFixed(1) + ' MB')}`);
-
-  // 2. baixa o tarball (asset privado exige Accept: octet-stream)
-  const bin = await api(`/repos/${REPO}/releases/assets/${asset.id}`, token,
-                        'application/octet-stream');
-  if (!bin.ok) throw new Error(`download falhou (${bin.status})`);
-
-  const tmp = join(tmpdir(), `jarvis-${Date.now()}.tar.gz`);
-  const total = Number(bin.headers.get('content-length')) || asset.size;
-  let feito = 0;
-  let ultimo = 0;
-
-  const origem = Readable.fromWeb(bin.body);
-  origem.on('data', pedaco => {
-    feito += pedaco.length;
-    const agora = Date.now();
-    // A barra so redesenha em TTY: com o output capturado (pipe, log, CI) o
-    // \r nao apaga a linha e o progresso vira uma parede de barras.
-    if (tty && agora - ultimo > 200) {
-      ultimo = agora;
-      process.stdout.write('\r' + barra(feito, total));
-    }
-  });
-  await pipeline(origem, createWriteStream(tmp));
-  if (tty) process.stdout.write('\r' + barra(total, total) + '\n');
-  else console.log(`  ${verde('✓')}  ${branco('Baixado')}  ${fraco((total / 1048576).toFixed(1) + ' MB')}`);
-
-  // 3. extrai
-  mkdirSync(destino, { recursive: true });
-  const tar = spawnSync('tar', ['xzf', tmp, '-C', destino, '--strip-components=1'],
-                        { encoding: 'utf8' });
-  if (tar.status !== 0) throw new Error(`tar falhou: ${(tar.stderr || '').slice(0, 120)}`);
-
-  const n = contar(destino);
-  console.log(`  ${verde('✓')}  ${branco('Extraído')}  ${fraco(n.toLocaleString('pt-BR') + ' arquivos')}`);
-  return destino;
-}
-
-function contar(dir) {
-  let n = 0;
-  for (const e of readdirSync(dir, { withFileTypes: true })) {
-    if (e.name === 'node_modules' || e.name === '.git') continue;
-    n += e.isDirectory() ? contar(join(dir, e.name)) : 1;
-  }
-  return n;
-}
-
-function erroDeAcesso(tipo) {
-  console.log();
-  if (tipo === 'TOKEN_INVALIDO') {
-    console.log(`  ${vermelho(neg('Token inválido.'))}`);
-    console.log(`  ${cinza('O token expirou ou foi digitado errado.')}`);
-  } else {
-    console.log(`  ${vermelho(neg('Este token não tem acesso ao JARVIS.'))}`);
-    console.log(`  ${cinza('A distribuição é privada — o acesso é liberado por quem entregou o sistema.')}`);
-  }
-  console.log();
-  console.log(`  ${fraco('Fale com quem forneceu o JARVIS para receber um token válido.')}`);
-  console.log();
-}
-
-/**
- * O harness roda em POSIX, não em Windows nativo: os 104 hooks do
- * settings.json são invocados com `bash .../pyrun.sh` e 153 arquivos usam
- * caminho POSIX. Instalar no PowerShell criaria um sistema que copia mas
- * não funciona — pior que não instalar.
- */
-function avisarWindows() {
-  if (process.platform !== 'win32') return true;
-  console.log(`  ${vermelho(neg('O JARVIS precisa do WSL — não roda no Windows direto.'))}`);
-  console.log();
-  console.log(`  ${cinza('O sistema usa bash para executar seus 104 hooks. No PowerShell')}`);
-  console.log(`  ${cinza('ele até instalaria, mas não funcionaria.')}`);
-  console.log();
-  console.log(`  ${branco('Abra o Ubuntu (WSL) e rode lá o mesmo comando:')}`);
-  console.log();
-  console.log(`      ${fraco('wsl')}`);
-  console.log(`      ${fraco('npx @fefsbenson/jarvis install')}`);
-  console.log();
-  console.log(`  ${fraco('Não tem WSL? No PowerShell como administrador:')} ${cinza('wsl --install')}`);
-  console.log();
-  return false;
-}
-
-async function instalar(args) {
-  abertura();
-
-  if (!avisarWindows()) return 1;
-
-  const py = acharPython();
-  if (!py) {
-    console.log(`  ${vermelho(neg('Falta Python 3.10 ou superior.'))}`);
-    console.log();
-    console.log(`  ${cinza('O JARVIS roda em Python. O Node serve só para este baixador.')}`);
-    console.log();
-    console.log(`  ${branco('No Ubuntu/WSL:')}  ${fraco('sudo apt install python3 python3-venv')}`);
-    console.log(`  ${branco('No macOS:')}       ${fraco('brew install python@3.12')}`);
-    console.log();
-    return 1;
-  }
-
-  const destino = resolve(process.cwd(), args[0] || PASTA_PADRAO);
-  if (existsSync(destino) && readdirSync(destino).length) {
-    console.log(`  ${vermelho(neg('A pasta ' + destino + ' já existe e não está vazia.'))}`);
-    console.log(`  ${cinza('Escolha outro nome: ')}${fraco('npx @fefsbenson/jarvis install minha-pasta')}`);
-    console.log();
-    return 1;
-  }
-
-  console.log(`  ${branco('Vou baixar o JARVIS e instalar aqui.')}`);
-  console.log(`  ${fraco('Destino:')}  ${branco(destino)}`);
-  console.log(`  ${fraco('Python:')}   ${branco(py.cmd + ' ' + py.versao)}`);
-  console.log();
-  console.log(`  ${cinza('O JARVIS não é público: ele carrega conhecimento licenciado, então')}`);
-  console.log(`  ${cinza('mora num repositório privado. Preciso de um token para baixá-lo.')}`);
-  console.log();
-  console.log(`  ${fraco('Quem te entregou o sistema forneceu esse token junto.')}`);
-  console.log(`  ${fraco('Se você mesmo publicou e tem o GitHub CLI aqui, use:')}`);
-  console.log(`      ${cinza('JARVIS_TOKEN=$(gh auth token) npx @fefsbenson/jarvis install')}`);
-  console.log();
-  console.log(`  ${fraco('(o token não aparece na tela enquanto você digita)')}`);
-  console.log();
-
-  const token = process.env.JARVIS_TOKEN || await perguntar('Token:', true);
-  if (!token) {
-    console.log(`\n  ${fraco('Sem token, não há o que baixar. Cancelado.')}\n`);
-    return 130;
-  }
-
-  console.log();
-  try {
-    await baixar(token, destino);
-  } catch (e) {
-    if (e.message === 'TOKEN_INVALIDO' || e.message === 'SEM_ACESSO') {
-      erroDeAcesso(e.message);
-    } else {
-      console.log(`\n  ${vermelho(neg('Não consegui baixar.'))}`);
-      console.log(`  ${cinza(e.message)}`);
-      console.log(`\n  ${fraco('Verifique sua conexão e tente de novo.')}\n`);
-    }
-    return 1;
-  }
-
-  // entrega o comando ao instalador de verdade, que é Python
-  console.log();
-  const r = spawnSync(py.cmd, [...(py.args || []), join(destino, 'install.py'), ...args.slice(1)],
-                      { stdio: 'inherit', cwd: destino });
-  return r.status ?? 0;
-}
-
-function ajuda() {
-  abertura();
-  console.log(`  ${branco('npx @fefsbenson/jarvis install')}          ${fraco('baixa e instala em ./jarvis')}`);
-  console.log(`  ${branco('npx @fefsbenson/jarvis install PASTA')}    ${fraco('instala na pasta que você escolher')}`);
-  console.log();
-  console.log(`  ${fraco('Precisa de: Node 18+, Python 3.10+ e o token de acesso.')}`);
-  console.log(`  ${fraco('O token também pode vir da variável JARVIS_TOKEN.')}`);
-  console.log();
-}
-
-const [, , comando, ...resto] = process.argv;
-if (comando === 'install') {
-  instalar(resto).then(cod => process.exit(cod));
-} else {
-  ajuda();
-  process.exit(comando ? 1 : 0);
-}