min-agent 0.1.6 → 0.1.7

package/dist/agent.js

@@ -2,7 +2,7 @@ import { streamText, stepCountIs } from "ai";
 import { readFileSync, existsSync } from "fs";
 import path from "path";
 import { resolveModel } from "./provider.js";
-import { createTools } from "./tools/index.js";
+import { createChatTools, createCodeTools } from "./tools/index.js";
 import { initMcp, shutdownMcp, getMcpTools, loadMcpConfig, getMcpStatus } from "./mcp.js";
 import { discoverSkills, getSkillsTool, getSkillsSystemPrompt, getSkills } from "./skills.js";
 import { loadInstructions } from "./instructions.js";
@@ -210,11 +210,10 @@ export async function runChat(modelId, resumeSessionId) {
     });
     // Wait for close
     await new Promise((resolve) => rl.on("close", resolve));
-    // Auto-save session on exit with LLM-generated title
+    // Auto-save session on exit
     if (messages.length > 0) {
-        const { saveSessionWithTitle } = await import("./sessions.js");
-        const model = resolveModel(modelId);
-        sessionId = await saveSessionWithTitle(messages, model, sessionId);
+        const { saveSession } = await import("./sessions.js");
+        sessionId = saveSession(messages, sessionId);
         console.log(`\x1b[90m  Session saved: ${sessionId}\x1b[0m`);
     }
     printDivider();
@@ -316,9 +315,8 @@ export async function runCode(modelId, resumeSessionId) {
     });
     await new Promise((resolve) => rl.on("close", resolve));
     if (messages.length > 0) {
-        const { saveSessionWithTitle } = await import("./sessions.js");
-        const model = resolveModel(modelId);
-        sessionId = await saveSessionWithTitle(messages, model, sessionId);
+        const { saveSession } = await import("./sessions.js");
+        sessionId = saveSession(messages, sessionId);
         console.log(`\x1b[90m  Session saved: ${sessionId}\x1b[0m`);
     }
     rl.close();
@@ -344,7 +342,7 @@ export async function runOnceWithSystem(messages, systemPrompt, modelId, abortSi
             console.log(`\x1b[90m  ✓ Compacted (${estimateTokens(messages)} tokens estimated)\x1b[0m`);
         }
     }
-    const builtinTools = createTools();
+    const builtinTools = createCodeTools();
     const mcpTools = getMcpTools();
     const memoryTools = getMemoryTools();
     const pluginTools = await loadPluginTools();
@@ -734,12 +732,11 @@ export async function runOnce(messages, instructions, modelId, abortSignal, call
             }
         }
     }
