@otto-assistant/bridge 0.4.92

package/dist/logger.js

@@ -0,0 +1,165 @@
+// Prefixed logging utility using @clack/prompts for consistent visual style.
+// All log methods use clack's log.message() with appropriate symbols to prevent
+// output interleaving from concurrent async operations.
+import { log as clackLog } from '@clack/prompts';
+import fs from 'node:fs';
+import path from 'node:path';
+import util from 'node:util';
+import pc from 'picocolors';
+import { sanitizeSensitiveText, sanitizeUnknownValue } from './privacy-sanitizer.js';
+// All known log prefixes - add new ones here to keep alignment consistent
+export const LogPrefix = {
+    ABORT: 'ABORT',
+    ADD_PROJECT: 'ADD_PROJ',
+    AGENT: 'AGENT',
+    ASK_QUESTION: 'QUESTION',
+    CHANNEL: 'CHANNEL',
+    CLI: 'CLI',
+    COMPACT: 'COMPACT',
+    CREATE_PROJECT: 'NEW_PROJ',
+    DB: 'DB',
+    DIFF: 'DIFF',
+    FILE_UPLOAD: 'FILEUP',
+    DISCORD: 'DISCORD',
+    FORK: 'FORK',
+    FORMATTING: 'FORMAT',
+    GENAI: 'GENAI',
+    HEAP: 'HEAP',
+    GENAI_WORKER: 'GENAI_W',
+    INTERACTION: 'INTERACT',
+    IPC: 'IPC',
+    LOGIN: 'LOGIN',
+    MARKDOWN: 'MARKDOWN',
+    MCP: 'MCP',
+    MODEL: 'MODEL',
+    OPENAI: 'OPENAI',
+    OPENCODE: 'OPENCODE',
+    PERMISSIONS: 'PERMS',
+    QUEUE: 'QUEUE',
+    REMOVE_PROJECT: 'RM_PROJ',
+    RESUME: 'RESUME',
+    SESSION: 'SESSION',
+    SHARE: 'SHARE',
+    TASK: 'TASK',
+    TOOLS: 'TOOLS',
+    UNDO_REDO: 'UNDO',
+    USER_CMD: 'USER_CMD',
+    VERBOSITY: 'VERBOSE',
+    VOICE: 'VOICE',
+    WORKER: 'WORKER',
+    THINKING: 'THINK',
+    WORKTREE: 'WORKTREE',
+    XML: 'XML',
+};
+// compute max length from all known prefixes for alignment
+const MAX_PREFIX_LENGTH = Math.max(...Object.values(LogPrefix).map((p) => p.length));
+// Log file path is set by initLogFile() after the data directory is known.
+// Before initLogFile() is called, file logging is skipped.
+let logFilePath = null;
+/**
+ * Initialize file logging. Call this after setDataDir() so the log file
+ * is written to `<dataDir>/kimaki.log`. The log file is truncated on
+ * every bot startup so it contains only the current run's logs.
+ */
+export function initLogFile(dataDir) {
+    logFilePath = path.join(dataDir, 'kimaki.log');
+    const logDir = path.dirname(logFilePath);
+    if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+    }
+    fs.writeFileSync(logFilePath, `--- kimaki log started at ${new Date().toISOString()} ---\n`);
+}
+/**
+ * Set the log file path without truncating. Use this in child processes
+ * (like the opencode plugin) that should append to the same log file
+ * the bot process already created with initLogFile().
+ */
+export function setLogFilePath(dataDir) {
+    logFilePath = path.join(dataDir, 'kimaki.log');
+}
+export function getLogFilePath() {
+    return logFilePath;
+}
+function formatArg(arg) {
+    if (typeof arg === 'string') {
+        return sanitizeSensitiveText(arg, { redactPaths: false });
+    }
+    const safeArg = sanitizeUnknownValue(arg, { redactPaths: false });
+    return util.inspect(safeArg, { colors: true, depth: 4 });
+}
+export function formatErrorWithStack(error) {
+    if (error instanceof Error) {
+        return sanitizeSensitiveText(error.stack ?? `${error.name}: ${error.message}`, { redactPaths: false });
+    }
+    if (typeof error === 'string') {
+        return sanitizeSensitiveText(error, { redactPaths: false });
+    }
+    // Keep this stable and safe for unknown values (handles circular structures).
+    const safeError = sanitizeUnknownValue(error, { redactPaths: false });
+    return sanitizeSensitiveText(util.inspect(safeError, { colors: false, depth: 4 }), {
+        redactPaths: false,
+    });
+}
+function writeToFile(level, prefix, args) {
+    const timestamp = new Date().toISOString();
+    const message = `[${timestamp}] [${level}] [${prefix}] ${args.map(formatArg).join(' ')}\n`;
+    if (!logFilePath) {
+        return;
+    }
+    fs.appendFileSync(logFilePath, message);
+}
+function getTimestamp() {
+    const now = new Date();
+    return `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`;
+}
+function padPrefix(prefix) {
+    return prefix.padEnd(MAX_PREFIX_LENGTH);
+}
+function formatMessage(timestamp, prefix, args) {
+    return [pc.dim(timestamp), prefix, ...args.map(formatArg)].join(' ');
+}
+const noSpacing = { spacing: 0 };
+// Suppress clack terminal output during vitest runs to avoid flooding
+// test output with hundreds of log lines. File logging still works.
+// Set KIMAKI_TEST_LOGS=1 when rerunning a failing test to see all
+// kimaki logger output in the terminal for debugging.
+const isVitest = !!process.env['KIMAKI_VITEST'];
+const showTestLogs = isVitest && !!process.env['KIMAKI_TEST_LOGS'];
+export function createLogger(prefix) {
+    const paddedPrefix = padPrefix(prefix);
+    const suppressConsole = isVitest && !showTestLogs;
+    const log = (...args) => {
+        writeToFile('LOG', prefix, args);
+        if (suppressConsole) {
+            return;
+        }
+        clackLog.message(formatMessage(getTimestamp(), pc.cyan(paddedPrefix), args), {
+            ...noSpacing,
+        });
+    };
+    return {
+        log,
+        error: (...args) => {
+            writeToFile('ERROR', prefix, args);
+            if (suppressConsole) {
+                return;
+            }
+            clackLog.error(formatMessage(getTimestamp(), pc.red(paddedPrefix), args), noSpacing);
+        },
+        warn: (...args) => {
+            writeToFile('WARN', prefix, args);
+            if (suppressConsole) {
+                return;
+            }
+            clackLog.warn(formatMessage(getTimestamp(), pc.yellow(paddedPrefix), args), noSpacing);
+        },
+        info: (...args) => {
+            writeToFile('INFO', prefix, args);
+            if (suppressConsole) {
+                return;
+            }
+            clackLog.info(formatMessage(getTimestamp(), pc.blue(paddedPrefix), args), noSpacing);
+        },
+        debug: log,
+    };
+}

