spiracha 2.0.0 → 2.1.0

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

@@ -14,6 +14,7 @@ import type {
 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,
@@ -117,18 +118,28 @@ const buildConversation = async (
     locations: ReturnType<typeof getQoderLocations>,
     matches: ConversationPathMatch[],
     options: Pick<ListConversationsForPathOptions, 'includeMessages' | 'messageSelector'>,
+    loadedTranscript: QoderSessionTranscript | null = null,
 ): Promise<ConversationDetail> => {
     const transcript = options.includeMessages
-        ? await readQoderSessionTranscript(
-              locations.globalStateDb,
-              locations.workspaceStorageDir,
-              session.sessionId,
-              locations.cliProjectsDir,
+        ? (loadedTranscript ??
+          (await runWithTranscriptLoadLimit(
+              () =>
+                  readQoderSessionTranscript(
+                      locations.globalStateDb,
+                      locations.workspaceStorageDir,
+                      session.sessionId,
+                      locations.cliProjectsDir,
+                      {
+                          acpSocketPath: locations.acpSocketPath,
+                          enableAcp: locations.acpSocketPath ? true : undefined,
+                      },
+                  ),
               {
-                  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
@@ -205,21 +216,35 @@ const listQoderConversationsForPath = async (options: ListConversationsForPathOp
 
 const getQoderConversation = async (options: GetConversationOptions): Promise<ConversationDetail | null> => {
     const locations = getQoderLocations(options);
-    const transcript = await readQoderSessionTranscript(
-        locations.globalStateDb,
-        locations.workspaceStorageDir,
-        options.id,
-        locations.cliProjectsDir,
+    const transcript = await runWithTranscriptLoadLimit(
+        () =>
+            readQoderSessionTranscript(
+                locations.globalStateDb,
+                locations.workspaceStorageDir,
+                options.id,
+                locations.cliProjectsDir,
+                {
+                    acpSocketPath: locations.acpSocketPath,
+                    enableAcp: locations.acpSocketPath ? true : undefined,
+                },
+            ),
         {
-            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',
-          })
+        ? buildConversation(
+              transcript.session,
+              locations,
+              [],
+              {
+                  includeMessages: true,
+                  messageSelector: options.messageSelector ?? 'all',
+              },
+              transcript,
+          )
         : null;
 };
 

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

@@ -1,6 +1,7 @@
 export const CONVERSATION_SOURCES = [
     'codex',
     'claude-code',
+    'grok',
     'kiro',
     'qoder',
     'cursor',
@@ -77,6 +78,7 @@ export type ConversationDataLocations = {
     claudeCodeProjectsDir?: string;
     codexDbPath?: string;
     cursorUserDir?: string;
+    grokSessionsDir?: string;
     kiroWorkspaceSessionsDir?: string;
     opencodeDbPath?: string;
     qoderAcpSocketPath?: string;
@@ -104,12 +106,53 @@ export type GetConversationOptions = {
     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;

package/src/lib/conversation-zip-export.ts

@@ -0,0 +1,57 @@
+import { randomUUID } from 'node:crypto';
+import { mkdtemp, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { resolveUniqueExportFileBaseName, sanitizeExportFileName, zipExportDirectory } from './ui-export-archive';
+
+type ConversationMarkdownZipEntry = {
+    fallbackBaseName: string;
+    markdown: string;
+    title: string | null;
+};
+
+type ConversationMarkdownZipOptions = {
+    entries: ConversationMarkdownZipEntry[];
+    fileBaseName: string;
+};
+
+export type ConversationMarkdownZip = {
+    blob: Blob;
+    fileName: string;
+    mimeType: 'application/zip';
+};
+
+const toSafeFileBaseName = (value: string | null, fallback: string) => {
+    return sanitizeExportFileName(value?.trim() || '') || sanitizeExportFileName(fallback) || 'conversation';
+};
+
+export const createConversationMarkdownZip = async ({
+    entries,
+    fileBaseName,
+}: ConversationMarkdownZipOptions): Promise<ConversationMarkdownZip> => {
+    if (entries.length === 0) {
+        throw new Error('No conversations selected for export');
+    }
+
+    const safeBaseName = toSafeFileBaseName(fileBaseName, 'conversations');
+    const workspaceDir = await mkdtemp(path.join(os.tmpdir(), `${safeBaseName}-`));
+    const zipPath = path.join(os.tmpdir(), `${safeBaseName}-${randomUUID()}.zip`);
+    const usedBaseNames = new Map<string, number>();
+
+    try {
+        for (const entry of entries) {
+            const entryBaseName = toSafeFileBaseName(entry.title, entry.fallbackBaseName);
+            const fileBaseNameForEntry = resolveUniqueExportFileBaseName(entryBaseName, usedBaseNames);
+            await Bun.write(path.join(workspaceDir, `${fileBaseNameForEntry}.md`), entry.markdown);
+        }
+
+        await zipExportDirectory(workspaceDir, zipPath);
+        return {
+            blob: new Blob([await Bun.file(zipPath).arrayBuffer()], { type: 'application/zip' }),
+            fileName: `${safeBaseName}.zip`,
+            mimeType: 'application/zip',
+        };
+    } finally {
+        await Promise.all([rm(workspaceDir, { force: true, recursive: true }), rm(zipPath, { force: true })]);
+    }
+};

package/src/lib/cursor-db.ts

@@ -126,6 +126,11 @@ const parseCodeWorkspaceJson = (text: string): { folders?: Array<{ path?: string
     }
 };
 
+const isMissingCodeWorkspaceFileError = (error: unknown): boolean => {
+    const code = (error as { code?: unknown }).code;
+    return code === 'ENOENT' || code === 'ENOTDIR';
+};
+
 const parseCodeWorkspaceFolders = async (workspaceFilePath: string): Promise<string[]> => {
     if (!workspaceFilePath.endsWith('.code-workspace')) {
         return [];
@@ -149,6 +154,10 @@ const parseCodeWorkspaceFolders = async (workspaceFilePath: string): Promise<str
 
         return folders;
     } catch (error) {
+        if (isMissingCodeWorkspaceFileError(error)) {
+            return [];
+        }
+
         warnCursorDataIssue('invalid_code_workspace_json', {
             error: error instanceof Error ? error.message : String(error),
             workspaceFilePath,
@@ -679,22 +688,32 @@ const readAllHeads = (db: Database, options: CursorDiscoveryOptions = {}): Map<s
                  WHERE key LIKE 'composerData:%'
                     AND COALESCE(json_extract(value, '$.lastUpdatedAt'), 0) >= ?`,
             )
-            .all(options.updatedAfterMs) as Array<{ id: string; value: string }>;
+            .all(options.updatedAfterMs) as Array<{ id: string; value: string | null }>;
 
         return new Map(rows.map((row) => [row.id, parseGlobalHead(row.value)]));
     }
 
     const rows = db
         .query(`SELECT substr(key, 14) AS id, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'`)
-        .all() as Array<{ id: string; value: string }>;
+        .all() as Array<{ id: string; value: string | null }>;
 
     return new Map(rows.map((row) => [row.id, parseGlobalHead(row.value)]));
 };
 
-const parseGlobalHead = (value: string): GlobalHead => {
-    let parsed: Record<string, JsonValue> = {};
+const parseGlobalHead = (value: string | null): GlobalHead => {
+    let parsed: Record<string, JsonValue> | null = {};
+    if (value === null) {
+        return {
+            createdAtMs: null,
+            lastUpdatedAtMs: null,
+            mode: null,
+            name: null,
+            pathHint: null,
+        };
+    }
+
     try {
-        parsed = JSON.parse(value) as Record<string, JsonValue>;
+        parsed = asObject(JSON.parse(value) as JsonValue);
     } catch {
         return {
             createdAtMs: null,
@@ -705,6 +724,16 @@ const parseGlobalHead = (value: string): GlobalHead => {
         };
     }
 
+    if (!parsed) {
+        return {
+            createdAtMs: null,
+            lastUpdatedAtMs: null,
+            mode: null,
+            name: null,
+            pathHint: inferFolderFromBlob(value),
+        };
+    }
+
     return {
         createdAtMs: asNumber(parsed.createdAt ?? null),
         lastUpdatedAtMs: asNumber(parsed.lastUpdatedAt ?? null),