spiracha 2.1.0 → 2.2.0

package/src/lib/antigravity-db.ts

@@ -1,4 +1,5 @@
-import { readdir, rm, stat } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { chmod, readdir, rename, rm, stat } from 'node:fs/promises';
 import path from 'node:path';
 import {
     type AntigravityArtifact,
@@ -12,7 +13,17 @@ import {
 } from './antigravity-exporter-types';
 import { decryptAntigravitySafeStoragePayload } from './antigravity-keychain';
 import { resolveAntigravityProjectNames } from './antigravity-projects';
+import { getAntigravityAssistantPhase, getFinalAntigravityAssistantSequences } from './antigravity-transcript-phase';
 import { mapWithConcurrency } from './concurrency';
+import {
+    type ExportFormat,
+    formatInlineLiteral,
+    type MetadataEntry,
+    renderCodeBlock,
+    renderDocumentTitle,
+    renderMetadataBlock,
+    renderSection,
+} from './shared';
 
 type ProtoField = {
     bytes?: Uint8Array;
@@ -66,11 +77,19 @@ export type AntigravityConversationMessage = {
     createdAtMs: number | null;
     metadata: Record<string, unknown>;
     order: number;
-    phase: 'final_answer' | 'reasoning' | 'tool_call' | 'tool_output' | 'unknown';
+    phase: 'commentary' | 'final_answer' | 'reasoning' | 'tool_call' | 'tool_output' | 'unknown';
     role: 'assistant' | 'system' | 'tool' | 'unknown' | 'user';
     text: string;
 };
 
+export type AntigravityConversationRenderOptions = {
+    includeCommentary?: boolean;
+    includeMetadata?: boolean;
+    includeTools?: boolean;
+    keychainSecret?: string | null;
+    outputFormat?: ExportFormat;
+};
+
 type WorkspaceInfo = Pick<SummaryEntry, 'workspaceFolder' | 'workspaceKey' | 'workspaceLabel' | 'workspaceUri'>;
 
 const UNKNOWN_WORKSPACE: WorkspaceInfo = {
@@ -400,7 +419,15 @@ const removeConversationFromSummaryIndex = async (summaryPath: string, conversat
         return false;
     }
 
-    await Bun.write(summaryPath, Buffer.concat(retained));
+    const tempPath = `${summaryPath}.${randomUUID()}.tmp`;
+    const mode = (await stat(summaryPath)).mode & 0o777;
+    try {
+        await Bun.write(tempPath, Buffer.concat(retained));
+        await chmod(tempPath, mode);
+        await rename(tempPath, summaryPath);
+    } finally {
+        await rm(tempPath, { force: true });
+    }
     return true;
 };
 
@@ -577,15 +604,6 @@ const mergeArtifactMaps = async (roots: string[]): Promise<Map<string, Antigravi
     return merged;
 };
 
-const countJsonlEntries = async (filePath: string): Promise<number> => {
-    try {
-        const text = await Bun.file(filePath).text();
-        return text.split(/\r?\n/u).filter((line) => line.trim().length > 0).length;
-    } catch {
-        return 0;
-    }
-};
-
 const stripModelQualifier = (value: string): string => value.replace(/\s*\([^)]*\)\s*$/u, '').trim();
 
 const extractModelSelection = (content: string): string | null => {
@@ -610,18 +628,31 @@ const extractModelSelection = (content: string): string | null => {
     return rawModel ? stripModelQualifier(rawModel) : null;
 };
 
-const extractTranscriptModel = async (filePath: string): Promise<string | null> => {
-    const text = await Bun.file(filePath)
-        .text()
-        .catch(() => '');
+const transcriptAnalysisCache = new Map<string, { entryCount: number; model: string | null }>();
+
+const analyzeTranscriptFile = async (filePath: string, size: number, mtimeMs: number) => {
+    const cacheKey = `${filePath}:${size}:${mtimeMs}`;
+    const cached = transcriptAnalysisCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const text = await Bun.file(filePath).text();
+    let model: string | null = null;
     for (const entry of parseLogEntries(text)) {
-        const model = extractModelSelection(getString(entry.content) ?? '');
-        if (model) {
-            return model;
+        model = extractModelSelection(getString(entry.content) ?? '') ?? model;
+        if (model !== null) {
+            break;
         }
     }
-
-    return null;
+    const analysis = {
+        entryCount: text.split(/\r?\n/u).filter((line) => line.trim().length > 0).length,
+        model,
+    };
+    if (transcriptAnalysisCache.size >= 256) {
+        transcriptAnalysisCache.delete(transcriptAnalysisCache.keys().next().value ?? '');
+    }
+    transcriptAnalysisCache.set(cacheKey, analysis);
+    return analysis;
 };
 
 const preferTranscriptFile = (current: TranscriptFile | undefined, candidate: TranscriptFile): TranscriptFile => {
@@ -658,11 +689,12 @@ const readTranscriptFileCandidate = async (
         if (!info.isFile()) {
             return null;
         }
+        const analysis = await analyzeTranscriptFile(transcriptPath, info.size, info.mtimeMs);
 
         return {
             bytes: info.size,
-            entryCount: await countJsonlEntries(transcriptPath),
-            model: await extractTranscriptModel(transcriptPath),
+            entryCount: analysis.entryCount,
+            model: analysis.model,
             mtimeMs: info.mtimeMs,
             path: transcriptPath,
             root,
@@ -1043,48 +1075,99 @@ const logEntryHeading = (entry: AntigravityLogEntry): string => {
     return type ? `Tool: ${type}` : 'Event';
 };
 
-const renderToolCalls = (toolCalls: unknown): string[] => {
+type ResolvedAntigravityConversationRenderOptions = {
+    includeCommentary: boolean;
+    includeMetadata: boolean;
+    includeTools: boolean;
+    keychainSecret: string | null;
+    outputFormat: ExportFormat;
+};
+
+const resolveAntigravityRenderOptions = (
+    options: AntigravityConversationRenderOptions,
+): ResolvedAntigravityConversationRenderOptions => ({
+    includeCommentary: options.includeCommentary ?? true,
+    includeMetadata: options.includeMetadata ?? true,
+    includeTools: options.includeTools ?? true,
+    keychainSecret: options.keychainSecret ?? null,
+    outputFormat: options.outputFormat ?? 'md',
+});
+
+const renderNestedHeading = (title: string, outputFormat: ExportFormat) => {
+    return outputFormat === 'md' ? `### ${title}` : `${title}\n${'~'.repeat(Math.max(title.length, 3))}`;
+};
+
+const renderToolCalls = (toolCalls: unknown, outputFormat: ExportFormat): string => {
     if (!Array.isArray(toolCalls) || toolCalls.length === 0) {
-        return [];
+        return '';
     }
 
-    const parts = ['### Tool Calls', ''];
+    const parts: string[] = [];
     for (const call of toolCalls) {
         if (!call || typeof call !== 'object') {
             continue;
         }
 
         const { args, name } = call as { args?: unknown; name?: unknown };
-        parts.push(`- \`${typeof name === 'string' ? name : 'unknown'}\``);
+        parts.push(`- ${formatInlineLiteral(typeof name === 'string' ? name : 'unknown', outputFormat)}`);
         if (args !== undefined) {
-            parts.push('', '```json', JSON.stringify(args, null, 2), '```', '');
+            parts.push('', 'Input:', '', renderCodeBlock(JSON.stringify(args, null, 2), outputFormat), '');
         }
     }
 
-    return parts;
+    return parts.length > 0 ? [renderNestedHeading('Tool Calls', outputFormat), '', ...parts].join('\n').trimEnd() : '';
 };
 
-const renderLogEntry = (entry: AntigravityLogEntry): string[] => {
-    const heading = logEntryHeading(entry);
-    const timestamp = getString(entry.created_at);
-    const content = cleanLogContent(entry);
+const renderLogEntryBodyParts = (
+    entry: AntigravityLogEntry,
+    role: AntigravityConversationMessage['role'],
+    sequence: number,
+    finalAssistantSequences: Set<number>,
+    options: ResolvedAntigravityConversationRenderOptions,
+): string[] => {
+    const bodyParts: string[] = [];
     const thinking = getString(entry.thinking) ?? '';
-    const parts = [`## ${heading}`, ''];
+    if (options.includeCommentary && thinking) {
+        bodyParts.push(renderNestedHeading('Thinking', options.outputFormat), '', thinking.trim(), '');
+    }
 
-    if (timestamp) {
-        parts.push(`_Timestamp: ${timestamp}_`, '');
+    const content = cleanLogContent(entry);
+    const phase = role === 'assistant' ? getAntigravityAssistantPhase(sequence, finalAssistantSequences) : 'unknown';
+    if (content && (role !== 'assistant' || phase !== 'commentary' || options.includeCommentary)) {
+        bodyParts.push(content, '');
     }
 
-    if (thinking) {
-        parts.push('### Thinking', '', thinking.trim(), '');
+    const toolCalls = options.includeTools ? renderToolCalls(entry.tool_calls, options.outputFormat) : '';
+    if (toolCalls) {
+        bodyParts.push(toolCalls);
     }
 
-    if (content) {
-        parts.push(content, '');
+    return bodyParts;
+};
+
+const renderLogEntry = (
+    entry: AntigravityLogEntry,
+    sequence: number,
+    finalAssistantSequences: Set<number>,
+    options: ResolvedAntigravityConversationRenderOptions,
+): string => {
+    const heading = logEntryHeading(entry);
+    const role = logEntryRole(entry);
+    if (!options.includeTools && (role === 'tool' || heading.startsWith('Tool: '))) {
+        return '';
     }
 
-    parts.push(...renderToolCalls(entry.tool_calls));
-    return parts;
+    const timestamp = getString(entry.created_at);
+    const bodyParts = renderLogEntryBodyParts(entry, role, sequence, finalAssistantSequences, options);
+
+    if (bodyParts.length === 0) {
+        return '';
+    }
+
+    const parts = timestamp
+        ? [options.outputFormat === 'md' ? `_Timestamp: ${timestamp}_` : `Timestamp: ${timestamp}`, '', ...bodyParts]
+        : bodyParts;
+    return renderSection(heading, parts.join('\n').trimEnd(), options.outputFormat);
 };
 
 const logEntryCreatedAtMs = (entry: AntigravityLogEntry): number | null => {
@@ -1122,10 +1205,14 @@ const logEntryRole = (entry: AntigravityLogEntry): AntigravityConversationMessag
     return 'unknown';
 };
 
-const logEntryPhase = (entry: AntigravityLogEntry): AntigravityConversationMessage['phase'] => {
+const logEntryPhase = (
+    entry: AntigravityLogEntry,
+    sequence: number,
+    finalAssistantSequences: Set<number>,
+): AntigravityConversationMessage['phase'] => {
     const role = logEntryRole(entry);
     if (role === 'assistant') {
-        return 'final_answer';
+        return getAntigravityAssistantPhase(sequence, finalAssistantSequences);
     }
     if (role === 'tool') {
         return 'tool_output';
@@ -1155,11 +1242,27 @@ const toolCallsText = (toolCalls: unknown): string => {
         .join('\n');
 };
 
-const logEntryToMessages = (entry: AntigravityLogEntry, index: number): AntigravityConversationMessage[] => {
+const getAntigravityPhaseItems = (entries: AntigravityLogEntry[]) => {
+    return entries.map((entry, sequence) => {
+        const role = logEntryRole(entry);
+        return {
+            hasContent: Boolean(cleanLogContent(entry)),
+            hasToolCalls: Array.isArray(entry.tool_calls) && entry.tool_calls.length > 0,
+            role: role === 'assistant' || role === 'user' ? role : ('other' as const),
+            sequence,
+        };
+    });
+};
+
+const logEntryToMessages = (
+    entry: AntigravityLogEntry,
+    index: number,
+    finalAssistantSequences: Set<number>,
+): AntigravityConversationMessage[] => {
     const order = logEntryOrder(entry, index);
     const createdAtMs = logEntryCreatedAtMs(entry);
     const role = logEntryRole(entry);
-    const phase = logEntryPhase(entry);
+    const phase = logEntryPhase(entry, index, finalAssistantSequences);
     const metadata = logEntryMetadata(entry);
     const messages: AntigravityConversationMessage[] = [];
     const thinking = getString(entry.thinking)?.trim();
@@ -1208,15 +1311,39 @@ export const readAntigravityConversationMessages = async (
         return [];
     }
 
-    try {
-        const entries = parseLogEntries(await Bun.file(conversation.transcriptPath).text());
-        return entries.flatMap(logEntryToMessages);
-    } catch {
-        return [];
+    const content = await Bun.file(conversation.transcriptPath).text();
+    const entries = parseLogEntries(content);
+    if (content.trim() && entries.length === 0) {
+        throw new Error(`Antigravity transcript is corrupt: ${conversation.transcriptPath}`);
+    }
+    const finalAssistantSequences = getFinalAntigravityAssistantSequences(getAntigravityPhaseItems(entries));
+    return entries.flatMap((entry, index) => logEntryToMessages(entry, index, finalAssistantSequences));
+};
+
+const renderAntigravityMetadata = (entries: MetadataEntry[], outputFormat: ExportFormat): string => {
+    if (outputFormat === 'txt') {
+        return renderMetadataBlock(entries, outputFormat);
     }
+
+    return entries
+        .filter((entry) => entry.value !== null && entry.value !== undefined && entry.value !== '')
+        .map((entry) => `- ${entry.key}: ${formatInlineLiteral(String(entry.value), outputFormat)}`)
+        .join('\n');
 };
 
-const renderAntigravityTranscriptMarkdown = async (conversation: AntigravityConversation): Promise<string | null> => {
+const buildAntigravityIdentityMetadata = (
+    conversation: AntigravityConversation,
+    exportedFrom: string,
+): MetadataEntry[] => [
+    { key: 'exported_from', value: exportedFrom },
+    { key: 'conversation_id', value: conversation.conversationId },
+    { key: 'workspace', value: conversation.workspaceUri },
+];
+
+const renderAntigravityTranscript = async (
+    conversation: AntigravityConversation,
+    options: ResolvedAntigravityConversationRenderOptions,
+): Promise<string | null> => {
     if (!conversation.transcriptPath || !conversation.transcriptSource) {
         return null;
     }
@@ -1230,33 +1357,44 @@ const renderAntigravityTranscriptMarkdown = async (conversation: AntigravityConv
         conversation.transcriptSource === 'overview'
             ? 'antigravity_overview_transcript'
             : 'antigravity_jsonl_transcript';
-    const sections = entries.flatMap((entry) => renderLogEntry(entry));
+    const finalAssistantSequences = getFinalAntigravityAssistantSequences(getAntigravityPhaseItems(entries));
+    const sections = entries
+        .map((entry, sequence) => renderLogEntry(entry, sequence, finalAssistantSequences, options))
+        .filter(Boolean);
     const parts = [
-        `# ${conversation.title}`,
-        '',
-        `- exported_from: \`${exportedFrom}\``,
-        `- conversation_id: \`${conversation.conversationId}\``,
-        conversation.workspaceUri ? `- workspace: \`${conversation.workspaceUri}\`` : '',
+        renderDocumentTitle(conversation.title, options.outputFormat),
         '',
+        options.includeMetadata
+            ? renderAntigravityMetadata(
+                  buildAntigravityIdentityMetadata(conversation, exportedFrom),
+                  options.outputFormat,
+              )
+            : '',
         ...sections,
     ].filter(Boolean);
 
     return `${parts.join('\n').trimEnd()}\n`;
 };
 
-const renderDecryptedSafeStorageMarkdown = (conversation: AntigravityConversation, content: string): string | null => {
+const renderDecryptedSafeStorage = (
+    conversation: AntigravityConversation,
+    content: string,
+    options: ResolvedAntigravityConversationRenderOptions,
+): string | null => {
     const trimmed = content.trim();
     if (!trimmed) {
         return null;
     }
 
     return [
-        `# ${conversation.title}`,
-        '',
-        '- exported_from: `antigravity_safe_storage_payload`',
-        `- conversation_id: \`${conversation.conversationId}\``,
-        conversation.workspaceUri ? `- workspace: \`${conversation.workspaceUri}\`` : '',
+        renderDocumentTitle(conversation.title, options.outputFormat),
         '',
+        options.includeMetadata
+            ? renderAntigravityMetadata(
+                  buildAntigravityIdentityMetadata(conversation, 'antigravity_safe_storage_payload'),
+                  options.outputFormat,
+              )
+            : '',
         trimmed,
         '',
     ]
@@ -1264,7 +1402,10 @@ const renderDecryptedSafeStorageMarkdown = (conversation: AntigravityConversatio
         .join('\n');
 };
 
-const renderAntigravitySummaryMarkdown = (conversation: AntigravityConversation): string | null => {
+const renderAntigravitySummary = (
+    conversation: AntigravityConversation,
+    options: ResolvedAntigravityConversationRenderOptions,
+): string | null => {
     if (conversation.artifactCount > 0) {
         return null;
     }
@@ -1274,16 +1415,30 @@ const renderAntigravitySummaryMarkdown = (conversation: AntigravityConversation)
     }
 
     return [
-        `# ${conversation.title}`,
-        '',
-        '- exported_from: `antigravity_summary_index`',
-        `- conversation_id: \`${conversation.conversationId}\``,
-        conversation.workspaceUri ? `- workspace: \`${conversation.workspaceUri}\`` : '',
-        conversation.indexedItemCount !== null ? `- indexed_items: \`${conversation.indexedItemCount}\`` : '',
-        conversation.createdAtMs ? `- created_at: \`${new Date(conversation.createdAtMs).toISOString()}\`` : '',
-        conversation.lastUpdatedAtMs ? `- updated_at: \`${new Date(conversation.lastUpdatedAtMs).toISOString()}\`` : '',
+        renderDocumentTitle(conversation.title, options.outputFormat),
         '',
-        'No local transcript log was found for this Antigravity conversation. The export contains the summary index metadata that Antigravity retained.',
+        options.includeMetadata
+            ? renderAntigravityMetadata(
+                  [
+                      ...buildAntigravityIdentityMetadata(conversation, 'antigravity_summary_index'),
+                      { key: 'indexed_items', value: conversation.indexedItemCount },
+                      {
+                          key: 'created_at',
+                          value: conversation.createdAtMs ? new Date(conversation.createdAtMs).toISOString() : null,
+                      },
+                      {
+                          key: 'updated_at',
+                          value: conversation.lastUpdatedAtMs
+                              ? new Date(conversation.lastUpdatedAtMs).toISOString()
+                              : null,
+                      },
+                  ],
+                  options.outputFormat,
+              )
+            : '',
+        options.includeMetadata
+            ? 'No local transcript log was found for this Antigravity conversation. The export contains the summary index metadata that Antigravity retained.'
+            : 'No local transcript log was found for this Antigravity conversation.',
         '',
     ]
         .filter(Boolean)
@@ -1292,22 +1447,21 @@ const renderAntigravitySummaryMarkdown = (conversation: AntigravityConversation)
 
 export const renderAntigravityConversationMarkdown = async (
     conversation: AntigravityConversation,
-    options: {
-        keychainSecret?: string | null;
-    } = {},
+    options: AntigravityConversationRenderOptions = {},
 ): Promise<string | null> => {
-    const transcript = await renderAntigravityTranscriptMarkdown(conversation);
+    const resolvedOptions = resolveAntigravityRenderOptions(options);
+    const transcript = await renderAntigravityTranscript(conversation, resolvedOptions);
     if (transcript) {
         return transcript;
     }
 
-    if (options.keychainSecret && conversation.conversationPath) {
+    if (resolvedOptions.keychainSecret && conversation.conversationPath) {
         const encrypted = Buffer.from(await Bun.file(conversation.conversationPath).arrayBuffer());
-        const decrypted = decryptAntigravitySafeStoragePayload(encrypted, options.keychainSecret);
+        const decrypted = decryptAntigravitySafeStoragePayload(encrypted, resolvedOptions.keychainSecret);
         if (decrypted) {
-            return renderDecryptedSafeStorageMarkdown(conversation, decrypted);
+            return renderDecryptedSafeStorage(conversation, decrypted, resolvedOptions);
         }
     }
 
-    return renderAntigravitySummaryMarkdown(conversation);
+    return renderAntigravitySummary(conversation, resolvedOptions);
 };

package/src/lib/antigravity-keychain.ts

@@ -169,19 +169,18 @@ export const getAntigravityDecryptionState = ({
 
 export const getCachedAntigravityKeychainSecret = (): string | null => cachedKeychainSecret;
 
+export const getAntigravityKeychainExecOptions = () => ({ timeout: 10_000 });
+
 export const readAntigravityKeychainSecret = async (): Promise<string> => {
     if (process.platform !== 'darwin') {
         throw new Error('Antigravity Keychain access is only available on macOS.');
     }
 
-    const { stdout } = await execFileAsync('security', [
-        'find-generic-password',
-        '-s',
-        ANTIGRAVITY_KEYCHAIN_SERVICE,
-        '-a',
-        ANTIGRAVITY_KEYCHAIN_ACCOUNT,
-        '-w',
-    ]);
+    const { stdout } = await execFileAsync(
+        'security',
+        ['find-generic-password', '-s', ANTIGRAVITY_KEYCHAIN_SERVICE, '-a', ANTIGRAVITY_KEYCHAIN_ACCOUNT, '-w'],
+        getAntigravityKeychainExecOptions(),
+    );
     const secret = stdout.trim();
     if (!secret) {
         throw new Error(`No secret was returned for ${ANTIGRAVITY_KEYCHAIN_SERVICE}.`);

package/src/lib/antigravity-transcript-phase.ts

@@ -0,0 +1,47 @@
+export type AntigravityTranscriptPhaseItem = {
+    hasContent: boolean;
+    hasToolCalls: boolean;
+    role: 'assistant' | 'other' | 'user';
+    sequence: number;
+};
+
+export type AntigravityAssistantMessagePhase = 'commentary' | 'final_answer';
+
+export const getFinalAntigravityAssistantSequences = (items: AntigravityTranscriptPhaseItem[]): Set<number> => {
+    const finalSequences = new Set<number>();
+    let latestAssistantContentSequence: number | null = null;
+
+    const flushAssistantRun = () => {
+        if (latestAssistantContentSequence !== null) {
+            finalSequences.add(latestAssistantContentSequence);
+        }
+        latestAssistantContentSequence = null;
+    };
+
+    for (const item of items) {
+        if (item.role === 'user') {
+            flushAssistantRun();
+            continue;
+        }
+
+        if (item.role !== 'assistant') {
+            continue;
+        }
+
+        if (item.hasToolCalls) {
+            latestAssistantContentSequence = null;
+        } else if (item.hasContent) {
+            latestAssistantContentSequence = item.sequence;
+        }
+    }
+
+    flushAssistantRun();
+    return finalSequences;
+};
+
+export const getAntigravityAssistantPhase = (
+    sequence: number,
+    finalAssistantSequences: Set<number>,
+): AntigravityAssistantMessagePhase => {
+    return finalAssistantSequences.has(sequence) ? 'final_answer' : 'commentary';
+};