llm-agent-cli 2.0.0

package/dist/index.js

@@ -0,0 +1,905 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import fs from "fs/promises";
+import path from "path";
+import { stdin as processStdin, stdout as processStdout } from "process";
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { Agent, TurnCancelledError, checkRouterHealth, } from "./agent.js";
+import { AuditLogger } from "./audit.js";
+import { getAgentPaths, loadConfig, ensureAgentDirectories, } from "./config.js";
+import { ContextManager } from "./context.js";
+import { ReplInput } from "./input.js";
+import { preprocessPrompt } from "./preprocessor.js";
+import { detectProjectContext } from "./project.js";
+import { renderMarkdown } from "./renderer.js";
+import { SessionStore } from "./session.js";
+import { listAvailableTools } from "./tools/index.js";
+import { resolveProtectedPath, getRuntimeConfig } from "./tools/security.js";
+import { run_linter, run_tests, security_scan } from "./tools/linter.js";
+import { loadCredentials, resolveConnectionFromEnvOrCreds, runLogin, runLogout, runWhoami, } from "./auth.js";
+import { loadMemory, appendMemory, clearMemory, showMemory, } from "./memory.js";
+const PERMISSION_MODES = ["safe", "standard", "yolo"];
+function isPermissionMode(value) {
+    return PERMISSION_MODES.includes(value);
+}
+function isOutputFormat(value) {
+    return value === "text" || value === "json";
+}
+function formatUsd(value) {
+    return `$${value.toFixed(4)}`;
+}
+function looksLikeMarkdown(text) {
+    return /(^\s{0,3}#{1,6}\s|\*\*|`[^`]+`|^\s*[-*+]\s|\|.+\|)/m.test(text);
+}
+function printBanner(runtime, permissionMode) {
+    const model = process.env.LLM_ROUTER_MODEL ?? "auto";
+    const baseUrl = process.env.LLM_ROUTER_BASE_URL ?? "(not set)";
+    console.log(chalk.bold.cyan(`\n  ╔══════════════════════════════════════╗\n  ║        LLM-Router CLI Agent          ║\n  ║   Powered by your local LLM-Router   ║\n  ╚══════════════════════════════════════╝`));
+    console.log(chalk.dim(`  Router: ${baseUrl}  |  Model: ${model}`));
+    console.log(chalk.dim(`  Session: ${runtime.sessionId}`));
+    console.log(chalk.dim(`  Workspace: ${runtime.project.workspaceRoot}`));
+    console.log(chalk.dim(`  Permissions: ${permissionMode}`));
+    console.log(chalk.dim(`  Type /help for commands`));
+    console.log();
+}
+function printHelp() {
+    console.log(chalk.bold("\nSlash commands:"));
+    console.log(chalk.cyan("  /help") + "         — show commands");
+    console.log(chalk.cyan("  /exit") + "         — quit");
+    console.log(chalk.cyan("  /clear") + "        — clear terminal");
+    console.log(chalk.cyan("  /compact") + "      — summarize and compact conversation");
+    console.log(chalk.cyan("  /models") + "       — list router models");
+    console.log(chalk.cyan("  /cost") + "         — show token/cost totals");
+    console.log(chalk.cyan("  /save [name]") + "  — save named session snapshot");
+    console.log(chalk.cyan("  /load [name]") + "  — load named session or list names");
+    console.log(chalk.cyan("  /retry") + "        — resend last user prompt");
+    console.log(chalk.cyan("  /undo") + "         — remove last user+assistant turn");
+    console.log(chalk.cyan("  /cd <path>") + "    — change working directory (within workspace)");
+    console.log(chalk.cyan("  /tools") + "        — list tools");
+    console.log(chalk.cyan("  /permissions") + "  — show permission mode");
+    console.log(chalk.cyan("  /verbose") + "      — toggle verbose tool output");
+    console.log(chalk.cyan("  /review [path]") + " — code review a file or directory");
+    console.log(chalk.cyan("  /scan [path]") + "  — security scan (secrets, XSS, SQLi, etc.)");
+    console.log(chalk.cyan("  /lint [path]") + "  — run project linter");
+    console.log(chalk.cyan("  /test [path]") + "  — run test suite");
+    console.log(chalk.cyan("  /memory") + "       — show persistent memory (global + project)");
+    console.log(chalk.cyan("  /remember <text>") + " — append a fact to project memory");
+    console.log(chalk.cyan("  /remember --global <text>") + " — append to global memory");
+    console.log(chalk.cyan("  /memory clear") + " — clear project memory");
+    console.log(chalk.cyan("  /memory clear --global") + " — clear global memory");
+    console.log();
+    console.log(chalk.bold("Multiline input:"));
+    console.log(chalk.dim("  End a line with \\ to continue onto next line."));
+    console.log(chalk.dim("  Type <<< then paste lines; end with a single . line."));
+    console.log();
+}
+function printTools() {
+    console.log(chalk.bold("\nAvailable tools:"));
+    for (const tool of listAvailableTools()) {
+        console.log(`  ${chalk.yellow(tool.name)} — ${tool.description}`);
+    }
+    console.log();
+}
+function modelFlag(model, key) {
+    const direct = model[key];
+    if (typeof direct === "boolean")
+        return direct;
+    const snake = key
+        .replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)
+        .toLowerCase();
+    const snakeValue = model[snake];
+    return typeof snakeValue === "boolean" ? snakeValue : false;
+}
+function extractModelCapabilities(model) {
+    const explicit = model.capabilities;
+    if (Array.isArray(explicit)) {
+        return explicit.map(String).slice(0, 6).join(",");
+    }
+    const derived = [];
+    const mapping = [
+        ["supportsFunctionCalling", "function_calling"],
+        ["supportsStreaming", "streaming"],
+        ["supportsJsonMode", "json_mode"],
+        ["supportsVision", "vision"],
+        ["supportsThinking", "thinking"],
+        ["supportsImageGen", "image_gen"],
+        ["supportsAudio", "audio"],
+        ["supportsVideo", "video"],
+        ["supportsEmbeddings", "embeddings"],
+    ];
+    for (const [field, label] of mapping) {
+        if (modelFlag(model, field)) {
+            derived.push(label);
+        }
+    }
+    return derived.slice(0, 6).join(",");
+}
+function formatModels(models) {
+    const rows = models.map((model) => ({
+        id: String(model.id ?? ""),
+        tier: String(model.tier ?? ""),
+        owner: String(model.owned_by ?? ""),
+        caps: extractModelCapabilities(model),
+    }));
+    const headers = ["ID", "TIER", "OWNER", "CAPABILITIES"];
+    const widths = [40, 10, 12, 45];
+    const line = (values) => values
+        .map((value, idx) => {
+        const width = widths[idx] ?? 20;
+        if (value.length <= width)
+            return value.padEnd(width, " ");
+        return `${value.slice(0, Math.max(0, width - 1))}…`;
+    })
+        .join("  ");
+    const divider = widths.map((w) => "-".repeat(w)).join("  ");
+    const body = rows.map((row) => line([row.id, row.tier, row.owner, row.caps]));
+    return [line(headers), divider, ...body].join("\n");
+}
+async function readAllStdin() {
+    const chunks = [];
+    for await (const chunk of processStdin) {
+        chunks.push(Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf-8");
+}
+async function restoreSnapshot(runtime, snapshot) {
+    runtime.agent.importState(snapshot);
+    runtime.context.loadState(snapshot.contextState);
+    if (snapshot.cwd) {
+        try {
+            const resolved = await resolveProtectedPath(snapshot.cwd);
+            process.chdir(resolved);
+        }
+        catch {
+            // keep current cwd if saved path is invalid now
+        }
+    }
+}
+async function bootstrapRuntime(options) {
+    const project = await detectProjectContext(process.cwd());
+    const paths = getAgentPaths();
+    await ensureAgentDirectories(paths);
+    const config = await loadConfig(paths);
+    const audit = new AuditLogger(paths);
+    const context = new ContextManager(config);
+    const sessions = new SessionStore(paths);
+    const memory = await loadMemory(project.workspaceRoot);
+    const agent = new Agent({
+        workspaceRoot: project.workspaceRoot,
+        permissionMode: options.permissions,
+        maxReadBytes: config.maxReadBytes,
+        maxToolResultChars: config.maxToolResultChars,
+        maxCommandOutputChars: config.maxCommandOutputChars,
+        shellTimeoutMs: config.shellTimeoutMs,
+        systemContext: project.summary,
+        auditLogger: audit,
+        contextWindowTokens: config.contextWindowTokens,
+        memory,
+    });
+    let sessionId = options.resume ?? sessions.createSessionId();
+    if (options.resume) {
+        const resumed = await sessions.loadLatestSnapshotById(options.resume);
+        if (resumed) {
+            await restoreSnapshot({
+                agent,
+                config,
+                paths,
+                project,
+                audit,
+                context,
+                sessions,
+                sessionId,
+                workspaceRoot: project.workspaceRoot,
+            }, resumed);
+        }
+    }
+    return {
+        agent,
+        config,
+        paths,
+        project,
+        audit,
+        context,
+        sessions,
+        sessionId,
+        workspaceRoot: project.workspaceRoot,
+    };
+}
+async function persistSnapshot(runtime) {
+    await runtime.sessions.appendSnapshot(runtime.sessionId, runtime.agent.exportState(runtime.context.serializeState()));
+}
+async function executeTurn(runtime, rawPrompt, signal, outputFormat, streamOutput) {
+    const preprocessed = await preprocessPrompt(rawPrompt, Math.min(runtime.config.maxReadBytes, 16_000));
+    if (preprocessed.includedFiles.length > 0) {
+        const files = preprocessed.includedFiles.map((file) => file.path).join(", ");
+        if (streamOutput) {
+            console.log(chalk.dim(`Including files in prompt: ${files}`));
+        }
+        else {
+            process.stderr.write(`info: including files in prompt: ${files}\n`);
+        }
+    }
+    for (const warning of preprocessed.warnings) {
+        if (streamOutput) {
+            console.log(chalk.yellow(`Warning: ${warning}`));
+        }
+        else {
+            // In non-interactive / JSON mode route to stderr so stdout stays clean
+            // for piping: llm-agent --prompt "..." --output-format json | jq '.'
+            process.stderr.write(`warning: ${warning}\n`);
+        }
+    }
+    const spinner = ora({ text: "Thinking...", color: "cyan" }).start();
+    let printedToken = false;
+    let printedAgentPrefix = false;
+    let toolTimer = null;
+    let toolStartAt = 0;
+    let currentToolLabel = "";
+    const clearToolTimer = () => {
+        if (toolTimer) {
+            clearInterval(toolTimer);
+            toolTimer = null;
+        }
+    };
+    const callbacks = {
+        onToken: async (token) => {
+            if (!streamOutput)
+                return;
+            if (spinner.isSpinning)
+                spinner.stop();
+            clearToolTimer();
+            if (!printedAgentPrefix) {
+                processStdout.write(chalk.bold.white("Agent: "));
+                printedAgentPrefix = true;
+            }
+            printedToken = true;
+            processStdout.write(token);
+        },
+        onRetry: async (attempt, delayMs) => {
+            spinner.text = `Retry ${attempt}/3 in ${Math.floor(delayMs / 1000)}s...`;
+        },
+        onToolStart: async (event) => {
+            if (!streamOutput)
+                return;
+            clearToolTimer();
+            toolStartAt = Date.now();
+            currentToolLabel = `${event.toolName} ${event.argsPreview}`;
+            spinner.start(`> ${currentToolLabel} (0s)`);
+            toolTimer = setInterval(() => {
+                const elapsed = Math.floor((Date.now() - toolStartAt) / 1000);
+                spinner.text = `> ${currentToolLabel} (${elapsed}s)`;
+            }, 1000);
+        },
+        onToolEnd: async (event) => {
+            if (!streamOutput)
+                return;
+            clearToolTimer();
+            spinner.stop();
+            if (runtime.agent.isVerboseTools()) {
+                console.log(chalk.dim(`\n[${event.toolName}]\n${event.resultPreview}`));
+            }
+            else if (event.truncated) {
+                console.log(chalk.yellow(`\nTool ${event.toolName} output was truncated before returning to model.`));
+            }
+        },
+    };
+    try {
+        const result = await runtime.agent.run(preprocessed.processedPrompt, {
+            signal,
+            callbacks,
+        });
+        clearToolTimer();
+        spinner.stop();
+        const responseText = result.response;
+        if (streamOutput) {
+            if (!printedToken) {
+                console.log(chalk.bold.white("Agent:"));
+                console.log(renderMarkdown(responseText).trimEnd());
+            }
+            else {
+                processStdout.write("\n");
+                if (looksLikeMarkdown(responseText)) {
+                    console.log(chalk.dim("[Rendered Markdown]"));
+                    console.log(renderMarkdown(responseText).trimEnd());
+                }
+            }
+        }
+        if (!streamOutput && outputFormat === "text") {
+            console.log(responseText);
+        }
+        if (result.usage) {
+            const metrics = runtime.context.recordTurn(result.model, result.usage);
+            if (streamOutput) {
+                console.log(chalk.dim(`[↑ ${metrics.promptTokens.toLocaleString()} | ↓ ${metrics.completionTokens.toLocaleString()} | ~${formatUsd(metrics.turnCostUsd)} | total ${formatUsd(metrics.cumulativeCostUsd)}]`));
+            }
+            if (metrics.warnThresholdCrossed && streamOutput) {
+                console.log(chalk.yellow(`Context usage warning: ${(metrics.contextUtilization * 100).toFixed(1)}% of configured window (${runtime.config.contextWindowTokens.toLocaleString()} tokens).`));
+            }
+            if (metrics.autoCompactRecommended) {
+                const summary = await runtime.agent.compactHistory(signal);
+                if (streamOutput) {
+                    console.log(chalk.yellow(`Auto-compact triggered at ${(metrics.contextUtilization * 100).toFixed(1)}% context usage.`));
+                    console.log(renderMarkdown(summary).trimEnd());
+                }
+            }
+        }
+        await persistSnapshot(runtime);
+        if (outputFormat === "json") {
+            const cost = runtime.context.getCostSummary();
+            const payload = {
+                response: responseText,
+                usage: result.usage,
+                model: result.model,
+                finish_reason: result.finishReason,
+                tool_calls: result.toolCalls,
+                cost,
+            };
+            console.log(JSON.stringify(payload, null, 2));
+        }
+        return { response: responseText };
+    }
+    catch (err) {
+        clearToolTimer();
+        spinner.stop();
+        throw err;
+    }
+}
+async function handleSlashCommand(runtime, commandLine, setLastRawPrompt) {
+    const [command, ...rest] = commandLine.trim().split(/\s+/);
+    const argText = rest.join(" ").trim();
+    switch (command) {
+        case "/help":
+            printHelp();
+            return { handled: true, shouldExit: false };
+        case "/exit":
+            return { handled: true, shouldExit: true };
+        case "/clear":
+            console.clear();
+            return { handled: true, shouldExit: false };
+        case "/tools":
+            printTools();
+            return { handled: true, shouldExit: false };
+        case "/permissions":
+            console.log(`Current permission mode: ${runtime.agent.getPermissionMode()}`);
+            return { handled: true, shouldExit: false };
+        case "/verbose": {
+            const next = !runtime.agent.isVerboseTools();
+            runtime.agent.setVerboseTools(next);
+            console.log(`Verbose tool output: ${next ? "ON" : "OFF"}`);
+            await persistSnapshot(runtime);
+            return { handled: true, shouldExit: false };
+        }
+        case "/cost": {
+            const summary = runtime.context.getCostSummary();
+            console.log(`${chalk.dim("input")}: ${summary.inputTokens.toLocaleString()}  ${chalk.dim("output")}: ${summary.outputTokens.toLocaleString()}  ${chalk.dim("total")}: ${summary.totalTokens.toLocaleString()}  ${chalk.dim("cost")}: ${formatUsd(summary.totalCostUsd)}`);
+            return { handled: true, shouldExit: false };
+        }
+        case "/compact": {
+            const summary = await runtime.agent.compactHistory();
+            console.log(renderMarkdown(summary).trimEnd());
+            await persistSnapshot(runtime);
+            return { handled: true, shouldExit: false };
+        }
+        case "/models": {
+            const models = await runtime.agent.listModels();
+            console.log(formatModels(models));
+            return { handled: true, shouldExit: false };
+        }
+        case "/undo": {
+            const undone = runtime.agent.undoLastTurn();
+            if (undone) {
+                setLastRawPrompt(undone);
+                console.log("Removed last user+assistant turn.");
+                await persistSnapshot(runtime);
+            }
+            else {
+                console.log("Nothing to undo.");
+            }
+            return { handled: true, shouldExit: false };
+        }
+        case "/retry":
+            return { handled: false, shouldExit: false };
+        case "/save": {
+            const name = argText || `session-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+            const location = await runtime.sessions.saveNamed(name, runtime.agent.exportState(runtime.context.serializeState()));
+            console.log(`Saved session as \"${name}\" -> ${location}`);
+            return { handled: true, shouldExit: false };
+        }
+        case "/load": {
+            if (!argText) {
+                const names = await runtime.sessions.listNamed();
+                if (names.length === 0) {
+                    console.log("No named sessions found.");
+                }
+                else {
+                    console.log(`Named sessions: ${names.join(", ")}`);
+                }
+                return { handled: true, shouldExit: false };
+            }
+            const loaded = await runtime.sessions.loadNamed(argText);
+            if (!loaded) {
+                console.log(`No named session found: ${argText}`);
+                return { handled: true, shouldExit: false };
+            }
+            await restoreSnapshot(runtime, loaded);
+            setLastRawPrompt(loaded.lastUserInput);
+            console.log(`Loaded session \"${argText}\".`);
+            await persistSnapshot(runtime);
+            return { handled: true, shouldExit: false };
+        }
+        case "/cd": {
+            if (!argText) {
+                console.log(process.cwd());
+                return { handled: true, shouldExit: false };
+            }
+            const resolved = await resolveProtectedPath(argText);
+            const stat = await fs.stat(resolved);
+            if (!stat.isDirectory()) {
+                console.log(`Not a directory: ${resolved}`);
+                return { handled: true, shouldExit: false };
+            }
+            process.chdir(path.resolve(resolved));
+            console.log(`Working directory: ${process.cwd()}`);
+            await persistSnapshot(runtime);
+            return { handled: true, shouldExit: false };
+        }
+        case "/lint": {
+            const targetPath = argText || getRuntimeConfig().workspaceRoot;
+            const spinner = ora({ text: "Running linter...", color: "cyan" }).start();
+            try {
+                const result = await run_linter({ path: targetPath, linter: "auto", fix: false });
+                spinner.stop();
+                console.log(result);
+            }
+            catch (err) {
+                spinner.stop();
+                console.log(chalk.red(`Linter error: ${err instanceof Error ? err.message : String(err)}`));
+            }
+            return { handled: true, shouldExit: false };
+        }
+        case "/test": {
+            const targetPath = argText || undefined;
+            const spinner = ora({ text: "Running tests...", color: "cyan" }).start();
+            try {
+                const result = await run_tests({ path: targetPath, runner: "auto", bail: false });
+                spinner.stop();
+                console.log(result);
+            }
+            catch (err) {
+                spinner.stop();
+                console.log(chalk.red(`Test runner error: ${err instanceof Error ? err.message : String(err)}`));
+            }
+            return { handled: true, shouldExit: false };
+        }
+        case "/scan": {
+            const targetPath = argText || getRuntimeConfig().workspaceRoot;
+            const spinner = ora({ text: "Scanning for security issues...", color: "cyan" }).start();
+            try {
+                const result = await security_scan({ path: targetPath, include_low_severity: false });
+                spinner.stop();
+                console.log(result);
+            }
+            catch (err) {
+                spinner.stop();
+                console.log(chalk.red(`Scan error: ${err instanceof Error ? err.message : String(err)}`));
+            }
+            return { handled: true, shouldExit: false };
+        }
+        case "/memory": {
+            // /memory             — show both scopes
+            // /memory clear       — clear project memory
+            // /memory clear --global — clear global memory
+            if (!argText) {
+                const output = await showMemory(runtime.workspaceRoot);
+                console.log(output);
+                return { handled: true, shouldExit: false };
+            }
+            const memArgs = argText.split(/\s+/);
+            if (memArgs[0] === "clear") {
+                const scope = memArgs.includes("--global") ? "global" : "project";
+                await clearMemory(scope, runtime.workspaceRoot);
+                const fresh = await loadMemory(runtime.workspaceRoot);
+                runtime.agent.updateMemory(fresh);
+                console.log(`${scope === "global" ? "Global" : "Project"} memory cleared.`);
+                return { handled: true, shouldExit: false };
+            }
+            console.log(`Unknown /memory subcommand: ${argText}`);
+            return { handled: true, shouldExit: false };
+        }
+        case "/remember": {
+            // /remember <text>          — append to project memory
+            // /remember --global <text> — append to global memory
+            if (!argText) {
+                console.log("Usage: /remember <text>  or  /remember --global <text>");
+                return { handled: true, shouldExit: false };
+            }
+            let scope = "project";
+            let fact = argText;
+            if (fact.startsWith("--global")) {
+                scope = "global";
+                fact = fact.slice("--global".length).trim();
+            }
+            if (!fact) {
+                console.log("Nothing to remember — provide text after the flag.");
+                return { handled: true, shouldExit: false };
+            }
+            const savedPath = await appendMemory(fact, scope, runtime.workspaceRoot);
+            const fresh = await loadMemory(runtime.workspaceRoot);
+            runtime.agent.updateMemory(fresh);
+            console.log(chalk.green(`Remembered (${scope}): ${fact}`));
+            console.log(chalk.dim(`  → ${savedPath}`));
+            return { handled: true, shouldExit: false };
+        }
+        case "/review": {
+            const targetPath = argText || process.cwd();
+            const reviewPrompt = [
+                `Please perform a thorough code review of: ${targetPath}`,
+                "",
+                "Structure your review with these sections:",
+                "1. **Summary** — what the code does",
+                "2. **Critical Issues** — bugs, security flaws, data loss risks (severity: critical)",
+                "3. **High Issues** — performance, correctness, API misuse (severity: high)",
+                "4. **Medium Issues** — code quality, maintainability, missing error handling (severity: medium)",
+                "5. **Suggestions** — style, naming, refactoring opportunities",
+                "6. **Verdict** — overall assessment (Approve / Request Changes / Needs Major Rework)",
+                "",
+                "For each issue provide: file:line location, description, and suggested fix.",
+                "Use read_file and search_files tools to explore the code before reviewing.",
+            ].join("\n");
+            const reviewController = new AbortController();
+            try {
+                await executeTurn(runtime, reviewPrompt, reviewController.signal, "text", true);
+            }
+            catch (err) {
+                if (!(err instanceof Error && err.name === "TurnCancelledError")) {
+                    console.log(chalk.red(`Review error: ${err instanceof Error ? err.message : String(err)}`));
+                }
+            }
+            return { handled: true, shouldExit: false };
+        }
+        default:
+            return { handled: false, shouldExit: false };
+    }
+}
+async function runNonInteractive(runtime, options) {
+    let promptText = options.prompt ?? "";
+    if (!promptText) {
+        promptText = (await readAllStdin()).trim();
+    }
+    if (!promptText) {
+        throw new Error("No prompt provided. Use --prompt or pipe input.");
+    }
+    const controller = new AbortController();
+    await executeTurn(runtime, promptText, controller.signal, options.outputFormat, false);
+}
+async function runInteractive(runtime, options) {
+    printBanner(runtime, options.permissions);
+    const health = await checkRouterHealth();
+    if (!health.ok) {
+        console.log(chalk.yellow(`Warning: ${health.message} — check LLM_ROUTER_BASE_URL before running requests.`));
+        console.log();
+    }
+    const replInput = new ReplInput(runtime.paths.historyFile, runtime.config.historyLimit);
+    await replInput.init();
+    let activeTurnController = null;
+    let lastRawPrompt = runtime.agent.getLastUserInput();
+    process.on("SIGINT", () => {
+        if (activeTurnController && !activeTurnController.signal.aborted) {
+            activeTurnController.abort();
+            console.log(chalk.yellow("\nTurn cancelled. Type a new message."));
+            return;
+        }
+        replInput
+            .close()
+            .catch(() => {
+            // ignore
+        })
+            .finally(() => {
+            console.log(chalk.yellow("\nGoodbye!"));
+            process.exit(0);
+        });
+    });
+    while (true) {
+        const userInput = await replInput.prompt();
+        const trimmed = userInput.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed.startsWith("/")) {
+            const commandResult = await handleSlashCommand(runtime, trimmed, (value) => {
+                lastRawPrompt = value;
+            });
+            if (commandResult.handled) {
+                if (commandResult.shouldExit)
+                    break;
+                continue;
+            }
+            if (trimmed === "/retry") {
+                if (!lastRawPrompt) {
+                    console.log("No previous prompt to retry.");
+                    continue;
+                }
+            }
+            else {
+                console.log(`Unknown command: ${trimmed}`);
+                continue;
+            }
+        }
+        const rawPrompt = trimmed === "/retry" ? lastRawPrompt ?? "" : userInput;
+        if (!rawPrompt.trim()) {
+            console.log("No previous prompt to retry.");
+            continue;
+        }
+        lastRawPrompt = rawPrompt;
+        activeTurnController = new AbortController();
+        try {
+            await executeTurn(runtime, rawPrompt, activeTurnController.signal, "text", true);
+        }
+        catch (err) {
+            if (err instanceof TurnCancelledError) {
+                // already messaged by SIGINT handler
+            }
+            else {
+                const message = err instanceof Error ? err.message : String(err);
+                console.log(chalk.red(`Error: ${message}`));
+            }
+        }
+        finally {
+            activeTurnController = null;
+        }
+        console.log();
+    }
+    await replInput.close();
+}
+// ── First-run setup wizard ────────────────────────────────────────────────────
+async function runFirstTimeSetup() {
+    const { confirm, input, select } = await import("@inquirer/prompts");
+    console.log(chalk.bold.cyan("\n  Welcome to LLM-Router CLI Agent!\n"));
+    console.log(chalk.dim("  No connection configured. Let's get you set up.\n"));
+    const routerUrl = await input({
+        message: "Router URL:",
+        default: "https://api.llm-router.dev",
+        validate: (v) => {
+            try {
+                new URL(v);
+                return true;
+            }
+            catch {
+                return "Enter a valid URL (e.g. https://api.llm-router.dev)";
+            }
+        },
+    });
+    const method = await select({
+        message: "How would you like to authenticate?",
+        choices: [
+            { name: "Log in with browser (Google / GitHub)", value: "browser" },
+            { name: "Paste an API key manually", value: "key" },
+        ],
+    });
+    if (method === "browser") {
+        await runLogin({ routerUrl });
+    }
+    else {
+        const apiKey = await input({
+            message: "API key:",
+            validate: (v) => v.startsWith("llr_prod_sk_") ? true : "Key must start with llr_prod_sk_",
+        });
+        const { saveCredentials } = await import("./auth.js");
+        await saveCredentials({
+            apiKey,
+            email: "",
+            tenantId: "",
+            routerUrl,
+            authenticatedAt: new Date().toISOString(),
+        });
+        process.env.LLM_ROUTER_BASE_URL = routerUrl;
+        process.env.LLM_ROUTER_API_KEY = apiKey;
+        console.log(chalk.green("\n✓ API key saved.\n"));
+    }
+    return true;
+}
+// ── Commander program ─────────────────────────────────────────────────────────
+const program = new Command();
+program
+    .name("llm-agent")
+    .description("Terminal-based AI agent powered by LLM-Router")
+    .version("2.0.0")
+    .option("-m, --model <model>", "Override the model to use")
+    .option("-u, --url <url>", "Override the LLM Router base URL")
+    .option("-p, --permissions <mode>", "Permission mode: safe|standard|yolo", "standard")
+    .option("--prompt <text>", "Run one non-interactive prompt and exit")
+    .option("--output-format <format>", "Output format for non-interactive mode: text|json", "text")
+    .option("--resume <sessionId>", "Resume a prior session by session ID")
+    .option("--local", "Bypass router — connect directly using OPENAI_API_KEY / ANTHROPIC_API_KEY")
+    .action(async (options) => {
+    if (!isPermissionMode(options.permissions)) {
+        console.error(chalk.red(`Invalid permission mode \"${options.permissions}\". Use one of: ${PERMISSION_MODES.join(", ")}`));
+        process.exit(1);
+    }
+    if (!isOutputFormat(options.outputFormat)) {
+        console.error(chalk.red(`Invalid output format \"${options.outputFormat}\". Use text or json.`));
+        process.exit(1);
+    }
+    // --local mode: bypass router, use provider key directly
+    if (options.local) {
+        const directKey = process.env.OPENAI_API_KEY ||
+            process.env.ANTHROPIC_API_KEY ||
+            process.env.GEMINI_API_KEY;
+        const directUrl = process.env.OPENAI_API_KEY
+            ? "https://api.openai.com/v1"
+            : process.env.ANTHROPIC_API_KEY
+                ? "https://api.anthropic.com/v1"
+                : "https://generativelanguage.googleapis.com/v1beta/openai";
+        if (!directKey) {
+            console.error(chalk.red("--local requires OPENAI_API_KEY, ANTHROPIC_API_KEY, or GEMINI_API_KEY to be set."));
+            process.exit(1);
+        }
+        process.env.LLM_ROUTER_BASE_URL = directUrl;
+        process.env.LLM_ROUTER_API_KEY = directKey;
+        if (!options.model)
+            process.env.LLM_ROUTER_MODEL = process.env.OPENAI_API_KEY ? "gpt-4o" : "claude-opus-4-6";
+    }
+    else {
+        // Apply explicit overrides first, then fall back to credentials file
+        if (options.url)
+            process.env.LLM_ROUTER_BASE_URL = options.url;
+        const conn = await resolveConnectionFromEnvOrCreds();
+        if (!conn) {
+            // No connection config at all — run first-time setup
+            if (!processStdin.isTTY) {
+                console.error(chalk.red("No credentials found. Run `llm-agent login` to authenticate first."));
+                process.exit(1);
+            }
+            await runFirstTimeSetup();
+        }
+    }
+    if (options.model)
+        process.env.LLM_ROUTER_MODEL = options.model;
+    process.env.LLM_AGENT_PERMISSION_MODE = options.permissions;
+    const runtime = await bootstrapRuntime(options);
+    await persistSnapshot(runtime);
+    const nonInteractive = Boolean(options.prompt) || !processStdin.isTTY;
+    if (nonInteractive) {
+        await runNonInteractive(runtime, options);
+        return;
+    }
+    await runInteractive(runtime, options);
+});
+// ── llm-agent login ───────────────────────────────────────────────────────────
+program
+    .command("login")
+    .description("Authenticate with your LLM-Router account")
+    .option("-u, --url <url>", "Router base URL", "")
+    .action(async (opts) => {
+    let routerUrl = opts.url || process.env.LLM_ROUTER_BASE_URL || "";
+    if (!routerUrl) {
+        const creds = await loadCredentials();
+        routerUrl = creds?.routerUrl ?? "";
+    }
+    if (!routerUrl) {
+        const { input } = await import("@inquirer/prompts");
+        routerUrl = await input({
+            message: "Router URL:",
+            default: "https://api.llm-router.dev",
+            validate: (v) => {
+                try {
+                    new URL(v);
+                    return true;
+                }
+                catch {
+                    return "Enter a valid URL";
+                }
+            },
+        });
+    }
+    try {
+        await runLogin({ routerUrl });
+    }
+    catch (err) {
+        console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+    }
+});
+// ── llm-agent logout ──────────────────────────────────────────────────────────
+program
+    .command("logout")
+    .description("Revoke CLI credentials and sign out")
+    .action(async () => {
+    try {
+        await runLogout();
+    }
+    catch (err) {
+        console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+    }
+});
+// ── llm-agent whoami ──────────────────────────────────────────────────────────
+program
+    .command("whoami")
+    .description("Show the currently authenticated account and router")
+    .action(async () => {
+    await runWhoami();
+});
+// ── llm-agent update ──────────────────────────────────────────────────────────
+program
+    .command("update")
+    .description("Update llm-agent to the latest version")
+    .action(async () => {
+    const { exec: execCb } = await import("child_process");
+    const { promisify: prom } = await import("util");
+    const execP = prom(execCb);
+    const spinner = ora("Checking for updates…").start();
+    // Detect which package manager installed us
+    let installCmd = "npm install -g llm-agent-cli@latest";
+    try {
+        await execP("which pnpm");
+        installCmd = "pnpm add -g llm-agent-cli@latest";
+    }
+    catch {
+        try {
+            await execP("which yarn");
+            installCmd = "yarn global add llm-agent-cli@latest";
+        }
+        catch {
+            // default npm
+        }
+    }
+    try {
+        const { stdout } = await execP(`npm show llm-agent-cli version`);
+        const latest = stdout.trim();
+        spinner.succeed(`Latest version: ${latest}`);
+        console.log(chalk.dim(`Running: ${installCmd}`));
+        const updateSpinner = ora("Installing update…").start();
+        await execP(installCmd);
+        updateSpinner.succeed("Updated successfully. Restart your terminal to use the new version.");
+    }
+    catch (err) {
+        spinner.fail("Update failed");
+        console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+    }
+});
+// ── llm-agent config ──────────────────────────────────────────────────────────
+program
+    .command("config")
+    .description("Show or edit CLI configuration")
+    .option("--show", "Print current config and credentials (hides key)")
+    .action(async (opts) => {
+    const creds = await loadCredentials();
+    const paths = getAgentPaths();
+    const config = await loadConfig(paths);
+    if (opts.show || true) {
+        console.log(chalk.bold("\nConnection"));
+        if (creds) {
+            console.log(`  Router:    ${creds.routerUrl}`);
+            console.log(`  Email:     ${creds.email || "(not set)"}`);
+            console.log(`  API Key:   ${creds.apiKey.slice(0, 16)}…`);
+            console.log(`  Auth date: ${new Date(creds.authenticatedAt).toLocaleString()}`);
+        }
+        else if (process.env.LLM_ROUTER_BASE_URL) {
+            console.log(`  Router:    ${process.env.LLM_ROUTER_BASE_URL} (from env)`);
+            console.log(`  API Key:   (from env)`);
+        }
+        else {
+            console.log(chalk.yellow("  Not logged in. Run `llm-agent login`."));
+        }
+        console.log(chalk.bold("\nAgent config"));
+        console.log(`  Context window:  ${config.contextWindowTokens.toLocaleString()} tokens`);
+        console.log(`  Max read bytes:  ${(config.maxReadBytes / 1024).toFixed(0)} KB`);
+        console.log(`  Shell timeout:   ${config.shellTimeoutMs / 1000}s`);
+        console.log(`  History limit:   ${config.historyLimit} entries`);
+        console.log(chalk.bold("\nPaths"));
+        console.log(`  Home:     ${paths.homeDir}`);
+        console.log(`  Config:   ${paths.configFile}`);
+        console.log(`  Sessions: ${paths.sessionsDir}`);
+        console.log(`  Audit:    ${paths.auditFile}`);
+        console.log();
+    }
+});
+program.parseAsync().catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(chalk.red(message));
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map