disunday 1.0.0

package/dist/commands/abort.js

@@ -0,0 +1,89 @@
+// /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, getDisundayMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { abortControllers } from '../session-handler.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import * as errore from 'errore';
+const logger = createLogger(LogPrefix.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 } = getDisundayMetadata(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;
+    const existingController = abortControllers.get(sessionId);
+    if (existingController) {
+        logger.log(`[ABORT] reason=user-requested sessionId=${sessionId} channelId=${channel.id} - user ran /abort command`);
+        existingController.abort(new Error('User requested abort'));
+        abortControllers.delete(sessionId);
+    }
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (getClient instanceof Error) {
+        await command.reply({
+            content: `Failed to abort: ${getClient.message}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    try {
+        logger.log(`[ABORT-API] reason=user-requested sessionId=${sessionId} channelId=${channel.id} - sending API abort from /abort command`);
+        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,117 @@
+// /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, LogPrefix } from '../logger.js';
+import { abbreviatePath } from '../utils.js';
+import * as errore from 'errore';
+const logger = createLogger(LogPrefix.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);
+        if (getClient instanceof Error) {
+            await command.editReply(getClient.message);
+            return;
+        }
+        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,
+        });
+        const voiceInfo = voiceChannelId ? `\n🔊 Voice: <#${voiceChannelId}>` : '';
+        await command.editReply(`✅ Created channels for project:\n📝 Text: <#${textChannelId}>${voiceInfo}\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);
+        if (getClient instanceof Error) {
+            await interaction.respond([]);
+            return;
+        }
+        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) => {
+            if (existingDirSet.has(project.worktree)) {
+                return false;
+            }
+            if (path.basename(project.worktree).startsWith('opencode-test-')) {
+                return false;
+            }
+            return true;
+        });
+        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)} (${abbreviatePath(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,250 @@
+// /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, } from 'discord.js';
+import crypto from 'node:crypto';
+import { getDatabase, setChannelAgent, setSessionAgent, clearSessionModel, runModelMigrations } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getDisundayMetadata } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import * as errore from 'errore';
+const agentLogger = createLogger(LogPrefix.AGENT);
+const pendingAgentContexts = new Map();
+/**
+ * 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 = getDisundayMetadata(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 = getDisundayMetadata(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 function setAgentForContext({ context, agentName, }) {
+    if (context.isThread && context.sessionId) {
+        setSessionAgent(context.sessionId, agentName);
+        // Clear session model so the new agent's model takes effect
+        clearSessionModel(context.sessionId);
+        agentLogger.log(`Set agent ${agentName} for session ${context.sessionId} (cleared session model)`);
+    }
+    else {
+        setChannelAgent(context.channelId, agentName);
+        agentLogger.log(`Set agent ${agentName} for channel ${context.channelId}`);
+    }
+}
+export async function handleAgentCommand({ interaction, appId, }) {
+    await interaction.deferReply({ ephemeral: true });
+    runModelMigrations();
+    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({
+            query: { 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 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**\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 {
+        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.
+ */
+export async function handleQuickAgentCommand({ command, appId, }) {
+    await command.deferReply({ ephemeral: true });
+    runModelMigrations();
+    // Extract agent name from command: "plan-agent" → "plan"
+    const sanitizedAgentName = command.commandName.replace(/-agent$/, '');
+    const context = await resolveAgentCommandContext({ interaction: command, appId });
+    if (!context) {
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(context.dir);
+        if (getClient instanceof Error) {
+            await command.editReply({ content: getClient.message });
+            return;
+        }
+        const agentsResponse = await getClient().app.agents({
+            query: { directory: context.dir },
+        });
+        if (!agentsResponse.data || agentsResponse.data.length === 0) {
+            await command.editReply({ content: 'No agents available in this project' });
+            return;
+        }
+        // Find the agent matching the sanitized command name
+        const matchingAgent = agentsResponse.data.find((a) => sanitizeAgentName(a.name) === sanitizedAgentName);
+        if (!matchingAgent) {
+            await command.editReply({
+                content: `Agent not found. Available agents: ${agentsResponse.data.map((a) => a.name).join(', ')}`,
+            });
+            return;
+        }
+        setAgentForContext({ context, agentName: matchingAgent.name });
+        if (context.isThread && context.sessionId) {
+            await command.editReply({
+                content: `Switched to **${matchingAgent.name}** agent for this session`,
+            });
+        }
+        else {
+            await command.editReply({
+                content: `Switched to **${matchingAgent.name}** agent for this channel\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,219 @@
+// 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, NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js';
+import { getOpencodeClientV2 } 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}**\n${q.question}`,
+            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.',
+            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 {
+        const clientV2 = getOpencodeClientV2(context.directory);
+        if (!clientV2) {
+            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 clientV2.question.reply({
+            requestID: context.requestId,
+            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 clientV2 = getOpencodeClientV2(context.directory);
+        if (!clientV2) {
+            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 clientV2.question.reply({
+            requestID: context.requestId,
+            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;
+}