spiracha 1.5.0 → 2.1.0

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

@@ -0,0 +1,139 @@
+import type { ThreadEvent, ThreadTranscriptStats } from '@spiracha/lib/codex-browser-types';
+import type {
+    QoderSessionTranscript,
+    QoderTranscriptEntry,
+    QoderTranscriptPart,
+} from '@spiracha/lib/qoder-exporter-types';
+import { getFinalQoderAssistantMessageEntryIds, getQoderMessagePhase } from '@spiracha/lib/qoder-transcript-phase';
+import type { JsonValue } from '@spiracha/lib/shared';
+import { getThreadTranscriptStats } from './thread-transcript-stats';
+
+const buildRaw = (
+    entry: QoderTranscriptEntry,
+    part: QoderTranscriptPart,
+    eventType: string,
+): Record<string, JsonValue> => ({
+    entryId: entry.entryId,
+    eventType,
+    requestId: entry.requestId,
+    role: entry.role,
+    source: 'qoder_local_history',
+    type: part.type,
+    ...part.raw,
+});
+
+const buildMessageEvent = (
+    transcript: QoderSessionTranscript,
+    entry: QoderTranscriptEntry,
+    part: QoderTranscriptPart,
+    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.model ?? 'Qoder',
+    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: QoderTranscriptPart, key: string): string | null => {
+    const value = part.raw[key];
+    return typeof value === 'string' && value.trim() ? value : null;
+};
+
+const buildToolCallEvent = (
+    transcript: QoderSessionTranscript,
+    entry: QoderTranscriptEntry,
+    part: QoderTranscriptPart,
+    sequence: number,
+    command: string,
+): ThreadEvent => ({
+    argumentsParseFailed: false,
+    argumentsText: command,
+    callId: entry.entryId,
+    command,
+    kind: 'tool_call',
+    name: getPartString(part, 'toolName') ?? 'qoder_file_operation',
+    raw: buildRaw(entry, part, 'tool_call'),
+    sequence,
+    timestamp: entry.timestamp,
+    workdir: transcript.session.worktree,
+});
+
+const buildToolOutputEvent = (
+    entry: QoderTranscriptEntry,
+    part: QoderTranscriptPart,
+    sequence: number,
+    outputText: string,
+): ThreadEvent => ({
+    callId: getPartString(part, 'toolCallId'),
+    exitCode: null,
+    kind: 'tool_output',
+    outputText,
+    raw: buildRaw(entry, part, 'tool_output'),
+    sequence,
+    summary: outputText,
+    timestamp: entry.timestamp,
+    wallTime: null,
+});
+
+const partToEvents = (
+    transcript: QoderSessionTranscript,
+    entry: QoderTranscriptEntry,
+    part: QoderTranscriptPart,
+    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 (entry.entryType === 'tool_output' && part.type === 'text') {
+        const outputText = part.text?.trim();
+        return outputText ? [buildToolOutputEvent(entry, part, sequence, outputText)] : [];
+    }
+
+    if (part.type === 'text') {
+        const text = part.text?.trim();
+        return text
+            ? [
+                  buildMessageEvent(
+                      transcript,
+                      entry,
+                      part,
+                      sequence,
+                      text,
+                      getQoderMessagePhase(entry, finalAssistantMessageEntryIds),
+                  ),
+              ]
+            : [];
+    }
+
+    return [];
+};
+
+export const qoderTranscriptToThreadEvents = (transcript: QoderSessionTranscript): ThreadEvent[] => {
+    const events: ThreadEvent[] = [];
+    const finalAssistantMessageEntryIds = getFinalQoderAssistantMessageEntryIds(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 getQoderThreadTranscriptStats = (events: ThreadEvent[]): ThreadTranscriptStats => {
+    return getThreadTranscriptStats(events);
+};

package/apps/ui/src/lib/route-search.ts

@@ -0,0 +1,182 @@
+export type TextQuerySearch = {
+    q?: string;
+};
+
+export type AnalyticsSearch = {
+    project?: string;
+};
+
+export type ThreadTranscriptSearch = {
+    commentary?: boolean;
+    extra?: boolean;
+    q?: string;
+    raw?: boolean;
+    sort?: 'earliest' | 'latest';
+    tools?: boolean;
+    user?: boolean;
+};
+
+type SearchRecord = Record<string, unknown>;
+
+const asNonBlankString = (value: unknown) => {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+};
+
+export const parseTextQuerySearch = (search: SearchRecord): TextQuerySearch => {
+    const q = asNonBlankString(search.q);
+    return q ? { q } : {};
+};
+
+export const parseAnalyticsSearch = (search: SearchRecord): AnalyticsSearch => {
+    const project = asNonBlankString(search.project);
+    return project ? { project } : {};
+};
+
+const asBooleanSearch = (value: unknown) => {
+    if (value === true || value === 'true' || value === '1') {
+        return true;
+    }
+
+    if (value === false || value === 'false' || value === '0') {
+        return false;
+    }
+
+    return undefined;
+};
+
+const setBooleanSearchParam = (target: SearchRecord, key: keyof ThreadTranscriptSearch, value: boolean) => {
+    if (value) {
+        target[key] = true;
+        return;
+    }
+
+    delete target[key];
+};
+
+const setTextSearchParam = (target: SearchRecord, key: keyof ThreadTranscriptSearch, value: string | undefined) => {
+    const trimmed = asNonBlankString(value);
+    if (trimmed) {
+        target[key] = trimmed;
+        return;
+    }
+
+    delete target[key];
+};
+
+const setThreadSortSearchParam = (target: SearchRecord, value: ThreadTranscriptSearch['sort']) => {
+    if (value === 'latest') {
+        target.sort = 'latest';
+        return;
+    }
+
+    delete target.sort;
+};
+
+export const parseThreadTranscriptSearch = (search: SearchRecord): ThreadTranscriptSearch => {
+    const q = asNonBlankString(search.q);
+    const sort = search.sort === 'latest' ? 'latest' : undefined;
+    const parsed: ThreadTranscriptSearch = q ? { q } : {};
+    const tools = asBooleanSearch(search.tools);
+    const commentary = asBooleanSearch(search.commentary);
+    const extra = asBooleanSearch(search.extra);
+    const raw = asBooleanSearch(search.raw);
+    const user = asBooleanSearch(search.user);
+
+    if (tools) {
+        parsed.tools = true;
+    }
+    if (commentary) {
+        parsed.commentary = true;
+    }
+    if (extra) {
+        parsed.extra = true;
+    }
+    if (raw) {
+        parsed.raw = true;
+    }
+    if (user) {
+        parsed.user = true;
+    }
+    if (sort) {
+        parsed.sort = sort;
+    }
+
+    return parsed;
+};
+
+export const withThreadTranscriptSearch = (
+    current: SearchRecord,
+    patch: Partial<ThreadTranscriptSearch>,
+): SearchRecord & ThreadTranscriptSearch => {
+    const next = { ...current };
+
+    if ('q' in patch) {
+        setTextSearchParam(next, 'q', patch.q);
+    }
+    if ('sort' in patch) {
+        setThreadSortSearchParam(next, patch.sort);
+    }
+
+    if ('tools' in patch && typeof patch.tools === 'boolean') {
+        setBooleanSearchParam(next, 'tools', patch.tools);
+    }
+    if ('commentary' in patch && typeof patch.commentary === 'boolean') {
+        setBooleanSearchParam(next, 'commentary', patch.commentary);
+    }
+    if ('extra' in patch && typeof patch.extra === 'boolean') {
+        setBooleanSearchParam(next, 'extra', patch.extra);
+    }
+    if ('raw' in patch && typeof patch.raw === 'boolean') {
+        setBooleanSearchParam(next, 'raw', patch.raw);
+    }
+    if ('user' in patch && typeof patch.user === 'boolean') {
+        setBooleanSearchParam(next, 'user', patch.user);
+    }
+
+    return next as SearchRecord & ThreadTranscriptSearch;
+};
+
+export const withTextQuerySearch = (current: SearchRecord, query: string): SearchRecord & TextQuerySearch => {
+    const next = { ...current };
+    const q = asNonBlankString(query);
+    if (q) {
+        next.q = q;
+    } else {
+        delete next.q;
+    }
+
+    return next as SearchRecord & TextQuerySearch;
+};
+
+export const withAnalyticsProjectSearch = (
+    current: SearchRecord,
+    project: string | null,
+): SearchRecord & AnalyticsSearch => {
+    const next = { ...current };
+    const trimmedProject = asNonBlankString(project);
+    if (trimmedProject) {
+        next.project = trimmedProject;
+    } else {
+        delete next.project;
+    }
+
+    return next as SearchRecord & AnalyticsSearch;
+};
+
+const ALL_PROJECTS_SELECT_VALUE = '__all__';
+const PROJECT_SELECT_PREFIX = 'project:';
+
+export const encodeAnalyticsProjectSelectValue = (project: string | null) => {
+    return project ? `${PROJECT_SELECT_PREFIX}${project}` : ALL_PROJECTS_SELECT_VALUE;
+};
+
+export const decodeAnalyticsProjectSelectValue = (value: string) => {
+    return value === ALL_PROJECTS_SELECT_VALUE || !value.startsWith(PROJECT_SELECT_PREFIX)
+        ? null
+        : value.slice(PROJECT_SELECT_PREFIX.length);
+};

package/apps/ui/src/lib/settings-store.tsx

@@ -0,0 +1,59 @@
+import type { ReactNode } from 'react';
+import { createContext, useContext, useEffect, useState } from 'react';
+
+export type Settings = {
+    convertToProjectRoot: boolean;
+    redactUsername: boolean;
+};
+
+type SettingsContextValue = {
+    settings: Settings;
+    updateSetting: <K extends keyof Settings>(key: K, value: Settings[K]) => void;
+};
+
+const STORAGE_KEY = 'spiracha-settings';
+
+const defaultSettings: Settings = {
+    convertToProjectRoot: false,
+    redactUsername: false,
+};
+
+const SettingsContext = createContext<SettingsContextValue>({
+    settings: defaultSettings,
+    updateSetting: () => {},
+});
+
+const loadSettings = (): Settings => {
+    if (typeof window === 'undefined') {
+        return defaultSettings;
+    }
+    try {
+        const stored = window.localStorage.getItem(STORAGE_KEY);
+        return stored ? { ...defaultSettings, ...(JSON.parse(stored) as Partial<Settings>) } : defaultSettings;
+    } catch {
+        return defaultSettings;
+    }
+};
+
+export function SettingsProvider({ children }: { children: ReactNode }) {
+    const [settings, setSettings] = useState<Settings>(defaultSettings);
+
+    // Load from localStorage on mount (client only — avoids SSR hydration mismatch)
+    useEffect(() => {
+        setSettings(loadSettings());
+    }, []);
+
+    const updateSetting = <K extends keyof Settings>(key: K, value: Settings[K]) => {
+        setSettings((prev) => {
+            const next = { ...prev, [key]: value };
+            try {
+                localStorage.setItem(STORAGE_KEY, JSON.stringify(next));
+            } catch {}
+            return next;
+        });
+    };
+
+    return <SettingsContext.Provider value={{ settings, updateSetting }}>{children}</SettingsContext.Provider>;
+}
+
+export const useSettings = () => useContext(SettingsContext);

package/apps/ui/src/lib/source-session-export-server.ts

@@ -0,0 +1,139 @@
+import { randomUUID } from 'node:crypto';
+import { mkdtemp, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {
+    buildBatchExportBaseName,
+    buildConversationExportBaseName,
+    getExportMimeType,
+    resolveUniqueExportFileBaseName,
+    sanitizeExportFileName,
+    zipExportDirectory,
+} from '@spiracha/lib/ui-export-archive';
+import { buildUiExportDownloadUrl, ensureUiExportDir } from '@spiracha/lib/ui-export-files';
+
+type ExportFormat = 'md' | 'txt';
+
+type RenderSourceSessionDownloadOptions = {
+    content: string;
+    cwd: string | null;
+    fallbackBaseName: string;
+    outputFormat: ExportFormat;
+    sessionId: string;
+    updatedAtMs: number | null;
+    zipArchive: boolean;
+};
+
+type RenderedSourceSession = {
+    content: string;
+    cwd: string | null;
+    fallbackBaseName: string;
+    fileBaseName: string;
+    sessionId: string;
+    updatedAtMs: number | null;
+};
+
+type RenderSourceSessionsDownloadOptions = {
+    entries: RenderedSourceSession[];
+    fallbackBaseName: string;
+    outputFormat: ExportFormat;
+    zipArchive: boolean;
+};
+
+export const toSafeSourceExportName = (value: string, fallback: string) => {
+    return sanitizeExportFileName(value) || fallback;
+};
+
+export const renderSourceSessionDownload = async ({
+    content,
+    cwd,
+    fallbackBaseName,
+    outputFormat,
+    sessionId,
+    updatedAtMs,
+    zipArchive,
+}: RenderSourceSessionDownloadOptions) => {
+    const safeBaseName = buildConversationExportBaseName(
+        {
+            cwd,
+            id: sessionId,
+            updatedAtMs,
+        },
+        fallbackBaseName,
+    );
+    if (!zipArchive) {
+        return {
+            content,
+            fileName: `${safeBaseName}.${outputFormat}`,
+            mimeType: getExportMimeType(outputFormat),
+            mode: 'download' as const,
+        };
+    }
+
+    const exportDir = await ensureUiExportDir();
+    const workspaceDir = await mkdtemp(path.join(os.tmpdir(), `${safeBaseName}-`));
+    const zipPath = path.join(exportDir, `${safeBaseName}-${randomUUID()}.zip`);
+
+    try {
+        await Bun.write(path.join(workspaceDir, `${safeBaseName}.${outputFormat}`), content);
+        await zipExportDirectory(workspaceDir, zipPath);
+    } finally {
+        await rm(workspaceDir, { force: true, recursive: true });
+    }
+
+    return {
+        downloadUrl: buildUiExportDownloadUrl(zipPath),
+        fileName: `${safeBaseName}.zip`,
+        mimeType: 'application/zip',
+        mode: 'download_url' as const,
+    };
+};
+
+export const renderSourceSessionsDownload = async ({
+    entries,
+    fallbackBaseName,
+    outputFormat,
+    zipArchive,
+}: RenderSourceSessionsDownloadOptions) => {
+    if (entries.length === 0) {
+        throw new Error('No transcripts selected for export');
+    }
+
+    if (entries.length === 1) {
+        const entry = entries[0]!;
+        return renderSourceSessionDownload({
+            content: entry.content,
+            cwd: entry.cwd,
+            fallbackBaseName: entry.fallbackBaseName,
+            outputFormat,
+            sessionId: entry.sessionId,
+            updatedAtMs: entry.updatedAtMs,
+            zipArchive,
+        });
+    }
+
+    const safeBaseName = buildBatchExportBaseName(entries, fallbackBaseName);
+    const exportDir = await ensureUiExportDir();
+    const workspaceDir = await mkdtemp(path.join(os.tmpdir(), `${safeBaseName}-`));
+    const zipPath = path.join(exportDir, `${safeBaseName}-${randomUUID()}.zip`);
+    const usedBaseNames = new Map<string, number>();
+
+    try {
+        for (const entry of entries) {
+            const baseName = toSafeSourceExportName(entry.fileBaseName, entry.fallbackBaseName);
+            const fileBaseName = resolveUniqueExportFileBaseName(baseName, usedBaseNames);
+            await Bun.write(path.join(workspaceDir, `${fileBaseName}.${outputFormat}`), entry.content);
+        }
+
+        await zipExportDirectory(workspaceDir, zipPath);
+    } finally {
+        await rm(workspaceDir, { force: true, recursive: true });
+    }
+
+    return {
+        downloadUrl: buildUiExportDownloadUrl(zipPath),
+        fileName: `${safeBaseName}.zip`,
+        mimeType: 'application/zip',
+        mode: 'download_url' as const,
+    };
+};

package/apps/ui/src/lib/text-filter.ts

@@ -0,0 +1,22 @@
+type SearchValue = boolean | number | string | null | undefined;
+
+const normalizeSearchToken = (value: string) => value.trim().toLowerCase();
+
+export const tokenizeSearchQuery = (query: string): string[] => {
+    const normalized = normalizeSearchToken(query);
+    return normalized ? normalized.split(/\s+/u).filter(Boolean) : [];
+};
+
+export const matchesTextQuery = (query: string, values: SearchValue[]): boolean => {
+    const tokens = tokenizeSearchQuery(query);
+    if (tokens.length === 0) {
+        return true;
+    }
+
+    const haystack = values
+        .filter((value) => value !== null && value !== undefined)
+        .map((value) => String(value).toLowerCase())
+        .join('\n');
+
+    return tokens.every((token) => haystack.includes(token));
+};

package/apps/ui/src/lib/thread-id.ts

@@ -0,0 +1,3 @@
+const THREAD_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+
+export const isCodexThreadId = (value: string) => THREAD_ID_PATTERN.test(value);

package/apps/ui/src/lib/thread-transcript-load.ts

@@ -0,0 +1,15 @@
+type TranscriptLoadState = {
+    isPartial: boolean;
+} | null;
+
+export const shouldLoadFullThreadTranscript = ({
+    shouldLoadTranscript,
+    snapshotTranscript,
+    transcriptMissing,
+}: {
+    shouldLoadTranscript: boolean;
+    snapshotTranscript: TranscriptLoadState;
+    transcriptMissing: boolean;
+}) => {
+    return shouldLoadTranscript && !transcriptMissing && (snapshotTranscript === null || snapshotTranscript.isPartial);
+};

package/apps/ui/src/lib/thread-transcript-stats.ts

@@ -0,0 +1,57 @@
+import type { ThreadEvent, ThreadTranscriptStats } from '@spiracha/lib/codex-browser-types';
+
+const EXEC_TOOL_NAMES = new Set(['bash', 'exec', 'execute', 'execute_command', 'run_command', 'shell', 'terminal']);
+
+const isExecToolName = (name: string | null | undefined): boolean => {
+    return EXEC_TOOL_NAMES.has((name ?? '').trim().toLowerCase());
+};
+
+const updateMessageStats = (stats: ThreadTranscriptStats, event: Extract<ThreadEvent, { kind: 'message' }>) => {
+    stats.messageCount += 1;
+    if (event.role === 'assistant') {
+        stats.assistantMessageCount += 1;
+    }
+    if (event.role === 'user') {
+        stats.userMessageCount += 1;
+    }
+    if (event.phase === 'commentary') {
+        stats.commentaryCount += 1;
+    }
+    if (event.phase === 'final_answer') {
+        stats.finalAnswerCount += 1;
+    }
+};
+
+export const getThreadTranscriptStats = (events: ThreadEvent[]): ThreadTranscriptStats => {
+    const stats: ThreadTranscriptStats = {
+        assistantMessageCount: 0,
+        commentaryCount: 0,
+        execCommandCount: 0,
+        finalAnswerCount: 0,
+        messageCount: 0,
+        toolCallCount: 0,
+        toolOutputCount: 0,
+        userMessageCount: 0,
+        webSearchEventCount: 0,
+    };
+
+    for (const event of events) {
+        if (event.kind === 'message') {
+            updateMessageStats(stats, event);
+        }
+        if (event.kind === 'tool_call') {
+            stats.toolCallCount += 1;
+            if (isExecToolName(event.name)) {
+                stats.execCommandCount += 1;
+            }
+        }
+        if (event.kind === 'tool_output') {
+            stats.toolOutputCount += 1;
+        }
+        if (event.kind === 'web_search') {
+            stats.webSearchEventCount += 1;
+        }
+    }
+
+    return stats;
+};

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

@@ -0,0 +1,7 @@
+import type { ClassValue } from 'clsx';
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+export function cn(...inputs: ClassValue[]) {
+    return twMerge(clsx(inputs));
+}

package/apps/ui/src/lib/workspace-delete-navigation.ts

@@ -0,0 +1,12 @@
+export const isWorkspaceEmptiedByDelete = <TItem>(
+    items: TItem[],
+    deletedIds: string[],
+    getItemId: (item: TItem) => string,
+) => {
+    if (items.length === 0 || deletedIds.length === 0) {
+        return false;
+    }
+
+    const deletedIdSet = new Set(deletedIds);
+    return items.every((item) => deletedIdSet.has(getItemId(item)));
+};