kimaki 0.4.25 → 0.4.26

package/dist/commands/model.js

@@ -4,6 +4,7 @@ import crypto from 'node:crypto';
 import { getDatabase, setChannelModel, setSessionModel, runModelMigrations } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
+import { abortAndRetrySession } from '../session-handler.js';
 import { createLogger } from '../logger.js';
 const modelLogger = createLogger('MODEL');
 // Store context by hash to avoid customId length limits (Discord max: 100 chars)
@@ -102,6 +103,7 @@ export async function handleModelCommand({ interaction, appId, }) {
             channelId: targetChannelId,
             sessionId: sessionId,
             isThread: isThread,
+            thread: isThread ? channel : undefined,
         };
         const contextHash = crypto.randomBytes(8).toString('hex');
         pendingModelContexts.set(contextHash, context);
@@ -267,10 +269,27 @@ export async function handleModelSelectMenu(interaction) {
             // Store for session
             setSessionModel(context.sessionId, fullModelId);
             modelLogger.log(`Set model ${fullModelId} for session ${context.sessionId}`);
-            await interaction.editReply({
-                content: `Model preference set for this session:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\``,
-                components: [],
-            });
+            // Check if there's a running request and abort+retry with new model
+            let retried = false;
+            if (context.thread) {
+                retried = await abortAndRetrySession({
+                    sessionId: context.sessionId,
+                    thread: context.thread,
+                    projectDirectory: context.dir,
+                });
+            }
+            if (retried) {
+                await interaction.editReply({
+                    content: `Model changed for this session:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\`\n\n_Retrying current request with new model..._`,
+                    components: [],
+                });
+            }
+            else {
+                await interaction.editReply({
+                    content: `Model preference set for this session:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\``,
+                    components: [],
+                });
+            }
         }
         else {
             // Store for channel

package/dist/commands/session.js

@@ -6,7 +6,7 @@ import { getDatabase } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { extractTagsArrays } from '../xml.js';
-import { handleOpencodeSession, parseSlashCommand } from '../session-handler.js';
+import { handleOpencodeSession } from '../session-handler.js';
 import { createLogger } from '../logger.js';
 const logger = createLogger('SESSION');
 export async function handleSessionCommand({ command, appId, }) {
@@ -61,12 +61,10 @@ export async function handleSessionCommand({ command, appId, }) {
             reason: 'OpenCode session',
         });
         await command.editReply(`Created new session in ${thread.toString()}`);
-        const parsedCommand = parseSlashCommand(fullPrompt);
         await handleOpencodeSession({
             prompt: fullPrompt,
             thread,
             projectDirectory,
-            parsedCommand,
             channelId: textChannel.id,
         });
     }

package/dist/commands/user-command.js

