spiracha 1.5.0 → 2.0.0

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

@@ -0,0 +1,110 @@
+import type {
+    ConversationDeepLinks,
+    ConversationMessage,
+    ConversationMessagePhase,
+    ConversationMessageRole,
+    ConversationSource,
+} from './types';
+
+export const toDateMs = (value: string | number | null | undefined): number | null => {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : null;
+    }
+
+    if (!value) {
+        return null;
+    }
+
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+};
+
+export const decodeFileUri = (value: string | null | undefined): string | null => {
+    if (!value) {
+        return null;
+    }
+
+    if (!value.startsWith('file://')) {
+        return value;
+    }
+
+    try {
+        const url = new URL(value);
+        const pathname = decodeURIComponent(url.pathname);
+        if (url.hostname) {
+            return `//${url.hostname}${pathname}`;
+        }
+        return pathname.replace(/^\/([A-Za-z]:)/u, '$1');
+    } catch {
+        const pathValue = decodeURIComponent(value.slice('file://'.length));
+        return pathValue.replace(/^\/([A-Za-z]:)/u, '$1');
+    }
+};
+
+export const createDeepLinks = (
+    source: ConversationSource,
+    id: string,
+    uiPath: string,
+    native: string | null = null,
+): ConversationDeepLinks => ({
+    native,
+    spiracha: `spiracha://conversation/${source}/${id}`,
+    ui: uiPath,
+});
+
+export const normalizeRole = (role: string | null | undefined): ConversationMessageRole => {
+    if (role === 'assistant' || role === 'system' || role === 'tool' || role === 'user') {
+        return role;
+    }
+
+    return 'unknown';
+};
+
+export const normalizeAssistantPhase = (
+    phase: string | null | undefined,
+    fallback: ConversationMessagePhase = 'final_answer',
+): ConversationMessagePhase => {
+    if (phase === 'final_answer' || phase === 'final') {
+        return 'final_answer';
+    }
+
+    if (phase === 'commentary') {
+        return 'commentary';
+    }
+
+    return fallback;
+};
+
+export const createTextMessage = (input: {
+    createdAtMs: number | null;
+    id: string;
+    metadata?: Record<string, unknown>;
+    order: number;
+    phase: ConversationMessagePhase;
+    role: ConversationMessageRole;
+    text: string | null | undefined;
+}): ConversationMessage[] => {
+    const text = input.text?.trim();
+    if (!text) {
+        return [];
+    }
+
+    return [
+        {
+            createdAtMs: input.createdAtMs,
+            id: input.id,
+            metadata: input.metadata ?? {},
+            order: input.order,
+            phase: input.phase,
+            role: input.role,
+            text,
+        },
+    ];
+};
+
+export const finalizeMessages = (messages: ConversationMessage[]) => {
+    return messages.map((message, index) => ({
+        ...message,
+        order: index,
+    }));
+};

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

