min-agent 0.5.1 → 0.6.0

package/dist/paste-handler.js

@@ -1,41 +0,0 @@
-/**
- * Paste handler for large text input.
- *
- * When the user pastes large content (multi-line or >150 chars),
- * shows a collapsed summary in the terminal but preserves the full
- * text for sending to the model.
- *
- * Based on opencode's paste handling in the TUI prompt component.
- */
-const PASTE_LINE_THRESHOLD = 3;
-const PASTE_CHAR_THRESHOLD = 150;
-const PREVIEW_LINES = 3;
-/**
- * Process input text and detect if it's a large paste.
- * Returns the full text plus display metadata.
- */
-export function processPastedInput(text) {
-    const lineCount = (text.match(/\n/g)?.length ?? 0) + 1;
-    if (lineCount < PASTE_LINE_THRESHOLD && text.length <= PASTE_CHAR_THRESHOLD) {
-        return { fullText: text, isLargePaste: false, lineCount };
-    }
-    const lines = text.split("\n");
-    const preview = lines.slice(0, PREVIEW_LINES).join("\n");
-    const remaining = lineCount - PREVIEW_LINES;
-    return {
-        fullText: text,
-        isLargePaste: true,
-        lineCount,
-        summary: remaining > 0
-            ? `${preview}\n\x1b[90m  ... (${remaining} more lines, ~${text.length} chars total)\x1b[0m`
-            : `\x1b[90m[Pasted ${text.length} chars]\x1b[0m`,
-    };
-}
-/**
- * Print paste feedback to the user.
- */
-export function printPasteFeedback(result) {
-    if (!result.isLargePaste)
-        return;
-    console.log(`\x1b[90m  📋 Pasted ~${result.lineCount} lines (${result.fullText.length} chars)\x1b[0m`);
-}

package/dist/permission-cli.js

@@ -1,40 +0,0 @@
-import { takeScopeFlags, scopeLabel } from "./scope.js";
-import { getPermissionSnapshot, parsePermissionMode, permissionModeLabel, setPermissionMode, } from "./config.js";
-import { getPermissionOverride, setPermissionOverride } from "./confirm.js";
-export const PERMISSION_CLI_USAGE = [
-    "Usage: min-agent permission [ask|accept-edits|allow-all] [--project|--global]",
-    "       min-agent --permission ask|accept-edits|allow-all [--project|--global]",
-].join("\n");
-function sourceLabel(source) {
-    return source === "cli" ? "this run" : source === "project" ? "project" : source === "global" ? "global" : "default";
-}
-export function runPermissionCli(input) {
-    const { scope: posScope, rest } = takeScopeFlags(input.positionals);
-    const scope = posScope ?? input.scope ?? "global";
-    if (rest[0] === "--help" || rest[0] === "-h") {
-        return { ok: true, lines: [PERMISSION_CLI_USAGE] };
-    }
-    if (rest.length === 1) {
-        const parsed = parsePermissionMode(rest[0]);
-        if (!parsed)
-            return { ok: false, lines: [PERMISSION_CLI_USAGE] };
-        setPermissionMode(parsed, scope);
-        setPermissionOverride(parsed);
-        return { ok: true, lines: [`✓ Permission set to ${permissionModeLabel(parsed)} (${scopeLabel(scope)})`] };
-    }
-    if (rest.length > 1)
-        return { ok: false, lines: [PERMISSION_CLI_USAGE] };
-    if (input.flagMode) {
-        setPermissionMode(input.flagMode, scope);
-        setPermissionOverride(input.flagMode);
-        return { ok: true, lines: [`✓ Permission set to ${permissionModeLabel(input.flagMode)} (${scopeLabel(scope)})`] };
-    }
-    const snap = getPermissionSnapshot();
-    const override = getPermissionOverride();
-    const mode = override ?? snap.permission;
-    const source = override ? "cli" : snap.source;
-    return {
-        ok: true,
-        lines: [`Current permission: ${permissionModeLabel(mode)} (${sourceLabel(source)})`, PERMISSION_CLI_USAGE],
-    };
-}

