liberty-code-cli 1.0.0 → 2.0.0

package/README.md

@@ -0,0 +1,212 @@
+# Liberty Code
+
+Agente de código do LibertyChat, operando no terminal sobre um projeto real
+(sistema de arquivos de verdade, não uma simulação). v2.0.0.
+
+## Instalação
+
+```bash
+npm install -g liberty-code-cli
+```
+
+## Login
+
+```bash
+liberty login <token>
+```
+
+Gere o token em **Configurações → Liberty Code** dentro do LibertyChat.
+
+## Uso
+
+```bash
+cd seu-projeto
+liberty
+```
+
+Flags:
+
+| Flag | Efeito |
+|---|---|
+| `-c`, `--continue` | Retoma a última sessão salva deste projeto |
+| `--resume [id]` | Retoma uma sessão específica; sem id, mostra a lista pra escolher |
+| `--permission-mode <modo>` | Inicia em `default` \| `acceptEdits` \| `bypassPermissions` \| `plan` |
+| `--dangerously-skip-permissions` | Atalho pra `bypassPermissions` (ainda pede confirmação explícita) |
+
+## Ferramentas do agente
+
+| Ferramenta | O que faz |
+|---|---|
+| `list_directory` | Lista arquivos/pastas (respeita `.gitignore`), com `recursive`/`max_depth` |
+| `read_file` | Lê um arquivo; aceita `offset`/`limit` pra arquivos grandes |
+| `write_file` | Cria ou sobrescreve um arquivo inteiro |
+| `edit_file` | Troca um trecho exato (`old_string` → `new_string`) — preferido para editar arquivo existente |
+| `glob_files` | Encontra arquivos por padrão (`**/*.test.js`) |
+| `grep_search` | Busca por regex dentro do conteúdo dos arquivos |
+| `run_command` | Roda um comando de shell; `run_in_background:true` pra processos longos (log em arquivo) |
+| `update_todos` | Checklist de progresso pra tarefas com vários passos |
+| `task` | Dispara um subagente com contexto isolado pra uma sub-tarefa |
+| `mcp__<servidor>__<ferramenta>` | Ferramentas de servidores MCP configurados (se houver) |
+
+Toda escrita de arquivo e todo comando passam pela confirmação do usuário
+(exceto nos modos que auto-aprovam — ver abaixo).
+
+## Modos de permissão
+
+Trocáveis a qualquer momento com `/mode <nome>`:
+
+- **default** — pergunta antes de editar arquivo ou rodar comando (padrão).
+- **acceptEdits** — edita arquivos sem perguntar; comandos ainda pedem confirmação.
+- **bypassPermissions** — aprova tudo sem perguntar. Pede confirmação explícita ao ligar (`/mode bypassPermissions` ou flag `--dangerously-skip-permissions`).
+- **plan** — somente leitura. As ferramentas de escrita **não são nem oferecidas** ao modelo nesse modo — não é uma instrução pra não usar, é ausência real da ferramenta. Ao final da resposta, o CLI pergunta se você quer sair do modo e executar o que foi combinado.
+
+Respondendo `a` (always) numa confirmação, aquela ação específica (aquele
+arquivo, ou aquele comando exato) passa a ser auto-aprovada **pelo resto
+desta sessão** — não persiste pra próxima vez que você abrir o `liberty`.
+
+## Memória de projeto (LIBERTY.md)
+
+Carregada automaticamente no início de cada sessão, em duas camadas:
+
+1. **Global** — `~/.libertycode/LIBERTY.md`: preferências suas, valem em
+   qualquer projeto (ex: "sempre responda em português").
+2. **Projeto** — `LIBERTY.md` na raiz do projeto: convenções do
+   repositório, pensado pra ir pro git e ser compartilhado pelo time.
+
+Dentro de qualquer um dos dois, uma linha `@caminho/arquivo.md` importa o
+conteúdo daquele arquivo (1 nível de profundidade).
+
+- `/init` — pede pro agente explorar o projeto e escrever/atualizar o `LIBERTY.md` sozinho.
+- `#texto` (digitado direto no chat) — anota `texto` no `LIBERTY.md` do projeto sem gastar uma chamada ao modelo.
+- `/memory` — mostra o que está carregado agora.
+
+## Sessões retomáveis
+
+Cada turno é salvo em `~/.libertycode/sessions/<projeto>/<id>.json`.
+
+- `liberty --continue` — retoma a última sessão deste diretório.
+- `liberty --resume [id]` — retoma uma sessão específica, ou lista pra escolher.
+- `/sessions` e `/resume <id|latest>` — o mesmo, de dentro do chat.
+
+## Hooks
+
+Configurados em `.liberty/settings.json` (veja o exemplo incluído nesta
+pasta). Eventos disponíveis: `SessionStart`, `UserPromptSubmit`,
+`PreToolUse`, `PostToolUse`, `Stop`. Convenção do código de saída:
+
+- `exit 0` → ok; stdout (se houver) só é informativo (ou, em `SessionStart`/`UserPromptSubmit`, vira contexto real pro modelo).
+- `exit 2` → bloqueia a ação (só faz sentido em `PreToolUse`/`UserPromptSubmit`); stderr vira o motivo, devolvido ao modelo.
+- qualquer outro código → aviso, não bloqueia.
+
+```json
+{
+  "hooks": {
+    "PreToolUse": [{ "matcher": "run_command", "command": "node .liberty/hooks/block-dangerous-commands.js" }],
+    "PostToolUse": [{ "matcher": "write_file|edit_file", "command": "npx eslint --fix \"$LIBERTY_FILE\"" }]
+  }
+}
+```
+
+## Skills
+
+Arquivos `.liberty/skills/<nome>/SKILL.md` (deste projeto) ou
+`~/.libertycode/skills/<nome>/SKILL.md` (globais, reusadas em todos os
+projetos). Só o manifesto (nome + descrição) entra no contexto no início da
+sessão; o modelo lê o `SKILL.md` inteiro (com `read_file`) quando o pedido
+combina com a descrição. `/skills` lista o que foi encontrado.
+
+```markdown
+---
+name: revisar-pr
+description: Use ao revisar um Pull Request — checklist de segurança, testes e estilo.
+---
+# conteúdo detalhado, só carregado quando relevante
+```
+
+## Subagentes
+
+A ferramenta `task` dispara um subagente com **histórico isolado** (não vê
+a conversa principal, só o `prompt` recebido), ferramentas restritas por
+`subagent_type` (`general` ou `read-only-researcher`), teto de 12 chamadas
+de ferramenta, e devolve só o resumo final pra conversa principal — os
+passos intermediários não poluem o contexto principal. Um subagente não
+pode disparar outro (profundidade máxima 1).
+
+## MCP
+
+`.liberty/mcp.json` (mesmo formato do `mcpServers` do Claude
+Desktop/Claude Code — copie o bloco de lá se já tiver):
+
+```json
+{
+  "mcpServers": {
+    "github": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"], "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "..." } }
+  }
+}
+```
+
+Ferramentas descobertas entram como `mcp__github__<ferramenta>`. `/mcp`
+lista os servidores conectados nesta sessão. Falha em um servidor não
+derruba os outros.
+
+## Comandos do chat
+
+```
+/help                 Mostra os comandos
+/clear                Limpa o histórico (mantém memória/skills carregadas)
+/exit, /quit           Sai
+/init                  Explora o projeto e cria/atualiza o LIBERTY.md
+/memory                Mostra a memória carregada agora
+/mode [nome]           Mostra ou troca o modo de permissão
+/sessions              Lista sessões salvas deste projeto
+/resume <id|latest>    Retoma uma sessão salva
+/skills                Lista skills carregadas
+/mcp                   Lista servidores MCP conectados
+/bg                    Lista processos em background desta sessão
+# texto                Anota no LIBERTY.md sem enviar ao modelo
+```
+
+## Arquitetura
+
+O **modelo roda no servidor** do LibertyChat (`/api/cli/chat`, Venice AI);
+este CLI decide qual ferramenta oferecer a cada chamada e **executa
+localmente** o que o modelo pede (ler/escrever arquivo, rodar comando) —
+nada do seu código sai da sua máquina além do que você explicitamente
+mandar (conteúdo de arquivo lido, saída de comando confirmado).
+
+```
+bin/liberty.js     entry point (argv, login/logout, flags)
+src/
+  engine.js         loop de tool-calling — reusado pela sessão principal E pelos subagentes
+  repl.js            REPL interativo (comandos de barra, plan mode, autosave)
+  api.js             cliente HTTP pro /api/cli/chat
+  tools/             list_directory, read_file, write_file, edit_file, glob_files, grep_search, run_command, update_todos
+  permissions.js      modos default/acceptEdits/bypassPermissions/plan
+  memory.js           LIBERTY.md hierárquico + /init + atalho #
+  session.js          sessões retomáveis
+  hooks.js            PreToolUse/PostToolUse/SessionStart/Stop/UserPromptSubmit
+  skills.js           descoberta de .liberty/skills
+  subagents.js         ferramenta task
+  mcp.js               cliente MCP (stdio, SDK oficial)
+```
+
+## Comparado ao Claude Code — o que ainda falta
+
+Sendo direto, como no pedido original: isto fecha a distância **estrutural**
+(os mesmos conceitos existem e funcionam de verdade — não são só nomes
+imitando a documentação), mas não fecha a distância de **maturidade de
+produto**. Especificamente, não implementado nesta rodada:
+
+- **Superfícies além do terminal** (extensão de IDE, app desktop). `engine.js`
+  foi desenhado pra ser reutilizável por uma futura superfície, mas construir
+  a extensão/app em si é outro projeto.
+- **Allow-list de permissão persistente** entre sessões (hoje `always` vale só
+  pra sessão atual, de propósito — é o default mais seguro).
+- **Compactação automática de contexto** em conversas muito longas.
+- **Streaming token-a-token** no terminal (resposta chega de uma vez, como já
+  era antes — não é algo que o CLI controla sozinho, depende do transporte
+  do servidor).
+
+## Requisitos
+
+Node.js ≥ 18.

