flowseeker 0.1.7

package/dist/pipeline/retrievalPlan.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRetrievalPlan = createRetrievalPlan;
+const contextBlueprint_1 = require("./contextBlueprint");
+const text_1 = require("../utils/text");
+function createRetrievalPlan(input, config) {
+    const strategies = detectStrategies(input.normalizedTask, input.concepts);
+    const passes = [
+        {
+            id: "seed",
+            label: "Seed concepts",
+            strategy: "seed_search",
+            purpose: "seed",
+            terms: weightedTerms(input.concepts, 3, "concept")
+                .concat(weightedTerms(input.actions, 1.5, "action"))
+                .concat(weightedTerms(expandConfigSynonyms(input.keywords, config), 2, "synonym"))
+        }
+    ];
+    const behaviorChange = extractBehaviorChange(input.normalizedTask);
+    if (behaviorChange) {
+        passes.push({
+            id: "current-behavior",
+            label: "Current behavior",
+            strategy: "behavior_change",
+            purpose: "find_current",
+            terms: weightedTerms((0, text_1.splitIdentifier)(behaviorChange.current), 4, "current_behavior")
+        });
+        passes.push({
+            id: "target-behavior",
+            label: "Target behavior",
+            strategy: "behavior_change",
+            purpose: "find_target",
+            terms: weightedTerms((0, text_1.splitIdentifier)(behaviorChange.target), 4, "target_behavior")
+        });
+    }
+    const transition = extractStateTransition(input.normalizedTask);
+    if (transition) {
+        passes.push({
+            id: "transition-gate",
+            label: "State transition gate",
+            strategy: "state_transition_side_effect",
+            purpose: "find_transition",
+            terms: weightedTerms((0, text_1.splitIdentifier)(transition.when), 4, "constraint")
+        });
+        passes.push({
+            id: "side-effect",
+            label: "Side effect",
+            strategy: "state_transition_side_effect",
+            purpose: "find_target",
+            terms: weightedTerms((0, text_1.splitIdentifier)(transition.then), 4, "target_behavior")
+        });
+    }
+    if (strategies.includes("identity_or_key_change")) {
+        passes.push({
+            id: "identity-key",
+            label: "Identity/key usage",
+            strategy: "identity_or_key_change",
+            purpose: "find_current",
+            terms: weightedTerms(["id", "key", "name", "slug", "lookup", "find", "where", "filter", "compare"], 2.5, "strategy")
+        });
+    }
+    if (strategies.includes("failure_investigation")) {
+        passes.push({
+            id: "failure-signals",
+            label: "Failure and handling signals",
+            strategy: "failure_investigation",
+            purpose: "find_context",
+            terms: weightedTerms(["error", "fail", "failed", "exception", "catch", "retry", "fallback", "log", "warning"], 2, "strategy")
+        });
+    }
+    for (const slot of (0, contextBlueprint_1.allContextSlots)(input.blueprint)) {
+        const slotTerms = (0, contextBlueprint_1.slotSearchTerms)(slot);
+        if (slotTerms.length === 0) {
+            continue;
+        }
+        passes.push({
+            id: `coverage-${slot}`,
+            label: `${(0, contextBlueprint_1.contextSlotLabel)(slot)} coverage`,
+            strategy: "flow_coverage",
+            purpose: slot === "tests" ? "find_tests" : "find_coverage",
+            terms: weightedTerms(slotTerms, input.blueprint.requiredSlots.includes(slot) ? 0.35 : 0.25, "coverage")
+        });
+    }
+    passes.push({
+        id: "tests",
+        label: "Tests and verification",
+        strategy: "seed_search",
+        purpose: "find_tests",
+        terms: weightedTerms(input.concepts, 1.5, "strategy")
+    });
+    return {
+        strategies: (0, text_1.uniq)(strategies.concat("seed_search", "flow_coverage")),
+        passes: passes.map((pass) => ({ ...pass, terms: mergeTerms(pass.terms) })).filter((pass) => pass.terms.length > 0)
+    };
+}
+function detectStrategies(normalizedTask, concepts) {
+    const strategies = ["seed_search"];
+    if (/\b(tu|from|instead|instead of|thay vi|thay bang|sang|doi tu|change from)\b/.test(normalizedTask)) {
+        strategies.push("behavior_change");
+    }
+    if (/\b(sau khi|after|when|once|on success|success|successful|thanh cong)\b/.test(normalizedTask)) {
+        strategies.push("state_transition_side_effect");
+    }
+    if (/\b(id|key|name|ten|slug|identifier)\b/.test(normalizedTask) && /\b(thay vi|instead|bang|by|lookup|find|where)\b/.test(normalizedTask)) {
+        strategies.push("identity_or_key_change");
+    }
+    if (/\b(error|fail|failed|bug|loi|khong|exception|crash|timeout)\b/.test(normalizedTask)) {
+        strategies.push("failure_investigation");
+    }
+    if (concepts.some((term) => ["config", "env", "schema", "migration", "database", "table"].includes(term))) {
+        strategies.push("data_or_config_change");
+    }
+    return (0, text_1.uniq)(strategies);
+}
+function extractBehaviorChange(normalizedTask) {
+    const patterns = [
+        /(?:tu|from)\s+(.+?)\s+(?:sang|to|thanh|thanh\s+|instead|thay vi)\s+(.+)$/,
+        /(?:thay|change|doi)\s+(.+?)\s+(?:bang|by|with|to)\s+(.+)$/
+    ];
+    for (const pattern of patterns) {
+        const match = normalizedTask.match(pattern);
+        if (match?.[1] && match[2]) {
+            return { current: match[1], target: match[2] };
+        }
+    }
+    return undefined;
+}
+function extractStateTransition(normalizedTask) {
+    const match = normalizedTask.match(/(?:sau khi|after|when|once)\s+(.+?)\s+(?:moi|then|thi|do|run|send|call)\s+(.+)$/);
+    if (match?.[1] && match[2]) {
+        return { when: match[1], then: match[2] };
+    }
+    return undefined;
+}
+function expandConfigSynonyms(keywords, config) {
+    const normalized = new Set(keywords.map(text_1.normalizeText));
+    const expanded = [];
+    for (const [key, values] of Object.entries(config.synonyms)) {
+        const candidates = [key, ...values];
+        if (candidates.some((candidate) => normalized.has((0, text_1.normalizeText)(candidate)))) {
+            expanded.push(...candidates);
+        }
+    }
+    return expanded;
+}
+function weightedTerms(terms, weight, source) {
+    return terms
+        .map(text_1.normalizeText)
+        .flatMap(text_1.splitIdentifier)
+        .filter((term) => term.length > 1)
+        .map((term) => ({ term, weight, source }));
+}
+function mergeTerms(terms) {
+    const byTerm = new Map();
+    for (const term of terms) {
+        const existing = byTerm.get(term.term);
+        if (!existing || term.weight > existing.weight) {
+            byTerm.set(term.term, term);
+        }
+    }
+    return Array.from(byTerm.values());
+}
+//# sourceMappingURL=retrievalPlan.js.map

