min-agent 0.1.0 → 0.1.2

package/dist/memory.js

@@ -0,0 +1,131 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import path from "path";
+import { getConfigDir } from "./config.js";
+import { tool, jsonSchema } from "ai";
+function getMemoryFile() {
+    return path.join(getConfigDir(), "memory.json");
+}
+export function loadMemories() {
+    const file = getMemoryFile();
+    if (!existsSync(file))
+        return [];
+    try {
+        return JSON.parse(readFileSync(file, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+function saveMemories(memories) {
+    const file = getMemoryFile();
+    mkdirSync(path.dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(memories, null, 2), "utf-8");
+}
+export function addMemory(content, tags = []) {
+    const memories = loadMemories();
+    const memory = {
+        content,
+        tags,
+        created: new Date().toISOString(),
+    };
+    memories.push(memory);
+    saveMemories(memories);
+    return memory;
+}
+export function deleteMemory(index) {
+    const memories = loadMemories();
+    if (index < 0 || index >= memories.length)
+        return false;
+    memories.splice(index, 1);
+    saveMemories(memories);
+    return true;
+}
+export function searchMemories(query) {
+    const memories = loadMemories();
+    const lower = query.toLowerCase();
+    return memories
+        .map((m, i) => ({ ...m, index: i }))
+        .filter((m) => m.content.toLowerCase().includes(lower) ||
+        m.tags.some((t) => t.toLowerCase().includes(lower)));
+}
+/** Build a system prompt section from stored memories */
+export function getMemorySystemPrompt() {
+    const memories = loadMemories();
+    if (memories.length === 0)
+        return "";
+    const items = memories.map((m, i) => {
+        const tags = m.tags.length > 0 ? ` [${m.tags.join(", ")}]` : "";
+        return `  ${i + 1}. ${m.content}${tags}`;
+    });
+    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,
+    ].join("\n");
+}
+/** Create the memory tools for the agent */
+export function getMemoryTools() {
+    const memorySave = tool({
+        description: "Save a memory for future conversations. Use this when the user shares preferences, project conventions, important context, or asks you to remember something. Memories persist across sessions.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                content: { type: "string", description: "The information to remember" },
+                tags: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional tags for categorization (e.g. 'preference', 'project', 'convention')",
+                },
+            },
+            required: ["content"],
+        }),
+        execute: async ({ content, tags }) => {
+            const memory = addMemory(content, tags ?? []);
+            return `Saved memory: "${content}" (tags: ${memory.tags.length > 0 ? memory.tags.join(", ") : "none"})`;
+        },
+    });
+    const memorySearch = tool({
+        description: "Search through saved memories by keyword. Use this to recall previously saved information.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Search keyword or phrase" },
+            },
+            required: ["query"],
+        }),
+        execute: async ({ query }) => {
+            const results = searchMemories(query);
+            if (results.length === 0)
+                return `No memories found matching "${query}"`;
+            return results
+                .map((m) => {
+                const tags = m.tags.length > 0 ? ` [${m.tags.join(", ")}]` : "";
+                return `#${m.index + 1}: ${m.content}${tags} (${m.created.split("T")[0]})`;
+            })
+                .join("\n");
+        },
+    });
+    const memoryDelete = tool({
+        description: "Delete a memory by its number. Use memory_search or memory_list first to find the index.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                index: { type: "number", description: "The memory number to delete (1-based)" },
+            },
+            required: ["index"],
+        }),
+        execute: async ({ index }) => {
+            const success = deleteMemory(index - 1);
+            if (success)
+                return `Memory #${index} deleted.`;
+            return `Memory #${index} not found.`;
+        },
+    });
+    return {
+        memory_save: memorySave,
+        memory_search: memorySearch,
+        memory_delete: memoryDelete,
+    };
+}

package/dist/output.js

@@ -0,0 +1,52 @@
+import { loadConfig } from "./config.js";
+const COLORS = {
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    bold: "\x1b[1m",
+    cyan: "\x1b[36m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    magenta: "\x1b[35m",
+    gray: "\x1b[90m",
+};
+export function printHeader(modelId) {
+    const config = loadConfig();
+    const model = modelId ?? config.provider?.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);
+    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`);
+}
+export function printDone(steps, usage) {
+    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}`);
+}
+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/plugins.js

