spiracha 1.4.0 → 1.5.0

package/apps/ui/dist/server/assets/claude-code-db-Ik3VStKZ.js

@@ -0,0 +1,361 @@
+import { a as cleanExtractedText, d as getPortablePathBasename, f as readJsonlObjects, i as asString, n as asNumber, o as cleanInlineTitle, r as asObject, t as asBoolean } from "./shared-DyhChtHf.js";
+import { t as mapWithConcurrency } from "./concurrency-VXtYvlGh.js";
+import { readdir, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+//#region ../../src/lib/claude-code-exporter-types.ts
+var getDefaultClaudeCodeDataDir = (_env = process.env, homeDir = os.homedir()) => {
+	return path.join(homeDir, ".claude");
+};
+var DEFAULT_CLAUDE_CODE_DATA_DIR = getDefaultClaudeCodeDataDir();
+var resolveClaudeCodeDataDir = () => {
+	const configured = process.env.SPIRACHA_CLAUDE_CODE_DATA_DIR?.trim() || process.env.SPIRACHA_CLAUDE_CODE_DIR?.trim() || process.env.SPIRACHA_CLAUDE_HOME?.trim();
+	return configured ? configured : DEFAULT_CLAUDE_CODE_DATA_DIR;
+};
+var resolveClaudeCodeProjectsDir = () => {
+	const configured = process.env.SPIRACHA_CLAUDE_CODE_PROJECTS_DIR?.trim();
+	return configured ? configured : path.join(resolveClaudeCodeDataDir(), "projects");
+};
+//#endregion
+//#region ../../src/lib/claude-code-db.ts
+var READ_CONCURRENCY = 8;
+var WORKSPACE_KEY_PREFIX = "project:";
+var pathExists = async (target) => {
+	return await stat(target).then(() => true).catch(() => false);
+};
+var cleanLabel = (value) => {
+	const cleaned = value?.replace(/\s+/g, " ").trim();
+	return cleaned ? cleaned : null;
+};
+var getWorkspaceKey = (directoryName) => `${WORKSPACE_KEY_PREFIX}${directoryName}`;
+var getDirectoryNameFromWorkspaceKey = (workspaceKey) => {
+	return workspaceKey.startsWith(WORKSPACE_KEY_PREFIX) ? workspaceKey.slice(8) : null;
+};
+var decodeWorktreeFromDirectoryName = (directoryName) => {
+	if (!directoryName.startsWith("-")) return directoryName.replace(/-/g, path.sep);
+	return path.join(path.sep, ...directoryName.slice(1).split("-").filter(Boolean));
+};
+var getWorkspaceLabel = (worktree) => {
+	if (worktree === path.sep) return "(global)";
+	return getPortablePathBasename(worktree) || worktree;
+};
+var getWorkspaceUri = (worktree) => {
+	return worktree.startsWith(path.sep) ? `file://${worktree}` : worktree;
+};
+var toIso = (value) => {
+	return value === null ? null : new Date(value).toISOString();
+};
+var parseTimestampMs = (value) => {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value !== "string" || !value.trim()) return null;
+	const numeric = Number(value);
+	if (Number.isFinite(numeric)) return numeric;
+	const parsed = Date.parse(value);
+	return Number.isFinite(parsed) ? parsed : null;
+};
+var formatJsonLike = (value) => {
+	if (value === void 0 || value === null) return null;
+	if (typeof value === "string") return value;
+	return JSON.stringify(value, null, 2);
+};
+var textFromContentValue = (value) => {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return value.map((item) => {
+		if (typeof item === "string") return item;
+		return asString(asObject(item)?.text ?? null) ?? "";
+	}).filter(Boolean).join("\n\n");
+	return asString(asObject(value ?? null)?.text ?? null) ?? "";
+};
+var parseTextContentPart = (item) => ({
+	raw: item,
+	text: asString(item.text ?? null) ?? "",
+	type: "text"
+});
+var parseThinkingContentPart = (item) => ({
+	raw: item,
+	text: asString(item.thinking ?? null) ?? "",
+	type: "thinking"
+});
+var parseToolUseContentPart = (item) => ({
+	argumentsText: formatJsonLike(item.input),
+	raw: item,
+	toolName: asString(item.name ?? null) ?? "unknown",
+	toolUseId: asString(item.id ?? null),
+	type: "tool_use"
+});
+var parseToolResultContentPart = (item) => ({
+	isError: asBoolean(item.is_error ?? null),
+	outputText: cleanExtractedText(textFromContentValue(item.content)).trim(),
+	raw: item,
+	toolUseId: asString(item.tool_use_id ?? null),
+	type: "tool_result"
+});
+var parseFallbackContentPart = (item) => {
+	const fallbackText = asString(item.text ?? null);
+	return {
+		raw: item,
+		text: fallbackText ?? void 0,
+		type: fallbackText ? "text" : "unknown"
+	};
+};
+var structuredContentParsers = {
+	input_text: parseTextContentPart,
+	output_text: parseTextContentPart,
+	text: parseTextContentPart,
+	thinking: parseThinkingContentPart,
+	tool_result: parseToolResultContentPart,
+	tool_use: parseToolUseContentPart
+};
+var parseStructuredContentPart = (item) => {
+	const type = asString(item.type ?? null);
+	return type ? structuredContentParsers[type]?.(item) ?? parseFallbackContentPart(item) : parseFallbackContentPart(item);
+};
+var parseMessageContentPart = (item) => {
+	if (typeof item === "string") return {
+		raw: { text: item },
+		text: item,
+		type: "text"
+	};
+	const object = asObject(item);
+	return object ? parseStructuredContentPart(object) : null;
+};
+var parseMessageParts = (message) => {
+	const content = message.content;
+	return (Array.isArray(content) ? content : [content]).map(parseMessageContentPart).filter((part) => part !== null && part.type !== "unknown");
+};
+var parseAttachmentParts = (raw) => {
+	const attachment = asObject(raw.attachment ?? null);
+	if (!attachment) return [];
+	return [{
+		attachmentType: asString(attachment.type ?? null),
+		raw: attachment,
+		text: textFromContentValue(attachment.content),
+		type: "attachment"
+	}];
+};
+var getTranscriptEntryParts = (type, message, raw) => {
+	if (message) return parseMessageParts(message);
+	if (type === "attachment") return parseAttachmentParts(raw);
+	return [];
+};
+var getTranscriptEntryRole = (type, message) => {
+	return asString(message?.role ?? null) ?? (type === "attachment" ? "attachment" : type);
+};
+var getTranscriptEntryId = (type, raw) => {
+	return asString(raw.uuid ?? null) ?? `${type}:${asString(raw.sessionId ?? null) ?? "unknown"}`;
+};
+var parseTranscriptEntry = (raw) => {
+	const type = asString(raw.type ?? null) ?? "unknown";
+	const message = asObject(raw.message ?? null);
+	const parts = getTranscriptEntryParts(type, message, raw);
+	if (parts.length === 0) return null;
+	return {
+		cwd: asString(raw.cwd ?? null),
+		entryId: getTranscriptEntryId(type, raw),
+		model: asString(message?.model ?? null),
+		parentEntryId: asString(raw.parentUuid ?? null),
+		parts,
+		raw,
+		role: getTranscriptEntryRole(type, message),
+		timestamp: asString(raw.timestamp ?? null),
+		type
+	};
+};
+var createEmptyStats = () => ({
+	assistantMessageCount: 0,
+	attachmentCount: 0,
+	cacheCreationInputTokens: 0,
+	cacheReadInputTokens: 0,
+	inputTokens: 0,
+	messageCount: 0,
+	outputTokens: 0,
+	renderablePartCount: 0,
+	toolCallCount: 0,
+	toolResultCount: 0,
+	userMessageCount: 0
+});
+var addUsageStats = (stats, message) => {
+	const usage = asObject(message?.usage ?? null);
+	if (!usage) return;
+	stats.inputTokens += asNumber(usage.input_tokens ?? null) ?? 0;
+	stats.outputTokens += asNumber(usage.output_tokens ?? null) ?? 0;
+	stats.cacheCreationInputTokens += asNumber(usage.cache_creation_input_tokens ?? null) ?? 0;
+	stats.cacheReadInputTokens += asNumber(usage.cache_read_input_tokens ?? null) ?? 0;
+};
+var updateStatsFromEntry = (stats, entry) => {
+	if (entry.type === "user" || entry.type === "assistant") stats.messageCount += 1;
+	if (entry.role === "user") stats.userMessageCount += 1;
+	if (entry.role === "assistant") stats.assistantMessageCount += 1;
+	if (entry.type === "attachment") stats.attachmentCount += 1;
+	stats.toolCallCount += entry.parts.filter((part) => part.type === "tool_use").length;
+	stats.toolResultCount += entry.parts.filter((part) => part.type === "tool_result").length;
+	stats.renderablePartCount += entry.parts.filter(isRenderablePart).length;
+	addUsageStats(stats, asObject(entry.raw.message ?? null));
+};
+var updateTimeline = (timeline, raw) => {
+	const timestampMs = parseTimestampMs(raw.timestamp);
+	if (timestampMs === null) return;
+	timeline.firstMs = timeline.firstMs === null ? timestampMs : Math.min(timeline.firstMs, timestampMs);
+	timeline.lastMs = timeline.lastMs === null ? timestampMs : Math.max(timeline.lastMs, timestampMs);
+};
+var readTitleCandidate = (raw) => {
+	const type = asString(raw.type ?? null);
+	if (type !== "ai-title" && type !== "custom-title") return null;
+	return cleanLabel(asString(raw.title ?? null) ?? asString(raw.content ?? null));
+};
+var updateIdentityFromRaw = (identity, raw) => {
+	identity.sessionId = asString(raw.sessionId ?? null) ?? identity.sessionId;
+	identity.cwd = asString(raw.cwd ?? null) ?? identity.cwd;
+	identity.version = asString(raw.version ?? null) ?? identity.version;
+	identity.gitBranch = asString(raw.gitBranch ?? null) ?? identity.gitBranch;
+	identity.model = asString(asObject(raw.message ?? null)?.model ?? null) ?? identity.model;
+	identity.title = readTitleCandidate(raw) ?? identity.title;
+};
+var updateIdentityFromEntry = (identity, entry) => {
+	if (entry.role === "user" && !identity.firstUserText) identity.firstUserText = cleanExtractedText(entry.parts.find((part) => part.type === "text" && part.text?.trim())?.text ?? "").trim() || null;
+};
+var toTimeline = (timeline, fallbackMs) => {
+	const createdAtMs = timeline.firstMs ?? fallbackMs;
+	const lastActiveAtMs = timeline.lastMs ?? fallbackMs;
+	return {
+		createdAtIso: toIso(createdAtMs),
+		createdAtMs,
+		lastActiveAtIso: toIso(lastActiveAtMs),
+		lastActiveAtMs
+	};
+};
+var getTitle = (identity) => {
+	return cleanInlineTitle(identity.title ?? identity.firstUserText ?? identity.sessionId);
+};
+var toSessionSummary = (file, identity, stats, timeline) => {
+	const worktree = identity.cwd ?? decodeWorktreeFromDirectoryName(file.directoryName);
+	const workspaceLabel = getWorkspaceLabel(worktree);
+	const totalTokens = stats.inputTokens + stats.outputTokens + stats.cacheCreationInputTokens + stats.cacheReadInputTokens;
+	return {
+		...stats,
+		...timeline,
+		cwd: identity.cwd,
+		filePath: file.filePath,
+		gitBranch: identity.gitBranch,
+		model: identity.model,
+		sessionId: identity.sessionId,
+		title: getTitle(identity),
+		totalTokens,
+		version: identity.version,
+		workspaceKey: getWorkspaceKey(file.directoryName),
+		workspaceLabel,
+		worktree
+	};
+};
+var isRenderablePart = (part) => {
+	if (part.type === "text" || part.type === "thinking" || part.type === "attachment") return Boolean(part.text?.trim());
+	if (part.type === "tool_use") return Boolean(part.toolName || part.argumentsText?.trim());
+	if (part.type === "tool_result") return Boolean(part.outputText?.trim());
+	return false;
+};
+var readTranscriptFile = async (file) => {
+	const fallbackMtimeMs = await stat(file.filePath).then((stats) => stats.mtimeMs).catch(() => null);
+	const identity = {
+		cwd: null,
+		firstUserText: null,
+		gitBranch: null,
+		model: null,
+		sessionId: path.basename(file.filePath, ".jsonl"),
+		title: null,
+		version: null
+	};
+	const stats = createEmptyStats();
+	const timeline = {
+		firstMs: null,
+		lastMs: null
+	};
+	const entries = [];
+	const rawEvents = [];
+	for await (const raw of readJsonlObjects(file.filePath)) {
+		rawEvents.push(raw);
+		updateTimeline(timeline, raw);
+		updateIdentityFromRaw(identity, raw);
+		const entry = parseTranscriptEntry(raw);
+		if (!entry) continue;
+		entries.push(entry);
+		updateStatsFromEntry(stats, entry);
+		updateIdentityFromEntry(identity, entry);
+	}
+	const session = toSessionSummary(file, identity, stats, toTimeline(timeline, fallbackMtimeMs));
+	return { transcript: {
+		entries,
+		rawEvents,
+		renderablePartCount: stats.renderablePartCount,
+		session
+	} };
+};
+var listTranscriptFilesForProject = async (projectsDir, directoryName) => {
+	const projectDir = path.join(projectsDir, directoryName);
+	return (await readdir(projectDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => ({
+		directoryName,
+		filePath: path.join(projectDir, entry.name)
+	}));
+};
+var listTranscriptFiles = async (projectsDir) => {
+	if (!await pathExists(projectsDir)) return [];
+	return (await mapWithConcurrency((await readdir(projectsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort(), READ_CONCURRENCY, (directoryName) => listTranscriptFilesForProject(projectsDir, directoryName))).flat();
+};
+var readTranscriptFiles = async (files) => {
+	return (await mapWithConcurrency(files, READ_CONCURRENCY, readTranscriptFile)).flatMap((item) => item ? [item.transcript] : []);
+};
+var compareNullableMsDesc = (left, right) => {
+	return (right ?? 0) - (left ?? 0);
+};
+var toWorkspaceGroup = (directoryName, sessions) => {
+	const worktree = sessions[0]?.worktree ?? decodeWorktreeFromDirectoryName(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: sessions.reduce((total, session) => total + session.assistantMessageCount, 0),
+		directoryName,
+		key: getWorkspaceKey(directoryName),
+		label: getWorkspaceLabel(worktree),
+		lastActiveAtIso: toIso(lastActiveAtMs),
+		lastActiveAtMs,
+		messageCount: sessions.reduce((total, session) => total + session.messageCount, 0),
+		sessionCount: sessions.length,
+		toolCallCount: sessions.reduce((total, session) => total + session.toolCallCount, 0),
+		toolResultCount: sessions.reduce((total, session) => total + session.toolResultCount, 0),
+		uri: getWorkspaceUri(worktree),
+		userMessageCount: sessions.reduce((total, session) => total + session.userMessageCount, 0),
+		worktree
+	};
+};
+var listClaudeCodeWorkspaceGroups = async (projectsDir = resolveClaudeCodeProjectsDir()) => {
+	const transcripts = await readTranscriptFiles(await listTranscriptFiles(projectsDir));
+	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 listClaudeCodeSessionsForGroup = async (workspaceKey, projectsDir = resolveClaudeCodeProjectsDir()) => {
+	const directoryName = getDirectoryNameFromWorkspaceKey(workspaceKey);
+	if (!directoryName || !await pathExists(projectsDir)) return [];
+	return sortSessions((await readTranscriptFiles(await listTranscriptFilesForProject(projectsDir, directoryName))).map((transcript) => transcript.session));
+};
+var locateSessionFile = async (projectsDir, sessionId) => {
+	return (await listTranscriptFiles(projectsDir)).find((file) => path.basename(file.filePath, ".jsonl") === sessionId) ?? null;
+};
+var readClaudeCodeSessionTranscript = async (projectsDir, sessionId) => {
+	if (!await pathExists(projectsDir)) return null;
+	const file = await locateSessionFile(projectsDir, sessionId);
+	if (!file) return null;
+	return (await readTranscriptFile(file))?.transcript ?? null;
+};
+//#endregion
+export { listClaudeCodeSessionsForGroup, listClaudeCodeWorkspaceGroups, readClaudeCodeSessionTranscript, resolveClaudeCodeProjectsDir };

package/apps/ui/dist/server/assets/claude-code-queries-Cgzi4K-e.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/claude-code-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 listClaudeCodeWorkspacesFn = createServerFn({ method: "GET" }).handler(createSsrRpc("059a21d54c070078df105ec79a9321ef1d40b40bf4327be93f6d118c598e300f"));
+var listClaudeCodeSessionsFn = createServerFn({ method: "GET" }).validator(workspaceSchema).handler(createSsrRpc("2ffc3b20be74973de734b47407226bae6130a05e31d0d9143b52c9a6e28ba6af"));
+var getClaudeCodeSessionDetailFn = createServerFn({ method: "GET" }).validator(sessionSchema).handler(createSsrRpc("6b9382b62370df4b167d9fa590406f3f450b655eee585d88047bb61129037c69"));
+var exportClaudeCodeSessionFn = createServerFn({ method: "POST" }).validator(exportSessionSchema).handler(createSsrRpc("59076299b518e4ee172c6793dceb83740eee7fa39888483c11affac937e1af70"));
+//#endregion
+//#region src/lib/claude-code-queries.ts
+var claudeCodeWorkspacesQueryOptions = () => queryOptions({
+	queryFn: () => listClaudeCodeWorkspacesFn(),
+	queryKey: ["claude-code-workspaces"]
+});
+var claudeCodeSessionsQueryOptions = (workspaceKey) => queryOptions({
+	enabled: workspaceKey !== null,
+	queryFn: () => listClaudeCodeSessionsFn({ data: { workspaceKey: workspaceKey ?? "" } }),
+	queryKey: ["claude-code-sessions", workspaceKey ?? "none"]
+});
+var claudeCodeSessionDetailQueryOptions = (sessionId) => queryOptions({
+	enabled: sessionId !== null,
+	queryFn: () => getClaudeCodeSessionDetailFn({ data: { sessionId: sessionId ?? "" } }),
+	queryKey: ["claude-code-session", sessionId ?? "none"]
+});
+//#endregion
+export { exportClaudeCodeSessionFn as i, claudeCodeSessionsQueryOptions as n, claudeCodeWorkspacesQueryOptions as r, claudeCodeSessionDetailQueryOptions as t };

package/apps/ui/dist/server/assets/claude-code-server-PfraClXS.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/claude-code-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 listClaudeCodeWorkspacesFn_createServerFn_handler = createServerRpc({
+	id: "059a21d54c070078df105ec79a9321ef1d40b40bf4327be93f6d118c598e300f",
+	name: "listClaudeCodeWorkspacesFn",
+	filename: "src/lib/claude-code-server.ts"
+}, (opts) => listClaudeCodeWorkspacesFn.__executeServer(opts));
+var listClaudeCodeWorkspacesFn = createServerFn({ method: "GET" }).handler(listClaudeCodeWorkspacesFn_createServerFn_handler, async () => {
+	const { listClaudeCodeWorkspaceGroups } = await import("./claude-code-db-Ik3VStKZ.js");
+	return listClaudeCodeWorkspaceGroups();
+});
+var listClaudeCodeSessionsFn_createServerFn_handler = createServerRpc({
+	id: "2ffc3b20be74973de734b47407226bae6130a05e31d0d9143b52c9a6e28ba6af",
+	name: "listClaudeCodeSessionsFn",
+	filename: "src/lib/claude-code-server.ts"
+}, (opts) => listClaudeCodeSessionsFn.__executeServer(opts));
+var listClaudeCodeSessionsFn = createServerFn({ method: "GET" }).validator(workspaceSchema).handler(listClaudeCodeSessionsFn_createServerFn_handler, async ({ data }) => {
+	const { listClaudeCodeSessionsForGroup } = await import("./claude-code-db-Ik3VStKZ.js");
+	return listClaudeCodeSessionsForGroup(data.workspaceKey);
+});
+var loadClaudeCodeSessionTranscript = async (sessionId) => {
+	const { readClaudeCodeSessionTranscript, resolveClaudeCodeProjectsDir } = await import("./claude-code-db-Ik3VStKZ.js");
+	const transcript = await readClaudeCodeSessionTranscript(resolveClaudeCodeProjectsDir(), sessionId);
+	if (!transcript) throw new Error(`Claude Code session not found: ${sessionId}`);
+	return transcript;
+};
+var getClaudeCodeSessionDetailFn_createServerFn_handler = createServerRpc({
+	id: "6b9382b62370df4b167d9fa590406f3f450b655eee585d88047bb61129037c69",
+	name: "getClaudeCodeSessionDetailFn",
+	filename: "src/lib/claude-code-server.ts"
+}, (opts) => getClaudeCodeSessionDetailFn.__executeServer(opts));
+var getClaudeCodeSessionDetailFn = createServerFn({ method: "GET" }).validator(sessionSchema).handler(getClaudeCodeSessionDetailFn_createServerFn_handler, async ({ data }) => {
+	return loadClaudeCodeSessionTranscript(data.sessionId);
+});
+var exportClaudeCodeSessionFn_createServerFn_handler = createServerRpc({
+	id: "59076299b518e4ee172c6793dceb83740eee7fa39888483c11affac937e1af70",
+	name: "exportClaudeCodeSessionFn",
+	filename: "src/lib/claude-code-server.ts"
+}, (opts) => exportClaudeCodeSessionFn.__executeServer(opts));
+var exportClaudeCodeSessionFn = createServerFn({ method: "POST" }).validator(exportSessionSchema).handler(exportClaudeCodeSessionFn_createServerFn_handler, async ({ data }) => {
+	const { renderClaudeCodeTranscript } = await import("./claude-code-transcript-C-bxh3cS.js");
+	const transcript = await loadClaudeCodeSessionTranscript(data.sessionId);
+	const content = renderClaudeCodeTranscript(transcript, {
+		includeCommentary: data.includeCommentary,
+		includeMetadata: data.includeMetadata,
+		includeTools: data.includeTools,
+		outputFormat: data.outputFormat
+	});
+	if (!content) throw new Error(`Claude Code session has no exportable content: ${data.sessionId}`);
+	return renderSourceSessionDownload({
+		content,
+		fallbackBaseName: "claude-code-session",
+		fileBaseName: transcript.session.title || transcript.session.sessionId,
+		outputFormat: data.outputFormat,
+		zipArchive: data.zipArchive
+	});
+});
+//#endregion
+export { exportClaudeCodeSessionFn_createServerFn_handler, getClaudeCodeSessionDetailFn_createServerFn_handler, listClaudeCodeSessionsFn_createServerFn_handler, listClaudeCodeWorkspacesFn_createServerFn_handler };

package/apps/ui/dist/server/assets/claude-code-sessions._sessionId-C55oe6zj.js

@@ -0,0 +1,18 @@
+import { t as claudeCodeSessionDetailQueryOptions } from "./claude-code-queries-Cgzi4K-e.js";
+import { t as LoadingPanel } from "./loading-panel-BGFnWseS.js";
+import { createFileRoute, lazyRouteComponent } from "@tanstack/react-router";
+import { jsx } from "react/jsx-runtime";
+//#region src/routes/claude-code-sessions.$sessionId.tsx
+var $$splitErrorComponentImporter = () => import("./claude-code-sessions._sessionId-DSvPLEUL.js");
+var $$splitComponentImporter = () => import("./claude-code-sessions._sessionId-D1RYYi3j.js");
+var Route = createFileRoute("/claude-code-sessions/$sessionId")({
+	component: lazyRouteComponent($$splitComponentImporter, "component"),
+	errorComponent: lazyRouteComponent($$splitErrorComponentImporter, "errorComponent"),
+	loader: ({ context, params }) => context.queryClient.ensureQueryData(claudeCodeSessionDetailQueryOptions(params.sessionId)),
+	pendingComponent: () => /* @__PURE__ */ jsx(LoadingPanel, {
+		description: "Loading the Claude Code transcript, messages, tool calls, and session metadata.",
+		title: "Loading session"
+	})
+});
+//#endregion
+export { Route as t };