kimaki 0.4.24 → 0.4.26

package/dist/database.js

@@ -1,3 +1,6 @@
+// SQLite database manager for persistent bot state.
+// Stores thread-session mappings, bot tokens, channel directories,
+// API keys, and model preferences in ~/.kimaki/discord-sessions.db.
 import Database from 'better-sqlite3';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -79,6 +82,21 @@ export function runModelMigrations(database) {
       model_id TEXT NOT NULL,
       created_at DATETIME DEFAULT CURRENT_TIMESTAMP
     )
+  `);
+    targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS channel_agents (
+      channel_id TEXT PRIMARY KEY,
+      agent_name TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+    targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS session_agents (
+      session_id TEXT PRIMARY KEY,
+      agent_name TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
   `);
     dbLogger.log('Model preferences migrations complete');
 }
@@ -122,6 +140,42 @@ export function setSessionModel(sessionId, modelId) {
     const db = getDatabase();
     db.prepare(`INSERT OR REPLACE INTO session_models (session_id, model_id) VALUES (?, ?)`).run(sessionId, modelId);
 }
+/**
+ * Get the agent preference for a channel.
+ */
+export function getChannelAgent(channelId) {
+    const db = getDatabase();
+    const row = db
+        .prepare('SELECT agent_name FROM channel_agents WHERE channel_id = ?')
+        .get(channelId);
+    return row?.agent_name;
+}
+/**
+ * Set the agent preference for a channel.
+ */
+export function setChannelAgent(channelId, agentName) {
+    const db = getDatabase();
+    db.prepare(`INSERT INTO channel_agents (channel_id, agent_name, updated_at) 
+     VALUES (?, ?, CURRENT_TIMESTAMP)
+     ON CONFLICT(channel_id) DO UPDATE SET agent_name = ?, updated_at = CURRENT_TIMESTAMP`).run(channelId, agentName, agentName);
+}
+/**
+ * Get the agent preference for a session.
+ */
+export function getSessionAgent(sessionId) {
+    const db = getDatabase();
+    const row = db
+        .prepare('SELECT agent_name FROM session_agents WHERE session_id = ?')
+        .get(sessionId);
+    return row?.agent_name;
+}
+/**
+ * Set the agent preference for a session.
+ */
+export function setSessionAgent(sessionId, agentName) {
+    const db = getDatabase();
+    db.prepare(`INSERT OR REPLACE INTO session_agents (session_id, agent_name) VALUES (?, ?)`).run(sessionId, agentName);
+}
 export function closeDatabase() {
     if (db) {
         db.close();

package/dist/discord-bot.js

@@ -1,3 +1,6 @@
+// Core Discord bot module that handles message events and bot lifecycle.
+// Bridges Discord messages to OpenCode sessions, manages voice connections,
+// and orchestrates the main event loop for the Kimaki bot.
 import { getDatabase, closeDatabase } from './database.js';
 import { initializeOpencodeForDirectory, getOpencodeServers } from './opencode.js';
 import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, SILENT_MESSAGE_FLAGS, } from './discord-utils.js';
@@ -5,7 +8,8 @@ import { getOpencodeSystemMessage } from './system-message.js';
 import { getFileAttachments, getTextAttachments } from './message-formatting.js';
 import { ensureKimakiCategory, ensureKimakiAudioCategory, createProjectChannels, getChannelsWithDescriptions, } from './channel-management.js';
 import { voiceConnections, cleanupVoiceConnection, processVoiceAttachment, registerVoiceStateHandler, } from './voice-handler.js';
-import { handleOpencodeSession, parseSlashCommand, } from './session-handler.js';
+import { getCompactSessionContext, getLastSessionId, } from './markdown.js';
+import { handleOpencodeSession } from './session-handler.js';
 import { registerInteractionHandler } from './interaction-handler.js';
 export { getDatabase, closeDatabase } from './database.js';
 export { initializeOpencodeForDirectory } from './opencode.js';
@@ -150,35 +154,37 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     return;
                 }
                 let messageContent = message.content || '';
