min-agent 0.1.4 → 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";
@@ -24,6 +24,7 @@ Usage:
   min-agent chat <message>          Send a message to the agent
   min-agent chat                    Start interactive multi-turn chat
   min-agent chat --resume <id>      Resume a previous session
+  min-agent code                    AI coding mode (project-aware)
   min-agent setup                   Configure API provider (interactive)
   min-agent models                  List available models
   min-agent history                 List saved sessions
@@ -159,7 +160,6 @@ async function main() {
             }
             const message = chatArgs.join(" ");
             if (!message) {
-                // No message provided — enter interactive multi-turn mode
                 await runChat(modelOverride, resumeId);
             }
             else {
@@ -167,6 +167,25 @@ async function main() {
             }
             break;
         }
+        case "code": {
+            if (!isConfigured()) {
+                console.error("Not configured. Run: min-agent setup");
+                process.exit(1);
+            }
+            let modelOverride;
+            let resumeId;
+            for (let i = 1; i < args.length; i++) {
+                if ((args[i] === "--model" || args[i] === "-m") && args[i + 1]) {
+                    modelOverride = args[++i];
+                }
+                else if (args[i] === "--resume" && args[i + 1]) {
+                    resumeId = args[++i];
+                }
+            }
+            const { runCode } = await import("./agent.js");
+            await runCode(modelOverride, resumeId);
+            break;
+        }
         case "serve": {
             if (!isConfigured()) {
                 console.error("Not configured. Run: min-agent setup");
@@ -188,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];
@@ -256,17 +288,45 @@ 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": {
                     const results = await checkAllMcpServers();
                     if (results.length === 0) {
@@ -298,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;
@@ -391,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/clipboard.js

@@ -0,0 +1,106 @@
+import { execSync } from "child_process";
+import path from "path";
+import os from "os";
+export function getClipboardImage() {
+    switch (process.platform) {
+        case "darwin":
+            return getClipboardImageMac();
+        case "linux":
+            return getClipboardImageLinux();
+        case "win32":
+            return getClipboardImageWindows();
+        default:
+            return null;
+    }
+}
+function getClipboardImageMac() {
+    const tmpFile = path.join(os.tmpdir(), `min-agent-paste-${Date.now()}.png`);
+    try {
+        // Try pngpaste first (brew install pngpaste)
+        execSync(`pngpaste "${tmpFile}" 2>/dev/null`, { stdio: "pipe" });
+        const { readFileSync } = require("fs");
+        const data = readFileSync(tmpFile);
+        try {
+            require("fs").unlinkSync(tmpFile);
+        }
+        catch { }
+        if (data.length > 0)
+            return { data, mimeType: "image/png" };
+    }
+    catch { }
+    try {
+        // Fallback: osascript to save clipboard image
+        const script = `
+      set tmpFile to POSIX file "${tmpFile}"
+      try
+        set imgData to the clipboard as «class PNGf»
+        set fp to open for access tmpFile with write permission
+        write imgData to fp
+        close access fp
+        return "ok"
+      on error
+        return "no_image"
+      end try
+    `;
+        const result = execSync(`osascript -e '${script.replace(/'/g, "'\\''")}'`, { encoding: "utf-8" }).trim();
+        if (result === "ok") {
+            const { readFileSync, unlinkSync } = require("fs");
+            const data = readFileSync(tmpFile);
+            try {
+                unlinkSync(tmpFile);
+            }
+            catch { }
+            if (data.length > 0)
+                return { data, mimeType: "image/png" };
+        }
+    }
+    catch { }
+    return null;
+}
+function getClipboardImageLinux() {
+    try {
+        // xclip
+        const data = execSync("xclip -selection clipboard -t image/png -o 2>/dev/null", {
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        if (data.length > 0)
+            return { data, mimeType: "image/png" };
+    }
+    catch { }
+    try {
+        // xsel fallback
+        const data = execSync("xsel --clipboard --output 2>/dev/null", {
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        // Check if it's actually image data (PNG magic bytes)
+        if (data.length > 8 && data[0] === 0x89 && data[1] === 0x50) {
+            return { data, mimeType: "image/png" };
+        }
+    }
+    catch { }
+    return null;
+}
+function getClipboardImageWindows() {
+    const tmpFile = path.join(os.tmpdir(), `min-agent-paste-${Date.now()}.png`);
+    try {
+        const ps = `
+      Add-Type -AssemblyName System.Windows.Forms
+      $img = [System.Windows.Forms.Clipboard]::GetImage()
+      if ($img) { $img.Save('${tmpFile.replace(/\\/g, "\\\\")}', [System.Drawing.Imaging.ImageFormat]::Png); Write-Output 'ok' }
+      else { Write-Output 'no_image' }
+    `;
+        const result = execSync(`powershell -NoProfile -Command "${ps}"`, { encoding: "utf-8" }).trim();
+        if (result === "ok") {
+            const { readFileSync, unlinkSync } = require("fs");
+            const data = readFileSync(tmpFile);
+            try {
+                unlinkSync(tmpFile);
+            }
+            catch { }
+            if (data.length > 0)
+                return { data, mimeType: "image/png" };
+        }
+    }
+    catch { }
+    return null;
+}

package/dist/code-mode.js

@@ -0,0 +1,166 @@
+import { execSync } from "child_process";
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import path from "path";
+export function scanProject() {
+    const cwd = process.cwd();
+    const isGitRepo = existsSync(path.join(cwd, ".git"));
+    let branch;
+    if (isGitRepo) {
+        try {
+            branch = execSync("git branch --show-current", { encoding: "utf-8", cwd }).trim();
+        }
+        catch { }
+    }
+    const languages = [];
+    const configFiles = [];
+    const entryFiles = [];
+    // Detect by config files
+    const checks = [
+        { file: "package.json", lang: "TypeScript/JavaScript", pm: "npm" },
+        { file: "bun.lock", lang: "TypeScript/JavaScript", pm: "bun" },
+        { file: "yarn.lock", lang: "TypeScript/JavaScript", pm: "yarn" },
+        { file: "pnpm-lock.yaml", lang: "TypeScript/JavaScript", pm: "pnpm" },
+        { file: "tsconfig.json", lang: "TypeScript" },
+        { file: "Cargo.toml", lang: "Rust", pm: "cargo" },
+        { file: "go.mod", lang: "Go" },
+        { file: "pyproject.toml", lang: "Python", pm: "pip/uv" },
+        { file: "requirements.txt", lang: "Python", pm: "pip" },
+        { file: "Gemfile", lang: "Ruby", pm: "bundler" },
+        { file: "pom.xml", lang: "Java", pm: "maven" },
+        { file: "build.gradle", lang: "Java/Kotlin", pm: "gradle" },
+        { file: "composer.json", lang: "PHP", pm: "composer" },
+        { file: "Makefile", lang: "" },
+        { file: "Dockerfile", lang: "" },
+    ];
+    let packageManager;
+    let framework;
+    for (const check of checks) {
+        if (existsSync(path.join(cwd, check.file))) {
+            configFiles.push(check.file);
+            if (check.lang && !languages.includes(check.lang))
+                languages.push(check.lang);
+            if (check.pm && !packageManager)
+                packageManager = check.pm;
+        }
+    }
+    // Detect framework from package.json
+    if (existsSync(path.join(cwd, "package.json"))) {
+        try {
+            const pkg = JSON.parse(readFileSync(path.join(cwd, "package.json"), "utf-8"));
+            const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (allDeps["next"])
+                framework = "Next.js";
+            else if (allDeps["nuxt"])
+                framework = "Nuxt";
+            else if (allDeps["@angular/core"])
+                framework = "Angular";
+            else if (allDeps["vue"])
+                framework = "Vue";
+            else if (allDeps["react"])
+                framework = "React";
+            else if (allDeps["svelte"])
+                framework = "Svelte";
+            else if (allDeps["express"])
+                framework = "Express";
+            else if (allDeps["fastify"])
+                framework = "Fastify";
+            else if (allDeps["hono"])
+                framework = "Hono";
+            else if (allDeps["effect"])
+                framework = "Effect";
+        }
+        catch { }
+    }
+    // Find entry files
+    const entryPatterns = [
+        "src/index.ts", "src/index.js", "src/main.ts", "src/main.js",
+        "src/app.ts", "src/app.js", "index.ts", "index.js",
+        "main.ts", "main.js", "app.ts", "app.js",
+        "src/lib.rs", "main.go", "main.py", "app.py",
+    ];
+    for (const p of entryPatterns) {
+        if (existsSync(path.join(cwd, p)))
+            entryFiles.push(p);
+    }
+    // Build summary
+    const parts = [];
+    parts.push(`Directory: ${cwd}`);
+    if (isGitRepo)
+        parts.push(`Git: yes (branch: ${branch ?? "unknown"})`);
+    if (languages.length)
+        parts.push(`Languages: ${languages.join(", ")}`);
+    if (framework)
+        parts.push(`Framework: ${framework}`);
+    if (packageManager)
+        parts.push(`Package manager: ${packageManager}`);
+    if (configFiles.length)
+        parts.push(`Config files: ${configFiles.join(", ")}`);
+    if (entryFiles.length)
+        parts.push(`Entry points: ${entryFiles.join(", ")}`);
+    // List top-level directory structure
+    try {
+        const items = readdirSync(cwd)
+            .filter((f) => !f.startsWith(".") || f === ".env.example")
+            .filter((f) => f !== "node_modules" && f !== ".git")
+            .slice(0, 30)
+            .map((f) => {
+            const stat = statSync(path.join(cwd, f));
+            return stat.isDirectory() ? `${f}/` : f;
+        });
+        parts.push(`Structure: ${items.join(", ")}`);
+    }
+    catch { }
+    return {
+        directory: cwd,
+        isGitRepo,
+        branch,
+        languages,
+        framework,
+        packageManager,
+        entryFiles,
+        configFiles,
+        summary: parts.join("\n"),
+    };
+}
+export function buildCodeSystemPrompt(project, instructions) {
+    const parts = [
+        "You are an expert AI coding assistant. You help users with software engineering tasks including writing code, debugging, refactoring, and architecture decisions.",
+        "",
+        "# Principles",
+        "- Be concise and direct. Minimize output tokens while maintaining quality.",
+        "- NEVER add comments to code unless asked. Write self-documenting code.",
+        "- Follow existing code conventions in the project. Mimic style, libraries, and patterns.",
+        "- NEVER assume a library is available — check package.json/Cargo.toml/etc first.",
+        "- Prefer editing existing files over creating new ones.",
+        "- After making changes, run lint/typecheck/build if available.",
+        "- NEVER commit unless explicitly asked.",
+        "",
+        "# Workflow",
+        "- Use search tools (grep, glob) to understand the codebase before making changes.",
+        "- Use the edit tool for precise changes instead of rewriting entire files.",
+        "- When fixing bugs: read the relevant code, understand the issue, fix it, verify.",
+        "- When adding features: explore existing patterns first, then implement consistently.",
+        "- Run tests after changes when a test command is available.",
+        "",
+        "# Environment",
+        `<env>`,
+        `  Working directory: ${project.directory}`,
+        `  Git repo: ${project.isGitRepo ? `yes (branch: ${project.branch ?? "unknown"})` : "no"}`,
+        `  Platform: ${process.platform}`,
+        `  Date: ${new Date().toDateString()}`,
+        project.languages.length ? `  Languages: ${project.languages.join(", ")}` : "",
+        project.framework ? `  Framework: ${project.framework}` : "",
+        project.packageManager ? `  Package manager: ${project.packageManager}` : "",
+        `</env>`,
+        "",
+        "# Project Structure",
+        "```",
+        project.summary,
+        "```",
+    ].filter(Boolean);
+    if (instructions.length > 0) {
+        parts.push("", "# User Instructions", "");
+        parts.push(...instructions);
+    }
+    return parts.join("\n");
+}