micro-models-agent 0.57.0 → 0.57.1

package/dist/modules/mcp/client.js

@@ -0,0 +1,399 @@
+import { spawn } from "child_process";
+export class MCPClient {
+    serverName;
+    config;
+    process = null;
+    _connected = false;
+    abortController = null;
+    pendingResolve = null;
+    pendingReject = null;
+    constructor(config) {
+        this.config = config;
+        this.serverName = config.name;
+    }
+    isConnected() {
+        return this._connected;
+    }
+    async connect() {
+        if (this._connected)
+            return;
+        if (this.config.transport === "http") {
+            this._connected = true;
+            return;
+        }
+        if (this.config.transport === "sse" || this.config.url) {
+            return this.connectSSE();
+        }
+        return this.connectStdio();
+    }
+    async connectSSE() {
+        const url = this.config.url;
+        if (!url)
+            throw new Error("SSE transport requires a url");
+        this.abortController = new AbortController();
+        const response = await fetch(url, {
+            method: "GET",
+            headers: {
+                Accept: "text/event-stream",
+                ...this.config.headers,
+            },
+            signal: this.abortController.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`SSE connection failed: ${response.status} ${response.statusText}`);
+        }
+        this._connected = true;
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        this.readSSE(reader, decoder, buffer);
+    }
+    async readSSE(reader, decoder, buffer) {
+        try {
+            while (this._connected) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                let eventType = "";
+                let data = "";
+                for (const line of lines) {
+                    if (line.startsWith("event: ")) {
+                        eventType = line.slice(7).trim();
+                    }
+                    else if (line.startsWith("data: ")) {
+                        data = line.slice(6);
+                    }
+                    else if (line === "") {
+                        if (eventType === "message" && data) {
+                            this.handleSSEMessage(data);
+                        }
+                        eventType = "";
+                        data = "";
+                    }
+                }
+            }
+        }
+        catch (err) {
+            if (err.name !== "AbortError") {
+                this.handleSSEError(err);
+            }
+        }
+        this._connected = false;
+    }
+    handleSSEMessage(data) {
+        try {
+            const msg = JSON.parse(data);
+            if (this.pendingResolve && msg.id) {
+                if (msg.error) {
+                    this.pendingReject?.(new Error(msg.error.message));
+                }
+                else {
+                    this.pendingResolve(msg.result);
+                }
+                this.pendingResolve = null;
+                this.pendingReject = null;
+            }
+        }
+        catch { }
+    }
+    handleSSEError(err) {
+        if (this.pendingReject) {
+            this.pendingReject(err);
+            this.pendingResolve = null;
+            this.pendingReject = null;
+        }
+    }
+    connectStdio() {
+        return new Promise((resolve, reject) => {
+            const child = spawn(this.config.command, this.config.args || [], {
+                env: { ...process.env, ...this.config.env },
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            let _resolved = false;
+            child.on("error", (err) => {
+                this._connected = false;
+                if (!_resolved) {
+                    _resolved = true;
+                    reject(err);
+                }
+            });
+            child.on("exit", (code) => {
+                this._connected = false;
+                if (code !== 0 && !_resolved) {
+                    _resolved = true;
+                    reject(new Error(`MCP server exited with code ${code}`));
+                }
+            });
+            child.on("spawn", () => {
+                this._connected = true;
+                this.process = child;
+                _resolved = true;
+                resolve();
+            });
+        });
+    }
+    async listTools() {
+        if (!this._connected) {
+            await this.connect();
+        }
+        if (this.config.transport === "http") {
+            return this.listToolsHTTP();
+        }
+        if (this.config.transport === "sse" || this.config.url) {
+            return this.listToolsSSE();
+        }
+        return this.listToolsStdio();
+    }
+    async listToolsHTTP() {
+        const request = {
+            jsonrpc: "2.0",
+            id: Date.now(),
+            method: "tools/list",
+        };
+        const response = await fetch(this.config.url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...this.config.headers,
+            },
+            body: JSON.stringify(request),
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => "");
+            throw new Error(`MCP listTools failed: ${response.status} ${text}`);
+        }
+        const result = await response.json();
+        if (result.error) {
+            throw new Error(result.error.message);
+        }
+        return result.result?.tools || [];
+    }
+    async listToolsSSE() {
+        const request = {
+            jsonrpc: "2.0",
+            id: Date.now(),
+            method: "tools/list",
+        };
+        const response = await fetch(this.config.url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...this.config.headers,
+            },
+            body: JSON.stringify(request),
+            signal: this.abortController?.signal,
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => "");
+            throw new Error(`MCP listTools failed: ${response.status} ${text}`);
+        }
+        const result = await response.json();
+        if (result.error) {
+            throw new Error(result.error.message);
+        }
+        return result.result?.tools || [];
+    }
+    async listToolsStdio() {
+        if (!this.process) {
+            throw new Error("Not connected to MCP server");
+        }
+        return new Promise((resolve, reject) => {
+            const request = {
+                jsonrpc: "2.0",
+                id: Date.now(),
+                method: "tools/list",
+            };
+            const requestStr = JSON.stringify(request) + "\n";
+            this.process.stdin.write(requestStr);
+            let responseData = "";
+            const onData = (data) => {
+                responseData += data.toString();
+                if (responseData.includes("\n")) {
+                    this.process.stdout.off("data", onData);
+                    try {
+                        const lines = responseData.split("\n").filter((l) => l.trim());
+                        for (const line of lines) {
+                            const response = JSON.parse(line);
+                            if (response.id === request.id) {
+                                if (response.error) {
+                                    reject(new Error(response.error.message));
+                                }
+                                else {
+                                    resolve(response.result?.tools || []);
+                                }
+                                return;
+                            }
+                        }
+                        reject(new Error("No matching response found"));
+                    }
+                    catch (e) {
+                        reject(new Error(`Parse error: ${e.message}`));
+                    }
+                }
+            };
+            this.process.stdout.on("data", onData);
+            setTimeout(() => {
+                this.process.stdout.off("data", onData);
+                reject(new Error("MCP listTools timeout"));
+            }, 30000);
+        });
+    }
+    async disconnect() {
+        if (this.config.transport === "http") {
+            this._connected = false;
+            return;
+        }
+        if (this.config.transport === "sse" || this.config.url) {
+            this.abortController?.abort();
+            this.abortController = null;
+        }
+        else if (this.process) {
+            this.process.kill();
+            this.process = null;
+        }
+        this._connected = false;
+    }
+    async callTool(toolName, args) {
+        if (!this._connected) {
+            throw new Error("Not connected to MCP server");
+        }
+        if (this.config.transport === "http") {
+            return this.callToolHTTP(toolName, args);
+        }
+        if (this.config.transport === "sse" || this.config.url) {
+            return this.callToolSSE(toolName, args);
+        }
+        return this.callToolStdio(toolName, args);
+    }
+    async callToolHTTP(toolName, args) {
+        const request = {
+            jsonrpc: "2.0",
+            id: Date.now(),
+            method: "tools/call",
+            params: {
+                name: toolName,
+                arguments: args,
+            },
+        };
+        const response = await fetch(this.config.url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...this.config.headers,
+            },
+            body: JSON.stringify(request),
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => "");
+            throw new Error(`MCP call failed: ${response.status} ${text}`);
+        }
+        const result = await response.json();
+        if (result.error) {
+            throw new Error(result.error.message);
+        }
+        return result.result || result;
+    }
+    async callToolSSE(toolName, args) {
+        const request = {
+            jsonrpc: "2.0",
+            id: Date.now(),
+            method: "tools/call",
+            params: {
+                name: toolName,
+                arguments: args,
+            },
+        };
+        return new Promise((resolve, reject) => {
+            this.pendingResolve = resolve;
+            this.pendingReject = reject;
+            const timeout = this.config.timeout || 30000;
+            const timer = setTimeout(() => {
+                this.pendingResolve = null;
+                this.pendingReject = null;
+                reject(new Error("MCP call timeout"));
+            }, timeout);
+            fetch(this.config.url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...this.config.headers,
+                },
+                body: JSON.stringify(request),
+                signal: this.abortController?.signal,
+            })
+                .then(async (response) => {
+                clearTimeout(timer);
+                if (!response.ok) {
+                    const text = await response.text().catch(() => "");
+                    reject(new Error(`MCP POST failed: ${response.status} ${text}`));
+                    return;
+                }
+                const result = await response.json();
+                if (result.error) {
+                    reject(new Error(result.error.message));
+                }
+                else {
+                    resolve(result.result || result);
+                }
+            })
+                .catch((err) => {
+                clearTimeout(timer);
+                if (err.name !== "AbortError") {
+                    reject(err);
+                }
+            });
+        });
+    }
+    callToolStdio(toolName, args) {
+        if (!this.process) {
+            throw new Error("Not connected to MCP server");
+        }
+        return new Promise((resolve, reject) => {
+            const request = {
+                jsonrpc: "2.0",
+                id: Date.now(),
+                method: "tools/call",
+                params: {
+                    name: toolName,
+                    arguments: args,
+                },
+            };
+            const requestStr = JSON.stringify(request) + "\n";
+            this.process.stdin.write(requestStr);
+            let responseData = "";
+            const onData = (data) => {
+                responseData += data.toString();
+                if (responseData.includes("\n")) {
+                    this.process.stdout.off("data", onData);
+                    try {
+                        const lines = responseData.split("\n").filter((l) => l.trim());
+                        for (const line of lines) {
+                            const response = JSON.parse(line);
+                            if (response.id === request.id) {
+                                if (response.error) {
+                                    reject(new Error(response.error.message));
+                                }
+                                else {
+                                    resolve(response.result);
+                                }
+                                return;
+                            }
+                        }
+                        reject(new Error("No matching response found"));
+                    }
+                    catch (e) {
+                        reject(new Error(`Parse error: ${e.message}`));
+                    }
+                }
+            };
+            this.process.stdout.on("data", onData);
+            setTimeout(() => {
+                this.process.stdout.off("data", onData);
+                reject(new Error("MCP call timeout"));
+            }, 30000);
+        });
+    }
+}

