spiracha 1.0.0 → 1.1.1

package/package.json

@@ -12,14 +12,27 @@
         "url": "https://github.com/ragaeeb/spiracha/issues"
     },
     "dependencies": {
-        "@inquirer/prompts": "^8.4.2",
+        "@inquirer/prompts": "^8.4.3",
         "@modelcontextprotocol/sdk": "^1.29.0",
+        "@tanstack/react-query": "5.100.14",
+        "@tanstack/react-router": "1.170.8",
+        "@tanstack/react-router-ssr-query": "1.167.0",
+        "@tanstack/react-table": "8.21.3",
+        "@tanstack/react-virtual": "3.13.25",
+        "class-variance-authority": "0.7.1",
+        "clsx": "2.1.1",
+        "iconv-lite": "^0.7.2",
+        "lucide-react": "1.16.0",
+        "radix-ui": "1.4.3",
+        "react": "19.2.6",
+        "react-dom": "19.2.6",
+        "tailwind-merge": "3.6.0",
         "zod": "^4.4.3"
     },
     "description": "Export local Codex chats and Claude Code transcripts to Markdown or plain text.",
     "devDependencies": {
-        "@types/bun": "^1.3.13",
-        "@types/node": "^25.6.2",
+        "@types/bun": "^1.3.14",
+        "@types/node": "^25.9.1",
         "typescript": "^6.0.3"
     },
     "engines": {
@@ -30,14 +43,35 @@
         "src/export-claude.ts",
         "src/mcp-server.ts",
         "src/spiracha.ts",
+        "src/ui-cli.ts",
         "src/lib/claude-exporter.ts",
         "src/lib/codex-exporter-cli.ts",
         "src/lib/codex-exporter-db.ts",
         "src/lib/codex-exporter-transcript.ts",
         "src/lib/codex-exporter-types.ts",
         "src/lib/codex-exporter.ts",
+        "src/lib/codex-browser-db.ts",
+        "src/lib/codex-browser-export.ts",
+        "src/lib/codex-browser-types.ts",
+        "src/lib/codex-thread-cache.ts",
+        "src/lib/codex-thread-parser.ts",
+        "src/lib/codex-analytics.ts",
+        "src/lib/path-transforms.ts",
+        "src/lib/sqlite-error.ts",
+        "src/lib/sqlite-retry.ts",
+        "src/lib/ui-export-files.ts",
+        "src/lib/ui-cache.ts",
         "src/lib/interactive-cli.ts",
+        "src/lib/model-label.ts",
+        "src/lib/native-open.ts",
         "src/lib/shared.ts",
+        "apps/ui/dist/client/assets/**/*",
+        "apps/ui/dist/client/favicon.ico",
+        "apps/ui/dist/client/logo192.png",
+        "apps/ui/dist/client/logo512.png",
+        "apps/ui/dist/client/manifest.json",
+        "apps/ui/dist/client/robots.txt",
+        "apps/ui/dist/server/**/*",
         "README.md",
         "AGENTS.md"
     ],
@@ -52,19 +86,31 @@
     ],
     "license": "MIT",
     "name": "spiracha",
-    "packageManager": "bun@1.3.13",
+    "packageManager": "bun@1.3.14",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/ragaeeb/spiracha.git"
     },
     "scripts": {
-        "build": "bun run typecheck",
+        "build": "bun run typecheck && bun run --cwd apps/ui build",
+        "coverage": "bun run coverage:root && bun run coverage:ui",
+        "coverage:root": "bun test --coverage --coverage-reporter=lcov --coverage-dir coverage && bun run ./src/coverage-check.ts root",
+        "coverage:ui": "bun run --cwd apps/ui coverage && bun run ./src/coverage-check.ts ui",
         "export:claude": "bun run ./src/export-claude.ts",
         "format": "biome check . --write && biome lint . --write",
+        "lint": "biome check .",
         "mcp": "bun run ./src/mcp-server.ts",
+        "smoke:package-ui": "bun run ./src/package-ui-smoke.ts",
         "start": "bun run ./src/export-chats.ts",
-        "typecheck": "bunx tsc --noEmit"
+        "typecheck": "bun run typecheck:root && bun run typecheck:ui",
+        "typecheck:root": "bunx tsc --noEmit",
+        "typecheck:ui": "bun run --cwd apps/ui typecheck",
+        "ui:dev": "bun run --cwd apps/ui dev",
+        "ui:preview": "bun run --cwd apps/ui preview"
     },
     "type": "module",
-    "version": "1.0.0"
+    "version": "1.1.1",
+    "workspaces": [
+        "apps/*"
+    ]
 }

package/src/export-chats.ts

@@ -5,7 +5,8 @@ import path from 'node:path';
 import { stdin as input, stdout as output } from 'node:process';
 import { createInterface } from 'node:readline/promises';
 import { getCodexHelpText, parseCodexCliArgs, runCodexExport } from './lib/codex-exporter';
