spiracha 2.1.0 → 2.2.0

package/apps/ui/src/lib/antigravity-server.ts

@@ -1,7 +1,9 @@
+import type { AntigravityConversation } from '@spiracha/lib/antigravity-exporter-types';
 import { buildConversationExportBaseName } from '@spiracha/lib/ui-export-archive';
 import { createServerFn } from '@tanstack/react-start';
 import { z } from 'zod';
 import { canExportAntigravityConversation, isAntigravityConversationLocked } from './antigravity-conversation-state';
+import { runDeleteBatch } from './delete-batch';
 
 const workspaceSchema = z.object({
     workspaceKey: z.string().min(1),
@@ -13,10 +15,18 @@ const conversationSchema = z.object({
 
 const exportSchema = z.object({
     conversationId: z.string().min(1),
+    includeCommentary: z.boolean().default(false),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
+    outputFormat: z.enum(['md', 'txt']).default('md'),
+    zipArchive: z.boolean().default(false),
 });
 
 const exportConversationsSchema = z.object({
     conversationIds: z.array(z.string().min(1)).min(1),
+    includeCommentary: z.boolean().default(false),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
     outputFormat: z.enum(['md', 'txt']).default('md'),
     zipArchive: z.boolean().default(true),
 });
@@ -111,11 +121,22 @@ export const loadAntigravityConversationDetail = async (conversationId: string)
     };
 };
 
-export const loadAntigravityConversationExport = async (conversationId: string) => {
+type AntigravityConversationExportOptions = {
+    includeCommentary?: boolean;
+    includeMetadata?: boolean;
+    includeTools?: boolean;
+    outputFormat?: 'md' | 'txt';
+};
+
+export const loadAntigravityConversationExport = async (
+    conversationId: string,
+    options: AntigravityConversationExportOptions = {},
+    loadedConversation?: AntigravityConversation,
+) => {
     const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
     const { renderAntigravityConversationMarkdown } = await import('@spiracha/lib/antigravity-db');
     const { getCachedAntigravityKeychainSecret } = await import('@spiracha/lib/antigravity-keychain');
-    const conversation = await findAntigravityConversationById(conversationId);
+    const conversation = loadedConversation ?? (await findAntigravityConversationById(conversationId));
     const keychainSecret = getCachedAntigravityKeychainSecret();
     const hasKeychainSecret = Boolean(keychainSecret);
 
@@ -130,7 +151,11 @@ export const loadAntigravityConversationExport = async (conversationId: string)
     const content = await runWithTranscriptLoadLimit(
         () =>
             renderAntigravityConversationMarkdown(conversation, {
+                includeCommentary: options.includeCommentary,
+                includeMetadata: options.includeMetadata,
+                includeTools: options.includeTools,
                 keychainSecret,
+                outputFormat: options.outputFormat,
             }),
         {
             id: conversation.conversationId,
@@ -152,7 +177,7 @@ export const loadAntigravityConversationExport = async (conversationId: string)
                 updatedAtMs: conversation.lastUpdatedAtMs ?? conversation.conversationMtimeMs,
             },
             'antigravity-conversation',
-        )}.md`,
+        )}.${options.outputFormat ?? 'md'}`,
     };
 };
 
@@ -171,8 +196,8 @@ export const deleteAntigravityConversationsById = async (conversationIds: string
     const { deleteAntigravityConversation } = await import('@spiracha/lib/antigravity-db');
     const { resolveAntigravityRoots } = await import('@spiracha/lib/antigravity-exporter-types');
     const roots = resolveAntigravityRoots();
-    const results = await Promise.all(
-        conversationIds.map((conversationId) => deleteAntigravityConversation(roots, conversationId)),
+    const results = await runDeleteBatch(conversationIds, (conversationId) =>
+        deleteAntigravityConversation(roots, conversationId),
     );
     const deletedConversationIds = results.flatMap((result) => result.deletedConversationIds);
     if (deletedConversationIds.length === 0) {
@@ -192,7 +217,7 @@ export const getAntigravityConversationDetailFn = createServerFn({ method: 'GET'
     });
 
 export const exportAntigravityArtifactsFn = createServerFn({ method: 'POST' })
-    .validator(exportSchema)
+    .validator(conversationSchema)
     .handler(async ({ data }) => {
         const { renderAntigravityArtifactsMarkdown } = await import('@spiracha/lib/antigravity-db');
         const conversation = await findAntigravityConversationById(data.conversationId);
@@ -211,22 +236,50 @@ export const exportAntigravityArtifactsFn = createServerFn({ method: 'POST' })
 export const exportAntigravityConversationFn = createServerFn({ method: 'POST' })
     .validator(exportSchema)
     .handler(async ({ data }) => {
-        return loadAntigravityConversationExport(data.conversationId);
+        return exportAntigravityConversations({
+            conversationIds: [data.conversationId],
+            includeCommentary: data.includeCommentary,
+            includeMetadata: data.includeMetadata,
+            includeTools: data.includeTools,
+            outputFormat: data.outputFormat,
+            zipArchive: data.zipArchive,
+        });
     });
 
-export const exportAntigravityConversations = async (data: z.infer<typeof exportConversationsSchema>) => {
+export const exportAntigravityConversations = async (input: z.input<typeof exportConversationsSchema>) => {
+    const data = exportConversationsSchema.parse(input);
     const { renderSourceSessionsDownload } = await import('./source-session-export-server');
-    const { listAntigravityWorkspaceGroups } = await import('@spiracha/lib/antigravity-db');
-    const groups = await listAntigravityWorkspaceGroups();
-    const groupsByKey = new Map(groups.map((group) => [group.key, group]));
+    const { listAntigravityConversations } = await import('@spiracha/lib/antigravity-db');
+    const { resolveAntigravityProjectNames } = await import('@spiracha/lib/antigravity-projects');
+    const conversations = await listAntigravityConversations();
+    const conversationsById = new Map(conversations.map((conversation) => [conversation.conversationId, conversation]));
+    const selectedConversations = data.conversationIds.map((conversationId) => {
+        const conversation = conversationsById.get(conversationId);
+        if (!conversation) {
+            throw new Error(`Antigravity conversation not found: ${conversationId}`);
+        }
+        return conversation;
+    });
+    const projectNames = await resolveAntigravityProjectNames(
+        selectedConversations.flatMap((conversation) => (conversation.projectId ? [conversation.projectId] : [])),
+    );
     const entries = await Promise.all(
-        data.conversationIds.map(async (conversationId) => {
-            const result = await loadAntigravityConversationExport(conversationId);
+        selectedConversations.map(async (loadedConversation) => {
+            const conversationId = loadedConversation.conversationId;
+            const result = await loadAntigravityConversationExport(
+                conversationId,
+                {
+                    includeCommentary: data.includeCommentary,
+                    includeMetadata: data.includeMetadata,
+                    includeTools: data.includeTools,
+                    outputFormat: data.outputFormat,
+                },
+                loadedConversation,
+            );
             const conversation = result.conversation;
-            const projectGroup = conversation.projectId
-                ? groupsByKey.get(`project:${conversation.projectId}`)
-                : undefined;
-            const exportCwd = projectGroup?.label ?? conversation.workspaceFolder;
+            const exportCwd =
+                (conversation.projectId ? projectNames.get(conversation.projectId) : null) ??
+                conversation.workspaceFolder;
             const updatedAtMs = conversation.lastUpdatedAtMs ?? conversation.conversationMtimeMs;
             return {
                 content: result.content,

package/apps/ui/src/lib/antigravity-transcript-events.ts

@@ -1,5 +1,7 @@
+import { getFinalAntigravityAssistantSequences } from '@spiracha/lib/antigravity-transcript-phase';
 import type { ThreadEvent, ThreadTranscriptStats } from '@spiracha/lib/codex-browser-types';
 import type { JsonValue } from '@spiracha/lib/shared';
+import { getThreadTranscriptStats } from './thread-transcript-stats';
 
 type MarkdownSection = {
     body: string;
@@ -23,6 +25,18 @@ const TIMESTAMP_PATTERN = /^_Timestamp:\s*(.+?)_$/u;
 const TOOL_HEADING_PATTERN = /^tool:\s*(.+)$/iu;
 const CONTROL_SUBHEADING_PATTERN = /^###\s+(Thinking|Tool Calls)\s*$/iu;
 
+type MarkdownFence = { character: string; length: number };
+
+const updateMarkdownFence = (fence: MarkdownFence | null, token: string | null): MarkdownFence | null => {
+    if (!token) {
+        return fence;
+    }
+    if (!fence) {
+        return { character: token[0]!, length: token.length };
+    }
+    return token[0] === fence.character && token.length >= fence.length ? null : fence;
+};
+
 const splitMarkdownSections = (markdown: string | null): MarkdownSection[] => {
     if (!markdown?.trim()) {
         return [];
@@ -32,6 +46,7 @@ const splitMarkdownSections = (markdown: string | null): MarkdownSection[] => {
     const lines = markdown.split(/\r?\n/u);
     let currentHeading: string | null = null;
     let currentLines: string[] = [];
+    let fence: MarkdownFence | null = null;
 
     const flush = () => {
         if (!currentHeading) {
@@ -41,12 +56,13 @@ const splitMarkdownSections = (markdown: string | null): MarkdownSection[] => {
         sections.push({
             body: currentLines.join('\n').trim(),
             heading: currentHeading,
-            sequence: sections.length * 10,
+            sequence: sections.length * 1000,
         });
     };
 
     for (const line of lines) {
-        const heading = HEADING_PATTERN.exec(line);
+        const fenceToken = /^\s*(`{3,}|~{3,})/u.exec(line)?.[1] ?? null;
+        const heading = fence === null && fenceToken === null ? HEADING_PATTERN.exec(line) : null;
         if (heading) {
             flush();
             currentHeading = heading[1]!.trim();
@@ -57,6 +73,8 @@ const splitMarkdownSections = (markdown: string | null): MarkdownSection[] => {
         if (currentHeading) {
             currentLines.push(line);
         }
+
+        fence = updateMarkdownFence(fence, fenceToken);
     }
 
     flush();
@@ -195,38 +213,37 @@ const buildToolOutputEvent = (
 });
 
 const getFinalAssistantSectionSequences = (sections: MarkdownSection[]): Set<number> => {
-    const finalAssistantSectionSequences = new Set<number>();
-    let currentAssistantContentSequence: number | null = null;
-
-    const flushAssistantRun = () => {
-        if (currentAssistantContentSequence !== null) {
-            finalAssistantSectionSequences.add(currentAssistantContentSequence);
-        }
-        currentAssistantContentSequence = null;
-    };
-
-    for (const section of sections) {
+    const items = sections.map((section) => {
         const heading = section.heading.toLowerCase();
         if (heading === 'user') {
-            flushAssistantRun();
-            continue;
+            return {
+                hasContent: Boolean(section.body),
+                hasToolCalls: false,
+                role: 'user' as const,
+                sequence: section.sequence,
+            };
         }
 
-        if (heading !== 'assistant') {
-            continue;
+        if (heading === 'assistant') {
+            const { body } = extractTimestamp(section.body);
+            const parsed = parseAssistantSection(body);
+            return {
+                hasContent: Boolean(parsed.content),
+                hasToolCalls: parsed.toolCalls.length > 0,
+                role: 'assistant' as const,
+                sequence: section.sequence,
+            };
         }
 
-        const { body } = extractTimestamp(section.body);
-        const parsed = parseAssistantSection(body);
-        if (parsed.toolCalls.length > 0) {
-            currentAssistantContentSequence = null;
-        } else if (parsed.content) {
-            currentAssistantContentSequence = section.sequence;
-        }
-    }
+        return {
+            hasContent: Boolean(section.body),
+            hasToolCalls: false,
+            role: 'other' as const,
+            sequence: section.sequence,
+        };
+    });
 
-    flushAssistantRun();
-    return finalAssistantSectionSequences;
+    return getFinalAntigravityAssistantSequences(items);
 };
 
 const textSectionToEvents = (
@@ -298,46 +315,5 @@ export const antigravityMarkdownToThreadEvents = (markdown: string | null): Thre
     return sections.flatMap((section) => sectionToEvents(section, finalAssistantSectionSequences));
 };
 
-const updateMessageStats = (stats: ThreadTranscriptStats, event: Extract<ThreadEvent, { kind: 'message' }>) => {
-    stats.messageCount += 1;
-    if (event.role === 'assistant') {
-        stats.assistantMessageCount += 1;
-    }
-    if (event.role === 'user') {
-        stats.userMessageCount += 1;
-    }
-    if (event.phase === 'commentary') {
-        stats.commentaryCount += 1;
-    }
-    if (event.phase === 'final_answer') {
-        stats.finalAnswerCount += 1;
-    }
-};
-
-export const getAntigravityThreadTranscriptStats = (events: ThreadEvent[]): ThreadTranscriptStats => {
-    const stats: ThreadTranscriptStats = {
-        assistantMessageCount: 0,
-        commentaryCount: 0,
-        execCommandCount: 0,
-        finalAnswerCount: 0,
-        messageCount: 0,
-        toolCallCount: 0,
-        toolOutputCount: 0,
-        userMessageCount: 0,
-        webSearchEventCount: 0,
-    };
-
-    for (const event of events) {
-        if (event.kind === 'message') {
-            updateMessageStats(stats, event);
-        }
-        if (event.kind === 'tool_call') {
-            stats.toolCallCount += 1;
-        }
-        if (event.kind === 'tool_output') {
-            stats.toolOutputCount += 1;
-        }
-    }
-
-    return stats;
-};
+export const getAntigravityThreadTranscriptStats = (events: ThreadEvent[]): ThreadTranscriptStats =>
+    getThreadTranscriptStats(events);

package/apps/ui/src/lib/claude-code-server.ts

@@ -1,5 +1,6 @@
 import { createServerFn } from '@tanstack/react-start';
 import { z } from 'zod';
+import { requireDeletedItems, runDeleteBatch } from './delete-batch';
 import { renderSourceSessionDownload, renderSourceSessionsDownload } from './source-session-export-server';
 
 const LARGE_CLAUDE_CODE_SESSION_SIZE_BYTES = 8 * 1024 * 1024;
@@ -56,7 +57,9 @@ const loadClaudeCodeSessionTranscript = async (sessionId: string) => {
     const projectsDir = resolveClaudeCodeProjectsDir();
     return runWithTranscriptLoadLimit(
         async () => {
-            const transcript = await readClaudeCodeSessionTranscript(projectsDir, sessionId);
+            const transcript = await readClaudeCodeSessionTranscript(projectsDir, sessionId, {
+                includeRawPayloads: false,
+            });
             if (!transcript) {
                 throw new Error(`Claude Code session not found: ${sessionId}`);
             }
@@ -225,7 +228,9 @@ export const deleteClaudeCodeSessionFn = createServerFn({ method: 'POST' })
     .validator(sessionSchema)
     .handler(async ({ data }) => {
         const { deleteClaudeCodeSession, resolveClaudeCodeProjectsDir } = await import('@spiracha/lib/claude-code-db');
-        return deleteClaudeCodeSession(resolveClaudeCodeProjectsDir(), data.sessionId);
+        const result = await deleteClaudeCodeSession(resolveClaudeCodeProjectsDir(), data.sessionId);
+        requireDeletedItems(result.deletedSessionIds, 'Claude Code session', data.sessionId);
+        return result;
     });
 
 export const deleteClaudeCodeSessionsFn = createServerFn({ method: 'POST' })
@@ -233,8 +238,13 @@ export const deleteClaudeCodeSessionsFn = createServerFn({ method: 'POST' })
     .handler(async ({ data }) => {
         const { deleteClaudeCodeSession, resolveClaudeCodeProjectsDir } = await import('@spiracha/lib/claude-code-db');
         const projectsDir = resolveClaudeCodeProjectsDir();
-        const results = await Promise.all(
-            data.sessionIds.map((sessionId) => deleteClaudeCodeSession(projectsDir, sessionId)),
+        const results = await runDeleteBatch(data.sessionIds, (sessionId) =>
+            deleteClaudeCodeSession(projectsDir, sessionId),
+        );
+        requireDeletedItems(
+            results.flatMap((result) => result.deletedSessionIds),
+            'Claude Code sessions',
+            'batch',
         );
         return {
             deletedFiles: [...new Set(results.flatMap((result) => result.deletedFiles))],

package/apps/ui/src/lib/codex-queries.ts

@@ -49,10 +49,10 @@ export const projectThreadsQueryOptions = (project: string) =>
         retryDelay,
     });
 
-export const threadSnapshotQueryOptions = (threadId: string, filters?: ThreadTranscriptFilters) =>
+export const threadSnapshotQueryOptions = (threadId: string) =>
     queryOptions({
-        queryFn: () => getThreadSnapshotFn({ data: { filters, threadId } }),
-        queryKey: ['thread', threadId, filters ?? 'all'],
+        queryFn: () => getThreadSnapshotFn({ data: { threadId } }),
+        queryKey: ['thread', threadId],
         retry: retrySqliteQuery,
         retryDelay,
     });

package/apps/ui/src/lib/codex-server.ts

@@ -22,7 +22,7 @@ const transcriptFiltersSchema = z.object({
     showUserMessages: z.boolean(),
 });
 
-const threadSnapshotSchema = z.object({
+const threadPreviewSchema = z.object({
     filters: transcriptFiltersSchema.optional(),
     threadId: z.string().min(1),
 });
@@ -101,7 +101,7 @@ export const listProjectThreadsFn = createServerFn({ method: 'GET' })
     });
 
 export const getThreadSnapshotFn = createServerFn({ method: 'GET' })
-    .validator(threadSnapshotSchema)
+    .validator(threadSchema)
     .handler(async ({ data }) => {
         const startedAt = Date.now();
         const [{ getThreadBrowseData }, { getThreadRolloutLoadState }] = await Promise.all([
@@ -197,7 +197,7 @@ export const loadThreadTranscript = async (threadId: string) => {
 };
 
 export const getThreadTranscriptPreviewFn = createServerFn({ method: 'GET' })
-    .validator(threadSnapshotSchema)
+    .validator(threadPreviewSchema)
     .handler(async ({ data }) => {
         return loadThreadTranscriptPreview(data.threadId, data.filters);
     });

package/apps/ui/src/lib/cursor-server.ts

@@ -1,25 +1,18 @@
-import { randomUUID } from 'node:crypto';
-import { mkdtemp, rm } from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import {
-    buildBatchExportBaseName,
-    buildConversationExportBaseName,
-    getExportMimeType,
-    resolveUniqueExportFileBaseName,
-    sanitizeExportFileName,
-    zipExportDirectory,
-} from '@spiracha/lib/ui-export-archive';
-import { buildUiExportDownloadUrl, ensureUiExportDir } from '@spiracha/lib/ui-export-files';
+import { isSafeCursorComposerId } from '@spiracha/lib/cursor-id';
 import { createServerFn } from '@tanstack/react-start';
 import { z } from 'zod';
+import { renderSourceSessionDownload, renderSourceSessionsDownload } from './source-session-export-server';
 
 const workspaceSchema = z.object({
     workspaceKey: z.string().min(1),
 });
 
+const composerIdSchema = z.string().refine(isSafeCursorComposerId, {
+    message: 'Invalid Cursor composer id.',
+});
+
 const threadSchema = z.object({
-    composerId: z.string().min(1),
+    composerId: composerIdSchema,
 });
 
 const recoverSchema = z.object({
@@ -28,7 +21,7 @@ const recoverSchema = z.object({
 });
 
 const exportSchema = z.object({
-    composerId: z.string().min(1),
+    composerId: composerIdSchema,
     includeCommentary: z.boolean().default(true),
     includeMetadata: z.boolean().default(true),
     includeTools: z.boolean().default(true),
@@ -37,7 +30,7 @@ const exportSchema = z.object({
 });
 
 const exportThreadsSchema = z.object({
-    composerIds: z.array(z.string().min(1)).min(1),
+    composerIds: z.array(composerIdSchema).min(1),
     includeCommentary: z.boolean().default(true),
     includeMetadata: z.boolean().default(true),
     includeTools: z.boolean().default(true),
@@ -46,7 +39,7 @@ const exportThreadsSchema = z.object({
 });
 
 const deleteThreadsSchema = z.object({
-    composerIds: z.array(z.string().min(1)).min(1),
+    composerIds: z.array(composerIdSchema).min(1),
 });
 
 const ensureCursorClosedForWrite = async () => {
@@ -69,48 +62,29 @@ const findGroupByKey = async (workspaceKey: string) => {
     return group;
 };
 
-const toSafeExportName = (value: string) => {
-    return sanitizeExportFileName(value) || 'cursor-thread';
-};
-
 const renderCursorZipDownload = async (
-    rendered: Array<{ composerId: string; content: string; cwd: string | null; updatedAtMs: number | null }>,
+    rendered: Array<{
+        composerId: string;
+        content: string;
+        cwd: string | null;
+        fileBaseName: string;
+        updatedAtMs: number | null;
+    }>,
     outputFormat: 'md' | 'txt',
 ) => {
-    const exportDir = await ensureUiExportDir();
-    const exportBaseName =
-        rendered.length === 1
-            ? buildConversationExportBaseName(
-                  {
-                      cwd: rendered[0]!.cwd,
-                      id: rendered[0]!.composerId,
-                      updatedAtMs: rendered[0]!.updatedAtMs,
-                  },
-                  'cursor-thread',
-              )
-            : buildBatchExportBaseName(rendered, 'cursor');
-    const workspaceDir = await mkdtemp(path.join(os.tmpdir(), `${exportBaseName}-`));
-    const zipPath = path.join(exportDir, `${exportBaseName}-${randomUUID()}.zip`);
-    const usedBaseNames = new Map<string, number>();
-
-    try {
-        for (const entry of rendered) {
-            const baseName = toSafeExportName(entry.composerId);
-            const fileBaseName = resolveUniqueExportFileBaseName(baseName, usedBaseNames);
-            await Bun.write(path.join(workspaceDir, `${fileBaseName}.${outputFormat}`), entry.content);
-        }
-
-        await zipExportDirectory(workspaceDir, zipPath);
-    } finally {
-        await rm(workspaceDir, { force: true, recursive: true });
-    }
-
-    return {
-        downloadUrl: buildUiExportDownloadUrl(zipPath),
-        fileName: `${exportBaseName}.zip`,
-        mimeType: 'application/zip',
-        mode: 'download_url' as const,
-    };
+    return renderSourceSessionsDownload({
+        entries: rendered.map((entry) => ({
+            content: entry.content,
+            cwd: entry.cwd,
+            fallbackBaseName: 'cursor-thread',
+            fileBaseName: entry.fileBaseName,
+            sessionId: entry.composerId,
+            updatedAtMs: entry.updatedAtMs,
+        })),
+        fallbackBaseName: 'cursor',
+        outputFormat,
+        zipArchive: true,
+    });
 };
 
 export const findCursorThreadByComposerId = async (composerId: string) => {
@@ -175,6 +149,7 @@ const renderCursorDownload = async (input: {
                 composerId,
                 content,
                 cwd: workspace?.folders[0] ?? null,
+                fileBaseName: transcript.head.name || composerId,
                 updatedAtMs: transcript.head.lastUpdatedAtMs,
             };
         }),
@@ -185,19 +160,16 @@ const renderCursorDownload = async (input: {
     }
 
     if (rendered.length === 1) {
-        return {
-            content: rendered[0]!.content,
-            fileName: `${buildConversationExportBaseName(
-                {
-                    cwd: rendered[0]!.cwd,
-                    id: rendered[0]!.composerId,
-                    updatedAtMs: rendered[0]!.updatedAtMs,
-                },
-                'cursor-thread',
-            )}.${input.outputFormat}`,
-            mimeType: getExportMimeType(input.outputFormat),
-            mode: 'download' as const,
-        };
+        const entry = rendered[0]!;
+        return renderSourceSessionDownload({
+            content: entry.content,
+            cwd: entry.cwd,
+            fallbackBaseName: 'cursor-thread',
+            outputFormat: input.outputFormat,
+            sessionId: entry.composerId,
+            updatedAtMs: entry.updatedAtMs,
+            zipArchive: false,
+        });
     }
 
     throw new Error('No Cursor threads selected for export');