min-agent 0.1.4 → 0.1.6

package/dist/agent.js

@@ -7,9 +7,11 @@ import { initMcp, shutdownMcp, getMcpTools, loadMcpConfig, getMcpStatus } from "
 import { discoverSkills, getSkillsTool, getSkillsSystemPrompt, getSkills } from "./skills.js";
 import { loadInstructions } from "./instructions.js";
 import { getMemorySystemPrompt, getMemoryTools } from "./memory.js";
-import { needsCompaction, compactMessages, estimateTokens } from "./compaction.js";
+import { needsCompaction, compactMessages, estimateTokens, TokenTracker } from "./compaction.js";
 import { loadPluginTools } from "./plugins.js";
 import { MarkdownRenderer } from "./markdown.js";
+import { DoomLoopDetector } from "./doom-loop.js";
+import { scanProject, buildCodeSystemPrompt } from "./code-mode.js";
 import { ThinkingBodySplitter, stripThinkingFromAssistantText } from "./assistant-stream.js";
 import { printHeader, printDivider, printToolCall, printToolResult, printDone } from "./output.js";
 import readline from "readline";
@@ -51,7 +53,7 @@ function buildSystemPrompt(instructions) {
         `Platform: ${process.platform}`,
         `Date: ${new Date().toDateString()}`,
         "",
-        "min-agent: when the user asks to configure or install this agent (MCP, skills, rules, CLI, HTTP API, etc.), use the **read** tool on `README.md` in the working directory first, then follow what it says.",
+        `When the user asks to configure, install, or manage MCP servers, skills, rules, memory, or other min-agent features, use the read tool on the file at ${path.resolve(path.dirname(new URL(import.meta.url).pathname), "../README.md")} first, then follow what it says.`,
     ];
     const skillsPrompt = getSkillsSystemPrompt();
     if (skillsPrompt) {
@@ -109,7 +111,8 @@ export async function runAgent(message, modelId, imagePaths) {
     console.log(`\x1b[36m> ${message}\x1b[0m\n`);
     const content = await buildUserContent(message, imagePaths);
     const messages = [{ role: "user", content }];
-    await runOnce(messages, instructions, modelId);
+    const tracker = new TokenTracker();
+    await runOnce(messages, instructions, modelId, undefined, undefined, tracker);
     await shutdownMcp();
 }
 /** Interactive multi-turn chat session */
@@ -123,6 +126,7 @@ export async function runChat(modelId, resumeSessionId) {
     printInitReady();
     let messages = [];
     let sessionId = resumeSessionId;
+    const tracker = new TokenTracker();
     // Resume existing session
     if (resumeSessionId) {
         const { loadSession } = await import("./sessions.js");
@@ -144,7 +148,7 @@ export async function runChat(modelId, resumeSessionId) {
         if (abortController) {
             abortController.abort();
             abortController = null;
-            console.log("\n\x1b[90m(interrupted)\x1b[0m\n");
+            console.log("\n\x1b[90m(cancelled)\x1b[0m\n");
             rl.prompt();
         }
         else {
@@ -155,32 +159,166 @@ export async function runChat(modelId, resumeSessionId) {
     });
     console.log("\x1b[90m输入消息开始对话，输入 /help 查看命令，/exit 退出\x1b[0m\n");
     rl.prompt();
-    for await (const line of rl) {
-        const input = line.trim();
+    // Multi-line paste detection: collect rapid successive lines
+    let pasteBuffer = [];
+    let pasteTimer = null;
+    const PASTE_DEBOUNCE_MS = 50;
+    const processInput = async (text) => {
+        const input = text.trim();
         if (!input) {
             rl.prompt();
-            continue;
+            return;
         }
-        // Handle slash commands
         if (input.startsWith("/")) {
-            const handled = await handleSlashCommand(input, messages, instructions, modelId, rl);
-            if (handled === "exit")
-                break;
+            const handled = await handleSlashCommand(input, messages, instructions, modelId, rl, tracker);
+            if (handled === "exit") {
+                rl.close();
+                return;
+            }
+            if (handled === "paste") {
+                console.log();
+                abortController = new AbortController();
+                await runOnce(messages, instructions, modelId, abortController.signal, undefined, tracker);
+                abortController = null;
+                console.log();
+            }
             rl.prompt();
-            continue;
+            return;
         }
+        // Show paste feedback for large inputs
+        const { processPastedInput, printPasteFeedback } = await import("./paste-handler.js");
+        const pasteResult = processPastedInput(input);
+        printPasteFeedback(pasteResult);
         console.log();
-        messages.push({ role: "user", content: input });
+        messages.push({ role: "user", content: pasteResult.fullText });
         abortController = new AbortController();
-        await runOnce(messages, instructions, modelId, abortController.signal);
+        await runOnce(messages, instructions, modelId, abortController.signal, undefined, tracker);
         abortController = null;
         console.log();
         rl.prompt();
+    };
+    rl.on("line", (line) => {
+        pasteBuffer.push(line);
+        if (pasteTimer)
+            clearTimeout(pasteTimer);
+        pasteTimer = setTimeout(() => {
+            const combined = pasteBuffer.join("\n");
+            pasteBuffer = [];
+            pasteTimer = null;
+            processInput(combined);
+        }, PASTE_DEBOUNCE_MS);
+    });
+    // Wait for close
+    await new Promise((resolve) => rl.on("close", resolve));
+    // Auto-save session on exit with LLM-generated title
+    if (messages.length > 0) {
+        const { saveSessionWithTitle } = await import("./sessions.js");
+        const model = resolveModel(modelId);
+        sessionId = await saveSessionWithTitle(messages, model, sessionId);
+        console.log(`\x1b[90m  Session saved: ${sessionId}\x1b[0m`);
     }
-    // Auto-save session on exit
+    printDivider();
+    console.log("\x1b[90mBye!\x1b[0m");
+    await shutdownMcp();
+}
+/** AI Coding mode: project-aware interactive session */
+export async function runCode(modelId, resumeSessionId) {
+    printHeader(modelId);
+    console.log("\x1b[90m  Mode: code\x1b[0m");
+    printDivider();
+    // Scan project
+    console.log("\x1b[90m⟳ Scanning project...\x1b[0m");
+    const project = scanProject();
+    console.log(`\x1b[90m  ${project.languages.join(", ") || "Unknown language"}${project.framework ? ` (${project.framework})` : ""} | ${project.isGitRepo ? `git:${project.branch}` : "no git"}\x1b[0m`);
+    await initMcp();
+    discoverSkills();
+    const instructions = await loadInstructions();
+    const codePrompt = buildCodeSystemPrompt(project, instructions);
+    console.log("\x1b[90m✓ Ready\x1b[0m");
+    let messages = [];
+    let sessionId = resumeSessionId;
+    const tracker = new TokenTracker();
+    if (resumeSessionId) {
+        const { loadSession } = await import("./sessions.js");
+        const session = loadSession(resumeSessionId);
+        if (session) {
+            messages = session.messages;
+            sessionId = resumeSessionId;
+            console.log(`\x1b[90m  Resumed: ${session.meta.title} (${messages.length} msgs)\x1b[0m`);
+        }
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: "\x1b[32m❯ \x1b[0m",
+    });
+    let abortController = null;
+    process.on("SIGINT", () => {
+        if (abortController) {
+            abortController.abort();
+            abortController = null;
+            console.log("\n\x1b[90m(cancelled)\x1b[0m\n");
+            rl.prompt();
+        }
+        else {
+            console.log();
+            rl.close();
+        }
+    });
+    console.log("\x1b[90m输入任务开始编码，/help 查看命令，Ctrl+C 中断\x1b[0m\n");
+    rl.prompt();
+    let pasteBuffer = [];
+    let pasteTimer = null;
+    const PASTE_DEBOUNCE_MS = 50;
+    const processCodeInput = async (text) => {
+        const input = text.trim();
+        if (!input) {
+            rl.prompt();
+            return;
+        }
+        if (input.startsWith("/")) {
+            const handled = await handleSlashCommand(input, messages, [codePrompt], modelId, rl, tracker);
+            if (handled === "exit") {
+                rl.close();
+                return;
+            }
+            if (handled === "paste") {
+                console.log();
+                abortController = new AbortController();
+                await runOnceWithSystem(messages, codePrompt, modelId, abortController.signal, undefined, tracker);
+                abortController = null;
+                console.log();
+            }
+            rl.prompt();
+            return;
+        }
+        const { processPastedInput, printPasteFeedback } = await import("./paste-handler.js");
+        const pasteResult = processPastedInput(input);
+        printPasteFeedback(pasteResult);
+        console.log();
+        messages.push({ role: "user", content: pasteResult.fullText });
+        abortController = new AbortController();
+        await runOnceWithSystem(messages, codePrompt, modelId, abortController.signal, undefined, tracker);
+        abortController = null;
+        console.log();
+        rl.prompt();
+    };
+    rl.on("line", (line) => {
+        pasteBuffer.push(line);
+        if (pasteTimer)
+            clearTimeout(pasteTimer);
+        pasteTimer = setTimeout(() => {
+            const combined = pasteBuffer.join("\n");
+            pasteBuffer = [];
+            pasteTimer = null;
+            processCodeInput(combined);
+        }, PASTE_DEBOUNCE_MS);
+    });
+    await new Promise((resolve) => rl.on("close", resolve));
     if (messages.length > 0) {
-        const { saveSession } = await import("./sessions.js");
-        sessionId = saveSession(messages, sessionId);
+        const { saveSessionWithTitle } = await import("./sessions.js");
+        const model = resolveModel(modelId);
+        sessionId = await saveSessionWithTitle(messages, model, sessionId);
         console.log(`\x1b[90m  Session saved: ${sessionId}\x1b[0m`);
     }
     rl.close();
@@ -188,13 +326,216 @@ export async function runChat(modelId, resumeSessionId) {
     console.log("\x1b[90mBye!\x1b[0m");
     await shutdownMcp();
 }
-async function handleSlashCommand(input, messages, instructions, modelId, rl) {
+/** runOnce variant that accepts a pre-built system prompt (for code mode) */
+export async function runOnceWithSystem(messages, systemPrompt, modelId, abortSignal, callbacks, tracker) {
+    const model = resolveModel(modelId);
+    const api = !!callbacks;
+    if (needsCompaction(messages, tracker)) {
+        console.log("\x1b[90m⟳ Compacting context...\x1b[0m");
+        const result = await compactMessages(messages, model);
+        if (result.compacted) {
+            messages.length = 0;
+            messages.push(...result.messages);
+            if (result.shouldContinue) {
+                messages.push({ role: "user", content: "Continue with your task." });
+            }
+            if (tracker)
+                tracker.resetContext();
+            console.log(`\x1b[90m  ✓ Compacted (${estimateTokens(messages)} tokens estimated)\x1b[0m`);
+        }
+    }
+    const builtinTools = createTools();
+    const mcpTools = getMcpTools();
+    const memoryTools = getMemoryTools();
+    const pluginTools = await loadPluginTools();
+    const { createTaskTool } = await import("./tools/task.js");
+    const { createExploreTool } = await import("./tools/explore.js");
+    const skills = getSkills();
+    const allTools = { ...builtinTools, ...memoryTools, ...pluginTools };
+    for (const [id, t] of Object.entries(mcpTools))
+        allTools[id] = t;
+    if (skills.length > 0)
+        allTools["skill"] = getSkillsTool();
+    allTools["task"] = createTaskTool(modelId);
+    allTools["explore"] = createExploreTool(modelId);
+    let stepCount = 0;
+    let hasError = false;
+    const doomLoop = new DoomLoopDetector();
+    const result = streamText({
+        model,
+        system: systemPrompt,
+        messages,
+        tools: allTools,
+        stopWhen: stepCountIs(MAX_STEPS),
+        maxRetries: 3,
+        abortSignal,
+        onStepFinish() { stepCount++; },
+        onError() { },
+    });
+    Promise.resolve(result.usage).catch(() => { });
+    let rawText = "";
+    let assistantText = "";
+    const md = new MarkdownRenderer();
+    const thinkingSplit = new ThinkingBodySplitter();
+    try {
+        for await (const event of result.fullStream) {
+            switch (event.type) {
+                case "text-delta": {
+                    const { display, thinking } = thinkingSplit.feed(event.text);
+                    if (thinking) {
+                        if (callbacks?.onThinkingDelta)
+                            callbacks.onThinkingDelta(thinking);
+                        else
+                            writeThinkingDelta(thinking);
+                    }
+                    if (display) {
+                        rawText += display;
+                        assistantText += display;
+                        if (callbacks?.onAssistantDisplayDelta)
+                            callbacks.onAssistantDisplayDelta(display);
+                        else {
+                            const formatted = md.write(display);
+                            if (formatted)
+                                process.stdout.write(formatted);
+                        }
+                    }
+                    break;
+                }
+                case "tool-call": {
+                    if (doomLoop.record(event.toolName, event.input)) {
+                        const warn = `Doom loop detected: "${event.toolName}" — breaking.`;
+                        if (callbacks?.onStreamError)
+                            callbacks.onStreamError(warn);
+                        else
+                            console.log(`\n\x1b[33m⚠ ${warn}\x1b[0m`);
+                        hasError = true;
+                        break;
+                    }
+                    const flush = thinkingSplit.flush();
+                    if (flush.thinking) {
+                        if (callbacks?.onThinkingDelta)
+                            callbacks.onThinkingDelta(flush.thinking);
+                        else
+                            writeThinkingDelta(flush.thinking);
+                    }
+                    if (flush.display) {
+                        rawText += flush.display;
+                        assistantText += flush.display;
+                        if (callbacks?.onAssistantDisplayDelta)
+                            callbacks.onAssistantDisplayDelta(flush.display);
+                        else {
+                            const extra = md.write(flush.display);
+                            if (extra)
+                                process.stdout.write(extra);
+                        }
+                    }
+                    if (!api) {
+                        const flushed = md.flush();
+                        if (flushed)
+                            process.stdout.write(flushed);
+                        if (rawText.trim())
+                            console.log();
+                    }
+                    rawText = "";
+                    if (callbacks?.onToolCall)
+                        callbacks.onToolCall(event.toolName, event.input);
+                    else
+                        printToolCall(event.toolName, event.input);
+                    break;
+                }
+                case "tool-result":
+                    if (callbacks?.onToolResult)
+                        callbacks.onToolResult(event.toolName, event.output);
+                    else
+                        printToolResult(event.toolName, event.output);
+                    break;
+                case "error":
+                    hasError = true;
+                    if (callbacks?.onStreamError)
+                        callbacks.onStreamError(String(event.error));
+                    else
+                        console.error(`\x1b[31mError: ${event.error}\x1b[0m`);
+                    break;
+                case "finish":
+                    break;
+            }
+        }
+        const end = thinkingSplit.flush();
+        if (end.thinking) {
+            if (callbacks?.onThinkingDelta)
+                callbacks.onThinkingDelta(end.thinking);
+            else
+                writeThinkingDelta(end.thinking);
+        }
+        if (end.display) {
+            assistantText += end.display;
+            if (callbacks?.onAssistantDisplayDelta)
+                callbacks.onAssistantDisplayDelta(end.display);
+            else {
+                const tail = md.write(end.display);
+                if (tail)
+                    process.stdout.write(tail);
+            }
+        }
+        if (!api) {
+            const remaining = md.flush();
+            if (remaining)
+                process.stdout.write(remaining);
+            if (rawText.trim())
+                console.log();
+        }
+        const cleaned = stripThinkingFromAssistantText(assistantText);
+        if (cleaned.trim())
+            messages.push({ role: "assistant", content: cleaned });
+        let usage;
+        try {
+            usage = await result.usage;
+        }
+        catch {
+            usage = undefined;
+        }
+        if (usage && tracker)
+            tracker.update(usage);
+        if (callbacks?.onRunFinish) {
+            callbacks.onRunFinish({ stepCount, usage, hasError, aborted: false });
+        }
+        else {
+            if (!hasError && usage) {
+                printDivider();
+                const { getContextWindow } = await import("./context-window.js");
+                const ctxWindow = await getContextWindow(modelId);
+                printDone(stepCount, usage, ctxWindow);
+            }
+            else {
+                printDivider();
+            }
+        }
+    }
+    catch (err) {
+        if (err.name === "AbortError" || abortSignal?.aborted) {
+            const cleaned = stripThinkingFromAssistantText(assistantText);
+            if (cleaned.trim())
+                messages.push({ role: "assistant", content: cleaned });
+            if (callbacks?.onRunFinish)
+                callbacks.onRunFinish({ stepCount, usage: undefined, hasError: false, aborted: true });
+            return;
+        }
+        if (callbacks?.onStreamError)
+            callbacks.onStreamError(err.message);
+        else {
+            printDivider();
+            console.error(`\x1b[31mError: ${err.message}\x1b[0m`);
+        }
+    }
+}
+async function handleSlashCommand(input, messages, instructions, modelId, rl, tracker) {
     const [cmd, ...rest] = input.slice(1).split(/\s+/);
     const arg = rest.join(" ");
     switch (cmd) {
         case "exit":
         case "quit":
         case "q":
+            console.log("\x1b[90m⟳ Exiting...\x1b[0m");
             return "exit";
         case "clear":
             messages.length = 0;
@@ -207,9 +548,11 @@ async function handleSlashCommand(input, messages, instructions, modelId, rl) {
             else {
                 console.log("\x1b[90m  ⟳ Compacting...\x1b[0m");
                 const model = resolveModel(modelId);
-                const result = await compactMessages(messages, model, { keepRecentTurns: 2 });
+                const result = await compactMessages(messages, model, { keepRecentTurns: 2, autoContinue: false });
                 messages.length = 0;
                 messages.push(...result.messages);
+                if (tracker)
+                    tracker.resetContext();
                 console.log(`\x1b[90m  ✓ Compacted (${estimateTokens(messages)} tokens estimated)\x1b[0m`);
             }
             return "handled";
@@ -275,12 +618,11 @@ async function handleSlashCommand(input, messages, instructions, modelId, rl) {
             discoverSkills();
             const skills = getSkills();
             if (skills.length === 0) {
-                console.log("\x1b[90m  No skills found\x1b[0m");
+                console.log("\x1b[90m  No skills available\x1b[0m");
             }
             else {
-                console.log(`\x1b[90m  Available skills (${skills.length}):\x1b[0m`);
                 for (const skill of skills) {
-                    console.log(`\x1b[90m  - ${skill.name}: ${skill.description}\x1b[0m`);
+                    console.log(`\x1b[90m  ${skill.name}  enabled\x1b[0m`);
                 }
             }
             return "handled";
@@ -305,10 +647,41 @@ async function handleSlashCommand(input, messages, instructions, modelId, rl) {
             }
             return "handled";
         }
-        case "tokens":
-            console.log(`\x1b[90m  Estimated tokens in context: ${estimateTokens(messages)}\x1b[0m`);
+        case "tokens": {
+            if (tracker && tracker.lastInputTokens > 0) {
+                const { getContextWindow } = await import("./context-window.js");
+                const ctxWindow = await getContextWindow(modelId);
+                const pct = Math.round((tracker.lastInputTokens / ctxWindow) * 100);
+                console.log(`\x1b[90m  Context: ${tracker.lastInputTokens} / ${ctxWindow} tokens (${pct}%)\x1b[0m`);
+                console.log(`\x1b[90m  Total: ${tracker.totalInputTokens} in / ${tracker.totalOutputTokens} out\x1b[0m`);
+            }
+            else {
+                console.log(`\x1b[90m  Estimated tokens in context: ${estimateTokens(messages)}\x1b[0m`);
+            }
             console.log(`\x1b[90m  Messages: ${messages.length}\x1b[0m`);
             return "handled";
+        }
+        case "path":
+        case "pwd":
+            console.log(`\x1b[90m  ${process.cwd()}\x1b[0m`);
+            return "handled";
+        case "paste": {
+            const { getClipboardImage } = await import("./clipboard.js");
+            const img = getClipboardImage();
+            if (!img) {
+                console.log("\x1b[90m  No image found in clipboard\x1b[0m");
+                return "handled";
+            }
+            console.log(`\x1b[90m  📎 Clipboard image (${(img.data.length / 1024).toFixed(1)} KB)\x1b[0m`);
+            const text = arg || "What's in this image?";
+            const content = [
+                { type: "text", text },
+                { type: "image", image: img.data, mimeType: img.mimeType },
+            ];
+            messages.push({ role: "user", content });
+            // Return a special signal to trigger runOnce
+            return "paste";
+        }
         case "help":
             console.log(`\x1b[90m  Slash commands:
   /clear          Clear conversation history
@@ -319,6 +692,8 @@ async function handleSlashCommand(input, messages, instructions, modelId, rl) {
   /skills         List discovered skills
   /mcp            List MCP servers and connection status
   /tokens         Show estimated token usage
+  /path           Show current working directory
+  /paste [text]   Paste clipboard image + optional prompt
   /help           Show this help
   /exit           Exit the chat\x1b[0m`);
             return "handled";
@@ -327,11 +702,11 @@ async function handleSlashCommand(input, messages, instructions, modelId, rl) {
             return "handled";
     }
 }
-export async function runOnce(messages, instructions, modelId, abortSignal, callbacks) {
+export async function runOnce(messages, instructions, modelId, abortSignal, callbacks, tracker) {
     const model = resolveModel(modelId);
     const api = !!callbacks;
     // Auto-compact if context is getting too large
-    if (needsCompaction(messages)) {
+    if (needsCompaction(messages, tracker)) {
         if (api) {
             callbacks.onCompaction?.("compacting_start");
         }
@@ -342,6 +717,15 @@ export async function runOnce(messages, instructions, modelId, abortSignal, call
         if (result.compacted) {
             messages.length = 0;
             messages.push(...result.messages);
+            // Auto-continue: inject a message so the agent keeps working
+            if (result.shouldContinue) {
+                messages.push({
+                    role: "user",
+                    content: "Continue if you have next steps, or stop and ask for clarification if you are unsure how to proceed.",
+                });
+            }
+            if (tracker)
+                tracker.resetContext();
             if (api) {
                 callbacks.onCompaction?.(`compacted_ok estimated_tokens=${estimateTokens(messages)}`);
             }
@@ -350,11 +734,12 @@ export async function runOnce(messages, instructions, modelId, abortSignal, call
             }
         }
     }
-    // Merge all tools: builtin + MCP + skill + memory + plugins
+    // Merge all tools: builtin + MCP + skill + memory + plugins + task
     const builtinTools = createTools();
     const mcpTools = getMcpTools();
     const memoryTools = getMemoryTools();
     const pluginTools = await loadPluginTools();
+    const { createTaskTool } = await import("./tools/task.js");
     const skills = getSkills();
     const allTools = { ...builtinTools, ...memoryTools, ...pluginTools };
     for (const [id, t] of Object.entries(mcpTools)) {
@@ -363,8 +748,10 @@ export async function runOnce(messages, instructions, modelId, abortSignal, call
     if (skills.length > 0) {
         allTools["skill"] = getSkillsTool();
     }
+    allTools["task"] = createTaskTool(modelId);
     let stepCount = 0;
     let hasError = false;
+    const doomLoop = new DoomLoopDetector();
     const result = streamText({
         model,
         system: buildSystemPrompt(instructions),
@@ -411,6 +798,16 @@ export async function runOnce(messages, instructions, modelId, abortSignal, call
                     break;
                 }
                 case "tool-call": {
+                    // Doom loop detection
+                    if (doomLoop.record(event.toolName, event.input)) {
+                        const warning = `\x1b[33m⚠ Doom loop detected: "${event.toolName}" called ${3} times with same args. Breaking loop.\x1b[0m`;
+                        if (callbacks?.onStreamError)
+                            callbacks.onStreamError(warning);
+                        else
+                            console.log(`\n${warning}`);
+                        hasError = true;
+                        break;
+                    }
                     const splitFlush = thinkingSplit.flush();
                     emitThinking(splitFlush.thinking);
                     if (splitFlush.display) {
@@ -492,6 +889,10 @@ export async function runOnce(messages, instructions, modelId, abortSignal, call
         catch {
             usage = undefined;
         }
+        // Update token tracker with real usage from API
+        if (usage && tracker) {
+            tracker.update(usage);
+        }
         if (callbacks?.onRunFinish) {
             callbacks.onRunFinish({ stepCount, usage, hasError, aborted: false });
         }
@@ -501,7 +902,9 @@ export async function runOnce(messages, instructions, modelId, abortSignal, call
                 return;
             }
             printDivider();
-            printDone(stepCount, usage);
+            const { getContextWindow } = await import("./context-window.js");
+            const ctxWindow = await getContextWindow(modelId);
+            printDone(stepCount, usage, ctxWindow);
         }
     }
     catch (err) {