min-agent 0.5.0 → 0.6.0

package/dist/cli/program.js

@@ -1,217 +0,0 @@
-import { Command, Option } from "commander";
-import { setAutoApprove } from "../confirm.js";
-import { CliError, formatCliError, exitCodeFor } from "./errors.js";
-import { parseNetworkPolicyArg, parsePermissionModeArg, parseSandboxModeArg, parseThinkingEffortArg, parseMemoryModeArg, } from "./option-helpers.js";
-import { localVersion } from "../updater.js";
-function collectImage(value, previous) {
-    return [...previous, value];
-}
-/** Options shared across the root command and `exec` (session-affecting flags). */
-export function addSessionOptions(cmd) {
-    return cmd
-        .option("-m, --model <model>", "Override model for this request")
-        .option("--provider <name>", "Use a specific configured provider")
-        .option("--resume <id>", "Resume a previous session by id")
-        .option("-i, --image <path>", "Attach an image (repeatable)", collectImage, [])
-        .addOption(new Option("--sandbox <mode>", "Isolation mode (off, workspace, strict)").argParser(parseSandboxModeArg))
-        .addOption(new Option("--network <policy>", "Network policy (allow, deny)").argParser(parseNetworkPolicyArg))
-        .addOption(new Option("--permission <mode>", "Confirmation mode (ask, accept-edits, allow-all)").argParser(parsePermissionModeArg))
-        .addOption(new Option("--think <level>", "Thinking intensity (off, low, medium, high, max)").argParser(parseThinkingEffortArg))
-        .addOption(new Option("--memory <mode>", "Memory across sessions (on, off; default off)").argParser(parseMemoryModeArg))
-        .option("--project", "Write --permission/--sandbox/--think/--memory to this repo's config")
-        .option("--global", "Write --permission/--sandbox/--think/--memory to the global config")
-        .option("-y, --yes", "This session only: same as --permission allow-all");
-}
-export function buildProgram() {
-    const program = new Command("min-agent");
-    program
-        .description("min-agent - Minimal AI coding agent")
-        .version(localVersion(), "-v, --version", "Show version number")
-        .helpOption("-h, --help", "Show help")
-        .allowUnknownOption()
-        .enablePositionalOptions()
-        .configureOutput({
-        writeErr: (str) => process.stderr.write(str),
-        outputError: (str) => process.stderr.write(str),
-    })
-        .exitOverride();
-    addSessionOptions(program);
-    program.argument("[prompt...]", "Prompt to send in an interactive session");
-    program.addHelpText("after", `
-Session:
-  min-agent                          Start interactive session
-  min-agent <message>                Start interactive session and send message
-  min-agent --resume <id>            Resume a previous interactive session
-  min-agent chat | code              Same as interactive session (compat)
-  min-agent exec <message>           Run one message non-interactively
-  min-agent exec --resume <id> <msg> Continue a saved exec session
-
-Setup & config:
-  min-agent setup                    Configure providers (interactively)
-  min-agent init                     Initialize .min-agent/ in current directory
-  min-agent models                   List available models
-  min-agent rules [edit]             Show or edit instruction rules
-  min-agent memory [on|off]                  Show or set memory (off by default)
-  min-agent memory <add|search|delete>       Manage saved memories
-  min-agent sandbox [off|workspace|strict]    Show or set isolation mode
-  min-agent sandbox network <allow|deny>      Show or set network policy
-  min-agent permission [ask|accept-edits|allow-all]  Show or set confirmation mode
-  min-agent think [off|low|medium|high|max]          Show or set thinking intensity
-
-Integrations:
-  min-agent mcp <list|add|remove|info|check|enable|disable>   Manage MCP servers
-  min-agent skills <list|info|new|enable|disable>             Manage skills
-
-Operations:
-  min-agent serve [--host H] [--port P]   Start the HTTP API (see docs/API.md)
-  min-agent history [delete|rename|export]  Manage saved sessions
-  min-agent update                          Upgrade to the latest npm release
-
-Confirmation modes (default: ask; independent of isolation):
-  ask            Prompt before dangerous operations
-  accept-edits   Auto-approve file writes; still prompt for dangerous commands
-  allow-all      Auto-approve everything
-
-Thinking intensity (default: medium):
-  off        Disable thinking
-  low        Light reasoning
-  medium     Standard reasoning
-  high       Strong reasoning
-  max        Highest reasoning
-
-Memory (default: off):
-  off        Do not inject memories or expose memory tools
-  on         Remember facts across sessions
-
-Isolation modes (default: off; independent of confirmation):
-  off        No sandboxing
-  workspace  Restrict file writes to the project workspace
-  strict     Restrict file writes and deny risky commands
-  Env: MIN_AGENT_SANDBOX, MIN_AGENT_SANDBOX_NETWORK
-
-Rules (loaded as system instructions):
-  Global:  ~/.min-agent/rules.md
-  Project: ./AGENTS.md or ./RULES.md or ./.min-agent/AGENTS.md
-  Config:  "instructions" array in ~/.min-agent/config.json
-
-Examples:
-  min-agent setup
-  min-agent
-  min-agent "hello"
-  min-agent exec "hello"
-  min-agent exec --resume <id> "continue"
-  min-agent --resume <id>
-  min-agent --permission ask
-  min-agent --think max
-  min-agent --memory on
-  min-agent serve --port 8787
-  min-agent update
-  min-agent rules edit
-  min-agent mcp add filesystem npx -y @modelcontextprotocol/server-filesystem /tmp
-  min-agent mcp add remote --url https://example.com/mcp --token "$TOKEN"
-`);
-    return program;
-}
-/** Apply --yes/-y for this process. Sandbox/permission overrides are applied per-invocation-kind. */
-export function applySessionOverrides(opts) {
-    if (opts.yes)
-        setAutoApprove(true);
-}
-export async function applySessionRuntimeOverrides(opts) {
-    if (opts.sandbox !== undefined || opts.network !== undefined) {
-        const { setSandboxOverride } = await import("../sandbox.js");
-        if (opts.sandbox !== undefined)
-            setSandboxOverride({ mode: opts.sandbox });
-        if (opts.network !== undefined)
-            setSandboxOverride({ network: opts.network });
-    }
-    if (opts.permission !== undefined) {
-        const { setPermissionOverride } = await import("../confirm.js");
-        setPermissionOverride(opts.permission);
-    }
-    if (opts.think !== undefined) {
-        const { setThinkingOverride } = await import("../thinking.js");
-        setThinkingOverride(opts.think);
-    }
-    if (opts.memory !== undefined) {
-        const { setMemoryOverride } = await import("../memory.js");
-        setMemoryOverride(opts.memory);
-    }
-}
-export function hasSessionIntent(opts, prompt) {
-    return (prompt.length > 0 || Boolean(opts.resume) || opts.image.length > 0 || Boolean(opts.model) || Boolean(opts.provider));
-}
-/** Extract `--unknown` style tokens left over in positionals (from allowUnknownOption) as errors. */
-export function extractUnknownOptionErrors(positionals) {
-    const rest = [];
-    const errors = [];
-    for (const p of positionals) {
-        if (p.startsWith("--"))
-            errors.push(`Unknown option: ${p}`);
-        else
-            rest.push(p);
-    }
-    return { rest, errors };
-}
-async function runRootAction(promptTokens, opts) {
-    applySessionOverrides(opts);
-    const { rest, errors } = extractUnknownOptionErrors(promptTokens);
-    const sessionIntent = hasSessionIntent(opts, rest);
-    const wantsConfigWrite = opts.sandbox !== undefined ||
-        opts.network !== undefined ||
-        opts.permission !== undefined ||
-        opts.think !== undefined ||
-        opts.memory !== undefined;
-    if (wantsConfigWrite && !sessionIntent) {
-        const { runWriteConfig } = await import("./commands/write-config.js");
-        await runWriteConfig({
-            sandbox: opts.sandbox,
-            network: opts.network,
-            permission: opts.permission,
-            think: opts.think,
-            memory: opts.memory,
-            scope: opts.project ? "project" : opts.global ? "global" : undefined,
-        });
-        return;
-    }
-    await applySessionRuntimeOverrides(opts);
-    if (errors.length > 0) {
-        console.error(errors[0]);
-        process.exitCode = 1;
-        return;
-    }
-    const { startTuiSession } = await import("./commands/shared.js");
-    await startTuiSession({
-        model: opts.model,
-        provider: opts.provider,
-        resume: opts.resume,
-        images: opts.image,
-        positionals: rest,
-    });
-}
-export async function runProgram(argv, registerCommands) {
-    const program = buildProgram();
-    program.action((promptTokens, opts) => runRootAction(promptTokens, opts));
-    registerCommands(program);
-    try {
-        await program.parseAsync(argv, { from: "user" });
-    }
-    catch (err) {
-        if (err instanceof CliError) {
-            console.error(formatCliError(err));
-            process.exitCode = exitCodeFor(err);
-            return;
-        }
-        // Commander throws a CommanderError for --help/--version and for its own
-        // usage errors; those already printed output and set process.exitCode.
-        if (isCommanderExit(err)) {
-            process.exitCode = err.exitCode;
-            return;
-        }
-        console.error(formatCliError(err));
-        process.exitCode = 2;
-    }
-}
-function isCommanderExit(err) {
-    return typeof err === "object" && err !== null && "exitCode" in err && "code" in err;
-}

