spiracha 1.5.0 → 2.1.0

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

@@ -0,0 +1,202 @@
+import {
+    deleteOpenCodeSession,
+    listOpenCodeSessionsForGroup,
+    listOpenCodeWorkspaceGroups,
+    readOpenCodeSessionTranscript,
+} from '../opencode-db';
+import type {
+    OpenCodeSessionSummary,
+    OpenCodeSessionTranscript,
+    OpenCodeTranscriptPart,
+} from '../opencode-exporter-types';
+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,
+    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 getDbPath = (options: { locations?: { opencodeDbPath?: string } }) =>
+    options.locations?.opencodeDbPath ?? resolveOpenCodeDbPath();
+
+const textPartToMessages = (
+    part: OpenCodeTranscriptPart,
+    finalTextPartIds: Set<string>,
+    order: number,
+): ConversationMessage[] => {
+    const split = splitOpenCodeThinkTaggedText(part.text ?? '');
+    return [
+        ...createTextMessage({
+            createdAtMs: part.createdAtMs,
+            id: `${part.partId}:reasoning`,
+            order,
+            phase: 'reasoning',
+            role: 'assistant',
+            text: split.reasoningBlocks.join('\n\n'),
+        }),
+        ...createTextMessage({
+            createdAtMs: part.createdAtMs,
+            id: part.partId,
+            order,
+            phase: normalizeAssistantPhase(getOpenCodeTextPartPhase(part, finalTextPartIds), 'unknown'),
+            role: normalizeRole(part.role),
+            text: split.visibleText,
+        }),
+    ];
+};
+
+const partToMessages = (
+    part: OpenCodeTranscriptPart,
+    finalTextPartIds: Set<string>,
+    order: number,
+): ConversationMessage[] => {
+    if (part.type === 'text') {
+        return textPartToMessages(part, finalTextPartIds, order);
+    }
+
+    if (part.type === 'reasoning') {
+        return createTextMessage({
+            createdAtMs: part.createdAtMs,
+            id: part.partId,
+            order,
+            phase: 'reasoning',
+            role: 'assistant',
+            text: part.text,
+        });
+    }
+
+    if (part.type === 'tool') {
+        return createTextMessage({
+            createdAtMs: part.createdAtMs,
+            id: part.partId,
+            metadata: { callId: part.callId, status: part.status, toolName: part.toolName },
+            order,
+            phase: part.outputText ? 'tool_output' : 'tool_call',
+            role: 'tool',
+            text: part.outputText ?? part.argumentsText ?? part.title ?? part.toolName,
+        });
+    }
+
+    return [];
+};
+
+const transcriptToMessages = (transcript: OpenCodeSessionTranscript) => {
+    const parts = transcript.messages.flatMap((message) => message.parts);
+    const finalTextPartIds = getFinalOpenCodeAssistantTextPartIds(parts);
+    return finalizeMessages(parts.flatMap((part, order) => partToMessages(part, finalTextPartIds, order)));
+};
+
+const buildConversation = async (
+    session: OpenCodeSessionSummary,
+    dbPath: string,
+    matches: ConversationPathMatch[],
+    options: Pick<ListConversationsForPathOptions, 'includeMessages' | 'messageSelector'>,
+    loadedTranscript: OpenCodeSessionTranscript | null = null,
+): Promise<ConversationDetail> => {
+    const transcript =
+        loadedTranscript ??
+        (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')
+        : [];
+
+    return {
+        createdAtMs: session.createdAtMs,
+        deepLinks: createDeepLinks('opencode', session.sessionId, `/opencode-sessions/${session.sessionId}`),
+        id: session.sessionId,
+        matches,
+        messageCount: options.includeMessages ? allMessages.length : session.messageCount,
+        messages,
+        metadata: {
+            agent: session.agent,
+            cost: session.cost,
+            model: session.model,
+            modelLabel: session.modelLabel,
+            totalTokens: session.totalTokens,
+        },
+        source: 'opencode',
+        title: cleanInlineTitle(session.title),
+        updatedAtMs: session.lastUpdatedAtMs,
+        workspaceKey: session.workspaceKey,
+        workspacePath: session.worktree,
+    };
+};
+
+const listOpenCodeConversationsForPath = async (options: ListConversationsForPathOptions) => {
+    const dbPath = getDbPath(options);
+    const groups = await listOpenCodeWorkspaceGroups(dbPath);
+    const conversations: ConversationDetail[] = [];
+
+    for (const group of groups) {
+        const match = await getConversationPathMatch(options.cwd, group.worktree);
+        if (!match) {
+            continue;
+        }
+        const sessions = await listOpenCodeSessionsForGroup(group.key, dbPath);
+        for (const session of sessions) {
+            conversations.push(await buildConversation(session, dbPath, [match], options));
+        }
+    }
+
+    return conversations;
+};
+
+const getOpenCodeConversation = async (options: GetConversationOptions): Promise<ConversationDetail | null> => {
+    const dbPath = getDbPath(options);
+    const transcript = await runWithTranscriptLoadLimit(() => readOpenCodeSessionTranscript(dbPath, options.id), {
+        id: options.id,
+        path: dbPath,
+        source: 'opencode-api',
+    });
+    return transcript
+        ? buildConversation(
+              transcript.session,
+              dbPath,
+              [],
+              {
+                  includeMessages: true,
+                  messageSelector: options.messageSelector ?? 'all',
+              },
+              transcript,
+          )
+        : 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',
+};

package/src/lib/conversation-data/path-match.ts

@@ -0,0 +1,79 @@
+import { realpath } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import type { ConversationPathMatch } from './types';
+
+const expandHome = (value: string) => {
+    if (value === '~') {
+        return os.homedir();
+    }
+
+    if (value.startsWith('~/') || value.startsWith('~\\')) {
+        return path.join(os.homedir(), value.slice(2));
+    }
+
+    return value;
+};
+
+const trimTrailingSeparators = (value: string) => {
+    const trimmed = value.replace(/[\\/]+$/u, '');
+    return trimmed || value;
+};
+
+const normalizeSeparators = (value: string) => value.replace(/\\/gu, '/');
+
+export const normalizeConversationPath = async (value: string): Promise<string> => {
+    const expanded = expandHome(value.trim());
+    const absolute = path.isAbsolute(expanded) ? expanded : path.resolve(expanded);
+    const resolved = await realpath(absolute).catch(() => absolute);
+    return normalizeSeparators(trimTrailingSeparators(resolved));
+};
+
+export const getConversationPathMatch = async (
+    requestedPath: string,
+    candidatePath: string | null,
+): Promise<ConversationPathMatch | null> => {
+    if (!candidatePath?.trim()) {
+        return null;
+    }
+
+    const [requested, candidate] = await Promise.all([
+        normalizeConversationPath(requestedPath),
+        normalizeConversationPath(candidatePath),
+    ]);
+
+    if (requested === candidate) {
+        return {
+            candidatePath: candidate,
+            kind: 'exact',
+            requestedPath: requested,
+        };
+    }
+
+    if (
+        (requested === '/' && candidate !== '/' && candidate.startsWith('/')) ||
+        candidate.startsWith(`${requested}/`)
+    ) {
+        return {
+            candidatePath: candidate,
+            kind: 'descendant',
+            requestedPath: requested,
+        };
+    }
+
+    return null;
+};
+
+export const getFirstConversationPathMatch = async (
+    requestedPath: string,
+    candidatePaths: Array<string | null>,
+): Promise<ConversationPathMatch | null> => {
+    for (const candidatePath of candidatePaths) {
+        const match = await getConversationPathMatch(requestedPath, candidatePath);
+        if (match) {
+            return match;
+        }
+    }
+
+    return null;
+};

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

@@ -0,0 +1,255 @@
+import { mapWithConcurrency } from '../concurrency';
+import {
+    listQoderSessionsForGroup,
+    listQoderWorkspaceGroups,
+    readQoderSessionTranscript,
+    resolveQoderCliProjectsDir,
+} from '../qoder-db';
+import type {
+    QoderSessionSummary,
+    QoderSessionTranscript,
+    QoderTranscriptEntry,
+    QoderTranscriptPart,
+} from '../qoder-exporter-types';
+import { resolveQoderGlobalStateDb, resolveQoderWorkspaceStorageDir } from '../qoder-exporter-types';
+import { getFinalQoderAssistantMessageEntryIds, getQoderMessagePhase } from '../qoder-transcript-phase';
+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,
+    GetConversationOptions,
+    ListConversationsForPathOptions,
+} from './types';
+
+const QODER_CONVERSATION_HYDRATION_CONCURRENCY = 4;
+
+const getQoderLocations = (options: {
+    locations?: {
+        qoderAcpSocketPath?: string;
+        qoderCliProjectsDir?: string;
+        qoderGlobalStateDb?: string;
+        qoderWorkspaceStorageDir?: string;
+    };
+}) => ({
+    acpSocketPath: options.locations?.qoderAcpSocketPath,
+    cliProjectsDir: options.locations?.qoderCliProjectsDir ?? resolveQoderCliProjectsDir(),
+    globalStateDb: options.locations?.qoderGlobalStateDb ?? resolveQoderGlobalStateDb(),
+    workspaceStorageDir: options.locations?.qoderWorkspaceStorageDir ?? resolveQoderWorkspaceStorageDir(),
+});
+
+const isWithinUpdatedWindow = (
+    session: QoderSessionSummary,
+    options: Pick<ListConversationsForPathOptions, 'updatedAfterMs' | 'updatedBeforeMs'>,
+): boolean => {
+    const updatedAtMs = session.lastActiveAtMs ?? 0;
+    if (options.updatedAfterMs !== undefined && updatedAtMs < options.updatedAfterMs) {
+        return false;
+    }
+    if (options.updatedBeforeMs !== undefined && updatedAtMs > options.updatedBeforeMs) {
+        return false;
+    }
+    return true;
+};
+
+const partToMessages = (
+    entry: QoderTranscriptEntry,
+    part: QoderTranscriptPart,
+    partIndex: number,
+    finalEntryIds: Set<string>,
+): ConversationMessage[] => {
+    if (entry.entryType === 'tool_call') {
+        return createTextMessage({
+            createdAtMs: toDateMs(entry.timestamp),
+            id: `${entry.entryId}:${partIndex}`,
+            metadata: { requestId: entry.requestId },
+            order: partIndex,
+            phase: 'tool_call',
+            role: 'tool',
+            text: part.text,
+        });
+    }
+
+    if (entry.entryType === 'tool_output') {
+        return createTextMessage({
+            createdAtMs: toDateMs(entry.timestamp),
+            id: `${entry.entryId}:${partIndex}`,
+            metadata: { requestId: entry.requestId },
+            order: partIndex,
+            phase: 'tool_output',
+            role: 'tool',
+            text: part.text,
+        });
+    }
+
+    return createTextMessage({
+        createdAtMs: toDateMs(entry.timestamp),
+        id: `${entry.entryId}:${partIndex}`,
+        order: partIndex,
+        phase: normalizeAssistantPhase(getQoderMessagePhase(entry, finalEntryIds), 'unknown'),
+        role: normalizeRole(entry.role),
+        text: part.text,
+    });
+};
+
+const transcriptToMessages = (transcript: QoderSessionTranscript) => {
+    const finalEntryIds = getFinalQoderAssistantMessageEntryIds(transcript.entries);
+    return finalizeMessages(
+        transcript.entries.flatMap((entry) =>
+            entry.parts.flatMap((part, partIndex) => partToMessages(entry, part, partIndex, finalEntryIds)),
+        ),
+    );
+};
+
+const buildConversation = async (
+    session: QoderSessionSummary,
+    locations: ReturnType<typeof getQoderLocations>,
+    matches: ConversationPathMatch[],
+    options: Pick<ListConversationsForPathOptions, 'includeMessages' | 'messageSelector'>,
+    loadedTranscript: QoderSessionTranscript | null = null,
+): Promise<ConversationDetail> => {
+    const transcript = options.includeMessages
+        ? (loadedTranscript ??
+          (await runWithTranscriptLoadLimit(
+              () =>
+                  readQoderSessionTranscript(
+                      locations.globalStateDb,
+                      locations.workspaceStorageDir,
+                      session.sessionId,
+                      locations.cliProjectsDir,
+                      {
+                          acpSocketPath: locations.acpSocketPath,
+                          enableAcp: locations.acpSocketPath ? true : undefined,
+                      },
+                  ),
+              {
+                  id: session.sessionId,
+                  path: session.sourceStatePath ?? locations.globalStateDb,
+                  source: 'qoder-api',
+              },
+          )))
+        : null;
+    const allMessages = transcript ? transcriptToMessages(transcript) : [];
+    const messages = options.includeMessages
+        ? selectConversationMessages(allMessages, options.messageSelector ?? 'last_final_answer')
+        : [];
+    const assistantMessageCount = options.includeMessages
+        ? allMessages.filter((message) => message.role === 'assistant').length
+        : session.assistantMessageCount;
+    const userMessageCount = options.includeMessages
+        ? allMessages.filter((message) => message.role === 'user').length
+        : session.userMessageCount;
+    const renderablePartCount = options.includeMessages ? allMessages.length : session.renderablePartCount;
+
+    return {
+        createdAtMs: session.createdAtMs,
+        deepLinks: createDeepLinks('qoder', session.sessionId, `/qoder-sessions/${session.sessionId}`),
+        id: session.sessionId,
+        matches,
+        messageCount: options.includeMessages ? allMessages.length : session.messageCount,
+        messages,
+        metadata: {
+            agentClass: session.agentClass,
+            assistantMessageCount,
+            executionMode: session.executionMode,
+            fileOperationCount: session.fileOperationCount,
+            historyIds: session.historyIds,
+            model: session.model,
+            query: session.query,
+            renderablePartCount,
+            requestId: session.requestId,
+            sourceStatePath: session.sourceStatePath,
+            status: session.status,
+            taskId: session.taskId,
+            userMessageCount,
+            workspaceStorageId: session.workspaceStorageId,
+        },
+        source: 'qoder',
+        title: cleanInlineTitle(session.title),
+        updatedAtMs: session.lastActiveAtMs,
+        workspaceKey: session.workspaceKey,
+        workspacePath: session.worktree,
+    };
+};
+
+const listQoderConversationsForPath = async (options: ListConversationsForPathOptions) => {
+    const locations = getQoderLocations(options);
+    const groups = await listQoderWorkspaceGroups(locations.globalStateDb, locations.workspaceStorageDir);
+    const candidates: { match: ConversationPathMatch; session: QoderSessionSummary }[] = [];
+
+    for (const group of groups) {
+        const match = await getConversationPathMatch(options.cwd, group.worktree);
+        if (!match) {
+            continue;
+        }
+
+        const sessions = await listQoderSessionsForGroup(
+            group.key,
+            locations.globalStateDb,
+            locations.workspaceStorageDir,
+        );
+        for (const session of sessions) {
+            if (!isWithinUpdatedWindow(session, options)) {
+                continue;
+            }
+
+            candidates.push({ match, session });
+        }
+    }
+
+    return await mapWithConcurrency(candidates, QODER_CONVERSATION_HYDRATION_CONCURRENCY, ({ match, session }) =>
+        buildConversation(session, locations, [match], options),
+    );
+};
+
+const getQoderConversation = async (options: GetConversationOptions): Promise<ConversationDetail | null> => {
+    const locations = getQoderLocations(options);
+    const transcript = await runWithTranscriptLoadLimit(
+        () =>
+            readQoderSessionTranscript(
+                locations.globalStateDb,
+                locations.workspaceStorageDir,
+                options.id,
+                locations.cliProjectsDir,
+                {
+                    acpSocketPath: locations.acpSocketPath,
+                    enableAcp: locations.acpSocketPath ? true : undefined,
+                },
+            ),
+        {
+            id: options.id,
+            path: locations.globalStateDb,
+            source: 'qoder-api',
+        },
+    );
+    return transcript
+        ? buildConversation(
+              transcript.session,
+              locations,
+              [],
+              {
+                  includeMessages: true,
+                  messageSelector: options.messageSelector ?? 'all',
+              },
+              transcript,
+          )
+        : null;
+};
+
+export const qoderConversationAdapter: ConversationAdapter = {
+    getConversation: getQoderConversation,
+    listConversationsForPath: listQoderConversationsForPath,
+    source: 'qoder',
+};

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

