spiracha 1.4.0 → 2.0.0

package/src/lib/opencode-exporter-types.ts

@@ -0,0 +1,129 @@
+import os from 'node:os';
+import path from 'node:path';
+import type { ExportFormat, JsonValue } from './shared';
+
+export const getDefaultOpenCodeDataDir = (env: NodeJS.ProcessEnv = process.env, homeDir = os.homedir()): string => {
+    return path.join(env.XDG_DATA_HOME || path.join(homeDir, '.local', 'share'), 'opencode');
+};
+
+export const DEFAULT_OPENCODE_DATA_DIR = getDefaultOpenCodeDataDir();
+
+export const resolveOpenCodeDataDir = (): string => {
+    const configured = process.env.SPIRACHA_OPENCODE_DATA_DIR?.trim() || process.env.SPIRACHA_OPENCODE_DIR?.trim();
+    return configured ? configured : DEFAULT_OPENCODE_DATA_DIR;
+};
+
+export const resolveOpenCodeDbPath = (): string => {
+    const configured = process.env.SPIRACHA_OPENCODE_DB?.trim();
+    return configured ? configured : path.join(resolveOpenCodeDataDir(), 'opencode.db');
+};
+
+export type OpenCodeWorkspaceGroup = {
+    archivedSessionCount: number;
+    key: string;
+    label: string;
+    lastActiveMs: number;
+    messageCount: number;
+    partCount: number;
+    projectId: string;
+    sessionCount: number;
+    uri: string;
+    worktree: string;
+};
+
+export type OpenCodeModelInfo = {
+    id: string | null;
+    providerID: string | null;
+    raw: JsonValue | string | null;
+    variant: string | null;
+};
+
+export type OpenCodeSessionSummary = {
+    agent: string | null;
+    archivedAtMs: number | null;
+    cost: number;
+    createdAtMs: number;
+    directory: string;
+    lastUpdatedAtMs: number;
+    messageCount: number;
+    model: OpenCodeModelInfo;
+    modelLabel: string | null;
+    partCount: number;
+    path: string | null;
+    permission: string | null;
+    projectId: string;
+    renderablePartCount: number;
+    sessionId: string;
+    slug: string;
+    summaryAdditions: number | null;
+    summaryDeletions: number | null;
+    summaryFiles: number | null;
+    textPartCount: number;
+    title: string;
+    tokensCacheRead: number;
+    tokensCacheWrite: number;
+    tokensInput: number;
+    tokensOutput: number;
+    tokensReasoning: number;
+    toolPartCount: number;
+    totalTokens: number;
+    worktree: string;
+    workspaceKey: string;
+    workspaceLabel: string;
+};
+
+export type OpenCodePartType = 'reasoning' | 'step-finish' | 'step-start' | 'text' | 'tool' | 'unknown';
+
+export type OpenCodeStepTokens = {
+    cacheRead: number;
+    cacheWrite: number;
+    input: number;
+    output: number;
+    reasoning: number;
+    total: number;
+};
+
+export type OpenCodeTranscriptPart = {
+    argumentsText?: string | null;
+    callId?: string | null;
+    createdAtMs: number;
+    endTimeMs?: number | null;
+    messageId: string;
+    outputText?: string | null;
+    partId: string;
+    raw: Record<string, JsonValue>;
+    reason?: string | null;
+    role: string;
+    snapshot?: string | null;
+    startTimeMs?: number | null;
+    status?: string | null;
+    text?: string;
+    title?: string | null;
+    tokens?: OpenCodeStepTokens | null;
+    toolName?: string | null;
+    type: OpenCodePartType;
+    updatedAtMs: number;
+};
+
+export type OpenCodeTranscriptMessage = {
+    createdAtMs: number;
+    messageId: string;
+    parts: OpenCodeTranscriptPart[];
+    raw: Record<string, JsonValue>;
+    role: string;
+    updatedAtMs: number;
+};
+
+export type OpenCodeSessionTranscript = {
+    messages: OpenCodeTranscriptMessage[];
+    partCount: number;
+    renderablePartCount: number;
+    session: OpenCodeSessionSummary;
+};
+
+export type OpenCodeExportOptions = {
+    includeCommentary: boolean;
+    includeMetadata: boolean;
+    includeTools: boolean;
+    outputFormat: ExportFormat;
+};

package/src/lib/opencode-think-tags.ts