package/bin/liberty.js

@@ -3,135 +3,55 @@
 /**
  * Liberty Code — CLI do LibertyChat.
  *
+ * v2: este arquivo virou um entry point fino. Toda a lógica (ferramentas,
+ * permissões, memória, sessões, hooks, skills, MCP, subagentes, o loop do
+ * agente) mora em src/ — bin/liberty.js só decide QUAL comando rodar a
+ * partir do argv e chama a função certa. Ver src/repl.js pro coração do CLI.
+ *
  * Instalação:  npm install -g liberty-code-cli
  * Login:       liberty login <token>     (gere o token em Configurações → Liberty Code)
  * Uso:         cd seu-projeto && liberty
  *
  * Arquitetura: o modelo roda no servidor do LibertyChat; as ferramentas
- * (ler/escrever arquivo, listar diretório, rodar comando) executam AQUI,
- * localmente, no processo deste CLI — o servidor só decide QUAL ferramenta
- * usar e com quais argumentos. Nada do seu código é enviado além do que você
- * explicitamente perguntar sobre (conteúdo de arquivos que o agente pede pra
- * ler, e a saída dos comandos que você confirmar rodar).
+ * (ler/escrever/editar arquivo, listar diretório, buscar, rodar comando)
+ * executam AQUI, localmente, no processo deste CLI — o servidor só decide
+ * QUAL ferramenta usar e com quais argumentos. Nada do seu código é enviado
+ * além do que você explicitamente pedir (conteúdo de arquivos que o agente
+ * lê, e a saída de comandos que você confirmar rodar).
  */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
 const readline = require('readline');
