sidekick-shared 0.27.6 → 0.28.0

package/dist/esm/parsers/openCodeParser.js

@@ -0,0 +1,625 @@
+/**
+ * @fileoverview Converts OpenCode message + parts into SessionEvent format.
+ *
+ * OpenCode stores messages and their parts as separate JSON/DB records.
+ * This module converts them to the SessionEvent format used by
+ * SessionMonitor and CLI consumers, enabling all existing event processing
+ * logic to work unchanged with OpenCode sessions.
+ *
+ * Moved from sidekick-vscode/src/services/providers/OpenCodeMessageParser.ts
+ *
+ * @module parsers/openCodeParser
+ */
+import { normalizeProviderUsage } from '../usageNormalization';
+/**
+ * OpenCode → Claude Code tool name mapping.
+ * OpenCode uses lowercase names; downstream code expects PascalCase.
+ */
+const TOOL_NAME_MAP = {
+    read: 'Read',
+    write: 'Write',
+    edit: 'Edit',
+    multiedit: 'MultiEdit',
+    bash: 'Bash',
+    glob: 'Glob',
+    grep: 'Grep',
+    webfetch: 'WebFetch',
+    websearch: 'WebSearch',
+    task: 'Task',
+    todowrite: 'TodoWrite',
+    todoread: 'TodoRead',
+    apply_patch: 'ApplyPatch',
+    list: 'List',
+    lsp: 'Lsp',
+    question: 'AskUserQuestion',
+    skill: 'Skill',
+    plan_enter: 'EnterPlanMode',
+    plan_exit: 'ExitPlanMode',
+};
+/**
+ * Normalizes an OpenCode tool name to PascalCase.
+ *
+ * Uses the known mapping table for common tools, and falls back to
+ * capitalizing the first letter for unknown names.
+ */
+export function normalizeToolName(name) {
+    if (!name)
+        return name;
+    // Check mapping (case-insensitive lookup via lowercase key)
+    const mapped = TOOL_NAME_MAP[name.toLowerCase()];
+    if (mapped)
+        return mapped;
+    // Already PascalCase (starts with uppercase)? Pass through.
+    if (name[0] >= 'A' && name[0] <= 'Z')
+        return name;
+    // Fallback: capitalize first letter
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+/**
+ * Detects plan mode enter/exit from assistant text content.
+ *
+ * OpenCode models mention plan mode in text/thinking blocks but never emit
+ * plan_enter/plan_exit tool invocations. This heuristic detects those
+ * mentions and returns the appropriate direction.
+ *
+ * @param text - Text content to scan for plan mode mentions
+ * @returns 'enter' if entering plan mode, 'exit' if leaving, null if no match
+ */
+export function detectPlanModeFromText(text) {
+    // Check exit first (more specific patterns)
+    if (/(exiting|leaving|deactivat(?:e|ing)|left) plan mode/i.test(text) ||
+        /plan mode (?:is )?(?:off|disabled|ended|complete)/i.test(text)) {
+        return 'exit';
+    }
+    // Check enter
+    if (/(entering|switch(?:ed|ing)? to|activat(?:e|ing)|now in) plan mode/i.test(text) ||
+        /plan mode (?:is )?(?:active|enabled|on)/i.test(text)) {
+        return 'enter';
+    }
+    return null;
+}
+/**
+ * Normalizes tool input fields for downstream compatibility.
+ *
+ * OpenCode uses camelCase field names (e.g. `filePath`); downstream code
+ * (MindMapDataService, SessionMonitor) expects snake_case (e.g. `file_path`).
+ * This adds snake_case aliases without removing the originals.
+ */
+export function normalizeToolInput(input) {
+    const result = { ...input };
+    // filePath → file_path (used by MindMapDataService.extractFiles, SessionMonitor.extractToolContext)
+    if ('filePath' in result && !('file_path' in result)) {
+        result.file_path = result.filePath;
+    }
+    // oldString → old_string (used by lineChangeCalculator, TempFilesTreeProvider, ToolInspectorProvider)
+    if ('oldString' in result && !('old_string' in result)) {
+        result.old_string = result.oldString;
+    }
+    // newString → new_string (used by lineChangeCalculator, TempFilesTreeProvider, ToolInspectorProvider)
+    if ('newString' in result && !('new_string' in result)) {
+        result.new_string = result.newString;
+    }
+    // replaceAll → replace_all (used by ToolInspectorProvider)
+    if ('replaceAll' in result && !('replace_all' in result)) {
+        result.replace_all = result.replaceAll;
+    }
+    return result;
+}
+/**
+ * Converts a timestamp value (ISO string or Unix ms) to ISO string.
+ */
+function toISOString(time) {
+    if (!time)
+        return new Date().toISOString();
+    if (typeof time === 'string')
+        return time;
+    return new Date(time).toISOString();
+}
+/**
+ * Converts an OpenCode message and its parts into SessionEvent array.
+ *
+ * Maps OpenCode's message/part model to the flat event stream that
+ * SessionMonitor expects. A single OpenCode message may produce multiple
+ * events (assistant message, tool results, compaction markers).
+ *
+ * @param message - OpenCode MessageV2 object
+ * @param parts - Array of OpenCode parts belonging to this message
+ * @returns Array of SessionEvent objects
+ */
+export function convertOpenCodeMessage(message, parts) {
+    const events = [];
+    // Sort parts by index if available
+    const sortedParts = [...parts].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+    if (message.role === 'user') {
+        events.push(...convertUserMessage(message, sortedParts));
+    }
+    else if (message.role === 'assistant') {
+        events.push(...convertAssistantMessage(message, sortedParts));
+    }
+    return events;
+}
+/**
+ * Converts a user-role message to events.
+ */
+function convertUserMessage(message, parts) {
+    const events = [];
+    const content = [];
+    for (const part of parts) {
+        if (part.type === 'text') {
+            content.push({ type: 'text', text: part.text });
+        }
+        else if (part.type === 'file') {
+            content.push({
+                type: 'text',
+                text: `[File: ${part.filename || 'unknown'} (${part.mime || 'unknown'})]`,
+            });
+        }
+        else if (part.type === 'subtask') {
+            content.push({ type: 'text', text: `[Subtask: ${part.description || 'unknown'}]` });
+        }
+    }
+    if (content.length > 0) {
+        events.push({
+            type: 'user',
+            message: { role: 'user', id: message.id, content },
+            timestamp: toISOString(message.time.created),
+        });
+    }
+    return events;
+}
+/**
+ * Converts an assistant-role message to events.
+ *
+ * Produces:
+ * 1. An assistant event with text, thinking, and tool_use content blocks
+ * 2. Synthetic user events for completed tool results
+ * 3. A summary event if compaction was detected
+ */
+function convertAssistantMessage(message, parts) {
+    const events = [];
+    const content = [];
+    for (const part of parts) {
+        switch (part.type) {
+            case 'text':
+                content.push({ type: 'text', text: part.text });
+                break;
+            case 'reasoning':
+                content.push({ type: 'thinking', thinking: part.text });
+                break;
+            case 'tool-invocation':
+                content.push({
+                    type: 'tool_use',
+                    id: part.callID,
+                    name: normalizeToolName(part.tool),
+                    input: normalizeToolInput(part.state.input || {}),
+                });
+                break;
+            case 'tool':
+                content.push({
+                    type: 'tool_use',
+                    id: part.callID,
+                    name: normalizeToolName(part.tool),
+                    input: normalizeToolInput(part.state.input || {}),
+                });
+                break;
+            case 'patch':
+                // Emit per-file synthetic Write tool_use blocks so downstream code
+                // (TempFilesTreeProvider, MindMapDataService) picks up file touches
+                // via the standard file_path field extraction.
+                if (part.files && part.files.length > 0) {
+                    for (let i = 0; i < part.files.length; i++) {
+                        content.push({
+                            type: 'tool_use',
+                            id: `patch-${part.id}-${i}`,
+                            name: 'Write',
+                            input: { file_path: part.files[i] },
+                        });
+                    }
+                }
+                else {
+                    content.push({
+                        type: 'tool_use',
+                        id: `patch-${part.id}`,
+                        name: 'Patch',
+                        input: { hash: part.hash, files: part.files },
+                    });
+                }
+                break;
+            case 'step-start':
+            case 'step-finish':
+                // Timeline markers — no content to emit
+                break;
+            case 'subtask':
+                content.push({
+                    type: 'tool_use',
+                    id: `subtask-${part.id}`,
+                    name: 'Subtask',
+                    input: {
+                        description: part.description,
+                        agent: part.agent,
+                        model: part.model,
+                        prompt: part.prompt,
+                        command: part.command,
+                    },
+                });
+                break;
+            case 'file':
+                content.push({
+                    type: 'text',
+                    text: `[File: ${part.filename || 'unknown'} (${part.mime || 'unknown'})]`,
+                });
+                break;
+            case 'retry':
+                content.push({
+                    type: 'text',
+                    text: `[Retry attempt ${part.attempt ?? '?'}: ${part.error?.message || 'unknown error'}]`,
+                });
+                break;
+            case 'agent':
+            case 'snapshot':
+                // Metadata only — no user-visible content
+                break;
+            case 'compaction':
+                // Will add summary event below
+                break;
+        }
+    }
+    // Surface message-level errors as text blocks so they appear in the timeline.
+    // OpenCode messages can carry structured errors (AuthError, APIError, etc.)
+    if (message.error) {
+        const errType = message.error.type || 'Error';
+        const errMsg = message.error.message || 'Unknown error';
+        const errCode = message.error.code ? ` (code: ${message.error.code})` : '';
+        content.push({
+            type: 'text',
+            text: `[${errType}]${errCode} ${errMsg}`,
+        });
+    }
+    // Detect plan mode mentions in text/thinking blocks and inject synthetic
+    // tool_use blocks (OpenCode doesn't emit plan_enter/plan_exit tools).
+    const hasExistingPlanMode = content.some((b) => {
+        const block = b;
+        return (block.type === 'tool_use' && (block.name === 'EnterPlanMode' || block.name === 'ExitPlanMode'));
+    });
+    if (!hasExistingPlanMode) {
+        for (const block of content) {
+            const b = block;
+            let text = null;
+            if (b.type === 'text')
+                text = b.text;
+            else if (b.type === 'thinking')
+                text = b.thinking;
+            if (!text)
+                continue;
+            const direction = detectPlanModeFromText(text);
+            if (direction) {
+                const toolName = direction === 'enter' ? 'EnterPlanMode' : 'ExitPlanMode';
+                const rawName = direction === 'enter' ? 'plan_enter' : 'plan_exit';
+                content.push({
+                    type: 'tool_use',
+                    id: `plan-${direction}-${message.id}`,
+                    name: toolName,
+                    input: { source: 'opencode_text_heuristic', _sidekickRawToolName: rawName },
+                });
+                break; // Only inject one plan mode block per message
+            }
+        }
+    }
+    // Sum cost from step-finish parts as fallback for reported_cost
+    // when the message-level cost is unavailable. Step-finish parts carry
+    // per-step cost from the provider which can improve accuracy.
+    let stepFinishCost = 0;
+    for (const part of parts) {
+        if (part.type === 'step-finish' && part.cost && part.cost > 0) {
+            stepFinishCost += part.cost;
+        }
+    }
+    // Build usage data from message tokens
+    const reportedCost = typeof message.cost === 'number' && Number.isFinite(message.cost) && message.cost >= 0
+        ? message.cost
+        : stepFinishCost > 0
+            ? stepFinishCost
+            : undefined;
+    const usage = {
+        input_tokens: message.tokens.input || 0,
+        output_tokens: message.tokens.output || 0,
+        cache_creation_input_tokens: message.tokens.cacheWrite || 0,
+        cache_read_input_tokens: message.tokens.cacheRead || 0,
+        reported_cost: reportedCost,
+        reasoning_tokens: message.tokens.reasoning || 0,
+    };
+    const normalizedUsage = normalizeProviderUsage({
+        semantics: message.providerID === 'openai'
+            ? 'openai'
+            : message.providerID === 'anthropic'
+                ? 'anthropic'
+                : 'sidekick',
+        provider: message.providerID ?? 'opencode',
+        source: 'opencode-message',
+        model: message.modelID,
+        inputTokens: message.tokens.input,
+        outputTokens: message.tokens.output,
+        cacheReadTokens: message.tokens.cacheRead,
+        cacheWriteTokens: message.tokens.cacheWrite,
+        reasoningTokens: message.tokens.reasoning,
+        reasoningIncludedInOutput: message.providerID === 'openai',
+        reportedCostUsd: reportedCost,
+    });
+    const timestamp = toISOString(message.time.completed || message.time.created);
+    const retryAttempts = parts
+        .filter((part) => part.type === 'retry')
+        .map((part) => part.attempt)
+        .filter((attempt) => typeof attempt === 'number');
+    const finishReasons = parts
+        .filter((part) => part.type === 'step-finish')
+        .map((part) => part.reason)
+        .filter((reason) => typeof reason === 'string' && reason.length > 0);
+    // Emit assistant event (even if content is empty, usage data is valuable)
+    if (content.length > 0 || message.tokens.input > 0 || message.tokens.output > 0) {
+        events.push({
+            type: 'assistant',
+            message: {
+                role: 'assistant',
+                id: message.id,
+                model: message.modelID,
+                usage,
+                normalizedUsage,
+                content,
+            },
+            timestamp,
+            providerMetadata: {
+                providerId: message.providerID ?? 'opencode',
+                source: 'opencode-message',
+                ...(retryAttempts.length > 0 ? { retryAttempts } : {}),
+                ...(finishReasons.length > 0 ? { finishReasons } : {}),
+                ...(message.error ? { providerError: message.error } : {}),
+            },
+        });
+    }
+    // Emit synthetic tool_result events for completed tool invocations
+    // and subtask parts. In Claude Code's format, tool results come as
+    // user messages with tool_result content blocks.
+    for (const part of parts) {
+        if ((part.type === 'tool-invocation' || part.type === 'tool') &&
+            (part.state.status === 'completed' || part.state.status === 'error')) {
+            // Calculate duration from provider-supplied timestamps when available
+            let duration;
+            if (part.state.time?.start && part.state.time?.end) {
+                const startMs = typeof part.state.time.start === 'number'
+                    ? part.state.time.start
+                    : new Date(part.state.time.start).getTime();
+                const endMs = typeof part.state.time.end === 'number'
+                    ? part.state.time.end
+                    : new Date(part.state.time.end).getTime();
+                if (endMs > startMs) {
+                    duration = endMs - startMs;
+                }
+            }
+            const resultContent = [
+                {
+                    type: 'tool_result',
+                    tool_use_id: part.callID,
+                    content: part.state.status === 'error' ? part.state.error : part.state.output,
+                    is_error: part.state.status === 'error',
+                    ...(duration !== undefined && { duration }),
+                },
+            ];
+            const resultTimestamp = part.state.time?.end ? toISOString(part.state.time.end) : timestamp;
+            events.push({
+                type: 'user',
+                message: {
+                    role: 'user',
+                    id: `${message.id}:${part.callID}:result`,
+                    content: resultContent,
+                },
+                timestamp: resultTimestamp,
+            });
+        }
+        // Subtask parts get a synthetic tool_result so they appear in the timeline
+        if (part.type === 'subtask') {
+            events.push({
+                type: 'user',
+                message: {
+                    role: 'user',
+                    id: `${message.id}:subtask-${part.id}:result`,
+                    content: [
+                        {
+                            type: 'tool_result',
+                            tool_use_id: `subtask-${part.id}`,
+                            content: part.description || 'Subtask completed',
+                            is_error: false,
+                        },
+                    ],
+                },
+                timestamp,
+            });
+        }
+    }
+    // Detect compaction via summary flag or compaction part
+    const hasCompaction = message.summary || parts.some((p) => p.type === 'compaction');
+    if (hasCompaction) {
+        events.push({
+            type: 'summary',
+            message: { role: 'assistant', id: `${message.id}:summary`, content: 'Context compacted' },
+            timestamp,
+        });
+    }
+    return events;
+}
+// --- DB-to-OpenCode adapter functions ---
+/**
+ * Parses a database message row's JSON `data` field into an OpenCodeMessage.
+ *
+ * DB messages store data as a JSON blob with slightly different field layout
+ * than the file-based format (e.g., `modelID` is at top level, tokens are
+ * nested under `tokens`).
+ */
+export function parseDbMessageData(row) {
+    const data = JSON.parse(row.data);
+    const time = data.time;
+    const tokens = data.tokens;
+    const cache = tokens?.cache;
+    const summary = data.summary;
+    // Parse error field if present (AuthError, APIError, OutputLengthError, etc.)
+    const errorData = data.error;
+    const error = errorData
+        ? {
+            type: errorData.type || undefined,
+            message: errorData.message || undefined,
+            code: errorData.code,
+        }
+        : undefined;
+    return {
+        id: row.id,
+        sessionID: row.session_id,
+        role: data.role,
+        modelID: data.modelID,
+        summary: summary != null ? true : undefined,
+        cost: data.cost || undefined,
+        providerID: data.providerID || undefined,
+        tokens: {
+            input: tokens?.input || 0,
+            output: tokens?.output || 0,
+            cacheRead: cache?.read || 0,
+            cacheWrite: cache?.write || 0,
+            reasoning: tokens?.reasoning || 0,
+        },
+        time: {
+            created: time?.created || row.time_created,
+            completed: time?.completed || undefined,
+        },
+        error,
+    };
+}
+/**
+ * Parses a database part row's JSON `data` field into an OpenCodePart.
+ */
+export function parseDbPartData(row) {
+    const data = JSON.parse(row.data);
+    const type = data.type;
+    const base = { id: row.id, messageID: row.message_id };
+    switch (type) {
+        case 'text':
+            return { ...base, type: 'text', text: data.text || '' };
+        case 'reasoning':
+            return { ...base, type: 'reasoning', text: data.text || '' };
+        case 'tool': {
+            const state = data.state;
+            return {
+                ...base,
+                type: 'tool',
+                callID: data.callID || '',
+                tool: data.tool || '',
+                state: {
+                    status: (state?.status || 'completed'),
+                    input: state?.input,
+                    output: state?.output,
+                    error: state?.error,
+                    title: state?.title,
+                    metadata: state?.metadata,
+                    time: state?.time,
+                },
+            };
+        }
+        case 'tool-invocation': {
+            const state = data.state;
+            return {
+                ...base,
+                type: 'tool-invocation',
+                callID: data.callID || '',
+                tool: data.tool || '',
+                state: {
+                    status: (state?.status || 'completed'),
+                    input: state?.input,
+                    output: state?.output,
+                    error: state?.error,
+                    time: state?.time,
+                },
+            };
+        }
+        case 'compaction':
+            return { ...base, type: 'compaction', text: data.text };
+        case 'step-start':
+            return { ...base, type: 'step-start', snapshot: data.snapshot };
+        case 'step-finish': {
+            const tokensData = data.tokens;
+            const cacheData = tokensData?.cache;
+            return {
+                ...base,
+                type: 'step-finish',
+                reason: data.reason,
+                snapshot: data.snapshot,
+                cost: data.cost,
+                tokens: tokensData
+                    ? {
+                        input: tokensData.input,
+                        output: tokensData.output,
+                        reasoning: tokensData.reasoning,
+                        cache: cacheData
+                            ? {
+                                read: cacheData.read,
+                                write: cacheData.write,
+                            }
+                            : undefined,
+                    }
+                    : undefined,
+            };
+        }
+        case 'patch':
+            return {
+                ...base,
+                type: 'patch',
+                hash: data.hash,
+                files: data.files,
+            };
+        case 'subtask':
+            return {
+                ...base,
+                type: 'subtask',
+                prompt: data.prompt,
+                description: data.description,
+                agent: data.agent,
+                model: data.model,
+                command: data.command,
+            };
+        case 'agent':
+            return {
+                ...base,
+                type: 'agent',
+                name: data.name,
+                source: data.source,
+            };
+        case 'file':
+            return {
+                ...base,
+                type: 'file',
+                mime: data.mime,
+                filename: data.filename,
+                url: data.url,
+            };
+        case 'retry': {
+            const errorData = data.error;
+            return {
+                ...base,
+                type: 'retry',
+                attempt: data.attempt,
+                error: errorData
+                    ? {
+                        message: errorData.message,
+                        code: errorData.code,
+                    }
+                    : undefined,
+                time: data.time,
+            };
+        }
+        case 'snapshot':
+            return {
+                ...base,
+                type: 'snapshot',
+                snapshot: data.snapshot,
+            };
+        default:
+            // Unknown part type — treat as text with raw JSON
+            return { ...base, type: 'text', text: JSON.stringify(data) };
+    }
+}