@otto-assistant/bridge 0.4.92

package/dist/commands/btw.js

@@ -0,0 +1,116 @@
+// /btw command - Fork the current session with full context and send a new prompt.
+// Unlike /fork, this does not replay past messages in Discord. It just creates
+// a new thread, forks the entire session (no messageID), and immediately
+// dispatches the user's prompt so the forked session starts working right away.
+import { ChannelType, ThreadAutoArchiveDuration, MessageFlags, } from 'discord.js';
+import { getThreadSession, setThreadSession } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveWorkingDirectory, resolveTextChannel, sendThreadMessage, } from '../discord-utils.js';
+import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.FORK);
+export async function handleBtwCommand({ command, appId, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral,
+        });
+        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',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const prompt = command.options.getString('prompt', true);
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const { projectDirectory } = resolved;
+    const sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    await command.deferReply({ flags: MessageFlags.Ephemeral });
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        await command.editReply({
+            content: `Failed to fork session: ${getClient.message}`,
+        });
+        return;
+    }
+    try {
+        // Fork the entire session (no messageID = fork at the latest point)
+        const forkResponse = await getClient().session.fork({
+            sessionID: sessionId,
+        });
+        if (!forkResponse.data) {
+            await command.editReply('Failed to fork session');
+            return;
+        }
+        const forkedSession = forkResponse.data;
+        const textChannel = await resolveTextChannel(channel);
+        if (!textChannel) {
+            await command.editReply('Could not resolve parent text channel');
+            return;
+        }
+        const threadName = `btw: ${prompt}`.slice(0, 100);
+        const thread = await textChannel.threads.create({
+            name: threadName,
+            autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+            reason: `btw fork from session ${sessionId}`,
+        });
+        // Claim the forked session immediately so external polling does not race
+        await setThreadSession(thread.id, forkedSession.id);
+        await thread.members.add(command.user.id);
+        logger.log(`Created btw fork session ${forkedSession.id} in thread ${thread.id} from ${sessionId}`);
+        // Short status message with prompt instead of replaying past messages
+        const sourceThreadLink = `<#${channel.id}>`;
+        await sendThreadMessage(thread, `Reusing context from ${sourceThreadLink} to answer prompt...\n${prompt}`);
+        const wrappedPrompt = [
+            `The user asked a side question while you were working on another task.`,
+            `This is a forked session whose ONLY goal is to answer this question.`,
+            `Do NOT continue, resume, or reference the previous task. Only answer the question below.\n`,
+            prompt,
+        ].join('\n');
+        const runtime = getOrCreateRuntime({
+            threadId: thread.id,
+            thread,
+            projectDirectory,
+            sdkDirectory: projectDirectory,
+            channelId: textChannel.id,
+            appId,
+        });
+        await runtime.enqueueIncoming({
+            prompt: wrappedPrompt,
+            userId: command.user.id,
+            username: command.user.displayName,
+            appId,
+            mode: 'opencode',
+        });
+        await command.editReply(`Session forked! Continue in ${thread.toString()}`);
+    }
+    catch (error) {
+        logger.error('Error in /btw:', error);
+        await command.editReply(`Failed to fork session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/commands/compact.js

@@ -0,0 +1,120 @@
+// /compact command - Trigger context compaction (summarization) for the current session.
+import { ChannelType, MessageFlags, } from 'discord.js';
+import { getThreadSession } from '../database.js';
+import { initializeOpencodeForDirectory, getOpencodeClient, } from '../opencode.js';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.COMPACT);
+export async function handleCompactCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | 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',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const { projectDirectory, workingDirectory } = resolved;
+    const sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    // Ensure server is running for the base project directory
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        await command.reply({
+            content: `Failed to compact: ${getClient.message}`,
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const client = getOpencodeClient(projectDirectory);
+    if (!client) {
+        await command.reply({
+            content: 'Failed to get OpenCode client',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    // Defer reply since compaction may take a moment
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    try {
+        // Get session messages to find the model from the last user message
+        const messagesResult = await client.session.messages({
+            sessionID: sessionId,
+            directory: workingDirectory,
+        });
+        if (messagesResult.error || !messagesResult.data) {
+            logger.error('[COMPACT] Failed to get messages:', messagesResult.error);
+            await command.editReply({
+                content: 'Failed to compact: Could not retrieve session messages',
+            });
+            return;
+        }
+        // Find the last user message to get the model
+        const lastUserMessage = [...messagesResult.data]
+            .reverse()
+            .find((msg) => msg.info.role === 'user');
+        if (!lastUserMessage || lastUserMessage.info.role !== 'user') {
+            await command.editReply({
+                content: 'Failed to compact: No user message found in session',
+            });
+            return;
+        }
+        const { providerID, modelID } = lastUserMessage.info.model;
+        const result = await client.session.summarize({
+            sessionID: sessionId,
+            directory: workingDirectory,
+            providerID,
+            modelID,
+            auto: false,
+        });
+        if (result.error) {
+            logger.error('[COMPACT] Error:', result.error);
+            const errorMessage = 'data' in result.error && result.error.data
+                ? result.error.data.message ||
+                    'Unknown error'
+                : 'Unknown error';
+            await command.editReply({
+                content: `Failed to compact: ${errorMessage}`,
+            });
+            return;
+        }
+        await command.editReply({
+            content: `📦 Session **compacted** successfully`,
+        });
+        logger.log(`Session ${sessionId} compacted by user`);
+    }
+    catch (error) {
+        logger.error('[COMPACT] Error:', error);
+        await command.editReply({
+            content: `Failed to compact: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}

package/dist/commands/context-usage.js

@@ -0,0 +1,140 @@
+// /context-usage command - Show token usage and context window percentage for the current session.
+import { ChannelType, MessageFlags, } from 'discord.js';
+import { getThreadSession } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import * as errore from 'errore';
+const logger = createLogger(LogPrefix.SESSION);
+function getTokenTotal({ input, output, reasoning, cache, }) {
+    return input + output + reasoning + cache.read + cache.write;
+}
+export async function handleContextUsageCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | 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',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const { projectDirectory, workingDirectory } = resolved;
+    const sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        await command.reply({
+            content: `Failed to get context usage: ${getClient.message}`,
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    try {
+        const messagesResponse = await getClient().session.messages({
+            sessionID: sessionId,
+            directory: workingDirectory,
+        });
+        const messages = messagesResponse.data || [];
+        const assistantMessages = messages.filter((m) => m.info.role === 'assistant');
+        if (assistantMessages.length === 0) {
+            await command.editReply({
+                content: 'No assistant messages in this session yet',
+            });
+            return;
+        }
+        const lastAssistant = [...assistantMessages].reverse().find((m) => {
+            if (m.info.role !== 'assistant') {
+                return false;
+            }
+            if (!m.info.tokens) {
+                return false;
+            }
+            return getTokenTotal(m.info.tokens) > 0;
+        });
+        if (!lastAssistant || lastAssistant.info.role !== 'assistant') {
+            await command.editReply({
+                content: 'Token usage not available for this session yet',
+            });
+            return;
+        }
+        const { tokens, modelID, providerID } = lastAssistant.info;
+        const totalTokens = getTokenTotal(tokens);
+        // Sum cost across all assistant messages for accurate session total
+        // (AssistantMessage.cost is per-message, not cumulative)
+        const totalCost = assistantMessages.reduce((sum, m) => {
+            if (m.info.role === 'assistant' && 'cost' in m.info) {
+                return sum + (m.info.cost || 0);
+            }
+            return sum;
+        }, 0);
+        // Fetch model context limit from provider API
+        let contextLimit;
+        const providersResult = await errore.tryAsync(() => {
+            return getClient().provider.list({ directory: workingDirectory });
+        });
+        if (providersResult instanceof Error) {
+            logger.error('[CONTEXT-USAGE] Failed to fetch provider info:', providersResult);
+        }
+        else {
+            const provider = providersResult.data?.all?.find((p) => p.id === providerID);
+            const model = provider?.models?.[modelID];
+            if (model?.limit?.context) {
+                contextLimit = model.limit.context;
+            }
+        }
+        const formattedTokens = totalTokens.toLocaleString('en-US');
+        const formattedCost = totalCost > 0 ? `$${totalCost.toFixed(4)}` : '$0.00';
+        const lines = [];
+        if (contextLimit) {
+            const percentage = Math.round((totalTokens / contextLimit) * 100);
+            const formattedLimit = contextLimit.toLocaleString('en-US');
+            lines.push(`**Context usage:** ${percentage}%, ${formattedTokens} / ${formattedLimit} tokens`);
+        }
+        else {
+            lines.push(`**Context usage:** ${formattedTokens} tokens (context limit unavailable)`);
+        }
+        if (modelID) {
+            lines.push(`**Model:** ${modelID}`);
+        }
+        if (totalCost > 0) {
+            lines.push(`**Session cost:** ${formattedCost}`);
+        }
+        await command.editReply({ content: lines.join('\n') });
+        logger.log(`Context usage shown for session ${sessionId}: ${totalTokens} tokens`);
+    }
+    catch (error) {
+        logger.error('[CONTEXT-USAGE] Error:', error);
+        await command.editReply({
+            content: `Failed to get context usage: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}

package/dist/commands/create-new-project.js

@@ -0,0 +1,130 @@
+// /create-new-project command - Create a new project folder, initialize git, and start a session.
+// Also exports createNewProject() for reuse during onboarding (welcome channel creation).
+import { ChannelType } from 'discord.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { execAsync } from '../worktrees.js';
+import { getProjectsDir } from '../config.js';
+import { createProjectChannels } from '../channel-management.js';
+import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.CREATE_PROJECT);
+/**
+ * Core project creation logic: creates directory, inits git, creates Discord channels.
+ * Reused by the slash command handler and by onboarding (welcome channel).
+ * Returns null if the project directory already exists.
+ */
+export async function createNewProject({ guild, projectName, botName, }) {
+    const sanitizedName = projectName
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 100);
+    if (!sanitizedName) {
+        return null;
+    }
+    const projectsDir = getProjectsDir();
+    const projectDirectory = path.join(projectsDir, sanitizedName);
+    if (!fs.existsSync(projectsDir)) {
+        fs.mkdirSync(projectsDir, { recursive: true });
+        logger.log(`Created projects directory: ${projectsDir}`);
+    }
+    if (fs.existsSync(projectDirectory)) {
+        return null;
+    }
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    logger.log(`Created project directory: ${projectDirectory}`);
+    // Git init — gracefully skip if git is not installed
+    try {
+        await execAsync('git init', { cwd: projectDirectory, timeout: 10_000 });
+        logger.log(`Initialized git in: ${projectDirectory}`);
+    }
+    catch (error) {
+        logger.warn(`Could not initialize git in ${projectDirectory}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+        guild,
+        projectDirectory,
+        botName,
+    });
+    return {
+        textChannelId,
+        voiceChannelId,
+        channelName,
+        projectDirectory,
+        sanitizedName,
+    };
+}
+export async function handleCreateNewProjectCommand({ command, appId, }) {
+    await command.deferReply();
+    const projectName = command.options.getString('name', true);
+    const guild = command.guild;
+    const channel = command.channel;
+    if (!guild) {
+        await command.editReply('This command can only be used in a guild');
+        return;
+    }
+    if (!channel || channel.type !== ChannelType.GuildText) {
+        await command.editReply('This command can only be used in a text channel');
+        return;
+    }
+    try {
+        const result = await createNewProject({
+            guild,
+            projectName,
+            botName: command.client.user?.username,
+        });
+        if (!result) {
+            const sanitizedName = projectName
+                .toLowerCase()
+                .replace(/[^a-z0-9-]/g, '-')
+                .replace(/-+/g, '-')
+                .replace(/^-|-$/g, '')
+                .slice(0, 100);
+            if (!sanitizedName) {
+                await command.editReply('Invalid project name');
+                return;
+            }
+            const projectDirectory = path.join(getProjectsDir(), sanitizedName);
+            await command.editReply(`Project directory already exists: ${projectDirectory}`);
+            return;
+        }
+        const { textChannelId, voiceChannelId, channelName, projectDirectory, sanitizedName, } = result;
+        const textChannel = (await guild.channels.fetch(textChannelId));
+        const voiceInfo = voiceChannelId ? `\n🔊 Voice: <#${voiceChannelId}>` : '';
+        await command.editReply(`✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>${voiceInfo}\n_Starting session..._`);
+        const starterMessage = await textChannel.send({
+            content: `🚀 **New project initialized**\n📁 \`${projectDirectory}\``,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        const thread = await starterMessage.startThread({
+            name: `Init: ${sanitizedName}`,
+            autoArchiveDuration: 1440,
+            reason: 'New project session',
+        });
+        // Add user to thread so it appears in their sidebar
+        await thread.members.add(command.user.id);
+        const runtime = getOrCreateRuntime({
+            threadId: thread.id,
+            thread,
+            projectDirectory,
+            sdkDirectory: projectDirectory,
+            channelId: textChannel.id,
+            appId,
+        });
+        await runtime.enqueueIncoming({
+            prompt: 'The project was just initialized. Say hi and ask what the user wants to build.',
+            userId: command.user.id,
+            username: command.user.displayName,
+            appId,
+            mode: 'opencode',
+        });
+        logger.log(`Created new project ${channelName} at ${projectDirectory}`);
+    }
+    catch (error) {
+        logger.error('[CREATE-NEW-PROJECT] Error:', error);
+        await command.editReply(`Failed to create new project: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/commands/diff.js

@@ -0,0 +1,63 @@
+// /diff command - Show git diff as a shareable URL.
+import { ChannelType, EmbedBuilder, MessageFlags, } from 'discord.js';
+import path from 'node:path';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { uploadGitDiffViaCritique } from '../critique-utils.js';
+const logger = createLogger(LogPrefix.DIFF);
+export async function handleDiffCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    const isTextChannel = channel.type === ChannelType.GuildText;
+    if (!isThread && !isTextChannel) {
+        await command.reply({
+            content: 'This command can only be used in a text channel or thread',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const { workingDirectory } = resolved;
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    const projectName = path.basename(workingDirectory);
+    const title = `${projectName}: Discord /diff`;
+    const result = await uploadGitDiffViaCritique({
+        title,
+        cwd: workingDirectory,
+    });
+    if (!result) {
+        await command.editReply({ content: 'No changes to show' });
+        return;
+    }
+    if (result.error || !result.url) {
+        await command.editReply({ content: result.error || 'No changes to show' });
+        return;
+    }
+    const imageUrl = `https://critique.work/og/${result.id}.png`;
+    const embed = new EmbedBuilder()
+        .setTitle(title)
+        .setURL(result.url)
+        .setImage(imageUrl);
+    await command.editReply({ embeds: [embed] });
+    logger.log(`Diff shared: ${result.url}`);
+}