arsenal-agent 0.1.0

package/COMANDOS.md

@@ -0,0 +1,34 @@
+# arsenal-agent — Comandos
+
+## Trocar de conta
+
+```bash
+aa profile use pessoal    # dbezerra106@gmail.com
+aa profile use trabalho   # claude-datascience@zerum.com
+```
+
+## Ver contas cadastradas
+
+```bash
+aa profile list
+```
+
+## Abrir o TUI (dual agent)
+
+```bash
+aa                        # usa o perfil ativo
+aa --profile trabalho     # força um perfil específico
+```
+
+## Adicionar nova conta
+
+```bash
+aa profile add <nome>
+```
+
+## Onde ficam os tokens
+
+```
+~/.arsenal-agent/credentials/pessoal.json
+~/.arsenal-agent/credentials/trabalho.json
+```

package/README.md

@@ -0,0 +1,36 @@
+# arsenal-agent
+
+Dual AI agent CLI — roteamento automático entre Claude Sonnet e Nemotron (free).
+
+Tasks simples vão pro Nemotron via OpenCode (grátis). Tasks complexas vão pro Claude Sonnet.
+
+## Instalação
+
+```bash
+npm install -g arsenal-agent
+```
+
+## Uso
+
+```bash
+arsenal-agent
+# ou o alias curto:
+aa
+```
+
+## Requisitos
+
+- `opencode` instalado: `npm install -g opencode-ai`
+- `ANTHROPIC_API_KEY` no ambiente
+- `OPENROUTER_API_KEY` no ambiente
+
+## Como funciona
+
+```
+Você digita uma task
+  └── ROUTER classifica
+        ├── task simples → Nemotron 120B (OpenRouter, free)
+        └── task complexa → Claude Sonnet 4.6 (Anthropic)
+```
+
+Teclado: `ctrl+c` sair · `ctrl+l` limpar

package/app.py