package/dist/markdown.js

@@ -0,0 +1,342 @@
+// Session-to-markdown renderer for sharing.
+// Generates shareable markdown from OpenCode sessions, formatting
+// user messages, assistant responses, tool calls, and reasoning blocks.
+// Uses errore for type-safe error handling.
+import * as errore from 'errore';
+import { createTaggedError } from 'errore';
+import YAML from 'yaml';
+import { formatDateTime } from './utils.js';
+import { extractNonXmlContent } from './xml.js';
+import { createLogger, LogPrefix } from './logger.js';
+import { SessionNotFoundError, MessagesNotFoundError } from './errors.js';
+// Generic error for unexpected exceptions in async operations
+class UnexpectedError extends createTaggedError({
+    name: 'UnexpectedError',
+}) {
+}
+const markdownLogger = createLogger(LogPrefix.MARKDOWN);
+const TOOL_OUTPUT_MAX_CHARS = 30_000;
+export class ShareMarkdown {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Generate a markdown representation of a session
+     * @param options Configuration options
+     * @returns Error or markdown string
+     */
+    async generate(options) {
+        const { sessionID, includeSystemInfo, lastAssistantOnly } = options;
+        // Get session info
+        const sessionResponse = await this.client.session.get({
+            sessionID,
+        });
+        if (!sessionResponse.data) {
+            return new SessionNotFoundError({ sessionId: sessionID });
+        }
+        const session = sessionResponse.data;
+        // Get all messages
+        const messagesResponse = await this.client.session.messages({
+            sessionID,
+        });
+        if (!messagesResponse.data) {
+            return new MessagesNotFoundError({ sessionId: sessionID });
+        }
+        const messages = messagesResponse.data;
+        // If lastAssistantOnly, filter to only the last assistant message
+        const messagesToRender = lastAssistantOnly
+            ? (() => {
+                const assistantMessages = messages.filter((m) => m.info.role === 'assistant');
+                return assistantMessages.length > 0
+                    ? [assistantMessages[assistantMessages.length - 1]]
+                    : [];
+            })()
+            : messages;
+        // Build markdown
+        const lines = [];
+        // Only include header and session info if not lastAssistantOnly
+        if (!lastAssistantOnly) {
+            // Header
+            lines.push(`# ${session.title || 'Untitled Session'}`);
+            lines.push('');
+            // Session metadata
+            if (includeSystemInfo === true) {
+                lines.push('## Session Information');
+                lines.push('');
+                lines.push(`- **Created**: ${formatDateTime(new Date(session.time.created))}`);
+                lines.push(`- **Updated**: ${formatDateTime(new Date(session.time.updated))}`);
+                if (session.version) {
+                    lines.push(`- **OpenCode Version**: v${session.version}`);
+                }
+                lines.push('');
+            }
+            // Process messages
+            lines.push('## Conversation');
+            lines.push('');
+        }
+        for (const message of messagesToRender) {
+            const messageLines = this.renderMessage(message.info, message.parts);
+            lines.push(...messageLines);
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    renderMessage(message, parts) {
+        const lines = [];
+        if (message.role === 'user') {
+            lines.push('### 👤 User');
+            lines.push('');
+            for (const part of parts) {
+                if (part.type === 'text' && part.text) {
+                    const cleanedText = extractNonXmlContent(part.text);
+                    if (cleanedText.trim()) {
+                        lines.push(cleanedText);
+                        lines.push('');
+                    }
+                }
+                else if (part.type === 'file') {
+                    lines.push(`📎 **Attachment**: ${part.filename || 'unnamed file'}`);
+                    if (part.url) {
+                        lines.push(`   - URL: ${part.url}`);
+                    }
+                    lines.push('');
+                }
+            }
+        }
+        else if (message.role === 'assistant') {
+            lines.push(`### 🤖 Assistant (${message.modelID || 'unknown model'})`);
+            lines.push('');
+            // Filter and process parts
+            const filteredParts = parts.filter((part) => {
+                if (part.type === 'step-start' && parts.indexOf(part) > 0)
+                    return false;
+                if (part.type === 'snapshot')
+                    return false;
+                if (part.type === 'patch')
+                    return false;
+                if (part.type === 'step-finish')
+                    return false;
+                if (part.type === 'text' && part.synthetic === true)
+                    return false;
+                if (part.type === 'tool' && part.tool === 'todoread')
+                    return false;
+                if (part.type === 'text' && !part.text)
+                    return false;
+                if (part.type === 'tool' &&
+                    (part.state.status === 'pending' || part.state.status === 'running'))
+                    return false;
+                return true;
+            });
+            for (const part of filteredParts) {
+                const partLines = this.renderPart(part, message);
+                lines.push(...partLines);
+            }
+            // Add completion time if available
+            if (message.time?.completed) {
+                const duration = message.time.completed - message.time.created;
+                lines.push('');
+                lines.push(`*Completed in ${this.formatDuration(duration)}*`);
+            }
+        }
+        return lines;
+    }
+    renderPart(part, message) {
+        const lines = [];
+        switch (part.type) {
+            case 'text':
+                if (part.text) {
+                    lines.push(part.text);
+                    lines.push('');
+                }
+                break;
+            case 'reasoning':
+                if (part.text) {
+                    lines.push('<details>');
+                    lines.push('<summary>💭 Thinking</summary>');
+                    lines.push('');
+                    lines.push(part.text);
+                    lines.push('');
+                    lines.push('</details>');
+                    lines.push('');
+                }
+                break;
+            case 'tool':
+                if (part.state.status === 'completed') {
+                    const output = part.state.output || '';
+                    const isOversized = output.length > TOOL_OUTPUT_MAX_CHARS;
+                    if (isOversized) {
+                        lines.push(`> ⚠️ **Large tool output** (${output.length.toLocaleString()} chars, truncated to ${TOOL_OUTPUT_MAX_CHARS.toLocaleString()})`);
+                        lines.push('');
+                    }
+                    lines.push(`#### 🛠️ Tool: ${part.tool}`);
+                    lines.push('');
+                    // Render input parameters in YAML
+                    if (part.state.input && Object.keys(part.state.input).length > 0) {
+                        lines.push('**Input:**');
+                        lines.push('```yaml');
+                        lines.push(YAML.stringify(part.state.input, null, { lineWidth: 0 }));
+                        lines.push('```');
+                        lines.push('');
+                    }
+                    // Render output, truncated if too large
+                    if (output) {
+                        lines.push('**Output:**');
+                        lines.push('```');
+                        lines.push(isOversized
+                            ? output.slice(0, TOOL_OUTPUT_MAX_CHARS) +
+                                '\n...(truncated)'
+                            : output);
+                        lines.push('```');
+                        lines.push('');
+                    }
+                    // Add timing info if significant
+                    if (part.state.time?.start && part.state.time?.end) {
+                        const duration = part.state.time.end - part.state.time.start;
+                        if (duration > 2000) {
+                            lines.push(`*Duration: ${this.formatDuration(duration)}*`);
+                            lines.push('');
+                        }
+                    }
+                }
+                else if (part.state.status === 'error') {
+                    lines.push(`#### ❌ Tool Error: ${part.tool}`);
+                    lines.push('');
+                    lines.push('```');
+                    lines.push(part.state.error || 'Unknown error');
+                    lines.push('```');
+                    lines.push('');
+                }
+                break;
+            case 'step-start':
+                lines.push(`**Started using ${message.providerID}/${message.modelID}**`);
+                lines.push('');
+                break;
+        }
+        return lines;
+    }
+    formatDuration(ms) {
+        if (ms < 1000)
+            return `${ms}ms`;
+        if (ms < 60000)
+            return `${(ms / 1000).toFixed(1)}s`;
+        const minutes = Math.floor(ms / 60000);
+        const seconds = Math.floor((ms % 60000) / 1000);
+        return `${minutes}m ${seconds}s`;
+    }
+}
+/**
+ * Generate compact session context for voice transcription.
+ * Includes system prompt (optional), user messages, assistant text,
+ * and tool calls in compact form (name + params only, no output).
+ */
+export function getCompactSessionContext({ client, sessionId, includeSystemPrompt = false, maxMessages = 20, }) {
+    return errore.tryAsync({
+        try: async () => {
+            const messagesResponse = await client.session.messages({
+                sessionID: sessionId,
+            });
+            const messages = messagesResponse.data || [];
+            const lines = [];
+            // Get system prompt if requested
+            // Note: OpenCode SDK doesn't expose system prompt directly. We try multiple approaches:
+            // 1. session.system field (if available in future SDK versions)
+            // 2. synthetic text part in first assistant message (current approach)
+            if (includeSystemPrompt && messages.length > 0) {
+                const firstAssistant = messages.find((m) => m.info.role === 'assistant');
+                if (firstAssistant) {
+                    // look for text part marked as synthetic (system prompt)
+                    const systemPart = (firstAssistant.parts || []).find((p) => p.type === 'text' && p.synthetic === true);
+                    if (systemPart && 'text' in systemPart && systemPart.text) {
+                        lines.push('[System Prompt]');
+                        const truncated = systemPart.text.slice(0, 3000);
+                        lines.push(truncated);
+                        if (systemPart.text.length > 3000) {
+                            lines.push('...(truncated)');
+                        }
+                        lines.push('');
+                    }
+                }
+            }
+            // Process recent messages
+            const recentMessages = messages.slice(-maxMessages);
+            for (const msg of recentMessages) {
+                if (msg.info.role === 'user') {
+                    const textParts = (msg.parts || [])
+                        .filter((p) => p.type === 'text')
+                        .map((p) => (p.type === 'text' ? extractNonXmlContent(p.text || '') : ''))
+                        .filter(Boolean);
+                    if (textParts.length > 0) {
+                        lines.push(`[User]: ${textParts.join(' ').slice(0, 1000)}`);
+                        lines.push('');
+                    }
+                }
+                else if (msg.info.role === 'assistant') {
+                    // Get assistant text parts (non-synthetic, non-empty)
+                    const textParts = (msg.parts || [])
+                        .filter((p) => p.type === 'text' && !p.synthetic && p.text)
+                        .map((p) => (p.type === 'text' ? p.text : ''))
+                        .filter(Boolean);
+                    if (textParts.length > 0) {
+                        lines.push(`[Assistant]: ${textParts.join(' ').slice(0, 1000)}`);
+                        lines.push('');
+                    }
+                    // Get tool calls in compact form (name + params only)
+                    const toolParts = (msg.parts || []).filter((p) => p.type === 'tool' &&
+                        'state' in p &&
+                        p.state?.status === 'completed');
+                    for (const part of toolParts) {
+                        if (part.type === 'tool' && 'tool' in part && 'state' in part) {
+                            const toolName = part.tool;
+                            // skip noisy tools
+                            if (toolName === 'todoread' || toolName === 'todowrite') {
+                                continue;
+                            }
+                            const input = part.state?.input || {};
+                            const normalize = (value) => value.replace(/\s+/g, ' ').trim();
+                            // compact params: just key=value on one line
+                            const params = Object.entries(input)
+                                .map(([k, v]) => {
+                                const val = typeof v === 'string'
+                                    ? v.slice(0, 100)
+                                    : JSON.stringify(v).slice(0, 100);
+                                return `${k}=${normalize(val)}`;
+                            })
+                                .join(', ');
+                            lines.push(`[Tool ${toolName}]: ${params}`);
+                        }
+                    }
+                }
+            }
+            return lines.join('\n').slice(0, 8000);
+        },
+        catch: (e) => {
+            markdownLogger.error('Failed to get compact session context:', e);
+            return new UnexpectedError({
+                message: 'Failed to get compact session context',
+                cause: e,
+            });
+        },
+    });
+}
+/**
+ * Get the last session for a directory (excluding the current one).
+ */
+export function getLastSessionId({ client, excludeSessionId, }) {
+    return errore.tryAsync({
+        try: async () => {
+            const sessionsResponse = await client.session.list();
+            const sessions = sessionsResponse.data || [];
+            // Sessions are sorted by time, get the most recent one that isn't the current
+            const lastSession = sessions.find((s) => s.id !== excludeSessionId);
+            return lastSession?.id || null;
+        },
+        catch: (e) => {
+            markdownLogger.error('Failed to get last session:', e);
+            return new UnexpectedError({
+                message: 'Failed to get last session',
+                cause: e,
+            });
+        },
+    });
+}