min-agent 0.5.1 → 0.6.0

package/dist/config.js

@@ -1,363 +0,0 @@
-import { readFileSync, mkdirSync, existsSync, statSync } from "fs";
-import path from "path";
-import os from "os";
-import { atomicWriteFileSync } from "./tools/atomic-file.js";
-import { getEffectiveSandboxPolicy, mergeSandboxConfig, parseSandboxConfig, sandboxLaunchSource, sandboxStatusLabel, } from "./sandbox.js";
-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 process.env.MIN_AGENT_CONFIG_DIR ?? DEFAULT_CONFIG_DIR;
-}
-export function getRulesFile() {
-    return path.join(getConfigDir(), RULES_FILE_NAME);
-}
-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 {
-        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;
-    atomicWriteFileSync(getProjectConfigFile(), JSON.stringify({
-        ...rest,
-        ...(disabledSkills?.length ? { disabledSkills } : {}),
-        ...(enabledSkills?.length ? { enabledSkills } : {}),
-    }, null, 2));
-    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 mergeProjectOverGlobal(global, project) {
-    const activeProvider = project.activeProvider ?? global.activeProvider;
-    const sampling = project.sampling ? { ...global.sampling, ...project.sampling } : global.sampling;
-    const budget = project.budget ? { ...global.budget, ...project.budget } : global.budget;
-    const permission = parsePermissionMode(project.permission) ?? parsePermissionMode(global.permission);
-    const thinking = parseThinkingEffort(project.thinking) ?? parseThinkingEffort(global.thinking);
-    const memory = parseMemoryMode(project.memory) ?? parseMemoryMode(global.memory);
-    const sandbox = mergeSandboxConfig(parseSandboxConfig(global.sandbox), parseSandboxConfig(project.sandbox));
-    const compaction = project.compaction ? { ...global.compaction, ...project.compaction } : global.compaction;
-    const agent = project.agent ? { ...global.agent, ...project.agent } : global.agent;
-    let providers = global.providers;
-    if (project.defaultModel && providers && providers.length > 0) {
-        const idx = activeProvider ? providers.findIndex((p) => p.name === activeProvider) : 0;
-        const target = idx >= 0 ? idx : 0;
-        providers = providers.map((p, i) => (i === target ? { ...p, defaultModel: project.defaultModel } : p));
-    }
-    return {
-        ...global,
-        activeProvider,
-        sampling,
-        budget,
-        permission,
-        ...(thinking ? { thinking } : {}),
-        ...(memory ? { memory } : {}),
-        ...(sandbox ? { sandbox } : {}),
-        compaction,
-        agent,
-        ...(providers ? { providers } : {}),
-    };
-}
-export function getEffectiveConfig() {
-    return mergeProjectOverGlobal(loadConfig(), loadProjectConfig());
-}
-export function getBudgetSnapshot() {
-    const global = loadConfig();
-    const project = loadProjectConfig();
-    const maxCostUSD = mergeProjectOverGlobal(global, project).budget?.maxCostUSD;
-    const source = project.budget?.maxCostUSD != null ? "project" : global.budget?.maxCostUSD != null ? "global" : null;
-    return { maxCostUSD, source };
-}
-export function parsePermissionMode(value) {
-    if (value === "ask" || value === "accept-edits" || value === "allow-all")
-        return value;
-    return undefined;
-}
-const THINKING_ALIASES = {
-    off: "off",
-    none: "off",
-    low: "low",
-    minimal: "low",
-    medium: "medium",
-    high: "high",
-    max: "max",
-    xhigh: "max",
-    "extra-high": "max",
-    extra_high: "max",
-    extrahigh: "max",
-};
-export function parseThinkingEffort(value) {
-    if (typeof value !== "string")
-        return undefined;
-    return THINKING_ALIASES[value.trim().toLowerCase()];
-}
-const MEMORY_ALIASES = {
-    on: "on",
-    true: "on",
-    enable: "on",
-    enabled: "on",
-    off: "off",
-    false: "off",
-    disable: "off",
-    disabled: "off",
-};
-export function parseMemoryMode(value) {
-    if (value === true)
-        return "on";
-    if (value === false)
-        return "off";
-    if (typeof value !== "string")
-        return undefined;
-    return MEMORY_ALIASES[value.trim().toLowerCase()];
-}
-export function permissionModeLabel(mode) {
-    if (mode === "allow-all")
-        return "allow all";
-    if (mode === "accept-edits")
-        return "accept edits";
-    return "ask";
-}
-export function getPermissionSnapshot() {
-    const global = loadConfig();
-    const project = loadProjectConfig();
-    const permission = parsePermissionMode(project.permission) ?? parsePermissionMode(global.permission) ?? "ask";
-    const source = parsePermissionMode(project.permission) != null
-        ? "project"
-        : parsePermissionMode(global.permission) != null
-            ? "global"
-            : null;
-    return { permission, source };
-}
-export function setPermissionMode(permission, scope) {
-    if (scope === "project") {
-        const project = loadProjectConfig();
-        saveProjectConfig({ ...project, permission });
-        return;
-    }
-    saveConfig({ ...loadConfig(), permission });
-}
-export function setSandboxConfig(partial, scope) {
-    if (scope === "project") {
-        const project = loadProjectConfig();
-        const current = parseSandboxConfig(project.sandbox) ?? {};
-        saveProjectConfig({ ...project, sandbox: { ...current, ...partial } });
-        return;
-    }
-    const cfg = loadConfig();
-    const current = parseSandboxConfig(cfg.sandbox) ?? {};
-    saveConfig({ ...cfg, sandbox: { ...current, ...partial } });
-}
-export function getSandboxSnapshot() {
-    const policy = getEffectiveSandboxPolicy();
-    const launch = sandboxLaunchSource();
-    const project = parseSandboxConfig(loadProjectConfig().sandbox);
-    const global = parseSandboxConfig(loadConfig().sandbox);
-    const projectSet = Boolean(project?.mode || project?.network || project?.extraWriteRoots?.length || project?.extraReadRoots?.length);
-    const globalSet = Boolean(global?.mode || global?.network || global?.extraWriteRoots?.length || global?.extraReadRoots?.length);
-    const source = launch ?? (projectSet ? "project" : globalSet ? "global" : null);
-    return {
-        mode: policy.mode,
-        network: policy.network,
-        extraWriteRoots: policy.extraWriteRoots,
-        extraReadRoots: policy.extraReadRoots,
-        source,
-        label: sandboxStatusLabel(policy),
-    };
-}
-export function setBudgetMaxCost(maxCostUSD, scope) {
-    if (scope === "project") {
-        const project = loadProjectConfig();
-        saveProjectConfig({ ...project, budget: { ...project.budget, maxCostUSD } });
-        return;
-    }
-    const cfg = loadConfig();
-    saveConfig({ ...cfg, budget: { ...cfg.budget, maxCostUSD } });
-}
-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) {
-    const dir = getConfigDir();
-    mkdirSync(dir, { recursive: true });
-    atomicWriteFileSync(path.join(dir, CONFIG_FILE_NAME), JSON.stringify(config, null, 2));
-    cachedConfig = null;
-}
-export function isConfigured() {
-    const config = loadConfig();
-    const provider = getActiveProvider(config);
-    return !!(provider?.baseURL && provider?.apiKey);
-}
-async function fetchModelsFromURL(url, apiKey) {
-    const noCacheURL = new URL(url);
-    noCacheURL.searchParams.set("_t", Date.now().toString());
-    const response = await fetch(noCacheURL.toString(), {
-        headers: {
-            Authorization: `Bearer ${apiKey}`,
-            "Cache-Control": "no-cache, no-store, must-revalidate",
-            Pragma: "no-cache",
-            Expires: "0",
-        },
-        cache: "no-store",
-        signal: AbortSignal.timeout(10000),
-    });
-    if (!response.ok)
-        return { models: [], ok: false, status: response.status };
-    const data = await response.json();
-    return { models: parseModelIds(data), ok: true, status: response.status };
-}
-function parseModelIds(data) {
-    const list = Array.isArray(data)
-        ? data
-        : data !== null && typeof data === "object" && "data" in data && Array.isArray(data.data)
-            ? data.data
-            : [];
-    return list
-        .map((item) => item !== null && typeof item === "object" && "id" in item && typeof item.id === "string" ? item.id : null)
-        .filter((id) => id != null)
-        .sort();
-}
-const MODELS_CACHE_FILE = "models-cache.json";
-function modelsCachePath() {
-    return path.join(getConfigDir(), MODELS_CACHE_FILE);
-}
-function modelsCacheKey(baseURL) {
-    return baseURL.replace(/\/$/, "");
-}
-function loadModelsCacheMap() {
-    const file = modelsCachePath();
-    if (!existsSync(file))
-        return {};
-    try {
-        const parsed = JSON.parse(readFileSync(file, "utf-8"));
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-            return {};
-        return Object.fromEntries(Object.entries(parsed).filter((entry) => Array.isArray(entry[1]) && entry[1].every((item) => typeof item === "string")));
-    }
-    catch {
-        return {};
-    }
-}
-function loadModelsCacheBucket(baseURL) {
-    return loadModelsCacheMap()[modelsCacheKey(baseURL)] ?? [];
-}
-function saveModelsCacheBucket(baseURL, models) {
-    const map = loadModelsCacheMap();
-    map[modelsCacheKey(baseURL)] = models;
-    mkdirSync(getConfigDir(), { recursive: true });
-    atomicWriteFileSync(modelsCachePath(), JSON.stringify(map));
-}
-export async function fetchModelsLive(baseURL, apiKey) {
-    try {
-        const trimmed = modelsCacheKey(baseURL);
-        let result = await fetchModelsFromURL(`${trimmed}/models`, apiKey);
-        if (result.models.length === 0 && !trimmed.endsWith("/v1")) {
-            result = await fetchModelsFromURL(`${trimmed}/v1/models`, apiKey);
-        }
-        if (result.ok && result.models.length > 0) {
-            saveModelsCacheBucket(trimmed, result.models);
-            return { models: result.models, ok: true, status: result.status };
-        }
-        if (!result.ok)
-            return { models: [], ok: false, status: result.status };
-        return { models: [], ok: true, status: result.status };
-    }
-    catch {
-        return { models: [], ok: false };
-    }
-}
-export async function fetchModels(baseURL, apiKey) {
-    const live = await fetchModelsLive(baseURL, apiKey);
-    if (live.models.length > 0)
-        return live.models;
-    const cached = loadModelsCacheBucket(baseURL);
-    if (cached.length > 0) {
-        const suffix = live.status == null && !live.ok ? " — network unavailable" : "";
-        console.log(`\x1b[90m  (using cached model list${suffix})\x1b[0m`);
-    }
-    return cached;
-}

