flowseeker 0.1.7 → 0.1.9

package/dist/pipeline/retrievalFusion.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fuseRetrievalChannelHits = fuseRetrievalChannelHits;
+const defaultRrfK = 60;
+const defaultChannelWeights = {
+    exact_literal: 1.4,
+    path: 1.3,
+    symbol: 1.25,
+    lexical_content: 1,
+    semantic_vector: 0.9,
+    graph: 0.85,
+    dependency: 0.75,
+    editor_context: 0.4
+};
+function fuseRetrievalChannelHits(channelHits, options = {}) {
+    const rrfK = options.rrfK ?? defaultRrfK;
+    const weights = { ...defaultChannelWeights, ...options.channelWeights };
+    const candidates = new Map();
+    for (const hit of channelHits) {
+        const current = candidates.get(hit.relativePath) ?? {
+            relativePath: hit.relativePath,
+            score: 0,
+            channelHits: [],
+            topChannel: hit.channel,
+            reasons: []
+        };
+        const channelWeight = weights[hit.channel] ?? 1;
+        const previousTopScore = Math.max(0, ...current.channelHits.map((item) => item.score));
+        current.score += channelWeight / (rrfK + Math.max(1, hit.rank));
+        current.channelHits.push(hit);
+        if (hit.reason && !current.reasons.includes(hit.reason)) {
+            current.reasons.push(hit.reason);
+        }
+        if (hit.score > previousTopScore) {
+            current.topChannel = hit.channel;
+        }
+        candidates.set(hit.relativePath, current);
+    }
+    return Array.from(candidates.values()).sort((a, b) => b.score - a.score);
+}
+//# sourceMappingURL=retrievalFusion.js.map