package/dist/modules/mcp/index.js

@@ -0,0 +1,3 @@
+export { MCPClient } from "./client";
+export { MCPRegistry } from "./registry";
+export { MCPModule } from "./module";

package/dist/modules/mcp/module.js

@@ -0,0 +1,142 @@
+import { MCPClient } from "./client";
+import { MCPRegistry } from "./registry";
+function sanitizeToolName(server, tool) {
+    const safeServer = server.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const safeTool = tool.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return `mcp__${safeServer}__${safeTool}`;
+}
+function convertInputSchema(schema) {
+    if (schema && typeof schema === "object" && "properties" in schema) {
+        const required = Array.isArray(schema.required) ? schema.required : [];
+        return {
+            type: "object",
+            properties: schema.properties,
+            required: required.length > 0 ? required : undefined,
+        };
+    }
+    return { type: "object", properties: {} };
+}
+export class MCPModule {
+    config;
+    name = "mcp";
+    connections = new Map();
+    discovered = [];
+    initialized = false;
+    initError = null;
+    constructor(config) {
+        this.config = config;
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        this.initialized = true;
+        const servers = this.config.mcpServers || {};
+        const serverEntries = Object.entries(servers).filter(([, cfg]) => cfg.enabled !== false);
+        if (serverEntries.length === 0)
+            return;
+        const registry = new MCPRegistry();
+        for (const [key, cfg] of serverEntries) {
+            const serverConfig = {
+                name: cfg.name || key,
+                command: cfg.command,
+                args: cfg.args,
+                env: cfg.env,
+                transport: cfg.transport,
+                url: cfg.url,
+                headers: cfg.headers,
+                timeout: cfg.timeout,
+            };
+            registry.register(serverConfig);
+        }
+        for (const serverName of registry.list()) {
+            const serverConfig = registry.get(serverName);
+            const client = new MCPClient(serverConfig);
+            try {
+                await client.connect();
+                const tools = await client.listTools();
+                this.connections.set(serverName, client);
+                for (const tool of tools) {
+                    this.discovered.push({
+                        serverName,
+                        toolName: tool.name,
+                        description: tool.description || `Tool on MCP server "${serverName}"`,
+                        inputSchema: tool.inputSchema || {},
+                    });
+                }
+            }
+            catch (e) {
+                this.initError = `MCP server "${serverName}" init failed: ${e.message}`;
+                await client.disconnect().catch(() => { });
+            }
+        }
+    }
+    getSystemPromptBlock() {
+        if (this.discovered.length === 0)
+            return null;
+        const lines = ["---", "MCP servers available:"];
+        const byServer = new Map();
+        for (const d of this.discovered) {
+            const list = byServer.get(d.serverName) || [];
+            list.push(d);
+            byServer.set(d.serverName, list);
+        }
+        for (const [server, tools] of byServer) {
+            lines.push(`  [${server}]`);
+            for (const t of tools) {
+                const toolRef = sanitizeToolName(server, t.toolName);
+                lines.push(`    - ${toolRef}: ${t.description}`);
+            }
+        }
+        lines.push("---");
+        return {
+            content: lines.join("\n"),
+            priority: "high",
+            essential: false,
+            estimatedTokens: this.discovered.length * 20 + 20,
+        };
+    }
+    getToolDefinitions() {
+        return this.discovered.map((d) => ({
+            name: sanitizeToolName(d.serverName, d.toolName),
+            description: `${d.description} [MCP server: ${d.serverName}]`,
+            parameters: convertInputSchema(d.inputSchema),
+            tags: ["code", "research"],
+            handler: async (_ctx, args) => {
+                const client = this.connections.get(d.serverName);
+                if (!client) {
+                    return {
+                        success: false,
+                        output: `MCP server "${d.serverName}" not connected`,
+                    };
+                }
+                try {
+                    if (!client.isConnected()) {
+                        await client.connect();
+                    }
+                    const result = await client.callTool(d.toolName, args);
+                    return {
+                        success: true,
+                        output: typeof result === "string" ? result : JSON.stringify(result, null, 2),
+                    };
+                }
+                catch (e) {
+                    return { success: false, output: `MCP call failed: ${e.message}` };
+                }
+            },
+        }));
+    }
+    getPlugin() {
+        return {
+            name: "mcp_module",
+            priority: 0,
+            onSessionEnd: async () => {
+                for (const client of this.connections.values()) {
+                    try {
+                        await client.disconnect();
+                    }
+                    catch { }
+                }
+            },
+        };
+    }
+}