package/dist/confirm.js

@@ -1,172 +0,0 @@
-import { AsyncLocalStorage } from "async_hooks";
-import { getEffectiveConfig } from "./config.js";
-import { normalizeQuestionOptions, normalizeQuestionPrompt } from "./question-format.js";
-import readline from "readline";
-let autoApprove = false;
-export function setAutoApprove(value) {
-    autoApprove = value;
-}
-export function isAutoApprove() {
-    const ctx = confirmAls.getStore();
-    if (ctx)
-        return ctx.autoApprove;
-    if (autoApprove)
-        return true;
-    return getPermissionMode() === "allow-all";
-}
-let permissionOverride;
-export function setPermissionOverride(mode) {
-    permissionOverride = mode;
-}
-export function getPermissionOverride() {
-    return permissionOverride;
-}
-export function getPermissionMode() {
-    if (permissionOverride)
-        return permissionOverride;
-    const config = getEffectiveConfig();
-    return config.permission === "allow-all" || config.permission === "accept-edits" || config.permission === "ask"
-        ? config.permission
-        : "ask";
-}
-export function isEditAutoApprove() {
-    if (isAutoApprove())
-        return true;
-    return getPermissionMode() === "accept-edits";
-}
-const confirmAls = new AsyncLocalStorage();
-export function runWithConfirmContext(ctx, fn) {
-    return confirmAls.run(ctx, fn);
-}
-/** Optional readline interface to pause/resume during confirmation prompts. */
-let _rl = null;
-export function setConfirmReadline(rl) {
-    _rl = rl;
-}
-/** Optional TUI confirm handler — when set, confirm() delegates to the TUI overlay. */
-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) {
-    const safePrompt = normalizeQuestionPrompt(prompt);
-    const choices = normalizeQuestionOptions(options);
-    const safeOptions = choices.length > 0 ? choices : undefined;
-    const ctx = confirmAls.getStore();
-    if (ctx) {
-        if (ctx.autoApprove)
-            return null;
-        if (ctx.onQuestion)
-            return ctx.onQuestion(safePrompt, safeOptions);
-        return null;
-    }
-    if (_tuiQuestion)
-        return _tuiQuestion(safePrompt, safeOptions);
-    if (!process.stdin.isTTY) {
-        console.log(`\n\x1b[33m❓ ${safePrompt} (no interactive terminal — skipped)\x1b[0m`);
-        return null;
-    }
-    console.log();
-    console.log(`\x1b[33m❓ ${safePrompt}\x1b[0m`);
-    if (safeOptions) {
-        for (let i = 0; i < safeOptions.length; i++) {
-            console.log(`\x1b[90m   ${i + 1}. ${safeOptions[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.
- */
-export async function confirm(message) {
-    const ctx = confirmAls.getStore();
-    if (ctx) {
-        if (ctx.autoApprove)
-            return true;
-        if (ctx.onConfirm)
-            return ctx.onConfirm(message);
-        return false;
-    }
-    if (isAutoApprove())
-        return true;
-    // 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
-    process.stdout.write(`\n\x1b[90m┌─ 即将执行 ─────────────────────────────────\x1b[0m\n`);
-    process.stdout.write(`\x1b[90m│\x1b[0m ${message}\n`);
-    process.stdout.write(`\x1b[90m└────────────────────────────────────────────\x1b[0m\n`);
-    process.stdout.write(`\n\x1b[1;34m? 是否允许执行？ [y/N] \x1b[0m`);
-    return new Promise((resolve) => {
-        const wasRaw = process.stdin.isRaw;
-        if (process.stdin.isTTY)
-            process.stdin.setRawMode(true);
-        // Ensure stdin is flowing so we can receive data even after readline pause
-        process.stdin.resume();
-        const onData = (buf) => {
-            const ch = buf.toString();
-            process.stdin.removeListener("data", onData);
-            if (process.stdin.isTTY)
-                process.stdin.setRawMode(wasRaw ?? false);
-            // Echo the character and newline
-            process.stdout.write(ch === "\r" || ch === "\n" ? "\n\n" : `${ch}\n\n`);
-            // Resume readline after confirmation
-            _rl?.resume();
-            const answer = ch.trim().toLowerCase();
-            resolve(answer === "y");
-        };
-        process.stdin.on("data", onData);
-    });
-}
-/** Check if a shell command is potentially dangerous */
-export function isDangerousCommand(command) {
-    const dangerous = [
-        /\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|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));
-}