spiracha 1.3.3 → 1.4.0

package/package.json

@@ -14,25 +14,25 @@
     "dependencies": {
         "@inquirer/prompts": "^8.5.2",
         "@modelcontextprotocol/sdk": "^1.29.0",
-        "@tanstack/react-query": "5.100.14",
-        "@tanstack/react-router": "1.170.10",
+        "@tanstack/react-query": "5.101.0",
+        "@tanstack/react-router": "1.170.15",
         "@tanstack/react-router-ssr-query": "1.167.1",
         "@tanstack/react-table": "8.21.3",
-        "@tanstack/react-virtual": "3.13.26",
+        "@tanstack/react-virtual": "3.14.2",
         "class-variance-authority": "0.7.1",
         "clsx": "2.1.1",
         "iconv-lite": "^0.7.2",
         "lucide-react": "1.17.0",
-        "radix-ui": "1.4.3",
-        "react": "19.2.6",
-        "react-dom": "19.2.6",
+        "radix-ui": "1.5.0",
+        "react": "19.2.7",
+        "react-dom": "19.2.7",
         "tailwind-merge": "3.6.0",
         "zod": "4.4.3"
     },
     "description": "Export local Codex, Claude Code, and Cursor transcripts, and browse Codex, Cursor, and Antigravity history through a local UI.",
     "devDependencies": {
         "@types/bun": "^1.3.14",
-        "@types/node": "^25.9.1",
+        "@types/node": "^25.9.2",
         "typescript": "^6.0.3"
     },
     "engines": {
@@ -86,7 +86,7 @@
         "README.md",
         "AGENTS.md"
     ],
-    "homepage": "https://github.com/ragaeeb/spiracha#readme",
+    "homepage": "https://github.com/ragaeeb/spiracha",
     "keywords": [
         "codex",
         "claude",
@@ -122,7 +122,7 @@
         "ui:preview": "bun run --cwd apps/ui preview"
     },
     "type": "module",
-    "version": "1.3.3",
+    "version": "1.4.0",
     "workspaces": [
         "apps/*"
     ]

package/src/lib/antigravity-db.ts

@@ -11,6 +11,7 @@ import {
     resolveAntigravityRoots,
 } from './antigravity-exporter-types';
 import { decryptAntigravitySafeStoragePayload } from './antigravity-keychain';
