spiracha 1.4.0 → 2.0.0

package/apps/ui/src/lib/formatters.ts

@@ -0,0 +1,149 @@
+import { formatModelLabel as formatSharedModelLabel } from '@spiracha/lib/model-label';
+
+type DateTimeFormatOptions = {
+    now?: Date;
+    timeZone?: string;
+};
+
+type DateTimeFormatterSet = {
+    dayKeyFormatter: Intl.DateTimeFormat;
+    timePartsFormatter: Intl.DateTimeFormat;
+};
+
+const DATE_TIME_FORMATTERS = new Map<string, DateTimeFormatterSet>();
+const DEFAULT_TIME_ZONE = 'UTC';
+
+const getDateTimeFormatters = (timeZone?: string): DateTimeFormatterSet => {
+    const resolvedTimeZone = timeZone ?? DEFAULT_TIME_ZONE;
+    const cacheKey = resolvedTimeZone;
+    const cached = DATE_TIME_FORMATTERS.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+
+    const created = {
+        dayKeyFormatter: new Intl.DateTimeFormat('en-CA', {
+            day: '2-digit',
+            month: '2-digit',
+            timeZone: resolvedTimeZone,
+            year: 'numeric',
+        }),
+        timePartsFormatter: new Intl.DateTimeFormat('en-US', {
+            day: 'numeric',
+            hour: 'numeric',
+            hour12: true,
+            minute: '2-digit',
+            month: 'short',
+            timeZone: resolvedTimeZone,
+            year: 'numeric',
+        }),
+    };
+
+    DATE_TIME_FORMATTERS.set(cacheKey, created);
+    return created;
+};
+
+const buildDayKey = (date: Date, timeZone?: string) => {
+    return getDateTimeFormatters(timeZone).dayKeyFormatter.format(date);
+};
+
+const formatTimeParts = (date: Date, timeZone?: string) => {
+    const parts = getDateTimeFormatters(timeZone).timePartsFormatter.formatToParts(date);
+    const partMap = new Map(parts.map((part) => [part.type, part.value]));
+    const hour = partMap.get('hour');
+    const minute = partMap.get('minute');
+    const dayPeriod = partMap.get('dayPeriod');
+
+    if (!hour || !minute || !dayPeriod) {
+        return null;
+    }
+
+    return {
+        day: partMap.get('day') ?? '',
+        month: partMap.get('month') ?? '',
+        time: `${hour}:${minute} ${dayPeriod}`.trim(),
+        year: partMap.get('year') ?? '',
+    };
+};
+
+export const formatNumber = (value: number) => {
+    return new Intl.NumberFormat('en-US').format(value);
+};
+
+export const formatTokens = (value: number) => {
+    return `${formatNumber(value)} tokens`;
+};
+
+export const formatBytes = (value: number | null | undefined) => {
+    if (!value || value <= 0) {
+        return '0 B';
+    }
+
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    let size = value;
+    let unitIndex = 0;
+
+    while (size >= 1024 && unitIndex < units.length - 1) {
+        size /= 1024;
+        unitIndex += 1;
+    }
+
+    const fractionDigits = size >= 100 || unitIndex === 0 ? 0 : 1;
+    return `${size.toFixed(fractionDigits)} ${units[unitIndex]}`;
+};
+
+export const formatDateTime = (
+    value: number | string | null | undefined,
+    options: DateTimeFormatOptions = {},
+): string => {
+    if (value === null || value === undefined || value === '') {
+        return 'n/a';
+    }
+
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        return 'n/a';
+    }
+
+    const now = options.now ?? new Date();
+    const parts = formatTimeParts(date, options.timeZone);
+    if (!parts) {
+        return 'n/a';
+    }
+
+    const { day, month, time, year } = parts;
+    const isToday = buildDayKey(date, options.timeZone) === buildDayKey(now, options.timeZone);
+
+    if (isToday) {
+        return time;
+    }
+
+    const currentYear = formatTimeParts(now, options.timeZone)?.year;
+    if (year && currentYear && year !== currentYear) {
+        return `${month} ${day}, ${year} · ${time}`;
+    }
+
+    return `${month} ${day} · ${time}`;
+};
+
+export const formatList = (values: string[]) => {
+    if (values.length === 0) {
+        return 'n/a';
+    }
+
+    return values.join(', ');
+};
+
+export const formatPercent = (value: number, total: number) => {
+    if (total <= 0) {
+        return '0%';
+    }
+
+    return `${Math.round((value / total) * 100)}%`;
+};
+
+export const formatBooleanLabel = (value: boolean) => {
+    return value ? 'Yes' : 'No';
+};
+
+export const formatModelLabel = formatSharedModelLabel;

