disunday 1.0.0

package/dist/commands/export.js

@@ -0,0 +1,100 @@
+import { ChannelType, AttachmentBuilder } 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 handleExportCommand({ 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;
+    }
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (getClient instanceof Error) {
+        await command.editReply({
+            content: `Failed to export: ${getClient.message}`,
+        });
+        return;
+    }
+    try {
+        const [sessionResponse, messagesResponse] = await Promise.all([
+            getClient().session.get({ path: { id: row.session_id } }),
+            getClient().session.messages({ path: { id: row.session_id } }),
+        ]);
+        const session = sessionResponse.data;
+        const messages = messagesResponse.data || [];
+        let markdown = `# Session Export\n\n`;
+        markdown += `**Session ID:** ${row.session_id}\n`;
+        markdown += `**Title:** ${session?.title || 'Untitled'}\n`;
+        markdown += `**Directory:** ${directory}\n`;
+        markdown += `**Messages:** ${messages.length}\n`;
+        markdown += `**Exported:** ${new Date().toISOString()}\n\n`;
+        markdown += `---\n\n`;
+        for (const msg of messages) {
+            const role = msg.info.role === 'user' ? '👤 User' : '🤖 Assistant';
+            markdown += `## ${role}\n\n`;
+            for (const part of msg.parts) {
+                if (part.type === 'text' && 'text' in part && part.text) {
+                    markdown += part.text + '\n\n';
+                }
+                else if (part.type === 'reasoning' && 'text' in part && part.text) {
+                    markdown += `_Thinking: ${part.text}_\n\n`;
+                }
+                else if (part.type === 'tool' && 'tool' in part) {
+                    markdown += `\`Tool: ${part.tool}\`\n\n`;
+                }
+            }
+            markdown += `---\n\n`;
+        }
+        const attachment = new AttachmentBuilder(Buffer.from(markdown, 'utf-8'), {
+            name: `session-${row.session_id.slice(0, 8)}.md`,
+        });
+        await command.editReply({
+            content: '📄 **Session exported to Markdown**',
+            files: [attachment],
+        });
+    }
+    catch (error) {
+        await command.editReply({
+            content: `Failed to export: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}

package/dist/commands/files.js

@@ -0,0 +1,73 @@
+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 handleFilesCommand({ 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 } = await execAsync('git ls-files | head -50', {
+            cwd: directory,
+            maxBuffer: 1024 * 1024,
+        });
+        const files = stdout.trim().split('\n').filter(Boolean);
+        const fileCount = files.length;
+        let message = `📁 **Project Files** (\`${directory}\`)\n\n`;
+        if (fileCount === 0) {
+            message += '_No tracked files found_';
+        }
+        else {
+            message += '```\n' + files.join('\n') + '\n```';
+            if (fileCount === 50) {
+                message += '\n_Showing first 50 files_';
+            }
+        }
+        await command.reply({
+            content: message.slice(0, 2000),
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+    }
+    catch (error) {
+        await command.reply({
+            content: `Failed to list files: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+    }
+}

package/dist/commands/fork.js

@@ -0,0 +1,199 @@
+// /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, getDisundayMetadata, sendThreadMessage } from '../discord-utils.js';
+import { collectLastAssistantParts } from '../message-formatting.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import * as errore from 'errore';
+const sessionLogger = createLogger(LogPrefix.SESSION);
+const forkLogger = createLogger(LogPrefix.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 } = getDisundayMetadata(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;
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (getClient instanceof Error) {
+        await interaction.editReply({
+            content: `Failed to load messages: ${getClient.message}`,
+        });
+        return;
+    }
+    try {
+        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 });
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (getClient instanceof Error) {
+        await interaction.editReply(`Failed to fork session: ${getClient.message}`);
+        return;
+    }
+    try {
+        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}`,
+        });
+        // Add user to thread so it appears in their sidebar
+        await thread.members.add(interaction.user.id);
+        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'}`);
+    }
+}

package/dist/commands/help.js

@@ -0,0 +1,54 @@
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+export async function handleHelpCommand({ command, }) {
+    const helpMessage = `# Disunday Commands
+
+## Session Management
+- \`/new-session\` - Start a new OpenCode session
+- \`/resume\` - Resume a previous session
+- \`/abort\` or \`/stop\` - Stop the current session
+- \`/fork\` - Fork session from a previous message
+- \`/compact\` - Summarize conversation history
+
+## Session Info
+- \`/status\` - Check bot and session status
+- \`/session-info\` - Get session ID and terminal command
+- \`/context\` - Show context window usage
+- \`/share\` - Generate a public share URL
+- \`/export\` - Export session to markdown
+
+## Code & Files
+- \`/diff\` - Show recent file changes
+- \`/files\` - List project files
+- \`/run\` - Execute a terminal command
+- \`/undo\` / \`/redo\` - Undo/redo changes
+
+## Worktrees
+- \`/new-worktree\` - Create a git worktree
+- \`/merge-worktree\` - Merge worktree branch
+- \`/toggle-worktrees\` - Toggle auto-worktree
+
+## Configuration
+- \`/model\` - Change AI model
+- \`/agent\` - Change agent
+- \`/login\` - Authenticate with provider
+- \`/verbosity\` - Set output detail level
+- \`/run-config\` - Configure /run notifications
+
+## Project Management
+- \`/add-project\` - Add project channels
+- \`/remove-project\` - Remove project channels
+- \`/create-new-project\` - Create new project
+
+## Utilities
+- \`/ping\` - Check connection latency
+- \`/help\` - Show this help message
+- \`/queue\` - Queue a follow-up message
+- \`/clear-queue\` - Clear message queue
+- \`/sync\` - Sync terminal activity to Discord
+- \`/rename\` - Rename current session`;
+    await command.reply({
+        content: helpMessage,
+        ephemeral: true,
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+}