micro-models-agent 0.24.12 → 0.25.0

package/dist/modules/indexer/module.js

@@ -0,0 +1,192 @@
+import { dirname } from 'path';
+import { Indexer } from './walker';
+import { IndexCache } from './cache';
+import { t } from '../../i18n/index';
+export class IndexerModule {
+    name = 'indexer';
+    indexer;
+    cache;
+    baseDir;
+    index = null;
+    rebuildTimeout = null;
+    constructor(opts) {
+        this.baseDir = opts.baseDir;
+        this.indexer = new Indexer(opts.baseDir);
+        this.cache = new IndexCache(opts.cacheDir);
+    }
+    async buildIndex() {
+        if (this.index)
+            return this.index;
+        const cached = this.cache.load();
+        if (cached) {
+            this.index = cached;
+            return cached;
+        }
+        try {
+            const result = await this.indexer.walk();
+            this.cache.save(result);
+            this.index = result;
+            return result;
+        }
+        catch {
+            return null;
+        }
+    }
+    async refresh() {
+        this.cache.invalidate();
+        this.index = null;
+        return this.buildIndex();
+    }
+    find(query) {
+        if (!this.index)
+            return [];
+        const q = query.toLowerCase();
+        return this.index.files.filter((f) => {
+            const path = f.path.toLowerCase();
+            return path.includes(q) || f.exports.some((e) => e.toLowerCase().includes(q));
+        });
+    }
+    watch() {
+        this.unwatch();
+        try {
+            this.indexer.watch((_event, filename) => {
+                if (!filename)
+                    return;
+                if (this.rebuildTimeout)
+                    clearTimeout(this.rebuildTimeout);
+                this.rebuildTimeout = setTimeout(() => {
+                    this.refresh().catch(() => { });
+                }, 2000);
+            });
+        }
+        catch {
+            // Watching is best-effort; manual refresh still works.
+        }
+    }
+    unwatch() {
+        if (this.rebuildTimeout) {
+            clearTimeout(this.rebuildTimeout);
+            this.rebuildTimeout = null;
+        }
+        this.indexer.unwatch();
+    }
+    getSystemPromptBlock() {
+        if (!this.index)
+            return null;
+        const content = this.formatMap(this.index);
+        return {
+            content,
+            priority: 'normal',
+            essential: false,
+            estimatedTokens: this.estimateTokens(content),
+        };
+    }
+    getToolDefinitions() {
+        return [this.createProjectMapTool()];
+    }
+    getPlugin() {
+        return {
+            name: 'indexer',
+            onSessionStart: () => {
+                this.buildIndex().catch(() => { });
+                this.watch();
+            },
+            onSessionEnd: () => {
+                this.unwatch();
+            },
+        };
+    }
+    formatMap(result) {
+        const summary = this.indexer.summarize(result);
+        const dirCounts = this.getDirectoryCounts(result);
+        const topDirs = Object.entries(dirCounts)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([dir, count]) => `${dir} (${count})`)
+            .join(', ') || '-';
+        const fileLines = result.files.slice(0, 100).map((f) => {
+            const path = f.path.replace(/\\/g, '/');
+            const exports = f.exports.length > 0 ? `: ${f.exports.join(', ')}` : '';
+            return `- ${path}${exports}`;
+        });
+        const more = result.files.length > 100
+            ? `\n${t('indexer.and_more', { count: result.files.length - 100 })}`
+            : '';
+        return [
+            `${t('indexer.map_header')} (${this.baseDir})`,
+            summary,
+            `${t('indexer.top_directories')}: ${topDirs}`,
+            `${t('indexer.files')}:` + (fileLines.length > 0 ? '' : ' ' + t('indexer.empty')),
+            ...fileLines,
+            more,
+        ].join('\n');
+    }
+    getDirectoryCounts(result) {
+        const counts = {};
+        for (const f of result.files) {
+            const normalized = f.path.replace(/\\/g, '/');
+            const dir = dirname(normalized);
+            const key = dir === '.' ? '(root)' : dir;
+            counts[key] = (counts[key] || 0) + 1;
+        }
+        return counts;
+    }
+    estimateTokens(content) {
+        return Math.ceil(content.length / 4);
+    }
+    createProjectMapTool() {
+        return {
+            name: 'project_map',
+            description: t('indexer.project_map_desc'),
+            parameters: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['summary', 'refresh', 'find'],
+                        description: t('indexer.project_map_action_desc'),
+                    },
+                    query: {
+                        type: 'string',
+                        description: t('indexer.project_map_query_desc'),
+                    },
+                },
+                required: ['action'],
+            },
+            handler: async (_ctx, args) => {
+                const action = String(args.action || 'summary');
+                if (action === 'refresh') {
+                    const result = await this.refresh();
+                    const summary = result ? this.indexer.summarize(result) : t('indexer.empty');
+                    return this.makeResult(t('indexer.refreshed', { summary }));
+                }
+                if (action === 'find') {
+                    const query = String(args.query || '').toLowerCase();
+                    if (!query)
+                        return { success: false, output: t('tool.invalid_params') };
+                    const matches = this.find(query);
+                    if (matches.length === 0) {
+                        return this.makeResult(t('indexer.no_matches', { query }));
+                    }
+                    const lines = matches.map((f) => {
+                        const path = f.path.replace(/\\/g, '/');
+                        const exports = f.exports.length > 0 ? `: ${f.exports.join(', ')}` : '';
+                        return `- ${path}${exports}`;
+                    }).join('\n');
+                    return this.makeResult(t('indexer.find_results', { count: matches.length, results: lines }));
+                }
+                if (!this.index) {
+                    await this.buildIndex();
+                }
+                if (!this.index) {
+                    return this.makeResult(t('indexer.not_indexed'));
+                }
+                const summary = this.indexer.summarize(this.index);
+                return this.makeResult(t('indexer.summary', { summary }));
+            },
+        };
+    }
+    makeResult(output) {
+        return { success: true, output, display: output };
+    }
+}

