flowseeker 0.1.7

package/dist/mcp/mcpProvider.js

@@ -0,0 +1,109 @@
+"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.registerFlowSeekerMcpProvider = registerFlowSeekerMcpProvider;
+const vscode = __importStar(require("vscode"));
+const capabilities_1 = require("../runtime/capabilities");
+const mcpConfig_1 = require("./mcpConfig");
+const logger_1 = require("../utils/logger");
+function registerFlowSeekerMcpProvider(context) {
+    const capabilities = (0, capabilities_1.getHostCapabilities)(context);
+    if (!capabilities.hasMcp || typeof vscode.lm?.registerMcpServerDefinitionProvider !== "function") {
+        (0, logger_1.logInfo)("MCP provider API is unavailable in this host. FlowSeeker MCP registration skipped.");
+        return undefined;
+    }
+    const disposable = vscode.lm.registerMcpServerDefinitionProvider("flowseeker", {
+        async provideMcpServerDefinitions() {
+            // Always expose FlowSeeker's own bundled MCP server first so the host can
+            // call it with zero manual config. User-defined servers are added on top.
+            const bundled = bundledFlowSeekerServer(context);
+            const configs = await (0, mcpConfig_1.loadMcpServerConfigs)();
+            const userServers = configs
+                .filter((server) => server.enabled !== false)
+                .filter((server) => server.name.toLowerCase() !== "flowseeker")
+                .flatMap(toMcpDefinition);
+            return bundled ? [bundled, ...userServers] : userServers;
+        },
+        resolveMcpServerDefinition(server) {
+            return server;
+        }
+    });
+    (0, logger_1.logInfo)("FlowSeeker MCP server definition provider registered (bundled server auto-exposed).");
+    return disposable;
+}
+function bundledFlowSeekerServer(context) {
+    try {
+        const serverPath = vscode.Uri.joinPath(context.extensionUri, "dist", "cli", "mcpServer.js").fsPath;
+        const workspaceFolder = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+        const args = [serverPath];
+        if (workspaceFolder) {
+            args.push("--workspace", workspaceFolder);
+        }
+        const definition = new vscode.McpStdioServerDefinition("flowseeker", process.execPath, args, { ELECTRON_RUN_AS_NODE: "1" });
+        if (workspaceFolder) {
+            definition.cwd = vscode.Uri.file(workspaceFolder);
+        }
+        return definition;
+    }
+    catch (error) {
+        (0, logger_1.logError)("Unable to create bundled FlowSeeker MCP server definition.", error);
+        return undefined;
+    }
+}
+function toMcpDefinition(server) {
+    try {
+        if (server.type === "http") {
+            if (!server.url) {
+                return [];
+            }
+            return [
+                new vscode.McpHttpServerDefinition(server.name, vscode.Uri.parse(server.url), server.headers, server.version)
+            ];
+        }
+        if (!server.command) {
+            return [];
+        }
+        const definition = new vscode.McpStdioServerDefinition(server.name, server.command, server.args ?? [], server.env ?? {}, server.version);
+        if (server.cwd) {
+            definition.cwd = vscode.Uri.file(server.cwd);
+        }
+        return [definition];
+    }
+    catch (error) {
+        (0, logger_1.logError)(`Unable to create MCP definition for ${server.name}.`, error);
+        return [];
+    }
+}
+//# sourceMappingURL=mcpProvider.js.map

package/dist/mcp/mcpTools.js

