shuvmaki 0.4.26

package/dist/message-formatting.js

@@ -0,0 +1,273 @@
+// OpenCode message part formatting for Discord.
+// Converts SDK message parts (text, tools, reasoning) to Discord-friendly format,
+// handles file attachments, and provides tool summary generation.
+import fs from 'node:fs';
+import path from 'node:path';
+import { createLogger } from './logger.js';
+const ATTACHMENTS_DIR = path.join(process.cwd(), 'tmp', 'discord-attachments');
+const logger = createLogger('FORMATTING');
+/**
+ * Escapes Discord inline markdown characters so dynamic content
+ * doesn't break formatting when wrapped in *, _, **, etc.
+ */
+function escapeInlineMarkdown(text) {
+    return text.replace(/([*_~|`\\])/g, '\\$1');
+}
+/**
+ * Collects and formats the last N assistant parts from session messages.
+ * Used by both /resume and /fork to show recent assistant context.
+ */
+export function collectLastAssistantParts({ messages, limit = 30, }) {
+    const allAssistantParts = [];
+    for (const message of messages) {
+        if (message.info.role === 'assistant') {
+            for (const part of message.parts) {
+                const content = formatPart(part);
+                if (content.trim()) {
+                    allAssistantParts.push({ id: part.id, content: content.trimEnd() });
+                }
+            }
+        }
+    }
+    const partsToRender = allAssistantParts.slice(-limit);
+    const partIds = partsToRender.map((p) => p.id);
+    const content = partsToRender.map((p) => p.content).join('\n');
+    const skippedCount = allAssistantParts.length - partsToRender.length;
+    return { partIds, content, skippedCount };
+}
+export const TEXT_MIME_TYPES = [
+    'text/',
+    'application/json',
+    'application/xml',
+    'application/javascript',
+    'application/typescript',
+    'application/x-yaml',
+    'application/toml',
+];
+export function isTextMimeType(contentType) {
+    if (!contentType) {
+        return false;
+    }
+    return TEXT_MIME_TYPES.some((prefix) => contentType.startsWith(prefix));
+}
+export async function getTextAttachments(message) {
+    const textAttachments = Array.from(message.attachments.values()).filter((attachment) => isTextMimeType(attachment.contentType));
+    if (textAttachments.length === 0) {
+        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>`;
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            return `<attachment filename="${attachment.name}" error="${errMsg}" />`;
+        }
+    }));
+    return textContents.join('\n\n');
+}
+export async function getFileAttachments(message) {
+    const fileAttachments = Array.from(message.attachments.values()).filter((attachment) => {
+        const contentType = attachment.contentType || '';
+        return (contentType.startsWith('image/') || contentType === 'application/pdf');
+    });
+    if (fileAttachments.length === 0) {
+        return [];
+    }
+    // ensure tmp directory exists
+    if (!fs.existsSync(ATTACHMENTS_DIR)) {
+        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,
+            };
+        }
+        catch (error) {
+            logger.error(`Error downloading attachment ${attachment.name}:`, error);
+            return null;
+        }
+    }));
+    return results.filter((r) => r !== null);
+}
+export function getToolSummaryText(part) {
+    if (part.type !== 'tool')
+        return '';
+    if (part.tool === 'edit') {
+        const filePath = part.state.input?.filePath || '';
+        const newString = part.state.input?.newString || '';
+        const oldString = part.state.input?.oldString || '';
+        const added = newString.split('\n').length;
+        const removed = oldString.split('\n').length;
+        const fileName = filePath.split('/').pop() || '';
+        return fileName ? `*${escapeInlineMarkdown(fileName)}* (+${added}-${removed})` : `(+${added}-${removed})`;
+    }
+    if (part.tool === 'write') {
+        const filePath = part.state.input?.filePath || '';
+        const content = part.state.input?.content || '';
+        const lines = content.split('\n').length;
+        const fileName = filePath.split('/').pop() || '';
+        return fileName ? `*${escapeInlineMarkdown(fileName)}* (${lines} line${lines === 1 ? '' : 's'})` : `(${lines} line${lines === 1 ? '' : 's'})`;
+    }
+    if (part.tool === 'webfetch') {
+        const url = part.state.input?.url || '';
+        const urlWithoutProtocol = url.replace(/^https?:\/\//, '');
+        return urlWithoutProtocol ? `*${escapeInlineMarkdown(urlWithoutProtocol)}*` : '';
+    }
+    if (part.tool === 'read') {
+        const filePath = part.state.input?.filePath || '';
+        const fileName = filePath.split('/').pop() || '';
+        return fileName ? `*${escapeInlineMarkdown(fileName)}*` : '';
+    }
+    if (part.tool === 'list') {
+        const path = part.state.input?.path || '';
+        const dirName = path.split('/').pop() || path;
+        return dirName ? `*${escapeInlineMarkdown(dirName)}*` : '';
+    }
+    if (part.tool === 'glob') {
+        const pattern = part.state.input?.pattern || '';
+        return pattern ? `*${escapeInlineMarkdown(pattern)}*` : '';
+    }
+    if (part.tool === 'grep') {
+        const pattern = part.state.input?.pattern || '';
+        return pattern ? `*${escapeInlineMarkdown(pattern)}*` : '';
+    }
+    if (part.tool === 'bash' || part.tool === 'todoread' || part.tool === 'todowrite') {
+        return '';
+    }
+    if (part.tool === 'task') {
+        const description = part.state.input?.description || '';
+        return description ? `_${escapeInlineMarkdown(description)}_` : '';
+    }
+    if (part.tool === 'skill') {
+        const name = part.state.input?.name || '';
+        return name ? `_${escapeInlineMarkdown(name)}_` : '';
+    }
+    if (!part.state.input)
+        return '';
+    const inputFields = Object.entries(part.state.input)
+        .map(([key, value]) => {
+        if (value === null || value === undefined)
+            return null;
+        const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
+        const truncatedValue = stringValue.length > 50 ? stringValue.slice(0, 50) + '…' : stringValue;
+        return `${key}: ${truncatedValue}`;
+    })
+        .filter(Boolean);
+    if (inputFields.length === 0)
+        return '';
+    return `(${inputFields.join(', ')})`;
+}
+export function formatTodoList(part) {
+    if (part.type !== 'tool' || part.tool !== 'todowrite')
+        return '';
+    const todos = part.state.input?.todos || [];
+    const activeIndex = todos.findIndex((todo) => {
+        return todo.status === 'in_progress';
+    });
+    const activeTodo = todos[activeIndex];
+    if (activeIndex === -1 || !activeTodo)
+        return '';
+    // parenthesized digits ⑴-⒇ for 1-20, fallback to regular number for 21+
+    const parenthesizedDigits = '⑴⑵⑶⑷⑸⑹⑺⑻⑼⑽⑾⑿⒀⒁⒂⒃⒄⒅⒆⒇';
+    const todoNumber = activeIndex + 1;
+    const num = todoNumber <= 20 ? parenthesizedDigits[todoNumber - 1] : `(${todoNumber})`;
+    const content = activeTodo.content.charAt(0).toLowerCase() + activeTodo.content.slice(1);
+    return `${num} **${escapeInlineMarkdown(content)}**`;
+}
+export function formatPart(part) {
+    if (part.type === 'text') {
+        if (!part.text?.trim())
+            return '';
+        const trimmed = part.text.trimStart();
+        const firstChar = trimmed[0] || '';
+        const markdownStarters = ['#', '*', '_', '-', '>', '`', '[', '|'];
+        const startsWithMarkdown = markdownStarters.includes(firstChar) || /^\d+\./.test(trimmed);
+        if (startsWithMarkdown) {
+            return `\n${part.text}`;
+        }
+        return `⬥ ${part.text}`;
+    }
+    if (part.type === 'reasoning') {
+        if (!part.text?.trim())
+            return '';
+        return `┣ thinking`;
+    }
+    if (part.type === 'file') {
+        return `📄 ${part.filename || 'File'}`;
+    }
+    if (part.type === 'step-start' || part.type === 'step-finish' || part.type === 'patch') {
+        return '';
+    }
+    if (part.type === 'agent') {
+        return `┣ agent ${part.id}`;
+    }
+    if (part.type === 'snapshot') {
+        return `┣ snapshot ${part.snapshot}`;
+    }
+    if (part.type === 'tool') {
+        if (part.tool === 'todowrite') {
+            return formatTodoList(part);
+        }
+        // Question tool is handled via Discord dropdowns, not text
+        if (part.tool === 'question') {
+            return '';
+        }
+        if (part.state.status === 'pending') {
+            return '';
+        }
+        const summaryText = getToolSummaryText(part);
+        const stateTitle = 'title' in part.state ? part.state.title : undefined;
+        let toolTitle = '';
+        if (part.state.status === 'error') {
+            toolTitle = part.state.error || 'error';
+        }
+        else if (part.tool === 'bash') {
+            const command = part.state.input?.command || '';
+            const description = part.state.input?.description || '';
+            const isSingleLine = !command.includes('\n');
+            if (isSingleLine && command.length <= 50) {
+                toolTitle = `_${escapeInlineMarkdown(command)}_`;
+            }
+            else if (description) {
+                toolTitle = `_${escapeInlineMarkdown(description)}_`;
+            }
+            else if (stateTitle) {
+                toolTitle = `_${escapeInlineMarkdown(stateTitle)}_`;
+            }
+        }
+        else if (stateTitle) {
+            toolTitle = `_${escapeInlineMarkdown(stateTitle)}_`;
+        }
+        const icon = (() => {
+            if (part.state.status === 'error') {
+                return '⨯';
+            }
+            if (part.tool === 'edit' || part.tool === 'write') {
+                return '◼︎';
+            }
+            return '┣';
+        })();
+        return `${icon} ${part.tool} ${toolTitle} ${summaryText}`;
+    }
+    logger.warn('Unknown part type:', part);
+    return '';
+}

package/dist/message-formatting.test.js

@@ -0,0 +1,73 @@
+import { describe, test, expect } from 'vitest';
+import { formatTodoList } from './message-formatting.js';
+describe('formatTodoList', () => {
+    test('formats active todo with monospace numbers', () => {
+        const part = {
+            id: 'test',
+            type: 'tool',
+            tool: 'todowrite',
+            sessionID: 'ses_test',
+            messageID: 'msg_test',
+            callID: 'call_test',
+            state: {
+                status: 'completed',
+                input: {
+                    todos: [
+                        { content: 'First task', status: 'completed' },
+                        { content: 'Second task', status: 'in_progress' },
+                        { content: 'Third task', status: 'pending' },
+                    ],
+                },
+                output: '',
+                title: 'todowrite',
+                metadata: {},
+                time: { start: 0, end: 0 },
+            },
+        };
+        expect(formatTodoList(part)).toMatchInlineSnapshot(`"⑵ **second task**"`);
+    });
+    test('formats double digit todo numbers', () => {
+        const todos = Array.from({ length: 12 }, (_, i) => ({
+            content: `Task ${i + 1}`,
+            status: i === 11 ? 'in_progress' : 'completed',
+        }));
+        const part = {
+            id: 'test',
+            type: 'tool',
+            tool: 'todowrite',
+            sessionID: 'ses_test',
+            messageID: 'msg_test',
+            callID: 'call_test',
+            state: {
+                status: 'completed',
+                input: { todos },
+                output: '',
+                title: 'todowrite',
+                metadata: {},
+                time: { start: 0, end: 0 },
+            },
+        };
+        expect(formatTodoList(part)).toMatchInlineSnapshot(`"⑿ **task 12**"`);
+    });
+    test('lowercases first letter of content', () => {
+        const part = {
+            id: 'test',
+            type: 'tool',
+            tool: 'todowrite',
+            sessionID: 'ses_test',
+            messageID: 'msg_test',
+            callID: 'call_test',
+            state: {
+                status: 'completed',
+                input: {
+                    todos: [{ content: 'Fix the bug', status: 'in_progress' }],
+                },
+                output: '',
+                title: 'todowrite',
+                metadata: {},
+                time: { start: 0, end: 0 },
+            },
+        };
+        expect(formatTodoList(part)).toMatchInlineSnapshot(`"⑴ **fix the bug**"`);
+    });
+});

package/dist/openai-realtime.js

@@ -0,0 +1,228 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* istanbul ignore file */
+// @ts-nocheck
+import { RealtimeClient } from '@openai/realtime-api-beta';
+import { writeFile } from 'fs';
+import { createLogger } from './logger.js';
+const openaiLogger = createLogger('OPENAI');
+const audioParts = [];
+function saveBinaryFile(fileName, content) {
+    writeFile(fileName, content, 'utf8', (err) => {
+        if (err) {
+            openaiLogger.error(`Error writing file ${fileName}:`, err);
+            return;
+        }
+        openaiLogger.log(`Appending stream content to file ${fileName}.`);
+    });
+}
+function convertToWav(rawData, mimeType) {
+    const options = parseMimeType(mimeType);
+    const dataLength = rawData.reduce((a, b) => a + b.length, 0);
+    const wavHeader = createWavHeader(dataLength, options);
+    const buffer = Buffer.concat(rawData);
+    return Buffer.concat([wavHeader, buffer]);
+}
+function parseMimeType(mimeType) {
+    const [fileType, ...params] = mimeType.split(';').map((s) => s.trim());
+    const [_, format] = fileType?.split('/') || [];
+    const options = {
+        numChannels: 1,
+        bitsPerSample: 16,
+    };
+    if (format && format.startsWith('L')) {
+        const bits = parseInt(format.slice(1), 10);
+        if (!isNaN(bits)) {
+            options.bitsPerSample = bits;
+        }
+    }
+    for (const param of params) {
+        const [key, value] = param.split('=').map((s) => s.trim());
+        if (key === 'rate') {
+            options.sampleRate = parseInt(value || '', 10);
+        }
+    }
+    return options;
+}
+function createWavHeader(dataLength, options) {
+    const { numChannels, sampleRate, bitsPerSample } = options;
+    // http://soundfile.sapp.org/doc/WaveFormat
+    const byteRate = (sampleRate * numChannels * bitsPerSample) / 8;
+    const blockAlign = (numChannels * bitsPerSample) / 8;
+    const buffer = Buffer.alloc(44);
+    buffer.write('RIFF', 0); // ChunkID
+    buffer.writeUInt32LE(36 + dataLength, 4); // ChunkSize
+    buffer.write('WAVE', 8); // Format
+    buffer.write('fmt ', 12); // Subchunk1ID
+    buffer.writeUInt32LE(16, 16); // Subchunk1Size (PCM)
+    buffer.writeUInt16LE(1, 20); // AudioFormat (1 = PCM)
+    buffer.writeUInt16LE(numChannels, 22); // NumChannels
+    buffer.writeUInt32LE(sampleRate, 24); // SampleRate
+    buffer.writeUInt32LE(byteRate, 28); // ByteRate
+    buffer.writeUInt16LE(blockAlign, 32); // BlockAlign
+    buffer.writeUInt16LE(bitsPerSample, 34); // BitsPerSample
+    buffer.write('data', 36); // Subchunk2ID
+    buffer.writeUInt32LE(dataLength, 40); // Subchunk2Size
+    return buffer;
+}
+function defaultAudioChunkHandler({ data, mimeType, }) {
+    audioParts.push(data);
+    const fileName = 'audio.wav';
+    const buffer = convertToWav(audioParts, mimeType);
+    saveBinaryFile(fileName, buffer);
+}
+export async function startGenAiSession({ onAssistantAudioChunk, onAssistantStartSpeaking, onAssistantStopSpeaking, onAssistantInterruptSpeaking, systemMessage, tools, } = {}) {
+    if (!process.env.OPENAI_API_KEY) {
+        throw new Error('OPENAI_API_KEY environment variable is required');
+    }
+    const client = new RealtimeClient({
+        apiKey: process.env.OPENAI_API_KEY,
+    });
+    const audioChunkHandler = onAssistantAudioChunk || defaultAudioChunkHandler;
+    let isAssistantSpeaking = false;
+    // Configure session with 24kHz sample rate
+    client.updateSession({
+        instructions: systemMessage || '',
+        voice: 'alloy',
+        input_audio_format: 'pcm16',
+        output_audio_format: 'pcm16',
+        input_audio_transcription: { model: 'whisper-1' },
+        turn_detection: { type: 'server_vad' },
+        modalities: ['text', 'audio'],
+        temperature: 0.8,
+    });
+    // Add tools if provided
+    if (tools) {
+        for (const [name, tool] of Object.entries(tools)) {
+            // Convert AI SDK tool to OpenAI Realtime format
+            // The tool.inputSchema is a Zod schema, we need to convert it to JSON Schema
+            let parameters = {
+                type: 'object',
+                properties: {},
+                required: [],
+            };
+            // If the tool has a Zod schema, we can try to extract basic structure
+            // For now, we'll use a simple placeholder
+            if (tool.description?.includes('session')) {
+                parameters = {
+                    type: 'object',
+                    properties: {
+                        sessionId: { type: 'string', description: 'The session ID' },
+                        message: { type: 'string', description: 'The message text' },
+                    },
+                    required: ['sessionId'],
+                };
+            }
+            client.addTool({
+                type: 'function',
+                name,
+                description: tool.description || '',
+                parameters,
+            }, async (params) => {
+                try {
+                    if (!tool.execute || typeof tool.execute !== 'function') {
+                        return { error: 'Tool execute function not found' };
+                    }
+                    // Call the execute function with params
+                    // The Tool type from 'ai' expects (input, options) but we need to handle this safely
+                    const result = await tool.execute(params, {
+                        abortSignal: new AbortController().signal,
+                        toolCallId: '',
+                        messages: [],
+                    });
+                    return result;
+                }
+                catch (error) {
+                    openaiLogger.error(`Tool ${name} execution error:`, error);
+                    return { error: String(error) };
+                }
+            });
+        }
+    }
+    // Set up event handlers
+    client.on('conversation.item.created', ({ item }) => {
+        if ('role' in item &&
+            item.role === 'assistant' &&
+            item.type === 'message') {
+            // Check if this is the first audio content
+            const hasAudio = 'content' in item &&
+                Array.isArray(item.content) &&
+                item.content.some((c) => 'type' in c && c.type === 'audio');
+            if (hasAudio && !isAssistantSpeaking && onAssistantStartSpeaking) {
+                isAssistantSpeaking = true;
+                onAssistantStartSpeaking();
+            }
+        }
+    });
+    client.on('conversation.updated', ({ item, delta, }) => {
+        // Handle audio chunks
+        if (delta?.audio && 'role' in item && item.role === 'assistant') {
+            if (!isAssistantSpeaking && onAssistantStartSpeaking) {
+                isAssistantSpeaking = true;
+                onAssistantStartSpeaking();
+            }
+            // OpenAI provides audio as Int16Array or base64
+            let audioBuffer;
+            if (delta.audio instanceof Int16Array) {
+                audioBuffer = Buffer.from(delta.audio.buffer);
+            }
+            else {
+                // Assume base64 string
+                audioBuffer = Buffer.from(delta.audio, 'base64');
+            }
+            // OpenAI uses 24kHz PCM16 format
+            audioChunkHandler({
+                data: audioBuffer,
+                mimeType: 'audio/pcm;rate=24000',
+            });
+        }
+        // Handle transcriptions
+        if (delta?.transcript) {
+            if ('role' in item) {
+                if (item.role === 'user') {
+                    openaiLogger.log('User transcription:', delta.transcript);
+                }
+                else if (item.role === 'assistant') {
+                    openaiLogger.log('Assistant transcription:', delta.transcript);
+                }
+            }
+        }
+    });
+    client.on('conversation.item.completed', ({ item }) => {
+        if ('role' in item &&
+            item.role === 'assistant' &&
+            isAssistantSpeaking &&
+            onAssistantStopSpeaking) {
+            isAssistantSpeaking = false;
+            onAssistantStopSpeaking();
+        }
+    });
+    client.on('conversation.interrupted', () => {
+        openaiLogger.log('Assistant was interrupted');
+        if (isAssistantSpeaking && onAssistantInterruptSpeaking) {
+            isAssistantSpeaking = false;
+            onAssistantInterruptSpeaking();
+        }
+    });
+    // Connect to the Realtime API
+    await client.connect();
+    const sessionResult = {
+        session: {
+            send: (audioData) => {
+                // Convert ArrayBuffer to Int16Array for OpenAI
+                const int16Data = new Int16Array(audioData);
+                client.appendInputAudio(int16Data);
+            },
+            sendText: (text) => {
+                // Send text message to OpenAI
+                client.sendUserMessageContent([{ type: 'input_text', text }]);
+            },
+            close: () => {
+                client.disconnect();
+            },
+        },
+        stop: () => {
+            client.disconnect();
+        },
+    };
+    return sessionResult;
+}