-    // Merge all tools: builtin + MCP + skill + memory + plugins + task
-    const builtinTools = createTools();
+    // Merge tools: chat builtin + MCP + skill + memory + plugins (no task/explore in chat mode)
+    const builtinTools = createChatTools();
     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)) {
@@ -748,7 +745,6 @@ 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();

package/dist/assistant-stream.js

@@ -41,6 +41,7 @@ export class ThinkingBodySplitter {
     drain(isFinal) {
         let display = "";
         let thinking = "";
+        let hadThinking = false;
         while (this.buf.length > 0) {
             const open = findFirstOpen(this.buf);
             if (!open) {
@@ -62,7 +63,11 @@ export class ThinkingBodySplitter {
                 break;
             }
             if (open.index > 0) {
-                display += this.buf.slice(0, open.index);
+                // Strip trailing newlines before thinking block
+                let pre = this.buf.slice(0, open.index);
+                pre = pre.replace(/\n+$/, "");
+                if (pre)
+                    display += pre;
                 this.buf = this.buf.slice(open.index);
             }
             const low = lower(this.buf);
@@ -81,8 +86,16 @@ export class ThinkingBodySplitter {
             }
             const inner = this.buf.slice(afterOpen, closeRel);
             thinking += inner;
+            hadThinking = true;
             this.buf = this.buf.slice(closeRel + open.tag.close.length);
         }
+        // Strip leading newlines from display that follow a thinking block
+        if (hadThinking && display.length === 0 && this.buf.startsWith("\n")) {
+            // Will be handled on next feed
+        }
+        if (hadThinking) {
+            display = display.replace(/^\n+/, "");
+        }
         return { display, thinking };
     }
 }

package/dist/confirm.js

@@ -1,4 +1,3 @@
-import readline from "readline";
 let autoApprove = false;
 export function setAutoApprove(value) {
     autoApprove = value;
@@ -10,12 +9,22 @@ export function isAutoApprove() {
 export async function confirm(message) {
     if (autoApprove)
         return true;
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    process.stdout.write(`\n\x1b[33m⚠ ${message} [y/N] \x1b[0m`);
     return new Promise((resolve) => {
-        rl.question(`\x1b[33m⚠ ${message} [y/N] \x1b[0m`, (answer) => {
-            rl.close();
-            resolve(answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes");
-        });
+        const wasRaw = process.stdin.isRaw;
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(true);
+        const onData = (buf) => {
+            const ch = buf.toString();
+            process.stdin.removeListener("data", onData);
+            if (process.stdin.isTTY)
+                process.stdin.setRawMode(wasRaw ?? false);
+            // Echo the character and newline
+            process.stdout.write(ch === "\r" || ch === "\n" ? "\n" : `${ch}\n`);
+            const answer = ch.trim().toLowerCase();
+            resolve(answer === "y");
+        };
+        process.stdin.on("data", onData);
     });
 }
 /** Check if a shell command is potentially dangerous */

package/dist/markdown.js

@@ -37,6 +37,8 @@ export class MarkdownRenderer {
     buffer = "";
     inCodeBlock = false;
     codeLang = "";
+    tableRows = [];
+    inTable = false;
     /** Process a text delta and return formatted output */
     write(text) {
         this.buffer += text;
@@ -49,19 +51,161 @@ export class MarkdownRenderer {
                 break;
             const line = this.buffer.slice(0, nlIdx);
             this.buffer = this.buffer.slice(nlIdx + 1);
+            // Table handling: collect rows, render when table ends
+            if (this.isTableRow(line)) {
+                if (this.isTableSeparator(line)) {
+                    this.inTable = true;
+                    continue;
+                }
+                this.inTable = true;
+                this.tableRows.push(this.parseTableRow(line));
+                continue;
+            }
+            // Table just ended — flush it
+            if (this.inTable) {
+                output += this.renderTable(c);
+                this.tableRows = [];
+                this.inTable = false;
+            }
             output += this.formatLine(line, c) + "\n";
         }
+        // Stream partial line immediately for real-time feel
+        // Hold back only if it could be start of table or code fence
+        if (!this.inTable && !this.inCodeBlock && this.buffer.length > 0) {
+            if (!this.buffer.startsWith("|") && !this.buffer.startsWith("`")) {
+                const partial = this.buffer;
+                this.buffer = "";
+                output += this.formatInline(partial, c);
+            }
+        }
+        // If we're in a table and buffer starts with "|", hold it (waiting for \n)
+        // If we're in a table and buffer does NOT start with "|", the table ended mid-stream
+        if (this.inTable && this.buffer.length > 0 && !this.buffer.startsWith("|")) {
+            output += this.renderTable(c);
+            this.tableRows = [];
+            this.inTable = false;
+            // Now output the non-table buffer content
+            if (this.buffer.length > 0 && !this.buffer.startsWith("`")) {
+                const partial = this.buffer;
+                this.buffer = "";
+                output += this.formatInline(partial, c);
+            }
+        }
         return output;
     }
     /** Flush remaining buffer */
     flush() {
-        if (!this.buffer)
-            return "";
         const c = useColor() ? C : Z;
-        const out = this.formatLine(this.buffer, c);
+        let out = "";
+        // If buffer has a pending table row, add it
+        if (this.inTable && this.buffer.length > 0) {
+            if (this.isTableRow(this.buffer)) {
+                if (!this.isTableSeparator(this.buffer)) {
+                    this.tableRows.push(this.parseTableRow(this.buffer));
+                }
+                this.buffer = "";
+            }
+        }
+        // Flush pending table
+        if (this.inTable && this.tableRows.length > 0) {
+            out += this.renderTable(c);
+            this.tableRows = [];
+            this.inTable = false;
+        }
+        if (!this.buffer)
+            return out;
+        out += this.formatLine(this.buffer, c);
         this.buffer = "";
         return out;
     }
+    isTableRow(line) {
+        const trimmed = line.trim();
+        return trimmed.startsWith("|") && trimmed.endsWith("|") && trimmed.includes("|", 1);
+    }
+    isTableSeparator(line) {
+        return /^\s*\|[\s:]*-+[\s:|-]*\|\s*$/.test(line);
+    }
+    parseTableRow(line) {
+        return line.trim().slice(1, -1).split("|").map((cell) => cell.trim());
+    }
+    /** Get display width of a string (CJK/emoji chars = 2, others = 1) */
+    displayWidth(str) {
+        let width = 0;
+        for (const ch of str) {
+            const code = ch.codePointAt(0) ?? 0;
+            if (
+            // CJK
+            (code >= 0x1100 && code <= 0x115f) ||
+                (code >= 0x2e80 && code <= 0x303e) ||
+                (code >= 0x3040 && code <= 0x33bf) ||
+                (code >= 0x3400 && code <= 0x4dbf) ||
+                (code >= 0x4e00 && code <= 0x9fff) ||
+                (code >= 0xa000 && code <= 0xa4cf) ||
+                (code >= 0xac00 && code <= 0xd7af) ||
+                (code >= 0xf900 && code <= 0xfaff) ||
+                (code >= 0xfe30 && code <= 0xfe6f) ||
+                (code >= 0xff01 && code <= 0xff60) ||
+                (code >= 0xffe0 && code <= 0xffe6) ||
+                (code >= 0x20000 && code <= 0x2fffd) ||
+                (code >= 0x30000 && code <= 0x3fffd) ||
+                // Emoji
+                (code >= 0x1f300 && code <= 0x1f9ff) || // Misc Symbols, Emoticons, Dingbats, etc.
+                (code >= 0x1fa00 && code <= 0x1faff) || // Chess, Extended-A
+                (code >= 0x2600 && code <= 0x27bf) || // Misc Symbols, Dingbats
+                (code >= 0xfe00 && code <= 0xfe0f) || // Variation Selectors (skip width)
+                (code >= 0x200d && code <= 0x200d) || // ZWJ (skip width)
+                (code >= 0x1f1e0 && code <= 0x1f1ff) // Regional Indicators (flags)
+            ) {
+                // Variation selectors and ZWJ are zero-width joiners
+                if ((code >= 0xfe00 && code <= 0xfe0f) || code === 0x200d) {
+                    width += 0;
+                }
+                else {
+                    width += 2;
+                }
+            }
+            else {
+                width += 1;
+            }
+        }
+        return width;
+    }
+    /** Pad string to target display width */
+    padToWidth(str, targetWidth) {
+        const currentWidth = this.displayWidth(str);
+        const padding = targetWidth - currentWidth;
+        return padding > 0 ? str + " ".repeat(padding) : str;
+    }
+    renderTable(c) {
+        if (this.tableRows.length === 0)
+            return "";
+        // Calculate column widths based on display width (CJK-aware)
+        const colCount = Math.max(...this.tableRows.map((r) => r.length));
+        const widths = Array(colCount).fill(0);
+        for (const row of this.tableRows) {
+            for (let i = 0; i < row.length; i++) {
+                widths[i] = Math.max(widths[i], this.displayWidth(row[i] ?? ""));
+            }
+        }
+        const lines = [];
+        const top = `${c.dim}┌${widths.map((w) => "─".repeat(w + 2)).join("┬")}┐${c.reset}`;
+        const mid = `${c.dim}├${widths.map((w) => "─".repeat(w + 2)).join("┼")}┤${c.reset}`;
+        const bot = `${c.dim}└${widths.map((w) => "─".repeat(w + 2)).join("┴")}┘${c.reset}`;
+        lines.push(top);
+        for (let r = 0; r < this.tableRows.length; r++) {
+            const row = this.tableRows[r];
+            const cells = widths.map((w, i) => {
+                const cell = row[i] ?? "";
+                const padded = this.padToWidth(cell, w);
+                return r === 0 ? `${c.bold}${padded}${c.reset}` : padded;
+            });
+            lines.push(`${c.dim}│${c.reset} ${cells.join(` ${c.dim}│${c.reset} `)} ${c.dim}│${c.reset}`);
+            if (r === 0)
+                lines.push(mid);
+        }
+        lines.push(bot);
+        return lines.join("\n") + "\n";
+    }
     formatInline(line, c) {
         // Split by inline code spans; format outside segments only
         const parts = line.split(/(`[^`]*`)/g);

package/dist/tools/index.js

@@ -9,7 +9,23 @@ import { webFetchTool } from "./web_fetch.js";
 import { todoTool } from "./todo.js";
 import { questionTool } from "./question.js";
 import { codeSearchTool } from "./code_search.js";
-export function createTools() {
+/** Chat mode: general assistant tools (fewer tools = less token overhead) */
+export function createChatTools() {
+    const tools = {
+        bash: bashTool,
+        read: readTool,
+        write: writeTool,
+        edit: editTool,
+        glob: globTool,
+        grep: grepTool,
+        web_search: webSearchTool,
+        web_fetch: webFetchTool,
+        question: questionTool,
+    };
+    return tools;
+}
+/** Code mode: full tool set including task tracking and code search */
+export function createCodeTools() {
     const tools = {
         bash: bashTool,
         read: readTool,
@@ -27,3 +43,7 @@ export function createTools() {
     }
     return tools;
 }
+/** @deprecated Use createChatTools or createCodeTools */
+export function createTools() {
+    return createChatTools();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-agent",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "type": "module",
   "description": "Minimal AI coding agent with tool use, MCP, and skills support",
   "license": "MIT",