flowseeker 0.1.7

package/dist/gateway/contextExpansion.js

@@ -0,0 +1,331 @@
+"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.truncateForAgent = truncateForAgent;
+exports.isMissingContextRequest = isMissingContextRequest;
+exports.isReviewablePlan = isReviewablePlan;
+exports.createExpandedPlanInstruction = createExpandedPlanInstruction;
+exports.createExpandedApprovedEditInstruction = createExpandedApprovedEditInstruction;
+exports.selectContextExpansionPaths = selectContextExpansionPaths;
+exports.readWorkspaceContextFiles = readWorkspaceContextFiles;
+const vscode = __importStar(require("vscode"));
+const fileGroups_1 = require("../pipeline/fileGroups");
+const editProposalStore_1 = require("./editProposalStore");
+const agentPrompts_1 = require("./agentPrompts");
+const MAX_CONTEXT_FILES = 6;
+const MAX_TOTAL_CONTEXT_CHARS = 50000;
+const MAX_CONTEXT_FILE_CHARS = 12000;
+const MAX_CONTEXT_FILE_BYTES = 250000;
+function truncateForAgent(value, maxLength) {
+    const clean = value.trim();
+    if (clean.length <= maxLength) {
+        return clean;
+    }
+    return `${clean.slice(0, Math.max(0, maxLength - 16)).trimEnd()}\n...[truncated]`;
+}
+function isMissingContextRequest(text) {
+    const normalized = normalizeHumanText(text);
+    if (looksLikeReviewableImplementationPlan(normalized)) {
+        return false;
+    }
+    return [
+        "can doc",
+        "can doc day du",
+        "can kiem tra",
+        "can xem",
+        "can xem them",
+        "can xem toan bo",
+        "can mo rong",
+        "can them context",
+        "cho phep toi doc",
+        "toi se doc",
+        "toi can doc",
+        "toi can xem",
+        "toi can kiem tra",
+        "truoc khi lap ke hoach",
+        "truoc khi de xuat sua",
+        "truoc khi generate edits",
+        "noi dung bi cat",
+        "noi dung file bi cat",
+        "bi cat ngan",
+        "mo rong context",
+        "mo rong packet",
+        "bo sung context",
+        "khong du context",
+        "khong du ngu canh",
+        "chua du context",
+        "chua du ngu canh",
+        "truncated",
+        "need to read",
+        "need to inspect",
+        "need more context",
+        "need additional context",
+        "not enough context",
+        "insufficient context",
+        "full file contents",
+        "read the full",
+        "expand context",
+        "expand the packet",
+        "before i can",
+        "cannot safely"
+    ].some((phrase) => normalized.includes(phrase));
+}
+function isReviewablePlan(text) {
+    const normalized = normalizeHumanText(text);
+    if (looksLikeReviewableImplementationPlan(normalized)) {
+        return true;
+    }
+    return false;
+}
+function looksLikeReviewableImplementationPlan(normalized) {
+    const structureMarkers = [
+        "awaiting user approval",
+        "ke hoach",
+        "ke hoach trien khai",
+        "muc tieu",
+        "edit candidates",
+        "files likely",
+        "files to inspect",
+        "cac file co kha nang",
+        "inspect only",
+        "chi can doc",
+        "buoc 1",
+        "buoc 2",
+        "step 1",
+        "step 2",
+        "verification",
+        "kiem thu",
+        "kiem tra / xac minh",
+        "test/verification",
+        "rui ro",
+        "risks",
+        "unknowns"
+    ];
+    const changeMarkers = [
+        "sua",
+        "cap nhat",
+        "them",
+        "xoa",
+        "bo",
+        "tao migration",
+        "migration",
+        "controller",
+        "model",
+        "view",
+        "template",
+        "mail",
+        "route",
+        "schema",
+        "constructor",
+        "update",
+        "add",
+        "remove",
+        "edit",
+        "change"
+    ];
+    const cautionMarkers = [
+        "rui ro",
+        "an so",
+        "unknown",
+        "risk",
+        "regression",
+        "tuong thich",
+        "anh huong"
+    ];
+    const structureScore = countPhraseMatches(normalized, structureMarkers);
+    const changeScore = countPhraseMatches(normalized, changeMarkers);
+    const hasVerification = /\b(verification|verify|test|kiem thu|kiem tra|xac minh)\b/.test(normalized);
+    const hasNumberedSteps = /\b(buoc|step)\s*\d+\b/.test(normalized);
+    const hasFileOrCodeReference = /\b(file|controller|model|migration|route|view|template|mail|blade|php|ts|js|py|java|go)\b/.test(normalized);
+    const hasApprovalMarker = normalized.includes("awaiting user approval") || normalized.includes("truoc khi tien hanh") || normalized.includes("cho approval");
+    const hasCaution = countPhraseMatches(normalized, cautionMarkers) > 0;
+    return (structureScore >= 3 &&
+        changeScore >= 2 &&
+        hasFileOrCodeReference &&
+        (hasVerification || hasNumberedSteps) &&
+        (hasApprovalMarker || hasCaution || structureScore >= 5));
+}
+function countPhraseMatches(value, phrases) {
+    return phrases.filter((phrase) => value.includes(phrase)).length;
+}
+function createExpandedPlanInstruction(previousResponse, expandedContext) {
+    return [
+        "Your previous response asked to read more context instead of returning a reviewable plan.",
+        "FlowSeeker has now provided a bounded extra context set below.",
+        "Use only the original Solve Packet plus this additional context.",
+        "Do not ask to read these same files again.",
+        "If this is still insufficient, return a concise explanation of exactly which missing file/route/model blocks the fix and do not invent edits.",
+        "",
+        (0, agentPrompts_1.createPlanInstruction)(),
+        "",
+        "Previous AI context request:",
+        truncateForAgent(previousResponse, 2000),
+        "",
+        "Additional bounded file context:",
+        expandedContext
+    ].join("\n");
+}
+function createExpandedApprovedEditInstruction(approvedPlan, previousResponse, expandedContext) {
+    return [
+        "Your previous response did not include structured edits and asked for more context, or explained that context was insufficient.",
+        "FlowSeeker has now provided a bounded extra context set below.",
+        "Use only the original Solve Packet plus this additional context.",
+        "Do not ask to read these same files again.",
+        "Return structured edits only if the change is directly supported by the approved plan and context.",
+        "",
+        (0, agentPrompts_1.createApprovedEditInstruction)(approvedPlan),
+        "",
+        "Previous AI response:",
+        truncateForAgent(previousResponse, 2000),
+        "",
+        "Additional bounded file context:",
+        expandedContext
+    ].join("\n");
+}
+function selectContextExpansionPaths(message, result) {
+    const explicit = extractPathMentions(message);
+    const groups = (0, fileGroups_1.aggregateEvidenceFiles)(result.units).map((group) => group.relativePath);
+    const primary = result.solvePacket?.primaryEditCandidates.map((candidate) => candidate.relativePath) ?? [];
+    const candidates = uniqueStrings([...explicit, ...primary, ...groups]);
+    const selected = [];
+    for (const file of explicit) {
+        pushUnique(selected, file);
+    }
+    const normalizedMessage = normalizePathText(message).toLowerCase();
+    const basenameCounts = new Map();
+    for (const file of candidates) {
+        const base = basename(file).toLowerCase();
+        basenameCounts.set(base, (basenameCounts.get(base) ?? 0) + 1);
+    }
+    for (const file of candidates) {
+        if (selected.length >= MAX_CONTEXT_FILES) {
+            break;
+        }
+        const normalizedFile = normalizePathText(file).toLowerCase();
+        const base = basename(file).toLowerCase();
+        if (normalizedMessage.includes(normalizedFile) || (basenameCounts.get(base) === 1 && normalizedMessage.includes(base))) {
+            pushUnique(selected, file);
+        }
+    }
+    if (selected.length === 0) {
+        for (const file of uniqueStrings([...primary, ...groups]).slice(0, MAX_CONTEXT_FILES)) {
+            pushUnique(selected, file);
+        }
+    }
+    return selected.slice(0, MAX_CONTEXT_FILES);
+}
+async function readWorkspaceContextFiles(paths) {
+    const root = vscode.workspace.workspaceFolders?.[0]?.uri;
+    if (!root) {
+        return "";
+    }
+    const chunks = [];
+    let totalChars = 0;
+    for (const file of paths) {
+        if (chunks.length >= MAX_CONTEXT_FILES || totalChars >= MAX_TOTAL_CONTEXT_CHARS) {
+            break;
+        }
+        try {
+            const uri = (0, editProposalStore_1.resolveWorkspaceFile)(root, file);
+            const bytes = await vscode.workspace.fs.readFile(uri);
+            if (bytes.byteLength > MAX_CONTEXT_FILE_BYTES) {
+                chunks.push(`### ${file}\n[Skipped: file is too large for bounded context expansion]\n`);
+                continue;
+            }
+            const raw = Buffer.from(bytes).toString("utf8");
+            if (raw.includes("\0")) {
+                chunks.push(`### ${file}\n[Skipped: file appears to be binary]\n`);
+                continue;
+            }
+            const remaining = Math.max(0, MAX_TOTAL_CONTEXT_CHARS - totalChars);
+            const maxChars = Math.min(MAX_CONTEXT_FILE_CHARS, remaining);
+            const clipped = raw.length > maxChars
+                ? `${raw.slice(0, maxChars).trimEnd()}\n... [FlowSeeker clipped this file for bounded context expansion]`
+                : raw;
+            const rendered = `### ${file}\n\nLine-numbered context. Do not include line prefixes in replacement text.\n\n\`\`\`\n${withLineNumbers(clipped)}\n\`\`\`\n`;
+            chunks.push(rendered);
+            totalChars += rendered.length;
+        }
+        catch {
+            chunks.push(`### ${file}\n[Skipped: FlowSeeker could not read this path safely]\n`);
+        }
+    }
+    return chunks.join("\n");
+}
+function extractPathMentions(text) {
+    const normalized = text.replace(/\\/g, "/");
+    const paths = [];
+    const pattern = /(?:^|[\s`'"])([A-Za-z0-9_@./+[\]-]+\.[A-Za-z0-9]{1,8})(?=[\s`'",).:;]|$)/g;
+    let match;
+    while ((match = pattern.exec(normalized))) {
+        const path = match[1].replace(/^\/+/, "");
+        if (path.includes("/") && !path.includes("..")) {
+            paths.push(path);
+        }
+    }
+    return uniqueStrings(paths);
+}
+function withLineNumbers(text) {
+    return text.split(/\r?\n/).map((line, index) => `${index + 1}: ${line}`).join("\n");
+}
+function normalizeHumanText(value) {
+    return value
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/\u0111/g, "d")
+        .replace(/\u0110/g, "D")
+        .toLowerCase();
+}
+function normalizePathText(value) {
+    return value.replace(/\\/g, "/");
+}
+function basename(file) {
+    return normalizePathText(file).split("/").filter(Boolean).pop() ?? file;
+}
+function uniqueStrings(values) {
+    const output = [];
+    for (const value of values) {
+        pushUnique(output, value);
+    }
+    return output;
+}
+function pushUnique(values, value) {
+    const clean = normalizePathText(value).trim();
+    if (!clean || values.some((item) => item.toLowerCase() === clean.toLowerCase())) {
+        return;
+    }
+    values.push(clean);
+}
+//# sourceMappingURL=contextExpansion.js.map

package/dist/gateway/editProposalStore.js

@@ -0,0 +1,238 @@
+"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.EditProposalStore = void 0;
+exports.resolveWorkspaceFile = resolveWorkspaceFile;
+const vscode = __importStar(require("vscode"));
+class EditProposalStore {
+    constructor() {
+        this.proposals = new Map();
+    }
+    store(edits, scope) {
+        const id = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+        this.proposals.set(id, { edits, scope });
+        return id;
+    }
+    get(proposalId) {
+        return this.proposals.get(proposalId)?.edits;
+    }
+    getScope(proposalId) {
+        return this.proposals.get(proposalId)?.scope;
+    }
+    listFiles(proposalId) {
+        const proposal = this.proposals.get(proposalId);
+        if (!proposal?.edits.length) {
+            return [];
+        }
+        return [...new Set(proposal.edits.map((edit) => edit.file))];
+    }
+    validateScope(proposalId) {
+        const proposal = this.proposals.get(proposalId);
+        if (!proposal?.edits.length) {
+            return { valid: false, outsideScope: [] };
+        }
+        if (!proposal.scope || proposal.scope.length === 0) {
+            return { valid: true };
+        }
+        const normalizedScope = proposal.scope.map(normalizePath);
+        const outsideScope = proposal.edits
+            .map((edit) => edit.file)
+            .filter((file) => !normalizedScope.some((allowed) => pathMatches(file, allowed)));
+        if (outsideScope.length > 0) {
+            return { valid: false, outsideScope: [...new Set(outsideScope)] };
+        }
+        return { valid: true };
+    }
+    async apply(proposalId) {
+        const proposal = this.proposals.get(proposalId);
+        if (!proposal?.edits.length) {
+            throw new Error("Edit proposal is no longer available.");
+        }
+        const scopeCheck = this.validateScope(proposalId);
+        if (!scopeCheck.valid) {
+            throw new Error(`Scope lock: these files are outside the approved plan scope: ${scopeCheck.outsideScope.join(", ")}. Approve a broader plan or ask for scope expansion.`);
+        }
+        const edits = proposal.edits;
+        const folders = vscode.workspace.workspaceFolders;
+        if (!folders?.[0]) {
+            throw new Error("Open a workspace folder before applying edits.");
+        }
+        const files = [...new Set(edits.map((edit) => edit.file))];
+        const appliedFiles = [];
+        const failedFiles = [];
+        for (const file of files) {
+            try {
+                const fileEdits = edits.filter((edit) => edit.file === file);
+                const workspaceEdit = new vscode.WorkspaceEdit();
+                const uri = resolveWorkspaceFile(folders[0].uri, file);
+                const document = await vscode.workspace.openTextDocument(uri);
+                for (const edit of fileEdits) {
+                    const range = toVscodeRange(document, edit);
+                    workspaceEdit.replace(uri, range, edit.text);
+                }
+                const applied = await vscode.workspace.applyEdit(workspaceEdit);
+                if (!applied) {
+                    failedFiles.push({ file, reason: `VS Code rejected the edit for ${file}. The file may have been modified or the edit range is no longer valid.` });
+                    continue;
+                }
+                await document.save();
+                appliedFiles.push(file);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                failedFiles.push({ file, reason: message });
+            }
+        }
+        if (appliedFiles.length === 0) {
+            const reasons = failedFiles.map((f) => `${f.file}: ${f.reason}`).join("; ");
+            throw new Error(`No edits were applied. ${reasons}`);
+        }
+        this.proposals.delete(proposalId);
+        return {
+            editCount: edits.length,
+            fileCount: files.length,
+            files: appliedFiles,
+            failedFiles
+        };
+    }
+    async previewFile(root, proposalId, file) {
+        const proposal = this.proposals.get(proposalId);
+        if (!proposal?.edits.length) {
+            throw new Error("Edit proposal is no longer available.");
+        }
+        const edits = proposal.edits.filter((edit) => pathMatches(edit.file, file));
+        if (edits.length === 0) {
+            throw new Error(`No proposed edits were found for ${file}.`);
+        }
+        const originalUri = resolveWorkspaceFile(root, edits[0].file);
+        const document = await vscode.workspace.openTextDocument(originalUri);
+        return {
+            file: edits[0].file,
+            originalUri,
+            languageId: document.languageId,
+            text: applyPreviewEdits(document, edits)
+        };
+    }
+}
+exports.EditProposalStore = EditProposalStore;
+function resolveWorkspaceFile(root, relativePath) {
+    const normalized = relativePath.trim().replace(/\\/g, "/");
+    if (!normalized ||
+        normalized.includes("\0") ||
+        normalized.startsWith("/") ||
+        /^[a-zA-Z]:\//.test(normalized)) {
+        throw new Error(`Unsafe workspace path: ${relativePath}`);
+    }
+    const segments = normalized.split("/").filter(Boolean);
+    if (segments.length === 0 || segments.some((segment) => segment === "." || segment === "..")) {
+        throw new Error(`Unsafe workspace path: ${relativePath}`);
+    }
+    return vscode.Uri.joinPath(root, ...segments);
+}
+function toVscodeRange(document, edit) {
+    if (edit.replaceWholeFile) {
+        const lastLine = document.lineAt(document.lineCount - 1);
+        return new vscode.Range(new vscode.Position(0, 0), lastLine.range.end);
+    }
+    if (!edit.range) {
+        throw new Error(`Gateway edit for ${edit.file} must include a range or replaceWholeFile=true.`);
+    }
+    const start = toVscodePosition(document, edit.file, edit.range.startLine, edit.range.startColumn ?? 1);
+    const end = toVscodePosition(document, edit.file, edit.range.endLine, edit.range.endColumn ?? 1);
+    if (end.isBefore(start)) {
+        throw new Error(`Gateway edit for ${edit.file} has an invalid range.`);
+    }
+    return new vscode.Range(start, end);
+}
+function applyPreviewEdits(document, edits) {
+    const wholeFileEdits = edits.filter((edit) => edit.replaceWholeFile);
+    if (wholeFileEdits.length > 0) {
+        if (edits.length > 1) {
+            throw new Error(`Cannot preview mixed whole-file and ranged edits for ${wholeFileEdits[0].file}.`);
+        }
+        return wholeFileEdits[0].text;
+    }
+    const replacements = edits
+        .map((edit) => {
+        const range = toVscodeRange(document, edit);
+        return {
+            start: document.offsetAt(range.start),
+            end: document.offsetAt(range.end),
+            text: edit.text,
+            file: edit.file
+        };
+    })
+        .sort((left, right) => right.start - left.start || right.end - left.end);
+    let text = document.getText();
+    let previousStart = Number.POSITIVE_INFINITY;
+    for (const replacement of replacements) {
+        if (replacement.end > previousStart) {
+            throw new Error(`Cannot preview overlapping edits for ${replacement.file}.`);
+        }
+        text = text.slice(0, replacement.start) + replacement.text + text.slice(replacement.end);
+        previousStart = replacement.start;
+    }
+    return text;
+}
+function toVscodePosition(document, file, line, column) {
+    const zeroLine = line - 1;
+    const zeroColumn = column - 1;
+    if (zeroLine < 0 || zeroLine >= document.lineCount) {
+        throw new Error(`Gateway edit for ${file} references line ${line}, but the file has ${document.lineCount} line(s).`);
+    }
+    if (zeroColumn < 0) {
+        throw new Error(`Gateway edit for ${file} has an invalid column ${column}.`);
+    }
+    const textLine = document.lineAt(zeroLine);
+    if (zeroColumn > textLine.text.length) {
+        throw new Error(`Gateway edit for ${file} references column ${column}, but line ${line} has ${textLine.text.length + 1} column position(s).`);
+    }
+    return new vscode.Position(zeroLine, zeroColumn);
+}
+function normalizePath(value) {
+    return value.replace(/\\/g, "/").toLowerCase();
+}
+function pathMatches(actualPath, allowedPath) {
+    const actual = normalizePath(actualPath);
+    const allowed = normalizePath(allowedPath);
+    if (actual === allowed) {
+        return true;
+    }
+    if (actual.endsWith(`/${allowed}`)) {
+        return true;
+    }
+    return allowed.endsWith(`/${actual}`);
+}
+//# sourceMappingURL=editProposalStore.js.map

package/dist/gateway/planProposalStore.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanProposalStore = void 0;
+class PlanProposalStore {
+    constructor() {
+        this.proposals = new Map();
+    }
+    store(result, plan) {
+        const id = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+        const allowedFiles = result.solvePacket?.primaryEditCandidates.map((candidate) => candidate.relativePath) ?? [];
+        this.proposals.set(id, {
+            id,
+            result,
+            plan,
+            allowedFiles,
+            createdAt: Date.now()
+        });
+        return id;
+    }
+    get(id) {
+        return this.proposals.get(id);
+    }
+    getAllowedFiles(id) {
+        return this.proposals.get(id)?.allowedFiles ?? [];
+    }
+}
+exports.PlanProposalStore = PlanProposalStore;
+//# sourceMappingURL=planProposalStore.js.map

package/dist/index/cacheStore.js

@@ -0,0 +1,51 @@
+"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.clearFlowSeekerCache = clearFlowSeekerCache;
+const vscode = __importStar(require("vscode"));
+async function clearFlowSeekerCache() {
+    const folders = vscode.workspace.workspaceFolders;
+    if (!folders || folders.length === 0) {
+        return;
+    }
+    const cacheUri = vscode.Uri.joinPath(folders[0].uri, ".flowseeker", "cache");
+    try {
+        await vscode.workspace.fs.delete(cacheUri, { recursive: true, useTrash: false });
+    }
+    catch {
+        // Cache may not exist yet.
+    }
+}
+//# sourceMappingURL=cacheStore.js.map

package/dist/index/chunker.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chunkFile = chunkFile;
+exports.chunkAroundLines = chunkAroundLines;
+const text_1 = require("../utils/text");
+function chunkFile(content, chunkSizeLines, overlapLines) {
+    const lines = content.split(/\r?\n/);
+    const chunks = [];
+    const size = Math.max(20, chunkSizeLines);
+    const overlap = Math.max(0, Math.min(overlapLines, size - 1));
+    for (let index = 0; index < lines.length; index += size - overlap) {
+        const startLine = index + 1;
+        const endLine = Math.min(lines.length, index + size);
+        chunks.push({
+            range: { startLine, endLine },
+            text: (0, text_1.snippetFromLines)(lines, startLine, endLine)
+        });
+        if (endLine >= lines.length) {
+            break;
+        }
+    }
+    return chunks;
+}
+function chunkAroundLines(content, lineNumbers, contextRadius, maxChunkLines = 120) {
+    const lines = content.split(/\r?\n/);
+    const sorted = [...new Set(lineNumbers)].sort((a, b) => a - b);
+    const ranges = [];
+    const maxLines = Math.max(contextRadius * 2 + 1, maxChunkLines);
+    for (const lineNumber of sorted) {
+        const startLine = Math.max(1, lineNumber - contextRadius);
+        const endLine = Math.min(lines.length, lineNumber + contextRadius);
+        const previous = ranges.at(-1);
+        if (previous && startLine <= previous.endLine + 1 && Math.max(previous.endLine, endLine) - previous.startLine + 1 <= maxLines) {
+            previous.endLine = Math.max(previous.endLine, endLine);
+        }
+        else {
+            ranges.push({ startLine, endLine });
+        }
+    }
+    return ranges.map((range) => ({
+        range,
+        text: (0, text_1.snippetFromLines)(lines, range.startLine, range.endLine)
+    }));
+}
+//# sourceMappingURL=chunker.js.map