package/dist/modules/mcp/registry.js

@@ -0,0 +1,15 @@
+export class MCPRegistry {
+    servers = new Map();
+    register(config) {
+        this.servers.set(config.name, config);
+    }
+    get(name) {
+        return this.servers.get(name);
+    }
+    list() {
+        return Array.from(this.servers.keys()).sort();
+    }
+    remove(name) {
+        this.servers.delete(name);
+    }
+}

package/dist/modules/memory/index.js

@@ -0,0 +1 @@
+export { MemoryStore } from "./store";

package/dist/modules/memory/module.js

@@ -0,0 +1,96 @@
+import { homedir } from "os";
+import { join } from "path";
+import { MemoryStore } from "./store";
+import { rememberTool } from "../../tools/remember";
+import { recallTool } from "../../tools/recall";
+const MEMORY_MD_FILES = ["errors", "conventions", "decisions", "facts"];
+export class MemoryModule {
+    name = "memory";
+    store;
+    constructor(storeOrDir) {
+        if (storeOrDir instanceof MemoryStore) {
+            this.store = storeOrDir;
+        }
+        else {
+            const dir = storeOrDir || join(homedir(), ".mma", "memory");
+            this.store = new MemoryStore(dir);
+        }
+    }
+    getSystemPromptBlock() {
+        const parts = [];
+        const prefs = this.store.getPreferences();
+        if (Object.keys(prefs).length > 0) {
+            const prefStr = Object.entries(prefs)
+                .map(([k, v]) => `${k}=${v}`)
+                .join(", ");
+            parts.push(`User preferences: ${prefStr}`);
+        }
+        const memoryTail = this.getMemoryTail();
+        if (memoryTail)
+            parts.push(memoryTail);
+        if (parts.length === 0)
+            return null;
+        const content = parts.join("\n\n");
+        return {
+            content,
+            priority: "normal",
+            essential: false,
+            estimatedTokens: Math.ceil(content.length / 4) + 10,
+        };
+    }
+    /**
+     * Bounded tail of the append-only .md memory files (errors, conventions,
+     * decisions, facts). This is what makes past-session lessons visible in the
+     * system prompt — without it the loop's error rules are write-only.
+     */
+    getMemoryTail() {
+        const sections = [];
+        const tailPerFile = 3;
+        for (const name of MEMORY_MD_FILES) {
+            const content = this.store.read(name).trim();
+            if (!content)
+                continue;
+            const entries = content
+                .split(/\r?\n/)
+                .map((l) => l.trim())
+                .filter((l) => l.startsWith("- "))
+                .slice(-tailPerFile);
+            if (entries.length === 0)
+                continue;
+            sections.push(`[Memory ${name}]:\n${entries.join("\n")}`);
+        }
+        if (sections.length === 0)
+            return null;
+        let joined = sections.join("\n\n");
+        // Hard cap so a huge errors.md can never blow the system prompt budget.
+        if (joined.length > 1200)
+            joined = joined.slice(0, 1200) + "\n…";
+        return joined;
+    }
+    getToolDefinitions() {
+        return [rememberTool, recallTool];
+    }
+    getPlugin() {
+        return {
+            name: "memory",
+            isBuiltin: true,
+            onBuildPrompt: () => {
+                const parts = [];
+                const prefs = this.store.getPreferences();
+                if (Object.keys(prefs).length > 0) {
+                    const prefStr = Object.entries(prefs)
+                        .map(([k, v]) => `${k}=${v}`)
+                        .join(", ");
+                    parts.push(`User preferences: ${prefStr}`);
+                }
+                const memoryTail = this.getMemoryTail();
+                if (memoryTail)
+                    parts.push(memoryTail);
+                return parts.length > 0 ? parts.join("\n\n") : null;
+            },
+        };
+    }
+    getStore() {
+        return this.store;
+    }
+}

