spiracha 2.0.0 → 2.2.0

package/src/lib/claude-code-exporter-types.ts

@@ -1,5 +1,6 @@
 import os from 'node:os';
 import path from 'node:path';
+import type { ClaudeCodeAssistantMessagePhase } from './claude-code-transcript-phase';
 import type { ExportFormat, JsonValue } from './shared';
 
 export type { ClaudeCodeAssistantMessagePhase } from './claude-code-transcript-phase';
@@ -84,6 +85,7 @@ export type ClaudeCodeTranscriptPart = {
 };
 
 export type ClaudeCodeTranscriptEntry = {
+    assistantPhase?: ClaudeCodeAssistantMessagePhase | null;
     cwd: string | null;
     entryId: string;
     model?: string | null;
@@ -97,6 +99,9 @@ export type ClaudeCodeTranscriptEntry = {
 
 export type ClaudeCodeSessionTranscript = {
     entries: ClaudeCodeTranscriptEntry[];
+    isPartial?: boolean;
+    omittedEntryCount?: number;
+    rawPayloadsOmitted?: boolean;
     rawEvents: Record<string, JsonValue>[];
     renderablePartCount: number;
     session: ClaudeCodeSessionSummary;

package/src/lib/claude-code-transcript-phase.ts

@@ -3,16 +3,39 @@ import type { JsonValue } from './shared';
 export type ClaudeCodeAssistantMessagePhase = 'commentary' | 'final_answer';
 
 type ClaudeCodeAssistantPhaseEntry = {
+    assistantPhase?: ClaudeCodeAssistantMessagePhase | null;
+    parts?: Array<{
+        text?: string;
+        type: string;
+    }>;
     raw: Record<string, JsonValue>;
     role: string;
 };
 
+type ClaudeCodeFilterEntry = ClaudeCodeAssistantPhaseEntry & {
+    parts: Array<{
+        text?: string;
+        type: string;
+    }>;
+};
+
+const SYNTHETIC_USER_TEXT_PREFIXES = [
+    '<local-command-caveat>',
+    '<local-command-stdout>',
+    '<task-notification>',
+    '[Request interrupted by user]',
+] as const;
+
 const asMessageObject = (value: JsonValue | undefined): Record<string, JsonValue> | null => {
     return typeof value === 'object' && value !== null && !Array.isArray(value)
         ? (value as Record<string, JsonValue>)
         : null;
 };
 
+export const isClaudeCodeRawFlagEnabled = (value: JsonValue | undefined): boolean => {
+    return value === true || value === 'true';
+};
+
 export const getClaudeCodeAssistantMessagePhase = (
     entry: ClaudeCodeAssistantPhaseEntry,
 ): ClaudeCodeAssistantMessagePhase | null => {
@@ -20,6 +43,42 @@ export const getClaudeCodeAssistantMessagePhase = (
         return null;
     }
 
+    if (entry.assistantPhase) {
+        return entry.assistantPhase;
+    }
+
     const stopReason = asMessageObject(entry.raw.message)?.stop_reason;
-    return stopReason === 'tool_use' ? 'commentary' : 'final_answer';
+    if (stopReason !== 'tool_use') {
+        return 'final_answer';
+    }
+
+    const toolUseIndex = entry.parts?.findIndex((part) => part.type === 'tool_use') ?? -1;
+    const hasTextAfterToolUse =
+        toolUseIndex >= 0 &&
+        entry.parts?.slice(toolUseIndex + 1).some((part) => part.type === 'text' && part.text?.trim()) === true;
+    return hasTextAfterToolUse ? 'final_answer' : 'commentary';
+};
+
+export const isClaudeCodeSyntheticTranscriptEntry = (entry: ClaudeCodeFilterEntry): boolean => {
+    if (
+        isClaudeCodeRawFlagEnabled(entry.raw.isApiErrorMessage) ||
+        isClaudeCodeRawFlagEnabled(entry.raw.isMeta) ||
+        isClaudeCodeRawFlagEnabled(entry.raw.isCompactSummary)
+    ) {
+        return true;
+    }
+
+    if (asMessageObject(entry.raw.message)?.model === '<synthetic>') {
+        return true;
+    }
+
+    if (entry.role !== 'user') {
+        return false;
+    }
+
+    const text = entry.parts.find((part) => part.type === 'text')?.text?.trim() ?? '';
+    return (
+        text.startsWith('<command-name>/compact</command-name>') ||
+        SYNTHETIC_USER_TEXT_PREFIXES.some((prefix) => text.startsWith(prefix))
+    );
 };

package/src/lib/claude-code-transcript.ts

@@ -5,7 +5,10 @@ import type {
     ClaudeCodeTranscriptEntry,
     ClaudeCodeTranscriptPart,
 } from './claude-code-exporter-types';
-import { getClaudeCodeAssistantMessagePhase } from './claude-code-transcript-phase';
+import {
+    getClaudeCodeAssistantMessagePhase,
+    isClaudeCodeSyntheticTranscriptEntry,
+} from './claude-code-transcript-phase';
 import {
     cleanExtractedText,
     cleanInlineTitle,
@@ -102,7 +105,7 @@ const renderToolResultPart = (part: ClaudeCodeTranscriptPart, options: ClaudeCod
         return '';
     }
 
-    const outputText = part.outputText?.trim();
+    const outputText = (part.outputText ?? '').trim();
     if (!outputText) {
         return '';
     }
@@ -160,9 +163,9 @@ export const renderClaudeCodeTranscript = (
     transcript: ClaudeCodeSessionTranscript,
     options: ClaudeCodeExportOptions,
 ): string | null => {
-    const sections = transcript.entries.flatMap((entry) =>
-        entry.parts.map((part) => renderPart(entry, part, options)).filter(Boolean),
-    );
+    const sections = transcript.entries
+        .filter((entry) => !isClaudeCodeSyntheticTranscriptEntry(entry))
+        .flatMap((entry) => entry.parts.map((part) => renderPart(entry, part, options)).filter(Boolean));
     if (sections.length === 0) {
         return null;
     }

package/src/lib/codex-analytics.ts

@@ -2,8 +2,9 @@ import { listScopedThreads } from './codex-browser-db';
 import type { CodexAnalytics, DistributionItem, ModelTokenSummary } from './codex-browser-types';
 import type { ThreadRow } from './codex-thread-types';
 import { mapWithConcurrency } from './concurrency';
-import { asObject, asString, getPortablePathBasename, readJsonlObjects } from './shared';
-import { hashCacheKeyParts, hashCacheKeyPartsIterable, withCachedJson } from './ui-cache';
+import { getPortablePathBasename } from './portable-path';
+import { asObject, asString, readJsonlObjects } from './shared';
+import { hashCacheKeyPartsIterable, withCachedJson } from './ui-cache';
 
 export type CodexAnalyticsInput = {
     dbPath: string;
@@ -38,6 +39,20 @@ const roundToTwoDecimals = (value: number) => {
     return Number(value.toFixed(2));
 };
 
+const median = (values: number[]) => {
+    if (values.length === 0) {
+        return 0;
+    }
+
+    const sorted = [...values].sort((left, right) => left - right);
+    const midpoint = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 1) {
+        return sorted[midpoint]!;
+    }
+
+    return roundToTwoDecimals((sorted[midpoint - 1]! + sorted[midpoint]!) / 2);
+};
+
 const incrementCount = (counts: Map<string, number>, key: string) => {
     counts.set(key, (counts.get(key) ?? 0) + 1);
 };
@@ -90,6 +105,8 @@ const threadMetadataCacheKeyParts = (thread: ThreadRow) => [
     String(thread.archived_at ?? ''),
     thread.cwd,
     thread.model ?? '',
+    thread.reasoning_effort ?? '',
+    thread.source,
     thread.model_provider,
     thread.cli_version,
     thread.title,
@@ -98,7 +115,7 @@ const threadMetadataCacheKeyParts = (thread: ThreadRow) => [
 
 export const buildCodexAnalyticsCacheKey = (dbPath: string, threads: ThreadRow[], project: string | null) => {
     const parts = (function* () {
-        yield 'v2';
+        yield 'v3';
         yield dbPath;
         yield project ?? 'all';
         yield String(threads.length);
@@ -111,7 +128,7 @@ export const buildCodexAnalyticsCacheKey = (dbPath: string, threads: ThreadRow[]
 };
 
 const buildThreadAnalyticsCacheKey = (thread: ThreadRow) => {
-    return `thread-analytics-${hashCacheKeyParts('v1', ...threadMetadataCacheKeyParts(thread))}`;
+    return `thread-analytics-${hashCacheKeyPartsIterable(['v1', ...threadMetadataCacheKeyParts(thread)])}`;
 };
 
 const parseThreadAnalyticsFile = async (sessionFile: string): Promise<ThreadAnalyticsSummary> => {
@@ -129,7 +146,7 @@ const parseThreadAnalyticsFile = async (sessionFile: string): Promise<ThreadAnal
         }
 
         const payloadType = asString(payload.type);
-        if (payloadType === 'function_call') {
+        if (payloadType === 'function_call' || payloadType === 'custom_tool_call') {
             toolNames.push(asString(payload.name) ?? 'unknown');
             continue;
         }
@@ -155,6 +172,8 @@ export const computeCodexAnalyticsFromThreads = async (
 ): 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 reasoningEfforts = new Map<string, number>();
+    const sources = new Map<string, number>();
     const toolUsage = new Map<string, number>();
     let threadsWithWebSearch = 0;
     const loadThreadAnalytics = options.loadThreadAnalytics ?? getCachedThreadAnalytics;
@@ -163,6 +182,11 @@ export const computeCodexAnalyticsFromThreads = async (
         loadThreadAnalytics(thread),
     );
 
+    for (const thread of threads) {
+        incrementCount(reasoningEfforts, thread.reasoning_effort?.trim() || 'unspecified');
+        incrementCount(sources, thread.source.trim() || 'unknown');
+    }
+
     for (const analytics of threadAnalytics) {
         if (analytics.hasWebSearch) {
             threadsWithWebSearch += 1;
@@ -175,10 +199,13 @@ export const computeCodexAnalyticsFromThreads = async (
 
     return {
         modelsByTokens: buildModelsByTokens(threads),
+        reasoningEfforts: toDistribution(reasoningEfforts),
+        sources: toDistribution(sources),
         summary: {
             archivedThreads: threads.filter((thread) => Boolean(thread.archived)).length,
             averageTokensPerThread: threads.length === 0 ? 0 : roundToTwoDecimals(totalTokens / threads.length),
             distinctToolNames: toolUsage.size,
+            medianTokensPerThread: median(threads.map((thread) => thread.tokens_used)),
             threadsWithWebSearch,
             totalProjects: projectNames.size,
             totalThreads: threads.length,