micro-models-agent 0.41.2 → 0.43.0

package/dist/modules/hallucination/confidence.js

@@ -8,11 +8,7 @@ export class ConfidenceCheck {
     }
     validate(response) {
         if (!response || response.length < MIN_CHARS) {
-            return {
-                status: "retry",
-                kind: "short",
-                reason: t("hall.short_response"),
-            };
+            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;
@@ -20,7 +16,6 @@ export class ConfidenceCheck {
         if (wordCount < MIN_WORDS && !hasStructure) {
             return {
                 status: "warn",
-                kind: "short",
                 reason: t("hall.short_response"),
             };
         }
@@ -30,7 +25,6 @@ export class ConfidenceCheck {
             if (overlap > 0.5) {
                 return {
                     status: "retry",
-                    kind: "repetition",
                     reason: t("hall.repetitive", { pct: Math.round(overlap * 100) }),
                 };
             }
@@ -46,7 +40,6 @@ export class ConfidenceCheck {
             if (diversity < 0.25) {
                 return {
                     status: "warn",
-                    kind: "diversity",
                     reason: t("hall.repetitive", {
                         pct: Math.round((1 - diversity) * 100),
                     }),

package/dist/modules/hallucination/detector.js

@@ -21,7 +21,8 @@ export class HallucinationDetector {
     }
     async 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);
@@ -29,7 +30,9 @@ export class HallucinationDetector {
             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 judgeResult = this.judge
+            ? await this.judge.validate(response, this.consistency)
+            : null;
         const warnings = [];
         if (judgeResult && judgeResult.status === "warn")
             warnings.push(judgeResult.reason || "");

package/dist/modules/hallucination/factual.js

@@ -1,7 +1,7 @@
 import { existsSync, readdirSync } from "fs";
 import { resolve, isAbsolute, join } from "path";
 import { t } from "../../i18n/index";
-import { extractFileLikeTokens, stripUrls } from "./js-identifiers";
+import { isJsMemberAccess } from "./js-identifiers";
 /** Generated/cached dirs to skip when scanning for bare file names. */
 const IGNORED_DIRS = new Set([
     "node_modules",
@@ -12,6 +12,59 @@ const IGNORED_DIRS = new Set([
     ".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;
@@ -82,7 +135,8 @@ export class FactualCheck {
      */
     getNameIndex() {
         const now = Date.now();
-        if (this.nameCache && now - this.nameCacheTime < FactualCheck.NAME_CACHE_TTL_MS) {
+        if (this.nameCache &&
+            now - this.nameCacheTime < FactualCheck.NAME_CACHE_TTL_MS) {
             return this.nameCache;
         }
         const index = new Map();
@@ -124,6 +178,13 @@ export class FactualCheck {
         return count;
     }
     extractFilePaths(text) {
-        return extractFileLikeTokens(stripUrls(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,4 +1,4 @@
-export { HallucinationDetector } from "./detector";
+export { HallucinationDetector, } from "./detector";
 export { ConsistencyCheck } from "./consistency";
 export { ConfidenceCheck } from "./confidence";
 export { FactualCheck } from "./factual";

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

@@ -3,17 +3,6 @@
  * `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",
@@ -81,182 +70,3 @@ export function isJsMemberAccess(candidate) {
     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

@@ -42,7 +42,9 @@ Reply with ONLY valid JSON, no other text:
             ]);
             const verdict = this.parseVerdict(verdictText);
             if (verdict.contradicts) {
-                const reason = verdict.reason?.trim() ? ` — ${verdict.reason.trim()}` : "";
+                const reason = verdict.reason?.trim()
+                    ? ` — ${verdict.reason.trim()}`
+                    : "";
                 return {
                     status: "warn",
                     reason: t("hall.contradiction_llm", { reason }),

package/dist/modules/indexer/cache.js

@@ -1,10 +1,10 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync } from "fs";
-import { join } from "path";
+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");
+        this.cachePath = join(cacheDir, 'index-cache.json');
     }
     load() {
         if (this.cache)
@@ -12,7 +12,7 @@ export class IndexCache {
         if (!existsSync(this.cachePath))
             return null;
         try {
-            this.cache = JSON.parse(readFileSync(this.cachePath, "utf-8"));
+            this.cache = JSON.parse(readFileSync(this.cachePath, 'utf-8'));
             return this.cache;
         }
         catch {
@@ -21,10 +21,10 @@ export class IndexCache {
     }
     save(result) {
         this.cache = result;
-        const dir = join(this.cachePath, "..");
+        const dir = join(this.cachePath, '..');
         if (!existsSync(dir))
             mkdirSync(dir, { recursive: true });
-        writeFileSync(this.cachePath, JSON.stringify(result), "utf-8");
+        writeFileSync(this.cachePath, JSON.stringify(result), 'utf-8');
     }
     invalidate() {
         this.cache = null;
@@ -32,9 +32,7 @@ export class IndexCache {
             try {
                 rmSync(this.cachePath);
             }
-            catch {
-                /* ignore */
-            }
+            catch { /* ignore */ }
         }
     }
 }

package/dist/modules/indexer/index.js

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

package/dist/modules/indexer/module.js

@@ -1,10 +1,9 @@
-import { dirname } from "path";
-import { Indexer } from "./walker";
-import { IndexCache } from "./cache";
-import { buildProjectProfileLine } from "./project-profile";
-import { t } from "../../i18n/index";
+import { dirname } from 'path';
+import { Indexer } from './walker';
+import { IndexCache } from './cache';
+import { t } from '../../i18n/index';
 export class IndexerModule {
-    name = "indexer";
+    name = 'indexer';
     indexer;
     cache;
     baseDir;
@@ -77,7 +76,7 @@ export class IndexerModule {
         const content = this.formatMap(this.index);
         return {
             content,
-            priority: "normal",
+            priority: 'normal',
             essential: false,
             estimatedTokens: this.estimateTokens(content),
         };
@@ -87,7 +86,7 @@ export class IndexerModule {
     }
     getPlugin() {
         return {
-            name: "indexer",
+            name: 'indexer',
             onSessionStart: () => {
                 this.buildIndex().catch(() => { });
                 this.watch();
@@ -99,77 +98,35 @@ export class IndexerModule {
     }
     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(", ") || "-";
+            .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(", ")}` : "";
+            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);
+            ? `\n${t('indexer.and_more', { count: result.files.length - 100 })}`
+            : '';
         return [
-            `${t("indexer.map_header")} (${this.baseDir})`,
+            `${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")),
+            `${t('indexer.top_directories')}: ${topDirs}`,
+            `${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;
+        ].join('\n');
     }
     getDirectoryCounts(result) {
         const counts = {};
         for (const f of result.files) {
-            const normalized = f.path.replace(/\\/g, "/");
+            const normalized = f.path.replace(/\\/g, '/');
             const dir = dirname(normalized);
-            const key = dir === "." ? "(root)" : dir;
+            const key = dir === '.' ? '(root)' : dir;
             counts[key] = (counts[key] || 0) + 1;
         }
         return counts;
@@ -179,63 +136,53 @@ export class IndexerModule {
     }
     createProjectMapTool() {
         return {
-            name: "project_map",
-            alwaysOn: true,
-            description: t("indexer.project_map_desc"),
+            name: 'project_map',
+            description: t('indexer.project_map_desc'),
             parameters: {
-                type: "object",
+                type: 'object',
                 properties: {
                     action: {
-                        type: "string",
-                        enum: ["summary", "refresh", "find"],
-                        description: t("indexer.project_map_action_desc"),
+                        type: 'string',
+                        enum: ['summary', 'refresh', 'find'],
+                        description: t('indexer.project_map_action_desc'),
                     },
                     query: {
-                        type: "string",
-                        description: t("indexer.project_map_query_desc"),
+                        type: 'string',
+                        description: t('indexer.project_map_query_desc'),
                     },
                 },
-                required: ["action"],
+                required: ['action'],
             },
             handler: async (_ctx, args) => {
-                const action = String(args.action || "summary");
-                if (action === "refresh") {
+                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 }));
+                    const summary = result ? this.indexer.summarize(result) : t('indexer.empty');
+                    return this.makeResult(t('indexer.refreshed', { summary }));
                 }
-                if (action === "find") {
-                    const query = String(args.query || "").toLowerCase();
+                if (action === 'find') {
+                    const query = String(args.query || '').toLowerCase();
                     if (!query)
-                        return { success: false, output: t("tool.invalid_params") };
+                        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 }));
+                        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(", ")}` : "";
+                    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,
-                    }));
+                    }).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"));
+                    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 }));
+                return this.makeResult(t('indexer.summary', { summary }));
             },
         };
     }