+import { mapWithConcurrency } from './concurrency';
 
 type ProtoField = {
     bytes?: Uint8Array;
@@ -39,6 +40,11 @@ type ConversationFile = {
     root: string;
 };
 
+const ANTIGRAVITY_ARTIFACT_READ_CONCURRENCY = 16;
+const SAFE_CONVERSATION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+
+const isSafeConversationId = (value: string) => SAFE_CONVERSATION_ID_PATTERN.test(value);
+
 type TranscriptFile = {
     bytes: number;
     entryCount: number;
@@ -428,25 +434,22 @@ const readArtifactsForRoot = async (root: string): Promise<Map<string, Antigravi
 
     const artifactsByConversation = new Map<string, AntigravityArtifact[]>();
     for (const entry of entries) {
-        if (!entry.isDirectory()) {
+        if (!entry.isDirectory() || !isSafeConversationId(entry.name)) {
             continue;
         }
 
         const artifactDir = path.join(brainDir, entry.name);
         const files = await readdir(artifactDir, { withFileTypes: true }).catch(() => []);
-        for (const file of files) {
-            if (!file.isFile() || !file.name.endsWith('.md')) {
-                continue;
+        const markdownFiles = files.filter((file) => file.isFile() && file.name.endsWith('.md'));
+        const artifacts = await mapWithConcurrency(markdownFiles, ANTIGRAVITY_ARTIFACT_READ_CONCURRENCY, (file) =>
+            readArtifactCandidate(root, path.join(artifactDir, file.name), file.name),
+        );
+        for (const artifact of artifacts) {
+            if (artifact) {
+                const list = artifactsByConversation.get(entry.name) ?? [];
+                list.push(artifact);
+                artifactsByConversation.set(entry.name, list);
             }
-
-            const artifactPath = path.join(artifactDir, file.name);
-            const artifact = await readArtifactCandidate(root, artifactPath, file.name);
-            if (!artifact) {
-                continue;
-            }
-            const list = artifactsByConversation.get(entry.name) ?? [];
-            list.push(artifact);
-            artifactsByConversation.set(entry.name, list);
         }
     }
 
@@ -811,6 +814,10 @@ const logEntryHeading = (entry: AntigravityLogEntry): string => {
     }
 
     if (source === 'MODEL') {
+        if (type && type !== 'PLANNER_RESPONSE') {
+            return `Tool: ${type}`;
+        }
+
         return 'Assistant';
     }
 

package/src/lib/codex-analytics.ts

@@ -1,13 +1,37 @@
 import { listScopedThreads } from './codex-browser-db';
 import type { CodexAnalytics, DistributionItem, ModelTokenSummary } from './codex-browser-types';
 import type { ThreadRow } from './codex-exporter-types';
-import { getCachedParsedCodexTranscript } from './codex-thread-cache';
-import { getPortablePathBasename } from './shared';
-import { getFileFingerprint, hashCacheKeyParts, withCachedJson } from './ui-cache';
+import { mapWithConcurrency } from './concurrency';
+import { asObject, asString, getPortablePathBasename, readJsonlObjects } from './shared';
+import { hashCacheKeyParts, hashCacheKeyPartsIterable, withCachedJson } from './ui-cache';
 
 export type CodexAnalyticsInput = {
     dbPath: string;
     project: string | null;
+    transcriptConcurrency?: number;
+};
+
+export type ThreadAnalyticsSummary = {
+    hasWebSearch: boolean;
+    toolNames: string[];
+};
+
+export type ComputeCodexAnalyticsOptions = {
+    loadThreadAnalytics?: (thread: ThreadRow) => Promise<ThreadAnalyticsSummary>;
+    transcriptConcurrency?: number;
+};
+
+export const DEFAULT_ANALYTICS_TRANSCRIPT_CONCURRENCY = 8;
+
+export const resolveAnalyticsTranscriptConcurrency = (
+    configuredValue = process.env.SPIRACHA_ANALYTICS_TRANSCRIPT_CONCURRENCY,
+) => {
+    const parsed = Number(configuredValue);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        return DEFAULT_ANALYTICS_TRANSCRIPT_CONCURRENCY;
+    }
+
+    return parsed;
 };
 
 const roundToTwoDecimals = (value: number) => {
@@ -52,28 +76,100 @@ const buildModelsByTokens = (threads: ThreadRow[]): ModelTokenSummary[] => {
         });
 };
 
-const buildAnalyticsCacheKey = async (dbPath: string, threads: ThreadRow[], project: string | null) => {
-    const dbFingerprint = await getFileFingerprint(dbPath);
-    const rolloutFingerprints = await Promise.all(threads.map((thread) => getFileFingerprint(thread.rollout_path)));
-    return `analytics-${hashCacheKeyParts(dbFingerprint, project ?? 'all', ...rolloutFingerprints)}`;
+const timestampSignature = (thread: ThreadRow) => {
+    return String(thread.updated_at_ms ?? thread.updated_at * 1000);
 };
 
-const computeCodexAnalytics = async (threads: ThreadRow[]): Promise<CodexAnalytics> => {
+const threadMetadataCacheKeyParts = (thread: ThreadRow) => [
+    thread.id,
+    thread.rollout_path,
+    timestampSignature(thread),
+    String(thread.created_at_ms ?? thread.created_at * 1000),
+    String(thread.tokens_used),
+    String(thread.archived),
+    String(thread.archived_at ?? ''),
+    thread.cwd,
+    thread.model ?? '',
+    thread.model_provider,
+    thread.cli_version,
+    thread.title,
+    thread.preview,
+];
+
+export const buildCodexAnalyticsCacheKey = (dbPath: string, threads: ThreadRow[], project: string | null) => {
+    const parts = (function* () {
+        yield 'v2';
+        yield dbPath;
+        yield project ?? 'all';
+        yield String(threads.length);
+        for (const thread of threads) {
+            yield* threadMetadataCacheKeyParts(thread);
+        }
+    })();
+
+    return `analytics-${hashCacheKeyPartsIterable(parts)}`;
+};
+
+const buildThreadAnalyticsCacheKey = (thread: ThreadRow) => {
+    return `thread-analytics-${hashCacheKeyParts('v1', ...threadMetadataCacheKeyParts(thread))}`;
+};
+
+const parseThreadAnalyticsFile = async (sessionFile: string): Promise<ThreadAnalyticsSummary> => {
+    const toolNames: string[] = [];
+    let hasWebSearch = false;
+
+    for await (const parsed of readJsonlObjects(sessionFile)) {
+        if (parsed.type !== 'response_item') {
+            continue;
+        }
+
+        const payload = asObject(parsed.payload);
+        if (!payload) {
+            continue;
+        }
+
+        const payloadType = asString(payload.type);
+        if (payloadType === 'function_call') {
+            toolNames.push(asString(payload.name) ?? 'unknown');
+            continue;
+        }
+
+        if (payloadType === 'web_search_call' || payloadType === 'web_search_end') {
+            hasWebSearch = true;
+        }
+    }
+
+    return {
+        hasWebSearch,
+        toolNames,
+    };
+};
+
+const getCachedThreadAnalytics = async (thread: ThreadRow): Promise<ThreadAnalyticsSummary> => {
+    return withCachedJson(buildThreadAnalyticsCacheKey(thread), () => parseThreadAnalyticsFile(thread.rollout_path));
+};
+
+export const computeCodexAnalyticsFromThreads = async (
+    threads: ThreadRow[],
+    options: ComputeCodexAnalyticsOptions = {},
+): Promise<CodexAnalytics> => {
     const totalTokens = threads.reduce((sum, thread) => sum + thread.tokens_used, 0);
     const projectNames = new Set(threads.map((thread) => getPortablePathBasename(thread.cwd)).filter(Boolean));
     const toolUsage = new Map<string, number>();
-    const transcripts = await Promise.all(threads.map((thread) => getCachedParsedCodexTranscript(thread.rollout_path)));
     let threadsWithWebSearch = 0;
-
-    for (const transcript of transcripts) {
-        if (transcript.stats.webSearchEventCount > 0) {
+    const loadThreadAnalytics = options.loadThreadAnalytics ?? getCachedThreadAnalytics;
+    const transcriptConcurrency = options.transcriptConcurrency ?? resolveAnalyticsTranscriptConcurrency();
+    const threadAnalytics = await mapWithConcurrency(threads, transcriptConcurrency, (thread) =>
+        loadThreadAnalytics(thread),
+    );
+
+    for (const analytics of threadAnalytics) {
+        if (analytics.hasWebSearch) {
             threadsWithWebSearch += 1;
         }
 
-        for (const event of transcript.events) {
-            if (event.kind === 'tool_call') {
-                incrementCount(toolUsage, event.name);
-            }
+        for (const toolName of analytics.toolNames) {
+            incrementCount(toolUsage, toolName);
         }
     }
 
@@ -94,7 +190,11 @@ const computeCodexAnalytics = async (threads: ThreadRow[]): Promise<CodexAnalyti
 
 export const getCodexAnalytics = async (input: CodexAnalyticsInput): Promise<CodexAnalytics> => {
     const threads = listScopedThreads(input.dbPath, input.project);
-    const key = await buildAnalyticsCacheKey(input.dbPath, threads, input.project);
+    const key = buildCodexAnalyticsCacheKey(input.dbPath, threads, input.project);
 
-    return withCachedJson(key, async () => computeCodexAnalytics(threads));
+    return withCachedJson(key, async () =>
+        computeCodexAnalyticsFromThreads(threads, {
+            transcriptConcurrency: input.transcriptConcurrency,
+        }),
+    );
 };

package/src/lib/codex-browser-db.ts

@@ -14,6 +14,7 @@ import type {
 import type { ThreadRelations, ThreadRow } from './codex-exporter-types';
 import { DEFAULT_CODEX_DIR, DEFAULT_DB_PATH } from './codex-exporter-types';
 import { getCachedParsedCodexTranscript, getThreadRolloutLoadState } from './codex-thread-cache';
+import { mapWithConcurrency } from './concurrency';
 import { cleanInlineTitle, getPortablePathBasename } from './shared';
 import { runWithSqliteRetry } from './sqlite-retry';
 import { invalidateCacheByPrefix } from './ui-cache';
@@ -48,31 +49,6 @@ const isPromiseLike = (value: unknown): value is PromiseLike<unknown> => {
     return 'then' in value && typeof value.then === 'function';
 };
 
-const mapWithConcurrency = async <T, TResult>(
-    values: T[],
-    limit: number,
-    mapper: (value: T, index: number) => Promise<TResult>,
-) => {
-    const results = new Array<TResult>(values.length);
-    let nextIndex = 0;
-
-    const worker = async () => {
-        while (true) {
-            const currentIndex = nextIndex;
-            nextIndex += 1;
-
-            if (currentIndex >= values.length) {
-                return;
-            }
-
-            results[currentIndex] = await mapper(values[currentIndex]!, currentIndex);
-        }
-    };
-
-    await Promise.all(Array.from({ length: Math.min(limit, values.length) }, () => worker()));
-    return results;
-};
-
 const openReadonlyDb = (dbPath: string, busyTimeoutMs: number) => {
     const db = new Database(dbPath, { readonly: true });
     try {

package/src/lib/codex-browser-export.ts

@@ -6,6 +6,7 @@ import { convertSessionFile, writeSessionFileExport } from './codex-exporter-tra
 import type { CodexCliOptions } from './codex-exporter-types';
 import { applyPathTransforms, type PathDisplaySettings } from './path-transforms';
 import { type ExportFormat, getPortablePathBasename } from './shared';
+import { getExportMimeType, sanitizeExportFileName, zipExportDirectory, zipExportFile } from './ui-export-archive';
 import { buildUiExportDownloadUrl, ensureUiExportDir } from './ui-export-files';
 
 type RenderCodexThreadDownloadInput = {
@@ -18,6 +19,7 @@ type RenderCodexThreadDownloadInput = {
     pathDisplaySettings?: Pick<PathDisplaySettings, 'convertToProjectRoot' | 'redactUsername'>;
     publicExportDir?: string;
     threadId: string;
+    zipArchive?: boolean;
 };
 
 type RenderCodexThreadsDownloadInput = Omit<RenderCodexThreadDownloadInput, 'threadId'> & {
@@ -40,14 +42,6 @@ export type CodexThreadDownload =
 
 const LARGE_BROWSER_EXPORT_THRESHOLD_BYTES = 128 * 1024 * 1024;
 
-const toSanitizedFileName = (value: string) => {
-    return value
-        .replace(/[<>:"/\\|?*\u0000-\u001f]/gu, ' ')
-        .replace(/\.\.+/gu, ' ')
-        .replace(/\s+/gu, ' ')
-        .trim();
-};
-
 const formatReadableExportDate = (value: number) => {
     const date = new Date(value);
     const year = date.getUTCFullYear();
@@ -59,7 +53,7 @@ const formatReadableExportDate = (value: number) => {
 };
 
 const buildExportBaseName = (thread: ReturnType<typeof getThreadBrowseData>['thread']) => {
-    const projectName = toSanitizedFileName(getPortablePathBasename(thread.cwd) || 'thread') || 'thread';
+    const projectName = sanitizeExportFileName(getPortablePathBasename(thread.cwd) || 'thread') || 'thread';
     const timestamp = thread.updated_at_ms ?? thread.updated_at * 1000;
     return `${projectName}-${formatReadableExportDate(timestamp)}-${thread.id.slice(0, 8)}`;
 };
@@ -70,7 +64,7 @@ const buildBatchExportBaseName = (threads: Array<ReturnType<typeof getThreadBrow
         throw new Error('No threads selected for export');
     }
 
-    const projectName = toSanitizedFileName(getPortablePathBasename(firstThread.cwd) || 'threads') || 'threads';
+    const projectName = sanitizeExportFileName(getPortablePathBasename(firstThread.cwd) || 'threads') || 'threads';
     const latestTimestamp = Math.max(...threads.map((thread) => thread.updated_at_ms ?? thread.updated_at * 1000));
     return `${projectName}-${formatReadableExportDate(latestTimestamp)}-threads-${threads.length}`;
 };
@@ -111,10 +105,6 @@ const toDownloadOptions = (input: RenderCodexThreadDownloadInput): CodexCliOptio
     };
 };
 
-const getMimeType = (outputFormat: ExportFormat) => {
-    return outputFormat === 'md' ? 'text/markdown; charset=utf-8' : 'text/plain; charset=utf-8';
-};
-
 const resolvePublicExportDir = async (publicExportDir?: string) => {
     if (publicExportDir) {
         await ensureDirectory(publicExportDir);
@@ -146,7 +136,6 @@ const logExportEvent = (level: 'error' | 'info' | 'warn', event: string, details
 
 const logRolloutChangeIfDetected = (
     threadId: string,
-    rolloutPath: string,
     beforeSnapshot: RolloutSnapshot,
     afterSnapshot: RolloutSnapshot,
 ) => {
@@ -159,7 +148,6 @@ const logRolloutChangeIfDetected = (
         afterSizeBytes: afterSnapshot.sizeBytes,
         beforeMtimeMs: beforeSnapshot.mtimeMs,
         beforeSizeBytes: beforeSnapshot.sizeBytes,
-        rolloutPath,
         threadId,
     });
 };
@@ -175,39 +163,6 @@ const cleanupExportWorkspace = async (workspacePath: string) => {
     }
 };
 
-const zipExportFile = async (sourcePath: string, zipPath: string) => {
-    const proc = Bun.spawn(['zip', '-9', '-j', zipPath, sourcePath], {
-        stderr: 'pipe',
-        stdout: 'pipe',
-    });
-    const [stdoutText, stderrText, exitCode] = await Promise.all([
-        new Response(proc.stdout).text(),
-        new Response(proc.stderr).text(),
-        proc.exited,
-    ]);
-
-    if (exitCode !== 0) {
-        throw new Error(`zip failed (${exitCode}): ${(stderrText || stdoutText).trim()}`);
-    }
-};
-
-const zipExportDirectory = async (sourceDirectory: string, zipPath: string) => {
-    const proc = Bun.spawn(['zip', '-9', '-r', zipPath, '.'], {
-        cwd: sourceDirectory,
-        stderr: 'pipe',
-        stdout: 'pipe',
-    });
-    const [stdoutText, stderrText, exitCode] = await Promise.all([
-        new Response(proc.stdout).text(),
-        new Response(proc.stderr).text(),
-        proc.exited,
-    ]);
-
-    if (exitCode !== 0) {
-        throw new Error(`zip failed (${exitCode}): ${(stderrText || stdoutText).trim()}`);
-    }
-};
-
 export const renderCodexThreadDownload = async (
     input: RenderCodexThreadDownloadInput,
 ): Promise<CodexThreadDownload> => {
@@ -216,7 +171,7 @@ export const renderCodexThreadDownload = async (
     const extension = input.outputFormat === 'md' ? 'md' : 'txt';
     const fileBaseName = buildExportBaseName(browseData.thread);
     const fileName = `${fileBaseName}.${extension}`;
-    const mimeType = getMimeType(input.outputFormat);
+    const mimeType = getExportMimeType(input.outputFormat);
     const transform = (text: string) =>
         input.pathDisplaySettings
             ? applyPathTransforms(text, {
@@ -228,13 +183,13 @@ export const renderCodexThreadDownload = async (
 
     logExportEvent('info', 'single_start', {
         fileName,
-        rolloutPath: browseData.thread.rollout_path,
         sizeBytes: rolloutSnapshotBefore.sizeBytes,
         threadId: input.threadId,
     });
 
     try {
         if (
+            input.zipArchive ||
             rolloutSnapshotBefore.sizeBytes > (input.largeExportThresholdBytes ?? LARGE_BROWSER_EXPORT_THRESHOLD_BYTES)
         ) {
             const exportBaseName = fileBaseName;
@@ -266,12 +221,7 @@ export const renderCodexThreadDownload = async (
             }
 
             const rolloutSnapshotAfter = await getRolloutSnapshot(browseData.thread.rollout_path);
-            logRolloutChangeIfDetected(
-                input.threadId,
-                browseData.thread.rollout_path,
-                rolloutSnapshotBefore,
-                rolloutSnapshotAfter,
-            );
+            logRolloutChangeIfDetected(input.threadId, rolloutSnapshotBefore, rolloutSnapshotAfter);
 
             const zipStat = await Bun.file(zipPath).stat();
             logExportEvent('info', 'single_zip_ready', {
@@ -307,12 +257,7 @@ export const renderCodexThreadDownload = async (
         }
 
         const rolloutSnapshotAfter = await getRolloutSnapshot(browseData.thread.rollout_path);
-        logRolloutChangeIfDetected(
-            input.threadId,
-            browseData.thread.rollout_path,
-            rolloutSnapshotBefore,
-            rolloutSnapshotAfter,
-        );
+        logRolloutChangeIfDetected(input.threadId, rolloutSnapshotBefore, rolloutSnapshotAfter);
         logExportEvent('info', 'single_inline_ready', {
             durationMs: Date.now() - startedAt,
             fileName,
@@ -412,12 +357,7 @@ export const renderCodexThreadsDownload = async (
             }
 
             const rolloutSnapshotAfter = await getRolloutSnapshot(entry.thread.rollout_path);
-            logRolloutChangeIfDetected(
-                entry.thread.id,
-                entry.thread.rollout_path,
-                rolloutSnapshotBefore,
-                rolloutSnapshotAfter,
-            );
+            logRolloutChangeIfDetected(entry.thread.id, rolloutSnapshotBefore, rolloutSnapshotAfter);
         }
 
         await zipExportDirectory(bundleDirectory, zipPath);