spiracha 1.5.0 → 2.1.0

package/apps/ui/dist/server/assets/cursor-db-CZnYy7aT.js

@@ -1,830 +0,0 @@
-import { i as asString, n as asNumber, r as asObject } from "./shared-DyhChtHf.js";
-import { getCursorGlobalDbPath, getCursorProjectsDir, getCursorWorkspaceStorageDir, resolveCursorUserDir } from "./cursor-exporter-types-CI3goo-c.js";
-import { createHash } from "node:crypto";
-import { readdir, stat } from "node:fs/promises";
-import path from "node:path";
-import { Database, constants } from "bun:sqlite";
-//#region ../../src/lib/cursor-db.ts
-var CURSOR_READONLY_DB_OPEN_FLAGS = constants.SQLITE_OPEN_READONLY | constants.SQLITE_OPEN_URI;
-var getCursorReadonlyDbUri = (dbPath) => {
-	const normalizedPath = dbPath.replace(/\\/gu, "/");
-	return `file://${(normalizedPath.startsWith("/") ? normalizedPath : `/${normalizedPath}`).split("/").map((segment) => /^[A-Za-z]:$/u.test(segment) ? segment : encodeURIComponent(segment)).join("/")}?immutable=1`;
-};
-var openCursorReadonlyDb = (dbPath) => {
-	return new Database(getCursorReadonlyDbUri(dbPath), CURSOR_READONLY_DB_OPEN_FLAGS);
-};
-var pathExists = async (target) => {
-	try {
-		await stat(target);
-		return true;
-	} catch {
-		return false;
-	}
-};
-var isMissingOrUnreadableCursorStoreError = (error) => {
-	const code = error.code;
-	return code === "ENOENT" || code === "ENOTDIR" || code === "SQLITE_CANTOPEN";
-};
-var readItemValue = (db, key) => {
-	const row = db.query("SELECT value FROM ItemTable WHERE key = ?").get(key);
-	if (!row?.value) return null;
-	try {
-		return JSON.parse(row.value);
-	} catch {
-		return null;
-	}
-};
-var readKvValue = (db, key) => {
-	const row = db.query("SELECT value FROM cursorDiskKV WHERE key = ?").get(key);
-	if (!row?.value) return null;
-	try {
-		return JSON.parse(row.value);
-	} catch {
-		return null;
-	}
-};
-var decodeCursorUri = (uri) => {
-	if (!uri) return "";
-	if (uri.startsWith("file://")) return decodeURIComponent(uri.slice(7));
-	return uri;
-};
-var normalizeCursorPath = (value) => {
-	const decoded = decodeCursorUri(value.trim());
-	if (!decoded) return "";
-	return decoded.replace(/\/+$/u, "") || decoded;
-};
-var warnCursorDataIssue = (event, details) => {
-	console.warn(`[spiracha:cursor] ${event}`, details);
-};
-var stripJsonComments = (value) => {
-	return value.replace(/\/\*[\s\S]*?\*\//gu, "").replace(/(^|\s)\/\/.*$/gmu, "$1");
-};
-var parseCodeWorkspaceJson = (text) => {
-	try {
-		return JSON.parse(text);
-	} catch {
-		return JSON.parse(stripJsonComments(text));
-	}
-};
-var parseCodeWorkspaceFolders = async (workspaceFilePath) => {
-	if (!workspaceFilePath.endsWith(".code-workspace")) return [];
-	try {
-		const data = parseCodeWorkspaceJson(await Bun.file(workspaceFilePath).text());
-		const folders = [];
-		for (const entry of data.folders ?? []) {
-			const folderPath = entry.path;
-			if (!folderPath) continue;
-			folders.push(folderPath.startsWith("/") ? normalizeCursorPath(folderPath) : normalizeCursorPath(path.join(path.dirname(workspaceFilePath), folderPath)));
-		}
-		return folders;
-	} catch (error) {
-		warnCursorDataIssue("invalid_code_workspace_json", {
-			error: error instanceof Error ? error.message : String(error),
-			workspaceFilePath
-		});
-		return [];
-	}
-};
-var loadGlobalComposerHeaders = (globalDbPath) => {
-	try {
-		const db = openCursorReadonlyDb(globalDbPath);
-		try {
-			return readItemValue(db, "composer.composerHeaders")?.allComposers ?? [];
-		} finally {
-			db.close();
-		}
-	} catch (error) {
-		warnCursorDataIssue("global_composer_headers_unavailable", {
-			error: error instanceof Error ? error.message : String(error),
-			globalDbPath
-		});
-		return [];
-	}
-};
-var readBucketWorkspaceJson = async (workspaceJsonPath) => {
-	try {
-		return await Bun.file(workspaceJsonPath).json();
-	} catch {
-		return null;
-	}
-};
-var resolveBucketIdentity = async (wsData, bucketId) => {
-	if (wsData.folder) {
-		const folder = normalizeCursorPath(wsData.folder);
-		return {
-			folders: folder ? [folder] : [],
-			kind: "folder",
-			label: folder ? path.basename(folder) : bucketId,
-			uri: wsData.folder
-		};
-	}
-	if (wsData.workspace) {
-		const workspacePath = normalizeCursorPath(wsData.workspace);
-		return {
-			folders: workspacePath ? await parseCodeWorkspaceFolders(workspacePath) : [],
-			kind: "workspace",
-			label: workspacePath ? path.basename(workspacePath) : bucketId,
-			uri: wsData.workspace
-		};
-	}
-	return {
-		folders: [],
-		kind: "unknown",
-		label: bucketId,
-		uri: ""
-	};
-};
-var readBucketComposerIds = (dbPath) => {
-	try {
-		const db = openCursorReadonlyDb(dbPath);
-		try {
-			return (readItemValue(db, "composer.composerData")?.allComposers ?? []).map((entry) => entry.composerId).filter((value) => Boolean(value));
-		} finally {
-			db.close();
-		}
-	} catch {
-		return [];
-	}
-};
-var loadCursorBuckets = async (userDir = resolveCursorUserDir()) => {
-	const workspaceStorageDir = getCursorWorkspaceStorageDir(userDir);
-	let bucketIds = [];
-	try {
-		bucketIds = await readdir(workspaceStorageDir);
-	} catch {
-		return [];
-	}
-	const globalDbPath = getCursorGlobalDbPath(userDir);
-	const headerIdsByBucket = /* @__PURE__ */ new Map();
-	if (await pathExists(globalDbPath)) for (const header of loadGlobalComposerHeaders(globalDbPath)) {
-		const id = header.workspaceIdentifier?.id;
-		if (id && header.composerId) {
-			const set = headerIdsByBucket.get(id) ?? /* @__PURE__ */ new Set();
-			set.add(header.composerId);
-			headerIdsByBucket.set(id, set);
-		}
-	}
-	const buckets = [];
-	for (const bucketId of bucketIds) {
-		const bucket = await buildBucket(workspaceStorageDir, bucketId, headerIdsByBucket);
-		if (bucket) buckets.push(bucket);
-	}
-	return buckets;
-};
-var buildBucket = async (workspaceStorageDir, bucketId, headerIdsByBucket) => {
-	const root = path.join(workspaceStorageDir, bucketId);
-	const workspaceJsonPath = path.join(root, "workspace.json");
-	const dbPath = path.join(root, "state.vscdb");
-	if (!await pathExists(workspaceJsonPath) || !await pathExists(dbPath)) return null;
-	const wsData = await readBucketWorkspaceJson(workspaceJsonPath);
-	if (!wsData || !wsData.folder && !wsData.workspace) return null;
-	let identity;
-	let dbStat;
-	let composerIds;
-	try {
-		identity = await resolveBucketIdentity(wsData, bucketId);
-		dbStat = await stat(dbPath);
-		composerIds = readBucketComposerIds(dbPath);
-	} catch (error) {
-		if (isMissingOrUnreadableCursorStoreError(error)) return null;
-		throw error;
-	}
-	const headerIds = headerIdsByBucket.get(bucketId) ?? /* @__PURE__ */ new Set();
-	const threadComposerIds = [...new Set([...composerIds, ...headerIds])];
-	return {
-		bucketId,
-		composerCount: composerIds.length,
-		dbPath,
-		dbSizeBytes: dbStat.size,
-		folders: identity.folders,
-		globalHeaderCount: headerIds.size,
-		kind: identity.kind,
-		label: identity.label,
-		mtimeMs: dbStat.mtimeMs,
-		threadComposerIds,
-		uri: identity.uri,
-		workspaceJsonPath
-	};
-};
-var getCursorWorkspaceGroupKey = (bucket) => {
-	if (bucket.kind === "folder" && bucket.folders[0]) return `folder:${bucket.folders[0]}`;
-	if (bucket.kind === "workspace") return `workspace:${normalizeCursorPath(bucket.uri)}`;
-	return `unknown:${bucket.bucketId}`;
-};
-var groupCursorBuckets = (buckets) => {
-	const grouped = /* @__PURE__ */ new Map();
-	for (const bucket of buckets) {
-		const key = getCursorWorkspaceGroupKey(bucket);
-		const list = grouped.get(key) ?? [];
-		list.push(bucket);
-		grouped.set(key, list);
-	}
-	const groups = [];
-	for (const [key, list] of grouped.entries()) {
-		const ranked = [...list].sort((a, b) => b.mtimeMs - a.mtimeMs || b.dbSizeBytes - a.dbSizeBytes);
-		const primary = ranked[0];
-		const newest = ranked[0];
-		const threadCount = new Set(ranked.flatMap((bucket) => bucket.threadComposerIds)).size;
-		const olderWithData = ranked.slice(1).some((bucket) => bucket.composerCount > 0 || bucket.globalHeaderCount > 0);
-		groups.push({
-			buckets: ranked,
-			folders: primary.folders,
-			key,
-			kind: primary.kind,
-			label: primary.label,
-			lastActiveMs: Math.max(...ranked.map((bucket) => bucket.mtimeMs)),
-			needsRecovery: ranked.length > 1 && olderWithData && newest.composerCount === 0,
-			threadCount,
-			uri: primary.uri
-		});
-	}
-	return groups.sort((a, b) => b.lastActiveMs - a.lastActiveMs);
-};
-var listCursorWorkspaceGroups = async (userDir = resolveCursorUserDir()) => {
-	return (await discoverCursorWorkspaces(userDir)).groups;
-};
-var countBubbles = (db, composerId) => {
-	const row = db.query("SELECT COUNT(*) AS count, COALESCE(SUM(length(value)), 0) AS bytes FROM cursorDiskKV WHERE key LIKE ?").get(`bubbleId:${composerId}:%`);
-	return {
-		bytes: row.bytes,
-		count: row.count
-	};
-};
-var findCursorTranscriptDirs = async (composerId, userDir = resolveCursorUserDir()) => {
-	const projectsDir = getCursorProjectsDir(userDir);
-	if (!await pathExists(projectsDir)) return [];
-	const matches = [];
-	let projectDirs = [];
-	try {
-		projectDirs = await readdir(projectsDir);
-	} catch {
-		return [];
-	}
-	for (const projectDir of projectDirs) {
-		const transcriptDir = path.join(projectsDir, projectDir, "agent-transcripts", composerId);
-		if (await pathExists(transcriptDir)) matches.push(transcriptDir);
-	}
-	return matches;
-};
-var listCursorThreadsForGroup = async (group, userDir = resolveCursorUserDir(), options = {}) => {
-	const threads = (await discoverCursorWorkspaces(userDir)).threadsByKey.get(group.key) ?? [];
-	if (options.includeTranscriptDirs === false) return threads;
-	return Promise.all(threads.map(async (thread) => ({
-		...thread,
-		transcriptDirs: await findCursorTranscriptDirs(thread.composerId, userDir)
-	})));
-};
-var DISCOVERY_TTL_MS = 6e4;
-var UNKNOWN_GROUP_KEY = "unknown";
-var discoveryCache = null;
-var invalidateCursorDiscoveryCache = () => {
-	discoveryCache = null;
-};
-var DEV_CONTAINER_DIRS = [
-	"workspace",
-	"projects",
-	"dev",
-	"code",
-	"repos",
-	"src",
-	"Documents",
-	"Downloads",
-	"Desktop"
-];
-var REVERSE_WORKSPACE_ROOT_RE = /^\/Users\/[^/]+\/workspace\/reverse\/[^/]+/u;
-var CONTAINER_ROOT_RE = new RegExp(`^(/Users/[^/]+/(?:${DEV_CONTAINER_DIRS.join("|")})/[^/]+)`);
-var ABS_PATH_RE = /\/Users\/[^"'\s:,)\]]+/g;
-var isNoisePath = (value) => /\/Library(?:\/|$)|\/\.cursor(?:\/|$)|\/node_modules\/|\/\.git\/|^\/tmp|^\/var|^\/private|\/\.Trash\//u.test(value) || /^\/Users\/[^/]+\/(?:Downloads|Desktop)$/u.test(value);
-var stripLikelyFileName = (value) => {
-	return path.basename(value).includes(".") ? path.dirname(value) : value;
-};
-var containerRootFromPath = (value) => {
-	const candidate = stripLikelyFileName(normalizeCursorPath(value));
-	const reverseMatch = candidate.match(REVERSE_WORKSPACE_ROOT_RE);
-	if (reverseMatch) return reverseMatch[0] ?? null;
-	const match = candidate.match(CONTAINER_ROOT_RE);
-	if (match) return match[1] ?? null;
-	const parts = candidate.split("/");
-	if (parts.length >= 4 && parts[1] === "Users") return `/${parts.slice(1, 4).join("/")}`;
-	return null;
-};
-var inferFolderFromPaths = (paths) => {
-	const counts = /* @__PURE__ */ new Map();
-	for (const value of paths) {
-		if (isNoisePath(value)) continue;
-		const root = containerRootFromPath(value);
-		if (root) counts.set(root, (counts.get(root) ?? 0) + 1);
-	}
-	let best = null;
-	let bestCount = 0;
-	for (const [root, count] of counts) if (count > bestCount) {
-		best = root;
-		bestCount = count;
-	}
-	return best;
-};
-var inferFolderFromBlob = (blob) => {
-	const matches = blob.match(ABS_PATH_RE);
-	return matches ? inferFolderFromPaths(matches) : null;
-};
-var readCursorFileHistoryProjectActivity = async (userDir) => {
-	const historyDir = path.join(userDir, "History");
-	let entries = [];
-	try {
-		entries = await readdir(historyDir, { withFileTypes: true });
-	} catch {
-		return /* @__PURE__ */ new Map();
-	}
-	const activity = /* @__PURE__ */ new Map();
-	for (const entry of entries) {
-		if (!entry.isDirectory()) continue;
-		const entriesPath = path.join(historyDir, entry.name, "entries.json");
-		let data;
-		try {
-			data = await Bun.file(entriesPath).json();
-		} catch {
-			continue;
-		}
-		const folder = containerRootFromPath(typeof data.resource === "string" ? data.resource : "");
-		if (!folder || isNoisePath(folder)) continue;
-		const lastActiveMs = Math.max(0, ...(data.entries ?? []).map((item) => item.timestamp ?? 0));
-		activity.set(folder, Math.max(activity.get(folder) ?? 0, lastActiveMs));
-	}
-	return activity;
-};
-var inferFolderFromBubbles = (db, composerId) => {
-	const rows = db.query("SELECT value FROM cursorDiskKV WHERE key LIKE ? LIMIT 80").all(`bubbleId:${composerId}:%`);
-	const paths = [];
-	for (const { value } of rows) {
-		let bubble;
-		try {
-			bubble = JSON.parse(value);
-		} catch {
-			continue;
-		}
-		const tool = asObject(bubble.toolFormerData ?? null);
-		if (!tool) continue;
-		const matches = `${asString(tool.rawArgs ?? null) ?? ""} ${asString(tool.params ?? null) ?? ""}`.match(ABS_PATH_RE);
-		if (matches) paths.push(...matches);
-		if (paths.length > 200) break;
-	}
-	return inferFolderFromPaths(paths);
-};
-var readAllHeads = (db) => {
-	const rows = db.query(`SELECT substr(key, 14) AS id, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'`).all();
-	return new Map(rows.map((row) => [row.id, parseGlobalHead(row.value)]));
-};
-var parseGlobalHead = (value) => {
-	let parsed = {};
-	try {
-		parsed = JSON.parse(value);
-	} catch {
-		return {
-			createdAtMs: null,
-			lastUpdatedAtMs: null,
-			mode: null,
-			name: null,
-			pathHint: inferFolderFromBlob(value)
-		};
-	}
-	return {
-		createdAtMs: asNumber(parsed.createdAt ?? null),
-		lastUpdatedAtMs: asNumber(parsed.lastUpdatedAt ?? null),
-		mode: asString(parsed.unifiedMode ?? null),
-		name: asString(parsed.name ?? null),
-		pathHint: inferFolderFromBlob(value)
-	};
-};
-var readBubbleStats = (db) => {
-	const rows = db.query(`SELECT substr(key, 10, instr(substr(key, 10), ':') - 1) AS id,
-                    COUNT(*) AS count,
-                    COALESCE(SUM(length(value)), 0) AS bytes
-             FROM cursorDiskKV WHERE key GLOB 'bubbleId:*:*' GROUP BY id`).all();
-	return new Map(rows.map((row) => [row.id, {
-		bytes: row.bytes,
-		count: row.count
-	}]));
-};
-var readHeaderInfo = (globalDbPath) => {
-	const info = /* @__PURE__ */ new Map();
-	for (const header of loadGlobalComposerHeaders(globalDbPath)) {
-		if (!header.composerId) continue;
-		const identifier = header.workspaceIdentifier;
-		const uriPath = identifier?.uri?.path ?? identifier?.uri?.fsPath ?? null;
-		info.set(header.composerId, {
-			bucketId: identifier?.id ?? null,
-			name: typeof header.name === "string" ? header.name : null,
-			uriPath: uriPath ? normalizeCursorPath(uriPath) : null
-		});
-	}
-	return info;
-};
-var collectBucketComposerIds = (buckets) => {
-	const map = /* @__PURE__ */ new Map();
-	for (const bucket of buckets) for (const composerId of readBucketComposerIds(bucket.dbPath)) if (!map.has(composerId)) map.set(composerId, bucket.bucketId);
-	return map;
-};
-var findLinkedBucketId = (composerId, headerInfo, bucketIdToGroupKey, bucketComposerIds) => {
-	if (headerInfo?.bucketId && bucketIdToGroupKey.has(headerInfo.bucketId)) return headerInfo.bucketId;
-	return bucketComposerIds.get(composerId) ?? null;
-};
-var resolveThreadFolderHint = (composerId, head, headerInfo, stat, linkedBucketId, bucketIdToGroupKey, bucketIdToFolder, db) => {
-	if (linkedBucketId && bucketIdToGroupKey.has(linkedBucketId)) return {
-		folder: bucketIdToFolder.get(linkedBucketId) ?? null,
-		groupKey: bucketIdToGroupKey.get(linkedBucketId)
-	};
-	if (headerInfo?.uriPath) return {
-		folder: headerInfo.uriPath,
-		groupKey: `folder:${headerInfo.uriPath}`
-	};
-	if (head?.pathHint) return {
-		folder: head.pathHint,
-		groupKey: `folder:${head.pathHint}`
-	};
-	if (stat.count > 0) {
-		const folder = inferFolderFromBubbles(db, composerId);
-		return {
-			folder,
-			groupKey: folder ? `folder:${folder}` : UNKNOWN_GROUP_KEY
-		};
-	}
-	return {
-		folder: null,
-		groupKey: UNKNOWN_GROUP_KEY
-	};
-};
-var resolveThreadFolder = (composerId, head, headerInfo, stat, bucketIdToGroupKey, bucketIdToFolder, bucketComposerIds, db) => {
-	const linkedBucketId = findLinkedBucketId(composerId, headerInfo, bucketIdToGroupKey, bucketComposerIds);
-	const { folder, groupKey } = resolveThreadFolderHint(composerId, head, headerInfo, stat, linkedBucketId, bucketIdToGroupKey, bucketIdToFolder, db);
-	return {
-		bucketId: linkedBucketId,
-		composerId,
-		createdAtMs: head?.createdAtMs ?? null,
-		folder,
-		groupKey,
-		groupLabel: folder ? path.basename(folder) : "Unknown project",
-		lastUpdatedAtMs: head?.lastUpdatedAtMs ?? null,
-		mode: head?.mode ?? null,
-		name: head?.name || headerInfo?.name || "(untitled)",
-		stat
-	};
-};
-var toThreadSummary = (resolved) => ({
-	bubbleBytes: resolved.stat.bytes,
-	bubbleCount: resolved.stat.count,
-	bucketId: resolved.bucketId,
-	composerId: resolved.composerId,
-	createdAtMs: resolved.createdAtMs,
-	lastUpdatedAtMs: resolved.lastUpdatedAtMs,
-	mode: resolved.mode,
-	name: resolved.name,
-	transcriptDirs: [],
-	workspaceKey: resolved.groupKey,
-	workspaceLabel: resolved.groupLabel
-});
-var assembleDiscovery = (resolved, bucketGroups, fileHistoryActivity) => {
-	const threadsByKey = /* @__PURE__ */ new Map();
-	const lastActiveByKey = /* @__PURE__ */ new Map();
-	for (const thread of resolved) {
-		if (thread.groupKey === UNKNOWN_GROUP_KEY && thread.stat.count === 0) continue;
-		const list = threadsByKey.get(thread.groupKey) ?? [];
-		list.push(toThreadSummary(thread));
-		threadsByKey.set(thread.groupKey, list);
-		lastActiveByKey.set(thread.groupKey, Math.max(lastActiveByKey.get(thread.groupKey) ?? 0, thread.lastUpdatedAtMs ?? 0));
-	}
-	for (const [folder, lastActiveMs] of fileHistoryActivity) {
-		const key = `folder:${folder}`;
-		lastActiveByKey.set(key, Math.max(lastActiveByKey.get(key) ?? 0, lastActiveMs));
-	}
-	for (const list of threadsByKey.values()) list.sort((a, b) => (b.lastUpdatedAtMs ?? 0) - (a.lastUpdatedAtMs ?? 0));
-	return {
-		groups: buildDiscoveryGroups(threadsByKey, bucketGroups, lastActiveByKey),
-		threadsByKey
-	};
-};
-var mergeBucketGroup = (bucketGroup, threadsByKey, lastActiveByKey) => {
-	const threads = threadsByKey.get(bucketGroup.key) ?? [];
-	return {
-		...bucketGroup,
-		lastActiveMs: Math.max(bucketGroup.lastActiveMs, lastActiveByKey.get(bucketGroup.key) ?? 0),
-		threadCount: threads.length || bucketGroup.threadCount
-	};
-};
-var buildBucketlessGroup = (key, threadCount, lastActiveMs) => {
-	const isUnknown = key === UNKNOWN_GROUP_KEY;
-	const folder = isUnknown ? "" : key.slice(7);
-	return {
-		buckets: [],
-		folders: folder ? [folder] : [],
-		key,
-		kind: isUnknown ? "unknown" : "folder",
-		label: isUnknown ? "Unknown project" : path.basename(folder),
-		lastActiveMs,
-		needsRecovery: false,
-		threadCount,
-		uri: folder ? `file://${folder}` : ""
-	};
-};
-var buildDiscoveryGroups = (threadsByKey, bucketGroups, lastActiveByKey) => {
-	const seen = new Set(bucketGroups.map((group) => group.key));
-	const groups = bucketGroups.map((group) => mergeBucketGroup(group, threadsByKey, lastActiveByKey));
-	const keys = new Set([...threadsByKey.keys(), ...lastActiveByKey.keys()]);
-	for (const key of keys) {
-		const threads = threadsByKey.get(key) ?? [];
-		if (!seen.has(key) && (threads.length > 0 || key !== UNKNOWN_GROUP_KEY)) {
-			groups.push(buildBucketlessGroup(key, threads.length, lastActiveByKey.get(key) ?? 0));
-			seen.add(key);
-		}
-	}
-	return groups.sort((a, b) => b.lastActiveMs - a.lastActiveMs);
-};
-var buildDiscovery = async (userDir) => {
-	const buckets = await loadCursorBuckets(userDir);
-	const bucketGroups = groupCursorBuckets(buckets);
-	const fileHistoryActivity = await readCursorFileHistoryProjectActivity(userDir);
-	const globalDbPath = getCursorGlobalDbPath(userDir);
-	if (!await pathExists(globalDbPath)) return assembleDiscovery([], bucketGroups, fileHistoryActivity);
-	const bucketIdToGroupKey = /* @__PURE__ */ new Map();
-	const bucketIdToFolder = /* @__PURE__ */ new Map();
-	for (const group of bucketGroups) for (const bucket of group.buckets) {
-		bucketIdToGroupKey.set(bucket.bucketId, group.key);
-		bucketIdToFolder.set(bucket.bucketId, group.folders[0] ?? null);
-	}
-	const headerInfo = readHeaderInfo(globalDbPath);
-	const bucketComposerIds = collectBucketComposerIds(buckets);
-	const db = openCursorReadonlyDb(globalDbPath);
-	try {
-		const heads = readAllHeads(db);
-		const stats = readBubbleStats(db);
-		const universe = new Set([
-			...heads.keys(),
-			...headerInfo.keys(),
-			...bucketComposerIds.keys()
-		]);
-		const resolved = [];
-		for (const composerId of universe) resolved.push(resolveThreadFolder(composerId, heads.get(composerId), headerInfo.get(composerId), stats.get(composerId) ?? {
-			bytes: 0,
-			count: 0
-		}, bucketIdToGroupKey, bucketIdToFolder, bucketComposerIds, db));
-		return assembleDiscovery(resolved, bucketGroups, fileHistoryActivity);
-	} finally {
-		db.close();
-	}
-};
-var discoverCursorWorkspaces = async (userDir) => {
-	const now = Date.now();
-	if (discoveryCache && discoveryCache.userDir === userDir && now - discoveryCache.at < DISCOVERY_TTL_MS) return discoveryCache.value;
-	const value = await buildDiscovery(userDir);
-	discoveryCache = {
-		at: now,
-		userDir,
-		value
-	};
-	return value;
-};
-var readCursorThreadHead = (globalDbPath, composerId) => {
-	const db = openCursorReadonlyDb(globalDbPath);
-	try {
-		const head = readKvValue(db, `composerData:${composerId}`);
-		if (!head) return null;
-		const headerList = Array.isArray(head.fullConversationHeadersOnly) ? head.fullConversationHeadersOnly : [];
-		const orderedBubbleIds = headerList.map((item) => asString(asObject(item)?.bubbleId ?? null)).filter((value) => Boolean(value));
-		return {
-			composerId,
-			createdAtMs: asNumber(head.createdAt ?? null),
-			lastUpdatedAtMs: asNumber(head.lastUpdatedAt ?? null),
-			mode: asString(head.unifiedMode ?? null),
-			name: asString(head.name ?? null),
-			orderedBubbleIds,
-			totalBubbleHeaders: headerList.length
-		};
-	} finally {
-		db.close();
-	}
-};
-var toBubbleKind = (rawType) => {
-	if (rawType === 1) return "user";
-	if (rawType === 2) return "assistant";
-	return "unknown";
-};
-var parseToolCall = (raw) => {
-	const data = asObject(raw);
-	if (!data) return null;
-	const name = asString(data.name ?? null);
-	if (!name) return null;
-	return {
-		argumentsText: asString(data.rawArgs ?? null) ?? asString(data.params ?? null),
-		callId: asString(data.toolCallId ?? null),
-		name,
-		resultText: asString(data.result ?? null),
-		status: asString(data.status ?? null)
-	};
-};
-var parseCursorBubble = (bubbleId, raw) => {
-	const thinking = asObject(raw.thinking ?? null);
-	return {
-		bubbleId,
-		createdAtMs: asNumber(raw.createdAt ?? null),
-		kind: toBubbleKind(raw.type ?? null),
-		text: asString(raw.text ?? null) ?? "",
-		thinking: thinking ? asString(thinking.text ?? null) : null,
-		toolCall: parseToolCall(raw.toolFormerData ?? null)
-	};
-};
-var readBubble = (db, composerId, bubbleId) => {
-	const raw = readKvValue(db, `bubbleId:${composerId}:${bubbleId}`);
-	if (!raw) return null;
-	return parseCursorBubble(bubbleId, raw);
-};
-var isRenderableBubble = (bubble) => {
-	return Boolean(bubble.text.trim() || bubble.thinking?.trim() || bubble.toolCall);
-};
-var normalizeBubbleText = (value) => {
-	return (value ?? "").replace(/\s+/gu, " ").trim();
-};
-var hashText = (value) => createHash("sha1").update(value).digest("hex").slice(0, 12);
-var stableStringifyJson = (value) => {
-	if (Array.isArray(value)) return `[${value.map(stableStringifyJson).join(",")}]`;
-	if (value && typeof value === "object") return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringifyJson(value[key])}`).join(",")}}`;
-	return JSON.stringify(value);
-};
-var normalizeToolArgumentsText = (value) => {
-	if (!value?.trim()) return "";
-	try {
-		return stableStringifyJson(JSON.parse(value));
-	} catch {
-		return normalizeBubbleText(value);
-	}
-};
-var hasRenderableTextSuperset = (left, right) => {
-	const normalizedLeft = normalizeBubbleText(left);
-	const normalizedRight = normalizeBubbleText(right);
-	if (!normalizedLeft && !normalizedRight) return true;
-	return normalizedLeft === normalizedRight || normalizedLeft.startsWith(normalizedRight) || normalizedRight.startsWith(normalizedLeft);
-};
-var haveSameToolIdentity = (left, right) => {
-	if (!left && !right) return true;
-	if (!left || !right) return false;
-	return left.name === right.name && normalizeToolArgumentsText(left.argumentsText) === normalizeToolArgumentsText(right.argumentsText);
-};
-var areEquivalentBubbles = (left, right) => {
-	return left.kind === right.kind && hasRenderableTextSuperset(left.text, right.text) && Boolean(normalizeBubbleText(left.thinking)) === Boolean(normalizeBubbleText(right.thinking)) && haveSameToolIdentity(left.toolCall, right.toolCall);
-};
-var findAgentTailStartIndex = (existingBubbles, agentBubbles) => {
-	const maxOverlap = Math.min(existingBubbles.length, agentBubbles.length);
-	for (let overlapLength = maxOverlap; overlapLength > 0; overlapLength -= 1) {
-		const existingStart = existingBubbles.length - overlapLength;
-		if (agentBubbles.slice(0, overlapLength).every((bubble, index) => areEquivalentBubbles(existingBubbles[existingStart + index], bubble))) return overlapLength;
-	}
-	return 0;
-};
-var hasEquivalentBubble = (bubbles, candidate) => {
-	return bubbles.some((bubble) => areEquivalentBubbles(bubble, candidate));
-};
-var getAgentTranscriptContentParts = (entry) => {
-	const content = asObject(entry.message ?? null)?.content ?? entry.content ?? null;
-	if (Array.isArray(content)) return content.map((part) => asObject(part)).filter((part) => Boolean(part));
-	if (typeof content === "string") return [{
-		text: content,
-		type: "text"
-	}];
-	return [];
-};
-var parseAgentTranscriptToolCall = (parts) => {
-	const toolUse = parts.find((part) => asString(part.type ?? null) === "tool_use");
-	if (!toolUse) return null;
-	const name = asString(toolUse.name ?? null);
-	if (!name) return null;
-	return {
-		argumentsText: toolUse.input === void 0 ? null : JSON.stringify(toolUse.input),
-		callId: asString(toolUse.id ?? null),
-		name,
-		resultText: null,
-		status: null
-	};
-};
-var parseAgentTranscriptBubble = (filePath, lineNumber, raw) => {
-	const message = asObject(raw.message ?? null);
-	const role = asString(raw.role ?? message?.role ?? null);
-	const kind = role === "user" || role === "assistant" ? role : "unknown";
-	const parts = getAgentTranscriptContentParts(raw);
-	const text = parts.filter((part) => asString(part.type ?? null) === "text").map((part) => asString(part.text ?? null)).filter((value) => Boolean(value?.trim())).join("\n\n");
-	const toolCall = parseAgentTranscriptToolCall(parts);
-	const bubble = {
-		bubbleId: `agent-transcript:${hashText(path.resolve(filePath))}:${path.basename(filePath)}:${lineNumber}`,
-		createdAtMs: null,
-		kind,
-		text,
-		thinking: null,
-		toolCall
-	};
-	return isRenderableBubble(bubble) ? bubble : null;
-};
-var readCursorAgentTranscriptFile = async (filePath) => {
-	let text = "";
-	try {
-		text = await Bun.file(filePath).text();
-	} catch (error) {
-		warnCursorDataIssue("agent_transcript_unreadable", {
-			error: error instanceof Error ? error.message : String(error),
-			filePath
-		});
-		return [];
-	}
-	const bubbles = [];
-	for (const [index, line] of text.split(/\n/u).entries()) {
-		if (!line.trim()) continue;
-		let raw;
-		try {
-			raw = JSON.parse(line);
-		} catch (error) {
-			warnCursorDataIssue("invalid_agent_transcript_jsonl", {
-				error: error instanceof Error ? error.message : String(error),
-				filePath,
-				lineNumber: index + 1
-			});
-			continue;
-		}
-		const entry = asObject(raw);
-		if (!entry) continue;
-		const bubble = parseAgentTranscriptBubble(filePath, index + 1, entry);
-		if (bubble) bubbles.push(bubble);
-	}
-	return bubbles;
-};
-var listCursorAgentTranscriptFiles = async (transcriptDir, composerId) => {
-	const preferred = path.join(transcriptDir, `${composerId}.jsonl`);
-	const files = /* @__PURE__ */ new Set();
-	if (await pathExists(preferred)) files.add(preferred);
-	let entries = [];
-	try {
-		entries = await readdir(transcriptDir);
-	} catch {
-		return [...files];
-	}
-	for (const entry of entries) if (entry.endsWith(".jsonl")) files.add(path.join(transcriptDir, entry));
-	return [...files].sort();
-};
-var readCursorAgentTranscriptBubbles = async (composerId, userDir) => {
-	const transcriptDirs = await findCursorTranscriptDirs(composerId, userDir);
-	const bubbles = [];
-	for (const transcriptDir of transcriptDirs.sort()) {
-		const files = await listCursorAgentTranscriptFiles(transcriptDir, composerId);
-		for (const file of files) bubbles.push(...await readCursorAgentTranscriptFile(file));
-	}
-	return bubbles;
-};
-var mergeAgentTranscriptTail = (transcript, agentBubbles) => {
-	const tailStartIndex = findAgentTailStartIndex(transcript.bubbles, agentBubbles);
-	const seen = [...transcript.bubbles];
-	const appended = [];
-	const candidates = agentBubbles.slice(tailStartIndex);
-	for (const bubble of candidates) {
-		if (hasEquivalentBubble(seen, bubble)) continue;
-		seen.push(bubble);
-		appended.push(bubble);
-	}
-	if (appended.length === 0) return transcript;
-	return {
-		...transcript,
-		bubbles: [...transcript.bubbles, ...appended],
-		renderableBubbleCount: transcript.renderableBubbleCount + appended.length
-	};
-};
-var inferCursorUserDirFromGlobalDbPath = (globalDbPath) => {
-	const globalStorageDir = path.dirname(globalDbPath);
-	return path.basename(globalStorageDir) === "globalStorage" ? path.dirname(globalStorageDir) : resolveCursorUserDir();
-};
-var readCursorThreadTranscript = (globalDbPath, composerId) => {
-	const head = readCursorThreadHead(globalDbPath, composerId);
-	if (!head) return null;
-	const db = openCursorReadonlyDb(globalDbPath);
-	try {
-		const orderedIds = head.orderedBubbleIds.length > 0 ? head.orderedBubbleIds : readAllBubbleIds(db, composerId);
-		const bubbles = [];
-		for (const bubbleId of orderedIds) {
-			const bubble = readBubble(db, composerId, bubbleId);
-			if (bubble && isRenderableBubble(bubble)) bubbles.push(bubble);
-		}
-		const totalBubbleRows = countBubbles(db, composerId).count;
-		return {
-			bubbles,
-			head,
-			omittedBubbleCount: Math.max(totalBubbleRows - orderedIds.length, 0),
-			renderableBubbleCount: bubbles.length
-		};
-	} finally {
-		db.close();
-	}
-};
-var readCursorThreadTranscriptWithAgentFiles = async (globalDbPath, composerId, userDir = inferCursorUserDirFromGlobalDbPath(globalDbPath)) => {
-	const transcript = readCursorThreadTranscript(globalDbPath, composerId);
-	if (!transcript) return null;
-	return mergeAgentTranscriptTail(transcript, await readCursorAgentTranscriptBubbles(composerId, userDir));
-};
-var readAllBubbleIds = (db, composerId) => {
-	const prefix = `bubbleId:${composerId}:`;
-	return db.query("SELECT key FROM cursorDiskKV WHERE key LIKE ? ORDER BY key ASC").all(`${prefix}%`).map((row) => row.key.slice(prefix.length));
-};
-//#endregion
-export { findCursorTranscriptDirs, invalidateCursorDiscoveryCache, listCursorThreadsForGroup, listCursorWorkspaceGroups, loadGlobalComposerHeaders, openCursorReadonlyDb, readCursorThreadTranscriptWithAgentFiles };