@@ -0,0 +1,148 @@
+import { listAntigravityConversations, readAntigravityConversationMessages } from '../antigravity-db';
+import type { AntigravityConversation } from '../antigravity-exporter-types';
+import { resolveAntigravityRoots } from '../antigravity-exporter-types';
+import { cleanInlineTitle } from '../shared';
+import { createDeepLinks, decodeFileUri, finalizeMessages } from './adapter-helpers';
+import { selectConversationMessages } from './message-selector';
+import { getConversationPathMatch, getFirstConversationPathMatch } from './path-match';
+import type {
+    ConversationAdapter,
+    ConversationDetail,
+    ConversationMessage,
+    ConversationPathMatch,
+    GetConversationOptions,
+    ListConversationsForPathOptions,
+} from './types';
+
+const getRoots = (options: { locations?: { antigravityRoots?: string[] } }) =>
+    options.locations?.antigravityRoots ?? resolveAntigravityRoots();
+
+const getWorkspacePath = (conversation: AntigravityConversation) =>
+    conversation.workspaceFolder ?? decodeFileUri(conversation.workspaceUri);
+
+const stripTrailingPathPunctuation = (value: string) => value.replace(/[),.;:\]`]+$/u, '');
+
+const extractAbsolutePathReferences = (text: string): string[] => {
+    return [...new Set((text.match(/\/[^\s"'`)\]]+/gu) ?? []).map(stripTrailingPathPunctuation))];
+};
+
+const readMessages = async (conversation: AntigravityConversation) => {
+    const messages = await readAntigravityConversationMessages(conversation);
+    return finalizeMessages(
+        messages.map(
+            (message): ConversationMessage => ({
+                ...message,
+                id: `${conversation.conversationId}:${message.order}:${message.role}:${message.phase}`,
+                metadata: {
+                    ...message.metadata,
+                    model: conversation.model,
+                    transcriptSource: conversation.transcriptSource,
+                },
+            }),
+        ),
+    );
+};
+
+const buildConversation = async (
+    conversation: AntigravityConversation,
+    matches: ConversationPathMatch[],
+    options: Pick<ListConversationsForPathOptions, 'includeMessages' | 'messageSelector'>,
+    preloadedMessages: ConversationMessage[] | null = null,
+): Promise<ConversationDetail> => {
+    const allMessages = options.includeMessages ? (preloadedMessages ?? (await readMessages(conversation))) : [];
+    const messages = options.includeMessages
+        ? selectConversationMessages(allMessages, options.messageSelector ?? 'last_final_answer')
+        : [];
+    const workspacePath = getWorkspacePath(conversation);
+
+    return {
+        createdAtMs: conversation.createdAtMs,
+        deepLinks: createDeepLinks(
+            'antigravity',
+            conversation.conversationId,
+            `/antigravity-conversations/${conversation.conversationId}`,
+        ),
+        id: conversation.conversationId,
+        matches,
+        messageCount: options.includeMessages ? allMessages.length : conversation.transcriptEntryCount,
+        messages,
+        metadata: {
+            artifactCount: conversation.artifactCount,
+            lockedTranscript: conversation.transcriptSource === 'safe-storage',
+            model: conversation.model,
+            transcriptSource: conversation.transcriptSource,
+        },
+        source: 'antigravity',
+        title: cleanInlineTitle(conversation.title),
+        updatedAtMs: conversation.lastUpdatedAtMs ?? conversation.conversationMtimeMs,
+        workspaceKey: conversation.workspaceKey,
+        workspacePath,
+    };
+};
+
+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[],
+): Promise<ConversationPathMatch | null> => {
+    const referencedPaths = messages.flatMap((message) => extractAbsolutePathReferences(message.text));
+    return getFirstConversationPathMatch(requestedPath, referencedPaths);
+};
+
+const listAntigravityConversationsForPath = async (options: ListConversationsForPathOptions) => {
+    const roots = getRoots(options);
+    const conversations = await listAntigravityConversations(roots);
+    const result: ConversationDetail[] = [];
+
+    for (const conversation of conversations) {
+        if (!isWithinUpdatedWindow(conversation, options)) {
+            continue;
+        }
+
+        const workspacePath = getWorkspacePath(conversation);
+        const match = await getConversationPathMatch(options.cwd, workspacePath);
+        if (match) {
+            result.push(await buildConversation(conversation, [match], options));
+            continue;
+        }
+
+        const messages = await readMessages(conversation);
+        const referencedPathMatch = await getReferencedPathMatch(options.cwd, messages);
+        if (referencedPathMatch) {
+            result.push(await buildConversation(conversation, [referencedPathMatch], options, messages));
+        }
+    }
+
+    return result;
+};
+
+const getAntigravityConversation = async (options: GetConversationOptions): Promise<ConversationDetail | null> => {
+    const conversation = (await listAntigravityConversations(getRoots(options))).find(
+        (entry) => entry.conversationId === options.id,
+    );
+    return conversation
+        ? buildConversation(conversation, [], {
+              includeMessages: true,
+              messageSelector: options.messageSelector ?? 'all',
+          })
+        : null;
+};
+
+export const antigravityConversationAdapter: ConversationAdapter = {
+    getConversation: getAntigravityConversation,
+    listConversationsForPath: listAntigravityConversationsForPath,
+    source: 'antigravity',
+};

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

