kimaki 0.4.25 → 0.4.27

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/permissions.js

@@ -1,126 +1,122 @@
-// Permission commands - /accept, /accept-always, /reject
-import { ChannelType } from 'discord.js';
+// Permission dropdown handler - Shows dropdown for permission requests.
+// When OpenCode asks for permission, this module renders a dropdown
+// with Accept, Accept Always, and Deny options.
+import { StringSelectMenuBuilder, StringSelectMenuInteraction, ActionRowBuilder, } from 'discord.js';
+import crypto from 'node:crypto';
 import { initializeOpencodeForDirectory } from '../opencode.js';
-import { pendingPermissions } from '../session-handler.js';
-import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js';
 import { createLogger } from '../logger.js';
 const logger = createLogger('PERMISSIONS');
-export async function handleAcceptCommand({ command, }) {
-    const scope = command.commandName === 'accept-always' ? 'always' : 'once';
-    const channel = command.channel;
-    if (!channel) {
-        await command.reply({
-            content: 'This command can only be used in a channel',
-            ephemeral: true,
-            flags: SILENT_MESSAGE_FLAGS,
-        });
-        return;
-    }
-    const isThread = [
-        ChannelType.PublicThread,
-        ChannelType.PrivateThread,
-        ChannelType.AnnouncementThread,
-    ].includes(channel.type);
-    if (!isThread) {
-        await command.reply({
-            content: 'This command can only be used in a thread with an active session',
-            ephemeral: true,
-            flags: SILENT_MESSAGE_FLAGS,
-        });
-        return;
-    }
-    const pending = pendingPermissions.get(channel.id);
-    if (!pending) {
-        await command.reply({
-            content: 'No pending permission request in this thread',
-            ephemeral: true,
-            flags: SILENT_MESSAGE_FLAGS,
-        });
-        return;
-    }
-    try {
-        const getClient = await initializeOpencodeForDirectory(pending.directory);
-        await getClient().postSessionIdPermissionsPermissionId({
-            path: {
-                id: pending.permission.sessionID,
-                permissionID: pending.permission.id,
-            },
-            body: {
-                response: scope,
-            },
-        });
-        pendingPermissions.delete(channel.id);
-        const msg = scope === 'always'
-            ? `✅ Permission **accepted** (auto-approve similar requests)`
-            : `✅ Permission **accepted**`;
-        await command.reply({ content: msg, flags: SILENT_MESSAGE_FLAGS });
-        logger.log(`Permission ${pending.permission.id} accepted with scope: ${scope}`);
-    }
-    catch (error) {
-        logger.error('[ACCEPT] Error:', error);
-        await command.reply({
-            content: `Failed to accept permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
-            ephemeral: true,
-            flags: SILENT_MESSAGE_FLAGS,
-        });
-    }
+// Store pending permission contexts by hash
+export const pendingPermissionContexts = new Map();
+/**
+ * Show permission dropdown for a permission request.
+ * Returns the message ID and context hash for tracking.
+ */
+export async function showPermissionDropdown({ thread, permission, directory, }) {
+    const contextHash = crypto.randomBytes(8).toString('hex');
+    const context = {
+        permission,
+        directory,
+        thread,
+        contextHash,
+    };
+    pendingPermissionContexts.set(contextHash, context);
+    const patternStr = permission.patterns.join(', ');
+    // Build dropdown options
+    const options = [
+        {
+            label: 'Accept',
+            value: 'once',
+            description: 'Allow this request only',
+        },
+        {
+            label: 'Accept Always',
+            value: 'always',
+            description: 'Auto-approve similar requests',
+        },
+        {
+            label: 'Deny',
+            value: 'reject',
+            description: 'Reject this permission request',
+        },
+    ];
+    const selectMenu = new StringSelectMenuBuilder()
+        .setCustomId(`permission:${contextHash}`)
+        .setPlaceholder('Choose an action')
+        .addOptions(options);
+    const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+    const permissionMessage = await thread.send({
+        content: `⚠️ **Permission Required**\n\n` +
+            `**Type:** \`${permission.permission}\`\n` +
+            (patternStr ? `**Pattern:** \`${patternStr}\`` : ''),
+        components: [actionRow],
+        flags: NOTIFY_MESSAGE_FLAGS,
+    });
+    logger.log(`Showed permission dropdown for ${permission.id}`);
+    return { messageId: permissionMessage.id, contextHash };
 }
-export async function handleRejectCommand({ command, }) {
-    const channel = command.channel;
-    if (!channel) {
-        await command.reply({
-            content: 'This command can only be used in a channel',
-            ephemeral: true,
-            flags: SILENT_MESSAGE_FLAGS,
-        });
-        return;
-    }
-    const isThread = [
-        ChannelType.PublicThread,
-        ChannelType.PrivateThread,
-        ChannelType.AnnouncementThread,
-    ].includes(channel.type);
-    if (!isThread) {
-        await command.reply({
-            content: 'This command can only be used in a thread with an active session',
-            ephemeral: true,
-            flags: SILENT_MESSAGE_FLAGS,
-        });
+/**
+ * Handle dropdown selection for permission.
+ */
+export async function handlePermissionSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('permission:')) {
         return;
     }
-    const pending = pendingPermissions.get(channel.id);
-    if (!pending) {
-        await command.reply({
-            content: 'No pending permission request in this thread',
+    const contextHash = customId.replace('permission:', '');
+    const context = pendingPermissionContexts.get(contextHash);
+    if (!context) {
+        await interaction.reply({
+            content: 'This permission request has expired or was already handled.',
             ephemeral: true,
-            flags: SILENT_MESSAGE_FLAGS,
         });
         return;
     }
+    await interaction.deferUpdate();
+    const response = interaction.values[0];
     try {
-        const getClient = await initializeOpencodeForDirectory(pending.directory);
+        const getClient = await initializeOpencodeForDirectory(context.directory);
         await getClient().postSessionIdPermissionsPermissionId({
             path: {
-                id: pending.permission.sessionID,
-                permissionID: pending.permission.id,
-            },
-            body: {
-                response: 'reject',
+                id: context.permission.sessionID,
+                permissionID: context.permission.id,
             },
+            body: { response },
         });
-        pendingPermissions.delete(channel.id);
-        await command.reply({
-            content: `❌ Permission **rejected**`,
-            flags: SILENT_MESSAGE_FLAGS,
+        pendingPermissionContexts.delete(contextHash);
+        // Update message: show result and remove dropdown
+        const resultText = (() => {
+            switch (response) {
+                case 'once':
+                    return '✅ Permission **accepted**';
+                case 'always':
+                    return '✅ Permission **accepted** (auto-approve similar requests)';
+                case 'reject':
+                    return '❌ Permission **rejected**';
+            }
+        })();
+        const patternStr = context.permission.patterns.join(', ');
+        await interaction.editReply({
+            content: `⚠️ **Permission Required**\n\n` +
+                `**Type:** \`${context.permission.permission}\`\n` +
+                (patternStr ? `**Pattern:** \`${patternStr}\`\n\n` : '\n') +
+                resultText,
+            components: [], // Remove the dropdown
         });
-        logger.log(`Permission ${pending.permission.id} rejected`);
+        logger.log(`Permission ${context.permission.id} ${response}`);
     }
     catch (error) {
-        logger.error('[REJECT] Error:', error);
-        await command.reply({
-            content: `Failed to reject permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
-            ephemeral: true,
-            flags: SILENT_MESSAGE_FLAGS,
+        logger.error('Error handling permission:', error);
+        await interaction.editReply({
+            content: `Failed to process permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            components: [],
         });
     }
 }
+/**
+ * Clean up a pending permission context (e.g., on auto-reject).
+ */
+export function cleanupPermissionContext(contextHash) {
+    pendingPermissionContexts.delete(contextHash);
+}

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,
                 });
             }