min-agent 0.1.0 → 0.1.2

package/dist/config.js

@@ -0,0 +1,142 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } 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");
+export function getConfigDir() {
+    return CONFIG_DIR;
+}
+export function getRulesFile() {
+    return RULES_FILE;
+}
+export function loadConfig() {
+    if (!existsSync(CONFIG_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(config) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+}
+export function isConfigured() {
+    const config = loadConfig();
+    return !!(config.provider?.baseURL && config.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 [];
+    const data = (await response.json());
+    const models = (data.data ?? data ?? []);
+    return models.map((m) => m.id).sort();
+}
+function ask(rl, question, defaultValue) {
+    const suffix = defaultValue ? ` (${defaultValue})` : "";
+    return new Promise((resolve) => {
+        rl.question(`${question}${suffix}: `, (answer) => {
+            resolve(answer.trim() || defaultValue || "");
+        });
+    });
+}
+export async function fetchModels(baseURL, apiKey) {
+    try {
+        const trimmed = baseURL.replace(/\/$/, "");
+        const primary = await fetchModelsFromURL(`${trimmed}/models`, apiKey);
+        if (primary.length > 0)
+            return primary;
+        // Ollama users often provide host without /v1; auto-retry that variant.
+        if (!trimmed.endsWith("/v1")) {
+            return await fetchModelsFromURL(`${trimmed}/v1/models`, apiKey);
+        }
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
+export async function runSetup() {
+    const config = loadConfig();
+    const existing = config.provider;
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    console.log("\n🔧 min-agent 配置\n");
+    console.log("Provider 类型:");
+    console.log("  1. openai-compatible (默认，兼容 OpenAI API 的任意服务)");
+    console.log("  2. openai (OpenAI 官方)");
+    console.log("  3. ollama (本地 Ollama)");
+    console.log();
+    const typeChoice = await ask(rl, "选择 Provider (1/2/3)", existing?.type === "ollama" ? "3" : existing?.type === "openai" ? "2" : "1");
+    const providerType = typeChoice === "3" ? "ollama"
+        : typeChoice === "2" ? "openai"
+            : "openai-compatible";
+    let baseURL;
+    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
+    }
+    else if (providerType === "openai") {
+        baseURL = "https://api.openai.com/v1";
+        apiKey = await ask(rl, "OpenAI API Key", existing?.apiKey);
+    }
+    else {
+        baseURL = await ask(rl, "API Base URL", existing?.baseURL || "https://api.openai.com/v1");
+        apiKey = await ask(rl, "API Key", existing?.apiKey);
+    }
+    if (!baseURL || (!apiKey && providerType !== "ollama")) {
+        console.error("URL 和 Key 不能为空");
+        rl.close();
+        process.exit(1);
+    }
+    console.log("\n正在获取模型列表...");
+    const models = await fetchModels(baseURL, apiKey);
+    let defaultModel = existing?.defaultModel ?? "";
+    if (models.length > 0) {
+        console.log(`\n可用模型 (${models.length}):`);
+        models.forEach((m, i) => {
+            const marker = m === defaultModel ? " ← 当前默认" : "";
+            console.log(`  ${i + 1}. ${m}${marker}`);
+        });
+        console.log();
+        const choice = await ask(rl, "选择默认模型 (输入序号或模型名)", defaultModel);
+        const idx = parseInt(choice) - 1;
+        if (idx >= 0 && idx < models.length) {
+            defaultModel = models[idx];
+        }
+        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`);
+}

package/dist/confirm.js

@@ -0,0 +1,37 @@
+import readline from "readline";
+let autoApprove = false;
+export function setAutoApprove(value) {
+    autoApprove = value;
+}
+export function isAutoApprove() {
+    return autoApprove;
+}
+/** Ask user for confirmation. Returns true if approved. */
+export async function confirm(message) {
+    if (autoApprove)
+        return true;
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(`\x1b[33m⚠ ${message} [y/N] \x1b[0m`, (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes");
+        });
+    });
+}
+/** Check if a shell command is potentially dangerous */
+export function isDangerousCommand(command) {
+    const dangerous = [
+        /\brm\s+(-rf?|--recursive)\s/,
+        /\brm\s+-[a-z]*f/,
+        /\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,
+        /\bformat\b.*\b[a-z]:\b/i,
+    ];
+    return dangerous.some((re) => re.test(command));
+}

package/dist/instructions.js

@@ -0,0 +1,115 @@
+import { readFileSync, existsSync } from "fs";
+import path from "path";
+import os from "os";
+import { getRulesFile, loadConfig } from "./config.js";
+/**
+ * Instruction/rules system.
+ *
+ * All config lives under ~/.min-agent/:
+ *   ~/.min-agent/rules.md          — Global rules (always loaded)
+ *   ~/.min-agent/config.json       — Can specify extra "instructions" paths/URLs
+ *
+ * Project-level rules (auto-discovered from cwd):
+ *   ./AGENTS.md, ./RULES.md, ./.min-agent/AGENTS.md
+ */
+const PROJECT_FILES = ["AGENTS.md", "RULES.md", "CLAUDE.md"];
+function findProjectInstructions() {
+    const results = [];
+    let current = process.cwd();
+    const root = path.parse(current).root;
+    while (current !== root) {
+        // Check .min-agent/AGENTS.md in project
+        const dotDir = path.join(current, ".min-agent", "AGENTS.md");
+        if (existsSync(dotDir)) {
+            results.push(dotDir);
+            break;
+        }
+        for (const file of PROJECT_FILES) {
+            const filepath = path.join(current, file);
+            if (existsSync(filepath)) {
+                results.push(filepath);
+                break;
+            }
+        }
+        if (results.length > 0)
+            break;
+        current = path.dirname(current);
+    }
+    return results;
+}
+function findGlobalRules() {
+    const results = [];
+    const rulesFile = getRulesFile();
+    if (existsSync(rulesFile))
+        results.push(rulesFile);
+    return results;
+}
+function resolveConfigInstructions() {
+    const config = loadConfig();
+    const instructions = config.instructions ?? [];
+    const results = [];
+    for (const item of instructions) {
+        if (item.startsWith("http://") || item.startsWith("https://"))
+            continue;
+        const resolved = item.startsWith("~/")
+            ? path.join(os.homedir(), item.slice(2))
+            : path.isAbsolute(item)
+                ? item
+                : path.resolve(process.cwd(), item);
+        if (existsSync(resolved))
+            results.push(resolved);
+    }
+    return results;
+}
+async function fetchRemoteInstructions() {
+    const config = loadConfig();
+    const instructions = config.instructions ?? [];
+    const results = [];
+    const urls = instructions.filter((i) => i.startsWith("http://") || i.startsWith("https://"));
+    for (const url of urls) {
+        try {
+            const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
+            if (response.ok) {
+                const text = await response.text();
+                if (text.trim())
+                    results.push(`Instructions from: ${url}\n${text}`);
+            }
+        }
+        catch { }
+    }
+    return results;
+}
+export async function loadInstructions() {
+    const parts = [];
+    // Global rules from ~/.min-agent/rules.md
+    for (const filepath of findGlobalRules()) {
+        try {
+            const content = readFileSync(filepath, "utf-8").trim();
+            if (content)
+                parts.push(`Instructions from: ${filepath}\n${content}`);
+        }
+        catch { }
+    }
+    // Project-level instructions
+    for (const filepath of findProjectInstructions()) {
+        try {
+            const content = readFileSync(filepath, "utf-8").trim();
+            if (content)
+                parts.push(`Instructions from: ${filepath}\n${content}`);
+        }
+        catch { }
+    }
+    // Config-defined file instructions
+    for (const filepath of resolveConfigInstructions()) {
+        try {
+            const content = readFileSync(filepath, "utf-8").trim();
+            if (content)
+                parts.push(`Instructions from: ${filepath}\n${content}`);
+        }
+        catch { }
+    }
+    // Remote URL instructions
+    const remote = await fetchRemoteInstructions();
+    parts.push(...remote);
+    return parts;
+}

package/dist/markdown.js

@@ -0,0 +1,130 @@
+/**
+ * Lightweight streaming markdown renderer for terminal.
+ * Tracks state across text deltas to apply ANSI formatting.
+ */
+function useColor() {
+    if ("NO_COLOR" in process.env)
+        return false;
+    if (process.env.FORCE_COLOR === "0")
+        return false;
+    return true;
+}
+const C = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    italic: "\x1b[3m",
+    cyan: "\x1b[36m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    magenta: "\x1b[35m",
+    gray: "\x1b[90m",
+    underline: "\x1b[4m",
+};
+const Z = {
+    reset: "",
+    bold: "",
+    dim: "",
+    italic: "",
+    cyan: "",
+    green: "",
+    yellow: "",
+    magenta: "",
+    gray: "",
+    underline: "",
+};
+export class MarkdownRenderer {
+    buffer = "";
+    inCodeBlock = false;
+    codeLang = "";
+    /** Process a text delta and return formatted output */
+    write(text) {
+        this.buffer += text;
+        let output = "";
+        const c = useColor() ? C : Z;
+        // Process complete lines
+        while (true) {
+            const nlIdx = this.buffer.indexOf("\n");
+            if (nlIdx === -1)
+                break;
+            const line = this.buffer.slice(0, nlIdx);
+            this.buffer = this.buffer.slice(nlIdx + 1);
+            output += this.formatLine(line, c) + "\n";
+        }
+        return output;
+    }
+    /** Flush remaining buffer */
+    flush() {
+        if (!this.buffer)
+            return "";
+        const c = useColor() ? C : Z;
+        const out = this.formatLine(this.buffer, c);
+        this.buffer = "";
+        return out;
+    }
+    formatInline(line, c) {
+        // Split by inline code spans; format outside segments only
+        const parts = line.split(/(`[^`]*`)/g);
+        return parts
+            .map((seg) => {
+            if (seg.startsWith("`") && seg.endsWith("`") && seg.length >= 2) {
+                const inner = seg.slice(1, -1);
+                return `${c.cyan}${inner}${c.reset}`;
+            }
+            let s = seg;
+            s = s.replace(/\*\*([^*]+)\*\*/g, `${c.bold}$1${c.reset}`);
+            s = s.replace(/\*([^*]+)\*/g, `${c.italic}$1${c.reset}`);
+            s = s.replace(/\[([^\]]+)\]\(([^)]+)\)/g, `${c.cyan}$1${c.reset} ${c.dim}($2)${c.reset}`);
+            return s;
+        })
+            .join("");
+    }
+    formatLine(line, c) {
+        // Code block fence
+        if (line.startsWith("```")) {
+            if (!this.inCodeBlock) {
+                this.inCodeBlock = true;
+                this.codeLang = line.slice(3).trim();
+                return `${c.dim}┌─ ${this.codeLang || "code"} ${"─".repeat(Math.max(0, 40 - (this.codeLang?.length ?? 0)))}${c.reset}`;
+            }
+            this.inCodeBlock = false;
+            this.codeLang = "";
+            return `${c.dim}└${"─".repeat(44)}${c.reset}`;
+        }
+        // Inside code block — dim
+        if (this.inCodeBlock) {
+            return `${c.dim}│${c.reset} ${line}`;
+        }
+        // Headers
+        if (line.startsWith("### "))
+            return `${c.bold}${this.formatInline(line.slice(4), c)}${c.reset}`;
+        if (line.startsWith("## "))
+            return `${c.bold}${this.formatInline(line.slice(3), c)}${c.reset}`;
+        if (line.startsWith("# "))
+            return `${c.bold}${c.cyan}${this.formatInline(line.slice(2), c)}${c.reset}`;
+        // Horizontal rule
+        if (/^---+$/.test(line))
+            return `${c.dim}${"─".repeat(44)}${c.reset}`;
+        // Blockquote
+        const bq = line.match(/^(\s*)>\s?(.*)$/);
+        if (bq) {
+            const indent = bq[1];
+            const body = bq[2];
+            return `${indent}${c.dim}▎${c.reset} ${this.formatInline(body, c)}`;
+        }
+        // Numbered list (1. item)
+        if (/^\s*\d+\.\s/.test(line)) {
+            const m = line.match(/^(\s*)(\d+\.)(\s)(.*)$/);
+            if (m) {
+                return `${m[1]}${c.yellow}${m[2]}${c.reset}${m[3]}${this.formatInline(m[4], c)}`;
+            }
+        }
+        // Bullet points
+        if (line.match(/^\s*[-*]\s/)) {
+            return line.replace(/^(\s*)([-*])(\s)(.*)$/, (_a, sp, _mark, sp2, rest) => {
+                return `${sp}${c.cyan}•${c.reset}${sp2}${this.formatInline(rest, c)}`;
+            });
+        }
+        return this.formatInline(line, c);
+    }
+}

package/dist/mcp.js

@@ -0,0 +1,237 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { tool, jsonSchema } from "ai";
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs";
+import path from "path";
+import { truncateToolOutput } from "./tool-output.js";
+const DEFAULT_TIMEOUT = 30000;
+function getMcpConfigPath() {
+    return path.join(process.cwd(), ".min-agent", "mcp.json");
+}
+let connectedServers = {};
+export function loadMcpConfig() {
+    const configPath = getMcpConfigPath();
+    if (!existsSync(configPath))
+        return { mcpServers: {} };
+    try {
+        return JSON.parse(readFileSync(configPath, "utf-8"));
+    }
+    catch {
+        return { mcpServers: {} };
+    }
+}
+export function saveMcpConfig(config) {
+    const configPath = getMcpConfigPath();
+    const dir = path.dirname(configPath);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+export function isRemoteMcpConfig(config) {
+    return typeof config.url === "string" && config.url.trim().length > 0;
+}
+function buildRemoteRequestInit(config) {
+    const headers = new Headers(config.headers ?? {});
+    const token = config.token?.trim();
+    if (token && !headers.has("Authorization")) {
+        headers.set("Authorization", `Bearer ${token}`);
+    }
+    if ([...headers.keys()].length === 0)
+        return undefined;
+    return { headers };
+}
+async function openStdioMcpServer(name, config) {
+    const [cmd, ...args] = config.command ?? [];
+    if (!cmd) {
+        throw new Error(`MCP "${name}" has empty command`);
+    }
+    const transport = new StdioClientTransport({
+        command: cmd,
+        args,
+        env: { ...process.env, ...(config.environment ?? {}) },
+        stderr: "pipe",
+    });
+    const client = new Client({ name: "agent-demo", version: "0.0.1" });
+    await client.connect(transport);
+    const { tools } = await client.listTools();
+    return { client, transport, tools };
+}
+async function openRemoteMcpServer(name, config) {
+    const rawUrl = config.url?.trim();
+    if (!rawUrl) {
+        throw new Error(`MCP "${name}" has empty url`);
+    }
+    let baseUrl;
+    try {
+        baseUrl = new URL(rawUrl);
+    }
+    catch {
+        throw new Error(`MCP "${name}" has invalid url: ${rawUrl}`);
+    }
+    if (baseUrl.protocol !== "http:" && baseUrl.protocol !== "https:") {
+        throw new Error(`MCP "${name}" url must be http or https`);
+    }
+    const requestInit = buildRemoteRequestInit(config);
+    const mode = config.remoteTransport ?? "auto";
+    const connectStreamable = async () => {
+        const client = new Client({ name: "agent-demo", version: "0.0.1" });
+        const transport = new StreamableHTTPClientTransport(baseUrl, requestInit ? { requestInit } : undefined);
+        await client.connect(transport);
+        const { tools } = await client.listTools();
+        return { client, transport, tools };
+    };
+    const connectSse = async () => {
+        const client = new Client({ name: "agent-demo", version: "0.0.1" });
+        const transport = new SSEClientTransport(baseUrl, requestInit ? { requestInit } : undefined);
+        await client.connect(transport);
+        const { tools } = await client.listTools();
+        return { client, transport, tools };
+    };
+    if (mode === "streamable-http") {
+        return await connectStreamable();
+    }
+    if (mode === "sse") {
+        return await connectSse();
+    }
+    // auto: prefer streamable-http, fall back to sse (older servers)
+    try {
+        return await connectStreamable();
+    }
+    catch (firstErr) {
+        try {
+            return await connectSse();
+        }
+        catch {
+            throw new Error(`MCP "${name}" remote connection failed (streamable-http + sse): ${firstErr?.message ?? String(firstErr)}`);
+        }
+    }
+}
+async function openMcpServer(name, config) {
+    if (isRemoteMcpConfig(config)) {
+        return await openRemoteMcpServer(name, config);
+    }
+    return await openStdioMcpServer(name, config);
+}
+/** One-line summary for CLI / logs (no secrets). */
+export function formatMcpServerBinding(config) {
+    if (isRemoteMcpConfig(config)) {
+        const mode = config.remoteTransport ?? "auto";
+        return `${config.url} [remote:${mode}]`;
+    }
+    return (config.command ?? []).join(" ");
+}
+export async function connectMcpServer(name, config) {
+    if (config.enabled === false)
+        return null;
+    try {
+        const server = await openMcpServer(name, config);
+        console.log(`\x1b[90m  MCP "${name}" connected (${server.tools.length} tools)\x1b[0m`);
+        return server;
+    }
+    catch (err) {
+        console.error(`\x1b[31m  MCP "${name}" failed: ${err.message}\x1b[0m`);
+        return null;
+    }
+}
+export async function checkMcpServer(name, config) {
+    if (config.enabled === false) {
+        return { name, enabled: false, ok: true, toolCount: 0 };
+    }
+    try {
+        const server = await openMcpServer(name, config);
+        const toolCount = server.tools.length;
+        try {
+            await server.client.close();
+        }
+        catch { }
+        return { name, enabled: true, ok: true, toolCount };
+    }
+    catch (err) {
+        return {
+            name,
+            enabled: true,
+            ok: false,
+            toolCount: 0,
+            error: err?.message ?? String(err),
+        };
+    }
+}
+export async function checkAllMcpServers() {
+    const config = loadMcpConfig();
+    const results = [];
+    for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+        results.push(await checkMcpServer(name, serverConfig));
+    }
+    return results;
+}
+export async function initMcp() {
+    const config = loadMcpConfig();
+    for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+        const server = await connectMcpServer(name, serverConfig);
+        if (server)
+            connectedServers[name] = server;
+    }
+}
+export async function shutdownMcp() {
+    for (const [name, server] of Object.entries(connectedServers)) {
+        try {
+            await server.client.close();
+        }
+        catch { }
+    }
+    connectedServers = {};
+}
+export function getMcpTools() {
+    const tools = {};
+    for (const [serverName, server] of Object.entries(connectedServers)) {
+        for (const mcpTool of server.tools) {
+            const toolId = `${sanitize(serverName)}_${sanitize(mcpTool.name)}`;
+            const schema = {
+                ...mcpTool.inputSchema,
+                type: "object",
+                properties: (mcpTool.inputSchema?.properties ?? {}),
+            };
+            tools[toolId] = tool({
+                description: mcpTool.description ?? `MCP tool: ${mcpTool.name}`,
+                inputSchema: jsonSchema(schema),
+                execute: async (args) => {
+                    try {
+                        const result = await server.client.callTool({
+                            name: mcpTool.name,
+                            arguments: args,
+                        });
+                        if (result.isError) {
+                            return truncateToolOutput(`Error: ${JSON.stringify(result.content)}`, { direction: "head" }).content;
+                        }
+                        const content = result.content;
+                        const text = content
+                            .filter((c) => c.type === "text")
+                            .map((c) => c.text ?? "")
+                            .join("\n") || JSON.stringify(result.content);
+                        return truncateToolOutput(text, { direction: "head" }).content;
+                    }
+                    catch (err) {
+                        return truncateToolOutput(`MCP tool error: ${err.message}`, { direction: "head" }).content;
+                    }
+                },
+            });
+        }
+    }
+    return tools;
+}
+export function getMcpStatus() {
+    const status = {};
+    const config = loadMcpConfig();
+    for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+        const server = connectedServers[name];
+        status[name] = {
+            connected: !!server,
+            tools: server?.tools.map((t) => t.name) ?? [],
+        };
+    }
+    return status;
+}
+function sanitize(s) {
+    return s.replace(/[^a-zA-Z0-9_-]/g, "_");
+}