disunday 1.0.0

package/dist/commands/compact.js

@@ -0,0 +1,126 @@
+// /compact command - Trigger context compaction (summarization) for the current session.
+import { ChannelType } from 'discord.js';
+import { getDatabase } from '../database.js';
+import { initializeOpencodeForDirectory, getOpencodeClientV2 } from '../opencode.js';
+import { resolveTextChannel, getDisundayMetadata, 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',
+            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;
+    // Ensure server is running for this directory
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (getClient instanceof Error) {
+        await command.reply({
+            content: `Failed to compact: ${getClient.message}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const clientV2 = getOpencodeClientV2(directory);
+    if (!clientV2) {
+        await command.reply({
+            content: 'Failed to get OpenCode client',
+            ephemeral: true,
+            flags: 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 clientV2.session.messages({
+            sessionID: sessionId,
+            directory,
+        });
+        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 clientV2.session.summarize({
+            sessionID: sessionId,
+            directory,
+            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'}`,
+        });
+    }
+}

package/dist/commands/context-menu.js

@@ -0,0 +1,171 @@
+import { ChannelType, ThreadAutoArchiveDuration, } from 'discord.js';
+import * as errore from 'errore';
+import { getDatabase } from '../database.js';
+import { getDisundayMetadata, resolveTextChannel, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { handleOpencodeSession } from '../session-handler.js';
+const contextMenuLogger = createLogger(LogPrefix.INTERACTION);
+export async function handleRetryContextMenu({ interaction, appId, }) {
+    const channel = interaction.channel;
+    if (!channel) {
+        await interaction.reply({
+            content: '❌ Could not access channel',
+            ephemeral: true,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await interaction.reply({
+            content: '❌ This command only works in session threads',
+            ephemeral: true,
+        });
+        return;
+    }
+    const thread = channel;
+    const message = interaction.targetMessage;
+    if (message.author.bot) {
+        await interaction.reply({
+            content: '❌ Cannot retry a bot message. Select a user message to retry.',
+            ephemeral: true,
+        });
+        return;
+    }
+    const prompt = message.content;
+    if (!prompt?.trim()) {
+        await interaction.reply({
+            content: '❌ Selected message has no text content',
+            ephemeral: true,
+        });
+        return;
+    }
+    const textChannel = await resolveTextChannel(thread);
+    const { projectDirectory } = getDisundayMetadata(textChannel);
+    if (!projectDirectory) {
+        await interaction.reply({
+            content: '❌ Could not find project directory for this channel',
+            ephemeral: true,
+        });
+        return;
+    }
+    await interaction.reply({
+        content: `🔄 Retrying: "${prompt.slice(0, 50)}${prompt.length > 50 ? '...' : ''}"`,
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+    contextMenuLogger.log(`[CONTEXT-MENU] Retry triggered for message ${message.id}`);
+    const result = await errore.tryAsync(() => {
+        return handleOpencodeSession({
+            prompt,
+            thread,
+            projectDirectory,
+        });
+    });
+    if (result instanceof Error) {
+        contextMenuLogger.error('[CONTEXT-MENU] Retry failed:', result);
+    }
+}
+export async function handleForkContextMenu({ interaction, appId, }) {
+    const channel = interaction.channel;
+    if (!channel) {
+        await interaction.reply({
+            content: '❌ Could not access channel',
+            ephemeral: true,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await interaction.reply({
+            content: '❌ This command only works in session threads',
+            ephemeral: true,
+        });
+        return;
+    }
+    const thread = channel;
+    const message = interaction.targetMessage;
+    const textChannel = await resolveTextChannel(thread);
+    const { projectDirectory } = getDisundayMetadata(textChannel);
+    if (!projectDirectory) {
+        await interaction.reply({
+            content: '❌ Could not find project directory for this channel',
+            ephemeral: true,
+        });
+        return;
+    }
+    const row = getDatabase()
+        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+        .get(thread.id);
+    if (!row?.session_id) {
+        await interaction.reply({
+            content: '❌ No session found for this thread',
+            ephemeral: true,
+        });
+        return;
+    }
+    const partRow = getDatabase()
+        .prepare('SELECT part_id FROM part_messages WHERE message_id = ?')
+        .get(message.id);
+    if (!partRow?.part_id) {
+        await interaction.reply({
+            content: '❌ This message is not linked to a session part. Select a message from the AI response.',
+            ephemeral: true,
+        });
+        return;
+    }
+    await interaction.deferReply({ ephemeral: true });
+    const { initializeOpencodeForDirectory } = await import('../opencode.js');
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        await interaction.editReply({
+            content: `❌ ${getClient.message}`,
+        });
+        return;
+    }
+    const forkResult = await errore.tryAsync(() => {
+        return getClient().session.fork({
+            path: { id: row.session_id },
+            body: { messageID: partRow.part_id },
+            query: { directory: projectDirectory },
+        });
+    });
+    if (forkResult instanceof Error) {
+        await interaction.editReply({
+            content: `❌ Fork failed: ${forkResult.message}`,
+        });
+        return;
+    }
+    const forkedSession = forkResult.data;
+    if (!forkedSession) {
+        await interaction.editReply({
+            content: '❌ Fork returned no session data',
+        });
+        return;
+    }
+    const parentTextChannel = await resolveTextChannel(thread);
+    if (!parentTextChannel) {
+        await interaction.editReply({
+            content: '❌ Could not find parent channel',
+        });
+        return;
+    }
+    const newThread = await parentTextChannel.threads.create({
+        name: `Fork: ${forkedSession.title || 'Untitled'}`.slice(0, 100),
+        autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+        reason: 'Session fork via context menu',
+    });
+    getDatabase()
+        .prepare('INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)')
+        .run(newThread.id, forkedSession.id);
+    await interaction.editReply({
+        content: `✅ Forked session to ${newThread}`,
+    });
+    contextMenuLogger.log(`[CONTEXT-MENU] Forked session ${row.session_id} to ${forkedSession.id} in thread ${newThread.id}`);
+}

package/dist/commands/context.js

@@ -0,0 +1,89 @@
+import { ChannelType } from 'discord.js';
+import { getDatabase } from '../database.js';
+import { resolveTextChannel, getDisundayMetadata, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+export async function handleContextCommand({ 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 getClient = await initializeOpencodeForDirectory(directory);
+    if (getClient instanceof Error) {
+        await command.reply({
+            content: `Failed to get context: ${getClient.message}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    try {
+        const messagesResponse = await getClient().session.messages({
+            path: { id: row.session_id },
+        });
+        const messages = messagesResponse.data || [];
+        const messageCount = messages.length;
+        const userMessages = messages.filter((m) => m.info.role === 'user').length;
+        const assistantMessages = messages.filter((m) => m.info.role === 'assistant').length;
+        const contextMessage = [
+            '📊 **Context Usage**',
+            '',
+            `**Session:** \`${row.session_id.slice(0, 8)}...\``,
+            `**Total Messages:** ${messageCount}`,
+            `**User:** ${userMessages} | **Assistant:** ${assistantMessages}`,
+            '',
+            messageCount > 50
+                ? '⚠️ Consider using `/compact` to reduce context'
+                : '✅ Context size is healthy',
+        ].join('\n');
+        await command.reply({
+            content: contextMessage,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+    }
+    catch (error) {
+        await command.reply({
+            content: `Failed to get context: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+    }
+}

package/dist/commands/cost.js

@@ -0,0 +1,93 @@
+import { ChannelType } from 'discord.js';
+import { getDatabase } from '../database.js';
+import { resolveTextChannel, getDisundayMetadata, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+export async function handleCostCommand({ 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 getClient = await initializeOpencodeForDirectory(directory);
+    if (getClient instanceof Error) {
+        await command.reply({
+            content: `Failed to get cost: ${getClient.message}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    try {
+        const messagesResponse = await getClient().session.messages({
+            path: { id: row.session_id },
+        });
+        const messages = messagesResponse.data || [];
+        const messageCount = messages.length;
+        const assistantMessages = messages.filter((m) => m.info.role === 'assistant').length;
+        const estimatedInputTokens = messageCount * 500;
+        const estimatedOutputTokens = assistantMessages * 1000;
+        const inputCost = (estimatedInputTokens / 1_000_000) * 3;
+        const outputCost = (estimatedOutputTokens / 1_000_000) * 15;
+        const totalCost = inputCost + outputCost;
+        const costMessage = [
+            '💰 **Session Cost Estimate**',
+            '',
+            `**Messages:** ${messageCount}`,
+            `**Est. Input Tokens:** ~${estimatedInputTokens.toLocaleString()}`,
+            `**Est. Output Tokens:** ~${estimatedOutputTokens.toLocaleString()}`,
+            '',
+            `**Estimated Cost:** ~$${totalCost.toFixed(4)}`,
+            '',
+            '_Based on Claude Sonnet pricing ($3/M input, $15/M output)_',
+        ].join('\n');
+        await command.reply({
+            content: costMessage,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+    }
+    catch (error) {
+        await command.reply({
+            content: `Failed to get cost: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+    }
+}

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

@@ -0,0 +1,111 @@
+// /create-new-project command - Create a new project folder, initialize git, and start a session.
+// Also exports createNewProject() for reuse during onboarding (welcome channel creation).
+import { ChannelType } from 'discord.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { getProjectsDir } from '../config.js';
+import { createProjectChannels } from '../channel-management.js';
+import { handleOpencodeSession } from '../session-handler.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.CREATE_PROJECT);
+/**
+ * Core project creation logic: creates directory, inits git, creates Discord channels.
+ * Reused by the slash command handler and by onboarding (welcome channel).
+ * Returns null if the project directory already exists.
+ */
+export async function createNewProject({ guild, projectName, appId, botName, }) {
+    const sanitizedName = projectName
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 100);
+    if (!sanitizedName) {
+        return null;
+    }
+    const projectsDir = getProjectsDir();
+    const projectDirectory = path.join(projectsDir, sanitizedName);
+    if (!fs.existsSync(projectsDir)) {
+        fs.mkdirSync(projectsDir, { recursive: true });
+        logger.log(`Created projects directory: ${projectsDir}`);
+    }
+    if (fs.existsSync(projectDirectory)) {
+        return null;
+    }
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    logger.log(`Created project directory: ${projectDirectory}`);
+    execSync('git init', { cwd: projectDirectory, stdio: 'pipe' });
+    logger.log(`Initialized git in: ${projectDirectory}`);
+    const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+        guild,
+        projectDirectory,
+        appId,
+        botName,
+    });
+    return { textChannelId, voiceChannelId, channelName, projectDirectory, sanitizedName };
+}
+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;
+    }
+    try {
+        const result = await createNewProject({
+            guild,
+            projectName,
+            appId,
+            botName: command.client.user?.username,
+        });
+        if (!result) {
+            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 projectDirectory = path.join(getProjectsDir(), sanitizedName);
+            await command.editReply(`Project directory already exists: ${projectDirectory}`);
+            return;
+        }
+        const { textChannelId, voiceChannelId, channelName, projectDirectory, sanitizedName } = result;
+        const textChannel = (await guild.channels.fetch(textChannelId));
+        const voiceInfo = voiceChannelId ? `\n🔊 Voice: <#${voiceChannelId}>` : '';
+        await command.editReply(`✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>${voiceInfo}\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',
+        });
+        // Add user to thread so it appears in their sidebar
+        await thread.members.add(command.user.id);
+        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/diff.js

@@ -0,0 +1,77 @@
+import { ChannelType } from 'discord.js';
+import { resolveTextChannel, getDisundayMetadata, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { getThreadWorktree } from '../database.js';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+const execAsync = promisify(exec);
+export async function handleDiffCommand({ 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);
+    let directory;
+    if (isThread) {
+        const textChannel = await resolveTextChannel(channel);
+        const metadata = getDisundayMetadata(textChannel);
+        directory = metadata.projectDirectory;
+        const worktree = getThreadWorktree(channel.id);
+        if (worktree?.status === 'ready' && worktree.worktree_directory) {
+            directory = worktree.worktree_directory;
+        }
+    }
+    else {
+        const metadata = getDisundayMetadata(channel);
+        directory = metadata.projectDirectory;
+    }
+    if (!directory) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    try {
+        const { stdout: diffOutput } = await execAsync('git diff --stat HEAD~5..HEAD 2>/dev/null || git diff --stat', {
+            cwd: directory,
+            maxBuffer: 1024 * 1024,
+        });
+        const { stdout: statusOutput } = await execAsync('git status --short', {
+            cwd: directory,
+            maxBuffer: 1024 * 1024,
+        });
+        let message = '📝 **Recent Changes**\n\n';
+        if (statusOutput.trim()) {
+            message +=
+                '**Uncommitted:**\n```\n' + statusOutput.slice(0, 500) + '\n```\n\n';
+        }
+        if (diffOutput.trim()) {
+            message +=
+                '**Last 5 commits:**\n```\n' + diffOutput.slice(0, 800) + '\n```';
+        }
+        if (!statusOutput.trim() && !diffOutput.trim()) {
+            message = '📝 **No recent changes**\n\nWorking directory is clean.';
+        }
+        await command.reply({
+            content: message.slice(0, 2000),
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+    }
+    catch (error) {
+        await command.reply({
+            content: `Failed to get diff: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+    }
+}