kimaki 0.4.24 → 0.4.26

package/dist/commands/agent.js

@@ -0,0 +1,152 @@
+// /agent command - Set the preferred agent for this channel or session.
+import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, } from 'discord.js';
+import crypto from 'node:crypto';
+import { getDatabase, setChannelAgent, setSessionAgent, runModelMigrations } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
+import { createLogger } from '../logger.js';
+const agentLogger = createLogger('AGENT');
+const pendingAgentContexts = new Map();
+export async function handleAgentCommand({ interaction, appId, }) {
+    await interaction.deferReply({ ephemeral: true });
+    runModelMigrations();
+    const channel = interaction.channel;
+    if (!channel) {
+        await interaction.editReply({ content: 'This command can only be used in a channel' });
+        return;
+    }
+    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 = getKimakiMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        channelAppId = metadata.channelAppId;
+        targetChannelId = textChannel?.id || channel.id;
+        const row = getDatabase()
+            .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+            .get(thread.id);
+        sessionId = row?.session_id;
+    }
+    else if (channel.type === ChannelType.GuildText) {
+        const textChannel = channel;
+        const metadata = 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;
+    }
+    if (channelAppId && channelAppId !== appId) {
+        await interaction.editReply({ content: 'This channel is not configured for this bot' });
+        return;
+    }
+    if (!projectDirectory) {
+        await interaction.editReply({ content: 'This channel is not configured with a project directory' });
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        const agentsResponse = await getClient().app.agents({
+            query: { directory: projectDirectory },
+        });
+        if (!agentsResponse.data || agentsResponse.data.length === 0) {
+            await interaction.editReply({ content: 'No agents available' });
+            return;
+        }
+        const agents = agentsResponse.data
+            .filter((a) => a.mode === 'primary' || a.mode === 'all')
+            .slice(0, 25);
+        if (agents.length === 0) {
+            await interaction.editReply({ content: 'No primary agents available' });
+            return;
+        }
+        const contextHash = crypto.randomBytes(8).toString('hex');
+        pendingAgentContexts.set(contextHash, {
+            dir: projectDirectory,
+            channelId: targetChannelId,
+            sessionId,
+            isThread,
+        });
+        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**\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 {
+        if (context.isThread && context.sessionId) {
+            setSessionAgent(context.sessionId, selectedAgent);
+            agentLogger.log(`Set agent ${selectedAgent} for session ${context.sessionId}`);
+            await interaction.editReply({
+                content: `Agent preference set for this session: **${selectedAgent}**`,
+                components: [],
+            });
+        }
+        else {
+            setChannelAgent(context.channelId, selectedAgent);
+            agentLogger.log(`Set agent ${selectedAgent} for channel ${context.channelId}`);
+            await interaction.editReply({
+                content: `Agent preference set for this channel: **${selectedAgent}**\n\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: [],
+        });
+    }
+}

package/dist/commands/ask-question.js

@@ -0,0 +1,183 @@
+// 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, } from 'discord.js';
+import crypto from 'node:crypto';
+import { sendThreadMessage } from '../discord-utils.js';
+import { getOpencodeServerPort } from '../opencode.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('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 selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`ask_question:${contextHash}:${i}`)
+            .setPlaceholder(`Select an option`)
+            .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}**\n${q.question}`,
+            components: [actionRow],
+        });
+    }
+    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.',
+            ephemeral: true,
+        });
+        return;
+    }
+    const context = pendingQuestionContexts.get(contextHash);
+    if (!context) {
+        await interaction.reply({
+            content: 'This question has expired. Please ask the AI again.',
+            ephemeral: true,
+        });
+        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 {
+        // Build answers array: each element is an array of selected labels for that question
+        const answersPayload = context.questions.map((_, i) => {
+            return context.answers[i] || [];
+        });
+        // Reply to the question using direct HTTP call to OpenCode API
+        // (v1 SDK doesn't have question.reply, so we call it directly)
+        const port = getOpencodeServerPort(context.directory);
+        if (!port) {
+            throw new Error('OpenCode server not found for directory');
+        }
+        const response = await fetch(`http://127.0.0.1:${port}/question/${context.requestId}/reply`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ answers: answersPayload }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Failed to reply to question: ${response.status} ${text}`);
+        }
+        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;
+}

package/dist/commands/create-new-project.js

@@ -0,0 +1,78 @@
+// /create-new-project command - Create a new project folder, initialize git, and start a session.
+import { ChannelType } from 'discord.js';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createProjectChannels } from '../channel-management.js';
+import { handleOpencodeSession } from '../session-handler.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('CREATE-NEW-PROJECT');
+export async function handleCreateNewProjectCommand({ command, appId, }) {
+    await command.deferReply({ ephemeral: false });
+    const projectName = command.options.getString('name', true);
+    const guild = command.guild;
+    const channel = command.channel;
+    if (!guild) {
+        await command.editReply('This command can only be used in a guild');
+        return;
+    }
+    if (!channel || channel.type !== ChannelType.GuildText) {
+        await command.editReply('This command can only be used in a text channel');
+        return;
+    }
+    const sanitizedName = projectName
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 100);
+    if (!sanitizedName) {
+        await command.editReply('Invalid project name');
+        return;
+    }
+    const kimakiDir = path.join(os.homedir(), 'kimaki');
+    const projectDirectory = path.join(kimakiDir, sanitizedName);
+    try {
+        if (!fs.existsSync(kimakiDir)) {
+            fs.mkdirSync(kimakiDir, { recursive: true });
+            logger.log(`Created kimaki directory: ${kimakiDir}`);
+        }
+        if (fs.existsSync(projectDirectory)) {
+            await command.editReply(`Project directory already exists: ${projectDirectory}`);
+            return;
+        }
+        fs.mkdirSync(projectDirectory, { recursive: true });
+        logger.log(`Created project directory: ${projectDirectory}`);
+        const { execSync } = await import('node:child_process');
+        execSync('git init', { cwd: projectDirectory, stdio: 'pipe' });
+        logger.log(`Initialized git in: ${projectDirectory}`);
+        const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+            guild,
+            projectDirectory,
+            appId,
+        });
+        const textChannel = (await guild.channels.fetch(textChannelId));
+        await command.editReply(`✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n\n_Starting session..._`);
+        const starterMessage = await textChannel.send({
+            content: `🚀 **New project initialized**\n📁 \`${projectDirectory}\``,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        const thread = await starterMessage.startThread({
+            name: `Init: ${sanitizedName}`,
+            autoArchiveDuration: 1440,
+            reason: 'New project session',
+        });
+        await handleOpencodeSession({
+            prompt: 'The project was just initialized. Say hi and ask what the user wants to build.',
+            thread,
+            projectDirectory,
+            channelId: textChannel.id,
+        });
+        logger.log(`Created new project ${channelName} at ${projectDirectory}`);
+    }
+    catch (error) {
+        logger.error('[CREATE-NEW-PROJECT] Error:', error);
+        await command.editReply(`Failed to create new project: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/commands/fork.js

@@ -0,0 +1,186 @@
+// /fork command - Fork the session from a past user message.
+import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, ThreadAutoArchiveDuration, } from 'discord.js';
+import { getDatabase } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getKimakiMetadata, sendThreadMessage } from '../discord-utils.js';
+import { collectLastAssistantParts } from '../message-formatting.js';
+import { createLogger } from '../logger.js';
+const sessionLogger = createLogger('SESSION');
+const forkLogger = createLogger('FORK');
+export async function handleForkCommand(interaction) {
+    const channel = interaction.channel;
+    if (!channel) {
+        await interaction.reply({
+            content: 'This command can only be used in a channel',
+            ephemeral: true,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await interaction.reply({
+            content: 'This command can only be used in a thread with an active session',
+            ephemeral: true,
+        });
+        return;
+    }
+    const textChannel = await resolveTextChannel(channel);
+    const { projectDirectory: directory } = getKimakiMetadata(textChannel);
+    if (!directory) {
+        await interaction.reply({
+            content: 'Could not determine project directory for this channel',
+            ephemeral: true,
+        });
+        return;
+    }
+    const row = getDatabase()
+        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+        .get(channel.id);
+    if (!row?.session_id) {
+        await interaction.reply({
+            content: 'No active session in this thread',
+            ephemeral: true,
+        });
+        return;
+    }
+    // Defer reply before API calls to avoid 3-second timeout
+    await interaction.deferReply({ ephemeral: true });
+    const sessionId = row.session_id;
+    try {
+        const getClient = await initializeOpencodeForDirectory(directory);
+        const messagesResponse = await getClient().session.messages({
+            path: { id: sessionId },
+        });
+        if (!messagesResponse.data) {
+            await interaction.editReply({
+                content: 'Failed to fetch session messages',
+            });
+            return;
+        }
+        const userMessages = messagesResponse.data.filter((m) => m.info.role === 'user');
+        if (userMessages.length === 0) {
+            await interaction.editReply({
+                content: 'No user messages found in this session',
+            });
+            return;
+        }
+        const recentMessages = userMessages.slice(-25);
+        const options = recentMessages.map((m, index) => {
+            const textPart = m.parts.find((p) => p.type === 'text');
+            const preview = textPart?.text?.slice(0, 80) || '(no text)';
+            const label = `${index + 1}. ${preview}${preview.length >= 80 ? '...' : ''}`;
+            return {
+                label: label.slice(0, 100),
+                value: m.info.id,
+                description: new Date(m.info.time.created).toLocaleString().slice(0, 50),
+            };
+        });
+        const encodedDir = Buffer.from(directory).toString('base64');
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`fork_select:${sessionId}:${encodedDir}`)
+            .setPlaceholder('Select a message to fork from')
+            .addOptions(options);
+        const actionRow = new ActionRowBuilder()
+            .addComponents(selectMenu);
+        await interaction.editReply({
+            content: '**Fork Session**\nSelect the user message to fork from. The forked session will continue as if you had not sent that message:',
+            components: [actionRow],
+        });
+    }
+    catch (error) {
+        forkLogger.error('Error loading messages:', error);
+        await interaction.editReply({
+            content: `Failed to load messages: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}
+export async function handleForkSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('fork_select:')) {
+        return;
+    }
+    const [, sessionId, encodedDir] = customId.split(':');
+    if (!sessionId || !encodedDir) {
+        await interaction.reply({
+            content: 'Invalid selection data',
+            ephemeral: true,
+        });
+        return;
+    }
+    const directory = Buffer.from(encodedDir, 'base64').toString('utf-8');
+    const selectedMessageId = interaction.values[0];
+    if (!selectedMessageId) {
+        await interaction.reply({
+            content: 'No message selected',
+            ephemeral: true,
+        });
+        return;
+    }
+    await interaction.deferReply({ ephemeral: false });
+    try {
+        const getClient = await initializeOpencodeForDirectory(directory);
+        const forkResponse = await getClient().session.fork({
+            path: { id: sessionId },
+            body: { messageID: selectedMessageId },
+        });
+        if (!forkResponse.data) {
+            await interaction.editReply('Failed to fork session');
+            return;
+        }
+        const forkedSession = forkResponse.data;
+        const parentChannel = interaction.channel;
+        if (!parentChannel || ![
+            ChannelType.PublicThread,
+            ChannelType.PrivateThread,
+            ChannelType.AnnouncementThread,
+        ].includes(parentChannel.type)) {
+            await interaction.editReply('Could not access parent channel');
+            return;
+        }
+        const textChannel = await resolveTextChannel(parentChannel);
+        if (!textChannel) {
+            await interaction.editReply('Could not resolve parent text channel');
+            return;
+        }
+        const thread = await textChannel.threads.create({
+            name: `Fork: ${forkedSession.title}`.slice(0, 100),
+            autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+            reason: `Forked from session ${sessionId}`,
+        });
+        getDatabase()
+            .prepare('INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)')
+            .run(thread.id, forkedSession.id);
+        sessionLogger.log(`Created forked session ${forkedSession.id} in thread ${thread.id}`);
+        await sendThreadMessage(thread, `**Forked session created!**\nFrom: \`${sessionId}\`\nNew session: \`${forkedSession.id}\``);
+        // Fetch and display the last assistant messages from the forked session
+        const messagesResponse = await getClient().session.messages({
+            path: { id: forkedSession.id },
+        });
+        if (messagesResponse.data) {
+            const { partIds, content } = collectLastAssistantParts({
+                messages: messagesResponse.data,
+            });
+            if (content.trim()) {
+                const discordMessage = await sendThreadMessage(thread, content);
+                // Store part-message mappings for future reference
+                const stmt = getDatabase().prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)');
+                const transaction = getDatabase().transaction((ids) => {
+                    for (const partId of ids) {
+                        stmt.run(partId, discordMessage.id, thread.id);
+                    }
+                });
+                transaction(partIds);
+            }
+        }
+        await sendThreadMessage(thread, `You can now continue the conversation from this point.`);
+        await interaction.editReply(`Session forked! Continue in ${thread.toString()}`);
+    }
+    catch (error) {
+        forkLogger.error('Error forking session:', error);
+        await interaction.editReply(`Failed to fork session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}