@@ -0,0 +1,145 @@
+// User-defined OpenCode command handler.
+// Handles slash commands that map to user-configured commands in opencode.json.
+import { ChannelType } from 'discord.js';
+import { extractTagsArrays } from '../xml.js';
+import { handleOpencodeSession } from '../session-handler.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger } from '../logger.js';
+import { getDatabase } from '../database.js';
+import fs from 'node:fs';
+const userCommandLogger = createLogger('USER_CMD');
+export const handleUserCommand = async ({ command, appId, }) => {
+    const discordCommandName = command.commandName;
+    // Strip the -cmd suffix to get the actual OpenCode command name
+    const commandName = discordCommandName.replace(/-cmd$/, '');
+    const args = command.options.getString('arguments') || '';
+    userCommandLogger.log(`Executing /${commandName} (from /${discordCommandName}) with args: ${args}`);
+    const channel = command.channel;
+    userCommandLogger.log(`Channel info: type=${channel?.type}, id=${channel?.id}, isNull=${channel === null}`);
+    const isThread = channel && [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    const isTextChannel = channel?.type === ChannelType.GuildText;
+    if (!channel || (!isTextChannel && !isThread)) {
+        await command.reply({
+            content: 'This command can only be used in text channels or threads',
+            ephemeral: true,
+        });
+        return;
+    }
+    let projectDirectory;
+    let channelAppId;
+    let textChannel = null;
+    let thread = null;
+    if (isThread) {
+        // Running in an existing thread - get project directory from parent channel
+        thread = channel;
+        textChannel = thread.parent;
+        // Verify this thread has an existing session
+        const row = getDatabase()
+            .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+            .get(thread.id);
+        if (!row) {
+            await command.reply({
+                content: 'This thread does not have an active session. Use this command in a project channel to create a new thread.',
+                ephemeral: true,
+            });
+            return;
+        }
+        if (textChannel?.topic) {
+            const extracted = extractTagsArrays({
+                xml: textChannel.topic,
+                tags: ['kimaki.directory', 'kimaki.app'],
+            });
+            projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+            channelAppId = extracted['kimaki.app']?.[0]?.trim();
+        }
+    }
+    else {
+        // Running in a text channel - will create a new thread
+        textChannel = channel;
+        if (textChannel.topic) {
+            const extracted = extractTagsArrays({
+                xml: textChannel.topic,
+                tags: ['kimaki.directory', 'kimaki.app'],
+            });
+            projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+            channelAppId = extracted['kimaki.app']?.[0]?.trim();
+        }
+    }
+    if (channelAppId && channelAppId !== appId) {
+        await command.reply({
+            content: 'This channel is not configured for this bot',
+            ephemeral: true,
+        });
+        return;
+    }
+    if (!projectDirectory) {
+        await command.reply({
+            content: 'This channel is not configured with a project directory',
+            ephemeral: true,
+        });
+        return;
+    }
+    if (!fs.existsSync(projectDirectory)) {
+        await command.reply({
+            content: `Directory does not exist: ${projectDirectory}`,
+            ephemeral: true,
+        });
+        return;
+    }
+    await command.deferReply({ ephemeral: false });
+    try {
+        // Use the dedicated session.command API instead of formatting as text prompt
+        const commandPayload = { name: commandName, arguments: args };
+        if (isThread && thread) {
+            // Running in existing thread - just send the command
+            await command.editReply(`Running /${commandName}...`);
+            await handleOpencodeSession({
+                prompt: '', // Not used when command is set
+                thread,
+                projectDirectory,
+                channelId: textChannel?.id,
+                command: commandPayload,
+            });
+        }
+        else if (textChannel) {
+            // Running in text channel - create a new thread
+            const starterMessage = await textChannel.send({
+                content: `**/${commandName}**${args ? ` ${args.slice(0, 200)}${args.length > 200 ? '…' : ''}` : ''}`,
+                flags: SILENT_MESSAGE_FLAGS,
+            });
+            const threadName = `/${commandName} ${args.slice(0, 80)}${args.length > 80 ? '…' : ''}`;
+            const newThread = await starterMessage.startThread({
+                name: threadName.slice(0, 100),
+                autoArchiveDuration: 1440,
+                reason: `OpenCode command: ${commandName}`,
+            });
+            await command.editReply(`Started /${commandName} in ${newThread.toString()}`);
+            await handleOpencodeSession({
+                prompt: '', // Not used when command is set
+                thread: newThread,
+                projectDirectory,
+                channelId: textChannel.id,
+                command: commandPayload,
+            });
+        }
+    }
+    catch (error) {
+        userCommandLogger.error(`Error executing /${commandName}:`, error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (command.deferred) {
+            await command.editReply({
+                content: `Failed to execute /${commandName}: ${errorMessage}`,
+            });
+        }
+        else {
+            await command.reply({
+                content: `Failed to execute /${commandName}: ${errorMessage}`,
+                ephemeral: true,
+            });
+        }
+    }
+};

package/dist/database.js

@@ -82,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');
 }
@@ -125,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

@@ -8,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';
@@ -153,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({
@@ -189,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;
@@ -265,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

@@ -56,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 {

package/dist/interaction-handler.js

@@ -11,8 +11,11 @@ import { handleAbortCommand } from './commands/abort.js';
 import { handleShareCommand } from './commands/share.js';
 import { handleForkCommand, handleForkSelectMenu } from './commands/fork.js';
 import { handleModelCommand, handleProviderSelectMenu, handleModelSelectMenu } from './commands/model.js';
+import { handleAgentCommand, handleAgentSelectMenu } from './commands/agent.js';
+import { handleAskQuestionSelectMenu } from './commands/ask-question.js';
 import { handleQueueCommand, handleClearQueueCommand } from './commands/queue.js';
 import { handleUndoCommand, handleRedoCommand } from './commands/undo-redo.js';
+import { handleUserCommand } from './commands/user-command.js';
 import { createLogger } from './logger.js';
 const interactionLogger = createLogger('INTERACTION');
 export function registerInteractionHandler({ discordClient, appId, }) {
@@ -63,6 +66,7 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                         await handleRejectCommand({ command: interaction, appId });
                         return;
                     case 'abort':
+                    case 'stop':
                         await handleAbortCommand({ command: interaction, appId });
                         return;
                     case 'share':
@@ -74,6 +78,9 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'model':
                         await handleModelCommand({ interaction, appId });
                         return;
+                    case 'agent':
+                        await handleAgentCommand({ interaction, appId });
+                        return;
                     case 'queue':
                         await handleQueueCommand({ command: interaction, appId });
                         return;
@@ -87,6 +94,11 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                         await handleRedoCommand({ command: interaction, appId });
                         return;
                 }
+                // Handle user-defined commands (ending with -cmd suffix)
+                if (interaction.commandName.endsWith('-cmd')) {
+                    await handleUserCommand({ command: interaction, appId });
+                    return;
+                }
                 return;
             }
             if (interaction.isStringSelectMenu()) {
@@ -103,6 +115,14 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     await handleModelSelectMenu(interaction);
                     return;
                 }
+                if (customId.startsWith('agent_select:')) {
+                    await handleAgentSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('ask_question:')) {
+                    await handleAskQuestionSelectMenu(interaction);
+                    return;
+                }
                 return;
             }
         }

package/dist/logger.js

@@ -2,12 +2,50 @@
 // Creates loggers with consistent prefixes for different subsystems
 // (DISCORD, VOICE, SESSION, etc.) for easier debugging.
 import { log } from '@clack/prompts';
+import fs from 'node:fs';
+import path, { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const isDev = !__dirname.includes('node_modules');
+const logFilePath = path.join(__dirname, '..', 'tmp', 'kimaki.log');
+// reset log file on startup in dev mode
+if (isDev) {
+    const logDir = path.dirname(logFilePath);
+    if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+    }
+    fs.writeFileSync(logFilePath, `--- kimaki log started at ${new Date().toISOString()} ---\n`);
+}
+function writeToFile(level, prefix, args) {
+    if (!isDev) {
+        return;
+    }
+    const timestamp = new Date().toISOString();
+    const message = `[${timestamp}] [${level}] [${prefix}] ${args.map((arg) => String(arg)).join(' ')}\n`;
+    fs.appendFileSync(logFilePath, message);
+}
 export function createLogger(prefix) {
     return {
-        log: (...args) => log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
-        error: (...args) => log.error([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
-        warn: (...args) => log.warn([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
-        info: (...args) => log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
-        debug: (...args) => log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
+        log: (...args) => {
+            writeToFile('INFO', prefix, args);
+            log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '));
+        },
+        error: (...args) => {
+            writeToFile('ERROR', prefix, args);
+            log.error([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '));
+        },
+        warn: (...args) => {
+            writeToFile('WARN', prefix, args);
+            log.warn([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '));
+        },
+        info: (...args) => {
+            writeToFile('INFO', prefix, args);
+            log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '));
+        },
+        debug: (...args) => {
+            writeToFile('DEBUG', prefix, args);
+            log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '));
+        },
     };
 }