spiracha 2.0.0 → 2.1.0

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

@@ -1,8 +1,14 @@
-import { getThreadBrowseData, listScopedThreads, resolveCodexThreadDbPath } from '../codex-browser-db';
+import {
+    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 { selectConversationMessages } from './message-selector';
 import { getConversationPathMatch } from './path-match';
 import type {
@@ -12,6 +18,7 @@ import type {
     ConversationMessagePhase,
     ConversationMessageRole,
     ConversationPathMatch,
+    DeleteConversationOptions,
     GetConversationOptions,
     ListConversationsForPathOptions,
 } from './types';
@@ -142,9 +149,17 @@ const toConversationMessage = (event: ThreadEvent): ConversationMessage | null =
 };
 
 const readCodexMessages = async (thread: ThreadRow): Promise<ConversationMessage[]> => {
-    const transcript = await parseCodexTranscriptFile(thread.rollout_path, {
-        includeRaw: false,
-    });
+    const transcript = await runWithTranscriptLoadLimit(
+        () =>
+            parseCodexTranscriptFile(thread.rollout_path, {
+                includeRaw: false,
+            }),
+        {
+            id: thread.id,
+            path: thread.rollout_path,
+            source: 'codex-api',
+        },
+    );
 
     return transcript.events.flatMap((event) => {
         const message = toConversationMessage(event);
@@ -238,7 +253,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',

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

@@ -11,7 +11,9 @@ import type {
     CursorWorkspaceGroup,
 } from '../cursor-exporter-types';
 import { getCursorGlobalDbPath, resolveCursorUserDir } from '../cursor-exporter-types';
+import { collectCursorThreadsForDeletion, isCursorRunning, pruneCursorThreads } from '../cursor-recovery';
 import { cleanInlineTitle } from '../shared';
+import { runWithTranscriptLoadLimit } from '../transcript-load-limiter';
 import { createDeepLinks, createTextMessage, finalizeMessages } from './adapter-helpers';
 import { selectConversationMessages } from './message-selector';
 import { getFirstConversationPathMatch } from './path-match';
@@ -20,6 +22,7 @@ import type {
     ConversationDetail,
     ConversationMessage,
     ConversationPathMatch,
+    DeleteConversationOptions,
     GetConversationOptions,
     ListConversationsForPathOptions,
 } from './types';
@@ -90,8 +93,16 @@ const buildConversation = async (
     matches: ConversationPathMatch[],
     options: Pick<ListConversationsForPathOptions, 'includeMessages' | 'messageSelector'>,
 ): Promise<ConversationDetail> => {
+    const globalDbPath = getCursorGlobalDbPath(userDir);
     const transcript = options.includeMessages
-        ? await readCursorThreadTranscriptWithAgentFiles(getCursorGlobalDbPath(userDir), thread.composerId, userDir)
+        ? await runWithTranscriptLoadLimit(
+              () => readCursorThreadTranscriptWithAgentFiles(globalDbPath, thread.composerId, userDir),
+              {
+                  id: thread.composerId,
+                  path: thread.transcriptDirs[0] ?? globalDbPath,
+                  source: 'cursor-api',
+              },
+          )
         : null;
     const allMessages = transcript ? transcriptToMessages(transcript) : [];
     const messages = options.includeMessages
@@ -164,7 +175,30 @@ const getCursorConversation = async (options: GetConversationOptions): Promise<C
     return null;
 };
 
+const deleteCursorConversation = async (options: DeleteConversationOptions) => {
+    const userDir = getUserDir(options);
+    if (!options.locations?.cursorUserDir && (await isCursorRunning())) {
+        throw new Error(
+            'Quit Cursor before deleting. It rewrites chat history on exit, which can resurrect deleted threads.',
+        );
+    }
+
+    const existing = await getCursorConversation(options);
+    if (!existing) {
+        return { deletedFiles: [], deletedIds: [] };
+    }
+
+    const threads = await collectCursorThreadsForDeletion([options.id], userDir);
+    const deletedFiles = threads.flatMap((thread) => thread.transcriptDirs);
+    const result = await pruneCursorThreads(threads, true, userDir);
+    return {
+        deletedFiles,
+        deletedIds: result.composerIds,
+    };
+};
+
 export const cursorConversationAdapter: ConversationAdapter = {
+    deleteConversation: deleteCursorConversation,
     getConversation: getCursorConversation,
     listConversationsForPath: listCursorConversationsForPath,
     source: 'cursor',

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

@@ -0,0 +1,210 @@
+import {
+    deleteGrokSession,
+    listGrokSessionsForGroup,
+    listGrokWorkspaceGroups,
+    readGrokSessionTranscript,
+    resolveGrokSessionsDir,
+} from '../grok-db';
+import type {
+    GrokSessionSummary,
+    GrokSessionTranscript,
+    GrokTranscriptEntry,
+    GrokTranscriptPart,
+} from '../grok-exporter-types';
+import { getFinalGrokAssistantTextPartIds, getGrokTextPartPhase } from '../grok-transcript-phase';
+import { cleanInlineTitle } from '../shared';
+import { runWithTranscriptLoadLimit } from '../transcript-load-limiter';
+import {
+    createDeepLinks,
+    createTextMessage,
+    finalizeMessages,
+    normalizeAssistantPhase,
+    normalizeRole,
+} from './adapter-helpers';
+import { selectConversationMessages } from './message-selector';
+import { getConversationPathMatch } from './path-match';
+import type {
+    ConversationAdapter,
+    ConversationDetail,
+    ConversationMessage,
+    ConversationPathMatch,
+    DeleteConversationOptions,
+    GetConversationOptions,
+    ListConversationsForPathOptions,
+} from './types';
+
+const getSessionsDir = (options: { locations?: { grokSessionsDir?: string } }) =>
+    options.locations?.grokSessionsDir ?? resolveGrokSessionsDir();
+
+const partToMessages = (
+    entry: GrokTranscriptEntry,
+    part: GrokTranscriptPart,
+    finalTextPartIds: Set<string>,
+    order: number,
+): ConversationMessage[] => {
+    if (part.type === 'text') {
+        return createTextMessage({
+            createdAtMs: entry.createdAtMs,
+            id: part.partId,
+            metadata: { modelFingerprint: entry.modelFingerprint, modelId: entry.modelId },
+            order,
+            phase: normalizeAssistantPhase(getGrokTextPartPhase(entry, part, finalTextPartIds), 'unknown'),
+            role: normalizeRole(entry.role),
+            text: part.text,
+        });
+    }
+
+    if (part.type === 'reasoning') {
+        return createTextMessage({
+            createdAtMs: entry.createdAtMs,
+            id: part.partId,
+            order,
+            phase: 'reasoning',
+            role: 'assistant',
+            text: part.text,
+        });
+    }
+
+    if (part.type === 'tool_call') {
+        return createTextMessage({
+            createdAtMs: entry.createdAtMs,
+            id: part.partId,
+            metadata: { toolCallId: part.toolCallId, toolName: part.toolName },
+            order,
+            phase: 'tool_call',
+            role: 'tool',
+            text: [part.toolName, part.argumentsText].filter(Boolean).join('\n'),
+        });
+    }
+
+    if (part.type === 'tool_result') {
+        return createTextMessage({
+            createdAtMs: entry.createdAtMs,
+            id: part.partId,
+            metadata: { toolCallId: part.toolCallId },
+            order,
+            phase: 'tool_output',
+            role: 'tool',
+            text: part.outputText,
+        });
+    }
+
+    return [];
+};
+
+const transcriptToMessages = (transcript: GrokSessionTranscript): ConversationMessage[] => {
+    const finalTextPartIds = getFinalGrokAssistantTextPartIds(transcript.entries);
+    return finalizeMessages(
+        transcript.entries.flatMap((entry, entryIndex) =>
+            entry.parts.flatMap((part, partIndex) =>
+                partToMessages(entry, part, finalTextPartIds, entryIndex + partIndex),
+            ),
+        ),
+    );
+};
+
+const buildConversation = async (
+    session: GrokSessionSummary,
+    sessionsDir: string,
+    matches: ConversationPathMatch[],
+    options: Pick<ListConversationsForPathOptions, 'includeMessages' | 'messageSelector'>,
+    loadedTranscript: GrokSessionTranscript | null = null,
+): Promise<ConversationDetail> => {
+    const transcript =
+        loadedTranscript ??
+        (options.includeMessages
+            ? await runWithTranscriptLoadLimit(
+                  () => readGrokSessionTranscript(sessionsDir, session.sessionId, { includeRawPayloads: false }),
+                  {
+                      id: session.sessionId,
+                      path: sessionsDir,
+                      source: 'grok-api',
+                  },
+              )
+            : null);
+    const allMessages = transcript ? transcriptToMessages(transcript) : [];
+    const messages = options.includeMessages
+        ? selectConversationMessages(allMessages, options.messageSelector ?? 'last_final_answer')
+        : [];
+
+    return {
+        createdAtMs: session.createdAtMs,
+        deepLinks: createDeepLinks('grok', session.sessionId, `/grok-sessions/${session.sessionId}`),
+        id: session.sessionId,
+        matches,
+        messageCount: options.includeMessages ? allMessages.length : session.messageCount,
+        messages,
+        metadata: {
+            agentName: session.agentName,
+            currentModelId: session.currentModelId,
+            gitBranch: session.gitBranch,
+            headCommit: session.headCommit,
+            modelLabel: session.modelLabel,
+            renderablePartCount: session.renderablePartCount,
+            sandboxProfile: session.sandboxProfile,
+        },
+        source: 'grok',
+        title: cleanInlineTitle(session.title),
+        updatedAtMs: session.lastActiveAtMs,
+        workspaceKey: session.workspaceKey,
+        workspacePath: session.worktree,
+    };
+};
+
+const listGrokConversationsForPath = async (options: ListConversationsForPathOptions) => {
+    const sessionsDir = getSessionsDir(options);
+    const groups = await listGrokWorkspaceGroups(sessionsDir);
+    const conversations: ConversationDetail[] = [];
+
+    for (const group of groups) {
+        const match = await getConversationPathMatch(options.cwd, group.worktree);
+        if (!match) {
+            continue;
+        }
+        const sessions = await listGrokSessionsForGroup(group.key, sessionsDir);
+        for (const session of sessions) {
+            conversations.push(await buildConversation(session, sessionsDir, [match], options));
+        }
+    }
+
+    return conversations;
+};
+
+const getGrokConversation = async (options: GetConversationOptions): Promise<ConversationDetail | null> => {
+    const sessionsDir = getSessionsDir(options);
+    const transcript = await runWithTranscriptLoadLimit(
+        () => readGrokSessionTranscript(sessionsDir, options.id, { includeRawPayloads: false }),
+        {
+            id: options.id,
+            path: sessionsDir,
+            source: 'grok-api',
+        },
+    );
+    return transcript
+        ? buildConversation(
+              transcript.session,
+              sessionsDir,
+              [],
+              {
+                  includeMessages: true,
+                  messageSelector: options.messageSelector ?? 'all',
+              },
+              transcript,
+          )
+        : null;
+};
+
+const deleteGrokConversation = async (options: DeleteConversationOptions) => {
+    const result = await deleteGrokSession(getSessionsDir(options), options.id);
+    return {
+        deletedFiles: result.deletedFiles,
+        deletedIds: result.deletedSessionIds,
+    };
+};
+
+export const grokConversationAdapter: ConversationAdapter = {
+    deleteConversation: deleteGrokConversation,
+    getConversation: getGrokConversation,
+    listConversationsForPath: listGrokConversationsForPath,
+    source: 'grok',
+};

package/src/lib/conversation-data/index.ts

@@ -1,7 +1,9 @@
+import { mapWithConcurrency } from '../concurrency';
 import { antigravityConversationAdapter } from './antigravity-adapter';
 import { claudeCodeConversationAdapter } from './claude-code-adapter';
 import { codexConversationAdapter } from './codex-adapter';
 import { cursorConversationAdapter } from './cursor-adapter';
+import { grokConversationAdapter } from './grok-adapter';
 import { kiroConversationAdapter } from './kiro-adapter';
 import { selectConversationMessages } from './message-selector';
 import { opencodeConversationAdapter } from './opencode-adapter';
@@ -14,6 +16,11 @@ import {
     type ConversationPage,
     type ConversationSource,
     type ConversationSourceInfo,
+    type DeleteConversationItemResult,
+    type DeleteConversationOptions,
+    type DeleteConversationResult,
+    type DeleteConversationsOptions,
+    type DeleteConversationsResult,
     type GetConversationOptions,
     type ListConversationsForPathOptions,
     type ResolvedConversationRef,
@@ -27,6 +34,7 @@ export {
     type ConversationDataLocations,
     type ConversationDeepLinks,
     type ConversationDetail,
+    type ConversationIdSetOptions,
     type ConversationMessage,
     type ConversationMessagePhase,
     type ConversationMessageRole,
@@ -35,6 +43,13 @@ export {
     type ConversationPathMatch,
     type ConversationSource,
     type ConversationSourceInfo,
+    type ConversationZipDownload,
+    type DeleteConversationItemResult,
+    type DeleteConversationOptions,
+    type DeleteConversationResult,
+    type DeleteConversationsOptions,
+    type DeleteConversationsResult,
+    type ExportConversationsZipOptions,
     type GetConversationOptions,
     type ListConversationsForPathOptions,
     type ResolvedConversationRef,
@@ -45,6 +60,7 @@ const SOURCE_LABELS: Record<ConversationSource, string> = {
     'claude-code': 'Claude Code',
     codex: 'Codex',
     cursor: 'Cursor',
+    grok: 'Grok',
     kiro: 'Kiro',
     opencode: 'OpenCode',
     qoder: 'Qoder',
@@ -64,6 +80,7 @@ const ADAPTERS: Partial<Record<ConversationSource, ConversationAdapter>> = {
     'claude-code': claudeCodeConversationAdapter,
     codex: codexConversationAdapter,
     cursor: cursorConversationAdapter,
+    grok: grokConversationAdapter,
     kiro: kiroConversationAdapter,
     opencode: opencodeConversationAdapter,
     qoder: qoderConversationAdapter,
@@ -71,6 +88,16 @@ const ADAPTERS: Partial<Record<ConversationSource, ConversationAdapter>> = {
 
 const MAX_LIMIT = 200;
 const DEFAULT_LIMIT = 100;
+const DELETE_CONCURRENCY_BY_SOURCE: Record<ConversationSource, number> = {
+    antigravity: 1,
+    'claude-code': 4,
+    codex: 1,
+    cursor: 1,
+    grok: 1,
+    kiro: 1,
+    opencode: 2,
+    qoder: 1,
+};
 
 const getEnabledSources = (sources: ListConversationsForPathOptions['sources']): ConversationSource[] => {
     if (!sources || sources === 'all') {
@@ -181,10 +208,56 @@ export const getConversation = async (options: GetConversationOptions) => {
     return getAdapter(options.source)?.getConversation(options) ?? null;
 };
 
+export const deleteConversation = async (
+    options: DeleteConversationOptions,
+): Promise<DeleteConversationResult | null> => {
+    return (await getAdapter(options.source)?.deleteConversation?.(options)) ?? null;
+};
+
+export const deleteConversations = async (
+    options: DeleteConversationsOptions,
+): Promise<DeleteConversationsResult | null> => {
+    const adapter = getAdapter(options.source);
+    if (!adapter?.deleteConversation) {
+        return null;
+    }
+    const deleteAdapterConversation = adapter.deleteConversation;
+
+    const rawResults = await mapWithConcurrency(
+        options.ids,
+        DELETE_CONCURRENCY_BY_SOURCE[options.source],
+        async (id) => ({
+            id,
+            result: await deleteAdapterConversation({
+                id,
+                locations: options.locations,
+                source: options.source,
+            }),
+        }),
+    );
+    const deletedIdSet = new Set(rawResults.flatMap(({ result }) => result.deletedIds));
+    const results: DeleteConversationItemResult[] = rawResults.map(({ id, result }) => ({
+        deleted: result.deletedIds.length > 0 || deletedIdSet.has(id),
+        deletedFiles: result.deletedFiles,
+        deletedIds: result.deletedIds,
+        id,
+    }));
+
+    return {
+        deletedFiles: [...new Set(results.flatMap((result) => result.deletedFiles))],
+        deletedIds: [...deletedIdSet],
+        missingIds: results.filter((result) => !result.deleted).map((result) => result.id),
+        results,
+    };
+};
+
 const sourceFromSessionRoute = (segment: string): ConversationSource | null => {
     if (segment === 'claude-code-sessions') {
         return 'claude-code';
     }
+    if (segment === 'grok-sessions') {
+        return 'grok';
+    }
     if (segment === 'kiro-sessions') {
         return 'kiro';
     }
@@ -287,7 +360,9 @@ export const renderConversationMarkdown = (
         messages: ConversationMessage[];
         title: string | null;
     },
-    options: { messageSelector?: ConversationMessageSelector } = {},
+    options: {
+        messageSelector?: ConversationMessageSelector;
+    } = {},
 ) => {
     const selectedMessages = options.messageSelector
         ? selectConversationMessages(conversation.messages, options.messageSelector)

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

@@ -1,4 +1,9 @@
-import { listKiroSessionsForGroup, listKiroWorkspaceGroups, readKiroSessionTranscript } from '../kiro-db';
+import {
+    deleteKiroSession,
+    listKiroSessionsForGroup,
+    listKiroWorkspaceGroups,
+    readKiroSessionTranscript,
+} from '../kiro-db';
 import type {
     KiroSessionSummary,
     KiroSessionTranscript,
@@ -8,6 +13,7 @@ import type {
 import { resolveKiroWorkspaceSessionsDir } from '../kiro-exporter-types';
 import { getFinalKiroAssistantMessageEntryIds, getKiroMessagePhase } from '../kiro-transcript-phase';
 import { cleanInlineTitle } from '../shared';
+import { runWithTranscriptLoadLimit } from '../transcript-load-limiter';
 import {
     createDeepLinks,
     createTextMessage,
@@ -23,6 +29,7 @@ import type {
     ConversationDetail,
     ConversationMessage,
     ConversationPathMatch,
+    DeleteConversationOptions,
     GetConversationOptions,
     ListConversationsForPathOptions,
 } from './types';
@@ -74,8 +81,16 @@ const buildConversation = async (
     sessionsDir: string,
     matches: ConversationPathMatch[],
     options: Pick<ListConversationsForPathOptions, 'includeMessages' | 'messageSelector'>,
+    loadedTranscript: KiroSessionTranscript | null = null,
 ): Promise<ConversationDetail> => {
-    const transcript = options.includeMessages ? await readKiroSessionTranscript(sessionsDir, session.sessionId) : null;
+    const transcript = options.includeMessages
+        ? (loadedTranscript ??
+          (await runWithTranscriptLoadLimit(() => readKiroSessionTranscript(sessionsDir, session.sessionId), {
+              id: session.sessionId,
+              path: session.filePath,
+              source: 'kiro-api',
+          })))
+        : null;
     const allMessages = transcript ? transcriptToMessages(transcript) : [];
     const messages = options.includeMessages
         ? selectConversationMessages(allMessages, options.messageSelector ?? 'last_final_answer')
@@ -124,16 +139,35 @@ const listKiroConversationsForPath = async (options: ListConversationsForPathOpt
 
 const getKiroConversation = async (options: GetConversationOptions): Promise<ConversationDetail | null> => {
     const sessionsDir = getSessionsDir(options);
-    const transcript = await readKiroSessionTranscript(sessionsDir, options.id);
+    const transcript = await runWithTranscriptLoadLimit(() => readKiroSessionTranscript(sessionsDir, options.id), {
+        id: options.id,
+        path: sessionsDir,
+        source: 'kiro-api',
+    });
     return transcript
-        ? buildConversation(transcript.session, sessionsDir, [], {
-              includeMessages: true,
-              messageSelector: options.messageSelector ?? 'all',
-          })
+        ? buildConversation(
+              transcript.session,
+              sessionsDir,
+              [],
+              {
+                  includeMessages: true,
+                  messageSelector: options.messageSelector ?? 'all',
+              },
+              transcript,
+          )
         : null;
 };
 
+const deleteKiroConversation = async (options: DeleteConversationOptions) => {
+    const result = await deleteKiroSession(getSessionsDir(options), options.id);
+    return {
+        deletedFiles: result.deletedFiles,
+        deletedIds: result.deletedSessionIds,
+    };
+};
+
 export const kiroConversationAdapter: ConversationAdapter = {
+    deleteConversation: deleteKiroConversation,
     getConversation: getKiroConversation,
     listConversationsForPath: listKiroConversationsForPath,
     source: 'kiro',

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

@@ -1,4 +1,5 @@
 import {
+    deleteOpenCodeSession,
     listOpenCodeSessionsForGroup,
     listOpenCodeWorkspaceGroups,
     readOpenCodeSessionTranscript,
@@ -12,6 +13,7 @@ import { resolveOpenCodeDbPath } from '../opencode-exporter-types';
 import { splitOpenCodeThinkTaggedText } from '../opencode-think-tags';
 import { getFinalOpenCodeAssistantTextPartIds, getOpenCodeTextPartPhase } from '../opencode-transcript-phase';
 import { cleanInlineTitle } from '../shared';
+import { runWithTranscriptLoadLimit } from '../transcript-load-limiter';
 import {
     createDeepLinks,
     createTextMessage,
@@ -26,6 +28,7 @@ import type {
     ConversationDetail,
     ConversationMessage,
     ConversationPathMatch,
+    DeleteConversationOptions,
     GetConversationOptions,
     ListConversationsForPathOptions,
 } from './types';
@@ -109,7 +112,13 @@ const buildConversation = async (
 ): Promise<ConversationDetail> => {
     const transcript =
         loadedTranscript ??
-        (options.includeMessages ? await readOpenCodeSessionTranscript(dbPath, session.sessionId) : null);
+        (options.includeMessages
+            ? await runWithTranscriptLoadLimit(() => readOpenCodeSessionTranscript(dbPath, session.sessionId), {
+                  id: session.sessionId,
+                  path: dbPath,
+                  source: 'opencode-api',
+              })
+            : null);
     const allMessages = transcript ? transcriptToMessages(transcript) : [];
     const messages = options.includeMessages
         ? selectConversationMessages(allMessages, options.messageSelector ?? 'last_final_answer')
@@ -158,7 +167,11 @@ const listOpenCodeConversationsForPath = async (options: ListConversationsForPat
 
 const getOpenCodeConversation = async (options: GetConversationOptions): Promise<ConversationDetail | null> => {
     const dbPath = getDbPath(options);
-    const transcript = await readOpenCodeSessionTranscript(dbPath, options.id);
+    const transcript = await runWithTranscriptLoadLimit(() => readOpenCodeSessionTranscript(dbPath, options.id), {
+        id: options.id,
+        path: dbPath,
+        source: 'opencode-api',
+    });
     return transcript
         ? buildConversation(
               transcript.session,
@@ -173,7 +186,16 @@ const getOpenCodeConversation = async (options: GetConversationOptions): Promise
         : null;
 };
 
+const deleteOpenCodeConversation = async (options: DeleteConversationOptions) => {
+    const result = await deleteOpenCodeSession(getDbPath(options), options.id);
+    return {
+        deletedFiles: [],
+        deletedIds: result.deletedSessionIds,
+    };
+};
+
 export const opencodeConversationAdapter: ConversationAdapter = {
+    deleteConversation: deleteOpenCodeConversation,
     getConversation: getOpenCodeConversation,
     listConversationsForPath: listOpenCodeConversationsForPath,
     source: 'opencode',