-import { runInteractiveExport } from './lib/interactive-cli';
+import type { InteractiveExportResult } from './lib/interactive-cli';
+import { openPathNatively } from './lib/native-open';
 import { CliUsageError } from './lib/shared';
 
 export const runExportChatsCli = async (argv = process.argv.slice(2)): Promise<void> => {
@@ -43,6 +44,7 @@ const shouldRunInteractive = (argv: string[]): boolean => {
 };
 
 const runInteractiveCliFlow = async (): Promise<void> => {
+    const { runInteractiveExport } = await import('./lib/interactive-cli');
     const result = await runInteractiveExport();
     const targetFolder = await printInteractiveExportResult(result);
     await maybeOpenExportFolder(targetFolder);
@@ -54,9 +56,7 @@ const runCodexCliFlow = async (argv: string[]): Promise<void> => {
     printCodexExportResult(result);
 };
 
-const printInteractiveExportResult = async (
-    result: Awaited<ReturnType<typeof runInteractiveExport>>,
-): Promise<string> => {
+const printInteractiveExportResult = async (result: InteractiveExportResult): Promise<string> => {
     if (result.mode === 'claude') {
         console.log(`Exported ${result.sourcePath} -> ${result.outputPath}`);
         return resolveExportFolder(result.outputPath);
@@ -115,20 +115,6 @@ const resolveExportFolder = async (targetPath: string): Promise<string> => {
     return path.dirname(targetPath);
 };
 
-const openPathNatively = async (targetPath: string): Promise<void> => {
-    const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'explorer' : 'xdg-open';
-
-    const proc = Bun.spawn([command, targetPath], {
-        stderr: 'pipe',
-        stdout: 'ignore',
-    });
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
-        const errorText = await new Response(proc.stderr).text();
-        throw new Error(`Failed to open ${targetPath} with ${command}: ${errorText.trim() || `exit code ${exitCode}`}`);
-    }
-};
-
 if (import.meta.main) {
     await runExportChatsCli();
 }

package/src/lib/claude-exporter.ts

@@ -848,7 +848,7 @@ const fileExists = async (targetPath: string): Promise<boolean> => {
 };
 
 const requireValue = (value: string | undefined, flag: string): string => {
-    if (!value || value.startsWith('--')) {
+    if (!value || (value.startsWith('-') && value !== '-')) {
         throw new CliUsageError(`Missing value for ${flag}`);
     }
 

package/src/lib/codex-analytics.ts

@@ -0,0 +1,100 @@
+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';
+
+export type CodexAnalyticsInput = {
+    dbPath: string;
+    project: string | null;
+};
+
+const roundToTwoDecimals = (value: number) => {
+    return Number(value.toFixed(2));
+};
+
+const incrementCount = (counts: Map<string, number>, key: string) => {
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+};
+
+const toDistribution = (counts: Map<string, number>): DistributionItem[] => {
+    return [...counts.entries()]
+        .map(([label, count]) => ({ count, label }))
+        .sort((left, right) => {
+            if (left.count !== right.count) {
+                return right.count - left.count;
+            }
+
+            return left.label.localeCompare(right.label);
+        });
+};
+
+const buildModelsByTokens = (threads: ThreadRow[]): ModelTokenSummary[] => {
+    const models = new Map<string, { threadCount: number; totalTokens: number }>();
+
+    for (const thread of threads) {
+        const model = thread.model ?? 'unknown';
+        const current = models.get(model) ?? { threadCount: 0, totalTokens: 0 };
+        current.threadCount += 1;
+        current.totalTokens += thread.tokens_used;
+        models.set(model, current);
+    }
+
+    return [...models.entries()]
+        .map(([model, value]) => ({ model, ...value }))
+        .sort((left, right) => {
+            if (left.totalTokens !== right.totalTokens) {
+                return right.totalTokens - left.totalTokens;
+            }
+
+            return left.model.localeCompare(right.model);
+        });
+};
+
+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 computeCodexAnalytics = async (threads: ThreadRow[]): 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) {
+            threadsWithWebSearch += 1;
+        }
+
+        for (const event of transcript.events) {
+            if (event.kind === 'tool_call') {
+                incrementCount(toolUsage, event.name);
+            }
+        }
+    }
+
+    return {
+        modelsByTokens: buildModelsByTokens(threads),
+        summary: {
+            archivedThreads: threads.filter((thread) => Boolean(thread.archived)).length,
+            averageTokensPerThread: threads.length === 0 ? 0 : roundToTwoDecimals(totalTokens / threads.length),
+            distinctToolNames: toolUsage.size,
+            threadsWithWebSearch,
+            totalProjects: projectNames.size,
+            totalThreads: threads.length,
+            totalTokens,
+        },
+        toolUsage: toDistribution(toolUsage).map((item) => ({ count: item.count, name: item.label })),
+    };
+};
+
+export const getCodexAnalytics = async (input: CodexAnalyticsInput): Promise<CodexAnalytics> => {
+    const threads = listScopedThreads(input.dbPath, input.project);
+    const key = await buildAnalyticsCacheKey(input.dbPath, threads, input.project);
+
+    return withCachedJson(key, async () => computeCodexAnalytics(threads));
+};