spiracha 1.3.3 → 1.5.0

package/apps/ui/dist/server/assets/kiro-db--fXrED_-.js

@@ -0,0 +1,552 @@
+import { a as cleanExtractedText, d as getPortablePathBasename, i as asString, o as cleanInlineTitle, r as asObject } from "./shared-DyhChtHf.js";
+import { t as mapWithConcurrency } from "./concurrency-VXtYvlGh.js";
+import { createHash } from "node:crypto";
+import { readdir, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+//#region ../../src/lib/kiro-exporter-types.ts
+var getDefaultKiroDataDir = (_env = process.env, homeDir = os.homedir()) => {
+	return path.join(homeDir, "Library", "Application Support", "Kiro", "User", "globalStorage", "kiro.kiroagent");
+};
+var DEFAULT_KIRO_DATA_DIR = getDefaultKiroDataDir();
+var resolveKiroDataDir = () => {
+	const configured = process.env.SPIRACHA_KIRO_DATA_DIR?.trim() || process.env.SPIRACHA_KIRO_AGENT_DIR?.trim() || process.env.SPIRACHA_KIRO_DIR?.trim();
+	return configured ? configured : DEFAULT_KIRO_DATA_DIR;
+};
+var resolveKiroWorkspaceSessionsDir = () => {
+	const configured = process.env.SPIRACHA_KIRO_WORKSPACE_SESSIONS_DIR?.trim();
+	return configured ? configured : path.join(resolveKiroDataDir(), "workspace-sessions");
+};
+//#endregion
+//#region ../../src/lib/kiro-db.ts
+var READ_CONCURRENCY = 8;
+var WORKSPACE_KEY_PREFIX = "workspace:";
+var pathExists = async (target) => {
+	return await stat(target).then(() => true).catch(() => false);
+};
+var toIso = (value) => {
+	return value === null ? null : new Date(value).toISOString();
+};
+var parseTimestampMs = (value) => {
+	if (typeof value === "number" && Number.isFinite(value)) return value > 0 && value < 1e10 ? value * 1e3 : value;
+	if (typeof value === "string") {
+		const numeric = Number(value);
+		if (Number.isFinite(numeric)) return numeric > 0 && numeric < 1e10 ? numeric * 1e3 : numeric;
+		const parsed = Date.parse(value);
+		return Number.isFinite(parsed) ? parsed : null;
+	}
+	return null;
+};
+var getWorkspaceKey = (directoryName) => `${WORKSPACE_KEY_PREFIX}${directoryName}`;
+var getDirectoryNameFromWorkspaceKey = (workspaceKey) => {
+	return workspaceKey.startsWith(WORKSPACE_KEY_PREFIX) ? workspaceKey.slice(10) : null;
+};
+var isPlausibleWorkspacePath = (value) => {
+	return Boolean(value.trim()) && !value.includes("�") && !value.includes("\0");
+};
+var decodeBase64WorkspacePath = (value, encoding) => {
+	try {
+		const decoded = Buffer.from(value, encoding).toString("utf8");
+		return isPlausibleWorkspacePath(decoded) ? decoded : null;
+	} catch {
+		return null;
+	}
+};
+var decodeWorkspaceDirectoryName = (directoryName) => {
+	return decodeBase64WorkspacePath(directoryName.replace(/_+$/u, (match) => "=".repeat(match.length)), "base64") ?? decodeBase64WorkspacePath(directoryName, "base64url") ?? directoryName;
+};
+var getWorkspaceLabel = (worktree) => {
+	return getPortablePathBasename(worktree) || worktree;
+};
+var getWorkspaceUri = (worktree) => {
+	return worktree.startsWith(path.sep) ? `file://${worktree}` : worktree;
+};
+var cleanLabel = (value) => {
+	const cleaned = value?.replace(/\s+/g, " ").trim();
+	return cleaned ? cleaned : null;
+};
+var readJsonObject = async (filePath) => {
+	return asObject(await Bun.file(filePath).json().catch(() => null));
+};
+var readSessionIndex = async (workspaceDir) => {
+	const indexPath = path.join(workspaceDir, "sessions.json");
+	const value = await Bun.file(indexPath).json().catch(() => null);
+	const items = Array.isArray(value) ? value : [];
+	const entries = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const object = asObject(item);
+		const sessionId = asString(object?.sessionId ?? null);
+		if (!object || !sessionId) continue;
+		entries.set(sessionId, {
+			createdAtMs: parseTimestampMs(object.dateCreated),
+			sessionId,
+			title: cleanLabel(asString(object.title ?? null)),
+			workspaceDirectory: asString(object.workspaceDirectory ?? null)
+		});
+	}
+	return entries;
+};
+var parseTextPart = (raw, text) => ({
+	raw,
+	text,
+	type: "text"
+});
+var parseImagePart = (raw) => {
+	return {
+		imageUrl: asString(asObject(raw.imageUrl ?? null)?.url ?? null) ?? asString(raw.url ?? null),
+		raw,
+		text: "Image attachment",
+		type: "image"
+	};
+};
+var parseObjectContentPart = (raw) => {
+	if (asString(raw.type ?? null) === "imageUrl") return parseImagePart(raw);
+	const text = asString(raw.text ?? null);
+	if (text !== null) return parseTextPart(raw, text);
+	return {
+		raw,
+		type: "unknown"
+	};
+};
+var parseMessageContentPart = (item) => {
+	if (typeof item === "string") return parseTextPart({ text: item }, item);
+	const object = asObject(item);
+	return object ? parseObjectContentPart(object) : null;
+};
+var getTextJoiner = (left, right) => {
+	const leftTrimmed = left.trim();
+	const rightTrimmed = right.trim();
+	return leftTrimmed.startsWith("|") && rightTrimmed.startsWith("|") ? "\n" : "\n\n";
+};
+var mergeTextParts = (left, right) => {
+	const text = `${left.text ?? ""}${getTextJoiner(left.text ?? "", right.text ?? "")}${right.text ?? ""}`;
+	return {
+		raw: {
+			sourceParts: [left.raw, right.raw],
+			text,
+			type: "text"
+		},
+		text,
+		type: "text"
+	};
+};
+var mergeAdjacentTextParts = (parts) => {
+	const merged = [];
+	for (const part of parts) {
+		const previous = merged.at(-1);
+		if (previous?.type === "text" && part.type === "text") {
+			merged[merged.length - 1] = mergeTextParts(previous, part);
+			continue;
+		}
+		merged.push(part);
+	}
+	return merged;
+};
+var parseMessageParts = (message) => {
+	const content = message.content;
+	return mergeAdjacentTextParts((Array.isArray(content) ? content : [content]).map(parseMessageContentPart).filter((part) => part !== null && part.type !== "unknown"));
+};
+var getPromptLogCount = (raw) => {
+	return Array.isArray(raw.promptLogs) ? raw.promptLogs.length : 0;
+};
+var parseHistoryEntry = (raw, index) => {
+	const message = asObject(raw.message ?? null);
+	if (!message) return null;
+	const parts = parseMessageParts(message);
+	if (parts.length === 0) return null;
+	return {
+		entryId: asString(message.id ?? null) ?? `entry:${index}`,
+		entryType: "message",
+		executionId: asString(raw.executionId ?? null),
+		parts,
+		promptLogCount: getPromptLogCount(raw),
+		raw,
+		role: asString(message.role ?? null) ?? "message",
+		timestamp: null
+	};
+};
+var createEmptyStats = () => ({
+	assistantMessageCount: 0,
+	imageCount: 0,
+	messageCount: 0,
+	promptLogCount: 0,
+	renderablePartCount: 0,
+	userMessageCount: 0
+});
+var updateStatsFromEntry = (stats, entry) => {
+	if (entry.role === "assistant" || entry.role === "user") stats.messageCount += 1;
+	if (entry.role === "assistant") stats.assistantMessageCount += 1;
+	if (entry.role === "user") stats.userMessageCount += 1;
+	stats.imageCount += entry.parts.filter((part) => part.type === "image").length;
+	stats.promptLogCount += entry.promptLogCount;
+	stats.renderablePartCount += entry.parts.filter(isRenderablePart).length;
+};
+var updateIdentityFromRaw = (identity, raw) => {
+	const rawString = (key) => asString(raw[key] ?? null);
+	const rawValues = {
+		autonomyMode: rawString("autonomyMode"),
+		defaultModelTitle: rawString("defaultModelTitle"),
+		selectedModel: rawString("selectedModel"),
+		selectedProfileId: rawString("selectedProfileId"),
+		sessionId: rawString("sessionId"),
+		sessionType: rawString("sessionType"),
+		title: cleanLabel(rawString("title")),
+		workspaceDirectory: rawString("workspaceDirectory"),
+		workspacePath: rawString("workspacePath")
+	};
+	identity.autonomyMode = rawValues.autonomyMode ?? identity.autonomyMode;
+	identity.defaultModelTitle = rawValues.defaultModelTitle ?? identity.defaultModelTitle;
+	identity.selectedModel = rawValues.selectedModel ?? identity.selectedModel;
+	identity.selectedProfileId = rawValues.selectedProfileId ?? identity.selectedProfileId;
+	identity.sessionId = rawValues.sessionId ?? identity.sessionId;
+	identity.sessionType = rawValues.sessionType ?? identity.sessionType;
+	identity.title = rawValues.title ?? identity.title;
+	identity.workspaceDirectory = rawValues.workspaceDirectory ?? identity.workspaceDirectory;
+	identity.workspacePath = rawValues.workspacePath ?? identity.workspacePath;
+};
+var updateIdentityFromEntry = (identity, entry) => {
+	if (entry.role !== "user" || identity.firstUserText) return;
+	identity.firstUserText = cleanExtractedText(entry.parts.find((part) => part.type === "text" && part.text?.trim())?.text ?? "").trim() || null;
+};
+var getEntryText = (entry) => {
+	return entry.parts.filter((part) => part.type === "text").map((part) => cleanExtractedText(part.text ?? "").trim()).filter(Boolean).join("\n\n").trim();
+};
+var KIRO_ASSISTANT_PLACEHOLDER_PATTERN = /^on it[.!]?$/iu;
+var isAssistantPlaceholderEntry = (entry) => {
+	return entry.role === "assistant" && KIRO_ASSISTANT_PLACEHOLDER_PATTERN.test(getEntryText(entry));
+};
+var isRenderablePart = (part) => {
+	if (part.type === "image") return true;
+	if (part.type === "text") return Boolean(part.text?.trim());
+	return false;
+};
+var getTitle = (identity, indexEntry) => {
+	return cleanInlineTitle(identity.title ?? indexEntry?.title ?? identity.firstUserText ?? identity.sessionId);
+};
+var getCreatedAtMs = (indexEntry, fileStats) => {
+	return indexEntry?.createdAtMs ?? fileStats?.birthtimeMs ?? fileStats?.mtimeMs ?? null;
+};
+var getLastActiveAtMs = (indexEntry, fileStats) => {
+	return fileStats?.mtimeMs ?? indexEntry?.createdAtMs ?? null;
+};
+var toSessionSummary = (file, identity, stats, fileStats) => {
+	const worktree = identity.workspaceDirectory ?? identity.workspacePath ?? file.indexEntry?.workspaceDirectory ?? decodeWorkspaceDirectoryName(file.directoryName);
+	const workspaceLabel = getWorkspaceLabel(worktree);
+	const createdAtMs = getCreatedAtMs(file.indexEntry, fileStats);
+	const lastActiveAtMs = getLastActiveAtMs(file.indexEntry, fileStats);
+	return {
+		...stats,
+		autonomyMode: identity.autonomyMode,
+		createdAtIso: toIso(createdAtMs),
+		createdAtMs,
+		defaultModelTitle: identity.defaultModelTitle,
+		filePath: file.filePath,
+		lastActiveAtIso: toIso(lastActiveAtMs),
+		lastActiveAtMs,
+		selectedModel: identity.selectedModel,
+		selectedProfileId: identity.selectedProfileId,
+		sessionId: identity.sessionId,
+		sessionType: identity.sessionType,
+		title: getTitle(identity, file.indexEntry),
+		workspaceDirectory: identity.workspaceDirectory ?? file.indexEntry?.workspaceDirectory ?? null,
+		workspaceKey: getWorkspaceKey(file.directoryName),
+		workspaceLabel,
+		workspacePath: identity.workspacePath,
+		worktree
+	};
+};
+var getKiroDataDirFromSessionsDir = (sessionsDir) => {
+	return path.basename(sessionsDir) === "workspace-sessions" ? path.dirname(sessionsDir) : sessionsDir;
+};
+var getKiroWorkspaceHash = (workspacePath) => {
+	return createHash("sha256").update(workspacePath).digest("hex").slice(0, 32);
+};
+var listFilesRecursively = async (root, maxDepth = 3) => {
+	const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
+	const files = [];
+	for (const entry of entries) {
+		const entryPath = path.join(root, entry.name);
+		if (entry.isFile()) {
+			files.push(entryPath);
+			continue;
+		}
+		if (entry.isDirectory() && maxDepth > 0) files.push(...await listFilesRecursively(entryPath, maxDepth - 1));
+	}
+	return files;
+};
+var listExecutionFilesForSession = async (dataDir, sessionId, worktree) => {
+	const workspaceExecutionRoot = path.join(dataDir, getKiroWorkspaceHash(worktree));
+	if (!await pathExists(workspaceExecutionRoot)) return [];
+	return (await mapWithConcurrency(await listFilesRecursively(workspaceExecutionRoot), READ_CONCURRENCY, async (filePath) => {
+		const raw = await readJsonObject(filePath);
+		return asString(raw?.chatSessionId ?? null) === sessionId && raw ? {
+			filePath,
+			raw
+		} : null;
+	})).flatMap((execution) => execution ? [execution] : []);
+};
+var getActionTimestamp = (action, execution) => {
+	return toIso(parseTimestampMs(action.emittedAt) ?? parseTimestampMs(action.endTime) ?? parseTimestampMs(execution.endTime));
+};
+var formatHumanLine = (value) => {
+	if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value >= Number.MAX_SAFE_INTEGER) return null;
+	return value + 1;
+};
+var formatFileRange = (file) => {
+	const range = asObject(file.range ?? null);
+	const startLine = formatHumanLine(range?.startLine);
+	const endLine = formatHumanLine(range?.endLine);
+	if (startLine !== null && endLine !== null) return `:${startLine}-${endLine}`;
+	if (startLine !== null) return `:${startLine}`;
+	return "";
+};
+var formatToolItems = (singularPrefix, pluralPrefix, items) => {
+	if (items.length === 1) return `${singularPrefix}: ${items[0]}`;
+	return `${pluralPrefix}:\n${items.map((item) => `- ${item}`).join("\n")}`;
+};
+var getToolCallSummary = (action) => {
+	const input = asObject(action.input ?? null);
+	if (!input) return null;
+	const files = Array.isArray(input.files) ? input.files.flatMap((item) => {
+		const file = asObject(item);
+		const filePath = asString(file?.path ?? null);
+		return file && filePath ? [`${filePath}${formatFileRange(file)}`] : [];
+	}) : [];
+	if (files.length > 0) return {
+		command: formatToolItems("Read file", "Read files", files),
+		toolName: "read_file"
+	};
+	const documents = Array.isArray(input.documents) ? input.documents.flatMap((item) => {
+		const document = typeof item === "string" ? item : asString(asObject(item)?.uri ?? null);
+		return document ? [document] : [];
+	}) : [];
+	if (documents.length > 0) return {
+		command: formatToolItems("Read document", "Read documents", documents),
+		toolName: "read_file"
+	};
+	const query = asString(input.query ?? null);
+	const why = asString(input.why ?? null);
+	if (query || why) return {
+		command: `Search: ${why ?? query}${why && query ? `\nQuery: ${query}` : ""}`,
+		toolName: "search"
+	};
+	return null;
+};
+var parseExecutionActionMessageEntry = (execution, action, index) => {
+	const text = cleanExtractedText(asString(asObject(action.output ?? null)?.message ?? null) ?? "").trim();
+	if (!text) return null;
+	const executionId = asString(execution.raw.executionId ?? null);
+	const actionId = asString(action.actionId ?? null) ?? `action:${index}`;
+	return {
+		entryId: `${executionId ?? path.basename(execution.filePath)}:${actionId}`,
+		entryType: "message",
+		executionId,
+		parts: [parseTextPart({
+			actionId,
+			executionFilePath: execution.filePath,
+			message: text,
+			type: "assistantMessage"
+		}, text)],
+		promptLogCount: 0,
+		raw: {
+			...action,
+			executionFilePath: execution.filePath
+		},
+		role: "assistant",
+		timestamp: getActionTimestamp(action, execution.raw)
+	};
+};
+var parseExecutionActionToolEntry = (execution, action, index) => {
+	const summary = getToolCallSummary(action);
+	if (!summary) return null;
+	const executionId = asString(execution.raw.executionId ?? null);
+	const actionId = asString(action.actionId ?? null) ?? `action:${index}`;
+	return {
+		entryId: `${executionId ?? path.basename(execution.filePath)}:${actionId}`,
+		entryType: "tool_call",
+		executionId,
+		parts: [parseTextPart({
+			actionId,
+			command: summary.command,
+			executionFilePath: execution.filePath,
+			toolName: summary.toolName,
+			type: "toolCall"
+		}, summary.command)],
+		promptLogCount: 0,
+		raw: {
+			...action,
+			executionFilePath: execution.filePath
+		},
+		role: "tool",
+		timestamp: getActionTimestamp(action, execution.raw)
+	};
+};
+var parseExecutionActionEntries = (execution, action, index) => {
+	return [parseExecutionActionToolEntry(execution, action, index), parseExecutionActionMessageEntry(execution, action, index)].filter((entry) => entry !== null);
+};
+var parseExecutionEntries = (execution) => {
+	return (Array.isArray(execution.raw.actions) ? execution.raw.actions : []).flatMap((item, index) => {
+		const action = asObject(item);
+		return action ? parseExecutionActionEntries(execution, action, index) : [];
+	});
+};
+var compareExecutionFiles = (left, right) => {
+	return (parseTimestampMs(left.raw.startTime) ?? 0) - (parseTimestampMs(right.raw.startTime) ?? 0) || left.filePath.localeCompare(right.filePath);
+};
+var readExecutionEntries = async (sessionsDir, session) => {
+	return (await listExecutionFilesForSession(getKiroDataDirFromSessionsDir(sessionsDir), session.sessionId, session.worktree)).sort(compareExecutionFiles).flatMap(parseExecutionEntries);
+};
+var getVisibleEntries = (historyEntries, executionEntries) => {
+	if (executionEntries.length === 0) return historyEntries;
+	const executionEntriesById = /* @__PURE__ */ new Map();
+	for (const entry of executionEntries) {
+		if (!entry.executionId) continue;
+		const entries = executionEntriesById.get(entry.executionId) ?? [];
+		entries.push(entry);
+		executionEntriesById.set(entry.executionId, entries);
+	}
+	const usedExecutionIds = /* @__PURE__ */ new Set();
+	const visibleEntries = [];
+	for (const entry of historyEntries) {
+		const matchingExecutionEntries = entry.executionId ? executionEntriesById.get(entry.executionId) : void 0;
+		if (isAssistantPlaceholderEntry(entry)) {
+			if (matchingExecutionEntries) {
+				visibleEntries.push(...matchingExecutionEntries);
+				usedExecutionIds.add(entry.executionId);
+			}
+			continue;
+		}
+		visibleEntries.push(entry);
+	}
+	visibleEntries.push(...executionEntries.filter((entry) => !entry.executionId || !usedExecutionIds.has(entry.executionId)));
+	return visibleEntries;
+};
+var createStatsFromEntries = (entries) => {
+	const stats = createEmptyStats();
+	for (const entry of entries) updateStatsFromEntry(stats, entry);
+	return stats;
+};
+var readSessionFile = async (file, options) => {
+	const rawSession = await readJsonObject(file.filePath);
+	if (!rawSession) return null;
+	const fileStats = await stat(file.filePath).then((stats) => ({
+		birthtimeMs: stats.birthtimeMs,
+		mtimeMs: stats.mtimeMs
+	})).catch(() => null);
+	const identity = {
+		autonomyMode: null,
+		defaultModelTitle: null,
+		firstUserText: null,
+		selectedModel: null,
+		selectedProfileId: null,
+		sessionId: path.basename(file.filePath, ".json"),
+		sessionType: null,
+		title: null,
+		workspaceDirectory: file.indexEntry?.workspaceDirectory ?? null,
+		workspacePath: null
+	};
+	const historyEntries = [];
+	const history = Array.isArray(rawSession.history) ? rawSession.history : [];
+	updateIdentityFromRaw(identity, rawSession);
+	history.forEach((item, index) => {
+		const raw = asObject(item);
+		if (!raw) return;
+		const entry = parseHistoryEntry(raw, index);
+		if (!entry) return;
+		historyEntries.push(entry);
+		updateIdentityFromEntry(identity, entry);
+	});
+	const baseSummary = toSessionSummary(file, identity, createEmptyStats(), fileStats);
+	const entries = getVisibleEntries(historyEntries, options.includeExecutions ? await readExecutionEntries(options.sessionsDir, baseSummary) : []);
+	const stats = createStatsFromEntries(entries);
+	return {
+		entries,
+		rawSession,
+		renderablePartCount: stats.renderablePartCount,
+		session: toSessionSummary(file, identity, stats, fileStats)
+	};
+};
+var listSessionFilesForWorkspace = async (sessionsDir, directoryName) => {
+	const workspaceDir = path.join(sessionsDir, directoryName);
+	const index = await readSessionIndex(workspaceDir);
+	return (await readdir(workspaceDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isFile() && entry.name.endsWith(".json") && entry.name !== "sessions.json").map((entry) => {
+		const sessionId = path.basename(entry.name, ".json");
+		return {
+			directoryName,
+			filePath: path.join(workspaceDir, entry.name),
+			indexEntry: index.get(sessionId) ?? null
+		};
+	});
+};
+var listSessionFiles = async (sessionsDir) => {
+	if (!await pathExists(sessionsDir)) return [];
+	return (await mapWithConcurrency((await readdir(sessionsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort(), READ_CONCURRENCY, (directoryName) => listSessionFilesForWorkspace(sessionsDir, directoryName))).flat();
+};
+var readSessionFiles = async (files) => {
+	return (await mapWithConcurrency(files, READ_CONCURRENCY, (file) => readSessionFile(file, {
+		includeExecutions: false,
+		sessionsDir: path.dirname(path.dirname(file.filePath))
+	}))).flatMap((transcript) => transcript ? [transcript] : []);
+};
+var compareNullableMsDesc = (left, right) => {
+	return (right ?? 0) - (left ?? 0);
+};
+var sumSessions = (sessions, key) => {
+	return sessions.reduce((total, session) => total + session[key], 0);
+};
+var toWorkspaceGroup = (directoryName, sessions) => {
+	const worktree = sessions[0]?.worktree ?? decodeWorkspaceDirectoryName(directoryName);
+	const lastActiveAtMs = sessions.reduce((latest, session) => {
+		if (session.lastActiveAtMs === null) return latest;
+		return latest === null ? session.lastActiveAtMs : Math.max(latest, session.lastActiveAtMs);
+	}, null);
+	return {
+		assistantMessageCount: sumSessions(sessions, "assistantMessageCount"),
+		directoryName,
+		imageCount: sumSessions(sessions, "imageCount"),
+		key: getWorkspaceKey(directoryName),
+		label: getWorkspaceLabel(worktree),
+		lastActiveAtIso: toIso(lastActiveAtMs),
+		lastActiveAtMs,
+		messageCount: sumSessions(sessions, "messageCount"),
+		promptLogCount: sumSessions(sessions, "promptLogCount"),
+		sessionCount: sessions.length,
+		uri: getWorkspaceUri(worktree),
+		userMessageCount: sumSessions(sessions, "userMessageCount"),
+		worktree
+	};
+};
+var listKiroWorkspaceGroups = async (sessionsDir = resolveKiroWorkspaceSessionsDir()) => {
+	const transcripts = await readSessionFiles(await listSessionFiles(sessionsDir));
+	const sessionsByDirectory = /* @__PURE__ */ new Map();
+	for (const transcript of transcripts) {
+		const directoryName = getDirectoryNameFromWorkspaceKey(transcript.session.workspaceKey);
+		if (!directoryName) continue;
+		const sessions = sessionsByDirectory.get(directoryName) ?? [];
+		sessions.push(transcript.session);
+		sessionsByDirectory.set(directoryName, sessions);
+	}
+	return [...sessionsByDirectory.entries()].map(([directoryName, sessions]) => toWorkspaceGroup(directoryName, sessions)).sort((left, right) => compareNullableMsDesc(left.lastActiveAtMs, right.lastActiveAtMs) || left.worktree.localeCompare(right.worktree));
+};
+var sortSessions = (sessions) => {
+	return [...sessions].sort((left, right) => compareNullableMsDesc(left.lastActiveAtMs, right.lastActiveAtMs) || left.title.localeCompare(right.title));
+};
+var listKiroSessionsForGroup = async (workspaceKey, sessionsDir = resolveKiroWorkspaceSessionsDir()) => {
+	const directoryName = getDirectoryNameFromWorkspaceKey(workspaceKey);
+	if (!directoryName || !await pathExists(sessionsDir)) return [];
+	return sortSessions((await readSessionFiles(await listSessionFilesForWorkspace(sessionsDir, directoryName))).map((transcript) => transcript.session));
+};
+var locateSessionFile = async (sessionsDir, sessionId) => {
+	return (await listSessionFiles(sessionsDir)).find((file) => path.basename(file.filePath, ".json") === sessionId) ?? null;
+};
+var readKiroSessionTranscript = async (sessionsDir, sessionId) => {
+	if (!await pathExists(sessionsDir)) return null;
+	const file = await locateSessionFile(sessionsDir, sessionId);
+	if (!file) return null;
+	return readSessionFile(file, {
+		includeExecutions: true,
+		sessionsDir
+	});
+};
+//#endregion
+export { listKiroSessionsForGroup, listKiroWorkspaceGroups, readKiroSessionTranscript, resolveKiroWorkspaceSessionsDir };

package/apps/ui/dist/server/assets/kiro-queries-CzNlM2ok.js

@@ -0,0 +1,37 @@
+import { t as createServerFn } from "../server.js";
+import { t as createSsrRpc } from "./createSsrRpc-C754NPki.js";
+import { z } from "zod";
+import { queryOptions } from "@tanstack/react-query";
+//#region src/lib/kiro-server.ts
+var workspaceSchema = z.object({ workspaceKey: z.string().min(1) });
+var sessionSchema = z.object({ sessionId: z.string().min(1) });
+var exportSessionSchema = z.object({
+	includeCommentary: z.boolean().default(true),
+	includeMetadata: z.boolean().default(true),
+	includeTools: z.boolean().default(true),
+	outputFormat: z.enum(["md", "txt"]).default("md"),
+	sessionId: z.string().min(1),
+	zipArchive: z.boolean().default(false)
+});
+var listKiroWorkspacesFn = createServerFn({ method: "GET" }).handler(createSsrRpc("e5dccf57fb45a9c1fe971e71935dd743e2c4108badfb95aa89cf08a5ccd7c3af"));
+var listKiroSessionsFn = createServerFn({ method: "GET" }).validator(workspaceSchema).handler(createSsrRpc("05f39c4ddd140732eec6814673bdb975c3092ae88d9fb87479586125e8da3917"));
+var getKiroSessionDetailFn = createServerFn({ method: "GET" }).validator(sessionSchema).handler(createSsrRpc("51dfddfd486f04b369fef0b3a5aaa0dcd275fc5495ac2fba85a3348408d897c9"));
+var exportKiroSessionFn = createServerFn({ method: "POST" }).validator(exportSessionSchema).handler(createSsrRpc("a3419cd85493ddc5959e22d85e6b1c5bfb4ce862bb7117ad6a98e3c97d14d066"));
+//#endregion
+//#region src/lib/kiro-queries.ts
+var kiroWorkspacesQueryOptions = () => queryOptions({
+	queryFn: () => listKiroWorkspacesFn(),
+	queryKey: ["kiro-workspaces"]
+});
+var kiroSessionsQueryOptions = (workspaceKey) => queryOptions({
+	enabled: workspaceKey !== null,
+	queryFn: () => listKiroSessionsFn({ data: { workspaceKey: workspaceKey ?? "" } }),
+	queryKey: ["kiro-sessions", workspaceKey ?? "none"]
+});
+var kiroSessionDetailQueryOptions = (sessionId) => queryOptions({
+	enabled: sessionId !== null,
+	queryFn: () => getKiroSessionDetailFn({ data: { sessionId: sessionId ?? "" } }),
+	queryKey: ["kiro-session", sessionId ?? "none"]
+});
+//#endregion
+export { exportKiroSessionFn as i, kiroSessionsQueryOptions as n, kiroWorkspacesQueryOptions as r, kiroSessionDetailQueryOptions as t };

package/apps/ui/dist/server/assets/kiro-server-9WRxg2Au.js

@@ -0,0 +1,72 @@
+import { t as createServerFn } from "../server.js";
+import { t as createServerRpc } from "./createServerRpc-CF_DEwnm.js";
+import { t as renderSourceSessionDownload } from "./source-session-export-server-DNutCawb.js";
+import { z } from "zod";
+//#region src/lib/kiro-server.ts?tss-serverfn-split
+var workspaceSchema = z.object({ workspaceKey: z.string().min(1) });
+var sessionSchema = z.object({ sessionId: z.string().min(1) });
+var exportSessionSchema = z.object({
+	includeCommentary: z.boolean().default(true),
+	includeMetadata: z.boolean().default(true),
+	includeTools: z.boolean().default(true),
+	outputFormat: z.enum(["md", "txt"]).default("md"),
+	sessionId: z.string().min(1),
+	zipArchive: z.boolean().default(false)
+});
+var listKiroWorkspacesFn_createServerFn_handler = createServerRpc({
+	id: "e5dccf57fb45a9c1fe971e71935dd743e2c4108badfb95aa89cf08a5ccd7c3af",
+	name: "listKiroWorkspacesFn",
+	filename: "src/lib/kiro-server.ts"
+}, (opts) => listKiroWorkspacesFn.__executeServer(opts));
+var listKiroWorkspacesFn = createServerFn({ method: "GET" }).handler(listKiroWorkspacesFn_createServerFn_handler, async () => {
+	const { listKiroWorkspaceGroups } = await import("./kiro-db--fXrED_-.js");
+	return listKiroWorkspaceGroups();
+});
+var listKiroSessionsFn_createServerFn_handler = createServerRpc({
+	id: "05f39c4ddd140732eec6814673bdb975c3092ae88d9fb87479586125e8da3917",
+	name: "listKiroSessionsFn",
+	filename: "src/lib/kiro-server.ts"
+}, (opts) => listKiroSessionsFn.__executeServer(opts));
+var listKiroSessionsFn = createServerFn({ method: "GET" }).validator(workspaceSchema).handler(listKiroSessionsFn_createServerFn_handler, async ({ data }) => {
+	const { listKiroSessionsForGroup } = await import("./kiro-db--fXrED_-.js");
+	return listKiroSessionsForGroup(data.workspaceKey);
+});
+var loadKiroSessionTranscript = async (sessionId) => {
+	const { readKiroSessionTranscript, resolveKiroWorkspaceSessionsDir } = await import("./kiro-db--fXrED_-.js");
+	const transcript = await readKiroSessionTranscript(resolveKiroWorkspaceSessionsDir(), sessionId);
+	if (!transcript) throw new Error(`Kiro session not found: ${sessionId}`);
+	return transcript;
+};
+var getKiroSessionDetailFn_createServerFn_handler = createServerRpc({
+	id: "51dfddfd486f04b369fef0b3a5aaa0dcd275fc5495ac2fba85a3348408d897c9",
+	name: "getKiroSessionDetailFn",
+	filename: "src/lib/kiro-server.ts"
+}, (opts) => getKiroSessionDetailFn.__executeServer(opts));
+var getKiroSessionDetailFn = createServerFn({ method: "GET" }).validator(sessionSchema).handler(getKiroSessionDetailFn_createServerFn_handler, async ({ data }) => {
+	return loadKiroSessionTranscript(data.sessionId);
+});
+var exportKiroSessionFn_createServerFn_handler = createServerRpc({
+	id: "a3419cd85493ddc5959e22d85e6b1c5bfb4ce862bb7117ad6a98e3c97d14d066",
+	name: "exportKiroSessionFn",
+	filename: "src/lib/kiro-server.ts"
+}, (opts) => exportKiroSessionFn.__executeServer(opts));
+var exportKiroSessionFn = createServerFn({ method: "POST" }).validator(exportSessionSchema).handler(exportKiroSessionFn_createServerFn_handler, async ({ data }) => {
+	const { renderKiroTranscript } = await import("./kiro-transcript-DoekQBaH.js");
+	const transcript = await loadKiroSessionTranscript(data.sessionId);
+	const content = renderKiroTranscript(transcript, {
+		includeCommentary: data.includeCommentary,
+		includeMetadata: data.includeMetadata,
+		includeTools: data.includeTools,
+		outputFormat: data.outputFormat
+	});
+	if (!content) throw new Error(`Kiro session has no exportable content: ${data.sessionId}`);
+	return renderSourceSessionDownload({
+		content,
+		fallbackBaseName: "kiro-session",
+		fileBaseName: transcript.session.title || transcript.session.sessionId,
+		outputFormat: data.outputFormat,
+		zipArchive: data.zipArchive
+	});
+});
+//#endregion
+export { exportKiroSessionFn_createServerFn_handler, getKiroSessionDetailFn_createServerFn_handler, listKiroSessionsFn_createServerFn_handler, listKiroWorkspacesFn_createServerFn_handler };

package/apps/ui/dist/server/assets/kiro-sessions._sessionId-CRY2c7YO.js

@@ -0,0 +1,11 @@
+import { t as ReloadErrorPanel } from "./reload-error-panel-BJMxY3U1.js";
+import { jsx } from "react/jsx-runtime";
+//#region src/routes/kiro-sessions.$sessionId.tsx?tsr-split=errorComponent
+var KiroSessionDetailErrorComponent = ({ error }) => {
+	return /* @__PURE__ */ jsx(ReloadErrorPanel, {
+		description: error.message,
+		title: "Failed to load Kiro session"
+	});
+};
+//#endregion
+export { KiroSessionDetailErrorComponent as errorComponent };