micro-models-agent 0.28.8 → 0.28.17

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/lsp/client.js

@@ -0,0 +1,235 @@
+import { spawn, execSync } from "child_process";
+import { resolve } from "path";
+const DEFAULT_TIMEOUT = 15000;
+export class LspClient {
+    process = null;
+    requestId = 0;
+    pending = new Map();
+    buffer = "";
+    contentLength = -1;
+    diagnostics = [];
+    diagnosticsResolve = null;
+    diagnosticsTimer = null;
+    initialized = false;
+    async checkFile(filePath, baseDir, config) {
+        const timeout = config.timeout ?? DEFAULT_TIMEOUT;
+        try {
+            await this.startServer(config, baseDir);
+            const rootUri = this.pathToUri(resolve(baseDir));
+            const initResult = await this.sendRequest("initialize", {
+                processId: process.pid,
+                rootUri,
+                workspaceFolders: [{ uri: rootUri, name: "workspace" }],
+                capabilities: { textDocument: { publishDiagnostics: {} } },
+            }, timeout);
+            this.initialized = true;
+            this.sendNotification("initialized", {});
+            const uri = this.pathToUri(resolve(filePath));
+            const fs = await import("fs");
+            const content = fs.readFileSync(filePath, "utf-8");
+            const diagPromise = new Promise((resolve) => {
+                this.diagnosticsResolve = resolve;
+                this.diagnostics = [];
+                this.diagnosticsTimer = setTimeout(() => {
+                    if (this.diagnosticsResolve) {
+                        this.diagnosticsResolve([]);
+                        this.diagnosticsResolve = null;
+                    }
+                }, timeout);
+            });
+            this.sendNotification("textDocument/didOpen", {
+                textDocument: {
+                    uri,
+                    languageId: this.languageFromPath(filePath),
+                    version: 1,
+                    text: content,
+                },
+            });
+            return await diagPromise;
+        }
+        catch {
+            return [];
+        }
+        finally {
+            await this.shutdown();
+        }
+    }
+    async startServer(config, baseDir) {
+        if (config.autoInstall === false) {
+            try {
+                execSync(`where ${config.command}`, { stdio: "pipe", timeout: 3000 });
+            }
+            catch {
+                throw new Error(`${config.command} not found in PATH`);
+            }
+        }
+        return new Promise((resolve, reject) => {
+            const args = config.args ?? [];
+            const proc = spawn(config.command, args, {
+                stdio: ["pipe", "pipe", "pipe"],
+                env: { ...process.env, ...config.env },
+                cwd: baseDir,
+            });
+            proc.on("error", reject);
+            proc.stdout.on("data", (chunk) => {
+                this.handleData(chunk);
+            });
+            proc.stderr.on("data", () => { });
+            proc.once("spawn", () => {
+                resolve();
+            });
+            this.process = proc;
+            setTimeout(() => {
+                if (!this.initialized && this.process) {
+                    reject(new Error("LSP server start timeout"));
+                }
+            }, config.timeout ?? 10000);
+        });
+    }
+    handleData(chunk) {
+        this.buffer += chunk.toString();
+        this.parseMessages();
+    }
+    parseMessages() {
+        while (true) {
+            if (this.contentLength === -1) {
+                const headerEnd = this.buffer.indexOf("\r\n\r\n");
+                if (headerEnd === -1)
+                    return;
+                const header = this.buffer.slice(0, headerEnd);
+                const match = header.match(/Content-Length: (\d+)/i);
+                if (!match) {
+                    this.buffer = this.buffer.slice(headerEnd + 4);
+                    this.contentLength = -1;
+                    continue;
+                }
+                this.contentLength = parseInt(match[1], 10);
+                // Guard against malicious/buggy servers sending absurd Content-Length
+                if (this.contentLength > 10 * 1024 * 1024) {
+                    this.buffer = this.buffer.slice(headerEnd + 4);
+                    this.contentLength = -1;
+                    continue;
+                }
+                this.buffer = this.buffer.slice(headerEnd + 4);
+            }
+            if (this.buffer.length < this.contentLength)
+                return;
+            const body = this.buffer.slice(0, this.contentLength);
+            this.buffer = this.buffer.slice(this.contentLength);
+            this.contentLength = -1;
+            try {
+                const msg = JSON.parse(body);
+                this.handleMessage(msg);
+            }
+            catch { }
+        }
+    }
+    handleMessage(msg) {
+        if (msg.method === "textDocument/publishDiagnostics") {
+            const params = msg.params;
+            if (params?.diagnostics) {
+                this.diagnostics = params.diagnostics;
+                if (this.diagnosticsTimer) {
+                    clearTimeout(this.diagnosticsTimer);
+                    this.diagnosticsTimer = null;
+                }
+                if (this.diagnosticsResolve) {
+                    this.diagnosticsResolve(this.diagnostics);
+                    this.diagnosticsResolve = null;
+                }
+            }
+            return;
+        }
+        if (msg.id !== undefined && msg.id !== null) {
+            const pending = this.pending.get(msg.id);
+            if (pending) {
+                this.pending.delete(msg.id);
+                if (msg.error) {
+                    pending.reject(new Error(String(msg.error.message ?? "LSP error")));
+                }
+                else {
+                    pending.resolve(msg.result);
+                }
+            }
+        }
+    }
+    sendRequest(method, params, timeout) {
+        return new Promise((resolve, reject) => {
+            const id = ++this.requestId;
+            this.pending.set(id, { resolve, reject });
+            const message = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+            this.write(message);
+            setTimeout(() => {
+                if (this.pending.has(id)) {
+                    this.pending.delete(id);
+                    reject(new Error(`LSP request timeout: ${method}`));
+                }
+            }, timeout);
+        });
+    }
+    sendNotification(method, params) {
+        const message = JSON.stringify({ jsonrpc: "2.0", method, params });
+        this.write(message);
+    }
+    write(message) {
+        if (!this.process?.stdin?.writable)
+            return;
+        const header = `Content-Length: ${Buffer.byteLength(message)}\r\n\r\n`;
+        try {
+            this.process.stdin.write(header + message);
+        }
+        catch { }
+    }
+    async shutdown() {
+        try {
+            if (this.process && this.initialized && this.process.stdin?.writable) {
+                this.sendRequest("shutdown", null, 3000).catch(() => { });
+                this.sendNotification("exit", null);
+                await new Promise((r) => setTimeout(r, 200));
+            }
+        }
+        catch {
+        }
+        finally {
+            if (this.process) {
+                try {
+                    this.process.kill();
+                }
+                catch { }
+                this.process = null;
+            }
+            this.initialized = false;
+            if (this.diagnosticsTimer) {
+                clearTimeout(this.diagnosticsTimer);
+                this.diagnosticsTimer = null;
+            }
+        }
+    }
+    pathToUri(filePath) {
+        const normalized = filePath.replace(/\\/g, "/");
+        if (/^[a-zA-Z]:/.test(normalized)) {
+            return `file:///${normalized}`;
+        }
+        return `file://${normalized}`;
+    }
+    languageFromPath(filePath) {
+        const ext = filePath.split(".").pop()?.toLowerCase();
+        const map = {
+            ts: "typescript",
+            tsx: "typescriptreact",
+            js: "javascript",
+            jsx: "javascriptreact",
+            py: "python",
+            go: "go",
+            rs: "rust",
+            json: "json",
+            html: "html",
+            css: "css",
+            scss: "scss",
+            md: "markdown",
+            yaml: "yaml",
+            yml: "yaml",
+        };
+        return map[ext ?? ""] ?? "plaintext";
+    }
+}

