@otto-assistant/otto 0.1.2 → 0.7.16

package/dist/commands/discord-commands-group-b.test.js

@@ -0,0 +1,595 @@
+import { ChannelType, MessageFlags } from 'discord.js';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+const mocks = vi.hoisted(() => {
+    return {
+        getThreadSession: vi.fn(),
+        getThreadWorktree: vi.fn(),
+        getChannelDirectory: vi.fn(),
+        getSessionEventSnapshot: vi.fn(),
+        getChannelMentionMode: vi.fn(),
+        setChannelMentionMode: vi.fn(),
+        getChannelVerbosity: vi.fn(),
+        setChannelVerbosity: vi.fn(),
+        getThreadDeletionSyncMode: vi.fn(),
+        setThreadDeletionSyncMode: vi.fn(),
+        resetThreadDeletionSyncMode: vi.fn(),
+        resolveWorkingDirectory: vi.fn(),
+        getOttoMetadata: vi.fn(),
+        initializeOpencodeForDirectory: vi.fn(),
+        getOpencodeServerPort: vi.fn(),
+        validateBranchRef: vi.fn(),
+        getDerivedSubagentSessions: vi.fn(),
+        uploadGitDiffViaCritique: vi.fn(),
+        getPrisma: vi.fn(),
+    };
+});
+vi.mock('../database.js', () => {
+    return {
+        getThreadSession: mocks.getThreadSession,
+        getThreadWorktree: mocks.getThreadWorktree,
+        getChannelDirectory: mocks.getChannelDirectory,
+        getSessionEventSnapshot: mocks.getSessionEventSnapshot,
+        getChannelMentionMode: mocks.getChannelMentionMode,
+        setChannelMentionMode: mocks.setChannelMentionMode,
+        getChannelVerbosity: mocks.getChannelVerbosity,
+        setChannelVerbosity: mocks.setChannelVerbosity,
+        getThreadDeletionSyncMode: mocks.getThreadDeletionSyncMode,
+        setThreadDeletionSyncMode: mocks.setThreadDeletionSyncMode,
+        resetThreadDeletionSyncMode: mocks.resetThreadDeletionSyncMode,
+        setThreadSession: vi.fn(),
+        setPartMessagesBatch: vi.fn(),
+    };
+});
+vi.mock('../discord-utils.js', () => {
+    return {
+        SILENT_MESSAGE_FLAGS: 0,
+        NOTIFY_MESSAGE_FLAGS: 0,
+        resolveWorkingDirectory: mocks.resolveWorkingDirectory,
+        resolveTextChannel: vi.fn(),
+        sendThreadMessage: vi.fn(),
+        getOttoMetadata: mocks.getOttoMetadata,
+        reactToThread: vi.fn(),
+        resolveProjectDirectoryFromAutocomplete: vi.fn(),
+    };
+});
+vi.mock('../opencode.js', () => {
+    return {
+        initializeOpencodeForDirectory: mocks.initializeOpencodeForDirectory,
+        getOpencodeServerPort: mocks.getOpencodeServerPort,
+        getOpencodeClient: vi.fn(),
+        buildExternalDirectoryPermissionRules: vi.fn(),
+    };
+});
+vi.mock('../worktrees.js', () => {
+    return {
+        validateBranchRef: mocks.validateBranchRef,
+        mergeWorktree: vi.fn(),
+        listBranchesByLastCommit: vi.fn(),
+        listGitWorktrees: vi.fn(),
+        getDefaultBranch: vi.fn(),
+        git: vi.fn(),
+        execAsync: vi.fn(),
+        createWorktreeWithSubmodules: vi.fn(),
+        deleteWorktree: vi.fn(),
+    };
+});
+vi.mock('../session-handler/event-stream-state.js', () => {
+    return {
+        getDerivedSubagentSessions: mocks.getDerivedSubagentSessions,
+    };
+});
+vi.mock('../db.js', () => {
+    return {
+        getPrisma: mocks.getPrisma,
+    };
+});
+vi.mock('../store.js', () => {
+    return {
+        store: {
+            getState: () => {
+                return { defaultVerbosity: 'text_and_essential_tools' };
+            },
+        },
+    };
+});
+vi.mock('../format-tables.js', () => {
+    return {
+        splitTablesFromMarkdown: vi.fn(),
+    };
+});
+vi.mock('../html-actions.js', () => {
+    return {
+        buildHtmlActionCustomId: vi.fn(),
+        cancelHtmlActionsForOwner: vi.fn(),
+        registerHtmlAction: vi.fn(),
+    };
+});
+vi.mock('../message-formatting.js', () => {
+    return {
+        collectSessionChunks: vi.fn(() => {
+            return { chunks: [] };
+        }),
+        batchChunksForDiscord: vi.fn(() => {
+            return [];
+        }),
+    };
+});
+vi.mock('../session-handler/thread-session-runtime.js', () => {
+    return {
+        getOrCreateRuntime: vi.fn(),
+    };
+});
+vi.mock('../critique-utils.js', () => {
+    return {
+        uploadGitDiffViaCritique: mocks.uploadGitDiffViaCritique,
+    };
+});
+import { handleWorktreesCommand } from './worktrees.js';
+import { handleNewWorktreeCommand } from './new-worktree.js';
+import { handleMergeWorktreeCommand } from './merge-worktree.js';
+import { handleForkCommand } from './fork.js';
+import { handleForkSubagentCommand } from './fork-subagent.js';
+import { handleBtwCommand } from './btw.js';
+import { handleShareCommand } from './share.js';
+import { handleDiffCommand } from './diff.js';
+import { handleVerbosityCommand, handleVerbositySelectMenu, } from './verbosity.js';
+import { addPermissionRequestToContext, arePatternsCoveredBy, cleanupPermissionContext, compactPermissionPatterns, pendingPermissionContexts, } from './permissions.js';
+import { handleContextUsageCommand } from './context-usage.js';
+import { handleSessionIdCommand } from './session-id.js';
+import { handleToggleMentionModeCommand } from './mention-mode.js';
+import { handleThreadDeletionSyncCommand } from './thread-deletion-sync.js';
+function createThreadChannel() {
+    return {
+        id: 'thread-1',
+        type: ChannelType.PublicThread,
+        parentId: 'chan-1',
+        name: 'thread name',
+        isThread: () => {
+            return true;
+        },
+        parent: {
+            id: 'chan-1',
+            type: ChannelType.GuildText,
+            name: 'project-room',
+        },
+        toString: () => {
+            return '<#thread-1>';
+        },
+    };
+}
+function createCommand({ channel, guildId = 'guild-1', getString, }) {
+    const reply = vi.fn(async (_options) => {
+        return {};
+    });
+    const editReply = vi.fn(async (_options) => {
+        return {};
+    });
+    const deferReply = vi.fn(async (_options) => {
+        return {};
+    });
+    return {
+        command: {
+            channel,
+            guildId,
+            channelId: channel?.id || 'chan-1',
+            user: {
+                id: 'user-1',
+                displayName: 'SerhiiD',
+            },
+            client: { rest: {} },
+            options: {
+                getString: vi.fn((name, required) => {
+                    if (getString) {
+                        return getString(name, required);
+                    }
+                    return null;
+                }),
+            },
+            reply,
+            editReply,
+            deferReply,
+        },
+        reply,
+        editReply,
+        deferReply,
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    pendingPermissionContexts.clear();
+});
+describe('discord commands group b', () => {
+    test('/worktrees server-only guard', async () => {
+        const { command, reply } = createCommand({
+            channel: { id: 'chan-1', type: ChannelType.GuildText },
+            guildId: null,
+        });
+        await handleWorktreesCommand({ command, appId: 'app-1' });
+        expect(reply.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          {
+            "content": "This command can only be used in a server channel.",
+            "flags": 64,
+          },
+        ],
+      ]
+    `);
+    });
+    test('/new-worktree invalid base-branch', async () => {
+        vi.mocked(mocks.getChannelDirectory).mockResolvedValue({
+            directory: process.cwd(),
+        });
+        vi.mocked(mocks.validateBranchRef).mockResolvedValue(new Error('invalid'));
+        const { command, editReply } = createCommand({
+            channel: { id: 'chan-1', type: ChannelType.GuildText },
+            getString: (name) => {
+                if (name === 'name') {
+                    return 'feature one';
+                }
+                if (name === 'base-branch') {
+                    return 'bad/ref';
+                }
+                return null;
+            },
+        });
+        await handleNewWorktreeCommand({ command, appId: 'app-1' });
+        expect(editReply.mock.calls).toEqual([['Invalid base branch: `bad/ref`']]);
+    });
+    test('/merge-worktree invalid target-branch', async () => {
+        vi.mocked(mocks.getThreadWorktree).mockResolvedValue({
+            thread_id: 'thread-1',
+            status: 'ready',
+            worktree_directory: '/repo/worktree',
+            project_directory: '/repo',
+            worktree_name: 'opencode/otto-feature',
+            error_message: null,
+        });
+        vi.mocked(mocks.validateBranchRef).mockResolvedValue(new Error('invalid'));
+        const { command, editReply } = createCommand({
+            channel: createThreadChannel(),
+            getString: (name) => {
+                if (name === 'target-branch') {
+                    return 'main~bad';
+                }
+                return null;
+            },
+        });
+        await handleMergeWorktreeCommand({ command, appId: 'app-1' });
+        expect(editReply.mock.calls).toEqual([['Invalid target branch: `main~bad`']]);
+    });
+    test('/fork no active session', async () => {
+        vi.mocked(mocks.resolveWorkingDirectory).mockResolvedValue({
+            projectDirectory: '/repo',
+            workingDirectory: '/repo',
+            channelAppId: undefined,
+        });
+        vi.mocked(mocks.getThreadSession).mockResolvedValue(null);
+        const { command, reply } = createCommand({
+            channel: createThreadChannel(),
+        });
+        await handleForkCommand(command);
+        expect(reply.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          {
+            "content": "No active session in this thread",
+            "flags": 64,
+          },
+        ],
+      ]
+    `);
+    });
+    test('/fork-subagent no active session', async () => {
+        vi.mocked(mocks.resolveWorkingDirectory).mockResolvedValue({
+            projectDirectory: '/repo',
+            workingDirectory: '/repo',
+            channelAppId: undefined,
+        });
+        vi.mocked(mocks.getThreadSession).mockResolvedValue(null);
+        const { command, reply } = createCommand({
+            channel: createThreadChannel(),
+        });
+        await handleForkSubagentCommand(command);
+        expect(reply.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          {
+            "content": "No active session in this thread",
+            "flags": 64,
+          },
+        ],
+      ]
+    `);
+    });
+    test('/btw no active session', async () => {
+        vi.mocked(mocks.resolveWorkingDirectory).mockResolvedValue({
+            projectDirectory: '/repo',
+            workingDirectory: '/repo',
+            channelAppId: undefined,
+        });
+        vi.mocked(mocks.getThreadSession).mockResolvedValue(null);
+        const { command, editReply } = createCommand({
+            channel: createThreadChannel(),
+            getString: () => {
+                return 'side question';
+            },
+        });
+        await handleBtwCommand({ command, appId: 'app-1' });
+        expect(editReply.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          "No active session in this thread",
+        ],
+      ]
+    `);
+    });
+    test('/share no active session', async () => {
+        vi.mocked(mocks.resolveWorkingDirectory).mockResolvedValue({
+            projectDirectory: '/repo',
+            workingDirectory: '/repo',
+            channelAppId: undefined,
+        });
+        vi.mocked(mocks.getThreadSession).mockResolvedValue(null);
+        const { command, reply } = createCommand({
+            channel: createThreadChannel(),
+        });
+        await handleShareCommand({ command, appId: 'app-1' });
+        expect(reply.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          {
+            "content": "No active session in this thread",
+            "flags": 64,
+          },
+        ],
+      ]
+    `);
+    });
+    test('/diff invalid channel type', async () => {
+        const { command, reply } = createCommand({
+            channel: { id: 'chan-1', type: ChannelType.DM },
+        });
+        await handleDiffCommand({ command, appId: 'app-1' });
+        expect(reply.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          {
+            "content": "This command can only be used in a text channel or thread",
+            "flags": 64,
+          },
+        ],
+      ]
+    `);
+    });
+    test('/verbosity command shows current source', async () => {
+        vi.mocked(mocks.getPrisma).mockResolvedValue({
+            channel_verbosity: {
+                findUnique: vi.fn(async () => {
+                    return null;
+                }),
+            },
+        });
+        const { command, reply } = createCommand({
+            channel: { id: 'chan-1', type: ChannelType.GuildText },
+        });
+        await handleVerbosityCommand({ command, appId: 'app-1' });
+        expect(reply).toHaveBeenCalledTimes(1);
+        expect(reply).toHaveBeenCalledWith(expect.objectContaining({
+            content: '**Verbosity**\nCurrent: `text_and_essential_tools` (global default)',
+            flags: MessageFlags.Ephemeral,
+        }));
+    });
+    test('/verbosity select no level selected', async () => {
+        const interaction = {
+            customId: 'verbosity_select:chan-1',
+            values: [],
+            deferUpdate: vi.fn(async () => {
+                return {};
+            }),
+            editReply: vi.fn(async () => {
+                return {};
+            }),
+        };
+        await handleVerbositySelectMenu(interaction);
+        expect(interaction.editReply.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          {
+            "components": [],
+            "content": "No level selected.",
+          },
+        ],
+      ]
+    `);
+    });
+    test('permissions helper logic', () => {
+        pendingPermissionContexts.set('ctx', {
+            permission: {
+                id: 'perm-1',
+                permission: 'bash',
+                patterns: ['/repo/*'],
+            },
+            requestIds: ['perm-1'],
+            directory: '/repo',
+            permissionDirectory: '/repo',
+            thread: { id: 'thread-1' },
+            contextHash: 'ctx',
+            messageId: 'msg-1',
+        });
+        const covered = arePatternsCoveredBy({
+            patterns: ['/repo', '/repo/src/*'],
+            coveringPatterns: ['/repo*'],
+        });
+        const compacted = compactPermissionPatterns([
+            '/repo/*',
+            '/repo/src/*',
+            '/repo/*',
+        ]);
+        const added = addPermissionRequestToContext({
+            contextHash: 'ctx',
+            requestId: 'perm-2',
+        });
+        cleanupPermissionContext('ctx');
+        expect({ covered, compacted, added, exists: pendingPermissionContexts.has('ctx') }).toMatchInlineSnapshot(`
+      {
+        "added": true,
+        "compacted": [
+          "/repo/*",
+        ],
+        "covered": true,
+        "exists": false,
+      }
+    `);
+    });
+    test('/context-usage no assistant messages', async () => {
+        vi.mocked(mocks.resolveWorkingDirectory).mockResolvedValue({
+            projectDirectory: '/repo',
+            workingDirectory: '/repo',
+            channelAppId: undefined,
+        });
+        vi.mocked(mocks.getThreadSession).mockResolvedValue('ses-1');
+        vi.mocked(mocks.initializeOpencodeForDirectory).mockResolvedValue(() => {
+            return {
+                session: {
+                    messages: vi.fn(async () => {
+                        return {
+                            data: [{ info: { role: 'user' } }],
+                        };
+                    }),
+                },
+            };
+        });
+        const { command, editReply } = createCommand({
+            channel: createThreadChannel(),
+        });
+        await handleContextUsageCommand({ command, appId: 'app-1' });
+        expect(editReply.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          {
+            "content": "No assistant messages in this session yet",
+          },
+        ],
+      ]
+    `);
+    });
+    test('/session-id missing server port', async () => {
+        vi.mocked(mocks.resolveWorkingDirectory).mockResolvedValue({
+            projectDirectory: '/repo',
+            workingDirectory: '/repo',
+            channelAppId: undefined,
+        });
+        vi.mocked(mocks.getThreadSession).mockResolvedValue('ses-1');
+        vi.mocked(mocks.getOpencodeServerPort).mockReturnValue(undefined);
+        vi.mocked(mocks.initializeOpencodeForDirectory).mockResolvedValue(() => {
+            return {};
+        });
+        const { command, editReply } = createCommand({
+            channel: createThreadChannel(),
+        });
+        await handleSessionIdCommand({ command, appId: 'app-1' });
+        expect(editReply.mock.calls).toEqual([
+            [
+                {
+                    content: [
+                        'Session ID: `ses-1`',
+                        'Could not determine OpenCode server port',
+                    ].join('\n'),
+                },
+            ],
+        ]);
+    });
+    test('/mention-mode toggle in project channel', async () => {
+        vi.mocked(mocks.getOttoMetadata).mockResolvedValue({
+            projectDirectory: '/repo',
+        });
+        vi.mocked(mocks.getChannelMentionMode).mockResolvedValue(false);
+        const { command, reply } = createCommand({
+            channel: {
+                id: 'chan-1',
+                name: 'project-room',
+                type: ChannelType.GuildText,
+            },
+        });
+        await handleToggleMentionModeCommand({ command, appId: 'app-1' });
+        expect(reply.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          {
+            "content": "Mention mode **enabled** for this channel.
+      The bot will only start new sessions when @mentioned.
+      Messages in existing threads are not affected.",
+            "flags": 64,
+          },
+        ],
+      ]
+    `);
+    });
+    test('/thread-deletion-sync reset', async () => {
+        const { command, reply } = createCommand({
+            channel: {
+                id: 'chan-1',
+                name: 'project-room',
+                type: ChannelType.GuildText,
+            },
+            getString: () => {
+                return 'reset';
+            },
+        });
+        await handleThreadDeletionSyncCommand({ command, appId: 'app-1' });
+        expect(reply.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          {
+            "content": "Thread deletion sync mode reset to **soft** (default).
+      Soft keeps the OpenCode session and only archives/aborts it.",
+            "flags": 64,
+          },
+        ],
+      ]
+    `);
+    });
+    test('coverage checklist snapshot', () => {
+        expect([
+            'worktrees',
+            'new-worktree',
+            'merge-worktree',
+            'fork',
+            'fork-subagent',
+            'btw',
+            'share',
+            'diff',
+            'verbosity',
+            'permissions',
+            'context-usage',
+            'session-id',
+            'mention-mode',
+            'thread-deletion-sync',
+        ]).toMatchInlineSnapshot(`
+      [
+        "worktrees",
+        "new-worktree",
+        "merge-worktree",
+        "fork",
+        "fork-subagent",
+        "btw",
+        "share",
+        "diff",
+        "verbosity",
+        "permissions",
+        "context-usage",
+        "session-id",
+        "mention-mode",
+        "thread-deletion-sync",
+      ]
+    `);
+    });
+    test('ephemeral flag snapshot', () => {
+        expect({ ephemeral: MessageFlags.Ephemeral }).toMatchInlineSnapshot(`
+      {
+        "ephemeral": 64,
+      }
+    `);
+    });
+});