@@ -0,0 +1,175 @@
+import {
+    listClaudeCodeSessionsForGroup,
+    listClaudeCodeWorkspaceGroups,
+    readClaudeCodeSessionTranscript,
+} from '../claude-code-db';
+import type {
+    ClaudeCodeSessionSummary,
+    ClaudeCodeSessionTranscript,
+    ClaudeCodeTranscriptEntry,
+    ClaudeCodeTranscriptPart,
+} from '../claude-code-exporter-types';
+import { getClaudeCodeAssistantMessagePhase, resolveClaudeCodeProjectsDir } from '../claude-code-exporter-types';
+import { cleanInlineTitle } from '../shared';
+import {
+    createDeepLinks,
+    createTextMessage,
+    finalizeMessages,
+    normalizeAssistantPhase,
+    normalizeRole,
+    toDateMs,
+} from './adapter-helpers';
+import { selectConversationMessages } from './message-selector';
+import { getConversationPathMatch } from './path-match';
+import type {
+    ConversationAdapter,
+    ConversationDetail,
+    ConversationMessage,
+    ConversationPathMatch,
+    GetConversationOptions,
+    ListConversationsForPathOptions,
+} from './types';
+
+const getProjectsDir = (options: { locations?: { claudeCodeProjectsDir?: string } }) =>
+    options.locations?.claudeCodeProjectsDir ?? resolveClaudeCodeProjectsDir();
+
+const partToMessages = (
+    entry: ClaudeCodeTranscriptEntry,
+    part: ClaudeCodeTranscriptPart,
+    partIndex: number,
+): ConversationMessage[] => {
+    const createdAtMs = toDateMs(entry.timestamp);
+    const baseId = `${entry.entryId}:${partIndex}`;
+    if (part.type === 'text') {
+        return createTextMessage({
+            createdAtMs,
+            id: baseId,
+            order: partIndex,
+            phase: normalizeAssistantPhase(getClaudeCodeAssistantMessagePhase(entry), 'unknown'),
+            role: normalizeRole(entry.role),
+            text: part.text,
+        });
+    }
+
+    if (part.type === 'thinking') {
+        return createTextMessage({
+            createdAtMs,
+            id: baseId,
+            order: partIndex,
+            phase: 'reasoning',
+            role: 'assistant',
+            text: part.text,
+        });
+    }
+
+    if (part.type === 'tool_use') {
+        return createTextMessage({
+            createdAtMs,
+            id: baseId,
+            metadata: { toolName: part.toolName, toolUseId: part.toolUseId },
+            order: partIndex,
+            phase: 'tool_call',
+            role: 'tool',
+            text: [part.toolName, part.argumentsText].filter(Boolean).join('\n'),
+        });
+    }
+
+    if (part.type === 'tool_result') {
+        return createTextMessage({
+            createdAtMs,
+            id: baseId,
+            metadata: { isError: part.isError, toolUseId: part.toolUseId },
+            order: partIndex,
+            phase: 'tool_output',
+            role: 'tool',
+            text: part.outputText,
+        });
+    }
+
+    return [];
+};
+
+const transcriptToMessages = (transcript: ClaudeCodeSessionTranscript): ConversationMessage[] => {
+    return finalizeMessages(
+        transcript.entries.flatMap((entry) =>
+            entry.parts.flatMap((part, partIndex) => partToMessages(entry, part, partIndex)),
+        ),
+    );
+};
+
+const buildConversation = async (
+    session: ClaudeCodeSessionSummary,
+    projectsDir: string,
+    matches: ConversationPathMatch[],
+    options: Pick<ListConversationsForPathOptions, 'includeMessages' | 'messageSelector'>,
+): Promise<ConversationDetail> => {
+    const transcript = options.includeMessages
+        ? await readClaudeCodeSessionTranscript(projectsDir, session.sessionId)
+        : null;
+    const allMessages = transcript ? transcriptToMessages(transcript) : [];
+    const messages = options.includeMessages
+        ? selectConversationMessages(allMessages, options.messageSelector ?? 'last_final_answer')
+        : [];
+
+    return {
+        createdAtMs: session.createdAtMs,
+        deepLinks: createDeepLinks('claude-code', session.sessionId, `/claude-code-sessions/${session.sessionId}`),
+        id: session.sessionId,
+        matches,
+        messageCount: options.includeMessages ? allMessages.length : session.messageCount,
+        messages,
+        metadata: {
+            filePath: session.filePath,
+            gitBranch: session.gitBranch,
+            model: session.model,
+            totalTokens: session.totalTokens,
+            version: session.version,
+        },
+        source: 'claude-code',
+        title: cleanInlineTitle(session.title),
+        updatedAtMs: session.lastActiveAtMs,
+        workspaceKey: session.workspaceKey,
+        workspacePath: session.worktree,
+    };
+};
+
+const listClaudeConversationsForPath = async (
+    options: ListConversationsForPathOptions,
+): Promise<ConversationDetail[]> => {
+    const projectsDir = getProjectsDir(options);
+    const groups = await listClaudeCodeWorkspaceGroups(projectsDir);
+    const conversations: ConversationDetail[] = [];
+
+    for (const group of groups) {
+        const match = await getConversationPathMatch(options.cwd, group.worktree);
+        if (!match) {
+            continue;
+        }
+
+        const sessions = await listClaudeCodeSessionsForGroup(group.key, projectsDir);
+        for (const session of sessions) {
+            conversations.push(await buildConversation(session, projectsDir, [match], options));
+        }
+    }
+
+    return conversations;
+};
+
+const getClaudeConversation = async (options: GetConversationOptions): Promise<ConversationDetail | null> => {
+    const projectsDir = getProjectsDir(options);
+    const transcript = await readClaudeCodeSessionTranscript(projectsDir, options.id);
+    if (!transcript) {
+        return null;
+    }
+
+    return buildConversation(transcript.session, projectsDir, [], {
+        includeMessages: true,
+        messageSelector: options.messageSelector ?? 'all',
+    });
+};
+
+export const claudeCodeConversationAdapter: ConversationAdapter = {
+    getConversation: getClaudeConversation,
+    listConversationsForPath: listClaudeConversationsForPath,
+    source: 'claude-code',
+};

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

@@ -0,0 +1,245 @@
+import { 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 { selectConversationMessages } from './message-selector';
+import { getConversationPathMatch } from './path-match';
+import type {
+    ConversationAdapter,
+    ConversationDetail,
+    ConversationMessage,
+    ConversationMessagePhase,
+    ConversationMessageRole,
+    ConversationPathMatch,
+    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 parseCodexTranscriptFile(thread.rollout_path, {
+        includeRaw: false,
+    });
+
+    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',
+    });
+};
+
+export const codexConversationAdapter: ConversationAdapter = {
+    getConversation: getCodexConversation,
+    listConversationsForPath: listCodexConversationsForPath,
+    source: 'codex',
+};