spiracha 2.0.0 → 2.2.0

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

@@ -1,6 +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),
@@ -12,6 +15,24 @@ 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),
+});
+
+const deleteConversationsSchema = z.object({
+    conversationIds: z.array(z.string().min(1)).min(1),
 });
 
 export const listAntigravityWorkspacesFn = createServerFn({ method: 'GET' }).handler(async () => {
@@ -48,7 +69,24 @@ const findAntigravityConversationById = async (conversationId: string) => {
     return conversation;
 };
 
+const resolveAntigravityConversationGroup = async (
+    conversation: Awaited<ReturnType<typeof findAntigravityConversationById>>,
+) => {
+    const fallback = {
+        key: conversation.projectId ? `project:${conversation.projectId}` : conversation.workspaceKey,
+        label: conversation.workspaceLabel,
+    };
+    if (!conversation.projectId) {
+        return fallback;
+    }
+
+    const { listAntigravityWorkspaceGroups } = await import('@spiracha/lib/antigravity-db');
+    const group = (await listAntigravityWorkspaceGroups()).find((candidate) => candidate.key === fallback.key);
+    return group ? { key: group.key, label: group.label } : fallback;
+};
+
 export const loadAntigravityConversationDetail = async (conversationId: string) => {
+    const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
     const { renderAntigravityArtifactsMarkdown, renderAntigravityConversationMarkdown } = await import(
         '@spiracha/lib/antigravity-db'
     );
@@ -57,25 +95,48 @@ export const loadAntigravityConversationDetail = async (conversationId: string)
     const keychainSecret = getCachedAntigravityKeychainSecret();
     const hasKeychainSecret = Boolean(keychainSecret);
     const transcriptLocked = isAntigravityConversationLocked(conversation, hasKeychainSecret);
-    const conversationMarkdown = transcriptLocked
-        ? null
-        : await renderAntigravityConversationMarkdown(conversation, { keychainSecret });
-    const artifactsMarkdown =
-        conversation.artifactCount > 0 ? await renderAntigravityArtifactsMarkdown(conversation) : null;
+    const [[conversationMarkdown, artifactsMarkdown], conversationGroup] = await Promise.all([
+        runWithTranscriptLoadLimit(
+            async () =>
+                Promise.all([
+                    transcriptLocked ? null : renderAntigravityConversationMarkdown(conversation, { keychainSecret }),
+                    conversation.artifactCount > 0 ? renderAntigravityArtifactsMarkdown(conversation) : null,
+                ]),
+            {
+                id: conversation.conversationId,
+                path: conversation.transcriptPath ?? conversation.conversationPath ?? undefined,
+                source: 'antigravity-ui-detail',
+            },
+        ),
+        resolveAntigravityConversationGroup(conversation),
+    ]);
 
     return {
         artifactsMarkdown,
         conversation,
+        conversationGroup,
         // Suppress the duplicate panel when artifactsMarkdown and conversationMarkdown are identical.
         conversationMarkdown: conversationMarkdown === artifactsMarkdown ? null : conversationMarkdown,
         transcriptLocked,
     };
 };
 
-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);
 
@@ -87,14 +148,65 @@ export const loadAntigravityConversationExport = async (conversationId: string)
         throw new Error(`No exportable Antigravity transcript found for conversation: ${conversationId}`);
     }
 
-    const content = await renderAntigravityConversationMarkdown(conversation, { keychainSecret });
+    const content = await runWithTranscriptLoadLimit(
+        () =>
+            renderAntigravityConversationMarkdown(conversation, {
+                includeCommentary: options.includeCommentary,
+                includeMetadata: options.includeMetadata,
+                includeTools: options.includeTools,
+                keychainSecret,
+                outputFormat: options.outputFormat,
+            }),
+        {
+            id: conversation.conversationId,
+            path: conversation.transcriptPath ?? conversation.conversationPath ?? undefined,
+            source: 'antigravity-ui-export',
+        },
+    );
     if (!content) {
         throw new Error(`No exportable Antigravity transcript found for conversation: ${conversationId}`);
     }
 
     return {
         content,
-        filename: `${conversationId}.md`,
+        conversation,
+        filename: `${buildConversationExportBaseName(
+            {
+                cwd: conversation.workspaceFolder,
+                id: conversation.conversationId,
+                updatedAtMs: conversation.lastUpdatedAtMs ?? conversation.conversationMtimeMs,
+            },
+            'antigravity-conversation',
+        )}.${options.outputFormat ?? 'md'}`,
+    };
+};
+
+export const deleteAntigravityConversationById = async (conversationId: string) => {
+    const { deleteAntigravityConversation } = await import('@spiracha/lib/antigravity-db');
+    const { resolveAntigravityRoots } = await import('@spiracha/lib/antigravity-exporter-types');
+    const result = await deleteAntigravityConversation(resolveAntigravityRoots(), conversationId);
+    if (result.deletedConversationIds.length === 0) {
+        throw new Error(`Antigravity conversation not found: ${conversationId}`);
+    }
+
+    return result;
+};
+
+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 runDeleteBatch(conversationIds, (conversationId) =>
+        deleteAntigravityConversation(roots, conversationId),
+    );
+    const deletedConversationIds = results.flatMap((result) => result.deletedConversationIds);
+    if (deletedConversationIds.length === 0) {
+        throw new Error('No Antigravity conversations were deleted');
+    }
+
+    return {
+        deletedConversationIds,
+        deletedPaths: results.flatMap((result) => result.deletedPaths),
     };
 };
 