package/apps/ui/src/lib/kiro-queries.ts

@@ -0,0 +1,22 @@
+import { queryOptions } from '@tanstack/react-query';
+import { getKiroSessionDetailFn, listKiroSessionsFn, listKiroWorkspacesFn } from './kiro-server';
+
+export const kiroWorkspacesQueryOptions = () =>
+    queryOptions({
+        queryFn: () => listKiroWorkspacesFn(),
+        queryKey: ['kiro-workspaces'],
+    });
+
+export const kiroSessionsQueryOptions = (workspaceKey: string | null) =>
+    queryOptions({
+        enabled: workspaceKey !== null,
+        queryFn: () => listKiroSessionsFn({ data: { workspaceKey: workspaceKey ?? '' } }),
+        queryKey: ['kiro-sessions', workspaceKey ?? 'none'],
+    });
+
+export const kiroSessionDetailQueryOptions = (sessionId: string | null) =>
+    queryOptions({
+        enabled: sessionId !== null,
+        queryFn: () => getKiroSessionDetailFn({ data: { sessionId: sessionId ?? '' } }),
+        queryKey: ['kiro-session', sessionId ?? 'none'],
+    });

package/apps/ui/src/lib/kiro-server.ts

@@ -0,0 +1,73 @@
+import { createServerFn } from '@tanstack/react-start';
+import { z } from 'zod';
+import { renderSourceSessionDownload } from './source-session-export-server';
+
+const workspaceSchema = z.object({
+    workspaceKey: z.string().min(1),
+});
+
+const sessionSchema = z.object({
+    sessionId: z.string().min(1),
+});
+
+const exportSessionSchema = z.object({
+    includeCommentary: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
+    outputFormat: z.enum(['md', 'txt']).default('md'),
+    sessionId: z.string().min(1),
+    zipArchive: z.boolean().default(false),
+});
+
+export const listKiroWorkspacesFn = createServerFn({ method: 'GET' }).handler(async () => {
+    const { listKiroWorkspaceGroups } = await import('@spiracha/lib/kiro-db');
+    return listKiroWorkspaceGroups();
+});
+
+export const listKiroSessionsFn = createServerFn({ method: 'GET' })
+    .validator(workspaceSchema)
+    .handler(async ({ data }) => {
+        const { listKiroSessionsForGroup } = await import('@spiracha/lib/kiro-db');
+        return listKiroSessionsForGroup(data.workspaceKey);
+    });
+
+const loadKiroSessionTranscript = async (sessionId: string) => {
+    const { readKiroSessionTranscript, resolveKiroWorkspaceSessionsDir } = await import('@spiracha/lib/kiro-db');
+    const transcript = await readKiroSessionTranscript(resolveKiroWorkspaceSessionsDir(), sessionId);
+    if (!transcript) {
+        throw new Error(`Kiro session not found: ${sessionId}`);
+    }
+
+    return transcript;
+};
+
+export const getKiroSessionDetailFn = createServerFn({ method: 'GET' })
+    .validator(sessionSchema)
+    .handler(async ({ data }) => {
+        return loadKiroSessionTranscript(data.sessionId);
+    });
+
+export const exportKiroSessionFn = createServerFn({ method: 'POST' })
+    .validator(exportSessionSchema)
+    .handler(async ({ data }) => {
+        const { renderKiroTranscript } = await import('@spiracha/lib/kiro-transcript');
+        const transcript = await loadKiroSessionTranscript(data.sessionId);
+        const content = renderKiroTranscript(transcript, {
+            includeCommentary: data.includeCommentary,
+            includeMetadata: data.includeMetadata,
+            includeTools: data.includeTools,
+            outputFormat: data.outputFormat,
+        });
+
+        if (!content) {
+            throw new Error(`Kiro session has no exportable content: ${data.sessionId}`);
+        }
+
+        return renderSourceSessionDownload({
+            content,
+            fallbackBaseName: 'kiro-session',
+            fileBaseName: transcript.session.title || transcript.session.sessionId,
+            outputFormat: data.outputFormat,
+            zipArchive: data.zipArchive,
+        });
+    });

