openplanter 0.1.0

package/dist/tui.js

@@ -0,0 +1,699 @@
+/**
+ * Terminal UI – migrated from agent/tui.py.
+ *
+ * Provides the interactive Rich-style REPL with splash screen, thinking
+ * spinner, tool-call tree display, and slash command handling.
+ */
+import * as readline from "node:readline";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import figlet from "figlet";
+import chalk from "chalk";
+import { _MODEL_CONTEXT_WINDOWS, _DEFAULT_CONTEXT_WINDOW } from "./engine.js";
+import { EchoFallbackModel, ModelError } from "./model.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+export const SLASH_COMMANDS = [
+    "/quit", "/exit", "/help", "/status", "/clear", "/model", "/reasoning",
+];
+export const HELP_LINES = [
+    "Commands:",
+    "  /model              Show current model, provider, aliases",
+    "  /model <name>       Switch model (e.g. /model opus, /model gpt5)",
+    "  /model <name> --save  Switch and persist as default",
+    "  /model list [all]   List available models",
+    "  /reasoning [low|medium|high|off]  Change reasoning effort",
+    "  /status  /clear  /quit  /exit  /help",
+];
+export const MODEL_ALIASES = {
+    opus: "claude-opus-4-6",
+    "opus4.6": "claude-opus-4-6",
+    sonnet: "claude-sonnet-4-5-20250929",
+    "sonnet4.5": "claude-sonnet-4-5-20250929",
+    haiku: "claude-haiku-4-5-20251001",
+    "haiku4.5": "claude-haiku-4-5-20251001",
+    gpt5: "gpt-5.2",
+    "gpt5.2": "gpt-5.2",
+    gpt4: "gpt-4.1",
+    "gpt4.1": "gpt-4.1",
+    gpt4o: "gpt-4o",
+    o4: "o4-mini",
+    "o4-mini": "o4-mini",
+    o3: "o3-mini",
+    "o3-mini": "o3-mini",
+    cerebras: "qwen-3-235b-a22b-instruct-2507",
+    qwen235b: "qwen-3-235b-a22b-instruct-2507",
+    oss120b: "gpt-oss-120b",
+    grok: "grok-4-1-fast-reasoning",
+    grok3mini: "grok-3-mini",
+    grok4: "grok-4-0709",
+    grok4fast: "grok-4-fast-reasoning",
+    grok41fast: "grok-4-1-fast-reasoning",
+};
+// ---------------------------------------------------------------------------
+// Formatting helpers
+// ---------------------------------------------------------------------------
+export function formatTokenCount(n) {
+    if (n < 1000)
+        return String(n);
+    if (n < 10_000)
+        return `${(n / 1000).toFixed(1)}k`;
+    if (n < 1_000_000)
+        return `${Math.round(n / 1000)}k`;
+    return `${(n / 1_000_000).toFixed(1)}M`;
+}
+export function formatSessionTokens(sessionTokens) {
+    let totalIn = 0;
+    let totalOut = 0;
+    for (const v of Object.values(sessionTokens)) {
+        totalIn += v.input;
+        totalOut += v.output;
+    }
+    if (totalIn === 0 && totalOut === 0)
+        return "";
+    return `${formatTokenCount(totalIn)} in / ${formatTokenCount(totalOut)} out`;
+}
+export function getModelDisplayName(engine) {
+    const model = engine.model;
+    if (model instanceof EchoFallbackModel)
+        return "(no model)";
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return model.model ?? "(unknown)";
+}
+// ---------------------------------------------------------------------------
+// Event trace helpers
+// ---------------------------------------------------------------------------
+const _RE_PREFIX = /^\[d(\d+)(?:\/s(\d+))?\]\s*/;
+const _RE_CALLING = /calling model/;
+const _RE_SUBTASK = />> entering subtask/;
+const _RE_EXECUTE = />> executing leaf/;
+const _RE_ERROR = /model error:/i;
+const _EVENT_MAX_CHARS = 300;
+export function _clip_event(text) {
+    const firstLine = text.split("\n", 1)[0];
+    if (firstLine.length > _EVENT_MAX_CHARS) {
+        return firstLine.slice(0, _EVENT_MAX_CHARS) + "...";
+    }
+    const rest = text.slice(firstLine.length + 1);
+    if (rest) {
+        const extraLines = (rest.match(/\n/g) ?? []).length + 1;
+        return firstLine + `  (+${extraLines} lines)`;
+    }
+    return firstLine;
+}
+const _KEY_ARGS = {
+    read_file: "path",
+    write_file: "path",
+    edit_file: "path",
+    hashline_edit: "path",
+    apply_patch: "patch",
+    run_shell: "command",
+    run_shell_bg: "command",
+    web_search: "query",
+    fetch_url: "urls",
+    search_files: "query",
+    list_files: "glob",
+    repo_map: "glob",
+    subtask: "objective",
+    execute: "objective",
+    think: "note",
+    check_shell_bg: "job_id",
+    kill_shell_bg: "job_id",
+};
+// ---------------------------------------------------------------------------
+// Helper functions
+// ---------------------------------------------------------------------------
+function _extractKeyArg(name, args) {
+    const key = _KEY_ARGS[name];
+    if (!key) {
+        for (const v of Object.values(args)) {
+            if (typeof v === "string" && v.trim()) {
+                const s = v.trim();
+                return s.length > 60 ? s.slice(0, 57) + "..." : s;
+            }
+        }
+        return "";
+    }
+    let val = args[key];
+    if (Array.isArray(val)) {
+        val = val.slice(0, 3).map(String).join(", ");
+    }
+    const s = String(val ?? "").trim();
+    return s.length > 60 ? s.slice(0, 57) + "..." : s;
+}
+function _apiKeyForProvider(cfg, provider) {
+    const map = {
+        openai: cfg.openaiApiKey,
+        anthropic: cfg.anthropicApiKey,
+        openrouter: cfg.openrouterApiKey,
+        cerebras: cfg.cerebrasApiKey,
+        grok: cfg.grokApiKey,
+    };
+    return map[provider] ?? null;
+}
+function _availableProviders(cfg) {
+    const providers = [];
+    if (cfg.openaiApiKey)
+        providers.push("openai");
+    if (cfg.anthropicApiKey)
+        providers.push("anthropic");
+    if (cfg.openrouterApiKey)
+        providers.push("openrouter");
+    if (cfg.cerebrasApiKey)
+        providers.push("cerebras");
+    if (cfg.grokApiKey)
+        providers.push("grok");
+    return providers;
+}
+function _getModeLabel(cfg) {
+    return cfg.recursive ? "recursive" : "flat";
+}
+// ---------------------------------------------------------------------------
+// Splash art
+// ---------------------------------------------------------------------------
+const _PLANT_LEFT = [
+    " .oOo.  ",
+    "oO.|.Oo ",
+    "Oo.|.oO ",
+    "  .|.   ",
+    "[=====] ",
+    " \\___/  ",
+];
+const _PLANT_RIGHT = [
+    "  .oOo. ",
+    " oO.|.Oo",
+    " Oo.|.oO",
+    "   .|.  ",
+    " [=====]",
+    "  \\___/ ",
+];
+function _buildSplash() {
+    let art;
+    try {
+        art = figlet.textSync("OpenPlanter", { font: "Standard" }).trimEnd();
+    }
+    catch {
+        art = "   OpenPlanter";
+    }
+    const lines = art.split("\n");
+    const minIndent = Math.min(...lines.filter((l) => l.trim()).map((l) => l.length - l.trimStart().length));
+    const stripped = lines.map((l) => l.slice(minIndent));
+    const maxW = Math.max(...stripped.map((l) => l.length));
+    const padded = stripped.map((l) => l.padEnd(maxW));
+    const n = padded.length;
+    const pwL = Math.max(..._PLANT_LEFT.map((l) => l.length));
+    const pwR = Math.max(..._PLANT_RIGHT.map((l) => l.length));
+    const left = n > _PLANT_LEFT.length
+        ? [...Array(n - _PLANT_LEFT.length).fill(" ".repeat(pwL)), ..._PLANT_LEFT]
+        : _PLANT_LEFT.slice(-n);
+    const right = n > _PLANT_RIGHT.length
+        ? [...Array(n - _PLANT_RIGHT.length).fill(" ".repeat(pwR)), ..._PLANT_RIGHT]
+        : _PLANT_RIGHT.slice(-n);
+    return padded.map((line, i) => `${left[i]}  ${line}  ${right[i]}`).join("\n");
+}
+export const SPLASH_ART = _buildSplash();
+// ---------------------------------------------------------------------------
+// Slash command: /model
+// ---------------------------------------------------------------------------
+export async function handleModelCommand(args, ctx) {
+    const { _fetchModelsForProvider, buildEngine, inferProviderForModel } = await import("./builder.js");
+    const parts = args.trim().split(/\s+/);
+    if (!parts[0]) {
+        const modelName = getModelDisplayName(ctx.runtime.engine);
+        const effort = ctx.cfg.reasoningEffort || "(off)";
+        const avail = _availableProviders(ctx.cfg).join(", ") || "none";
+        return [
+            `Provider: ${ctx.cfg.provider} | Model: ${modelName} | Reasoning: ${effort}`,
+            `Configured providers: ${avail}`,
+            `Aliases: ${Object.keys(MODEL_ALIASES).sort().join(", ")}`,
+        ];
+    }
+    if (parts[0] === "list") {
+        const listTarget = parts[1] ?? null;
+        let providers;
+        if (listTarget === "all") {
+            providers = _availableProviders(ctx.cfg);
+        }
+        else if (listTarget &&
+            ["openai", "anthropic", "openrouter", "cerebras", "grok"].includes(listTarget)) {
+            providers = [listTarget];
+        }
+        else {
+            providers = [ctx.cfg.provider];
+        }
+        const lines = [];
+        for (const provider of providers) {
+            try {
+                const models = await _fetchModelsForProvider(ctx.cfg, provider);
+                lines.push(`${provider}: ${models.length} models`);
+                for (const row of models.slice(0, 15)) {
+                    lines.push(`  ${row["id"]}`);
+                }
+                if (models.length > 15) {
+                    lines.push(`  ...and ${models.length - 15} more`);
+                }
+            }
+            catch (exc) {
+                lines.push(`${provider}: skipped (${exc})`);
+            }
+        }
+        return lines;
+    }
+    const rawModel = parts[0];
+    const newModel = MODEL_ALIASES[rawModel.toLowerCase()] ?? rawModel;
+    const save = parts.includes("--save");
+    const inferred = inferProviderForModel(newModel);
+    let providerSwitched = false;
+    if (inferred && inferred !== ctx.cfg.provider && ctx.cfg.provider !== "openrouter") {
+        const key = _apiKeyForProvider(ctx.cfg, inferred);
+        if (!key) {
+            return [
+                `Model '${newModel}' requires provider '${inferred}', but no API key is configured for it.`,
+            ];
+        }
+        ctx.cfg.provider = inferred;
+        providerSwitched = true;
+    }
+    ctx.cfg.model = newModel;
+    let newEngine;
+    try {
+        newEngine = buildEngine(ctx.cfg);
+    }
+    catch (exc) {
+        if (exc instanceof ModelError) {
+            return [`Failed to switch model: ${exc.message}`];
+        }
+        throw exc;
+    }
+    ctx.runtime.engine = newEngine;
+    const aliasNote = rawModel.toLowerCase() in MODEL_ALIASES ? ` (alias: ${rawModel})` : "";
+    const lines = [`Switched to model: ${newModel}${aliasNote}`];
+    if (providerSwitched) {
+        lines.push(`Provider auto-switched to: ${ctx.cfg.provider}`);
+    }
+    if (save) {
+        const settings = ctx.settingsStore.load();
+        const provider = ctx.cfg.provider;
+        if (provider === "openai")
+            settings.defaultModelOpenai = newModel;
+        else if (provider === "anthropic")
+            settings.defaultModelAnthropic = newModel;
+        else if (provider === "openrouter")
+            settings.defaultModelOpenrouter = newModel;
+        else if (provider === "cerebras")
+            settings.defaultModelCerebras = newModel;
+        else if (provider === "grok")
+            settings.defaultModelGrok = newModel;
+        else
+            settings.defaultModel = newModel;
+        ctx.settingsStore.save(settings);
+        lines.push("Saved as workspace default.");
+    }
+    return lines;
+}
+// ---------------------------------------------------------------------------
+// Slash command: /reasoning
+// ---------------------------------------------------------------------------
+export async function handleReasoningCommand(args, ctx) {
+    const { buildEngine } = await import("./builder.js");
+    const parts = args.trim().split(/\s+/);
+    if (!parts[0]) {
+        const effort = ctx.cfg.reasoningEffort || "(off)";
+        return [
+            `Current reasoning effort: ${effort}`,
+            "Usage: /reasoning <low|medium|high|off> [--save]",
+        ];
+    }
+    const value = parts[0].toLowerCase();
+    const save = parts.includes("--save");
+    if (["off", "none", "disable", "disabled"].includes(value)) {
+        ctx.cfg.reasoningEffort = null;
+    }
+    else if (["low", "medium", "high"].includes(value)) {
+        ctx.cfg.reasoningEffort = value;
+    }
+    else {
+        return [`Invalid effort '${value}'. Use: low, medium, high, off`];
+    }
+    try {
+        const newEngine = buildEngine(ctx.cfg);
+        ctx.runtime.engine = newEngine;
+    }
+    catch (exc) {
+        if (exc instanceof ModelError) {
+            return [`Failed to apply reasoning change: ${exc.message}`];
+        }
+        throw exc;
+    }
+    const display = ctx.cfg.reasoningEffort || "off";
+    const lines = [`Reasoning effort set to: ${display}`];
+    if (save) {
+        const settings = ctx.settingsStore.load();
+        settings.defaultReasoningEffort = ctx.cfg.reasoningEffort;
+        ctx.settingsStore.save(settings);
+        lines.push("Saved as workspace default.");
+    }
+    return lines;
+}
+// ---------------------------------------------------------------------------
+// Slash command dispatch
+// ---------------------------------------------------------------------------
+export async function dispatchSlashCommand(command, ctx, emit) {
+    if (command === "/quit" || command === "/exit")
+        return "quit";
+    if (command === "/help") {
+        for (const ln of HELP_LINES)
+            emit(ln);
+        return "handled";
+    }
+    if (command === "/status") {
+        const modelName = getModelDisplayName(ctx.runtime.engine);
+        const effort = ctx.cfg.reasoningEffort || "(off)";
+        const mode = _getModeLabel(ctx.cfg);
+        emit(`Provider: ${ctx.cfg.provider} | Model: ${modelName} | Reasoning: ${effort} | Mode: ${mode}`);
+        const tokens = ctx.runtime.engine.sessionTokens;
+        if (Object.keys(tokens).length > 0) {
+            for (const [mname, counts] of Object.entries(tokens)) {
+                emit(`  ${mname}: ${formatTokenCount(counts.input)} in / ${formatTokenCount(counts.output)} out`);
+            }
+        }
+        else {
+            emit("  Tokens: (none yet)");
+        }
+        return "handled";
+    }
+    if (command === "/clear")
+        return "clear";
+    if (command.startsWith("/model")) {
+        const cmdArgs = command.slice("/model".length).trim();
+        const lines = await handleModelCommand(cmdArgs, ctx);
+        for (const line of lines)
+            emit(line);
+        return "handled";
+    }
+    if (command.startsWith("/reasoning")) {
+        const cmdArgs = command.slice("/reasoning".length).trim();
+        const lines = await handleReasoningCommand(cmdArgs, ctx);
+        for (const line of lines)
+            emit(line);
+        return "handled";
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Thinking display
+// ---------------------------------------------------------------------------
+const _THINKING_TAIL_LINES = 6;
+const _THINKING_MAX_LINE_WIDTH = 80;
+class ThinkingDisplay {
+    _buf = "";
+    _startTime = 0;
+    _active = false;
+    _interval = null;
+    start() {
+        if (this._active)
+            return;
+        this._buf = "";
+        this._startTime = performance.now();
+        this._active = true;
+        this._interval = setInterval(() => this._render(), 250);
+    }
+    stop() {
+        if (!this._active)
+            return;
+        this._active = false;
+        if (this._interval !== null) {
+            clearInterval(this._interval);
+            this._interval = null;
+        }
+        process.stdout.write("\r\x1b[K");
+    }
+    feed(deltaType, text) {
+        if (!this._active || deltaType !== "thinking")
+            return;
+        this._buf += text;
+        this._render();
+    }
+    _render() {
+        if (!this._active)
+            return;
+        const elapsed = (performance.now() - this._startTime) / 1000;
+        const header = chalk.bold.cyan("Thinking...") + chalk.dim(` (${elapsed.toFixed(1)}s)`);
+        if (!this._buf) {
+            process.stdout.write(`\r\x1b[K  ${header}`);
+            return;
+        }
+        const lines = this._buf.split("\n");
+        const tail = lines.slice(-_THINKING_TAIL_LINES);
+        const clipped = tail.map((ln) => ln.length > _THINKING_MAX_LINE_WIDTH
+            ? ln.slice(0, _THINKING_MAX_LINE_WIDTH - 3) + "..."
+            : ln);
+        process.stdout.write(`\r\x1b[K  ${header}  ${chalk.dim.italic(clipped[clipped.length - 1] ?? "")}`);
+    }
+    get active() {
+        return this._active;
+    }
+}
+// ---------------------------------------------------------------------------
+// RichREPL
+// ---------------------------------------------------------------------------
+export class RichREPL {
+    ctx;
+    startupInfo;
+    currentStep = null;
+    thinking;
+    censorFn = null;
+    historyPath;
+    history = [];
+    constructor(ctx, startupInfo) {
+        this.ctx = ctx;
+        this.startupInfo = startupInfo ?? {};
+        this.thinking = new ThinkingDisplay();
+        if (ctx.cfg.demo) {
+            // Lazy-load demo censor
+            const { DemoCensor } = require("./demo.js");
+            const censor = new DemoCensor(ctx.cfg.workspace);
+            this.censorFn = censor.censorText.bind(censor);
+        }
+        const historyDir = path.join(os.homedir(), ".openplanter");
+        fs.mkdirSync(historyDir, { recursive: true });
+        this.historyPath = path.join(historyDir, "repl_history");
+        this._loadHistory();
+    }
+    _loadHistory() {
+        try {
+            if (fs.existsSync(this.historyPath)) {
+                this.history = fs
+                    .readFileSync(this.historyPath, "utf-8")
+                    .split("\n")
+                    .filter((l) => l.trim());
+            }
+        }
+        catch {
+            this.history = [];
+        }
+    }
+    _saveHistory() {
+        try {
+            const last500 = this.history.slice(-500);
+            fs.writeFileSync(this.historyPath, last500.join("\n") + "\n", "utf-8");
+        }
+        catch {
+            // ignore
+        }
+    }
+    _print(text) {
+        const output = this.censorFn ? this.censorFn(text) : text;
+        console.log(output);
+    }
+    // -- Event callbacks ---
+    _onEvent = (msg) => {
+        const m = _RE_PREFIX.exec(msg);
+        const body = m ? msg.slice(m[0].length) : msg;
+        if (_RE_CALLING.test(body)) {
+            this._flushStep();
+            this.thinking.start();
+            return;
+        }
+        if (_RE_SUBTASK.test(body) || _RE_EXECUTE.test(body)) {
+            this._flushStep();
+            this.thinking.stop();
+            const label = body.replace(/>> (entering subtask|executing leaf):\s*/, "").trim();
+            console.log(chalk.dim(`--- ${label} ---`));
+            return;
+        }
+        if (_RE_ERROR.test(body)) {
+            this.thinking.stop();
+            const firstLine = msg.split("\n", 1)[0];
+            console.log(chalk.bold.red(firstLine.length > _EVENT_MAX_CHARS
+                ? firstLine.slice(0, _EVENT_MAX_CHARS) + "..."
+                : firstLine));
+        }
+    };
+    _onStep = (stepEvent) => {
+        const action = stepEvent.action;
+        if (!action || typeof action !== "object")
+            return;
+        const name = action.name;
+        if (name === "_model_turn") {
+            this.thinking.stop();
+            this.currentStep = {
+                depth: stepEvent.depth ?? 0,
+                step: stepEvent.step ?? 0,
+                maxSteps: this.ctx.cfg.maxStepsPerCall,
+                modelText: stepEvent.model_text ?? "",
+                modelElapsedSec: stepEvent.elapsed_sec ?? 0,
+                inputTokens: stepEvent.input_tokens ?? 0,
+                outputTokens: stepEvent.output_tokens ?? 0,
+                toolCalls: [],
+            };
+            return;
+        }
+        if (name === "final") {
+            this._flushStep();
+            return;
+        }
+        if (this.currentStep !== null) {
+            const keyArg = _extractKeyArg(name, (action.arguments ?? {}));
+            const elapsed = stepEvent.elapsed_sec ?? 0;
+            const obs = stepEvent.observation ?? "";
+            const isError = obs.startsWith("Tool ") && obs.includes("crashed");
+            this.currentStep.toolCalls.push({
+                name,
+                keyArg,
+                elapsedSec: elapsed,
+                isError,
+            });
+        }
+    };
+    _onContentDelta = (deltaType, text) => {
+        this.thinking.feed(deltaType, text);
+    };
+    // -- Step flushing ---
+    _flushStep() {
+        const step = this.currentStep;
+        if (step === null)
+            return;
+        this.currentStep = null;
+        const ts = new Date().toLocaleTimeString("en-US", { hour12: false });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const modelName = this.ctx.runtime.engine.model.model ?? "(unknown)";
+        const contextWindow = _MODEL_CONTEXT_WINDOWS[modelName] ?? _DEFAULT_CONTEXT_WINDOW;
+        const ctxStr = `${formatTokenCount(step.inputTokens)}/${formatTokenCount(contextWindow)}`;
+        const rightParts = [];
+        if (step.depth > 0)
+            rightParts.push(`depth ${step.depth}`);
+        if (step.maxSteps)
+            rightParts.push(`${step.step}/${step.maxSteps}`);
+        if (step.inputTokens || step.outputTokens) {
+            rightParts.push(`${formatTokenCount(step.inputTokens)}in/${formatTokenCount(step.outputTokens)}out`);
+        }
+        rightParts.push(`[${ctxStr}]`);
+        const right = rightParts.join(" | ");
+        console.log(chalk.cyan(`--- ${ts}  Step ${step.step}  ${chalk.dim(right)} ---`));
+        if (step.modelText) {
+            let preview = step.modelText.trim();
+            if (preview.length > 200)
+                preview = preview.slice(0, 197) + "...";
+            console.log(chalk.dim(`  (${step.modelElapsedSec.toFixed(1)}s) ${preview}`));
+        }
+        const n = step.toolCalls.length;
+        for (let i = 0; i < n; i++) {
+            const tc = step.toolCalls[i];
+            const isLast = i === n - 1;
+            const connector = isLast ? "\u2514\u2500" : "\u251c\u2500";
+            const nameStr = tc.isError ? chalk.bold.red(tc.name) : tc.name;
+            const argStr = tc.keyArg ? chalk.dim(`  "${tc.keyArg}"`) : "";
+            console.log(`  ${chalk.dim(connector)} ${nameStr}${argStr}  ${chalk.dim(`${tc.elapsedSec.toFixed(1)}s`)}`);
+        }
+    }
+    // -- Main REPL loop ---
+    async run() {
+        console.log(chalk.bold.cyan(SPLASH_ART));
+        if (Object.keys(this.startupInfo).length > 0) {
+            for (const [key, val] of Object.entries(this.startupInfo)) {
+                this._print(chalk.dim(`  ${key.padStart(10)}  ${val}`));
+            }
+            console.log();
+        }
+        console.log(chalk.dim("Type /help for commands, Ctrl+D to exit."));
+        console.log();
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: "you> ",
+            completer: (line) => {
+                if (line.startsWith("/") && !line.includes(" ")) {
+                    const hits = SLASH_COMMANDS.filter((c) => c.startsWith(line));
+                    return [hits.length > 0 ? hits : SLASH_COMMANDS, line];
+                }
+                return [[], line];
+            },
+        });
+        const askLine = () => {
+            return new Promise((resolve) => {
+                rl.question("you> ", (answer) => {
+                    if (answer === undefined) {
+                        resolve(null);
+                        return;
+                    }
+                    resolve(answer);
+                });
+            });
+        };
+        let running = true;
+        while (running) {
+            let userInput;
+            try {
+                userInput = await askLine();
+            }
+            catch {
+                break;
+            }
+            if (userInput === null)
+                break;
+            const trimmed = userInput.trim();
+            if (!trimmed)
+                continue;
+            this.history.push(trimmed);
+            this._saveHistory();
+            const result = await dispatchSlashCommand(trimmed, this.ctx, (line) => console.log(chalk.cyan(line)));
+            if (result === "quit") {
+                running = false;
+                break;
+            }
+            if (result === "clear") {
+                process.stdout.write("\x1b[2J\x1b[H");
+                continue;
+            }
+            if (result === "handled")
+                continue;
+            console.log();
+            const answer = await this.ctx.runtime.solve(trimmed, {
+                onEvent: this._onEvent,
+                onStep: this._onStep,
+                onContentDelta: this._onContentDelta,
+            });
+            this.thinking.stop();
+            this._flushStep();
+            console.log();
+            this._print(answer);
+            const tokenStr = formatSessionTokens(this.ctx.runtime.engine.sessionTokens);
+            if (tokenStr) {
+                console.log(chalk.dim(`  tokens: ${tokenStr}`));
+            }
+            console.log();
+        }
+        rl.close();
+    }
+}
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+export async function runRichRepl(ctx, startupInfo) {
+    const repl = new RichREPL(ctx, startupInfo);
+    await repl.run();
+}
+//# sourceMappingURL=tui.js.map