disunday 1.0.0

package/dist/interaction-handler.js

@@ -0,0 +1,289 @@
+// Discord slash command and interaction handler.
+// Processes all slash commands (/session, /resume, /fork, /model, /abort, etc.)
+// and manages autocomplete, select menu interactions for the bot.
+import { Events } from 'discord.js';
+import { handleSessionCommand, handleSessionAutocomplete, } from './commands/session.js';
+import { handleNewWorktreeCommand } from './commands/worktree.js';
+import { handleMergeWorktreeCommand } from './commands/merge-worktree.js';
+import { handleToggleWorktreesCommand } from './commands/worktree-settings.js';
+import { handleResumeCommand, handleResumeAutocomplete, } from './commands/resume.js';
+import { handleAddProjectCommand, handleAddProjectAutocomplete, } from './commands/add-project.js';
+import { handleRemoveProjectCommand, handleRemoveProjectAutocomplete, } from './commands/remove-project.js';
+import { handleCreateNewProjectCommand } from './commands/create-new-project.js';
+import { handlePermissionSelectMenu } from './commands/permissions.js';
+import { handleAbortCommand } from './commands/abort.js';
+import { handleCompactCommand } from './commands/compact.js';
+import { handleShareCommand } from './commands/share.js';
+import { handleRenameCommand } from './commands/rename.js';
+import { handleSessionInfoCommand } from './commands/session-info.js';
+import { handleSyncCommand } from './commands/sync.js';
+import { handleForkCommand, handleForkSelectMenu } from './commands/fork.js';
+import { handleModelCommand, handleProviderSelectMenu, handleModelSelectMenu, } from './commands/model.js';
+import { handleLoginCommand, handleLoginProviderSelectMenu, handleLoginMethodSelectMenu, handleApiKeyModalSubmit, } from './commands/login.js';
+import { handleAgentCommand, handleAgentSelectMenu, handleQuickAgentCommand, } from './commands/agent.js';
+import { handleAskQuestionSelectMenu } from './commands/ask-question.js';
+import { handleQueueCommand, handleClearQueueCommand, } from './commands/queue.js';
+import { handleUndoCommand, handleRedoCommand } from './commands/undo-redo.js';
+import { handleUserCommand } from './commands/user-command.js';
+import { handleVerbosityCommand } from './commands/verbosity.js';
+import { handleThemeCommand } from './commands/theme.js';
+import { handleSettingsCommand } from './commands/settings.js';
+import { handleRestartOpencodeServerCommand } from './commands/restart-opencode-server.js';
+import { handleRunCommand, handleRunAutocomplete } from './commands/run.js';
+import { handleRunConfigCommand } from './commands/run-config.js';
+import { handleStatusCommand } from './commands/status.js';
+import { handleHelpCommand } from './commands/help.js';
+import { handlePingCommand } from './commands/ping.js';
+import { handleContextCommand } from './commands/context.js';
+import { handleCostCommand } from './commands/cost.js';
+import { handleDiffCommand } from './commands/diff.js';
+import { handleExportCommand } from './commands/export.js';
+import { handleFilesCommand } from './commands/files.js';
+import { handleScheduleCommand } from './commands/schedule.js';
+import { handleRetryContextMenu, handleForkContextMenu, } from './commands/context-menu.js';
+import { createLogger, LogPrefix } from './logger.js';
+const interactionLogger = createLogger(LogPrefix.INTERACTION);
+export function registerInteractionHandler({ discordClient, appId, }) {
+    interactionLogger.log('[REGISTER] Interaction handler registered');
+    discordClient.on(Events.InteractionCreate, async (interaction) => {
+        try {
+            interactionLogger.log(`[INTERACTION] Received: ${interaction.type} - ${interaction.isChatInputCommand()
+                ? interaction.commandName
+                : interaction.isAutocomplete()
+                    ? `autocomplete:${interaction.commandName}`
+                    : 'other'}`);
+            if (interaction.isAutocomplete()) {
+                switch (interaction.commandName) {
+                    case 'new-session':
+                        await handleSessionAutocomplete({ interaction, appId });
+                        return;
+                    case 'resume':
+                        await handleResumeAutocomplete({ interaction, appId });
+                        return;
+                    case 'add-project':
+                        await handleAddProjectAutocomplete({ interaction, appId });
+                        return;
+                    case 'remove-project':
+                        await handleRemoveProjectAutocomplete({ interaction, appId });
+                        return;
+                    case 'run':
+                        await handleRunAutocomplete({ interaction });
+                        return;
+                    default:
+                        await interaction.respond([]);
+                        return;
+                }
+            }
+            if (interaction.isChatInputCommand()) {
+                interactionLogger.log(`[COMMAND] Processing: ${interaction.commandName}`);
+                switch (interaction.commandName) {
+                    case 'new-session':
+                        await handleSessionCommand({ command: interaction, appId });
+                        return;
+                    case 'new-worktree':
+                        await handleNewWorktreeCommand({ command: interaction, appId });
+                        return;
+                    case 'merge-worktree':
+                        await handleMergeWorktreeCommand({ command: interaction, appId });
+                        return;
+                    case 'toggle-worktrees':
+                        await handleToggleWorktreesCommand({
+                            command: interaction,
+                            appId,
+                        });
+                        return;
+                    case 'resume':
+                        await handleResumeCommand({ command: interaction, appId });
+                        return;
+                    case 'add-project':
+                        await handleAddProjectCommand({ command: interaction, appId });
+                        return;
+                    case 'remove-project':
+                        await handleRemoveProjectCommand({ command: interaction, appId });
+                        return;
+                    case 'create-new-project':
+                        await handleCreateNewProjectCommand({
+                            command: interaction,
+                            appId,
+                        });
+                        return;
+                    case 'abort':
+                    case 'stop':
+                        await handleAbortCommand({ command: interaction, appId });
+                        return;
+                    case 'compact':
+                        await handleCompactCommand({ command: interaction, appId });
+                        return;
+                    case 'share':
+                        await handleShareCommand({ command: interaction, appId });
+                        return;
+                    case 'rename':
+                        await handleRenameCommand({ command: interaction, appId });
+                        return;
+                    case 'session-info':
+                        await handleSessionInfoCommand({ command: interaction, appId });
+                        return;
+                    case 'sync':
+                        await handleSyncCommand({ command: interaction, appId });
+                        return;
+                    case 'fork':
+                        await handleForkCommand(interaction);
+                        return;
+                    case 'model':
+                        await handleModelCommand({ interaction, appId });
+                        return;
+                    case 'login':
+                        await handleLoginCommand({ interaction, appId });
+                        return;
+                    case 'agent':
+                        await handleAgentCommand({ interaction, appId });
+                        return;
+                    case 'queue':
+                        await handleQueueCommand({ command: interaction, appId });
+                        return;
+                    case 'clear-queue':
+                        await handleClearQueueCommand({ command: interaction, appId });
+                        return;
+                    case 'undo':
+                        await handleUndoCommand({ command: interaction, appId });
+                        return;
+                    case 'redo':
+                        await handleRedoCommand({ command: interaction, appId });
+                        return;
+                    case 'verbosity':
+                        await handleVerbosityCommand({ command: interaction, appId });
+                        return;
+                    case 'theme':
+                        await handleThemeCommand({ command: interaction, appId });
+                        return;
+                    case 'restart-opencode-server':
+                        await handleRestartOpencodeServerCommand({
+                            command: interaction,
+                            appId,
+                        });
+                        return;
+                    case 'run':
+                        await handleRunCommand({ command: interaction, appId });
+                        return;
+                    case 'run-config':
+                        await handleRunConfigCommand({ command: interaction, appId });
+                        return;
+                    case 'status':
+                        await handleStatusCommand({ command: interaction, appId });
+                        return;
+                    case 'help':
+                        await handleHelpCommand({ command: interaction, appId });
+                        return;
+                    case 'ping':
+                        await handlePingCommand({ command: interaction, appId });
+                        return;
+                    case 'context':
+                        await handleContextCommand({ command: interaction, appId });
+                        return;
+                    case 'cost':
+                        await handleCostCommand({ command: interaction, appId });
+                        return;
+                    case 'diff':
+                        await handleDiffCommand({ command: interaction, appId });
+                        return;
+                    case 'export':
+                        await handleExportCommand({ command: interaction, appId });
+                        return;
+                    case 'files':
+                        await handleFilesCommand({ command: interaction, appId });
+                        return;
+                    case 'settings':
+                        await handleSettingsCommand({ command: interaction, appId });
+                        return;
+                    case 'schedule':
+                        await handleScheduleCommand({ command: interaction, appId });
+                        return;
+                }
+                // Handle quick agent commands (ending with -agent suffix, but not the base /agent command)
+                if (interaction.commandName.endsWith('-agent') &&
+                    interaction.commandName !== 'agent') {
+                    await handleQuickAgentCommand({ command: interaction, appId });
+                    return;
+                }
+                // Handle user-defined commands (ending with -cmd suffix)
+                if (interaction.commandName.endsWith('-cmd')) {
+                    await handleUserCommand({ command: interaction, appId });
+                    return;
+                }
+                return;
+            }
+            if (interaction.isStringSelectMenu()) {
+                const customId = interaction.customId;
+                if (customId.startsWith('fork_select:')) {
+                    await handleForkSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('model_provider:')) {
+                    await handleProviderSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('model_select:')) {
+                    await handleModelSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('agent_select:')) {
+                    await handleAgentSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('ask_question:')) {
+                    await handleAskQuestionSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('permission:')) {
+                    await handlePermissionSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('login_provider:')) {
+                    await handleLoginProviderSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('login_method:')) {
+                    await handleLoginMethodSelectMenu(interaction);
+                    return;
+                }
+                return;
+            }
+            if (interaction.isModalSubmit()) {
+                const customId = interaction.customId;
+                if (customId.startsWith('login_apikey:')) {
+                    await handleApiKeyModalSubmit(interaction);
+                    return;
+                }
+                return;
+            }
+            if (interaction.isMessageContextMenuCommand()) {
+                interactionLogger.log(`[CONTEXT-MENU] Processing: ${interaction.commandName}`);
+                switch (interaction.commandName) {
+                    case 'Retry this prompt':
+                        await handleRetryContextMenu({ interaction, appId });
+                        return;
+                    case 'Fork from here':
+                        await handleForkContextMenu({ interaction, appId });
+                        return;
+                }
+                return;
+            }
+        }
+        catch (error) {
+            interactionLogger.error('[INTERACTION] Error handling interaction:', error);
+            try {
+                if (interaction.isRepliable() &&
+                    !interaction.replied &&
+                    !interaction.deferred) {
+                    await interaction.reply({
+                        content: 'An error occurred processing this command.',
+                        ephemeral: true,
+                    });
+                }
+            }
+            catch (replyError) {
+                interactionLogger.error('[INTERACTION] Failed to send error reply:', replyError);
+            }
+        }
+    });
+}

