scai 0.1.178 → 1.0.0

package/dist/search/SearchOrchestrator.js

@@ -0,0 +1,928 @@
+/**
+ * Runs all repo search behind one discovery-only orchestrator.
+ *
+ * Why this file exists:
+ * - search used to be split across explicit target resolution, semantic bootstrap, and planner fallback
+ * - that mixed "what did we find" with downstream "what should we act on"
+ * - this file keeps search output in one packet so focus and execution can derive their own state later
+ *
+ * Boundary:
+ * - this file may resolve files, folders, symbols, snippets, and raw pattern hits
+ * - this file must not set `selectedFiles`, `candidateFiles`, or execution policy state
+ * - callers may keep temporary compatibility fields like `relatedFiles`, but only after search returns
+ */
+import fs from "fs";
+import path from "path";
+import { execFileSync } from "child_process";
+import fg from "fast-glob";
+import { getDbForRepo } from "../db/client.js";
+import { plannerSearchFiles, resolveSymbolRows, resolveSymbolRowsByPattern, semanticSearchFiles, } from "../db/fileIndex.js";
+import { IGNORED_EXTENSIONS } from "../fileRules/ignoredExtensions.js";
+import { isPathIgnoredByFolderGlobs } from "../fileRules/ignoredPaths.js";
+import { isExplicitRefCandidate, queryLooksLikeOperatorPattern, queryNeedsRegexMode, } from "../fileRules/queryTokenRules.js";
+import { compileSearchQuery } from "../utils/compileSearchQuery.js";
+import { extractFileReferences } from "../utils/extractFileReferences.js";
+import { getContextExecutionPath, mapCanonicalPathToExecutionPath, } from "../utils/repoIdentity.js";
+import { logInputOutput } from "../utils/promptLogHelper.js";
+import { buildMethodSelectionRetrievalQuery, isMethodSelectionRetrievalQuery, scoreCandidateFiles, } from "./sharedRankingPolicy.js";
+import { isVerifyFocusQueryText } from "../utils/verifyFocusPreference.js";
+const DEFAULT_LIMIT = 8;
+export class SearchOrchestrator {
+    async run(args) {
+        return this.runDbSearch(args);
+    }
+    async runDbSearch(args) {
+        const query = String(args.query ?? "").trim();
+        const mode = this.resolveMode(args);
+        const result = createEmptySearchResult(mode, [], "db");
+        if (!query) {
+            return result;
+        }
+        if (mode === "exact-target") {
+            const exact = await this.runExactTargetSearchWithSemanticFallback(args.context, query, args.plannerQuery, args.limit ?? DEFAULT_LIMIT);
+            logInputOutput("SearchOrchestrator", "output", exact);
+            return exact;
+        }
+        if (mode === "sentence-fragment") {
+            const fragment = await this.runSentenceFragmentSearch(args.context, query);
+            logInputOutput("SearchOrchestrator", "output", fragment);
+            return fragment;
+        }
+        if (mode === "operator-pattern") {
+            const pattern = await this.runOperatorPatternSearchWithSemanticFallback(args.context, query, args.plannerQuery, args.limit ?? DEFAULT_LIMIT);
+            logInputOutput("SearchOrchestrator", "output", pattern);
+            return pattern;
+        }
+        const semantic = await this.runSemanticRetrieval(args.context, query, args.plannerQuery, args.limit ?? DEFAULT_LIMIT);
+        logInputOutput("SearchOrchestrator", "output", semantic);
+        return semantic;
+    }
+    async runRegexSearch(args) {
+        const result = createEmptySearchResult("regex-execution", ["regex-searcher", "result-merger-and-ranker"], "regex");
+        result.regexSpec = args.spec;
+        const repoRoot = getContextExecutionPath(args.context);
+        if (!repoRoot || !fs.existsSync(repoRoot)) {
+            result.failure = {
+                status: "failed",
+                failureClass: "scope-missing",
+                message: "Repo root is missing for regex search.",
+            };
+            return result;
+        }
+        const flags = normalizeRegexFlags(args.spec.flags);
+        const regex = safeCreateRegex(args.spec.pattern, flags);
+        if (!regex) {
+            result.failure = {
+                status: "failed",
+                failureClass: "invalid-regex",
+                message: "Regex pattern could not be compiled.",
+                pattern: args.spec.pattern,
+                flags,
+            };
+            return result;
+        }
+        const scopedFiles = this.resolveRegexScopeFiles(args.context, args.spec.scope, repoRoot);
+        if (scopedFiles.length === 0) {
+            result.failure = {
+                status: "failed",
+                failureClass: "scope-missing",
+                message: "Regex search scope did not resolve to any searchable files.",
+                pattern: args.spec.pattern,
+                flags,
+            };
+            return result;
+        }
+        const pathMatches = args.spec.target === "content"
+            ? []
+            : collectRegexPathMatches(scopedFiles, regex, repoRoot);
+        const contentMatches = args.spec.target === "path"
+            ? []
+            : collectRegexContentMatches(scopedFiles, regex);
+        const fileCandidates = dedupeSearchResults([
+            ...pathMatches.map(match => buildFsSearchResult(match.path)),
+            ...contentMatches.map(match => buildFsSearchResult(match.path)),
+        ]).slice(0, args.limit ?? DEFAULT_LIMIT);
+        result.patternMatches = contentMatches;
+        result.fileCandidates = fileCandidates;
+        result.resolvedFolders = dedupeStrings(args.spec.scope?.folders ?? []);
+        if (pathMatches.length === 0 && contentMatches.length === 0) {
+            result.failure = {
+                status: "failed",
+                failureClass: "no-match",
+                message: "Regex search found no matches in scope.",
+                pattern: args.spec.pattern,
+                flags,
+            };
+        }
+        return result;
+    }
+    runDirectoryListing(args) {
+        const result = createEmptySearchResult("directory-listing", ["directory-listing"], "list-directory");
+        const repoRoot = getContextExecutionPath(args.context);
+        if (!repoRoot || !fs.existsSync(repoRoot)) {
+            result.failure = {
+                status: "failed",
+                failureClass: "scope-missing",
+                message: "Repo root is missing for directory listing.",
+            };
+            return result;
+        }
+        const folderPath = resolveDirectoryListingTarget(args.context, args.query, repoRoot);
+        if (!folderPath) {
+            result.failure = {
+                status: "failed",
+                failureClass: "scope-missing",
+                message: "Could not resolve a folder to list.",
+            };
+            return result;
+        }
+        result.resolvedFolders = [folderPath];
+        result.directoryEntries = collectDirectDirectoryEntries(folderPath);
+        result.folderCandidates = [folderPath];
+        return result;
+    }
+    /**
+     * Keeps exact-target routing narrow, but avoids dead ends when nothing resolves at all.
+     * Example: "/resume" stays an explicit ref first, then falls back to semantic retrieval only if exact-target found nothing.
+     */
+    async runExactTargetSearchWithSemanticFallback(context, query, plannerQuery, limit) {
+        const exact = this.runExactTargetSearch(context, query);
+        if (!shouldFallbackFromExactTarget(exact)) {
+            return exact;
+        }
+        const semantic = await this.runSemanticRetrieval(context, query, plannerQuery, limit);
+        exact.stagesRun.push("fallback-semantic-retriever");
+        exact.fallbackUsed = true;
+        exact.fileCandidates = semantic.fileCandidates;
+        exact.folderCandidates = semantic.folderCandidates;
+        exact.symbolCandidates = semantic.symbolCandidates;
+        exact.fragmentMatches = semantic.fragmentMatches;
+        exact.patternMatches = semantic.patternMatches;
+        exact.directoryEntries = semantic.directoryEntries;
+        exact.failure = semantic.failure;
+        return exact;
+    }
+    /**
+     * Keeps true operator queries narrow, but broadens once when the lane found nothing useful.
+     * Example: a regex-like snippet can fall back to semantic retrieval only after zero matches.
+     */
+    async runOperatorPatternSearchWithSemanticFallback(context, query, plannerQuery, limit) {
+        const pattern = await this.runOperatorPatternSearch(context, query);
+        if (!shouldFallbackFromOperatorPattern(pattern)) {
+            return pattern;
+        }
+        const semantic = await this.runSemanticRetrieval(context, query, plannerQuery, limit);
+        pattern.stagesRun.push("fallback-semantic-retriever");
+        pattern.fallbackUsed = true;
+        pattern.fileCandidates = semantic.fileCandidates;
+        pattern.folderCandidates = semantic.folderCandidates;
+        pattern.symbolCandidates = semantic.symbolCandidates;
+        pattern.fragmentMatches = semantic.fragmentMatches;
+        pattern.directoryEntries = semantic.directoryEntries;
+        pattern.failure = semantic.failure;
+        return pattern;
+    }
+    resolveMode(args) {
+        if (args.mode && args.mode !== "auto") {
+            return args.mode;
+        }
+        const query = String(args.query ?? "").trim();
+        const intent = args.context.analysis?.intent;
+        const quotedFragments = extractQuotedFragments(query);
+        const explicitFileRefs = extractFileReferences(query);
+        // Keep pure quoted-code lookups on fragment search even when intent extraction found symbol-like tokens.
+        // Example: "const currentQuestionId = ..." should search for matching lines, not chase `currentQuestionId` as an explicit target.
+        if (quotedFragments.length > 0 && explicitFileRefs.length === 0) {
+            return "sentence-fragment";
+        }
+        if ((intent?.targetFiles?.length ?? 0) > 0 ||
+            (intent?.targetSymbols?.length ?? 0) > 0 ||
+            explicitFileRefs.length > 0) {
+            return "exact-target";
+        }
+        if (quotedFragments.length > 0) {
+            return "sentence-fragment";
+        }
+        if (queryLooksLikeOperatorPattern(query)) {
+            return "operator-pattern";
+        }
+        return "semantic-retrieval";
+    }
+    runExactTargetSearch(context, query) {
+        const stagesRun = ["explicit-target-resolver", "result-merger-and-ranker"];
+        const repoRoot = getContextExecutionPath(context);
+        const result = createEmptySearchResult("exact-target", stagesRun, "db");
+        if (!repoRoot || !fs.existsSync(repoRoot)) {
+            return result;
+        }
+        const allTargetRefs = dedupeStrings([
+            ...(context.analysis?.intent?.targetFiles ?? []),
+            ...extractFileReferences(query),
+        ]);
+        const rawTargetRefs = allTargetRefs.filter(shouldTreatAsExplicitRef);
+        const symbolRefs = dedupeStrings(context.analysis?.intent?.targetSymbols ?? []);
+        const fileRows = [];
+        const resolvedFolders = [];
+        const unresolvedRefs = new Set(allTargetRefs.filter(ref => !shouldTreatAsExplicitRef(ref)));
+        const ambiguousRefs = new Set();
+        for (const rawRef of rawTargetRefs) {
+            const resolution = resolvePathReference(rawRef, repoRoot);
+            if (resolution.kind === "file" && resolution.path) {
+                fileRows.push(buildFsSearchResult(resolution.path));
+                continue;
+            }
+            if (resolution.kind === "folder" && resolution.path) {
+                resolvedFolders.push(resolution.path);
+                for (const childFile of collectSearchablePaths(resolution.path, {
+                    includeIgnoredExtensions: true,
+                    allowIgnoredPaths: true,
+                })) {
+                    fileRows.push(buildFsSearchResult(childFile));
+                }
+                continue;
+            }
+            if (resolution.kind === "ambiguous") {
+                ambiguousRefs.add(rawRef);
+                continue;
+            }
+            unresolvedRefs.add(rawRef);
+        }
+        const db = getDbForRepo();
+        const resolvedSymbols = [];
+        const symbolCandidates = [];
+        for (const symbol of symbolRefs) {
+            const rows = resolveSymbolRowsWithFallback(db, symbol)
+                .map(row => this.remapSearchResult(row, context));
+            if (rows.length === 1) {
+                resolvedSymbols.push({ symbol, filePath: rows[0].path });
+                fileRows.push(rows[0]);
+            }
+            else if (rows.length > 1) {
+                ambiguousRefs.add(symbol);
+                for (const row of rows) {
+                    symbolCandidates.push({ symbol, filePath: row.path });
+                }
+            }
+            else {
+                unresolvedRefs.add(symbol);
+            }
+        }
+        result.resolvedFiles = dedupeSearchResults(fileRows);
+        result.resolvedFolders = dedupeStrings(resolvedFolders);
+        result.resolvedSymbols = dedupeSymbolResolutions(resolvedSymbols);
+        result.unresolvedRefs = Array.from(unresolvedRefs);
+        result.ambiguousRefs = Array.from(ambiguousRefs);
+        result.fileCandidates = dedupeSearchResults([
+            ...result.resolvedFiles,
+            ...dedupeSearchResults(fileRows).filter(item => !result.resolvedFiles.some(resolved => resolved.path === item.path)),
+        ]);
+        result.folderCandidates = result.resolvedFolders;
+        result.symbolCandidates = dedupeSymbolResolutions(symbolCandidates);
+        return result;
+    }
+    async runSemanticRetrieval(context, query, plannerQuery, limit) {
+        const result = createEmptySearchResult("semantic-retrieval", ["semantic-retriever"], "db");
+        const seen = new Map();
+        const addResults = (rows) => {
+            for (const row of rows.map(item => this.remapSearchResult(item, context))) {
+                if (!seen.has(row.path)) {
+                    seen.set(row.path, row);
+                }
+            }
+        };
+        if (plannerQuery?.trim()) {
+            addResults(await plannerSearchFiles(query, plannerQuery, limit));
+        }
+        else {
+            addResults(await semanticSearchFiles(query, limit, context.analysis?.intent ?? {}));
+            const orderedQuestionQueries = collectOrderedQuestionQueries(context, query);
+            for (const orderedQuery of orderedQuestionQueries) {
+                addResults(await plannerSearchFiles(query, orderedQuery, Math.min(limit, 6)));
+            }
+            const methodSelectionQuery = buildMethodSelectionRetrievalQuery(query);
+            if (isMethodSelectionRetrievalQuery(query) && methodSelectionQuery) {
+                addResults(await plannerSearchFiles(query, methodSelectionQuery, 12));
+                const pathSupplement = collectMethodSelectionPathSupplement(context, query, new Set(seen.keys()));
+                addResults(pathSupplement);
+            }
+            const pathSupplementQueries = [
+                ...(isVerifyFocusQueryText(query) ? [query] : []),
+                ...orderedQuestionQueries,
+            ];
+            const pathSupplement = collectScopedPathSupplements(context, pathSupplementQueries, new Set(seen.keys()));
+            addResults(pathSupplement);
+        }
+        if (seen.size === 0) {
+            const fallbackRows = await this.runFallbackContentScan(context, plannerQuery?.trim() || query, query);
+            if (fallbackRows.length > 0) {
+                result.stagesRun.push("fallback-content-scanner");
+                result.fallbackUsed = true;
+                addResults(fallbackRows);
+            }
+        }
+        result.stagesRun.push("result-merger-and-ranker");
+        result.fileCandidates = rankMergedSearchResults(Array.from(seen.values()), query).slice(0, limit);
+        return result;
+    }
+    async runSentenceFragmentSearch(context, query) {
+        const result = createEmptySearchResult("sentence-fragment", [
+            "sentence-fragment-resolver",
+            "result-merger-and-ranker",
+        ], "db");
+        const repoRoot = getContextExecutionPath(context);
+        if (!repoRoot || !fs.existsSync(repoRoot)) {
+            return result;
+        }
+        const fragments = extractQuotedFragments(query);
+        const matches = new Map();
+        const files = [];
+        for (const fragment of fragments) {
+            const fragmentMatches = await searchContentMatches({
+                repoRoot,
+                query: fragment,
+                fixed: true,
+            });
+            for (const match of fragmentMatches) {
+                const key = `${match.path}:${match.line}:${match.column}`;
+                if (!matches.has(key)) {
+                    matches.set(key, match);
+                }
+            }
+        }
+        for (const match of matches.values()) {
+            files.push(buildFsSearchResult(match.path));
+        }
+        result.fragmentMatches = Array.from(matches.values());
+        result.fileCandidates = dedupeSearchResults(files);
+        result.fallbackUsed = result.fragmentMatches.length > 0 && !isRipgrepAvailable();
+        return result;
+    }
+    async runOperatorPatternSearch(context, query) {
+        const result = createEmptySearchResult("operator-pattern", [
+            "operator-pattern-searcher",
+            "result-merger-and-ranker",
+        ], "db");
+        const repoRoot = getContextExecutionPath(context);
+        if (!repoRoot || !fs.existsSync(repoRoot)) {
+            return result;
+        }
+        const compiled = compileSearchQuery({
+            query,
+            intent: context.analysis?.intent,
+            mode: queryNeedsRegexMode(query) ? "regex" : "auto",
+        });
+        const matches = await searchContentMatches({
+            repoRoot,
+            query: compiled.regex.enabled ? compiled.regex.terms[0] ?? query : query,
+            fixed: !compiled.regex.enabled && !query.includes("|"),
+        });
+        result.patternMatches = matches;
+        result.fileCandidates = dedupeSearchResults(matches.map(match => buildFsSearchResult(match.path)));
+        result.fallbackUsed = matches.length > 0 && !isRipgrepAvailable();
+        return result;
+    }
+    async runFallbackContentScan(context, query, rankingQuery) {
+        const repoRoot = getContextExecutionPath(context);
+        if (!repoRoot || !fs.existsSync(repoRoot))
+            return [];
+        const compiled = compileSearchQuery({ query, mode: "auto", intent: context.analysis?.intent });
+        const fallbackTerms = compiled.literal.terms.filter(term => term.length >= 2);
+        if (fallbackTerms.length === 0)
+            return [];
+        const scored = scoreCandidateFiles(collectSearchablePaths(repoRoot).filter(filePath => {
+            const content = safeReadFile(filePath);
+            if (!content)
+                return false;
+            return fallbackTerms.some(term => content.toLowerCase().includes(term.toLowerCase()));
+        }), {}, rankingQuery).slice(0, DEFAULT_LIMIT);
+        return scored.map(item => buildFsSearchResult(item.filePath));
+    }
+    remapSearchResult(result, context) {
+        return {
+            ...result,
+            path: mapCanonicalPathToExecutionPath(result.path, context),
+        };
+    }
+    resolveRegexScopeFiles(context, scope, repoRoot) {
+        const scopedFiles = dedupeStrings([
+            ...(scope?.files ?? []),
+            ...(context.analysis?.focus?.resolvedTargetFiles ?? []),
+        ]).filter(filePath => path.isAbsolute(filePath) && fs.existsSync(filePath));
+        if (scopedFiles.length > 0) {
+            return scopedFiles;
+        }
+        const scopedFolders = dedupeStrings([
+            ...(scope?.folders ?? []),
+            ...(context.analysis?.focus?.resolvedTargetFolders ?? []),
+        ]).filter(folder => path.isAbsolute(folder) && fs.existsSync(folder));
+        if (scopedFolders.length > 0) {
+            return dedupeStrings(scopedFolders.flatMap(folder => collectSearchablePaths(folder)));
+        }
+        return collectSearchablePaths(repoRoot);
+    }
+}
+/**
+ * Resolves one target symbol with the same exact-then-pattern fallback the old path used.
+ * Example: `run search now` -> exact miss -> pattern rows from `runSearchNow`.
+ */
+function resolveSymbolRowsWithFallback(db, symbol) {
+    const exactRows = resolveSymbolRows(db, [symbol]);
+    if (exactRows.length > 0) {
+        return exactRows;
+    }
+    return resolveSymbolRowsByPattern(db, [symbol]);
+}
+function createEmptySearchResult(mode, stagesRun = [], route = "db") {
+    return {
+        route,
+        mode,
+        stagesRun,
+        resolvedFiles: [],
+        resolvedFolders: [],
+        resolvedSymbols: [],
+        unresolvedRefs: [],
+        ambiguousRefs: [],
+        fileCandidates: [],
+        folderCandidates: [],
+        symbolCandidates: [],
+        fragmentMatches: [],
+        patternMatches: [],
+        directoryEntries: [],
+        fallbackUsed: false,
+    };
+}
+function shouldFallbackFromExactTarget(result) {
+    return result.resolvedFiles.length === 0 &&
+        result.resolvedFolders.length === 0 &&
+        result.resolvedSymbols.length === 0 &&
+        result.fileCandidates.length === 0 &&
+        result.folderCandidates.length === 0 &&
+        result.symbolCandidates.length === 0 &&
+        result.ambiguousRefs.length === 0;
+}
+function shouldFallbackFromOperatorPattern(result) {
+    return result.fileCandidates.length === 0 && result.patternMatches.length === 0;
+}
+function shouldTreatAsExplicitRef(rawRef) {
+    return isExplicitRefCandidate(String(rawRef ?? "").trim());
+}
+function resolvePathReference(rawRef, repoRoot) {
+    const ref = String(rawRef ?? "").trim().replace(/\\/g, "/");
+    if (!ref)
+        return { kind: "unresolved", ref: rawRef };
+    const directCandidates = [
+        ref,
+        path.join(repoRoot, ref),
+    ].map(candidate => path.isAbsolute(candidate) ? candidate : path.join(repoRoot, candidate));
+    for (const candidate of directCandidates) {
+        if (!fs.existsSync(candidate))
+            continue;
+        const normalized = path.normalize(candidate);
+        const stat = fs.statSync(normalized);
+        if (stat.isFile())
+            return { kind: "file", ref: rawRef, path: normalized };
+        if (stat.isDirectory())
+            return { kind: "folder", ref: rawRef, path: normalized };
+    }
+    if (ref.includes("/")) {
+        const fileMatches = fg.sync(`**/${ref}`, {
+            cwd: repoRoot,
+            absolute: true,
+            onlyFiles: true,
+            dot: false,
+            ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/.scai-worktrees/**"],
+        }).map(path.normalize);
+        if (fileMatches.length === 1)
+            return { kind: "file", ref: rawRef, path: fileMatches[0] };
+        if (fileMatches.length > 1)
+            return { kind: "ambiguous", ref: rawRef, paths: fileMatches };
+        const folderMatches = fg.sync(`**/${ref}`, {
+            cwd: repoRoot,
+            absolute: true,
+            onlyDirectories: true,
+            dot: false,
+            ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/.scai-worktrees/**"],
+        }).map(path.normalize);
+        if (folderMatches.length === 1)
+            return { kind: "folder", ref: rawRef, path: folderMatches[0] };
+        if (folderMatches.length > 1)
+            return { kind: "ambiguous", ref: rawRef, paths: folderMatches };
+        return { kind: "unresolved", ref: rawRef };
+    }
+    const fileMatches = fg.sync(`**/${ref}*`, {
+        cwd: repoRoot,
+        absolute: true,
+        onlyFiles: true,
+        dot: false,
+        ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/.scai-worktrees/**"],
+    }).map(path.normalize).filter(candidate => {
+        const filename = path.basename(candidate);
+        return normalizeLookupToken(filename) === normalizeLookupToken(ref) ||
+            normalizeLookupToken(path.parse(filename).name) === normalizeLookupToken(ref);
+    });
+    if (fileMatches.length === 1)
+        return { kind: "file", ref: rawRef, path: fileMatches[0] };
+    if (fileMatches.length > 1)
+        return { kind: "ambiguous", ref: rawRef, paths: fileMatches };
+    const folderMatches = fg.sync(`**/${ref}*`, {
+        cwd: repoRoot,
+        absolute: true,
+        onlyDirectories: true,
+        dot: false,
+        ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/.scai-worktrees/**"],
+    }).map(path.normalize).filter(candidate => {
+        return normalizeLookupToken(path.basename(candidate)) === normalizeLookupToken(ref);
+    });
+    if (folderMatches.length === 1)
+        return { kind: "folder", ref: rawRef, path: folderMatches[0] };
+    if (folderMatches.length > 1)
+        return { kind: "ambiguous", ref: rawRef, paths: folderMatches };
+    return { kind: "unresolved", ref: rawRef };
+}
+function normalizeLookupToken(value) {
+    return String(value ?? "").toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function buildFsSearchResult(filePath) {
+    return {
+        id: -Math.abs(hashPath(filePath)),
+        path: path.normalize(filePath),
+        filename: path.basename(filePath),
+        summary: null,
+        type: path.extname(filePath).replace(/^\./, "") || "unknown",
+        lastModified: readLastModified(filePath),
+    };
+}
+function hashPath(filePath) {
+    let hash = 0;
+    for (const char of filePath) {
+        hash = ((hash << 5) - hash) + char.charCodeAt(0);
+        hash |= 0;
+    }
+    return hash === 0 ? 1 : hash;
+}
+function readLastModified(filePath) {
+    try {
+        return fs.statSync(filePath).mtime.toISOString();
+    }
+    catch {
+        return new Date(0).toISOString();
+    }
+}
+function extractQuotedFragments(query) {
+    const out = new Set();
+    const patterns = [
+        /"([^"\n]{4,})"/g,
+        /'([^'\n]{4,})'/g,
+        /`([^`\n]{4,})`/g,
+    ];
+    for (const pattern of patterns) {
+        let match = null;
+        while ((match = pattern.exec(query)) !== null) {
+            const fragment = String(match[1] ?? "").trim();
+            if (fragment.length >= 4) {
+                out.add(fragment);
+            }
+        }
+    }
+    return Array.from(out);
+}
+/**
+ * Keeps regex flags predictable and small.
+ * Example: "igx" -> "gi" because only supported JS flags are kept.
+ */
+function normalizeRegexFlags(flags) {
+    const allowed = new Set(["g", "i", "m", "s", "u", "y"]);
+    const normalized = String(flags ?? "")
+        .split("")
+        .filter(flag => allowed.has(flag));
+    return Array.from(new Set(normalized)).join("");
+}
+async function searchContentMatches(options) {
+    const rgMatches = runRipgrepContentSearch(options);
+    if (rgMatches.available) {
+        return rgMatches.matches;
+    }
+    return runNodeContentSearch(options);
+}
+function runRipgrepContentSearch(options) {
+    try {
+        const args = [
+            "--line-number",
+            "--column",
+            "--with-filename",
+            "--color",
+            "never",
+            options.fixed ? "--fixed-strings" : "--regexp",
+            options.query,
+            ".",
+        ];
+        const output = execFileSync("rg", args, {
+            cwd: options.repoRoot,
+            encoding: "utf8",
+            maxBuffer: 1024 * 1024 * 8,
+        });
+        const matches = String(output ?? "")
+            .split(/\r?\n/)
+            .map(line => line.trim())
+            .filter(Boolean)
+            .map(line => parseRipgrepLine(line, options.repoRoot))
+            .filter((match) => Boolean(match))
+            .filter(match => !isPathIgnoredByFolderGlobs(match.path));
+        return { available: true, matches };
+    }
+    catch (err) {
+        if (err?.code === "ENOENT") {
+            return { available: false, matches: [] };
+        }
+        if (err?.status === 1) {
+            return { available: true, matches: [] };
+        }
+        return { available: false, matches: [] };
+    }
+}
+function parseRipgrepLine(line, repoRoot) {
+    const match = line.match(/^(.*?):(\d+):(\d+):(.*)$/);
+    if (!match)
+        return undefined;
+    const [, rawPath, rawLine, rawColumn, snippet] = match;
+    return {
+        path: path.normalize(path.join(repoRoot, rawPath)),
+        line: Number(rawLine),
+        column: Number(rawColumn),
+        snippet: snippet.trim(),
+    };
+}
+function runNodeContentSearch(options) {
+    const files = collectSearchablePaths(options.repoRoot);
+    const matches = [];
+    const regex = options.fixed ? null : safeCreateRegex(options.query);
+    for (const filePath of files) {
+        const content = safeReadFile(filePath);
+        if (!content)
+            continue;
+        const lines = content.split(/\r?\n/);
+        lines.forEach((line, index) => {
+            const column = options.fixed
+                ? line.indexOf(options.query)
+                : regex
+                    ? line.search(regex)
+                    : -1;
+            if (column < 0)
+                return;
+            matches.push({
+                path: filePath,
+                line: index + 1,
+                column: column + 1,
+                snippet: line.trim(),
+            });
+        });
+    }
+    return matches;
+}
+function safeCreateRegex(pattern, flags = "i") {
+    try {
+        return new RegExp(pattern, flags);
+    }
+    catch {
+        return null;
+    }
+}
+function safeReadFile(filePath) {
+    try {
+        return fs.readFileSync(filePath, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function collectSearchablePaths(rootDir, options = {}) {
+    const files = [];
+    const stack = [rootDir];
+    while (stack.length > 0) {
+        const currentDir = stack.pop();
+        if (!currentDir)
+            continue;
+        let entries = [];
+        try {
+            entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (shouldIgnoreDirectoryEntry(entry.name))
+                continue;
+            const fullPath = path.join(currentDir, entry.name);
+            if (!options.allowIgnoredPaths && isPathIgnoredByFolderGlobs(fullPath))
+                continue;
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+                continue;
+            }
+            const ext = path.extname(entry.name).toLowerCase();
+            if (!options.includeIgnoredExtensions && IGNORED_EXTENSIONS.includes(ext))
+                continue;
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+/**
+ * Returns direct child entries for lightweight folder listing answers.
+ * Example: `/repo/artifacts` -> `[{"name":"evals","kind":"folder"}, {"name":"run.md","kind":"file"}]`.
+ */
+function collectDirectDirectoryEntries(folderPath) {
+    let entries = [];
+    try {
+        entries = fs.readdirSync(folderPath, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter(entry => !shouldIgnoreDirectoryEntry(entry.name))
+        .map(entry => ({
+        path: path.join(folderPath, entry.name),
+        name: entry.name,
+        kind: entry.isDirectory() ? "folder" : "file",
+    }))
+        .sort((left, right) => {
+        if (left.kind !== right.kind) {
+            return left.kind === "folder" ? -1 : 1;
+        }
+        return left.name.localeCompare(right.name);
+    });
+}
+function shouldIgnoreDirectoryEntry(name) {
+    if (!name)
+        return true;
+    if (name.startsWith("."))
+        return true;
+    return false;
+}
+function resolveDirectoryListingTarget(context, query, repoRoot) {
+    const explicitFolders = dedupeStrings([
+        ...(context.analysis?.focus?.resolvedTargetFolders ?? []),
+        ...(context.analysis?.intent?.targetFiles ?? []),
+        ...extractFileReferences(query),
+    ]);
+    for (const ref of explicitFolders) {
+        const resolution = resolvePathReference(ref, repoRoot);
+        if (resolution.kind === "folder" && resolution.path) {
+            return resolution.path;
+        }
+    }
+    return undefined;
+}
+function collectRegexPathMatches(files, regex, repoRoot) {
+    const matches = [];
+    for (const filePath of files) {
+        const relativePath = path.relative(repoRoot, filePath);
+        const basename = path.basename(filePath);
+        regex.lastIndex = 0;
+        const matchedText = regex.test(relativePath) || regex.test(basename) ? relativePath : null;
+        if (!matchedText)
+            continue;
+        matches.push({
+            path: filePath,
+            line: 1,
+            column: 1,
+            snippet: matchedText,
+        });
+    }
+    return matches;
+}
+function collectRegexContentMatches(files, regex) {
+    const matches = [];
+    for (const filePath of files) {
+        const content = safeReadFile(filePath);
+        if (!content)
+            continue;
+        const lines = content.split(/\r?\n/);
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index];
+            regex.lastIndex = 0;
+            const match = regex.exec(line);
+            if (!match)
+                continue;
+            matches.push({
+                path: filePath,
+                line: index + 1,
+                column: (match.index ?? 0) + 1,
+                snippet: line.trim(),
+            });
+        }
+    }
+    return matches;
+}
+function isRipgrepAvailable() {
+    try {
+        execFileSync("rg", ["--version"], { encoding: "utf8" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function dedupeStrings(values) {
+    const out = [];
+    const seen = new Set();
+    for (const value of values) {
+        const normalized = String(value ?? "").trim();
+        if (!normalized)
+            continue;
+        if (seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+}
+function dedupeSearchResults(results) {
+    const seen = new Set();
+    const out = [];
+    for (const result of results) {
+        if (seen.has(result.path))
+            continue;
+        seen.add(result.path);
+        out.push(result);
+    }
+    return out;
+}
+function dedupeSymbolResolutions(entries) {
+    const seen = new Set();
+    const out = [];
+    for (const entry of entries) {
+        const key = `${entry.symbol}::${entry.filePath}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(entry);
+    }
+    return out;
+}
+function collectOrderedQuestionQueries(context, query) {
+    const orderedQuestions = context.analysis?.intent?.questions ?? [];
+    if (orderedQuestions.length <= 1) {
+        return [];
+    }
+    const seen = new Set();
+    const out = [];
+    for (const item of orderedQuestions) {
+        const text = String(item?.text ?? "").trim();
+        if (!text || text === query || seen.has(text))
+            continue;
+        seen.add(text);
+        out.push(text);
+    }
+    return out;
+}
+function rankMergedSearchResults(results, query) {
+    const relatedFileScores = Object.fromEntries(results.flatMap(result => typeof result.bm25Score === "number" && Number.isFinite(result.bm25Score)
+        ? [[result.path, result.bm25Score]]
+        : []));
+    const ranked = scoreCandidateFiles(results.map(result => result.path), relatedFileScores, query);
+    const resultByPath = new Map(results.map(result => [result.path, result]));
+    return ranked
+        .map(item => resultByPath.get(item.filePath))
+        .filter((result) => Boolean(result));
+}
+function collectMethodSelectionPathSupplement(context, retrievalQuery, existingPaths) {
+    const repoRoot = getContextExecutionPath(context);
+    if (!repoRoot || !fs.existsSync(repoRoot))
+        return [];
+    const candidates = collectSearchablePaths(repoRoot)
+        .filter(filePath => !existingPaths.has(filePath));
+    const scored = scoreCandidateFiles(candidates, {}, retrievalQuery)
+        .filter(item => item.score >= 8)
+        .slice(0, 8);
+    return scored.map(item => buildFsSearchResult(item.filePath));
+}
+/**
+ * Adds a small path-scored supplement for broad queries whose first semantic hits skew toward docs.
+ * Example: ordered questions can add both routing and verify implementation files before file-check runs.
+ */
+function collectScopedPathSupplements(context, retrievalQueries, existingPaths) {
+    const repoRoot = getContextExecutionPath(context);
+    if (!repoRoot || !fs.existsSync(repoRoot))
+        return [];
+    const candidates = collectSearchablePaths(repoRoot)
+        .filter(filePath => !existingPaths.has(filePath));
+    const out = [];
+    const added = new Set();
+    for (const retrievalQuery of dedupeStrings(retrievalQueries)) {
+        if (!retrievalQuery.trim())
+            continue;
+        const scored = scoreCandidateFiles(candidates, {}, retrievalQuery)
+            .filter(item => item.score >= 12)
+            .slice(0, 3);
+        for (const item of scored) {
+            if (added.has(item.filePath))
+                continue;
+            added.add(item.filePath);
+            out.push(buildFsSearchResult(item.filePath));
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=SearchOrchestrator.js.map