flowseeker 0.1.7

package/dist/ui/resultTreeProvider.js

@@ -0,0 +1,174 @@
+"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.ResultTreeProvider = exports.ResultNode = void 0;
+const vscode = __importStar(require("vscode"));
+class ResultNode {
+    constructor(type, label, role, unit) {
+        this.type = type;
+        this.label = label;
+        this.role = role;
+        this.unit = unit;
+    }
+}
+exports.ResultNode = ResultNode;
+const roleLabels = [
+    { role: "edit_candidate", label: "Most Likely Edit Areas" },
+    { role: "read_context", label: "Read Before Editing" },
+    { role: "impact", label: "Impact And Risk" },
+    { role: "test", label: "Tests To Run Or Update" },
+    { role: "verify", label: "Verify" },
+    { role: "unknown", label: "Uncertain Candidates" }
+];
+class ResultTreeProvider {
+    constructor() {
+        this.changeEmitter = new vscode.EventEmitter();
+        this.onDidChangeTreeData = this.changeEmitter.event;
+        this.checkedIds = new Set();
+    }
+    setResult(result) {
+        this.result = result;
+        this.checkedIds = new Set(result.units.filter((unit) => unit.role !== "unknown").map((unit) => unit.id));
+        this.changeEmitter.fire();
+    }
+    getResult() {
+        return this.result;
+    }
+    setChecked(unitId, checked) {
+        if (checked) {
+            this.checkedIds.add(unitId);
+        }
+        else {
+            this.checkedIds.delete(unitId);
+        }
+    }
+    getSelectedUnits() {
+        if (!this.result) {
+            return [];
+        }
+        const selected = this.result.units.filter((unit) => this.checkedIds.has(unit.id));
+        return selected.length > 0 ? selected : this.result.units;
+    }
+    findUnitsForFile(filePath) {
+        return this.result?.units.filter((unit) => unit.file === filePath) ?? [];
+    }
+    getUnitsByRole(role) {
+        return this.result?.units.filter((unit) => unit.role === role) ?? [];
+    }
+    getTreeItem(element) {
+        if (element.type === "empty") {
+            const item = new vscode.TreeItem(element.label, vscode.TreeItemCollapsibleState.None);
+            item.iconPath = new vscode.ThemeIcon("search");
+            return item;
+        }
+        if (element.type === "group") {
+            const count = this.result?.units.filter((unit) => unit.role === element.role).length ?? 0;
+            const item = new vscode.TreeItem(`${element.label} (${count})`, vscode.TreeItemCollapsibleState.Expanded);
+            item.contextValue = "flowseekerGroup";
+            item.iconPath = iconForRole(element.role);
+            return item;
+        }
+        const unit = element.unit;
+        const range = unit?.range ? `:${unit.range.startLine}-${unit.range.endLine}` : "";
+        const item = new vscode.TreeItem(`${unit?.relativePath ?? element.label}${range}`, vscode.TreeItemCollapsibleState.None);
+        item.description = unit ? `${unit.kind} ${unit.tier} ${unit.confidence.toFixed(2)}` : undefined;
+        item.tooltip = unit ? tooltipForUnit(unit) : undefined;
+        item.contextValue = "flowseekerEvidence";
+        item.iconPath = unit ? iconForRole(unit.role) : undefined;
+        item.command = unit
+            ? {
+                command: "flowseeker.openEvidence",
+                title: "Open Evidence",
+                arguments: [unit]
+            }
+            : undefined;
+        if (unit) {
+            item.checkboxState = this.checkedIds.has(unit.id) ? vscode.TreeItemCheckboxState.Checked : vscode.TreeItemCheckboxState.Unchecked;
+        }
+        return item;
+    }
+    getChildren(element) {
+        if (!this.result) {
+            return [new ResultNode("empty", "Run FlowSeeker: Find Relevant Context")];
+        }
+        if (!element) {
+            return roleLabels
+                .filter(({ role }) => this.result?.units.some((unit) => unit.role === role))
+                .map(({ role, label }) => new ResultNode("group", label, role));
+        }
+        if (element.type === "group" && element.role) {
+            return this.result.units
+                .filter((unit) => unit.role === element.role)
+                .map((unit) => new ResultNode("evidence", unit.relativePath, element.role, unit));
+        }
+        return [];
+    }
+}
+exports.ResultTreeProvider = ResultTreeProvider;
+function tooltipForUnit(unit) {
+    const lines = [
+        `**${unit.relativePath}**`,
+        "",
+        `Kind: ${unit.kind}`,
+        `Role: ${unit.role}`,
+        `Score: ${unit.score.toFixed(1)}`,
+        `Confidence: ${unit.confidence.toFixed(2)}`,
+        `Retrieval passes: ${unit.retrievalPasses.length > 0 ? unit.retrievalPasses.join(", ") : "seed"}`,
+        `Imports: ${unit.imports.length > 0 ? unit.imports.slice(0, 5).join(", ") : "none"}`,
+        "",
+        "Reasons:",
+        ...unit.reasons.map((reason) => `- ${reason}`)
+    ];
+    return new vscode.MarkdownString(lines.join("\n"));
+}
+function iconForRole(role) {
+    switch (role) {
+        case "edit_candidate":
+            return new vscode.ThemeIcon("edit");
+        case "read_context":
+            return new vscode.ThemeIcon("book");
+        case "impact":
+            return new vscode.ThemeIcon("references");
+        case "test":
+            return new vscode.ThemeIcon("beaker");
+        case "verify":
+            return new vscode.ThemeIcon("checklist");
+        case "unknown":
+            return new vscode.ThemeIcon("question");
+        default:
+            return new vscode.ThemeIcon("folder");
+    }
+}
+//# sourceMappingURL=resultTreeProvider.js.map

