@otto-assistant/bridge 0.4.101 → 0.4.103

package/dist/commands/btw.js

@@ -9,6 +9,64 @@ import { resolveWorkingDirectory, resolveTextChannel, sendThreadMessage, } from
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
 const logger = createLogger(LogPrefix.FORK);
+export async function forkSessionToBtwThread({ sourceThread, projectDirectory, prompt, userId, username, appId, }) {
+    const sessionId = await getThreadSession(sourceThread.id);
+    if (!sessionId) {
+        return new Error('No active session in this thread');
+    }
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        return new Error(`Failed to fork session: ${getClient.message}`, {
+            cause: getClient,
+        });
+    }
+    const forkResponse = await getClient().session.fork({
+        sessionID: sessionId,
+    });
+    if (!forkResponse.data) {
+        return new Error('Failed to fork session');
+    }
+    const textChannel = await resolveTextChannel(sourceThread);
+    if (!textChannel) {
+        return new Error('Could not resolve parent text channel');
+    }
+    const forkedSession = forkResponse.data;
+    const thread = await textChannel.threads.create({
+        name: `btw: ${prompt}`.slice(0, 100),
+        autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+        reason: `btw fork from session ${sessionId}`,
+    });
+    await setThreadSession(thread.id, forkedSession.id);
+    await thread.members.add(userId);
+    logger.log(`Created btw fork session ${forkedSession.id} in thread ${thread.id} from ${sessionId}`);
+    const sourceThreadLink = `<#${sourceThread.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,
+        username,
+        appId,
+        mode: 'opencode',
+    });
+    return {
+        thread,
+        forkedSessionId: forkedSession.id,
+    };
+}
 export async function handleBtwCommand({ command, appId, }) {
     const channel = command.channel;
     if (!channel) {
@@ -18,21 +76,19 @@ export async function handleBtwCommand({ command, appId, }) {
         });
         return;
     }
-    const isThread = [
-        ChannelType.PublicThread,
-        ChannelType.PrivateThread,
-        ChannelType.AnnouncementThread,
-    ].includes(channel.type);
-    if (!isThread) {
+    if (channel.type !== ChannelType.PublicThread
+        && channel.type !== ChannelType.PrivateThread
+        && channel.type !== ChannelType.AnnouncementThread) {
         await command.reply({
             content: 'This command can only be used in a thread with an active session',
             flags: MessageFlags.Ephemeral,
         });
         return;
     }
+    const threadChannel = channel;
     const prompt = command.options.getString('prompt', true);
     const resolved = await resolveWorkingDirectory({
-        channel: channel,
+        channel: threadChannel,
     });
     if (!resolved) {
         await command.reply({
@@ -42,72 +98,21 @@ export async function handleBtwCommand({ command, appId, }) {
         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,
+        const result = await forkSessionToBtwThread({
+            sourceThread: threadChannel,
             projectDirectory,
-            sdkDirectory: projectDirectory,
-            channelId: textChannel.id,
-            appId,
-        });
-        await runtime.enqueueIncoming({
-            prompt: wrappedPrompt,
+            prompt,
             userId: command.user.id,
             username: command.user.displayName,
             appId,
-            mode: 'opencode',
         });
-        await command.editReply(`Session forked! Continue in ${thread.toString()}`);
+        if (result instanceof Error) {
+            await command.editReply(result.message);
+            return;
+        }
+        await command.editReply(`Session forked! Continue in ${result.thread.toString()}`);
     }
     catch (error) {
         logger.error('Error in /btw:', error);

package/dist/commands/new-worktree.js

@@ -11,6 +11,18 @@ import { createWorktreeWithSubmodules, execAsync, listBranchesByLastCommit, vali
 import { WORKTREE_PREFIX } from './merge-worktree.js';
 import * as errore from 'errore';
 const logger = createLogger(LogPrefix.WORKTREE);
+const DEFAULT_WORKTREE_BASE_REF = 'HEAD';
+async function resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch, }) {
+    if (!rawBaseBranch) {
+        // Default to the current local HEAD so worktrees can branch from
+        // unpublished commits in the main checkout.
+        return DEFAULT_WORKTREE_BASE_REF;
+    }
+    return validateBranchRef({
+        directory: projectDirectory,
+        ref: rawBaseBranch,
+    });
+}
 /** Status message shown while a worktree is being created. */
 export function worktreeCreatingMessage(worktreeName) {
     return `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`;
@@ -22,24 +34,78 @@ class WorktreeError extends Error {
     }
 }
 /**
- * Format worktree name: lowercase, spaces to dashes, remove special chars, add opencode/kimaki- prefix.
- * "My Feature" → "opencode/kimaki-my-feature"
- * Returns empty string if no valid name can be extracted.
+ * Lowercase, collapse whitespace to dashes, drop non-[a-z0-9-] chars.
+ * Does NOT add the `opencode/kimaki-` prefix — callers do that so they can
+ * optionally compress the slug first for auto-derived names.
  */
-export function formatWorktreeName(name) {
-    const formatted = name
+export function slugifyWorktreeName(name) {
+    return name
         .toLowerCase()
         .trim()
         .replace(/\s+/g, '-')
         .replace(/[^a-z0-9-]/g, '');
-    if (!formatted) {
+}
+/**
+ * Compress a slug by stripping vowels from each dash-separated word, but
+ * keeping the first character so the word stays recognizable.
+ * Only applied to slugs longer than 20 chars — short names are left alone.
+ *
+ * "configurable-sidebar-width-by-component" → "cnfgrbl-sdbr-wdth-by-cmpnnt"
+ *
+ * Used ONLY for auto-derived worktree names (thread name, prompt slug)
+ * so long Discord titles don't produce 80-char folder paths that make
+ * the agent lazy and reuse the previous worktree. User-provided names
+ * via `--worktree <name>` or `/new-worktree name:` are never compressed.
+ */
+export function shortenWorktreeSlug(slug) {
+    if (slug.length <= 20) {
+        return slug;
+    }
+    const shortened = slug
+        .split('-')
+        .map((word) => {
+        if (!word) {
+            return word;
+        }
+        const first = word[0];
+        const rest = word.slice(1).replace(/[aeiou]/g, '');
+        return first + rest;
+    })
+        .join('-');
+    return shortened || slug;
+}
+/**
+ * Format worktree name: lowercase, spaces to dashes, remove special chars, add opencode/kimaki- prefix.
+ * "My Feature" → "opencode/kimaki-my-feature"
+ * Returns empty string if no valid name can be extracted.
+ *
+ * This is the "explicit" path used when the user provides a specific name.
+ * The slug is NOT compressed — if you ask for `my-long-explicit-branch-name`
+ * you get `opencode/kimaki-my-long-explicit-branch-name` verbatim.
+ */
+export function formatWorktreeName(name) {
+    const slug = slugifyWorktreeName(name);
+    if (!slug) {
+        return '';
+    }
+    return `opencode/kimaki-${slug}`;
+}
+/**
+ * Format an auto-derived worktree name (from a Discord thread title or a
+ * prompt). Same as formatWorktreeName but compresses slugs longer than 20
+ * chars by stripping vowels so the on-disk folder name stays short.
+ */
+export function formatAutoWorktreeName(name) {
+    const slug = slugifyWorktreeName(name);
+    if (!slug) {
         return '';
     }
-    return `opencode/kimaki-${formatted}`;
+    return `opencode/kimaki-${shortenWorktreeSlug(slug)}`;
 }
 /**
  * Derive worktree name from thread name.
  * Handles existing "⬦ worktree: opencode/kimaki-name" format or uses thread name directly.
+ * Uses formatAutoWorktreeName so long thread titles get vowel-compressed.
  */
 function deriveWorktreeNameFromThread(threadName) {
     // Handle existing "⬦ worktree: opencode/kimaki-name" format
@@ -50,10 +116,10 @@ function deriveWorktreeNameFromThread(threadName) {
         if (extractedName.startsWith('opencode/kimaki-')) {
             return extractedName;
         }
-        return formatWorktreeName(extractedName);
+        return formatAutoWorktreeName(extractedName);
     }
-    // Use thread name directly
-    return formatWorktreeName(threadName);
+    // Use thread name directly (compressed if > 20 chars)
+    return formatAutoWorktreeName(threadName);
 }
 /**
  * Get project directory from database.
@@ -169,10 +235,9 @@ export async function handleNewWorktreeCommand({ command, }) {
         await command.editReply('Cannot determine channel');
         return;
     }
-    const isThread = channel.type === ChannelType.PublicThread ||
-        channel.type === ChannelType.PrivateThread;
     // Handle command in existing thread - attach worktree to this thread
-    if (isThread) {
+    if (channel.type === ChannelType.PublicThread ||
+        channel.type === ChannelType.PrivateThread) {
         await handleWorktreeInThread({
             command,
             thread: channel,
@@ -201,17 +266,13 @@ export async function handleNewWorktreeCommand({ command, }) {
         await command.editReply(projectDirectory.message);
         return;
     }
-    let baseBranch = rawBaseBranch;
-    if (baseBranch) {
-        const validated = await validateBranchRef({
-            directory: projectDirectory,
-            ref: baseBranch,
-        });
-        if (validated instanceof Error) {
-            await command.editReply(`Invalid base branch: \`${baseBranch}\``);
-            return;
-        }
-        baseBranch = validated;
+    const baseBranch = await resolveRequestedWorktreeBaseRef({
+        projectDirectory,
+        rawBaseBranch,
+    });
+    if (baseBranch instanceof Error) {
+        await command.editReply(`Invalid base branch: \`${rawBaseBranch}\``);
+        return;
     }
     const existingWorktree = await findExistingWorktreePath({
         projectDirectory,
@@ -294,17 +355,13 @@ async function handleWorktreeInThread({ command, thread, }) {
         await command.editReply(projectDirectory.message);
         return;
     }
-    let baseBranch = rawBaseBranch;
-    if (baseBranch) {
-        const validated = await validateBranchRef({
-            directory: projectDirectory,
-            ref: baseBranch,
-        });
-        if (validated instanceof Error) {
-            await command.editReply(`Invalid base branch: \`${baseBranch}\``);
-            return;
-        }
-        baseBranch = validated;
+    const baseBranch = await resolveRequestedWorktreeBaseRef({
+        projectDirectory,
+        rawBaseBranch,
+    });
+    if (baseBranch instanceof Error) {
+        await command.editReply(`Invalid base branch: \`${rawBaseBranch}\``);
+        return;
     }
     const existingWorktreePath = await findExistingWorktreePath({
         projectDirectory,

package/dist/commands/queue.js

@@ -72,6 +72,7 @@ export async function handleQueueCommand({ command, appId, }) {
 }
 export async function handleClearQueueCommand({ command, }) {
     const channel = command.channel;
+    const position = command.options.getInteger('position') ?? undefined;
     if (!channel) {
         await command.reply({
             content: 'This command can only be used in a channel',
@@ -100,6 +101,22 @@ export async function handleClearQueueCommand({ command, }) {
         });
         return;
     }
+    if (position !== undefined) {
+        const removed = runtime?.removeQueuePosition(position);
+        if (!removed) {
+            await command.reply({
+                content: `No queued message at position ${position}`,
+                flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+            });
+            return;
+        }
+        await command.reply({
+            content: `Cleared queued message at position ${position}`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        logger.log(`[QUEUE] User ${command.user.displayName} cleared queued position ${position} in thread ${channel.id}`);
+        return;
+    }
     runtime?.clearQueue();
     await command.reply({
         content: `Cleared ${queueLength} queued message${queueLength > 1 ? 's' : ''}`,