@@ -105,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);
@@ -124,5 +236,91 @@ 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 (input: z.input<typeof exportConversationsSchema>) => {
+    const data = exportConversationsSchema.parse(input);
+    const { renderSourceSessionsDownload } = await import('./source-session-export-server');
+    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(
+        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 exportCwd =
+                (conversation.projectId ? projectNames.get(conversation.projectId) : null) ??
+                conversation.workspaceFolder;
+            const updatedAtMs = conversation.lastUpdatedAtMs ?? conversation.conversationMtimeMs;
+            return {
+                content: result.content,
+                cwd: exportCwd,
+                fallbackBaseName: 'antigravity-conversation',
+                fileBaseName: buildConversationExportBaseName(
+                    {
+                        cwd: exportCwd,
+                        id: conversation.conversationId,
+                        updatedAtMs,
+                    },
+                    'antigravity-conversation',
+                ),
+                sessionId: conversation.conversationId,
+                updatedAtMs,
+            };
+        }),
+    );
+
+    return renderSourceSessionsDownload({
+        entries,
+        fallbackBaseName: 'antigravity-conversations',
+        outputFormat: data.outputFormat,
+        zipArchive: data.zipArchive,
+    });
+};
+
+export const exportAntigravityConversationsFn = createServerFn({ method: 'POST' })
+    .validator(exportConversationsSchema)
+    .handler(async ({ data }) => {
+        return exportAntigravityConversations(data);
+    });
+
+export const deleteAntigravityConversationFn = createServerFn({ method: 'POST' })
+    .validator(conversationSchema)
+    .handler(async ({ data }) => {
+        return deleteAntigravityConversationById(data.conversationId);
+    });
+
+export const deleteAntigravityConversationsFn = createServerFn({ method: 'POST' })
+    .validator(deleteConversationsSchema)
+    .handler(async ({ data }) => {
+        return deleteAntigravityConversationsById(data.conversationIds);
     });

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;
@@ -18,9 +20,22 @@ type ParsedToolCall = {
     name: string;
 };
 
-const HEADING_PATTERN = /^##\s+(.+)$/u;
+const HEADING_PATTERN = /^##\s+((?:User|Assistant|System|Event)|Tool:\s*.+)$/iu;
 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()) {
@@ -31,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) {
@@ -40,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();
@@ -56,6 +73,8 @@ const splitMarkdownSections = (markdown: string | null): MarkdownSection[] => {
         if (currentHeading) {
             currentLines.push(line);
         }
+
+        fence = updateMarkdownFence(fence, fenceToken);
     }
 
     flush();
@@ -72,7 +91,12 @@ const extractTimestamp = (body: string): { body: string; timestamp: string | nul
 };
 
 const sectionBodyBeforeSubheading = (body: string): string => {
-    return body.split(/^###\s+/mu)[0]?.trim() ?? '';
+    const lines = body.split(/\r?\n/u);
+    const controlIndex = lines.findIndex((line) => CONTROL_SUBHEADING_PATTERN.test(line.trim()));
+    return lines
+        .slice(0, controlIndex === -1 ? undefined : controlIndex)
+        .join('\n')
+        .trim();
 };
 
 const extractSubheadingBlock = (body: string, title: string): string => {
@@ -82,7 +106,9 @@ const extractSubheadingBlock = (body: string, title: string): string => {
         return '';
     }
 
-    const nextSubheadingIndex = lines.findIndex((line, index) => index > startIndex && line.startsWith('### '));
+    const nextSubheadingIndex = lines.findIndex(
+        (line, index) => index > startIndex && CONTROL_SUBHEADING_PATTERN.test(line.trim()),
+    );
     return lines
         .slice(startIndex + 1, nextSubheadingIndex === -1 ? undefined : nextSubheadingIndex)
         .join('\n')
@@ -187,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 = (
@@ -290,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-queries.ts

@@ -1,6 +1,7 @@
 import { queryOptions } from '@tanstack/react-query';
 import {
     getClaudeCodeSessionDetailFn,
+    getClaudeCodeSessionTranscriptFn,
     listClaudeCodeSessionsFn,
     listClaudeCodeWorkspacesFn,
 } from './claude-code-server';
@@ -24,3 +25,10 @@ export const claudeCodeSessionDetailQueryOptions = (sessionId: string | null) =>
         queryFn: () => getClaudeCodeSessionDetailFn({ data: { sessionId: sessionId ?? '' } }),
         queryKey: ['claude-code-session', sessionId ?? 'none'],
     });
+
+export const claudeCodeSessionTranscriptQueryOptions = (sessionId: string | null) =>
+    queryOptions({
+        enabled: sessionId !== null,
+        queryFn: () => getClaudeCodeSessionTranscriptFn({ data: { sessionId: sessionId ?? '' } }),
+        queryKey: ['claude-code-session-transcript', sessionId ?? 'none'],
+    });