-                let sessionMessagesText;
-                if (projectDirectory && row.session_id) {
+                let currentSessionContext;
+                let lastSessionContext;
+                if (projectDirectory) {
                     try {
                         const getClient = await initializeOpencodeForDirectory(projectDirectory);
-                        const messagesResponse = await getClient().session.messages({
-                            path: { id: row.session_id },
+                        const client = getClient();
+                        // get current session context (without system prompt, it would be duplicated)
+                        if (row.session_id) {
+                            currentSessionContext = await getCompactSessionContext({
+                                client,
+                                sessionId: row.session_id,
+                                includeSystemPrompt: false,
+                                maxMessages: 15,
+                            });
+                        }
+                        // get last session context (with system prompt for project context)
+                        const lastSessionId = await getLastSessionId({
+                            client,
+                            excludeSessionId: row.session_id,
                         });
-                        const messages = messagesResponse.data || [];
-                        const recentMessages = messages.slice(-10);
-                        sessionMessagesText = recentMessages
-                            .map((m) => {
-                            const role = m.info.role === 'user' ? 'User' : 'Assistant';
-                            const text = (() => {
-                                if (m.info.role === 'user') {
-                                    const textParts = (m.parts || []).filter((p) => p.type === 'text');
-                                    return textParts
-                                        .map((p) => ('text' in p ? p.text : ''))
-                                        .filter(Boolean)
-                                        .join('\n');
-                                }
-                                const assistantInfo = m.info;
-                                return assistantInfo.text?.slice(0, 500);
-                            })();
-                            return `[${role}]: ${text || '(no text)'}`;
-                        })
-                            .join('\n\n');
+                        if (lastSessionId) {
+                            lastSessionContext = await getCompactSessionContext({
+                                client,
+                                sessionId: lastSessionId,
+                                includeSystemPrompt: true,
+                                maxMessages: 10,
+                            });
+                        }
                     }
                     catch (e) {
-                        voiceLogger.log(`Could not get session messages:`, e);
+                        voiceLogger.error(`Could not get session context:`, e);
                     }
                 }
                 const transcription = await processVoiceAttachment({
@@ -186,24 +192,23 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     thread,
                     projectDirectory,
                     appId: currentAppId,
-                    sessionMessages: sessionMessagesText,
+                    currentSessionContext,
+                    lastSessionContext,
                 });
                 if (transcription) {
                     messageContent = transcription;
                 }
-                const fileAttachments = getFileAttachments(message);
+                const fileAttachments = await getFileAttachments(message);
                 const textAttachmentsContent = await getTextAttachments(message);
                 const promptWithAttachments = textAttachmentsContent
                     ? `${messageContent}\n\n${textAttachmentsContent}`
                     : messageContent;
-                const parsedCommand = parseSlashCommand(messageContent);
                 await handleOpencodeSession({
                     prompt: promptWithAttachments,
                     thread,
                     projectDirectory,
                     originalMessage: message,
                     images: fileAttachments,
-                    parsedCommand,
                     channelId: parent?.id,
                 });
                 return;
@@ -262,19 +267,17 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 if (transcription) {
                     messageContent = transcription;
                 }
-                const fileAttachments = getFileAttachments(message);
+                const fileAttachments = await getFileAttachments(message);
                 const textAttachmentsContent = await getTextAttachments(message);
                 const promptWithAttachments = textAttachmentsContent
                     ? `${messageContent}\n\n${textAttachmentsContent}`
                     : messageContent;
-                const parsedCommand = parseSlashCommand(messageContent);
                 await handleOpencodeSession({
                     prompt: promptWithAttachments,
                     thread,
                     projectDirectory,
                     originalMessage: message,
                     images: fileAttachments,
-                    parsedCommand,
                     channelId: textChannel.id,
                 });
             }

package/dist/discord-utils.js

@@ -1,3 +1,6 @@
+// Discord-specific utility functions.
+// Handles markdown splitting for Discord's 2000-char limit, code block escaping,
+// thread message sending, and channel metadata extraction from topic tags.
 import { ChannelType, } from 'discord.js';
 import { Lexer } from 'marked';
 import { extractTagsArrays } from './xml.js';
@@ -5,6 +8,8 @@ import { formatMarkdownTables } from './format-tables.js';
 import { createLogger } from './logger.js';
 const discordLogger = createLogger('DISCORD');
 export const SILENT_MESSAGE_FLAGS = 4 | 4096;
+// Same as SILENT but without SuppressNotifications - triggers badge/notification
+export const NOTIFY_MESSAGE_FLAGS = 4;
 export function escapeBackticksInCodeBlocks(markdown) {
     const lexer = new Lexer();
     const tokens = lexer.lex(markdown);
@@ -51,29 +56,86 @@ export function splitMarkdownForDiscord({ content, maxLength, }) {
     const chunks = [];
     let currentChunk = '';
     let currentLang = null;
+    // helper to split a long line into smaller pieces at word boundaries or hard breaks
+    const splitLongLine = (text, available, inCode) => {
+        const pieces = [];
+        let remaining = text;
+        while (remaining.length > available) {
+            let splitAt = available;
+            // for non-code, try to split at word boundary
+            if (!inCode) {
+                const lastSpace = remaining.lastIndexOf(' ', available);
+                if (lastSpace > available * 0.5) {
+                    splitAt = lastSpace + 1;
+                }
+            }
+            pieces.push(remaining.slice(0, splitAt));
+            remaining = remaining.slice(splitAt);
+        }
+        if (remaining) {
+            pieces.push(remaining);
+        }
+        return pieces;
+    };
     for (const line of lines) {
         const wouldExceed = currentChunk.length + line.text.length > maxLength;
-        if (wouldExceed && currentChunk) {
-            if (currentLang !== null) {
-                currentChunk += '```\n';
-            }
-            chunks.push(currentChunk);
-            if (line.isClosingFence && currentLang !== null) {
-                currentChunk = '';
+        if (wouldExceed) {
+            // handle case where single line is longer than maxLength
+            if (line.text.length > maxLength) {
+                // first, flush current chunk if any
+                if (currentChunk) {
+                    if (currentLang !== null) {
+                        currentChunk += '```\n';
+                    }
+                    chunks.push(currentChunk);
+                    currentChunk = '';
+                }
+                // calculate overhead for code block markers
+                const codeBlockOverhead = line.inCodeBlock ? ('```' + line.lang + '\n').length + '```\n'.length : 0;
+                const availablePerChunk = maxLength - codeBlockOverhead - 50; // safety margin
+                const pieces = splitLongLine(line.text, availablePerChunk, line.inCodeBlock);
+                for (let i = 0; i < pieces.length; i++) {
+                    const piece = pieces[i];
+                    if (line.inCodeBlock) {
+                        chunks.push('```' + line.lang + '\n' + piece + '```\n');
+                    }
+                    else {
+                        chunks.push(piece);
+                    }
+                }
                 currentLang = null;
                 continue;
             }
-            if (line.inCodeBlock || line.isOpeningFence) {
-                const lang = line.lang;
-                currentChunk = '```' + lang + '\n';
-                if (!line.isOpeningFence) {
-                    currentChunk += line.text;
+            // normal case: line fits in a chunk but current chunk would overflow
+            if (currentChunk) {
+                if (currentLang !== null) {
+                    currentChunk += '```\n';
+                }
+                chunks.push(currentChunk);
+                if (line.isClosingFence && currentLang !== null) {
+                    currentChunk = '';
+                    currentLang = null;
+                    continue;
+                }
+                if (line.inCodeBlock || line.isOpeningFence) {
+                    const lang = line.lang;
+                    currentChunk = '```' + lang + '\n';
+                    if (!line.isOpeningFence) {
+                        currentChunk += line.text;
+                    }
+                    currentLang = lang;
+                }
+                else {
+                    currentChunk = line.text;
+                    currentLang = null;
                 }
-                currentLang = lang;
             }
             else {
+                // currentChunk is empty but line still exceeds - shouldn't happen after above check
                 currentChunk = line.text;
-                currentLang = null;
+                if (line.inCodeBlock || line.isOpeningFence) {
+                    currentLang = line.lang;
+                }
             }
         }
         else {
@@ -91,10 +153,14 @@ export function splitMarkdownForDiscord({ content, maxLength, }) {
     }
     return chunks;
 }
-export async function sendThreadMessage(thread, content) {
+export async function sendThreadMessage(thread, content, options) {
     const MAX_LENGTH = 2000;
     content = formatMarkdownTables(content);
     content = escapeBackticksInCodeBlocks(content);
+    // If custom flags provided, send as single message (no chunking)
+    if (options?.flags !== undefined) {
+        return thread.send({ content, flags: options.flags });
+    }
     const chunks = splitMarkdownForDiscord({ content, maxLength: MAX_LENGTH });
     if (chunks.length > 1) {
         discordLogger.log(`MESSAGE: Splitting ${content.length} chars into ${chunks.length} messages`);

package/dist/format-tables.js

@@ -1,3 +1,6 @@
+// Markdown table to code block converter.
+// Discord doesn't render GFM tables, so this converts them to
+// space-aligned code blocks for proper monospace display.
 import { Lexer } from 'marked';
 export function formatMarkdownTables(markdown) {
     const lexer = new Lexer();

package/dist/genai-worker-wrapper.js

@@ -1,3 +1,6 @@
+// Main thread interface for the GenAI worker.
+// Spawns and manages the worker thread, handling message passing for
+// audio input/output, tool call completions, and graceful shutdown.
 import { Worker } from 'node:worker_threads';
 import { createLogger } from './logger.js';
 const genaiWorkerLogger = createLogger('GENAI WORKER');

package/dist/genai-worker.js

@@ -1,3 +1,6 @@
+// Worker thread for GenAI voice processing.
+// Runs in a separate thread to handle audio encoding/decoding without blocking.
+// 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';

package/dist/genai.js

@@ -1,3 +1,6 @@
+// Google GenAI Live session manager for real-time voice interactions.
+// Establishes bidirectional audio streaming with Gemini, handles tool calls,
+// and manages the assistant's audio output for Discord voice channels.
 import { GoogleGenAI, LiveServerMessage, MediaResolution, Modality, Session, } from '@google/genai';
 import { writeFile } from 'fs';
 import { createLogger } from './logger.js';