min-agent 0.3.0 → 0.4.0

package/dist/cli/commands/chat.js

@@ -0,0 +1,10 @@
+import { startTuiSession } from "./shared.js";
+export async function runChat(promptTokens, opts) {
+    await startTuiSession({
+        model: opts.model,
+        provider: opts.provider,
+        resume: opts.resume,
+        images: opts.image,
+        positionals: promptTokens,
+    });
+}

package/dist/cli/commands/exec.js

@@ -0,0 +1,32 @@
+import { runAgent } from "../../agent.js";
+import { isConfigured } from "../../config.js";
+import { resolveExecPrompt } from "../exec-prompt.js";
+import { CliError } from "../errors.js";
+export async function runExec(messageTokens, opts) {
+    if (!isConfigured()) {
+        throw new CliError("Not configured.", { hint: "Run: min-agent setup" });
+    }
+    const stdinIsTty = Boolean(process.stdin.isTTY);
+    const joined = messageTokens.join(" ");
+    const shouldReadStdin = joined === "-" || !stdinIsTty;
+    let stdinText = "";
+    if (shouldReadStdin) {
+        try {
+            const chunks = [];
+            for await (const chunk of process.stdin) {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            }
+            stdinText = Buffer.concat(chunks).toString("utf-8");
+        }
+        catch {
+            throw new CliError("Failed to read stdin");
+        }
+    }
+    const resolved = resolveExecPrompt(messageTokens, stdinText, stdinIsTty);
+    if (!resolved.ok) {
+        throw new CliError(resolved.error);
+    }
+    const failed = await runAgent(resolved.prompt, opts.model, opts.image.length > 0 ? opts.image : undefined, opts.provider, opts.resume);
+    if (failed)
+        process.exitCode = 1;
+}

package/dist/cli/commands/history.js

@@ -0,0 +1,58 @@
+import { writeFileSync } from "fs";
+import { CliError } from "../errors.js";
+export async function runHistoryList() {
+    const { listSessions } = await import("../../sessions.js");
+    const sessions = listSessions();
+    if (sessions.length === 0) {
+        console.log("No saved sessions.");
+        console.log("Sessions are auto-saved when you exit interactive chat.");
+    }
+    else {
+        console.log(`Sessions (${sessions.length}):`);
+        for (const s of sessions.slice(0, 20)) {
+            const date = s.updated.split("T")[0];
+            console.log(`  ${s.id}  ${date}  ${s.title} (${s.messageCount} msgs)`);
+        }
+        console.log("\nResume with: min-agent --resume <id>");
+    }
+}
+export async function runHistoryDelete(id) {
+    const { deleteSession } = await import("../../sessions.js");
+    if (deleteSession(id)) {
+        console.log(`✓ Session ${id} deleted`);
+    }
+    else {
+        throw new CliError(`Session ${id} not found`);
+    }
+}
+export async function runHistoryRename(id, titleTokens) {
+    const title = titleTokens.join(" ");
+    if (!title)
+        throw new CliError("Usage: min-agent history rename <id> <title>");
+    const { renameSession } = await import("../../sessions.js");
+    if (renameSession(id, title)) {
+        console.log(`✓ Session ${id} renamed to: ${title}`);
+    }
+    else {
+        throw new CliError(`Session ${id} not found`);
+    }
+}
+export async function runHistoryExport(id, opts) {
+    const { loadSession } = await import("../../sessions.js");
+    const session = loadSession(id);
+    if (!session)
+        throw new CliError(`Session ${id} not found`);
+    const json = JSON.stringify(session, null, 2);
+    if (opts.output) {
+        try {
+            writeFileSync(opts.output, json, "utf-8");
+            console.log(`✓ Session ${id} exported to ${opts.output}`);
+        }
+        catch (err) {
+            throw new CliError(`Export failed: ${err.message}`, { exitCode: 2 });
+        }
+    }
+    else {
+        console.log(json);
+    }
+}

package/dist/cli/commands/index.js

