spiracha 1.5.0 → 2.1.0

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

@@ -0,0 +1,151 @@
+import { createServerFn } from '@tanstack/react-start';
+import { z } from 'zod';
+import { renderSourceSessionDownload, renderSourceSessionsDownload } 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),
+});
+
+const exportSessionsSchema = z.object({
+    includeCommentary: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
+    outputFormat: z.enum(['md', 'txt']).default('md'),
+    sessionIds: z.array(z.string().min(1)).min(1),
+    zipArchive: z.boolean().default(true),
+});
+
+const deleteSessionsSchema = z.object({
+    sessionIds: z.array(z.string().min(1)).min(1),
+});
+
+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 { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
+    const { readOpenCodeSessionTranscript, resolveOpenCodeDbPath } = await import('@spiracha/lib/opencode-db');
+    const dbPath = resolveOpenCodeDbPath();
+    return runWithTranscriptLoadLimit(
+        async () => {
+            const transcript = await readOpenCodeSessionTranscript(dbPath, sessionId);
+            if (!transcript) {
+                throw new Error(`OpenCode session not found: ${sessionId}`);
+            }
+
+            return transcript;
+        },
+        {
+            id: sessionId,
+            path: dbPath,
+            source: 'opencode-ui',
+        },
+    );
+};
+
+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,
+            cwd: transcript.session.worktree,
+            fallbackBaseName: 'opencode-session',
+            outputFormat: data.outputFormat,
+            sessionId: transcript.session.sessionId,
+            updatedAtMs: transcript.session.lastUpdatedAtMs,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const exportOpenCodeSessionsFn = createServerFn({ method: 'POST' })
+    .validator(exportSessionsSchema)
+    .handler(async ({ data }) => {
+        const { renderOpenCodeTranscript } = await import('@spiracha/lib/opencode-transcript');
+        const entries = await Promise.all(
+            data.sessionIds.map(async (sessionId) => {
+                const transcript = await loadOpenCodeSessionTranscript(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: ${sessionId}`);
+                }
+
+                return {
+                    content,
+                    cwd: transcript.session.worktree,
+                    fallbackBaseName: 'opencode-session',
+                    fileBaseName: transcript.session.title || transcript.session.slug || transcript.session.sessionId,
+                    sessionId: transcript.session.sessionId,
+                    updatedAtMs: transcript.session.lastUpdatedAtMs,
+                };
+            }),
+        );
+
+        return renderSourceSessionsDownload({
+            entries,
+            fallbackBaseName: 'opencode-sessions',
+            outputFormat: data.outputFormat,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const deleteOpenCodeSessionFn = createServerFn({ method: 'POST' })
+    .validator(sessionSchema)
+    .handler(async ({ data }) => {
+        const { deleteOpenCodeSession, resolveOpenCodeDbPath } = await import('@spiracha/lib/opencode-db');
+        return deleteOpenCodeSession(resolveOpenCodeDbPath(), data.sessionId);
+    });
+
+export const deleteOpenCodeSessionsFn = createServerFn({ method: 'POST' })
+    .validator(deleteSessionsSchema)
+    .handler(async ({ data }) => {
+        const { deleteOpenCodeSession, resolveOpenCodeDbPath } = await import('@spiracha/lib/opencode-db');
+        const dbPath = resolveOpenCodeDbPath();
+        return Promise.all(data.sessionIds.map((sessionId) => deleteOpenCodeSession(dbPath, sessionId)));
+    });

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);
+};

package/apps/ui/src/lib/package-metadata.ts

@@ -0,0 +1,16 @@
+import packageJsonRaw from '../../../../package.json?raw';
+
+type PackageMetadata = {
+    homepage: string;
+    version: string;
+};
+
+const parsePackageMetadata = (): PackageMetadata => {
+    const packageJson = JSON.parse(packageJsonRaw) as Partial<PackageMetadata>;
+    return {
+        homepage: typeof packageJson.homepage === 'string' ? packageJson.homepage : '',
+        version: typeof packageJson.version === 'string' ? packageJson.version : '0.0.0',
+    };
+};
+
+export const packageMetadata = parsePackageMetadata();

package/apps/ui/src/lib/path-utils.ts

@@ -0,0 +1,13 @@
+import { applyPathTransforms as applySharedPathTransforms } from '@spiracha/lib/path-transforms';
+import type { Settings } from './settings-store';
+
+export const applyPathTransforms = (
+    text: string,
+    settings: Pick<Settings, 'convertToProjectRoot' | 'redactUsername'>,
+    projectPath: string | null,
+) => {
+    return applySharedPathTransforms(text, {
+        ...settings,
+        projectPath,
+    });
+};

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

@@ -0,0 +1,22 @@
+import { queryOptions } from '@tanstack/react-query';
+import { getQoderSessionDetailFn, listQoderSessionsFn, listQoderWorkspacesFn } from './qoder-server';
+
+export const qoderWorkspacesQueryOptions = () =>
+    queryOptions({
+        queryFn: () => listQoderWorkspacesFn(),
+        queryKey: ['qoder-workspaces'],
+    });
+
+export const qoderSessionsQueryOptions = (workspaceKey: string | null) =>
+    queryOptions({
+        enabled: workspaceKey !== null,
+        queryFn: () => listQoderSessionsFn({ data: { workspaceKey: workspaceKey ?? '' } }),
+        queryKey: ['qoder-sessions', workspaceKey ?? 'none'],
+    });
+
+export const qoderSessionDetailQueryOptions = (sessionId: string | null) =>
+    queryOptions({
+        enabled: sessionId !== null,
+        queryFn: () => getQoderSessionDetailFn({ data: { sessionId: sessionId ?? '' } }),
+        queryKey: ['qoder-session', sessionId ?? 'none'],
+    });

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

@@ -0,0 +1,135 @@
+import { createServerFn } from '@tanstack/react-start';
+import { z } from 'zod';
+import { renderSourceSessionDownload, renderSourceSessionsDownload } 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),
+});
+
+const exportSessionsSchema = z.object({
+    includeCommentary: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
+    outputFormat: z.enum(['md', 'txt']).default('md'),
+    sessionIds: z.array(z.string().min(1)).min(1),
+    zipArchive: z.boolean().default(true),
+});
+
+export const listQoderWorkspacesFn = createServerFn({ method: 'GET' }).handler(async () => {
+    const { listQoderWorkspaceGroups } = await import('@spiracha/lib/qoder-db');
+    return listQoderWorkspaceGroups();
+});
+
+export const listQoderSessionsFn = createServerFn({ method: 'GET' })
+    .validator(workspaceSchema)
+    .handler(async ({ data }) => {
+        const { listQoderSessionsForGroup } = await import('@spiracha/lib/qoder-db');
+        return listQoderSessionsForGroup(data.workspaceKey);
+    });
+
+const loadQoderSessionTranscript = async (sessionId: string) => {
+    const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
+    const { readQoderSessionTranscript, resolveQoderGlobalStateDb, resolveQoderWorkspaceStorageDir } = await import(
+        '@spiracha/lib/qoder-db'
+    );
+    const globalStateDb = resolveQoderGlobalStateDb();
+    const workspaceStorageDir = resolveQoderWorkspaceStorageDir();
+    return runWithTranscriptLoadLimit(
+        async () => {
+            const transcript = await readQoderSessionTranscript(globalStateDb, workspaceStorageDir, sessionId);
+            if (!transcript) {
+                throw new Error(`Qoder session not found: ${sessionId}`);
+            }
+
+            return transcript;
+        },
+        {
+            id: sessionId,
+            path: globalStateDb,
+            source: 'qoder-ui',
+        },
+    );
+};
+
+export const getQoderSessionDetailFn = createServerFn({ method: 'GET' })
+    .validator(sessionSchema)
+    .handler(async ({ data }) => {
+        return loadQoderSessionTranscript(data.sessionId);
+    });
+
+export const exportQoderSessionFn = createServerFn({ method: 'POST' })
+    .validator(exportSessionSchema)
+    .handler(async ({ data }) => {
+        const { renderQoderTranscript } = await import('@spiracha/lib/qoder-transcript');
+        const transcript = await loadQoderSessionTranscript(data.sessionId);
+        const content = renderQoderTranscript(transcript, {
+            includeCommentary: data.includeCommentary,
+            includeMetadata: data.includeMetadata,
+            includeTools: data.includeTools,
+            outputFormat: data.outputFormat,
+        });
+
+        if (!content) {
+            throw new Error(`Qoder session has no exportable content: ${data.sessionId}`);
+        }
+
+        return renderSourceSessionDownload({
+            content,
+            cwd: transcript.session.workspacePath ?? transcript.session.worktree,
+            fallbackBaseName: 'qoder-session',
+            outputFormat: data.outputFormat,
+            sessionId: transcript.session.sessionId,
+            updatedAtMs: transcript.session.lastActiveAtMs,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const exportQoderSessionsFn = createServerFn({ method: 'POST' })
+    .validator(exportSessionsSchema)
+    .handler(async ({ data }) => {
+        const { renderQoderTranscript } = await import('@spiracha/lib/qoder-transcript');
+        const entries = await Promise.all(
+            data.sessionIds.map(async (sessionId) => {
+                const transcript = await loadQoderSessionTranscript(sessionId);
+                const content = renderQoderTranscript(transcript, {
+                    includeCommentary: data.includeCommentary,
+                    includeMetadata: data.includeMetadata,
+                    includeTools: data.includeTools,
+                    outputFormat: data.outputFormat,
+                });
+
+                if (!content) {
+                    throw new Error(`Qoder session has no exportable content: ${sessionId}`);
+                }
+
+                return {
+                    content,
+                    cwd: transcript.session.workspacePath ?? transcript.session.worktree,
+                    fallbackBaseName: 'qoder-session',
+                    fileBaseName: transcript.session.title || transcript.session.sessionId,
+                    sessionId: transcript.session.sessionId,
+                    updatedAtMs: transcript.session.lastActiveAtMs,
+                };
+            }),
+        );
+
+        return renderSourceSessionsDownload({
+            entries,
+            fallbackBaseName: 'qoder-sessions',
+            outputFormat: data.outputFormat,
+            zipArchive: data.zipArchive,
+        });
+    });