micro-models-agent 0.19.1 → 0.20.0

package/dist/modules/mcp/client.js

@@ -1,393 +0,0 @@
-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"],
-            });
-            child.on("error", (err) => {
-                this._connected = false;
-                reject(err);
-            });
-            child.on("exit", (code) => {
-                this._connected = false;
-                if (code !== 0) {
-                    reject(new Error(`MCP server exited with code ${code}`));
-                }
-            });
-            child.on("spawn", () => {
-                this._connected = true;
-                this.process = child;
-                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

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

package/dist/modules/mcp/module.js

@@ -1,146 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

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

package/dist/modules/memory/module.js

@@ -1,48 +0,0 @@
-import { homedir } from 'os';
-import { join } from 'path';
-import { MemoryStore } from './store';
-import { rememberTool } from '../../tools/remember';
-import { recallTool } from '../../tools/recall';
-export class MemoryModule {
-    name = 'memory';
-    store;
-    constructor(memoryDir) {
-        const dir = memoryDir || join(homedir(), '.mma', 'memory');
-        this.store = new MemoryStore(dir);
-    }
-    getSystemPromptBlock() {
-        const prefs = this.store.getPreferences();
-        if (Object.keys(prefs).length === 0)
-            return null;
-        const prefStr = Object.entries(prefs)
-            .map(([k, v]) => `${k}=${v}`)
-            .join(', ');
-        return {
-            content: `User preferences: ${prefStr}`,
-            priority: 'normal',
-            essential: false,
-            estimatedTokens: Math.ceil(prefStr.length / 4) + 10,
-        };
-    }
-    getToolDefinitions() {
-        return [rememberTool, recallTool];
-    }
-    getPlugin() {
-        return {
-            name: 'memory',
-            isBuiltin: true,
-            onBuildPrompt: () => {
-                const prefs = this.store.getPreferences();
-                if (Object.keys(prefs).length === 0)
-                    return null;
-                const prefStr = Object.entries(prefs)
-                    .map(([k, v]) => `${k}=${v}`)
-                    .join(', ');
-                return `User preferences: ${prefStr}`;
-            },
-        };
-    }
-    getStore() {
-        return this.store;
-    }
-}

package/dist/modules/memory/search.js

@@ -1,40 +0,0 @@
-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;
-    }
-}