micro-models-agent 0.46.1 → 0.46.3

package/dist/cli/repl.js

@@ -1,616 +0,0 @@
-import * as readline from "readline";
-import { pc } from "../ui/colors";
-import { LineEditor } from "../ui/line-editor";
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import { join, dirname } 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, divider } from "../ui/box";
-import stringWidth from "string-width";
-import { t } from "../i18n/index";
-import { registerAllCommands } from "./repl-commands";
-import { probeLspServers } from "../modules/lsp/probe";
-import { DEFAULT_LSP_CONFIG } from "../modules/lsp/config";
-import { readActivePlan, formatPlanChecklist, stepContextForTool } from "../ui/plan-view";
-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) {
-    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;
-}
-export class Repl {
-    completer = new Completer();
-    running = false;
-    agentRunning = false;
-    inputLocked = false;
-    historyPath;
-    history = [];
-    maxHistory = 1000;
-    lastEscTime = 0;
-    doubleEscDelay = 500;
-    configDir;
-    baseDir;
-    noAgentsMd;
-    pendingClipboardImage = null;
-    exitOnClose = false;
-    activePlan = null;
-    lastPlanSig = "";
-    rl;
-    agent;
-    config;
-    sessionManager;
-    skillsModule;
-    pluginManager;
-    logger;
-    constructor(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd, logger, exitOnClose) {
-        this.agent = agent;
-        this.config = config;
-        this.exitOnClose = exitOnClose === true;
-        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.rl = process.stdin.isTTY
-            ? new LineEditor({
-                input: process.stdin,
-                output: process.stdout,
-                prompt: pc.cyan(t("repl.you")),
-                history: this.history,
-                historySize: this.maxHistory,
-                completer: (line) => {
-                    const [matches, partial] = this.completer.complete(line);
-                    if (matches.length > 0)
-                        return [matches, partial];
-                    return [[], line];
-                },
-            })
-            : readline.createInterface({
-                input: process.stdin,
-                output: process.stdout,
-                prompt: pc.cyan(t("repl.you")),
-                history: this.history,
-                historySize: this.maxHistory,
-                tabSize: 2,
-                completer: (line) => {
-                    const [matches, partial] = this.completer.complete(line);
-                    if (matches.length > 0)
-                        return [matches, partial];
-                    return [[], line];
-                },
-            });
-        registerAllCommands(this);
-        this.setupCompleter();
-        this.setupListeners();
-    }
-    loadHistory() {
-        if (existsSync(this.historyPath)) {
-            try {
-                const raw = readFileSync(this.historyPath, "utf-8");
-                this.history = raw.split("\n").filter(Boolean).slice(-this.maxHistory);
-            }
-            catch {
-                this.history = [];
-            }
-        }
-    }
-    saveHistory() {
-        const allHistory = this.history.slice(-this.maxHistory);
-        writeFileSync(this.historyPath, allHistory.join("\n"), "utf-8");
-    }
-    setupCompleter() {
-        const slashCommands = Array.from(this.commands.keys());
-        this.completer.registerProvider(new SlashCommandProvider(slashCommands));
-        if (this.sessionManager) {
-            this.completer.registerProvider(new SessionNameProvider(() => this.sessionManager.list().map((s) => s.name)));
-        }
-        if (this.skillsModule) {
-            this.completer.registerProvider(new SubcommandProvider("skill", ["list", "loaded", "load", "unload", "search"]));
-            this.completer.registerProvider(new SkillNameProvider(this.skillsModule));
-        }
-    }
-    setupListeners() {
-        let multiLineBuffer = "";
-        let inMultiLine = false;
-        this.rl.on("line", async (line) => {
-            const trimmed = line.trim();
-            if (this.agentRunning || this.inputLocked) {
-                if (trimmed) {
-                    this.history.push(trimmed);
-                    if (this.history.length > this.maxHistory) {
-                        this.history = this.history.slice(-this.maxHistory);
-                    }
-                }
-                return;
-            }
-            if (trimmed) {
-                this.history.push(trimmed);
-                if (this.history.length > this.maxHistory) {
-                    this.history = this.history.slice(-this.maxHistory);
-                }
-            }
-            if (inMultiLine) {
-                multiLineBuffer += "\n" + line;
-                if (!this.isMultiLineInput(multiLineBuffer)) {
-                    inMultiLine = false;
-                    const fullInput = multiLineBuffer.trim();
-                    multiLineBuffer = "";
-                    if (fullInput) {
-                        if (fullInput.startsWith("/")) {
-                            await this.executeCommand(fullInput);
-                        }
-                        else {
-                            await this.runAgent(fullInput);
-                        }
-                    }
-                    if (this.running) {
-                        this.rl.setPrompt(pc.cyan(t("repl.you")));
-                        this.rl.prompt();
-                    }
-                }
-                else {
-                    this.rl.setPrompt(pc.cyan(t("repl.you") + "… "));
-                    this.rl.prompt();
-                }
-                return;
-            }
-            if (this.isMultiLineInput(trimmed)) {
-                inMultiLine = true;
-                multiLineBuffer = trimmed;
-                this.rl.setPrompt(pc.cyan(t("repl.you") + "… "));
-                this.rl.prompt();
-                return;
-            }
-            if (!trimmed) {
-                this.rl.prompt();
-                return;
-            }
-            if (trimmed.startsWith("/")) {
-                await this.executeCommand(trimmed);
-            }
-            else {
-                await this.runAgent(trimmed);
-            }
-            if (this.running) {
-                this.rl.prompt();
-            }
-        });
-        this.rl.on("close", () => {
-            this.running = false;
-            this.saveHistory();
-            this.agent.shutdown();
-            if (this.exitOnClose)
-                process.exit(0);
-        });
-        if (this.exitOnClose && !process.stdin.isTTY) {
-            process.stdin.on("end", () => {
-                this.running = false;
-                this.saveHistory();
-                this.agent.shutdown();
-                process.exit(0);
-            });
-        }
-        if (this.rl instanceof LineEditor) {
-            this.rl.onKeyInput = (str, key) => this.handleSpecialKey(str, key);
-        }
-        let forceExitTimer = null;
-        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();
-            }
-            else {
-                process.exit(0);
-            }
-        });
-    }
-    handleSpecialKey(str, key) {
-        if (key.name === "escape") {
-            // Bun's keypress decoder 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();
-                }
-            }
-            return true;
-        }
-        if (key.ctrl && key.name === "v" && !this.agentRunning) {
-            this.pasteClipboardImage();
-            return true;
-        }
-        return false;
-    }
-    async pasteClipboardImage() {
-        try {
-            const { readClipboardImage, bufferToDataUrl } = await import("../llm/image-utils");
-            const clipBuf = await readClipboardImage();
-            if (clipBuf) {
-                const { dataUrl } = await bufferToDataUrl(clipBuf);
-                this.pendingClipboardImage = dataUrl;
-                const sizeKb = Math.round((dataUrl.length * 3) / 4 / 1024);
-                console.log(pc.green(`\n${t("image.attached", { source: "clipboard", size: `${sizeKb} KB` })}`));
-                if (this.rl instanceof LineEditor)
-                    this.rl.reset();
-                this.rl.prompt();
-            }
-            else {
-                console.log(pc.yellow(`\n${t("image.clipboard_empty")}`));
-                if (this.rl instanceof LineEditor)
-                    this.rl.reset();
-                this.rl.prompt();
-            }
-        }
-        catch {
-            // clipboard read failed — ignore, let terminal paste text normally
-        }
-    }
-    isMultiLineInput(line) {
-        if (line.endsWith("\\"))
-            return true;
-        const openBraces = (line.match(/\{/g) || []).length;
-        const closeBraces = (line.match(/\}/g) || []).length;
-        if (openBraces > closeBraces)
-            return true;
-        return false;
-    }
-    async runAgent(input) {
-        if (this.agentRunning)
-            return;
-        this.agentRunning = true;
-        try {
-            if (this.pendingClipboardImage) {
-                const contextManager = this.agent.contextManager;
-                if (contextManager) {
-                    contextManager.addPendingImage({
-                        type: "image_url",
-                        image_url: { url: this.pendingClipboardImage },
-                    });
-                }
-                this.pendingClipboardImage = null;
-            }
-            this.logger?.logREPL("user", input);
-            if (this.rl instanceof LineEditor)
-                this.rl.reset();
-            // Overwrite the empty prompt that reset() just drew with a divider,
-            // then label the agent's reply — separates the user's message from
-            // the agent's answer.
-            process.stdout.write("\r" + divider() + "\n" + pc.green(t("repl.agent")));
-            const renderer = new Renderer({
-                spinner: this.config.ui?.spinner ?? true,
-                toolStyle: this.config.ui?.toolStyle ?? "inline",
-            });
-            this.refreshActivePlan(renderer);
-            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, stepContextForTool(this.activePlan, ev.tool, ev.args));
-                }
-                else {
-                    renderer.toolEnd(ev.tool, ev.duration ?? 0, ev.error, ev.ctxDelta);
-                    if (ev.tool === "plan" || ev.tool === "todo") {
-                        this.refreshActivePlan(renderer);
-                    }
-                }
-            }, (phase) => {
-                if (phase === "thinking") {
-                    renderer.thinkingStart();
-                }
-                else {
-                    renderer.thinkingEnd();
-                }
-            });
-            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}`));
-            }
-            this.showContextBar(result);
-            // Close the agent's turn: a divider before the next prompt keeps
-            // consecutive user/agent messages visually separated.
-            process.stdout.write("\n" + divider() + "\n");
-        }
-        finally {
-            this.agentRunning = false;
-        }
-    }
-    /** Re-read the active plan from disk; print a live checklist when it changed. */
-    refreshActivePlan(renderer) {
-        const plan = readActivePlan(this.baseDir);
-        const sig = plan ? JSON.stringify(plan.steps.map((s) => `${s.id}:${s.status}`)) : "";
-        if (!plan) {
-            this.activePlan = null;
-            this.lastPlanSig = "";
-            return;
-        }
-        this.activePlan = plan;
-        if (sig !== this.lastPlanSig) {
-            this.lastPlanSig = sig;
-            renderer.planBlock(formatPlanChecklist(plan));
-        }
-    }
-    commands = new Map();
-    registerCommand(cmd) {
-        this.commands.set(cmd.name, cmd);
-        if (cmd.aliases) {
-            for (const alias of cmd.aliases) {
-                this.commands.set(alias, cmd);
-            }
-        }
-    }
-    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);
-        const args = parts.slice(1);
-        const cmd = this.commands.get(name);
-        if (!cmd) {
-            console.log(pc.red(t("cli.unknown_cmd", { name })), t("cli.help_hint"));
-            return;
-        }
-        try {
-            await cmd.action(args);
-        }
-        catch (err) {
-            console.error(pc.red(t("error.command_error", {
-                message: err instanceof Error ? err.message : String(err),
-            })));
-        }
-    }
-    showHelp() {
-        const { COMMAND_GROUPS } = require("./repl-commands");
-        const order = ["general", "agent", "session", "skill"];
-        const seen = new Set();
-        for (const groupKey of order) {
-            const cmds = [];
-            for (const [name, cmd] of this.commands) {
-                if (cmd.aliases?.includes(name))
-                    continue;
-                if (seen.has(cmd.name))
-                    continue;
-                const group = COMMAND_GROUPS[cmd.name] ?? "general";
-                if (group !== groupKey)
-                    continue;
-                seen.add(cmd.name);
-                cmds.push(cmd);
-            }
-            if (cmds.length === 0)
-                continue;
-            console.log(pc.bold(t(`repl.group.${groupKey}`)));
-            for (const cmd of cmds) {
-                const aliases = cmd.aliases?.length ? ` (${pc.dim(cmd.aliases.join(", "))})` : "";
-                console.log(`  ${pc.cyan("/" + cmd.name)}${aliases}  ${pc.dim(cmd.description)}`);
-                if (cmd.usage) {
-                    console.log(`    ${pc.dim(cmd.usage)}`);
-                }
-            }
-            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) {
-            console.log();
-            const ctxLine = formatContextBar(result.contextUsed, result.contextLimit, result.compactionCount, result.contextQuality);
-            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})`));
-            }
-        }
-    }
-    async start() {
-        this.running = true;
-        const info = [];
-        const row = (label, value) => {
-            info.push(` ${pc.yellow(label)} ${value}`);
-        };
-        const ctx = this.config.contextWindow;
-        const sysBudget = Math.floor(ctx * this.config.contextBudget.systemPrompt);
-        const resBudget = Math.floor(ctx * this.config.contextBudget.responseReserve);
-        const histBudget = ctx - sysBudget - resBudget;
-        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`)}`);
-        }
-        if (this.pluginManager) {
-            const infos = this.pluginManager.getPluginInfos().filter(({ plugin }) => !plugin.isBuiltin);
-            if (infos.length > 0) {
-                const pluginNames = infos
-                    .map(({ plugin, source }) => {
-                    const version = plugin.version ? `${pc.dim(plugin.version)}` : "";
-                    const origin = source ? pc.dim(` [${source}]`) : "";
-                    return `${plugin.name}${version}${origin}`;
-                })
-                    .join(", ");
-                row(t("repl.plugins_label"), `${pc.white(String(infos.length))} active  ${pc.dim(`(${pluginNames})`)}`);
-            }
-        }
-        const mcpServers = this.config.mcpServers || {};
-        const enabledServers = Object.entries(mcpServers).filter(([, s]) => s.enabled !== false);
-        if (enabledServers.length > 0) {
-            const names = enabledServers.map(([name]) => name).join(", ");
-            row(t("repl.mcp_label"), `${pc.white(String(enabledServers.length))}  ${pc.dim(`(${names})`)}`);
-        }
-        const cwd = process.cwd();
-        row(t("repl.work_dir"), pc.dim(cwd));
-        if (this.noAgentsMd) {
-            row(t("repl.agents_label"), pc.red(t("repl.disabled")));
-        }
-        else {
-            const agentsMdCandidates = [
-                join(this.baseDir, "AGENTS.md"),
-                join(this.baseDir, ".mma", "AGENTS.md"),
-                join(this.configDir, "AGENTS.md"),
-            ];
-            const foundAgents = agentsMdCandidates.filter((p) => existsSync(p));
-            if (foundAgents.length > 0) {
-                for (const p of foundAgents) {
-                    row(t("repl.agents_label"), pc.dim(p));
-                }
-            }
-            else {
-                row(t("repl.agents_label"), pc.dim(t("repl.not_found")));
-            }
-        }
-        const meta = this.sessionManager?.getActiveMeta();
-        if (meta) {
-            const sessionPath = join(this.configDir, "sessions", meta.id);
-            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));
-        // LSP status is probed in the background — it must never block the banner.
-        const isTty = process.stdout.isTTY === true;
-        const lspEnabled = isTty && (this.config.lsp ?? DEFAULT_LSP_CONFIG).enabled !== false;
-        if (lspEnabled) {
-            row(t("repl.lsp_label"), pc.dim("…"));
-        }
-        const boxLines = box(info, {
-            title: t("repl.title", { version }),
-            width: headerWidth,
-        });
-        for (const line of boxLines) {
-            console.log(line);
-        }
-        console.log();
-        this.rl.prompt();
-        if (lspEnabled) {
-            this.probeLspBanner()
-                .then((lspSummary) => {
-                if (lspSummary)
-                    this.updateLspRow(boxLines.length, headerWidth, lspSummary);
-            })
-                .catch(() => { });
-        }
-    }
-    /**
-     * Replace the LSP banner row (rendered as "…") in place once the probe
-     * finishes. The LSP row is the last data row of the box, so it sits exactly
-     * two terminal rows above the prompt line — that offset is stable no matter
-     * how earlier rows wrap. Skipped (placeholder stays) when a rewrite would
-     * corrupt the screen: the agent is already running, the terminal is not a
-     * TTY, a box line wrapped, or the summary is too wide for a single row.
-     */
-    updateLspRow(boxLineCount, headerWidth, summary) {
-        if (this.agentRunning || !process.stdout.isTTY)
-            return;
-        if ((process.stdout.columns ?? 96) < headerWidth)
-            return;
-        const inner = headerWidth - 4;
-        // Match box()'s wrapText normalization (leading space stripped, runs of
-        // whitespace collapsed) so the rewritten row is byte-identical to what
-        // box() would render for the same text.
-        const rowText = `${pc.yellow(t("repl.lsp_label"))} ${summary.replace(/\s+/g, " ").trim()}`;
-        if (stringWidth(rowText) > inner)
-            return;
-        const padded = rowText + " ".repeat(Math.max(0, inner - stringWidth(rowText)));
-        const line = pc.dim("│") + " " + padded + " " + pc.dim("│");
-        // From the prompt row (boxLineCount) up 2 to the LSP row (last data row,
-        // directly above the bottom border), clear it, write the new row, and
-        // return the cursor to the prompt row. The editor re-positions itself on
-        // the next keystroke, so any typed input is preserved.
-        process.stdout.write(`\x1b[2A\r\x1b[2K${line}\x1b[2B\r`);
-    }
-    /**
-     * Probe the LSP servers applicable to the current project and format a
-     * one-line banner summary, e.g. "✓ typescript (1.2s)" or "✗ css — timeout".
-     * Returns null when LSP is disabled or no server applies.
-     */
-    async probeLspBanner() {
-        const config = this.config.lsp ?? DEFAULT_LSP_CONFIG;
-        try {
-            const summary = await probeLspServers(config, this.baseDir);
-            if (summary.noneApplicable)
-                return null;
-            const parts = [];
-            for (const r of summary.ok) {
-                parts.push(pc.green(`✓ ${r.language}${pc.dim(` (${(r.durationMs / 1000).toFixed(1)}s)`)}`));
-            }
-            for (const r of summary.failed) {
-                const reason = r.error?.includes("timeout") ? t("repl.lsp_timeout") : t("repl.lsp_failed");
-                parts.push(pc.red(`✗ ${r.language}${pc.dim(` — ${reason}`)}`));
-            }
-            return parts.join("  ");
-        }
-        catch {
-            return pc.yellow(t("repl.lsp_unknown"));
-        }
-    }
-    stop() {
-        this.running = false;
-        this.saveHistory();
-        this.agent.shutdown();
-        this.rl.close();
-    }
-}

package/dist/cli/run-result.js

@@ -1,22 +0,0 @@
-import { t } from "../i18n/index";
-import { pc } from "../ui/colors";
-/**
- * Render a single-run AgentResult to the terminal (non-JSON mode) and return
- * the process exit code.
- *
- * On failure only the error is printed. The model's `text` (which is the last
- * *accepted* message, i.e. possibly stale after an audit/hallucination error)
- * was already streamed live during the run — re-printing it here misleadingly
- * suggests the task succeeded.
- */
-export function printRunResult(result, flush) {
-    flush();
-    if (result.success) {
-        if (!result.text) {
-            console.log(pc.yellow(t("cli.no_output")));
-        }
-        return 0;
-    }
-    console.error(`${t("error.prefix")}${result.error}`);
-    return 1;
-}