package/dist/modules/memory/search.js

@@ -0,0 +1,42 @@
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+const MEMORY_FILES = ["conventions", "decisions", "errors", "facts"];
+export class MemorySearch {
+    memoryDir;
+    constructor(memoryDir) {
+        this.memoryDir = memoryDir;
+    }
+    query(query) {
+        const results = [];
+        const lowerQuery = query.toLowerCase();
+        for (const name of MEMORY_FILES) {
+            const path = join(this.memoryDir, `${name}.md`);
+            if (!existsSync(path))
+                continue;
+            const content = readFileSync(path, "utf-8");
+            const lines = content.split("\n");
+            for (const line of lines) {
+                if (line.toLowerCase().includes(lowerQuery)) {
+                    results.push({ file: name, match: line.trim() });
+                }
+            }
+        }
+        // Search preferences.json
+        const prefsPath = join(this.memoryDir, "preferences.json");
+        if (existsSync(prefsPath)) {
+            try {
+                const prefs = JSON.parse(readFileSync(prefsPath, "utf-8"));
+                for (const [key, value] of Object.entries(prefs)) {
+                    const searchStr = `${key}=${value}`;
+                    if (searchStr.toLowerCase().includes(lowerQuery)) {
+                        results.push({ file: "preferences", match: `${key} = ${value}` });
+                    }
+                }
+            }
+            catch {
+                /* skip */
+            }
+        }
+        return results;
+    }
+}