spiracha 1.5.0 → 2.1.0

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

@@ -0,0 +1,269 @@
+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 {
+    ConversationAdapter,
+    ConversationDetail,
+    ConversationMessage,
+    ConversationMessagePhase,
+    ConversationMessageRole,
+    ConversationPathMatch,
+    DeleteConversationOptions,
+    GetConversationOptions,
+    ListConversationsForPathOptions,
+} from './types';
+
+const getCodexDbPath = (options: { locations?: { codexDbPath?: string } }) => {
+    return options.locations?.codexDbPath ?? resolveCodexThreadDbPath();
+};
+
+const toTimestampMs = (thread: ThreadRow) => {
+    return thread.updated_at_ms ?? thread.updated_at * 1000;
+};
+
+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) {
+        return null;
+    }
+
+    return {
+        createdAtMs: event.timestamp ? Date.parse(event.timestamp) : null,
+        id: `codex:${event.sequence}`,
+        metadata: {
+            model: event.model,
+            variant: event.variant,
+        },
+        order: event.sequence,
+        phase: normalizeMessagePhase(event),
+        role: normalizeRole(event.role),
+        text,
+    };
+};
+
+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,
+        };
+    }
+
+    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 null;
+};
+
+const toConversationMessage = (event: ThreadEvent): ConversationMessage | null => {
+    if (event.kind === 'message') {
+        return toMessageEventMessage(event);
+    }
+
+    if (event.kind === 'reasoning') {
+        const text = event.summary.join('\n').trim();
+        return text
+            ? {
+                  createdAtMs: event.timestamp ? Date.parse(event.timestamp) : null,
+                  id: `codex:${event.sequence}`,
+                  metadata: {
+                      hasEncryptedContent: event.hasEncryptedContent,
+                  },
+                  order: event.sequence,
+                  phase: 'reasoning',
+                  role: 'assistant',
+                  text,
+              }
+            : null;
+    }
+
+    return toToolMessage(event);
+};
+
+const readCodexMessages = async (thread: ThreadRow): Promise<ConversationMessage[]> => {
+    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);
+        return message ? [message] : [];
+    });
+};
+
+const buildCodexConversation = async (
+    thread: ThreadRow,
+    matches: ConversationPathMatch[],
+    options: { includeMessages: boolean; messageSelector: ListConversationsForPathOptions['messageSelector'] },
+): Promise<ConversationDetail> => {
+    const allMessages = options.includeMessages ? await readCodexMessages(thread) : [];
+    const messages = options.includeMessages
+        ? selectConversationMessages(allMessages, options.messageSelector ?? 'last_final_answer')
+        : [];
+
+    return {
+        createdAtMs: toCreatedAtMs(thread),
+        deepLinks: buildCodexDeepLinks(thread.id),
+        id: thread.id,
+        matches,
+        messageCount: options.includeMessages ? allMessages.length : null,
+        messages,
+        metadata: {
+            agentNickname: thread.agent_nickname,
+            agentPath: thread.agent_path,
+            agentRole: thread.agent_role,
+            archived: Boolean(thread.archived),
+            cliVersion: thread.cli_version,
+            model: thread.model,
+            modelProvider: thread.model_provider,
+            tokensUsed: thread.tokens_used,
+        },
+        source: 'codex',
+        title: cleanInlineTitle(thread.title || thread.first_user_message || thread.id),
+        updatedAtMs: toTimestampMs(thread),
+        workspaceKey: thread.cwd ? `folder:${thread.cwd}` : null,
+        workspacePath: thread.cwd || null,
+    };
+};
+
+const filterThreadsForPath = async (
+    threads: ThreadRow[],
+    cwd: string,
+): Promise<Array<{ matches: ConversationPathMatch[]; thread: ThreadRow }>> => {
+    const filtered: Array<{ matches: ConversationPathMatch[]; thread: ThreadRow }> = [];
+    for (const thread of threads) {
+        const match = await getConversationPathMatch(cwd, thread.cwd);
+        if (match) {
+            filtered.push({ matches: [match], thread });
+        }
+    }
+
+    return filtered;
+};
+
+const listCodexConversationsForPath = async (
+    options: ListConversationsForPathOptions,
+): Promise<ConversationDetail[]> => {
+    const dbPath = getCodexDbPath(options);
+    const threads = listScopedThreads(dbPath, null);
+    const matchedThreads = await filterThreadsForPath(threads, options.cwd);
+
+    return Promise.all(
+        matchedThreads.map(({ matches, thread }) =>
+            buildCodexConversation(thread, matches, {
+                includeMessages: options.includeMessages ?? false,
+                messageSelector: options.messageSelector,
+            }),
+        ),
+    );
+};
+
+const getCodexConversation = async (options: GetConversationOptions): Promise<ConversationDetail | null> => {
+    const dbPath = getCodexDbPath(options);
+    let browseData: ThreadBrowseData;
+    try {
+        browseData = getThreadBrowseData(dbPath, options.id);
+    } catch (error) {
+        if (error instanceof Error && /not found/i.test(error.message)) {
+            return null;
+        }
+
+        throw error;
+    }
+
+    return buildCodexConversation(browseData.thread, [], {
+        includeMessages: true,
+        messageSelector: options.messageSelector ?? 'all',
+    });
+};
+
+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