package/dist/pipeline/runHeadless.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFlowSeekerHeadless = runFlowSeekerHeadless;
+const async_1 = require("../utils/async");
+const contextPack_1 = require("./contextPack");
+const evidenceGraph_1 = require("./evidenceGraph");
+const contextBlueprint_1 = require("./contextBlueprint");
+const nodeScan_1 = require("./nodeScan");
+const ranker_1 = require("./ranker");
+const solvePacket_1 = require("./solvePacket");
+const taskUnderstanding_1 = require("./taskUnderstanding");
+const tokenSavings_1 = require("./tokenSavings");
+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);
+    log("scan", `${profile.intent} | ${profile.keywords.length} keywords`);
+    const scan = await (0, nodeScan_1.nodeScanWorkspace)(workspacePath, profile, config, options);
+    log("rank", `${scan.units.length} raw units from ${scan.stats.scannedFiles} files`);
+    const ranked = (0, ranker_1.rankEvidence)(scan.units, config, profile);
+    log("graph", `${ranked.length} units`);
+    const graph = (0, evidenceGraph_1.buildEvidenceGraph)(ranked);
+    const frameworkResult = await (0, async_1.withTimeout)((0, evidenceGraph_1.extractFrameworkEdges)(ranked, (msg) => options.onStage?.("framework", msg)), 15000, "framework edge extraction").catch(() => ({ edges: [], newUnits: [] }));
+    if (frameworkResult.edges.length > 0 || frameworkResult.newUnits.length > 0) {
+        log("framework", `${frameworkResult.edges.length} edges, ${frameworkResult.newUnits.length} discovered`);
+    }
+    let allUnits = ranked;
+    if (frameworkResult.edges.length > 0) {
+        graph.edges.push(...frameworkResult.edges);
+    }
+    if (frameworkResult.newUnits.length > 0) {
+        allUnits = [...ranked, ...frameworkResult.newUnits];
+    }
+    const graphBoosted = (0, evidenceGraph_1.boostWithGraph)(allUnits, graph);
+    const finalUnits = (0, ranker_1.rankEvidence)(graphBoosted, config, profile);
+    const contextPack = (0, contextPack_1.createContextPack)(task, finalUnits, config);
+    const result = {
+        task,
+        profile,
+        units: finalUnits,
+        contextPack,
+        stats: {
+            ...scan.stats,
+            rankedEvidenceCount: finalUnits.length,
+            maxCandidates: config.pipeline.maxCandidates,
+            capped: scan.stats.rawEvidenceCount > finalUnits.length
+        }
+    };
+    result.solvePacket = await (0, solvePacket_1.buildSolvePacket)(result, config);
+    result.contextCoverage = (0, contextBlueprint_1.computeContextCoverage)(profile, finalUnits);
+    result.tokenSavings = (0, tokenSavings_1.computeTokenSavings)(result);
+    return result;
+}
+//# sourceMappingURL=runHeadless.js.map