@@ -0,0 +1,308 @@
+#!/usr/bin/env python3
+"""
+Dual Agent CLI — Claude Code + OpenCode side-by-side
+Roteador automatico: tasks simples vao pro Nemotron (free), complexas pro Claude Sonnet.
+"""
+
+import subprocess
+import threading
+import time
+import os
+import re
+from datetime import datetime
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import (
+    Header, Footer, Input, RichLog, Static, Label
+)
+from textual.reactive import reactive
+from textual import work
+from rich.text import Text
+from rich.panel import Panel
+
+# ── Custo aproximado por 1k tokens ──────────────────────────────────────────
+COST_PER_1K = {
+    "nemotron-120b": 0.0,
+    "nemotron-nano": 0.0,
+    "sonnet":        0.003,
+}
+
+MODELS = {
+    "nemotron-120b": "openrouter/nvidia/nemotron-3-super-120b-a12b:free",
+    "nemotron-nano": "openrouter/nvidia/nemotron-nano-12b-v2-vl:free",
+    "sonnet":        "anthropic/claude-sonnet-4-6",
+}
+
+# Palavras-chave que indicam task COMPLEXA → Claude Sonnet
+COMPLEX_KEYWORDS = [
+    "arquitetura", "architecture", "seguranca", "security", "vulnerabilidade",
+    "refatora", "refactor", "por que", "why", "debug", "erro complexo",
+    "analisa", "analyze", "projeta", "design", "mcp", "agente", "agent",
+    "pipeline", "infraestrutura", "infrastructure", "revisao", "review",
+    "estrategia", "strategy", "implemente", "implement", "crie um sistema",
+    "como funciona", "how does", "explique a arquitetura",
+]
+
+
+def classify_task(task: str) -> tuple[str, str]:
+    """Retorna (model_alias, razao) para a task."""
+    low = task.lower()
+    for kw in COMPLEX_KEYWORDS:
+        if kw in low:
+            return "sonnet", f"keyword: '{kw}'"
+    if len(task) > 400:
+        return "sonnet", "prompt longo (>400 chars)"
+    return "nemotron-120b", "task simples → free"
+
+
+def run_opencode(task: str, model_alias: str) -> tuple[str, float]:
+    """Executa opencode run e retorna (output, tempo_segundos)."""
+    model_id = MODELS[model_alias]
+    t0 = time.time()
+    result = subprocess.run(
+        ["opencode", "run", task, "--model", model_id],
+        capture_output=True, text=True, timeout=120,
+    )
+    elapsed = time.time() - t0
+    output = result.stdout.strip() or result.stderr.strip() or "Sem resposta."
+    # Remove escape sequences de cor do opencode
+    output = re.sub(r'\x1b\[[0-9;]*m', '', output)
+    output = re.sub(r'\[[\d]+m', '', output)
+    return output.strip(), elapsed
+
+
+def run_claude(task: str) -> tuple[str, float]:
+    """Executa Claude via claude CLI e retorna (output, tempo_segundos)."""
+    t0 = time.time()
+    result = subprocess.run(
+        ["claude", "--print", task],
+        capture_output=True, text=True, timeout=180,
+        env={**os.environ},
+    )
+    elapsed = time.time() - t0
+    output = result.stdout.strip() or result.stderr.strip() or "Sem resposta do Claude."
+    return output, elapsed
+
+
+# ── Widgets ─────────────────────────────────────────────────────────────────
+
+class AgentPanel(Vertical):
+    """Painel de um agente com log de mensagens."""
+
+    DEFAULT_CSS = """
+    AgentPanel {
+        border: solid $primary;
+        padding: 0 1;
+        height: 100%;
+    }
+    AgentPanel .panel-title {
+        text-align: center;
+        text-style: bold;
+        color: $accent;
+        padding: 0 0 1 0;
+    }
+    AgentPanel RichLog {
+        height: 1fr;
+    }
+    """
+
+    def __init__(self, title: str, id: str):
+        super().__init__(id=id)
+        self._title = title
+
+    def compose(self) -> ComposeResult:
+        yield Label(self._title, classes="panel-title")
+        yield RichLog(highlight=True, markup=True, wrap=True, id=f"{self.id}-log")
+
+    def log(self, text: str, style: str = ""):
+        log = self.query_one(f"#{self.id}-log", RichLog)
+        if style:
+            log.write(Text(text, style=style))
+        else:
+            log.write(text)
+
+    def clear(self):
+        self.query_one(f"#{self.id}-log", RichLog).clear()
+
+
+class StatsBar(Static):
+    """Barra de estatísticas de tokens/custo."""
+
+    tasks_routed: reactive[int] = reactive(0)
+    tokens_saved: reactive[int] = reactive(0)
+    cost_paid: reactive[float] = reactive(0.0)
+    cost_saved: reactive[float] = reactive(0.0)
+
+    DEFAULT_CSS = """
+    StatsBar {
+        background: $surface;
+        padding: 0 2;
+        height: 3;
+        border-top: solid $primary-darken-2;
+        color: $text-muted;
+    }
+    """
+
+    def render(self) -> str:
+        saved_pct = 0
+        total = self.cost_paid + self.cost_saved
+        if total > 0:
+            saved_pct = int((self.cost_saved / total) * 100)
+        return (
+            f" Tasks: [bold]{self.tasks_routed}[/bold]  |  "
+            f"Economizado: [green]{saved_pct}%[/green] (~${self.cost_saved:.4f})  |  "
+            f"Gasto real: [yellow]${self.cost_paid:.4f}[/yellow]  |  "
+            f"[dim]Nemotron = free • Sonnet = $3/MTok[/dim]"
+        )
+
+
+# ── App principal ────────────────────────────────────────────────────────────
+
+class DualAgentApp(App):
+    """Dual Agent CLI: Claude Code + OpenCode side-by-side."""
+
+    CSS = """
+    Screen {
+        background: #0a0a0a;
+    }
+    Header {
+        background: #111111;
+    }
+    Footer {
+        background: #111111;
+    }
+    #main {
+        height: 1fr;
+    }
+    #left-panel {
+        width: 1fr;
+        border: solid #00aaff;
+    }
+    #router-panel {
+        width: 28;
+        border: solid #444444;
+        padding: 0 1;
+        height: 100%;
+    }
+    #router-panel Label {
+        text-align: center;
+        color: #888888;
+        text-style: bold;
+        padding: 0 0 1 0;
+    }
+    #router-log {
+        height: 1fr;
+        color: #666666;
+    }
+    #right-panel {
+        width: 1fr;
+        border: solid #ff6600;
+    }
+    #input-bar {
+        height: 3;
+        padding: 0 1;
+        border-top: solid #222222;
+    }
+    #task-input {
+        width: 1fr;
+    }
+    """
+
+    TITLE = "Dual Agent CLI"
+    SUB_TITLE = "Claude Sonnet + Nemotron (free)"
+    BINDINGS = [
+        ("ctrl+c", "quit", "Sair"),
+        ("ctrl+l", "clear_all", "Limpar"),
+    ]
+
+    def __init__(self):
+        super().__init__()
+        self._stats = None
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Horizontal(id="main"):
+            yield AgentPanel("Claude Sonnet 4.6  [dim](tasks complexas)[/dim]", id="left-panel")
+            with Vertical(id="router-panel"):
+                yield Label("ROUTER")
+                yield RichLog(highlight=False, markup=True, wrap=True, id="router-log")
+            yield AgentPanel("Nemotron 120B  [dim](free • tasks simples)[/dim]", id="right-panel")
+        with Horizontal(id="input-bar"):
+            yield Input(placeholder="Digite sua task e pressione Enter...", id="task-input")
+        yield StatsBar(id="stats")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self._stats = self.query_one("#stats", StatsBar)
+        self.query_one("#task-input", Input).focus()
+        self._router_log("Sistema iniciado")
+        self._router_log(f"Claude: claude CLI")
+        self._router_log(f"OpenCode: {MODELS['nemotron-120b'][:30]}...")
+
+    def _router_log(self, msg: str) -> None:
+        ts = datetime.now().strftime("%H:%M:%S")
+        log = self.query_one("#router-log", RichLog)
+        log.write(f"[dim]{ts}[/dim] {msg}")
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        task = event.value.strip()
+        if not task:
+            return
+        event.input.value = ""
+        self._dispatch_task(task)
+
+    @work(thread=True)
+    def _dispatch_task(self, task: str) -> None:
+        model_alias, reason = classify_task(task)
+        ts = datetime.now().strftime("%H:%M:%S")
+
+        self.call_from_thread(self._router_log, f"[cyan]→[/cyan] {task[:40]}...")
+        self.call_from_thread(self._router_log, f"  [yellow]{model_alias}[/yellow] ({reason})")
+
+        if model_alias == "sonnet":
+            panel = self.query_one("#left-panel", AgentPanel)
+            self.call_from_thread(panel.log, f"\n[bold cyan][{ts}] Você:[/bold cyan] {task}")
+            self.call_from_thread(panel.log, "[dim]aguardando Claude...[/dim]", "dim")
+
+            output, elapsed = run_claude(task)
+
+            self.call_from_thread(panel.log, f"[bold green]Claude:[/bold green]")
+            self.call_from_thread(panel.log, output)
+            self.call_from_thread(panel.log, f"[dim]({elapsed:.1f}s)[/dim]")
+
+            # Estima custo: ~300 tokens de output
+            cost = (300 / 1000) * COST_PER_1K["sonnet"]
+            cost_saved = (300 / 1000) * COST_PER_1K["nemotron-120b"]  # seria 0
+            self.call_from_thread(self._update_stats, cost, 0.0)
+
+        else:
+            panel = self.query_one("#right-panel", AgentPanel)
+            self.call_from_thread(panel.log, f"\n[bold orange1][{ts}] Você:[/bold orange1] {task}")
+            self.call_from_thread(panel.log, "[dim]aguardando Nemotron...[/dim]", "dim")
+
+            output, elapsed = run_opencode(task, model_alias)
+
+            self.call_from_thread(panel.log, f"[bold green]Nemotron:[/bold green]")
+            self.call_from_thread(panel.log, output)
+            self.call_from_thread(panel.log, f"[dim]({elapsed:.1f}s • $0.00)[/dim]")
+
+            # Quanto teria custado no Sonnet
+            cost_saved = (300 / 1000) * COST_PER_1K["sonnet"]
+            self.call_from_thread(self._update_stats, 0.0, cost_saved)
+
+    def _update_stats(self, cost_paid: float, cost_saved: float) -> None:
+        stats = self._stats
+        stats.tasks_routed += 1
+        stats.cost_paid += cost_paid
+        stats.cost_saved += cost_saved
+
+    def action_clear_all(self) -> None:
+        self.query_one("#left-panel", AgentPanel).clear()
+        self.query_one("#right-panel", AgentPanel).clear()
+        self.query_one("#router-log", RichLog).clear()
+        self._router_log("Logs limpos")
+
+
+if __name__ == "__main__":
+    app = DualAgentApp()
+    app.run()

