moodline 0.1.0 → 0.2.0

package/README.md

@@ -16,12 +16,14 @@ A cor da barra é interpolada de forma contínua no espaço HSL, do verde (matiz
 
 ## Instalação
 
-Uma linha. Detecta as CLIs instaladas e configura cada uma:
+Uma linha. Abre um **wizard interativo** (logo animado, seletor de CLIs e features):
 
 ```bash
 npx moodline init
 ```
 
+A instalação é sempre **global (user-level)** — vale pra todos os projetos daquela CLI, nunca por repositório. Modo não-interativo (CI/scripts): `npx moodline init --all --yes`.
+
 Depois é só abrir uma sessão do Claude Code (ou do Copilot CLI). Pra testar a barra na hora, sem abrir sessão:
 
 ```bash
@@ -46,9 +48,9 @@ Resumo: **Claude Code e Copilot CLI funcionam de verdade hoje**, porque comparti
 
 ```
 npx moodline init
-   └─ copia o engine (lib/moodline-core.mjs) pra ~/.claude/moodline/ e ~/.copilot/moodline/
+   └─ copia o engine (moodline-core.mjs + puns.mjs) pra ~/.claude/moodline/ e ~/.copilot/moodline/
    └─ escreve um config.json com as features escolhidas
-   └─ aponta o settings.json da CLI pra: node ".../moodline-core.mjs" --adapter=claude --config=...
+   └─ aponta o settings.json (user-level) da CLI pra: node ".../moodline-core.mjs" --adapter=claude --config=...
 ```
 
 A cada atualização, a CLI executa o engine passando o JSON da sessão no stdin. O engine **normaliza** os campos (via um *adapter* por CLI), monta a barra e imprime no stdout. Zero dependências de runtime, então o render é rápido.
@@ -76,14 +78,28 @@ npx moodline init --all                    # força Claude Code E Copilot CLI
 ## Comandos
 
 ```
-moodline init        Configura a statusline nas CLIs detectadas
+moodline init        Wizard de instalação (interativo) — escopo global
+moodline enable      Liga a statusline      [--all | --claude | --copilot]
+moodline disable     Desliga (mantém config; re-enable instantâneo)
+moodline doctor      Mostra o que está instalado e ligado
+moodline uninstall   Remove a statusLine    [--purge apaga o engine]
 moodline render      Lê JSON no stdin e imprime a barra (teste)
-moodline doctor      Mostra o que está instalado e configurado
-moodline uninstall   Remove a statusLine das CLIs
 moodline watch       [experimental] Poller pro OpenCode → stdout
 moodline --help
 ```
 
+### Ligar e desligar
+
+Habilite ou desabilite por CLI, sem perder a configuração — ideal pra alternar dentro do Claude Code ou do Copilot:
+
+```bash
+moodline disable --claude     # desliga só no Claude Code
+moodline enable --copilot      # liga só no Copilot CLI
+moodline disable --all         # desliga em todas
+```
+
+`disable` só remove a chave `statusLine` do `settings.json`; o engine e o `config.json` ficam, então `enable` volta na hora.
+
 ## Configuração manual
 
 O `init` faz tudo, mas se preferir na mão — `~/.claude/settings.json`:
@@ -132,7 +148,16 @@ npm test        # smoke tests (sem framework, só node)
 echo '{"model":{"display_name":"Opus"},"context_window":{"used_percentage":50,"total_input_tokens":100000}}' | node bin/moodline.js render
 ```
 
-Arquitetura: `lib/moodline-core.mjs` é o engine auto-contido (render + adapters + git + puns). `bin/moodline.js` é o instalador/CLI. Adicionar uma CLI = escrever um adapter `fromX(json)` que normaliza pro mesmo formato de estado.
+Arquitetura (arquivos separados de propósito):
+
+- `lib/moodline-core.mjs` — engine (render + adapters + git). Importa só `./puns.mjs` e built-ins.
+- `lib/puns.mjs` — lista de trocadilhos PT-BR (o arquivo mais fácil de editar/crescer).
+- `lib/logo.mjs` — logo ASCII + render com gradiente + animação de onda.
+- `lib/ui.mjs` — prompts interativos (multiselect/select/confirm) e spinner, em `node:readline` puro.
+- `lib/install.mjs` — instalar/enable/disable/uninstall (sempre user-level; aceita `home` pra testes).
+- `bin/moodline.js` — dispatcher fino dos comandos.
+
+O `init` copia só os arquivos do engine (`moodline-core.mjs` + `puns.mjs`) pra dentro da CLI. Adicionar uma CLI = escrever um adapter `fromX(json)` em `moodline-core.mjs` que normaliza pro mesmo formato de estado.
 
 ### Release
 

package/bin/moodline.js

@@ -1,244 +1,200 @@
 #!/usr/bin/env node
-// moodline — instalador/configurador da statusline para CLIs de IA.
+// moodline — instalador/CLI. Escopo de instalacao SEMPRE global (user-level).
 //
-// Comandos:
-//   moodline init        configura a(s) CLI(s) detectada(s) (Claude Code, Copilot CLI)
-//   moodline render      le JSON no stdin e imprime a barra (pra testar)
-//   moodline doctor      mostra o que esta instalado/configurado
-//   moodline uninstall   remove a statusLine das CLIs
-//   moodline watch       [EXPERIMENTAL] poller pro OpenCode (HTTP) -> stdout
+//   moodline init               wizard interativo (logo animado + seletor de CLIs/features)
+//   moodline enable [--all]     liga a statusline (Claude Code / Copilot CLI)
+//   moodline disable [--all]    desliga (mantem config; re-enable instantaneo)
+//   moodline doctor             mostra estado
+//   moodline uninstall [--purge] remove a statusLine (e o engine com --purge)
+//   moodline render             le JSON no stdin e imprime a barra (teste)
+//   moodline watch              [experimental] poller pro OpenCode
 //   moodline --help|--version
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync } from 'node:fs';
-import { homedir } from 'node:os';
+import { readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { render, ADAPTERS, fromOpenCode, loadConfig, attachGit, DEFAULT_CFG } from '../lib/moodline-core.mjs';
+import { fileURLToPath } from 'node:url';
+import { render, ADAPTERS, attachGit, loadConfig, fromOpenCode } from '../lib/moodline-core.mjs';
+import * as ui from '../lib/ui.mjs';
+import { printLogo, smallLogo } from '../lib/logo.mjs';
+import * as install from '../lib/install.mjs';
 
+const C = ui.C;
 const HERE = dirname(fileURLToPath(import.meta.url));
-const CORE_SRC = join(HERE, '..', 'lib', 'moodline-core.mjs');
 const PKG = JSON.parse(readFileSync(join(HERE, '..', 'package.json'), 'utf8'));
 
-const C = { cyan: '\x1b[36m', green: '\x1b[32m', yellow: '\x1b[33m', dim: '\x1b[2m', red: '\x1b[31m', reset: '\x1b[0m', bold: '\x1b[1m' };
-const ok = (s) => console.log(`${C.green}✓${C.reset} ${s}`);
-const warn = (s) => console.log(`${C.yellow}!${C.reset} ${s}`);
-const info = (s) => console.log(`  ${C.dim}${s}${C.reset}`);
-
-// --------- arg parsing ---------
 function parseArgs(argv) {
   const o = { _: [] };
   for (const a of argv) {
-    if (a.startsWith('--')) {
-      const [k, v] = a.slice(2).split('=');
-      o[k] = v === undefined ? true : v;
-    } else o._.push(a);
+    if (a.startsWith('--')) { const [k, v] = a.slice(2).split('='); o[k] = v === undefined ? true : v; }
+    else o._.push(a);
   }
   return o;
 }
 
-// --------- alvos de CLI suportados (statusLine nativa por comando + JSON no stdin) ---------
-const TARGETS = {
-  claude: {
-    label: 'Claude Code',
-    dir: join(homedir(), '.claude'),
-    settings: join(homedir(), '.claude', 'settings.json'),
-    adapter: 'claude',
-    patch(s, command) {
-      s.statusLine = { type: 'command', command, padding: 0, refreshInterval: 5 };
-    },
-  },
-  copilot: {
-    label: 'GitHub Copilot CLI',
-    dir: join(homedir(), '.copilot'),
-    settings: join(homedir(), '.copilot', 'settings.json'),
-    adapter: 'copilot',
-    patch(s, command) {
-      s.statusLine = { type: 'command', command, padding: 1 };
-      // statusLine no Copilot e experimental: liga a feature flag
-      s.feature_flags = s.feature_flags || {};
-      s.feature_flags.enabled = Array.from(new Set([...(s.feature_flags.enabled || []), 'STATUS_LINE']));
-    },
-  },
-};
-
-function readJson(path) {
-  if (!existsSync(path)) return {};
-  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return {}; }
-}
-function fwd(p) { return p.replace(/\\/g, '/'); }
-
-function buildFeatures(opts) {
-  const f = structuredClone(DEFAULT_CFG.features);
-  if (typeof opts.features === 'string') {
-    const want = new Set(opts.features.split(',').map((x) => x.trim()).filter(Boolean));
-    for (const k of Object.keys(f)) f[k] = want.has(k);
+const ALL_FEATURES = ['git', 'cost', 'rate', 'puns'];
+
+async function cmdInit(opts) {
+  await printLogo({ animate: ui.isInteractive() && !opts['no-anim'] });
+  const home = opts.home;
+  const detected = install.detectInstalled(home);
+  const interactive = ui.isInteractive() && !opts.yes && !opts['no-input'];
+
+  let keys, features, layout;
+  if (interactive) {
+    const cliChoices = detected.map((d) => ({
+      name: d.present ? d.label : `${d.label} ${C.dim}(não detectado)${C.reset}`,
+      value: d.key, checked: d.present,
+    }));
+    keys = await ui.multiselect('Em quais CLIs instalar a statusline?', cliChoices);
+    if (!keys.length) { console.log(`${C.yellow}Nada selecionado. Saindo.${C.reset}`); return; }
+
+    features = await ui.multiselect('Quais extras ligar?', [
+      { name: 'Git — branch + estado (dirty/ahead/behind)', value: 'git', checked: true },
+      { name: 'Custo USD + tempo + linhas +/-', value: 'cost', checked: true },
+      { name: 'Rate limits 5h/7d (Claude Pro/Max)', value: 'rate', checked: true },
+      { name: 'Trocadilhos de dev 💬', value: 'puns', checked: true },
+    ]);
+    layout = await ui.select('Layout da barra?', [
+      { name: 'Uma linha (compacto)', value: 'single' },
+      { name: 'Duas linhas (mais informação)', value: 'multi' },
+    ]);
+  } else {
+    keys = ['claude', 'copilot'].filter((k) => opts[k] || opts.all);
+    if (!keys.length) keys = detected.filter((d) => d.present || d.key === 'claude').map((d) => d.key);
+    features = typeof opts.features === 'string'
+      ? opts.features.split(',').map((s) => s.trim()).filter(Boolean)
+      : ALL_FEATURES.filter((k) => !opts[`no-${k}`]);
+    layout = opts.multi ? 'multi' : 'single';
   }
-  for (const k of Object.keys(f)) {
-    if (opts[`no-${k}`]) f[k] = false;
+
+  console.log();
+  for (const key of keys) {
+    const t = install.targets(home)[key];
+    const sp = ui.spinner(`Configurando ${t.label}…`);
+    try { install.configure(key, { features, layout, home }); sp.stop(true, `${t.label} ${C.green}pronto${C.reset}`); }
+    catch (e) { sp.stop(false, `${t.label}: ${e.message}`); }
   }
-  return f;
+  postInstall(keys);
 }
 
-function configureTarget(key, opts) {
-  const t = TARGETS[key];
-  const root = join(t.dir, 'moodline');
-  const coreDest = join(root, 'moodline-core.mjs');
-  const cfgDest = join(root, 'config.json');
-
-  mkdirSync(root, { recursive: true });
-  copyFileSync(CORE_SRC, coreDest);
-
-  const cfg = { ...structuredClone(DEFAULT_CFG), features: buildFeatures(opts) };
-  if (opts.multi) cfg.layout = 'multi';
-  writeFileSync(cfgDest, JSON.stringify(cfg, null, 2) + '\n');
-
-  const command = `node "${fwd(coreDest)}" --adapter=${t.adapter} --config="${fwd(cfgDest)}"`;
-  const settings = readJson(t.settings);
-  t.patch(settings, command);
-  mkdirSync(dirname(t.settings), { recursive: true });
-  writeFileSync(t.settings, JSON.stringify(settings, null, 2) + '\n');
-
-  ok(`${t.label} configurado`);
-  info(`engine: ${fwd(coreDest)}`);
-  info(`config: ${fwd(cfgDest)}`);
-  info(`settings: ${fwd(t.settings)}`);
-  return { coreDest, cfgDest, command };
+function postInstall(keys) {
+  console.log(`\n${C.green}✓ Instalado${C.reset} (global, user-level). Abra uma sessão da CLI pra ver a barra.`);
+  if (keys.includes('copilot')) {
+    console.log(`${C.yellow}!${C.reset} Copilot CLI: statusLine é experimental — se não aparecer, rode ${C.cyan}/experimental${C.reset} ou reinicie.`);
+  }
+  console.log(`\n${C.dim}Ligar/desligar quando quiser:${C.reset}`);
+  console.log(`  ${C.cyan}moodline disable${C.reset}   ${C.dim}# desliga (mantém config)${C.reset}`);
+  console.log(`  ${C.cyan}moodline enable${C.reset}    ${C.dim}# liga de novo${C.reset}`);
+  console.log(`\n${C.dim}Teste agora:${C.reset} ${C.cyan}moodline render${C.reset}`);
 }
 
-function cmdInit(opts) {
-  console.log(`${C.bold}\u{1F33F}  moodline init${C.reset}\n`);
-
-  const explicit = ['claude', 'copilot'].filter((k) => opts[k] || opts.all);
-  let keys;
-  if (explicit.length) {
-    keys = explicit;
-  } else {
-    // default: Claude Code sempre; Copilot se detectado
-    keys = ['claude'];
-    if (existsSync(TARGETS.copilot.dir)) keys.push('copilot');
+function resolveKeys(opts, needConfigured) {
+  let keys = ['claude', 'copilot'].filter((k) => opts[k] || opts.all);
+  if (!keys.length) {
+    const det = install.detectInstalled(opts.home);
+    keys = det.filter((d) => (needConfigured ? d.engine || d.wired : d.present)).map((d) => d.key);
   }
+  return keys;
+}
 
-  for (const k of keys) configureTarget(k, opts);
-
-  console.log();
-  if (keys.includes('copilot')) {
-    warn('Copilot CLI: statusLine e experimental — reinicie o copilot ou rode `/experimental` se a barra nao aparecer.');
+function cmdToggle(opts, enabled) {
+  const keys = resolveKeys(opts, true);
+  if (!keys.length) { console.log(`${C.yellow}Nada configurado.${C.reset} Rode ${C.cyan}moodline init${C.reset}.`); return; }
+  for (const key of keys) {
+    const t = install.targets(opts.home)[key];
+    try { install.setEnabled(key, enabled, { home: opts.home }); console.log(`${C.green}✓${C.reset} ${t.label}: statusline ${enabled ? 'habilitada' : 'desabilitada'}`); }
+    catch (e) { console.log(`${C.yellow}!${C.reset} ${e.message}`); }
   }
-  console.log(`\n${C.bold}Outras CLIs:${C.reset}`);
-  info('Gemini CLI  — sem statusLine por comando; so footer fixo (toggles) ou extensao HUD 3rd-party. [experimental]');
-  info('OpenCode    — sem statusLine na TUI; use `moodline watch` num painel tmux/zellij. [experimental]');
-  info('Junie CLI   — nao suporta statusline (hook SessionStart descarta o output). Sem suporte.');
-  console.log(`\n${C.green}Pronto.${C.reset} Abra uma sessao da CLI pra ver a barra. Teste agora: ${C.cyan}moodline render${C.reset}`);
 }
 
 function cmdUninstall(opts) {
-  const keys = ['claude', 'copilot'].filter((k) => opts[k] || opts.all);
-  const list = keys.length ? keys : ['claude', 'copilot'];
-  for (const k of list) {
-    const t = TARGETS[k];
-    if (!existsSync(t.settings)) continue;
-    const s = readJson(t.settings);
-    if (s.statusLine) { delete s.statusLine; writeFileSync(t.settings, JSON.stringify(s, null, 2) + '\n'); ok(`${t.label}: statusLine removida`); }
-    else info(`${t.label}: nada pra remover`);
+  const keys = resolveKeys(opts, true);
+  if (!keys.length) { console.log('Nada pra remover.'); return; }
+  for (const key of keys) {
+    const t = install.targets(opts.home)[key];
+    const r = install.uninstall(key, { home: opts.home, purge: opts.purge });
+    console.log(`${C.green}✓${C.reset} ${t.label}: ${r.had ? 'statusLine removida' : 'nada na statusLine'}${opts.purge ? ' + engine apagado' : ''}`);
   }
 }
 
-function cmdDoctor() {
-  console.log(`${C.bold}moodline doctor${C.reset}  v${PKG.version}\n`);
-  info(`home: ${fwd(homedir())}`);
-  for (const [k, t] of Object.entries(TARGETS)) {
-    const has = existsSync(t.dir);
-    const s = readJson(t.settings);
-    const wired = !!s.statusLine && /moodline-core\.mjs/.test(s.statusLine.command || '');
-    console.log(`\n${C.bold}${t.label}${C.reset} (${k})`);
-    info(`dir existe: ${has ? 'sim' : 'nao'}`);
-    info(`statusLine moodline: ${wired ? C.green + 'ativa' + C.reset : 'nao'}`);
-    if (s.statusLine?.command) info(`command: ${s.statusLine.command}`);
+function cmdDoctor(opts) {
+  console.log(`${smallLogo()} ${C.dim}v${PKG.version}${C.reset}\n`);
+  for (const d of install.detectInstalled(opts.home)) {
+    const state = d.wired ? `${C.green}ativa${C.reset}` : d.engine ? `${C.yellow}configurada, desligada${C.reset}` : `${C.dim}não instalada${C.reset}`;
+    console.log(`${C.bold}${d.label}${C.reset}`);
+    console.log(`  dir detectado: ${d.present ? 'sim' : 'não'}   statusline: ${state}`);
   }
 }
 
 function cmdRender(opts) {
-  // delega pro engine: le stdin, imprime barra. Reusa as mesmas flags.
-  const adapterName = (opts.adapter || 'claude').toLowerCase();
-  const adapter = ADAPTERS[adapterName] || ADAPTERS.claude;
+  const adapter = ADAPTERS[(opts.adapter || 'claude').toLowerCase()] || ADAPTERS.claude;
   const cfg = loadConfig(opts.config);
-  for (const k of ['git', 'cost', 'rate', 'puns']) if (opts[`no-${k}`]) cfg.features[k] = false;
+  for (const k of ALL_FEATURES) if (opts[`no-${k}`]) cfg.features[k] = false;
   if (opts.multi) cfg.layout = 'multi';
   if (opts.width) cfg.width = parseInt(opts.width, 10) || undefined;
 
   let raw = '';
   try { raw = readFileSync(0, 'utf8'); } catch {}
   if (!raw.trim()) {
-    // sem stdin: demo
+    console.log(`${C.dim}sem stdin — demo:${C.reset}`);
     raw = JSON.stringify({ model: { display_name: 'Opus' }, effort: { level: 'high' }, context_window: { used_percentage: 42, total_input_tokens: 84000 }, cost: { total_cost_usd: 0.12, total_duration_ms: 320000, total_lines_added: 120, total_lines_removed: 30 } });
-    warn('sem stdin — mostrando demo:');
   }
-  let j = {};
-  try { j = JSON.parse(raw); } catch {}
-  const state = attachGit(adapter(j), cfg.features.git);
-  console.log(render(state, cfg));
+  let j = {}; try { j = JSON.parse(raw); } catch {}
+  console.log(render(attachGit(adapter(j), cfg.features.git), cfg));
 }
 
 async function cmdWatch(opts) {
-  // EXPERIMENTAL: poller pro OpenCode. Endpoint pode variar por versao.
-  const port = opts.port || 4096;
-  const url = opts.url || `http://127.0.0.1:${port}/session`;
+  const url = opts.url || `http://127.0.0.1:${opts.port || 4096}/session`;
   const cfg = loadConfig(opts.config);
-  warn(`[experimental] OpenCode watch: GET ${url} a cada ${opts.interval || 2}s`);
   const interval = (parseInt(opts.interval, 10) || 2) * 1000;
+  console.log(`${C.yellow}[experimental]${C.reset} OpenCode watch: GET ${url}`);
   const tick = async () => {
     try {
       const r = await fetch(url);
       const j = await r.json();
-      const state = fromOpenCode(Array.isArray(j) ? j[0] : j);
-      process.stdout.write('\r\x1b[K' + render(state, cfg));
-    } catch (e) {
-      process.stdout.write('\r\x1b[K' + C.dim + 'moodline: aguardando OpenCode em ' + url + C.reset);
-    }
+      process.stdout.write('\r\x1b[K' + render(fromOpenCode(Array.isArray(j) ? j[0] : j), cfg));
+    } catch { process.stdout.write(`\r\x1b[K${C.dim}aguardando OpenCode em ${url}${C.reset}`); }
   };
   await tick();
   setInterval(tick, interval);
 }
 
 function cmdHelp() {
-  console.log(`${C.bold}\u{1F33F}  moodline${C.reset} v${PKG.version} — statusline divertida pra CLIs de IA
+  console.log(`${smallLogo()} ${C.dim}v${PKG.version}${C.reset} — statusline divertida pra CLIs de IA
 
-${C.bold}Uso:${C.reset}
-  npx moodline <comando> [opcoes]
+${C.bold}Uso:${C.reset} npx moodline <comando> [opções]
 
 ${C.bold}Comandos:${C.reset}
-  init           Configura a statusline nas CLIs detectadas (Claude Code, Copilot CLI)
-  render         Le JSON no stdin e imprime a barra (pra testar)
-  doctor         Mostra o que esta instalado e configurado
-  uninstall      Remove a statusLine das CLIs
-  watch          [experimental] Poller pro OpenCode -> stdout (use num painel tmux)
-
-${C.bold}Opcoes do init:${C.reset}
-  --all                  Configura Claude Code E Copilot CLI
-  --claude / --copilot   So a CLI escolhida
-  --features=git,cost    Liga so essas features (git,cost,rate,puns)
-  --no-puns --no-rate    Desliga uma feature especifica
-  --multi                Layout em 2 linhas
-
-${C.bold}Exemplos:${C.reset}
-  npx moodline init
-  npx moodline init --all --no-rate
+  ${C.cyan}init${C.reset}        Wizard de instalação (interativo) — escopo global
+  ${C.cyan}enable${C.reset}      Liga a statusline   ${C.dim}[--all | --claude | --copilot]${C.reset}
+  ${C.cyan}disable${C.reset}     Desliga (mantém config; re-enable instantâneo)
+  ${C.cyan}doctor${C.reset}      Mostra o que está instalado e ligado
+  ${C.cyan}uninstall${C.reset}   Remove a statusLine ${C.dim}[--purge apaga o engine]${C.reset}
+  ${C.cyan}render${C.reset}      Lê JSON no stdin e imprime a barra (teste)
+  ${C.cyan}watch${C.reset}       [experimental] Poller pro OpenCode → stdout
+
+${C.bold}init não-interativo:${C.reset}
+  --all | --claude | --copilot     escolhe a(s) CLI(s)
+  --features=git,cost,rate,puns    liga só essas
+  --no-puns --no-rate              desliga uma feature
+  --multi                          layout em 2 linhas
+  --yes                            pula o wizard (usa defaults/flags)
+
+${C.bold}Exemplo:${C.reset}
   echo '{"model":{"display_name":"Opus"},"context_window":{"used_percentage":92,"total_input_tokens":184000}}' | npx moodline render
 `);
 }
 
-// --------- dispatch ---------
-const argv = process.argv.slice(2);
-const opts = parseArgs(argv);
-const cmd = opts._[0] || (opts.version ? 'version' : opts.help ? 'help' : 'help');
-
+const opts = parseArgs(process.argv.slice(2));
+const cmd = opts._[0] || (opts.version ? 'version' : 'help');
 switch (cmd) {
-  case 'init': cmdInit(opts); break;
+  case 'init': await cmdInit(opts); break;
+  case 'enable': cmdToggle(opts, true); break;
+  case 'disable': cmdToggle(opts, false); break;
   case 'uninstall': cmdUninstall(opts); break;
-  case 'doctor': cmdDoctor(); break;
+  case 'doctor': cmdDoctor(opts); break;
   case 'render': cmdRender(opts); break;
   case 'watch': await cmdWatch(opts); break;
   case 'version': console.log(PKG.version); break;
-  case 'help':
-  default: cmdHelp(); break;
+  default: cmdHelp();
 }

package/lib/install.mjs

@@ -0,0 +1,99 @@
+// install.mjs — logica de instalacao/toggle. SOMENTE escopo global (user-level):
+// ~/.claude/settings.json e ~/.copilot/settings.json. Nunca escreve em .claude de projeto.
+// Todas as funcoes aceitam `home` opcional (default os.homedir()) pra permitir testes em sandbox.
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync, rmSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DEFAULT_CFG } from './moodline-core.mjs';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+// Arquivos do engine copiados juntos pro dir da CLI (core importa ./puns.mjs em runtime).
+export const ENGINE_FILES = ['moodline-core.mjs', 'puns.mjs'];
+
+export function targets(home = homedir()) {
+  const mk = (key, label, sub, adapter) => {
+    const dir = join(home, sub);
+    const engineDir = join(dir, 'moodline');
+    return {
+      key, label, adapter, dir, engineDir,
+      settings: join(dir, 'settings.json'),
+      core: join(engineDir, 'moodline-core.mjs'),
+      config: join(engineDir, 'config.json'),
+    };
+  };
+  return {
+    claude: mk('claude', 'Claude Code', '.claude', 'claude'),
+    copilot: mk('copilot', 'GitHub Copilot CLI', '.copilot', 'copilot'),
+  };
+}
+
+const fwd = (p) => p.replace(/\\/g, '/');
+function readJson(p) { if (!existsSync(p)) return {}; try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return {}; } }
+function writeJson(p, o) { mkdirSync(dirname(p), { recursive: true }); writeFileSync(p, JSON.stringify(o, null, 2) + '\n'); }
+
+function buildFeatures(list) {
+  const f = structuredClone(DEFAULT_CFG.features);
+  if (Array.isArray(list)) for (const k of Object.keys(f)) f[k] = list.includes(k);
+  return f;
+}
+function commandFor(t) {
+  return `node "${fwd(t.core)}" --adapter=${t.adapter} --config="${fwd(t.config)}"`;
+}
+function setStatusLine(s, t) {
+  const command = commandFor(t);
+  if (t.adapter === 'copilot') {
+    s.statusLine = { type: 'command', command, padding: 1 };
+    // statusLine no Copilot e experimental: garante a feature flag
+    s.feature_flags = s.feature_flags || {};
+    s.feature_flags.enabled = Array.from(new Set([...(s.feature_flags.enabled || []), 'STATUS_LINE']));
+  } else {
+    s.statusLine = { type: 'command', command, padding: 0, refreshInterval: 5 };
+  }
+}
+
+// Copia o engine, escreve o config e liga a statusLine.
+export function configure(key, { features, layout, home } = {}) {
+  const t = targets(home)[key];
+  mkdirSync(t.engineDir, { recursive: true });
+  for (const f of ENGINE_FILES) copyFileSync(join(HERE, f), join(t.engineDir, f));
+  const cfg = { ...structuredClone(DEFAULT_CFG), features: buildFeatures(features) };
+  if (layout) cfg.layout = layout;
+  writeJson(t.config, cfg);
+  const s = readJson(t.settings);
+  setStatusLine(s, t);
+  writeJson(t.settings, s);
+  return t;
+}
+
+// Habilita/desabilita sem destruir config — re-enable e instantaneo.
+export function setEnabled(key, enabled, { home } = {}) {
+  const t = targets(home)[key];
+  const s = readJson(t.settings);
+  if (enabled) {
+    if (!existsSync(t.core)) throw new Error(`${t.label}: não configurado — rode 'moodline init' primeiro`);
+    setStatusLine(s, t);
+  } else {
+    delete s.statusLine; // mantem engine + config.json
+  }
+  writeJson(t.settings, s);
+  return t;
+}
+
+export function uninstall(key, { home, purge } = {}) {
+  const t = targets(home)[key];
+  const s = readJson(t.settings);
+  const had = !!s.statusLine;
+  delete s.statusLine;
+  writeJson(t.settings, s);
+  if (purge && existsSync(t.engineDir)) rmSync(t.engineDir, { recursive: true, force: true });
+  return { ...t, had };
+}
+
+export function detectInstalled(home) {
+  return Object.values(targets(home)).map((t) => {
+    const s = readJson(t.settings);
+    const wired = !!s.statusLine && /moodline-core\.mjs/.test(s.statusLine?.command || '');
+    return { ...t, present: existsSync(t.dir), engine: existsSync(t.core), wired };
+  });
+}

package/lib/logo.mjs

@@ -0,0 +1,82 @@
+// logo.mjs — logo ASCII do moodline + render com gradiente + animacao de onda.
+// Usado so no instalador (nao entra no caminho da barra). Auto-contido.
+
+const ESC = '\x1b';
+const RESET = `${ESC}[0m`;
+
+// HSL -> RGB (h em graus 0..360, s/l em 0..1)
+function hsl(h, s, l) {
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+  const m = l - c / 2;
+  let r = 0, g = 0, b = 0;
+  if (h < 60) [r, g, b] = [c, x, 0];
+  else if (h < 120) [r, g, b] = [x, c, 0];
+  else if (h < 180) [r, g, b] = [0, c, x];
+  else if (h < 240) [r, g, b] = [0, x, c];
+  else if (h < 300) [r, g, b] = [x, 0, c];
+  else [r, g, b] = [c, 0, x];
+  return [Math.round((r + m) * 255), Math.round((g + m) * 255), Math.round((b + m) * 255)];
+}
+const tc = (r, g, b) => `${ESC}[38;2;${r};${g};${b}m`;
+
+// Glyphs (fonte ANSI Shadow). Cada letra: 6 linhas de largura igual.
+const G = {
+  M: ['███╗   ███╗', '████╗ ████║', '██╔████╔██║', '██║╚██╔╝██║', '██║ ╚═╝ ██║', '╚═╝     ╚═╝'],
+  O: [' ██████╗ ', '██╔═══██╗', '██║   ██║', '██║   ██║', '╚██████╔╝', ' ╚═════╝ '],
+  D: ['██████╗ ', '██╔══██╗', '██║  ██║', '██║  ██║', '██████╔╝', '╚═════╝ '],
+  L: ['██╗     ', '██║     ', '██║     ', '██║     ', '███████╗', '╚══════╝'],
+  I: ['██╗ ', '██║ ', '██║ ', '██║ ', '██║ ', '╚═╝ '],
+  N: ['███╗   ██╗', '████╗  ██║', '██╔██╗ ██║', '██║╚██╗██║', '██║ ╚████║', '╚═╝  ╚═══╝'],
+  E: ['███████╗', '██╔════╝', '█████╗  ', '██╔══╝  ', '███████╗', '╚══════╝'],
+};
+const WORD = 'MOODLINE';
+export const LOGO_LINES = Array.from({ length: 6 }, (_, r) => [...WORD].map((ch) => G[ch][r]).join(' '));
+const MAXW = Math.max(...LOGO_LINES.map((l) => [...l].length));
+export const TAGLINE = '🌿 statusline divertida e informativa pra CLIs de IA';
+
+// Colore cada coluna por matiz, com deslocamento de fase (onda verde->vermelho).
+export function renderLogo(phase = 0) {
+  return LOGO_LINES.map((line) => {
+    const chars = [...line];
+    let out = '';
+    for (let x = 0; x < chars.length; x++) {
+      const ch = chars[x];
+      if (ch === ' ') { out += ' '; continue; }
+      const hue = (((x / MAXW) * 120 + phase) % 120 + 120) % 120; // 0..120 (verde->vermelho)
+      const [r, g, b] = hsl(hue, 1, 0.55);
+      out += tc(r, g, b) + ch;
+    }
+    return out + RESET;
+  }).join('\n');
+}
+
+// Versao compacta pra terminais estreitos
+export function smallLogo() {
+  const [r, g, b] = hsl(90, 1, 0.55);
+  return `${tc(r, g, b)}🌿 moodline${RESET}`;
+}
+
+const sleep = (ms) => new Promise((res) => setTimeout(res, ms));
+
+// Imprime o logo. Anima (onda) se for TTY e couber; senao imprime estatico.
+export async function printLogo({ animate = true, frames = 16, delay = 45 } = {}) {
+  const out = process.stdout;
+  const cols = out.columns || parseInt(process.env.COLUMNS || '80', 10);
+  if (cols < MAXW) { out.write('\n' + smallLogo() + '\n' + '\x1b[2m' + TAGLINE + '\x1b[0m\n\n'); return; }
+
+  if (!animate || !out.isTTY) {
+    out.write('\n' + renderLogo(0) + '\n\x1b[2m  ' + TAGLINE + '\x1b[0m\n\n');
+    return;
+  }
+  out.write('\x1b[?25l'); // esconde cursor
+  out.write('\n');
+  for (let i = 0; i < frames; i++) {
+    if (i > 0) out.write(`\x1b[${LOGO_LINES.length}A`); // sobe N linhas
+    const block = renderLogo(i * 9).split('\n').map((l) => '\x1b[0G\x1b[K' + l).join('\n');
+    out.write(block + '\n');
+    await sleep(delay);
+  }
+  out.write('\x1b[2m  ' + TAGLINE + '\x1b[0m\n\n');
+  out.write('\x1b[?25h'); // mostra cursor
+}

package/lib/moodline-core.mjs

@@ -12,6 +12,7 @@
 import { readFileSync, existsSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { pathToFileURL } from 'node:url';
+import { PUNS } from './puns.mjs';
 
 // ---------------- ANSI ----------------
 const ESC = '\x1b';
@@ -70,30 +71,13 @@ function mood(p) {
   return '\u{1F60E}';              // de boa
 }
 
-// ---------------- trocadilhos de dev (PT-BR) ----------------
-const PUNS = [
-  'git push? mais pra git shove',
-  'funciona na minha maquina ¯\\_(ツ)_/¯',
-  'bug? feature nao documentada',
-  'merge sem conflito e merge mentiroso',
-  'CSS: Continua Sem Solucao',
-  '404: piada nao encontrada',
-  'deploy na sexta, coragem de sobra',
-  'cache: o problema e a solucao',
-  'recursao: ver "recursao"',
-  'prod de pe? reza o commit',
-  'TODO: escrever um TODO melhor',
-  'semicolon ; o heroi anonimo',
-  'rebase com fe, push com medo',
-  'git blame aponta pra mim de novo',
-  'tabs vs spaces: a guerra eterna',
-  'commit -m "ajustes"',
-  'tava funcionando ontem',
-  'dark mode pra esconder os bugs',
-];
-function pickPun(rotateMs) {
-  const idx = Math.floor(Date.now() / Math.max(1000, rotateMs)) % PUNS.length;
-  return PUNS[idx];
+// ---------------- trocadilhos de dev (lista em ./puns.mjs) ----------------
+// Rotaciona devagar (por janela de tempo) pra mudar sem piscar. `extra` permite
+// adicionar trocadilhos via config.json sem editar o engine.
+function pickPun(rotateMs, extra = []) {
+  const pool = Array.isArray(extra) && extra.length ? PUNS.concat(extra) : PUNS;
+  const idx = Math.floor(Date.now() / Math.max(1000, rotateMs)) % pool.length;
+  return pool[idx];
 }
 
 // ---------------- formatadores ----------------
@@ -196,7 +180,7 @@ export function render(state, cfg = DEFAULT_CFG) {
   }
 
   if (f.puns) {
-    opt.push({ txt: `${DIM}\u{1F4AC} ${pickPun(cfg.punRotateMs ?? 30000)}${RESET}`, prio: 4 });
+    opt.push({ txt: `${DIM}\u{1F4AC} ${pickPun(cfg.punRotateMs ?? 30000, cfg.extraPuns)}${RESET}`, prio: 4 });
   }
 
   const sep = ` ${DIM}·${RESET} `;

package/lib/puns.mjs

@@ -0,0 +1,50 @@
+// puns.mjs — trocadilhos/piadas de dev (PT-BR). Arquivo separado de proposito: e o
+// mais fácil de editar e o que mais cresce. Copiado junto do engine no `moodline init`.
+// Regras: curto (a barra trunca), PT-BR, sem quebrar em terminal estreito.
+export const PUNS = [
+  'git push? mais pra git shove',
+  'funciona na minha máquina ¯\\_(ツ)_/¯',
+  'bug? feature não documentada',
+  'merge sem conflito é merge mentiroso',
+  'CSS: Continua Sem Solução',
+  '404: piada não encontrada',
+  'deploy na sexta, coragem de sobra',
+  'cache: o problema e a solução',
+  'recursão: ver "recursão"',
+  'prod de pé? reza o commit',
+  'TODO: escrever um TODO melhor',
+  'semicolon ; o herói anônimo',
+  'rebase com fé, push com medo',
+  'git blame aponta pra mim de novo',
+  'tabs vs spaces: a guerra eterna',
+  'commit -m "ajustes"',
+  'tava funcionando ontem',
+  'dark mode pra esconder os bugs',
+  'café.exe parou de responder',
+  'compilou? então tá pronto',
+  'é só um if, o que pode dar errado?',
+  'prod é o melhor ambiente de testes',
+  'documentação? o código é a doc',
+  'Stack Overflow, meu copiloto de verdade',
+  'um teste a menos, um deploy a mais',
+  'null: o erro de um bilhão de dólares',
+  'regex: agora você tem 2 problemas',
+  'quem precisa de QA tem usuário',
+  'funcionou de primeira? desconfie',
+  'legacy: código com medo de mexer',
+  'hotfix vira feature permanente',
+  '"depois eu refatoro" — ninguém, nunca',
+  'force push, força e fé',
+  'erro 500: culpa do estagiário',
+  'clean code? clean café primeiro',
+  'deadline: substantivo coletivo de pânico',
+  'rollback é o novo deploy',
+  'off by one, off by sanidade',
+  'YAML: os espaços te odeiam',
+  'docker: roda na minha e na sua máquina',
+  'o bug é o teste passando errado',
+  'sexta 17h: não mexe que tá funcionando',
+  'pair programming: dois pra culpar',
+  'microserviço: monólito distribuído',
+  'temporário é o que mais dura',
+];

package/lib/ui.mjs

@@ -0,0 +1,111 @@
+// ui.mjs — helpers de terminal pro instalador interativo. Zero dependencias (node:readline).
+// Prompts (multiselect/select/confirm) usam raw mode; sempre restauram o terminal no fim.
+import readline from 'node:readline';
+
+const out = process.stdout;
+export const C = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  cyan: '\x1b[36m', green: '\x1b[32m', yellow: '\x1b[33m', red: '\x1b[31m', magenta: '\x1b[35m', gray: '\x1b[90m',
+};
+export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export const hideCursor = () => out.isTTY && out.write('\x1b[?25l');
+export const showCursor = () => out.isTTY && out.write('\x1b[?25h');
+
+export const isInteractive = () => !!process.stdin.isTTY && !!process.stdout.isTTY;
+
+function withKeypress(onKey, draw) {
+  return new Promise((resolve) => {
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    hideCursor();
+    const cleanup = () => {
+      process.stdin.removeListener('keypress', handler);
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+      process.stdin.pause();
+      showCursor();
+    };
+    const handler = (str, key) => {
+      if (!key) return;
+      if (key.ctrl && key.name === 'c') { cleanup(); out.write('\n'); process.exit(130); }
+      onKey(key, (result) => { cleanup(); resolve(result); }, draw);
+    };
+    process.stdin.on('keypress', handler);
+    draw(true);
+  });
+}
+
+// choices: [{ name, value, checked? }]  -> retorna array de values marcados
+export function multiselect(message, choices) {
+  let idx = 0;
+  const sel = choices.map((c) => !!c.checked);
+  const render = (first) => {
+    const lines = choices.length + 1;
+    if (!first) out.write(`\x1b[${lines}A`);
+    out.write(`\x1b[0G\x1b[K${C.bold}? ${message}${C.reset} ${C.dim}(↑↓ · espaço marca · a=todos · enter)${C.reset}\n`);
+    choices.forEach((c, i) => {
+      const ptr = i === idx ? `${C.cyan}❯${C.reset}` : ' ';
+      const box = sel[i] ? `${C.green}◉${C.reset}` : `${C.dim}◯${C.reset}`;
+      const label = i === idx ? `${C.cyan}${c.name}${C.reset}` : c.name;
+      out.write(`\x1b[0G\x1b[K ${ptr} ${box} ${label}\n`);
+    });
+  };
+  return withKeypress((key, done) => {
+    if (key.name === 'up') idx = (idx - 1 + choices.length) % choices.length;
+    else if (key.name === 'down') idx = (idx + 1) % choices.length;
+    else if (key.name === 'space') sel[idx] = !sel[idx];
+    else if (key.name === 'a') { const all = sel.every(Boolean); sel.fill(!all); }
+    else if (key.name === 'return') return done(choices.filter((_, i) => sel[i]).map((c) => c.value));
+    render(false);
+  }, render);
+}
+
+// choices: [{ name, value }] -> retorna 1 value
+export function select(message, choices, initial = 0) {
+  let idx = initial;
+  const render = (first) => {
+    const lines = choices.length + 1;
+    if (!first) out.write(`\x1b[${lines}A`);
+    out.write(`\x1b[0G\x1b[K${C.bold}? ${message}${C.reset} ${C.dim}(↑↓ · enter)${C.reset}\n`);
+    choices.forEach((c, i) => {
+      const ptr = i === idx ? `${C.cyan}❯${C.reset}` : ' ';
+      const label = i === idx ? `${C.cyan}${c.name}${C.reset}` : c.name;
+      out.write(`\x1b[0G\x1b[K ${ptr} ${label}\n`);
+    });
+  };
+  return withKeypress((key, done) => {
+    if (key.name === 'up') idx = (idx - 1 + choices.length) % choices.length;
+    else if (key.name === 'down') idx = (idx + 1) % choices.length;
+    else if (key.name === 'return') return done(choices[idx].value);
+    render(false);
+  }, render);
+}
+
+export function confirm(message, def = true) {
+  const render = (first) => {
+    if (!first) out.write('\x1b[1A');
+    out.write(`\x1b[0G\x1b[K${C.bold}? ${message}${C.reset} ${C.dim}(${def ? 'Y/n' : 'y/N'})${C.reset}\n`);
+  };
+  return withKeypress((key, done) => {
+    if (key.name === 'y') return done(true);
+    if (key.name === 'n') return done(false);
+    if (key.name === 'return') return done(def);
+    render(false);
+  }, render);
+}
+
+// spinner com checkmark no fim
+export function spinner(text) {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  if (!out.isTTY) { out.write(`  ${C.dim}…${C.reset} ${text}\n`); return { stop() {} }; }
+  hideCursor();
+  let i = 0;
+  const t = setInterval(() => out.write(`\x1b[0G\x1b[K${C.cyan}${frames[i++ % frames.length]}${C.reset} ${text}`), 80);
+  return {
+    stop(ok = true, msg) {
+      clearInterval(t);
+      out.write(`\x1b[0G\x1b[K${ok ? C.green + '✓' : C.red + '✗'}${C.reset} ${msg || text}\n`);
+      showCursor();
+    },
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moodline",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Statusline divertida e informativa para CLIs de IA (Claude Code, GitHub Copilot CLI e mais): barra de contexto em gradiente, emoji-humor, git, custo e trocadilhos de dev.",
   "type": "module",
   "bin": {