package/apps/ui/src/lib/kiro-transcript-events.ts

@@ -0,0 +1,113 @@
+import type { ThreadEvent, ThreadTranscriptStats } from '@spiracha/lib/codex-browser-types';
+import type { KiroSessionTranscript, KiroTranscriptEntry, KiroTranscriptPart } from '@spiracha/lib/kiro-exporter-types';
+import { getFinalKiroAssistantMessageEntryIds, getKiroMessagePhase } from '@spiracha/lib/kiro-transcript-phase';
+import type { JsonValue } from '@spiracha/lib/shared';
+import { getThreadTranscriptStats } from './thread-transcript-stats';
+
+const buildRaw = (
+    entry: KiroTranscriptEntry,
+    part: KiroTranscriptPart,
+    eventType: string,
+): Record<string, JsonValue> => ({
+    entryId: entry.entryId,
+    eventType,
+    executionId: entry.executionId,
+    role: entry.role,
+    source: 'kiro_workspace_sessions',
+    type: part.type,
+    ...part.raw,
+});
+
+const buildMessageEvent = (
+    transcript: KiroSessionTranscript,
+    entry: KiroTranscriptEntry,
+    part: KiroTranscriptPart,
+    sequence: number,
+    text: string,
+    phase: Extract<ThreadEvent, { kind: 'message' }>['phase'],
+): ThreadEvent => ({
+    isHiddenByDefault: entry.role !== 'assistant' && entry.role !== 'user',
+    kind: 'message',
+    memoryCitation: null,
+    model: transcript.session.selectedModel ?? transcript.session.defaultModelTitle,
+    phase,
+    raw: buildRaw(entry, part, 'message'),
+    role: entry.role,
+    sequence,
+    text,
+    timestamp: entry.timestamp,
+    variant: entry.role === 'user' ? 'user_message' : entry.role === 'assistant' ? 'agent_message' : 'message',
+});
+
+const getPartString = (part: KiroTranscriptPart, key: string): string | null => {
+    const value = part.raw[key];
+    return typeof value === 'string' && value.trim() ? value : null;
+};
+
+const buildToolCallEvent = (
+    transcript: KiroSessionTranscript,
+    entry: KiroTranscriptEntry,
+    part: KiroTranscriptPart,
+    sequence: number,
+    command: string,
+): ThreadEvent => ({
+    argumentsParseFailed: false,
+    argumentsText: command,
+    callId: entry.entryId,
+    command,
+    kind: 'tool_call',
+    name: getPartString(part, 'toolName') ?? 'kiro_action',
+    raw: buildRaw(entry, part, 'tool_call'),
+    sequence,
+    timestamp: entry.timestamp,
+    workdir: transcript.session.worktree,
+});
+
+const partToEvents = (
+    transcript: KiroSessionTranscript,
+    entry: KiroTranscriptEntry,
+    part: KiroTranscriptPart,
+    sequence: number,
+    finalAssistantMessageEntryIds: Set<string>,
+): ThreadEvent[] => {
+    if (entry.entryType === 'tool_call' && part.type === 'text') {
+        const command = part.text?.trim();
+        return command ? [buildToolCallEvent(transcript, entry, part, sequence, command)] : [];
+    }
+
+    if (part.type === 'text' || part.type === 'image') {
+        const text = part.text?.trim();
+        return text
+            ? [
+                  buildMessageEvent(
+                      transcript,
+                      entry,
+                      part,
+                      sequence,
+                      text,
+                      getKiroMessagePhase(entry, finalAssistantMessageEntryIds),
+                  ),
+              ]
+            : [];
+    }
+
+    return [];
+};
+
+export const kiroTranscriptToThreadEvents = (transcript: KiroSessionTranscript): ThreadEvent[] => {
+    const events: ThreadEvent[] = [];
+    const finalAssistantMessageEntryIds = getFinalKiroAssistantMessageEntryIds(transcript.entries);
+    let sequence = 0;
+
+    for (const entry of transcript.entries) {
+        for (const part of entry.parts) {
+            events.push(...partToEvents(transcript, entry, part, sequence, finalAssistantMessageEntryIds));
+            sequence += 1;
+        }
+    }
+    return events;
+};
+
+export const getKiroThreadTranscriptStats = (events: ThreadEvent[]): ThreadTranscriptStats => {
+    return getThreadTranscriptStats(events);
+};

