kimaki 0.4.21 → 0.4.23

package/dist/session-handler.js

@@ -0,0 +1,467 @@
+import prettyMilliseconds from 'pretty-ms';
+import { getDatabase, getSessionModel, getChannelModel } from './database.js';
+import { initializeOpencodeForDirectory, getOpencodeServers } from './opencode.js';
+import { sendThreadMessage } from './discord-utils.js';
+import { formatPart } from './message-formatting.js';
+import { getOpencodeSystemMessage } from './system-message.js';
+import { createLogger } from './logger.js';
+import { isAbortError } from './utils.js';
+const sessionLogger = createLogger('SESSION');
+const voiceLogger = createLogger('VOICE');
+const discordLogger = createLogger('DISCORD');
+export function parseSlashCommand(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('/')) {
+        return { isCommand: false };
+    }
+    const match = trimmed.match(/^\/(\S+)(?:\s+(.*))?$/);
+    if (!match) {
+        return { isCommand: false };
+    }
+    const command = match[1];
+    const args = match[2]?.trim() || '';
+    return { isCommand: true, command, arguments: args };
+}
+export const abortControllers = new Map();
+export const pendingPermissions = new Map();
+export async function handleOpencodeSession({ prompt, thread, projectDirectory, originalMessage, images = [], parsedCommand, channelId, }) {
+    voiceLogger.log(`[OPENCODE SESSION] Starting for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}${prompt.length > 50 ? '...' : ''}"`);
+    const sessionStartTime = Date.now();
+    const directory = projectDirectory || process.cwd();
+    sessionLogger.log(`Using directory: ${directory}`);
+    const getClient = await initializeOpencodeForDirectory(directory);
+    const serverEntry = getOpencodeServers().get(directory);
+    const port = serverEntry?.port;
+    const row = getDatabase()
+        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+        .get(thread.id);
+    let sessionId = row?.session_id;
+    let session;
+    if (sessionId) {
+        sessionLogger.log(`Attempting to reuse existing session ${sessionId}`);
+        try {
+            const sessionResponse = await getClient().session.get({
+                path: { id: sessionId },
+            });
+            session = sessionResponse.data;
+            sessionLogger.log(`Successfully reused session ${sessionId}`);
+        }
+        catch (error) {
+            voiceLogger.log(`[SESSION] Session ${sessionId} not found, will create new one`);
+        }
+    }
+    if (!session) {
+        const sessionTitle = prompt.length > 80 ? prompt.slice(0, 77) + '...' : prompt.slice(0, 80);
+        voiceLogger.log(`[SESSION] Creating new session with title: "${sessionTitle}"`);
+        const sessionResponse = await getClient().session.create({
+            body: { title: sessionTitle },
+        });
+        session = sessionResponse.data;
+        sessionLogger.log(`Created new session ${session?.id}`);
+    }
+    if (!session) {
+        throw new Error('Failed to create or get session');
+    }
+    getDatabase()
+        .prepare('INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)')
+        .run(thread.id, session.id);
+    sessionLogger.log(`Stored session ${session.id} for thread ${thread.id}`);
+    const existingController = abortControllers.get(session.id);
+    if (existingController) {
+        voiceLogger.log(`[ABORT] Cancelling existing request for session: ${session.id}`);
+        existingController.abort(new Error('New request started'));
+    }
+    const pendingPerm = pendingPermissions.get(thread.id);
+    if (pendingPerm) {
+        try {
+            sessionLogger.log(`[PERMISSION] Auto-rejecting pending permission ${pendingPerm.permission.id} due to new message`);
+            await getClient().postSessionIdPermissionsPermissionId({
+                path: {
+                    id: pendingPerm.permission.sessionID,
+                    permissionID: pendingPerm.permission.id,
+                },
+                body: { response: 'reject' },
+            });
+            pendingPermissions.delete(thread.id);
+            await sendThreadMessage(thread, `⚠️ Previous permission request auto-rejected due to new message`);
+        }
+        catch (e) {
+            sessionLogger.log(`[PERMISSION] Failed to auto-reject permission:`, e);
+            pendingPermissions.delete(thread.id);
+        }
+    }
+    const abortController = new AbortController();
+    abortControllers.set(session.id, abortController);
+    if (existingController) {
+        await new Promise((resolve) => { setTimeout(resolve, 200); });
+        if (abortController.signal.aborted) {
+            sessionLogger.log(`[DEBOUNCE] Request was superseded during wait, exiting`);
+            return;
+        }
+    }
+    if (abortController.signal.aborted) {
+        sessionLogger.log(`[DEBOUNCE] Aborted before subscribe, exiting`);
+        return;
+    }
+    const eventsResult = await getClient().event.subscribe({
+        signal: abortController.signal,
+    });
+    if (abortController.signal.aborted) {
+        sessionLogger.log(`[DEBOUNCE] Aborted during subscribe, exiting`);
+        return;
+    }
+    const events = eventsResult.stream;
+    sessionLogger.log(`Subscribed to OpenCode events`);
+    const sentPartIds = new Set(getDatabase()
+        .prepare('SELECT part_id FROM part_messages WHERE thread_id = ?')
+        .all(thread.id)
+        .map((row) => row.part_id));
+    let currentParts = [];
+    let stopTyping = null;
+    let usedModel;
+    let usedProviderID;
+    let tokensUsedInSession = 0;
+    let lastDisplayedContextPercentage = 0;
+    let modelContextLimit;
+    let typingInterval = null;
+    function startTyping() {
+        if (abortController.signal.aborted) {
+            discordLogger.log(`Not starting typing, already aborted`);
+            return () => { };
+        }
+        if (typingInterval) {
+            clearInterval(typingInterval);
+            typingInterval = null;
+        }
+        thread.sendTyping().catch((e) => {
+            discordLogger.log(`Failed to send initial typing: ${e}`);
+        });
+        typingInterval = setInterval(() => {
+            thread.sendTyping().catch((e) => {
+                discordLogger.log(`Failed to send periodic typing: ${e}`);
+            });
+        }, 8000);
+        if (!abortController.signal.aborted) {
+            abortController.signal.addEventListener('abort', () => {
+                if (typingInterval) {
+                    clearInterval(typingInterval);
+                    typingInterval = null;
+                }
+            }, { once: true });
+        }
+        return () => {
+            if (typingInterval) {
+                clearInterval(typingInterval);
+                typingInterval = null;
+            }
+        };
+    }
+    const sendPartMessage = async (part) => {
+        const content = formatPart(part) + '\n\n';
+        if (!content.trim() || content.length === 0) {
+            discordLogger.log(`SKIP: Part ${part.id} has no content`);
+            return;
+        }
+        if (sentPartIds.has(part.id)) {
+            return;
+        }
+        try {
+            const firstMessage = await sendThreadMessage(thread, content);
+            sentPartIds.add(part.id);
+            getDatabase()
+                .prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)')
+                .run(part.id, firstMessage.id, thread.id);
+        }
+        catch (error) {
+            discordLogger.error(`ERROR: Failed to send part ${part.id}:`, error);
+        }
+    };
+    const eventHandler = async () => {
+        try {
+            let assistantMessageId;
+            for await (const event of events) {
+                if (event.type === 'message.updated') {
+                    const msg = event.properties.info;
+                    if (msg.sessionID !== session.id) {
+                        continue;
+                    }
+                    if (msg.role === 'assistant') {
+                        const newTokensTotal = msg.tokens.input + msg.tokens.output + msg.tokens.reasoning + msg.tokens.cache.read + msg.tokens.cache.write;
+                        if (newTokensTotal > 0) {
+                            tokensUsedInSession = newTokensTotal;
+                        }
+                        assistantMessageId = msg.id;
+                        usedModel = msg.modelID;
+                        usedProviderID = msg.providerID;
+                        if (tokensUsedInSession > 0 && usedProviderID && usedModel) {
+                            if (!modelContextLimit) {
+                                try {
+                                    const providersResponse = await getClient().provider.list({ query: { directory } });
+                                    const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID);
+                                    const model = provider?.models?.[usedModel];
+                                    if (model?.limit?.context) {
+                                        modelContextLimit = model.limit.context;
+                                    }
+                                }
+                                catch (e) {
+                                    sessionLogger.error('Failed to fetch provider info for context limit:', e);
+                                }
+                            }
+                            if (modelContextLimit) {
+                                const currentPercentage = Math.floor((tokensUsedInSession / modelContextLimit) * 100);
+                                const thresholdCrossed = Math.floor(currentPercentage / 10) * 10;
+                                if (thresholdCrossed > lastDisplayedContextPercentage && thresholdCrossed >= 10) {
+                                    lastDisplayedContextPercentage = thresholdCrossed;
+                                    await sendThreadMessage(thread, `◼︎ context usage ${currentPercentage}%`);
+                                }
+                            }
+                        }
+                    }
+                }
+                else if (event.type === 'message.part.updated') {
+                    const part = event.properties.part;
+                    if (part.sessionID !== session.id) {
+                        continue;
+                    }
+                    if (part.messageID !== assistantMessageId) {
+                        continue;
+                    }
+                    const existingIndex = currentParts.findIndex((p) => p.id === part.id);
+                    if (existingIndex >= 0) {
+                        currentParts[existingIndex] = part;
+                    }
+                    else {
+                        currentParts.push(part);
+                    }
+                    if (part.type === 'step-start') {
+                        stopTyping = startTyping();
+                    }
+                    if (part.type === 'tool' && part.state.status === 'running') {
+                        await sendPartMessage(part);
+                    }
+                    if (part.type === 'reasoning') {
+                        await sendPartMessage(part);
+                    }
+                    if (part.type === 'step-finish') {
+                        for (const p of currentParts) {
+                            if (p.type !== 'step-start' && p.type !== 'step-finish') {
+                                await sendPartMessage(p);
+                            }
+                        }
+                        setTimeout(() => {
+                            if (abortController.signal.aborted)
+                                return;
+                            stopTyping = startTyping();
+                        }, 300);
+                    }
+                }
+                else if (event.type === 'session.error') {
+                    sessionLogger.error(`ERROR:`, event.properties);
+                    if (event.properties.sessionID === session.id) {
+                        const errorData = event.properties.error;
+                        const errorMessage = errorData?.data?.message || 'Unknown error';
+                        sessionLogger.error(`Sending error to thread: ${errorMessage}`);
+                        await sendThreadMessage(thread, `✗ opencode session error: ${errorMessage}`);
+                        if (originalMessage) {
+                            try {
+                                await originalMessage.reactions.removeAll();
+                                await originalMessage.react('❌');
+                                voiceLogger.log(`[REACTION] Added error reaction due to session error`);
+                            }
+                            catch (e) {
+                                discordLogger.log(`Could not update reaction:`, e);
+                            }
+                        }
+                    }
+                    else {
+                        voiceLogger.log(`[SESSION ERROR IGNORED] Error for different session (expected: ${session.id}, got: ${event.properties.sessionID})`);
+                    }
+                    break;
+                }
+                else if (event.type === 'permission.updated') {
+                    const permission = event.properties;
+                    if (permission.sessionID !== session.id) {
+                        voiceLogger.log(`[PERMISSION IGNORED] Permission for different session (expected: ${session.id}, got: ${permission.sessionID})`);
+                        continue;
+                    }
+                    sessionLogger.log(`Permission requested: type=${permission.type}, title=${permission.title}`);
+                    const patternStr = Array.isArray(permission.pattern)
+                        ? permission.pattern.join(', ')
+                        : permission.pattern || '';
+                    const permissionMessage = await sendThreadMessage(thread, `⚠️ **Permission Required**\n\n` +
+                        `**Type:** \`${permission.type}\`\n` +
+                        `**Action:** ${permission.title}\n` +
+                        (patternStr ? `**Pattern:** \`${patternStr}\`\n` : '') +
+                        `\nUse \`/accept\` or \`/reject\` to respond.`);
+                    pendingPermissions.set(thread.id, {
+                        permission,
+                        messageId: permissionMessage.id,
+                        directory,
+                    });
+                }
+                else if (event.type === 'permission.replied') {
+                    const { permissionID, response, sessionID } = event.properties;
+                    if (sessionID !== session.id) {
+                        continue;
+                    }
+                    sessionLogger.log(`Permission ${permissionID} replied with: ${response}`);
+                    const pending = pendingPermissions.get(thread.id);
+                    if (pending && pending.permission.id === permissionID) {
+                        pendingPermissions.delete(thread.id);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            if (isAbortError(e, abortController.signal)) {
+                sessionLogger.log('AbortController aborted event handling (normal exit)');
+                return;
+            }
+            sessionLogger.error(`Unexpected error in event handling code`, e);
+            throw e;
+        }
+        finally {
+            for (const part of currentParts) {
+                if (!sentPartIds.has(part.id)) {
+                    try {
+                        await sendPartMessage(part);
+                    }
+                    catch (error) {
+                        sessionLogger.error(`Failed to send part ${part.id}:`, error);
+                    }
+                }
+            }
+            if (stopTyping) {
+                stopTyping();
+                stopTyping = null;
+            }
+            if (!abortController.signal.aborted ||
+                abortController.signal.reason === 'finished') {
+                const sessionDuration = prettyMilliseconds(Date.now() - sessionStartTime);
+                const attachCommand = port ? ` ⋅ ${session.id}` : '';
+                const modelInfo = usedModel ? ` ⋅ ${usedModel}` : '';
+                let contextInfo = '';
+                try {
+                    const providersResponse = await getClient().provider.list({ query: { directory } });
+                    const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID);
+                    const model = provider?.models?.[usedModel || ''];
+                    if (model?.limit?.context) {
+                        const percentage = Math.round((tokensUsedInSession / model.limit.context) * 100);
+                        contextInfo = ` ⋅ ${percentage}%`;
+                    }
+                }
+                catch (e) {
+                    sessionLogger.error('Failed to fetch provider info for context percentage:', e);
+                }
+                await sendThreadMessage(thread, `_Completed in ${sessionDuration}${contextInfo}_${attachCommand}${modelInfo}`);
+                sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}, tokens ${tokensUsedInSession}`);
+            }
+            else {
+                sessionLogger.log(`Session was aborted (reason: ${abortController.signal.reason}), skipping duration message`);
+            }
+        }
+    };
+    try {
+        const eventHandlerPromise = eventHandler();
+        if (abortController.signal.aborted) {
+            sessionLogger.log(`[DEBOUNCE] Aborted before prompt, exiting`);
+            return;
+        }
+        stopTyping = startTyping();
+        let response;
+        if (parsedCommand?.isCommand) {
+            sessionLogger.log(`[COMMAND] Sending command /${parsedCommand.command} to session ${session.id} with args: "${parsedCommand.arguments.slice(0, 100)}${parsedCommand.arguments.length > 100 ? '...' : ''}"`);
+            response = await getClient().session.command({
+                path: { id: session.id },
+                body: {
+                    command: parsedCommand.command,
+                    arguments: parsedCommand.arguments,
+                },
+                signal: abortController.signal,
+            });
+        }
+        else {
+            voiceLogger.log(`[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`);
+            if (images.length > 0) {
+                sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({ mime: img.mime, filename: img.filename, url: img.url.slice(0, 100) })));
+            }
+            const parts = [{ type: 'text', text: prompt }, ...images];
+            sessionLogger.log(`[PROMPT] Parts to send:`, parts.length);
+            // Get model preference: session-level overrides channel-level
+            const modelPreference = getSessionModel(session.id) || (channelId ? getChannelModel(channelId) : undefined);
+            const modelParam = (() => {
+                if (!modelPreference) {
+                    return undefined;
+                }
+                const [providerID, ...modelParts] = modelPreference.split('/');
+                const modelID = modelParts.join('/');
+                if (!providerID || !modelID) {
+                    return undefined;
+                }
+                sessionLogger.log(`[MODEL] Using model preference: ${modelPreference}`);
+                return { providerID, modelID };
+            })();
+            response = await getClient().session.prompt({
+                path: { id: session.id },
+                body: {
+                    parts,
+                    system: getOpencodeSystemMessage({ sessionId: session.id }),
+                    model: modelParam,
+                },
+                signal: abortController.signal,
+            });
+        }
+        if (response.error) {
+            const errorMessage = (() => {
+                const err = response.error;
+                if (err && typeof err === 'object') {
+                    if ('data' in err && err.data && typeof err.data === 'object' && 'message' in err.data) {
+                        return String(err.data.message);
+                    }
+                    if ('errors' in err && Array.isArray(err.errors) && err.errors.length > 0) {
+                        return JSON.stringify(err.errors);
+                    }
+                }
+                return JSON.stringify(err);
+            })();
+            throw new Error(`OpenCode API error (${response.response.status}): ${errorMessage}`);
+        }
+        abortController.abort('finished');
+        sessionLogger.log(`Successfully sent prompt, got response`);
+        if (originalMessage) {
+            try {
+                await originalMessage.reactions.removeAll();
+                await originalMessage.react('✅');
+            }
+            catch (e) {
+                discordLogger.log(`Could not update reactions:`, e);
+            }
+        }
+        return { sessionID: session.id, result: response.data, port };
+    }
+    catch (error) {
+        sessionLogger.error(`ERROR: Failed to send prompt:`, error);
+        if (!isAbortError(error, abortController.signal)) {
+            abortController.abort('error');
+            if (originalMessage) {
+                try {
+                    await originalMessage.reactions.removeAll();
+                    await originalMessage.react('❌');
+                    discordLogger.log(`Added error reaction to message`);
+                }
+                catch (e) {
+                    discordLogger.log(`Could not update reaction:`, e);
+                }
+            }
+            const errorName = error &&
+                typeof error === 'object' &&
+                'constructor' in error &&
+                error.constructor &&
+                typeof error.constructor.name === 'string'
+                ? error.constructor.name
+                : typeof error;
+            const errorMsg = error instanceof Error ? error.stack || error.message : String(error);
+            await sendThreadMessage(thread, `✗ Unexpected bot Error: [${errorName}]\n${errorMsg}`);
+        }
+    }
+}

package/dist/system-message.js

@@ -0,0 +1,92 @@
+export function getOpencodeSystemMessage({ sessionId }) {
+    return `
+The user is reading your messages from inside Discord, via kimaki.xyz
+
+The user cannot see bash tool outputs. If there is important information in bash output, include it in your text response.
+
+Your current OpenCode session ID is: ${sessionId}
+
+## permissions
+
+Only users with these Discord permissions can send messages to the bot:
+- Server Owner
+- Administrator permission
+- Manage Server permission
+- "Kimaki" role (case-insensitive)
+
+## changing the model
+
+To change the model used by OpenCode, edit the project's \`opencode.json\` config file and set the \`model\` field:
+
+\`\`\`json
+{
+  "model": "anthropic/claude-sonnet-4-20250514"
+}
+\`\`\`
+
+Examples:
+- \`"anthropic/claude-sonnet-4-20250514"\` - Claude Sonnet 4
+- \`"anthropic/claude-opus-4-20250514"\` - Claude Opus 4
+- \`"openai/gpt-4o"\` - GPT-4o
+- \`"google/gemini-2.5-pro"\` - Gemini 2.5 Pro
+
+Format is \`provider/model-name\`. You can also set \`small_model\` for tasks like title generation.
+
+## uploading files to discord
+
+To upload files to the Discord thread (images, screenshots, long files that would clutter the chat), run:
+
+npx -y kimaki upload-to-discord --session ${sessionId} <file1> [file2] ...
+
+## showing diffs
+
+IMPORTANT: After editing any files, you MUST execute the critique command using the Bash tool to get a diff URL, then share that URL with the user.
+
+Execute this after making changes:
+
+bunx critique web
+
+If there are other unrelated changes in the working directory, filter to only show the files you edited:
+
+bunx critique web -- path/to/file1.ts path/to/file2.ts
+
+You can also show latest commit changes using:
+
+bunx critique web HEAD~1
+
+Do this in case you committed the changes yourself (only if the user asks so, never commit otherwise).
+
+The command outputs a URL - share that URL with the user so they can see the diff.
+
+## markdown
+
+discord does support basic markdown features like code blocks, code blocks languages, inline code, bold, italic, quotes, etc.
+
+the max heading level is 3, so do not use ####
+
+headings are discouraged anyway. instead try to use bold text for titles which renders more nicely in Discord
+
+## tables
+
+discord does NOT support markdown gfm tables.
+
+so instead of using full markdown tables ALWAYS show code snippets with space aligned cells:
+
+\`\`\`
+Item        Qty   Price
+----------  ---   -----
+Apples      10    $5
+Oranges     3     $2
+\`\`\`
+
+Using code blocks will make the content use monospaced font so that space will be aligned correctly
+
+IMPORTANT: add enough space characters to align the table! otherwise the content will not look good and will be difficult to understand for the user
+
+code blocks for tables and diagrams MUST have Max length of 85 characters. otherwise the content will wrap
+
+## diagrams
+
+you can create diagrams wrapping them in code blocks too.
+`;
+}

package/dist/tools.js

@@ -5,10 +5,10 @@ import net from 'node:net';
 import { createOpencodeClient, } from '@opencode-ai/sdk';
 import { createLogger } from './logger.js';
 const toolsLogger = createLogger('TOOLS');
-import { formatDistanceToNow } from 'date-fns';
 import { ShareMarkdown } from './markdown.js';
+import { formatDistanceToNow } from './utils.js';
 import pc from 'picocolors';
-import { initializeOpencodeForDirectory, getOpencodeSystemMessage, } from './discordBot.js';
+import { initializeOpencodeForDirectory, getOpencodeSystemMessage, } from './discord-bot.js';
 export async function getTools({ onMessageCompleted, directory, }) {
     const getClient = await initializeOpencodeForDirectory(directory);
     const client = getClient();
@@ -187,9 +187,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                         id: session.id,
                         folder: session.directory,
                         status,
-                        finishedAt: formatDistanceToNow(new Date(finishedAt), {
-                            addSuffix: true,
-                        }),
+                        finishedAt: formatDistanceToNow(new Date(finishedAt)),
                         title: session.title,
                         prompt: session.title,
                     };

package/dist/utils.js

@@ -49,3 +49,34 @@ export function isAbortError(error, signal) {
             (signal?.aborted ?? false))) ||
         (error instanceof DOMException && error.name === 'AbortError'));
 }
+const rtf = new Intl.RelativeTimeFormat('en', { numeric: 'auto' });
+const TIME_DIVISIONS = [
+    { amount: 60, name: 'seconds' },
+    { amount: 60, name: 'minutes' },
+    { amount: 24, name: 'hours' },
+    { amount: 7, name: 'days' },
+    { amount: 4.34524, name: 'weeks' },
+    { amount: 12, name: 'months' },
+    { amount: Number.POSITIVE_INFINITY, name: 'years' },
+];
+export function formatDistanceToNow(date) {
+    let duration = (date.getTime() - Date.now()) / 1000;
+    for (const division of TIME_DIVISIONS) {
+        if (Math.abs(duration) < division.amount) {
+            return rtf.format(Math.round(duration), division.name);
+        }
+        duration /= division.amount;
+    }
+    return rtf.format(Math.round(duration), 'years');
+}
+const dtf = new Intl.DateTimeFormat('en-US', {
+    month: 'short',
+    day: 'numeric',
+    year: 'numeric',
+    hour: 'numeric',
+    minute: '2-digit',
+    hour12: true,
+});
+export function formatDateTime(date) {
+    return dtf.format(date);
+}