@otto-assistant/bridge 0.4.102 → 0.4.103

package/dist/thread-message-queue.e2e.test.js

@@ -748,6 +748,115 @@ e2eTest('thread message queue ordering', () => {
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
     }, 12_000);
+    test('/clear-queue position clears only that queued message', async () => {
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: clear-queue-setup',
+        });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: clear-queue-setup';
+            },
+        });
+        const th = discord.thread(thread.id);
+        await th.waitForBotReply({ timeout: 4_000 });
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+        });
+        await th.user(TEST_USER_ID).runSlashCommand({
+            name: 'queue',
+            options: [{ name: 'message', type: 3, value: 'Reply with exactly: race-final' }],
+        });
+        const { id: secondQueueInteractionId } = await th.user(TEST_USER_ID)
+            .runSlashCommand({
+            name: 'queue',
+            options: [{ name: 'message', type: 3, value: 'Reply with exactly: removed-queued-message' }],
+        });
+        const secondQueueAck = await th.waitForInteractionAck({
+            interactionId: secondQueueInteractionId,
+            timeout: 4_000,
+        });
+        if (!secondQueueAck.messageId) {
+            throw new Error('Expected second /queue response message id');
+        }
+        const secondQueueAckMessage = await waitForMessageById({
+            discord,
+            threadId: thread.id,
+            messageId: secondQueueAck.messageId,
+            timeout: 4_000,
+        });
+        expect(secondQueueAckMessage.content).toContain('Queued message (position 1)');
+        const { id: thirdQueueInteractionId } = await th.user(TEST_USER_ID).runSlashCommand({
+            name: 'queue',
+            options: [{ name: 'message', type: 3, value: 'Reply with exactly: kept-queued-message' }],
+        });
+        const thirdQueueAck = await th.waitForInteractionAck({
+            interactionId: thirdQueueInteractionId,
+            timeout: 4_000,
+        });
+        if (!thirdQueueAck.messageId) {
+            throw new Error('Expected third /queue response message id');
+        }
+        const thirdQueueAckMessage = await waitForMessageById({
+            discord,
+            threadId: thread.id,
+            messageId: thirdQueueAck.messageId,
+            timeout: 4_000,
+        });
+        expect(thirdQueueAckMessage.content).toContain('Queued message (position 2)');
+        const { id: clearInteractionId } = await th.user(TEST_USER_ID).runSlashCommand({
+            name: 'clear-queue',
+            options: [{ name: 'position', type: 4, value: 1 }],
+        });
+        const clearAck = await th.waitForInteractionAck({
+            interactionId: clearInteractionId,
+            timeout: 4_000,
+        });
+        if (!clearAck.messageId) {
+            throw new Error('Expected /clear-queue response message id');
+        }
+        const clearAckMessage = await waitForMessageById({
+            discord,
+            threadId: thread.id,
+            messageId: clearAck.messageId,
+            timeout: 4_000,
+        });
+        expect(clearAckMessage.content).toBe('Cleared queued message at position 1');
+        await waitForBotMessageContaining({
+            discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: '» **queue-tester:** Reply with exactly: kept-queued-message',
+            afterMessageId: clearAckMessage.id,
+            timeout: 8_000,
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 8_000,
+            afterMessageIncludes: '⬥ ok',
+            afterAuthorId: discord.botUserId,
+        });
+        const threadText = await th.text();
+        expect(threadText).toMatchInlineSnapshot(`
+        "--- from: user (queue-tester)
+        Reply with exactly: clear-queue-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        » **queue-tester:** Reply with exactly: race-final
+        Queued message (position 1)
+        Queued message (position 2)
+        Cleared queued message at position 1
+        ⬥ race-final
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        » **queue-tester:** Reply with exactly: kept-queued-message"
+      `);
+        expect(threadText).not.toContain('removed-queued-message');
+        expect(threadText).toContain('kept-queued-message');
+    }, 12_000);
     test('queued message waits for running session and then processes next', async () => {
         // When a new message arrives while a session is running, it queues and
         // runs after the in-flight request completes.

package/dist/worktree-lifecycle.e2e.test.js

@@ -293,7 +293,10 @@ describe('worktree lifecycle', () => {
         expect(runtimeAfter).toBe(runtimeBefore);
         // sdkDirectory should now point to the worktree path
         expect(runtimeAfter.sdkDirectory).not.toBe(directories.projectDirectory);
-        expect(runtimeAfter.sdkDirectory).toContain(`kimaki-${WORKTREE_NAME}`);
+        // Folder name drops the `opencode-kimaki-` prefix (branch name keeps it).
+        // See getManagedWorktreeDirectory in worktrees.ts.
+        expect(runtimeAfter.sdkDirectory).toContain(WORKTREE_NAME);
+        expect(runtimeAfter.sdkDirectory).toContain(`${path.sep}worktrees${path.sep}`);
         // Snapshot uses dynamic worktree name so we verify structure, not exact text
         const text = await th.text();
         expect(text).toContain('Reply with exactly: before-worktree');

package/dist/worktrees.js

@@ -3,9 +3,9 @@
 // submodule initialization, and git diff transfer utilities.
 import crypto from 'node:crypto';
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import * as errore from 'errore';
+import { getDataDir } from './config.js';
 import { execAsync } from './exec-async.js';
 import { createLogger, LogPrefix } from './logger.js';
 export { execAsync } from './exec-async.js';
@@ -396,10 +396,32 @@ async function validateSubmodulePointers(directory) {
 async function resolveDefaultWorktreeTarget(directory) {
     return 'HEAD';
 }
-function getManagedWorktreeDirectory({ directory, name, }) {
-    const projectHash = crypto.createHash('sha1').update(directory).digest('hex');
-    const safeName = name.replaceAll('/', '-');
-    return path.join(os.homedir(), '.local', 'share', 'opencode', 'worktree', projectHash, safeName);
+/**
+ * Build the on-disk directory for a managed worktree.
+ *
+ * Layout: `<kimakiDataDir>/worktrees/<8charProjectHash>/<basename>`
+ *
+ * - Lives under the kimaki data dir instead of the long
+ *   `~/.local/share/opencode/worktree/<40-char-hash>/<name>` path so folder
+ *   names stay short and readable (agents tend to give up and reuse the old
+ *   worktree when paths get absurdly long).
+ * - The 8-char project hash keeps worktrees from different projects that
+ *   happen to share a slug from colliding.
+ * - Strips the `opencode/kimaki-` (or `opencode-kimaki-`) prefix from the
+ *   folder name since it's redundant noise on disk. The git branch name
+ *   itself still uses `opencode/kimaki-<slug>` so merge/cleanup logic is
+ *   unchanged.
+ */
+export function getManagedWorktreeDirectory({ directory, name, }) {
+    const projectHash = crypto
+        .createHash('sha1')
+        .update(directory)
+        .digest('hex')
+        .slice(0, 8);
+    const withoutPrefix = name
+        .replace(/^opencode\/kimaki-/, '')
+        .replaceAll('/', '-');
+    return path.join(getDataDir(), 'worktrees', projectHash, withoutPrefix);
 }
 /**
  * Create a worktree using git and initialize git submodules.
@@ -527,19 +549,22 @@ export async function deleteWorktree({ projectDirectory, worktreeDirectory, work
         }
     }
     if (removeResult instanceof Error) {
-        return new Error(`Failed to remove worktree ${worktreeName}`, {
+        return new Error(`Failed to remove worktree ${worktreeName || worktreeDirectory}`, {
             cause: removeResult,
         });
     }
-    const deleteBranchResult = await git(projectDirectory, `branch -d ${JSON.stringify(worktreeName)}`);
-    if (deleteBranchResult instanceof Error) {
-        return new Error(`Failed to delete branch ${worktreeName}`, {
-            cause: deleteBranchResult,
-        });
+    // Skip branch deletion for detached HEAD worktrees (no branch to delete)
+    if (worktreeName) {
+        const deleteBranchResult = await git(projectDirectory, `branch -d ${JSON.stringify(worktreeName)}`);
+        if (deleteBranchResult instanceof Error) {
+            return new Error(`Failed to delete branch ${worktreeName}`, {
+                cause: deleteBranchResult,
+            });
+        }
     }
     const pruneResult = await git(projectDirectory, 'worktree prune');
     if (pruneResult instanceof Error) {
-        logger.warn(`Failed to prune worktrees after deleting ${worktreeName}`);
+        logger.warn(`Failed to prune worktrees after deleting ${worktreeName || worktreeDirectory}`);
     }
 }
 export async function isDirty(dir, opts) {
@@ -894,3 +919,72 @@ export async function validateWorktreeDirectory({ projectDirectory, candidatePat
     }
     return absoluteCandidate;
 }
+function flushGitWorktreeEntry(current) {
+    if (!current.directory) {
+        return null;
+    }
+    return {
+        directory: current.directory,
+        branch: current.branch ?? null,
+        head: current.head ?? '',
+        detached: current.detached ?? false,
+        locked: current.locked ?? false,
+        prunable: current.prunable ?? false,
+    };
+}
+// Parse `git worktree list --porcelain` output into structured entries.
+// Skips the first entry (the main checkout) since that's the project root.
+export function parseGitWorktreeListPorcelain(output) {
+    const entries = [];
+    let current = {};
+    for (const line of output.split('\n')) {
+        if (line.startsWith('worktree ')) {
+            const flushed = flushGitWorktreeEntry(current);
+            if (flushed) {
+                entries.push(flushed);
+            }
+            current = { directory: line.slice('worktree '.length) };
+            continue;
+        }
+        if (line.startsWith('HEAD ')) {
+            current.head = line.slice('HEAD '.length);
+            continue;
+        }
+        if (line.startsWith('branch ')) {
+            // "branch refs/heads/opencode/kimaki-foo" → "opencode/kimaki-foo"
+            current.branch = line.slice('branch '.length).replace(/^refs\/heads\//, '');
+            continue;
+        }
+        if (line === 'detached') {
+            current.detached = true;
+            continue;
+        }
+        // "locked" or "locked <reason>"
+        if (line === 'locked' || line.startsWith('locked ')) {
+            current.locked = true;
+            continue;
+        }
+        if (line.startsWith('prunable')) {
+            current.prunable = true;
+            continue;
+        }
+    }
+    // Flush last entry
+    const flushed = flushGitWorktreeEntry(current);
+    if (flushed) {
+        entries.push(flushed);
+    }
+    // Skip the first entry — it's the main checkout (project root)
+    return entries.slice(1);
+}
+// List all git worktrees for a project directory (excluding the main checkout).
+// Returns Error on git failure, empty array if no worktrees exist.
+export async function listGitWorktrees({ projectDirectory, timeout, }) {
+    const result = await git(projectDirectory, 'worktree list --porcelain', {
+        timeout,
+    });
+    if (result instanceof Error) {
+        return result;
+    }
+    return parseGitWorktreeListPorcelain(result);
+}

package/dist/worktrees.test.js

@@ -3,17 +3,17 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { describe, expect, test } from 'vitest';
-import { buildSubmoduleReferencePlan, createWorktreeWithSubmodules, execAsync, parseGitmodulesFileContent, } from './worktrees.js';
+import { buildSubmoduleReferencePlan, createWorktreeWithSubmodules, execAsync, getManagedWorktreeDirectory, parseGitmodulesFileContent, parseGitWorktreeListPorcelain, } from './worktrees.js';
+import { formatAutoWorktreeName, formatWorktreeName, shortenWorktreeSlug, } from './commands/new-worktree.js';
+import { setDataDir } from './config.js';
 const GIT_TIMEOUT_MS = 60_000;
-function gitCommand(args) {
-    return `git ${args
+async function git({ cwd, args, }) {
+    const command = `git ${args
         .map((arg) => {
         return JSON.stringify(arg);
     })
         .join(' ')}`;
-}
-async function git({ cwd, args, }) {
-    const result = await execAsync(gitCommand(args), {
+    const result = await execAsync(command, {
         cwd,
         timeout: GIT_TIMEOUT_MS,
     });
@@ -186,4 +186,230 @@ describe('worktrees', () => {
             fs.rmSync(sandbox, { recursive: true, force: true });
         }
     });
+    test('createWorktreeWithSubmodules uses current HEAD even when origin does not have the commit', async () => {
+        const sandbox = createTestRoot();
+        const parentRemote = path.join(sandbox, 'parent-remote.git');
+        const parentLocal = path.join(sandbox, 'parent-local');
+        const worktreeName = `opencode/kimaki-local-head-${Date.now()}`;
+        let createdWorktreeDirectory = '';
+        try {
+            await git({ cwd: sandbox, args: ['init', '--bare', '-b', 'main', parentRemote] });
+            await git({ cwd: sandbox, args: ['clone', parentRemote, parentLocal] });
+            await git({
+                cwd: parentLocal,
+                args: ['config', 'user.email', 'kimaki-tests@example.com'],
+            });
+            await git({
+                cwd: parentLocal,
+                args: ['config', 'user.name', 'Kimaki Tests'],
+            });
+            fs.writeFileSync(path.join(parentLocal, 'README.md'), 'v1\n', 'utf-8');
+            await git({ cwd: parentLocal, args: ['add', 'README.md'] });
+            await git({ cwd: parentLocal, args: ['commit', '-m', 'v1'] });
+            await git({ cwd: parentLocal, args: ['push', 'origin', 'HEAD:main'] });
+            fs.writeFileSync(path.join(parentLocal, 'README.md'), 'v2-local-only\n', 'utf-8');
+            await git({ cwd: parentLocal, args: ['commit', '-am', 'v2 local only'] });
+            const localHeadSha = await git({
+                cwd: parentLocal,
+                args: ['rev-parse', 'HEAD'],
+            });
+            const originHeadSha = await git({
+                cwd: parentLocal,
+                args: ['rev-parse', 'origin/main'],
+            });
+            const worktreeResult = await createWorktreeWithSubmodules({
+                directory: parentLocal,
+                name: worktreeName,
+            });
+            if (worktreeResult instanceof Error) {
+                throw worktreeResult;
+            }
+            createdWorktreeDirectory = worktreeResult.directory;
+            const worktreeHeadSha = await git({
+                cwd: createdWorktreeDirectory,
+                args: ['rev-parse', 'HEAD'],
+            });
+            expect({
+                localHeadShaLength: localHeadSha.length,
+                originHeadShaLength: originHeadSha.length,
+                worktreeHeadShaLength: worktreeHeadSha.length,
+                usesLocalOnlyHead: localHeadSha === worktreeHeadSha,
+                differsFromOrigin: localHeadSha !== originHeadSha,
+            }).toMatchInlineSnapshot(`
+        {
+          "differsFromOrigin": true,
+          "localHeadShaLength": 40,
+          "originHeadShaLength": 40,
+          "usesLocalOnlyHead": true,
+          "worktreeHeadShaLength": 40,
+        }
+      `);
+        }
+        finally {
+            if (createdWorktreeDirectory) {
+                await git({
+                    cwd: parentLocal,
+                    args: ['worktree', 'remove', '--force', createdWorktreeDirectory],
+                }).catch(() => {
+                    return '';
+                });
+            }
+            fs.rmSync(sandbox, { recursive: true, force: true });
+        }
+    });
+    test('shortenWorktreeSlug leaves short slugs alone', () => {
+        expect(shortenWorktreeSlug('short-name')).toMatchInlineSnapshot(`"short-name"`);
+        expect(shortenWorktreeSlug('exactly-twenty-chars')).toMatchInlineSnapshot(`"exactly-twenty-chars"`);
+    });
+    test('shortenWorktreeSlug strips vowels from long slugs', () => {
+        expect(shortenWorktreeSlug('configurable-sidebar-width-by-component')).toMatchInlineSnapshot(`"cnfgrbl-sdbr-wdth-by-cmpnnt"`);
+        expect(shortenWorktreeSlug('add-dark-mode-toggle-to-settings-page')).toMatchInlineSnapshot(`"add-drk-md-tggl-t-sttngs-pg"`);
+    });
+    test('formatWorktreeName keeps user-provided slugs verbatim', () => {
+        expect(formatWorktreeName('Configurable sidebar width by component')).toMatchInlineSnapshot(`"opencode/kimaki-configurable-sidebar-width-by-component"`);
+        expect(formatWorktreeName('my-feature')).toMatchInlineSnapshot(`"opencode/kimaki-my-feature"`);
+    });
+    test('formatAutoWorktreeName compresses long auto-derived slugs', () => {
+        expect(formatAutoWorktreeName('Configurable sidebar width by component')).toMatchInlineSnapshot(`"opencode/kimaki-cnfgrbl-sdbr-wdth-by-cmpnnt"`);
+        expect(formatAutoWorktreeName('my-feature')).toMatchInlineSnapshot(`"opencode/kimaki-my-feature"`);
+    });
+    test('getManagedWorktreeDirectory writes under kimaki data dir and strips prefix', () => {
+        const sandbox = createTestRoot();
+        try {
+            setDataDir(sandbox);
+            const dir = getManagedWorktreeDirectory({
+                directory: '/Users/test/projects/my-app',
+                name: 'opencode/kimaki-cnfgrbl-sdbr-wdth-by-cmpnnt',
+            });
+            // Must sit inside <dataDir>/worktrees/<8hash>/<basename>
+            const rel = path.relative(sandbox, dir);
+            const parts = rel.split(path.sep);
+            expect({
+                topLevel: parts[0],
+                hashLength: parts[1]?.length,
+                basename: parts[2],
+                partsCount: parts.length,
+            }).toMatchInlineSnapshot(`
+        {
+          "basename": "cnfgrbl-sdbr-wdth-by-cmpnnt",
+          "hashLength": 8,
+          "partsCount": 3,
+          "topLevel": "worktrees",
+        }
+      `);
+        }
+        finally {
+            fs.rmSync(sandbox, { recursive: true, force: true });
+        }
+    });
+});
+describe('parseGitWorktreeListPorcelain', () => {
+    test('parses porcelain output, skips main worktree', () => {
+        const output = [
+            'worktree /Users/me/project',
+            'HEAD abc123',
+            'branch refs/heads/main',
+            '',
+            'worktree /Users/me/.local/share/opencode/worktree/hash/opencode-kimaki-feature',
+            'HEAD def456',
+            'branch refs/heads/opencode/kimaki-feature',
+            '',
+            'worktree /Users/me/project-manual-wt',
+            'HEAD 789abc',
+            'branch refs/heads/my-branch',
+            '',
+        ].join('\n');
+        expect(parseGitWorktreeListPorcelain(output)).toMatchInlineSnapshot(`
+      [
+        {
+          "branch": "opencode/kimaki-feature",
+          "detached": false,
+          "directory": "/Users/me/.local/share/opencode/worktree/hash/opencode-kimaki-feature",
+          "head": "def456",
+          "locked": false,
+          "prunable": false,
+        },
+        {
+          "branch": "my-branch",
+          "detached": false,
+          "directory": "/Users/me/project-manual-wt",
+          "head": "789abc",
+          "locked": false,
+          "prunable": false,
+        },
+      ]
+    `);
+    });
+    test('handles detached HEAD worktrees', () => {
+        const output = [
+            'worktree /Users/me/project',
+            'HEAD abc123',
+            'branch refs/heads/main',
+            '',
+            'worktree /Users/me/detached-wt',
+            'HEAD deadbeef',
+            'detached',
+            '',
+        ].join('\n');
+        const result = parseGitWorktreeListPorcelain(output);
+        expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "branch": null,
+          "detached": true,
+          "directory": "/Users/me/detached-wt",
+          "head": "deadbeef",
+          "locked": false,
+          "prunable": false,
+        },
+      ]
+    `);
+    });
+    test('parses locked and prunable flags', () => {
+        const output = [
+            'worktree /Users/me/project',
+            'HEAD abc123',
+            'branch refs/heads/main',
+            '',
+            'worktree /Users/me/locked-wt',
+            'HEAD aaa111',
+            'branch refs/heads/feature-locked',
+            'locked portable disk',
+            '',
+            'worktree /Users/me/prunable-wt',
+            'HEAD bbb222',
+            'branch refs/heads/stale-branch',
+            'prunable gitdir file points to non-existent location',
+            '',
+        ].join('\n');
+        expect(parseGitWorktreeListPorcelain(output)).toMatchInlineSnapshot(`
+      [
+        {
+          "branch": "feature-locked",
+          "detached": false,
+          "directory": "/Users/me/locked-wt",
+          "head": "aaa111",
+          "locked": true,
+          "prunable": false,
+        },
+        {
+          "branch": "stale-branch",
+          "detached": false,
+          "directory": "/Users/me/prunable-wt",
+          "head": "bbb222",
+          "locked": false,
+          "prunable": true,
+        },
+      ]
+    `);
+    });
+    test('returns empty array when only main worktree exists', () => {
+        const output = [
+            'worktree /Users/me/project',
+            'HEAD abc123',
+            'branch refs/heads/main',
+            '',
+        ].join('\n');
+        expect(parseGitWorktreeListPorcelain(output)).toMatchInlineSnapshot(`[]`);
+    });
 });

package/package.json

@@ -2,7 +2,7 @@
   "name": "@otto-assistant/bridge",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.102",
+  "version": "0.4.103",
   "scripts": {
     "dev": "tsx src/bin.ts",
     "prepublishOnly": "pnpm generate && pnpm tsc",
@@ -70,7 +70,7 @@
     "discord.js": "^14.25.1",
     "domhandler": "^6.0.1",
     "errore": "workspace:^",
-    "goke": "^6.3.2",
+    "goke": "^6.6.0",
     "htmlparser2": "^12.0.0",
     "kitty-graphics-agent": "^0.0.5",
     "libsql": "^0.5.22",