package/dist/plugins.js

@@ -1,131 +0,0 @@
-import { tool, jsonSchema } from "ai";
-import { existsSync, readdirSync, statSync } from "fs";
-import { pathToFileURL } from "url";
-import path from "path";
-import { getConfigDir } from "./config.js";
-import { confirm, isAutoApprove } from "./confirm.js";
-const PLUGIN_DIRS = [path.join(process.cwd(), ".min-agent", "tools"), path.join(getConfigDir(), "tools")];
-let cachedPlugins = null;
-let pluginReadOnlyIds = new Set();
-export function pluginNeedsConfirm(def) {
-    if (def.readOnly === true)
-        return false;
-    if (def.dangerous === false)
-        return false;
-    return true;
-}
-export function getPluginReadOnlyIds() {
-    return pluginReadOnlyIds;
-}
-function pluginSignature(dirs) {
-    return dirs
-        .map((dir) => {
-        if (!existsSync(dir))
-            return `${dir}:missing`;
-        const files = readdirSync(dir)
-            .filter((f) => f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".mjs"))
-            .sort();
-        const mtimes = files.map((f) => statSync(path.join(dir, f)).mtimeMs).join(",");
-        return `${dir}:${files.join(",")}:${mtimes}`;
-    })
-        .join("|");
-}
-export async function loadPluginTools(dirs) {
-    const pluginDirs = dirs ?? PLUGIN_DIRS;
-    const signature = pluginSignature(pluginDirs);
-    if (cachedPlugins && cachedPlugins.signature === signature) {
-        pluginReadOnlyIds = cachedPlugins.readOnlyIds;
-        return cachedPlugins.tools;
-    }
-    const tools = await loadPluginToolsUncached(pluginDirs);
-    cachedPlugins = { signature, tools, readOnlyIds: pluginReadOnlyIds };
-    return tools;
-}
-async function loadPluginToolsUncached(pluginDirs) {
-    const tools = {};
-    const readOnlyIds = new Set();
-    for (const dir of pluginDirs) {
-        if (!existsSync(dir))
-            continue;
-        const files = readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".mjs"));
-        for (const file of files) {
-            const filePath = path.join(dir, file);
-            const namespace = path.basename(file, path.extname(file));
-            try {
-                const mod = await import(pathToFileURL(filePath).href);
-                for (const [exportName, def] of Object.entries(mod)) {
-                    if (!isPluginTool(def))
-                        continue;
-                    const toolId = exportName === "default" ? namespace : `${namespace}_${exportName}`;
-                    if (tools[toolId]) {
-                        console.warn(`\x1b[33m  ⚠ Plugin tool "${toolId}" from ${filePath} conflicts with an existing tool; skipping\x1b[0m`);
-                        continue;
-                    }
-                    const properties = {};
-                    const required = [];
-                    for (const [key, param] of Object.entries(def.parameters)) {
-                        const type = narrowJsonType(param.type);
-                        properties[key] = { type, ...(param.description ? { description: param.description } : {}) };
-                        required.push(key);
-                    }
-                    if (def.readOnly === true)
-                        readOnlyIds.add(toolId);
-                    tools[toolId] = tool({
-                        description: def.description,
-                        inputSchema: jsonSchema({
-                            type: "object",
-                            properties,
-                            required,
-                        }),
-                        execute: async (args) => {
-                            if (pluginNeedsConfirm(def) && !isAutoApprove()) {
-                                const preview = summarizePluginArgs(args);
-                                const approved = await confirm(`运行自定义工具 ${toolId}${preview ? `\n${preview}` : ""}`);
-                                if (!approved)
-                                    return "自定义工具已被拒绝。";
-                            }
-                            try {
-                                const result = await def.execute(args);
-                                return typeof result === "string" ? result : (JSON.stringify(result) ?? "undefined");
-                            }
-                            catch (err) {
-                                return `Plugin error: ${String(err instanceof Error ? err.message : err)}`;
-                            }
-                        },
-                    });
-                }
-            }
-            catch (err) {
-                console.error(`\x1b[90m  Plugin "${file}" failed to load: ${String(err instanceof Error ? err.message : err)}\x1b[0m`);
-            }
-        }
-    }
-    pluginReadOnlyIds = readOnlyIds;
-    const count = Object.keys(tools).length;
-    if (count > 0) {
-        console.log(`\x1b[90m  Plugins loaded: ${count} tool(s)\x1b[0m`);
-    }
-    return tools;
-}
-function summarizePluginArgs(args) {
-    try {
-        const text = JSON.stringify(args);
-        if (!text || text === "{}")
-            return "";
-        return text.length > 400 ? `${text.slice(0, 400)}…` : text;
-    }
-    catch {
-        return "";
-    }
-}
-function narrowJsonType(type) {
-    if (type === "number" || type === "boolean" || type === "object" || type === "array")
-        return type;
-    return "string";
-}
-function isPluginTool(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    const obj = value;
-    return typeof obj.description === "string" && typeof obj.parameters === "object" && typeof obj.execute === "function";
-}