package/dist/clipboard.js

@@ -1,142 +0,0 @@
-import { execSync } from "child_process";
-import { readFileSync, unlinkSync } from "fs";
-import path from "path";
-import os from "os";
-function readTmpImage(tmpFile) {
-    const data = readFileSync(tmpFile);
-    try {
-        unlinkSync(tmpFile);
-    }
-    catch { }
-    return data.length > 0 ? data : null;
-}
-function tmpImagePath() {
-    return path.join(os.tmpdir(), `min-agent-paste-${Date.now()}.png`);
-}
-export function getClipboardImage() {
-    switch (process.platform) {
-        case "darwin":
-            return getClipboardImageMac();
-        case "linux":
-            return getClipboardImageLinux();
-        case "win32":
-            return getClipboardImageWindows();
-        default:
-            return null;
-    }
-}
-/** Write plain text to the system clipboard. False on failure (silent). */
-export function writeClipboard(text) {
-    switch (process.platform) {
-        case "darwin":
-            try {
-                execSync("pbcopy", { input: text, stdio: "pipe" });
-                return true;
-            }
-            catch {
-                return false;
-            }
-        case "linux": {
-            try {
-                execSync("xclip -selection clipboard", { input: text, stdio: "pipe" });
-                return true;
-            }
-            catch { }
-            try {
-                execSync("xsel --clipboard --input", { input: text, stdio: "pipe" });
-                return true;
-            }
-            catch { }
-            return false;
-        }
-        case "win32":
-            try {
-                execSync('powershell -NoProfile -Command "Set-Clipboard -Value ([Console]::In.ReadToEnd())"', {
-                    input: text,
-                    stdio: "pipe",
-                });
-                return true;
-            }
-            catch {
-                return false;
-            }
-        default:
-            return false;
-    }
-}
-function getClipboardImageMac() {
-    const tmpFile = tmpImagePath();
-    try {
-        // Try pngpaste first (brew install pngpaste)
-        execSync(`pngpaste "${tmpFile}" 2>/dev/null`, { stdio: "pipe" });
-        const data = readTmpImage(tmpFile);
-        if (data)
-            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 data = readTmpImage(tmpFile);
-            if (data)
-                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 = tmpImagePath();
-    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 data = readTmpImage(tmpFile);
-            if (data)
-                return { data, mimeType: "image/png" };
-        }
-    }
-    catch { }
-    return null;
-}

