shuvmaki 0.4.26

package/dist/commands/abort.js

@@ -0,0 +1,78 @@
+// /abort command - Abort the current OpenCode request in this thread.
+import { ChannelType } from 'discord.js';
+import { getDatabase } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { abortControllers } from '../session-handler.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('ABORT');
+export async function handleAbortCommand({ 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,
+        });
+        return;
+    }
+    const textChannel = await resolveTextChannel(channel);
+    const { projectDirectory: directory } = getKimakiMetadata(textChannel);
+    if (!directory) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const row = getDatabase()
+        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+        .get(channel.id);
+    if (!row?.session_id) {
+        await command.reply({
+            content: 'No active session in this thread',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const sessionId = row.session_id;
+    try {
+        const existingController = abortControllers.get(sessionId);
+        if (existingController) {
+            existingController.abort(new Error('User requested abort'));
+            abortControllers.delete(sessionId);
+        }
+        const getClient = await initializeOpencodeForDirectory(directory);
+        await getClient().session.abort({
+            path: { id: sessionId },
+        });
+        await command.reply({
+            content: `🛑 Request **aborted**`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        logger.log(`Session ${sessionId} aborted by user`);
+    }
+    catch (error) {
+        logger.error('[ABORT] Error:', error);
+        await command.reply({
+            content: `Failed to abort: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+    }
+}

package/dist/commands/add-project.js

@@ -0,0 +1,98 @@
+// /add-project command - Create Discord channels for an existing OpenCode project.
+import fs from 'node:fs';
+import path from 'node:path';
+import { getDatabase } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { createProjectChannels } from '../channel-management.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('ADD-PROJECT');
+export async function handleAddProjectCommand({ command, appId, }) {
+    await command.deferReply({ ephemeral: false });
+    const projectId = command.options.getString('project', true);
+    const guild = command.guild;
+    if (!guild) {
+        await command.editReply('This command can only be used in a guild');
+        return;
+    }
+    try {
+        const currentDir = process.cwd();
+        const getClient = await initializeOpencodeForDirectory(currentDir);
+        const projectsResponse = await getClient().project.list({});
+        if (!projectsResponse.data) {
+            await command.editReply('Failed to fetch projects');
+            return;
+        }
+        const project = projectsResponse.data.find((p) => p.id === projectId);
+        if (!project) {
+            await command.editReply('Project not found');
+            return;
+        }
+        const directory = project.worktree;
+        if (!fs.existsSync(directory)) {
+            await command.editReply(`Directory does not exist: ${directory}`);
+            return;
+        }
+        const db = getDatabase();
+        const existingChannel = db
+            .prepare('SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ?')
+            .get(directory, 'text');
+        if (existingChannel) {
+            await command.editReply(`A channel already exists for this directory: <#${existingChannel.channel_id}>`);
+            return;
+        }
+        const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+            guild,
+            projectDirectory: directory,
+            appId,
+            botName: command.client.user?.username,
+        });
+        await command.editReply(`✅ Created channels for project:\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n📁 Directory: \`${directory}\``);
+        logger.log(`Created channels for project ${channelName} at ${directory}`);
+    }
+    catch (error) {
+        logger.error('[ADD-PROJECT] Error:', error);
+        await command.editReply(`Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+export async function handleAddProjectAutocomplete({ interaction, appId, }) {
+    const focusedValue = interaction.options.getFocused();
+    try {
+        const currentDir = process.cwd();
+        const getClient = await initializeOpencodeForDirectory(currentDir);
+        const projectsResponse = await getClient().project.list({});
+        if (!projectsResponse.data) {
+            await interaction.respond([]);
+            return;
+        }
+        const db = getDatabase();
+        const existingDirs = db
+            .prepare('SELECT DISTINCT directory FROM channel_directories WHERE channel_type = ?')
+            .all('text');
+        const existingDirSet = new Set(existingDirs.map((row) => row.directory));
+        const availableProjects = projectsResponse.data.filter((project) => !existingDirSet.has(project.worktree));
+        const projects = availableProjects
+            .filter((project) => {
+            const baseName = path.basename(project.worktree);
+            const searchText = `${baseName} ${project.worktree}`.toLowerCase();
+            return searchText.includes(focusedValue.toLowerCase());
+        })
+            .sort((a, b) => {
+            const aTime = a.time.initialized || a.time.created;
+            const bTime = b.time.initialized || b.time.created;
+            return bTime - aTime;
+        })
+            .slice(0, 25)
+            .map((project) => {
+            const name = `${path.basename(project.worktree)} (${project.worktree})`;
+            return {
+                name: name.length > 100 ? name.slice(0, 99) + '…' : name,
+                value: project.id,
+            };
+        });
+        await interaction.respond(projects);
+    }
+    catch (error) {
+        logger.error('[AUTOCOMPLETE] Error fetching projects:', error);
+        await interaction.respond([]);
+    }
+}

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'}`);
+    }
+}