micro-models-agent 0.59.0 → 0.60.0

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

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

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

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

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

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

package/dist/modules/indexer/module.js

@@ -1,246 +0,0 @@
-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 };
-    }
-}