package/dist/limit-heading-depth.js

@@ -0,0 +1,25 @@
+// Limit heading depth for Discord.
+// Discord only supports headings up to ### (h3), so this converts
+// ####, #####, etc. to ### to maintain consistent rendering.
+import { Lexer } from 'marked';
+export function limitHeadingDepth(markdown, maxDepth = 3) {
+    const lexer = new Lexer();
+    const tokens = lexer.lex(markdown);
+    let result = '';
+    for (const token of tokens) {
+        if (token.type === 'heading') {
+            const heading = token;
+            if (heading.depth > maxDepth) {
+                const hashes = '#'.repeat(maxDepth);
+                result += hashes + ' ' + heading.text + '\n';
+            }
+            else {
+                result += token.raw;
+            }
+        }
+        else {
+            result += token.raw;
+        }
+    }
+    return result;
+}

package/dist/limit-heading-depth.test.js

@@ -0,0 +1,105 @@
+import { expect, test } from 'vitest';
+import { limitHeadingDepth } from './limit-heading-depth.js';
+test('converts h4 to h3', () => {
+    const input = '#### Fourth level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "### Fourth level heading
+    "
+  `);
+});
+test('converts h5 to h3', () => {
+    const input = '##### Fifth level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "### Fifth level heading
+    "
+  `);
+});
+test('converts h6 to h3', () => {
+    const input = '###### Sixth level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "### Sixth level heading
+    "
+  `);
+});
+test('preserves h3 unchanged', () => {
+    const input = '### Third level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`"### Third level heading"`);
+});
+test('preserves h2 unchanged', () => {
+    const input = '## Second level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`"## Second level heading"`);
+});
+test('preserves h1 unchanged', () => {
+    const input = '# First level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`"# First level heading"`);
+});
+test('handles multiple headings in document', () => {
+    const input = `# Title
+
+Some text
+
+## Section
+
+### Subsection
+
+#### Too deep
+
+##### Even deeper
+
+Regular paragraph
+
+### Back to normal
+`;
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "# Title
+
+    Some text
+
+    ## Section
+
+    ### Subsection
+
+    ### Too deep
+    ### Even deeper
+    Regular paragraph
+
+    ### Back to normal
+    "
+  `);
+});
+test('preserves heading with inline formatting', () => {
+    const input = '#### Heading with **bold** and `code`';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "### Heading with **bold** and \`code\`
+    "
+  `);
+});
+test('handles empty markdown', () => {
+    const result = limitHeadingDepth('');
+    expect(result).toMatchInlineSnapshot(`""`);
+});
+test('handles markdown with no headings', () => {
+    const input = 'Just some text\n\nAnd more text';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "Just some text
+
+    And more text"
+  `);
+});
+test('allows custom maxDepth', () => {
+    const input = '### Third level';
+    const result = limitHeadingDepth(input, 2);
+    expect(result).toMatchInlineSnapshot(`
+    "## Third level
+    "
+  `);
+});