@@ -0,0 +1,159 @@
+export const CONVERSATION_SOURCES = [
+    'codex',
+    'claude-code',
+    'grok',
+    'kiro',
+    'qoder',
+    'cursor',
+    'antigravity',
+    'opencode',
+] as const;
+
+export type ConversationSource = (typeof CONVERSATION_SOURCES)[number];
+
+export type ConversationMessageRole = 'assistant' | 'system' | 'tool' | 'unknown' | 'user';
+
+export type ConversationMessagePhase =
+    | 'commentary'
+    | 'final_answer'
+    | 'reasoning'
+    | 'tool_call'
+    | 'tool_output'
+    | 'unknown';
+
+export type ConversationMessageSelector = 'all' | 'last_assistant' | 'last_final_answer';
+
+export type ConversationPathMatch = {
+    candidatePath: string | null;
+    kind: 'descendant' | 'exact' | 'unknown';
+    requestedPath: string;
+};
+
+export type ConversationSourceInfo = {
+    label: string;
+    source: ConversationSource;
+};
+
+export type ConversationDeepLinks = {
+    native: string | null;
+    spiracha: string;
+    ui: string;
+};
+
+export type ConversationMessage = {
+    createdAtMs: number | null;
+    id: string;
+    metadata: Record<string, unknown>;
+    order: number;
+    phase: ConversationMessagePhase;
+    role: ConversationMessageRole;
+    text: string;
+};
+
+export type ConversationDetail = {
+    createdAtMs: number | null;
+    deepLinks: ConversationDeepLinks;
+    id: string;
+    matches: ConversationPathMatch[];
+    messageCount: number | null;
+    messages: ConversationMessage[];
+    metadata: Record<string, unknown>;
+    source: ConversationSource;
+    title: string | null;
+    updatedAtMs: number | null;
+    workspaceKey: string | null;
+    workspacePath: string | null;
+};
+
+export type ConversationPage = {
+    data: ConversationDetail[];
+    meta: {
+        hasNext: boolean;
+        nextCursor: string | null;
+    };
+};
+
+export type ConversationDataLocations = {
+    antigravityRoots?: string[];
+    claudeCodeProjectsDir?: string;
+    codexDbPath?: string;
+    cursorUserDir?: string;
+    grokSessionsDir?: string;
+    kiroWorkspaceSessionsDir?: string;
+    opencodeDbPath?: string;
+    qoderAcpSocketPath?: string;
+    qoderCliProjectsDir?: string;
+    qoderGlobalStateDb?: string;
+    qoderWorkspaceStorageDir?: string;
+};
+
+export type ListConversationsForPathOptions = {
+    cursor?: string | null;
+    cwd: string;
+    includeMessages?: boolean;
+    limit?: number;
+    locations?: ConversationDataLocations;
+    messageSelector?: ConversationMessageSelector;
+    sources?: ConversationSource[] | 'all';
+    updatedAfterMs?: number;
+    updatedBeforeMs?: number;
+};
+
+export type GetConversationOptions = {
+    id: string;
+    locations?: ConversationDataLocations;
+    messageSelector?: ConversationMessageSelector;
+    source: ConversationSource;
+};
+
+export type DeleteConversationOptions = {
+    id: string;
+    locations?: ConversationDataLocations;
+    source: ConversationSource;
+};
+
+export type DeleteConversationResult = {
+    deletedFiles: string[];
+    deletedIds: string[];
+};
+
+export type ConversationIdSetOptions = {
+    ids: string[];
+    locations?: ConversationDataLocations;
+    source: ConversationSource;
+};
+
+export type DeleteConversationsOptions = ConversationIdSetOptions;
+
+export type DeleteConversationItemResult = DeleteConversationResult & {
+    deleted: boolean;
+    id: string;
+};
+
+export type DeleteConversationsResult = DeleteConversationResult & {
+    missingIds: string[];
+    results: DeleteConversationItemResult[];
+};
+
+export type ExportConversationsZipOptions = ConversationIdSetOptions & {
+    messageSelector?: ConversationMessageSelector;
+    outputFormat?: 'md';
+};
+
+export type ConversationZipDownload = {
+    blob: Blob;
+    fileName: string;
+    mimeType: 'application/zip';
+};
+
+export type ResolvedConversationRef = {
+    id: string;
+    source: ConversationSource;
+};
+
+export type ConversationAdapter = {
+    deleteConversation?: (options: DeleteConversationOptions) => Promise<DeleteConversationResult>;
+    getConversation: (options: GetConversationOptions) => Promise<ConversationDetail | null>;
+    listConversationsForPath: (options: ListConversationsForPathOptions) => Promise<ConversationDetail[]>;
+    source: ConversationSource;
+};