@brianli/kimaki 0.4.72-brianli.1

package/dist/commands/agent.js

@@ -0,0 +1,291 @@
+// /agent command - Set the preferred agent for this channel or session.
+// Also provides quick agent commands like /plan-agent, /build-agent that switch instantly.
+import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, MessageFlags, } from 'discord.js';
+import crypto from 'node:crypto';
+import { setChannelAgent, setSessionAgent, clearSessionModel, getThreadSession, getSessionAgent, getChannelAgent, } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const agentLogger = createLogger(LogPrefix.AGENT);
+const pendingAgentContexts = new Map();
+/**
+ * Get the current agent info for a channel/session, including where it comes from.
+ * Priority: session > channel > none
+ */
+export async function getCurrentAgentInfo({ sessionId, channelId, }) {
+    if (sessionId) {
+        const sessionAgent = await getSessionAgent(sessionId);
+        if (sessionAgent) {
+            return { type: 'session', agent: sessionAgent };
+        }
+    }
+    if (channelId) {
+        const channelAgent = await getChannelAgent(channelId);
+        if (channelAgent) {
+            return { type: 'channel', agent: channelAgent };
+        }
+    }
+    return { type: 'none' };
+}
+/**
+ * Sanitize an agent name to be a valid Discord command name component.
+ * Lowercase, alphanumeric and hyphens only.
+ */
+export function sanitizeAgentName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+/**
+ * Resolve the context for an agent command (directory, channel, session).
+ * Returns null if the command cannot be executed in this context.
+ */
+export async function resolveAgentCommandContext({ interaction, appId, }) {
+    const channel = interaction.channel;
+    if (!channel) {
+        await interaction.editReply({
+            content: 'This command can only be used in a channel',
+        });
+        return null;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    let projectDirectory;
+    let channelAppId;
+    let targetChannelId;
+    let sessionId;
+    if (isThread) {
+        const thread = channel;
+        const textChannel = await resolveTextChannel(thread);
+        const metadata = await getKimakiMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        channelAppId = metadata.channelAppId;
+        targetChannelId = textChannel?.id || channel.id;
+        sessionId = await getThreadSession(thread.id);
+    }
+    else if (channel.type === ChannelType.GuildText) {
+        const textChannel = channel;
+        const metadata = await getKimakiMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        channelAppId = metadata.channelAppId;
+        targetChannelId = channel.id;
+    }
+    else {
+        await interaction.editReply({
+            content: 'This command can only be used in text channels or threads',
+        });
+        return null;
+    }
+    if (channelAppId && channelAppId !== appId) {
+        await interaction.editReply({
+            content: 'This channel is not configured for this bot',
+        });
+        return null;
+    }
+    if (!projectDirectory) {
+        await interaction.editReply({
+            content: 'This channel is not configured with a project directory',
+        });
+        return null;
+    }
+    return {
+        dir: projectDirectory,
+        channelId: targetChannelId,
+        sessionId,
+        isThread,
+    };
+}
+/**
+ * Set the agent preference for a context (session or channel).
+ * When switching agents for a session, clears session model preference
+ * so the new agent's model takes effect (agent model > channel model).
+ */
+export async function setAgentForContext({ context, agentName, }) {
+    if (context.isThread && context.sessionId) {
+        await setSessionAgent(context.sessionId, agentName);
+        // Clear session model so the new agent's model takes effect
+        await clearSessionModel(context.sessionId);
+        agentLogger.log(`Set agent ${agentName} for session ${context.sessionId} (cleared session model)`);
+    }
+    else {
+        await setChannelAgent(context.channelId, agentName);
+        agentLogger.log(`Set agent ${agentName} for channel ${context.channelId}`);
+    }
+}
+export async function handleAgentCommand({ interaction, appId, }) {
+    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+    const context = await resolveAgentCommandContext({ interaction, appId });
+    if (!context) {
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(context.dir);
+        if (getClient instanceof Error) {
+            await interaction.editReply({ content: getClient.message });
+            return;
+        }
+        const agentsResponse = await getClient().app.agents({
+            directory: context.dir,
+        });
+        if (!agentsResponse.data || agentsResponse.data.length === 0) {
+            await interaction.editReply({ content: 'No agents available' });
+            return;
+        }
+        const agents = agentsResponse.data
+            .filter((agent) => {
+            const hidden = agent.hidden;
+            return (agent.mode === 'primary' || agent.mode === 'all') && !hidden;
+        })
+            .slice(0, 25);
+        if (agents.length === 0) {
+            await interaction.editReply({ content: 'No primary agents available' });
+            return;
+        }
+        const currentAgentInfo = await getCurrentAgentInfo({
+            sessionId: context.sessionId,
+            channelId: context.channelId,
+        });
+        const currentAgentText = (() => {
+            switch (currentAgentInfo.type) {
+                case 'session':
+                    return `**Current (session override):** \`${currentAgentInfo.agent}\``;
+                case 'channel':
+                    return `**Current (channel override):** \`${currentAgentInfo.agent}\``;
+                case 'none':
+                    return '**Current:** none';
+            }
+        })();
+        const contextHash = crypto.randomBytes(8).toString('hex');
+        pendingAgentContexts.set(contextHash, context);
+        const options = agents.map((agent) => ({
+            label: agent.name.slice(0, 100),
+            value: agent.name,
+            description: (agent.description || `${agent.mode} agent`).slice(0, 100),
+        }));
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`agent_select:${contextHash}`)
+            .setPlaceholder('Select an agent')
+            .addOptions(options);
+        const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+        await interaction.editReply({
+            content: `**Set Agent Preference**\n${currentAgentText}\nSelect an agent:`,
+            components: [actionRow],
+        });
+    }
+    catch (error) {
+        agentLogger.error('Error loading agents:', error);
+        await interaction.editReply({
+            content: `Failed to load agents: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}
+export async function handleAgentSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('agent_select:')) {
+        return;
+    }
+    await interaction.deferUpdate();
+    const contextHash = customId.replace('agent_select:', '');
+    const context = pendingAgentContexts.get(contextHash);
+    if (!context) {
+        await interaction.editReply({
+            content: 'Selection expired. Please run /agent again.',
+            components: [],
+        });
+        return;
+    }
+    const selectedAgent = interaction.values[0];
+    if (!selectedAgent) {
+        await interaction.editReply({
+            content: 'No agent selected',
+            components: [],
+        });
+        return;
+    }
+    try {
+        await setAgentForContext({ context, agentName: selectedAgent });
+        if (context.isThread && context.sessionId) {
+            await interaction.editReply({
+                content: `Agent preference set for this session: **${selectedAgent}**`,
+                components: [],
+            });
+        }
+        else {
+            await interaction.editReply({
+                content: `Agent preference set for this channel: **${selectedAgent}**\nAll new sessions in this channel will use this agent.`,
+                components: [],
+            });
+        }
+        pendingAgentContexts.delete(contextHash);
+    }
+    catch (error) {
+        agentLogger.error('Error saving agent preference:', error);
+        await interaction.editReply({
+            content: `Failed to save agent preference: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            components: [],
+        });
+    }
+}
+/**
+ * Handle quick agent commands like /plan-agent, /build-agent.
+ * These instantly switch to the specified agent without showing a dropdown.
+ *
+ * Optimized for speed: skips opencode server entirely.
+ * The agent name is already validated at command registration time (cli.ts registers
+ * commands from the agents list), so we trust the command name directly instead of
+ * calling initializeOpencodeForDirectory + app.agents() to re-validate.
+ * This eliminates two HTTP round-trips (~400-1000ms) that the old implementation had.
+ */
+export async function handleQuickAgentCommand({ command, appId, }) {
+    // Extract agent name from command: "plan-agent" → "plan"
+    const sanitizedAgentName = command.commandName.replace(/-agent$/, '');
+    await command.deferReply({ flags: MessageFlags.Ephemeral });
+    const context = await resolveAgentCommandContext({
+        interaction: command,
+        appId,
+    });
+    if (!context) {
+        return;
+    }
+    try {
+        // Check current agent and set new one.
+        // getCurrentAgentInfo is fast (DB only), use it for the "was X" text.
+        const previousAgent = await getCurrentAgentInfo({
+            sessionId: context.sessionId,
+            channelId: context.channelId,
+        });
+        const previousAgentName = previousAgent.type !== 'none' ? previousAgent.agent : undefined;
+        if (previousAgentName === sanitizedAgentName) {
+            await command.editReply({
+                content: `Already using **${sanitizedAgentName}** agent`,
+            });
+            return;
+        }
+        // Set the agent preference (DB write only, no HTTP calls)
+        await setAgentForContext({ context, agentName: sanitizedAgentName });
+        const previousText = previousAgentName
+            ? ` (was **${previousAgentName}**)`
+            : '';
+        if (context.isThread && context.sessionId) {
+            await command.editReply({
+                content: `Switched to **${sanitizedAgentName}** agent for this session${previousText}`,
+            });
+        }
+        else {
+            await command.editReply({
+                content: `Switched to **${sanitizedAgentName}** agent for this channel${previousText}\nAll new sessions will use this agent.`,
+            });
+        }
+    }
+    catch (error) {
+        agentLogger.error('Error in quick agent command:', error);
+        await command.editReply({
+            content: `Failed to switch agent: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}

package/dist/commands/ask-question.js

@@ -0,0 +1,223 @@
+// AskUserQuestion tool handler - Shows Discord dropdowns for AI questions.
+// When the AI uses the AskUserQuestion tool, this module renders dropdowns
+// for each question and collects user responses.
+import { StringSelectMenuBuilder, StringSelectMenuInteraction, ActionRowBuilder, MessageFlags, } from 'discord.js';
+import crypto from 'node:crypto';
+import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js';
+import { getOpencodeClient } from '../opencode.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.ASK_QUESTION);
+// Store pending question contexts by hash
+export const pendingQuestionContexts = new Map();
+/**
+ * Show dropdown menus for question tool input.
+ * Sends one message per question with the dropdown directly under the question text.
+ */
+export async function showAskUserQuestionDropdowns({ thread, sessionId, directory, requestId, input, }) {
+    const contextHash = crypto.randomBytes(8).toString('hex');
+    const context = {
+        sessionId,
+        directory,
+        thread,
+        requestId,
+        questions: input.questions,
+        answers: {},
+        totalQuestions: input.questions.length,
+        answeredCount: 0,
+        contextHash,
+    };
+    pendingQuestionContexts.set(contextHash, context);
+    // Send one message per question with its dropdown directly underneath
+    for (let i = 0; i < input.questions.length; i++) {
+        const q = input.questions[i];
+        // Map options to Discord select menu options
+        // Discord max: 25 options per select menu
+        const options = [
+            ...q.options.slice(0, 24).map((opt, optIdx) => ({
+                label: opt.label.slice(0, 100),
+                value: `${optIdx}`,
+                description: opt.description.slice(0, 100),
+            })),
+            {
+                label: 'Other',
+                value: 'other',
+                description: 'Provide a custom answer in chat',
+            },
+        ];
+        const placeholder = options.find((x) => x.label)?.label || 'Select an option';
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`ask_question:${contextHash}:${i}`)
+            .setPlaceholder(placeholder)
+            .addOptions(options);
+        // Enable multi-select if the question supports it
+        if (q.multiple) {
+            selectMenu.setMinValues(1);
+            selectMenu.setMaxValues(options.length);
+        }
+        const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+        await thread.send({
+            content: `**${(q.header || '').slice(0, 200)}**\n${q.question.slice(0, 1700)}`,
+            components: [actionRow],
+            flags: NOTIFY_MESSAGE_FLAGS,
+        });
+    }
+    logger.log(`Showed ${input.questions.length} question dropdown(s) for session ${sessionId}`);
+}
+/**
+ * Handle dropdown selection for AskUserQuestion.
+ */
+export async function handleAskQuestionSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('ask_question:')) {
+        return;
+    }
+    const parts = customId.split(':');
+    const contextHash = parts[1];
+    const questionIndex = parseInt(parts[2], 10);
+    if (!contextHash) {
+        await interaction.reply({
+            content: 'Invalid selection.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const context = pendingQuestionContexts.get(contextHash);
+    if (!context) {
+        await interaction.reply({
+            content: 'This question has expired. Please ask the AI again.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    await interaction.deferUpdate();
+    const selectedValues = interaction.values;
+    const question = context.questions[questionIndex];
+    if (!question) {
+        logger.error(`Question index ${questionIndex} not found in context`);
+        return;
+    }
+    // Check if "other" was selected
+    if (selectedValues.includes('other')) {
+        // User wants to provide custom answer
+        // For now, mark as "Other" - they can type in chat
+        context.answers[questionIndex] = ['Other (please type your answer in chat)'];
+    }
+    else {
+        // Map value indices back to option labels
+        context.answers[questionIndex] = selectedValues.map((v) => {
+            const optIdx = parseInt(v, 10);
+            return question.options[optIdx]?.label || `Option ${optIdx + 1}`;
+        });
+    }
+    context.answeredCount++;
+    // Update this question's message: show answer and remove dropdown
+    const answeredText = context.answers[questionIndex].join(', ');
+    await interaction.editReply({
+        content: `**${question.header}**\n${question.question}\n✓ _${answeredText}_`,
+        components: [], // Remove the dropdown
+    });
+    // Check if all questions are answered
+    if (context.answeredCount >= context.totalQuestions) {
+        // All questions answered - send result back to session
+        await submitQuestionAnswers(context);
+        pendingQuestionContexts.delete(contextHash);
+    }
+}
+/**
+ * Submit all collected answers back to the OpenCode session.
+ * Uses the question.reply API to provide answers to the waiting tool.
+ */
+async function submitQuestionAnswers(context) {
+    try {
+        const client = getOpencodeClient(context.directory);
+        if (!client) {
+            throw new Error('OpenCode server not found for directory');
+        }
+        // Build answers array: each element is an array of selected labels for that question
+        const answers = context.questions.map((_, i) => {
+            return context.answers[i] || [];
+        });
+        await client.question.reply({
+            requestID: context.requestId,
+            directory: context.directory,
+            answers,
+        });
+        logger.log(`Submitted answers for question ${context.requestId} in session ${context.sessionId}`);
+    }
+    catch (error) {
+        logger.error('Failed to submit answers:', error);
+        await sendThreadMessage(context.thread, `✗ Failed to submit answers: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Check if a tool part is an AskUserQuestion tool.
+ * Returns the parsed input if valid, null otherwise.
+ */
+export function parseAskUserQuestionTool(part) {
+    if (part.type !== 'tool') {
+        return null;
+    }
+    // Check for the tool name (case-insensitive)
+    const toolName = part.tool?.toLowerCase();
+    if (toolName !== 'question') {
+        return null;
+    }
+    const input = part.state?.input;
+    if (!input?.questions ||
+        !Array.isArray(input.questions) ||
+        input.questions.length === 0) {
+        return null;
+    }
+    // Validate structure
+    for (const q of input.questions) {
+        if (typeof q.question !== 'string' ||
+            typeof q.header !== 'string' ||
+            !Array.isArray(q.options) ||
+            q.options.length < 2) {
+            return null;
+        }
+    }
+    return input;
+}
+/**
+ * Cancel a pending question for a thread (e.g., when user sends a new message).
+ * Sends the user's message as the answer to OpenCode so the model sees their actual response.
+ */
+export async function cancelPendingQuestion(threadId, userMessage) {
+    // Find pending question for this thread
+    let contextHash;
+    let context;
+    for (const [hash, ctx] of pendingQuestionContexts) {
+        if (ctx.thread.id === threadId) {
+            contextHash = hash;
+            context = ctx;
+            break;
+        }
+    }
+    if (!contextHash || !context) {
+        return false;
+    }
+    try {
+        const client = getOpencodeClient(context.directory);
+        if (!client) {
+            throw new Error('OpenCode server not found for directory');
+        }
+        // Use user's message as answer if provided, otherwise mark as "Other"
+        const customAnswer = userMessage || 'Other';
+        const answers = context.questions.map((_, i) => {
+            return context.answers[i] || [customAnswer];
+        });
+        await client.question.reply({
+            requestID: context.requestId,
+            directory: context.directory,
+            answers,
+        });
+        logger.log(`Answered question ${context.requestId} with user message`);
+    }
+    catch (error) {
+        logger.error('Failed to answer question:', error);
+    }
+    // Clean up regardless of whether the API call succeeded
+    pendingQuestionContexts.delete(contextHash);
+    return true;
+}

package/dist/commands/compact.js

@@ -0,0 +1,120 @@
+// /compact command - Trigger context compaction (summarization) for the current session.
+import { ChannelType, MessageFlags, } from 'discord.js';
+import { getThreadSession } from '../database.js';
+import { initializeOpencodeForDirectory, getOpencodeClient, } from '../opencode.js';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.COMPACT);
+export async function handleCompactCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | 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',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const { projectDirectory, workingDirectory } = resolved;
+    const sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    // Ensure server is running for the base project directory
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        await command.reply({
+            content: `Failed to compact: ${getClient.message}`,
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const client = getOpencodeClient(projectDirectory);
+    if (!client) {
+        await command.reply({
+            content: 'Failed to get OpenCode client',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    // Defer reply since compaction may take a moment
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    try {
+        // Get session messages to find the model from the last user message
+        const messagesResult = await client.session.messages({
+            sessionID: sessionId,
+            directory: workingDirectory,
+        });
+        if (messagesResult.error || !messagesResult.data) {
+            logger.error('[COMPACT] Failed to get messages:', messagesResult.error);
+            await command.editReply({
+                content: 'Failed to compact: Could not retrieve session messages',
+            });
+            return;
+        }
+        // Find the last user message to get the model
+        const lastUserMessage = [...messagesResult.data]
+            .reverse()
+            .find((msg) => msg.info.role === 'user');
+        if (!lastUserMessage || lastUserMessage.info.role !== 'user') {
+            await command.editReply({
+                content: 'Failed to compact: No user message found in session',
+            });
+            return;
+        }
+        const { providerID, modelID } = lastUserMessage.info.model;
+        const result = await client.session.summarize({
+            sessionID: sessionId,
+            directory: workingDirectory,
+            providerID,
+            modelID,
+            auto: false,
+        });
+        if (result.error) {
+            logger.error('[COMPACT] Error:', result.error);
+            const errorMessage = 'data' in result.error && result.error.data
+                ? result.error.data.message ||
+                    'Unknown error'
+                : 'Unknown error';
+            await command.editReply({
+                content: `Failed to compact: ${errorMessage}`,
+            });
+            return;
+        }
+        await command.editReply({
+            content: `📦 Session **compacted** successfully`,
+        });
+        logger.log(`Session ${sessionId} compacted by user`);
+    }
+    catch (error) {
+        logger.error('[COMPACT] Error:', error);
+        await command.editReply({
+            content: `Failed to compact: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}