package/dist/usage/quotaTracker.js

@@ -0,0 +1,358 @@
+"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.QuotaTracker = void 0;
+exports.formatUsageSummary = formatUsageSummary;
+const vscode = __importStar(require("vscode"));
+const PRICING = {
+    "gpt-5.2": { inputPer1M: 2.50, outputPer1M: 10.00 },
+    "gpt-5.5": { inputPer1M: 2.50, outputPer1M: 10.00 },
+    "gpt-5": { inputPer1M: 2.50, outputPer1M: 10.00 },
+    "gpt-4o": { inputPer1M: 2.50, outputPer1M: 10.00 },
+    "gpt-4o-mini": { inputPer1M: 0.15, outputPer1M: 0.60 },
+    "gpt-4.1": { inputPer1M: 2.00, outputPer1M: 8.00 },
+    "gpt-4.1-mini": { inputPer1M: 0.40, outputPer1M: 1.60 },
+    "gpt-4.1-nano": { inputPer1M: 0.10, outputPer1M: 0.40 },
+    "o4-mini": { inputPer1M: 1.10, outputPer1M: 4.40 },
+    "claude-sonnet-4-5": { inputPer1M: 3.00, outputPer1M: 15.00 },
+    "claude-sonnet-4": { inputPer1M: 3.00, outputPer1M: 15.00 },
+    "claude-opus-4": { inputPer1M: 15.00, outputPer1M: 75.00 },
+    "claude-haiku-4-5": { inputPer1M: 0.80, outputPer1M: 4.00 },
+    "gemini-2.5-flash": { inputPer1M: 0.15, outputPer1M: 0.60 },
+    "gemini-2.5-pro": { inputPer1M: 1.25, outputPer1M: 10.00 },
+    "grok-4": { inputPer1M: 2.00, outputPer1M: 8.00 },
+    "deepseek-chat": { inputPer1M: 0.27, outputPer1M: 1.10 },
+    "deepseek-reasoner": { inputPer1M: 0.55, outputPer1M: 2.19 },
+    "mistral-large-latest": { inputPer1M: 2.00, outputPer1M: 6.00 },
+    "llama-3.3-70b": { inputPer1M: 0.59, outputPer1M: 0.79 },
+};
+const DEFAULT_MONTHLY_COST = 10;
+const QUOTA_LIMITS_KEY = "flowseeker.usage.limits";
+const BUDGET_KEY = "flowseeker.usage.budget";
+const LIVE_QUOTA_KEY = "flowseeker.usage.liveQuota.v1";
+function getPricing(model) {
+    const lower = model.toLowerCase();
+    for (const [key, tier] of Object.entries(PRICING)) {
+        const lowerKey = key.toLowerCase();
+        if (lower === lowerKey || lower.includes(lowerKey) || lowerKey.includes(lower)) {
+            return tier;
+        }
+    }
+    return { inputPer1M: 1.00, outputPer1M: 4.00 };
+}
+function calculateCost(model, inputTokens, outputTokens) {
+    const pricing = getPricing(model);
+    return (inputTokens / 1000000) * pricing.inputPer1M + (outputTokens / 1000000) * pricing.outputPer1M;
+}
+function usageStateKey() {
+    return "flowseeker.usage.records.v1";
+}
+function dailyResetMs() {
+    const now = new Date();
+    const tomorrow = new Date(now);
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    tomorrow.setHours(0, 0, 0, 0);
+    return tomorrow.getTime();
+}
+function monthlyResetMs() {
+    const now = new Date();
+    const nextMonth = new Date(now.getFullYear(), now.getMonth() + 1, 1);
+    nextMonth.setHours(0, 0, 0, 0);
+    return nextMonth.getTime();
+}
+class QuotaTracker {
+    constructor(context) {
+        this.context = context;
+        this.records = [];
+        this.limits = {};
+        this.liveQuota = new Map();
+        this.onChangeCallbacks = [];
+        this.load();
+    }
+    onDidChange(callback) {
+        this.onChangeCallbacks.push(callback);
+        return { dispose: () => { this.onChangeCallbacks = this.onChangeCallbacks.filter((cb) => cb !== callback); } };
+    }
+    notifyChange() {
+        for (const cb of this.onChangeCallbacks) {
+            try {
+                cb();
+            }
+            catch { /* ignore */ }
+        }
+    }
+    record(provider, model, inputTokens, outputTokens, providerQuota) {
+        const cost = calculateCost(model, inputTokens, outputTokens);
+        this.records.push({
+            provider,
+            model,
+            timestamp: Date.now(),
+            inputTokens,
+            outputTokens,
+            costUSD: cost
+        });
+        if (this.records.length > 2000) {
+            this.records = this.records.slice(-2000);
+        }
+        // Store latest live quota from provider
+        if (providerQuota && hasQuotaSignal(providerQuota)) {
+            this.liveQuota.set(`${provider}|${model}`, providerQuota);
+            this.saveLiveQuota();
+        }
+        this.save();
+        this.notifyChange();
+        void this.checkBudget();
+    }
+    getSummary() {
+        const todayStart = new Date();
+        todayStart.setHours(0, 0, 0, 0);
+        const monthStart = new Date(new Date().getFullYear(), new Date().getMonth(), 1);
+        const now = Date.now();
+        const modelMap = new Map();
+        let totalInput = 0;
+        let totalOutput = 0;
+        let totalCost = 0;
+        let todayCost = 0;
+        for (const r of this.records) {
+            totalInput += r.inputTokens;
+            totalOutput += r.outputTokens;
+            totalCost += r.costUSD;
+            const key = `${r.provider}|${r.model}`;
+            let entry = modelMap.get(key);
+            if (!entry) {
+                entry = {
+                    provider: r.provider,
+                    model: r.model,
+                    dailyTokens: 0,
+                    monthlyCost: 0,
+                    requestsToday: 0
+                };
+                modelMap.set(key, entry);
+            }
+            if (r.timestamp >= todayStart.getTime()) {
+                entry.dailyTokens += r.inputTokens + r.outputTokens;
+                entry.requestsToday++;
+                todayCost += r.costUSD;
+            }
+            if (r.timestamp >= monthStart.getTime()) {
+                entry.monthlyCost += r.costUSD;
+            }
+        }
+        const quotaKeys = new Set([...modelMap.keys(), ...this.liveQuota.keys()]);
+        const models = [];
+        for (const key of quotaKeys) {
+            const entry = modelMap.get(key) ?? createEmptyEntryFromKey(key);
+            if (!entry) {
+                continue;
+            }
+            const userLimit = this.getLimit(entry.provider, entry.model);
+            const liveQuota = this.liveQuota.get(key);
+            const hasLiveQuota = liveQuota && hasQuotaSignal(liveQuota);
+            const hasLiveTokenLimit = typeof liveQuota?.tokensLimit === "number";
+            // Prefer provider quota when available. If a provider only exposes request
+            // limits, keep token quota unknown instead of showing a fake token cap.
+            const dailyLimit = hasLiveTokenLimit
+                ? liveQuota.tokensLimit
+                : userLimit.dailyTokens ?? -1;
+            const monthlyLimit = userLimit.monthlyCost ?? DEFAULT_MONTHLY_COST;
+            const quotaSource = hasLiveQuota
+                ? "live"
+                : userLimit.dailyTokens
+                    ? "manual"
+                    : "unknown";
+            // Calculate tokens used from live quota (remaining) if available
+            const tokensUsed = hasLiveTokenLimit && liveQuota?.tokensRemaining !== undefined
+                ? dailyLimit - liveQuota.tokensRemaining
+                : entry.dailyTokens;
+            const dailyPct = dailyLimit > 0 ? Math.min(100, Math.round((tokensUsed / dailyLimit) * 100)) : -1;
+            models.push({
+                provider: entry.provider,
+                model: entry.model,
+                dailyTokensUsed: tokensUsed,
+                dailyTokenLimit: dailyLimit,
+                dailyPct,
+                quotaSource,
+                requestsLimit: liveQuota?.requestsLimit,
+                requestsRemaining: liveQuota?.requestsRemaining,
+                monthlyCostUsed: Math.round(entry.monthlyCost * 10000) / 10000,
+                monthlyCostLimit: monthlyLimit,
+                monthlyPct: Math.min(100, Math.round((entry.monthlyCost / monthlyLimit) * 100)),
+                requestsToday: entry.requestsToday,
+                dailyResetMs: dailyResetMs(),
+                monthlyResetMs: monthlyResetMs()
+            });
+        }
+        models.sort((a, b) => b.monthlyCostUsed - a.monthlyCostUsed);
+        const weekAgo = now - 7 * 24 * 60 * 60 * 1000;
+        let weekCost = 0;
+        for (const r of this.records) {
+            if (r.timestamp >= weekAgo) {
+                weekCost += r.costUSD;
+            }
+        }
+        return {
+            totalRequests: this.records.length,
+            totalInputTokens: totalInput,
+            totalOutputTokens: totalOutput,
+            totalCostUSD: Math.round(totalCost * 10000) / 10000,
+            todayCostUSD: Math.round(todayCost * 10000) / 10000,
+            thisWeekCostUSD: Math.round(weekCost * 10000) / 10000,
+            models
+        };
+    }
+    async setLimit(provider, model, limit) {
+        const key = `${provider}|${model}`;
+        this.limits[key] = limit;
+        await this.saveLimits();
+    }
+    getLimit(provider, model) {
+        const key = `${provider}|${model}`;
+        return this.limits[key] ?? {};
+    }
+    async setBudget(limitUSD) {
+        await this.context.globalState.update(BUDGET_KEY, limitUSD);
+    }
+    getBudget() {
+        return this.context.globalState.get(BUDGET_KEY, 0);
+    }
+    async clearHistory() {
+        this.records = [];
+        await this.context.globalState.update(usageStateKey(), undefined);
+    }
+    load() {
+        const stored = this.context.globalState.get(usageStateKey(), []);
+        this.records = Array.isArray(stored) ? stored : [];
+        this.limits = this.context.globalState.get(QUOTA_LIMITS_KEY, {});
+        const storedLiveQuota = this.context.globalState.get(LIVE_QUOTA_KEY, {});
+        this.liveQuota = new Map(Object.entries(storedLiveQuota).filter((entry) => hasQuotaSignal(entry[1])));
+    }
+    save() {
+        void this.context.globalState.update(usageStateKey(), this.records);
+    }
+    async saveLimits() {
+        await this.context.globalState.update(QUOTA_LIMITS_KEY, this.limits);
+    }
+    saveLiveQuota() {
+        void this.context.globalState.update(LIVE_QUOTA_KEY, Object.fromEntries(this.liveQuota));
+    }
+    async checkBudget() {
+        const budget = this.getBudget();
+        if (budget <= 0) {
+            return;
+        }
+        const summary = this.getSummary();
+        const pctUsed = summary.todayCostUSD / budget;
+        if (pctUsed >= 0.75 && pctUsed < 1.0) {
+            void vscode.window.showWarningMessage(`FlowSeeker: ${Math.round(pctUsed * 100)}% of daily budget used ($${summary.todayCostUSD.toFixed(2)} / $${budget.toFixed(2)})`, "Dismiss");
+        }
+        else if (pctUsed >= 1.0) {
+            void vscode.window.showErrorMessage(`FlowSeeker: Daily budget exceeded ($${summary.todayCostUSD.toFixed(2)} / $${budget.toFixed(2)}).`, "Set new budget", "Dismiss").then((choice) => {
+                if (choice === "Set new budget") {
+                    void vscode.commands.executeCommand("flowseeker.setBudget");
+                }
+            });
+        }
+    }
+}
+exports.QuotaTracker = QuotaTracker;
+function hasQuotaSignal(value) {
+    return Boolean(value &&
+        (value.tokensLimit !== undefined ||
+            value.tokensRemaining !== undefined ||
+            value.requestsLimit !== undefined ||
+            value.requestsRemaining !== undefined));
+}
+function createEmptyEntryFromKey(key) {
+    const separator = key.indexOf("|");
+    if (separator <= 0) {
+        return undefined;
+    }
+    return {
+        provider: key.slice(0, separator),
+        model: key.slice(separator + 1),
+        dailyTokens: 0,
+        monthlyCost: 0,
+        requestsToday: 0
+    };
+}
+function formatUsageSummary(summary) {
+    const lines = [
+        `**Today:** $${summary.todayCostUSD.toFixed(3)}  |  **Week:** $${summary.thisWeekCostUSD.toFixed(3)}  |  **Total:** $${summary.totalCostUSD.toFixed(3)}`,
+        `**Requests:** ${summary.totalRequests}  |  **Tokens:** ${formatTokenCount(summary.totalInputTokens + summary.totalOutputTokens)}`,
+        "",
+    ];
+    if (summary.models.length > 0) {
+        lines.push("| Provider/Model | Today Tokens | Daily % | Month Cost | Month % |");
+        lines.push("|---|---|---|---|---|");
+        for (const m of summary.models.slice(0, 10)) {
+            const dailyLabel = m.dailyTokenLimit > 0
+                ? `${formatTokenCount(m.dailyTokensUsed)} / ${formatTokenCount(m.dailyTokenLimit)}`
+                : `${formatTokenCount(m.dailyTokensUsed)} / token limit unknown`;
+            const dailyPctLabel = m.dailyPct >= 0
+                ? `${progressBar(m.dailyPct)} ${m.dailyPct}%`
+                : formatRequestQuota(m);
+            lines.push(`| ${m.provider} / ${m.model} | ${dailyLabel} | ${dailyPctLabel} | $${m.monthlyCostUsed.toFixed(2)} / $${m.monthlyCostLimit} | ${progressBar(m.monthlyPct)} ${m.monthlyPct}% |`);
+        }
+    }
+    return lines.join("\n");
+}
+function formatRequestQuota(model) {
+    if (model.requestsLimit !== undefined && model.requestsRemaining !== undefined) {
+        const used = Math.max(0, model.requestsLimit - model.requestsRemaining);
+        return `${formatTokenCount(used)} / ${formatTokenCount(model.requestsLimit)} requests`;
+    }
+    if (model.requestsRemaining !== undefined) {
+        return `${formatTokenCount(model.requestsRemaining)} requests remaining`;
+    }
+    if (model.requestsLimit !== undefined) {
+        return `${formatTokenCount(model.requestsLimit)} request limit`;
+    }
+    return model.quotaSource === "live" ? "live quota" : "unknown";
+}
+function progressBar(pct) {
+    const filled = Math.round(pct / 10);
+    const empty = 10 - filled;
+    return `[${"#".repeat(filled)}${".".repeat(empty)}]`;
+}
+function formatTokenCount(n) {
+    if (n >= 1000000) {
+        return `${(n / 1000000).toFixed(1)}M`;
+    }
+    if (n >= 1000) {
+        return `${(n / 1000).toFixed(0)}K`;
+    }
+    return String(n);
+}
+//# sourceMappingURL=quotaTracker.js.map

