micro-models-agent 0.28.17 → 0.29.1

package/dist/cli/repl.js

@@ -1,56 +1,56 @@
 import * as readline from "readline";
 import { pc } from "../ui/colors";
 import { existsSync, readFileSync, writeFileSync } from "fs";
-import { join, dirname } from "path";
+import { join } from "path";
 import { homedir } from "os";
-import { fileURLToPath } from "url";
 import { Completer, SlashCommandProvider, SessionNameProvider, SubcommandProvider, SkillNameProvider, } from "./completer";
 import { Renderer } from "../ui/renderer";
 import { box } from "../ui/box";
+import { renderTable } from "../ui/table";
 import { t } from "../i18n/index";
-import { registerAllCommands } from "./repl-commands";
-function readVersion() {
-    const here = dirname(fileURLToPath(import.meta.url));
-    const candidates = [
-        join(here, "..", "..", "package.json"),
-        join(here, "..", "package.json"),
-    ];
-    for (const p of candidates) {
-        if (existsSync(p)) {
-            try {
-                const raw = JSON.parse(readFileSync(p, "utf8"));
-                if (raw.version)
-                    return raw.version;
-            }
-            catch {
-                // Broken package.json — fall through to the next candidate
-            }
-        }
-    }
-    return "0.0.0";
-}
-const version = readVersion();
-function formatContextBar(used, limit, compactions, quality) {
+import { runSetup } from "./setup";
+import { saveConfig } from "../config/config";
+import { getMessageText } from "../llm/provider";
+const COMMAND_GROUPS = {
+    help: "general",
+    exit: "general",
+    clear: "general",
+    run: "general",
+    image: "general",
+    config: "agent",
+    status: "agent",
+    reasoning: "agent",
+    provider: "agent",
+    model: "agent",
+    context: "agent",
+    reload: "agent",
+    wizard: "agent",
+    sessions: "session",
+    new: "session",
+    resume: "session",
+    rename: "session",
+    delete: "session",
+    skill: "skill",
+};
+function formatContextBar(used, limit) {
     const pct = Math.min(100, Math.round((used / limit) * 100));
     const barLen = 20;
     const filled = Math.round((pct / 100) * barLen);
     const bar = pc.green("█".repeat(filled)) + pc.dim("░".repeat(barLen - filled));
     const pctStr = pct >= 75 ? pc.yellow(`${pct}%`) : pc.dim(`${pct}%`);
-    let line = `  ${bar}  ${pctStr}  ${pc.dim(`(${used} / ${limit} tokens)`)}`;
-    if (compactions !== undefined) {
-        line += pc.dim(`  compactions: ${compactions}`);
-    }
-    if (quality !== undefined) {
-        const qColor = quality >= 70 ? pc.green : quality >= 40 ? pc.yellow : pc.red;
-        line += `  ${qColor(`quality: ${quality}%`)}`;
-    }
-    return line;
+    return `  ${bar}  ${pctStr}  ${pc.dim(`(${used} / ${limit} tokens)`)}`;
 }
 export class Repl {
+    rl;
+    commands = new Map();
     completer = new Completer();
     running = false;
     agentRunning = false;
-    inputLocked = false;
+    agent;
+    config;
+    sessionManager;
+    skillsModule;
+    pluginManager;
     historyPath;
     history = [];
     maxHistory = 1000;
@@ -60,25 +60,22 @@ export class Repl {
     baseDir;
     noAgentsMd;
     pendingClipboardImage = null;
-    rl;
-    agent;
-    config;
-    sessionManager;
-    skillsModule;
-    pluginManager;
-    logger;
-    constructor(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd, logger) {
+    constructor(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd) {
         this.agent = agent;
         this.config = config;
         this.sessionManager = sessionManager;
         this.skillsModule = skillsModule;
         this.pluginManager = pluginManager;
-        this.logger = logger;
         this.configDir = configDir || join(homedir(), ".mma");
         this.baseDir = baseDir || process.cwd();
         this.noAgentsMd = noAgentsMd === true;
         this.historyPath = join(homedir(), ".mma", "repl-history");
         this.loadHistory();
+        this.registerBuiltinCommands();
+        this.registerMmaCommands();
+        this.registerSessionCommands();
+        this.registerSkillCommands();
+        this.setupCompleter();
         this.rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout,
@@ -93,8 +90,6 @@ export class Repl {
                 return [[], line];
             },
         });
-        registerAllCommands(this);
-        this.setupCompleter();
         this.setupListeners();
     }
     loadHistory() {
@@ -112,6 +107,551 @@ export class Repl {
         const allHistory = this.history.slice(-this.maxHistory);
         writeFileSync(this.historyPath, allHistory.join("\n"), "utf-8");
     }
+    registerBuiltinCommands() {
+        this.registerCommand({
+            name: "help",
+            description: t("repl.help"),
+            usage: t("repl.help_usage"),
+            action: () => this.showHelp(),
+        });
+        this.registerCommand({
+            name: "exit",
+            description: t("repl.exit"),
+            aliases: ["quit", "q"],
+            usage: t("repl.exit_usage"),
+            action: () => this.stop(),
+        });
+        this.registerCommand({
+            name: "clear",
+            description: t("repl.clear"),
+            usage: t("repl.clear_usage"),
+            action: () => {
+                console.clear();
+            },
+        });
+    }
+    registerMmaCommands() {
+        this.registerCommand({
+            name: "run",
+            description: t("repl.run"),
+            usage: t("repl.run_usage"),
+            action: async (args) => {
+                if (args.length === 0) {
+                    console.log(t("repl.run_usage"));
+                    return;
+                }
+                const prompt = args.join(" ");
+                await this.runAgent(prompt);
+            },
+        });
+        this.registerCommand({
+            name: "image",
+            description: t("repl.image"),
+            aliases: ["img"],
+            usage: t("repl.image_usage"),
+            action: async (args) => {
+                const source = args.join(" ");
+                if (!source) {
+                    console.log(t("repl.image_usage"));
+                    return;
+                }
+                try {
+                    const { loadFileAsDataUrl, loadUrlAsDataUrl, readClipboardImage } = await import("../llm/image-utils");
+                    const { existsSync } = await import("fs");
+                    const { resolve } = await import("path");
+                    let dataUrl;
+                    let label;
+                    if (source.toLowerCase() === "clipboard") {
+                        const clipBuf = await readClipboardImage();
+                        if (!clipBuf) {
+                            console.log(pc.yellow(t("image.clipboard_empty")));
+                            return;
+                        }
+                        const { bufferToDataUrl } = await import("../llm/image-utils");
+                        const result = await bufferToDataUrl(clipBuf);
+                        dataUrl = result.dataUrl;
+                        label = "clipboard";
+                    }
+                    else if (source.startsWith("http://") || source.startsWith("https://")) {
+                        const result = await loadUrlAsDataUrl(source);
+                        dataUrl = result.dataUrl;
+                        label = source;
+                    }
+                    else {
+                        const absPath = resolve(process.cwd(), source);
+                        if (!existsSync(absPath)) {
+                            console.log(pc.red(t("image.not_found", { path: source })));
+                            return;
+                        }
+                        const result = await loadFileAsDataUrl(absPath);
+                        dataUrl = result.dataUrl;
+                        label = source;
+                    }
+                    // Store the image data on the agent's context manager for the next message
+                    const contextManager = this.agent.contextManager;
+                    if (!contextManager) {
+                        console.log(pc.red(t("image.no_context")));
+                        return;
+                    }
+                    contextManager.addPendingImage({
+                        type: "image_url",
+                        image_url: { url: dataUrl },
+                    });
+                    const sizeKb = Math.round((dataUrl.length * 3) / 4 / 1024);
+                    console.log(pc.green(t("image.attached", { source: label, size: `${sizeKb} KB` })));
+                }
+                catch (err) {
+                    console.log(pc.red(t("image.error", { message: err.message })));
+                }
+            },
+        });
+        this.registerCommand({
+            name: "config",
+            description: t("repl.config"),
+            usage: t("repl.config_usage"),
+            action: () => {
+                const ctx = this.config.contextWindow;
+                const sys = Math.floor(ctx * this.config.contextBudget.systemPrompt);
+                const res = Math.floor(ctx * this.config.contextBudget.responseReserve);
+                console.log(`${t("repl.model")}       ${this.config.model}`);
+                console.log(`${t("repl.provider")}    ${this.config.provider.type}  →  ${this.config.provider.baseUrl}`);
+                console.log(`${t("repl.context")}     ${ctx}  (sys:${sys}  res:${res}  hist:${ctx - sys - res})`);
+                console.log(`${t("repl.max_iters")}   ${this.config.maxToolIterations}`);
+                console.log(`${t("repl.stuck_thresh")} ${this.config.stuckThreshold}`);
+                console.log(`${t("repl.reasoning_label")}   ${this.config.showReasoning ? pc.green(t("repl.show")) : pc.dim(t("repl.hide"))}`);
+                console.log(`${t("repl.log_level")}   ${this.config.logLevel}`);
+                console.log(`${t("repl.locale")}      ${this.config.locale}`);
+                const meta = this.sessionManager?.getActiveMeta();
+                if (meta) {
+                    console.log(`${t("repl.session_label")}     ${meta.name} (${meta.id})  —  ${meta.messageCount} msgs`);
+                }
+            },
+        });
+        this.registerCommand({
+            name: "reasoning",
+            description: t("repl.reasoning"),
+            usage: t("repl.reasoning_usage"),
+            action: () => {
+                this.config.showReasoning = !this.config.showReasoning;
+                const status = this.config.showReasoning
+                    ? pc.green(t("repl.show"))
+                    : pc.dim(t("repl.hide"));
+                console.log(t("repl.reasoning_status", { status }));
+            },
+        });
+        this.registerCommand({
+            name: "status",
+            description: t("repl.status"),
+            usage: t("repl.status_usage"),
+            action: () => {
+                console.log(`${t("repl.model")} ${this.config.model}`);
+                console.log(`${t("repl.provider")} ${this.config.provider.type} @ ${this.config.provider.baseUrl}`);
+                const meta = this.sessionManager?.getActiveMeta();
+                if (meta) {
+                    console.log(`${t("repl.session_label")} ${meta.name} (${meta.id}) — ${meta.messageCount} messages`);
+                }
+            },
+        });
+        this.registerCommand({
+            name: "wizard",
+            description: t("repl.wizard"),
+            aliases: ["setup"],
+            usage: t("repl.wizard_usage"),
+            action: async () => {
+                console.log(pc.yellow(t("repl.wizard_running")));
+                const answers = await runSetup();
+                const configPath = join(homedir(), ".mma", "config.json");
+                this.config.provider.type = answers.provider;
+                this.config.provider.baseUrl = answers.apiBase;
+                this.config.provider.apiKey = answers.apiKey;
+                this.config.model = answers.model;
+                this.config.contextWindow = answers.contextWindow;
+                this.config.maxToolIterations = answers.maxToolIterations;
+                this.config.locale = answers.locale;
+                saveConfig(this.config, configPath);
+                console.log(pc.green(t("cli.config_saved")));
+            },
+        });
+        this.registerCommand({
+            name: "provider",
+            description: t("repl.provider_list"),
+            usage: t("repl.provider_usage"),
+            action: (args) => {
+                const subcmd = args[0];
+                if (!subcmd || subcmd === "list") {
+                    console.log(`${t("repl.provider_current")}  ${this.config.provider.type}`);
+                    console.log(`  ${this.config.provider.baseUrl}`);
+                    return;
+                }
+                if (subcmd === "use") {
+                    const name = args[1];
+                    if (!name) {
+                        console.log(t("repl.provider_usage"));
+                        return;
+                    }
+                    this.config.provider.type = name;
+                    const configPath = join(homedir(), ".mma", "config.json");
+                    saveConfig(this.config, configPath);
+                    console.log(pc.green(t("repl.provider_set", { name })));
+                    return;
+                }
+                console.log(t("repl.provider_usage"));
+            },
+        });
+        this.registerCommand({
+            name: "model",
+            description: t("repl.model_list"),
+            usage: t("repl.model_usage"),
+            action: async (args) => {
+                const subcmd = args[0];
+                if (!subcmd || subcmd === "list") {
+                    console.log(`${t("repl.model_current")}  ${this.config.model}`);
+                    // Fetch available models from provider
+                    const { OpenAICompatProvider } = await import("../llm/openai-compat");
+                    const provider = new OpenAICompatProvider({
+                        model: this.config.model,
+                        baseUrl: this.config.provider.baseUrl,
+                        apiKey: this.config.provider.apiKey,
+                        contextWindow: this.config.contextWindow,
+                    });
+                    const { Spinner } = await import("../ui/spinner");
+                    const s = new Spinner();
+                    s.start(t("cli.fetching_models"));
+                    try {
+                        const models = await provider.listModels();
+                        s.stop();
+                        if (models.length > 0) {
+                            console.log(t("cli.available_models"));
+                            for (const m of models) {
+                                const marker = m === this.config.model ? pc.green("* ") : "  ";
+                                console.log(` ${marker}${m}`);
+                            }
+                        }
+                        else {
+                            console.log(t("cli.no_models_found"));
+                        }
+                    }
+                    catch (err) {
+                        s.stop();
+                        console.log(t("cli.model_fetch_failed", { error: String(err) }));
+                    }
+                    console.log(t("cli.model_hint"));
+                    return;
+                }
+                if (subcmd === "use") {
+                    const name = args[1];
+                    if (!name) {
+                        console.log(t("repl.model_usage"));
+                        return;
+                    }
+                    this.config.model = name;
+                    const configPath = join(homedir(), ".mma", "config.json");
+                    saveConfig(this.config, configPath);
+                    console.log(pc.green(t("repl.model_set", { name })));
+                    return;
+                }
+                console.log(t("repl.model_usage"));
+            },
+        });
+        this.registerCommand({
+            name: "context",
+            description: t("cli.manage_context"),
+            usage: "/context <size>",
+            action: (args) => {
+                if (args.length === 0) {
+                    console.log(`/context ${t("repl.context")}  ${this.config.contextWindow}`);
+                    console.log(`Usage: /context <size>  (min 1024)`);
+                    return;
+                }
+                const size = parseInt(args[0], 10);
+                if (isNaN(size) || size < 1024) {
+                    console.log(t("cli.invalid_context_size"));
+                    return;
+                }
+                this.config.contextWindow = size;
+                const configPath = join(homedir(), ".mma", "config.json");
+                saveConfig(this.config, configPath);
+                console.log(pc.green(t("cli.context_set", { size })));
+            },
+        });
+        this.registerCommand({
+            name: "reload",
+            description: t("repl.reload"),
+            usage: t("repl.reload_usage"),
+            action: async () => {
+                console.log(pc.yellow(t("repl.reloading")));
+                // Save current session if auto-save enabled
+                if (this.sessionManager && this.config.session.autoSave) {
+                    const active = this.sessionManager.getActiveMeta();
+                    if (active) {
+                        // Session is already auto-saved on each message
+                    }
+                }
+                // Shutdown current agent
+                this.agent.shutdown();
+                // Reload config from disk
+                const { loadConfig } = await import("../config/config");
+                const { homedir } = await import("os");
+                const { join } = await import("path");
+                const configDir = join(homedir(), ".mma");
+                const projectConfigPath = join(process.cwd(), ".mmrc");
+                const freshConfig = loadConfig({ configDir, projectConfigPath });
+                // Update config reference
+                Object.assign(this.config, freshConfig);
+                // Recreate agent with new config (re-bootstrap)
+                const { bootstrap } = await import("../core/bootstrap");
+                const result = await bootstrap(configDir, process.cwd(), this.noAgentsMd, false);
+                // Replace agent and related components
+                this.agent = result.agent;
+                this.sessionManager = result.sessionManager;
+                this.skillsModule = result.skillsModule;
+                this.pluginManager = result.pluginManager;
+                // Update completer with new session/skill data
+                this.setupCompleter();
+                console.log(pc.green(t("repl.reloaded")));
+                console.log(`${t("repl.model")}       ${this.config.model}`);
+                console.log(`${t("repl.context")}     ${this.config.contextWindow}`);
+                console.log(`${t("repl.provider")}    ${this.config.provider.type} @ ${this.config.provider.baseUrl}`);
+            },
+        });
+    }
+    registerSessionCommands() {
+        if (!this.sessionManager)
+            return;
+        this.registerCommand({
+            name: "sessions",
+            description: t("repl.sessions"),
+            aliases: ["ls"],
+            usage: t("repl.sessions_usage"),
+            action: () => {
+                const sessions = this.sessionManager.list();
+                const active = this.sessionManager.getActive();
+                if (sessions.length === 0) {
+                    console.log(t("session.no_sessions_hint"));
+                    return;
+                }
+                const rows = sessions.map((s) => [
+                    s.id === active ? pc.green("●") : "",
+                    s.id.slice(0, 12),
+                    s.name,
+                    s.updatedAt.slice(0, 19).replace("T", " "),
+                    String(s.messageCount),
+                ]);
+                for (const line of renderTable([
+                    t("session.col_active"),
+                    t("session.col_id"),
+                    t("session.col_name"),
+                    t("session.col_updated"),
+                    t("session.col_msgs"),
+                ], rows)) {
+                    console.log(line);
+                }
+                console.log(pc.dim(`\n  ${t("repl.resume_hint")}`));
+            },
+        });
+        this.registerCommand({
+            name: "new",
+            description: t("repl.new"),
+            aliases: ["create"],
+            usage: t("repl.new_usage"),
+            action: (args) => {
+                const name = args.join(" ") || undefined;
+                const meta = this.sessionManager.create(name);
+                this.agent.clearContext();
+                console.clear();
+                console.log(`${t("session.created", { name: meta.name })} (${pc.dim(meta.id.slice(0, 12))})`);
+                console.log(pc.dim(`  ${t("session.chat_cleared")}\n`));
+            },
+        });
+        this.registerCommand({
+            name: "resume",
+            description: t("repl.resume"),
+            aliases: ["switch", "use"],
+            usage: t("repl.resume_usage"),
+            action: (args) => {
+                const query = args.join(" ");
+                const sessions = this.sessionManager.list();
+                if (!query) {
+                    console.log(pc.dim(t("session.available")));
+                    const active = this.sessionManager.getActive();
+                    for (const s of sessions) {
+                        const marker = s.id === active ? pc.green(" *") : "  ";
+                        console.log(pc.dim(` ${marker} ${s.id.slice(0, 12)}  ${s.name}`));
+                    }
+                    console.log(pc.dim(`\n  ${t("repl.resume_usage")}`));
+                    return;
+                }
+                const match = sessions.find((s) => s.id === query ||
+                    s.id.startsWith(query) ||
+                    s.name.toLowerCase().includes(query.toLowerCase()));
+                if (!match) {
+                    console.log(t("session.no_match", { query }));
+                    return;
+                }
+                this.sessionManager.setActive(match.id);
+                const history = this.sessionManager.loadHistory();
+                this.agent.setContext(history);
+                console.clear();
+                console.log(pc.bold(pc.green(t("session.resumed", { name: match.name }))) +
+                    " " +
+                    pc.dim(`(${match.id.slice(0, 12)})`) +
+                    "  —  " +
+                    match.messageCount +
+                    " msgs");
+                console.log(pc.dim("─".repeat(50)));
+                if (history.length === 0) {
+                    console.log(pc.dim(t("session.no_history")));
+                }
+                else {
+                    console.log(pc.dim(t("session.chat_history")));
+                    console.log();
+                    for (const msg of history) {
+                        if (msg.role === "user") {
+                            console.log(pc.cyan(t("session.user_label") + ":"));
+                            console.log(getMessageText(msg.content));
+                            console.log();
+                        }
+                        else if (msg.role === "assistant") {
+                            console.log(pc.green(t("session.assistant_label") + ":"));
+                            console.log(getMessageText(msg.content));
+                            console.log();
+                        }
+                    }
+                }
+                console.log(pc.dim("─".repeat(50)));
+                console.log(pc.dim(`  ${t("session.chat_loaded")}`));
+            },
+        });
+        this.registerCommand({
+            name: "rename",
+            description: t("repl.rename"),
+            usage: t("repl.rename_usage"),
+            action: (args) => {
+                const name = args.join(" ");
+                if (!name) {
+                    console.log(t("repl.rename_usage"));
+                    return;
+                }
+                const active = this.sessionManager.getActive();
+                if (!active) {
+                    console.log(t("session.no_active"));
+                    return;
+                }
+                this.sessionManager.rename(active, name);
+                console.log(t("session.renamed", { name }));
+            },
+        });
+        this.registerCommand({
+            name: "delete",
+            description: t("repl.delete"),
+            aliases: ["rm"],
+            usage: t("repl.delete_usage"),
+            action: (args) => {
+                const query = args[0];
+                if (!query) {
+                    console.log(t("repl.delete_usage"));
+                    return;
+                }
+                const sessions = this.sessionManager.list();
+                const match = sessions.find((s) => s.id === query || s.id.startsWith(query));
+                if (!match) {
+                    console.log(t("session.no_match", { query }));
+                    return;
+                }
+                this.sessionManager.delete(match.id);
+                console.log(`${t("session.deleted", { id: match.id })}: ${match.name}`);
+            },
+        });
+    }
+    registerSkillCommands() {
+        if (!this.skillsModule)
+            return;
+        this.registerCommand({
+            name: "skill",
+            description: t("repl.skill"),
+            usage: t("repl.skill_usage"),
+            action: (args) => {
+                const subcmd = args[0];
+                const arg = args.slice(1).join(" ");
+                if (!subcmd || subcmd === "list") {
+                    const available = this.skillsModule.getAvailable();
+                    if (available.length === 0) {
+                        console.log(t("repl.no_skills"));
+                        return;
+                    }
+                    console.log(pc.bold(t("repl.available_skills")));
+                    for (const skill of available) {
+                        const tokens = Math.ceil(skill.content.length / 4);
+                        const loaded = this.skillsModule.getLoaded().some((s) => s.name === skill.name);
+                        const marker = loaded ? pc.green(" [loaded]") : "";
+                        console.log(`  ${pc.cyan(skill.name)}${marker}  ${pc.dim(`(${tokens} tokens)`)}  ${skill.description.slice(0, 60)}`);
+                    }
+                    return;
+                }
+                if (subcmd === "loaded") {
+                    const loaded = this.skillsModule.getLoaded();
+                    const budget = this.skillsModule.getBudget();
+                    if (loaded.length === 0) {
+                        console.log(t("repl.no_loaded"));
+                        return;
+                    }
+                    console.log(pc.bold(t("repl.loaded_skills")));
+                    for (const skill of loaded) {
+                        const tokens = Math.ceil(skill.content.length / 4);
+                        console.log(`  ${pc.cyan(skill.name)}  ${pc.dim(`(${tokens} tokens)`)}  ${skill.description.slice(0, 60)}`);
+                    }
+                    console.log(pc.dim(`\n  ${t("repl.budget", { used: budget.used, total: budget.total, remaining: budget.remaining })}`));
+                    return;
+                }
+                if (subcmd === "load") {
+                    if (!arg) {
+                        console.log(t("repl.skill_load_usage"));
+                        return;
+                    }
+                    const result = this.skillsModule.loadByName(arg);
+                    if (result.success) {
+                        console.log(pc.green(result.message));
+                    }
+                    else {
+                        console.log(pc.red(result.message));
+                    }
+                    return;
+                }
+                if (subcmd === "unload") {
+                    if (!arg) {
+                        console.log(t("repl.skill_unload_usage"));
+                        return;
+                    }
+                    if (this.skillsModule.unload(arg)) {
+                        console.log(pc.green(t("repl.skill_unloaded", { name: arg })));
+                    }
+                    else {
+                        console.log(pc.red(t("repl.skill_not_loaded", { name: arg })));
+                    }
+                    return;
+                }
+                if (subcmd === "search") {
+                    if (!arg) {
+                        console.log(t("repl.skill_search_usage"));
+                        return;
+                    }
+                    const results = this.skillsModule.search(arg);
+                    if (results.length === 0) {
+                        console.log(t("repl.no_skill_match", { query: arg }));
+                        return;
+                    }
+                    console.log(pc.bold(t("repl.skills_matching", { query: arg })));
+                    for (const skill of results) {
+                        const tokens = Math.ceil(skill.content.length / 4);
+                        console.log(`  ${pc.cyan(skill.name)}  ${pc.dim(`(${tokens} tokens)`)}  ${skill.description.slice(0, 60)}`);
+                    }
+                    return;
+                }
+                console.log(pc.red(t("repl.skill_unknown_sub", { subcmd })));
+                console.log(t("repl.skill_usage"));
+            },
+        });
+    }
     setupCompleter() {
         const slashCommands = Array.from(this.commands.keys());
         this.completer.registerProvider(new SlashCommandProvider(slashCommands));
@@ -134,7 +674,7 @@ export class Repl {
         let inMultiLine = false;
         this.rl.on("line", async (line) => {
             const trimmed = line.trim();
-            if (this.agentRunning || this.inputLocked) {
+            if (this.agentRunning) {
                 if (trimmed) {
                     this.history.push(trimmed);
                     if (this.history.length > this.maxHistory) {
@@ -202,25 +742,18 @@ export class Repl {
             readline.emitKeypressEvents(process.stdin);
             process.stdin.on("keypress", async (str, key) => {
                 if (key.name === "escape") {
-                    // Bun/Node's readline collapses a fast double-Esc into a single
-                    // keypress whose `sequence` contains two ESC bytes ("\x1b\x1b").
-                    // Counting bytes (not events) catches both the collapsed case and
-                    // the case where two separate escape keypresses land in the window.
-                    const escBytes = key.sequence
-                        ? (key.sequence.match(/\x1b/g) || []).length
-                        : 1;
                     const now = Date.now();
-                    const withinWindow = now - this.lastEscTime < this.doubleEscDelay;
-                    this.lastEscTime = now;
-                    if (escBytes >= 2 || withinWindow) {
-                        this.lastEscTime = 0;
-                        if (this.agentRunning) {
-                            process.stdout.write(pc.yellow(`\n${t("repl.interrupt")}\n`));
-                            this.agent.shutdown();
-                        }
+                    if (now - this.lastEscTime < this.doubleEscDelay) {
+                        console.log(pc.yellow("\n\n[Ctrl+C] Остановка агента..."));
+                        this.agent.shutdown();
+                        this.running = false;
+                        this.saveHistory();
+                        this.rl.close();
+                        process.exit(0);
                     }
-                    return;
+                    this.lastEscTime = now;
                 }
+                // Ctrl+V: try to paste image from clipboard
                 if (key.ctrl && key.name === "v" && !this.agentRunning) {
                     try {
                         const { readClipboardImage, bufferToDataUrl } = await import("../llm/image-utils");
@@ -232,10 +765,6 @@ export class Repl {
                             console.log(pc.green(`\n${t("image.attached", { source: "clipboard", size: `${sizeKb} KB` })}`));
                             this.rl.prompt();
                         }
-                        else {
-                            console.log(pc.yellow(`\n${t("image.clipboard_empty")}`));
-                            this.rl.prompt();
-                        }
                     }
                     catch {
                         // clipboard read failed — ignore, let terminal paste text normally
@@ -243,15 +772,14 @@ export class Repl {
                 }
             });
         }
-        let forceExitTimer = null;
+        // SIGINT: first Ctrl+C sends graceful shutdown, second forces exit
         process.on("SIGINT", () => {
             if (this.agentRunning) {
                 console.log(pc.yellow("\n[Ctrl+C] Остановка агента... (ещё раз — принудительно)"));
                 this.agent.shutdown();
                 this.agentRunning = false;
-                if (forceExitTimer)
-                    clearTimeout(forceExitTimer);
-                forceExitTimer = setTimeout(() => process.exit(1), 2000).unref();
+                // Force exit after 2s if graceful shutdown hangs
+                setTimeout(() => process.exit(1), 2000).unref();
             }
             else {
                 process.exit(0);
@@ -271,7 +799,9 @@ export class Repl {
         if (this.agentRunning)
             return;
         this.agentRunning = true;
+        this.rl.pause();
         try {
+            // Attach pending clipboard image if Ctrl+V was pressed
             if (this.pendingClipboardImage) {
                 const contextManager = this.agent.contextManager;
                 if (contextManager) {
@@ -282,18 +812,14 @@ export class Repl {
                 }
                 this.pendingClipboardImage = null;
             }
-            this.logger?.logREPL("user", input);
             process.stdout.write("\n" + pc.green(t("repl.agent")));
-            const renderer = new Renderer({
-                spinner: this.config.ui?.spinner ?? true,
-                toolStyle: this.config.ui?.toolStyle ?? "inline",
-            });
+            const renderer = new Renderer({ spinner: this.config.ui?.spinner ?? true });
             const result = await this.agent.run(input, (c) => renderer.text(c), (m) => renderer.meta(m), (ev) => {
                 if (ev.type === "start") {
                     renderer.toolStart(ev.tool, ev.args);
                 }
                 else {
-                    renderer.toolEnd(ev.tool, ev.duration ?? 0, ev.error, ev.ctxDelta);
+                    renderer.toolEnd(ev.tool, ev.duration ?? 0, ev.error);
                 }
             }, (phase) => {
                 if (phase === "thinking") {
@@ -305,7 +831,6 @@ export class Repl {
             });
             renderer.flush();
             process.stdout.write("\n");
-            this.logger?.logREPL(result.success ? "assistant" : "system", result.text?.slice(0, 400) || result.error || "");
             if (!result.success) {
                 console.error(pc.red(`${t("error.prefix")}${result.error}`));
             }
@@ -313,9 +838,11 @@ export class Repl {
         }
         finally {
             this.agentRunning = false;
+            if (this.running) {
+                this.rl.resume();
+            }
         }
     }
-    commands = new Map();
     registerCommand(cmd) {
         this.commands.set(cmd.name, cmd);
         if (cmd.aliases) {
@@ -324,15 +851,6 @@ export class Repl {
             }
         }
     }
-    async withExclusiveInput(fn) {
-        this.inputLocked = true;
-        try {
-            await fn();
-        }
-        finally {
-            this.inputLocked = false;
-        }
-    }
     async executeCommand(input) {
         const parts = input.split(/\s+/);
         const name = parts[0].slice(1);
@@ -352,7 +870,6 @@ export class Repl {
         }
     }
     showHelp() {
-        const { COMMAND_GROUPS } = require("./repl-commands");
         const order = ["general", "agent", "session", "skill"];
         const seen = new Set();
         for (const groupKey of order) {
@@ -383,29 +900,18 @@ export class Repl {
             console.log();
         }
     }
-    lastCompactionShown = 0;
     showContextBar(result) {
-        if (result.contextUsed === undefined ||
-            result.contextLimit === undefined ||
-            result.contextLimit <= 0) {
-            return;
-        }
-        const ui = this.config.ui;
-        if (ui?.showContextStats) {
+        if (result.contextUsed !== undefined &&
+            result.contextLimit !== undefined &&
+            result.contextLimit > 0) {
             console.log();
-            const ctxLine = formatContextBar(result.contextUsed, result.contextLimit, result.compactionCount, result.contextQuality);
+            const ctxLine = formatContextBar(result.contextUsed, result.contextLimit);
             console.log(ctxLine);
             if (result.totalTokens !== undefined && result.totalTokens > 0) {
                 const apiLine = pc.dim(`  API: ${result.promptTokens} prompt + ${result.completionTokens} completion = ${result.totalTokens} total`);
                 console.log(apiLine);
             }
         }
-        else if (ui?.showCompaction && result.compactionCount !== undefined) {
-            if (result.compactionCount > this.lastCompactionShown) {
-                this.lastCompactionShown = result.compactionCount;
-                console.log(pc.dim(`\n  ⟳ Context compacted (${result.compactionCount})`));
-            }
-        }
     }
     start() {
         this.running = true;
@@ -420,8 +926,6 @@ export class Repl {
         row(t("repl.model"), pc.white(this.config.model));
         row(t("repl.provider"), `${this.config.provider.type}  →  ${pc.dim(this.config.provider.baseUrl)}`);
         row(t("repl.context"), `${pc.white(String(ctx))}  ${pc.dim(`(sys:${sysBudget}  res:${resBudget}  hist:${histBudget})`)}`);
-        const si = this.agent.getSystemPromptInfo();
-        row(t("repl.sysprompt_label"), pc.dim(t("repl.sysprompt_size", { used: si.tokenCount, budget: sysBudget })));
         if (this.skillsModule) {
             const budget = this.skillsModule.getBudget();
             row(t("repl.skills_label"), `${pc.white(String(this.skillsModule.getAvailable().length))} available, ${pc.dim(`budget: ${budget.total} tokens`)}`);
@@ -468,10 +972,7 @@ export class Repl {
             row(t("repl.session_label"), `${pc.cyan(meta.name)} ${pc.dim(`(${meta.id.slice(0, 12)})`)}  —  ${meta.messageCount} msgs  ${pc.dim(sessionPath)}`);
         }
         const headerWidth = Math.max(50, Math.min(96, process.stdout.columns || 96));
-        for (const line of box(info, {
-            title: t("repl.title", { version }),
-            width: headerWidth,
-        })) {
+        for (const line of box(info, { title: t("repl.title"), width: headerWidth })) {
             console.log(line);
         }
         console.log();