-const { execSync } = require('child_process');
-
-// ── Configuração ────────────────────────────────────────────────────────────
-const CONFIG_DIR  = path.join(os.homedir(), '.libertycode');
-const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
-const SERVER_URL  = process.env.LIBERTY_SERVER_URL || 'https://libertychat.onrender.com';
-const MAX_FILE_READ_BYTES = 200 * 1024; // 200KB — protege contexto do modelo contra arquivos enormes
-const MAX_TOOL_ITERATIONS = 12;         // evita loop infinito se o modelo insistir em ferramentas
-
-// ── Cores ANSI (sem dependências externas, de propósito) ───────────────────
-const c = {
-  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
-  red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m',
-  blue: '\x1b[34m', magenta: '\x1b[35m', cyan: '\x1b[36m', gray: '\x1b[90m',
-};
-const paint = (color, text) => `${c[color]}${text}${c.reset}`;
-
-function loadConfig() {
-  try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')); } catch { return null; }
-}
-function saveConfig(cfg) {
-  fs.mkdirSync(CONFIG_DIR, { recursive: true });
-  fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2), { mode: 0o600 });
-}
-
-// ── HTTP helper ──────────────────────────────────────────────────────────────
-async function apiChat(messages, token) {
-  const res = await fetch(`${SERVER_URL}/api/cli/chat`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` },
-    body: JSON.stringify({ messages, cwd: process.cwd() }),
-  });
-  const data = await res.json().catch(() => ({}));
-  if (!res.ok) throw new Error(data.error || `Erro do servidor (${res.status})`);
-  return data;
-}
-
-// ── Ferramentas locais (executam de verdade no disco do usuário) ───────────
-function safeResolve(relPath) {
-  // Nunca deixa o modelo escapar do diretório do projeto via ../../
-  const resolved = path.resolve(process.cwd(), relPath || '.');
-  if (!resolved.startsWith(process.cwd())) {
-    throw new Error('Caminho fora do diretório do projeto não é permitido.');
-  }
-  return resolved;
-}
-
-function toolListDirectory(args) {
-  const dir = safeResolve(args.path || '.');
-  const entries = fs.readdirSync(dir, { withFileTypes: true })
-    .filter(e => !['node_modules', '.git', '.next', 'dist', 'build'].includes(e.name))
-    .map(e => (e.isDirectory() ? `${e.name}/` : e.name));
-  return entries.join('\n') || '(diretório vazio)';
-}
-
-function toolReadFile(args) {
-  const filePath = safeResolve(args.path);
-  const stat = fs.statSync(filePath);
-  if (stat.size > MAX_FILE_READ_BYTES) {
-    return `[Arquivo muito grande: ${(stat.size / 1024).toFixed(0)}KB — limite de ${MAX_FILE_READ_BYTES / 1024}KB. Peça uma parte específica.]`;
-  }
-  return fs.readFileSync(filePath, 'utf8');
-}
-
-function toolWriteFile(args, rl) {
-  const filePath = safeResolve(args.path);
-  const exists = fs.existsSync(filePath);
-  console.log(paint('yellow', `\n${exists ? '✏️  Sobrescrever' : '📄 Criar'} arquivo: ${path.relative(process.cwd(), filePath)}`));
-  console.log(paint('gray', `   (${(args.content || '').length} caracteres)`));
-  return askConfirmation(rl, '   Permitir?').then(ok => {
-    if (!ok) return '[Usuário negou a escrita deste arquivo.]';
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, args.content, 'utf8');
-    return `Arquivo salvo com sucesso: ${path.relative(process.cwd(), filePath)}`;
-  });
-}
-
-function toolRunCommand(args, rl) {
-  console.log(paint('yellow', `\n💻 Executar comando: `) + paint('bold', args.command));
-  return askConfirmation(rl, '   Permitir?').then(ok => {
-    if (!ok) return '[Usuário negou a execução deste comando.]';
-    try {
-      const output = execSync(args.command, { cwd: process.cwd(), encoding: 'utf8', timeout: 60000, maxBuffer: 5 * 1024 * 1024 });
-      return output || '(comando executado sem output)';
-    } catch (e) {
-      return `Erro (exit ${e.status ?? '?'}):\n${e.stdout || ''}${e.stderr || e.message}`;
-    }
-  });
-}
-
-function askConfirmation(rl, label) {
-  return new Promise(resolve => {
-    rl.question(`${label} ${paint('gray', '[y/N] ')}`, answer => {
-      resolve(['y', 'yes', 's', 'sim'].includes(answer.trim().toLowerCase()));
-    });
-  });
-}
-
-async function executeLocalTool(call, rl) {
-  try {
-    switch (call.name) {
-      case 'list_directory': return toolListDirectory(call.arguments);
-      case 'read_file':      return toolReadFile(call.arguments);
-      case 'write_file':     return await toolWriteFile(call.arguments, rl);
-      case 'run_command':    return await toolRunCommand(call.arguments, rl);
-      default: return `Ferramenta desconhecida: ${call.name}`;
-    }
-  } catch (e) {
-    return `Erro ao executar ${call.name}: ${e.message}`;
+const pkg = require('../package.json');
+const { SERVER_URL, PERMISSION_MODES } = require('../src/constants');
+const { paint } = require('../src/ui');
+const { loadConfig, saveConfig } = require('../src/configStore');
+const sessionStore = require('../src/session');
+
+const KNOWN_COMMANDS = new Set(['login', 'logout', '--version', '-v', '--help', '-h']);
+
+function parseArgs(argv) {
+  // FIX: argv[0] só é tratado como "comando" (login/logout/--version/--help)
+  // se for de fato um desses — senão o comando é o chat (default) e o
+  // array INTEIRO (incluindo argv[0]) precisa ser escaneado em busca de
+  // flags. Antes, "liberty --continue" ou "liberty --permission-mode plan"
+  // (flag logo de cara, sem subcomando) tinham a primeira flag engolida
+  // como se fosse "cmd" e nunca chegavam a ser reconhecidas.
+  const cmd = KNOWN_COMMANDS.has(argv[0]) ? argv[0] : null;
+  const rest = cmd ? argv.slice(1) : argv;
+  const opts = { permissionMode: null, resumeId: null, dangerouslySkipPermissions: false };
+  const positional = [];
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === '--continue' || a === '-c') opts.resumeId = 'latest';
+    else if (a === '--resume') opts.resumeId = rest[i + 1] && !rest[i + 1].startsWith('-') ? rest[++i] : '__pick__';
+    else if (a === '--permission-mode') opts.permissionMode = rest[++i];
+    else if (a === '--dangerously-skip-permissions') opts.dangerouslySkipPermissions = true;
+    else positional.push(a);
   }
+  // "login" continua vindo de argv[1] em diante mesmo com essa mudança,
+  // já que cmd="login" implica rest=argv.slice(1), igual antes.
+  return { cmd: cmd || 'chat', positional, opts };
 }
 
-// ── Comandos de CLI ─────────────────────────────────────────────────────────
 async function cmdLogin(token) {
   if (!token) {
     console.log(paint('red', 'Uso: liberty login <token>'));
@@ -140,15 +60,38 @@ async function cmdLogin(token) {
   }
   saveConfig({ token, serverUrl: SERVER_URL });
   console.log(paint('green', '✅ Login salvo com sucesso.'));
+  const { CONFIG_FILE } = require('../src/constants');
   console.log(paint('gray', `Token guardado em ${CONFIG_FILE}`));
 }
 
 function cmdLogout() {
+  const fs = require('fs');
+  const { CONFIG_FILE } = require('../src/constants');
   try { fs.unlinkSync(CONFIG_FILE); console.log(paint('green', '✅ Logout feito.')); }
   catch { console.log(paint('gray', 'Nenhuma sessão ativa.')); }
 }
 
-async function cmdChat() {
+async function pickSessionInteractively(cwd) {
+  const list = sessionStore.listSessions(cwd);
+  if (!list.length) { console.log(paint('gray', 'Nenhuma sessão salva pra este projeto ainda — começando uma nova.')); return null; }
+  console.log(paint('gray', '\nSessões salvas:'));
+  list.forEach((s, i) => console.log(paint('gray', `  ${i + 1}) `) + `${s.updatedAt}  (${s.messageCount} msgs)  ${s.preview}`));
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise(resolve => rl.question(paint('cyan', '\nEscolha um número (Enter pra cancelar e começar do zero): '), a => { rl.close(); resolve(a.trim()); }));
+  const idx = parseInt(answer, 10) - 1;
+  if (!Number.isInteger(idx) || !list[idx]) return null;
+  return list[idx].id;
+}
+
+async function confirmDangerousMode() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  console.log(paint('red', '\n⚠ --dangerously-skip-permissions liga o modo bypassPermissions:'));
+  console.log(paint('red', '  TODA escrita de arquivo e TODO comando serão executados sem perguntar.'));
+  const ok = await new Promise(resolve => rl.question(paint('red', 'Confirma? Digite "sim" pra prosseguir: '), a => { rl.close(); resolve(a.trim().toLowerCase() === 'sim'); }));
+  if (!ok) { console.log(paint('gray', 'Cancelado.')); process.exit(0); }
+}
+
+async function cmdChat(opts) {
   const config = loadConfig();
   if (!config?.token) {
     console.log(paint('red', 'Você ainda não está logado.'));
@@ -156,64 +99,51 @@ async function cmdChat() {
     process.exit(1);
   }
 
-  console.log(paint('bold', '\n🦅 Liberty Code') + paint('gray', `  —  ${process.cwd()}`));
-  console.log(paint('gray', 'Digite seu pedido. Ctrl+C para sair.\n'));
+  if (opts.dangerouslySkipPermissions) {
+    await confirmDangerousMode();
+    opts.permissionMode = PERMISSION_MODES.BYPASS;
+  }
+  if (opts.permissionMode && !Object.values(PERMISSION_MODES).includes(opts.permissionMode)) {
+    console.log(paint('red', `Modo de permissão inválido: "${opts.permissionMode}". Use: ${Object.values(PERMISSION_MODES).join(', ')}`));
+    process.exit(1);
+  }
+  if (opts.resumeId === '__pick__') {
+    opts.resumeId = await pickSessionInteractively(process.cwd());
+  }
 
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const messages = [];
+  const { start } = require('../src/repl');
+  await start(config, opts);
+}
 
-  const promptUser = () => rl.question(paint('cyan', '› '), async (input) => {
-    if (!input.trim()) return promptUser();
-    messages.push({ role: 'user', content: input });
+function printHelp() {
+  console.log(`Liberty Code — agente do LibertyChat no terminal (v${pkg.version})
 
-    try {
-      let iterations = 0;
-      while (iterations++ < MAX_TOOL_ITERATIONS) {
-        process.stdout.write(paint('gray', '⏳ pensando...\r'));
-        const response = await apiChat(messages, config.token);
-        process.stdout.write('              \r'); // limpa a linha "pensando..."
+Uso:
+  liberty login <token>   Autentica com um token gerado em Configurações → Liberty Code
+  liberty logout          Remove a sessão salva
+  liberty                 Inicia o chat no diretório atual (é o seu projeto)
 
-        if (response.type === 'tool_calls') {
-          messages.push({
-            role: 'assistant', content: response.content || null,
-            tool_calls: response.toolCalls.map(tc => ({ id: tc.id, type: 'function', function: { name: tc.name, arguments: JSON.stringify(tc.arguments) } })),
-          });
-          for (const call of response.toolCalls) {
-            const result = await executeLocalTool(call, rl);
-            console.log(paint('gray', `   → ${String(result).slice(0, 200)}${String(result).length > 200 ? '...' : ''}`));
-            messages.push({ role: 'tool', tool_call_id: call.id, content: String(result).slice(0, 8000) });
-          }
-          continue; // manda o resultado de volta e deixa o modelo decidir o próximo passo
-        }
+Flags do chat:
+  -c, --continue                 Retoma a última sessão salva deste projeto
+  --resume [id]                  Retoma uma sessão específica (sem id, mostra a lista pra escolher)
+  --permission-mode <modo>       Inicia já em: default | acceptEdits | bypassPermissions | plan
+  --dangerously-skip-permissions Atalho pra bypassPermissions (pede confirmação explícita)
 
-        console.log('\n' + response.content + '\n');
-        messages.push({ role: 'assistant', content: response.content });
-        break;
-      }
-    } catch (e) {
-      console.log(paint('red', `\n❌ ${e.message}\n`));
-    }
-    promptUser();
-  });
+Dentro do chat, digite /help pra ver os comandos (memória, sessões, skills, MCP, modo de permissão etc).
 