@@ -0,0 +1,126 @@
+export type OpenCodeThinkTagText = {
+    reasoningBlocks: string[];
+    visibleText: string;
+};
+
+const THINK_OPEN_PATTERN = /<think\b[^>]*>/iy;
+const THINK_CLOSE_PATTERN = /<\/think>/gi;
+const THINK_CLOSE_TAG_LENGTH = '</think>'.length;
+
+const normalizeExtractedText = (text: string): string => {
+    return text.replace(/\n{3,}/g, '\n\n').trim();
+};
+
+const getBacktickRunLength = (text: string, start: number): number => {
+    let end = start;
+    while (text[end] === '`') {
+        end += 1;
+    }
+
+    return end - start;
+};
+
+const findClosingBackticks = (text: string, start: number, runLength: number): number => {
+    const marker = '`'.repeat(runLength);
+    const index = text.indexOf(marker, start + runLength);
+    return index === -1 ? text.length : index + runLength;
+};
+
+const findThinkCloseIndex = (text: string, start: number): number => {
+    THINK_CLOSE_PATTERN.lastIndex = start;
+    const match = THINK_CLOSE_PATTERN.exec(text);
+    return match ? match.index : -1;
+};
+
+const getLastVisibleChar = (parts: string[]): string => {
+    for (let index = parts.length - 1; index >= 0; index -= 1) {
+        const part = parts[index];
+        if (part) {
+            return part.at(-1) ?? '';
+        }
+    }
+
+    return '';
+};
+
+const getThinkReplacement = (previous: string, next: string): string => {
+    if (previous === '\n' || next === '\n') {
+        return '\n';
+    }
+    if ((previous && /\s/u.test(previous)) || (next && /\s/u.test(next))) {
+        return '';
+    }
+
+    return ' ';
+};
+
+const shouldSkipFollowingSpace = (replacement: string, previous: string, next: string): boolean => {
+    return (replacement === ' ' || Boolean(previous && /[^\S\n]/u.test(previous))) && /[^\S\n]/u.test(next);
+};
+
+const readThinkBlock = (
+    text: string,
+    cursor: number,
+    visibleParts: string[],
+): { nextCursor: number; reasoning: string | null; replacement: string } | null => {
+    THINK_OPEN_PATTERN.lastIndex = cursor;
+    const openMatch = THINK_OPEN_PATTERN.exec(text);
+    if (openMatch?.index !== cursor) {
+        return null;
+    }
+
+    const reasoningStart = THINK_OPEN_PATTERN.lastIndex;
+    const closeIndex = findThinkCloseIndex(text, reasoningStart);
+    const reasoningEnd = closeIndex === -1 ? text.length : closeIndex;
+    const normalizedReasoning = normalizeExtractedText(text.slice(reasoningStart, reasoningEnd));
+    let nextCursor = closeIndex === -1 ? text.length : closeIndex + THINK_CLOSE_TAG_LENGTH;
+    const previous = getLastVisibleChar(visibleParts);
+    const replacement = getThinkReplacement(previous, text[nextCursor] ?? '');
+    if (shouldSkipFollowingSpace(replacement, previous, text[nextCursor] ?? '')) {
+        nextCursor += 1;
+    }
+
+    return {
+        nextCursor,
+        reasoning: normalizedReasoning || null,
+        replacement,
+    };
+};
+
+/**
+ * OpenCode can store MiniMax reasoning inline as <think> blocks. Preserve literal
+ * examples in Markdown code while extracting model-emitted tags as commentary.
+ */
+export const splitOpenCodeThinkTaggedText = (text: string): OpenCodeThinkTagText => {
+    const reasoningBlocks: string[] = [];
+    const visibleParts: string[] = [];
+    let cursor = 0;
+
+    while (cursor < text.length) {
+        if (text[cursor] === '`') {
+            const runLength = getBacktickRunLength(text, cursor);
+            const end = findClosingBackticks(text, cursor, runLength);
+            visibleParts.push(text.slice(cursor, end));
+            cursor = end;
+            continue;
+        }
+
+        const thinkBlock = readThinkBlock(text, cursor, visibleParts);
+        if (thinkBlock) {
+            if (thinkBlock.reasoning) {
+                reasoningBlocks.push(thinkBlock.reasoning);
+            }
+            visibleParts.push(thinkBlock.replacement);
+            cursor = thinkBlock.nextCursor;
+            continue;
+        }
+
+        visibleParts.push(text[cursor]!);
+        cursor += 1;
+    }
+
+    return {
+        reasoningBlocks,
+        visibleText: normalizeExtractedText(visibleParts.join('')),
+    };
+};

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

@@ -0,0 +1,50 @@
+import type { OpenCodeTranscriptPart } from './opencode-exporter-types';
+import { splitOpenCodeThinkTaggedText } from './opencode-think-tags';
+
+export type OpenCodeMessagePhase = 'commentary' | 'final_answer' | null;
+
+export const getFinalOpenCodeAssistantTextPartIds = (parts: OpenCodeTranscriptPart[]): Set<string> => {
+    const finalPartIds = new Set<string>();
+    let latestAssistantTextPartId: string | null = null;
+
+    const flushAssistantRun = () => {
+        if (latestAssistantTextPartId) {
+            finalPartIds.add(latestAssistantTextPartId);
+            latestAssistantTextPartId = null;
+        }
+    };
+
+    for (const part of parts) {
+        if (part.role === 'user') {
+            flushAssistantRun();
+            continue;
+        }
+
+        if (part.role !== 'assistant') {
+            continue;
+        }
+
+        if (part.type === 'tool') {
+            latestAssistantTextPartId = null;
+            continue;
+        }
+
+        if (part.type === 'text' && splitOpenCodeThinkTaggedText(part.text ?? '').visibleText.trim()) {
+            latestAssistantTextPartId = part.partId;
+        }
+    }
+
+    flushAssistantRun();
+    return finalPartIds;
+};
+
+export const getOpenCodeTextPartPhase = (
+    part: OpenCodeTranscriptPart,
+    finalAssistantTextPartIds: Set<string>,
+): OpenCodeMessagePhase => {
+    if (part.role !== 'assistant') {
+        return null;
+    }
+
+    return finalAssistantTextPartIds.has(part.partId) ? 'final_answer' : 'commentary';
+};

package/src/lib/opencode-transcript.ts