@@ -0,0 +1,224 @@
+import { Option } from "commander";
+import { resolveScope, parsePositiveIntArg } from "../option-helpers.js";
+import { runSetupCommand } from "./setup.js";
+import { runModelsCommand } from "./models.js";
+import { runChat } from "./chat.js";
+import { runExec } from "./exec.js";
+import { runServeCommand } from "./serve.js";
+import { runSandboxCommand } from "./sandbox.js";
+import { runPermissionCommand } from "./permission.js";
+import { runInitCommand } from "./init.js";
+import { runRulesShow, runRulesEdit } from "./rules.js";
+import { runUpdateCommand } from "./update.js";
+import { runHistoryList, runHistoryDelete, runHistoryRename, runHistoryExport } from "./history.js";
+import { runMemoryList, runMemoryAdd, runMemorySearch, runMemoryDelete } from "./memory.js";
+import { runMcpAdd, runMcpRemove, runMcpList, runMcpInfo, runMcpCheck, runMcpToggle, } from "./mcp.js";
+import { runSkillsList, runSkillsInfo, runSkillsToggle, runSkillsNew } from "./skills.js";
+/**
+ * All `--project`/`--global`/`--model`/`--provider`/`--resume`/`--image`/`--sandbox`/
+ * `--network`/`--permission` flags live on the root `program` (see addSessionOptions),
+ * so they can appear before or after a subcommand name. Subcommands read them via
+ * `program.opts<SessionOptions>()` instead of re-declaring the same options — commander
+ * resolves options against the first command in the chain that declares them, so a
+ * subcommand-local redeclaration would silently shadow the root option instead of merging.
+ */
+export function registerCommands(program) {
+    const rootOpts = () => program.opts();
+    // --- Session aliases -----------------------------------------------------
+    for (const alias of ["chat", "code"]) {
+        program
+            .command(alias)
+            .description("Same as interactive session (compat)")
+            .argument("[prompt...]", "Prompt to send")
+            .allowUnknownOption()
+            .action(async (prompt) => {
+            await runChat(prompt, rootOpts());
+        });
+    }
+    program
+        .command("exec")
+        .description("Run one message non-interactively")
+        .argument("[message...]", 'Message to send (use "-" to read from stdin)')
+        .allowUnknownOption()
+        .action(async (message) => {
+        await runExec(message, rootOpts());
+    });
+    // --- Setup & config ----------------------------------------------------
+    program.command("setup").description("Configure providers (interactively)").action(runSetupCommand);
+    program.command("init").description("Initialize .min-agent/ in current directory").action(runInitCommand);
+    program
+        .command("models")
+        .description("List available models")
+        .action(async () => {
+        await runModelsCommand(rootOpts());
+    });
+    const rules = program.command("rules").description("Show or edit instruction rules");
+    rules.action(runRulesShow);
+    rules.command("edit").description("Edit the global rules file").action(runRulesEdit);
+    const memory = program.command("memory").description("Manage saved memories (uses --project/--global)");
+    memory.action(async () => {
+        const opts = rootOpts();
+        await runMemoryList(opts.project ? "project" : opts.global ? "global" : undefined);
+    });
+    memory
+        .command("add")
+        .argument("<text...>")
+        .description("Add a memory")
+        .action(async (text) => {
+        const opts = rootOpts();
+        await runMemoryAdd(text, opts.project ? "project" : opts.global ? "global" : undefined);
+    });
+    memory
+        .command("search")
+        .argument("<query...>")
+        .description("Search memories")
+        .action(async (query) => {
+        const opts = rootOpts();
+        await runMemorySearch(query, opts.project ? "project" : opts.global ? "global" : undefined);
+    });
+    memory
+        .command("delete")
+        .argument("<index>")
+        .description("Delete a memory by index")
+        .action(async (index) => {
+        const opts = rootOpts();
+        await runMemoryDelete(index, opts.project ? "project" : opts.global ? "global" : undefined);
+    });
+    const sandbox = program
+        .command("sandbox")
+        .description("Show or set isolation mode (uses --project/--global)")
+        .argument("[mode]", "off, workspace, or strict");
+    sandbox.action(async (mode) => {
+        const opts = rootOpts();
+        await runSandboxCommand(mode ? [mode] : [], opts, opts);
+    });
+    sandbox
+        .command("network")
+        .description("Show or set network policy")
+        .argument("[policy]", "allow or deny")
+        .action(async (policy) => {
+        const opts = rootOpts();
+        await runSandboxCommand(["network", ...(policy ? [policy] : [])], opts, opts);
+    });
+    program
+        .command("permission")
+        .description("Show or set confirmation mode (uses --project/--global)")
+        .argument("[mode]", "ask, accept-edits, or allow-all")
+        .action(async (mode) => {
+        const opts = rootOpts();
+        await runPermissionCommand(mode ? [mode] : [], opts, opts);
+    });
+    // --- Integrations --------------------------------------------------------
+    const mcp = program.command("mcp").description("Manage MCP servers");
+    mcp
+        .command("add")
+        .description("Add a new MCP server (stdio or remote)")
+        .usage("[options] <name> [command...]")
+        .argument("<name>")
+        .argument("[cmd...]", "Command to launch a stdio server (npx, node, ...)")
+        .option("--url <url>", "Remote server URL")
+        .option("--sse", "Use SSE transport for the remote server")
+        .option("--streamable-http", "Use streamable-http transport for the remote server")
+        .option("--token <token>", "Bearer token for remote servers")
+        .option("--env <KEY=VALUE>", "Extra env for stdio servers (repeatable)", (v, prev) => [...prev, v], [])
+        .addOption(new Option("--timeout <ms>", "Connection/call timeout").argParser(parsePositiveIntArg("--timeout")))
+        .option("--skip-check", "Skip validation before saving")
+        .addHelpText("after", "\nAll options above must come before <name>. Everything after <name> (including flags meant for the\n" +
+        "launched command, like `npx -y`) is passed through as-is.\n" +
+        "Scope: pass --project on `min-agent` before `mcp add` to write to .min-agent/mcp.json.")
+        .allowUnknownOption()
+        .passThroughOptions()
+        .action(async (name, cmd, opts) => {
+        await runMcpAdd(name, cmd, { ...opts, project: rootOpts().project });
+    });
+    mcp
+        .command("remove")
+        .argument("<name>")
+        .description("Remove a server")
+        .action(async (name) => {
+        await runMcpRemove(name, { project: rootOpts().project });
+    });
+    mcp.command("list").description("List configured MCP servers").action(runMcpList);
+    mcp.command("info").argument("<name>").description("Show details of a server").action(runMcpInfo);
+    mcp.command("check").description("Test connectivity of all servers").action(runMcpCheck);
+    mcp
+        .command("enable")
+        .argument("<names...>")
+        .description("Enable disabled servers (use --project to target project scope)")
+        .action(async (names) => {
+        await runMcpToggle(names, true, { project: rootOpts().project });
+    });
+    mcp
+        .command("disable")
+        .argument("<names...>")
+        .description("Disable servers (use --project to target project scope)")
+        .action(async (names) => {
+        await runMcpToggle(names, false, { project: rootOpts().project });
+    });
+    const skills = program.command("skills").description("Manage skills");
+    skills
+        .command("list")
+        .option("--json", "Machine-readable JSON output")
+        .description("List skills")
+        .action(async (opts) => {
+        await runSkillsList(Boolean(opts.json));
+    });
+    skills
+        .command("info")
+        .argument("<name>")
+        .option("--json", "Machine-readable JSON output")
+        .description("Show details of a skill")
+        .action(async (name, opts) => {
+        await runSkillsInfo(name, Boolean(opts.json));
+    });
+    skills
+        .command("new")
+        .argument("<name>")
+        .description("Create a new skill scaffold (use --global on `min-agent` for ~/.agents/skills/)")
+        .action(async (name) => {
+        await runSkillsNew(name, Boolean(rootOpts().global));
+    });
+    skills
+        .command("enable")
+        .argument("<names...>")
+        .description("Enable disabled skills (use --project to target this project only)")
+        .action(async (names) => {
+        await runSkillsToggle(names, true, resolveScope(rootOpts()));
+    });
+    skills
+        .command("disable")
+        .argument("<names...>")
+        .description("Disable skills (use --project to target this project only)")
+        .action(async (names) => {
+        await runSkillsToggle(names, false, resolveScope(rootOpts()));
+    });
+    // --- Operations -----------------------------------------------------------
+    program
+        .command("serve")
+        .description("Start the HTTP API (see docs/API.md)")
+        .option("--host <host>", "Bind host")
+        .addOption(new Option("--port <port>", "Bind port").argParser(parsePositiveIntArg("--port")))
+        .action(async (opts) => {
+        await runServeCommand(opts);
+    });
+    const history = program.command("history").description("Manage saved sessions");
+    history.action(runHistoryList);
+    history.command("delete").argument("<id>").description("Delete a saved session").action(runHistoryDelete);
+    history
+        .command("rename")
+        .argument("<id>")
+        .argument("<title...>")
+        .description("Rename a saved session")
+        .action(async (id, title) => {
+        await runHistoryRename(id, title);
+    });
+    history
+        .command("export")
+        .argument("<id>")
+        .option("-o, --output <file>", "Write to a file instead of stdout")
+        .description("Export a session as JSON")
+        .action(async (id, opts) => {
+        await runHistoryExport(id, opts);
+    });
+    program.command("update").description("Upgrade to the latest npm release").action(runUpdateCommand);
+}

