min-agent 0.1.5 → 0.1.7

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/cli.js

@@ -2,7 +2,7 @@ import { runAgent, runChat } from "./agent.js";
 import { loadMcpConfig, saveMcpConfig, checkMcpServer, checkAllMcpServers, formatMcpServerBinding, } from "./mcp.js";
 import { discoverSkills, getSkills } from "./skills.js";
 import { loadMemories, addMemory, deleteMemory, searchMemories } from "./memory.js";
-import { runSetup, isConfigured, loadConfig, fetchModels, getConfigDir, getRulesFile } from "./config.js";
+import { runSetup, isConfigured, loadConfig, saveConfig, fetchModels, getConfigDir, getRulesFile } from "./config.js";
 import { setAutoApprove } from "./confirm.js";
 import { existsSync, writeFileSync, mkdirSync } from "fs";
 import path from "path";
@@ -207,6 +207,19 @@ async function main() {
         }
         case "mcp": {
             const subcommand = args[1];
+            if (subcommand === "-h" || subcommand === "--help" || !subcommand) {
+                console.log(`Usage: min-agent mcp <command>
+
+Commands:
+  list              List configured MCP servers (name + status)
+  info <name>       Show details of a server
+  add <name> ...    Add a new server (stdio or remote)
+  remove <name>     Remove a server
+  enable <name>     Enable a disabled server
+  disable <name>    Disable a server
+  check             Test connectivity of all servers`);
+                process.exit(0);
+            }
             switch (subcommand) {
                 case "add": {
                     const name = args[2];
@@ -275,15 +288,43 @@ async function main() {
                     const servers = Object.entries(config.mcpServers);
                     if (servers.length === 0) {
                         console.log("No MCP servers configured.");
-                        console.log("Add one with: min-agent mcp add <name> <command...>  or  --url <https://...>");
+                        console.log("Add one with: min-agent mcp add <name> <command...>");
                     }
                     else {
                         console.log("MCP Servers:");
                         for (const [name, cfg] of servers) {
-                            const status = cfg.enabled === false ? " (disabled)" : "";
-                            console.log(`  ${name}: ${formatMcpServerBinding(cfg)}${status}`);
+                            const status = cfg.enabled === false ? "\x1b[90mdisabled\x1b[0m" : "\x1b[32menabled\x1b[0m";
+                            console.log(`  ${name}  ${status}`);
                         }
+                        console.log("\nUse: min-agent mcp info <name>  for details");
+                    }
+                    break;
+                }
+                case "info": {
+                    const name = args[2];
+                    if (!name) {
+                        console.error("Usage: min-agent mcp info <name>");
+                        process.exit(1);
                     }
+                    const config = loadMcpConfig();
+                    const cfg = config.mcpServers[name];
+                    if (!cfg) {
+                        console.error(`MCP server "${name}" not found`);
+                        process.exit(1);
+                    }
+                    console.log(`Name:      ${name}`);
+                    console.log(`Status:    ${cfg.enabled === false ? "disabled" : "enabled"}`);
+                    console.log(`Binding:   ${formatMcpServerBinding(cfg)}`);
+                    if (cfg.command)
+                        console.log(`Command:   ${Array.isArray(cfg.command) ? cfg.command.join(" ") : `${cfg.command} ${(cfg.args ?? []).join(" ")}`.trim()}`);
+                    if (cfg.url)
+                        console.log(`URL:       ${cfg.url}`);
+                    if (cfg.token)
+                        console.log(`Token:     ***`);
+                    if (cfg.environment)
+                        console.log(`Env:       ${Object.keys(cfg.environment).join(", ")}`);
+                    if (cfg.timeout)
+                        console.log(`Timeout:   ${cfg.timeout}ms`);
                     break;
                 }
                 case "check": {
@@ -317,8 +358,44 @@ async function main() {
                     }
                     break;
                 }
+                case "enable": {
+                    const names = args.slice(2);
+                    if (names.length === 0) {
+                        console.error("Usage: min-agent mcp enable <name...>");
+                        process.exit(1);
+                    }
+                    const config = loadMcpConfig();
+                    for (const name of names) {
+                        if (!config.mcpServers[name]) {
+                            console.error(`MCP server "${name}" not found`);
+                            continue;
+                        }
+                        config.mcpServers[name].enabled = true;
+                        console.log(`✓ MCP server "${name}" enabled`);
+                    }
+                    saveMcpConfig(config);
+                    break;
+                }
+                case "disable": {
+                    const names = args.slice(2);
+                    if (names.length === 0) {
+                        console.error("Usage: min-agent mcp disable <name...>");
+                        process.exit(1);
+                    }
+                    const config = loadMcpConfig();
+                    for (const name of names) {
+                        if (!config.mcpServers[name]) {
+                            console.error(`MCP server "${name}" not found`);
+                            continue;
+                        }
+                        config.mcpServers[name].enabled = false;
+                        console.log(`✓ MCP server "${name}" disabled`);
+                    }
+                    saveMcpConfig(config);
+                    break;
+                }
                 default:
-                    console.error("Usage: min-agent mcp [add|remove|list|check]");
+                    console.error("Usage: min-agent mcp -h");
                     process.exit(1);
             }
             break;
@@ -410,35 +487,89 @@ async function main() {
         }
         case "skills": {
             const subcommand = args[1];
+            if (subcommand === "-h" || subcommand === "--help" || !subcommand) {
+                console.log(`Usage: min-agent skills <command>
+
+Commands:
+  list              List skills (name + status)
+  info <name>       Show details of a skill
+  enable <name>     Enable a disabled skill
+  disable <name>    Disable a skill`);
+                process.exit(0);
+            }
             switch (subcommand) {
+                case "info": {
+                    const name = args[2];
+                    if (!name) {
+                        console.error("Usage: min-agent skills info <name>");
+                        process.exit(1);
+                    }
+                    discoverSkills({ silent: true });
+                    const { getSkill } = await import("./skills.js");
+                    const skill = getSkill(name);
+                    if (!skill) {
+                        console.error(`Skill "${name}" not found`);
+                        process.exit(1);
+                    }
+                    const config = loadConfig();
+                    const isDisabled = (config.disabledSkills ?? []).includes(name);
+                    console.log(`Name:        ${skill.name}`);
+                    console.log(`Status:      ${isDisabled ? "disabled" : "enabled"}`);
+                    console.log(`Description: ${skill.description}`);
+                    console.log(`Location:    ${skill.location}`);
+                    break;
+                }
+                case "enable": {
+                    const names = args.slice(2);
+                    if (names.length === 0) {
+                        console.error("Usage: min-agent skills enable <name...>");
+                        process.exit(1);
+                    }
+                    const config = loadConfig();
+                    config.disabledSkills = (config.disabledSkills ?? []).filter((s) => !names.includes(s));
+                    saveConfig(config);
+                    for (const name of names)
+                        console.log(`✓ Skill "${name}" enabled`);
+                    break;
+                }
+                case "disable": {
+                    const names = args.slice(2);
+                    if (names.length === 0) {
+                        console.error("Usage: min-agent skills disable <name...>");
+                        process.exit(1);
+                    }
+                    const config = loadConfig();
+                    const disabled = config.disabledSkills ?? [];
+                    for (const name of names) {
+                        if (!disabled.includes(name))
+                            disabled.push(name);
+                        console.log(`✓ Skill "${name}" disabled`);
+                    }
+                    config.disabledSkills = disabled;
+                    saveConfig(config);
+                    break;
+                }
                 case "list": {
-                    discoverSkills();
+                    discoverSkills({ silent: true });
                     const skills = getSkills();
-                    if (skills.length === 0) {
-                        console.log("No skills found.");
-                        console.log("Add skills by creating SKILL.md files in:");
-                        console.log("  ~/.agents/skills/<name>/SKILL.md   (global, all projects)");
-                        console.log("  .min-agent/skills/<name>/SKILL.md");
-                        console.log("  .opencode/skills/<name>/SKILL.md");
-                        console.log("");
-                        console.log("SKILL.md format:");
-                        console.log("  ---");
-                        console.log("  name: my-skill");
-                        console.log("  description: What this skill does");
-                        console.log("  ---");
-                        console.log("  # Instructions content...");
+                    const config = loadConfig();
+                    const disabledNames = config.disabledSkills ?? [];
+                    if (skills.length === 0 && disabledNames.length === 0) {
+                        console.log("No skills found. Add SKILL.md files in .min-agent/skills/<name>/");
+                        break;
                     }
-                    else {
-                        console.log("Available Skills:");
-                        for (const skill of skills) {
-                            console.log(`  ${skill.name}: ${skill.description}`);
-                            console.log(`    ${skill.location}`);
-                        }
+                    console.log("Skills:");
+                    for (const skill of skills) {
+                        console.log(`  ${skill.name}  \x1b[32menabled\x1b[0m`);
+                    }
+                    for (const n of disabledNames) {
+                        console.log(`  ${n}  \x1b[90mdisabled\x1b[0m`);
                     }
+                    console.log("\nUse: min-agent skills info <name>  for details");
                     break;
                 }
                 default:
-                    console.error("Usage: min-agent skills [list]");
+                    console.error("Usage: min-agent skills -h");
                     process.exit(1);
             }
             break;

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/mcp.js

@@ -7,24 +7,47 @@ import { tool, jsonSchema } from "ai";
 import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs";
 import path from "path";
 import { truncateToolOutput } from "./tool-output.js";
+import { getConfigDir } from "./config.js";
 const DEFAULT_TIMEOUT = 30000;
 function getMcpConfigPath() {
-    return path.join(process.cwd(), ".min-agent", "mcp.json");
+    // Check project-local first, then global
+    const local = path.join(process.cwd(), ".min-agent", "mcp.json");
+    if (existsSync(local))
+        return local;
+    return path.join(getConfigDir(), "mcp.json");
+}
+function getMcpConfigWritePath() {
+    // Write to project-local if it exists, otherwise global
+    const local = path.join(process.cwd(), ".min-agent", "mcp.json");
+    if (existsSync(path.dirname(local)))
+        return local;
+    return path.join(getConfigDir(), "mcp.json");
 }
 let connectedServers = {};
 export function loadMcpConfig() {
-    const configPath = getMcpConfigPath();
-    if (!existsSync(configPath))
-        return { mcpServers: {} };
-    try {
-        return JSON.parse(readFileSync(configPath, "utf-8"));
+    const globalPath = path.join(getConfigDir(), "mcp.json");
+    const localPath = path.join(process.cwd(), ".min-agent", "mcp.json");
+    let config = { mcpServers: {} };
+    // Load global first
+    if (existsSync(globalPath)) {
+        try {
+            const global = JSON.parse(readFileSync(globalPath, "utf-8"));
+            config.mcpServers = { ...config.mcpServers, ...global.mcpServers };
+        }
+        catch { }
     }
-    catch {
-        return { mcpServers: {} };
+    // Local overrides global
+    if (existsSync(localPath) && localPath !== globalPath) {
+        try {
+            const local = JSON.parse(readFileSync(localPath, "utf-8"));
+            config.mcpServers = { ...config.mcpServers, ...local.mcpServers };
+        }
+        catch { }
     }
+    return config;
 }
 export function saveMcpConfig(config) {
-    const configPath = getMcpConfigPath();
+    const configPath = path.join(getConfigDir(), "mcp.json");
     const dir = path.dirname(configPath);
     mkdirSync(dir, { recursive: true });
     writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
@@ -43,7 +66,21 @@ function buildRemoteRequestInit(config) {
     return { headers };
 }
 async function openStdioMcpServer(name, config) {
-    const [cmd, ...args] = config.command ?? [];
+    // Support both formats:
+    // { command: ["uvx", "mcp-server-time"] }           — min-agent native
+    // { command: "uvx", args: ["mcp-server-time"] }     — opencode/claude style
+    let cmd;
+    let args;
+    if (Array.isArray(config.command)) {
+        [cmd, ...args] = config.command;
+    }
+    else if (typeof config.command === "string") {
+        cmd = config.command;
+        args = config.args ?? [];
+    }
+    else {
+        throw new Error(`MCP "${name}" has empty command`);
+    }
     if (!cmd) {
         throw new Error(`MCP "${name}" has empty command`);
     }
@@ -131,13 +168,18 @@ export function formatMcpServerBinding(config) {
         const mode = config.remoteTransport ?? "auto";
         return `${config.url} [remote:${mode}]`;
     }
-    return (config.command ?? []).join(" ");
+    const cmd = Array.isArray(config.command) ? config.command.join(" ") : `${config.command ?? ""} ${(config.args ?? []).join(" ")}`.trim();
+    return cmd || "(no command)";
 }
 export async function connectMcpServer(name, config) {
     if (config.enabled === false)
         return null;
+    const timeout = config.timeout ?? DEFAULT_TIMEOUT;
     try {
-        const server = await openMcpServer(name, config);
+        const server = await Promise.race([
+            openMcpServer(name, config),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`connection timed out after ${timeout}ms`)), timeout)),
+        ]);
         console.log(`\x1b[90m  MCP "${name}" connected (${server.tools.length} tools)\x1b[0m`);
         return server;
     }

package/dist/paste-handler.js

@@ -0,0 +1,41 @@
+/**
+ * Paste handler for large text input.
+ *
+ * When the user pastes large content (multi-line or >150 chars),
+ * shows a collapsed summary in the terminal but preserves the full
+ * text for sending to the model.
+ *
+ * Based on opencode's paste handling in the TUI prompt component.
+ */
+const PASTE_LINE_THRESHOLD = 3;
+const PASTE_CHAR_THRESHOLD = 150;
+const PREVIEW_LINES = 3;
+/**
+ * Process input text and detect if it's a large paste.
+ * Returns the full text plus display metadata.
+ */
+export function processPastedInput(text) {
+    const lineCount = (text.match(/\n/g)?.length ?? 0) + 1;
+    if (lineCount < PASTE_LINE_THRESHOLD && text.length <= PASTE_CHAR_THRESHOLD) {
+        return { fullText: text, isLargePaste: false };
+    }
+    const lines = text.split("\n");
+    const preview = lines.slice(0, PREVIEW_LINES).join("\n");
+    const remaining = lineCount - PREVIEW_LINES;
+    return {
+        fullText: text,
+        isLargePaste: true,
+        summary: remaining > 0
+            ? `${preview}\n\x1b[90m  ... (${remaining} more lines, ~${text.length} chars total)\x1b[0m`
+            : `\x1b[90m[Pasted ${text.length} chars]\x1b[0m`,
+    };
+}
+/**
+ * Print paste feedback to the user.
+ */
+export function printPasteFeedback(result) {
+    if (!result.isLargePaste)
+        return;
+    const lineCount = (result.fullText.match(/\n/g)?.length ?? 0) + 1;
+    console.log(`\x1b[90m  📋 Pasted ~${lineCount} lines (${result.fullText.length} chars)\x1b[0m`);
+}