micro-models-agent 0.28.17 → 0.29.0

package/dist/modules/hallucination/llm-judge.js

@@ -1,103 +0,0 @@
-import { t } from "../../i18n/index";
-const JUDGE_TIMEOUT_MS = 15000;
-const MAX_DECISIONS_SHOWN = 6;
-const MAX_RESPONSE_CHARS = 2000;
-/**
- * LLM-as-judge consistency check. Asks a model whether the agent's latest
- * response contradicts any of its earlier decisions — replacing the fragile
- * word-matching heuristic that only caught exact substring reversals.
- *
- * Fast path: when no decisions are tracked, returns pass without any LLM call.
- * Any judge failure (timeout, provider error, unparseable verdict) degrades to
- * pass so the agent loop is never blocked by the judge.
- */
-export class LLMJudge {
-    provider;
-    constructor(provider) {
-        this.provider = provider;
-    }
-    async validate(response, consistency) {
-        const decisions = consistency.getDecisions();
-        if (decisions.length === 0) {
-            return { status: "pass" };
-        }
-        const shown = decisions.slice(-MAX_DECISIONS_SHOWN);
-        const decisionLines = shown
-            .map((d, i) => `${i + 1}. [${d.location || "agent"}] "${d.decision}"`)
-            .join("\n");
-        const system = `You are a consistency checker for an AI coding agent. The agent previously made these decisions:
-
-${decisionLines}
-
-Decide whether the agent's NEW response contradicts any of these decisions. A contradiction means reversing or abandoning a previously stated approach (e.g. switching to a different framework, changing a chosen strategy, or undoing a decision that was explicitly made).
-
-Reply with ONLY valid JSON, no other text:
-- {"contradicts": false}
-- {"contradicts": true, "reason": "short explanation"}`;
-        const user = `Agent's new response:\n\n${response.slice(0, MAX_RESPONSE_CHARS)}`;
-        try {
-            const verdictText = await this.askJudge([
-                { role: "system", content: system },
-                { role: "user", content: user },
-            ]);
-            const verdict = this.parseVerdict(verdictText);
-            if (verdict.contradicts) {
-                const reason = verdict.reason?.trim()
-                    ? ` — ${verdict.reason.trim()}`
-                    : "";
-                return {
-                    status: "warn",
-                    reason: t("hall.contradiction_llm", { reason }),
-                };
-            }
-            return { status: "pass" };
-        }
-        catch {
-            return { status: "pass" };
-        }
-    }
-    async askJudge(messages) {
-        let text = "";
-        let timer;
-        const consume = (async () => {
-            for await (const chunk of this.provider.chat(messages, [])) {
-                if (chunk.type === "text" && chunk.content) {
-                    text += chunk.content;
-                }
-            }
-            return text;
-        })();
-        const timeout = new Promise((_, reject) => {
-            timer = setTimeout(() => reject(new Error("LLM judge timed out")), JUDGE_TIMEOUT_MS);
-        });
-        try {
-            return await Promise.race([consume, timeout]);
-        }
-        finally {
-            if (timer)
-                clearTimeout(timer);
-        }
-    }
-    parseVerdict(text) {
-        const block = text.match(/\{[\s\S]*\}/);
-        if (block) {
-            try {
-                const obj = JSON.parse(block[0]);
-                if (typeof obj.contradicts === "boolean") {
-                    return {
-                        contradicts: obj.contradicts,
-                        reason: typeof obj.reason === "string" ? obj.reason : undefined,
-                    };
-                }
-            }
-            catch {
-                // fall through to lenient parsing
-            }
-        }
-        const lower = text.toLowerCase();
-        if (lower.includes('"contradicts": true') || /^yes\b/.test(lower.trim())) {
-            return { contradicts: true, reason: text.slice(0, 200) };
-        }
-        return { contradicts: false };
-    }
-}

package/dist/modules/lsp/client.js

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

@@ -1,81 +0,0 @@
-/**
- * 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

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

package/dist/modules/lsp/module.js

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

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