package/dist/pricing.js

@@ -1,119 +0,0 @@
-import { readFileSync, mkdirSync, existsSync } from "fs";
-import path from "path";
-import { atomicWriteFileSync } from "./tools/atomic-file.js";
-import { getConfigDir, loadConfig } from "./config.js";
-const CACHE_TTL = 7 * 24 * 60 * 60 * 1000;
-const memoryCache = new Map();
-const inFlight = new Map();
-const NEGATIVE_TTL = 60 * 60 * 1000;
-const negativeCache = new Map();
-function cacheFile() {
-    return path.join(getConfigDir(), "pricing-cache.json");
-}
-function loadDiskCache() {
-    const file = cacheFile();
-    if (!existsSync(file))
-        return {};
-    try {
-        return JSON.parse(readFileSync(file, "utf-8"));
-    }
-    catch {
-        return {};
-    }
-}
-function saveCache(cache) {
-    const file = cacheFile();
-    mkdirSync(path.dirname(file), { recursive: true });
-    atomicWriteFileSync(file, JSON.stringify(cache));
-}
-function getCached(modelId) {
-    const memory = memoryCache.get(modelId);
-    if (memory && Date.now() - memory.timestamp <= CACHE_TTL)
-        return memory;
-    const disk = loadDiskCache()[modelId];
-    if (disk && Date.now() - disk.timestamp <= CACHE_TTL) {
-        memoryCache.set(modelId, disk);
-        return disk;
-    }
-    return null;
-}
-function setCache(modelId, price) {
-    const entry = { price, timestamp: Date.now() };
-    memoryCache.set(modelId, entry);
-    const cache = loadDiskCache();
-    cache[modelId] = entry;
-    saveCache(cache);
-}
-function priceFromConfig(modelId) {
-    const override = loadConfig().pricing?.[modelId];
-    if (!override)
-        return null;
-    if (typeof override.inputPerMillion !== "number" || typeof override.outputPerMillion !== "number")
-        return null;
-    return { inputPerMillion: override.inputPerMillion, outputPerMillion: override.outputPerMillion };
-}
-async function fetchFromModelsDev(modelId) {
-    try {
-        const response = await fetch("https://models.dev/api.json", { signal: AbortSignal.timeout(10000) });
-        if (!response.ok)
-            return null;
-        const providers = (await response.json());
-        for (const provider of Object.values(providers)) {
-            if (!provider.models)
-                continue;
-            for (const [id, model] of Object.entries(provider.models)) {
-                if (id === modelId || id.endsWith(`/${modelId}`) || modelId.endsWith(`/${id}`)) {
-                    const p = model?.pricing;
-                    if (p && typeof p.input === "number" && typeof p.output === "number") {
-                        return { inputPerMillion: p.input, outputPerMillion: p.output };
-                    }
-                }
-            }
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-export async function getModelPrice(modelId) {
-    const override = priceFromConfig(modelId);
-    if (override)
-        return override;
-    const cached = getCached(modelId);
-    if (cached)
-        return cached.price;
-    const negAt = negativeCache.get(modelId);
-    if (negAt !== undefined && Date.now() - negAt <= NEGATIVE_TTL)
-        return null;
-    const pending = inFlight.get(modelId);
-    if (pending)
-        return pending;
-    const probing = fetchFromModelsDev(modelId).then((price) => {
-        if (price) {
-            setCache(modelId, price);
-        }
-        else {
-            negativeCache.set(modelId, Date.now());
-        }
-        return price;
-    });
-    inFlight.set(modelId, probing);
-    try {
-        return await probing;
-    }
-    finally {
-        inFlight.delete(modelId);
-    }
-}
-export function estimateCost(usage, price) {
-    if (!price)
-        return null;
-    const cost = (usage.inputTokens / 1_000_000) * price.inputPerMillion + (usage.outputTokens / 1_000_000) * price.outputPerMillion;
-    return cost > 0 ? cost : null;
-}
-export function formatCost(cost) {
-    if (cost === null)
-        return "--";
-    return cost >= 0.1 ? `$${cost.toFixed(3)}` : `$${cost.toFixed(4)}`;
-}

package/dist/provider.js

@@ -1,63 +0,0 @@
-import { createOpenAI } from "@ai-sdk/openai";
-import { getEffectiveConfig, getActiveProvider, normalizeOllamaBaseURL } from "./config.js";
-import { createTimeoutFetch, DEFAULT_FIRST_BYTE_TIMEOUT_MS, DEFAULT_STREAM_IDLE_TIMEOUT_MS, } from "./fetch-timeout.js";
-import { foldReasoningInChatResponse } from "./reasoning-stream.js";
-import { fetchWithThinkingWire } from "./thinking-wire.js";
-function positiveMs(raw, fallback) {
-    const value = typeof raw === "string" ? Number(raw) : raw;
-    if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
-        return fallback;
-    return value;
-}
-/** Timeout/trace-aware fetch shared by every provider client. */
-export function modelFetch() {
-    const cfg = getEffectiveConfig();
-    const inner = createTimeoutFetch({
-        firstByteTimeoutMs: positiveMs(process.env.MIN_AGENT_REQUEST_TIMEOUT_MS ?? cfg.agent?.requestTimeoutMs, DEFAULT_FIRST_BYTE_TIMEOUT_MS),
-        idleTimeoutMs: positiveMs(process.env.MIN_AGENT_STREAM_IDLE_TIMEOUT_MS ?? cfg.agent?.streamIdleTimeoutMs, DEFAULT_STREAM_IDLE_TIMEOUT_MS),
-        trace: process.env.MIN_AGENT_TRACE === "1" || process.env.MIN_AGENT_TRACE === "true",
-    });
-    return (input, init) => fetchWithThinkingWire(inner, input, init).then(foldReasoningInChatResponse);
-}
-export function resolveModelForProvider(provider, modelId) {
-    if (!provider.baseURL || !provider.apiKey) {
-        throw new Error("Not configured. Run: min-agent setup");
-    }
-    const id = modelId ?? provider.defaultModel;
-    if (!id) {
-        throw new Error("No model specified. Run: min-agent setup");
-    }
-    const fetchImpl = modelFetch();
-    switch (provider.type ?? "openai-compatible") {
-        case "openai": {
-            const client = createOpenAI({ apiKey: provider.apiKey, fetch: fetchImpl });
-            return client.chat(id);
-        }
-        case "ollama": {
-            const client = createOpenAI({
-                baseURL: normalizeOllamaBaseURL(provider.baseURL),
-                apiKey: provider.apiKey || "ollama",
-                fetch: fetchImpl,
-            });
-            return client.chat(id);
-        }
-        case "openai-compatible": {
-            const client = createOpenAI({
-                baseURL: provider.baseURL,
-                apiKey: provider.apiKey,
-                fetch: fetchImpl,
-            });
-            return client.chat(id);
-        }
-        default:
-            throw new Error(`Unknown provider type: ${provider.type}`);
-    }
-}
-export function resolveModel(modelId, providerName) {
-    const config = getEffectiveConfig();
-    const provider = providerName ? config.providers?.find((p) => p.name === providerName) : getActiveProvider(config);
-    if (!provider) {
-        throw new Error(providerName ? `Provider "${providerName}" not found` : "Not configured. Run: min-agent setup");
-    }
-    return resolveModelForProvider(provider, modelId);
-}

package/dist/question-format.js

@@ -1,60 +0,0 @@
-const OPTION_TEXT_KEYS = ["label", "description", "title", "text", "value", "content", "prompt"];
-function firstText(rec, keys) {
-    const parts = [];
-    const seen = new Set();
-    for (const key of keys) {
-        const v = rec[key];
-        if (typeof v !== "string")
-            continue;
-        const text = v.trim();
-        if (!text || seen.has(text))
-            continue;
-        seen.add(text);
-        parts.push(text);
-    }
-    return parts;
-}
-/** Pull a user-visible label out of a model-supplied question option. */
-export function optionText(item) {
-    if (item == null)
-        return null;
-    if (typeof item === "string") {
-        const text = item.trim();
-        return text.length > 0 ? text : null;
-    }
-    if (typeof item === "number" || typeof item === "boolean")
-        return String(item);
-    if (typeof item !== "object" || Array.isArray(item))
-        return null;
-    const rec = item;
-    const parts = firstText(rec, OPTION_TEXT_KEYS);
-    if (parts.length > 0)
-        return parts.join(" — ");
-    const key = rec.key;
-    return typeof key === "string" && key.trim() ? key.trim() : null;
-}
-export function normalizeQuestionPrompt(question) {
-    if (typeof question === "string")
-        return question;
-    return optionText(question) ?? "";
-}
-/**
- * Models often send `{label, description, key}` (Claude-style) instead of
- * `string[]`. Normalize to display strings so the TUI never calls string
- * methods on objects.
- */
-export function normalizeQuestionOptions(options) {
-    if (options == null)
-        return [];
-    const list = Array.isArray(options) ? options : [options];
-    const out = [];
-    const seen = new Set();
-    for (const item of list) {
-        const text = optionText(item);
-        if (!text || seen.has(text))
-            continue;
-        seen.add(text);
-        out.push(text);
-    }
-    return out;
-}

package/dist/reasoning-stream.js

@@ -1,158 +0,0 @@
-/**
- * OpenAI-compatible chat completions put the thinking chain in
- * `reasoning_content` / `reasoning` / `reasoning_details`. The @ai-sdk/openai
- * chat parser only reads `delta.content`, so those fields never become
- * reasoning events. Fold them into `<think>` tags that ThinkingBodySplitter
- * already turns into on-screen thinking.
- */
-function isRecord(v) {
-    return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function sanitizeReasoning(text) {
-    return text.replace(/<\/?(?:think|thinking)>/gi, "");
-}
-function stringField(v, key) {
-    if (!isRecord(v))
-        return "";
-    return typeof v[key] === "string" ? v[key] : "";
-}
-function reasoningFromDetails(details) {
-    if (!Array.isArray(details))
-        return "";
-    return details
-        .map((item) => {
-        const text = stringField(item, "text");
-        if (text)
-            return text;
-        return stringField(item, "content");
-    })
-        .join("");
-}
-function reasoningFromValue(v) {
-    if (typeof v === "string")
-        return v;
-    if (!isRecord(v))
-        return "";
-    return stringField(v, "content") || stringField(v, "text");
-}
-export function reasoningTextFromDelta(delta) {
-    const details = reasoningFromDetails(delta.reasoning_details);
-    const primary = reasoningFromValue(delta.reasoning_content) ||
-        reasoningFromValue(delta.reasoning) ||
-        reasoningFromValue(delta.thinking);
-    return sanitizeReasoning(`${details}${primary}`);
-}
-export function createReasoningDeltaTracker() {
-    let acc = "";
-    return (text) => {
-        if (!text)
-            return "";
-        if (acc && text.startsWith(acc)) {
-            const extra = text.slice(acc.length);
-            acc = text;
-            return extra;
-        }
-        acc += text;
-        return text;
-    };
-}
-export function foldReasoningIntoDelta(delta, takeDelta) {
-    const reasoning = takeDelta(reasoningTextFromDelta(delta));
-    if (!reasoning)
-        return false;
-    const content = typeof delta.content === "string" ? delta.content : "";
-    delta.content = `<think>${reasoning}</think>${content}`;
-    return true;
-}
-export function foldReasoningInChunk(chunk, takeDelta = (t) => t) {
-    if (!isRecord(chunk) || !Array.isArray(chunk.choices))
-        return false;
-    let changed = false;
-    for (const choice of chunk.choices) {
-        if (!isRecord(choice))
-            continue;
-        if (isRecord(choice.delta) && foldReasoningIntoDelta(choice.delta, takeDelta))
-            changed = true;
-        if (isRecord(choice.message) && foldReasoningIntoDelta(choice.message, takeDelta))
-            changed = true;
-    }
-    return changed;
-}
-export function foldReasoningIntoSseLine(line, takeDelta) {
-    const trimmed = line.replace(/\r$/, "");
-    if (!trimmed.startsWith("data:"))
-        return line;
-    const payload = trimmed.slice("data:".length).trim();
-    if (!payload || payload === "[DONE]")
-        return line;
-    try {
-        const parsed = JSON.parse(payload);
-        if (!foldReasoningInChunk(parsed, takeDelta))
-            return line;
-        const prefix = line.startsWith("data: ") ? "data: " : "data:";
-        const nl = line.endsWith("\r") ? "\r" : "";
-        return `${prefix}${JSON.stringify(parsed)}${nl}`;
-    }
-    catch {
-        return line;
-    }
-}
-function rewriteSseFragment(fragment, takeDelta) {
-    const keepLastNl = fragment.endsWith("\n");
-    const raw = keepLastNl ? fragment.slice(0, -1) : fragment;
-    return (raw
-        .split("\n")
-        .map((line) => foldReasoningIntoSseLine(line, takeDelta))
-        .join("\n") + (keepLastNl ? "\n" : ""));
-}
-export function transformReasoningSse(source) {
-    const decoder = new TextDecoder();
-    const encoder = new TextEncoder();
-    const reader = source.getReader();
-    const takeDelta = createReasoningDeltaTracker();
-    let pending = "";
-    return new ReadableStream({
-        async pull(controller) {
-            for (;;) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    pending += decoder.decode();
-                    if (pending)
-                        controller.enqueue(encoder.encode(rewriteSseFragment(pending, takeDelta)));
-                    controller.close();
-                    return;
-                }
-                pending += decoder.decode(value, { stream: true });
-                const nl = pending.lastIndexOf("\n");
-                if (nl < 0)
-                    continue;
-                const complete = pending.slice(0, nl + 1);
-                pending = pending.slice(nl + 1);
-                controller.enqueue(encoder.encode(rewriteSseFragment(complete, takeDelta)));
-                return;
-            }
-        },
-        cancel(reason) {
-            return reader.cancel(reason);
-        },
-    });
-}
-function isChatSseResponse(response) {
-    const ctype = (response.headers.get("content-type") ?? "").toLowerCase();
-    if (ctype.includes("event-stream"))
-        return true;
-    if (!ctype || ctype.startsWith("text/plain"))
-        return true;
-    return false;
-}
-export function foldReasoningInChatResponse(response) {
-    if (!response.body || response.status >= 400)
-        return response;
-    if (!isChatSseResponse(response))
-        return response;
-    return new Response(transformReasoningSse(response.body), {
-        status: response.status,
-        statusText: response.statusText,
-        headers: response.headers,
-    });
-}