flowseeker 0.1.7

package/dist/chat/nativeChatParticipant.js

@@ -0,0 +1,616 @@
+"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.registerNativeChatParticipant = registerNativeChatParticipant;
+const vscode = __importStar(require("vscode"));
+const aiGateway_1 = require("../gateway/aiGateway");
+const agentPrompts_1 = require("../gateway/agentPrompts");
+const editProposalStore_1 = require("../gateway/editProposalStore");
+const fileGroups_1 = require("../pipeline/fileGroups");
+const runPipeline_1 = require("../pipeline/runPipeline");
+const diffPreview_1 = require("../pipeline/diffPreview");
+const tokenSavings_1 = require("../pipeline/tokenSavings");
+const logger_1 = require("../utils/logger");
+const contextExpansion_1 = require("../gateway/contextExpansion");
+const participantId = "flowseeker.participant";
+function registerNativeChatParticipant(context, resultProvider, gateway, editStore, planStore, skillRegistry) {
+    const handler = async (request, _chatContext, stream, token) => {
+        let task = request.prompt.trim();
+        if (request.command === "apply") {
+            return handleApprovedPlan(request, stream, token, gateway, editStore, planStore);
+        }
+        // Skill commands: /skillName → prepend skill prompt to user request
+        const skill = skillRegistry.getSkill(request.command ?? "");
+        if (skill && !task) {
+            stream.markdown(`**${skill.name}** — ${skill.description}\n\nDescribe what you want to ${skill.name}.`);
+            return {};
+        }
+        if (skill && task) {
+            task = `${skill.prompt}\n\nUser request: ${task}`;
+        }
+        if (!task) {
+            stream.markdown("Describe the codebase task you want FlowSeeker to solve.");
+            return {};
+        }
+        const mode = skill?.mode === "auto" ? "auto" : commandToMode(request.command);
+        try {
+            (0, logger_1.logInfo)(`Native chat scan started for task: ${task}`);
+            const result = await runWithCompactProgress(stream, "FlowSeeker", "Finding relevant files before asking the agent...", async (progress) => (0, runPipeline_1.runFlowSeeker)(task, { token, progress }));
+            resultProvider.setResult(result);
+            streamRetrievalSummary(stream, result);
+            const connection = await gateway.getConnection();
+            if (connection.connected && connection.mode === "direct") {
+                try {
+                    stream.progress(`Asking ${connection.providerLabel ?? "configured provider"}${connection.model ? `: ${connection.model}` : ""}...`);
+                    const answer = await gateway.ask(result, mode);
+                    if (mode === "auto") {
+                        const plan = await maybeExpandGatewayPlan(gateway, result, answer.message, stream);
+                        renderPlan(stream, result, plan, planStore);
+                    }
+                    else {
+                        renderAgentResponse(stream, answer, editStore);
+                    }
+                    return {
+                        metadata: {
+                            mode,
+                            provider: connection.provider,
+                            model: connection.model
+                        }
+                    };
+                }
+                catch (providerError) {
+                    (0, logger_1.logError)("Configured AI provider request failed.", providerError);
+                    const message = providerError instanceof Error ? providerError.message : String(providerError);
+                    stream.markdown(`\nConfigured AI provider could not answer: ${message}`);
+                }
+            }
+            const modelAvailable = await isLanguageModelAvailable(request.model, token);
+            if (modelAvailable) {
+                try {
+                    stream.progress(`Asking selected VSCode model: ${request.model.name}...`);
+                    if (mode === "auto") {
+                        const initialPlan = await askVsCodeModelForPlan(request.model, result, token, (tokens) => streamModelPromptTokens(stream, request.model, result, tokens));
+                        const plan = await maybeExpandVsCodePlan(request.model, result, initialPlan, token, stream);
+                        renderPlan(stream, result, plan, planStore);
+                    }
+                    else {
+                        const answer = await askVsCodeModelForGuidance(request.model, result, token, (tokens) => streamModelPromptTokens(stream, request.model, result, tokens));
+                        renderAgentResponse(stream, answer, editStore);
+                    }
+                    return {
+                        metadata: {
+                            mode,
+                            provider: "vscode-language-model",
+                            model: request.model.name,
+                            vendor: request.model.vendor
+                        }
+                    };
+                }
+                catch (modelError) {
+                    (0, logger_1.logError)("Selected VSCode model request failed.", modelError);
+                    const message = modelError instanceof Error ? modelError.message : String(modelError);
+                    stream.markdown(`\nSelected VSCode model could not answer: ${message}`);
+                }
+            }
+            if (connection.connected && connection.mode === "customGateway") {
+                try {
+                    stream.progress("Asking custom AI Gateway...");
+                    const answer = await gateway.ask(result, mode);
+                    if (mode === "auto") {
+                        const plan = await maybeExpandGatewayPlan(gateway, result, answer.message, stream);
+                        renderPlan(stream, result, plan, planStore);
+                    }
+                    else {
+                        renderAgentResponse(stream, answer, editStore);
+                    }
+                    return { metadata: { mode, provider: "customGateway", connected: true } };
+                }
+                catch (gatewayError) {
+                    (0, logger_1.logError)("Custom AI Gateway request failed.", gatewayError);
+                    const message = gatewayError instanceof Error ? gatewayError.message : String(gatewayError);
+                    stream.markdown(`\nCustom AI Gateway could not answer: ${message}`);
+                }
+            }
+            {
+                stream.markdown("\n## No AI provider available");
+                stream.markdown([
+                    "",
+                    "FlowSeeker retrieved the relevant context, but no AI model is available to reason over it.",
+                    "",
+                    "**To fix this, choose one:**",
+                    "",
+                    "- **Configure AI Provider** - connect OpenAI, Anthropic, Gemini, Ollama, OpenRouter, Mistral, Groq, xAI, or DeepSeek.",
+                    "- **Install GitHub Copilot** - use a VS Code Chat model directly.",
+                    "- **Use another AI tool** - click **Copy Agent Prompt**, then paste into ChatGPT, Claude, or another AI assistant.",
+                    ""
+                ].join("\n"));
+                stream.button({ command: "flowseeker.copyAgentPrompt", title: "Copy Agent Prompt" });
+                stream.button({ command: "flowseeker.connectGateway", title: "Configure AI Provider" });
+                stream.button({ command: "flowseeker.checkHostCompatibility", title: "Check Host Compatibility" });
+                return { metadata: { mode, connected: false, modelAvailable } };
+            }
+        }
+        catch (error) {
+            (0, logger_1.logError)("FlowSeeker native chat request failed.", error);
+            const message = error instanceof Error ? error.message : String(error);
+            stream.markdown(`FlowSeeker failed: ${message}`);
+            return { errorDetails: { message } };
+        }
+    };
+    const participant = vscode.chat.createChatParticipant(participantId, handler);
+    participant.iconPath = vscode.Uri.joinPath(context.extensionUri, "resources", "flowseeker-logo-vector-v2.svg");
+    participant.followupProvider = {
+        provideFollowups(result) {
+            const metadata = result.metadata;
+            return [
+                { prompt: "/guide Explain why these files are relevant", label: "Explain retrieved files" },
+                { prompt: "/auto Propose a reviewable fix plan", label: "Propose a plan" },
+                { prompt: "/guide What can FlowSeeker do in this editor?", label: "Check editor support" },
+                ...(metadata?.connected === false ? [{ prompt: "/guide What should I paste into my current AI agent?", label: "Use without gateway" }] : [])
+            ];
+        }
+    };
+    return participant;
+}
+async function runWithCompactProgress(stream, title, chatMessage, work) {
+    const transcript = createTranscriptProgress(stream);
+    transcript.push("start", chatMessage);
+    let lastMessage = "";
+    let lastReportAt = 0;
+    let lastIndexed;
+    let lastScanned;
+    return vscode.window.withProgress({
+        location: vscode.ProgressLocation.Window,
+        title,
+        cancellable: false
+    }, async (windowProgress) => {
+        const compactProgress = {
+            report: (value) => {
+                if (!value.message) {
+                    return;
+                }
+                const message = compactProgressMessage(value.message);
+                const now = Date.now();
+                updateTranscriptProgress(value.message);
+                if (message === lastMessage || now - lastReportAt < 150) {
+                    return;
+                }
+                lastMessage = message;
+                lastReportAt = now;
+                windowProgress.report({ message, increment: value.increment });
+            }
+        };
+        return work(compactProgress);
+    });
+    function updateTranscriptProgress(message) {
+        const indexed = message.match(/^Indexing\s+(\d+)\/(\d+)(?:\s+files)?(?::\s*(.+))?/i);
+        if (indexed) {
+            lastIndexed = { current: Number(indexed[1]), total: Number(indexed[2]) };
+            transcript.push("indexing", "Indexing workspace files...");
+            return;
+        }
+        const scanning = message.match(/^Scanning\s+(\d+)\/(\d+):/i);
+        if (scanning) {
+            if (lastIndexed) {
+                transcript.push("scanning", `Indexed ${lastIndexed.current}/${lastIndexed.total} files. Scanning candidate files...`);
+            }
+            else {
+                transcript.push("scanning", "Scanning candidate files...");
+            }
+            return;
+        }
+        const scanned = message.match(/^Scanned\s+(\d+)\/(\d+)\s+files,\s+(\d+)\s+evidence/i);
+        if (scanned) {
+            lastScanned = { current: Number(scanned[1]), total: Number(scanned[2]), evidence: Number(scanned[3]) };
+            return;
+        }
+        if (/^Ranking\b/i.test(message)) {
+            const summary = lastScanned
+                ? `Scanned ${lastScanned.current}/${lastScanned.total} files, ${lastScanned.evidence} evidence.`
+                : "Candidate scan complete.";
+            transcript.push("ranking", `${summary} Ranking evidence...`);
+            return;
+        }
+        if (/^Building evidence graph/i.test(message)) {
+            transcript.push("graph", "Building evidence graph...");
+            return;
+        }
+    }
+}
+function compactProgressMessage(message) {
+    const indexing = message.match(/^Indexing\s+(\d+)\/(\d+)(?:\s+files)?(?::\s*(.+))?/i);
+    if (indexing) {
+        const suffix = indexing[3] ? ` - ${shortenPath(indexing[3])}` : "";
+        return `Indexing ${indexing[1]}/${indexing[2]} (${percent(Number(indexing[1]), Number(indexing[2]))})${suffix}`;
+    }
+    const indexed = message.match(/^Indexed\s+(\d+)\/(\d+)\s+files/i);
+    if (indexed) {
+        return `Indexed ${indexed[1]}/${indexed[2]} (${percent(Number(indexed[1]), Number(indexed[2]))})`;
+    }
+    const scanning = message.match(/^Scanning\s+(\d+\/\d+):\s+(.+)$/);
+    if (scanning) {
+        const [current, total] = scanning[1].split("/").map(Number);
+        return `Scanning ${scanning[1]} (${percent(current, total)}) - ${shortenPath(scanning[2])}`;
+    }
+    return shortenProgress(message);
+}
+function createTranscriptProgress(stream) {
+    const seen = new Set();
+    let lineCount = 0;
+    const maxLines = 5;
+    return {
+        push: (key, message) => {
+            if (seen.has(key) || lineCount >= maxLines) {
+                return;
+            }
+            seen.add(key);
+            lineCount += 1;
+            stream.progress(message);
+        }
+    };
+}
+function percent(current, total) {
+    if (!Number.isFinite(current) || !Number.isFinite(total) || total <= 0) {
+        return "0%";
+    }
+    return `${Math.min(100, Math.max(0, Math.round((current / total) * 100)))}%`;
+}
+function shortenPath(value) {
+    const normalized = value.replace(/\\/g, "/");
+    if (normalized.length <= 60) {
+        return normalized;
+    }
+    const parts = normalized.split("/");
+    const fileName = parts.at(-1) ?? normalized;
+    const parent = parts.at(-2);
+    const shortPath = parent ? `${parent}/${fileName}` : fileName;
+    return shortPath.length <= 60 ? shortPath : `...${shortPath.slice(-57)}`;
+}
+function shortenProgress(value) {
+    return value.length <= 96 ? value : `${value.slice(0, 93)}...`;
+}
+function commandToMode(command) {
+    return command === "auto" ? "auto" : "guide";
+}
+async function isLanguageModelAvailable(model, token) {
+    try {
+        const models = await vscode.lm.selectChatModels({ vendor: model.vendor, family: model.family });
+        return models.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function handleApprovedPlan(request, stream, token, gateway, editStore, planStore) {
+    const planId = request.prompt.trim().split(/\s+/)[0];
+    if (!planId) {
+        stream.markdown("No approved plan id was provided. Run `/auto <task>` first, review the plan, then use the approve button.");
+        return { errorDetails: { message: "Missing plan id." } };
+    }
+    const proposal = planStore.get(planId);
+    if (!proposal) {
+        stream.markdown("This plan is no longer available. Run `/auto <task>` again to regenerate a reviewable plan.");
+        return { errorDetails: { message: "Plan not found." } };
+    }
+    const allowedFiles = proposal.allowedFiles;
+    stream.markdown("Plan approved. FlowSeeker will now ask for structured edits. No files will be written until you press **Apply Proposed Edits**.");
+    if (allowedFiles.length > 0) {
+        stream.markdown(`\nScope locked to ${allowedFiles.length} approved file(s): ${allowedFiles.map((file) => `\`${file}\``).join(", ")}`);
+    }
+    const connection = await gateway.getConnection();
+    if (connection.connected && connection.mode === "direct") {
+        try {
+            stream.progress(`Asking ${connection.providerLabel ?? "configured provider"} for edits${connection.model ? `: ${connection.model}` : ""}...`);
+            let answer = await gateway.askWithInstruction(proposal.result, "auto", (0, agentPrompts_1.createApprovedEditInstruction)(proposal.plan), { stage: "approved_edits", approvedPlan: proposal.plan });
+            answer = await maybeExpandGatewayApprovedEdits(gateway, proposal.result, proposal.plan, answer, stream);
+            renderApprovedEditResponse(stream, answer, editStore, allowedFiles);
+            return {
+                metadata: {
+                    mode: "auto",
+                    stage: "approved_edits",
+                    provider: connection.provider,
+                    model: connection.model
+                }
+            };
+        }
+        catch (providerError) {
+            (0, logger_1.logError)("Configured AI provider failed to generate approved edits.", providerError);
+            const message = providerError instanceof Error ? providerError.message : String(providerError);
+            stream.markdown(`\nConfigured AI provider could not generate edits: ${message}`);
+        }
+    }
+    try {
+        stream.progress(`Asking selected VSCode model for edits: ${request.model.name}...`);
+        let answer = await askVsCodeModelForApprovedEdits(request.model, proposal.result, proposal.plan, token, (tokens) => streamModelPromptTokens(stream, request.model, proposal.result, tokens));
+        answer = await maybeExpandVsCodeApprovedEdits(request.model, proposal.result, proposal.plan, answer, token, stream);
+        renderApprovedEditResponse(stream, answer, editStore, allowedFiles);
+        return {
+            metadata: {
+                mode: "auto",
+                stage: "approved_edits",
+                provider: "vscode-language-model",
+                model: request.model.name,
+                vendor: request.model.vendor
+            }
+        };
+    }
+    catch (modelError) {
+        (0, logger_1.logError)("Selected VSCode model failed to generate approved edits.", modelError);
+        const message = modelError instanceof Error ? modelError.message : String(modelError);
+        stream.markdown(`\nSelected VSCode model could not generate edits: ${message}`);
+    }
+    if (!connection.connected) {
+        stream.markdown("\nNo AI provider fallback is connected, so FlowSeeker cannot generate edits from the approved plan.");
+        stream.button({ command: "flowseeker.connectGateway", title: "Configure AI Provider" });
+        return { metadata: { mode: "auto", stage: "approved_edits", connected: false } };
+    }
+    stream.progress("Asking custom AI Gateway for edits from the approved plan...");
+    let answer = await gateway.askWithInstruction(proposal.result, "auto", (0, agentPrompts_1.createApprovedEditInstruction)(proposal.plan), { stage: "approved_edits", approvedPlan: proposal.plan });
+    answer = await maybeExpandGatewayApprovedEdits(gateway, proposal.result, proposal.plan, answer, stream);
+    renderApprovedEditResponse(stream, answer, editStore, allowedFiles);
+    return { metadata: { mode: "auto", stage: "approved_edits", connected: true } };
+}
+async function askVsCodeModelForGuidance(model, result, token, onPromptTokens) {
+    const prompt = (0, agentPrompts_1.createGuidancePrompt)(result);
+    onPromptTokens?.(await countModelPromptTokens(model, prompt, token));
+    const text = await sendModelPrompt(model, prompt, token);
+    return { message: text.trim() || "The selected model returned an empty response." };
+}
+async function askVsCodeModelForPlan(model, result, token, onPromptTokens) {
+    const prompt = (0, agentPrompts_1.createPlanPrompt)(result);
+    onPromptTokens?.(await countModelPromptTokens(model, prompt, token));
+    const text = await sendModelPrompt(model, prompt, token);
+    return text.trim() || "The selected model returned an empty plan.";
+}
+async function askVsCodeModelForApprovedEdits(model, result, approvedPlan, token, onPromptTokens) {
+    const prompt = (0, agentPrompts_1.createApprovedEditPrompt)(result, approvedPlan);
+    onPromptTokens?.(await countModelPromptTokens(model, prompt, token));
+    const text = await sendModelPrompt(model, prompt, token);
+    return (0, aiGateway_1.parseAgentResponse)(text);
+}
+async function countModelPromptTokens(model, prompt, token) {
+    try {
+        return await model.countTokens(vscode.LanguageModelChatMessage.User(prompt), token);
+    }
+    catch (error) {
+        (0, logger_1.logError)("Selected VSCode model token counting failed.", error);
+        return undefined;
+    }
+}
+function streamModelPromptTokens(stream, model, result, promptTokens) {
+    if (promptTokens === undefined) {
+        return;
+    }
+    const workspaceTokens = result.tokenSavings?.workspaceTokensEstimate;
+    const reduction = workspaceTokens && workspaceTokens > 0 ? `; vs workspace baseline: **${(0, tokenSavings_1.formatReductionPercent)(((workspaceTokens - promptTokens) / workspaceTokens) * 100)}** reduction` : "";
+    stream.markdown(`\nSelected model input measured by \`${model.name}\`: **${(0, tokenSavings_1.formatTokenCount)(promptTokens)}** tokens${reduction}.`);
+}
+async function sendModelPrompt(model, prompt, token) {
+    const response = await model.sendRequest([vscode.LanguageModelChatMessage.User(prompt)], {
+        justification: "FlowSeeker uses the selected VSCode chat model to reason over the relevant codebase context it retrieved."
+    }, token);
+    let text = "";
+    for await (const chunk of response.text) {
+        text += chunk;
+    }
+    return text;
+}
+function renderApprovedEditResponse(stream, answer, editStore, scope) {
+    if (!answer.edits?.length) {
+        stream.markdown([
+            "\nThe AI provider did not return structured edits FlowSeeker can apply.",
+            "",
+            "Expected JSON shape: `{\"message\":\"...\",\"edits\":[{\"file\":\"relative/path\",\"range\":{\"startLine\":1,\"endLine\":1},\"text\":\"replacement\"}],\"commands\":[],\"mcpTools\":[]}`.",
+            "",
+            "Provider response preview:",
+            "",
+            (0, contextExpansion_1.truncateForAgent)(answer.message, 1200),
+            "",
+            "No workspace files were changed."
+        ].join("\n"));
+        return;
+    }
+    renderAgentResponse(stream, answer, editStore, scope);
+}
+function renderAgentResponse(stream, answer, editStore, scope) {
+    stream.markdown(`\n${answer.message}`);
+    if (answer.patch) {
+        stream.markdown(["", "```diff", answer.patch, "```"].join("\n"));
+    }
+    if (answer.edits?.length) {
+        stream.markdown(`\n${(0, diffPreview_1.renderDiffPreviewMarkdown)(answer.edits)}`);
+        const proposalId = editStore.store(answer.edits, scope);
+        stream.markdown(`\nProposed ${answer.edits.length} structured edit(s). Review the target files before applying.`);
+        stream.button({
+            command: "flowseeker.openGatewayDiff",
+            title: "Open Diff",
+            arguments: [proposalId]
+        });
+        stream.button({
+            command: "flowseeker.applyGatewayEdits",
+            title: "Apply Proposed Edits",
+            arguments: [proposalId]
+        });
+    }
+    if (answer.commands?.length) {
+        stream.markdown(`\nSuggested ${answer.commands.length} verification command(s). FlowSeeker will ask before running commands unless your approval policy allows it.`);
+        for (const command of answer.commands.slice(0, 4)) {
+            stream.button({
+                command: "flowseeker.runAgentCommand",
+                title: `Run: ${shortenCommand(command.command)}`,
+                arguments: [command]
+            });
+        }
+    }
+    if (answer.mcpTools?.length) {
+        stream.markdown(`\nSuggested ${answer.mcpTools.length} MCP/tool invocation(s). FlowSeeker will ask before invoking tools unless your approval policy allows it.`);
+        for (const tool of answer.mcpTools.slice(0, 4)) {
+            stream.button({
+                command: "flowseeker.runMcpTool",
+                title: `Invoke: ${shortenCommand(tool.tool)}`,
+                arguments: [tool]
+            });
+        }
+    }
+}
+function shortenCommand(command) {
+    return command.length <= 42 ? command : `${command.slice(0, 39)}...`;
+}
+function renderPlan(stream, result, plan, planStore) {
+    if (!(0, contextExpansion_1.isReviewablePlan)(plan)) {
+        stream.markdown(`\n${plan}`);
+        stream.markdown("\nFlowSeeker did not receive a reviewable implementation plan, so approval is disabled for this response.");
+        return;
+    }
+    const planId = planStore.store(result, plan);
+    stream.markdown(`\n${plan}`);
+    stream.markdown("\nNo files were changed. Review this plan first. If it looks right, approve it to generate structured edits.");
+    stream.button({
+        command: "flowseeker.approvePlan",
+        title: "Approve Plan: Generate Edits",
+        arguments: [planId]
+    });
+}
+async function maybeExpandGatewayPlan(gateway, result, plan, stream) {
+    if (!(0, contextExpansion_1.isMissingContextRequest)(plan)) {
+        return plan;
+    }
+    const paths = (0, contextExpansion_1.selectContextExpansionPaths)(plan, result);
+    if (paths.length === 0) {
+        stream.markdown("\nThe AI requested more context, but FlowSeeker could not identify a bounded file set to read.");
+        return plan;
+    }
+    stream.progress(`AI requested more context. Reading ${paths.length} bounded file(s) and retrying the plan...`);
+    const expandedContext = await (0, contextExpansion_1.readWorkspaceContextFiles)(paths);
+    if (!expandedContext.trim()) {
+        stream.markdown("\nFlowSeeker could not read the requested context files safely.");
+        return plan;
+    }
+    const answer = await gateway.askWithInstruction(result, "auto", (0, contextExpansion_1.createExpandedPlanInstruction)(plan, expandedContext), { stage: "expanded_plan", requestedFiles: paths });
+    return answer.message;
+}
+async function maybeExpandGatewayApprovedEdits(gateway, result, approvedPlan, answer, stream) {
+    if (answer.edits?.length || !(0, contextExpansion_1.isMissingContextRequest)(answer.message)) {
+        return answer;
+    }
+    const paths = (0, contextExpansion_1.selectContextExpansionPaths)(answer.message, result);
+    if (paths.length === 0) {
+        stream.markdown("\nThe AI requested more edit context, but FlowSeeker could not identify a bounded file set to read.");
+        return answer;
+    }
+    stream.progress(`AI requested more edit context. Reading ${paths.length} bounded file(s) and retrying structured edits...`);
+    const expandedContext = await (0, contextExpansion_1.readWorkspaceContextFiles)(paths);
+    if (!expandedContext.trim()) {
+        stream.markdown("\nFlowSeeker could not read the requested edit context files safely.");
+        return answer;
+    }
+    return gateway.askWithInstruction(result, "auto", (0, contextExpansion_1.createExpandedApprovedEditInstruction)(approvedPlan, answer.message, expandedContext), { stage: "expanded_approved_edits", requestedFiles: paths, approvedPlan });
+}
+async function maybeExpandVsCodePlan(model, result, plan, token, stream) {
+    if (!(0, contextExpansion_1.isMissingContextRequest)(plan)) {
+        return plan;
+    }
+    const paths = (0, contextExpansion_1.selectContextExpansionPaths)(plan, result);
+    if (paths.length === 0) {
+        stream.markdown("\nThe AI requested more context, but FlowSeeker could not identify a bounded file set to read.");
+        return plan;
+    }
+    stream.progress(`AI requested more context. Reading ${paths.length} bounded file(s) and retrying the plan...`);
+    const expandedContext = await (0, contextExpansion_1.readWorkspaceContextFiles)(paths);
+    if (!expandedContext.trim()) {
+        stream.markdown("\nFlowSeeker could not read the requested context files safely.");
+        return plan;
+    }
+    return sendModelPrompt(model, (0, agentPrompts_1.createPromptWithInstruction)(result, (0, contextExpansion_1.createExpandedPlanInstruction)(plan, expandedContext)), token);
+}
+async function maybeExpandVsCodeApprovedEdits(model, result, approvedPlan, answer, token, stream) {
+    if (answer.edits?.length || !(0, contextExpansion_1.isMissingContextRequest)(answer.message)) {
+        return answer;
+    }
+    const paths = (0, contextExpansion_1.selectContextExpansionPaths)(answer.message, result);
+    if (paths.length === 0) {
+        stream.markdown("\nThe AI requested more edit context, but FlowSeeker could not identify a bounded file set to read.");
+        return answer;
+    }
+    stream.progress(`AI requested more edit context. Reading ${paths.length} bounded file(s) and retrying structured edits...`);
+    const expandedContext = await (0, contextExpansion_1.readWorkspaceContextFiles)(paths);
+    if (!expandedContext.trim()) {
+        stream.markdown("\nFlowSeeker could not read the requested edit context files safely.");
+        return answer;
+    }
+    const text = await sendModelPrompt(model, (0, agentPrompts_1.createPromptWithInstruction)(result, (0, contextExpansion_1.createExpandedApprovedEditInstruction)(approvedPlan, answer.message, expandedContext)), token);
+    return (0, aiGateway_1.parseAgentResponse)(text);
+}
+function streamRetrievalSummary(stream, result) {
+    const groups = (0, fileGroups_1.aggregateEvidenceFiles)(result.units).slice(0, 10);
+    const stats = result.stats;
+    const tokenSavings = result.tokenSavings;
+    stream.markdown([
+        `Found **${result.units.length}** evidence unit(s) from **${stats.scannedFiles}** scanned file(s).`,
+        ...(tokenSavings && tokenSavings.status !== "unavailable"
+            ? [
+                `Measured token savings: Solve Packet **${(0, tokenSavings_1.formatTokenCount)(tokenSavings.solvePacketTokensEstimate)}** / workspace **${(0, tokenSavings_1.formatTokenCount)(tokenSavings.workspaceTokensEstimate)}** tokens by \`${tokenSavings.tokenizer}\` (**${(0, tokenSavings_1.formatReductionPercent)(tokenSavings.reductionPercent)}** reduction).`,
+                tokenSavings.status === "partial" ? `Estimate note: ${tokenSavings.reason ?? "partial scan basis"}.` : "",
+                tokenSavings.proofWarnings.length ? `Proof warning: ${tokenSavings.proofWarnings.join("; ")}.` : ""
+            ].filter(Boolean)
+            : []),
+        result.contextCoverage
+            ? `Context coverage: **${result.contextCoverage.foundRequiredSlots.length}/${result.contextCoverage.requiredSlots.length}** required slot(s) found${result.contextCoverage.missingRequiredSlots.length ? `; missing ${result.contextCoverage.missingRequiredSlots.join(", ")}` : ""}.`
+            : "",
+        `Intent: \`${result.profile.intent}\``,
+        result.profile.keywords.length ? `Keywords: ${result.profile.keywords.map((keyword) => `\`${keyword}\``).join(", ")}` : "Keywords: none",
+        "",
+        "Top files:"
+    ].join("\n"));
+    const root = vscode.workspace.workspaceFolders?.[0]?.uri;
+    for (const [index, group] of groups.entries()) {
+        const range = group.ranges[0];
+        const lineSuffix = range ? `:${range.startLine}-${range.endLine}` : "";
+        stream.markdown(`\n${index + 1}. \`${group.relativePath}${lineSuffix}\` - ${group.role}/${group.slot}, score ${group.score.toFixed(1)}, evidence ${group.unitCount}`);
+        if (root) {
+            try {
+                const uri = (0, editProposalStore_1.resolveWorkspaceFile)(root, group.relativePath);
+                const location = range
+                    ? new vscode.Location(uri, new vscode.Range(new vscode.Position(range.startLine - 1, 0), new vscode.Position(Math.max(range.endLine - 1, range.startLine - 1), 0)))
+                    : uri;
+                stream.anchor(location, group.relativePath);
+            }
+            catch {
+                // The markdown path is still useful even when an anchor cannot be built.
+            }
+        }
+    }
+}
+//# sourceMappingURL=nativeChatParticipant.js.map