spiracha 1.4.0 → 2.0.0

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

@@ -0,0 +1,154 @@
+import type {
+    ClaudeCodeSessionTranscript,
+    ClaudeCodeTranscriptEntry,
+    ClaudeCodeTranscriptPart,
+} from '@spiracha/lib/claude-code-exporter-types';
+import { getClaudeCodeAssistantMessagePhase } 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) {
+        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,66 @@
+import { isRetryableSqliteError } from '@spiracha/lib/sqlite-error';
+import { queryOptions } from '@tanstack/react-query';
+import {
+    getAnalyticsFn,
+    getDashboardSummaryFn,
+    getThreadSnapshotFn,
+    getThreadTranscriptFn,
+    listProjectsFn,
+    listProjectThreadsFn,
+} from './codex-server';
+
+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) =>
+    queryOptions({
+        queryFn: () => getThreadSnapshotFn({ data: { threadId } }),
+        queryKey: ['thread', threadId],
+        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,
+    });

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

@@ -0,0 +1,209 @@
+import { getCodexAnalytics } from '@spiracha/lib/codex-analytics';
+import {
+    deleteCodexProject,
+    deleteCodexThread,
+    deleteCodexThreads,
+    getCodexDashboardSummary,
+    getThreadBrowseData,
+    listCodexProjects,
+    listProjectThreads,
+    resolveCodexThreadDbPath,
+} from '@spiracha/lib/codex-browser-db';
+import { renderCodexThreadDownload, renderCodexThreadsDownload } from '@spiracha/lib/codex-browser-export';
+import {
+    getCachedParsedCodexTranscript,
+    getCachedThreadTranscriptPreview,
+    getThreadRolloutLoadState,
+} from '@spiracha/lib/codex-thread-cache';
+import { recoverCodexProjectThreads } from '@spiracha/lib/codex-thread-recovery';
+import { createServerFn } from '@tanstack/react-start';
+import { z } from 'zod';
+
+const projectSchema = z.object({
+    project: z.string().min(1),
+});
+
+const deleteProjectSchema = z.object({
+    deleteSessionFiles: z.boolean().default(false),
+    project: z.string().min(1),
+});
+
+const threadSchema = z.object({
+    threadId: z.string().min(1),
+});
+
+const deleteThreadSchema = z.object({
+    deleteSessionFiles: z.boolean().default(false),
+    threadId: z.string().min(1),
+});
+
+const deleteThreadsSchema = z.object({
+    deleteSessionFiles: z.boolean().default(false),
+    threadIds: z.array(z.string().min(1)).min(1),
+});
+
+const analyticsSchema = z.object({
+    project: z.string().min(1).nullable(),
+});
+
+const exportSchema = z.object({
+    convertToProjectRoot: z.boolean(),
+    includeCommentary: z.boolean(),
+    includeMetadata: z.boolean(),
+    includeTools: z.boolean(),
+    outputFormat: z.enum(['md', 'txt']),
+    redactUsername: z.boolean(),
+    threadId: z.string().min(1),
+    zipArchive: z.boolean().default(false),
+});
+
+const exportThreadsSchema = z.object({
+    convertToProjectRoot: z.boolean(),
+    includeCommentary: z.boolean(),
+    includeMetadata: z.boolean(),
+    includeTools: z.boolean(),
+    outputFormat: z.enum(['md', 'txt']),
+    redactUsername: z.boolean(),
+    threadIds: z.array(z.string().min(1)).min(1),
+    zipArchive: z.boolean().default(true),
+});
+
+const getDbPath = () => process.env.SPIRACHA_CODEX_DB?.trim() || resolveCodexThreadDbPath();
+
+const isMissingFileError = (error: unknown) => {
+    return error instanceof Error && /ENOENT|no such file/i.test(error.message);
+};
+
+export const getDashboardSummaryFn = createServerFn({ method: 'GET' }).handler(async () => {
+    return getCodexDashboardSummary(getDbPath());
+});
+
+export const listProjectsFn = createServerFn({ method: 'GET' }).handler(async () => {
+    return listCodexProjects(getDbPath());
+});
+
+export const listProjectThreadsFn = createServerFn({ method: 'GET' })
+    .validator(projectSchema)
+    .handler(async ({ data }) => {
+        return listProjectThreads(getDbPath(), data.project, {
+            includeTranscriptStats: false,
+        });
+    });
+
+export const getThreadSnapshotFn = createServerFn({ method: 'GET' })
+    .validator(threadSchema)
+    .handler(async ({ data }) => {
+        const dbPath = getDbPath();
+        const browseData = getThreadBrowseData(dbPath, data.threadId);
+        const rollout = await getThreadRolloutLoadState(browseData.thread.rollout_path);
+        let transcript = null;
+        let transcriptState: 'available' | 'deferred' | 'missing' = rollout.shouldDeferTranscriptLoad
+            ? 'deferred'
+            : 'available';
+
+        if (!rollout.shouldDeferTranscriptLoad) {
+            try {
+                transcript = await getCachedParsedCodexTranscript(browseData.thread.rollout_path);
+            } catch (error) {
+                if (!isMissingFileError(error)) {
+                    throw error;
+                }
+
+                transcriptState = 'missing';
+            }
+        }
+
+        return {
+            ...browseData,
+            availableTools:
+                browseData.dynamicTools.length > 0
+                    ? browseData.dynamicTools
+                    : (transcript?.sessionMeta.dynamicTools ?? []),
+            rollout,
+            transcript,
+            transcriptState,
+        };
+    });
+
+export const getThreadTranscriptFn = createServerFn({ method: 'GET' })
+    .validator(threadSchema)
+    .handler(async ({ data }) => {
+        const dbPath = getDbPath();
+        const browseData = getThreadBrowseData(dbPath, data.threadId);
+        return getCachedThreadTranscriptPreview(browseData.thread.rollout_path);
+    });
+
+export const getAnalyticsFn = createServerFn({ method: 'GET' })
+    .validator(analyticsSchema)
+    .handler(async ({ data }) => {
+        return getCodexAnalytics({
+            dbPath: getDbPath(),
+            project: data.project,
+        });
+    });
+
+export const exportThreadFn = createServerFn({ method: 'POST' })
+    .validator(exportSchema)
+    .handler(async ({ data }) => {
+        return renderCodexThreadDownload({
+            dbPath: getDbPath(),
+            includeCommentary: data.includeCommentary,
+            includeMetadata: data.includeMetadata,
+            includeTools: data.includeTools,
+            outputFormat: data.outputFormat,
+            pathDisplaySettings: {
+                convertToProjectRoot: data.convertToProjectRoot,
+                redactUsername: data.redactUsername,
+            },
+            threadId: data.threadId,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const exportThreadsFn = createServerFn({ method: 'POST' })
+    .validator(exportThreadsSchema)
+    .handler(async ({ data }) => {
+        return renderCodexThreadsDownload({
+            dbPath: getDbPath(),
+            includeCommentary: data.includeCommentary,
+            includeMetadata: data.includeMetadata,
+            includeTools: data.includeTools,
+            outputFormat: data.outputFormat,
+            pathDisplaySettings: {
+                convertToProjectRoot: data.convertToProjectRoot,
+                redactUsername: data.redactUsername,
+            },
+            threadIds: data.threadIds,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const deleteThreadFn = createServerFn({ method: 'POST' })
+    .validator(deleteThreadSchema)
+    .handler(async ({ data }) => {
+        return deleteCodexThread(getDbPath(), data.threadId, {
+            deleteSessionFiles: data.deleteSessionFiles,
+        });
+    });
+
+export const deleteThreadsFn = createServerFn({ method: 'POST' })
+    .validator(deleteThreadsSchema)
+    .handler(async ({ data }) => {
+        return deleteCodexThreads(getDbPath(), data.threadIds, {
+            deleteSessionFiles: data.deleteSessionFiles,
+        });
+    });
+
+export const deleteProjectFn = createServerFn({ method: 'POST' })
+    .validator(deleteProjectSchema)
+    .handler(async ({ data }) => {
+        return deleteCodexProject(getDbPath(), data.project, {
+            deleteSessionFiles: data.deleteSessionFiles,
+        });
+    });
+
+export const recoverProjectThreadsFn = createServerFn({ method: 'POST' })
+    .validator(projectSchema)
+    .handler(async ({ data }) => {
+        return recoverCodexProjectThreads(getDbPath(), data.project);
+    });

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

@@ -0,0 +1,37 @@
+import { isRetryableSqliteError } from '@spiracha/lib/sqlite-error';
+import { queryOptions } from '@tanstack/react-query';
+import { getCursorThreadDetailFn, listCursorThreadsFn, listCursorWorkspacesFn } from './cursor-server';
+
+const retrySqliteQuery = (failureCount: number, error: unknown) => {
+    return failureCount < 3 && isRetryableSqliteError(error);
+};
+
+const retryDelay = (attemptIndex: number) => {
+    return [150, 400][attemptIndex] ?? 800;
+};
+
+export const cursorWorkspacesQueryOptions = () =>
+    queryOptions({
+        queryFn: () => listCursorWorkspacesFn(),
+        queryKey: ['cursor-workspaces'],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });
+
+export const cursorThreadsQueryOptions = (workspaceKey: string | null) =>
+    queryOptions({
+        enabled: workspaceKey !== null,
+        queryFn: () => listCursorThreadsFn({ data: { workspaceKey: workspaceKey ?? '' } }),
+        queryKey: ['cursor-threads', workspaceKey ?? 'none'],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });
+
+export const cursorThreadDetailQueryOptions = (composerId: string | null) =>
+    queryOptions({
+        enabled: composerId !== null,
+        queryFn: () => getCursorThreadDetailFn({ data: { composerId: composerId ?? '' } }),
+        queryKey: ['cursor-thread', composerId ?? 'none'],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });