spiracha 2.0.0 → 2.1.0

package/src/lib/opencode-transcript.ts

@@ -88,10 +88,11 @@ const renderTextPart = (
     options: OpenCodeExportOptions,
     finalAssistantTextPartIds: Set<string>,
 ): string => {
+    const rawText = part.text ?? '';
     const { reasoningBlocks, visibleText } =
         part.role === 'assistant'
-            ? splitOpenCodeThinkTaggedText(part.text ?? '')
-            : { reasoningBlocks: [], visibleText: part.text ?? '' };
+            ? splitOpenCodeThinkTaggedText(rawText)
+            : { reasoningBlocks: [], visibleText: rawText };
     const sections: string[] = [];
 
     if (options.includeCommentary) {
@@ -119,7 +120,8 @@ const renderReasoningPart = (part: OpenCodeTranscriptPart, options: OpenCodeExpo
         return '';
     }
 
-    const { reasoningBlocks, visibleText } = splitOpenCodeThinkTaggedText(part.text ?? '');
+    const rawText = part.text ?? '';
+    const { reasoningBlocks, visibleText } = splitOpenCodeThinkTaggedText(rawText);
     const text = cleanExtractedText([...reasoningBlocks, visibleText].filter(Boolean).join('\n\n')).trim();
     return text ? renderSection('Reasoning', text, options.outputFormat) : '';
 };
@@ -143,8 +145,9 @@ const renderToolPart = (part: OpenCodeTranscriptPart, options: OpenCodeExportOpt
     if (part.argumentsText?.trim()) {
         lines.push('', 'Input:', '', renderCodeBlock(part.argumentsText.trim(), options.outputFormat));
     }
-    if (part.outputText?.trim()) {
-        lines.push('', 'Output:', '', renderCodeBlock(truncateOutput(part.outputText.trim()), options.outputFormat));
+    const outputText = part.outputText ?? '';
+    if (outputText.trim()) {
+        lines.push('', 'Output:', '', renderCodeBlock(truncateOutput(outputText.trim()), options.outputFormat));
     }
 
     return renderSection('Tool Call', lines.join('\n'), options.outputFormat);

package/src/lib/shared.ts

@@ -86,6 +86,18 @@ export const cleanExtractedText = (text: string): string => {
     return text.replace(/^\s*<\/?image>\s*$/gm, '').replace(/\n{3,}/g, '\n\n');
 };
 
+const CODEX_APP_DIRECTIVE_PATTERN =
+    /^::(?:code-comment|created-thread|git-commit|git-create-branch|git-create-pr|git-push|git-stage)\{.*\}\s*$/u;
+
+export const stripCodexAppDirectiveLines = (text: string): string => {
+    return text
+        .split('\n')
+        .filter((line) => !CODEX_APP_DIRECTIVE_PATTERN.test(line.trim()))
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+};
+
 export const formatModelLabel = formatSharedModelLabel;
 
 export const asObject = (value: JsonValue): Record<string, JsonValue> | null => {

package/src/lib/transcript-load-limiter.ts

@@ -0,0 +1,82 @@
+import { createConcurrencyLimiter } from './concurrency';
+
+const DEFAULT_TRANSCRIPT_LOAD_CONCURRENCY = 3;
+const MAX_TRANSCRIPT_LOAD_CONCURRENCY = 16;
+type TranscriptLoadLogContext = {
+    id?: string;
+    path?: string;
+    source?: string;
+};
+
+let nextTranscriptLoadId = 1;
+let activeTranscriptLoads = 0;
+let queuedTranscriptLoads = 0;
+
+export const resolveTranscriptLoadConcurrency = (value = process.env.SPIRACHA_TRANSCRIPT_LOAD_CONCURRENCY): number => {
+    const parsed = Number.parseInt(value ?? '', 10);
+    return Number.isFinite(parsed) && parsed > 0
+        ? Math.min(parsed, MAX_TRANSCRIPT_LOAD_CONCURRENCY)
+        : DEFAULT_TRANSCRIPT_LOAD_CONCURRENCY;
+};
+
+const transcriptLoadLimiter = createConcurrencyLimiter(resolveTranscriptLoadConcurrency());
+
+const shouldLogTranscriptLoads = () => process.env.SPIRACHA_TRANSCRIPT_LOAD_LOGS !== '0';
+
+const logTranscriptLoad = (event: string, details: Record<string, unknown>) => {
+    if (shouldLogTranscriptLoads()) {
+        console.info(`[spiracha:transcript-load] ${event}`, details);
+    }
+};
+
+export const runWithTranscriptLoadLimit = async <T>(
+    loader: () => Promise<T>,
+    context: TranscriptLoadLogContext = {},
+): Promise<T> => {
+    const loadId = nextTranscriptLoadId;
+    nextTranscriptLoadId += 1;
+    queuedTranscriptLoads += 1;
+    const queuedAt = Date.now();
+
+    return transcriptLoadLimiter(async () => {
+        queuedTranscriptLoads -= 1;
+        activeTranscriptLoads += 1;
+        const startedAt = Date.now();
+        logTranscriptLoad('start', {
+            active: activeTranscriptLoads,
+            id: context.id,
+            loadId,
+            path: context.path,
+            queued: queuedTranscriptLoads,
+            source: context.source,
+            waitMs: startedAt - queuedAt,
+        });
+
+        try {
+            return await loader();
+        } catch (error) {
+            logTranscriptLoad('error', {
+                active: activeTranscriptLoads,
+                durationMs: Date.now() - startedAt,
+                error: error instanceof Error ? error.message : String(error),
+                id: context.id,
+                loadId,
+                path: context.path,
+                queued: queuedTranscriptLoads,
+                source: context.source,
+            });
+            throw error;
+        } finally {
+            activeTranscriptLoads -= 1;
+            logTranscriptLoad('finish', {
+                active: activeTranscriptLoads,
+                durationMs: Date.now() - startedAt,
+                id: context.id,
+                loadId,
+                path: context.path,
+                queued: queuedTranscriptLoads,
+                source: context.source,
+            });
+        }
+    });
+};

package/src/lib/ui-cache.ts

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { mkdir, readdir, rename, rm, stat } from 'node:fs/promises';
+import { chmod, mkdir, readdir, rename, rm, stat } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
@@ -11,8 +11,13 @@ type CacheEnvelope<T> = {
     version: number;
 };
 
+type CacheReadResult<T> = { hit: true; value: T } | { hit: false };
+
+const inFlightCacheLoads = new Map<string, Promise<unknown>>();
+
 const ensureCacheDir = async () => {
-    await mkdir(CACHE_DIR, { recursive: true });
+    await mkdir(CACHE_DIR, { mode: 0o700, recursive: true });
+    await chmod(CACHE_DIR, 0o700);
 };
 
 const toCachePath = (key: string) => {
@@ -41,12 +46,12 @@ export const getFileFingerprint = async (filePath: string) => {
     return `${filePath}:${metadata.size}:${metadata.mtimeMs}`;
 };
 
-export const getCachedJson = async <T>(key: string): Promise<T | null> => {
+const readCachedJson = async <T>(key: string): Promise<CacheReadResult<T>> => {
     await ensureCacheDir();
     const filePath = toCachePath(key);
     const file = Bun.file(filePath);
     if (!(await file.exists())) {
-        return null;
+        return { hit: false };
     }
 
     let parsed: CacheEnvelope<T> | T;
@@ -54,7 +59,7 @@ export const getCachedJson = async <T>(key: string): Promise<T | null> => {
         parsed = (await file.json()) as CacheEnvelope<T> | T;
     } catch {
         await rm(filePath, { force: true });
-        return null;
+        return { hit: false };
     }
 
     if (
@@ -64,11 +69,16 @@ export const getCachedJson = async <T>(key: string): Promise<T | null> => {
         (parsed as CacheEnvelope<T>).version === CACHE_ENVELOPE_VERSION &&
         'value' in parsed
     ) {
-        return (parsed as CacheEnvelope<T>).value;
+        return { hit: true, value: (parsed as CacheEnvelope<T>).value };
     }
 
     await rm(filePath, { force: true });
-    return null;
+    return { hit: false };
+};
+
+export const getCachedJson = async <T>(key: string): Promise<T | null> => {
+    const cached = await readCachedJson<T>(key);
+    return cached.hit ? cached.value : null;
 };
 
 export const setCachedJson = async <T>(key: string, value: T) => {
@@ -80,21 +90,37 @@ export const setCachedJson = async <T>(key: string, value: T) => {
         version: CACHE_ENVELOPE_VERSION,
     };
 
-    await Bun.write(tempPath, JSON.stringify(envelope));
-    await rename(tempPath, filePath);
+    try {
+        await Bun.write(tempPath, JSON.stringify(envelope));
+        await rename(tempPath, filePath);
+    } finally {
+        await rm(tempPath, { force: true });
+    }
 };
 
 export const withCachedJson = async <T>(key: string, loader: () => Promise<T>): Promise<T> => {
-    const filePath = toCachePath(key);
-    const existedBeforeRead = await Bun.file(filePath).exists();
-    const cached = await getCachedJson<T>(key);
-    if (cached !== null || (existedBeforeRead && (await Bun.file(filePath).exists()))) {
-        return cached as T;
+    const cached = await readCachedJson<T>(key);
+    if (cached.hit) {
+        return cached.value;
+    }
+
+    const inFlight = inFlightCacheLoads.get(key);
+    if (inFlight) {
+        return (await inFlight) as T;
     }
 
-    const value = await loader();
-    await setCachedJson(key, value);
-    return value;
+    const load = (async () => {
+        const value = await loader();
+        await setCachedJson(key, value);
+        return value;
+    })();
+    inFlightCacheLoads.set(key, load);
+
+    try {
+        return await load;
+    } finally {
+        inFlightCacheLoads.delete(key);
+    }
 };
 
 export const invalidateCacheByPrefix = async (...prefixes: string[]) => {

package/src/lib/ui-export-archive.ts

@@ -1,5 +1,24 @@
 import type { ExportFormat } from './shared';
 
+type BatchExportNameEntry = {
+    cwd: string | null;
+    updatedAtMs: number | null;
+};
+
+type ConversationExportNameEntry = BatchExportNameEntry & {
+    id: string;
+};
+
+const getPortablePathBasename = (value: string): string => {
+    const trimmed = value.replace(/[\\/]+$/u, '');
+    if (!trimmed) {
+        return '';
+    }
+
+    const separatorIndex = Math.max(trimmed.lastIndexOf('/'), trimmed.lastIndexOf('\\'));
+    return separatorIndex === -1 ? trimmed : trimmed.slice(separatorIndex + 1);
+};
+
 export const sanitizeExportFileName = (value: string) => {
     return value
         .replace(/[<>:"/\\|?*\u0000-\u001f]/gu, ' ')
@@ -18,6 +37,47 @@ export const resolveUniqueExportFileBaseName = (baseName: string, usedCounts: Ma
     return count === 1 ? baseName : `${baseName}-${count}`;
 };
 
+const formatBatchExportDate = (value: number) => {
+    const date = new Date(value);
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(date.getUTCDate()).padStart(2, '0');
+    const hours = String(date.getUTCHours()).padStart(2, '0');
+    const minutes = String(date.getUTCMinutes()).padStart(2, '0');
+    return `${year}-${month}-${day}-${hours}${minutes}`;
+};
+
+const resolveExportProjectName = (cwd: string | null, fallbackProjectName: string) => {
+    return sanitizeExportFileName(getPortablePathBasename(cwd ?? '') || fallbackProjectName) || 'threads';
+};
+
+export const buildConversationExportBaseName = (
+    { cwd, id, updatedAtMs }: ConversationExportNameEntry,
+    fallbackProjectName: string,
+) => {
+    const projectName = resolveExportProjectName(cwd, fallbackProjectName);
+    const shortId = sanitizeExportFileName(id).slice(0, 8) || 'conversation';
+    return Number.isFinite(updatedAtMs) && (updatedAtMs ?? 0) > 0
+        ? `${projectName}-${formatBatchExportDate(updatedAtMs!)}-${shortId}`
+        : `${projectName}-${shortId}`;
+};
+
+export const buildBatchExportBaseName = (entries: BatchExportNameEntry[], fallbackProjectName: string) => {
+    if (entries.length === 0) {
+        throw new Error('No conversations selected for export');
+    }
+
+    const firstCwd = entries.find((entry) => entry.cwd?.trim())?.cwd ?? null;
+    const projectName = resolveExportProjectName(firstCwd, fallbackProjectName);
+    const latestUpdatedAtMs = Math.max(
+        ...entries.map((entry) => (Number.isFinite(entry.updatedAtMs) ? (entry.updatedAtMs ?? 0) : 0)),
+    );
+
+    return latestUpdatedAtMs > 0
+        ? `${projectName}-${formatBatchExportDate(latestUpdatedAtMs)}-threads-${entries.length}`
+        : `${projectName}-threads-${entries.length}`;
+};
+
 const readPipeText = async (pipe: ReadableStream<Uint8Array> | number | undefined) => {
     return pipe && typeof pipe !== 'number' ? new Response(pipe).text() : '';
 };