package/dist/pipeline/runPipeline.js

@@ -0,0 +1,114 @@
+"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.runFlowSeeker = runFlowSeeker;
+const vscode = __importStar(require("vscode"));
+const loadConfig_1 = require("../config/loadConfig");
+const async_1 = require("../utils/async");
+const contextPack_1 = require("./contextPack");
+const evidenceGraph_1 = require("./evidenceGraph");
+const contextBlueprint_1 = require("./contextBlueprint");
+const ranker_1 = require("./ranker");
+const solvePacket_1 = require("./solvePacket");
+const taskUnderstanding_1 = require("./taskUnderstanding");
+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);
+    // 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)}..."` });
+    const scan = await (0, universalScan_1.universalScan)(profile, config, options);
+    options.progress?.report({ message: `Ranking ${scan.units.length} evidence units from ${scan.stats.scannedFiles} files...` });
+    const ranked = (0, ranker_1.rankEvidence)(scan.units, config, profile, { editorContext });
+    options.progress?.report({ message: "Building evidence graph..." });
+    (0, async_1.checkCancelled)(options.token);
+    const graph = (0, evidenceGraph_1.buildEvidenceGraph)(ranked);
+    options.progress?.report({ message: "Extracting framework edges..." });
+    (0, async_1.checkCancelled)(options.token);
+    const frameworkResult = await (0, async_1.withTimeout)((0, evidenceGraph_1.extractFrameworkEdges)(ranked, (msg) => options.progress?.report({ message: msg })), 15000, "framework edge extraction").catch(() => {
+        options.progress?.report({ message: "Framework edges timed out — continuing without them." });
+        return { edges: [], newUnits: [] };
+    });
+    let allUnits = ranked;
+    if (frameworkResult.edges.length > 0) {
+        graph.edges.push(...frameworkResult.edges);
+    }
+    if (frameworkResult.newUnits.length > 0) {
+        allUnits = [...ranked, ...frameworkResult.newUnits];
+    }
+    const graphBoosted = (0, evidenceGraph_1.boostWithGraph)(allUnits, graph);
+    const finalUnits = (0, ranker_1.rankEvidence)(graphBoosted, config, profile, { editorContext });
+    const contextPack = (0, contextPack_1.createContextPack)(task, finalUnits, config);
+    const result = {
+        task,
+        profile,
+        units: finalUnits,
+        contextPack,
+        stats: {
+            ...scan.stats,
+            rankedEvidenceCount: finalUnits.length,
+            maxCandidates: config.pipeline.maxCandidates,
+            capped: scan.stats.rawEvidenceCount > finalUnits.length
+        }
+    };
+    result.solvePacket = await (0, solvePacket_1.buildSolvePacket)(result, config);
+    result.contextCoverage = (0, contextBlueprint_1.computeContextCoverage)(profile, finalUnits);
+    result.tokenSavings = (0, tokenSavings_1.computeTokenSavings)(result);
+    return result;
+}
+function collectEditorContext() {
+    try {
+        const activeEditorUri = vscode.window.activeTextEditor?.document.uri.fsPath;
+        const tabs = vscode.window.tabGroups.all
+            .flatMap((group) => group.tabs)
+            .filter((tab) => {
+            const input = tab.input;
+            return input !== undefined && input !== null && typeof input === "object" && "uri" in input;
+        })
+            .map((tab) => tab.input.uri.fsPath)
+            .filter(Boolean);
+        const uniqueTabs = Array.from(new Set(tabs));
+        return {
+            activeFile: activeEditorUri,
+            recentFiles: uniqueTabs.length > 0 ? uniqueTabs.slice(0, 10) : undefined
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=runPipeline.js.map