min-agent 0.1.0 → 0.1.1

package/dist/compaction.js

@@ -0,0 +1,99 @@
+import { generateText } from "ai";
+/**
+ * Context compaction system.
+ *
+ * When conversation history exceeds a token threshold, older messages are
+ * summarized into a compact form to free up context window space.
+ *
+ * Strategy:
+ * 1. Estimate token count of messages (rough: 1 token ≈ 4 chars for English, 2 chars for CJK)
+ * 2. When over threshold, take older messages and summarize them via the LLM
+ * 3. Replace old messages with a single system summary message
+ * 4. Keep recent N turns verbatim for continuity
+ */
+const COMPACTION_PROMPT = `You are a conversation summarizer. Summarize the following conversation history into a concise but complete summary that preserves:
+- Key decisions made
+- Important context and facts discussed
+- Current state of any tasks in progress
+- User preferences mentioned
+- File paths, code snippets, or technical details that are still relevant
+
+Be concise but don't lose critical information. Output only the summary, no preamble.`;
+// Default: trigger compaction at ~80% of context window
+const DEFAULT_MAX_TOKENS = 128000;
+const COMPACTION_RATIO = 0.75;
+const KEEP_RECENT_TURNS = 4; // Keep last N user+assistant pairs verbatim
+/** Rough token estimation */
+export function estimateTokens(messages) {
+    let chars = 0;
+    for (const msg of messages) {
+        if (typeof msg.content === "string") {
+            chars += msg.content.length;
+        }
+        else if (Array.isArray(msg.content)) {
+            for (const part of msg.content) {
+                if ("text" in part && typeof part.text === "string") {
+                    chars += part.text.length;
+                }
+            }
+        }
+    }
+    // Rough estimate: mix of English (~4 chars/token) and CJK (~2 chars/token)
+    return Math.ceil(chars / 3);
+}
+/** Check if compaction is needed */
+export function needsCompaction(messages, config) {
+    const maxTokens = config?.maxTokens ?? DEFAULT_MAX_TOKENS;
+    const threshold = maxTokens * COMPACTION_RATIO;
+    return estimateTokens(messages) > threshold;
+}
+/** Compact messages by summarizing older history */
+export async function compactMessages(messages, model, config) {
+    const keepTurns = config?.keepRecentTurns ?? KEEP_RECENT_TURNS;
+    if (messages.length <= keepTurns * 2) {
+        // Not enough messages to compact
+        return { messages, compacted: false };
+    }
+    // Split: older messages to summarize, recent messages to keep
+    const splitIdx = messages.length - keepTurns * 2;
+    const toSummarize = messages.slice(0, splitIdx);
+    const toKeep = messages.slice(splitIdx);
+    // Build conversation text for summarization
+    const conversationText = toSummarize
+        .map((msg) => {
+        const role = msg.role;
+        const content = typeof msg.content === "string"
+            ? msg.content
+            : Array.isArray(msg.content)
+                ? msg.content
+                    .filter((p) => "text" in p)
+                    .map((p) => p.text)
+                    .join("\n")
+                : "";
+        return `[${role}]: ${content.slice(0, 2000)}`;
+    })
+        .join("\n\n");
+    try {
+        const result = await generateText({
+            model,
+            messages: [
+                { role: "system", content: COMPACTION_PROMPT },
+                { role: "user", content: `Summarize this conversation:\n\n${conversationText}` },
+            ],
+        });
+        const summary = result.text;
+        // Build compacted message list
+        const compactedMessages = [
+            {
+                role: "system",
+                content: `[Context Summary - Previous conversation was compacted]\n\n${summary}`,
+            },
+            ...toKeep,
+        ];
+        return { messages: compactedMessages, compacted: true };
+    }
+    catch {
+        // If summarization fails, just truncate older messages
+        return { messages: toKeep, compacted: true };
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,17 @@
+export interface ProviderConfig {
+    type?: "openai-compatible" | "openai" | "ollama";
+    baseURL: string;
+    apiKey: string;
+    defaultModel?: string;
+}
+export interface AppConfig {
+    provider?: ProviderConfig;
+    instructions?: string[];
+}
+export declare function getConfigDir(): string;
+export declare function getRulesFile(): string;
+export declare function loadConfig(): AppConfig;
+export declare function saveConfig(config: AppConfig): void;
+export declare function isConfigured(): boolean;
+export declare function fetchModels(baseURL: string, apiKey: string): Promise<string[]>;
+export declare function runSetup(): Promise<void>;

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.d.ts

@@ -0,0 +1,6 @@
+export declare function setAutoApprove(value: boolean): void;
+export declare function isAutoApprove(): boolean;
+/** Ask user for confirmation. Returns true if approved. */
+export declare function confirm(message: string): Promise<boolean>;
+/** Check if a shell command is potentially dangerous */
+export declare function isDangerousCommand(command: string): boolean;

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.d.ts

@@ -0,0 +1 @@
+export declare function loadInstructions(): Promise<string[]>;

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.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Lightweight streaming markdown renderer for terminal.
+ * Tracks state across text deltas to apply ANSI formatting.
+ */
+export declare class MarkdownRenderer {
+    private buffer;
+    private inCodeBlock;
+    private codeLang;
+    /** Process a text delta and return formatted output */
+    write(text: string): string;
+    /** Flush remaining buffer */
+    flush(): string;
+    private formatInline;
+    private formatLine;
+}

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.d.ts

@@ -0,0 +1,61 @@
+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 { type Tool } from "ai";
+export interface McpServerConfig {
+    /** Local stdio server: command + args. Ignored when `url` is set. */
+    command?: string[];
+    /** Remote MCP endpoint (http/https). When set, connects via HTTP transport instead of stdio. */
+    url?: string;
+    /**
+     * Remote transport mode.
+     * - `streamable-http`: MCP Streamable HTTP (default for new remote servers)
+     * - `sse`: legacy HTTP + SSE transport
+     * - `auto`: try streamable-http first, then fall back to sse
+     */
+    remoteTransport?: "streamable-http" | "sse" | "auto";
+    /** Shorthand: sets `Authorization: Bearer <token>` if not already present in `headers`. */
+    token?: string;
+    /** Extra HTTP headers for remote transports. */
+    headers?: Record<string, string>;
+    environment?: Record<string, string>;
+    enabled?: boolean;
+    timeout?: number;
+}
+export interface McpConfig {
+    mcpServers: Record<string, McpServerConfig>;
+}
+type McpClientTransport = StdioClientTransport | StreamableHTTPClientTransport | SSEClientTransport;
+interface ConnectedServer {
+    client: Client;
+    transport: McpClientTransport;
+    tools: Array<{
+        name: string;
+        description?: string;
+        inputSchema: any;
+    }>;
+}
+export interface McpCheckResult {
+    name: string;
+    enabled: boolean;
+    ok: boolean;
+    toolCount: number;
+    error?: string;
+}
+export declare function loadMcpConfig(): McpConfig;
+export declare function saveMcpConfig(config: McpConfig): void;
+export declare function isRemoteMcpConfig(config: McpServerConfig): boolean;
+/** One-line summary for CLI / logs (no secrets). */
+export declare function formatMcpServerBinding(config: McpServerConfig): string;
+export declare function connectMcpServer(name: string, config: McpServerConfig): Promise<ConnectedServer | null>;
+export declare function checkMcpServer(name: string, config: McpServerConfig): Promise<McpCheckResult>;
+export declare function checkAllMcpServers(): Promise<McpCheckResult[]>;
+export declare function initMcp(): Promise<void>;
+export declare function shutdownMcp(): Promise<void>;
+export declare function getMcpTools(): Record<string, Tool>;
+export declare function getMcpStatus(): Record<string, {
+    connected: boolean;
+    tools: string[];
+}>;
+export {};