disunday 1.0.0

package/dist/system-message.js

@@ -0,0 +1,138 @@
+// OpenCode system prompt generator.
+// Creates the system message injected into every OpenCode session,
+// including Discord-specific formatting rules, diff commands, and permissions info.
+export function getOpencodeSystemMessage({ sessionId, channelId, worktree, }) {
+    return `
+The user is reading your messages from inside Discord, via disunday
+
+The user cannot see bash tool outputs. If there is important information in bash output, include it in your text response.
+
+## bash tool
+
+When calling the bash tool, always include a boolean field \`hasSideEffect\`.
+Set \`hasSideEffect: true\` for any command that writes files, modifies repo state, installs packages, changes config, runs scripts that mutate state, or triggers external effects.
+Set \`hasSideEffect: false\` for read-only commands (e.g. ls, tree, cat, rg, grep, git status, git diff, pwd, whoami, etc).
+This is required to distinguish essential bash calls from read-only ones in low-verbosity mode.
+
+Your current OpenCode session ID is: ${sessionId}${channelId ? `\nYour current Discord channel ID is: ${channelId}` : ''}
+
+## permissions
+
+Only users with these Discord permissions can send messages to the bot:
+- Server Owner
+- Administrator permission
+- Manage Server permission
+- "Disunday" role (case-insensitive)
+
+## uploading files to discord
+
+To upload files to the Discord thread (images, screenshots, long files that would clutter the chat), run:
+
+npx -y disunday upload-to-discord --session ${sessionId} <file1> [file2] ...
+${channelId
+        ? `
+## starting new sessions from CLI
+
+To start a new thread/session in this channel programmatically, run:
+
+npx -y disunday send --channel ${channelId} --prompt "your prompt here"
+
+Use --notify-only to create a notification thread without starting an AI session:
+
+npx -y disunday send --channel ${channelId} --prompt "User cancelled subscription" --notify-only
+
+This is useful for automation (cron jobs, GitHub webhooks, n8n, etc.)
+
+### Session handoff
+
+When you are approaching the **context window limit** or the user explicitly asks to **handoff to a new thread**, use the \`disunday send\` command to start a fresh session with context:
+
+\`\`\`bash
+npx -y disunday send --channel ${channelId} --prompt "Continuing from previous session: <summary of current task and state>"
+\`\`\`
+
+The command automatically handles long prompts (over 2000 chars) by sending them as file attachments.
+
+Use this for handoff when:
+- User asks to "handoff", "continue in new thread", or "start fresh session"
+- You detect you're running low on context window space
+- A complex task would benefit from a clean slate with summarized context
+`
+        : ''}${worktree
+        ? `
+## worktree
+
+This session is running inside a git worktree.
+- **Worktree path:** \`${worktree.worktreeDirectory}\`
+- **Branch:** \`${worktree.branch}\`
+- **Main repo:** \`${worktree.mainRepoDirectory}\`
+
+Before finishing a task, ask the user if they want to merge changes back to the main branch.
+
+To merge (without leaving the worktree):
+\`\`\`bash
+# Get the default branch name
+DEFAULT_BRANCH=$(git -C ${worktree.mainRepoDirectory} symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@' || echo "main")
+
+# Merge worktree branch into main
+git -C ${worktree.mainRepoDirectory} checkout $DEFAULT_BRANCH && git -C ${worktree.mainRepoDirectory} merge ${worktree.branch}
+\`\`\`
+`
+        : ''}
+## showing diffs
+
+IMPORTANT: After editing any files, you MUST execute the critique command using the Bash tool to get a diff URL, then share that URL with the user.
+
+Execute this after making changes:
+
+bunx critique --web "Add user authentication flow"
+
+If there are other unrelated changes in the working directory, filter to only show the files you edited:
+
+bunx critique --web "Fix database connection retry" --filter "path/to/file1.ts" --filter "path/to/file2.ts"
+
+You can also show latest commit changes using:
+
+bunx critique HEAD --web "Refactor API endpoints"
+
+bunx critique HEAD~1 --web "Update dependencies"
+
+Do this in case you committed the changes yourself (only if the user asks so, never commit otherwise).
+
+To compare two branches:
+
+bunx critique main feature-branch --web "Compare branches"
+
+The command outputs a URL - share that URL with the user so they can see the diff.
+
+## markdown
+
+discord does support basic markdown features like code blocks, code blocks languages, inline code, bold, italic, quotes, etc.
+
+the max heading level is 3, so do not use ####
+
+headings are discouraged anyway. instead try to use bold text for titles which renders more nicely in Discord
+
+
+## diagrams
+
+you can create diagrams wrapping them in code blocks.
+
+## proactivity
+
+Be proactive. When the user asks you to do something, do it. Do NOT stop to ask for confirmation.
+
+Only ask questions when the request is genuinely ambiguous with multiple valid approaches, or the action is destructive and irreversible.
+
+## ending conversations with options
+
+After **completing** a task, use the question tool to offer follow-up options. The question tool must be called last, after all text parts.
+
+IMPORTANT: Do NOT use the question tool to ask permission before doing work. Do the work first, then offer follow-ups.
+
+Examples:
+- After completing edits: offer "Commit changes?" or "Run tests?"
+- After debugging: offer "Apply fix", "Investigate further", "Try different approach"
+- After a genuinely ambiguous request where you cannot infer intent: offer the different approaches
+`;
+}

package/dist/tools.js

@@ -0,0 +1,354 @@
+// Voice assistant tool definitions for the GenAI worker.
+// Provides tools for managing OpenCode sessions (create, submit, abort),
+// listing chats, searching files, and reading session messages.
+import { tool } from 'ai';
+import { z } from 'zod';
+import { spawn } from 'node:child_process';
+import net from 'node:net';
+import { createOpencodeClient, } from '@opencode-ai/sdk';
+import { createLogger, LogPrefix } from './logger.js';
+import * as errore from 'errore';
+const toolsLogger = createLogger(LogPrefix.TOOLS);
+import { ShareMarkdown } from './markdown.js';
+import { formatDistanceToNow } from './utils.js';
+import pc from 'picocolors';
+import { initializeOpencodeForDirectory, getOpencodeSystemMessage } from './discord-bot.js';
+export async function getTools({ onMessageCompleted, directory, }) {
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (getClient instanceof Error) {
+        throw new Error(getClient.message);
+    }
+    const client = getClient();
+    const markdownRenderer = new ShareMarkdown(client);
+    const providersResponse = await client.config.providers({});
+    const providers = providersResponse.data?.providers || [];
+    // Helper: get last assistant model for a session (non-summary)
+    const getSessionModel = async (sessionId) => {
+        const res = await getClient().session.messages({ path: { id: sessionId } });
+        const data = res.data;
+        if (!data || data.length === 0)
+            return undefined;
+        for (let i = data.length - 1; i >= 0; i--) {
+            const info = data?.[i]?.info;
+            if (info?.role === 'assistant') {
+                const ai = info;
+                if (!ai.summary && ai.providerID && ai.modelID) {
+                    return { providerID: ai.providerID, modelID: ai.modelID };
+                }
+            }
+        }
+        return undefined;
+    };
+    const tools = {
+        submitMessage: tool({
+            description: 'Submit a message to an existing chat session. Does not wait for the message to complete',
+            inputSchema: z.object({
+                sessionId: z.string().describe('The session ID to send message to'),
+                message: z.string().describe('The message text to send'),
+            }),
+            execute: async ({ sessionId, message }) => {
+                const sessionModel = await getSessionModel(sessionId);
+                // do not await
+                getClient()
+                    .session.prompt({
+                    path: { id: sessionId },
+                    body: {
+                        parts: [{ type: 'text', text: message }],
+                        model: sessionModel,
+                        system: getOpencodeSystemMessage({ sessionId }),
+                    },
+                })
+                    .then(async (response) => {
+                    const markdownResult = await markdownRenderer.generate({
+                        sessionID: sessionId,
+                        lastAssistantOnly: true,
+                    });
+                    onMessageCompleted?.({
+                        sessionId,
+                        messageId: '',
+                        data: response.data,
+                        markdown: errore.unwrapOr(markdownResult, ''),
+                    });
+                })
+                    .catch((error) => {
+                    onMessageCompleted?.({
+                        sessionId,
+                        messageId: '',
+                        error,
+                    });
+                });
+                return {
+                    success: true,
+                    sessionId,
+                    directive: 'Tell user that message has been sent successfully',
+                };
+            },
+        }),
+        createNewChat: tool({
+            description: 'Start a new chat session with an initial message. Does not wait for the message to complete',
+            inputSchema: z.object({
+                message: z.string().describe('The initial message to start the chat with'),
+                title: z.string().optional().describe('Optional title for the session'),
+                model: z
+                    .object({
+                    providerId: z.string().describe('The provider ID (e.g., "anthropic", "openai")'),
+                    modelId: z.string().describe('The model ID (e.g., "claude-opus-4-20250514", "gpt-5")'),
+                })
+                    .optional()
+                    .describe('Optional model to use for this session'),
+            }),
+            execute: async ({ message, title }) => {
+                if (!message.trim()) {
+                    throw new Error(`message must be a non empty string`);
+                }
+                try {
+                    const session = await getClient().session.create({
+                        body: {
+                            title: title || message.slice(0, 50),
+                        },
+                    });
+                    if (!session.data) {
+                        throw new Error('Failed to create session');
+                    }
+                    // do not await
+                    getClient()
+                        .session.prompt({
+                        path: { id: session.data.id },
+                        body: {
+                            parts: [{ type: 'text', text: message }],
+                            system: getOpencodeSystemMessage({ sessionId: session.data.id }),
+                        },
+                    })
+                        .then(async (response) => {
+                        const markdownResult = await markdownRenderer.generate({
+                            sessionID: session.data.id,
+                            lastAssistantOnly: true,
+                        });
+                        onMessageCompleted?.({
+                            sessionId: session.data.id,
+                            messageId: '',
+                            data: response.data,
+                            markdown: errore.unwrapOr(markdownResult, ''),
+                        });
+                    })
+                        .catch((error) => {
+                        onMessageCompleted?.({
+                            sessionId: session.data.id,
+                            messageId: '',
+                            error,
+                        });
+                    });
+                    return {
+                        success: true,
+                        sessionId: session.data.id,
+                        title: session.data.title,
+                    };
+                }
+                catch (error) {
+                    return {
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Failed to create chat session',
+                    };
+                }
+            },
+        }),
+        listChats: tool({
+            description: 'Get a list of available chat sessions sorted by most recent',
+            inputSchema: z.object({}),
+            execute: async () => {
+                toolsLogger.log(`Listing opencode sessions`);
+                const sessions = await getClient().session.list();
+                if (!sessions.data) {
+                    return { success: false, error: 'No sessions found' };
+                }
+                const sortedSessions = [...sessions.data]
+                    .sort((a, b) => {
+                    return b.time.updated - a.time.updated;
+                })
+                    .slice(0, 20);
+                const sessionList = sortedSessions.map(async (session) => {
+                    const finishedAt = session.time.updated;
+                    const status = await (async () => {
+                        if (session.revert)
+                            return 'error';
+                        const messagesResponse = await getClient().session.messages({
+                            path: { id: session.id },
+                        });
+                        const messages = messagesResponse.data || [];
+                        const lastMessage = messages[messages.length - 1];
+                        if (lastMessage?.info.role === 'assistant' && !lastMessage.info.time.completed) {
+                            return 'in_progress';
+                        }
+                        return 'finished';
+                    })();
+                    return {
+                        id: session.id,
+                        folder: session.directory,
+                        status,
+                        finishedAt: formatDistanceToNow(new Date(finishedAt)),
+                        title: session.title,
+                        prompt: session.title,
+                    };
+                });
+                const resolvedList = await Promise.all(sessionList);
+                return {
+                    success: true,
+                    sessions: resolvedList,
+                };
+            },
+        }),
+        searchFiles: tool({
+            description: 'Search for files in a folder',
+            inputSchema: z.object({
+                folder: z
+                    .string()
+                    .optional()
+                    .describe('The folder path to search in, optional. only use if user specifically asks for it'),
+                query: z.string().describe('The search query for files'),
+            }),
+            execute: async ({ folder, query }) => {
+                const results = await getClient().find.files({
+                    query: {
+                        query,
+                        directory: folder,
+                    },
+                });
+                return {
+                    success: true,
+                    files: results.data || [],
+                };
+            },
+        }),
+        readSessionMessages: tool({
+            description: 'Read messages from a chat session',
+            inputSchema: z.object({
+                sessionId: z.string().describe('The session ID to read messages from'),
+                lastAssistantOnly: z.boolean().optional().describe('Only read the last assistant message'),
+            }),
+            execute: async ({ sessionId, lastAssistantOnly = false }) => {
+                if (lastAssistantOnly) {
+                    const messages = await getClient().session.messages({
+                        path: { id: sessionId },
+                    });
+                    if (!messages.data) {
+                        return { success: false, error: 'No messages found' };
+                    }
+                    const assistantMessages = messages.data.filter((m) => m.info.role === 'assistant');
+                    if (assistantMessages.length === 0) {
+                        return {
+                            success: false,
+                            error: 'No assistant messages found',
+                        };
+                    }
+                    const lastMessage = assistantMessages[assistantMessages.length - 1];
+                    const status = 'completed' in lastMessage.info.time && lastMessage.info.time.completed
+                        ? 'completed'
+                        : 'in_progress';
+                    const markdownResult = await markdownRenderer.generate({
+                        sessionID: sessionId,
+                        lastAssistantOnly: true,
+                    });
+                    if (markdownResult instanceof Error) {
+                        throw new Error(markdownResult.message);
+                    }
+                    return {
+                        success: true,
+                        markdown: markdownResult,
+                        status,
+                    };
+                }
+                else {
+                    const markdownResult = await markdownRenderer.generate({
+                        sessionID: sessionId,
+                    });
+                    if (markdownResult instanceof Error) {
+                        throw new Error(markdownResult.message);
+                    }
+                    const messages = await getClient().session.messages({
+                        path: { id: sessionId },
+                    });
+                    const lastMessage = messages.data?.[messages.data.length - 1];
+                    const status = lastMessage?.info.role === 'assistant' &&
+                        lastMessage?.info.time &&
+                        'completed' in lastMessage.info.time &&
+                        !lastMessage.info.time.completed
+                        ? 'in_progress'
+                        : 'completed';
+                    return {
+                        success: true,
+                        markdown: markdownResult,
+                        status,
+                    };
+                }
+            },
+        }),
+        abortChat: tool({
+            description: 'Abort/stop an in-progress chat session',
+            inputSchema: z.object({
+                sessionId: z.string().describe('The session ID to abort'),
+            }),
+            execute: async ({ sessionId }) => {
+                try {
+                    toolsLogger.log(`[ABORT] reason=voice-tool sessionId=${sessionId} - user requested abort via voice assistant tool`);
+                    const result = await getClient().session.abort({
+                        path: { id: sessionId },
+                    });
+                    if (!result.data) {
+                        return {
+                            success: false,
+                            error: 'Failed to abort session',
+                        };
+                    }
+                    return {
+                        success: true,
+                        sessionId,
+                        message: 'Session aborted successfully',
+                    };
+                }
+                catch (error) {
+                    return {
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error occurred',
+                    };
+                }
+            },
+        }),
+        getModels: tool({
+            description: 'Get all available AI models from all providers',
+            inputSchema: z.object({}),
+            execute: async () => {
+                try {
+                    const providersResponse = await getClient().config.providers({});
+                    const providers = providersResponse.data?.providers || [];
+                    const models = [];
+                    providers.forEach((provider) => {
+                        if (provider.models && typeof provider.models === 'object') {
+                            Object.entries(provider.models).forEach(([modelId, model]) => {
+                                models.push({
+                                    providerId: provider.id,
+                                    modelId: modelId,
+                                });
+                            });
+                        }
+                    });
+                    return {
+                        success: true,
+                        models,
+                        totalCount: models.length,
+                    };
+                }
+                catch (error) {
+                    return {
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Failed to fetch models',
+                        models: [],
+                    };
+                }
+            },
+        }),
+    };
+    return {
+        tools,
+        providers,
+    };
+}

package/dist/unnest-code-blocks.js

@@ -0,0 +1,117 @@
+// Unnest code blocks from list items for Discord.
+// Discord doesn't render code blocks inside lists, so this hoists them
+// to root level while preserving list structure.
+import { Lexer } from 'marked';
+export function unnestCodeBlocksFromLists(markdown) {
+    const lexer = new Lexer();
+    const tokens = lexer.lex(markdown);
+    const result = [];
+    for (const token of tokens) {
+        if (token.type === 'list') {
+            const segments = processListToken(token);
+            result.push(renderSegments(segments));
+        }
+        else {
+            result.push(token.raw);
+        }
+    }
+    return result.join('');
+}
+function processListToken(list) {
+    const segments = [];
+    const start = typeof list.start === 'number' ? list.start : parseInt(list.start, 10) || 1;
+    const prefix = list.ordered ? (i) => `${start + i}. ` : () => '- ';
+    for (let i = 0; i < list.items.length; i++) {
+        const item = list.items[i];
+        const itemSegments = processListItem(item, prefix(i));
+        segments.push(...itemSegments);
+    }
+    return segments;
+}
+function processListItem(item, prefix) {
+    const segments = [];
+    let currentText = [];
+    // Track if we've seen a code block - text after code uses continuation prefix
+    let seenCodeBlock = false;
+    const flushText = () => {
+        const text = currentText.join('').trim();
+        if (text) {
+            // After a code block, use '-' as continuation prefix to avoid repeating numbers
+            const effectivePrefix = seenCodeBlock ? '- ' : prefix;
+            segments.push({ type: 'list-item', prefix: effectivePrefix, content: text });
+        }
+        currentText = [];
+    };
+    for (const token of item.tokens) {
+        if (token.type === 'code') {
+            flushText();
+            const codeToken = token;
+            const lang = codeToken.lang || '';
+            segments.push({
+                type: 'code',
+                content: '```' + lang + '\n' + codeToken.text + '\n```\n',
+            });
+            seenCodeBlock = true;
+        }
+        else if (token.type === 'list') {
+            flushText();
+            // Recursively process nested list - segments bubble up
+            const nestedSegments = processListToken(token);
+            segments.push(...nestedSegments);
+        }
+        else {
+            currentText.push(extractText(token));
+        }
+    }
+    flushText();
+    // If no segments were created (empty item), return empty
+    if (segments.length === 0) {
+        return [];
+    }
+    // If item had no code blocks (all segments are list-items from this level),
+    // return original raw to preserve formatting
+    const hasCode = segments.some((s) => s.type === 'code');
+    if (!hasCode) {
+        return [{ type: 'list-item', prefix: '', content: item.raw }];
+    }
+    return segments;
+}
+function extractText(token) {
+    if (token.type === 'text') {
+        return token.text;
+    }
+    if (token.type === 'space') {
+        return '';
+    }
+    if ('raw' in token) {
+        return token.raw;
+    }
+    return '';
+}
+function renderSegments(segments) {
+    const result = [];
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        const prev = segments[i - 1];
+        if (segment.type === 'code') {
+            // Add newline before code if previous was a list item
+            if (prev && prev.type === 'list-item') {
+                result.push('\n');
+            }
+            result.push(segment.content);
+        }
+        else {
+            // list-item
+            if (segment.prefix) {
+                result.push(segment.prefix + segment.content + '\n');
+            }
+            else {
+                // Raw content (no prefix means it's original raw)
+                // Ensure raw ends with newline for proper separation from next segment
+                const raw = segment.content.trimEnd();
+                result.push(raw + '\n');
+            }
+        }
+    }
+    return result.join('').trimEnd();
+}