min-agent 0.1.5 → 0.1.6

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/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`);
+}

package/dist/skills.js

@@ -3,6 +3,7 @@ import { readFileSync, existsSync, readdirSync, statSync } from "fs";
 import os from "os";
 import path from "path";
 import { globSync } from "glob";
+import { loadConfig } from "./config.js";
 /**
  * Skill scan order: later entries win on duplicate `name` in frontmatter.
  * Global user skills first, then project-local dirs so repo skills override ~/.agents.
@@ -15,7 +16,7 @@ const SKILL_DIRS = [
     path.join(process.cwd(), ".claude", "skills"),
 ];
 let loadedSkills = {};
-export function discoverSkills() {
+export function discoverSkills(opts) {
     loadedSkills = {};
     for (const dir of SKILL_DIRS) {
         if (!existsSync(dir))
@@ -29,8 +30,10 @@ export function discoverSkills() {
         }
     }
     const count = Object.keys(loadedSkills).length;
-    if (count > 0) {
-        console.log(`\x1b[90m  Skills loaded: ${count} (${Object.keys(loadedSkills).join(", ")})\x1b[0m`);
+    if (count > 0 && !opts?.silent) {
+        const disabled = new Set(loadConfig().disabledSkills ?? []);
+        const enabledCount = Object.keys(loadedSkills).filter((n) => !disabled.has(n)).length;
+        console.log(`\x1b[90m  Skills: ${enabledCount} enabled${count > enabledCount ? `, ${count - enabledCount} disabled` : ""}\x1b[0m`);
     }
 }
 function parseSkillFile(filePath) {
@@ -58,7 +61,8 @@ function parseSkillFile(filePath) {
     }
 }
 export function getSkills() {
-    return Object.values(loadedSkills);
+    const disabled = new Set(loadConfig().disabledSkills ?? []);
+    return Object.values(loadedSkills).filter((s) => !disabled.has(s.name));
 }
 export function getSkill(name) {
     return loadedSkills[name];
@@ -74,9 +78,13 @@ export function getSkillsTool() {
             required: ["name"],
         }),
         execute: async ({ name }) => {
+            const disabled = new Set(loadConfig().disabledSkills ?? []);
+            if (disabled.has(name)) {
+                return `Skill "${name}" is disabled. Available skills: ${getSkills().map((s) => s.name).join(", ") || "none"}`;
+            }
             const skill = loadedSkills[name];
             if (!skill) {
-                const available = Object.keys(loadedSkills);
+                const available = getSkills().map((s) => s.name);
                 return `Skill "${name}" not found. Available skills: ${available.length ? available.join(", ") : "none"}`;
             }
             const dir = path.dirname(skill.location);
@@ -104,7 +112,7 @@ export function getSkillsTool() {
     });
 }
 export function getSkillsSystemPrompt() {
-    const skills = Object.values(loadedSkills);
+    const skills = getSkills();
     if (skills.length === 0)
         return "";
     return [
@@ -115,7 +123,7 @@ export function getSkillsSystemPrompt() {
     ].join("\n");
 }
 function buildSkillDescription() {
-    const skills = Object.values(loadedSkills);
+    const skills = getSkills();
     if (skills.length === 0)
         return "Load a specialized skill. No skills are currently available.";
     return [

package/dist/tools/bash.js

@@ -21,11 +21,15 @@ export const bashTool = tool({
             const chunks = [];
             let killed = false;
             let timer;
-            const proc = spawn(command, [], {
+            // On Windows, force UTF-8 codepage to avoid Chinese garbled text
+            const isWin = process.platform === "win32";
+            const actualCommand = isWin ? `chcp 65001 >nul && ${command}` : command;
+            const proc = spawn(actualCommand, [], {
                 shell: true,
                 cwd: process.cwd(),
                 stdio: ["ignore", "pipe", "pipe"],
                 detached: process.platform !== "win32",
+                env: { ...process.env, ...(isWin ? { PYTHONIOENCODING: "utf-8" } : {}) },
             });
             proc.stdout?.on("data", (chunk) => chunks.push(chunk));
             proc.stderr?.on("data", (chunk) => chunks.push(chunk));