micro-models-agent 0.63.3 → 1.1.0

package/dist/modules/execution/verifier.js

@@ -1,9 +1,9 @@
-import { existsSync } from "fs";
-import { resolve, extname, join } from "path";
+import { existsSync, readFileSync } from "fs";
+import { resolve, extname, dirname, join } from "path";
 import { spawn } from "child_process";
 import { t } from "../../i18n/index";
 import { validateExpertConfig } from "../../config/experts";
-import { findProjectRoot } from "../lsp/project-root";
+import { findProjectRoot, resolveTscCommand } from "../lsp/project-root";
 import { extractFileLikeTokens, stripUrls } from "../hallucination/js-identifiers";
 import { findExistingFile } from "./auditor";
 export class StepVerifier {
@@ -36,8 +36,11 @@ export class StepVerifier {
         if (!existsSync(tsconfigPath)) {
             return { passed: true, message: "No tsconfig.json found — skipping type check" };
         }
+        const tsc = resolveTscCommand(this.baseDir);
+        if (!tsc)
+            return { passed: true, message: "tsc not installed — skipping type check" };
         try {
-            await this.runAsync("npx tsc --noEmit", this.baseDir, 60_000);
+            await this.runAsync(`${tsc} --noEmit`, this.baseDir, 60_000);
             return { passed: true, message: "TypeScript type check passed" };
         }
         catch (e) {
@@ -58,8 +61,11 @@ export class StepVerifier {
         if (!existsSync(tsconfigPath)) {
             return { passed: true, message: "No tsconfig.json found — skipping type check" };
         }
+        const tsc = resolveTscCommand(projectRoot);
+        if (!tsc)
+            return { passed: true, message: "tsc not installed — skipping type check" };
         try {
-            await this.runAsync("npx tsc --noEmit --skipLibCheck", projectRoot, 60_000);
+            await this.runAsync(`${tsc} --noEmit --skipLibCheck`, projectRoot, 60_000);
             return { passed: true, message: "TypeScript type check passed" };
         }
         catch (e) {
@@ -86,6 +92,75 @@ export class StepVerifier {
     async verifyArtifactFiles(files) {
         return Promise.all(files.map((f) => this.checkFileExists(f)));
     }
+    /**
+     * Check a subtask's machine-readable success_criteria BEFORE the merge
+     * decision (Plan 5.1). Supported forms:
+     * - `file-exists:<path>`
+     * - `substring-in-file:<path>:<text>`
+     * - `command-exit-0:<command>`
+     * Anything else is treated as an LLM-only criterion and reported as a
+     * warning (never an error) so the Router still sees it in context.
+     */
+    async verifySubtaskCriteria(subtask) {
+        const errors = [];
+        const warnings = [];
+        const details = [];
+        for (const criterion of subtask.success_criteria || []) {
+            const sep = criterion.indexOf(":");
+            if (sep <= 0) {
+                warnings.push(`Subtask "${subtask.id}": non-machine criterion "${criterion}" (LLM-only)`);
+                continue;
+            }
+            const kind = criterion.slice(0, sep);
+            const rest = criterion.slice(sep + 1);
+            if (kind === "file-exists") {
+                const check = await this.checkFileExists(rest);
+                details.push(check);
+                if (!check.passed)
+                    errors.push(`[${subtask.id}] ${check.message}`);
+                continue;
+            }
+            if (kind === "substring-in-file") {
+                const colon = rest.indexOf(":");
+                if (colon <= 0) {
+                    warnings.push(`Subtask "${subtask.id}": malformed substring-in-file criterion "${criterion}"`);
+                    continue;
+                }
+                const path = rest.slice(0, colon);
+                const needle = rest.slice(colon + 1);
+                const resolved = resolve(this.baseDir, path);
+                if (!existsSync(resolved)) {
+                    const item = { passed: false, message: t("verify.file_not_found", { path }) };
+                    details.push(item);
+                    errors.push(`[${subtask.id}] ${item.message}`);
+                    continue;
+                }
+                const content = readFileSync(resolved, "utf-8");
+                const passed = content.includes(needle);
+                details.push({ passed, message: `substring "${needle}" in ${path}: ${passed}` });
+                if (!passed)
+                    errors.push(`[${subtask.id}] "${needle}" not found in ${path}`);
+                continue;
+            }
+            if (kind === "command-exit-0") {
+                try {
+                    await this.runAsync(rest, this.baseDir, 30_000);
+                    details.push({ passed: true, message: `command ok: ${rest}` });
+                }
+                catch (e) {
+                    const item = {
+                        passed: false,
+                        message: `command failed: ${rest} (${String(e.message).slice(0, 200)})`,
+                    };
+                    details.push(item);
+                    errors.push(`[${subtask.id}] ${item.message}`);
+                }
+                continue;
+            }
+            warnings.push(`Subtask "${subtask.id}": unknown criterion kind "${kind}" (LLM-only)`);
+        }
+        return { errors, warnings, details };
+    }
     async verifyMoEManifest(plan, config, allToolTags) {
         const errors = [];
         const warnings = [];
@@ -108,6 +183,11 @@ export class StepVerifier {
                     errors.push(check.message);
                 }
             }
+            // Machine-readable success_criteria (Plan 5.1) — checked before merge.
+            const criteria = await this.verifySubtaskCriteria(sub);
+            errors.push(...criteria.errors);
+            warnings.push(...criteria.warnings);
+            details.push(...criteria.details);
         }
         return {
             success: errors.length === 0,
@@ -161,8 +241,15 @@ export class StepVerifier {
     async validateSyntax(filePath) {
         const ext = extname(filePath);
         if (ext === ".ts" || ext === ".tsx" || ext === ".cts" || ext === ".mts") {
+            // Локальный tsc, а не npx: npx без локального пакета уходит в сеть и
+            // висит секундами. Нет tsc — пропускаем проверку (как и раньше «not
+            // found → true»), но мгновенно.
+            const tsc = resolveTscCommand(dirname(filePath));
+            if (!tsc)
+                return true;
             try {
-                await this.runAsync(`npx tsc --noEmit --skipLibCheck ${filePath}`, this.baseDir, 10000);
+                // Quote the path — commands run through a shell and break on spaces.
+                await this.runAsync(`${tsc} --noEmit --skipLibCheck "${filePath}"`, this.baseDir, 20000);
                 return true;
             }
             catch (err) {
@@ -180,7 +267,7 @@ export class StepVerifier {
         }
         if (ext === ".js" || ext === ".jsx" || ext === ".cjs" || ext === ".mjs") {
             try {
-                await this.runAsync(`node --check ${filePath}`, this.baseDir, 5000);
+                await this.runAsync(`node --check "${filePath}"`, this.baseDir, 5000);
                 return true;
             }
             catch {

package/dist/modules/execution/windows-commands.js

@@ -16,6 +16,17 @@
 const FORBIDDEN_COMMANDS = new Set([
     "grep",
     "sed",
+    "awk",
+    "uniq",
+    "xargs",
+    "cut",
+    "tr",
+    "basename",
+    "dirname",
+    "export",
+    "source",
+    "sleep",
+    "env",
     "ls",
     "find",
     "rm",

package/dist/modules/hallucination/confidence.js

@@ -1,6 +1,12 @@
 import { t } from "../../i18n/index";
 const MIN_CHARS = 1;
-const MIN_WORDS = 5;
+/** Both responses must be this long before repetition applies — a short
+ *  honest answer ("Done." / "The build passes.") repeated twice is not
+ *  degeneration and must not burn a hallucination retry. */
+const MIN_REPEAT_CHARS = 120;
+const MIN_REPEAT_WORDS = 20;
+/** Word-overlap above this threshold counts as repetition (was 0.5). */
+const REPEAT_OVERLAP_THRESHOLD = 0.8;
 export class ConfidenceCheck {
     previousResponse = "";
     setPreviousResponse(response) {
@@ -14,25 +20,28 @@ export class ConfidenceCheck {
                 reason: t("hall.short_response"),
             };
         }
-        // Language-agnostic: very short response with no structured content
+        // Short replies are not flagged: a greeting, a terse acknowledgement or a
+        // one-line confirmation is a valid answer. Real truncation is caught by the
+        // provider's finish_reason ("length"), and emptiness by the retry above.
         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",
-                kind: "short",
-                reason: t("hall.short_response"),
-            };
-        }
-        // Language-agnostic: repetition detection via word overlap
+        // Language-agnostic: repetition detection via word overlap. Only flag when
+        // BOTH the current and the previous response are substantive — a short
+        // answer after a long one (or two short answers) is not a loop.
         if (this.previousResponse) {
-            const overlap = this.calculateOverlap(response, this.previousResponse);
-            if (overlap > 0.5) {
-                return {
-                    status: "retry",
-                    kind: "repetition",
-                    reason: t("hall.repetitive", { pct: Math.round(overlap * 100) }),
-                };
+            const prevWords = this.previousResponse.split(/\s+/).filter(Boolean).length;
+            const bothSubstantive = response.length >= MIN_REPEAT_CHARS &&
+                this.previousResponse.length >= MIN_REPEAT_CHARS &&
+                wordCount >= MIN_REPEAT_WORDS &&
+                prevWords >= MIN_REPEAT_WORDS;
+            if (bothSubstantive) {
+                const overlap = this.calculateOverlap(response, this.previousResponse);
+                if (overlap > REPEAT_OVERLAP_THRESHOLD) {
+                    return {
+                        status: "retry",
+                        kind: "repetition",
+                        reason: t("hall.repetitive", { pct: Math.round(overlap * 100) }),
+                    };
+                }
             }
         }
         // Language-agnostic: very low word diversity (same words repeated)
@@ -56,11 +65,15 @@ export class ConfidenceCheck {
         return { status: "pass" };
     }
     calculateOverlap(a, b) {
-        const wordsA = new Set(a.toLowerCase().split(/\s+/));
-        const wordsB = b.toLowerCase().split(/\s+/);
-        if (wordsB.length === 0)
+        const wordsA = new Set(a.toLowerCase().split(/\s+/).filter(Boolean));
+        const wordsB = new Set(b.toLowerCase().split(/\s+/).filter(Boolean));
+        const smaller = Math.min(wordsA.size, wordsB.size);
+        if (smaller === 0)
             return 0;
-        const matches = wordsB.filter((w) => wordsA.has(w));
-        return matches.length / wordsB.length;
+        let matches = 0;
+        for (const w of wordsB)
+            if (wordsA.has(w))
+                matches++;
+        return matches / smaller;
     }
 }

package/dist/modules/hallucination/consistency.js

@@ -7,6 +7,9 @@ export class ConsistencyCheck {
     }
     trackCreatedFile(path) {
         this.createdFiles.add(path);
+        // A delete followed by a re-create un-deletes the file — otherwise
+        // wasFileDeleted() keeps reporting it as gone after delete+create.
+        this.deletedFiles.delete(path);
     }
     trackDeletedFile(path) {
         this.deletedFiles.add(path);

package/dist/modules/hallucination/detector.js

@@ -7,11 +7,15 @@ export class HallucinationDetector {
     confidence;
     factual;
     judge;
-    constructor(baseDir, llmProvider) {
+    constructor(baseDir, llmProvider, options) {
         this.consistency = new ConsistencyCheck();
         this.confidence = new ConfidenceCheck();
         this.factual = baseDir ? new FactualCheck(baseDir) : null;
-        this.judge = llmProvider ? new LLMJudge(llmProvider) : null;
+        // The judge is opt-out: it only runs when a provider is supplied AND the
+        // caller did not explicitly disable it (the main agent disables it by
+        // default via config.hallucination.judge.enabled).
+        const judgeEnabled = options?.judgeEnabled ?? true;
+        this.judge = llmProvider && judgeEnabled ? new LLMJudge(llmProvider) : null;
     }
     getConsistencyCheck() {
         return this.consistency;
@@ -28,7 +32,8 @@ export class HallucinationDetector {
         if (confidenceResult.status === "retry" || confidenceResult.status === "block") {
             return confidenceResult;
         }
-        const factualResult = this.factual?.validate(response);
+        const deletedFiles = new Set(this.consistency.getDeletedFiles());
+        const factualResult = this.factual?.validate(response, deletedFiles);
         if (factualResult && factualResult.status !== "pass") {
             return factualResult;
         }

package/dist/modules/hallucination/factual.js

@@ -32,12 +32,17 @@ export class FactualCheck {
         for (const f of files)
             this.knownFiles.add(f);
     }
-    validate(response) {
+    validate(response, deletedFiles) {
         const filePaths = this.extractFilePaths(response);
         if (filePaths.length === 0)
             return { status: "pass" };
+        const deletedBasenames = deletedFiles
+            ? new Set([...deletedFiles].map((p) => p.split(/[/\\]/).pop() ?? p))
+            : undefined;
         const nonExistent = [];
         for (const fp of filePaths) {
+            if (deletedBasenames?.has(fp))
+                continue;
             if (!this.pathExists(fp)) {
                 nonExistent.push(fp);
             }
@@ -81,14 +86,28 @@ export class FactualCheck {
      * non-word char and `.`), so dotfiles (.prettierrc.json, .env, …) are
      * extracted as "prettierrc.json". Try the dot-prefixed basename too before
      * declaring the file missing. "src/config.json" also yields
-     * "src/.config.json".
+     * "src/.config.json". For paths like "mma/index-cache.json", also try
+     * ".mma/index-cache.json" (dot-prefixed parent directories).
      */
     dotfileVariants(fp) {
-        const idx = Math.max(fp.lastIndexOf("/"), fp.lastIndexOf("\\"));
-        const base = idx >= 0 ? fp.slice(idx + 1) : fp;
-        if (base.startsWith("."))
-            return [fp];
-        return idx >= 0 ? [fp, `${fp.slice(0, idx + 1)}.${base}`] : [fp, `.${fp}`];
+        const variants = [fp];
+        const sep = fp.includes("\\") ? "\\" : "/";
+        const parts = fp.split(sep);
+        // Try dot-prefixing the basename (existing logic)
+        const base = parts[parts.length - 1];
+        if (!base.startsWith(".")) {
+            const withDotBase = [...parts.slice(0, -1), `.${base}`].join(sep);
+            variants.push(withDotBase);
+        }
+        // Try dot-prefixing each parent directory component
+        for (let i = 0; i < parts.length - 1; i++) {
+            if (!parts[i].startsWith(".")) {
+                const dotted = [...parts.slice(0, i), `.${parts[i]}`, ...parts.slice(i + 1)].join(sep);
+                if (!variants.includes(dotted))
+                    variants.push(dotted);
+            }
+        }
+        return variants;
     }
     bareNameExists(name) {
         for (const cand of this.dotfileVariants(name)) {

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

@@ -56,17 +56,24 @@ Reply with ONLY valid JSON, no other text:
     }
     async askJudge(messages) {
         let text = "";
+        const controller = new AbortController();
         let timer;
         const consume = (async () => {
-            for await (const chunk of this.provider.chat(messages, [])) {
+            for await (const chunk of this.provider.chat(messages, [], controller.signal)) {
                 if (chunk.type === "text" && chunk.content) {
                     text += chunk.content;
                 }
             }
             return text;
         })();
+        // The timeout can settle the race while the background stream is still
+        // running; its later rejection must not surface as an unhandled rejection.
+        consume.catch(() => { });
         const timeout = new Promise((_, reject) => {
-            timer = setTimeout(() => reject(new Error("LLM judge timed out")), JUDGE_TIMEOUT_MS);
+            timer = setTimeout(() => {
+                controller.abort();
+                reject(new Error("LLM judge timed out"));
+            }, JUDGE_TIMEOUT_MS);
         });
         try {
             return await Promise.race([consume, timeout]);
@@ -74,6 +81,9 @@ Reply with ONLY valid JSON, no other text:
         finally {
             if (timer)
                 clearTimeout(timer);
+            // Abort the background stream on the success path too, so a judge that
+            // resolved early never keeps streaming in the background.
+            controller.abort();
         }
     }
     parseVerdict(text) {

package/dist/modules/indexer/map-command.js

@@ -0,0 +1,35 @@
+import { t } from "../../i18n/index";
+/**
+ * Shared implementation of the project-map command used by both `mma map`
+ * (CLI) and `/map` (REPL): summary (the exact text injected into the system
+ * prompt), refresh, and find.
+ */
+export async function runMapAction(module, action, query) {
+    const summary = async () => {
+        const result = await module.buildIndex();
+        if (!result)
+            return { ok: false, output: t("indexer.not_indexed") };
+        return { ok: true, output: module.getPromptMap() ?? t("indexer.not_indexed") };
+    };
+    switch (action) {
+        case "refresh": {
+            const result = await module.refresh();
+            if (!result)
+                return { ok: false, output: t("indexer.not_indexed") };
+            return {
+                ok: true,
+                output: `${t("map.refreshed")}\n${module.getPromptMap() ?? ""}`.trimEnd(),
+            };
+        }
+        case "find": {
+            const q = (query ?? "").trim();
+            if (!q)
+                return { ok: false, output: t("map.find_usage") };
+            await module.buildIndex();
+            return { ok: true, output: module.formatFind(q) };
+        }
+        case "summary":
+        default:
+            return summary();
+    }
+}

package/dist/modules/indexer/map-select.js

@@ -0,0 +1,87 @@
+import { toForwardSlash } from "../../tools/path-utils";
+import { isCodeLanguage } from "./symbols";
+/** Lockfiles and generated manifests: no structural value in the map. */
+const NOISE_BASENAMES = new Set([
+    "package-lock.json",
+    "bun.lock",
+    "bun.lockb",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "cargo.lock",
+    "go.sum",
+    "composer.lock",
+    "poetry.lock",
+]);
+export function isNoiseFile(file) {
+    const base = toForwardSlash(file.path).split("/").pop()?.toLowerCase() ?? "";
+    return NOISE_BASENAMES.has(base);
+}
+function isTestFile(path) {
+    return (path.startsWith("test/") ||
+        path.startsWith("tests/") ||
+        path.includes("/test/") ||
+        path.includes("/tests/") ||
+        path.includes("__tests__/") ||
+        /\.(test|spec)\.[a-z0-9]+$/i.test(path));
+}
+/** Lower rank = more useful for understanding the project structure. */
+function rank(file) {
+    const path = toForwardSlash(file.path).toLowerCase();
+    if (isTestFile(path))
+        return 1;
+    if (isCodeLanguage(file.language))
+        return 0;
+    return 2;
+}
+/** Top-level segment of a path (`src/core/x.ts` → `src`; root file → its name). */
+function topDir(path) {
+    const normalized = toForwardSlash(path);
+    const slash = normalized.indexOf("/");
+    return slash >= 0 ? normalized.slice(0, slash) : normalized;
+}
+/** How many source-code files live under each top-level directory. */
+function codeCountByTopDir(files) {
+    const counts = new Map();
+    for (const file of files) {
+        if (isNoiseFile(file) || rank(file) !== 0)
+            continue;
+        const dir = topDir(file.path);
+        counts.set(dir, (counts.get(dir) ?? 0) + 1);
+    }
+    return counts;
+}
+/**
+ * Pick the files to list in the project-map prompt block.
+ *
+ * The index is built by an arbitrary `readdir` walk, so a naive
+ * `files.slice(0, N)` can end up listing only docs, config and tests while the
+ * actual source tree (`src/`) never appears — the model then sees a "project
+ * map" with no code in it. The selection:
+ *   1. drops lockfile noise,
+ *   2. ranks source before tests, tests before docs/config,
+ *   3. within a rank, puts directories with the most source files first (the
+ *      densest code root is almost always the real source tree — no directory
+ *      names hardcoded),
+ *   4. then shallower paths, then alphabetical — deterministic so the block
+ *      does not change between turns and the prefix KV-cache survives.
+ */
+export function selectMapFiles(files, max) {
+    const codeByDir = codeCountByTopDir(files);
+    return files
+        .filter((file) => !isNoiseFile(file))
+        .sort((a, b) => {
+        const rankDiff = rank(a) - rank(b);
+        if (rankDiff !== 0)
+            return rankDiff;
+        const densityDiff = (codeByDir.get(topDir(b.path)) ?? 0) - (codeByDir.get(topDir(a.path)) ?? 0);
+        if (densityDiff !== 0)
+            return densityDiff;
+        const pathA = toForwardSlash(a.path);
+        const pathB = toForwardSlash(b.path);
+        const depthDiff = pathA.split("/").length - pathB.split("/").length;
+        if (depthDiff !== 0)
+            return depthDiff;
+        return pathA < pathB ? -1 : pathA > pathB ? 1 : 0;
+    })
+        .slice(0, max);
+}

package/dist/modules/indexer/module.js

@@ -1,8 +1,13 @@
 import { dirname } from "path";
 import { Indexer } from "./walker";
 import { IndexCache } from "./cache";
+import { selectMapFiles } from "./map-select";
 import { buildProjectProfileLine } from "./project-profile";
 import { t } from "../../i18n/index";
+import { toForwardSlash } from "../../tools/path-utils";
+import { estimateTokens } from "../../llm/token-counter";
+/** Max files listed in the project-map prompt block (code first; see map-select). */
+const MAP_FILE_LIMIT = 80;
 export class IndexerModule {
     name = "indexer";
     indexer;
@@ -47,6 +52,25 @@ export class IndexerModule {
             return path.includes(q) || f.exports.some((e) => e.toLowerCase().includes(q));
         });
     }
+    /** Human/model-readable result of a `find` query (shared by the tool and `mma map`). */
+    formatFind(query) {
+        const matches = this.find(query);
+        if (matches.length === 0) {
+            return t("indexer.no_matches", { query });
+        }
+        const lines = matches
+            .map((f) => {
+            const path = toForwardSlash(f.path);
+            const exports = f.exports.length > 0 ? `: ${f.exports.join(", ")}` : "";
+            return `- ${path}${exports}`;
+        })
+            .join("\n");
+        return t("indexer.find_results", { count: matches.length, results: lines });
+    }
+    /** The exact project-map text injected into the system prompt (null if not indexed). */
+    getPromptMap() {
+        return this.index ? this.formatMap(this.index) : null;
+    }
     watch() {
         this.unwatch();
         try {
@@ -80,6 +104,7 @@ export class IndexerModule {
             priority: "normal",
             essential: false,
             estimatedTokens: this.estimateTokens(content),
+            kind: "project-map",
         };
     }
     getToolDefinitions() {
@@ -106,13 +131,14 @@ export class IndexerModule {
             .slice(0, 10)
             .map(([dir, count]) => `${dir} (${count})`)
             .join(", ") || "-";
-        const fileLines = result.files.slice(0, 100).map((f) => {
-            const path = f.path.replace(/\\/g, "/");
+        const listed = selectMapFiles(result.files, MAP_FILE_LIMIT);
+        const fileLines = listed.map((f) => {
+            const path = toForwardSlash(f.path);
             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 more = result.files.length > listed.length
+            ? `\n${t("indexer.and_more", { count: result.files.length - listed.length })}`
             : "";
         const duplicates = this.findDuplicateBasenames(result);
         return [
@@ -137,7 +163,7 @@ export class IndexerModule {
     findDuplicateBasenames(result) {
         const byDir = {};
         for (const f of result.files) {
-            const path = f.path.replace(/\\/g, "/");
+            const path = toForwardSlash(f.path);
             const idx = path.lastIndexOf("/");
             const dir = idx >= 0 ? path.slice(0, idx) : "";
             const name = path.slice(idx + 1);
@@ -167,7 +193,7 @@ export class IndexerModule {
     getDirectoryCounts(result) {
         const counts = {};
         for (const f of result.files) {
-            const normalized = f.path.replace(/\\/g, "/");
+            const normalized = toForwardSlash(f.path);
             const dir = dirname(normalized);
             const key = dir === "." ? "(root)" : dir;
             counts[key] = (counts[key] || 0) + 1;
@@ -175,7 +201,7 @@ export class IndexerModule {
         return counts;
     }
     estimateTokens(content) {
-        return Math.ceil(content.length / 4);
+        return estimateTokens(content);
     }
     createProjectMapTool() {
         return {
@@ -211,21 +237,7 @@ export class IndexerModule {
                     const query = String(args.query || "").toLowerCase();
                     if (!query)
                         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 }));
-                    }
-                    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,
-                    }));
+                    return this.makeResult(this.formatFind(query));
                 }
                 if (!this.index) {
                     await this.buildIndex();