micro-models-agent 0.60.1 → 0.61.1

package/dist/modules/hallucination/js-identifiers.js

@@ -0,0 +1,262 @@
+/**
+ * JS/TS global identifiers whose member access (`process.env`, `console.log`,
+ * `Math.max`) looks like a file path to `\b[\w./\\-]+\.[a-z]+\b`-style regexes
+ * but is code, not a file. Shared by the hallucination factual check and the
+ * execution auditor so both stop flagging member access as "missing files".
+ *
+ * Also home of the shared "is this token actually a file?" filter
+ * (`isFilePathLike` / `extractFileLikeTokens` / `stripUrls`) so the two
+ * extractors cannot drift apart again (observed: auditor treated a URL
+ * hostname `whom-pointing-jewel-maine.trycloudflare.com` in a plan step as a
+ * missing file while the factual check correctly ignored it).
+ *
+ * Bare `word.ext` tokens are gated on an allow-list of real file extensions
+ * (`FILE_EXTENSIONS`) instead of a deny-list of TLDs — a domain in any present
+ * or future TLD (`Gismeteo.by`, `weather.com`, `example.xyz`) can never be
+ * mistaken for a file, and no TLD list needs maintaining.
+ */
+const JS_GLOBALS = new Set([
+    "process",
+    "console",
+    "math",
+    "json",
+    "global",
+    "globalthis",
+    "window",
+    "document",
+    "buffer",
+    "module",
+    "require",
+    "exports",
+    "url",
+    "promise",
+    "array",
+    "object",
+    "string",
+    "number",
+    "boolean",
+    "symbol",
+    "date",
+    "regexp",
+    "error",
+    "map",
+    "set",
+    "weakmap",
+    "weakset",
+    "proxy",
+    "reflect",
+    "intl",
+    "crypto",
+    "performance",
+    "fetch",
+    "navigator",
+    "location",
+    "settimeout",
+    "setinterval",
+    "cleartimeout",
+    "clearinterval",
+    "queuemicrotask",
+    "structuredclone",
+    "textencoder",
+    "textdecoder",
+    "atomics",
+    "sharedarraybuffer",
+    "dataview",
+    "arraybuffer",
+    "bigint",
+    "infinity",
+    "nan",
+    "undefined",
+    "bun",
+    "deno",
+    "node",
+]);
+/**
+ * True when `candidate` starts with a known JS/TS global followed by a dot
+ * (`process.env`, `console.log`, `process.env.NODE` partial matches from
+ * `\b[\w./\\-]+\.[a-z]+`-style regexes) — member access, not a file path.
+ */
+export function isJsMemberAccess(candidate) {
+    const lower = candidate.toLowerCase();
+    const m = lower.match(/^([\w-]+)\./);
+    return m !== null && JS_GLOBALS.has(m[1]);
+}
+/**
+ * File extensions that make a bare `word.ext` token a plausible file path.
+ *
+ * An allow-list, deliberately: enumerating everything that is NOT a file (TLDs,
+ * brand names, …) is a brittle heuristic that can never be complete. Instead a
+ * bare `word.ext` is only treated as a file when its extension is a known one —
+ * so `Gismeteo.by`, `weather.com`, or any future TLD is never flagged, while a
+ * genuine `config.json` / `helper.ts` still is.
+ */
+const FILE_EXTENSIONS = new Set([
+    // source / code
+    "ts",
+    "tsx",
+    "js",
+    "jsx",
+    "mjs",
+    "cjs",
+    "py",
+    "pyc",
+    "rb",
+    "go",
+    "rs",
+    "java",
+    "jar",
+    "kt",
+    "kts",
+    "c",
+    "h",
+    "cc",
+    "cpp",
+    "cxx",
+    "hpp",
+    "hh",
+    "cs",
+    "php",
+    "swift",
+    "m",
+    "mm",
+    "lua",
+    "pl",
+    "sh",
+    "bash",
+    "zsh",
+    "fish",
+    "bat",
+    "cmd",
+    "ps1",
+    "vue",
+    "svelte",
+    "dart",
+    // config / data / docs
+    "json",
+    "jsonc",
+    "json5",
+    "yaml",
+    "yml",
+    "toml",
+    "ini",
+    "cfg",
+    "conf",
+    "env",
+    "xml",
+    "html",
+    "htm",
+    "md",
+    "markdown",
+    "rst",
+    "txt",
+    "log",
+    "csv",
+    "tsv",
+    "lock",
+    "sql",
+    "sqlite",
+    "db",
+    "wasm",
+    "map",
+    "css",
+    "scss",
+    "sass",
+    "less",
+    // assets / binary
+    "svg",
+    "png",
+    "jpg",
+    "jpeg",
+    "gif",
+    "webp",
+    "bmp",
+    "ico",
+    "avif",
+    "tiff",
+    "pdf",
+    "doc",
+    "docx",
+    "xls",
+    "xlsx",
+    "ppt",
+    "pptx",
+    "odt",
+    "ods",
+    "zip",
+    "gz",
+    "tar",
+    "tgz",
+    "bz2",
+    "xz",
+    "7z",
+    "rar",
+    "bin",
+    "exe",
+    "dll",
+    "so",
+    "o",
+    "a",
+    "dylib",
+]);
+/** Well-known runtime/library names that end in .js/.ts but are NOT files. */
+const TECH_NAMES = new Set([
+    "node.js",
+    "react.js",
+    "vue.js",
+    "next.js",
+    "angular.js",
+    "express.js",
+    "deno.js",
+    "qwik.js",
+    "svelte.js",
+    "jquery.js",
+]);
+const FILE_TOKEN_RE = /\b(?:[a-zA-Z]:[\\/])?[\w./\\-]+\.[a-z]{1,6}\b/gi;
+/**
+ * True when `candidate` is a plausible file path token: for a path with a
+ * directory separator the last segment must carry a non-empty stem before the
+ * extension (extension-only segments like `tsx/.ts` are rejected), while a bare
+ * `word.ext` is only a file when its extension is a known file extension (so
+ * domains like `Gismeteo.by` / `weather.com` are never files). JS member access
+ * (`process.env`) and technology names (`node.js`) are never files.
+ */
+export function isFilePathLike(s) {
+    const lower = s.toLowerCase();
+    if (TECH_NAMES.has(lower))
+        return false;
+    if (isJsMemberAccess(s))
+        return false;
+    const ext = s.split(".").pop()?.toLowerCase() || "";
+    if (!s.includes("/") && !s.includes("\\")) {
+        if (!/^\w+\.[a-z]{1,6}$/i.test(s))
+            return false;
+        return FILE_EXTENSIONS.has(ext);
+    }
+    // Tokens with a directory separator: require the LAST segment to carry a
+    // real file name (a non-empty stem before the extension). Otherwise an
+    // extension-only segment like "tsx/.ts" (from ".tsx/.ts" in a step
+    // description) or a dotfile ("src/.env") is misread as a file and the plan
+    // deliverable gate demands "create tsx/.ts" (observed in ses_mstda6uo:
+    // step "Проверить что остались только .tsx/.ts файлы").
+    const last = s.split(/[\\/]/).pop() ?? "";
+    const lastDot = last.lastIndexOf(".");
+    if (lastDot <= 0)
+        return false;
+    return true;
+}
+/**
+ * Extract deduplicated file-like tokens from free text. Bare `word.ext` tokens
+ * are filtered through `isFilePathLike` (allow-list of real file extensions, so
+ * hostnames/TLDs like `whom-pointing-jewel-maine.trycloudflare.com` or
+ * `Gismeteo.by` never survive); URLs are stripped first so
+ * `https://host/repo.git` never survives as a "file".
+ */
+export function extractFileLikeTokens(text) {
+    const matches = text.match(FILE_TOKEN_RE) || [];
+    return [...new Set(matches.filter(isFilePathLike))];
+}
+/** Remove URL tokens (scheme://… up to whitespace/quote) so they are never
+ *  parsed as file paths. */
+export function stripUrls(text) {
+    return text.replace(/\bhttps?:\/\/[^\s"'<>]+/gi, " ");
+}

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

@@ -0,0 +1,101 @@
+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/index.js

@@ -0,0 +1,5 @@
+export { ModuleRegistry } from "./registry";
+export { SkillsLoader, SkillsModule } from "./skills";
+export { PluginManager } from "./plugins";
+export { PluginLoader } from "./plugins/loader";
+export { MCPClient, MCPRegistry } from "./mcp";

package/dist/modules/indexer/cache.js

@@ -0,0 +1,40 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync } from "fs";
+import { join } from "path";
+export class IndexCache {
+    cachePath;
+    cache = null;
+    constructor(cacheDir) {
+        this.cachePath = join(cacheDir, "index-cache.json");
+    }
+    load() {
+        if (this.cache)
+            return this.cache;
+        if (!existsSync(this.cachePath))
+            return null;
+        try {
+            this.cache = JSON.parse(readFileSync(this.cachePath, "utf-8"));
+            return this.cache;
+        }
+        catch {
+            return null;
+        }
+    }
+    save(result) {
+        this.cache = result;
+        const dir = join(this.cachePath, "..");
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(this.cachePath, JSON.stringify(result), "utf-8");
+    }
+    invalidate() {
+        this.cache = null;
+        if (existsSync(this.cachePath)) {
+            try {
+                rmSync(this.cachePath);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+}

package/dist/modules/indexer/index.js

@@ -0,0 +1,3 @@
+export { Indexer } from "./walker";
+export { IndexCache } from "./cache";
+export { IndexerModule } from "./module";

package/dist/modules/indexer/module.js

@@ -0,0 +1,246 @@
+import { dirname } from "path";
+import { Indexer } from "./walker";
+import { IndexCache } from "./cache";
+import { buildProjectProfileLine } from "./project-profile";
+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 stackLine = buildProjectProfileLine(this.baseDir);
+        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 })}`
+            : "";
+        const duplicates = this.findDuplicateBasenames(result);
+        return [
+            `${t("indexer.map_header")} (${this.baseDir})`,
+            summary,
+            ...(stackLine ? [stackLine] : []),
+            `${t("indexer.top_directories")}: ${topDirs}`,
+            ...(duplicates.length > 0 ? [t("indexer.duplicates", { names: duplicates.join(", ") })] : []),
+            `${t("indexer.files")}:` + (fileLines.length > 0 ? "" : " " + t("indexer.empty")),
+            ...fileLines,
+            more,
+        ].join("\n");
+    }
+    /**
+     * Find files that share a basename across different extensions in the same
+     * directory (e.g. `ProductCard.js` + `ProductCard.tsx`). This is a purely
+     * structural fact about the file tree — a stale transpiled twin may shadow
+     * the real source at build time. Flagging it is not task classification, so
+     * it does not violate the no-keyword-matching rule; the model decides what
+     * to do with the information.
+     */
+    findDuplicateBasenames(result) {
+        const byDir = {};
+        for (const f of result.files) {
+            const path = f.path.replace(/\\/g, "/");
+            const idx = path.lastIndexOf("/");
+            const dir = idx >= 0 ? path.slice(0, idx) : "";
+            const name = path.slice(idx + 1);
+            const dot = name.lastIndexOf(".");
+            if (dot <= 0)
+                continue;
+            const base = name.slice(0, dot);
+            const ext = name.slice(dot + 1);
+            if (!byDir[dir])
+                byDir[dir] = new Map();
+            const list = byDir[dir].get(base) ?? [];
+            list.push(ext);
+            byDir[dir].set(base, list);
+        }
+        const dups = [];
+        for (const dir of Object.keys(byDir).sort()) {
+            for (const [base, exts] of byDir[dir]) {
+                if (exts.length < 2)
+                    continue;
+                const uniqueExts = [...new Set(exts)].sort();
+                const dirPrefix = dir ? `${dir}/` : "";
+                dups.push(`${dirPrefix}${base}.{${uniqueExts.join(",")}}`);
+            }
+        }
+        return dups;
+    }
+    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",
+            icon: "🗺️",
+            alwaysOn: true,
+            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");
+                    const stackLine = result ? buildProjectProfileLine(this.baseDir) : null;
+                    const output = summary && stackLine ? `${summary}\n${stackLine}` : summary;
+                    return this.makeResult(t("indexer.refreshed", { summary: output }));
+                }
+                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);
+                const stackLine = buildProjectProfileLine(this.baseDir);
+                const output = summary && stackLine ? `${summary}\n${stackLine}` : summary;
+                return this.makeResult(t("indexer.summary", { summary: output }));
+            },
+        };
+    }
+    makeResult(output) {
+        return { success: true, output, display: output };
+    }
+}