spiracha 2.1.0 → 2.2.0

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

@@ -15,6 +15,7 @@ import {
     isClaudeCodeSyntheticTranscriptEntry,
 } from './claude-code-transcript-phase';
 import { mapWithConcurrency } from './concurrency';
+import { getPortablePathBasename } from './portable-path';
 import {
     asBoolean,
     asNumber,
@@ -22,9 +23,9 @@ import {
     asString,
     cleanExtractedText,
     cleanInlineTitle,
-    getPortablePathBasename,
     isWorkspacePathQuery,
     type JsonValue,
+    readDirectoryEntriesIfExists,
     readJsonlObjects,
     workspacePathMatchesQuery,
 } from './shared';
@@ -579,13 +580,14 @@ const markLatestAssistantAsCommentary = (entries: ClaudeCodeTranscriptEntry[]):
     }
 };
 
-const isSubagentTaskNotification = (raw: Record<string, JsonValue>): boolean => {
-    return (
-        raw.type === 'queue-operation' &&
-        asString(raw.content ?? null)
-            ?.trimStart()
-            .startsWith('<task-notification>') === true
-    );
+const isTaskNotification = (raw: Record<string, JsonValue>): boolean => {
+    const content =
+        raw.type === 'queue-operation'
+            ? asString(raw.content ?? null)
+            : raw.type === 'user'
+              ? textFromContentValue(asObject(raw.message ?? null)?.content)
+              : null;
+    return content?.trimStart().startsWith('<task-notification>') === true;
 };
 
 const buildTranscriptFromRawEvents = (
@@ -612,7 +614,7 @@ const buildTranscriptFromRawEvents = (
         updateTimeline(timeline, raw);
         updateIdentityFromRaw(identity, raw);
 
-        if (isSubagentTaskNotification(raw)) {
+        if (isTaskNotification(raw)) {
             markLatestAssistantAsCommentary(entries);
         }
 
@@ -669,7 +671,7 @@ const readTranscriptFile = async (
 
 const listTranscriptFilesForProject = async (projectsDir: string, directoryName: string): Promise<TranscriptFile[]> => {
     const projectDir = path.join(projectsDir, directoryName);
-    const entries = await readdir(projectDir, { withFileTypes: true }).catch(() => []);
+    const entries = await readDirectoryEntriesIfExists(projectDir);
     return entries
         .filter((entry) => entry.isFile() && entry.name.endsWith('.jsonl'))
         .map((entry) => ({
@@ -928,7 +930,11 @@ const compareNullableMsDesc = (left: number | null, right: number | null): numbe
 };
 
 const toWorkspaceGroup = (directoryName: string, sessions: ClaudeCodeSessionSummary[]): ClaudeCodeWorkspaceGroup => {
-    const worktree = sessions[0]?.worktree ?? decodeWorktreeFromDirectoryName(directoryName);
+    const decodedWorktree = decodeWorktreeFromDirectoryName(directoryName);
+    const worktree =
+        sessions.find((session) => session.worktree !== decodedWorktree)?.worktree ??
+        sessions[0]?.worktree ??
+        decodedWorktree;
     const lastActiveAtMs = sessions.reduce<number | null>((latest, session) => {
         if (session.lastActiveAtMs === null) {
             return latest;
@@ -1014,17 +1020,17 @@ export const findClaudeCodeWorkspaceGroups = (
     return groups.filter((group) => claudeCodeWorkspaceMatchesQuery(group, query));
 };
 
+const compareSessions = (left: ClaudeCodeSessionSummary, right: ClaudeCodeSessionSummary) =>
+    compareNullableMsDesc(left.lastActiveAtMs, right.lastActiveAtMs) || left.title.localeCompare(right.title);
+
 const sortSessions = (sessions: ClaudeCodeSessionSummary[]): ClaudeCodeSessionSummary[] => {
-    return [...sessions].sort(
-        (left, right) =>
-            compareNullableMsDesc(left.lastActiveAtMs, right.lastActiveAtMs) || left.title.localeCompare(right.title),
-    );
+    return [...sessions].sort(compareSessions);
 };
 
-export const listClaudeCodeSessionsForGroup = async (
+export const listClaudeCodeSessionTranscriptsForGroup = async (
     workspaceKey: string,
     projectsDir = resolveClaudeCodeProjectsDir(),
-): Promise<ClaudeCodeSessionSummary[]> => {
+): Promise<ClaudeCodeSessionTranscript[]> => {
     const directoryName = getDirectoryNameFromWorkspaceKey(workspaceKey);
     if (!directoryName || !(await pathExists(projectsDir))) {
         return [];
@@ -1032,12 +1038,32 @@ export const listClaudeCodeSessionsForGroup = async (
 
     const files = await listTranscriptFilesForProject(projectsDir, directoryName);
     const transcripts = coalesceTranscriptLineages(await readTranscriptFiles(files));
-    return sortSessions(transcripts.filter(hasSessionContent).map((transcript) => transcript.session));
+    return transcripts.filter(hasSessionContent).sort((left, right) => compareSessions(left.session, right.session));
+};
+
+export const listClaudeCodeSessionsForGroup = async (
+    workspaceKey: string,
+    projectsDir = resolveClaudeCodeProjectsDir(),
+): Promise<ClaudeCodeSessionSummary[]> => {
+    return sortSessions(
+        (await listClaudeCodeSessionTranscriptsForGroup(workspaceKey, projectsDir)).map(
+            (transcript) => transcript.session,
+        ),
+    );
 };
 
 const locateSessionFile = async (projectsDir: string, sessionId: string): Promise<TranscriptFile | null> => {
     const files = await listTranscriptFiles(projectsDir);
-    return files.find((file) => path.basename(file.filePath, '.jsonl') === sessionId) ?? null;
+    const filenameMatch = files.find((file) => path.basename(file.filePath, '.jsonl') === sessionId);
+    if (filenameMatch) {
+        return filenameMatch;
+    }
+
+    const bodyMatches = await mapWithConcurrency(files, READ_CONCURRENCY, async (file) => {
+        const parsed = await readTranscriptFile(file, { includeRawPayloads: false });
+        return parsed?.transcript.session.sessionId === sessionId ? file : null;
+    });
+    return bodyMatches.find((file): file is TranscriptFile => file !== null) ?? null;
 };
 
 export const readClaudeCodeSessionTranscript = async (

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,