package/apps/ui/src/lib/opencode-queries.ts

@@ -0,0 +1,37 @@
+import { isRetryableSqliteError } from '@spiracha/lib/sqlite-error';
+import { queryOptions } from '@tanstack/react-query';
+import { getOpenCodeSessionDetailFn, listOpenCodeSessionsFn, listOpenCodeWorkspacesFn } from './opencode-server';
+
+const retrySqliteQuery = (failureCount: number, error: unknown) => {
+    return failureCount < 3 && isRetryableSqliteError(error);
+};
+
+const retryDelay = (attemptIndex: number) => {
+    return [150, 400][attemptIndex] ?? 800;
+};
+
+export const openCodeWorkspacesQueryOptions = () =>
+    queryOptions({
+        queryFn: () => listOpenCodeWorkspacesFn(),
+        queryKey: ['opencode-workspaces'],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });
+
+export const openCodeSessionsQueryOptions = (workspaceKey: string | null) =>
+    queryOptions({
+        enabled: workspaceKey !== null,
+        queryFn: () => listOpenCodeSessionsFn({ data: { workspaceKey: workspaceKey ?? '' } }),
+        queryKey: ['opencode-sessions', workspaceKey ?? 'none'],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });
+
+export const openCodeSessionDetailQueryOptions = (sessionId: string | null) =>
+    queryOptions({
+        enabled: sessionId !== null,
+        queryFn: () => getOpenCodeSessionDetailFn({ data: { sessionId: sessionId ?? '' } }),
+        queryKey: ['opencode-session', sessionId ?? 'none'],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });

package/apps/ui/src/lib/opencode-server.ts

@@ -0,0 +1,73 @@
+import { createServerFn } from '@tanstack/react-start';
+import { z } from 'zod';
+import { renderSourceSessionDownload } from './source-session-export-server';
+
+const workspaceSchema = z.object({
+    workspaceKey: z.string().min(1),
+});
+
+const sessionSchema = z.object({
+    sessionId: z.string().min(1),
+});
+
+const exportSessionSchema = z.object({
+    includeCommentary: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
+    outputFormat: z.enum(['md', 'txt']).default('md'),
+    sessionId: z.string().min(1),
+    zipArchive: z.boolean().default(false),
+});
+
+export const listOpenCodeWorkspacesFn = createServerFn({ method: 'GET' }).handler(async () => {
+    const { listOpenCodeWorkspaceGroups } = await import('@spiracha/lib/opencode-db');
+    return listOpenCodeWorkspaceGroups();
+});
+
+export const listOpenCodeSessionsFn = createServerFn({ method: 'GET' })
+    .validator(workspaceSchema)
+    .handler(async ({ data }) => {
+        const { listOpenCodeSessionsForGroup } = await import('@spiracha/lib/opencode-db');
+        return listOpenCodeSessionsForGroup(data.workspaceKey);
+    });
+
+const loadOpenCodeSessionTranscript = async (sessionId: string) => {
+    const { readOpenCodeSessionTranscript, resolveOpenCodeDbPath } = await import('@spiracha/lib/opencode-db');
+    const transcript = await readOpenCodeSessionTranscript(resolveOpenCodeDbPath(), sessionId);
+    if (!transcript) {
+        throw new Error(`OpenCode session not found: ${sessionId}`);
+    }
+
+    return transcript;
+};
+
+export const getOpenCodeSessionDetailFn = createServerFn({ method: 'GET' })
+    .validator(sessionSchema)
+    .handler(async ({ data }) => {
+        return loadOpenCodeSessionTranscript(data.sessionId);
+    });
+
+export const exportOpenCodeSessionFn = createServerFn({ method: 'POST' })
+    .validator(exportSessionSchema)
+    .handler(async ({ data }) => {
+        const { renderOpenCodeTranscript } = await import('@spiracha/lib/opencode-transcript');
+        const transcript = await loadOpenCodeSessionTranscript(data.sessionId);
+        const content = renderOpenCodeTranscript(transcript, {
+            includeCommentary: data.includeCommentary,
+            includeMetadata: data.includeMetadata,
+            includeTools: data.includeTools,
+            outputFormat: data.outputFormat,
+        });
+
+        if (!content) {
+            throw new Error(`OpenCode session has no exportable content: ${data.sessionId}`);
+        }
+
+        return renderSourceSessionDownload({
+            content,
+            fallbackBaseName: 'opencode-session',
+            fileBaseName: transcript.session.title || transcript.session.slug || transcript.session.sessionId,
+            outputFormat: data.outputFormat,
+            zipArchive: data.zipArchive,
+        });
+    });

