min-agent 0.2.0 → 0.3.0

package/dist/memory.js

@@ -1,26 +1,58 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync, unlinkSync } from "fs";
 import path from "path";
+import { randomUUID } from "crypto";
 import { getConfigDir } from "./config.js";
 import { tool, jsonSchema } from "ai";
 function getMemoryFile() {
     return path.join(getConfigDir(), "memory.json");
 }
+/** Preserve corrupt data instead of letting it be overwritten and lost forever. */
+function backupCorrupt(file) {
+    try {
+        renameSync(file, `${file}.corrupt-${Date.now()}`);
+    }
+    catch {
+        // nothing else we can do with an unreadable file
+    }
+}
 export function loadMemories() {
     const file = getMemoryFile();
     if (!existsSync(file))
         return [];
+    let data;
     try {
-        return JSON.parse(readFileSync(file, "utf-8"));
+        data = JSON.parse(readFileSync(file, "utf-8"));
     }
     catch {
+        backupCorrupt(file);
         return [];
     }
+    if (!Array.isArray(data)) {
+        backupCorrupt(file);
+        return [];
+    }
+    return data.filter((m) => typeof m === "object" && m !== null && typeof m.content === "string");
 }
+/** Atomic replace via temp file + rename, so a crash never leaves a truncated memory.json. */
 function saveMemories(memories) {
     const file = getMemoryFile();
     mkdirSync(path.dirname(file), { recursive: true });
-    writeFileSync(file, JSON.stringify(memories, null, 2), "utf-8");
+    const tmp = `${file}.tmp-${randomUUID()}`;
+    try {
+        writeFileSync(tmp, JSON.stringify(memories, null, 2), "utf-8");
+        renameSync(tmp, file);
+    }
+    catch (err) {
+        try {
+            if (existsSync(tmp))
+                unlinkSync(tmp);
+        }
+        catch { }
+        throw err;
+    }
 }