package/dist/code-mode.js

@@ -1,184 +0,0 @@
-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, timeout: 5000 }).trim();
-        }
-        catch { }
-    }
-    const languages = [];
-    const configFiles = [];
-    const entryFiles = [];
-    // Detect by config files (lockfiles first so they win over package.json)
-    const checks = [
-        { 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: "package.json", lang: "TypeScript/JavaScript", pm: "npm" },
-        { 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.",
-        "- When the user asks to configure, install, or manage MCP servers, skills, rules, memory, permission, sandbox, providers, plugins, or other min-agent settings, follow the built-in `self-config` skill (already loaded). If its instructions are missing, load it with the skill tool before making changes.",
-        "",
-        "# Workflow",
-        "- For greetings, thanks, or general chat with no concrete task, reply directly — do not call any tools. Memories and session state are not a reason to start work; only the current user message is. The Project Structure below already covers the basics; do not re-explore the codebase just to answer a greeting.",
-        "- Use search tools (grep, glob) to understand the codebase before making changes, only once the user gives a concrete task.",
-        "- Use the search_web tool for live web search. Never emit XML tags such as <web_search>.",
-        "- After a few targeted web searches and fetching the best sources, stop researching and produce the requested output.",
-        "- Do not keep searching for completeness, extra models, or slightly better numbers. Mark uncertain dates or scores as estimates and move on.",
-        "- If the user asked for a file or other artifact, write it as soon as the required fields can be filled. Then stop.",
-        "- 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");
-}