-  rl.on('close', () => { console.log(paint('gray', '\nAté mais!')); process.exit(0); });
-  promptUser();
+Dica: crie um arquivo LIBERTY.md na raiz do projeto (ou rode /init de dentro do chat) com
+convenções, comandos de build/teste e o que o agente deve evitar.
+`);
 }
 
-// ── Entry point ──────────────────────────────────────────────────────────────
 (async () => {
-  const [, , cmd, arg] = process.argv;
-  if (cmd === 'login') await cmdLogin(arg);
+  const { cmd, positional, opts } = parseArgs(process.argv.slice(2));
+  if (cmd === 'login') await cmdLogin(positional[0]);
   else if (cmd === 'logout') cmdLogout();
-  else if (cmd === '--version' || cmd === '-v') console.log('liberty-code 1.0.0');
-  else if (cmd === '--help' || cmd === '-h') {
-    console.log(`Liberty Code — agente do LibertyChat no terminal
-
-Uso:
-  liberty login <token>   Autentica com um token gerado em Configurações → Liberty Code
-  liberty logout          Remove a sessão salva
-  liberty                 Inicia o chat no diretório atual (é o seu projeto)
-`);
-  }
-  else await cmdChat();
-})();
+  else if (cmd === '--version' || cmd === '-v') console.log(`liberty-code-cli ${pkg.version}`);
+  else if (cmd === '--help' || cmd === '-h') printHelp();
+  else await cmdChat(opts);
+})().catch(e => {
+  console.error(paint('red', `\n❌ Erro fatal: ${e.message}`));
+  process.exit(1);
+});

package/package.json

@@ -1,17 +1,34 @@
 {
   "name": "liberty-code-cli",
-  "version": "1.0.0",
-  "description": "Liberty Code — o agente do LibertyChat operando no terminal, sobre projetos de código reais.",
+  "version": "2.0.0",
+  "description": "Liberty Code — o agente do LibertyChat operando no terminal: memória de projeto, sessões retomáveis, permissões por modo, hooks, skills, subagentes e MCP.",
   "bin": {
     "liberty": "bin/liberty.js"
   },
   "type": "commonjs",
+  "scripts": {
+    "test": "node --test"
+  },
   "engines": {
     "node": ">=18.0.0"
   },
   "files": [
-    "bin/"
+    "bin/",
+    "src/"
   ],
   "license": "MIT",
-  "keywords": ["libertychat", "cli", "ai", "agent", "terminal"]
+  "keywords": [
+    "libertychat",
+    "cli",
+    "ai",
+    "agent",
+    "terminal",
+    "mcp",
+    "skills",
+    "subagents"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "ignore": "^7.0.6"
+  }
 }

package/src/api.js

@@ -0,0 +1,45 @@
+'use strict';
+/**
+ * apiChat — v1 mandava só {messages, cwd}. Pra suportar plan mode (menos
+ * ferramentas), subagentes (ferramentas + prompt diferentes) e MCP
+ * (ferramentas extras), o cliente agora manda seu PRÓPRIO array de tools e
+ * um systemPromptSuffix opcional — o server.js precisa aceitar isso (ver
+ * FIX correspondente em server.js) em vez de sempre usar o
+ * buildLibertyCodeTools() fixo dele.
+ *
+ * Retrocompatível dos dois lados: se o server ainda for a versão antiga (que
+ * ignora campos desconhecidos no body), o CLI simplesmente volta a se
+ * comportar como v1 (4 ferramentas fixas, sem suffix) — não quebra.
+ */
+const { SERVER_URL, HISTORY_MESSAGES_SENT } = require('./constants');
+
+async function apiChat(messages, token, { tools, systemPromptSuffix, serverUrl, signal } = {}) {
+  const url = `${serverUrl || SERVER_URL}/api/cli/chat`;
+  const body = { messages: messages.slice(-HISTORY_MESSAGES_SENT), cwd: process.cwd() };
+  if (tools) body.tools = tools;
+  if (systemPromptSuffix) body.systemPromptSuffix = systemPromptSuffix;
+
+  const attempt = async () => {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
+      body: JSON.stringify(body),
+      signal,
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) throw new Error(data.error || `Erro do servidor (${res.status})`);
+    return data;
+  };
+
+  try {
+    return await attempt();
+  } catch (e) {
+    if (e.name === 'AbortError') throw e; // usuário cancelou (Ctrl+C) — não faz sentido tentar de novo
+    if (/^(Erro do servidor|HTTP)/.test(e.message)) throw e; // erro do servidor (4xx/5xx) — repetir não ajuda
+    // provável falha de rede transitória (wifi caiu, DNS etc) — uma retentativa curta
+    await new Promise(r => setTimeout(r, 1200));
+    return attempt();
+  }
+}
+
+module.exports = { apiChat };

package/src/configStore.js

@@ -0,0 +1,14 @@
+'use strict';
+const fs = require('fs');
+const { CONFIG_FILE, ensureDir, GLOBAL_DIR } = require('./constants');
+
+function loadConfig() {
+  try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')); } catch { return null; }
+}
+
+function saveConfig(cfg) {
+  ensureDir(GLOBAL_DIR);
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2), { mode: 0o600 });
+}
+
+module.exports = { loadConfig, saveConfig };