min-agent 0.2.1 → 0.3.0

package/dist/config.js

@@ -1,33 +1,127 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, statSync } from "fs";
 import path from "path";
 import os from "os";
 import readline from "readline";
-const CONFIG_DIR = path.join(os.homedir(), ".min-agent");
-const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
-const RULES_FILE = path.join(CONFIG_DIR, "rules.md");
+const DEFAULT_CONFIG_DIR = path.join(os.homedir(), ".min-agent");
+const CONFIG_FILE_NAME = "config.json";
+const RULES_FILE_NAME = "rules.md";
 export function getConfigDir() {
-    return CONFIG_DIR;
+    return process.env.MIN_AGENT_CONFIG_DIR ?? DEFAULT_CONFIG_DIR;
 }
 export function getRulesFile() {
-    return RULES_FILE;
+    return path.join(getConfigDir(), RULES_FILE_NAME);
 }
-export function loadConfig() {
-    if (!existsSync(CONFIG_FILE))
+let cachedConfig = null;
+const projectCache = new Map();
+export function getProjectConfigDir() {
+    return path.join(process.cwd(), ".min-agent");
+}
+export function getProjectConfigFile() {
+    return path.join(getProjectConfigDir(), CONFIG_FILE_NAME);
+}
+export function loadProjectConfig() {
+    const file = getProjectConfigFile();
+    let st;
+    try {
+        st = statSync(file);
+    }
+    catch {
         return {};
+    }
+    const cached = projectCache.get(file);
+    if (cached && cached.mtimeMs === st.mtimeMs && cached.size === st.size)
+        return cached.config;
+    let config;
     try {
-        return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+        config = JSON.parse(readFileSync(file, "utf-8"));
     }
     catch {
+        console.warn(`\x1b[33m  ⚠ Project config ${file} is not valid JSON; ignoring\x1b[0m`);
         return {};
     }
+    projectCache.set(file, { mtimeMs: st.mtimeMs, size: st.size, config });
+    return config;
+}
+export function saveProjectConfig(config) {
+    const dir = getProjectConfigDir();
+    mkdirSync(dir, { recursive: true });
+    // Keep unknown keys, drop empty skill arrays so the file stays minimal.
+    const { disabledSkills, enabledSkills, ...rest } = config;
+    writeFileSync(getProjectConfigFile(), JSON.stringify({
+        ...rest,
+        ...(disabledSkills?.length ? { disabledSkills } : {}),
+        ...(enabledSkills?.length ? { enabledSkills } : {}),
+    }, null, 2), "utf-8");
+    projectCache.delete(getProjectConfigFile());
+}
+export function loadConfigFile(configFile) {
+    let st;
+    try {
+        st = statSync(configFile);
+    }
+    catch {
+        return {};
+    }
+    if (cachedConfig && cachedConfig.file === configFile && cachedConfig.mtimeMs === st.mtimeMs && cachedConfig.size === st.size) {
+        return cachedConfig.config;
+    }
+    let config;
+    try {
+        config = JSON.parse(readFileSync(configFile, "utf-8"));
+    }
+    catch {
+        console.warn(`\x1b[33m  ⚠ Config file ${configFile} is not valid JSON; using defaults\x1b[0m`);
+        return {};
+    }
+    cachedConfig = { file: configFile, mtimeMs: st.mtimeMs, size: st.size, config };
+    return config;
+}
+export function loadConfig() {
+    const raw = loadConfigFile(path.join(getConfigDir(), CONFIG_FILE_NAME));
+    const { config, migrated } = migrateLegacyConfig(raw);
+    if (migrated) {
+        try {
+            saveConfig(config);
+        }
+        catch { }
+    }
+    return config;
+}
+export function migrateLegacyConfig(config) {
+    const legacy = config.provider;
+    if (!legacy)
+        return { config, migrated: false };
+    const { provider, ...rest } = config;
+    return {
+        config: { ...rest, providers: [{ name: "default", ...provider }], activeProvider: "default" },
+        migrated: true,
+    };
+}
+export function getActiveProvider(config) {
+    if (!config.providers || config.providers.length === 0)
+        return undefined;
+    if (config.activeProvider) {
+        const found = config.providers.find((p) => p.name === config.activeProvider);
+        if (found)
+            return found;
+    }
+    return config.providers[0];
+}
+/** Appends /v1 to an Ollama base URL unless already present */
+export function normalizeOllamaBaseURL(baseURL) {
+    const trimmed = baseURL.replace(/\/$/, "");
+    return trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
 }
 export function saveConfig(config) {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+    const dir = getConfigDir();
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(path.join(dir, CONFIG_FILE_NAME), JSON.stringify(config, null, 2), "utf-8");
+    cachedConfig = null;
 }
 export function isConfigured() {
     const config = loadConfig();
-    return !!(config.provider?.baseURL && config.provider?.apiKey);
+    const provider = getActiveProvider(config);
+    return !!(provider?.baseURL && provider?.apiKey);
 }
 async function fetchModelsFromURL(url, apiKey) {
     const noCacheURL = new URL(url);
@@ -56,20 +150,24 @@ function ask(rl, question, defaultValue) {
         });
     });
 }
