micro-models-agent 0.19.0 → 0.19.2

package/dist/modules/indexer/module.js

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

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

@@ -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";