spiracha 1.5.0 → 2.1.0

package/src/lib/{codex-exporter-transcript.ts → codex-transcript-renderer.ts}

@@ -2,8 +2,14 @@ import { createReadStream } from 'node:fs';
 import { rm } from 'node:fs/promises';
 import path from 'node:path';
 import { finished } from 'node:stream/promises';
-import { matchesFilters, toCodexRelativePath } from './codex-exporter-db';
-import type { CodexCliOptions, ExportTarget, MessageRecord, SessionMeta, ToolRecord } from './codex-exporter-types';
+import {
+    type CodexTranscriptExportTarget,
+    type CodexTranscriptRenderOptions,
+    DEFAULT_CODEX_DIR,
+    type MessageRecord,
+    type SessionMeta,
+    type ToolRecord,
+} from './codex-thread-types';
 import {
     asObject,
     asString,
@@ -20,22 +26,30 @@ import {
     renderDocumentTitle,
     renderMetadataBlock,
     renderSection,
+    stripCodexAppDirectiveLines,
 } from './shared';
+import { runWithTranscriptLoadLimit } from './transcript-load-limiter';
 
-export const convertSessionFile = async (target: ExportTarget, options: CodexCliOptions): Promise<string | null> => {
+export const renderCodexSessionFile = async (
+    target: CodexTranscriptExportTarget,
+    options: CodexTranscriptRenderOptions,
+): Promise<string | null> => {
     let transcriptState: CodexTranscriptState;
 
     try {
-        transcriptState = await collectCodexTranscript(target.sessionFile, options, target.thread?.model ?? null);
+        transcriptState = await runWithTranscriptLoadLimit(
+            () => collectCodexTranscript(target.sessionFile, options, target.thread?.model ?? null),
+            {
+                id: target.thread?.id,
+                path: target.sessionFile,
+                source: 'codex-export-inline',
+            },
+        );
     } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         throw new Error(`Failed to read Codex transcript ${target.sessionFile}: ${message}`);
     }
 
-    if (!matchesFilters(target.thread?.cwd ?? transcriptState.sessionMeta.cwd ?? null, options)) {
-        return null;
-    }
-
     if (transcriptState.sections.length === 0) {
         return null;
     }
@@ -57,9 +71,9 @@ export const convertSessionFile = async (target: ExportTarget, options: CodexCli
 
 type TranscriptTextTransform = (text: string) => string;
 
-export const writeSessionFileExport = async (
-    target: ExportTarget,
-    options: CodexCliOptions,
+export const writeCodexSessionFileExport = async (
+    target: CodexTranscriptExportTarget,
+    options: CodexTranscriptRenderOptions,
     outputPath: string,
     transform: TranscriptTextTransform = (text) => text,
 ): Promise<boolean> => {
@@ -73,21 +87,30 @@ export const writeSessionFileExport = async (
     let wroteSection = false;
 
     try {
-        transcriptStream = await createExportWriteStream(transcriptOutputPath);
-        for await (const parsed of readJsonlObjects(target.sessionFile)) {
-            captureSessionMeta(parsed, state.sessionMeta);
-            const block = renderCodexTranscriptRecord(parsed, options, state);
-            if (!block) {
-                continue;
-            }
-
-            transcriptStream.write(transform(wroteSection ? `${getSectionSeparator()}${block}` : block));
-            wroteSection = true;
-        }
-        await finalizeExportWriteStream(transcriptStream);
-        transcriptStream = null;
-
-        if (!matchesFilters(target.thread?.cwd ?? state.sessionMeta.cwd ?? null, options) || !wroteSection) {
+        await runWithTranscriptLoadLimit(
+            async () => {
+                transcriptStream = await createExportWriteStream(transcriptOutputPath);
+                for await (const parsed of readJsonlObjects(target.sessionFile)) {
+                    captureSessionMeta(parsed, state.sessionMeta);
+                    const block = renderCodexTranscriptRecord(parsed, options, state);
+                    if (!block) {
+                        continue;
+                    }
+
+                    transcriptStream.write(transform(wroteSection ? `${getSectionSeparator()}${block}` : block));
+                    wroteSection = true;
+                }
+                await finalizeExportWriteStream(transcriptStream);
+                transcriptStream = null;
+            },
+            {
+                id: target.thread?.id,
+                path: target.sessionFile,
+                source: 'codex-export-stream',
+            },
+        );
+
+        if (!wroteSection) {
             return false;
         }
 
@@ -127,7 +150,7 @@ type CodexTranscriptState = {
 
 const collectCodexTranscript = async (
     sessionFile: string,
-    options: CodexCliOptions,
+    options: CodexTranscriptRenderOptions,
     assistantModel: string | null = null,
 ): Promise<CodexTranscriptState> => {
     const state: CodexTranscriptState = {
@@ -147,7 +170,7 @@ const getSectionSeparator = () => '\n';
 
 const processCodexTranscriptRecord = (
     parsed: Record<string, JsonValue>,
-    options: CodexCliOptions,
+    options: CodexTranscriptRenderOptions,
     state: CodexTranscriptState,
 ) => {
     captureSessionMeta(parsed, state.sessionMeta);
@@ -159,7 +182,7 @@ const processCodexTranscriptRecord = (
 
 const renderCodexTranscriptRecord = (
     parsed: Record<string, JsonValue>,
-    options: CodexCliOptions,
+    options: CodexTranscriptRenderOptions,
     state: CodexTranscriptState,
 ) => {
     const message = extractMessageRecord(parsed);
@@ -179,16 +202,24 @@ const renderCodexTranscriptRecord = (
     return renderToolBlock(tool, options.outputFormat);
 };
 
-const processCodexMessageRecord = (message: MessageRecord, options: CodexCliOptions, state: CodexTranscriptState) => {
-    return renderMessageBlock(message, options.outputFormat, state.assistantModel, options.includeCommentary);
+const processCodexMessageRecord = (
+    message: MessageRecord,
+    options: CodexTranscriptRenderOptions,
+    state: CodexTranscriptState,
+) => {
+    return renderMessageBlock(message, options.outputFormat, state, options.includeCommentary);
 };
 
-const buildStreamExportPrefix = (target: ExportTarget, sessionMeta: SessionMeta, options: CodexCliOptions) => {
+const buildStreamExportPrefix = (
+    target: CodexTranscriptExportTarget,
+    sessionMeta: SessionMeta,
+    options: CodexTranscriptRenderOptions,
+) => {
+    const title = getTitle(target, sessionMeta);
     if (!options.includeMetadata) {
-        return '';
+        return `${renderDocumentTitle(title, options.outputFormat)}\n`;
     }
 
-    const title = getTitle(target, sessionMeta);
     const parts = [
         renderDocumentTitle(title, options.outputFormat),
         '',
@@ -253,7 +284,7 @@ export const parseExecCommandArguments = (argumentsText?: string) => {
     }
 };
 
-const getTitle = (target: ExportTarget, sessionMeta: SessionMeta): string => {
+const getTitle = (target: CodexTranscriptExportTarget, sessionMeta: SessionMeta): string => {
     if (target.thread?.title) {
         return cleanInlineTitle(target.thread.title);
     }
@@ -261,10 +292,21 @@ const getTitle = (target: ExportTarget, sessionMeta: SessionMeta): string => {
     return sessionMeta.id ?? path.basename(target.sessionFile, '.jsonl');
 };
 
+const toCodexRelativePath = (targetPath: string): string => {
+    const codexRoot = path.resolve(DEFAULT_CODEX_DIR);
+    const normalized = path.resolve(targetPath);
+
+    if (normalized.startsWith(`${codexRoot}${path.sep}`)) {
+        return path.relative(codexRoot, normalized);
+    }
+
+    return normalized;
+};
+
 const buildMetadataEntries = (
-    target: ExportTarget,
+    target: CodexTranscriptExportTarget,
     sessionMeta: SessionMeta,
-    options: CodexCliOptions,
+    options: CodexTranscriptRenderOptions,
 ): MetadataEntry[] => {
     return [
         ...buildCodexExportIdentityMetadata(target, sessionMeta),
@@ -275,7 +317,10 @@ const buildMetadataEntries = (
     ];
 };
 
-const buildCodexExportIdentityMetadata = (target: ExportTarget, sessionMeta: SessionMeta): MetadataEntry[] => {
+const buildCodexExportIdentityMetadata = (
+    target: CodexTranscriptExportTarget,
+    sessionMeta: SessionMeta,
+): MetadataEntry[] => {
     const thread = target.thread;
 
     return [
@@ -289,7 +334,10 @@ const buildCodexExportIdentityMetadata = (target: ExportTarget, sessionMeta: Ses
     ];
 };
 
-const buildCodexExportPathMetadata = (target: ExportTarget, options: CodexCliOptions): MetadataEntry[] => {
+const buildCodexExportPathMetadata = (
+    target: CodexTranscriptExportTarget,
+    options: CodexTranscriptRenderOptions,
+): MetadataEntry[] => {
     const relativeOutputPath = target.outputRelativePath;
 
     return [
@@ -306,7 +354,7 @@ const buildCodexExportPathMetadata = (target: ExportTarget, options: CodexCliOpt
     ];
 };
 
-const buildCodexRelationMetadata = (target: ExportTarget): MetadataEntry[] => {
+const buildCodexRelationMetadata = (target: CodexTranscriptExportTarget): MetadataEntry[] => {
     const childThreadIds = target.relations.childEdges.map((edge) => edge.child_thread_id);
     const childEdges = target.relations.childEdges.map((edge) => ({
         child_thread_id: edge.child_thread_id,
@@ -320,14 +368,17 @@ const buildCodexRelationMetadata = (target: ExportTarget): MetadataEntry[] => {
     ];
 };
 
-const buildCodexThreadMetadata = (target: ExportTarget, sessionMeta: SessionMeta): MetadataEntry[] => {
+const buildCodexThreadMetadata = (target: CodexTranscriptExportTarget, sessionMeta: SessionMeta): MetadataEntry[] => {
     return [
         ...buildCodexThreadTimingMetadata(target, sessionMeta),
         ...buildCodexThreadIdentityMetadata(target, sessionMeta),
     ];
 };
 
-const buildCodexThreadTimingMetadata = (target: ExportTarget, sessionMeta: SessionMeta): MetadataEntry[] => {
+const buildCodexThreadTimingMetadata = (
+    target: CodexTranscriptExportTarget,
+    sessionMeta: SessionMeta,
+): MetadataEntry[] => {
     const thread = target.thread;
 
     return [
@@ -341,7 +392,10 @@ const buildCodexThreadTimingMetadata = (target: ExportTarget, sessionMeta: Sessi
     ];
 };
 
-const buildCodexThreadIdentityMetadata = (target: ExportTarget, sessionMeta: SessionMeta): MetadataEntry[] => {
+const buildCodexThreadIdentityMetadata = (
+    target: CodexTranscriptExportTarget,
+    sessionMeta: SessionMeta,
+): MetadataEntry[] => {
     const thread = target.thread;
 
     return [
@@ -367,7 +421,7 @@ const buildCodexThreadIdentityMetadata = (target: ExportTarget, sessionMeta: Ses
     ];
 };
 
-const buildCodexAgentMetadata = (target: ExportTarget): MetadataEntry[] => {
+const buildCodexAgentMetadata = (target: CodexTranscriptExportTarget): MetadataEntry[] => {
     const thread = target.thread;
 
     return [
@@ -506,7 +560,7 @@ const extractToolRecord = (parsed: Record<string, JsonValue>): ToolRecord | null
 const renderMessageBlock = (
     message: MessageRecord,
     outputFormat: ExportFormat,
-    assistantModel: string | null,
+    state: CodexTranscriptState,
     includeCommentary: boolean,
 ): string => {
     if (message.role !== 'user' && message.role !== 'assistant') {
@@ -517,12 +571,13 @@ const renderMessageBlock = (
         return '';
     }
 
-    const text = cleanExtractedText(stripPreviewBlock(extractText(message.content))).trim();
+    const extractedText = extractText(message.content);
+    const text = stripCodexAppDirectiveLines(cleanExtractedText(stripPreviewBlock(extractedText)));
     if (!text || shouldSkipMessage(message.role, text)) {
         return '';
     }
 
-    const title = message.role === 'user' ? 'User' : formatModelLabel(message.model ?? assistantModel);
+    const title = message.role === 'user' ? 'User' : formatModelLabel(message.model ?? state.assistantModel);
     const body = message.phase ? `Phase: ${message.phase}\n\n${text}` : text;
 
     return renderSection(title, body, outputFormat);
@@ -534,7 +589,8 @@ const renderToolBlock = (tool: ToolRecord, outputFormat: ExportFormat): string =
         return details ? renderSection('Tool', details, outputFormat) : '';
     }
 
-    const summary = formatToolOutputSummary(tool.outputText ?? '', outputFormat);
+    const outputText = tool.outputText ?? '';
+    const summary = formatToolOutputSummary(outputText, outputFormat);
     return summary ? renderSection('Tool Output', summary, outputFormat) : '';
 };
 

package/src/lib/concurrency.ts

@@ -23,3 +23,44 @@ export const mapWithConcurrency = async <T, TResult>(
     await Promise.all(Array.from({ length: Math.min(workerLimit, values.length) }, () => worker()));
     return results;
 };
+
+export const createConcurrencyLimiter = (limit: number) => {
+    const requestedLimit = Number.isFinite(limit) ? Math.floor(limit) : 1;
+    const workerLimit = Math.max(1, requestedLimit);
+    const queue: Array<() => void> = [];
+    let activeCount = 0;
+
+    const drain = () => {
+        if (activeCount >= workerLimit) {
+            return;
+        }
+
+        const next = queue.shift();
+        if (next) {
+            next();
+        }
+    };
+
+    return async <T>(task: () => Promise<T>): Promise<T> => {
+        await new Promise<void>((resolve) => {
+            const start = () => {
+                activeCount += 1;
+                resolve();
+            };
+
+            if (activeCount < workerLimit) {
+                start();
+                return;
+            }
+
+            queue.push(start);
+        });
+
+        try {
+            return await task();
+        } finally {
+            activeCount -= 1;
+            drain();
+        }
+    };
+};