@@ -0,0 +1,66 @@
+import { tool, jsonSchema } from "ai";
+import { existsSync, readdirSync } from "fs";
+import { pathToFileURL } from "url";
+import path from "path";
+import { getConfigDir } from "./config.js";
+const PLUGIN_DIRS = [
+    path.join(process.cwd(), ".min-agent", "tools"),
+    path.join(getConfigDir(), "tools"),
+];
+export async function loadPluginTools() {
+    const tools = {};
+    for (const dir of PLUGIN_DIRS) {
+        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}`;
+                    const properties = {};
+                    const required = [];
+                    for (const [key, param] of Object.entries(def.parameters)) {
+                        properties[key] = { type: param.type, description: param.description };
+                        required.push(key);
+                    }
+                    tools[toolId] = tool({
+                        description: def.description,
+                        inputSchema: jsonSchema({
+                            type: "object",
+                            properties,
+                            required,
+                        }),
+                        execute: async (args) => {
+                            try {
+                                const result = await def.execute(args);
+                                return typeof result === "string" ? result : JSON.stringify(result);
+                            }
+                            catch (err) {
+                                return `Plugin error: ${err.message}`;
+                            }
+                        },
+                    });
+                }
+            }
+            catch (err) {
+                console.error(`\x1b[90m  Plugin "${file}" failed to load: ${err.message}\x1b[0m`);
+            }
+        }
+    }
+    const count = Object.keys(tools).length;
+    if (count > 0) {
+        console.log(`\x1b[90m  Plugins loaded: ${count} tool(s)\x1b[0m`);
+    }
+    return tools;
+}
+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/provider.js

@@ -0,0 +1,41 @@
+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) {
+        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) {
+        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: {
+            const client = createOpenAI({
+                baseURL: provider.baseURL,
+                apiKey: provider.apiKey,
+            });
+            return client.chat(id);
+        }
+    }
+}

package/dist/serve.js

@@ -0,0 +1,351 @@
+/**
+ * HTTP API server: exposes chat / models / health for programmatic use.
+ * Run: min-agent serve [--host 127.0.0.1] [--port 8787]
+ */
+import { createServer } from "http";
+import { readFileSync, existsSync } from "fs";
+import path from "path";
+import { initMcp, shutdownMcp } from "./mcp.js";
+import { discoverSkills } from "./skills.js";
+import { loadInstructions } from "./instructions.js";
+import { loadConfig, fetchModels, isConfigured } from "./config.js";
+import { setAutoApprove } from "./confirm.js";
+import { runOnce, buildUserContent } from "./agent.js";
+import { loadSession, saveSession } from "./sessions.js";
+const MAX_BODY_BYTES = 2 * 1024 * 1024;
+const MAX_TOOL_RESULT_SSE_CHARS = 48_000;
+function packageVersion() {
+    try {
+        const pkgPath = path.join(process.cwd(), "package.json");
+        if (existsSync(pkgPath)) {
+            const j = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            return j.version ?? "0.0.0";
+        }
+    }
+    catch { }
+    return "0.0.0";
+}
+function corsHeaders() {
+    if (process.env.MIN_AGENT_SERVE_CORS === "1" || process.env.MIN_AGENT_SERVE_CORS === "true") {
+        return {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+            "Access-Control-Allow-Headers": "Content-Type, Authorization",
+        };
+    }
+    return {};
+}
+function authOk(req) {
+    const token = process.env.MIN_AGENT_SERVE_TOKEN?.trim();
+    if (!token)
+        return true;
+    const h = req.headers.authorization?.trim();
+    if (!h?.startsWith("Bearer "))
+        return false;
+    return h.slice(7) === token;
+}
+function sendJson(res, status, body) {
+    const headers = {
+        "Content-Type": "application/json; charset=utf-8",
+        ...corsHeaders(),
+    };
+    res.writeHead(status, headers);
+    res.end(JSON.stringify(body));
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let total = 0;
+        req.on("data", (c) => {
+            total += c.length;
+            if (total > MAX_BODY_BYTES) {
+                reject(new Error("body_too_large"));
+                return;
+            }
+            chunks.push(c);
+        });
+        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+        req.on("error", reject);
+    });
+}
+function sseWrite(res, obj) {
+    try {
+        if (res.writableEnded)
+            return;
+        res.write(`data: ${JSON.stringify(obj)}\n\n`);
+    }
+    catch {
+        /* client gone */
+    }
+}
+function truncateForJson(v, max) {
+    if (typeof v === "string" && v.length > max)
+        return v.slice(0, max) + `\n… [truncated ${v.length - max} chars]`;
+    return v;
+}
+function normalizeMessages(body) {
+    if (body.messages && Array.isArray(body.messages)) {
+        if (body.messages.length === 0)
+            return { ok: false, error: "messages must be non-empty" };
+        return { ok: true, messages: [...body.messages] };
+    }
+    if (typeof body.message === "string" && body.message.length > 0) {
+        return { ok: true, messages: [{ role: "user", content: body.message }] };
+    }
+    return { ok: false, error: "Provide `message` (string) or non-empty `messages` array" };
+}
+export async function runServe(opts = {}) {
+    if (!isConfigured()) {
+        console.error("Not configured. Run: min-agent setup");
+        process.exit(1);
+    }
+    const host = opts.host ?? process.env.MIN_AGENT_SERVE_HOST ?? "127.0.0.1";
+    const port = opts.port ?? parseInt(process.env.MIN_AGENT_SERVE_PORT ?? "8787", 10);
+    console.error("\x1b[33m⚠ min-agent serve: confirmations are auto-approved for this process (same as -y). Dangerous shell commands will run without prompts.\x1b[0m");
+    setAutoApprove(true);
+    console.error("\x1b[90m⟳ Initializing MCP, skills, instructions…\x1b[0m");
+    await initMcp();
+    discoverSkills();
+    let instructions = await loadInstructions();
+    const version = packageVersion();
+    const server = createServer(async (req, res) => {
+        const c = corsHeaders();
+        if (req.method === "OPTIONS") {
+            res.writeHead(204, c);
+            res.end();
+            return;
+        }
+        if (!authOk(req)) {
+            sendJson(res, 401, { error: "unauthorized", detail: "Set Authorization: Bearer <MIN_AGENT_SERVE_TOKEN> when MIN_AGENT_SERVE_TOKEN is set" });
+            return;
+        }
+        const url = new URL(req.url ?? "/", `http://${host}`);
+        const pathname = url.pathname.replace(/\/$/, "") || "/";
+        try {
+            if (req.method === "GET" && pathname === "/health") {
+                sendJson(res, 200, { ok: true, service: "min-agent", version });
+                return;
+            }
+            if (req.method === "GET" && pathname === "/v1/meta") {
+                sendJson(res, 200, {
+                    version,
+                    cwd: process.cwd(),
+                    instructions_chars: instructions.join("\n").length,
+                });
+                return;
+            }
+            if (req.method === "GET" && pathname === "/v1/models") {
+                const config = loadConfig();
+                const base = config.provider?.baseURL;
+                const key = config.provider?.apiKey;
+                if (!base || !key) {
+                    sendJson(res, 500, { error: "provider_not_configured" });
+                    return;
+                }
+                const models = await fetchModels(base, key);
+                sendJson(res, 200, {
+                    default_model: config.provider?.defaultModel ?? null,
+                    models,
+                });
+                return;
+            }
+            if (req.method === "POST" && pathname === "/v1/chat/reload-instructions") {
+                instructions = await loadInstructions();
+                sendJson(res, 200, { ok: true, instructions_chars: instructions.join("\n").length });
+                return;
+            }
+            if (req.method === "POST" && pathname === "/v1/chat") {
+                if (req.headers["content-type"]?.split(";")[0]?.trim() !== "application/json") {
+                    sendJson(res, 415, { error: "unsupported_media_type", detail: "Use Content-Type: application/json" });
+                    return;
+                }
+                let raw;
+                try {
+                    raw = await readBody(req);
+                }
+                catch (e) {
+                    if (e?.message === "body_too_large") {
+                        sendJson(res, 413, { error: "payload_too_large", max_bytes: MAX_BODY_BYTES });
+                        return;
+                    }
+                    throw e;
+                }
+                let body;
+                try {
+                    body = JSON.parse(raw);
+                }
+                catch {
+                    sendJson(res, 400, { error: "invalid_json" });
+                    return;
+                }
+                const modelId = typeof body.model === "string" ? body.model : undefined;
+                const stream = body.stream === true;
+                const sessionId = typeof body.session_id === "string" ? body.session_id : undefined;
+                let messages;
+                if (sessionId) {
+                    const session = loadSession(sessionId);
+                    if (!session) {
+                        sendJson(res, 404, { error: "session_not_found", session_id: sessionId });
+                        return;
+                    }
+                    if (typeof body.message !== "string" || !body.message.trim()) {
+                        sendJson(res, 400, {
+                            error: "session_requires_message",
+                            detail: "With `session_id`, send a non-empty `message` for the new user turn",
+                        });
+                        return;
+                    }
+                    messages = [...session.messages];
+                    const content = body.images && body.images.length > 0 ? await buildUserContent(body.message, body.images) : body.message;
+                    messages.push({ role: "user", content });
+                }
+                else {
+                    const norm = normalizeMessages(body);
+                    if (!norm.ok) {
+                        sendJson(res, 400, { error: "invalid_body", detail: norm.error });
+                        return;
+                    }
+                    messages = norm.messages;
+                    if (body.images && body.images.length > 0) {
+                        const last = messages[messages.length - 1];
+                        if (!last || last.role !== "user" || typeof body.message !== "string") {
+                            sendJson(res, 400, {
+                                error: "images_require_message",
+                                detail: "With `images`, send a top-level `message` string for the user turn",
+                            });
+                            return;
+                        }
+                        messages[messages.length - 1] = {
+                            role: "user",
+                            content: await buildUserContent(body.message, body.images),
+                        };
+                    }
+                }
+                const abort = new AbortController();
+                req.on("close", () => abort.abort());
+                if (stream) {
+                    res.writeHead(200, {
+                        "Content-Type": "text/event-stream; charset=utf-8",
+                        "Cache-Control": "no-cache, no-transform",
+                        Connection: "keep-alive",
+                        "X-Accel-Buffering": "no",
+                        ...c,
+                    });
+                    res.flushHeaders?.();
+                    const toolCalls = [];
+                    const toolResults = [];
+                    const callbacks = {
+                        onAssistantDisplayDelta(delta) {
+                            sseWrite(res, { type: "assistant", text: delta });
+                        },
+                        onThinkingDelta(delta) {
+                            sseWrite(res, { type: "thinking", text: delta });
+                        },
+                        onToolCall(name, input) {
+                            toolCalls.push({ name, input });
+                            sseWrite(res, { type: "tool_call", name, input });
+                        },
+                        onToolResult(name, output) {
+                            const out = truncateForJson(output, MAX_TOOL_RESULT_SSE_CHARS);
+                            toolResults.push({ name, output: out });
+                            sseWrite(res, { type: "tool_result", name, output: out });
+                        },
+                        onCompaction(line) {
+                            sseWrite(res, { type: "compaction", line });
+                        },
+                        onStreamError(message) {
+                            sseWrite(res, { type: "error", message });
+                        },
+                        onRunFinish(info) {
+                            let saved;
+                            if (sessionId && messages.length > 0) {
+                                try {
+                                    saved = saveSession(messages, sessionId);
+                                }
+                                catch {
+                                    saved = undefined;
+                                }
+                            }
+                            sseWrite(res, {
+                                type: "done",
+                                step_count: info.stepCount,
+                                usage: info.usage,
+                                has_error: info.hasError,
+                                aborted: info.aborted,
+                                session_id: saved,
+                                messages,
+                            });
+                            if (!res.writableEnded)
+                                res.end();
+                        },
+                    };
+                    try {
+                        await runOnce(messages, instructions, modelId, abort.signal, callbacks);
+                    }
+                    catch (err) {
+                        if (!res.writableEnded) {
+                            sseWrite(res, { type: "fatal", message: err?.message ?? String(err) });
+                            res.end();
+                        }
+                    }
+                    return;
+                }
+                const toolCalls = [];
+                const toolResults = [];
+                const finishBox = { info: null };
+                await runOnce(messages, instructions, modelId, abort.signal, {
+                    onToolCall(name, input) {
+                        toolCalls.push({ name, input });
+                    },
+                    onToolResult(name, output) {
+                        toolResults.push({ name, output: truncateForJson(output, MAX_TOOL_RESULT_SSE_CHARS) });
+                    },
+                    onRunFinish(info) {
+                        finishBox.info = info;
+                    },
+                });
+                const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
+                let savedSession;
+                if (sessionId && messages.length > 0) {
+                    try {
+                        savedSession = saveSession(messages, sessionId);
+                    }
+                    catch {
+                        savedSession = undefined;
+                    }
+                }
+                const fi = finishBox.info;
+                sendJson(res, 200, {
+                    messages,
+                    assistant: lastAssistant ?? null,
+                    tool_calls: toolCalls,
+                    tool_results: toolResults,
+                    session_id: savedSession,
+                    step_count: fi?.stepCount ?? 0,
+                    usage: fi?.usage ?? null,
+                    has_error: fi?.hasError ?? false,
+                    aborted: fi?.aborted ?? false,
+                });
+                return;
+            }
+            sendJson(res, 404, { error: "not_found", path: pathname });
+        }
+        catch (err) {
+            sendJson(res, 500, { error: "internal_error", message: err?.message ?? String(err) });
+        }
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, host, () => {
+            console.error(`\x1b[32m✓ min-agent serve\x1b[0m http://${host}:${port}  (API: docs/API.md)`);
+            resolve();
+        });
+    });
+    const shutdown = async () => {
+        await shutdownMcp();
+        server.close();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}