@@ -0,0 +1,215 @@
+"use strict";
+/**
+ * FlowSeeker MCP Tool Definitions and Handlers.
+ *
+ * Exposes FlowSeeker retrieval pipeline as MCP tools for use in:
+ * - Cursor, Antigravity, Windsurf, Claude Desktop
+ * - Any MCP-compliant AI client
+ *
+ * Tools run the headless pipeline (no VS Code dependency) and return structured results.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCP_PROMPT_DEFINITIONS = exports.TOOL_DEFINITIONS = void 0;
+exports.handleToolCall = handleToolCall;
+const loadConfigFromPath_1 = require("../config/loadConfigFromPath");
+const defaultConfig_1 = require("../config/defaultConfig");
+const runHeadless_1 = require("../pipeline/runHeadless");
+const solvePacket_1 = require("../pipeline/solvePacket");
+const agentPromptHeadless_1 = require("../pipeline/agentPromptHeadless");
+const fileGroups_1 = require("../pipeline/fileGroups");
+const tokenSavings_1 = require("../pipeline/tokenSavings");
+exports.TOOL_DEFINITIONS = [
+    {
+        name: "flowseeker_retrieve",
+        description: "Find relevant code context and return a full Solve Packet. Includes ranked files, context coverage, and token savings before code edits.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                task: {
+                    type: "string",
+                    description: "Natural-language task, bug, or feature to find code context for."
+                },
+                workspace: {
+                    type: "string",
+                    description: "Workspace root path. Use an absolute path if the IDE does not resolve cwd correctly."
+                },
+                maxFiles: {
+                    type: "number",
+                    description: "Maximum files to scan. Default: 5000."
+                }
+            },
+            required: ["task"]
+        }
+    },
+    {
+        name: "flowseeker_guide",
+        description: "Create an agent guidance prompt from relevant code context. Includes edit candidates, file context, and suggested verification steps.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                task: {
+                    type: "string",
+                    description: "Natural-language codebase task to prepare agent guidance for."
+                },
+                workspace: {
+                    type: "string",
+                    description: "Workspace root path. Use an absolute path if the IDE does not resolve cwd correctly."
+                }
+            },
+            required: ["task"]
+        }
+    },
+    {
+        name: "flowseeker_files",
+        description: "List top ranked files for a task. Lightweight result for quickly finding where to inspect or edit.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                task: {
+                    type: "string",
+                    description: "Natural-language codebase task to find relevant files for."
+                },
+                workspace: {
+                    type: "string",
+                    description: "Workspace root path. Use an absolute path if the IDE does not resolve cwd correctly."
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum number of files to return. Default: 15."
+                }
+            },
+            required: ["task"]
+        }
+    }
+];
+exports.MCP_PROMPT_DEFINITIONS = [
+    {
+        name: "retrieve",
+        description: "Find relevant code context and return a full Solve Packet.",
+        toolName: "flowseeker_retrieve",
+        toolPurpose: "return a full Solve Packet with ranked files, context coverage, and token savings",
+        arguments: [
+            { name: "task", description: "Task, bug, or feature to analyze.", required: true },
+            { name: "workspace", description: "Optional workspace root path." }
+        ]
+    },
+    {
+        name: "guide",
+        description: "Create an agent guidance prompt from relevant code context.",
+        toolName: "flowseeker_guide",
+        toolPurpose: "return an agent guidance prompt with relevant files, edit candidates, and verification steps",
+        arguments: [
+            { name: "task", description: "Task, bug, or feature to prepare guidance for.", required: true },
+            { name: "workspace", description: "Optional workspace root path." }
+        ]
+    },
+    {
+        name: "files",
+        description: "List top ranked files for a task.",
+        toolName: "flowseeker_files",
+        toolPurpose: "return a lightweight top-file list for quick inspection",
+        arguments: [
+            { name: "task", description: "Task, bug, or feature to find files for.", required: true },
+            { name: "workspace", description: "Optional workspace root path." },
+            { name: "limit", description: "Optional maximum number of files to return." }
+        ]
+    }
+];
+async function handleToolCall(toolName, input, defaultWorkspace) {
+    const workspace = input.workspace ?? defaultWorkspace;
+    const task = input.task?.trim();
+    if (!task) {
+        return errorResult("A task description is required.");
+    }
+    try {
+        switch (toolName) {
+            case "flowseeker_retrieve":
+                return await handleRetrieve(task, workspace, input.maxFiles);
+            case "flowseeker_guide":
+                return await handleGuide(task, workspace);
+            case "flowseeker_files":
+                return await handleFiles(task, workspace, input.limit);
+            default:
+                return errorResult(`Unknown tool: ${toolName}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return errorResult(`FlowSeeker failed: ${message}`);
+    }
+}
+// ── Individual Handlers ───────────────────────────────────────────────
+async function handleRetrieve(task, workspace, maxFiles) {
+    const result = await runPipeline(task, workspace, maxFiles);
+    const packet = result.solvePacket
+        ? (0, solvePacket_1.renderSolvePacketMarkdown)(result.solvePacket)
+        : result.contextPack;
+    const summary = formatResultSummary(result);
+    return textResult(`${summary}\n\n${packet}`);
+}
+async function handleGuide(task, workspace) {
+    const result = await runPipeline(task, workspace);
+    const prompt = (0, agentPromptHeadless_1.createAgentSolvePromptHeadless)(result);
+    const summary = formatResultSummary(result);
+    return textResult(`${summary}\n\n${prompt}`);
+}
+async function handleFiles(task, workspace, limit) {
+    const result = await runPipeline(task, workspace);
+    const groups = (0, fileGroups_1.aggregateEvidenceFiles)(result.units).slice(0, limit ?? 15);
+    const lines = [
+        `# FlowSeeker File Results`,
+        ``,
+        `Task: ${task}`,
+        `Intent: ${result.profile.intent}`,
+        `Keywords: ${result.profile.keywords.join(", ") || "none"}`,
+        `Scanned: ${result.stats.scannedFiles} files`,
+        `Evidence: ${result.units.length} units`,
+        ``,
+        `## Top Files`,
+        ``
+    ];
+    for (const [index, group] of groups.entries()) {
+        const ranges = group.ranges
+            .slice(0, 3)
+            .map((r) => `${r.startLine}-${r.endLine}`)
+            .join(", ");
+        lines.push(`${index + 1}. **${group.relativePath}**${ranges ? ` (lines: ${ranges})` : ""}`, `   Role: ${group.role} | Slot: ${group.slot ?? "unknown"} | Score: ${group.score.toFixed(1)} | Evidence: ${group.unitCount}`, ``);
+    }
+    return textResult(lines.join("\n"));
+}
+// ── Helpers ───────────────────────────────────────────────────────────
+async function runPipeline(task, workspace, maxFiles) {
+    const baseConfig = await (0, loadConfigFromPath_1.loadConfigFromPath)(workspace);
+    const config = maxFiles && maxFiles > 0
+        ? (0, defaultConfig_1.mergeConfig)(baseConfig, { pipeline: { ...baseConfig.pipeline, maxFiles } })
+        : baseConfig;
+    return (0, runHeadless_1.runFlowSeekerHeadless)(workspace, task, config, {
+        onStage: (stage, detail) => {
+            // MCP servers communicate via stdio; progress goes to stderr
+            process.stderr.write(`[FlowSeeker] ${stage}${detail ? `: ${detail}` : ""}\n`);
+        }
+    });
+}
+function formatResultSummary(result) {
+    const parts = [
+        `FlowSeeker retrieved **${result.units.length}** evidence unit(s) from **${result.stats.scannedFiles}** scanned file(s).`,
+        `Intent: \`${result.profile.intent}\``,
+        `Keywords: ${result.profile.keywords.map((k) => `\`${k}\``).join(", ") || "none"}`
+    ];
+    const ts = result.tokenSavings;
+    if (ts && ts.status !== "unavailable") {
+        parts.push(`Token savings: Solve Packet **${(0, tokenSavings_1.formatTokenCount)(ts.solvePacketTokensEstimate)}** / workspace **${(0, tokenSavings_1.formatTokenCount)(ts.workspaceTokensEstimate)}** tokens (**${(0, tokenSavings_1.formatReductionPercent)(ts.reductionPercent)}** reduction).`);
+    }
+    const cc = result.contextCoverage;
+    if (cc) {
+        parts.push(`Context coverage: **${cc.foundRequiredSlots.length}/${cc.requiredSlots.length}** required slot(s) found${cc.missingRequiredSlots.length ? `; missing: ${cc.missingRequiredSlots.join(", ")}` : ""}.`);
+    }
+    return parts.join("\n");
+}
+function textResult(text) {
+    return { content: [{ type: "text", text }] };
+}
+function errorResult(message) {
+    return { content: [{ type: "text", text: message }], isError: true };
+}
+//# sourceMappingURL=mcpTools.js.map

package/dist/pipeline/agentPrompt.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgentSolvePrompt = createAgentSolvePrompt;
+const fileGroups_1 = require("./fileGroups");
+function createAgentSolvePrompt(result, selectedUnits) {
+    const units = (0, fileGroups_1.selectDiverseEvidenceUnits)(selectedUnits.length > 0 ? selectedUnits : result.units, 2);
+    const editCandidates = units.filter((unit) => unit.role === "edit_candidate");
+    const readContext = units.filter((unit) => unit.role === "read_context" || unit.role === "impact" || unit.role === "verify");
+    const tests = units.filter((unit) => unit.role === "test");
+    const fileGroups = (0, fileGroups_1.aggregateEvidenceFiles)(selectedUnits.length > 0 ? selectedUnits : result.units);
+    const primaryEditFiles = fileGroups.filter((group) => group.role === "edit_candidate").slice(0, 8);
+    const readOnlyFiles = fileGroups.filter((group) => group.role !== "edit_candidate").slice(0, 12);
+    const allowedFiles = primaryEditFiles.map((group) => group.relativePath);
+    return [
+        "# FlowSeeker Agent Solve Prompt",
+        "",
+        "You are working inside a large codebase. Use the evidence below to solve the task with minimal additional context.",
+        "",
+        "## Task",
+        result.task,
+        "",
+        "## Retrieval Strategy",
+        `Intent: ${result.profile.intent}`,
+        `Strategies: ${result.profile.strategies.join(", ")}`,
+        `Keywords: ${result.profile.keywords.join(", ")}`,
+        "",
+        "## Guardrails",
+        "- Prefer editing only files listed in Allowed Edit Files.",
+        "- If the correct fix clearly requires another file, explain why before expanding scope.",
+        "- Use Read/Impact evidence to understand behavior, not as default edit targets.",
+        "- Update or add tests when a test evidence file is relevant.",
+        "- After edits, run the narrowest relevant checks first.",
+        "",
+        "## Allowed Edit Files",
+        allowedFiles.length > 0 ? allowedFiles.map((file) => `- ${file}`).join("\n") : "- None identified. Ask for more retrieval before editing.",
+        "",
+        "## File Scope",
+        renderFileScope(primaryEditFiles, readOnlyFiles),
+        "",
+        "## Edit Candidates",
+        renderUnits(editCandidates),
+        "",
+        "## Read / Impact Context",
+        renderUnits(readContext),
+        "",
+        "## Tests / Verification",
+        renderUnits(tests),
+        "",
+        "## Expected Agent Workflow",
+        "1. Read the edit candidates and relevant context snippets.",
+        "2. Identify the current behavior and target behavior from retrieval passes.",
+        "3. Apply the smallest coherent patch within Allowed Edit Files.",
+        "4. Update tests if the behavior changes.",
+        "5. Run focused checks and summarize changed files plus remaining risk.",
+        ""
+    ].join("\n");
+}
+function renderUnits(units) {
+    if (units.length === 0) {
+        return "- None";
+    }
+    return units
+        .map((unit) => {
+        const range = unit.range ? `:${unit.range.startLine}-${unit.range.endLine}` : "";
+        const passes = unit.retrievalPasses.length > 0 ? unit.retrievalPasses.join(", ") : "seed";
+        const reasons = unit.reasons.join("; ") || "ranked evidence";
+        const imports = unit.imports.length > 0 ? unit.imports.slice(0, 5).join(", ") : "none";
+        return [`- ${unit.relativePath}${range}`, `  Role: ${unit.role}; Kind: ${unit.kind}; Score: ${unit.score.toFixed(1)}; Passes: ${passes}`, `  Imports: ${imports}`, `  Reasons: ${reasons}`].join("\n");
+    })
+        .join("\n");
+}
+function renderFileScope(primaryEditFiles, readOnlyFiles) {
+    const lines = ["Primary edit files:"];
+    lines.push(...(primaryEditFiles.length > 0 ? primaryEditFiles.map((group) => `- ${group.relativePath} [${group.role}] score=${group.score.toFixed(1)} evidence=${group.unitCount}`) : ["- None"]));
+    lines.push("", "Read-only/context files:");
+    lines.push(...(readOnlyFiles.length > 0 ? readOnlyFiles.map((group) => `- ${group.relativePath} [${group.role}] score=${group.score.toFixed(1)} evidence=${group.unitCount}`) : ["- None"]));
+    return lines.join("\n");
+}
+//# sourceMappingURL=agentPrompt.js.map

package/dist/pipeline/agentPromptHeadless.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Headless agent solve prompt — no VS Code dependency.
+ * Used by MCP server and CLI tools that run outside the extension host.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgentSolvePromptHeadless = createAgentSolvePromptHeadless;
+const fileGroups_1 = require("./fileGroups");
+const solvePacket_1 = require("./solvePacket");
+const tokenSavings_1 = require("./tokenSavings");
+function createAgentSolvePromptHeadless(result) {
+    const units = (0, fileGroups_1.selectDiverseEvidenceUnits)(result.units, 2);
+    const editCandidates = units.filter((unit) => unit.role === "edit_candidate");
+    const readContext = units.filter((unit) => unit.role === "read_context" || unit.role === "impact" || unit.role === "verify");
+    const tests = units.filter((unit) => unit.role === "test");
+    const fileGroups = (0, fileGroups_1.aggregateEvidenceFiles)(result.units);
+    const primaryEditFiles = fileGroups.filter((group) => group.role === "edit_candidate").slice(0, 8);
+    const readOnlyFiles = fileGroups.filter((group) => group.role !== "edit_candidate").slice(0, 12);
+    const allowedFiles = primaryEditFiles.map((group) => group.relativePath);
+    const packetSection = result.solvePacket
+        ? (0, solvePacket_1.renderSolvePacketMarkdown)(result.solvePacket)
+        : renderFallbackContextPack(result);
+    return [
+        "# FlowSeeker Agent Solve Prompt",
+        "",
+        "You are working inside a large codebase. FlowSeeker has retrieved a bounded context pack to reduce token usage.",
+        "Use the evidence below to solve the task with minimal additional context.",
+        "",
+        renderTokenSavingsHeadless(result),
+        "",
+        "## Task",
+        result.task,
+        "",
+        "## Retrieval Strategy",
+        `Intent: ${result.profile.intent}`,
+        `Strategies: ${result.profile.strategies.join(", ")}`,
+        `Keywords: ${result.profile.keywords.join(", ")}`,
+        "",
+        "## Guardrails",
+        "- Prefer editing only files listed in Allowed Edit Files.",
+        "- If the correct fix clearly requires another file, explain why before expanding scope.",
+        "- Use Read/Impact evidence to understand behavior, not as default edit targets.",
+        "- Update or add tests when a test evidence file is relevant.",
+        "- After edits, run the narrowest relevant checks first.",
+        "",
+        "## Allowed Edit Files",
+        allowedFiles.length > 0 ? allowedFiles.map((file) => `- ${file}`).join("\n") : "- None identified. Ask for more retrieval before editing.",
+        "",
+        "## File Scope",
+        renderFileScope(primaryEditFiles, readOnlyFiles),
+        "",
+        packetSection,
+        "",
+        "## Expected Agent Workflow",
+        "1. Read the edit candidates and relevant context snippets.",
+        "2. Identify the current behavior and target behavior from retrieval passes.",
+        "3. Apply the smallest coherent patch within Allowed Edit Files.",
+        "4. Update tests if the behavior changes.",
+        "5. Run focused checks and summarize changed files plus remaining risk.",
+        ""
+    ].join("\n");
+}
+function renderTokenSavingsHeadless(result) {
+    const metrics = result.tokenSavings;
+    if (!metrics || metrics.status === "unavailable") {
+        return "Token savings metrics are unavailable for this run.";
+    }
+    const basis = metrics.basis === "workspace_index" ? "workspace index" : "scanned candidate text";
+    return `Measured token savings: Solve Packet ${(0, tokenSavings_1.formatTokenCount)(metrics.solvePacketTokensEstimate)} tokens vs ${basis} ${(0, tokenSavings_1.formatTokenCount)(metrics.workspaceTokensEstimate)} tokens (${(0, tokenSavings_1.formatReductionPercent)(metrics.reductionPercent)} reduction).`;
+}
+function renderFallbackContextPack(result) {
+    return result.contextPack;
+}
+function renderFileScope(primaryEditFiles, readOnlyFiles) {
+    const lines = ["Primary edit files:"];
+    lines.push(...(primaryEditFiles.length > 0
+        ? primaryEditFiles.map((group) => `- ${group.relativePath} [${group.role}] score=${group.score.toFixed(1)} evidence=${group.unitCount}`)
+        : ["- None"]));
+    lines.push("", "Read-only/context files:");
+    lines.push(...(readOnlyFiles.length > 0
+        ? readOnlyFiles.map((group) => `- ${group.relativePath} [${group.role}] score=${group.score.toFixed(1)} evidence=${group.unitCount}`)
+        : ["- None"]));
+    return lines.join("\n");
+}
+//# sourceMappingURL=agentPromptHeadless.js.map