package/dist/pipeline/roleRefinement.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyRoleRefinement = applyRoleRefinement;
+function applyRoleRefinement(units, profile, config) {
+    const mode = config.pipeline.roleRefinementMode ?? "off";
+    if (mode !== "conservative")
+        return { units, demotions: [] };
+    const taskLower = profile.normalizedTask || "";
+    const taskShape = profile.taskShape || "unknown";
+    const taskExplicitlyTargetsTests = /\b(test|spec|verify|assert)\b/i.test(taskLower);
+    const taskTargetsRouteConfig = /\b(route|router|endpoint|url|config|env|setting)\b/i.test(taskLower);
+    const taskTargetsViewUI = /\b(view|page|layout|render|blade|template|ui|frontend|modal|component)\b/i.test(taskLower);
+    const taskNeedsSideEffects = /\b(job|queue|event|listener|notify|notification|email|mail|dispatch|async|webhook|cron|command|console)\b/i.test(taskLower);
+    const taskNamedFiles = extractNamedFiles(taskLower);
+    const demotions = [];
+    const refined = units.map((unit) => {
+        if (unit.role !== "edit_candidate")
+            return unit;
+        const fp = (unit.relativePath || "").toLowerCase().replace(/\\/g, "/");
+        const taskMentionsFile = taskNamedFiles.some((n) => fp.includes(n));
+        // Rule 1: tests/specs → test
+        if (!taskExplicitlyTargetsTests && /(^|\/)(tests?|specs?|__tests__)(\/|$)/.test(fp)) {
+            demotions.push({ filePath: unit.relativePath, beforeRole: "edit_candidate", afterRole: "test", reason: "test path demoted — task does not target tests", ruleId: "demote_test", confidence: "high", taskShape });
+            return { ...unit, role: "test" };
+        }
+        // Rule 2: routes/config/views → read_context
+        if (!taskTargetsRouteConfig && /(^|\/)(routes?|router|config)(\/|$)/.test(fp)) {
+            demotions.push({ filePath: unit.relativePath, beforeRole: "edit_candidate", afterRole: "read_context", reason: "route/config demoted to read_context — task does not target routing/config", ruleId: "demote_route_config", confidence: "high", taskShape });
+            return { ...unit, role: "read_context" };
+        }
+        if (!taskTargetsViewUI && /(^|\/)resources\/views(\/|$)/.test(fp)) {
+            demotions.push({ filePath: unit.relativePath, beforeRole: "edit_candidate", afterRole: "read_context", reason: "view demoted to read_context — task does not target UI/view", ruleId: "demote_view", confidence: "high", taskShape });
+            return { ...unit, role: "read_context" };
+        }
+        // Rule 3: helpers/utilities → read_context
+        if (!taskMentionsFile && /(^|\/)(helpers?|utils?)(\/|$)/i.test(fp)) {
+            demotions.push({ filePath: unit.relativePath, beforeRole: "edit_candidate", afterRole: "read_context", reason: "helper/utility demoted to read_context — not directly named by task", ruleId: "demote_helper", confidence: "medium", taskShape });
+            return { ...unit, role: "read_context" };
+        }
+        // Rule 4: side effects → read_context unless task needs them (includes Console/Commands)
+        if (!taskNeedsSideEffects && /(^|\/)(Jobs|Events|Listeners|Mail|Notifications|Console\/Commands)(\/|$)/i.test(fp)) {
+            demotions.push({ filePath: unit.relativePath, beforeRole: "edit_candidate", afterRole: "read_context", reason: "side_effect file demoted to read_context — task does not need side effects", ruleId: "demote_side_effect", confidence: "high", taskShape });
+            return { ...unit, role: "read_context" };
+        }
+        // Rule 5: contrast/avoid → read_context
+        if (unit.contrastContext || unit.taskAvoidGuardFlag === "demoted" || unit.taskAvoidGuardFlag === "blocked_slot") {
+            demotions.push({ filePath: unit.relativePath, beforeRole: "edit_candidate", afterRole: "read_context", reason: "contrast/avoid file demoted — flagged by guard", ruleId: "demote_contrast_avoid", confidence: "high", taskShape });
+            return { ...unit, role: "read_context" };
+        }
+        return unit;
+    });
+    return { units: refined, demotions };
+}
+function extractNamedFiles(taskLower) {
+    const names = [];
+    const m = taskLower.match(/['"]?([\w./-]+\.(?:php|ts|js|py|java|rb|go|cs|kt|rs|dart))['"]?/g);
+    if (m)
+        for (const n of m)
+            names.push(n.replace(/['"]/g, "").toLowerCase());
+    return names;
+}
+//# sourceMappingURL=roleRefinement.js.map

package/dist/pipeline/runHeadless.js

@@ -7,20 +7,32 @@ const evidenceGraph_1 = require("./evidenceGraph");
 const contextBlueprint_1 = require("./contextBlueprint");
 const nodeScan_1 = require("./nodeScan");
 const ranker_1 = require("./ranker");
+const roleRefinement_1 = require("./roleRefinement");
 const solvePacket_1 = require("./solvePacket");
 const taskUnderstanding_1 = require("./taskUnderstanding");
 const tokenSavings_1 = require("./tokenSavings");
+const semanticChunkIndex_1 = require("../index/semanticChunkIndex");
 async function runFlowSeekerHeadless(workspacePath, task, config, options = {}) {
     const log = (stage, detail) => options.onStage?.(stage, detail);
     log("task", task);
-    const profile = (0, taskUnderstanding_1.understandTask)(task, config);
+    const tTaskStart = performance.now();
+    const profile = await (0, taskUnderstanding_1.understandTask)(task, config, workspacePath);
+    const taskDurationMs = Math.round(performance.now() - tTaskStart);
     log("scan", `${profile.intent} | ${profile.keywords.length} keywords`);
+    const tScanStart = performance.now();
     const scan = await (0, nodeScan_1.nodeScanWorkspace)(workspacePath, profile, config, options);
+    const scanLoopDurationMs = Math.round(performance.now() - tScanStart);
     log("rank", `${scan.units.length} raw units from ${scan.stats.scannedFiles} files`);
+    const tRank1Start = performance.now();
     const ranked = (0, ranker_1.rankEvidence)(scan.units, config, profile);
+    const rankFirstPassDurationMs = Math.round(performance.now() - tRank1Start);
     log("graph", `${ranked.length} units`);
+    const tGraphStart = performance.now();
     const graph = (0, evidenceGraph_1.buildEvidenceGraph)(ranked);
+    const graphBuildDurationMs = Math.round(performance.now() - tGraphStart);
+    const tFrameworkStart = performance.now();
     const frameworkResult = await (0, async_1.withTimeout)((0, evidenceGraph_1.extractFrameworkEdges)(ranked, (msg) => options.onStage?.("framework", msg)), 15000, "framework edge extraction").catch(() => ({ edges: [], newUnits: [] }));
+    const frameworkExpansionDurationMs = Math.round(performance.now() - tFrameworkStart);
     if (frameworkResult.edges.length > 0 || frameworkResult.newUnits.length > 0) {
         log("framework", `${frameworkResult.edges.length} edges, ${frameworkResult.newUnits.length} discovered`);
     }
@@ -31,24 +43,67 @@ async function runFlowSeekerHeadless(workspacePath, task, config, options = {})
     if (frameworkResult.newUnits.length > 0) {
         allUnits = [...ranked, ...frameworkResult.newUnits];
     }
+    const tBoostStart = performance.now();
     const graphBoosted = (0, evidenceGraph_1.boostWithGraph)(allUnits, graph);
+    const graphBoostDurationMs = Math.round(performance.now() - tBoostStart);
+    const tRank2Start = performance.now();
     const finalUnits = (0, ranker_1.rankEvidence)(graphBoosted, config, profile);
-    const contextPack = (0, contextPack_1.createContextPack)(task, finalUnits, config);
+    const rankFinalPassDurationMs = Math.round(performance.now() - tRank2Start);
+    // Conservative role demotion (16B, config-gated, default off)
+    const refinement = (0, roleRefinement_1.applyRoleRefinement)(finalUnits, profile, config);
+    const refinedUnits = refinement.units;
+    const tCtxStart = performance.now();
+    const contextPack = (0, contextPack_1.createContextPack)(task, refinedUnits, config);
+    const contextPackDurationMs = Math.round(performance.now() - tCtxStart);
     const result = {
         task,
         profile,
-        units: finalUnits,
+        units: refinedUnits,
         contextPack,
         stats: {
             ...scan.stats,
             rankedEvidenceCount: finalUnits.length,
             maxCandidates: config.pipeline.maxCandidates,
-            capped: scan.stats.rawEvidenceCount > finalUnits.length
+            capped: scan.stats.rawEvidenceCount > finalUnits.length,
+            // Role refinement telemetry (16B/16D-R1) — needed before buildSolvePacket
+            roleRefinementMode: config.pipeline.roleRefinementMode ?? "off",
+            roleDemotions: refinement.demotions.length,
+            roleDemotionLog: refinement.demotions.slice(0, 100),
         }
     };
-    result.solvePacket = await (0, solvePacket_1.buildSolvePacket)(result, config);
+    const tSolveStart = performance.now();
+    result.solvePacket = await (0, solvePacket_1.buildSolvePacket)(result, config, workspacePath);
+    const solvePacketDurationMs = Math.round(performance.now() - tSolveStart);
+    const tPostStart = performance.now();
     result.contextCoverage = (0, contextBlueprint_1.computeContextCoverage)(profile, finalUnits);
     result.tokenSavings = (0, tokenSavings_1.computeTokenSavings)(result);
+    // Semantic chunk diagnostics (18A — report-only, disabled by default)
+    result.stats = {
+        ...result.stats,
+        semanticChunkDiagnostic: (0, semanticChunkIndex_1.buildSemanticChunkDiagnostic)(config, {
+            chunksConsidered: 0, cacheHits: 0, cacheMisses: 0,
+            candidatesFound: 0, candidatesAccepted: 0, candidatesRejected: 0,
+            topK: 0, providerReady: false,
+            contributionReport: (0, semanticChunkIndex_1.buildContributionReport)(false, false, 0, 0),
+            hybridPromotionReport: (0, semanticChunkIndex_1.buildHybridPromotionReport)(false, false, [], [], []),
+        }),
+    };
+    const postProcessDurationMs = Math.round(performance.now() - tPostStart);
+    const totalDurationMs = taskDurationMs + scanLoopDurationMs + rankFirstPassDurationMs + graphBuildDurationMs + frameworkExpansionDurationMs + graphBoostDurationMs + rankFinalPassDurationMs + contextPackDurationMs + solvePacketDurationMs + postProcessDurationMs;
+    result.stats = {
+        ...result.stats,
+        totalDurationMs,
+        taskDurationMs,
+        scanLoopDurationMs,
+        rankFirstPassDurationMs,
+        graphBuildDurationMs,
+        frameworkExpansionDurationMs,
+        graphBoostDurationMs,
+        rankFinalPassDurationMs,
+        contextPackDurationMs,
+        solvePacketDurationMs,
+        postProcessDurationMs
+    };
     return result;
 }
 //# sourceMappingURL=runHeadless.js.map

package/dist/pipeline/runPipeline.js

@@ -47,7 +47,7 @@ const tokenSavings_1 = require("./tokenSavings");
 const universalScan_1 = require("./universalScan");
 async function runFlowSeeker(task, options = {}) {
     const config = await (0, loadConfig_1.loadConfig)();
-    const profile = (0, taskUnderstanding_1.understandTask)(task, config);
+    const profile = await (0, taskUnderstanding_1.understandTask)(task, config, process.cwd());
     // Collect editor context for ranking bias (only in VS Code; null in headless).
     const editorContext = options.editorContext ?? collectEditorContext();
     options.progress?.report({ message: `Scanning workspace for "${task.slice(0, 60)}..."` });
@@ -85,7 +85,7 @@ async function runFlowSeeker(task, options = {}) {
             capped: scan.stats.rawEvidenceCount > finalUnits.length
         }
     };
-    result.solvePacket = await (0, solvePacket_1.buildSolvePacket)(result, config);
+    result.solvePacket = await (0, solvePacket_1.buildSolvePacket)(result, config, process.cwd());
     result.contextCoverage = (0, contextBlueprint_1.computeContextCoverage)(profile, finalUnits);
     result.tokenSavings = (0, tokenSavings_1.computeTokenSavings)(result);
     return result;