package/dist/modules/lsp/config.js

@@ -0,0 +1,81 @@
+/**
+ * LSP server defaults.
+ *
+ * Strategy: prefer `npx` (auto-downloads) over globally installed binaries.
+ * Servers using system tools (rust-analyzer, gopls) have `autoInstall: false`
+ * and are skipped silently when not found.
+ */
+export const DEFAULT_LSP_CONFIG = {
+    enabled: true,
+    timeout: 15000,
+    servers: {
+        typescript: {
+            command: 'npx',
+            args: ['typescript-language-server', '--stdio'],
+            timeout: 20000,
+            autoInstall: true,
+        },
+        javascript: {
+            command: 'npx',
+            args: ['typescript-language-server', '--stdio'],
+            timeout: 15000,
+            autoInstall: true,
+        },
+        python: {
+            command: 'npx',
+            args: ['pyright', '--stdio'],
+            timeout: 15000,
+            autoInstall: true,
+        },
+        rust: {
+            command: 'rust-analyzer',
+            timeout: 15000,
+            autoInstall: false,
+        },
+        go: {
+            command: 'gopls',
+            timeout: 15000,
+            autoInstall: false,
+        },
+        json: {
+            command: 'npx',
+            args: ['vscode-json-languageserver', '--stdio'],
+            timeout: 10000,
+            autoInstall: true,
+        },
+        html: {
+            command: 'npx',
+            args: ['vscode-html-languageserver', '--stdio'],
+            timeout: 10000,
+            autoInstall: true,
+        },
+        css: {
+            command: 'npx',
+            args: ['vscode-css-languageserver', '--stdio'],
+            timeout: 10000,
+            autoInstall: true,
+        },
+    },
+};
+const LANGUAGE_MAP = {
+    ts: 'typescript',
+    tsx: 'typescript',
+    js: 'javascript',
+    jsx: 'javascript',
+    py: 'python',
+    rs: 'rust',
+    go: 'go',
+    json: 'json',
+    html: 'html',
+    css: 'css',
+    scss: 'css',
+};
+export function getServerForFile(filePath, config) {
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    if (!ext)
+        return null;
+    const lang = LANGUAGE_MAP[ext];
+    if (!lang)
+        return null;
+    return config.servers[lang] ?? null;
+}