package/dist/cli/commands/init.js

@@ -0,0 +1,18 @@
+import { existsSync, writeFileSync, mkdirSync } from "fs";
+import path from "path";
+function ensureProjectDefaults() {
+    const projectConfigDir = path.join(process.cwd(), ".min-agent");
+    const projectSkillsDir = path.join(projectConfigDir, "skills");
+    const projectMcpFile = path.join(projectConfigDir, "mcp.json");
+    if (!existsSync(projectSkillsDir)) {
+        mkdirSync(projectSkillsDir, { recursive: true });
+    }
+    if (!existsSync(projectMcpFile)) {
+        mkdirSync(projectConfigDir, { recursive: true });
+        writeFileSync(projectMcpFile, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
+    }
+}
+export async function runInitCommand() {
+    ensureProjectDefaults();
+    console.log(`✓ Initialized .min-agent/ in ${process.cwd()}`);
+}

package/dist/cli/commands/mcp.js

@@ -0,0 +1,173 @@
+import { loadMcpConfigFile, loadMcpConfigEntries, saveMcpConfig, checkMcpServer, checkAllMcpServers, formatMcpServerBinding, getMcpStatus, listMcpCatalog, } from "../../mcp.js";
+import { CliError } from "../errors.js";
+function parseEnvPairs(pairs) {
+    const environment = {};
+    for (const kv of pairs ?? []) {
+        const eq = kv.indexOf("=");
+        if (eq <= 0)
+            throw new CliError(`Invalid --env format: ${kv}`, { hint: "use KEY=VALUE" });
+        environment[kv.slice(0, eq)] = kv.slice(eq + 1);
+    }
+    return environment;
+}
+export async function runMcpAdd(name, cmd, opts) {
+    const scope = opts.project ? "project" : "global";
+    if (opts.sse && opts.streamableHttp) {
+        throw new CliError("--sse and --streamable-http are mutually exclusive");
+    }
+    const usage = "Usage: min-agent mcp add <name> [--project] [--skip-check] <command...>\n" +
+        "   or: min-agent mcp add <name> --url <https://host/mcp> [--sse|--streamable-http] [--token <bearer>] [--project] [--skip-check]";
+    let entry;
+    if (opts.url?.trim()) {
+        entry = {
+            url: opts.url.trim(),
+            enabled: true,
+            remoteTransport: opts.streamableHttp ? "streamable-http" : opts.sse ? "sse" : "auto",
+            ...(opts.timeout ? { timeout: opts.timeout } : {}),
+        };
+        if (opts.token?.trim())
+            entry.token = opts.token.trim();
+    }
+    else if (cmd.length > 0) {
+        entry = { command: cmd, enabled: true, ...(opts.timeout ? { timeout: opts.timeout } : {}) };
+    }
+    else {
+        throw new CliError(usage);
+    }
+    const environment = parseEnvPairs(opts.env);
+    if (Object.keys(environment).length > 0)
+        entry.environment = environment;
+    let detectedTools = 0;
+    if (!opts.skipCheck) {
+        console.log(`Validating MCP server "${name}"...`);
+        const checkResult = await checkMcpServer(name, entry);
+        if (!checkResult.ok) {
+            throw new CliError(`MCP server "${name}" validation failed: ${checkResult.error ?? "unknown error"}`, {
+                exitCode: 2,
+            });
+        }
+        detectedTools = checkResult.toolCount;
+    }
+    else {
+        console.log(`Skipping MCP validation for "${name}" (--skip-check).`);
+    }
+    const config = loadMcpConfigFile(scope);
+    config.mcpServers[name] = entry;
+    saveMcpConfig(config, scope);
+    const toolsSuffix = opts.skipCheck ? "" : ` (${detectedTools} tools detected)`;
+    const scopeSuffix = opts.project ? " [project]" : "";
+    console.log(`✓ MCP server "${name}" added${scopeSuffix}: ${formatMcpServerBinding(entry)}${toolsSuffix}`);
+}
+export async function runMcpRemove(name, opts) {
+    const scope = opts.project ? "project" : "global";
+    const config = loadMcpConfigFile(scope);
+    if (!config.mcpServers[name]) {
+        const elsewhere = loadMcpConfigEntries().find((e) => e.name === name);
+        throw new CliError(elsewhere
+            ? `MCP server "${name}" is defined in ${elsewhere.scope} scope, not ${scope}.`
+            : `MCP server "${name}" not found`);
+    }
+    delete config.mcpServers[name];
+    saveMcpConfig(config, scope);
+    console.log(`✓ MCP server "${name}" removed${opts.project ? " [project]" : ""}`);
+}
+export async function runMcpList() {
+    const entries = loadMcpConfigEntries();
+    if (entries.length === 0) {
+        console.log("No MCP servers configured.");
+        console.log("Add one with: min-agent mcp add <name> <command...>");
+        return;
+    }
+    console.log("MCP Servers:");
+    for (const { name, config, scope } of entries) {
+        const status = config.enabled === false ? "\x1b[90mdisabled\x1b[0m" : "\x1b[32menabled\x1b[0m";
+        const scopeMark = scope === "project" ? " \x1b[90m[project]\x1b[0m" : "";
+        console.log(`  ${name}  ${status}${scopeMark}`);
+    }
+    console.log("\nUse: min-agent mcp info <name>  for details");
+}
+export async function runMcpInfo(name) {
+    const found = loadMcpConfigEntries().find((e) => e.name === name);
+    if (!found)
+        throw new CliError(`MCP server "${name}" not found`);
+    const cfg = found.config;
+    console.log(`Name:      ${name}`);
+    console.log(`Scope:     ${found.scope}`);
+    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.remoteTransport)
+            console.log(`Transport: ${cfg.remoteTransport}`);
+        if (cfg.oauth === false)
+            console.log(`OAuth:     disabled`);
+        else if (cfg.oauth)
+            console.log(`OAuth:     enabled${cfg.oauth.clientId ? ` (clientId set)` : ""}`);
+    }
+    if (cfg.headers)
+        console.log(`Headers:   ${Object.keys(cfg.headers).join(", ")} (values hidden)`);
+    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`);
+    if (cfg.connectTimeout)
+        console.log(`ConnectTimeout: ${cfg.connectTimeout}ms`);
+    if (cfg.callTimeout)
+        console.log(`CallTimeout:    ${cfg.callTimeout}ms`);
+    const st = getMcpStatus()[name];
+    if (st?.connected) {
+        const catalog = listMcpCatalog(name).servers[0];
+        if (catalog) {
+            console.log(`Tools:     ${st.tools.join(", ") || "(none)"}`);
+            console.log(`Resources: ${catalog.resources.length === 0 ? "(none)" : catalog.resources.map((r) => r.uri).join(", ")}`);
+            console.log(`Prompts:   ${catalog.prompts.length === 0 ? "(none)" : catalog.prompts.map((p) => p.name).join(", ")}`);
+        }
+    }
+}
+export async function runMcpCheck() {
+    const results = await checkAllMcpServers();
+    if (results.length === 0) {
+        console.log("No MCP servers configured.");
+        console.log("Add one with: min-agent mcp add <name> <command...>  or  --url <https://...>");
+        return;
+    }
+    let failed = 0;
+    console.log("MCP Check Results:");
+    for (const result of results) {
+        if (!result.enabled) {
+            console.log(`  ${result.name}: skipped (disabled)`);
+            continue;
+        }
+        if (result.ok) {
+            console.log(`  ${result.name}: ok (${result.toolCount} tools)`);
+        }
+        else {
+            failed++;
+            console.log(`  ${result.name}: failed${result.error ? ` - ${result.error}` : ""}`);
+        }
+    }
+    if (failed > 0) {
+        throw new CliError(`${failed} MCP server(s) failed.`, { exitCode: 1 });
+    }
+    console.log("\nAll enabled MCP servers are available.");
+}
+export async function runMcpToggle(names, enabled, opts) {
+    const scope = opts.project ? "project" : "global";
+    const verb = enabled ? "enable" : "disable";
+    if (names.length === 0)
+        throw new CliError(`Usage: min-agent mcp ${verb} <name...> [--project]`);
+    const config = loadMcpConfigFile(scope);
+    for (const name of names) {
+        if (!config.mcpServers[name]) {
+            console.error(`MCP server "${name}" not found${opts.project ? " in project scope" : ""}`);
+            continue;
+        }
+        config.mcpServers[name].enabled = enabled;
+        console.log(`✓ MCP server "${name}" ${verb}d${opts.project ? " [project]" : ""}`);
+    }
+    saveMcpConfig(config, scope);
+}

package/dist/cli/commands/memory.js

@@ -0,0 +1,69 @@
+import { loadMemories, addMemory, deleteMemory, searchMemories, defaultMemoryScope, } from "../../memory.js";
+import { CliError } from "../errors.js";
+function printList(which) {
+    const memories = loadMemories(which);
+    const label = which === "project" ? "Project memories" : "Global memories";
+    if (memories.length === 0) {
+        console.log(`${label}: none`);
+        return;
+    }
+    console.log(`${label} (${memories.length}):`);
+    for (let i = 0; i < memories.length; i++) {
+        const m = memories[i];
+        const tags = m.tags.length > 0 ? ` [${m.tags.join(", ")}]` : "";
+        const date = m.created.split("T")[0];
+        console.log(`  #${i + 1}: ${m.content}${tags} (${date})`);
+    }
+}
+export async function runMemoryList(scope) {
+    if (!scope && loadMemories("project").length === 0 && loadMemories("global").length === 0) {
+        console.log("No memories stored.");
+        console.log("The agent will automatically save memories during conversations.");
+        console.log('Or add manually: min-agent memory add "prefer TypeScript over JavaScript"');
+        return;
+    }
+    const scopes = scope ? [scope] : ["project", "global"];
+    for (const s of scopes)
+        printList(s);
+}
+export async function runMemoryAdd(textTokens, scope) {
+    const text = textTokens.join(" ");
+    if (!text)
+        throw new CliError("Usage: min-agent memory add <text> [--project|--global]");
+    const resolved = scope ?? defaultMemoryScope();
+    addMemory(text, [], resolved);
+    console.log(`✓ ${resolved === "project" ? "Project" : "Global"} memory saved: "${text}"`);
+}
+export async function runMemorySearch(queryTokens, scope) {
+    const query = queryTokens.join(" ");
+    if (!query)
+        throw new CliError("Usage: min-agent memory search <query> [--project|--global]");
+    const scopes = scope ? [scope] : ["project", "global"];
+    const lines = [];
+    for (const s of scopes) {
+        for (const m of searchMemories(query, s)) {
+            const tags = m.tags.length > 0 ? ` [${m.tags.join(", ")}]` : "";
+            lines.push(`  [${s}] #${m.index + 1}: ${m.content}${tags}`);
+        }
+    }
+    if (lines.length === 0) {
+        console.log(`No memories matching "${query}"`);
+    }
+    else {
+        console.log(`Found ${lines.length} memory(s):`);
+        for (const line of lines)
+            console.log(line);
+    }
+}
+export async function runMemoryDelete(indexArg, scope) {
+    const idx = Number.parseInt(indexArg, 10);
+    if (Number.isNaN(idx))
+        throw new CliError("Usage: min-agent memory delete <number> [--project|--global]");
+    const resolved = scope ?? defaultMemoryScope();
+    if (deleteMemory(idx - 1, resolved)) {
+        console.log(`✓ ${resolved === "project" ? "Project" : "Global"} memory #${idx} deleted`);
+    }
+    else {
+        throw new CliError(`${resolved === "project" ? "Project" : "Global"} memory #${idx} not found`);
+    }
+}

