flowseeker 0.1.7

package/dist/pipeline/fileScanner.js

@@ -0,0 +1,866 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanTextFile = scanTextFile;
+exports.getWeightedTerms = getWeightedTerms;
+const path = __importStar(require("path"));
+const chunker_1 = require("../index/chunker");
+const dependencyExtractor_1 = require("../index/dependencyExtractor");
+const structuredExtractor_1 = require("../index/structuredExtractor");
+const text_1 = require("../utils/text");
+const contextBlueprint_1 = require("./contextBlueprint");
+const subsystem_1 = require("./subsystem");
+const MAX_MATCHED_LINES_PER_FILE = 160;
+const MAX_CHUNKS_PER_FILE = 12;
+const MAX_CHUNK_LINES = 120;
+const MAX_SEARCHABLE_LINE_CHARS = 12000;
+const MAX_STRUCTURED_MATCHED_LINES = 80;
+const MAX_STRUCTURED_SCAN_BYTES = 220000;
+function scanTextFile(input) {
+    if (input.content.includes("\u0000")) {
+        return [];
+    }
+    const weightedTerms = getWeightedTerms(input.profile);
+    const pathScore = scorePath(input.relativePath, weightedTerms);
+    const matchedLines = findMatchedLines(input.content, weightedTerms, MAX_MATCHED_LINES_PER_FILE);
+    const hasOversizedLine = containsLineLongerThan(input.content, MAX_SEARCHABLE_LINE_CHARS);
+    const headContent = input.content.slice(0, 200000);
+    const imports = (0, dependencyExtractor_1.extractImports)(headContent).map((item) => item.source).slice(0, 30);
+    const language = (0, structuredExtractor_1.detectLanguage)(input.relativePath);
+    const canExtractStructuredNodes = language &&
+        input.config.index.enableTreeSitter &&
+        input.size <= MAX_STRUCTURED_SCAN_BYTES &&
+        matchedLines.size <= MAX_STRUCTURED_MATCHED_LINES &&
+        !hasOversizedLine &&
+        (matchedLines.size > 0 || pathScore > 0);
+    const structuredNodes = canExtractStructuredNodes ? (0, structuredExtractor_1.extractStructuredNodes)(headContent, language) : [];
+    const fileMetadata = buildEvidenceMetadata(input.relativePath, structuredNodes, weightedTerms);
+    const units = [];
+    if (matchedLines.size > 0) {
+        const lineNumbers = Array.from(matchedLines.keys());
+        const chunks = (0, chunker_1.chunkAroundLines)(input.content, lineNumbers, 14, MAX_CHUNK_LINES).slice(0, MAX_CHUNKS_PER_FILE);
+        for (const chunk of chunks) {
+            const evidenceText = `${input.relativePath}\n${chunk.text}`;
+            const matchedTerms = collectMatchedTerms(evidenceText, weightedTerms);
+            const retrievalPasses = collectRetrievalPasses(evidenceText, input.profile, input.relativePath);
+            const score = pathScore + scoreSnippet(chunk.text, matchedTerms) + kindBonus(input.relativePath, chunk.text) + pathIntentModifier(input.relativePath, chunk.text, input.profile);
+            const kind = detectKind(input.relativePath, chunk.text);
+            const role = detectRole(kind, score, input.profile, input.relativePath, chunk.text);
+            units.push(toEvidenceUnit(input.file, input.relativePath, kind, role, chunk.range, score, matchedTerms, retrievalPasses, imports, reasonsFor(input.relativePath, kind, matchedTerms, retrievalPasses, imports, pathScore, chunk.text), chunk.text, fileMetadata));
+        }
+    }
+    if (pathScore > 0 && units.length === 0) {
+        const firstChunk = (0, chunker_1.chunkFile)(input.content, input.config.index.chunkSizeLines, input.config.index.chunkOverlapLines)[0];
+        const kind = detectKind(input.relativePath, firstChunk?.text ?? "");
+        const evidenceText = `${input.relativePath}\n${firstChunk?.text ?? ""}`;
+        const matchedTerms = collectMatchedTerms(evidenceText, weightedTerms);
+        const retrievalPasses = collectRetrievalPasses(evidenceText, input.profile, input.relativePath);
+        const score = pathScore + kindBonus(input.relativePath, firstChunk?.text ?? "") + pathIntentModifier(input.relativePath, firstChunk?.text ?? "", input.profile);
+        units.push(toEvidenceUnit(input.file, input.relativePath, kind, detectRole(kind, score, input.profile, input.relativePath, firstChunk?.text ?? ""), firstChunk?.range, score, matchedTerms, retrievalPasses, imports, reasonsFor(input.relativePath, kind, matchedTerms, retrievalPasses, imports, pathScore, firstChunk?.text ?? ""), firstChunk?.text, fileMetadata));
+    }
+    if (structuredNodes.length > 0 && language) {
+        units.push(...buildStructuredEvidence(input, structuredNodes, weightedTerms, imports, pathScore, fileMetadata, language));
+    }
+    return dedupeUnitsPerFile(units, 6);
+}
+function getWeightedTerms(profile) {
+    const byTerm = new Map();
+    const fallbackTerms = profile.keywords.map((term) => ({ term, weight: 1.5, source: "concept" }));
+    for (const term of profile.passes.flatMap((pass) => pass.terms).concat(fallbackTerms)) {
+        const normalized = (0, text_1.normalizeText)(term.term);
+        const existing = byTerm.get(normalized);
+        if (!existing || term.weight > existing.weight) {
+            byTerm.set(normalized, { ...term, term: normalized });
+        }
+    }
+    return Array.from(byTerm.values());
+}
+function scorePath(relativePath, terms) {
+    const normalizedPath = (0, text_1.normalizeText)(relativePath);
+    const pathTokens = (0, text_1.splitIdentifier)(relativePath);
+    let score = 0;
+    for (const term of terms) {
+        if (normalizedPath.includes(term.term)) {
+            score += (pathTokens.includes(term.term) ? 5 : 3) * term.weight;
+        }
+    }
+    return score;
+}
+function findMatchedLines(content, terms, maxMatches) {
+    const lines = content.split(/\r?\n/);
+    const matches = new Map();
+    const highSignalKeywords = terms.map((term) => term.term).filter(isHighSignalSearchTerm);
+    const broadKeywords = terms.map((term) => term.term).filter((term) => !highSignalKeywords.includes(term));
+    collectLineMatches(lines, highSignalKeywords, matches, maxMatches);
+    collectLineMatches(lines, broadKeywords, matches, maxMatches);
+    return matches;
+}
+function collectLineMatches(lines, keywords, matches, maxMatches) {
+    if (keywords.length === 0 || matches.size >= maxMatches) {
+        return;
+    }
+    for (let index = 0; index < lines.length && matches.size < maxMatches; index += 1) {
+        const line = lines[index];
+        if (line.length === 0) {
+            continue;
+        }
+        const normalizedLine = (0, text_1.normalizeText)(line.length > MAX_SEARCHABLE_LINE_CHARS ? line.slice(0, MAX_SEARCHABLE_LINE_CHARS) : line);
+        const lineMatches = keywords.filter((keyword) => normalizedLine.includes(keyword));
+        if (lineMatches.length > 0) {
+            matches.set(index + 1, Array.from(new Set([...(matches.get(index + 1) ?? []), ...lineMatches])));
+        }
+    }
+}
+function isHighSignalSearchTerm(term) {
+    return isSpecificCompoundTerm(term) || (term.length >= 14 && !term.includes(" "));
+}
+function containsLineLongerThan(content, maxChars) {
+    let currentLength = 0;
+    for (let index = 0; index < content.length; index += 1) {
+        const char = content.charCodeAt(index);
+        if (char === 10 || char === 13) {
+            currentLength = 0;
+            continue;
+        }
+        currentLength += 1;
+        if (currentLength > maxChars) {
+            return true;
+        }
+    }
+    return false;
+}
+function scoreSnippet(snippet, matchedTerms) {
+    const normalizedSnippet = (0, text_1.normalizeText)(snippet);
+    let score = matchedTerms.length * 2;
+    for (const term of matchedTerms) {
+        const occurrences = normalizedSnippet.split(term).length - 1;
+        score += Math.min(occurrences, 8);
+        if (isSpecificCompoundTerm(term)) {
+            score += 8;
+        }
+    }
+    if (/\b(class|function|def|public|private|route|router|controller|service|repository|handler|listener|job|worker|schema|migration)\b/i.test(snippet)) {
+        score += 4;
+    }
+    if (/\b(describe|it|test)\s*\(|\bexpect\s*\(|\bassert[.(]/i.test(snippet)) {
+        score += 2;
+    }
+    return score;
+}
+function isSpecificCompoundTerm(term) {
+    return term.length >= 10 && (term.includes("_") || /[a-z][0-9]/.test(term)) && (0, text_1.splitIdentifier)(term).length >= 3;
+}
+function collectMatchedTerms(text, terms) {
+    const normalizedText = (0, text_1.normalizeText)(text);
+    const matched = terms
+        .filter((term) => normalizedText.includes(term.term))
+        .sort((left, right) => retrievalTermPriority(right) - retrievalTermPriority(left))
+        .map((term) => term.term);
+    return Array.from(new Set(matched)).slice(0, 12);
+}
+function retrievalTermPriority(term) {
+    return term.weight * 10 + (isHighSignalSearchTerm(term.term) ? 40 : 0) + Math.min(12, term.term.length / 2);
+}
+function collectRetrievalPasses(text, profile, relativePath) {
+    const normalizedText = (0, text_1.normalizeText)(text);
+    const normalizedPath = (0, text_1.normalizeText)(relativePath);
+    return profile.passes
+        .filter((pass) => {
+        if (pass.purpose === "find_tests" && !isTestPath(normalizedPath)) {
+            return false;
+        }
+        return pass.terms.some((term) => normalizedText.includes((0, text_1.normalizeText)(term.term)));
+    })
+        .map((pass) => pass.label);
+}
+function detectKind(relativePath, snippet) {
+    const normalizedPath = (0, text_1.normalizeText)(relativePath);
+    const normalizedSnippet = (0, text_1.normalizeText)(snippet);
+    const ext = path.extname(relativePath).toLowerCase();
+    if (isTestPath(normalizedPath) || /\b(describe|it|test)\s*\(|\bexpect\s*\(|\bassert[.(]/.test(normalizedSnippet)) {
+        return "test";
+    }
+    if (/\b(migration|migrations|database)\b/.test(normalizedPath) || [".sql", ".prisma"].includes(ext)) {
+        return "migration";
+    }
+    if (/\b(schema|model|models)\b/.test(normalizedPath) || [".graphql", ".gql"].includes(ext)) {
+        return "schema";
+    }
+    if (/\b(config|env|settings|properties)\b/.test(normalizedPath) || [".env", ".ini", ".toml", ".yaml", ".yml", ".xml", ".json", ".properties"].includes(ext)) {
+        return "config";
+    }
+    if ([".md", ".mdx", ".txt", ".rst"].includes(ext)) {
+        return "doc";
+    }
+    if (isI18nPath(normalizedPath)) {
+        return "template";
+    }
+    if (isFrontendRoutePath(normalizedPath) || /\b(route|routes|router)\b/.test(normalizedPath) || /(@getmapping|@postmapping|route::|router\.|app\.get|app\.post|urlpatterns)/.test(normalizedSnippet)) {
+        return "route";
+    }
+    if ([".html", ".vue", ".svelte", ".blade.php", ".twig", ".erb", ".hbs", ".ejs", ".tsx", ".jsx"].some((suffix) => relativePath.toLowerCase().endsWith(suffix))) {
+        return "template";
+    }
+    return "code_region";
+}
+function detectRole(kind, score, profile, relativePath, snippet) {
+    const normalizedPath = (0, text_1.normalizeText)(relativePath);
+    const normalizedSnippet = (0, text_1.normalizeText)(snippet);
+    if (kind === "test") {
+        return "test";
+    }
+    if (kind === "doc") {
+        return "read_context";
+    }
+    if (isI18nPath(normalizedPath)) {
+        return "read_context";
+    }
+    if (isStaticContentPath(normalizedPath)) {
+        return "read_context";
+    }
+    if (/\b(smoke|e2e|fixture|mock|seed)\b/.test(normalizedPath)) {
+        return "verify";
+    }
+    if (isGuidanceOrReadinessPath(normalizedPath)) {
+        return "read_context";
+    }
+    if (isReadOnlyInvestigationTask(profile)) {
+        return "read_context";
+    }
+    if (isInfrastructurePath(normalizedPath)) {
+        return score >= 18 && isPrimaryFlowPath(normalizedPath, normalizedSnippet, profile) && hasStrongRuntimeSignal(normalizedSnippet) ? "impact" : "read_context";
+    }
+    if (isAdminSurfacePath(normalizedPath) && !isRuntimeFlowPath(normalizedPath, normalizedSnippet)) {
+        return "impact";
+    }
+    if (kind === "route" || kind === "template") {
+        const primaryRuntime = isPrimaryFlowPath(normalizedPath, normalizedSnippet, profile) && isRuntimeFlowPath(normalizedPath, normalizedSnippet);
+        const primaryUi = isPrimaryUiFlowPath(normalizedPath, normalizedSnippet, profile);
+        const primaryEntry = kind === "route" && isFrameworkEntryPath(normalizedPath) && hasTaskTermSignal(profile, normalizedPath, normalizedSnippet);
+        const stateStatusUi = taskTargetsStateOrStatus(profile) && isUiSurfacePath(normalizedPath) && hasTaskTermSignal(profile, normalizedPath, normalizedSnippet);
+        return (primaryRuntime || primaryUi || primaryEntry || stateStatusUi) && score >= 14 ? "edit_candidate" : "impact";
+    }
+    if (kind === "config" || kind === "schema" || kind === "migration") {
+        if (kind === "schema" && isPrimaryFlowPath(normalizedPath, normalizedSnippet, profile) && score >= 10) {
+            return "edit_candidate";
+        }
+        return shouldEditDataOrConfig(kind, profile) ? "edit_candidate" : "read_context";
+    }
+    if (isUiSurfacePath(normalizedPath) && !isPrimaryFlowPath(normalizedPath, normalizedSnippet, profile)) {
+        return score >= 18 ? "impact" : "read_context";
+    }
+    if (isFrontendStatePath(normalizedPath) && isPrimaryFlowPath(normalizedPath, normalizedSnippet, profile) && score >= 10) {
+        return "edit_candidate";
+    }
+    if (isRuntimeFlowPath(normalizedPath, normalizedSnippet) && isPrimaryFlowPath(normalizedPath, normalizedSnippet, profile) && score >= 10) {
+        return "edit_candidate";
+    }
+    if (score >= 18) {
+        return isRuntimePath(normalizedPath) || hasStrongRuntimeSignal(normalizedSnippet) ? "edit_candidate" : "read_context";
+    }
+    if (score >= 8) {
+        return isRuntimePath(normalizedPath) ? "impact" : "read_context";
+    }
+    if (score >= 5) {
+        return "read_context";
+    }
+    return "unknown";
+}
+function kindBonus(relativePath, snippet) {
+    const kind = detectKind(relativePath, snippet);
+    const bonus = {
+        file: 0,
+        code_region: 2,
+        symbol: 4,
+        callsite: 3,
+        route: 4,
+        config: 3,
+        schema: 3,
+        migration: 3,
+        template: 2,
+        test: 3,
+        doc: 1,
+        asset: 0
+    };
+    return bonus[kind];
+}
+function pathIntentModifier(relativePath, snippet, profile) {
+    const normalizedPath = (0, text_1.normalizeText)(relativePath);
+    const normalizedSnippet = (0, text_1.normalizeText)(snippet);
+    let modifier = 0;
+    const pathTermHits = countTaskTermHits(normalizedPath, profile.concepts);
+    const snippetTermHits = countTaskTermHits(normalizedSnippet, profile.concepts);
+    const keywordPathHits = countTaskTermHits(normalizedPath, profile.keywords);
+    const focusedPathHits = countTaskTermHits(normalizedPath, focusedPathTerms(profile));
+    const focusedKeywordPathHits = countTaskTermHits(normalizedPath, focusedKeywordPathTerms(profile));
+    const primaryFocusedPathHits = countTaskTermHits(normalizedPath, primaryFocusedPathTerms(profile));
+    const domainEntityTerms = focusedEntityPathTerms(profile);
+    const entityPathHits = countTaskTermHits(normalizedPath, domainEntityTerms);
+    if (isPrimaryFlowPath(normalizedPath, normalizedSnippet, profile)) {
+        modifier += 12;
+    }
+    if (entityPathHits > 0) {
+        modifier += 28 + Math.min(28, entityPathHits * 10);
+    }
+    if (taskTargetsUi(profile) && isUiSurfacePath(normalizedPath)) {
+        const focusedSnippetHits = countTaskTermHits(normalizedSnippet, focusedPathTerms(profile));
+        modifier += 8;
+        if (focusedPathHits > 0) {
+            modifier += 18 + Math.min(36, focusedPathHits * 10);
+        }
+        if (focusedPathHits >= 2) {
+            modifier += 18;
+        }
+        if (isFrontendRoutePath(normalizedPath)) {
+            modifier += focusedPathHits > 0 ? 16 : 4;
+        }
+        if (focusedSnippetHits >= 2 && hasFormOrDisplaySignal(normalizedSnippet)) {
+            modifier += 28 + Math.min(28, focusedSnippetHits * 6);
+        }
+        if (taskTargetsSettings(profile) && /\bsettings?\b/.test(normalizedPath)) {
+            modifier += 178;
+        }
+        if (matchesRequestedUiPrimitive(profile, normalizedPath)) {
+            modifier += 152;
+        }
+        if (isFrontendRouteScriptPath(normalizedPath) && (taskTargetsUrlOrRoute(profile) || focusedSnippetHits >= 2)) {
+            modifier += focusedPathHits > 0 ? 42 : 18;
+        }
+        if (isFrontendRouteScriptPath(normalizedPath) && focusedPathHits > 0) {
+            modifier += primaryFocusedPathHits > 0 ? 64 : focusedPathHits >= 2 ? 44 : 16;
+        }
+        if (isComponentPath(normalizedPath)) {
+            modifier += focusedPathHits > 0 ? 16 : 4;
+            if (focusedPathHits >= 2) {
+                modifier += 18;
+            }
+        }
+    }
+    if (isFrontendStatePath(normalizedPath) && focusedPathHits > 0) {
+        modifier += 18 + Math.min(24, focusedPathHits * 8);
+    }
+    if (isValidationPath(normalizedPath) && taskTargetsValidation(profile)) {
+        modifier += 18 + Math.min(18, Math.max(focusedPathHits, 1) * 6);
+    }
+    if (taskTargetsData(profile) && isGenericDataPath(normalizedPath) && focusedPathHits > 0) {
+        modifier += 38 + Math.min(36, focusedPathHits * 10);
+    }
+    if (taskTargetsSecurity(profile) && taskTargetsAdmin(profile)) {
+        if (isAdminSurfacePath(normalizedPath) && (focusedPathHits > 0 || snippetTermHits > 0)) {
+            modifier += 46;
+        }
+        if (isFrameworkEntryPath(normalizedPath) && snippetTermHits > 0) {
+            modifier += 34;
+        }
+        if (isPermissionPath(normalizedPath) && !/\b(login|reset|forgot)\b/.test(normalizedPath)) {
+            modifier += 24;
+        }
+    }
+    if (isRuntimeFlowPath(normalizedPath, normalizedSnippet)) {
+        modifier += 4;
+        modifier += Math.min(10, pathTermHits * 3 + snippetTermHits);
+    }
+    if (taskTargetsConfig(profile) && isConfigPath(normalizedPath)) {
+        modifier += 46 + Math.min(36, Math.max(keywordPathHits, focusedKeywordPathHits, focusedPathHits) * 10);
+        if (/\b(settings?|config|cache|env|environment|properties)\b/.test(normalizedPath)) {
+            modifier += 18;
+        }
+    }
+    if ((isBackendOnlyPath(normalizedPath) || isRuntimePath(normalizedPath)) && !isUiSurfacePath(normalizedPath) && focusedKeywordPathHits > 0) {
+        modifier += 40 + Math.min(24, focusedKeywordPathHits * 8);
+    }
+    if (domainEntityTerms.length > 0 && entityPathHits === 0 && (isRuntimePath(normalizedPath) || isBackendOnlyPath(normalizedPath)) && !isFrameworkEntryPath(normalizedPath)) {
+        modifier -= 18;
+    }
+    if (keywordPathHits > 0 && isRuntimePath(normalizedPath)) {
+        modifier += Math.min(8, keywordPathHits * 2);
+    }
+    if (hasActionSignal(normalizedSnippet, profile)) {
+        modifier += 4;
+    }
+    if (isI18nPath(normalizedPath)) {
+        modifier -= taskTargetsCopyOrI18n(profile) ? 0 : 24;
+    }
+    if (isUiSurfacePath(normalizedPath) && !taskTargetsUi(profile) && !isPrimaryFlowPath(normalizedPath, normalizedSnippet, profile)) {
+        modifier -= 10;
+    }
+    if (isUiSurfacePath(normalizedPath) && taskTargetsSecurity(profile) && !taskTargetsUi(profile)) {
+        modifier -= 34;
+    }
+    if (taskTargetsConfig(profile) && !taskTargetsSecurity(profile) && isPermissionPath(normalizedPath) && focusedPathHits === 0) {
+        modifier -= 20;
+    }
+    if (taskTargetsUi(profile) && !taskTargetsBackend(profile) && isBackendOnlyPath(normalizedPath) && focusedPathHits === 0) {
+        modifier -= 30;
+    }
+    if (!taskTargetsData(profile) && isGenericDataPath(normalizedPath) && focusedPathHits === 0) {
+        modifier -= taskTargetsUi(profile) ? 26 : 10;
+    }
+    if (isGenericUtilityPath(normalizedPath) && !taskTargetsUtility(profile)) {
+        modifier -= taskTargetsUi(profile) ? 24 : focusedPathHits === 0 ? 24 : 14;
+    }
+    if (isMaintenanceCommandPath(normalizedPath) && !taskTargetsMaintenanceCommand(profile)) {
+        modifier -= 42;
+    }
+    if (isGuidanceOrReadinessPath(normalizedPath)) {
+        modifier -= 16;
+    }
+    if (isStaticContentPath(normalizedPath)) {
+        modifier -= 24;
+    }
+    if (isAdminSurfacePath(normalizedPath) && !taskTargetsAdmin(profile) && !isRuntimeFlowPath(normalizedPath, normalizedSnippet)) {
+        modifier -= 8;
+    }
+    if (/\b(smoke|fixture|mock|seed)\b/.test(normalizedPath)) {
+        modifier -= 8;
+    }
+    if (/(^|\/)\.flowseeker(\/|$)|(^|\/)_gen[^/]*\.(py|sh)$|(^|\/)_bulk_write\.js$/.test(normalizedPath)) {
+        modifier -= 80;
+    }
+    return modifier;
+}
+function reasonsFor(relativePath, kind, matchedTerms, retrievalPasses, imports, pathScore, snippet) {
+    const reasons = [];
+    if (pathScore > 0) {
+        reasons.push(`path matches: ${matchedTerms.join(", ")}`);
+    }
+    if (matchedTerms.length > 0) {
+        reasons.push(`content matches: ${matchedTerms.join(", ")}`);
+    }
+    if (retrievalPasses.length > 0) {
+        reasons.push(`retrieval passes: ${retrievalPasses.join(", ")}`);
+    }
+    if (imports.length > 0) {
+        reasons.push(`dependency imports: ${imports.slice(0, 4).join(", ")}`);
+    }
+    if (kind !== "code_region") {
+        reasons.push(`detected as ${kind}`);
+    }
+    if (isTestPath((0, text_1.normalizeText)(relativePath)) || /\b(describe|it|test)\s*\(|\bexpect\s*\(|\bassert[.(]/i.test(snippet)) {
+        reasons.push("test-related evidence");
+    }
+    if (/\b(route|router|controller|handler|listener|job|worker|queue)\b/i.test(`${relativePath}\n${snippet}`)) {
+        reasons.push("flow/control-path evidence");
+    }
+    return Array.from(new Set(reasons));
+}
+function isTestPath(normalizedPath) {
+    return /(^|[/\\])(__tests__|tests?|specs?|fixtures?|mocks?)([/\\]|$)|(^|[/\\])(test_|spec_)[^/\\]+\.[a-z0-9]+$|(^|[/\\])[^/\\]+_(test|spec)\.[a-z0-9]+$|(^|[/\\])(tests?|specs?)\.[a-z0-9]+$|\.(test|spec)\./.test(normalizedPath);
+}
+function isI18nPath(normalizedPath) {
+    return /(^|[/\\])(i18n|locales?|translations?|dictionaries|messages)([/\\]|$)|dictionary|dictionaries/.test(normalizedPath);
+}
+function isStaticContentPath(normalizedPath) {
+    return /(^|[/\\])(privacy-policy|terms|terms-of-service|cookie-policy|legal|about|contact)(\.|[/\\]|$)/.test(normalizedPath);
+}
+function isUiSurfacePath(normalizedPath) {
+    return /(^|[/\\])(app|pages|routes|components|views|screens|dashboard|admin)([/\\]|$)|\.(tsx|jsx|vue|svelte|blade\.php|twig|erb)$/.test(normalizedPath);
+}
+function isAdminSurfacePath(normalizedPath) {
+    return /(^|[/\\])(admin|dashboard)([/\\]|$)|admin|dashboard/.test(normalizedPath);
+}
+function isGuidanceOrReadinessPath(normalizedPath) {
+    return /\b(guidance|readiness|dictionary|dictionaries|i18n|locale|locales|translation|translations|message|messages|copy|content)\b/.test(normalizedPath);
+}
+function isRuntimeFlowPath(normalizedPath, normalizedSnippet) {
+    return isRuntimePath(normalizedPath) && hasRuntimeCodeSignal(normalizedSnippet);
+}
+function isRuntimePath(normalizedPath) {
+    return /\b(service|services|provider|providers|handler|handlers|listener|listeners|job|jobs|worker|workers|queue|queues|controller|controllers|action|actions|usecase|usecases|use-case|command|commands|consumer|consumers|producer|producers|resolver|resolvers|middleware|policy|policies|guard|guards|processor|processors|notification|notifications|repository|repositories|store|stores|hook|hooks|validator|validators|composable|composables)\b/.test(normalizedPath);
+}
+function hasRuntimeCodeSignal(normalizedSnippet) {
+    const normalizedCode = normalizedSnippet.replace(/[^a-z0-9_\s=]+/g, " ");
+    return /\b(class|function|def|async function|export async|export function|public|private|protected|const [a-z0-9_]+\s*=\s*async|dispatch|emit|publish|subscribe|handle|execute|process|run|send|create|update|delete|validate|verify|approve|reject)\b/.test(normalizedCode);
+}
+function hasStrongRuntimeSignal(normalizedSnippet) {
+    const normalizedCode = normalizedSnippet.replace(/[^a-z0-9_\s=]+/g, " ");
+    return /\b(class\s+\w+|function\s+\w+|def\s+\w+|async function\s+\w+|export async function\s+\w+|export function\s+\w+|public\s+(async\s+)?\w+\s*\(|protected\s+(async\s+)?\w+\s*\(|private\s+(async\s+)?\w+\s*\(|dispatch\s*\(|emit\s*\(|publish\s*\(|subscribe\s*\(|handle\s*\(|execute\s*\(|process\s*\(|run\s*\(|const\s+\w+\s*=\s*async\s*\()\b/.test(normalizedCode);
+}
+function isInfrastructurePath(normalizedPath) {
+    return (/\b(extension|plugin|manifest|package)\.(ts|js|py|rb|php)$/.test(normalizedPath) ||
+        /\b(register|registration|bootstrap|setup|init|activate|deactivate)\b/.test(normalizedPath) ||
+        /\b(configuration|settings?|preferences?)\b/.test(normalizedPath) && !/\b(service|handler|controller|usecase|command)\b/.test(normalizedPath));
+}
+function hasActionSignal(normalizedSnippet, profile) {
+    if (profile.actions.length === 0) {
+        return false;
+    }
+    return profile.actions.some((action) => normalizedSnippet.includes((0, text_1.normalizeText)(action)));
+}
+function countTaskTermHits(text, terms) {
+    return terms.filter((term) => text.includes((0, text_1.normalizeText)(term))).length;
+}
+function hasTaskTermSignal(profile, normalizedPath, normalizedSnippet) {
+    const terms = profile.concepts.length > 0 ? profile.concepts : profile.keywords;
+    return countTaskTermHits(normalizedPath, terms) > 0 || countTaskTermHits(normalizedSnippet, terms) > 0;
+}
+function taskTargetsUi(profile) {
+    return hasAnyConcept(profile, ["ui", "frontend", "client", "browser", "page", "screen", "component", "view", "form", "button", "modal", "table", "layout", "responsive", "grid", "drawer", "sidebar", "toast", "chart", "gallery", "avatar", "badge", "bar", "input", "suggestion", "suggestions", "autocomplete", "dropdown", "image", "photo", "zoom", "giao", "dien", "hien", "thi", "nut", "anh", "display", "displayed", "render", "rendered", "show", "visible", "hide"]);
+}
+function taskTargetsAdmin(profile) {
+    return hasAnyConcept(profile, ["admin", "dashboard", "backoffice", "console"]);
+}
+function taskTargetsCopyOrI18n(profile) {
+    return hasAnyConcept(profile, ["copy", "text", "label", "message", "translation", "i18n", "locale", "wording", "content"]);
+}
+function isPrimaryFlowPath(normalizedPath, normalizedSnippet, profile) {
+    return hasTaskTermSignal(profile, normalizedPath, normalizedSnippet) && (isRuntimePath(normalizedPath) || hasRuntimeCodeSignal(normalizedSnippet)) && !isI18nPath(normalizedPath);
+}
+function isPrimaryUiFlowPath(normalizedPath, normalizedSnippet, profile) {
+    if (!taskTargetsUi(profile) || !isUiSurfacePath(normalizedPath)) {
+        return false;
+    }
+    return countTaskTermHits(normalizedPath, focusedPathTerms(profile)) > 0 || hasTaskTermSignal(profile, normalizedPath, normalizedSnippet);
+}
+function hasAnyConcept(profile, values) {
+    const terms = new Set(profile.keywords.map(text_1.normalizeText));
+    return values.some((value) => terms.has((0, text_1.normalizeText)(value)));
+}
+function taskTargetsBackend(profile) {
+    return hasAnyConcept(profile, ["api", "endpoint", "route", "router", "controller", "handler", "server", "backend", "job", "worker", "queue", "webhook", "event", "listener"]);
+}
+function taskTargetsData(profile) {
+    return hasAnyConcept(profile, ["schema", "migration", "database", "table", "db", "model", "query", "queries", "join", "repository", "prisma", "orm"]);
+}
+function taskTargetsValidation(profile) {
+    return hasAnyConcept(profile, ["validate", "validation", "validator", "validators", "request", "rule", "rules", "input", "form"]);
+}
+function taskTargetsSecurity(profile) {
+    return profile.intent === "security" || hasAnyConcept(profile, ["permission", "policy", "authorize", "auth", "guard", "middleware", "acl", "role"]);
+}
+function taskTargetsConfig(profile) {
+    return profile.blueprint.requiredSlots.includes("config") || hasAnyConcept(profile, ["config", "env", "environment", "setting", "settings", "property", "properties", "feature", "flag"]);
+}
+function taskTargetsUrlOrRoute(profile) {
+    if (hasAnyConcept(profile, ["route", "path", "href", "link", "slug", "param", "params", "lookup", "id"])) {
+        return true;
+    }
+    return hasAnyConcept(profile, ["url"]) && !taskTargetsConfig(profile);
+}
+function taskTargetsStateOrStatus(profile) {
+    return hasAnyConcept(profile, ["state", "status", "transition", "changes", "changed", "change", "shipped", "completed", "pending", "approved"]);
+}
+function taskTargetsSettings(profile) {
+    return hasAnyConcept(profile, ["settings", "setting", "preferences", "profile", "organization", "org"]);
+}
+function taskTargetsUtility(profile) {
+    return hasAnyConcept(profile, ["format", "formatter", "utility", "utils", "helper", "helpers", "api", "client"]);
+}
+function taskTargetsMaintenanceCommand(profile) {
+    return hasAnyConcept(profile, ["command", "cli", "console", "cron", "schedule", "scheduler", "maintenance", "batch", "digest", "cleanup", "job", "worker", "queue"]);
+}
+function isReadOnlyInvestigationTask(profile) {
+    if (profile.intent !== "investigation") {
+        return false;
+    }
+    return !profile.actions.some((action) => ["fix", "sua", "update", "change", "doi", "add", "them", "create", "tao", "remove", "delete", "xoa", "refactor", "rename"].includes(action));
+}
+const genericPathTerms = new Set([
+    "add",
+    "create",
+    "new",
+    "update",
+    "change",
+    "fix",
+    "remove",
+    "delete",
+    "refactor",
+    "implement",
+    "should",
+    "server",
+    "side",
+    "client",
+    "api",
+    "page",
+    "route",
+    "routes",
+    "screen",
+    "component",
+    "valid",
+    "code",
+    "data",
+    "logic",
+    "flow",
+    "use",
+    "using",
+    "include",
+    "includes",
+    "show",
+    "hide",
+    "display",
+    "render"
+]);
+function focusedPathTerms(profile) {
+    const base = profile.concepts.length > 0 ? profile.concepts : profile.keywords;
+    return base.map(text_1.normalizeText).filter((term) => term.length > 2 && !genericPathTerms.has(term));
+}
+function focusedKeywordPathTerms(profile) {
+    return profile.keywords.map(text_1.normalizeText).filter((term) => term.length > 2 && !genericPathTerms.has(term));
+}
+function primaryFocusedPathTerms(profile) {
+    return focusedPathTerms(profile).slice(0, 6);
+}
+const lowSignalEntityTerms = new Set(["user", "account", "member", "admin", "file", "document", "submission", "attachment"]);
+function focusedEntityPathTerms(profile) {
+    return profile.entities.map(text_1.normalizeText).filter((term) => term.length > 2 && !lowSignalEntityTerms.has(term));
+}
+function isFrameworkEntryPath(normalizedPath) {
+    return /(^|[/\\])(routes?|router)([/\\]|$)|(^|[/\\])urls\.py$|(^|[/\\])web\.php$|(^|[/\\])api\.php$/.test(normalizedPath);
+}
+function isFrontendRoutePath(normalizedPath) {
+    return /(^|[/\\])routes?([/\\]|$).*(^|[/\\])\+(page|layout|server)\.(ts|js|svelte)$|(^|[/\\])(app|pages)([/\\]|$).*\b(page|layout|route)\.(ts|tsx|js|jsx|svelte)$/.test(normalizedPath);
+}
+function isFrontendRouteScriptPath(normalizedPath) {
+    return /(^|[/\\])routes?([/\\]|$).*(^|[/\\])\+(page|layout|server)\.(ts|js)$|(^|[/\\])(app|pages)([/\\]|$).*\b(page|layout|route)\.(ts|tsx|js|jsx)$/.test(normalizedPath);
+}
+function isComponentPath(normalizedPath) {
+    return /(^|[/\\])components?([/\\]|$)|\.(svelte|vue|tsx|jsx)$/.test(normalizedPath);
+}
+function isFrontendStatePath(normalizedPath) {
+    return /(^|[/\\])(store|stores|hooks?|composables?)([/\\]|$)|(^|[/\\])hooks?\.(client|server)?\.(ts|js)$/.test(normalizedPath);
+}
+function isValidationPath(normalizedPath) {
+    return /\b(validators?|validation|rules?|request|dto|schema)\b/.test(normalizedPath);
+}
+function hasFormOrDisplaySignal(normalizedSnippet) {
+    return /\b(form|input|field|label|onchange|value|error|dialog|modal|display|render|show|visible|address|href|link|params?)\b/.test(normalizedSnippet);
+}
+function matchesRequestedUiPrimitive(profile, normalizedPath) {
+    return (hasAnyConcept(profile, ["input", "field"]) && /(^|[/\\])input\.(tsx|jsx|ts|js|vue|svelte)$/.test(normalizedPath)) || (hasAnyConcept(profile, ["modal", "dialog", "confirmation", "confirm"]) && /(^|[/\\])(modal|dialog)\.(tsx|jsx|ts|js|vue|svelte)$/.test(normalizedPath)) || (hasAnyConcept(profile, ["form"]) && /(^|[/\\])form\.(tsx|jsx|ts|js|vue|svelte)$/.test(normalizedPath));
+}
+function isConfigPath(normalizedPath) {
+    return /\b(config|configs|settings?|environment|environments|properties)\b/.test(normalizedPath) || /\.(env|ini|toml|ya?ml|xml|json|properties)$/.test(normalizedPath);
+}
+function isPermissionPath(normalizedPath) {
+    return /\b(policies?|permissions?|roles?|guards?|middleware|auth|acl|authorize)\b/.test(normalizedPath);
+}
+function isBackendOnlyPath(normalizedPath) {
+    return /(^|[/\\])apps[/\\](api|server|backend|worker)([/\\]|$)|(^|[/\\])(server|backend|api|controllers?|handlers?|jobs?|workers?|queues?|middleware|policies|mail|notifications?)([/\\]|$)/.test(normalizedPath);
+}
+function isGenericDataPath(normalizedPath) {
+    return /(^|[/\\])(db|database|schema|models?|repositories?)(\.|[/\\]|$)|(^|[/\\])(db|database)\.(ts|js|py|rb|php|go|rs|cs)$/.test(normalizedPath);
+}
+function isGenericUtilityPath(normalizedPath) {
+    return (/(^|[/\\])helpers?([/\\]|$)/.test(normalizedPath) ||
+        /(^|[/\\])(helpers?|utils?)\.(ts|js|tsx|jsx|py|rb|php|go|rs|cs)$/.test(normalizedPath) ||
+        /(^|[/\\])(utils?|helpers?|lib)([/\\]|$).*(^|[/\\])(format|formats|formatter|api|client|http|request|requests|common|shared)\.(ts|js|tsx|jsx|py|rb|php|go|rs|cs)$/.test(normalizedPath));
+}
+function isMaintenanceCommandPath(normalizedPath) {
+    return /(^|[/\\])(management[/\\]commands|console[/\\]commands|commands?|cli|scripts?|tasks?)([/\\]|$)/.test(normalizedPath);
+}
+function shouldEditDataOrConfig(kind, profile) {
+    if (kind === "migration" || kind === "schema") {
+        return profile.blueprint.requiredSlots.includes("data") || profile.intent === "migration" || hasAnyConcept(profile, ["schema", "migration", "database", "table", "db"]);
+    }
+    if (kind === "config") {
+        return hasAnyConcept(profile, ["config", "env", "environment", "setting", "settings", "property", "properties", "feature", "flag"]) || taskChangesLiteralValue(profile);
+    }
+    return false;
+}
+function taskChangesLiteralValue(profile) {
+    if (!profile.actions.some((action) => ["change", "update", "doi", "sua", "fix"].includes(action))) {
+        return false;
+    }
+    return profile.concepts.some((term) => term.includes("@") || term.includes("://"));
+}
+function toEvidenceUnit(file, relativePath, kind, role, range, score, matchedTerms, retrievalPasses, imports, reasons, snippet, metadata) {
+    const confidence = (0, text_1.clamp)(score / 24, 0.1, 0.98);
+    const id = `${relativePath}:${range?.startLine ?? 1}:${range?.endLine ?? 1}:${kind}`;
+    const slot = (0, contextBlueprint_1.detectContextSlot)(relativePath, kind, role, snippet);
+    return {
+        id,
+        kind,
+        role,
+        file,
+        relativePath,
+        range,
+        language: (0, text_1.languageFromPath)(relativePath),
+        slot,
+        score,
+        confidence,
+        tier: confidence >= 0.75 ? "high" : confidence >= 0.45 ? "medium" : "low",
+        reasons,
+        snippet,
+        matchedTerms,
+        retrievalPasses,
+        imports,
+        ...metadata
+    };
+}
+function buildStructuredEvidence(input, nodes, weightedTerms, imports, pathScore, fileMetadata, language) {
+    const units = [];
+    const relevantNodes = nodes.filter((node) => {
+        if (node.kind === "string_literal" || node.kind === "comment") {
+            const normalizedText = (0, text_1.normalizeText)(node.text);
+            return weightedTerms.some((term) => normalizedText.includes(term.term));
+        }
+        if (node.kind === "declaration" || node.kind === "call") {
+            const normalizedName = node.name ? (0, text_1.normalizeText)(node.name) : "";
+            return normalizedName.length > 0 && weightedTerms.some((term) => normalizedName.includes(term.term));
+        }
+        return false;
+    });
+    const fileKind = detectKind(input.relativePath, input.content.slice(0, 500));
+    const maxCallsitesPerFile = 4;
+    let callsiteCount = 0;
+    for (const node of relevantNodes.slice(0, 12)) {
+        const nodeKind = fileKind !== "code_region" ? fileKind : structuredKindToEvidenceKind(node.kind);
+        if (nodeKind === "callsite") {
+            callsiteCount += 1;
+            if (callsiteCount > maxCallsitesPerFile) {
+                continue;
+            }
+        }
+        const snippet = getNodeSnippet(input.content, node, 3, language);
+        const evidenceText = `${input.relativePath}\n${snippet}`;
+        const matchedTerms = collectMatchedTerms(evidenceText, weightedTerms);
+        const retrievalPasses = collectRetrievalPasses(evidenceText, input.profile, input.relativePath);
+        const nodeScore = pathScore + scoreSnippet(snippet, matchedTerms) + kindBonus(input.relativePath, snippet) + pathIntentModifier(input.relativePath, snippet, input.profile) + (node.kind === "declaration" ? 8 : 4);
+        const role = detectRole(nodeKind, nodeScore, input.profile, input.relativePath, snippet);
+        units.push(toEvidenceUnit(input.file, input.relativePath, nodeKind, role, node.range, nodeScore, matchedTerms, retrievalPasses, imports, reasonsFor(input.relativePath, nodeKind, matchedTerms, retrievalPasses, imports, pathScore, snippet), snippet, {
+            ...fileMetadata,
+            symbolMatches: collectSymbolMatches([node.name ?? "", ...(fileMetadata.symbols ?? [])], weightedTerms)
+        }));
+    }
+    return units;
+}
+function structuredKindToEvidenceKind(kind) {
+    switch (kind) {
+        case "declaration":
+            return "symbol";
+        case "call":
+            return "callsite";
+        case "string_literal":
+        case "comment":
+            return "code_region";
+        case "import":
+            return "code_region";
+        case "annotation":
+            return "code_region";
+    }
+}
+function getNodeSnippet(content, node, contextLines, language) {
+    const lines = content.split(/\r?\n/);
+    const scopedRange = node.kind === "declaration" ? inferScopeRange(lines, node.range.startLine, language) : node.range;
+    const start = Math.max(0, scopedRange.startLine - 1 - contextLines);
+    const end = Math.min(lines.length, scopedRange.endLine + contextLines);
+    return lines.slice(start, end).join("\n");
+}
+function buildEvidenceMetadata(relativePath, nodes, weightedTerms) {
+    const symbols = nodes
+        .filter((node) => node.kind === "declaration" && node.name)
+        .map((node) => node.name ?? "")
+        .slice(0, 40);
+    const subsystemTerms = (0, subsystem_1.inferSubsystemTerms)(relativePath, symbols);
+    return {
+        symbols,
+        symbolMatches: collectSymbolMatches(symbols, weightedTerms),
+        subsystem: subsystemTerms[0],
+        subsystemTerms
+    };
+}
+function collectSymbolMatches(symbols, weightedTerms) {
+    const normalizedTerms = weightedTerms.map((term) => (0, text_1.normalizeText)(term.term));
+    return Array.from(new Set(symbols
+        .map(text_1.normalizeText)
+        .filter((symbol) => symbol.length > 0 && normalizedTerms.some((term) => symbol.includes(term) || term.includes(symbol))))).slice(0, 8);
+}
+function inferScopeRange(lines, startLine, language) {
+    if (language === "python" || language === "ruby") {
+        return inferIndentScopeRange(lines, startLine);
+    }
+    return inferBraceScopeRange(lines, startLine);
+}
+function inferIndentScopeRange(lines, startLine) {
+    const startIndex = Math.max(0, startLine - 1);
+    const startIndent = leadingWhitespace(lines[startIndex] ?? "").length;
+    let endLine = startLine;
+    for (let index = startIndex + 1; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (line.trim().length === 0) {
+            endLine = index + 1;
+            continue;
+        }
+        const indent = leadingWhitespace(line).length;
+        if (indent <= startIndent) {
+            break;
+        }
+        endLine = index + 1;
+        if (endLine - startLine >= MAX_CHUNK_LINES) {
+            break;
+        }
+    }
+    return { startLine, endLine };
+}
+function inferBraceScopeRange(lines, startLine) {
+    let depth = 0;
+    let seenOpenBrace = false;
+    let endLine = startLine;
+    for (let index = Math.max(0, startLine - 1); index < lines.length; index += 1) {
+        const line = lines[index];
+        for (const char of line) {
+            if (char === "{") {
+                depth += 1;
+                seenOpenBrace = true;
+            }
+            else if (char === "}") {
+                depth = Math.max(0, depth - 1);
+            }
+        }
+        endLine = index + 1;
+        if (seenOpenBrace && depth === 0) {
+            break;
+        }
+        if (endLine - startLine >= MAX_CHUNK_LINES) {
+            break;
+        }
+    }
+    return { startLine, endLine };
+}
+function leadingWhitespace(value) {
+    return value.match(/^\s*/)?.[0] ?? "";
+}
+function dedupeUnitsPerFile(units, maxPerFile) {
+    const counts = new Map();
+    return units.filter((unit) => {
+        const count = counts.get(unit.relativePath) ?? 0;
+        if (count >= maxPerFile) {
+            return false;
+        }
+        counts.set(unit.relativePath, count + 1);
+        return true;
+    });
+}
+//# sourceMappingURL=fileScanner.js.map