disunday 1.0.0

package/dist/commands/settings.js

@@ -0,0 +1,84 @@
+import { ChatInputCommandInteraction, ChannelType, EmbedBuilder, } from 'discord.js';
+import { getBotSettings, setBotSettings } from '../database.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const settingsLogger = createLogger(LogPrefix.SETTINGS);
+export async function handleSettingsCommand({ command, appId, }) {
+    const subcommand = command.options.getSubcommand();
+    switch (subcommand) {
+        case 'hub-channel': {
+            await handleHubChannelSetting({ command, appId });
+            return;
+        }
+        case 'view': {
+            await handleViewSettings({ command, appId });
+            return;
+        }
+        default: {
+            await command.reply({
+                content: `Unknown setting: ${subcommand}`,
+                ephemeral: true,
+            });
+        }
+    }
+}
+async function handleHubChannelSetting({ command, appId, }) {
+    const channel = command.options.getChannel('channel');
+    const clear = command.options.getBoolean('clear');
+    if (clear) {
+        setBotSettings(appId, { hub_channel_id: null });
+        settingsLogger.log(`[SETTINGS] Cleared hub channel for app ${appId}`);
+        await command.reply({
+            content: '✓ Hub channel cleared. Session completion notifications will no longer be sent to a central channel.',
+            ephemeral: true,
+        });
+        return;
+    }
+    if (!channel) {
+        const currentSettings = getBotSettings(appId);
+        if (currentSettings.hub_channel_id) {
+            await command.reply({
+                content: `Current hub channel: <#${currentSettings.hub_channel_id}>`,
+                ephemeral: true,
+            });
+        }
+        else {
+            await command.reply({
+                content: 'No hub channel configured. Use `/settings hub-channel channel:#channel` to set one.',
+                ephemeral: true,
+            });
+        }
+        return;
+    }
+    if (channel.type !== ChannelType.GuildText) {
+        await command.reply({
+            content: 'Hub channel must be a text channel.',
+            ephemeral: true,
+        });
+        return;
+    }
+    setBotSettings(appId, { hub_channel_id: channel.id });
+    settingsLogger.log(`[SETTINGS] Set hub channel to ${channel.id} for app ${appId}`);
+    await command.reply({
+        content: `✓ Hub channel set to <#${channel.id}>.\nSession completion notifications will be sent here.`,
+        ephemeral: true,
+    });
+}
+async function handleViewSettings({ command, appId, }) {
+    const settings = getBotSettings(appId);
+    const embed = new EmbedBuilder()
+        .setTitle('Bot Settings')
+        .setColor(0x5865f2)
+        .addFields({
+        name: 'Hub Channel',
+        value: settings.hub_channel_id
+            ? `<#${settings.hub_channel_id}>`
+            : '_Not configured_',
+        inline: true,
+    })
+        .setFooter({ text: `App ID: ${appId}` })
+        .setTimestamp();
+    await command.reply({
+        embeds: [embed],
+        ephemeral: true,
+    });
+}

package/dist/commands/share.js

