spiracha 2.0.0 → 2.2.0

package/src/lib/conversation-data/antigravity-adapter.ts

@@ -1,8 +1,21 @@
-import { listAntigravityConversations, readAntigravityConversationMessages } from '../antigravity-db';
+import {
+    deleteAntigravityConversation,
+    listAntigravityConversations,
+    readAntigravityConversationMessages,
+} from '../antigravity-db';
 import type { AntigravityConversation } from '../antigravity-exporter-types';
 import { resolveAntigravityRoots } from '../antigravity-exporter-types';
+import { mapWithConcurrency } from '../concurrency';
 import { cleanInlineTitle } from '../shared';
-import { createDeepLinks, decodeFileUri, finalizeMessages } from './adapter-helpers';
+import { runWithTranscriptLoadLimit } from '../transcript-load-limiter';
+import { getFileFingerprint, hashCacheKeyPartsIterable, withCachedJson } from '../ui-cache';
+import {
+    createConversationUiPath,
+    createDeepLinks,
+    decodeFileUri,
+    finalizeMessages,
+    isWithinUpdatedWindow,
+} from './adapter-helpers';
 import { selectConversationMessages } from './message-selector';
 import { getConversationPathMatch, getFirstConversationPathMatch } from './path-match';
 import type {
@@ -10,6 +23,7 @@ import type {
     ConversationDetail,
     ConversationMessage,
     ConversationPathMatch,
+    DeleteConversationOptions,
     GetConversationOptions,
     ListConversationsForPathOptions,
 } from './types';
@@ -21,18 +35,33 @@ const getWorkspacePath = (conversation: AntigravityConversation) =>
     conversation.workspaceFolder ?? decodeFileUri(conversation.workspaceUri);
 
 const stripTrailingPathPunctuation = (value: string) => value.replace(/[),.;:\]`]+$/u, '');
+const PATH_REFERENCE_FALLBACK_LIMIT = 100;
+const PATH_REFERENCE_CONCURRENCY = 4;
 
 const extractAbsolutePathReferences = (text: string): string[] => {
     return [...new Set((text.match(/\/[^\s"'`)\]]+/gu) ?? []).map(stripTrailingPathPunctuation))];
 };
 
 const readMessages = async (conversation: AntigravityConversation) => {
-    const messages = await readAntigravityConversationMessages(conversation);
+    const load = () =>
+        runWithTranscriptLoadLimit(() => readAntigravityConversationMessages(conversation), {
+            id: conversation.conversationId,
+            path: conversation.transcriptPath ?? conversation.conversationPath ?? undefined,
+            source: 'antigravity-api',
+        });
+    const transcriptPath = conversation.transcriptPath;
+    const messages = transcriptPath
+        ? await getFileFingerprint(transcriptPath)
+              .then((fingerprint) =>
+                  withCachedJson(`antigravity-api-messages-${hashCacheKeyPartsIterable([fingerprint])}`, load),
+              )
+              .catch(load)
+        : await load();
     return finalizeMessages(
         messages.map(
-            (message): ConversationMessage => ({
+            (message, entryIndex): ConversationMessage => ({
                 ...message,
-                id: `${conversation.conversationId}:${message.order}:${message.role}:${message.phase}`,
+                id: `${conversation.conversationId}:${message.order}:${message.role}:${message.phase}:${entryIndex}`,
                 metadata: {
                     ...message.metadata,
                     model: conversation.model,
@@ -60,7 +89,7 @@ const buildConversation = async (
         deepLinks: createDeepLinks(
             'antigravity',
             conversation.conversationId,
-            `/antigravity-conversations/${conversation.conversationId}`,
+            createConversationUiPath('antigravity-conversations', conversation.conversationId),
         ),
         id: conversation.conversationId,
         matches,
@@ -80,20 +109,6 @@ const buildConversation = async (
     };
 };
 
-const isWithinUpdatedWindow = (
-    conversation: AntigravityConversation,
-    options: Pick<ListConversationsForPathOptions, 'updatedAfterMs' | 'updatedBeforeMs'>,
-) => {
-    const updatedAtMs = conversation.lastUpdatedAtMs ?? conversation.conversationMtimeMs ?? 0;
-    if (options.updatedAfterMs !== undefined && updatedAtMs < options.updatedAfterMs) {
-        return false;
-    }
-    if (options.updatedBeforeMs !== undefined && updatedAtMs > options.updatedBeforeMs) {
-        return false;
-    }
-    return true;
-};
-
 const getReferencedPathMatch = async (
     requestedPath: string,
     messages: ConversationMessage[],
@@ -106,9 +121,10 @@ const listAntigravityConversationsForPath = async (options: ListConversationsFor
     const roots = getRoots(options);
     const conversations = await listAntigravityConversations(roots);
     const result: ConversationDetail[] = [];
+    const pathReferenceCandidates: AntigravityConversation[] = [];
 
     for (const conversation of conversations) {
-        if (!isWithinUpdatedWindow(conversation, options)) {
+        if (!isWithinUpdatedWindow(conversation.lastUpdatedAtMs ?? conversation.conversationMtimeMs, options)) {
             continue;
         }
 
@@ -119,13 +135,32 @@ const listAntigravityConversationsForPath = async (options: ListConversationsFor
             continue;
         }
 
-        const messages = await readMessages(conversation);
-        const referencedPathMatch = await getReferencedPathMatch(options.cwd, messages);
-        if (referencedPathMatch) {
-            result.push(await buildConversation(conversation, [referencedPathMatch], options, messages));
-        }
+        pathReferenceCandidates.push(conversation);
     }
 
+    const referencedConversations = await mapWithConcurrency(
+        pathReferenceCandidates.slice(0, PATH_REFERENCE_FALLBACK_LIMIT),
+        PATH_REFERENCE_CONCURRENCY,
+        async (conversation) => {
+            let messages: ConversationMessage[];
+            try {
+                messages = await readMessages(conversation);
+            } catch (error) {
+                console.warn('[spiracha:antigravity] skipped unreadable path-reference transcript', {
+                    conversationId: conversation.conversationId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return null;
+            }
+            const referencedPathMatch = await getReferencedPathMatch(options.cwd, messages);
+            if (referencedPathMatch) {
+                return buildConversation(conversation, [referencedPathMatch], options, messages);
+            }
+            return null;
+        },
+    );
+    result.push(...referencedConversations.flatMap((conversation) => (conversation ? [conversation] : [])));
+
     return result;
 };
 
@@ -141,7 +176,16 @@ const getAntigravityConversation = async (options: GetConversationOptions): Prom
         : null;
 };
 
+const deleteAntigravityConversationById = async (options: DeleteConversationOptions) => {
+    const result = await deleteAntigravityConversation(getRoots(options), options.id);
+    return {
+        deletedFiles: result.deletedPaths,
+        deletedIds: result.deletedConversationIds,
+    };
+};
+
 export const antigravityConversationAdapter: ConversationAdapter = {
+    deleteConversation: deleteAntigravityConversationById,
     getConversation: getAntigravityConversation,
     listConversationsForPath: listAntigravityConversationsForPath,
     source: 'antigravity',

package/src/lib/conversation-data/claude-code-adapter.ts

@@ -1,5 +1,6 @@
 import {
-    listClaudeCodeSessionsForGroup,
+    deleteClaudeCodeSession,
+    listClaudeCodeSessionTranscriptsForGroup,
     listClaudeCodeWorkspaceGroups,
     readClaudeCodeSessionTranscript,
 } from '../claude-code-db';
@@ -10,11 +11,15 @@ import type {
     ClaudeCodeTranscriptPart,
 } from '../claude-code-exporter-types';
 import { getClaudeCodeAssistantMessagePhase, resolveClaudeCodeProjectsDir } from '../claude-code-exporter-types';
+import { mapWithConcurrency } from '../concurrency';
 import { cleanInlineTitle } from '../shared';
+import { runWithTranscriptLoadLimit } from '../transcript-load-limiter';
 import {
+    createConversationUiPath,
     createDeepLinks,
     createTextMessage,
     finalizeMessages,
+    isWithinUpdatedWindow,
     normalizeAssistantPhase,
     normalizeRole,
     toDateMs,
@@ -26,10 +31,13 @@ import type {
     ConversationDetail,
     ConversationMessage,
     ConversationPathMatch,
+    DeleteConversationOptions,
     GetConversationOptions,
     ListConversationsForPathOptions,
 } from './types';
 
+const CLAUDE_CONVERSATION_HYDRATION_CONCURRENCY = 4;
+
 const getProjectsDir = (options: { locations?: { claudeCodeProjectsDir?: string } }) =>
     options.locations?.claudeCodeProjectsDir ?? resolveClaudeCodeProjectsDir();
 
@@ -86,6 +94,19 @@ const partToMessages = (
         });
     }
 
+    if (part.type === 'attachment') {
+        const attachmentLabel = part.attachmentType?.trim() || 'file';
+        return createTextMessage({
+            createdAtMs,
+            id: baseId,
+            metadata: { attachmentType: part.attachmentType ?? null },
+            order: partIndex,
+            phase: 'unknown',
+            role: normalizeRole(entry.role),
+            text: part.text?.trim() || `[Attachment: ${attachmentLabel}]`,
+        });
+    }
+
     return [];
 };
 
@@ -102,9 +123,15 @@ const buildConversation = async (
     projectsDir: string,
     matches: ConversationPathMatch[],
     options: Pick<ListConversationsForPathOptions, 'includeMessages' | 'messageSelector'>,
+    loadedTranscript: ClaudeCodeSessionTranscript | null = null,
 ): Promise<ConversationDetail> => {
     const transcript = options.includeMessages
-        ? await readClaudeCodeSessionTranscript(projectsDir, session.sessionId)
+        ? (loadedTranscript ??
+          (await runWithTranscriptLoadLimit(() => readClaudeCodeSessionTranscript(projectsDir, session.sessionId), {
+              id: session.sessionId,
+              path: session.filePath,
+              source: 'claude-code-api',
+          })))
         : null;
     const allMessages = transcript ? transcriptToMessages(transcript) : [];
     const messages = options.includeMessages
@@ -113,7 +140,11 @@ const buildConversation = async (
 
     return {
         createdAtMs: session.createdAtMs,
-        deepLinks: createDeepLinks('claude-code', session.sessionId, `/claude-code-sessions/${session.sessionId}`),
+        deepLinks: createDeepLinks(
+            'claude-code',
+            session.sessionId,
+            createConversationUiPath('claude-code-sessions', session.sessionId),
+        ),
         id: session.sessionId,
         matches,
         messageCount: options.includeMessages ? allMessages.length : session.messageCount,
@@ -146,10 +177,14 @@ const listClaudeConversationsForPath = async (
             continue;
         }
 
-        const sessions = await listClaudeCodeSessionsForGroup(group.key, projectsDir);
-        for (const session of sessions) {
-            conversations.push(await buildConversation(session, projectsDir, [match], options));
-        }
+        const transcripts = (await listClaudeCodeSessionTranscriptsForGroup(group.key, projectsDir)).filter(
+            (transcript) => isWithinUpdatedWindow(transcript.session.lastActiveAtMs, options),
+        );
+        conversations.push(
+            ...(await mapWithConcurrency(transcripts, CLAUDE_CONVERSATION_HYDRATION_CONCURRENCY, (transcript) =>
+                buildConversation(transcript.session, projectsDir, [match], options, transcript),
+            )),
+        );
     }
 
     return conversations;
@@ -157,18 +192,40 @@ const listClaudeConversationsForPath = async (
 
 const getClaudeConversation = async (options: GetConversationOptions): Promise<ConversationDetail | null> => {
     const projectsDir = getProjectsDir(options);
-    const transcript = await readClaudeCodeSessionTranscript(projectsDir, options.id);
+    const transcript = await runWithTranscriptLoadLimit(
+        () => readClaudeCodeSessionTranscript(projectsDir, options.id),
+        {
+            id: options.id,
+            path: projectsDir,
+            source: 'claude-code-api',
+        },
+    );
     if (!transcript) {
         return null;
     }
 
-    return buildConversation(transcript.session, projectsDir, [], {
-        includeMessages: true,
-        messageSelector: options.messageSelector ?? 'all',
-    });
+    return buildConversation(
+        transcript.session,
+        projectsDir,
+        [],
+        {
+            includeMessages: true,
+            messageSelector: options.messageSelector ?? 'all',
+        },
+        transcript,
+    );
+};
+
+const deleteClaudeConversation = async (options: DeleteConversationOptions) => {
+    const result = await deleteClaudeCodeSession(getProjectsDir(options), options.id);
+    return {
+        deletedFiles: result.deletedFiles,
+        deletedIds: result.deletedSessionIds,
+    };
 };
 
 export const claudeCodeConversationAdapter: ConversationAdapter = {
+    deleteConversation: deleteClaudeConversation,
     getConversation: getClaudeConversation,
     listConversationsForPath: listClaudeConversationsForPath,
     source: 'claude-code',

package/src/lib/conversation-data/codex-adapter.ts

@@ -1,17 +1,33 @@
-import { getThreadBrowseData, listScopedThreads, resolveCodexThreadDbPath } from '../codex-browser-db';
+import {
+    CodexThreadNotFoundError,
+    deleteCodexThread,
+    getThreadBrowseData,
+    listScopedThreads,
+    resolveCodexThreadDbPath,
+} from '../codex-browser-db';
 import type { MessageEvent, ThreadBrowseData, ThreadEvent } from '../codex-browser-types';
 import { parseCodexTranscriptFile } from '../codex-thread-parser';
 import type { ThreadRow } from '../codex-thread-types';
 import { cleanInlineTitle } from '../shared';
+import { runWithTranscriptLoadLimit } from '../transcript-load-limiter';
+import {
+    createConversationUiPath,
+    createDeepLinks,
+    createTextMessage,
+    finalizeMessages,
+    isWithinUpdatedWindow,
+    normalizeAssistantPhase,
+    normalizeRole,
+    toDateMs,
+} from './adapter-helpers';
 import { selectConversationMessages } from './message-selector';
 import { getConversationPathMatch } from './path-match';
 import type {
     ConversationAdapter,
     ConversationDetail,
     ConversationMessage,
-    ConversationMessagePhase,
-    ConversationMessageRole,
     ConversationPathMatch,
+    DeleteConversationOptions,
     GetConversationOptions,
     ListConversationsForPathOptions,
 } from './types';
@@ -28,36 +44,6 @@ const toCreatedAtMs = (thread: ThreadRow) => {
     return thread.created_at_ms ?? thread.created_at * 1000;
 };
 
-const buildCodexDeepLinks = (id: string) => ({
-    native: `codex://threads/${id}`,
-    spiracha: `spiracha://conversation/codex/${id}`,
-    ui: `/threads/${id}`,
-});
-
-const normalizeRole = (role: string): ConversationMessageRole => {
-    if (role === 'assistant' || role === 'user' || role === 'system') {
-        return role;
-    }
-
-    return 'unknown';
-};
-
-const normalizeMessagePhase = (event: MessageEvent): ConversationMessagePhase => {
-    if (event.role !== 'assistant') {
-        return 'unknown';
-    }
-
-    if (event.phase === 'final_answer' || event.phase === 'final') {
-        return 'final_answer';
-    }
-
-    if (event.phase === 'commentary' || event.isHiddenByDefault) {
-        return 'commentary';
-    }
-
-    return 'final_answer';
-};
-
 const toMessageEventMessage = (event: MessageEvent): ConversationMessage | null => {
     const text = event.text.trim();
     if (!text) {
@@ -65,14 +51,17 @@ const toMessageEventMessage = (event: MessageEvent): ConversationMessage | null
     }
 
     return {
-        createdAtMs: event.timestamp ? Date.parse(event.timestamp) : null,
+        createdAtMs: toDateMs(event.timestamp),
         id: `codex:${event.sequence}`,
         metadata: {
             model: event.model,
             variant: event.variant,
         },
         order: event.sequence,
-        phase: normalizeMessagePhase(event),
+        phase:
+            event.role === 'assistant'
+                ? normalizeAssistantPhase(event.isHiddenByDefault ? 'commentary' : event.phase, 'unknown')
+                : 'unknown',
         role: normalizeRole(event.role),
         text,
     };
@@ -80,37 +69,41 @@ const toMessageEventMessage = (event: MessageEvent): ConversationMessage | null
 
 const toToolMessage = (event: ThreadEvent): ConversationMessage | null => {
     if (event.kind === 'tool_call') {
-        return {
-            createdAtMs: event.timestamp ? Date.parse(event.timestamp) : null,
-            id: `codex:${event.sequence}`,
-            metadata: {
-                callId: event.callId,
-                command: event.command,
-                name: event.name,
-                workdir: event.workdir,
-            },
-            order: event.sequence,
-            phase: 'tool_call',
-            role: 'tool',
-            text: event.command ?? event.name,
-        };
+        return (
+            createTextMessage({
+                createdAtMs: toDateMs(event.timestamp),
+                id: `codex:${event.sequence}`,
+                metadata: {
+                    callId: event.callId,
+                    command: event.command,
+                    name: event.name,
+                    workdir: event.workdir,
+                },
+                order: event.sequence,
+                phase: 'tool_call',
+                role: 'tool',
+                text: event.command || event.name,
+            })[0] ?? null
+        );
     }
 
     if (event.kind === 'tool_output') {
         const text = event.summary || event.outputText;
-        return {
-            createdAtMs: event.timestamp ? Date.parse(event.timestamp) : null,
-            id: `codex:${event.sequence}`,
-            metadata: {
-                callId: event.callId,
-                exitCode: event.exitCode,
-                wallTime: event.wallTime,
-            },
-            order: event.sequence,
-            phase: 'tool_output',
-            role: 'tool',
-            text,
-        };
+        return (
+            createTextMessage({
+                createdAtMs: toDateMs(event.timestamp),
+                id: `codex:${event.sequence}`,
+                metadata: {
+                    callId: event.callId,
+                    exitCode: event.exitCode,
+                    wallTime: event.wallTime,
+                },
+                order: event.sequence,
+                phase: 'tool_output',
+                role: 'tool',
+                text,
+            })[0] ?? null
+        );
     }
 
     return null;
@@ -118,6 +111,10 @@ const toToolMessage = (event: ThreadEvent): ConversationMessage | null => {
 
 const toConversationMessage = (event: ThreadEvent): ConversationMessage | null => {
     if (event.kind === 'message') {
+        if (event.isHiddenByDefault) {
+            return null;
+        }
+
         return toMessageEventMessage(event);
     }
 
@@ -125,7 +122,7 @@ const toConversationMessage = (event: ThreadEvent): ConversationMessage | null =
         const text = event.summary.join('\n').trim();
         return text
             ? {
-                  createdAtMs: event.timestamp ? Date.parse(event.timestamp) : null,
+                  createdAtMs: toDateMs(event.timestamp),
                   id: `codex:${event.sequence}`,
                   metadata: {
                       hasEncryptedContent: event.hasEncryptedContent,
@@ -142,14 +139,33 @@ const toConversationMessage = (event: ThreadEvent): ConversationMessage | null =
 };
 
 const readCodexMessages = async (thread: ThreadRow): Promise<ConversationMessage[]> => {
-    const transcript = await parseCodexTranscriptFile(thread.rollout_path, {
-        includeRaw: false,
-    });
+    let transcript: Awaited<ReturnType<typeof parseCodexTranscriptFile>>;
+    try {
+        transcript = await runWithTranscriptLoadLimit(
+            () =>
+                parseCodexTranscriptFile(thread.rollout_path, {
+                    includeRaw: false,
+                }),
+            {
+                id: thread.id,
+                path: thread.rollout_path,
+                source: 'codex-api',
+            },
+        );
+    } catch (error) {
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+            return [];
+        }
 
-    return transcript.events.flatMap((event) => {
-        const message = toConversationMessage(event);
-        return message ? [message] : [];
-    });
+        throw error;
+    }
+
+    return finalizeMessages(
+        transcript.events.flatMap((event) => {
+            const message = toConversationMessage(event);
+            return message ? [message] : [];
+        }),
+    );
 };
 
 const buildCodexConversation = async (
@@ -164,7 +180,12 @@ const buildCodexConversation = async (
 
     return {
         createdAtMs: toCreatedAtMs(thread),
-        deepLinks: buildCodexDeepLinks(thread.id),
+        deepLinks: createDeepLinks(
+            'codex',
+            thread.id,
+            createConversationUiPath('threads', thread.id),
+            `codex://threads/${encodeURIComponent(thread.id)}`,
+        ),
         id: thread.id,
         matches,
         messageCount: options.includeMessages ? allMessages.length : null,
@@ -206,8 +227,13 @@ const listCodexConversationsForPath = async (
     options: ListConversationsForPathOptions,
 ): Promise<ConversationDetail[]> => {
     const dbPath = getCodexDbPath(options);
+    if (!(await Bun.file(dbPath).exists())) {
+        return [];
+    }
     const threads = listScopedThreads(dbPath, null);
-    const matchedThreads = await filterThreadsForPath(threads, options.cwd);
+    const matchedThreads = (await filterThreadsForPath(threads, options.cwd)).filter(({ thread }) =>
+        isWithinUpdatedWindow(toTimestampMs(thread), options),
+    );
 
     return Promise.all(
         matchedThreads.map(({ matches, thread }) =>
@@ -225,7 +251,7 @@ const getCodexConversation = async (options: GetConversationOptions): Promise<Co
     try {
         browseData = getThreadBrowseData(dbPath, options.id);
     } catch (error) {
-        if (error instanceof Error && /not found/i.test(error.message)) {
+        if (error instanceof CodexThreadNotFoundError) {
             return null;
         }
 
@@ -238,7 +264,16 @@ const getCodexConversation = async (options: GetConversationOptions): Promise<Co
     });
 };
 
+const deleteCodexConversation = async (options: DeleteConversationOptions) => {
+    const result = await deleteCodexThread(getCodexDbPath(options), options.id, { deleteSessionFiles: true });
+    return {
+        deletedFiles: result.deletedSessionFiles,
+        deletedIds: result.deletedThreadIds,
+    };
+};
+
 export const codexConversationAdapter: ConversationAdapter = {
+    deleteConversation: deleteCodexConversation,
     getConversation: getCodexConversation,
     listConversationsForPath: listCodexConversationsForPath,
     source: 'codex',