package/dist/agents.d.ts

@@ -0,0 +1,8 @@
+import type { ModelAlias } from "./types.js";
+export interface AgentResult {
+    content: string;
+    elapsed: number;
+    model: ModelAlias;
+}
+export declare function runClaude(task: string): Promise<AgentResult>;
+export declare function runOpencode(task: string, alias: ModelAlias): Promise<AgentResult>;

package/dist/agents.js

@@ -0,0 +1,37 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import Anthropic from "@anthropic-ai/sdk";
+import { getModelId } from "./router.js";
+const execFileAsync = promisify(execFile);
+const anthropic = new Anthropic({
+    apiKey: process.env.ANTHROPIC_API_KEY,
+});
+export async function runClaude(task) {
+    const t0 = Date.now();
+    const message = await anthropic.messages.create({
+        model: "claude-sonnet-4-6-20251101",
+        max_tokens: 2048,
+        messages: [{ role: "user", content: task }],
+    });
+    const content = message.content
+        .filter((b) => b.type === "text")
+        .map((b) => b.text)
+        .join("\n");
+    return { content, elapsed: (Date.now() - t0) / 1000, model: "sonnet" };
+}
+export async function runOpencode(task, alias) {
+    const t0 = Date.now();
+    const modelId = getModelId(alias);
+    try {
+        const { stdout, stderr } = await execFileAsync("opencode", ["run", task, "--model", modelId], { timeout: 120_000, env: process.env });
+        const raw = stdout || stderr || "Sem resposta.";
+        // Remove ANSI escape codes
+        const content = raw.replace(/\x1b\[[0-9;]*m/g, "").replace(/\[[\d]+m/g, "").trim();
+        return { content, elapsed: (Date.now() - t0) / 1000, model: alias };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { content: `Erro: ${msg}`, elapsed: (Date.now() - t0) / 1000, model: alias };
+    }
+}
+//# sourceMappingURL=agents.js.map

package/dist/app.d.ts

@@ -0,0 +1 @@
+export declare function App(): import("react/jsx-runtime").JSX.Element;

package/dist/app.js

@@ -0,0 +1,121 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useCallback } from "react";
+import { Box, Text, useInput, useApp } from "ink";
+import { classifyTask, COST_PER_1K } from "./router.js";
+import { runClaude, runOpencode } from "./agents.js";
+// ── Componentes ──────────────────────────────────────────────────────────────
+function MessageList({ messages, model }) {
+    const filtered = messages.filter((m) => model === "sonnet" ? m.model === "sonnet" : m.model !== "sonnet");
+    return (_jsx(Box, { flexDirection: "column", gap: 0, children: filtered.map((msg) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { color: msg.role === "user" ? "cyan" : "green", bold: true, children: [msg.role === "user" ? "Você" : model === "sonnet" ? "Claude" : "Nemotron", msg.elapsed ? ` (${msg.elapsed.toFixed(1)}s)` : ""] }), _jsx(Text, { wrap: "wrap", children: msg.content })] }, msg.id))) }));
+}
+function Panel({ title, color, messages, model, loading, width, }) {
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: color, width: width, height: 30, paddingX: 1, children: [_jsx(Text, { bold: true, color: color, children: title }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: [_jsx(MessageList, { messages: messages, model: model }), loading && (_jsx(Text, { color: "gray", dimColor: true, children: "aguardando..." }))] })] }));
+}
+function RouterLog({ entries }) {
+    const last = entries.slice(-12);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", width: 26, height: 30, paddingX: 1, children: [_jsx(Text, { bold: true, color: "gray", children: "ROUTER" }), last.map((e, i) => (_jsx(Text, { color: "gray", dimColor: true, wrap: "wrap", children: e }, i)))] }));
+}
+function StatsBar({ stats }) {
+    const pct = stats.costSaved + stats.costPaid > 0
+        ? Math.round((stats.costSaved / (stats.costSaved + stats.costPaid)) * 100)
+        : 0;
+    return (_jsx(Box, { borderStyle: "single", borderColor: "gray", paddingX: 2, marginTop: 0, children: _jsxs(Text, { children: ["Tasks: ", _jsx(Text, { bold: true, children: stats.tasksTotal }), "  ", "Free: ", _jsx(Text, { color: "green", bold: true, children: stats.tasksFree }), "  ", "Pago: ", _jsx(Text, { color: "yellow", bold: true, children: stats.tasksPaid }), "  ", "Economizado: ", _jsxs(Text, { color: "green", bold: true, children: [pct, "%"] }), " (~$", stats.costSaved.toFixed(4), ")", "  ", "Gasto: ", _jsxs(Text, { color: "yellow", children: ["$", stats.costPaid.toFixed(4)] }), "  ", _jsx(Text, { dimColor: true, children: "[ctrl+c sair \u2022 ctrl+l limpar]" })] }) }));
+}
+// ── App principal ─────────────────────────────────────────────────────────────
+export function App() {
+    const { exit } = useApp();
+    const [messages, setMessages] = useState([]);
+    const [routerLog, setRouterLog] = useState(["iniciado", "claude: sonnet-4-6", "free: nemotron-120b"]);
+    const [input, setInput] = useState("");
+    const [loadingLeft, setLoadingLeft] = useState(false);
+    const [loadingRight, setLoadingRight] = useState(false);
+    const [stats, setStats] = useState({
+        tasksTotal: 0, tasksFree: 0, tasksPaid: 0, costPaid: 0, costSaved: 0,
+    });
+    const addRouter = useCallback((line) => {
+        setRouterLog((prev) => [...prev, line]);
+    }, []);
+    const dispatch = useCallback(async (task) => {
+        const decision = classifyTask(task);
+        const ts = new Date().toLocaleTimeString("pt-BR", { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+        addRouter(`${ts} → ${task.slice(0, 22)}...`);
+        addRouter(`  ${decision.model} (${decision.reason})`);
+        const userMsg = {
+            id: `u-${Date.now()}`,
+            role: "user",
+            content: task,
+            model: decision.model,
+            timestamp: new Date(),
+        };
+        setMessages((prev) => [...prev, userMsg]);
+        if (decision.model === "sonnet") {
+            setLoadingLeft(true);
+            try {
+                const result = await runClaude(task);
+                const assistantMsg = {
+                    id: `a-${Date.now()}`,
+                    role: "assistant",
+                    content: result.content,
+                    model: "sonnet",
+                    elapsed: result.elapsed,
+                    timestamp: new Date(),
+                };
+                setMessages((prev) => [...prev, assistantMsg]);
+                const cost = (300 / 1000) * COST_PER_1K["sonnet"];
+                const saved = (300 / 1000) * COST_PER_1K["nemotron-120b"];
+                setStats((s) => ({ ...s, tasksTotal: s.tasksTotal + 1, tasksPaid: s.tasksPaid + 1, costPaid: s.costPaid + cost, costSaved: s.costSaved + saved }));
+            }
+            finally {
+                setLoadingLeft(false);
+            }
+        }
+        else {
+            setLoadingRight(true);
+            try {
+                const result = await runOpencode(task, decision.model);
+                const assistantMsg = {
+                    id: `a-${Date.now()}`,
+                    role: "assistant",
+                    content: result.content,
+                    model: decision.model,
+                    elapsed: result.elapsed,
+                    timestamp: new Date(),
+                };
+                setMessages((prev) => [...prev, assistantMsg]);
+                const saved = (300 / 1000) * COST_PER_1K["sonnet"];
+                setStats((s) => ({ ...s, tasksTotal: s.tasksTotal + 1, tasksFree: s.tasksFree + 1, costSaved: s.costSaved + saved }));
+            }
+            finally {
+                setLoadingRight(false);
+            }
+        }
+    }, [addRouter]);
+    useInput((char, key) => {
+        if (key.ctrl && char === "c") {
+            exit();
+            return;
+        }
+        if (key.ctrl && char === "l") {
+            setMessages([]);
+            setRouterLog(["limpo"]);
+            return;
+        }
+        if (key.return) {
+            const task = input.trim();
+            if (task) {
+                setInput("");
+                dispatch(task);
+            }
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setInput((prev) => prev.slice(0, -1));
+            return;
+        }
+        if (char && !key.ctrl && !key.meta) {
+            setInput((prev) => prev + char);
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "blue", children: " arsenal-agent " }), _jsx(Text, { dimColor: true, children: "Claude Sonnet + Nemotron free \u2014 roteamento automatico" })] }), _jsxs(Box, { flexDirection: "row", gap: 0, children: [_jsx(Panel, { title: "Claude Sonnet 4.6  (tasks complexas)", color: "cyan", messages: messages, model: "sonnet", loading: loadingLeft, width: 50 }), _jsx(RouterLog, { entries: routerLog }), _jsx(Panel, { title: "Nemotron 120B  (free \u00B7 tasks simples)", color: "yellow", messages: messages, model: "nemotron", loading: loadingRight, width: 50 })] }), _jsxs(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, children: [_jsxs(Text, { color: "gray", children: [">", " "] }), _jsx(Text, { children: input }), _jsx(Text, { color: "gray", children: "\u2588" })] }), _jsx(StatsBar, { stats: stats })] }));
+}
+//# sourceMappingURL=app.js.map

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { Command } from "commander";
+import { App } from "./app.js";
+import { addProfile, listProfiles, useProfile, loadProfile, applyProfile } from "./profiles.js";
+const program = new Command();
+program
+    .name("arsenal-agent")
+    .description("Dual AI agent CLI — Claude Sonnet + Nemotron free, roteamento automatico")
+    .version("0.1.0")
+    .option("-p, --profile <name>", "perfil a usar (substitui env vars)");
+// ── Subcomando: profile ────────────────────────────────────────────────────
+const profileCmd = program
+    .command("profile")
+    .description("gerenciar perfis de API keys");
+profileCmd
+    .command("add [name]")
+    .description("adicionar ou atualizar um perfil")
+    .action(async (name) => {
+    await addProfile(name);
+    process.exit(0);
+});
+profileCmd
+    .command("list")
+    .alias("ls")
+    .description("listar perfis cadastrados")
+    .action(() => {
+    listProfiles();
+    process.exit(0);
+});
+profileCmd
+    .command("use <name>")
+    .description("definir perfil ativo padrão")
+    .action((name) => {
+    useProfile(name);
+    process.exit(0);
+});
+// ── Ação principal: lança TUI ──────────────────────────────────────────────
+program.action((opts) => {
+    // Aplica perfil se informado ou se há um perfil ativo salvo
+    const profile = loadProfile(opts.profile);
+    if (profile) {
+        applyProfile(profile);
+        process.stderr.write(`[arsenal-agent] perfil: ${profile.label ?? profile.name}\n`);
+    }
+    else if (!process.env.ANTHROPIC_API_KEY) {
+        console.error("Nenhuma ANTHROPIC_API_KEY encontrada.");
+        console.error("Adicione um perfil: aa profile add");
+        console.error("Ou exporte a variável: export ANTHROPIC_API_KEY=sk-ant-...");
+        process.exit(1);
+    }
+    const { waitUntilExit } = render(_jsx(App, {}));
+    waitUntilExit().then(() => process.exit(0));
+});
+program.parse();
+//# sourceMappingURL=index.js.map

package/dist/profiles.d.ts

@@ -0,0 +1,14 @@
+export type AuthMethod = "api_key" | "browser";
+export interface Profile {
+    name: string;
+    label?: string;
+    auth_method: AuthMethod;
+    anthropic_api_key?: string;
+    openrouter_api_key?: string;
+    email?: string;
+}
+export declare function addProfile(name?: string): Promise<void>;
+export declare function listProfiles(): void;
+export declare function useProfile(name: string): void;
+export declare function loadProfile(name?: string): Profile | null;
+export declare function applyProfile(profile: Profile): void;