kimaki 0.4.38 → 0.4.39

package/dist/genai-worker.js

@@ -3,12 +3,13 @@
 // Resamples 24kHz GenAI output to 48kHz stereo Opus packets for Discord.
 import { parentPort, threadId } from 'node:worker_threads';
 import { createWriteStream } from 'node:fs';
-import { mkdir } from 'node:fs/promises';
 import path from 'node:path';
+import * as errore from 'errore';
 import { Resampler } from '@purinton/resampler';
 import * as prism from 'prism-media';
 import { startGenAiSession } from './genai.js';
 import { getTools } from './tools.js';
+import { mkdir } from 'node:fs/promises';
 import { createLogger } from './logger.js';
 if (!parentPort) {
     throw new Error('This module must be run as a worker thread');
@@ -98,23 +99,24 @@ async function createAssistantAudioLogStream(guildId, channelId) {
         return null;
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
     const audioDir = path.join(process.cwd(), 'discord-audio-logs', guildId, channelId);
-    try {
-        await mkdir(audioDir, { recursive: true });
-        // Create stream for assistant audio (24kHz mono s16le PCM)
-        const outputFileName = `assistant_${timestamp}.24.pcm`;
-        const outputFilePath = path.join(audioDir, outputFileName);
-        const outputAudioStream = createWriteStream(outputFilePath);
-        // Add error handler to prevent crashes
-        outputAudioStream.on('error', (error) => {
-            workerLogger.error(`Assistant audio log stream error:`, error);
-        });
-        workerLogger.log(`Created assistant audio log: ${outputFilePath}`);
-        return outputAudioStream;
-    }
-    catch (error) {
-        workerLogger.error(`Failed to create audio log directory:`, error);
+    const mkdirError = await errore.tryAsync({
+        try: () => mkdir(audioDir, { recursive: true }),
+        catch: (e) => e,
+    });
+    if (errore.isError(mkdirError)) {
+        workerLogger.error(`Failed to create audio log directory:`, mkdirError.message);
         return null;
     }
+    // Create stream for assistant audio (24kHz mono s16le PCM)
+    const outputFileName = `assistant_${timestamp}.24.pcm`;
+    const outputFilePath = path.join(audioDir, outputFileName);
+    const outputAudioStream = createWriteStream(outputFilePath);
+    // Add error handler to prevent crashes
+    outputAudioStream.on('error', (error) => {
+        workerLogger.error(`Assistant audio log stream error:`, error);
+    });
+    workerLogger.log(`Created assistant audio log: ${outputFilePath}`);
+    return outputAudioStream;
 }
 // Handle encoded Opus packets
 opusEncoder.on('data', (packet) => {

package/dist/markdown.js

@@ -1,10 +1,16 @@
 // 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 * as yaml from 'js-yaml';
 import { formatDateTime } from './utils.js';
 import { extractNonXmlContent } from './xml.js';
 import { createLogger } from './logger.js';
+import { SessionNotFoundError, MessagesNotFoundError } from './errors.js';
+// Generic error for unexpected exceptions in async operations
+class UnexpectedError extends errore.TaggedError('UnexpectedError')() {
+}
 const markdownLogger = createLogger('MARKDOWN');
 export class ShareMarkdown {
     client;
@@ -14,7 +20,7 @@ export class ShareMarkdown {
     /**
      * Generate a markdown representation of a session
      * @param options Configuration options
-     * @returns Markdown string representation of the session
+     * @returns Error or markdown string
      */
     async generate(options) {
         const { sessionID, includeSystemInfo, lastAssistantOnly } = options;
@@ -23,7 +29,7 @@ export class ShareMarkdown {
             path: { id: sessionID },
         });
         if (!sessionResponse.data) {
-            throw new Error(`Session ${sessionID} not found`);
+            return new SessionNotFoundError({ sessionId: sessionID });
         }
         const session = sessionResponse.data;
         // Get all messages
@@ -31,7 +37,7 @@ export class ShareMarkdown {
             path: { id: sessionID },
         });
         if (!messagesResponse.data) {
-            throw new Error(`No messages found for session ${sessionID}`);
+            return new MessagesNotFoundError({ sessionId: sessionID });
         }
         const messages = messagesResponse.data;
         // If lastAssistantOnly, filter to only the last assistant message
@@ -211,98 +217,103 @@ export class ShareMarkdown {
  * Includes system prompt (optional), user messages, assistant text,
  * and tool calls in compact form (name + params only, no output).
  */
-export async function getCompactSessionContext({ client, sessionId, includeSystemPrompt = false, maxMessages = 20, }) {
-    try {
-        const messagesResponse = await client.session.messages({
-            path: { id: 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)');
+export function getCompactSessionContext({ client, sessionId, includeSystemPrompt = false, maxMessages = 20, }) {
+    return errore.tryAsync({
+        try: async () => {
+            const messagesResponse = await client.session.messages({
+                path: { id: 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('');
                     }
-                    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' && 'text' in p)
-                    .map((p) => ('text' in p ? 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' && 'text' in p && !p.synthetic && p.text)
-                    .map((p) => ('text' in p ? p.text : ''))
-                    .filter(Boolean);
-                if (textParts.length > 0) {
-                    lines.push(`[Assistant]: ${textParts.join(' ').slice(0, 1000)}`);
-                    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' && 'text' in p)
+                        .map((p) => ('text' in p ? extractNonXmlContent(p.text || '') : ''))
+                        .filter(Boolean);
+                    if (textParts.length > 0) {
+                        lines.push(`[User]: ${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;
+                else if (msg.info.role === 'assistant') {
+                    // Get assistant text parts (non-synthetic, non-empty)
+                    const textParts = (msg.parts || [])
+                        .filter((p) => p.type === 'text' && 'text' in p && !p.synthetic && p.text)
+                        .map((p) => ('text' in p ? 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}`);
                         }
-                        const input = part.state?.input || {};
-                        // 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}=${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 '';
-    }
+            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 async function getLastSessionId({ client, excludeSessionId, }) {
-    try {
-        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 null;
-    }
+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 });
+        },
+    });
 }

package/dist/markdown.test.js

@@ -1,6 +1,7 @@
 import { test, expect, beforeAll, afterAll } from 'vitest';
 import { spawn } from 'child_process';
 import { OpencodeClient } from '@opencode-ai/sdk';
+import * as errore from 'errore';
 import { ShareMarkdown, getCompactSessionContext } from './markdown.js';
 let serverProcess;
 let client;
@@ -100,10 +101,12 @@ test('generate markdown from first available session', async () => {
     // Create markdown exporter
     const exporter = new ShareMarkdown(client);
     // Generate markdown with system info
-    const markdown = await exporter.generate({
+    const markdownResult = await exporter.generate({
         sessionID,
         includeSystemInfo: true,
     });
+    expect(errore.isOk(markdownResult)).toBe(true);
+    const markdown = errore.unwrap(markdownResult);
     console.log(`Generated markdown length: ${markdown.length} characters`);
     // Basic assertions
     expect(markdown).toBeTruthy();
@@ -233,12 +236,14 @@ test('generate markdown from multiple sessions', async () => {
 // test for getCompactSessionContext - disabled in CI since it requires a specific session
 test.skipIf(process.env.CI)('getCompactSessionContext generates compact format', async () => {
     const sessionId = 'ses_46c2205e8ffeOll1JUSuYChSAM';
-    const context = await getCompactSessionContext({
+    const contextResult = await getCompactSessionContext({
         client,
         sessionId,
         includeSystemPrompt: true,
         maxMessages: 15,
     });
+    expect(errore.isOk(contextResult)).toBe(true);
+    const context = errore.unwrap(contextResult);
     console.log(`Generated compact context length: ${context.length} characters`);
     expect(context).toBeTruthy();
     expect(context.length).toBeGreaterThan(0);
@@ -248,12 +253,14 @@ test.skipIf(process.env.CI)('getCompactSessionContext generates compact format',
 });
 test.skipIf(process.env.CI)('getCompactSessionContext without system prompt', async () => {
     const sessionId = 'ses_46c2205e8ffeOll1JUSuYChSAM';
-    const context = await getCompactSessionContext({
+    const contextResult = await getCompactSessionContext({
         client,
         sessionId,
         includeSystemPrompt: false,
         maxMessages: 10,
     });
+    expect(errore.isOk(contextResult)).toBe(true);
+    const context = errore.unwrap(contextResult);
     console.log(`Generated compact context (no system) length: ${context.length} characters`);
     expect(context).toBeTruthy();
     // should NOT have system prompt

package/dist/message-formatting.js

@@ -3,7 +3,9 @@
 // handles file attachments, and provides tool summary generation.
 import fs from 'node:fs';
 import path from 'node:path';
+import * as errore from 'errore';
 import { createLogger } from './logger.js';
+import { FetchError } from './errors.js';
 const ATTACHMENTS_DIR = path.join(process.cwd(), 'tmp', 'discord-attachments');
 const logger = createLogger('FORMATTING');
 /**
@@ -56,18 +58,18 @@ export async function getTextAttachments(message) {
         return '';
     }
     const textContents = await Promise.all(textAttachments.map(async (attachment) => {
-        try {
-            const response = await fetch(attachment.url);
-            if (!response.ok) {
-                return `<attachment filename="${attachment.name}" error="Failed to fetch: ${response.status}" />`;
-            }
-            const text = await response.text();
-            return `<attachment filename="${attachment.name}" mime="${attachment.contentType}">\n${text}\n</attachment>`;
+        const response = await errore.tryAsync({
+            try: () => fetch(attachment.url),
+            catch: (e) => new FetchError({ url: attachment.url, cause: e }),
+        });
+        if (errore.isError(response)) {
+            return `<attachment filename="${attachment.name}" error="${response.message}" />`;
         }
-        catch (error) {
-            const errMsg = error instanceof Error ? error.message : String(error);
-            return `<attachment filename="${attachment.name}" error="${errMsg}" />`;
+        if (!response.ok) {
+            return `<attachment filename="${attachment.name}" error="Failed to fetch: ${response.status}" />`;
         }
+        const text = await response.text();
+        return `<attachment filename="${attachment.name}" mime="${attachment.contentType}">\n${text}\n</attachment>`;
     }));
     return textContents.join('\n\n');
 }
@@ -84,27 +86,28 @@ export async function getFileAttachments(message) {
         fs.mkdirSync(ATTACHMENTS_DIR, { recursive: true });
     }
     const results = await Promise.all(fileAttachments.map(async (attachment) => {
-        try {
-            const response = await fetch(attachment.url);
-            if (!response.ok) {
-                logger.error(`Failed to fetch attachment ${attachment.name}: ${response.status}`);
-                return null;
-            }
-            const buffer = Buffer.from(await response.arrayBuffer());
-            const localPath = path.join(ATTACHMENTS_DIR, `${message.id}-${attachment.name}`);
-            fs.writeFileSync(localPath, buffer);
-            logger.log(`Downloaded attachment to ${localPath}`);
-            return {
-                type: 'file',
-                mime: attachment.contentType || 'application/octet-stream',
-                filename: attachment.name,
-                url: localPath,
-            };
+        const response = await errore.tryAsync({
+            try: () => fetch(attachment.url),
+            catch: (e) => new FetchError({ url: attachment.url, cause: e }),
+        });
+        if (errore.isError(response)) {
+            logger.error(`Error downloading attachment ${attachment.name}:`, response.message);
+            return null;
         }
-        catch (error) {
-            logger.error(`Error downloading attachment ${attachment.name}:`, error);
+        if (!response.ok) {
+            logger.error(`Failed to fetch attachment ${attachment.name}: ${response.status}`);
             return null;
         }
+        const buffer = Buffer.from(await response.arrayBuffer());
+        const localPath = path.join(ATTACHMENTS_DIR, `${message.id}-${attachment.name}`);
+        fs.writeFileSync(localPath, buffer);
+        logger.log(`Downloaded attachment to ${localPath}`);
+        return {
+            type: 'file',
+            mime: attachment.contentType || 'application/octet-stream',
+            filename: attachment.name,
+            url: localPath,
+        };
     }));
     return results.filter((r) => r !== null);
 }
@@ -157,9 +160,9 @@ export function getToolSummaryText(part) {
     if (part.tool === 'bash' || part.tool === 'todoread' || part.tool === 'todowrite') {
         return '';
     }
+    // Task tool display is handled via subtask part in session-handler (shows label like explore-1)
     if (part.tool === 'task') {
-        const description = part.state.input?.description || '';
-        return description ? `_${escapeInlineMarkdown(description)}_` : '';
+        return '';
     }
     if (part.tool === 'skill') {
         const name = part.state.input?.name || '';
@@ -197,10 +200,15 @@ export function formatTodoList(part) {
     const content = activeTodo.content.charAt(0).toLowerCase() + activeTodo.content.slice(1);
     return `${num} **${escapeInlineMarkdown(content)}**`;
 }
-export function formatPart(part) {
+export function formatPart(part, prefix) {
+    const pfx = prefix ? `${prefix}: ` : '';
     if (part.type === 'text') {
         if (!part.text?.trim())
             return '';
+        // For subtask text, always use bullet with prefix
+        if (prefix) {
+            return `⬥ ${pfx}${part.text.trim()}`;
+        }
         const trimmed = part.text.trimStart();
         const firstChar = trimmed[0] || '';
         const markdownStarters = ['#', '*', '_', '-', '>', '`', '[', '|'];
@@ -213,28 +221,33 @@ export function formatPart(part) {
     if (part.type === 'reasoning') {
         if (!part.text?.trim())
             return '';
-        return `┣ thinking`;
+        return `┣ ${pfx}thinking`;
     }
     if (part.type === 'file') {
-        return `📄 ${part.filename || 'File'}`;
+        return prefix ? `📄 ${pfx}${part.filename || 'File'}` : `📄 ${part.filename || 'File'}`;
     }
     if (part.type === 'step-start' || part.type === 'step-finish' || part.type === 'patch') {
         return '';
     }
     if (part.type === 'agent') {
-        return `┣ agent ${part.id}`;
+        return `┣ ${pfx}agent ${part.id}`;
     }
     if (part.type === 'snapshot') {
-        return `┣ snapshot ${part.snapshot}`;
+        return `┣ ${pfx}snapshot ${part.snapshot}`;
     }
     if (part.type === 'tool') {
         if (part.tool === 'todowrite') {
-            return formatTodoList(part);
+            const formatted = formatTodoList(part);
+            return prefix && formatted ? `┣ ${pfx}${formatted}` : formatted;
         }
         // Question tool is handled via Discord dropdowns, not text
         if (part.tool === 'question') {
             return '';
         }
+        // Task tool display is handled in session-handler with proper label
+        if (part.tool === 'task') {
+            return '';
+        }
         if (part.state.status === 'pending') {
             return '';
         }
@@ -270,7 +283,7 @@ export function formatPart(part) {
             }
             return '┣';
         })();
-        return `${icon} ${part.tool} ${toolTitle} ${summaryText}`;
+        return `${icon} ${pfx}${part.tool} ${toolTitle} ${summaryText}`.trim();
     }
     logger.warn('Unknown part type:', part);
     return '';