-const MODELS_CACHE_FILE = path.join(CONFIG_DIR, "models-cache.json");
+const MODELS_CACHE_FILE = "models-cache.json";
+function modelsCachePath() {
+    return path.join(getConfigDir(), MODELS_CACHE_FILE);
+}
 function loadModelsCache() {
-    if (!existsSync(MODELS_CACHE_FILE))
+    const file = modelsCachePath();
+    if (!existsSync(file))
         return [];
     try {
-        return JSON.parse(readFileSync(MODELS_CACHE_FILE, "utf-8"));
+        return JSON.parse(readFileSync(file, "utf-8"));
     }
     catch {
         return [];
     }
 }
 function saveModelsCache(models) {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-    writeFileSync(MODELS_CACHE_FILE, JSON.stringify(models), "utf-8");
+    mkdirSync(getConfigDir(), { recursive: true });
+    writeFileSync(modelsCachePath(), JSON.stringify(models), "utf-8");
 }
 export async function fetchModels(baseURL, apiKey) {
     try {
@@ -101,9 +199,73 @@ export async function fetchModels(baseURL, apiKey) {
 }
 export async function runSetup() {
     const config = loadConfig();
-    const existing = config.provider;
+    const providers = config.providers ?? [];
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     console.log("\n🔧 min-agent 配置\n");
+    if (providers.length > 0) {
+        console.log("已配置的 Provider:");
+        providers.forEach((p, i) => {
+            const marker = p.name === config.activeProvider ? " ← 当前" : "";
+            console.log(`  ${i + 1}. ${p.name ?? "(未命名)"}  ${p.baseURL}  (${p.defaultModel ?? "未设置模型"})${marker}`);
+        });
+        console.log();
+        console.log("选项:");
+        console.log("  1. 添加新 Provider");
+        console.log("  2. 切换当前 Provider");
+        console.log("  3. 修改当前 Provider");
+        console.log("  4. 完成");
+        const choice = await ask(rl, "选择 (1/2/3/4)", "4");
+        if (choice === "1") {
+            const provider = await collectProvider(rl, undefined);
+            provider.name = (await ask(rl, "Provider 名称", `provider-${providers.length + 1}`)).trim() || `provider-${providers.length + 1}`;
+            providers.push(provider);
+            config.activeProvider = provider.name;
+            config.providers = providers;
+            saveConfig(config);
+            console.log(`\n✓ Provider "${provider.name}" 已添加并设为当前`);
+        }
+        else if (choice === "2") {
+            const sel = await ask(rl, "输入序号选择当前 Provider");
+            const idx = parseInt(sel, 10) - 1;
+            const target = providers[idx];
+            if (!target?.name) {
+                console.error("无效序号");
+            }
+            else {
+                config.activeProvider = target.name;
+                saveConfig(config);
+                console.log(`\n✓ 当前 Provider 已切换为: ${target.name}`);
+            }
+        }
+        else if (choice === "3") {
+            const name = getActiveProvider(config)?.name ?? providers[0]?.name;
+            if (!name) {
+                console.error("无可用 Provider");
+                rl.close();
+                return;
+            }
+            const idx = providers.findIndex((p) => p.name === name);
+            providers[idx] = { ...(await collectProvider(rl, providers[idx])), name };
+            config.providers = providers;
+            saveConfig(config);
+            console.log(`\n✓ Provider "${name}" 已更新`);
+        }
+        else {
+            console.log("\n配置未变更");
+        }
+        rl.close();
+        return;
+    }
+    // 首次配置
+    const provider = await collectProvider(rl, undefined);
+    provider.name = "default";
+    config.providers = [provider];
+    config.activeProvider = "default";
+    saveConfig(config);
+    rl.close();
+    console.log(`\n✓ 配置已保存到 ${path.join(getConfigDir(), CONFIG_FILE_NAME)}`);
+}
+async function collectProvider(rl, existing) {
     console.log("Provider 类型:");
     console.log("  1. openai-compatible (默认，兼容 OpenAI API 的任意服务)");
     console.log("  2. openai (OpenAI 官方)");
@@ -117,10 +279,8 @@ export async function runSetup() {
     let apiKey;
     if (providerType === "ollama") {
         baseURL = await ask(rl, "Ollama API URL", existing?.baseURL || "http://localhost:11434/v1");
-        if (!baseURL.replace(/\/$/, "").endsWith("/v1")) {
-            baseURL = `${baseURL.replace(/\/$/, "")}/v1`;
-        }
-        apiKey = "ollama"; // Ollama doesn't need a real key
+        baseURL = normalizeOllamaBaseURL(baseURL);
+        apiKey = "ollama";
     }
     else if (providerType === "openai") {
         baseURL = "https://api.openai.com/v1";
@@ -132,7 +292,6 @@ export async function runSetup() {
     }
     if (!baseURL || (!apiKey && providerType !== "ollama")) {
         console.error("URL 和 Key 不能为空");
-        rl.close();
         process.exit(1);
     }
     console.log("\n正在获取模型列表...");
@@ -146,24 +305,16 @@ export async function runSetup() {
         });
         console.log();
         const choice = await ask(rl, "选择默认模型 (输入序号或模型名)", defaultModel);
-        const idx = parseInt(choice) - 1;
-        if (idx >= 0 && idx < models.length) {
+        const idx = parseInt(choice, 10) - 1;
+        if (idx >= 0 && idx < models.length)
             defaultModel = models[idx];
-        }
-        else if (choice) {
+        else if (choice)
             defaultModel = choice;
-        }
     }
     else {
         console.log("  ⚠ 无法获取模型列表，请手动输入模型名");
         const hint = providerType === "ollama" ? "llama3" : providerType === "openai" ? "gpt-4o" : "";
         defaultModel = await ask(rl, "默认模型", defaultModel || hint);
     }
-    rl.close();
-    config.provider = { type: providerType, baseURL, apiKey, defaultModel };
-    saveConfig(config);
-    console.log(`\n✓ 配置已保存到 ${CONFIG_FILE}`);
-    console.log(`  Type:  ${providerType}`);
-    console.log(`  URL:   ${baseURL}`);
-    console.log(`  Model: ${defaultModel}\n`);
+    return { type: providerType, baseURL, apiKey, defaultModel };
 }

package/dist/confirm.js

@@ -1,4 +1,5 @@
 import { loadConfig } from "./config.js";
+import readline from "readline";
 let autoApprove = false;
 export function setAutoApprove(value) {
     autoApprove = value;
@@ -19,6 +20,37 @@ let _tuiConfirm = null;
 export function setTuiConfirm(handler) {
     _tuiConfirm = handler;
 }
+/** Optional TUI question handler — when set, askQuestion() delegates to the TUI. Returns null on cancel. */
+let _tuiQuestion = null;
+export function setTuiQuestion(handler) {
+    _tuiQuestion = handler;
+}
+/** Ask the user a free-form question. Returns the answer, or null if cancelled. */
+export async function askQuestion(prompt, options) {
+    if (_tuiQuestion)
+        return _tuiQuestion(prompt, options);
+    if (!process.stdin.isTTY) {
+        console.log(`\n\x1b[33m❓ ${prompt} (no interactive terminal — skipped)\x1b[0m`);
+        return null;
+    }
+    console.log();
+    console.log(`\x1b[33m❓ ${prompt}\x1b[0m`);
+    if (options && options.length > 0) {
+        for (let i = 0; i < options.length; i++) {
+            console.log(`\x1b[90m   ${i + 1}. ${options[i]}\x1b[0m`);
+        }
+    }
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question("\x1b[36m   → \x1b[0m", (answer) => {
+            rl.close();
+            resolve(answer.trim() || "(no answer)");
+        });
+    });
+}
 /**
  * Ask user for confirmation. Returns true if approved.
  * Display order: detail first, then [y/N] prompt at the bottom.
@@ -29,6 +61,11 @@ export async function confirm(message) {
     // If TUI mode is active, delegate to the TUI overlay
     if (_tuiConfirm)
         return _tuiConfirm(message);
+    // Non-interactive stdin can never answer — reject instead of hanging
+    if (!process.stdin.isTTY) {
+        console.log(`\n\x1b[33m⚠ Rejected (no interactive terminal): ${message}\x1b[0m`);
+        return false;
+    }
     // Pause readline so it doesn't consume/echo the keystroke
     _rl?.pause();
     // Detail on top, prompt at the bottom
@@ -60,17 +97,29 @@ export async function confirm(message) {
 /** Check if a shell command is potentially dangerous */
 export function isDangerousCommand(command) {
     const dangerous = [
-        /\brm\s+(-rf?|--recursive)\s/,
-        /\brm\s+-[a-z]*f/,
+        /\brm\s+(-[a-z]*[rf][a-z]*|--recursive)\s/,
         /\bsudo\b/,
         /\bmkfs\b/,
         /\bdd\s+/,
         /\b(shutdown|reboot|halt|poweroff)\b/,
-        /\bgit\s+(push|reset\s+--hard|clean\s+-[a-z]*f)/,
-        /\bnpm\s+publish\b/,
-        /\bdrop\s+(table|database)\b/i,
-        /\btruncate\s+table\b/i,
+        /\bgit\s+(push|reset\s+--hard|clean\s+-[a-z]*f|rebase)/,
+        /\bnpm\s+(publish|unpublish)\b/,
+        /\b(drop|truncate)\s+(table|database)\b/i,
         /\bformat\b.*\b[a-z]:\b/i,
+        /\bfind\b[^|;&]*\s+-delete\b/,
+        /\|\s*(ba|z|fi)?sh\b/,
+        /\bchmod\s+(-[a-zA-Z]+\s+)?[0-7]{3,4}\b/,
+        /\bchown\s+-R\b/,
+        /\bkill(all)?\s+(-9|-[a-z]*9)/,
+        /\b(pkill|killall)\b/,
+        /\bgit\s+checkout\s+\./,
+        /\bgit\s+stash\b/,
+        /\b(docker|podman)\s+(rm|prune|system)\b/,
+        /\b(shred|wipefs)\b/,
+        /\b(cp|mv)\s+-[a-z]*f\b/,
+        /[^<>=!&]\s*>>?\s*[^<>=&]|^\s*>>?\s*[^<>=&]/,
+        /:\(\)\s*\{/,
+        />+\s*\/dev\/(sd[a-z]+|nvme\d|disk\d)/,
     ];
     return dangerous.some((re) => re.test(command));
 }

package/dist/context-window.js

@@ -1,6 +1,6 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
 import path from "path";
-import { getConfigDir, loadConfig } from "./config.js";
+import { getConfigDir, loadConfig, getActiveProvider } from "./config.js";
 /**
  * Auto-detect context window size for the current model.
  *
@@ -11,34 +11,44 @@ import { getConfigDir, loadConfig } from "./config.js";
  * 4. Fallback: 128000
  */
 const DEFAULT_CONTEXT_WINDOW = 128000;
-const CACHE_FILE = path.join(getConfigDir(), "context-window-cache.json");
 const CACHE_TTL = 7 * 24 * 60 * 60 * 1000; // 7 days
-function loadCache() {
-    if (!existsSync(CACHE_FILE))
+function cacheFile() {
+    return path.join(getConfigDir(), "context-window-cache.json");
+}
+const memoryCache = new Map();
+const inFlight = new Map();
+function loadDiskCache() {
+    const file = cacheFile();
+    if (!existsSync(file))
         return {};
     try {
-        return JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+        return JSON.parse(readFileSync(file, "utf-8"));
     }
     catch {
         return {};
     }
 }
 function saveCache(cache) {
-    mkdirSync(path.dirname(CACHE_FILE), { recursive: true });
-    writeFileSync(CACHE_FILE, JSON.stringify(cache), "utf-8");
+    const file = cacheFile();
+    mkdirSync(path.dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(cache), "utf-8");
 }
 function getCached(modelId) {
-    const cache = loadCache();
-    const entry = cache[modelId];
-    if (!entry)
-        return null;
-    if (Date.now() - entry.timestamp > CACHE_TTL)
-        return null;
-    return entry.contextWindow;
+    const memory = memoryCache.get(modelId);
+    if (memory && Date.now() - memory.timestamp <= CACHE_TTL)
+        return memory.contextWindow;
+    const disk = loadDiskCache()[modelId];
+    if (disk && Date.now() - disk.timestamp <= CACHE_TTL) {
+        memoryCache.set(modelId, disk);
+        return disk.contextWindow;
+    }
+    return null;
 }
 function setCache(modelId, contextWindow) {
-    const cache = loadCache();
-    cache[modelId] = { contextWindow, timestamp: Date.now() };
+    const entry = { contextWindow, timestamp: Date.now() };
+    memoryCache.set(modelId, entry);
+    const cache = loadDiskCache();
+    cache[modelId] = entry;
     saveCache(cache);
 }
 /** Try OpenRouter: GET /api/v1/models returns context_length per model */
@@ -62,6 +72,8 @@ async function tryOpenRouter(baseURL, apiKey, modelId) {
 }
 /** Try vLLM: GET /v1/models returns max_model_len */
 async function tryVllm(baseURL, apiKey, modelId) {
+    if (!baseURL.includes("vllm"))
+        return null;
     try {
         const url = `${baseURL.replace(/\/$/, "")}/models`;
         const response = await fetch(url, {
@@ -114,15 +126,7 @@ async function tryModelsDev(modelId) {
         if (!response.ok)
             return null;
         const providers = (await response.json());
-        // Search all providers for the model ID
-        for (const provider of Object.values(providers)) {
-            if (!provider.models)
-                continue;
-            const model = provider.models[modelId];
-            if (model?.limit?.context)
-                return model.limit.context;
-        }
-        // Try partial match (some providers prefix model IDs)
+        // Single pass: exact match or partial match (some providers prefix model IDs)
         for (const provider of Object.values(providers)) {
             if (!provider.models)
                 continue;
@@ -139,47 +143,56 @@ async function tryModelsDev(modelId) {
         return null;
     }
 }
+/**
+ * Detect context window size for a model by probing all sources in parallel.
+ * Returns the first non-null result, respecting the original precedence.
+ */
+async function detectContextWindow(config, id) {
+    const provider = getActiveProvider(config);
+    const baseURL = provider?.baseURL ?? "";
+    const apiKey = provider?.apiKey ?? "";
+    const results = await Promise.all([
+        tryOpenRouter(baseURL, apiKey, id),
+        tryOllama(baseURL, id),
+        tryVllm(baseURL, apiKey, id),
+        tryModelsDev(id),
+    ]);
+    const found = results.find((v) => v !== null);
+    if (found) {
+        setCache(id, found);
+        return found;
+    }
+    setCache(id, DEFAULT_CONTEXT_WINDOW);
+    return DEFAULT_CONTEXT_WINDOW;
+}
 /**
  * Get context window size for the current model.
- * Tries multiple sources, caches the result.
+ * Tries multiple sources, caches the result in memory and on disk.
+ * Concurrent calls for the same model share a single probe.
  */
 export async function getContextWindow(modelId) {
     const config = loadConfig();
+    const provider = getActiveProvider(config);
     // 1. Explicit user config
-    if (config.provider?.contextWindow)
-        return config.provider.contextWindow;
-    const id = modelId ?? config.provider?.defaultModel;
+    if (provider?.contextWindow)
+        return provider.contextWindow;
+    const id = modelId ?? provider?.defaultModel;
     if (!id)
         return DEFAULT_CONTEXT_WINDOW;
     // 2. Check cache
     const cached = getCached(id);
     if (cached !== null)
         return cached;
-    const baseURL = config.provider?.baseURL ?? "";
-    const apiKey = config.provider?.apiKey ?? "";
-    // 3. Provider-specific APIs
-    const openRouter = await tryOpenRouter(baseURL, apiKey, id);
-    if (openRouter) {
-        setCache(id, openRouter);
-        return openRouter;
-    }
-    const ollama = await tryOllama(baseURL, id);
-    if (ollama) {
-        setCache(id, ollama);
-        return ollama;
-    }
-    const vllm = await tryVllm(baseURL, apiKey, id);
-    if (vllm) {
-        setCache(id, vllm);
-        return vllm;
+    // 3. Reuse an in-flight probe for the same model
+    const pending = inFlight.get(id);
+    if (pending)
+        return pending;
+    const probing = detectContextWindow(config, id);
+    inFlight.set(id, probing);
+    try {
+        return await probing;
     }
-    // 4. models.dev lookup
-    const modelsDev = await tryModelsDev(id);
-    if (modelsDev) {
-        setCache(id, modelsDev);
-        return modelsDev;
+    finally {
+        inFlight.delete(id);
     }
-    // 5. Fallback
-    setCache(id, DEFAULT_CONTEXT_WINDOW);
-    return DEFAULT_CONTEXT_WINDOW;
 }

package/dist/doom-loop.js

@@ -8,26 +8,33 @@
  * Based on opencode's processor.ts doom loop detection.
  */
 const THRESHOLD = 3;
+/** Deterministic serialization so equivalent objects compare equal regardless of key order. */
+function serializeInput(input) {
+    if (input === null || typeof input !== "object")
+        return JSON.stringify(input);
+    if (Array.isArray(input))
+        return JSON.stringify(input.map(serializeInput));
+    const sorted = {};
+    for (const key of Object.keys(input).sort()) {
+        sorted[key] = serializeInput(input[key]);
+    }
+    return JSON.stringify(sorted);
+}
 export class DoomLoopDetector {
     recentCalls = [];
     /** Record a tool call. Returns true if a doom loop is detected. */
     record(toolName, input) {
-        const serialized = JSON.stringify(input);
-        this.recentCalls.push({ toolName, input: serialized });
-        // Only check the last THRESHOLD calls
-        if (this.recentCalls.length < THRESHOLD)
-            return false;
-        const recent = this.recentCalls.slice(-THRESHOLD);
-        const allSame = recent.every((call) => call.toolName === recent[0].toolName && call.input === recent[0].input);
+        const call = { toolName, input: serializeInput(input) };
+        this.recentCalls.push(call);
+        const window = this.recentCalls.slice(-THRESHOLD);
+        const allSame = window.length === THRESHOLD &&
+            window.every((c) => c.toolName === call.toolName && c.input === call.input);
+        // Keep only the most recent THRESHOLD-1 calls to bound memory
+        this.recentCalls = window.slice(-(THRESHOLD - 1));
         if (allSame) {
-            // Reset to prevent repeated warnings
             this.recentCalls = [];
             return true;
         }
-        // Keep only last THRESHOLD entries to bound memory
-        if (this.recentCalls.length > THRESHOLD * 2) {
-            this.recentCalls = this.recentCalls.slice(-THRESHOLD);
-        }
         return false;
     }
     reset() {