micro-models-agent 0.41.0 → 0.41.2

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 { isJsMemberAccess } from "./js-identifiers";
+import { extractFileLikeTokens, stripUrls } from "./js-identifiers";
 /** Generated/cached dirs to skip when scanning for bare file names. */
 const IGNORED_DIRS = new Set([
     "node_modules",
@@ -12,59 +12,6 @@ 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;
@@ -135,8 +82,7 @@ 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();
@@ -178,13 +124,6 @@ export class FactualCheck {
         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 extractFileLikeTokens(stripUrls(text));
     }
 }

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,6 +3,17 @@
  * `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",
@@ -70,3 +81,182 @@ 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,9 +42,7 @@ 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,7 +32,9 @@ 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,9 +1,10 @@
-import { dirname } from 'path';
-import { Indexer } from './walker';
-import { IndexCache } from './cache';
-import { t } from '../../i18n/index';
+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';
+    name = "indexer";
     indexer;
     cache;
     baseDir;
@@ -76,7 +77,7 @@ export class IndexerModule {
         const content = this.formatMap(this.index);
         return {
             content,
-            priority: 'normal',
+            priority: "normal",
             essential: false,
             estimatedTokens: this.estimateTokens(content),
         };
@@ -86,7 +87,7 @@ export class IndexerModule {
     }
     getPlugin() {
         return {
-            name: 'indexer',
+            name: "indexer",
             onSessionStart: () => {
                 this.buildIndex().catch(() => { });
                 this.watch();
@@ -98,35 +99,77 @@ 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 })}`
-            : '';
+            ? `\n${t("indexer.and_more", { count: result.files.length - 100 })}`
+            : "";
+        const duplicates = this.findDuplicateBasenames(result);
         return [
-            `${t('indexer.map_header')} (${this.baseDir})`,
+            `${t("indexer.map_header")} (${this.baseDir})`,
             summary,
-            `${t('indexer.top_directories')}: ${topDirs}`,
-            `${t('indexer.files')}:` + (fileLines.length > 0 ? '' : ' ' + t('indexer.empty')),
+            ...(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');
+        ].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 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;
@@ -136,53 +179,63 @@ export class IndexerModule {
     }
     createProjectMapTool() {
         return {
-            name: 'project_map',
-            description: t('indexer.project_map_desc'),
+            name: "project_map",
+            alwaysOn: true,
+            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');
-                    return this.makeResult(t('indexer.refreshed', { summary }));
+                    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 (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);
-                return this.makeResult(t('indexer.summary', { summary }));
+                const stackLine = buildProjectProfileLine(this.baseDir);
+                const output = summary && stackLine ? `${summary}\n${stackLine}` : summary;
+                return this.makeResult(t("indexer.summary", { summary: output }));
             },
         };
     }