spiracha 1.5.0 → 2.1.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,167 @@
+import {
+    deleteAntigravityConversation,
+    listAntigravityConversations,
+    readAntigravityConversationMessages,
+} from '../antigravity-db';
+import type { AntigravityConversation } from '../antigravity-exporter-types';
+import { resolveAntigravityRoots } from '../antigravity-exporter-types';
+import { cleanInlineTitle } from '../shared';
+import { runWithTranscriptLoadLimit } from '../transcript-load-limiter';
+import { createDeepLinks, decodeFileUri, finalizeMessages } from './adapter-helpers';
+import { selectConversationMessages } from './message-selector';
+import { getConversationPathMatch, getFirstConversationPathMatch } from './path-match';
+import type {
+    ConversationAdapter,
+    ConversationDetail,
+    ConversationMessage,
+    ConversationPathMatch,
+    DeleteConversationOptions,
+    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 runWithTranscriptLoadLimit(() => readAntigravityConversationMessages(conversation), {
+        id: conversation.conversationId,
+        path: conversation.transcriptPath ?? conversation.conversationPath ?? undefined,
+        source: 'antigravity-api',
+    });
+    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;
+};
+
+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

@@ -0,0 +1,206 @@
+import {
+    deleteClaudeCodeSession,
+    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 { runWithTranscriptLoadLimit } from '../transcript-load-limiter';
+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,
+    DeleteConversationOptions,
+    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'>,
+    loadedTranscript: ClaudeCodeSessionTranscript | null = null,
+): Promise<ConversationDetail> => {
+    const transcript = options.includeMessages
+        ? (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
+        ? 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 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',
+        },
+        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',
+};