@@ -0,0 +1,194 @@
+import type {
+    OpenCodeExportOptions,
+    OpenCodeSessionSummary,
+    OpenCodeSessionTranscript,
+    OpenCodeTranscriptPart,
+} from './opencode-exporter-types';
+import { splitOpenCodeThinkTaggedText } from './opencode-think-tags';
+import { getFinalOpenCodeAssistantTextPartIds, getOpenCodeTextPartPhase } from './opencode-transcript-phase';
+import {
+    cleanExtractedText,
+    cleanInlineTitle,
+    formatInlineLiteral,
+    type MetadataEntry,
+    renderCodeBlock,
+    renderDocumentTitle,
+    renderMetadataBlock,
+    renderSection,
+} from './shared';
+
+const TOOL_OUTPUT_PREVIEW_LIMIT = 4000;
+const MIN_DATE_MS = -8_640_000_000_000_000;
+const MAX_DATE_MS = 8_640_000_000_000_000;
+
+const formatUnixMillis = (value: number | null): string | null => {
+    if (
+        value === null ||
+        value === undefined ||
+        !Number.isFinite(value) ||
+        value < MIN_DATE_MS ||
+        value > MAX_DATE_MS
+    ) {
+        return null;
+    }
+
+    return new Date(value).toISOString();
+};
+
+const getSessionTitle = (session: OpenCodeSessionSummary): string => {
+    return cleanInlineTitle(session.title || session.sessionId);
+};
+
+const buildMetadataEntries = (session: OpenCodeSessionSummary): MetadataEntry[] => [
+    { key: 'exported_from', value: 'opencode_sqlite' },
+    { key: 'session_id', value: session.sessionId },
+    { key: 'title', value: session.title },
+    { key: 'slug', value: session.slug },
+    { key: 'project_id', value: session.projectId },
+    { key: 'worktree', value: session.worktree },
+    { key: 'directory', value: session.directory },
+    { key: 'agent', value: session.agent },
+    { key: 'model', value: session.modelLabel },
+    { key: 'created_at_unix_ms', value: session.createdAtMs },
+    { key: 'created_at_iso', value: formatUnixMillis(session.createdAtMs) },
+    { key: 'last_updated_at_unix_ms', value: session.lastUpdatedAtMs },
+    { key: 'last_updated_at_iso', value: formatUnixMillis(session.lastUpdatedAtMs) },
+    { key: 'message_count', value: session.messageCount },
+    { key: 'part_count', value: session.partCount },
+    { key: 'total_tokens', value: session.totalTokens },
+    { key: 'cost', value: session.cost },
+];
+
+const roleTitle = (role: string): string => {
+    if (role === 'assistant') {
+        return 'Assistant';
+    }
+
+    if (role === 'user') {
+        return 'User';
+    }
+
+    if (role === 'system') {
+        return 'System';
+    }
+
+    return role ? cleanInlineTitle(role) : 'Message';
+};
+
+const truncateOutput = (text: string): string => {
+    if (text.length <= TOOL_OUTPUT_PREVIEW_LIMIT) {
+        return text;
+    }
+
+    return `${text.slice(0, TOOL_OUTPUT_PREVIEW_LIMIT)}\n... (truncated)`;
+};
+
+const renderTextPart = (
+    part: OpenCodeTranscriptPart,
+    options: OpenCodeExportOptions,
+    finalAssistantTextPartIds: Set<string>,
+): string => {
+    const { reasoningBlocks, visibleText } =
+        part.role === 'assistant'
+            ? splitOpenCodeThinkTaggedText(part.text ?? '')
+            : { reasoningBlocks: [], visibleText: part.text ?? '' };
+    const sections: string[] = [];
+
+    if (options.includeCommentary) {
+        sections.push(
+            ...reasoningBlocks
+                .map((block) => cleanExtractedText(block).trim())
+                .filter(Boolean)
+                .map((block) => renderSection('Reasoning', block, options.outputFormat)),
+        );
+    }
+
+    const text = cleanExtractedText(visibleText).trim();
+    if (
+        text &&
+        (getOpenCodeTextPartPhase(part, finalAssistantTextPartIds) !== 'commentary' || options.includeCommentary)
+    ) {
+        sections.push(renderSection(roleTitle(part.role), text, options.outputFormat));
+    }
+
+    return sections.join('\n\n');
+};
+
+const renderReasoningPart = (part: OpenCodeTranscriptPart, options: OpenCodeExportOptions): string => {
+    if (!options.includeCommentary) {
+        return '';
+    }
+
+    const { reasoningBlocks, visibleText } = splitOpenCodeThinkTaggedText(part.text ?? '');
+    const text = cleanExtractedText([...reasoningBlocks, visibleText].filter(Boolean).join('\n\n')).trim();
+    return text ? renderSection('Reasoning', text, options.outputFormat) : '';
+};
+
+const renderToolPart = (part: OpenCodeTranscriptPart, options: OpenCodeExportOptions): string => {
+    if (!options.includeTools) {
+        return '';
+    }
+
+    const toolName = part.toolName ?? 'unknown';
+    const lines = [`Tool: ${formatInlineLiteral(toolName, options.outputFormat)}`];
+    if (part.status) {
+        lines.push(`Status: ${part.status}`);
+    }
+    if (part.callId) {
+        lines.push(`Call ID: ${part.callId}`);
+    }
+    if (part.title) {
+        lines.push(`Title: ${part.title}`);
+    }
+    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));
+    }
+
+    return renderSection('Tool Call', lines.join('\n'), options.outputFormat);
+};
+
+const renderPart = (
+    part: OpenCodeTranscriptPart,
+    options: OpenCodeExportOptions,
+    finalAssistantTextPartIds: Set<string>,
+): string => {
+    if (part.type === 'text') {
+        return renderTextPart(part, options, finalAssistantTextPartIds);
+    }
+
+    if (part.type === 'reasoning') {
+        return renderReasoningPart(part, options);
+    }
+
+    if (part.type === 'tool') {
+        return renderToolPart(part, options);
+    }
+
+    return '';
+};
+
+export const renderOpenCodeTranscript = (
+    transcript: OpenCodeSessionTranscript,
+    options: OpenCodeExportOptions,
+): string | null => {
+    const partsList = transcript.messages.flatMap((message) => message.parts);
+    const finalAssistantTextPartIds = getFinalOpenCodeAssistantTextPartIds(partsList);
+    const sections = partsList.map((part) => renderPart(part, options, finalAssistantTextPartIds)).filter(Boolean);
+    if (sections.length === 0) {
+        return null;
+    }
+
+    const parts = [
+        renderDocumentTitle(getSessionTitle(transcript.session), options.outputFormat),
+        '',
+        options.includeMetadata
+            ? renderMetadataBlock(buildMetadataEntries(transcript.session), options.outputFormat)
+            : '',
+        ...sections,
+    ].filter(Boolean);
+
+    return `${parts.join('\n').trimEnd()}\n`;
+};