min-agent 0.1.3 → 0.1.5

package/dist/context-window.js

@@ -0,0 +1,185 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import path from "path";
+import { getConfigDir, loadConfig } from "./config.js";
+/**
+ * Auto-detect context window size for the current model.
+ *
+ * Resolution order:
+ * 1. User config: provider.contextWindow (explicit override)
+ * 2. Provider-specific API (OpenRouter, vLLM, Ollama)
+ * 3. models.dev API lookup
+ * 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))
+        return {};
+    try {
+        return JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function saveCache(cache) {
+    mkdirSync(path.dirname(CACHE_FILE), { recursive: true });
+    writeFileSync(CACHE_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;
+}
+function setCache(modelId, contextWindow) {
+    const cache = loadCache();
+    cache[modelId] = { contextWindow, timestamp: Date.now() };
+    saveCache(cache);
+}
+/** Try OpenRouter: GET /api/v1/models returns context_length per model */
+async function tryOpenRouter(baseURL, apiKey, modelId) {
+    if (!baseURL.includes("openrouter"))
+        return null;
+    try {
+        const response = await fetch("https://openrouter.ai/api/v1/models", {
+            headers: { Authorization: `Bearer ${apiKey}` },
+            signal: AbortSignal.timeout(8000),
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        const model = data.data?.find((m) => m.id === modelId);
+        return model?.context_length ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Try vLLM: GET /v1/models returns max_model_len */
+async function tryVllm(baseURL, apiKey, modelId) {
+    try {
+        const url = `${baseURL.replace(/\/$/, "")}/models`;
+        const response = await fetch(url, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        const model = (data.data ?? []).find((m) => m.id === modelId);
+        // vLLM exposes max_model_len on the model object
+        return model?.max_model_len ?? model?.max_model_length ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Try Ollama: POST /api/show returns model info with context length */
+async function tryOllama(baseURL, modelId) {
+    if (!baseURL.includes("localhost") && !baseURL.includes("127.0.0.1") && !baseURL.includes("ollama"))
+        return null;
+    try {
+        // Ollama's /api/show endpoint
+        const ollamaBase = baseURL.replace(/\/v1\/?$/, "");
+        const response = await fetch(`${ollamaBase}/api/show`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name: modelId }),
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        // Ollama returns model_info with context length
+        const ctxLength = data.model_info?.["general.context_length"] ??
+            data.model_info?.context_length ??
+            data.parameters?.num_ctx;
+        return typeof ctxLength === "number" ? ctxLength : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Try models.dev API */
+async function tryModelsDev(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());
+        // 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)
+        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}`)) {
+                    if (model?.limit?.context)
+                        return model.limit.context;
+                }
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get context window size for the current model.
+ * Tries multiple sources, caches the result.
+ */
+export async function getContextWindow(modelId) {
+    const config = loadConfig();
+    // 1. Explicit user config
+    if (config.provider?.contextWindow)
+        return config.provider.contextWindow;
+    const id = modelId ?? config.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;
+    }
+    // 4. models.dev lookup
+    const modelsDev = await tryModelsDev(id);
+    if (modelsDev) {
+        setCache(id, modelsDev);
+        return modelsDev;
+    }
+    // 5. Fallback
+    setCache(id, DEFAULT_CONTEXT_WINDOW);
+    return DEFAULT_CONTEXT_WINDOW;
+}

package/dist/doom-loop.js

@@ -0,0 +1,36 @@
+/**
+ * Doom loop detection.
+ *
+ * Detects when the agent calls the same tool with the same arguments
+ * repeatedly (indicating it's stuck in a loop). After THRESHOLD consecutive
+ * identical calls, the loop is broken and the agent is informed.
+ *
+ * Based on opencode's processor.ts doom loop detection.
+ */
+const THRESHOLD = 3;
+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);
+        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() {
+        this.recentCalls = [];
+    }
+}

package/dist/instructions.js

@@ -11,8 +11,50 @@ import { getRulesFile, loadConfig } from "./config.js";
  *
  * Project-level rules (auto-discovered from cwd):
  *   ./AGENTS.md, ./RULES.md, ./.min-agent/AGENTS.md
+ *
+ * Context-aware (like opencode):
+ *   When the agent reads a file, nearby AGENTS.md/RULES.md are auto-loaded.
  */
 const PROJECT_FILES = ["AGENTS.md", "RULES.md", "CLAUDE.md"];
+/** Tracks which instruction files have already been loaded to avoid duplicates */
+export class InstructionTracker {
+    loaded = new Set();
+    isLoaded(filepath) {
+        return this.loaded.has(path.resolve(filepath));
+    }
+    markLoaded(filepath) {
+        this.loaded.add(path.resolve(filepath));
+    }
+    /**
+     * Context-aware: when a file is read, walk up from its directory
+     * looking for AGENTS.md/RULES.md that haven't been loaded yet.
+     * Returns new instruction content to inject.
+     */
+    resolveForFile(filepath) {
+        const results = [];
+        const root = process.cwd();
+        let current = path.dirname(path.resolve(filepath));
+        while (current.startsWith(root) && current !== path.dirname(root)) {
+            for (const file of PROJECT_FILES) {
+                const candidate = path.join(current, file);
+                if (existsSync(candidate) && !this.isLoaded(candidate)) {
+                    try {
+                        const content = readFileSync(candidate, "utf-8").trim();
+                        if (content) {
+                            this.markLoaded(candidate);
+                            results.push(`Instructions from: ${candidate}\n${content}`);
+                        }
+                    }
+                    catch { }
+                }
+            }
+            if (results.length > 0)
+                break;
+            current = path.dirname(current);
+        }
+        return results;
+    }
+}
 function findProjectInstructions() {
     const results = [];
     let current = process.cwd();

package/dist/mcp.js

@@ -2,6 +2,7 @@ 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 { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
 import { tool, jsonSchema } from "ai";
 import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs";
 import path from "path";
@@ -52,7 +53,7 @@ async function openStdioMcpServer(name, config) {
         env: { ...process.env, ...(config.environment ?? {}) },
         stderr: "pipe",
     });
-    const client = new Client({ name: "agent-demo", version: "0.0.1" });
+    const client = new Client({ name: "min-agent", version: "0.1.0" });
     await client.connect(transport);
     const { tools } = await client.listTools();
     return { client, transport, tools };
@@ -75,36 +76,47 @@ async function openRemoteMcpServer(name, config) {
     const requestInit = buildRemoteRequestInit(config);
     const mode = config.remoteTransport ?? "auto";
     const connectStreamable = async () => {
-        const client = new Client({ name: "agent-demo", version: "0.0.1" });
+        const client = new Client({ name: "min-agent", version: "0.1.0" });
         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 client = new Client({ name: "min-agent", version: "0.1.0" });
         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 {
+        if (mode === "streamable-http")
+            return await connectStreamable();
+        if (mode === "sse")
             return await connectSse();
+        // auto: prefer streamable-http, fall back to sse
+        try {
+            return await connectStreamable();
+        }
+        catch (firstErr) {
+            try {
+                return await connectSse();
+            }
+            catch {
+                throw firstErr;
+            }
         }
-        catch {
-            throw new Error(`MCP "${name}" remote connection failed (streamable-http + sse): ${firstErr?.message ?? String(firstErr)}`);
+    }
+    catch (err) {
+        // Handle OAuth/Unauthorized errors
+        if (err instanceof UnauthorizedError || err?.message?.includes("Unauthorized") || err?.message?.includes("401")) {
+            if (config.oauth === false) {
+                throw new Error(`MCP "${name}" requires authentication but OAuth is disabled in config`);
+            }
+            throw new Error(`MCP "${name}" requires authentication. Add a "token" field to the server config, or configure OAuth:\n` +
+                `  min-agent mcp add ${name} --url ${rawUrl} --token YOUR_TOKEN`);
         }
+        throw new Error(`MCP "${name}" remote connection failed: ${err?.message ?? String(err)}`);
     }
 }
 async function openMcpServer(name, config) {

package/dist/output.js

@@ -32,11 +32,24 @@ export function printToolResult(name, result) {
     const suffix = truncated ? ` (${lines.length - maxLines} more lines)` : "";
     console.log(`${COLORS.green}  ✓${COLORS.reset} ${COLORS.dim}${display}${suffix}${COLORS.reset}\n`);
 }
-export function printDone(steps, usage) {
+export function printDone(steps, usage, contextWindow) {
     const input = usage.inputTokens ?? 0;
     const output = usage.outputTokens ?? 0;
     const total = input + output;
-    console.log(`${COLORS.dim}Done in ${steps} step(s) | Tokens: ${input} in / ${output} out / ${total} total${COLORS.reset}`);
+    let contextInfo = "";
+    if (input > 0 && contextWindow && contextWindow > 0) {
+        const pct = Math.round((input / contextWindow) * 100);
+        const bar = renderBar(pct);
+        contextInfo = ` | Context: ${bar} ${pct}%`;
+    }
+    console.log(`${COLORS.dim}Done in ${steps} step(s) | Tokens: ${input} in / ${output} out / ${total} total${contextInfo}${COLORS.reset}`);
+}
+function renderBar(pct) {
+    const width = 10;
+    const filled = Math.round((pct / 100) * width);
+    const empty = width - filled;
+    const color = pct >= 80 ? "\x1b[31m" : pct >= 50 ? "\x1b[33m" : "\x1b[32m";
+    return `${color}${"█".repeat(filled)}${"░".repeat(empty)}\x1b[0m\x1b[90m`;
 }
 function formatArgs(args) {
     if (!args || typeof args !== "object")