package/dist/logger.js

@@ -0,0 +1,111 @@
+// Prefixed logging utility.
+// Uses picocolors for compact frequent logs (log, info, debug).
+// Uses @clack/prompts only for important events (warn, error) with visual distinction.
+import { log as clackLog } from '@clack/prompts';
+import fs from 'node:fs';
+import path, { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import util from 'node:util';
+import pc from 'picocolors';
+// All known log prefixes - add new ones here to keep alignment consistent
+export const LogPrefix = {
+    ABORT: 'ABORT',
+    ADD_PROJECT: 'ADD_PROJ',
+    AGENT: 'AGENT',
+    ASK_QUESTION: 'QUESTION',
+    CLI: 'CLI',
+    COMPACT: 'COMPACT',
+    CREATE_PROJECT: 'NEW_PROJ',
+    DB: 'DB',
+    DISCORD: 'DISCORD',
+    FORK: 'FORK',
+    FORMATTING: 'FORMAT',
+    GENAI: 'GENAI',
+    GENAI_WORKER: 'GENAI_W',
+    INTERACTION: 'INTERACT',
+    LOGIN: 'LOGIN',
+    MARKDOWN: 'MARKDOWN',
+    MODEL: 'MODEL',
+    OPENAI: 'OPENAI',
+    OPENCODE: 'OPENCODE',
+    PERMISSIONS: 'PERMS',
+    QUEUE: 'QUEUE',
+    REACTION: 'REACTION',
+    REMOVE_PROJECT: 'RM_PROJ',
+    SCHEDULE: 'SCHEDULE',
+    RESUME: 'RESUME',
+    SESSION: 'SESSION',
+    SETTINGS: 'SETTINGS',
+    SHARE: 'SHARE',
+    THEME: 'THEME',
+    TOOLS: 'TOOLS',
+    UNDO_REDO: 'UNDO',
+    USER_CMD: 'USER_CMD',
+    VERBOSITY: 'VERBOSE',
+    VOICE: 'VOICE',
+    WORKER: 'WORKER',
+    WORKTREE: 'WORKTREE',
+    XML: 'XML',
+};
+// compute max length from all known prefixes for alignment
+const MAX_PREFIX_LENGTH = Math.max(...Object.values(LogPrefix).map((p) => p.length));
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const isDev = !__dirname.includes('node_modules');
+const logFilePath = path.join(__dirname, '..', 'tmp', 'disunday.log');
+// reset log file on startup in dev mode
+if (isDev) {
+    const logDir = path.dirname(logFilePath);
+    if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+    }
+    fs.writeFileSync(logFilePath, `--- disunday log started at ${new Date().toISOString()} ---\n`);
+}
+function formatArg(arg) {
+    if (typeof arg === 'string') {
+        return arg;
+    }
+    return util.inspect(arg, { colors: true, depth: 4 });
+}
+function writeToFile(level, prefix, args) {
+    if (!isDev) {
+        return;
+    }
+    const timestamp = new Date().toISOString();
+    const message = `[${timestamp}] [${level}] [${prefix}] ${args.map(formatArg).join(' ')}\n`;
+    fs.appendFileSync(logFilePath, message);
+}
+function getTimestamp() {
+    const now = new Date();
+    return `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}`;
+}
+function padPrefix(prefix) {
+    return prefix.padEnd(MAX_PREFIX_LENGTH);
+}
+export function createLogger(prefix) {
+    const paddedPrefix = padPrefix(prefix);
+    return {
+        log: (...args) => {
+            writeToFile('INFO', prefix, args);
+            console.log(pc.dim(getTimestamp()), pc.cyan(paddedPrefix), ...args.map(formatArg));
+        },
+        error: (...args) => {
+            writeToFile('ERROR', prefix, args);
+            // use clack for errors - visually distinct
+            clackLog.error([paddedPrefix, ...args.map(formatArg)].join(' '));
+        },
+        warn: (...args) => {
+            writeToFile('WARN', prefix, args);
+            // use clack for warnings - visually distinct
+            clackLog.warn([paddedPrefix, ...args.map(formatArg)].join(' '));
+        },
+        info: (...args) => {
+            writeToFile('INFO', prefix, args);
+            console.log(pc.dim(getTimestamp()), pc.blue(paddedPrefix), ...args.map(formatArg));
+        },
+        debug: (...args) => {
+            writeToFile('DEBUG', prefix, args);
+            console.log(pc.dim(getTimestamp()), pc.dim(paddedPrefix), ...args.map(formatArg));
+        },
+    };
+}