@@ -0,0 +1,89 @@
+// /share command - Share the current session as a public URL.
+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 { createLogger, LogPrefix } from '../logger.js';
+import * as errore from 'errore';
+const logger = createLogger(LogPrefix.SHARE);
+export async function handleShareCommand({ 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 getClient = await initializeOpencodeForDirectory(directory);
+    if (getClient instanceof Error) {
+        await command.reply({
+            content: `Failed to share session: ${getClient.message}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    try {
+        const response = await getClient().session.share({
+            path: { id: sessionId },
+        });
+        if (!response.data?.share?.url) {
+            await command.reply({
+                content: 'Failed to generate share URL',
+                ephemeral: true,
+                flags: SILENT_MESSAGE_FLAGS,
+            });
+            return;
+        }
+        await command.reply({
+            content: `🔗 **Session shared:** ${response.data.share.url}`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        logger.log(`Session ${sessionId} shared: ${response.data.share.url}`);
+    }
+    catch (error) {
+        logger.error('[SHARE] Error:', error);
+        await command.reply({
+            content: `Failed to share session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+    }
+}

package/dist/commands/status.js

@@ -0,0 +1,79 @@
+import { ChannelType } from 'discord.js';
+import { getDatabase, getThreadWorktree } from '../database.js';
+import { resolveTextChannel, getDisundayMetadata, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+export async function handleStatusCommand({ 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 sessionInfo = '';
+    let worktreeInfo = '';
+    let serverStatus = '🔴 Not connected';
+    if (isThread) {
+        const textChannel = await resolveTextChannel(channel);
+        const { projectDirectory: directory } = getDisundayMetadata(textChannel);
+        if (directory) {
+            const row = getDatabase()
+                .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+                .get(channel.id);
+            if (row?.session_id) {
+                sessionInfo = `\n**Session ID:** \`${row.session_id}\``;
+                const worktree = getThreadWorktree(channel.id);
+                if (worktree?.status === 'ready' && worktree.worktree_directory) {
+                    worktreeInfo = `\n**Worktree:** \`${worktree.worktree_directory}\``;
+                }
+            }
+            const getClient = await initializeOpencodeForDirectory(directory);
+            if (!(getClient instanceof Error)) {
+                try {
+                    await getClient().session.list({});
+                    serverStatus = '🟢 Connected';
+                }
+                catch {
+                    serverStatus = '🟡 Server error';
+                }
+            }
+        }
+    }
+    else {
+        const { projectDirectory: directory } = getDisundayMetadata(channel);
+        if (directory) {
+            const getClient = await initializeOpencodeForDirectory(directory);
+            if (!(getClient instanceof Error)) {
+                try {
+                    await getClient().session.list({});
+                    serverStatus = '🟢 Connected';
+                }
+                catch {
+                    serverStatus = '🟡 Server error';
+                }
+            }
+        }
+    }
+    const statusMessage = [
+        '📊 **Bot Status**',
+        '',
+        `**OpenCode Server:** ${serverStatus}`,
+        sessionInfo,
+        worktreeInfo,
+        '',
+        `**Channel:** ${isThread ? 'Thread' : 'Channel'}`,
+    ]
+        .filter(Boolean)
+        .join('\n');
+    await command.reply({
+        content: statusMessage,
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+}

package/dist/commands/sync.js

@@ -0,0 +1,119 @@
+import { ChannelType } from 'discord.js';
+import { getDatabase, getThreadWorktree } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getDisundayMetadata, sendThreadMessage, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { collectLastAssistantParts } from '../message-formatting.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.SESSION);
+export async function handleSyncCommand({ 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;
+    }
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    const thread = channel;
+    const textChannel = await resolveTextChannel(thread);
+    const { projectDirectory: directory } = getDisundayMetadata(textChannel);
+    if (!directory) {
+        await command.editReply('Could not determine project directory for this channel');
+        return;
+    }
+    const row = getDatabase()
+        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+        .get(channel.id);
+    if (!row?.session_id) {
+        await command.editReply('No active session in this thread');
+        return;
+    }
+    const sessionId = row.session_id;
+    const worktreeInfo = getThreadWorktree(channel.id);
+    const sdkDirectory = worktreeInfo?.status === 'ready' && worktreeInfo.worktree_directory
+        ? worktreeInfo.worktree_directory
+        : directory;
+    try {
+        const getClient = await initializeOpencodeForDirectory(directory);
+        if (getClient instanceof Error) {
+            await command.editReply(`Failed to sync: ${getClient.message}`);
+            return;
+        }
+        const [sessionResponse, messagesResponse] = await Promise.all([
+            getClient().session.get({
+                path: { id: sessionId },
+                query: { directory: sdkDirectory },
+            }),
+            getClient().session.messages({
+                path: { id: sessionId },
+                query: { directory: sdkDirectory },
+            }),
+        ]);
+        const sessionTitle = sessionResponse.data?.title;
+        const originalThreadName = thread.name;
+        let wasRenamed = false;
+        logger.log(`[SYNC] Session title: "${sessionTitle}", Thread name: "${originalThreadName}"`);
+        if (sessionTitle && sessionTitle !== originalThreadName) {
+            const renameResult = await thread
+                .setName(sessionTitle.slice(0, 100))
+                .then(() => true)
+                .catch((err) => {
+                logger.error(`[SYNC] Failed to rename thread: ${err}`);
+                return false;
+            });
+            wasRenamed = renameResult;
+            if (wasRenamed) {
+                logger.log(`[SYNC] Updated thread name to "${sessionTitle}" for session ${sessionId}`);
+            }
+        }
+        if (!messagesResponse.data) {
+            await command.editReply('Failed to fetch session messages');
+            return;
+        }
+        const messages = messagesResponse.data;
+        const { partIds, content, skippedCount } = collectLastAssistantParts({
+            messages,
+            limit: 3,
+        });
+        if (!content.trim()) {
+            const titleNote = wasRenamed
+                ? ` (thread renamed to "${sessionTitle}")`
+                : '';
+            await command.editReply(`No recent assistant messages to sync${titleNote}`);
+            return;
+        }
+        const titleNote = wasRenamed ? ` | renamed to "${sessionTitle}"` : '';
+        await command.editReply(`🔄 **Synced from terminal** (${messages.length} total messages${titleNote})`);
+        if (skippedCount > 0) {
+            await sendThreadMessage(thread, `*Skipped ${skippedCount} older assistant parts...*`);
+        }
+        const discordMessage = await sendThreadMessage(thread, content);
+        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);
+        logger.log(`[SYNC] Synced ${partIds.length} parts from session ${sessionId}`);
+    }
+    catch (error) {
+        logger.error('[SYNC] Error:', error);
+        await command.editReply(`Failed to sync: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/commands/theme.js

@@ -0,0 +1,53 @@
+import { ChatInputCommandInteraction, ChannelType, } from 'discord.js';
+import { getChannelTheme, setChannelTheme, } from '../database.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const themeLogger = createLogger(LogPrefix.THEME);
+export async function handleThemeCommand({ command, appId, }) {
+    themeLogger.log('[THEME] Command called');
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'Could not determine channel.',
+            ephemeral: true,
+        });
+        return;
+    }
+    const channelId = (() => {
+        if (channel.type === ChannelType.GuildText) {
+            return channel.id;
+        }
+        if (channel.type === ChannelType.PublicThread ||
+            channel.type === ChannelType.PrivateThread ||
+            channel.type === ChannelType.AnnouncementThread) {
+            return channel.parentId || channel.id;
+        }
+        return channel.id;
+    })();
+    const theme = command.options.getString('style', true);
+    const currentTheme = getChannelTheme(channelId);
+    if (currentTheme === theme) {
+        await command.reply({
+            content: `Theme is already set to **${theme}** for this channel.`,
+            ephemeral: true,
+        });
+        return;
+    }
+    setChannelTheme(channelId, theme);
+    themeLogger.log(`[THEME] Set channel ${channelId} to ${theme}`);
+    const description = (() => {
+        switch (theme) {
+            case 'minimal':
+                return 'Minimal formatting with reduced bullets and no emoji. Thinking is hidden.';
+            case 'detailed':
+                return 'Rich formatting with emoji icons for different message types.';
+            case 'plain':
+                return 'Text-based formatting using brackets like [file], [tool], [edit].';
+            default:
+                return 'Default formatting with diamond bullets and emoji icons.';
+        }
+    })();
+    await command.reply({
+        content: `Theme set to **${theme}** for this channel.\n${description}\nThis is a per-channel setting and applies immediately, including any active sessions.`,
+        ephemeral: true,
+    });
+}

package/dist/commands/types.js

@@ -0,0 +1,2 @@
+// Shared types for command handlers.
+export {};

package/dist/commands/undo-redo.js

@@ -0,0 +1,170 @@
+// Undo/Redo commands - /undo, /redo
+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 { createLogger, LogPrefix } from '../logger.js';
+import * as errore from 'errore';
+const logger = createLogger(LogPrefix.UNDO_REDO);
+export async function handleUndoCommand({ 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;
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (getClient instanceof Error) {
+        await command.editReply(`Failed to undo: ${getClient.message}`);
+        return;
+    }
+    try {
+        // Fetch messages to find the last assistant message
+        const messagesResponse = await getClient().session.messages({
+            path: { id: sessionId },
+        });
+        if (!messagesResponse.data || messagesResponse.data.length === 0) {
+            await command.editReply('No messages to undo');
+            return;
+        }
+        // Find the last assistant message
+        const lastAssistantMessage = [...messagesResponse.data]
+            .reverse()
+            .find((m) => m.info.role === 'assistant');
+        if (!lastAssistantMessage) {
+            await command.editReply('No assistant message to undo');
+            return;
+        }
+        const response = await getClient().session.revert({
+            path: { id: sessionId },
+            body: { messageID: lastAssistantMessage.info.id },
+        });
+        if (response.error) {
+            await command.editReply(`Failed to undo: ${JSON.stringify(response.error)}`);
+            return;
+        }
+        const diffInfo = response.data?.revert?.diff
+            ? `\n\`\`\`diff\n${response.data.revert.diff.slice(0, 1500)}\n\`\`\``
+            : '';
+        await command.editReply(`⏪ **Undone** - reverted last assistant message${diffInfo}`);
+        logger.log(`Session ${sessionId} reverted message ${lastAssistantMessage.info.id}`);
+    }
+    catch (error) {
+        logger.error('[UNDO] Error:', error);
+        await command.editReply(`Failed to undo: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+export async function handleRedoCommand({ 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;
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (getClient instanceof Error) {
+        await command.editReply(`Failed to redo: ${getClient.message}`);
+        return;
+    }
+    try {
+        // Check if session has reverted state
+        const sessionResponse = await getClient().session.get({
+            path: { id: sessionId },
+        });
+        if (!sessionResponse.data?.revert) {
+            await command.editReply('Nothing to redo - no previous undo found');
+            return;
+        }
+        const response = await getClient().session.unrevert({
+            path: { id: sessionId },
+        });
+        if (response.error) {
+            await command.editReply(`Failed to redo: ${JSON.stringify(response.error)}`);
+            return;
+        }
+        await command.editReply(`⏩ **Restored** - session back to previous state`);
+        logger.log(`Session ${sessionId} unrevert completed`);
+    }
+    catch (error) {
+        logger.error('[REDO] Error:', error);
+        await command.editReply(`Failed to redo: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}