flowseeker 0.1.7 → 0.1.8

package/dist/pipeline/fileScanner.js

@@ -90,10 +90,47 @@ function scanTextFile(input) {
         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 (units.length === 0 && input.channelHits?.some((hit) => hit.channel === "semantic_vector")) {
+        const semanticHit = input.channelHits.find((hit) => hit.channel === "semantic_vector");
+        const minSimilarity = input.config.index.semanticMinSimilarity ?? 0.5;
+        const maxRank = input.config.index.semanticEvidenceMaxRank ?? 20;
+        if (semanticHit.score >= minSimilarity && semanticHit.rank <= maxRank) {
+            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 score = 10 + Math.max(0, semanticHit.score) * 20;
+            units.push(toEvidenceUnit(input.file, input.relativePath, kind, detectRole(kind, score, input.profile, input.relativePath, firstChunk?.text ?? ""), firstChunk?.range, score, [], ["semantic_vector"], imports, [`semantic-only file evidence: similarity=${semanticHit.score.toFixed(3)} rank=${semanticHit.rank}`], firstChunk?.text, {
+                ...fileMetadata,
+                semanticTrace: {
+                    channel: "semantic_vector",
+                    similarity: semanticHit.score,
+                    rank: semanticHit.rank,
+                    reason: semanticHit.reason
+                }
+            }));
+        }
+    }
     if (structuredNodes.length > 0 && language) {
         units.push(...buildStructuredEvidence(input, structuredNodes, weightedTerms, imports, pathScore, fileMetadata, language));
     }
-    return dedupeUnitsPerFile(units, 6);
+    const result = dedupeUnitsPerFile(units, 6);
+    return result.map((unit) => {
+        const hasSemanticChannel = input.channelHits?.some((hit) => hit.channel === "semantic_vector");
+        const updatedPasses = hasSemanticChannel && !unit.retrievalPasses.includes("semantic_vector")
+            ? [...unit.retrievalPasses, "semantic_vector"]
+            : unit.retrievalPasses;
+        return {
+            ...unit,
+            channelHits: input.channelHits,
+            retrievalTrace: input.retrievalTrace,
+            graphReasons: input.graphReasons,
+            retrievalPasses: updatedPasses,
+            reasons: [
+                ...unit.reasons,
+                ...(input.retrievalTrace ?? []).map((trace) => `retrieval channel: ${trace}`),
+                ...(input.graphReasons ?? []).map((reason) => `graph expansion: ${reason}`)
+            ]
+        };
+    });
 }
 function getWeightedTerms(profile) {
     const byTerm = new Map();
@@ -401,6 +438,12 @@ function pathIntentModifier(relativePath, snippet, profile) {
     if ((isBackendOnlyPath(normalizedPath) || isRuntimePath(normalizedPath)) && !isUiSurfacePath(normalizedPath) && focusedKeywordPathHits > 0) {
         modifier += 40 + Math.min(24, focusedKeywordPathHits * 8);
     }
+    if ((isFrameworkEntryPath(normalizedPath) || /(^|\/)(controllers?|handlers?)(\/|$)/.test(normalizedPath)) && focusedPathHits > 0) {
+        modifier += 38 + Math.min(22, focusedPathHits * 8);
+    }
+    if (/(^|\/)(jobs?|events?|listeners?|mail|notifications?|queues?|workers?)(\/|$)/.test(normalizedPath) && focusedPathHits > 0) {
+        modifier += 28 + Math.min(18, focusedPathHits * 6);
+    }
     if (domainEntityTerms.length > 0 && entityPathHits === 0 && (isRuntimePath(normalizedPath) || isBackendOnlyPath(normalizedPath)) && !isFrameworkEntryPath(normalizedPath)) {
         modifier -= 18;
     }
@@ -414,41 +457,78 @@ function pathIntentModifier(relativePath, snippet, profile) {
         modifier -= taskTargetsCopyOrI18n(profile) ? 0 : 24;
     }
     if (isUiSurfacePath(normalizedPath) && !taskTargetsUi(profile) && !isPrimaryFlowPath(normalizedPath, normalizedSnippet, profile)) {
-        modifier -= 10;
+        modifier -= 22;
     }
     if (isUiSurfacePath(normalizedPath) && taskTargetsSecurity(profile) && !taskTargetsUi(profile)) {
-        modifier -= 34;
+        modifier -= 46;
     }
     if (taskTargetsConfig(profile) && !taskTargetsSecurity(profile) && isPermissionPath(normalizedPath) && focusedPathHits === 0) {
         modifier -= 20;
     }
     if (taskTargetsUi(profile) && !taskTargetsBackend(profile) && isBackendOnlyPath(normalizedPath) && focusedPathHits === 0) {
-        modifier -= 30;
+        modifier -= 46;
     }
     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;
+        modifier -= taskTargetsUi(profile) ? 36 : focusedPathHits === 0 ? 42 : 28;
     }
     if (isMaintenanceCommandPath(normalizedPath) && !taskTargetsMaintenanceCommand(profile)) {
-        modifier -= 42;
+        modifier -= 64;
     }
     if (isGuidanceOrReadinessPath(normalizedPath)) {
-        modifier -= 16;
+        modifier -= 28;
     }
     if (isStaticContentPath(normalizedPath)) {
-        modifier -= 24;
+        modifier -= 38;
     }
     if (isAdminSurfacePath(normalizedPath) && !taskTargetsAdmin(profile) && !isRuntimeFlowPath(normalizedPath, normalizedSnippet)) {
-        modifier -= 8;
+        modifier -= 22;
     }
     if (/\b(smoke|fixture|mock|seed)\b/.test(normalizedPath)) {
-        modifier -= 8;
+        modifier -= 18;
     }
     if (/(^|\/)\.flowseeker(\/|$)|(^|\/)_gen[^/]*\.(py|sh)$|(^|\/)_bulk_write\.js$/.test(normalizedPath)) {
         modifier -= 80;
     }
+    // Framework-specific path hints — moderate boosts for common patterns in weak workspaces
+    if (focusedPathHits > 0 || keywordPathHits > 0) {
+        // Go: handler/service in internal/, cmd/server entry, router, domain services
+        if (/(^|\/)internal\/handler\b/.test(normalizedPath))
+            modifier += 12;
+        if (/(^|\/)internal\/service\b/.test(normalizedPath))
+            modifier += 10;
+        if (/(^|\/)cmd\/server\b/.test(normalizedPath))
+            modifier += 10;
+        if (/(^|\/)internal\/router\b/.test(normalizedPath))
+            modifier += 8;
+        if (/(^|\/)internal\/domain\b/.test(normalizedPath))
+            modifier += 8;
+        // Spring Boot: controller/service/repository with java/kotlin, annotated entry points
+        if (/\.java$|\.kt$/.test(relativePath.toLowerCase()) && /(^|\/)(controller|service|repository)(\/|$)/.test(normalizedPath))
+            modifier += 12;
+        if (/\.java$/.test(relativePath.toLowerCase()) && /\b@(RestController|Controller|Service|Repository)\b/i.test(snippet))
+            modifier += 6;
+        // Rails: controller, model, service, mailer, job, policy
+        if (/\.rb$/.test(relativePath.toLowerCase()) && /(^|\/)app\/(controllers|models|services|mailers|jobs|policies)(\/|$)/.test(normalizedPath))
+            modifier += 12;
+        if (/\.rb$/.test(relativePath.toLowerCase()) && /(^|\/)config\/routes\.rb$/.test(normalizedPath))
+            modifier += 10;
+        // ASP.NET Core: Controllers/, Services/, Program.cs, Startup
+        if (/\.cs$/.test(relativePath.toLowerCase()) && /(^|\/)(Controllers|Services|Repositories)(\/|$)/.test(normalizedPath))
+            modifier += 12;
+        if (/\.cs$/.test(relativePath.toLowerCase()) && /\b(Program|Startup)\.cs$/.test(normalizedPath))
+            modifier += 8;
+        // Flutter/Dart: screen, provider, bloc, service directories
+        if (/\.dart$/.test(relativePath.toLowerCase()) && /(^|\/)(screens?|providers?|blocs?|services?)(\/|$)/.test(normalizedPath))
+            modifier += 12;
+        // SvelteKit: route files, lib/server, lib/components
+        if (/\.svelte$|\.ts$/.test(relativePath.toLowerCase()) && /(^|\/)\+(page|layout|server)\./.test(normalizedPath))
+            modifier += 12;
+        if (/\.ts$/.test(relativePath.toLowerCase()) && /(^|\/)lib\/server\//.test(normalizedPath))
+            modifier += 10;
+    }
     return modifier;
 }
 function reasonsFor(relativePath, kind, matchedTerms, retrievalPasses, imports, pathScore, snippet) {
@@ -751,6 +831,7 @@ function buildStructuredEvidence(input, nodes, weightedTerms, imports, pathScore
         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,
+            extractorKind: node.extractorKind ?? "structured-regex",
             symbolMatches: collectSymbolMatches([node.name ?? "", ...(fileMetadata.symbols ?? [])], weightedTerms)
         }));
     }