+// read-modify-write runs fully synchronously, so concurrent tool calls in
+// this process cannot interleave between load and save.
 export function addMemory(content, tags = []) {
     const memories = loadMemories();
     const memory = {
@@ -48,21 +80,31 @@ export function searchMemories(query) {
         .filter((m) => m.content.toLowerCase().includes(lower) ||
         m.tags.some((t) => t.toLowerCase().includes(lower)));
 }
-/** Build a system prompt section from stored memories */
+/** Build a system prompt section from stored memories (newest first, capped). */
 export function getMemorySystemPrompt() {
     const memories = loadMemories();
     if (memories.length === 0)
         return "";
-    const items = memories.map((m, i) => {
+    const MAX_MEMORIES = 30;
+    const start = Math.max(0, memories.length - MAX_MEMORIES);
+    const items = memories
+        .slice(start)
+        .map((m, i) => ({ m, num: start + i + 1 }))
+        .reverse()
+        .map(({ m, num }) => {
         const tags = m.tags.length > 0 ? ` [${m.tags.join(", ")}]` : "";
-        return `  ${i + 1}. ${m.content}${tags}`;
+        return `  ${num}. ${m.content}${tags}`;
     });
+    const capped = memories.length > MAX_MEMORIES
+        ? `\n(${memories.length - MAX_MEMORIES} older memories not shown — use memory_search to find them.)`
+        : "";
     return [
         "## Memories",
         "The following are things you have remembered from previous conversations. Use them to provide better, personalized responses.",
         "You can save new memories with the memory_save tool when the user tells you something worth remembering (preferences, project details, conventions, etc).",
         "",
         ...items,
+        capped,
     ].join("\n");
 }
 /** Create the memory tools for the agent */

package/dist/output.js

@@ -1,4 +1,5 @@
-import { loadConfig } from "./config.js";
+import { loadConfig, getActiveProvider } from "./config.js";
+import { summarizeToolCall, toolResultText, truncateDisplay } from "./tool-display.js";
 const COLORS = {
     reset: "\x1b[0m",
     dim: "\x1b[2m",
@@ -11,30 +12,50 @@ const COLORS = {
     gray: "\x1b[90m",
 };
 export function printHeader(modelId) {
-    const config = loadConfig();
-    const model = modelId ?? config.provider?.defaultModel ?? "unknown";
+    const model = modelId ?? getActiveProvider(loadConfig())?.defaultModel ?? "unknown";
     console.log(`${COLORS.bold}🤖 min-agent${COLORS.reset} ${COLORS.dim}(${model})${COLORS.reset}`);
 }
 export function printDivider() {
     console.log(`${COLORS.dim}${"─".repeat(60)}${COLORS.reset}`);
 }
 export function printToolCall(name, input) {
-    const argsStr = formatArgs(input);
+    const argsStr = summarizeToolCall(name, input, 160);
     console.log(`\n${COLORS.yellow}⚡ ${name}${COLORS.reset} ${COLORS.dim}${argsStr}${COLORS.reset}`);
 }
-export function printToolResult(name, result) {
-    const output = typeof result === "string" ? result : JSON.stringify(result, null, 2);
-    const lines = output.split("\n");
-    const maxLines = 20;
-    const truncated = lines.length > maxLines;
-    const preview = truncated ? lines.slice(0, maxLines).join("\n") : output;
-    const display = preview.length > 500 ? preview.slice(0, 500) + "..." : preview;
-    const suffix = truncated ? ` (${lines.length - maxLines} more lines)` : "";
-    console.log(`${COLORS.green}  ✓${COLORS.reset} ${COLORS.dim}${display}${suffix}${COLORS.reset}\n`);
+/** Console preview limits for a tool result (the full text goes to the model). */
+const RESULT_PREVIEW_MAX_LINES = 20;
+const RESULT_PREVIEW_MAX_CHARS = 1200;
+/**
+ * Print a tool result preview. Lines are kept whole and both limits are
+ * applied in one pass, so the "N more lines" count always matches what was
+ * actually withheld.
+ */
+export function printToolResult(name, result, isError = false) {
+    const text = toolResultText(result).replace(/\s+$/, "");
+    const lines = text === "" ? [] : text.split("\n");
+    const kept = [];
+    let chars = 0;
+    for (const line of lines) {
+        if (kept.length >= RESULT_PREVIEW_MAX_LINES)
+            break;
+        if (chars + line.length > RESULT_PREVIEW_MAX_CHARS)
+            break;
+        kept.push(line);
+        chars += line.length + 1;
+    }
+    // A single very long first line still deserves a preview.
+    if (kept.length === 0 && lines.length > 0) {
+        kept.push(truncateDisplay(lines[0], RESULT_PREVIEW_MAX_CHARS));
+    }
+    const hidden = lines.length - kept.length;
+    const suffix = hidden > 0 ? ` (${hidden} more line${hidden === 1 ? "" : "s"})` : "";
+    const marker = isError ? `${COLORS.red}  ✗${COLORS.reset}` : `${COLORS.green}  ✓${COLORS.reset}`;
+    const body = kept.join(`\n${COLORS.dim}    `);
+    console.log(`${marker} ${COLORS.dim}${body}${suffix}${COLORS.reset}\n`);
 }
 export function printDone(steps, usage, contextWindow) {
-    const input = usage.inputTokens ?? 0;
-    const output = usage.outputTokens ?? 0;
+    const input = usage?.inputTokens ?? 0;
+    const output = usage?.outputTokens ?? 0;
     const total = input + output;
     let contextInfo = "";
     if (input > 0 && contextWindow && contextWindow > 0) {
@@ -51,15 +72,3 @@ function renderBar(pct) {
     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")
-        return "";
-    const entries = Object.entries(args);
-    if (entries.length === 0)
-        return "";
-    const parts = entries.map(([k, v]) => {
-        const val = typeof v === "string" ? (v.length > 60 ? v.slice(0, 60) + "..." : v) : JSON.stringify(v);
-        return `${k}=${val}`;
-    });
-    return parts.join(" ");
-}

package/dist/paste-handler.js

@@ -17,7 +17,7 @@ const PREVIEW_LINES = 3;
 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 };
+        return { fullText: text, isLargePaste: false, lineCount };
     }
     const lines = text.split("\n");
     const preview = lines.slice(0, PREVIEW_LINES).join("\n");
@@ -25,6 +25,7 @@ export function processPastedInput(text) {
     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`,
@@ -36,6 +37,5 @@ export function processPastedInput(text) {
 export function printPasteFeedback(result) {
     if (!result.isLargePaste)
         return;
-    const lineCount = (result.fullText.match(/\n/g)?.length ?? 0) + 1;
-    console.log(`\x1b[90m  📋 Pasted ~${lineCount} lines (${result.fullText.length} chars)\x1b[0m`);
+    console.log(`\x1b[90m  📋 Pasted ~${result.lineCount} lines (${result.fullText.length} chars)\x1b[0m`);
 }

package/dist/plugins.js

@@ -1,5 +1,5 @@
 import { tool, jsonSchema } from "ai";
-import { existsSync, readdirSync } from "fs";
+import { existsSync, readdirSync, statSync } from "fs";
 import { pathToFileURL } from "url";
 import path from "path";
 import { getConfigDir } from "./config.js";
@@ -7,9 +7,32 @@ const PLUGIN_DIRS = [
     path.join(process.cwd(), ".min-agent", "tools"),
     path.join(getConfigDir(), "tools"),
 ];
-export async function loadPluginTools() {
+let cachedPlugins = null;
+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)
+        return cachedPlugins.tools;
+    const tools = await loadPluginToolsUncached(pluginDirs);
+    cachedPlugins = { signature, tools };
+    return tools;
+}
+async function loadPluginToolsUncached(pluginDirs) {
     const tools = {};
-    for (const dir of PLUGIN_DIRS) {
+    for (const dir of pluginDirs) {
         if (!existsSync(dir))
             continue;
         const files = readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".mjs"));
@@ -22,6 +45,10 @@ export async function loadPluginTools() {
                     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)) {
@@ -38,17 +65,17 @@ export async function loadPluginTools() {
                         execute: async (args) => {
                             try {
                                 const result = await def.execute(args);
-                                return typeof result === "string" ? result : JSON.stringify(result);
+                                return typeof result === "string" ? result : JSON.stringify(result) ?? "undefined";
                             }
                             catch (err) {
-                                return `Plugin error: ${err.message}`;
+                                return `Plugin error: ${String(err instanceof Error ? err.message : err)}`;
                             }
                         },
                     });
                 }
             }
             catch (err) {
-                console.error(`\x1b[90m  Plugin "${file}" failed to load: ${err.message}\x1b[0m`);
+                console.error(`\x1b[90m  Plugin "${file}" failed to load: ${String(err instanceof Error ? err.message : err)}\x1b[0m`);
             }
         }
     }

package/dist/pricing.js

@@ -0,0 +1,119 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import path from "path";
+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 });
+    writeFileSync(file, JSON.stringify(cache), "utf-8");
+}
+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,41 +1,43 @@
 import { createOpenAI } from "@ai-sdk/openai";
-import { loadConfig } from "./config.js";
-function normalizeOllamaBaseURL(baseURL) {
-    const trimmed = baseURL.replace(/\/$/, "");
-    return trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
-}
-export function resolveModel(modelId) {
-    const config = loadConfig();
-    const provider = config.provider;
-    if (!provider?.baseURL || !provider?.apiKey) {
+import { loadConfig, getActiveProvider, normalizeOllamaBaseURL } from "./config.js";
+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 type = provider.type ?? "openai-compatible";
-    switch (type) {
+    switch (provider.type ?? "openai-compatible") {
         case "openai": {
             const client = createOpenAI({ apiKey: provider.apiKey });
             return client.chat(id);
         }
         case "ollama": {
-            // Ollama exposes an OpenAI-compatible API at /v1.
-            // Accept both "...:11434" and "...:11434/v1" in user config.
             const client = createOpenAI({
                 baseURL: normalizeOllamaBaseURL(provider.baseURL),
                 apiKey: provider.apiKey || "ollama",
             });
             return client.chat(id);
         }
-        case "openai-compatible":
-        default: {
+        case "openai-compatible": {
             const client = createOpenAI({
                 baseURL: provider.baseURL,
                 apiKey: provider.apiKey,
             });
             return client.chat(id);
         }
+        default:
+            throw new Error(`Unknown provider type: ${provider.type}`);
+    }
+}
+export function resolveModel(modelId, providerName) {
+    const config = loadConfig();
+    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);
 }