package/dist/utils/async.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTimeout = withTimeout;
+exports.checkCancelled = checkCancelled;
+async function withTimeout(promise, ms, label) {
+    if (ms <= 0) {
+        return promise;
+    }
+    let timeoutId;
+    const timeout = new Promise((_resolve, reject) => {
+        timeoutId = setTimeout(() => {
+            reject(new Error(`Timed out after ${ms}ms: ${label}`));
+        }, ms);
+    });
+    try {
+        const result = await Promise.race([promise, timeout]);
+        return result;
+    }
+    finally {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+    }
+}
+function checkCancelled(token) {
+    if (token?.isCancellationRequested) {
+        throw new Error("Cancelled");
+    }
+}
+//# sourceMappingURL=async.js.map

package/dist/utils/logger.js

@@ -0,0 +1,64 @@
+"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.initializeLogger = initializeLogger;
+exports.showLog = showLog;
+exports.logInfo = logInfo;
+exports.logWarn = logWarn;
+exports.logError = logError;
+const vscode = __importStar(require("vscode"));
+let channel;
+function initializeLogger(context) {
+    channel = vscode.window.createOutputChannel("FlowSeeker");
+    context.subscriptions.push(channel);
+}
+function showLog() {
+    channel?.show(true);
+}
+function logInfo(message) {
+    write("INFO", message);
+}
+function logWarn(message) {
+    write("WARN", message);
+}
+function logError(message, error) {
+    const suffix = error instanceof Error ? `\n${error.stack ?? error.message}` : error ? `\n${String(error)}` : "";
+    write("ERROR", `${message}${suffix}`);
+}
+function write(level, message) {
+    const timestamp = new Date().toISOString();
+    channel?.appendLine(`[${level}] ${timestamp} - ${message}`);
+}
+//# sourceMappingURL=logger.js.map