micro-models-agent 0.28.17 → 0.29.0

package/dist/modules/hallucination/detector.js

@@ -1,17 +1,17 @@
-import { ConsistencyCheck } from "./consistency";
-import { ConfidenceCheck } from "./confidence";
-import { FactualCheck } from "./factual";
-import { LLMJudge } from "./llm-judge";
+import { FactualCheck } from './factual';
+import { ConsistencyCheck } from './consistency';
+import { ConfidenceCheck } from './confidence';
 export class HallucinationDetector {
+    factual;
     consistency;
     confidence;
-    factual;
-    judge;
-    constructor(baseDir, llmProvider) {
+    constructor() {
+        this.factual = new FactualCheck();
         this.consistency = new ConsistencyCheck();
         this.confidence = new ConfidenceCheck();
-        this.factual = baseDir ? new FactualCheck(baseDir) : null;
-        this.judge = llmProvider ? new LLMJudge(llmProvider) : null;
+    }
+    getFactualCheck() {
+        return this.factual;
     }
     getConsistencyCheck() {
         return this.consistency;
@@ -19,28 +19,23 @@ export class HallucinationDetector {
     getConfidenceCheck() {
         return this.confidence;
     }
-    async validate(response) {
+    validate(response) {
         const confidenceResult = this.confidence.validate(response);
-        if (confidenceResult.status === "retry" ||
-            confidenceResult.status === "block") {
+        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 factualResult = this.factual.validate(response);
+        const consistencyResult = this.consistency.validate(response);
         const warnings = [];
-        if (judgeResult && judgeResult.status === "warn")
-            warnings.push(judgeResult.reason || "");
-        if (confidenceResult.status === "warn")
-            warnings.push(confidenceResult.reason || "");
+        if (factualResult.status === 'warn')
+            warnings.push(factualResult.reason || '');
+        if (consistencyResult.status === 'warn')
+            warnings.push(consistencyResult.reason || '');
+        if (confidenceResult.status === 'warn')
+            warnings.push(confidenceResult.reason || '');
         if (warnings.length > 0) {
-            return { status: "warn", reason: warnings.join("; ") };
+            return { status: 'warn', reason: warnings.join('; ') };
         }
-        return { status: "pass" };
+        return { status: 'pass' };
     }
 }

package/dist/modules/hallucination/factual.js

@@ -1,190 +1,170 @@
-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",
+import { existsSync } from "fs";
+import { join } from "path";
+const FILE_EXTENSIONS = new Set([
+    "ts",
+    "tsx",
+    "js",
+    "jsx",
+    "mjs",
+    "cjs",
+    "mts",
+    "cts",
+    "json",
+    "md",
+    "yaml",
+    "yml",
+    "py",
+    "rs",
+    "go",
+    "java",
+    "c",
+    "cpp",
+    "h",
+    "hpp",
+    "html",
+    "css",
+    "scss",
+    "less",
+    "vue",
+    "svelte",
+    "sh",
+    "bash",
+    "zsh",
+    "ps1",
+    "bat",
+    "cmd",
+    "txt",
+    "env",
+    "env.local",
+    "env.production",
+    "gitignore",
+    "dockerignore",
+    "dockerfile",
+    "makefile",
+    "cmake",
+    "toml",
+    "lock",
+    "config",
+    "log",
+    "xml",
+    "sql",
+    "graphql",
+    "proto",
+    "wasm",
 ]);
-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",
+const VERSION_PATTERN = /^\d+(\.\d+)*$/;
+const COMMON_WORDS = new Set([
+    "node.js", "Node.js",
+    "console.log", "console.error", "console.warn", "console.info",
+    "Math.floor", "Math.ceil", "Math.round", "Math.max", "Math.min",
+    "JSON.parse", "JSON.stringify",
+    "Object.keys", "Object.values", "Object.entries",
+    "Array.from", "Array.isArray",
+    "Date.now", "Date.parse",
+    "RegExp", "Promise",
 ]);
-/** 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;
+    knownPaths = new Set();
+    createdPaths = new Set();
+    readFiles = new Set();
+    baseDir = process.cwd();
+    setBaseDir(dir) {
+        this.baseDir = dir;
     }
-    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));
+    trackReadPath(path) {
+        this.knownPaths.add(path);
+        const base = path.split(/[/\\]/).pop();
+        if (base && base !== path)
+            this.knownPaths.add(base);
+        // Track that this file was actually read by the agent
+        this.readFiles.add(base || path);
     }
-    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);
+    trackCreatedPath(path) {
+        this.knownPaths.add(path);
+        const base = path.split(/[/\\]/).pop();
+        if (base && base !== path)
+            this.knownPaths.add(base);
+        this.createdPaths.add(path);
     }
-    indexHas(name) {
-        return (this.getNameIndex().get(name)?.length ?? 0) > 0;
+    trackDeletedPath(path) {
+        this.knownPaths.add(path);
+        const base = path.split(/[/\\]/).pop();
+        if (base && base !== path)
+            this.knownPaths.add(base);
+        this.createdPaths.delete(path);
     }
     /**
-     * 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.
+     * Register file paths found in a document (e.g. structure.md, README).
+     * Files mentioned in project documentation are not hallucinations.
      */
-    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;
+    trackDocumentContent(content) {
+        // Match common path patterns in documentation
+        const pathPatterns = /(?:^|\s)([\w\-./]+\.\w{1,10})(?:\s|$|[,;)])/gm;
+        let match;
+        while ((match = pathPatterns.exec(content)) !== null) {
+            const file = match[1];
+            if (file.includes('/') || file.includes('\\')) {
+                this.knownPaths.add(file);
+            }
+            const base = file.split(/[/\\]/).pop();
+            if (base)
+                this.knownPaths.add(base);
         }
-        return index;
     }
-    scanDir(dir, index, count) {
-        if (count >= FactualCheck.MAX_INDEXED_FILES)
-            return count;
-        let entries;
+    pathExistsOnDisk(path) {
         try {
-            entries = readdirSync(dir, { withFileTypes: true });
+            // Skip absolute paths — they're either system paths or outside the project.
+            // On Windows, existsSync('/...') can hang on certain paths.
+            if (path.startsWith("/") || path.startsWith("~") || /^[A-Za-z]:/.test(path)) {
+                return false;
+            }
+            return existsSync(join(this.baseDir, path));
         }
         catch {
-            return count;
+            return false;
         }
-        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++;
+    }
+    validate(response) {
+        const pathRegex = /[\w\-./]+\.\w+/g;
+        const mentionedPaths = response.match(pathRegex) || [];
+        const unknownPaths = mentionedPaths.filter((p) => {
+            if (this.knownPaths.has(p))
+                return false;
+            if (VERSION_PATTERN.test(p))
+                return false;
+            if (COMMON_WORDS.has(p))
+                return false;
+            // Skip absolute paths — agent responses use relative paths; absolute
+            // paths are either system paths or URLs, and existsSync can hang on
+            // Windows for root-relative paths like "/page.html".
+            if (p.startsWith("/") || p.startsWith("~") || /^[A-Za-z]:/.test(p))
+                return false;
+            if (this.pathExistsOnDisk(p))
+                return false;
+            const ext = p.split(".").pop()?.toLowerCase() || "";
+            if (!FILE_EXTENSIONS.has(ext))
+                return false;
+            const basename = p
+                .split("/")
+                .pop()
+                ?.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            if (basename) {
+                const urlPattern = new RegExp(`(https?|file)://[^\\s]*${basename}`);
+                if (urlPattern.test(response))
+                    return false;
             }
+            return true;
+        });
+        if (unknownPaths.length > 0) {
+            const uniquePaths = [...new Set(unknownPaths)];
+            return {
+                status: "warn",
+                reason: t("hall.unknown_paths", {
+                    paths: uniquePaths.slice(0, 3).join(", "),
+                }),
+            };
         }
-        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);
+        return { status: "pass" };
     }
 }

package/dist/modules/hallucination/index.js

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

package/dist/modules/index.js

@@ -1,5 +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";
+export { ModuleRegistry } from './registry';
+export { SkillsLoader, SkillsMatcher, SkillsModule } from './skills';
+export { PluginManager } from './plugins';
+export { PluginLoader } from './plugins/loader';
+export { MCPClient, MCPRegistry } from './mcp';

package/dist/modules/mcp/client.js

@@ -112,25 +112,19 @@ export class MCPClient {
                 env: { ...process.env, ...this.config.env },
                 stdio: ["pipe", "pipe", "pipe"],
             });
-            let _resolved = false;
             child.on("error", (err) => {
                 this._connected = false;
-                if (!_resolved) {
-                    _resolved = true;
-                    reject(err);
-                }
+                reject(err);
             });
             child.on("exit", (code) => {
                 this._connected = false;
-                if (code !== 0 && !_resolved) {
-                    _resolved = true;
+                if (code !== 0) {
                     reject(new Error(`MCP server exited with code ${code}`));
                 }
             });
             child.on("spawn", () => {
                 this._connected = true;
                 this.process = child;
-                _resolved = true;
                 resolve();
             });
         });

package/dist/modules/memory/store.js

@@ -62,8 +62,4 @@ export class MemoryStore {
         writeFileSync(this.prefsPath(), JSON.stringify(prefs, null, 2), 'utf-8');
         return true;
     }
-    appendRule(category, pattern, cause, solution) {
-        const entry = `**pattern:** ${pattern}\n  **cause:** ${cause}\n  **solution:** ${solution}`;
-        this.append(category, entry);
-    }
 }