package/apps/ui/src/lib/opencode-transcript-events.ts

@@ -0,0 +1,221 @@
+import type { ThreadEvent, ThreadTranscriptStats } from '@spiracha/lib/codex-browser-types';
+import type { OpenCodeSessionTranscript, OpenCodeTranscriptPart } from '@spiracha/lib/opencode-exporter-types';
+import { splitOpenCodeThinkTaggedText } from '@spiracha/lib/opencode-think-tags';
+import {
+    getFinalOpenCodeAssistantTextPartIds,
+    getOpenCodeTextPartPhase,
+} from '@spiracha/lib/opencode-transcript-phase';
+import type { JsonValue } from '@spiracha/lib/shared';
+import { getThreadTranscriptStats } from './thread-transcript-stats';
+
+const toTimestamp = (value: number | null | undefined): string | null => {
+    if (value === null || value === undefined || !Number.isFinite(value)) {
+        return null;
+    }
+
+    return new Date(value).toISOString();
+};
+
+const buildRaw = (part: OpenCodeTranscriptPart, eventType: string): Record<string, JsonValue> => ({
+    eventType,
+    messageId: part.messageId,
+    partId: part.partId,
+    role: part.role,
+    source: 'opencode_part',
+    type: part.type,
+    ...part.raw,
+});
+
+const buildMessageEvent = (
+    part: OpenCodeTranscriptPart,
+    sequence: number,
+    text: string,
+    phase: string | null,
+): ThreadEvent => ({
+    isHiddenByDefault: part.role !== 'assistant' && part.role !== 'user',
+    kind: 'message',
+    memoryCitation: null,
+    model: null,
+    phase,
+    raw: buildRaw(part, 'message'),
+    role: part.role,
+    sequence,
+    text,
+    timestamp: toTimestamp(part.createdAtMs),
+    variant: part.role === 'user' ? 'user_message' : part.role === 'assistant' ? 'agent_message' : 'message',
+});
+
+const buildReasoningEventFromText = (
+    part: OpenCodeTranscriptPart,
+    sequence: number,
+    textValue: string | null | undefined,
+): ThreadEvent | null => {
+    const text = textValue?.trim();
+    if (!text) {
+        return null;
+    }
+
+    return {
+        content: text,
+        hasEncryptedContent: false,
+        kind: 'reasoning',
+        raw: buildRaw(part, 'reasoning'),
+        sequence,
+        summary: [text],
+        timestamp: toTimestamp(part.createdAtMs),
+    };
+};
+
+const buildReasoningEvent = (part: OpenCodeTranscriptPart, sequence: number): ThreadEvent | null => {
+    const { reasoningBlocks, visibleText } = splitOpenCodeThinkTaggedText(part.text ?? '');
+    return buildReasoningEventFromText(part, sequence, [...reasoningBlocks, visibleText].filter(Boolean).join('\n\n'));
+};
+
+const buildToolCallCommand = (part: OpenCodeTranscriptPart): string => {
+    const toolName = part.toolName ?? 'unknown';
+    if (!part.argumentsText?.trim()) {
+        return toolName;
+    }
+
+    return `${toolName}\n${part.argumentsText}`;
+};
+
+const buildToolCallEvent = (part: OpenCodeTranscriptPart, sequence: number): ThreadEvent => ({
+    argumentsParseFailed: false,
+    argumentsText: part.argumentsText ?? null,
+    callId: part.callId ?? null,
+    command: buildToolCallCommand(part),
+    kind: 'tool_call',
+    name: part.toolName ?? 'unknown',
+    raw: buildRaw(part, 'tool_call'),
+    sequence,
+    timestamp: toTimestamp(part.createdAtMs),
+    workdir: null,
+});
+
+const buildToolOutputEvent = (part: OpenCodeTranscriptPart, sequence: number): ThreadEvent | null => {
+    const outputText = part.outputText?.trim();
+    if (!outputText) {
+        return null;
+    }
+
+    return {
+        callId: part.callId ?? null,
+        exitCode: null,
+        kind: 'tool_output',
+        outputText,
+        raw: buildRaw(part, 'tool_output'),
+        sequence,
+        summary: outputText,
+        timestamp: toTimestamp(part.createdAtMs),
+        wallTime: null,
+    };
+};
+
+const buildStepStartedEvent = (part: OpenCodeTranscriptPart, sequence: number): ThreadEvent => ({
+    collaborationModeKind: null,
+    kind: 'task_started',
+    modelContextWindow: null,
+    raw: buildRaw(part, 'step_start'),
+    sequence,
+    startedAt: part.startTimeMs ?? part.createdAtMs,
+    timestamp: toTimestamp(part.createdAtMs),
+    turnId: part.messageId,
+});
+
+const buildStepCompleteEvent = (part: OpenCodeTranscriptPart, sequence: number): ThreadEvent => ({
+    completedAt: part.endTimeMs ?? part.updatedAtMs,
+    durationMs: part.startTimeMs && part.endTimeMs ? part.endTimeMs - part.startTimeMs : null,
+    kind: 'task_complete',
+    lastAgentMessage: part.reason ?? null,
+    raw: buildRaw(part, 'step_finish'),
+    sequence,
+    timestamp: toTimestamp(part.updatedAtMs),
+    timeToFirstTokenMs: null,
+    turnId: part.messageId,
+});
+
+const flattenParts = (transcript: OpenCodeSessionTranscript): OpenCodeTranscriptPart[] => {
+    return transcript.messages.flatMap((message) => message.parts);
+};
+
+const textPartToEvents = (
+    part: OpenCodeTranscriptPart,
+    sequence: number,
+    finalAssistantTextPartIds: Set<string>,
+): ThreadEvent[] => {
+    const { reasoningBlocks, visibleText } =
+        part.role === 'assistant'
+            ? splitOpenCodeThinkTaggedText(part.text ?? '')
+            : { reasoningBlocks: [], visibleText: part.text ?? '' };
+    const events: ThreadEvent[] = [];
+
+    if (part.role === 'assistant') {
+        events.push(
+            ...reasoningBlocks
+                .map((block, index) => buildReasoningEventFromText(part, sequence + index, block))
+                .filter((event): event is ThreadEvent => event !== null),
+        );
+    }
+
+    const text = visibleText.trim();
+    if (!text) {
+        return events;
+    }
+
+    const messageSequence = sequence + events.length;
+    const phase = getOpenCodeTextPartPhase(part, finalAssistantTextPartIds);
+    events.push(buildMessageEvent(part, messageSequence, text, phase));
+    return events;
+};
+
+const toolPartToEvents = (part: OpenCodeTranscriptPart, sequence: number): ThreadEvent[] => {
+    const output = buildToolOutputEvent(part, sequence + 1);
+    return [buildToolCallEvent(part, sequence), output].filter((event): event is ThreadEvent => event !== null);
+};
+
+const partToEvents = (
+    part: OpenCodeTranscriptPart,
+    sequence: number,
+    finalAssistantTextPartIds: Set<string>,
+): ThreadEvent[] => {
+    if (part.type === 'text') {
+        return textPartToEvents(part, sequence, finalAssistantTextPartIds);
+    }
+
+    if (part.type === 'reasoning') {
+        const event = buildReasoningEvent(part, sequence);
+        return event ? [event] : [];
+    }
+
+    if (part.type === 'tool') {
+        return toolPartToEvents(part, sequence);
+    }
+
+    if (part.type === 'step-start') {
+        return [buildStepStartedEvent(part, sequence)];
+    }
+
+    if (part.type === 'step-finish') {
+        return [buildStepCompleteEvent(part, sequence)];
+    }
+
+    return [];
+};
+
+export const openCodeTranscriptToThreadEvents = (transcript: OpenCodeSessionTranscript): ThreadEvent[] => {
+    const parts = flattenParts(transcript);
+    const finalAssistantTextPartIds = getFinalOpenCodeAssistantTextPartIds(parts);
+    const events: ThreadEvent[] = [];
+    let sequence = 0;
+    for (const part of parts) {
+        const partEvents = partToEvents(part, sequence, finalAssistantTextPartIds);
+        events.push(...partEvents);
+        sequence += Math.max(partEvents.length, 1);
+    }
+    return events;
+};
+
+export const getOpenCodeThreadTranscriptStats = (events: ThreadEvent[]): ThreadTranscriptStats => {
+    return getThreadTranscriptStats(events);
+};