package/dist/cli/commands/models.js

@@ -0,0 +1,21 @@
+import { loadConfig, fetchModels, getActiveProvider } from "../../config.js";
+import { CliError } from "../errors.js";
+export async function runModelsCommand(opts) {
+    const config = loadConfig();
+    const provider = opts.provider ? config.providers?.find((p) => p.name === opts.provider) : getActiveProvider(config);
+    if (!provider?.baseURL || !provider?.apiKey) {
+        throw new CliError("Not configured.", { hint: "Run: min-agent setup" });
+    }
+    console.log(`Fetching models (${provider.name ?? "default"})...`);
+    const models = await fetchModels(provider.baseURL, provider.apiKey);
+    if (models.length === 0) {
+        console.log("No models found or unable to fetch model list.");
+    }
+    else {
+        console.log(`\nAvailable models (${models.length}):`);
+        for (const m of models) {
+            const marker = m === provider.defaultModel ? " ← default" : "";
+            console.log(`  ${m}${marker}`);
+        }
+    }
+}

package/dist/cli/commands/permission.js

@@ -0,0 +1,12 @@
+import { runPermissionCli } from "../../permission-cli.js";
+export async function runPermissionCommand(args, opts, parentOpts) {
+    const scope = opts.project ? "project" : opts.global ? "global" : undefined;
+    const result = runPermissionCli({
+        positionals: args,
+        flagMode: parentOpts.permission,
+        scope,
+    });
+    console.log(result.lines.join("\n"));
+    if (!result.ok)
+        process.exitCode = 1;
+}

