disunday 1.0.0

package/dist/discord-utils.js

@@ -0,0 +1,336 @@
+// Discord-specific utility functions.
+// Handles markdown splitting for Discord's 2000-char limit, code block escaping,
+// thread message sending, and channel metadata extraction from topic tags.
+import { ChannelType, PermissionsBitField, } from 'discord.js';
+import { Lexer } from 'marked';
+import { formatMarkdownTables } from './format-tables.js';
+import { getChannelDirectory } from './database.js';
+import { limitHeadingDepth } from './limit-heading-depth.js';
+import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js';
+import { createLogger, LogPrefix } from './logger.js';
+import mime from 'mime';
+import fs from 'node:fs';
+import path from 'node:path';
+const discordLogger = createLogger(LogPrefix.DISCORD);
+export const SILENT_MESSAGE_FLAGS = 4 | 4096;
+// Same as SILENT but without SuppressNotifications - triggers badge/notification
+export const NOTIFY_MESSAGE_FLAGS = 4;
+export function escapeBackticksInCodeBlocks(markdown) {
+    const lexer = new Lexer();
+    const tokens = lexer.lex(markdown);
+    let result = '';
+    for (const token of tokens) {
+        if (token.type === 'code') {
+            const escapedCode = token.text.replace(/`/g, '\\`');
+            result += '```' + (token.lang || '') + '\n' + escapedCode + '\n```\n';
+        }
+        else {
+            result += token.raw;
+        }
+    }
+    return result;
+}
+export function splitMarkdownForDiscord({ content, maxLength, }) {
+    if (content.length <= maxLength) {
+        return [content];
+    }
+    const lexer = new Lexer();
+    const tokens = lexer.lex(content);
+    const lines = [];
+    for (const token of tokens) {
+        if (token.type === 'code') {
+            const lang = token.lang || '';
+            lines.push({
+                text: '```' + lang + '\n',
+                inCodeBlock: false,
+                lang,
+                isOpeningFence: true,
+                isClosingFence: false,
+            });
+            const codeLines = token.text.split('\n');
+            for (const codeLine of codeLines) {
+                lines.push({
+                    text: codeLine + '\n',
+                    inCodeBlock: true,
+                    lang,
+                    isOpeningFence: false,
+                    isClosingFence: false,
+                });
+            }
+            lines.push({
+                text: '```\n',
+                inCodeBlock: false,
+                lang: '',
+                isOpeningFence: false,
+                isClosingFence: true,
+            });
+        }
+        else {
+            const rawLines = token.raw.split('\n');
+            for (let i = 0; i < rawLines.length; i++) {
+                const isLast = i === rawLines.length - 1;
+                const text = isLast ? rawLines[i] : rawLines[i] + '\n';
+                if (text) {
+                    lines.push({
+                        text,
+                        inCodeBlock: false,
+                        lang: '',
+                        isOpeningFence: false,
+                        isClosingFence: false,
+                    });
+                }
+            }
+        }
+    }
+    const chunks = [];
+    let currentChunk = '';
+    let currentLang = null;
+    // helper to split a long line into smaller pieces at word boundaries or hard breaks
+    const splitLongLine = (text, available, inCode) => {
+        const pieces = [];
+        let remaining = text;
+        while (remaining.length > available) {
+            let splitAt = available;
+            // for non-code, try to split at word boundary
+            if (!inCode) {
+                const lastSpace = remaining.lastIndexOf(' ', available);
+                if (lastSpace > available * 0.5) {
+                    splitAt = lastSpace + 1;
+                }
+            }
+            pieces.push(remaining.slice(0, splitAt));
+            remaining = remaining.slice(splitAt);
+        }
+        if (remaining) {
+            pieces.push(remaining);
+        }
+        return pieces;
+    };
+    const closingFence = '```\n';
+    for (const line of lines) {
+        const openingFenceSize = currentChunk.length === 0 && (line.inCodeBlock || line.isOpeningFence)
+            ? ('```' + line.lang + '\n').length
+            : 0;
+        const lineLength = line.isOpeningFence ? 0 : line.text.length;
+        const activeFenceOverhead = currentLang !== null || openingFenceSize > 0 ? closingFence.length : 0;
+        const wouldExceed = currentChunk.length + openingFenceSize + lineLength + activeFenceOverhead > maxLength;
+        if (wouldExceed) {
+            // handle case where single line is longer than maxLength
+            if (line.text.length > maxLength) {
+                // first, flush current chunk if any
+                if (currentChunk) {
+                    if (currentLang !== null) {
+                        currentChunk += '```\n';
+                    }
+                    chunks.push(currentChunk);
+                    currentChunk = '';
+                }
+                // calculate overhead for code block markers
+                const codeBlockOverhead = line.inCodeBlock
+                    ? ('```' + line.lang + '\n').length + '```\n'.length
+                    : 0;
+                // ensure at least 10 chars available, even if maxLength is very small
+                const availablePerChunk = Math.max(10, maxLength - codeBlockOverhead - 50);
+                const pieces = splitLongLine(line.text, availablePerChunk, line.inCodeBlock);
+                for (let i = 0; i < pieces.length; i++) {
+                    const piece = pieces[i];
+                    if (line.inCodeBlock) {
+                        chunks.push('```' + line.lang + '\n' + piece + '```\n');
+                    }
+                    else {
+                        chunks.push(piece);
+                    }
+                }
+                currentLang = null;
+                continue;
+            }
+            // normal case: line fits in a chunk but current chunk would overflow
+            if (currentChunk) {
+                if (currentLang !== null) {
+                    currentChunk += '```\n';
+                }
+                chunks.push(currentChunk);
+                if (line.isClosingFence && currentLang !== null) {
+                    currentChunk = '';
+                    currentLang = null;
+                    continue;
+                }
+                if (line.inCodeBlock || line.isOpeningFence) {
+                    const lang = line.lang;
+                    currentChunk = '```' + lang + '\n';
+                    if (!line.isOpeningFence) {
+                        currentChunk += line.text;
+                    }
+                    currentLang = lang;
+                }
+                else {
+                    currentChunk = line.text;
+                    currentLang = null;
+                }
+            }
+            else {
+                // currentChunk is empty but line still exceeds - shouldn't happen after above check
+                const openingFence = line.inCodeBlock || line.isOpeningFence;
+                const openingFenceSize = openingFence ? ('```' + line.lang + '\n').length : 0;
+                if (line.text.length + openingFenceSize + activeFenceOverhead > maxLength) {
+                    const fencedOverhead = openingFence
+                        ? ('```' + line.lang + '\n').length + closingFence.length
+                        : 0;
+                    const availablePerChunk = Math.max(10, maxLength - fencedOverhead - 50);
+                    const pieces = splitLongLine(line.text, availablePerChunk, line.inCodeBlock);
+                    for (const piece of pieces) {
+                        if (openingFence) {
+                            chunks.push('```' + line.lang + '\n' + piece + closingFence);
+                        }
+                        else {
+                            chunks.push(piece);
+                        }
+                    }
+                    currentChunk = '';
+                    currentLang = null;
+                }
+                else {
+                    if (openingFence) {
+                        currentChunk = '```' + line.lang + '\n';
+                        if (!line.isOpeningFence) {
+                            currentChunk += line.text;
+                        }
+                        currentLang = line.lang;
+                    }
+                    else {
+                        currentChunk = line.text;
+                        currentLang = null;
+                    }
+                }
+            }
+        }
+        else {
+            currentChunk += line.text;
+            if (line.inCodeBlock || line.isOpeningFence) {
+                currentLang = line.lang;
+            }
+            else if (line.isClosingFence) {
+                currentLang = null;
+            }
+        }
+    }
+    if (currentChunk) {
+        if (currentLang !== null) {
+            currentChunk += closingFence;
+        }
+        chunks.push(currentChunk);
+    }
+    return chunks;
+}
+export async function sendThreadMessage(thread, content, options) {
+    const MAX_LENGTH = 2000;
+    content = formatMarkdownTables(content);
+    content = unnestCodeBlocksFromLists(content);
+    content = limitHeadingDepth(content);
+    content = escapeBackticksInCodeBlocks(content);
+    // If custom flags provided, send as single message (no chunking)
+    if (options?.flags !== undefined) {
+        return thread.send({ content, flags: options.flags });
+    }
+    const chunks = splitMarkdownForDiscord({ content, maxLength: MAX_LENGTH });
+    if (chunks.length > 1) {
+        discordLogger.log(`MESSAGE: Splitting ${content.length} chars into ${chunks.length} messages`);
+    }
+    let firstMessage;
+    for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        if (!chunk) {
+            continue;
+        }
+        const message = await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS });
+        if (i === 0) {
+            firstMessage = message;
+        }
+    }
+    return firstMessage;
+}
+export async function resolveTextChannel(channel) {
+    if (!channel) {
+        return null;
+    }
+    if (channel.type === ChannelType.GuildText) {
+        return channel;
+    }
+    if (channel.type === ChannelType.PublicThread ||
+        channel.type === ChannelType.PrivateThread ||
+        channel.type === ChannelType.AnnouncementThread) {
+        const parentId = channel.parentId;
+        if (parentId) {
+            const parent = await channel.guild.channels.fetch(parentId);
+            if (parent?.type === ChannelType.GuildText) {
+                return parent;
+            }
+        }
+    }
+    return null;
+}
+export function escapeDiscordFormatting(text) {
+    return text.replace(/```/g, '\\`\\`\\`').replace(/````/g, '\\`\\`\\`\\`');
+}
+/**
+ * Check if a member has required permissions to use Disunday.
+ * Returns true if user is owner, admin, has ManageGuild, or has "Disunday" role.
+ * Returns false if user has "no-disunday" role (blocks access).
+ */
+export function hasRequiredPermissions(member, guild) {
+    const hasNoDisundayRole = member.roles.cache.some((role) => role.name.toLowerCase() === 'no-disunday');
+    if (hasNoDisundayRole) {
+        return false;
+    }
+    const isOwner = member.id === guild.ownerId;
+    const isAdmin = member.permissions.has(PermissionsBitField.Flags.Administrator);
+    const canManageServer = member.permissions.has(PermissionsBitField.Flags.ManageGuild);
+    const hasDisundayRole = member.roles.cache.some((role) => role.name.toLowerCase() === 'disunday');
+    return isOwner || isAdmin || canManageServer || hasDisundayRole;
+}
+export function getDisundayMetadata(textChannel) {
+    if (!textChannel) {
+        return {};
+    }
+    const channelConfig = getChannelDirectory(textChannel.id);
+    if (!channelConfig) {
+        return {};
+    }
+    return {
+        projectDirectory: channelConfig.directory,
+        channelAppId: channelConfig.appId || undefined,
+    };
+}
+/**
+ * Upload files to a Discord thread/channel in a single message.
+ * Sending all files in one message causes Discord to display images in a grid layout.
+ */
+export async function uploadFilesToDiscord({ threadId, botToken, files, }) {
+    if (files.length === 0) {
+        return;
+    }
+    // Build attachments array for all files
+    const attachments = files.map((file, index) => ({
+        id: index,
+        filename: path.basename(file),
+    }));
+    const formData = new FormData();
+    formData.append('payload_json', JSON.stringify({ attachments }));
+    // Append each file with its array index, with correct MIME type for grid display
+    files.forEach((file, index) => {
+        const buffer = fs.readFileSync(file);
+        const mimeType = mime.getType(file) || 'application/octet-stream';
+        formData.append(`files[${index}]`, new Blob([buffer], { type: mimeType }), path.basename(file));
+    });
+    const response = await fetch(`https://discord.com/api/v10/channels/${threadId}/messages`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bot ${botToken}`,
+        },
+        body: formData,
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Discord API error: ${response.status} - ${error}`);
+    }
+}

