min-agent 0.4.1 → 0.5.1

package/dist/cli/commands/shared.js

@@ -1,8 +1,17 @@
 import { isConfigured } from "../../config.js";
 import { CliError } from "../errors.js";
+import { shouldOfferSetupWizard } from "../setup/flow.js";
 export async function startTuiSession(input) {
     if (!isConfigured()) {
-        throw new CliError("Not configured.", { hint: "Run: min-agent setup" });
+        const tty = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+        if (!shouldOfferSetupWizard(false, tty)) {
+            throw new CliError("Not configured.", { hint: "Run: min-agent setup" });
+        }
+        const { offerInteractiveSetup } = await import("./setup.js");
+        await offerInteractiveSetup("session-gate");
+        if (!isConfigured()) {
+            throw new CliError("Not configured.", { hint: "Run: min-agent setup" });
+        }
     }
     const { runTui } = await import("../../tui-chat.js");
     const prompt = input.positionals.join(" ").trim();

package/dist/cli/commands/think.js

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

package/dist/cli/commands/write-config.js

@@ -1,5 +1,7 @@
 import { runSandboxCli } from "../../sandbox-cli.js";
 import { runPermissionCli } from "../../permission-cli.js";
+import { runThinkCli } from "../../think-cli.js";
+import { runMemoryCli } from "../../memory-cli.js";
 export async function runWriteConfig(input) {
     const lines = [];
     let ok = true;
@@ -24,6 +26,26 @@ export async function runWriteConfig(input) {
         if (!result.ok)
             ok = false;
     }
+    if (input.think !== undefined) {
+        const result = runThinkCli({
+            positionals: [],
+            flagEffort: input.think,
+            scope: input.scope,
+        });
+        lines.push(...result.lines);
+        if (!result.ok)
+            ok = false;
+    }
+    if (input.memory !== undefined) {
+        const result = runMemoryCli({
+            positionals: [],
+            flagMode: input.memory,
+            scope: input.scope,
+        });
+        lines.push(...result.lines);
+        if (!result.ok)
+            ok = false;
+    }
     console.log(lines.join("\n"));
     if (!ok)
         process.exitCode = 1;

package/dist/cli/option-helpers.js

@@ -1,6 +1,6 @@
 import { Option } from "commander";
 import { parseNetworkPolicy, parseSandboxMode } from "../sandbox.js";
-import { parsePermissionMode } from "../config.js";
+import { parsePermissionMode, parseThinkingEffort, parseMemoryMode, } from "../config.js";
 import { userError } from "./errors.js";
 /** Reusable --project / --global mutually exclusive scope selector. */
 export function scopeOptions() {
@@ -35,6 +35,18 @@ export function parsePermissionModeArg(value) {
         throw userError(`Invalid --permission value: "${value}"`, "use one of: ask, accept-edits, allow-all");
     return parsed;
 }
+export function parseThinkingEffortArg(value) {
+    const parsed = parseThinkingEffort(value);
+    if (!parsed)
+        throw userError(`Invalid --think value: "${value}"`, "use one of: off, low, medium, high, max");
+    return parsed;
+}
+export function parseMemoryModeArg(value) {
+    const parsed = parseMemoryMode(value);
+    if (!parsed)
+        throw userError(`Invalid --memory value: "${value}"`, "use one of: on, off");
+    return parsed;
+}
 export function parsePortArg(value) {
     const n = Number.parseInt(value, 10);
     if (!Number.isFinite(n) || n <= 0 || n > 65535) {

package/dist/cli/program.js

@@ -1,7 +1,7 @@
 import { Command, Option } from "commander";
 import { setAutoApprove } from "../confirm.js";
 import { CliError, formatCliError, exitCodeFor } from "./errors.js";
-import { parseNetworkPolicyArg, parsePermissionModeArg, parseSandboxModeArg } from "./option-helpers.js";
+import { parseNetworkPolicyArg, parsePermissionModeArg, parseSandboxModeArg, parseThinkingEffortArg, parseMemoryModeArg, } from "./option-helpers.js";
 import { localVersion } from "../updater.js";
 function collectImage(value, previous) {
     return [...previous, value];
@@ -16,8 +16,10 @@ export function addSessionOptions(cmd) {
         .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))
-        .option("--project", "Write --permission/--sandbox to this repo's config")
-        .option("--global", "Write --permission/--sandbox to the global config")
+        .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() {
@@ -45,14 +47,17 @@ Session:
   min-agent exec --resume <id> <msg> Continue a saved exec session
 
 Setup & config:
-  min-agent setup                    Configure providers (interactively)
+  min-agent setup [--type T]         Configure providers (interactively, or with flags)
   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 <add|search|delete|list>   Manage saved memories
+  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
+  min-agent ctx [2k|4k|8k|12k|16k|32k|64k|128k|256k|auto]  Show or set Ollama context window
 
 Integrations:
   min-agent mcp <list|add|remove|info|check|enable|disable>   Manage MCP servers
@@ -68,6 +73,21 @@ Confirmation modes (default: ask; independent of isolation):
   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
+
+Ollama context window:
+  2k … 256k  Loaded window size
+  auto       Use the model's default
+
+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
@@ -81,12 +101,15 @@ Rules (loaded as system instructions):
 
 Examples:
   min-agent setup
+  min-agent setup --type ollama
   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
@@ -100,6 +123,27 @@ 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));
 }
@@ -117,27 +161,26 @@ export function extractUnknownOptionErrors(positionals) {
 }
 async function runRootAction(promptTokens, opts) {
     applySessionOverrides(opts);
-    const { setSandboxOverride } = await import("../sandbox.js");
-    const { setPermissionOverride } = await import("../confirm.js");
     const { rest, errors } = extractUnknownOptionErrors(promptTokens);
     const sessionIntent = hasSessionIntent(opts, rest);
-    const wantsConfigWrite = opts.sandbox !== undefined || opts.network !== undefined || opts.permission !== undefined;
+    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;
     }
-    if (opts.sandbox !== undefined)
-        setSandboxOverride({ mode: opts.sandbox });
-    if (opts.network !== undefined)
-        setSandboxOverride({ network: opts.network });
-    if (opts.permission !== undefined)
-        setPermissionOverride(opts.permission);
+    await applySessionRuntimeOverrides(opts);
     if (errors.length > 0) {
         console.error(errors[0]);
         process.exitCode = 1;

package/dist/cli/setup/detect.js

@@ -0,0 +1,17 @@
+import { normalizeOllamaBaseURL } from "../../config.js";
+const DEFAULT_TAGS_URL = "http://localhost:11434/api/tags";
+const DEFAULT_TIMEOUT_MS = 800;
+const DEFAULT_BASE = "http://localhost:11434/v1";
+export async function detectLocalOllama(opts) {
+    const fetchImpl = opts?.fetchImpl ?? fetch;
+    const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    try {
+        const response = await fetchImpl(DEFAULT_TAGS_URL, { signal: AbortSignal.timeout(timeoutMs) });
+        if (!response.ok)
+            return { found: false };
+        return { found: true, baseURL: normalizeOllamaBaseURL(DEFAULT_BASE) };
+    }
+    catch {
+        return { found: false };
+    }
+}

package/dist/cli/setup/flags.js

@@ -0,0 +1,12 @@
+import { userError } from "../errors.js";
+export function parseProviderType(value) {
+    if (value === "openai-compatible" || value === "openai" || value === "ollama")
+        return value;
+    throw userError(`Invalid --type value: "${value}"`, "use one of: openai-compatible, openai, ollama");
+}
+export function isNonInteractive(flags) {
+    return Boolean(flags.type || flags.switch || flags.remove);
+}
+export function exclusiveActionCount(flags) {
+    return [flags.type, flags.switch, flags.remove].filter(Boolean).length;
+}

package/dist/cli/setup/flow.js

@@ -0,0 +1,108 @@
+import { getActiveProvider, normalizeOllamaBaseURL } from "../../config.js";
+import { CliError, runtimeError } from "../errors.js";
+import { applyAddProvider, applyRemoveProvider, applySwitchProvider, suggestName, } from "./provider-form.js";
+import { exclusiveActionCount } from "./flags.js";
+const OPENAI_URL = "https://api.openai.com/v1";
+const OLLAMA_URL = "http://localhost:11434/v1";
+const NON_INTERACTIVE_HINT = "使用 --type、--switch 或 --remove。例如: min-agent setup --type ollama";
+export function shouldOfferSetupWizard(configured, isTty) {
+    return !configured && isTty;
+}
+export async function runSetup(flags, deps, wizardMode) {
+    if (exclusiveActionCount(flags) > 1) {
+        throw new CliError("一次只能执行一种操作。");
+    }
+    if (flags.remove) {
+        await runRemove(flags.remove, flags.yes === true, deps);
+        return;
+    }
+    if (flags.switch) {
+        persist(applySwitchProvider(deps.load(), flags.switch), deps);
+        return;
+    }
+    if (flags.type) {
+        await runAdd(flags, deps);
+        return;
+    }
+    if (!deps.isTty) {
+        throw new CliError("无法在非交互环境完成配置。", { hint: NON_INTERACTIVE_HINT });
+    }
+    const config = deps.load();
+    const mode = wizardMode ?? (hasUsableProvider(config) ? "hub" : "first-run");
+    await deps.runWizard(mode);
+}
+function hasUsableProvider(config) {
+    const provider = getActiveProvider(config);
+    return Boolean(provider?.baseURL && provider?.apiKey);
+}
+async function runRemove(name, yes, deps) {
+    if (!yes) {
+        throw new CliError("删除需要确认。", { hint: "加上 --yes" });
+    }
+    persist(applyRemoveProvider(deps.load(), name), deps);
+}
+async function runAdd(flags, deps) {
+    const type = flags.type;
+    const baseURL = resolveBaseURL(type, flags.url);
+    const apiKey = resolveApiKey(type, flags.apiKey);
+    const defaultModel = await resolveDefaultModel(type, baseURL, apiKey, flags.defaultModel, deps.fetchLive);
+    const config = deps.load();
+    const existing = (config.providers ?? []).map((p) => p.name).filter((name) => Boolean(name));
+    const name = (flags.name?.trim() || suggestName(type, baseURL, existing)).trim();
+    const draft = {
+        name,
+        type,
+        baseURL,
+        apiKey,
+        defaultModel,
+        ...(flags.contextWindow != null ? { contextWindow: flags.contextWindow } : {}),
+    };
+    const overwrite = flags.yes === true;
+    const result = applyAddProvider(config, draft, { overwrite });
+    if (isApplyError(result) && result.error.startsWith("已存在同名服务商") && !overwrite) {
+        throw new CliError(result.error, { hint: "加上 --yes 以覆盖" });
+    }
+    persist(result, deps);
+}
+function resolveBaseURL(type, url) {
+    if (type === "openai")
+        return OPENAI_URL;
+    if (type === "ollama")
+        return normalizeOllamaBaseURL(url?.trim() || OLLAMA_URL);
+    const trimmed = url?.trim() ?? "";
+    if (!trimmed)
+        throw new CliError("API 地址不能为空。");
+    return trimmed.replace(/\/$/, "");
+}
+function resolveApiKey(type, apiKey) {
+    if (type === "ollama")
+        return apiKey?.trim() || "ollama";
+    const trimmed = apiKey?.trim() ?? "";
+    if (!trimmed)
+        throw new CliError("API 密钥不能为空。");
+    return trimmed;
+}
+async function resolveDefaultModel(type, baseURL, apiKey, explicit, fetchLive) {
+    const given = explicit?.trim() ?? "";
+    if (given)
+        return given;
+    const live = await fetchLive(baseURL, apiKey);
+    if (live.models[0])
+        return live.models[0];
+    if (type === "ollama")
+        return "llama3";
+    if (!live.ok && live.status == null) {
+        throw runtimeError("无法连接到该服务商。");
+    }
+    throw new CliError("默认模型不能为空。");
+}
+function persist(result, deps) {
+    if (isApplyError(result))
+        throw new CliError(result.error);
+    deps.save(result);
+    deps.log(`已保存到 ${deps.configPath()}`);
+}
+function isApplyError(result) {
+    return Object.keys(result).length === 1 && "error" in result;
+}
+export { isNonInteractive } from "./flags.js";

package/dist/cli/setup/provider-form.js

@@ -0,0 +1,102 @@
+export function suggestName(type, baseURL, existing) {
+    const base = type === "openai" ? "openai" : type === "ollama" ? "ollama" : (hostSlug(baseURL) ?? "provider");
+    return uniqueName(base, existing);
+}
+export function validateProviderName(name) {
+    const trimmed = name.trim();
+    if (!trimmed || trimmed.includes("/") || trimmed.includes(":")) {
+        return "名称不能为空，且不能包含 / 或 :。";
+    }
+    return null;
+}
+export function maskApiKey(key) {
+    if (key.length < 4)
+        return "****";
+    return `…${key.slice(-4)}`;
+}
+export function filterChoices(query, items) {
+    const q = query.trim().toLowerCase();
+    if (!q)
+        return [...items];
+    return items.filter((item) => item.toLowerCase().includes(q));
+}
+export function applyAddProvider(config, draft, opts) {
+    const nameError = validateProviderName(draft.name);
+    if (nameError)
+        return { error: nameError };
+    const name = draft.name.trim();
+    const providers = [...(config.providers ?? [])];
+    const idx = providers.findIndex((p) => p.name === name);
+    if (idx >= 0 && !opts.overwrite)
+        return { error: `已存在同名服务商 "${name}"。` };
+    const entry = toProvider(draft, name);
+    if (idx >= 0)
+        providers[idx] = entry;
+    else
+        providers.push(entry);
+    return { ...config, providers, activeProvider: name };
+}
+export function applySwitchProvider(config, name) {
+    const target = (config.providers ?? []).find((p) => p.name === name);
+    if (!target)
+        return { error: `找不到服务商 "${name}"。` };
+    return { ...config, activeProvider: name };
+}
+export function applyUpdateProvider(config, oldName, draft) {
+    const nameError = validateProviderName(draft.name);
+    if (nameError)
+        return { error: nameError };
+    const name = draft.name.trim();
+    const providers = [...(config.providers ?? [])];
+    const idx = providers.findIndex((p) => p.name === oldName);
+    if (idx < 0)
+        return { error: `找不到服务商 "${oldName}"。` };
+    if (name !== oldName && providers.some((p) => p.name === name)) {
+        return { error: `已存在同名服务商 "${name}"。` };
+    }
+    providers[idx] = toProvider(draft, name);
+    const activeProvider = config.activeProvider === oldName ? name : config.activeProvider;
+    return { ...config, providers, activeProvider };
+}
+export function applyRemoveProvider(config, name) {
+    const providers = config.providers ?? [];
+    if (!providers.some((p) => p.name === name))
+        return { error: `找不到服务商 "${name}"。` };
+    const remaining = providers.filter((p) => p.name !== name);
+    if (remaining.length === 0) {
+        const { activeProvider: _dropped, ...rest } = config;
+        return { ...rest, providers: [] };
+    }
+    const activeProvider = config.activeProvider === name ? remaining[0]?.name : config.activeProvider;
+    return { ...config, providers: remaining, activeProvider };
+}
+function toProvider(draft, name) {
+    return {
+        name,
+        type: draft.type,
+        baseURL: draft.baseURL,
+        apiKey: draft.apiKey,
+        defaultModel: draft.defaultModel,
+        ...(draft.contextWindow != null ? { contextWindow: draft.contextWindow } : {}),
+    };
+}
+function hostSlug(baseURL) {
+    try {
+        const host = new URL(baseURL).hostname.toLowerCase();
+        const trimmed = host.startsWith("www.") ? host.slice(4) : host;
+        if (!trimmed)
+            return undefined;
+        return trimmed.replace(/\./g, "-");
+    }
+    catch {
+        return undefined;
+    }
+}
+function uniqueName(base, existing) {
+    if (!existing.includes(base))
+        return base;
+    let n = 2;
+    while (existing.includes(`${base}-${n}`))
+        n += 1;
+    return `${base}-${n}`;
+}