@@ -788,7 +869,8 @@ function buildEvidenceMetadata(relativePath, nodes, weightedTerms) {
         symbols,
         symbolMatches: collectSymbolMatches(symbols, weightedTerms),
         subsystem: subsystemTerms[0],
-        subsystemTerms
+        subsystemTerms,
+        extractorKind: "fallback-chunk"
     };
 }
 function collectSymbolMatches(symbols, weightedTerms) {

package/dist/pipeline/llmReranker.js

@@ -0,0 +1,151 @@
+"use strict";
+// Phase 05 Sprint 5G-B — Disabled Optional LLM Reranker Module
+// Execution mode: disabled_prototype_report_only
+// No provider/client/API calls. No network. No production imports.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildLlmRerankRequest = buildLlmRerankRequest;
+exports.validateLlmRerankResponse = validateLlmRerankResponse;
+exports.applyLlmRerankOrFallback = applyLlmRerankOrFallback;
+exports.redactLlmRerankCandidate = redactLlmRerankCandidate;
+exports.createDeterministicFallback = createDeterministicFallback;
+const DEFAULT_SYSTEM_PROMPT = "You are a code search result reranker. Given a task description and a list of candidate files with their retrieval metadata, reorder the candidates so the most relevant files appear first. Output a JSON array of {relativePath, newRank, reason}. Do not add files not in the input list. Do not change relativePath values. Do not include file contents or secrets.";
+const FORBIDDEN_FIELDS = new Set([
+    "expectedPath", "expectedPaths", "avoidPath", "avoidPaths",
+    "caseId", "caseIds", "suiteName", "suiteLabels",
+    "benchmark", "benchmarkLabel", "benchmarkLabels",
+    "oracle", "postHoc", "fixture", "isAvoid", "isExpected",
+    "contrastContext", "fullFileContents",
+]);
+// --- 1. buildLlmRerankRequest ---
+function buildLlmRerankRequest(candidates, model) {
+    const redacted = candidates.map((c) => redactLlmRerankCandidate(c));
+    const userContent = JSON.stringify({
+        taskDescription: candidates[0]?.taskDescription || "",
+        candidates: redacted,
+    });
+    return {
+        model: model || "default",
+        messages: [
+            { role: "system", content: DEFAULT_SYSTEM_PROMPT },
+            { role: "user", content: userContent },
+        ],
+        temperature: 0,
+        max_tokens: 1024,
+        response_format: { type: "json_object" },
+    };
+}
+// --- 2. validateLlmRerankResponse ---
+function validateLlmRerankResponse(input, response) {
+    const errors = [];
+    if (!response || !Array.isArray(response.reranked)) {
+        errors.push("R1: reranked must be a non-empty array");
+        return { valid: false, errors };
+    }
+    if (response.reranked.length === 0) {
+        errors.push("R7: empty reranked array");
+        return { valid: false, errors };
+    }
+    // Build normalized input path set
+    const inputPaths = new Set();
+    for (const c of input) {
+        inputPaths.add((c.relativePath || "").replace(/\\/g, "/").toLowerCase());
+    }
+    const seenRanks = new Set();
+    const responsePaths = new Set();
+    for (const r of response.reranked) {
+        const np = (r.relativePath || "").replace(/\\/g, "/").toLowerCase();
+        // R3: no new paths
+        if (!inputPaths.has(np)) {
+            errors.push("R3: unknown file in response: " + r.relativePath);
+        }
+        // R4: unique ranks in [1, N]
+        if (!Number.isInteger(r.newRank) || r.newRank < 1 || r.newRank > input.length) {
+            errors.push("R4: invalid newRank " + r.newRank + " for " + r.relativePath);
+        }
+        if (seenRanks.has(r.newRank)) {
+            errors.push("R4: duplicate newRank " + r.newRank);
+        }
+        seenRanks.add(r.newRank);
+        responsePaths.add(np);
+        // R5: reason present, non-empty, <= 200 chars
+        if (typeof r.reason !== "string" || r.reason.length === 0) {
+            errors.push("R5: reason missing for " + r.relativePath);
+        }
+        if (r.reason && r.reason.length > 200) {
+            errors.push("R5: reason too long for " + r.relativePath);
+        }
+    }
+    // R2: all input paths must be in response
+    if (responsePaths.size !== inputPaths.size) {
+        errors.push("R2/R8: candidate count mismatch (input=" + inputPaths.size + " response=" + responsePaths.size + ")");
+    }
+    return { valid: errors.length === 0, errors };
+}
+// --- 3. applyLlmRerankOrFallback ---
+function applyLlmRerankOrFallback(input, response, fallbackReason) {
+    if (!response) {
+        return createDeterministicFallback(input, fallbackReason || "no_response");
+    }
+    // Try to parse if response is string
+    let parsed = response;
+    // Validate
+    const validation = validateLlmRerankResponse(input, parsed);
+    if (!validation.valid) {
+        return createDeterministicFallback(input, (fallbackReason || "validation_failed") + ": " + validation.errors.join("; "));
+    }
+    // Reorder candidates by newRank
+    const rankMap = new Map();
+    for (const r of parsed.reranked) {
+        rankMap.set(r.newRank, r.relativePath);
+    }
+    const pathToCandidate = new Map();
+    for (const c of input) {
+        const np = (c.relativePath || "").replace(/\\/g, "/").toLowerCase();
+        pathToCandidate.set(np, c);
+    }
+    const reordered = [];
+    for (let rank = 1; rank <= input.length; rank++) {
+        const rp = rankMap.get(rank);
+        if (rp) {
+            const np = rp.replace(/\\/g, "/").toLowerCase();
+            const candidate = pathToCandidate.get(np);
+            if (candidate)
+                reordered.push(candidate);
+        }
+    }
+    // Append any remaining not assigned a rank
+    for (const c of input) {
+        const np = (c.relativePath || "").replace(/\\/g, "/").toLowerCase();
+        if (!reordered.some((r) => (r.relativePath || "").replace(/\\/g, "/").toLowerCase() === np)) {
+            reordered.push(c);
+        }
+    }
+    return {
+        candidates: reordered,
+        fallbackTriggered: false,
+        fallbackReason: null,
+        validationPassed: true,
+    };
+}
+// --- 4. redactLlmRerankCandidate ---
+function redactLlmRerankCandidate(candidate) {
+    const redacted = {};
+    for (const key of Object.keys(candidate)) {
+        if (!FORBIDDEN_FIELDS.has(key)) {
+            redacted[key] = candidate[key];
+        }
+    }
+    return redacted;
+}
+// --- 5. createDeterministicFallback ---
+function createDeterministicFallback(input, reason) {
+    // Sort by originalRank ascending (preserves deterministic ordering)
+    const sorted = [...input].sort((a, b) => a.originalRank - b.originalRank);
+    return {
+        candidates: sorted,
+        fallbackTriggered: true,
+        fallbackReason: reason,
+        validationPassed: false,
+    };
+}
+//# sourceMappingURL=llmReranker.js.map

package/dist/pipeline/nodeScan.js

@@ -119,7 +119,26 @@ async function nodeScanWorkspace(workspacePath, profile, config, options = {}) {
             indexedTokens: discovery.indexedTokens,
             candidateFiles: discovery.candidateFiles,
             indexReusedFiles: discovery.indexReusedFiles,
-            indexUpdatedFiles: discovery.indexUpdatedFiles
+            indexUpdatedFiles: discovery.indexUpdatedFiles,
+            indexDeletedFiles: discovery.indexDeletedFiles,
+            indexDurationMs: discovery.indexDurationMs,
+            indexStatus: discovery.indexStatus,
+            partialReason: discovery.partialReason,
+            semanticRetrievalStatus: discovery.semanticRetrievalStatus,
+            semanticProvider: config.index.semanticProvider || "none",
+            semanticModel: config.index.semanticModel || "(empty)",
+            semanticErrorType: discovery.semanticErrorType,
+            semanticErrorMessage: discovery.semanticErrorMessage,
+            semanticEmbeddedFiles: discovery.semanticEmbeddedFiles ?? 0,
+            semanticCacheHits: discovery.semanticCacheHits ?? 0,
+            semanticCacheMisses: discovery.semanticCacheMisses ?? 0,
+            semanticHitCount: discovery.semanticHitCount ?? 0,
+            semanticAddedFileCount: discovery.semanticAddedFileCount ?? 0,
+            semanticSupportedFileCount: discovery.semanticSupportedFileCount ?? 0,
+            semanticFallbackUsed: discovery.semanticRetrievalStatus === "error_fallback",
+            deepCandidateDiscoveryCandidates: discovery.deepCandidateDiscoveryCandidates ?? 0,
+            deepCandidateDiscoveryAdded: discovery.deepCandidateDiscoveryAdded ?? 0,
+            deepCandidateDiscoveryAvoidBlocked: discovery.deepCandidateDiscoveryAvoidBlocked ?? 0
         }
     };
 }