package/dist/modules/lsp/index.js

@@ -0,0 +1,3 @@
+export { LspModule } from './module';
+export { LspClient } from './client';
+export { getServerForFile, DEFAULT_LSP_CONFIG } from './config';

package/dist/modules/lsp/module.js

@@ -0,0 +1,68 @@
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { LspClient } from './client';
+import { getServerForFile, DEFAULT_LSP_CONFIG } from './config';
+const severityLabels = {
+    1: 'error',
+    2: 'warning',
+    3: 'info',
+    4: 'hint',
+};
+export class LspModule {
+    name = 'lsp';
+    config;
+    client = new LspClient();
+    constructor(config) {
+        this.config = { ...DEFAULT_LSP_CONFIG, ...config };
+    }
+    getPlugin() {
+        const self = this;
+        return {
+            name: 'lsp-check',
+            priority: 15,
+            onAfterTool: async (_ctx, call, result) => {
+                if (!self.config.enabled)
+                    return;
+                if (call.name !== 'write_file' && call.name !== 'edit_file')
+                    return;
+                if (!result.success)
+                    return;
+                const filePath = String(call.arguments.path ?? '');
+                if (!filePath)
+                    return;
+                const fullPath = resolve(_ctx.baseDir, filePath);
+                if (!existsSync(fullPath))
+                    return;
+                const serverConfig = getServerForFile(fullPath, self.config);
+                if (!serverConfig)
+                    return;
+                try {
+                    const diagnostics = await self.client.checkFile(fullPath, _ctx.baseDir, serverConfig);
+                    const errors = diagnostics.filter((d) => d.severity === 1);
+                    const warnings = diagnostics.filter((d) => d.severity === 2);
+                    if (errors.length > 0) {
+                        const items = formatDiagnostics(errors, fullPath);
+                        result.output += `\n\n[LSP errors]:\n${items}`;
+                    }
+                    if (warnings.length > 0) {
+                        const items = formatDiagnostics(warnings, fullPath);
+                        result.output += `\n\n[LSP warnings]:\n${items}`;
+                    }
+                }
+                catch { }
+            },
+        };
+    }
+}
+function formatDiagnostics(diagnostics, filePath) {
+    const filename = filePath.replace(/\\/g, '/').split('/').pop() ?? filePath;
+    return diagnostics
+        .slice(0, 5)
+        .map((d) => {
+        const line = d.range.start.line + 1;
+        const col = d.range.start.character + 1;
+        const sev = severityLabels[d.severity] ?? 'unknown';
+        return `  ${filename}(${line},${col}): ${sev}: ${d.message}`;
+    })
+        .join('\n');
+}

package/dist/modules/lsp/types.js

@@ -0,0 +1 @@
+export {};