spiracha 1.5.0 → 2.1.0

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

@@ -0,0 +1,243 @@
+import { createServerFn } from '@tanstack/react-start';
+import { z } from 'zod';
+import { renderSourceSessionDownload, renderSourceSessionsDownload } from './source-session-export-server';
+
+const LARGE_CLAUDE_CODE_SESSION_SIZE_BYTES = 8 * 1024 * 1024;
+const CLAUDE_CODE_DETAIL_PREVIEW_ENTRY_LIMIT = 400;
+const CLAUDE_CODE_DETAIL_PREVIEW_LEADING_ENTRY_LIMIT = 100;
+
+const workspaceSchema = z.object({
+    workspaceKey: z.string().min(1),
+});
+
+const sessionSchema = z.object({
+    sessionId: z.string().min(1),
+});
+
+const 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),
+});
+
+const exportSessionsSchema = z.object({
+    includeCommentary: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
+    outputFormat: z.enum(['md', 'txt']).default('md'),
+    sessionIds: z.array(z.string().min(1)).min(1),
+    zipArchive: z.boolean().default(true),
+});
+
+const deleteSessionsSchema = z.object({
+    sessionIds: z.array(z.string().min(1)).min(1),
+});
+
+export const listClaudeCodeWorkspacesFn = createServerFn({ method: 'GET' }).handler(async () => {
+    const { listClaudeCodeWorkspaceGroups } = await import('@spiracha/lib/claude-code-db');
+    return listClaudeCodeWorkspaceGroups();
+});
+
+export const listClaudeCodeSessionsFn = createServerFn({ method: 'GET' })
+    .validator(workspaceSchema)
+    .handler(async ({ data }) => {
+        const { listClaudeCodeSessionsForGroup } = await import('@spiracha/lib/claude-code-db');
+        return listClaudeCodeSessionsForGroup(data.workspaceKey);
+    });
+
+const loadClaudeCodeSessionTranscript = async (sessionId: string) => {
+    const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
+    const { readClaudeCodeSessionTranscript, resolveClaudeCodeProjectsDir } = await import(
+        '@spiracha/lib/claude-code-db'
+    );
+    const projectsDir = resolveClaudeCodeProjectsDir();
+    return runWithTranscriptLoadLimit(
+        async () => {
+            const transcript = await readClaudeCodeSessionTranscript(projectsDir, sessionId);
+            if (!transcript) {
+                throw new Error(`Claude Code session not found: ${sessionId}`);
+            }
+
+            return transcript;
+        },
+        {
+            id: sessionId,
+            path: projectsDir,
+            source: 'claude-code-ui',
+        },
+    );
+};
+
+export const buildClaudeCodeSessionDetailPreview = (
+    transcript: Awaited<ReturnType<typeof loadClaudeCodeSessionTranscript>>,
+) => {
+    if (transcript.entries.length <= CLAUDE_CODE_DETAIL_PREVIEW_ENTRY_LIMIT) {
+        return transcript;
+    }
+
+    const trailingEntryLimit = CLAUDE_CODE_DETAIL_PREVIEW_ENTRY_LIMIT - CLAUDE_CODE_DETAIL_PREVIEW_LEADING_ENTRY_LIMIT;
+    return {
+        ...transcript,
+        entries: [
+            ...transcript.entries.slice(0, CLAUDE_CODE_DETAIL_PREVIEW_LEADING_ENTRY_LIMIT),
+            ...transcript.entries.slice(-trailingEntryLimit),
+        ].map((entry) => ({
+            ...entry,
+            parts: entry.parts.map((part) => ({ ...part, raw: {} })),
+            raw: {},
+        })),
+        isPartial: true,
+        omittedEntryCount: transcript.entries.length - CLAUDE_CODE_DETAIL_PREVIEW_ENTRY_LIMIT,
+        rawEvents: [],
+        rawPayloadsOmitted: true,
+    };
+};
+
+export const loadClaudeCodeSessionDetail = async (sessionId: string) => {
+    const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
+    const { readClaudeCodeSessionTranscript, resolveClaudeCodeProjectsDir } = await import(
+        '@spiracha/lib/claude-code-db'
+    );
+    const projectsDir = resolveClaudeCodeProjectsDir();
+    return runWithTranscriptLoadLimit(
+        async () => {
+            const transcript = await readClaudeCodeSessionTranscript(projectsDir, sessionId, {
+                maxRawPayloadFileSizeBytes: LARGE_CLAUDE_CODE_SESSION_SIZE_BYTES,
+            });
+            if (!transcript) {
+                throw new Error(`Claude Code session not found: ${sessionId}`);
+            }
+
+            return buildClaudeCodeSessionDetailPreview(transcript);
+        },
+        {
+            id: sessionId,
+            path: projectsDir,
+            source: 'claude-code-ui-detail',
+        },
+    );
+};
+
+export const loadClaudeCodeSessionFullDetail = async (sessionId: string) => {
+    const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
+    const { readClaudeCodeSessionTranscript, resolveClaudeCodeProjectsDir } = await import(
+        '@spiracha/lib/claude-code-db'
+    );
+    const projectsDir = resolveClaudeCodeProjectsDir();
+    return runWithTranscriptLoadLimit(
+        async () => {
+            const transcript = await readClaudeCodeSessionTranscript(projectsDir, sessionId, {
+                includeRawPayloads: false,
+            });
+            if (!transcript) {
+                throw new Error(`Claude Code session not found: ${sessionId}`);
+            }
+            return transcript;
+        },
+        {
+            id: sessionId,
+            path: projectsDir,
+            source: 'claude-code-ui-full-detail',
+        },
+    );
+};
+
+export const getClaudeCodeSessionDetailFn = createServerFn({ method: 'GET' })
+    .validator(sessionSchema)
+    .handler(async ({ data }) => {
+        return loadClaudeCodeSessionDetail(data.sessionId);
+    });
+
+export const getClaudeCodeSessionTranscriptFn = createServerFn({ method: 'GET' })
+    .validator(sessionSchema)
+    .handler(async ({ data }) => {
+        return loadClaudeCodeSessionFullDetail(data.sessionId);
+    });
+
+export const exportClaudeCodeSessionFn = createServerFn({ method: 'POST' })
+    .validator(exportSessionSchema)
+    .handler(async ({ data }) => {
+        const { renderClaudeCodeTranscript } = await import('@spiracha/lib/claude-code-transcript');
+        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,
+            cwd: transcript.session.cwd ?? transcript.session.worktree,
+            fallbackBaseName: 'claude-code-session',
+            outputFormat: data.outputFormat,
+            sessionId: transcript.session.sessionId,
+            updatedAtMs: transcript.session.lastActiveAtMs,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const exportClaudeCodeSessionsFn = createServerFn({ method: 'POST' })
+    .validator(exportSessionsSchema)
+    .handler(async ({ data }) => {
+        const { renderClaudeCodeTranscript } = await import('@spiracha/lib/claude-code-transcript');
+        const entries = await Promise.all(
+            data.sessionIds.map(async (sessionId) => {
+                const transcript = await loadClaudeCodeSessionTranscript(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: ${sessionId}`);
+                }
+
+                return {
+                    content,
+                    cwd: transcript.session.cwd ?? transcript.session.worktree,
+                    fallbackBaseName: 'claude-code-session',
+                    fileBaseName: transcript.session.title || transcript.session.sessionId,
+                    sessionId: transcript.session.sessionId,
+                    updatedAtMs: transcript.session.lastActiveAtMs,
+                };
+            }),
+        );
+
+        return renderSourceSessionsDownload({
+            entries,
+            fallbackBaseName: 'claude-code-sessions',
+            outputFormat: data.outputFormat,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+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);
+    });
+
+export const deleteClaudeCodeSessionsFn = createServerFn({ method: 'POST' })
+    .validator(deleteSessionsSchema)
+    .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)),
+        );
+        return {
+            deletedFiles: [...new Set(results.flatMap((result) => result.deletedFiles))],
+            deletedSessionIds: [...new Set(results.flatMap((result) => result.deletedSessionIds))],
+        };
+    });

package/apps/ui/src/lib/claude-code-transcript-events.ts

@@ -0,0 +1,161 @@
+import type {
+    ClaudeCodeSessionTranscript,
+    ClaudeCodeTranscriptEntry,
+    ClaudeCodeTranscriptPart,
+} from '@spiracha/lib/claude-code-exporter-types';
+import {
+    getClaudeCodeAssistantMessagePhase,
+    isClaudeCodeSyntheticTranscriptEntry,
+} from '@spiracha/lib/claude-code-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';
+
+const buildRaw = (
+    entry: ClaudeCodeTranscriptEntry,
+    part: ClaudeCodeTranscriptPart,
+    eventType: string,
+): Record<string, JsonValue> => ({
+    entryId: entry.entryId,
+    eventType,
+    role: entry.role,
+    source: 'claude_code_local_jsonl',
+    type: part.type,
+    ...part.raw,
+});
+
+const buildMessageEvent = (
+    entry: ClaudeCodeTranscriptEntry,
+    part: ClaudeCodeTranscriptPart,
+    sequence: number,
+    text: string,
+): ThreadEvent => ({
+    isHiddenByDefault: entry.role !== 'assistant' && entry.role !== 'user',
+    kind: 'message',
+    memoryCitation: null,
+    model: entry.model ?? null,
+    phase: getClaudeCodeAssistantMessagePhase(entry),
+    raw: buildRaw(entry, part, 'message'),
+    role: entry.role,
+    sequence,
+    text,
+    timestamp: entry.timestamp,
+    variant: entry.role === 'user' ? 'user_message' : entry.role === 'assistant' ? 'agent_message' : 'message',
+});
+
+const buildReasoningEvent = (
+    entry: ClaudeCodeTranscriptEntry,
+    part: ClaudeCodeTranscriptPart,
+    sequence: number,
+): ThreadEvent | null => {
+    const text = part.text?.trim();
+    if (!text) {
+        return null;
+    }
+
+    return {
+        content: text,
+        hasEncryptedContent: false,
+        kind: 'reasoning',
+        raw: buildRaw(entry, part, 'reasoning'),
+        sequence,
+        summary: [text],
+        timestamp: entry.timestamp,
+    };
+};
+
+const buildToolCallCommand = (part: ClaudeCodeTranscriptPart): string => {
+    const toolName = part.toolName ?? 'unknown';
+    if (!part.argumentsText?.trim()) {
+        return toolName;
+    }
+
+    return `${toolName}\n${part.argumentsText}`;
+};
+
+const buildToolCallEvent = (
+    entry: ClaudeCodeTranscriptEntry,
+    part: ClaudeCodeTranscriptPart,
+    sequence: number,
+): ThreadEvent => ({
+    argumentsParseFailed: false,
+    argumentsText: part.argumentsText ?? null,
+    callId: part.toolUseId ?? null,
+    command: buildToolCallCommand(part),
+    kind: 'tool_call',
+    name: part.toolName ?? 'unknown',
+    raw: buildRaw(entry, part, 'tool_call'),
+    sequence,
+    timestamp: entry.timestamp,
+    workdir: entry.cwd,
+});
+
+const buildToolOutputEvent = (
+    entry: ClaudeCodeTranscriptEntry,
+    part: ClaudeCodeTranscriptPart,
+    sequence: number,
+): ThreadEvent | null => {
+    const outputText = part.outputText?.trim();
+    if (!outputText) {
+        return null;
+    }
+
+    return {
+        callId: part.toolUseId ?? null,
+        exitCode: part.isError ? 1 : null,
+        kind: 'tool_output',
+        outputText,
+        raw: buildRaw(entry, part, 'tool_output'),
+        sequence,
+        summary: outputText,
+        timestamp: entry.timestamp,
+        wallTime: null,
+    };
+};
+
+const partToEvents = (
+    entry: ClaudeCodeTranscriptEntry,
+    part: ClaudeCodeTranscriptPart,
+    sequence: number,
+): ThreadEvent[] => {
+    if (part.type === 'text' || part.type === 'attachment') {
+        const text = part.text?.trim();
+        return text ? [buildMessageEvent(entry, part, sequence, text)] : [];
+    }
+
+    if (part.type === 'thinking') {
+        const event = buildReasoningEvent(entry, part, sequence);
+        return event ? [event] : [];
+    }
+
+    if (part.type === 'tool_use') {
+        return [buildToolCallEvent(entry, part, sequence)];
+    }
+
+    if (part.type === 'tool_result') {
+        const event = buildToolOutputEvent(entry, part, sequence);
+        return event ? [event] : [];
+    }
+
+    return [];
+};
+
+export const claudeCodeTranscriptToThreadEvents = (transcript: ClaudeCodeSessionTranscript): ThreadEvent[] => {
+    const events: ThreadEvent[] = [];
+    let sequence = 0;
+    for (const entry of transcript.entries) {
+        if (isClaudeCodeSyntheticTranscriptEntry(entry)) {
+            continue;
+        }
+
+        for (const part of entry.parts) {
+            events.push(...partToEvents(entry, part, sequence));
+            sequence += 1;
+        }
+    }
+    return events;
+};
+
+export const getClaudeCodeThreadTranscriptStats = (events: ThreadEvent[]): ThreadTranscriptStats => {
+    return getThreadTranscriptStats(events);
+};

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

@@ -0,0 +1,82 @@
+import { isRetryableSqliteError } from '@spiracha/lib/sqlite-error';
+import { queryOptions } from '@tanstack/react-query';
+import {
+    getAnalyticsFn,
+    getDashboardSummaryFn,
+    getThreadSnapshotFn,
+    getThreadTranscriptFn,
+    getThreadTranscriptPreviewFn,
+    listProjectsFn,
+    listProjectThreadsFn,
+} from './codex-server';
+
+type ThreadTranscriptFilters = {
+    showCommentary: boolean;
+    showExtraEvents: boolean;
+    showToolCalls: boolean;
+    showUserMessages: boolean;
+};
+
+const retrySqliteQuery = (failureCount: number, error: unknown) => {
+    return failureCount < 3 && isRetryableSqliteError(error);
+};
+
+const retryDelay = (attemptIndex: number) => {
+    return [150, 400][attemptIndex] ?? 800;
+};
+
+export const dashboardQueryOptions = () =>
+    queryOptions({
+        queryFn: () => getDashboardSummaryFn(),
+        queryKey: ['dashboard'],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });
+
+export const projectsQueryOptions = () =>
+    queryOptions({
+        queryFn: () => listProjectsFn(),
+        queryKey: ['projects'],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });
+
+export const projectThreadsQueryOptions = (project: string) =>
+    queryOptions({
+        queryFn: () => listProjectThreadsFn({ data: { project } }),
+        queryKey: ['project-threads', project],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });
+
+export const threadSnapshotQueryOptions = (threadId: string, filters?: ThreadTranscriptFilters) =>
+    queryOptions({
+        queryFn: () => getThreadSnapshotFn({ data: { filters, threadId } }),
+        queryKey: ['thread', threadId, filters ?? 'all'],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });
+
+export const threadTranscriptPreviewQueryOptions = (threadId: string, filters?: ThreadTranscriptFilters) =>
+    queryOptions({
+        queryFn: () => getThreadTranscriptPreviewFn({ data: { filters, threadId } }),
+        queryKey: ['thread-transcript-preview', threadId, filters ?? 'all'],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });
+
+export const threadTranscriptQueryOptions = (threadId: string) =>
+    queryOptions({
+        queryFn: () => getThreadTranscriptFn({ data: { threadId } }),
+        queryKey: ['thread-transcript', threadId],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });
+
+export const analyticsQueryOptions = (project: string | null) =>
+    queryOptions({
+        queryFn: () => getAnalyticsFn({ data: { project } }),
+        queryKey: ['analytics', project ?? 'all'],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });