moodline 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alison Amorim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,150 @@
+# 🌿 moodline
+
+> Statusline divertida e informativa para CLIs de IA. Barra de contexto em gradiente, emoji que reage à ocupação, git, custo da sessão e trocadilhos de dev — instalável com um comando.
+
+Feita pra quem vive no terminal com agentes de código. Mostra de relance **quanto contexto ainda sobra** (antes de tomar um `/compact` na cara), o **modelo e o effort**, e ainda solta um **trocadilho** pra alegrar o `git push`.
+
+```
+Opus high [█▒▒░░░░░░░░░░░░░░░░░░]  😎   5%  10k · 🌿 main · 💬 commit -m "ajustes"
+Opus high [█████▒▒░░░░░░░░░░░░░░]  🙂  25%  50k · 🌿 main* · 💸 $0.08 ⏱ 4m
+Opus high [██████████▒▒░░░░░░░░░]  😅  50% 100k · 🌿 feat/bar ↑2 · 💸 $0.21 ⏱ 12m +120/-30
+Opus high [███████████████▒▒░░░░]  🥵  75% 150k · ⏳ 5h 42% 7d 13%
+Opus high [██████████████████▒▒░]  💀  92% 184k · 🌿 main · 404: piada nao encontrada
+```
+
+A cor da barra é interpolada de forma contínua no espaço HSL, do verde (matiz 120°) ao vermelho (0°). O emoji vai de 😎 (tranquilo) a 💀 (hora de dar `/clear`). Quando o terminal é estreito, os segmentos extras somem da direita pra esquerda — o essencial (modelo, barra, %, tokens) nunca cai.
+
+## Instalação
+
+Uma linha. Detecta as CLIs instaladas e configura cada uma:
+
+```bash
+npx moodline init
+```
+
+Depois é só abrir uma sessão do Claude Code (ou do Copilot CLI). Pra testar a barra na hora, sem abrir sessão:
+
+```bash
+echo '{"model":{"display_name":"Opus"},"effort":{"level":"high"},"context_window":{"used_percentage":92,"total_input_tokens":184000}}' | npx moodline render
+```
+
+## Compatibilidade com as CLIs
+
+A barra precisa que a CLI rode um **comando** e mande os dados via **JSON no stdin**. Nem toda CLI de IA suporta isso. Situação atual:
+
+| CLI | Statusline custom? | moodline |
+|-----|:---:|-----|
+| **Claude Code** | ✅ Nativo | **Suportado.** Configurado pelo `init`. |
+| **GitHub Copilot CLI** | ⚗️ Experimental | **Suportado.** O `init` liga a feature flag `STATUS_LINE`. |
+| **Gemini CLI** | ❌ Só footer fixo | Experimental — só via extensão HUD de terceiros (hooks + scroll-region). Não é statusline por comando. |
+| **OpenCode** | ❌ TUI fixa | Experimental — `moodline watch` lê a API HTTP e renderiza num painel tmux/zellij (fora da TUI). |
+| **Junie (JetBrains)** | ❌ Não suporta | Sem suporte. O único hook (`SessionStart`) **descarta o output**, então não dá pra renderizar uma barra. |
+
+Resumo: **Claude Code e Copilot CLI funcionam de verdade hoje**, porque compartilham o mesmo modelo (comando + JSON no stdin) com schemas quase idênticos — um único engine serve os dois. Os outros três dependem de mecanismos diferentes; veja [Outras CLIs](#outras-clis).
+
+## Como funciona
+
+```
+npx moodline init
+   └─ copia o engine (lib/moodline-core.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=...
+```
+
+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.
+
+## Features
+
+A base sempre aparece: **modelo · effort · barra de contexto em gradiente · emoji-humor · % · tokens em `###k`**. Os extras são ligáveis:
+
+| Feature | Flag | O que mostra |
+|---------|------|--------------|
+| **git** | `git` | 🌿 branch + `*` (dirty) `↑n` (ahead) `↓n` (behind) |
+| **cost** | `cost` | 💸 custo USD da sessão · ⏱ tempo · `+linhas/-linhas` |
+| **rate** | `rate` | ⏳ uso das janelas 5h e 7d (Claude Pro/Max; some se ausente) |
+| **puns** | `puns` | 💬 trocadilho de dev rotativo (troca a cada ~30s) |
+
+Tudo ligado por padrão. Pra escolher:
+
+```bash
+npx moodline init --features=git,cost      # só git e custo
+npx moodline init --no-puns --no-rate      # tudo menos trocadilhos e rate limits
+npx moodline init --multi                  # layout em 2 linhas
+npx moodline init --all                    # força Claude Code E Copilot CLI
+```
+
+## Comandos
+
+```
+moodline init        Configura a statusline nas CLIs detectadas
+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
+```
+
+## Configuração manual
+
+O `init` faz tudo, mas se preferir na mão — `~/.claude/settings.json`:
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "node \"C:/Users/voce/.claude/moodline/moodline-core.mjs\" --adapter=claude",
+    "padding": 0,
+    "refreshInterval": 5
+  }
+}
+```
+
+Use barra normal `/` no caminho mesmo no Windows (o Git Bash trata `\` como escape). O `--config=...` é opcional; sem ele, todas as features ficam ligadas.
+
+O `config.json`:
+
+```json
+{
+  "layout": "single",
+  "bar": { "width": 20 },
+  "punRotateMs": 30000,
+  "features": { "git": true, "cost": true, "rate": true, "puns": true }
+}
+```
+
+## Outras CLIs
+
+- **Gemini CLI** — tem footer embutido com toggles (`ui.footer.*`), mas não roda um comando seu pra renderizar conteúdo arbitrário. Dá pra ter uma barra custom só via extensão de terceiros (estilo `gemini-cli-hud`, que usa hooks + escape de scroll-region). No roadmap do moodline como adapter experimental.
+- **OpenCode** — a barra da TUI é fixa. O caminho é externo: `moodline watch --port 4096` consulta a API HTTP/SSE do OpenCode e imprime a barra, pra você fixar num painel do tmux/zellij. Experimental (o endpoint pode mudar entre versões).
+- **Junie (JetBrains)** — a CLI existe (beta), mas não tem statusline e o hook `SessionStart` descarta o stdout. Sem caminho viável hoje.
+
+## Requisitos
+
+- **Node.js ≥ 18** (o engine é JS puro, sem dependências).
+- Terminal com **truecolor** pro gradiente 24-bit: Windows Terminal, WezTerm, iTerm2, Kitty ou o terminal do VS Code.
+
+## Desenvolvimento
+
+```bash
+git clone https://github.com/slipalison/moodline
+cd moodline
+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.
+
+### Release
+
+Versionamento começa no `v0`. Publicação é automática via GitHub Action ao empurrar uma tag:
+
+```bash
+npm version patch            # bumpa 0.1.0 -> 0.1.1 e cria a tag v0.1.1
+git push --follow-tags       # dispara o workflow release.yml (publica no npm + cria o GitHub Release)
+```
+
+Requer o secret `NPM_TOKEN` no repositório (token de Automation do npm).
+
+## Licença
+
+MIT © Alison Amorim

