spiracha 1.5.0 → 2.1.0

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

@@ -0,0 +1,273 @@
+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';
+
+const workspaceSchema = z.object({
+    workspaceKey: z.string().min(1),
+});
+
+const conversationSchema = z.object({
+    conversationId: z.string().min(1),
+});
+
+const exportSchema = z.object({
+    conversationId: z.string().min(1),
+});
+
+const exportConversationsSchema = z.object({
+    conversationIds: z.array(z.string().min(1)).min(1),
+    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 () => {
+    const { listAntigravityWorkspaceGroups } = await import('@spiracha/lib/antigravity-db');
+    return listAntigravityWorkspaceGroups();
+});
+
+export const getAntigravityDecryptionStateFn = createServerFn({ method: 'GET' }).handler(async () => {
+    const { getAntigravityDecryptionState } = await import('@spiracha/lib/antigravity-keychain');
+    return getAntigravityDecryptionState();
+});
+
+export const unlockAntigravityDecryptionFn = createServerFn({ method: 'POST' }).handler(async () => {
+    const { unlockAntigravityDecryption } = await import('@spiracha/lib/antigravity-keychain');
+    return unlockAntigravityDecryption();
+});
+
+export const listAntigravityConversationsFn = createServerFn({ method: 'GET' })
+    .validator(workspaceSchema)
+    .handler(async ({ data }) => {
+        const { listAntigravityConversationsForGroup } = await import('@spiracha/lib/antigravity-db');
+        return listAntigravityConversationsForGroup(data.workspaceKey);
+    });
+
+const findAntigravityConversationById = async (conversationId: string) => {
+    const { listAntigravityConversations } = await import('@spiracha/lib/antigravity-db');
+    const conversation = (await listAntigravityConversations()).find(
+        (candidate) => candidate.conversationId === conversationId,
+    );
+    if (!conversation) {
+        throw new Error(`Antigravity conversation not found: ${conversationId}`);
+    }
+
+    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'
+    );
+    const { getCachedAntigravityKeychainSecret } = await import('@spiracha/lib/antigravity-keychain');
+    const conversation = await findAntigravityConversationById(conversationId);
+    const keychainSecret = getCachedAntigravityKeychainSecret();
+    const hasKeychainSecret = Boolean(keychainSecret);
+    const transcriptLocked = isAntigravityConversationLocked(conversation, hasKeychainSecret);
+    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) => {
+    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 keychainSecret = getCachedAntigravityKeychainSecret();
+    const hasKeychainSecret = Boolean(keychainSecret);
+
+    if (!canExportAntigravityConversation(conversation, hasKeychainSecret)) {
+        if (isAntigravityConversationLocked(conversation, hasKeychainSecret)) {
+            throw new Error('Unlock Antigravity Keychain access before exporting transcript logs.');
+        }
+
+        throw new Error(`No exportable Antigravity transcript found for conversation: ${conversationId}`);
+    }
+
+    const content = await runWithTranscriptLoadLimit(
+        () =>
+            renderAntigravityConversationMarkdown(conversation, {
+                keychainSecret,
+            }),
+        {
+            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,
+        conversation,
+        filename: `${buildConversationExportBaseName(
+            {
+                cwd: conversation.workspaceFolder,
+                id: conversation.conversationId,
+                updatedAtMs: conversation.lastUpdatedAtMs ?? conversation.conversationMtimeMs,
+            },
+            'antigravity-conversation',
+        )}.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 Promise.all(
+        conversationIds.map((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),
+    };
+};
+
+export const getAntigravityConversationDetailFn = createServerFn({ method: 'GET' })
+    .validator(conversationSchema)
+    .handler(async ({ data }) => {
+        return loadAntigravityConversationDetail(data.conversationId);
+    });
+
+export const exportAntigravityArtifactsFn = createServerFn({ method: 'POST' })
+    .validator(exportSchema)
+    .handler(async ({ data }) => {
+        const { renderAntigravityArtifactsMarkdown } = await import('@spiracha/lib/antigravity-db');
+        const conversation = await findAntigravityConversationById(data.conversationId);
+
+        const content = await renderAntigravityArtifactsMarkdown(conversation);
+        if (!content) {
+            throw new Error(`No Markdown artifacts found for conversation: ${data.conversationId}`);
+        }
+
+        return {
+            content,
+            filename: `${data.conversationId}-artifacts.md`,
+        };
+    });
+
+export const exportAntigravityConversationFn = createServerFn({ method: 'POST' })
+    .validator(exportSchema)
+    .handler(async ({ data }) => {
+        return loadAntigravityConversationExport(data.conversationId);
+    });
+
+export const exportAntigravityConversations = async (data: z.infer<typeof exportConversationsSchema>) => {
+    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 entries = await Promise.all(
+        data.conversationIds.map(async (conversationId) => {
+            const result = await loadAntigravityConversationExport(conversationId);
+            const conversation = result.conversation;
+            const projectGroup = conversation.projectId
+                ? groupsByKey.get(`project:${conversation.projectId}`)
+                : undefined;
+            const exportCwd = projectGroup?.label ?? 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

@@ -0,0 +1,343 @@
+import type { ThreadEvent, ThreadTranscriptStats } from '@spiracha/lib/codex-browser-types';
+import type { JsonValue } from '@spiracha/lib/shared';
+
+type MarkdownSection = {
+    body: string;
+    heading: string;
+    sequence: number;
+};
+
+type ParsedAssistantSection = {
+    content: string;
+    thinking: string;
+    toolCalls: ParsedToolCall[];
+};
+
+type ParsedToolCall = {
+    argumentsText: string | null;
+    name: string;
+};
+
+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;
+
+const splitMarkdownSections = (markdown: string | null): MarkdownSection[] => {
+    if (!markdown?.trim()) {
+        return [];
+    }
+
+    const sections: MarkdownSection[] = [];
+    const lines = markdown.split(/\r?\n/u);
+    let currentHeading: string | null = null;
+    let currentLines: string[] = [];
+
+    const flush = () => {
+        if (!currentHeading) {
+            return;
+        }
+
+        sections.push({
+            body: currentLines.join('\n').trim(),
+            heading: currentHeading,
+            sequence: sections.length * 10,
+        });
+    };
+
+    for (const line of lines) {
+        const heading = HEADING_PATTERN.exec(line);
+        if (heading) {
+            flush();
+            currentHeading = heading[1]!.trim();
+            currentLines = [];
+            continue;
+        }
+
+        if (currentHeading) {
+            currentLines.push(line);
+        }
+    }
+
+    flush();
+    return sections;
+};
+
+const extractTimestamp = (body: string): { body: string; timestamp: string | null } => {
+    const lines = body.split(/\r?\n/u);
+    const timestamp = TIMESTAMP_PATTERN.exec(lines[0]?.trim() ?? '')?.[1]?.trim() ?? null;
+    return {
+        body: timestamp ? lines.slice(1).join('\n').trim() : body.trim(),
+        timestamp,
+    };
+};
+
+const sectionBodyBeforeSubheading = (body: string): string => {
+    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 => {
+    const lines = body.split(/\r?\n/u);
+    const startIndex = lines.findIndex((line) => line.trim().toLowerCase() === `### ${title.toLowerCase()}`);
+    if (startIndex === -1) {
+        return '';
+    }
+
+    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')
+        .trim();
+};
+
+const parseToolCalls = (body: string): ParsedToolCall[] => {
+    const toolCallsBlock = extractSubheadingBlock(body, 'Tool Calls');
+    if (!toolCallsBlock) {
+        return [];
+    }
+
+    const calls: ParsedToolCall[] = [];
+    const callPattern = /-\s+`([^`]+)`(?:\s*\n+```json\s*\n([\s\S]*?)\n```)?/gu;
+    for (const match of toolCallsBlock.matchAll(callPattern)) {
+        calls.push({
+            argumentsText: match[2]?.trim() ?? null,
+            name: match[1]?.trim() || 'unknown',
+        });
+    }
+
+    return calls;
+};
+
+const parseAssistantSection = (body: string): ParsedAssistantSection => {
+    const content = sectionBodyBeforeSubheading(body);
+    const thinkingBlock = extractSubheadingBlock(body, 'Thinking');
+    const [thinking, ...remainingThinkingBlock] = thinkingBlock.split(/\n{2,}/u).map((entry) => entry.trim());
+
+    return {
+        content: content || remainingThinkingBlock.join('\n\n').trim(),
+        thinking: thinking ?? '',
+        toolCalls: parseToolCalls(body),
+    };
+};
+
+const buildRaw = (section: MarkdownSection, extra: Record<string, JsonValue> = {}): Record<string, JsonValue> => ({
+    heading: section.heading,
+    source: 'antigravity_markdown',
+    ...extra,
+});
+
+const buildMessageEvent = (
+    section: MarkdownSection,
+    role: string,
+    text: string,
+    timestamp: string | null,
+    phase: string | null,
+    sequenceOffset = 0,
+): ThreadEvent => ({
+    isHiddenByDefault: role !== 'assistant' && role !== 'user',
+    kind: 'message',
+    memoryCitation: null,
+    model: null,
+    phase,
+    raw: buildRaw(section, { role }),
+    role,
+    sequence: section.sequence + sequenceOffset,
+    text,
+    timestamp,
+    variant: role === 'user' ? 'user_message' : role === 'assistant' ? 'agent_message' : 'message',
+});
+
+const buildToolCallEvent = (
+    section: MarkdownSection,
+    toolCall: ParsedToolCall,
+    timestamp: string | null,
+    sequenceOffset: number,
+): ThreadEvent => ({
+    argumentsParseFailed: false,
+    argumentsText: toolCall.argumentsText,
+    callId: null,
+    command: [toolCall.name, toolCall.argumentsText].filter(Boolean).join('\n'),
+    kind: 'tool_call',
+    name: toolCall.name,
+    raw: buildRaw(section, {
+        argumentsText: toolCall.argumentsText,
+        name: toolCall.name,
+    }),
+    sequence: section.sequence + sequenceOffset,
+    timestamp,
+    workdir: null,
+});
+
+const buildToolOutputEvent = (
+    section: MarkdownSection,
+    toolName: string,
+    outputText: string,
+    timestamp: string | null,
+): ThreadEvent => ({
+    callId: null,
+    exitCode: null,
+    kind: 'tool_output',
+    outputText,
+    raw: buildRaw(section, {
+        name: toolName,
+    }),
+    sequence: section.sequence,
+    summary: outputText,
+    timestamp,
+    wallTime: null,
+});
+
+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 heading = section.heading.toLowerCase();
+        if (heading === 'user') {
+            flushAssistantRun();
+            continue;
+        }
+
+        if (heading !== 'assistant') {
+            continue;
+        }
+
+        const { body } = extractTimestamp(section.body);
+        const parsed = parseAssistantSection(body);
+        if (parsed.toolCalls.length > 0) {
+            currentAssistantContentSequence = null;
+        } else if (parsed.content) {
+            currentAssistantContentSequence = section.sequence;
+        }
+    }
+
+    flushAssistantRun();
+    return finalAssistantSectionSequences;
+};
+
+const textSectionToEvents = (
+    section: MarkdownSection,
+    role: string,
+    body: string,
+    timestamp: string | null,
+): ThreadEvent[] => {
+    return body ? [buildMessageEvent(section, role, body, timestamp, null)] : [];
+};
+
+const toolOutputSectionToEvents = (
+    section: MarkdownSection,
+    toolName: string,
+    body: string,
+    timestamp: string | null,
+): ThreadEvent[] => {
+    return body ? [buildToolOutputEvent(section, toolName, body, timestamp)] : [];
+};
+
+const assistantSectionToEvents = (
+    section: MarkdownSection,
+    body: string,
+    timestamp: string | null,
+    finalAssistantSectionSequences: Set<number>,
+): ThreadEvent[] => {
+    const parsed = parseAssistantSection(body);
+    const events: ThreadEvent[] = [];
+    if (parsed.thinking) {
+        events.push(buildMessageEvent(section, 'assistant', parsed.thinking, timestamp, 'commentary'));
+    }
+    if (parsed.content) {
+        const phase = finalAssistantSectionSequences.has(section.sequence) ? 'final_answer' : 'commentary';
+        events.push(buildMessageEvent(section, 'assistant', parsed.content, timestamp, phase, 1));
+    }
+    parsed.toolCalls.forEach((toolCall, index) => {
+        events.push(buildToolCallEvent(section, toolCall, timestamp, 2 + index));
+    });
+    return events;
+};
+
+const sectionToEvents = (section: MarkdownSection, finalAssistantSectionSequences: Set<number>): ThreadEvent[] => {
+    const { body, timestamp } = extractTimestamp(section.body);
+    const heading = section.heading.toLowerCase();
+    const toolHeading = TOOL_HEADING_PATTERN.exec(section.heading);
+
+    if (heading === 'user') {
+        return textSectionToEvents(section, 'user', body, timestamp);
+    }
+
+    if (toolHeading) {
+        return toolOutputSectionToEvents(section, toolHeading[1]?.trim() || 'unknown', body, timestamp);
+    }
+
+    if (heading === 'assistant') {
+        return assistantSectionToEvents(section, body, timestamp, finalAssistantSectionSequences);
+    }
+
+    if (heading === 'system') {
+        return textSectionToEvents(section, 'system', body, timestamp);
+    }
+
+    return textSectionToEvents(section, 'event', body, timestamp);
+};
+
+export const antigravityMarkdownToThreadEvents = (markdown: string | null): ThreadEvent[] => {
+    const sections = splitMarkdownSections(markdown);
+    const finalAssistantSectionSequences = getFinalAssistantSectionSequences(sections);
+    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;
+};

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

@@ -0,0 +1,34 @@
+import { queryOptions } from '@tanstack/react-query';
+import {
+    getClaudeCodeSessionDetailFn,
+    getClaudeCodeSessionTranscriptFn,
+    listClaudeCodeSessionsFn,
+    listClaudeCodeWorkspacesFn,
+} from './claude-code-server';
+
+export const claudeCodeWorkspacesQueryOptions = () =>
+    queryOptions({
+        queryFn: () => listClaudeCodeWorkspacesFn(),
+        queryKey: ['claude-code-workspaces'],
+    });
+
+export const claudeCodeSessionsQueryOptions = (workspaceKey: string | null) =>
+    queryOptions({
+        enabled: workspaceKey !== null,
+        queryFn: () => listClaudeCodeSessionsFn({ data: { workspaceKey: workspaceKey ?? '' } }),
+        queryKey: ['claude-code-sessions', workspaceKey ?? 'none'],
+    });
+
+export const claudeCodeSessionDetailQueryOptions = (sessionId: string | null) =>
+    queryOptions({
+        enabled: sessionId !== 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'],
+    });