@@ -0,0 +1,205 @@
+import { mapWithConcurrency } from '../concurrency';
+import {
+    listCursorThreadsForGroup,
+    listCursorWorkspaceGroups,
+    readCursorThreadTranscriptWithAgentFiles,
+} from '../cursor-db';
+import type {
+    CursorBubble,
+    CursorThreadSummary,
+    CursorThreadTranscript,
+    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';
+import type {
+    ConversationAdapter,
+    ConversationDetail,
+    ConversationMessage,
+    ConversationPathMatch,
+    DeleteConversationOptions,
+    GetConversationOptions,
+    ListConversationsForPathOptions,
+} from './types';
+
+const CURSOR_CONVERSATION_HYDRATION_CONCURRENCY = 4;
+
+const getUserDir = (options: { locations?: { cursorUserDir?: string } }) =>
+    options.locations?.cursorUserDir ?? resolveCursorUserDir();
+
+const isWithinUpdatedWindow = (
+    thread: CursorThreadSummary,
+    options: Pick<ListConversationsForPathOptions, 'updatedAfterMs' | 'updatedBeforeMs'>,
+): boolean => {
+    const updatedAtMs = thread.lastUpdatedAtMs ?? 0;
+    if (options.updatedAfterMs !== undefined && updatedAtMs < options.updatedAfterMs) {
+        return false;
+    }
+    if (options.updatedBeforeMs !== undefined && updatedAtMs > options.updatedBeforeMs) {
+        return false;
+    }
+    return true;
+};
+
+const bubbleToMessages = (bubble: CursorBubble, order: number): ConversationMessage[] => {
+    const thinking = createTextMessage({
+        createdAtMs: bubble.createdAtMs,
+        id: `${bubble.bubbleId}:thinking`,
+        order,
+        phase: 'reasoning',
+        role: 'assistant',
+        text: bubble.thinking,
+    });
+    const text = createTextMessage({
+        createdAtMs: bubble.createdAtMs,
+        id: bubble.bubbleId,
+        order,
+        phase: bubble.kind === 'assistant' ? 'final_answer' : 'unknown',
+        role: bubble.kind === 'assistant' ? 'assistant' : bubble.kind === 'user' ? 'user' : 'unknown',
+        text: bubble.text,
+    });
+    const tool = bubble.toolCall
+        ? createTextMessage({
+              createdAtMs: bubble.createdAtMs,
+              id: `${bubble.bubbleId}:tool`,
+              metadata: { callId: bubble.toolCall.callId, status: bubble.toolCall.status },
+              order,
+              phase: bubble.toolCall.resultText ? 'tool_output' : 'tool_call',
+              role: 'tool',
+              text: bubble.toolCall.resultText ?? bubble.toolCall.argumentsText ?? bubble.toolCall.name,
+          })
+        : [];
+
+    return [...thinking, ...text, ...tool];
+};
+
+const transcriptToMessages = (transcript: CursorThreadTranscript) => {
+    return finalizeMessages(transcript.bubbles.flatMap((bubble, order) => bubbleToMessages(bubble, order)));
+};
+
+const getWorkspacePath = (group: CursorWorkspaceGroup) => {
+    return group.folders[0] ?? null;
+};
+
+const buildConversation = async (
+    thread: CursorThreadSummary,
+    group: CursorWorkspaceGroup,
+    userDir: string,
+    matches: ConversationPathMatch[],
+    options: Pick<ListConversationsForPathOptions, 'includeMessages' | 'messageSelector'>,
+): Promise<ConversationDetail> => {
+    const globalDbPath = getCursorGlobalDbPath(userDir);
+    const transcript = options.includeMessages
+        ? 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
+        ? selectConversationMessages(allMessages, options.messageSelector ?? 'last_final_answer')
+        : [];
+
+    return {
+        createdAtMs: thread.createdAtMs,
+        deepLinks: createDeepLinks('cursor', thread.composerId, `/cursor-threads/${thread.composerId}`),
+        id: thread.composerId,
+        matches,
+        messageCount: options.includeMessages ? allMessages.length : thread.bubbleCount,
+        messages,
+        metadata: {
+            bubbleBytes: thread.bubbleBytes,
+            bucketId: thread.bucketId,
+            mode: thread.mode,
+            transcriptDirs: thread.transcriptDirs,
+        },
+        source: 'cursor',
+        title: cleanInlineTitle(thread.name),
+        updatedAtMs: thread.lastUpdatedAtMs,
+        workspaceKey: group.key,
+        workspacePath: getWorkspacePath(group),
+    };
+};
+
+const listCursorConversationsForPath = async (options: ListConversationsForPathOptions) => {
+    const userDir = getUserDir(options);
+    const groups = await listCursorWorkspaceGroups(userDir, { updatedAfterMs: options.updatedAfterMs });
+    const candidates: { group: CursorWorkspaceGroup; match: ConversationPathMatch; thread: CursorThreadSummary }[] = [];
+
+    for (const group of groups) {
+        const match = await getFirstConversationPathMatch(options.cwd, group.folders);
+        if (!match) {
+            continue;
+        }
+        const threads = await listCursorThreadsForGroup(group, userDir, {
+            includeTranscriptDirs: false,
+            updatedAfterMs: options.updatedAfterMs,
+        });
+        for (const thread of threads) {
+            if (!isWithinUpdatedWindow(thread, options)) {
+                continue;
+            }
+
+            candidates.push({ group, match, thread });
+        }
+    }
+
+    return await mapWithConcurrency(candidates, CURSOR_CONVERSATION_HYDRATION_CONCURRENCY, ({ group, match, thread }) =>
+        buildConversation(thread, group, userDir, [match], options),
+    );
+};
+
+const getCursorConversation = async (options: GetConversationOptions): Promise<ConversationDetail | null> => {
+    const userDir = getUserDir(options);
+    const groups = await listCursorWorkspaceGroups(userDir);
+    for (const group of groups) {
+        const threads = await listCursorThreadsForGroup(group, userDir, { includeTranscriptDirs: false });
+        const thread = threads.find((entry) => entry.composerId === options.id);
+        if (thread) {
+            return buildConversation(thread, group, userDir, [], {
+                includeMessages: true,
+                messageSelector: options.messageSelector ?? 'all',
+            });
+        }
+    }
+
+    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',
+};