micro-models-agent 0.28.8 → 0.28.17

package/dist/modules/hallucination/confidence.js

@@ -0,0 +1,59 @@
+import { t } from "../../i18n/index";
+const MIN_CHARS = 1;
+const MIN_WORDS = 5;
+export class ConfidenceCheck {
+    previousResponse = "";
+    setPreviousResponse(response) {
+        this.previousResponse = response;
+    }
+    validate(response) {
+        if (!response || response.length < MIN_CHARS) {
+            return { status: "retry", reason: t("hall.short_response") };
+        }
+        // Language-agnostic: very short response with no structured content
+        const wordCount = response.split(/\s+/).filter(Boolean).length;
+        const hasStructure = /```|^\s*[-*]\s|^\s*\d+\.\s|<[^>]+>/m.test(response);
+        if (wordCount < MIN_WORDS && !hasStructure) {
+            return {
+                status: "warn",
+                reason: t("hall.short_response"),
+            };
+        }
+        // Language-agnostic: repetition detection via word overlap
+        if (this.previousResponse) {
+            const overlap = this.calculateOverlap(response, this.previousResponse);
+            if (overlap > 0.5) {
+                return {
+                    status: "retry",
+                    reason: t("hall.repetitive", { pct: Math.round(overlap * 100) }),
+                };
+            }
+        }
+        // Language-agnostic: very low word diversity (same words repeated)
+        const words = response
+            .toLowerCase()
+            .split(/\s+/)
+            .filter((w) => w.length > 2);
+        if (words.length >= 10) {
+            const unique = new Set(words);
+            const diversity = unique.size / words.length;
+            if (diversity < 0.25) {
+                return {
+                    status: "warn",
+                    reason: t("hall.repetitive", {
+                        pct: Math.round((1 - diversity) * 100),
+                    }),
+                };
+            }
+        }
+        return { status: "pass" };
+    }
+    calculateOverlap(a, b) {
+        const wordsA = new Set(a.toLowerCase().split(/\s+/));
+        const wordsB = b.toLowerCase().split(/\s+/);
+        if (wordsB.length === 0)
+            return 0;
+        const matches = wordsB.filter((w) => wordsA.has(w));
+        return matches.length / wordsB.length;
+    }
+}

package/dist/modules/hallucination/consistency.js

@@ -0,0 +1,26 @@
+export class ConsistencyCheck {
+    decisions = [];
+    createdFiles = new Set();
+    deletedFiles = new Set();
+    trackDecision(decision, location) {
+        this.decisions.push({ decision, location });
+    }
+    trackCreatedFile(path) {
+        this.createdFiles.add(path);
+    }
+    trackDeletedFile(path) {
+        this.deletedFiles.add(path);
+    }
+    getCreatedFiles() {
+        return Array.from(this.createdFiles);
+    }
+    getDeletedFiles() {
+        return Array.from(this.deletedFiles);
+    }
+    getDecisions() {
+        return this.decisions;
+    }
+    hasDecisions() {
+        return this.decisions.length > 0;
+    }
+}

package/dist/modules/hallucination/detector.js

@@ -0,0 +1,46 @@
+import { ConsistencyCheck } from "./consistency";
+import { ConfidenceCheck } from "./confidence";
+import { FactualCheck } from "./factual";
+import { LLMJudge } from "./llm-judge";
+export class HallucinationDetector {
+    consistency;
+    confidence;
+    factual;
+    judge;
+    constructor(baseDir, llmProvider) {
+        this.consistency = new ConsistencyCheck();
+        this.confidence = new ConfidenceCheck();
+        this.factual = baseDir ? new FactualCheck(baseDir) : null;
+        this.judge = llmProvider ? new LLMJudge(llmProvider) : null;
+    }
+    getConsistencyCheck() {
+        return this.consistency;
+    }
+    getConfidenceCheck() {
+        return this.confidence;
+    }
+    async validate(response) {
+        const confidenceResult = this.confidence.validate(response);
+        if (confidenceResult.status === "retry" ||
+            confidenceResult.status === "block") {
+            return confidenceResult;
+        }
+        const factualResult = this.factual?.validate(response);
+        if (factualResult && factualResult.status !== "pass") {
+            return factualResult;
+        }
+        // LLM-as-judge consistency: fast path (no decisions) skips any LLM call.
+        const judgeResult = this.judge
+            ? await this.judge.validate(response, this.consistency)
+            : null;
+        const warnings = [];
+        if (judgeResult && judgeResult.status === "warn")
+            warnings.push(judgeResult.reason || "");
+        if (confidenceResult.status === "warn")
+            warnings.push(confidenceResult.reason || "");
+        if (warnings.length > 0) {
+            return { status: "warn", reason: warnings.join("; ") };
+        }
+        return { status: "pass" };
+    }
+}

package/dist/modules/hallucination/factual.js

@@ -0,0 +1,190 @@
+import { existsSync, readdirSync } from "fs";
+import { resolve, isAbsolute, join } from "path";
+import { t } from "../../i18n/index";
+import { isJsMemberAccess } from "./js-identifiers";
+/** Generated/cached dirs to skip when scanning for bare file names. */
+const IGNORED_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "coverage",
+    ".mma",
+    "_testing",
+]);
+const NON_FILE_EXTENSIONS = new Set([
+    "com",
+    "org",
+    "net",
+    "gov",
+    "edu",
+    "io",
+    "dev",
+    "app",
+    "co",
+    "ai",
+    "ru",
+    "de",
+    "fr",
+    "uk",
+    "us",
+    "es",
+    "it",
+    "jp",
+    "cn",
+    "br",
+]);
+/** 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",
+]);
+/**
+ * JS/TS global identifiers whose member access (`process.env`, `console.log`)
+ * looks like a file path to the regex but is code, not a file.
+ */
+function looksLikeFilePath(s) {
+    const lower = s.toLowerCase();
+    // "Node.js" etc. are technologies, not files — never flag them.
+    if (TECH_NAMES.has(lower))
+        return false;
+    if (!s.includes("/") && !s.includes("\\") && !s.match(/^\w+\.[a-z]{2,4}$/i))
+        return false;
+    // process.env / console.log / Math.max — member access on JS globals,
+    // not file paths. Only applies to bare `word.word` (no slashes).
+    if (isJsMemberAccess(s))
+        return false;
+    const ext = s.split(".").pop()?.toLowerCase() || "";
+    return !NON_FILE_EXTENSIONS.has(ext);
+}
+export class FactualCheck {
+    baseDir;
+    nameCache = null;
+    nameCacheTime = 0;
+    lastRescan = 0;
+    static NAME_CACHE_TTL_MS = 5_000;
+    static RESCAN_COOLDOWN_MS = 2_000;
+    static MAX_INDEXED_FILES = 20_000;
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+    }
+    validate(response) {
+        const filePaths = this.extractFilePaths(response);
+        if (filePaths.length === 0)
+            return { status: "pass" };
+        const nonExistent = [];
+        for (const fp of filePaths) {
+            if (!this.pathExists(fp)) {
+                nonExistent.push(fp);
+            }
+        }
+        if (nonExistent.length > 0) {
+            return {
+                status: "warn",
+                reason: t("hall.unknown_paths", {
+                    paths: nonExistent.slice(0, 5).join(", "),
+                }),
+            };
+        }
+        return { status: "pass" };
+    }
+    /**
+     * Bare filenames ("bikes.json") and relative paths ("src/data/bikes.json")
+     * both land on the project tree. Absolute paths are checked as-is.
+     */
+    pathExists(fp) {
+        if (isAbsolute(fp))
+            return existsSync(fp);
+        // "foo.json" has no directory part — treat it as a bare name that may
+        // live anywhere under baseDir (e.g. src/data/bikes.json). Resolving it
+        // against the workspace root alone produced false "unknown file" warnings.
+        if (!fp.includes("/") && !fp.includes("\\")) {
+            return this.bareNameExists(fp);
+        }
+        return existsSync(resolve(this.baseDir, fp));
+    }
+    bareNameExists(name) {
+        if (existsSync(resolve(this.baseDir, name)))
+            return true;
+        if (this.indexHas(name))
+            return true;
+        // A write_file from this session may have created the file after the
+        // index was built. Do a one-off rescan (rate-limited) before warning.
+        const now = Date.now();
+        if (now - this.lastRescan < FactualCheck.RESCAN_COOLDOWN_MS)
+            return false;
+        this.lastRescan = now;
+        this.nameCache = null;
+        this.nameCacheTime = 0;
+        return this.indexHas(name);
+    }
+    indexHas(name) {
+        return (this.getNameIndex().get(name)?.length ?? 0) > 0;
+    }
+    /**
+     * Basename → paths index, rebuilt every NAME_CACHE_TTL_MS so newly created
+     * files (write_file) are picked up without a full scan on every response.
+     */
+    getNameIndex() {
+        const now = Date.now();
+        if (this.nameCache &&
+            now - this.nameCacheTime < FactualCheck.NAME_CACHE_TTL_MS) {
+            return this.nameCache;
+        }
+        const index = new Map();
+        const scanned = this.scanDir(this.baseDir, index, 0);
+        if (scanned > 0 || index.size > 0) {
+            this.nameCache = index;
+            this.nameCacheTime = now;
+        }
+        return index;
+    }
+    scanDir(dir, index, count) {
+        if (count >= FactualCheck.MAX_INDEXED_FILES)
+            return count;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return count;
+        }
+        for (const entry of entries) {
+            if (count >= FactualCheck.MAX_INDEXED_FILES)
+                break;
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (!IGNORED_DIRS.has(entry.name)) {
+                    count = this.scanDir(full, index, count);
+                }
+            }
+            else if (entry.isFile()) {
+                const list = index.get(entry.name);
+                if (list)
+                    list.push(full);
+                else
+                    index.set(entry.name, [full]);
+                count++;
+            }
+        }
+        return count;
+    }
+    extractFilePaths(text) {
+        // Capture absolute Windows paths (with drive letter) and relative paths.
+        // The old pattern started at a word boundary, so "E:\project\src\a.ts"
+        // only matched "project\src\a.ts" — resolve() then glued that onto
+        // baseDir producing a bogus path and a false "unknown file" warning
+        // even for files that actually exist on disk.
+        const pattern = /\b(?:[a-zA-Z]:[\\/])?[\w./\\-]+\.[a-z]{2,6}\b/gi;
+        const matches = text.match(pattern) || [];
+        return [...new Set(matches)].filter(looksLikeFilePath);
+    }
+}

package/dist/modules/hallucination/index.js

@@ -0,0 +1,5 @@
+export { HallucinationDetector, } from "./detector";
+export { ConsistencyCheck } from "./consistency";
+export { ConfidenceCheck } from "./confidence";
+export { FactualCheck } from "./factual";
+export { LLMJudge } from "./llm-judge";

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

@@ -0,0 +1,72 @@
+/**
+ * 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".
+ */
+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]);
+}

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

@@ -0,0 +1,103 @@
+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,38 @@
+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';