micro-models-agent 0.43.3 → 0.45.0

package/dist/modules/hallucination/confidence.js

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

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

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

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

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

@@ -1,72 +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".
- */
-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

@@ -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/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,38 +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';