package/dist/cli/commands/rules.js

@@ -0,0 +1,33 @@
+import { existsSync, writeFileSync, mkdirSync } from "fs";
+import { getConfigDir, getRulesFile } from "../../config.js";
+export async function runRulesShow() {
+    const { loadInstructions } = await import("../../instructions.js");
+    const instructions = await loadInstructions();
+    if (instructions.length === 0) {
+        console.log("No instruction rules loaded.");
+        console.log("");
+        console.log("Add rules by creating:");
+        console.log(`  Global:  ${getRulesFile()}`);
+        console.log("  Project: ./AGENTS.md or ./RULES.md");
+        console.log("");
+        console.log("Or add paths/URLs in ~/.min-agent/config.json:");
+        console.log('  { "instructions": ["./docs/rules.md", "https://..."] }');
+    }
+    else {
+        console.log(`Loaded ${instructions.length} instruction source(s):\n`);
+        for (const inst of instructions) {
+            const firstLine = inst.split("\n")[0];
+            console.log(`  ${firstLine}`);
+        }
+    }
+}
+export async function runRulesEdit() {
+    const rulesFile = getRulesFile();
+    if (!existsSync(rulesFile)) {
+        mkdirSync(getConfigDir(), { recursive: true });
+        writeFileSync(rulesFile, `# Global Agent Rules\n\n<!-- Add your custom instructions here. They will be included in every conversation. -->\n`, "utf-8");
+    }
+    const editor = process.env.EDITOR || "vi";
+    const { execSync } = await import("child_process");
+    execSync(`${editor} "${rulesFile}"`, { stdio: "inherit" });
+}

package/dist/cli/commands/sandbox.js

@@ -0,0 +1,13 @@
+import { runSandboxCli } from "../../sandbox-cli.js";
+export async function runSandboxCommand(args, opts, parentOpts) {
+    const scope = opts.project ? "project" : opts.global ? "global" : undefined;
+    const result = runSandboxCli({
+        positionals: args,
+        flagMode: parentOpts.sandbox,
+        flagNetwork: parentOpts.network ?? opts.network,
+        scope,
+    });
+    console.log(result.lines.join("\n"));
+    if (!result.ok)
+        process.exitCode = 1;
+}