@@ -136,12 +155,22 @@ async function discoverScanFiles(rootPath, profile, config, startedAt, options)
     if (!config.index.enableWorkspaceIndex) {
         return (0, fileDiscovery_1.discoverWorkspaceFiles)(rootPath, config, { startedAt, shouldCancel: options.shouldCancel });
     }
+    const idxStart = Date.now();
     const indexed = await (0, workspaceIndex_1.loadOrBuildWorkspaceIndex)(rootPath, config, {
         startedAt,
         shouldCancel: options.shouldCancel,
-        onProgress: options.onProgress
+        onProgress: options.onProgress,
+        readOnly: options.readOnly
     });
-    const candidates = (0, workspaceIndex_1.selectIndexCandidates)(indexed.index, profile, config);
+    const indexDurationMs = Date.now() - idxStart;
+    const selection = await (0, workspaceIndex_1.selectIndexCandidates)(indexed.index, profile, config);
+    const candidates = selection.files;
+    const semanticRetrievalStatus = selection.semanticStatus;
+    const semanticErrorType = selection.semanticErrorType;
+    const semanticErrorMessage = selection.semanticErrorMessage;
+    const deepCands = selection.deepCandidateDiscoveryCandidates ?? 0;
+    const deepAdded = selection.deepCandidateDiscoveryAdded ?? 0;
+    const deepBlocked = selection.deepCandidateDiscoveryAvoidBlocked ?? 0;
     const files = candidates.length > 0
         ? candidates
         : fallbackIndexCandidates(rootPath, indexed.index.files, config.index.maxIndexedCandidateFiles);