package/dist/modules/indexer/walker.js

@@ -0,0 +1,101 @@
+import { readdirSync, readFileSync, statSync, existsSync, watch } from 'fs';
+import { join, relative, extname } from 'path';
+const LANGUAGES = {
+    '.ts': 'typescript',
+    '.tsx': 'typescript-react',
+    '.js': 'javascript',
+    '.jsx': 'javascript-react',
+    '.json': 'json',
+    '.md': 'markdown',
+    '.yaml': 'yaml',
+    '.yml': 'yaml',
+    '.py': 'python',
+    '.rs': 'rust',
+    '.go': 'go',
+};
+const IGNORE_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.mma', 'coverage']);
+export class Indexer {
+    baseDir;
+    MAX_FILES = 1000;
+    watcher = null;
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+    }
+    watch(callback) {
+        this.watcher = watch(this.baseDir, { recursive: true }, (event, filename) => {
+            if (filename && !Array.from(IGNORE_DIRS).some((dir) => filename.includes(dir))) {
+                callback(event, filename);
+            }
+        });
+    }
+    unwatch() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+    }
+    async walk() {
+        const files = [];
+        let totalSize = 0;
+        let count = 0;
+        const walkDir = (dir) => {
+            if (!existsSync(dir))
+                return;
+            let entries;
+            try {
+                entries = readdirSync(dir);
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (count >= this.MAX_FILES)
+                    return;
+                const fullPath = join(dir, entry);
+                const relPath = relative(this.baseDir, fullPath);
+                const stat = statSync(fullPath);
+                if (stat.isDirectory()) {
+                    if (!IGNORE_DIRS.has(entry)) {
+                        walkDir(fullPath);
+                    }
+                }
+                else if (stat.isFile()) {
+                    const ext = extname(entry).toLowerCase();
+                    const language = LANGUAGES[ext];
+                    if (language) {
+                        const content = readFileSync(fullPath, 'utf-8');
+                        const exports = this.extractExports(content, language);
+                        files.push({ path: relPath, language, exports, size: stat.size });
+                        totalSize += stat.size;
+                        count++;
+                    }
+                }
+            }
+        };
+        walkDir(this.baseDir);
+        return { files, totalSize };
+    }
+    extractExports(content, language) {
+        if (language === 'typescript' || language === 'javascript') {
+            const exports = [];
+            const exportRegex = /export\s+(?:const|function|class|interface|type|enum|default\s+(?:class|function))\s+(\w+)/g;
+            let match;
+            while ((match = exportRegex.exec(content)) !== null) {
+                exports.push(match[1]);
+            }
+            return exports;
+        }
+        return [];
+    }
+    summarize(result) {
+        const byLang = {};
+        for (const f of result.files) {
+            byLang[f.language] = (byLang[f.language] || 0) + 1;
+        }
+        const langs = Object.entries(byLang)
+            .sort((a, b) => b[1] - a[1])
+            .map(([lang, count]) => `${lang}:${count}`)
+            .join(', ');
+        return `[Index: ${result.files.length} files, ${(result.totalSize / 1024).toFixed(1)}KB (${langs})]`;
+    }
+}

package/dist/modules/mcp/client.js

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

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