package/dist/discord-utils.test.js

@@ -0,0 +1,20 @@
+import { describe, expect, test } from 'vitest';
+import { splitMarkdownForDiscord } from './discord-utils.js';
+describe('splitMarkdownForDiscord', () => {
+    test('never returns chunks over the max length with code fences', () => {
+        const maxLength = 2000;
+        const header = '## Summary of Current Architecture\n\n';
+        const codeFenceStart = '```\n';
+        const codeFenceEnd = '\n```\n';
+        const codeLine = 'x'.repeat(180);
+        const codeBlock = Array.from({ length: 20 })
+            .map(() => codeLine)
+            .join('\n');
+        const markdown = `${header}${codeFenceStart}${codeBlock}${codeFenceEnd}`;
+        const chunks = splitMarkdownForDiscord({ content: markdown, maxLength });
+        expect(chunks.length).toBeGreaterThan(1);
+        for (const chunk of chunks) {
+            expect(chunk.length).toBeLessThanOrEqual(maxLength);
+        }
+    });
+});

package/dist/errors.js

@@ -0,0 +1,193 @@
+// TaggedError definitions for type-safe error handling with errore.
+// Errors are grouped by category: infrastructure, domain, and validation.
+// Use errore.matchError() for exhaustive error handling in command handlers.
+import { createTaggedError } from 'errore';
+// ═══════════════════════════════════════════════════════════════════════════
+// INFRASTRUCTURE ERRORS - Server, filesystem, external services
+// ═══════════════════════════════════════════════════════════════════════════
+export class DirectoryNotAccessibleError extends createTaggedError({
+    name: 'DirectoryNotAccessibleError',
+    message: 'Directory does not exist or is not accessible: $directory',
+}) {
+}
+export class ServerStartError extends createTaggedError({
+    name: 'ServerStartError',
+    message: 'Server failed to start on port $port: $reason',
+}) {
+}
+export class ServerNotFoundError extends createTaggedError({
+    name: 'ServerNotFoundError',
+    message: 'OpenCode server not found for directory: $directory',
+}) {
+}
+export class ServerNotReadyError extends createTaggedError({
+    name: 'ServerNotReadyError',
+    message: 'OpenCode server for directory "$directory" is in an error state (no client available)',
+}) {
+}
+export class ApiKeyMissingError extends createTaggedError({
+    name: 'ApiKeyMissingError',
+    message: '$service API key is required',
+}) {
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// DOMAIN ERRORS - Sessions, messages, transcription
+// ═══════════════════════════════════════════════════════════════════════════
+export class SessionNotFoundError extends createTaggedError({
+    name: 'SessionNotFoundError',
+    message: 'Session $sessionId not found',
+}) {
+}
+export class SessionCreateError extends createTaggedError({
+    name: 'SessionCreateError',
+    message: '$message',
+}) {
+}
+export class MessagesNotFoundError extends createTaggedError({
+    name: 'MessagesNotFoundError',
+    message: 'No messages found for session $sessionId',
+}) {
+}
+export class TranscriptionError extends createTaggedError({
+    name: 'TranscriptionError',
+    message: 'Transcription failed: $reason',
+}) {
+}
+export class GrepSearchError extends createTaggedError({
+    name: 'GrepSearchError',
+    message: 'Grep search failed for pattern: $pattern',
+}) {
+}
+export class GlobSearchError extends createTaggedError({
+    name: 'GlobSearchError',
+    message: 'Glob search failed for pattern: $pattern',
+}) {
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// VALIDATION ERRORS - Input validation, format checks
+// ═══════════════════════════════════════════════════════════════════════════
+export class InvalidAudioFormatError extends createTaggedError({
+    name: 'InvalidAudioFormatError',
+    message: 'Invalid audio format',
+}) {
+}
+export class EmptyTranscriptionError extends createTaggedError({
+    name: 'EmptyTranscriptionError',
+    message: 'Model returned empty transcription',
+}) {
+}
+export class NoResponseContentError extends createTaggedError({
+    name: 'NoResponseContentError',
+    message: 'No response content from model',
+}) {
+}
+export class NoToolResponseError extends createTaggedError({
+    name: 'NoToolResponseError',
+    message: 'No valid tool responses',
+}) {
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// NETWORK ERRORS - Fetch and HTTP
+// ═══════════════════════════════════════════════════════════════════════════
+export class FetchError extends createTaggedError({
+    name: 'FetchError',
+    message: 'Fetch failed for $url',
+}) {
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// API ERRORS - External service responses
+// ═══════════════════════════════════════════════════════════════════════════
+export class DiscordApiError extends createTaggedError({
+    name: 'DiscordApiError',
+    message: 'Discord API error: $status $body',
+}) {
+}
+export class OpenCodeApiError extends createTaggedError({
+    name: 'OpenCodeApiError',
+    message: 'OpenCode API error ($status): $body',
+}) {
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// USER-SAFE ERROR HANDLING
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Error class for messages that are safe to show to users.
+ * Use this when you want the error message to be displayed verbatim.
+ */
+export class UserSafeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'UserSafeError';
+    }
+}
+/**
+ * Generic error message shown to users when we can't expose internal details.
+ */
+const GENERIC_ERROR_MESSAGE = 'Something went wrong. Please try again.';
+/**
+ * Patterns that indicate sensitive information in error messages.
+ */
+const SENSITIVE_PATTERNS = [
+    /SQLITE/i,
+    /database/i,
+    /token/i,
+    /api.?key/i,
+    /secret/i,
+    /password/i,
+    /credential/i,
+    /at\s+\S+:\d+:\d+/, // Stack trace lines
+    /node_modules/i,
+    /internal\//i,
+];
+/**
+ * Check if an error message contains sensitive information.
+ */
+function containsSensitiveInfo(message) {
+    return SENSITIVE_PATTERNS.some((pattern) => {
+        return pattern.test(message);
+    });
+}
+/**
+ * Sanitize an error for display to Discord users.
+ *
+ * - UserSafeError: Returns the original message (it's explicitly safe)
+ * - Tagged errors (from errore): Returns the error name and message
+ * - Other errors with safe messages: Returns the message
+ * - Errors with sensitive info: Returns generic message
+ */
+export function sanitizeErrorForUser(error) {
+    // UserSafeError is explicitly safe to show
+    if (error instanceof UserSafeError) {
+        return error.message;
+    }
+    // Not an error object
+    if (!(error instanceof Error)) {
+        return GENERIC_ERROR_MESSAGE;
+    }
+    const message = error.message || '';
+    // Check for sensitive patterns
+    if (containsSensitiveInfo(message)) {
+        return GENERIC_ERROR_MESSAGE;
+    }
+    // Tagged errors (from errore) are generally safe - they have structured messages
+    if ('_tag' in error &&
+        typeof error._tag === 'string') {
+        return message;
+    }
+    // Short, simple error messages are probably safe
+    if (message.length < 100 && message.indexOf('\n') === -1) {
+        return message;
+    }
+    // Default to generic message for safety
+    return GENERIC_ERROR_MESSAGE;
+}
+/**
+ * Create a log-safe version of an error (preserves full details for logging).
+ * Returns the original error message and stack trace.
+ */
+export function getErrorForLogging(error) {
+    if (error instanceof Error) {
+        return error.stack || error.message;
+    }
+    return String(error);
+}