@@ -154,7 +183,23 @@ async function discoverScanFiles(rootPath, profile, config, startedAt, options)
         indexedTokens: indexed.indexedTokens,
         candidateFiles: files.length,
         indexReusedFiles: indexed.reusedFiles,
-        indexUpdatedFiles: indexed.updatedFiles
+        indexUpdatedFiles: indexed.updatedFiles,
+        indexDeletedFiles: indexed.deletedFiles,
+        indexStatus: indexed.stopReason ? "partial" : "fresh",
+        indexDurationMs,
+        partialReason: indexed.stopReason,
+        semanticRetrievalStatus,
+        semanticErrorType,
+        semanticErrorMessage,
+        semanticEmbeddedFiles: selection.semanticEmbeddedFiles ?? 0,
+        semanticCacheHits: selection.semanticCacheHits ?? 0,
+        semanticCacheMisses: selection.semanticCacheMisses ?? 0,
+        semanticHitCount: selection.semanticHitCount ?? 0,
+        semanticAddedFileCount: selection.semanticAddedFileCount ?? 0,
+        semanticSupportedFileCount: selection.semanticSupportedFileCount ?? 0,
+        deepCandidateDiscoveryCandidates: deepCands,
+        deepCandidateDiscoveryAdded: deepAdded,
+        deepCandidateDiscoveryAvoidBlocked: deepBlocked
     };
 }
 function fallbackIndexCandidates(rootPath, files, maxFiles) {
@@ -202,15 +247,49 @@ async function scanNodeFile(file, profile, config) {
     if (content.includes("\u0000")) {
         return { units: [], scanned: false, size: stat.size, tokenCount: 0 };
     }
+    var units = (0, fileScanner_1.scanTextFile)({
+        file: file.absolutePath,
+        relativePath: file.relativePath,
+        content,
+        size: stat.size,
+        profile,
+        config,
+        channelHits: file.channelHits,
+        retrievalTrace: file.retrievalTrace,
+        graphReasons: file.graphReasons
+    });
+    // Fallback: if a selected file has graphReasons but produced no units, create
+    // one minimal unit so the semantic evidence (discovered by semantic) is visible.
+    if (units.length === 0 && file.graphReasons && file.graphReasons.length > 0) {
+        units = [{
+                id: file.relativePath,
+                file: file.absolutePath,
+                relativePath: file.relativePath,
+                absolutePath: file.absolutePath,
+                size: stat.size,
+                kind: "file",
+                role: "read_context",
+                score: 0,
+                confidence: 0,
+                tier: "low",
+                reasons: [],
+                matchedTerms: [],
+                retrievalPasses: file.retrievalTrace ?? [],
+                imports: [],
+                channelHits: file.channelHits,
+                graphReasons: file.graphReasons,
+                lines: "0-0",
+                context: "",
+                contrastContext: false,
+                symbols: [],
+                symbolMatches: [],
+                subsystem: undefined,
+                subsystemTerms: [],
+                extractorKind: undefined
+            }];
+    }
     return {
-        units: (0, fileScanner_1.scanTextFile)({
-            file: file.absolutePath,
-            relativePath: file.relativePath,
-            content,
-            size: stat.size,
-            profile,
-            config
-        }),
+        units,
         scanned: true,
         size: stat.size,
         tokenCount: (0, text_1.fastTokenEstimate)(`${file.relativePath}\n${content}`)