package/bin/moodline.js

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+// moodline — instalador/configurador da statusline para CLIs de IA.
+//
+// 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 --help|--version
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+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';
+
+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);
+  }
+  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);
+  }
+  for (const k of Object.keys(f)) {
+    if (opts[`no-${k}`]) f[k] = false;
+  }
+  return f;
+}
+
+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 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');
+  }
+
+  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.');
+  }
+  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`);
+  }
+}
+
+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 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 cfg = loadConfig(opts.config);
+  for (const k of ['git', 'cost', 'rate', 'puns']) 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
+    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));
+}
+
+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 cfg = loadConfig(opts.config);
+  warn(`[experimental] OpenCode watch: GET ${url} a cada ${opts.interval || 2}s`);
+  const interval = (parseInt(opts.interval, 10) || 2) * 1000;
+  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);
+    }
+  };
+  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
+
+${C.bold}Uso:${C.reset}
+  npx moodline <comando> [opcoes]
+
+${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
+  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');
+
+switch (cmd) {
+  case 'init': cmdInit(opts); break;
+  case 'uninstall': cmdUninstall(opts); break;
+  case 'doctor': cmdDoctor(); break;
+  case 'render': cmdRender(opts); break;
+  case 'watch': await cmdWatch(opts); break;
+  case 'version': console.log(PKG.version); break;
+  case 'help':
+  default: cmdHelp(); break;
+}

package/lib/moodline-core.mjs

@@ -0,0 +1,386 @@
+// moodline-core.mjs — engine da statusline (zero dependencias, ESM puro)
+//
+// Roda de dois jeitos:
+//   1) Importado pelo bin/CLI (exporta render, adapters, DEFAULT_CFG).
+//   2) Executado direto pela CLI de IA: le JSON no stdin, imprime a barra no stdout.
+//      Ex.: node moodline-core.mjs --adapter=claude --config=/caminho/config.json
+//
+// Este arquivo e copiado para ~/.claude/moodline/ (e ~/.copilot/moodline/) no `moodline init`,
+// e o settings.json da CLI aponta direto pra ca. Mantido auto-contido de proposito: sem
+// imports entre arquivos, so node built-ins, pra poder ser copiado sozinho e rodar rapido.
+
+import { readFileSync, existsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { pathToFileURL } from 'node:url';
+
+// ---------------- ANSI ----------------
+const ESC = '\x1b';
+const RESET = `${ESC}[0m`;
+const DIM = `${ESC}[2m`;
+const CYAN = `${ESC}[36m`;
+const MAGENTA = `${ESC}[35m`;
+const GREEN = `${ESC}[32m`;
+const RED = `${ESC}[31m`;
+const YELLOW = `${ESC}[33m`;
+const truecolor = (r, g, b) => `${ESC}[38;2;${r};${g};${b}m`;
+
+// ---------------- config padrao ----------------
+export const DEFAULT_CFG = {
+  layout: 'single',          // 'single' | 'multi'
+  bar: { width: 20 },
+  punRotateMs: 30000,        // troca o trocadilho a cada ~30s
+  features: {
+    git: true,               // branch + estado (dirty/ahead/behind)
+    cost: true,              // custo USD + tempo + linhas +/-
+    rate: true,              // rate limits 5h/7d (Claude Pro/Max)
+    puns: true,              // trocadilhos rotativos de dev
+  },
+};
+
+// ---------------- gradiente HSL (verde 120 -> vermelho 0) ----------------
+function gradColor(pct) {
+  let h = (120 * (100 - pct)) / 100;
+  if (h < 0) h = 0;
+  if (h > 120) h = 120;
+  let r, g, b;
+  if (h < 60) { r = 255; g = (255 * h) / 60; b = 0; }
+  else { r = (255 * (120 - h)) / 60; g = 255; b = 0; }
+  return truecolor(Math.round(r), Math.round(g), Math.round(b));
+}
+
+// ---------------- barra (cheio / borda / vazio) ----------------
+function bar(pct, width = 20) {
+  let full = Math.floor((pct * width) / 100);
+  if (full > width) full = width;
+  let edge = 0;
+  if (full < width && pct > 0) {
+    edge = 2;
+    if (full + edge > width) edge = width - full;
+  }
+  const empty = Math.max(0, width - full - edge);
+  return '█'.repeat(full) + '▒'.repeat(edge) + '░'.repeat(empty);
+}
+
+// ---------------- emoji-humor pela ocupacao ----------------
+function mood(p) {
+  if (p >= 90) return '\u{1F480}'; // caveira
+  if (p >= 75) return '\u{1F975}'; // rosto quente
+  if (p >= 50) return '\u{1F605}'; // suando
+  if (p >= 25) return '\u{1F642}'; // sorriso leve
+  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];
+}
+
+// ---------------- formatadores ----------------
+const ktok = (t) => `${Math.round((Number(t) || 0) / 1000)}k`;
+function money(usd) {
+  if (usd == null) return null;
+  const n = Number(usd);
+  if (!isFinite(n)) return null;
+  const dec = n > 0 && n < 0.01 ? 3 : 2; // mostra centavos de centavo so quando minusculo
+  return '$' + n.toFixed(dec);
+}
+function dur(ms) {
+  if (ms == null) return null;
+  const s = Math.floor(Number(ms) / 1000);
+  if (!isFinite(s) || s < 0) return null;
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  return `${h}h${m % 60}m`;
+}
+
+// ---------------- git ----------------
+function gitInfo(cwd) {
+  if (!cwd || !existsSync(cwd)) return null;
+  const opt = { cwd, encoding: 'utf8', timeout: 250, stdio: ['ignore', 'pipe', 'ignore'] };
+  try {
+    const branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], opt).trim();
+    if (!branch) return null;
+    let dirty = false, ahead = 0, behind = 0;
+    try { dirty = execFileSync('git', ['status', '--porcelain'], opt).trim().length > 0; } catch {}
+    try {
+      const lr = execFileSync('git', ['rev-list', '--left-right', '--count', '@{u}...HEAD'], opt)
+        .trim().split(/\s+/);
+      behind = Number(lr[0]) || 0;
+      ahead = Number(lr[1]) || 0;
+    } catch {}
+    return { branch, dirty, ahead, behind };
+  } catch {
+    return null;
+  }
+}
+
+// ---------------- medir largura visivel (ignora ANSI; emoji conta 2) ----------------
+function vlen(s) {
+  const t = s.replace(/\x1b\[[0-9;]*m/g, '');
+  let n = 0;
+  for (const ch of t) n += ch.codePointAt(0) > 0xffff ? 2 : 1;
+  return n;
+}
+
+// ---------------- render ----------------
+export function render(state, cfg = DEFAULT_CFG) {
+  const f = cfg.features || {};
+  const cols = cfg.width || parseInt(process.env.COLUMNS || '', 10) || 80;
+  const c = gradColor(state.pct);
+
+  // segmento principal (sempre presente): modelo + effort + barra + emoji + pct + tokens
+  let core = `${CYAN}${state.model}${RESET}`;
+  if (state.effort) core += ` ${DIM}${state.effort}${RESET}`;
+  core += ` ${c}[${bar(state.pct, cfg.bar?.width ?? 20)}]${RESET}`;
+  core += ` ${mood(state.pct)} ${c}${state.pct}%${RESET} ${DIM}${ktok(state.tokens)}${RESET}`;
+
+  // segmentos opcionais (prioridade menor = sai por ultimo quando o terminal e estreito)
+  const opt = [];
+
+  if (f.git && state.git && state.git.branch) {
+    let g = `${MAGENTA}\u{1F33F} ${state.git.branch}${RESET}`;
+    const flags = [];
+    if (state.git.dirty) flags.push(`${YELLOW}*${RESET}`);
+    if (state.git.ahead) flags.push(`${GREEN}↑${state.git.ahead}${RESET}`);
+    if (state.git.behind) flags.push(`${RED}↓${state.git.behind}${RESET}`);
+    if (flags.length) g += ' ' + flags.join('');
+    opt.push({ txt: g, prio: 1 });
+  }
+
+  if (f.cost) {
+    const parts = [];
+    const mo = money(state.costUsd);
+    if (mo) parts.push(`\u{1F4B8} ${mo}`);
+    const d = dur(state.durationMs);
+    if (d) parts.push(`⏱ ${d}`);
+    if (state.linesAdded != null || state.linesRemoved != null) {
+      parts.push(`${GREEN}+${state.linesAdded || 0}${RESET}/${RED}-${state.linesRemoved || 0}${RESET}`);
+    }
+    if (parts.length) opt.push({ txt: parts.join(' '), prio: 2 });
+  }
+
+  if (f.rate && state.rate && (state.rate.five != null || state.rate.seven != null)) {
+    const parts = [];
+    if (state.rate.five != null) {
+      const v = Math.round(state.rate.five);
+      parts.push(`${gradColor(v)}5h ${v}%${RESET}`);
+    }
+    if (state.rate.seven != null) {
+      const v = Math.round(state.rate.seven);
+      parts.push(`${gradColor(v)}7d ${v}%${RESET}`);
+    }
+    opt.push({ txt: `⏳ ${parts.join(' ')}`, prio: 3 });
+  }
+
+  if (f.puns) {
+    opt.push({ txt: `${DIM}\u{1F4AC} ${pickPun(cfg.punRotateMs ?? 30000)}${RESET}`, prio: 4 });
+  }
+
+  const sep = ` ${DIM}·${RESET} `;
+  const sepLen = 3;
+
+  if (cfg.layout === 'multi') {
+    const line2 = opt.sort((a, b) => a.prio - b.prio).map((s) => s.txt).join(sep);
+    return line2 ? `${core}\n${line2}` : core;
+  }
+
+  // single: encaixa o que couber na largura, dropando por prioridade
+  let out = core;
+  let used = vlen(core);
+  for (const s of opt.sort((a, b) => a.prio - b.prio)) {
+    const add = sepLen + vlen(s.txt);
+    if (used + add <= cols - 1) { out += sep + s.txt; used += add; }
+  }
+  return out;
+}
+
+// ---------------- adapters (entrada bruta -> estado normalizado) ----------------
+export function attachGit(state, useGit) {
+  if (state.gitBranch) {
+    state.git = { branch: state.gitBranch, dirty: false, ahead: 0, behind: 0 };
+  } else if (useGit) {
+    state.git = gitInfo(state.cwd);
+  } else {
+    state.git = null;
+  }
+  return state;
+}
+
+// Claude Code — schema oficial (code.claude.com/docs/en/statusline)
+export function fromClaude(j) {
+  const cw = j.context_window || {};
+  const rl = j.rate_limits || null;
+  return {
+    model: j.model?.display_name || '?',
+    effort: j.effort?.level || null,
+    pct: Math.floor(Number(cw.used_percentage) || 0),
+    tokens: Number(cw.total_input_tokens) || 0,
+    ctxSize: cw.context_window_size || null,
+    costUsd: j.cost?.total_cost_usd ?? null,
+    durationMs: j.cost?.total_duration_ms ?? null,
+    linesAdded: j.cost?.total_lines_added ?? null,
+    linesRemoved: j.cost?.total_lines_removed ?? null,
+    rate: rl ? { five: rl.five_hour?.used_percentage ?? null, seven: rl.seven_day?.used_percentage ?? null } : null,
+    cwd: j.workspace?.current_dir || j.cwd || null,
+    gitBranch: null, // Claude nao manda branch; calculamos via git
+    repo: j.workspace?.repo || null,
+  };
+}
+
+// GitHub Copilot CLI — schema espelha o do Claude Code (statusLine experimental)
+export function fromCopilot(j) {
+  const cw = j.context_window || {};
+  return {
+    model: j.model?.display_name || '?',
+    effort: j.effort?.level || j.model?.effort || null,
+    pct: Math.floor(Number(cw.used_percentage) || 0),
+    tokens: Number(cw.total_input_tokens ?? cw.current_context_tokens) || 0,
+    ctxSize: cw.context_window_size || cw.displayed_context_limit || null,
+    costUsd: j.cost?.total_cost_usd ?? null,
+    durationMs: j.cost?.total_duration_ms ?? null,
+    linesAdded: j.cost?.total_lines_added ?? null,
+    linesRemoved: j.cost?.total_lines_removed ?? null,
+    rate: null,
+    cwd: j.cwd || null,
+    gitBranch: j.remote?.branch || null,
+    repo: null,
+  };
+}
+
+// OpenCode — EXPERIMENTAL. Sem statusLine nativa; alimentado pelo `moodline watch` (HTTP/SSE).
+// Mapeamento tolerante; ajuste conforme a versao da API do OpenCode.
+export function fromOpenCode(j) {
+  const ctx = j.context || j.tokens || {};
+  return {
+    model: j.model?.name || j.model?.id || j.model || '?',
+    effort: null,
+    pct: Math.floor(Number(ctx.used_percentage ?? ctx.percentage ?? j.percentage) || 0),
+    tokens: Number(ctx.input ?? ctx.tokens ?? j.input_tokens) || 0,
+    ctxSize: ctx.limit || null,
+    costUsd: j.cost ?? null,
+    durationMs: null,
+    linesAdded: null,
+    linesRemoved: null,
+    rate: null,
+    cwd: j.directory || j.cwd || null,
+    gitBranch: j.git?.branch || null,
+    repo: null,
+  };
+}
+
+// Gemini CLI — EXPERIMENTAL. Sem statusLine nativa por comando; passthroughgenerico de JSON
+// caso o usuario ligue via hook/extensao. Veja docs do projeto.
+export function fromGemini(j) {
+  const cw = j.context_window || j.context || {};
+  return {
+    model: j.model?.display_name || j.model || '?',
+    effort: null,
+    pct: Math.floor(Number(cw.used_percentage ?? j.percentage) || 0),
+    tokens: Number(cw.total_input_tokens ?? cw.tokens) || 0,
+    ctxSize: cw.context_window_size || null,
+    costUsd: null,
+    durationMs: null,
+    linesAdded: null,
+    linesRemoved: null,
+    rate: null,
+    cwd: j.cwd || null,
+    gitBranch: null,
+    repo: null,
+  };
+}
+
+export const ADAPTERS = {
+  claude: fromClaude,
+  copilot: fromCopilot,
+  opencode: fromOpenCode,
+  gemini: fromGemini,
+};
+
+// ---------------- util ----------------
+function deepMerge(base, over) {
+  const out = { ...base };
+  for (const k of Object.keys(over || {})) {
+    if (over[k] && typeof over[k] === 'object' && !Array.isArray(over[k])) {
+      out[k] = deepMerge(base[k] || {}, over[k]);
+    } else {
+      out[k] = over[k];
+    }
+  }
+  return out;
+}
+
+export function loadConfig(path) {
+  let cfg = structuredClone(DEFAULT_CFG);
+  if (path && existsSync(path)) {
+    try { cfg = deepMerge(cfg, JSON.parse(readFileSync(path, 'utf8'))); } catch {}
+  }
+  return cfg;
+}
+
+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);
+  }
+  return o;
+}
+
+// ---------------- main (so quando executado direto) ----------------
+function readStdin() {
+  if (process.stdin.isTTY) return '';
+  try { return readFileSync(0, 'utf8'); } catch { return ''; }
+}
+
+export function runMain(argv) {
+  const args = parseArgs(argv);
+  const adapterName = (args.adapter || 'claude').toLowerCase();
+  const adapter = ADAPTERS[adapterName] || fromClaude;
+
+  const cfg = loadConfig(args.config);
+  if (args['no-git']) cfg.features.git = false;
+  if (args['no-cost']) cfg.features.cost = false;
+  if (args['no-rate']) cfg.features.rate = false;
+  if (args['no-puns']) cfg.features.puns = false;
+  if (args.multi) cfg.layout = 'multi';
+  if (args.width) cfg.width = parseInt(args.width, 10) || undefined;
+
+  let raw = {};
+  try { raw = JSON.parse(readStdin() || '{}'); } catch { raw = {}; }
+
+  try {
+    const state = attachGit(adapter(raw), cfg.features.git);
+    process.stdout.write(render(state, cfg) + '\n');
+  } catch (e) {
+    // statusline nunca deve quebrar a CLI: imprime algo minimo
+    process.stdout.write(`${CYAN}${raw?.model?.display_name || 'moodline'}${RESET}\n`);
+  }
+}
+
+const isMain = process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (isMain) runMain(process.argv.slice(2));

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "moodline",
+  "version": "0.1.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": {
+    "moodline": "bin/moodline.js"
+  },
+  "exports": {
+    ".": "./lib/moodline-core.mjs"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node test/smoke.mjs"
+  },
+  "keywords": [
+    "statusline",
+    "status-line",
+    "claude-code",
+    "copilot-cli",
+    "github-copilot",
+    "ai-cli",
+    "cli",
+    "terminal",
+    "prompt",
+    "context-window",
+    "tokens",
+    "emoji",
+    "developer-tools"
+  ],
+  "author": "Alison Amorim <alison.amorim.mail@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/slipalison/moodline.git"
+  },
+  "homepage": "https://github.com/slipalison/moodline#readme",
+  "bugs": {
+    "url": "https://github.com/slipalison/moodline/issues"
+  }
+}