@otto-assistant/otto 0.1.2 → 0.7.15

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

@@ -0,0 +1,621 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { ChannelType, MessageFlags } from 'discord.js';
+import fs from 'node:fs';
+const mocks = vi.hoisted(() => {
+    return {
+        getChannelDirectory: vi.fn(),
+        setThreadSession: vi.fn(),
+        setPartMessagesBatch: vi.fn(),
+        getAllThreadSessionIds: vi.fn(),
+        getThreadSession: vi.fn(),
+        setChannelModel: vi.fn(),
+        setSessionModel: vi.fn(),
+        setSessionAgent: vi.fn(),
+        getChannelModel: vi.fn(),
+        getSessionModel: vi.fn(),
+        getSessionAgent: vi.fn(),
+        getChannelAgent: vi.fn(),
+        getGlobalModel: vi.fn(),
+        setGlobalModel: vi.fn(),
+        getVariantCascade: vi.fn(),
+        clearSessionModel: vi.fn(),
+        initializeOpencodeForDirectory: vi.fn(),
+        getOpencodeClient: vi.fn(),
+        getDefaultModel: vi.fn(),
+        resolveWorkingDirectory: vi.fn(),
+        resolveProjectDirectoryFromAutocomplete: vi.fn(),
+        sendThreadMessage: vi.fn(),
+        resolveTextChannel: vi.fn(),
+        getOttoMetadata: vi.fn(),
+        getRuntime: vi.fn(),
+        getOrCreateRuntime: vi.fn(),
+        collectSessionChunks: vi.fn(),
+        batchChunksForDiscord: vi.fn(),
+        getThinkingValuesForModel: vi.fn(),
+    };
+});
+const mockGetChannelDirectory = mocks.getChannelDirectory;
+const mockSetThreadSession = mocks.setThreadSession;
+const mockSetPartMessagesBatch = mocks.setPartMessagesBatch;
+const mockGetAllThreadSessionIds = mocks.getAllThreadSessionIds;
+const mockGetThreadSession = mocks.getThreadSession;
+const mockSetChannelModel = mocks.setChannelModel;
+const mockSetSessionModel = mocks.setSessionModel;
+const mockSetSessionAgent = mocks.setSessionAgent;
+const mockGetChannelModel = mocks.getChannelModel;
+const mockGetSessionModel = mocks.getSessionModel;
+const mockGetSessionAgent = mocks.getSessionAgent;
+const mockGetChannelAgent = mocks.getChannelAgent;
+const mockGetGlobalModel = mocks.getGlobalModel;
+const mockSetGlobalModel = mocks.setGlobalModel;
+const mockGetVariantCascade = mocks.getVariantCascade;
+const mockClearSessionModel = mocks.clearSessionModel;
+const mockInitializeOpencodeForDirectory = mocks.initializeOpencodeForDirectory;
+const mockGetOpencodeClient = mocks.getOpencodeClient;
+const mockGetDefaultModel = mocks.getDefaultModel;
+const mockResolveWorkingDirectory = mocks.resolveWorkingDirectory;
+const mockResolveProjectDirectoryFromAutocomplete = mocks.resolveProjectDirectoryFromAutocomplete;
+const mockSendThreadMessage = mocks.sendThreadMessage;
+const mockResolveTextChannel = mocks.resolveTextChannel;
+const mockGetOttoMetadata = mocks.getOttoMetadata;
+const mockGetRuntime = mocks.getRuntime;
+const mockGetOrCreateRuntime = mocks.getOrCreateRuntime;
+const mockCollectSessionChunks = mocks.collectSessionChunks;
+const mockBatchChunksForDiscord = mocks.batchChunksForDiscord;
+const mockGetThinkingValuesForModel = mocks.getThinkingValuesForModel;
+vi.mock('../database.js', () => {
+    return {
+        getChannelDirectory: mocks.getChannelDirectory,
+        setThreadSession: mocks.setThreadSession,
+        setPartMessagesBatch: mocks.setPartMessagesBatch,
+        getAllThreadSessionIds: mocks.getAllThreadSessionIds,
+        getThreadSession: mocks.getThreadSession,
+        setChannelModel: mocks.setChannelModel,
+        setSessionModel: mocks.setSessionModel,
+        setSessionAgent: mocks.setSessionAgent,
+        getChannelModel: mocks.getChannelModel,
+        getSessionModel: mocks.getSessionModel,
+        getSessionAgent: mocks.getSessionAgent,
+        getChannelAgent: mocks.getChannelAgent,
+        getGlobalModel: mocks.getGlobalModel,
+        setGlobalModel: mocks.setGlobalModel,
+        getVariantCascade: mocks.getVariantCascade,
+        clearSessionModel: mocks.clearSessionModel,
+    };
+});
+vi.mock('../opencode.js', () => {
+    return {
+        initializeOpencodeForDirectory: mocks.initializeOpencodeForDirectory,
+        getOpencodeClient: mocks.getOpencodeClient,
+    };
+});
+vi.mock('../session-handler/model-utils.js', () => {
+    return {
+        getDefaultModel: mocks.getDefaultModel,
+    };
+});
+vi.mock('../discord-utils.js', () => {
+    return {
+        resolveWorkingDirectory: mocks.resolveWorkingDirectory,
+        resolveProjectDirectoryFromAutocomplete: mocks.resolveProjectDirectoryFromAutocomplete,
+        sendThreadMessage: mocks.sendThreadMessage,
+        resolveTextChannel: mocks.resolveTextChannel,
+        getOttoMetadata: mocks.getOttoMetadata,
+        SILENT_MESSAGE_FLAGS: MessageFlags.SuppressNotifications,
+        NOTIFY_MESSAGE_FLAGS: MessageFlags.SuppressNotifications,
+    };
+});
+vi.mock('../session-handler/thread-session-runtime.js', () => {
+    return {
+        getRuntime: mocks.getRuntime,
+        getOrCreateRuntime: mocks.getOrCreateRuntime,
+    };
+});
+vi.mock('../message-formatting.js', () => {
+    return {
+        collectSessionChunks: mocks.collectSessionChunks,
+        batchChunksForDiscord: mocks.batchChunksForDiscord,
+    };
+});
+vi.mock('../thinking-utils.js', () => {
+    return {
+        getThinkingValuesForModel: mocks.getThinkingValuesForModel,
+    };
+});
+vi.mock('../sentry.js', () => {
+    return {
+        notifyError: vi.fn(),
+    };
+});
+vi.mock('../store.js', () => {
+    return {
+        store: {
+            getState: vi.fn(() => {
+                return { registeredUserCommands: [] };
+            }),
+        },
+    };
+});
+vi.mock('../logger.js', () => {
+    return {
+        LogPrefix: {
+            RESUME: 'resume',
+            SESSION: 'session',
+            ABORT: 'abort',
+            COMPACT: 'compact',
+            MODEL: 'model',
+            AGENT: 'agent',
+            QUEUE: 'queue',
+            UNDO_REDO: 'undo-redo',
+        },
+        createLogger: vi.fn(() => {
+            return {
+                log: vi.fn(),
+                warn: vi.fn(),
+                error: vi.fn(),
+            };
+        }),
+    };
+});
+import { handleResumeAutocomplete, handleResumeCommand, } from './resume.js';
+import { handleSessionCommand } from './session.js';
+import { handleAbortCommand } from './abort.js';
+import { handleCompactCommand } from './compact.js';
+import { handleModelCommand } from './model.js';
+import { handleAgentCommand } from './agent.js';
+import { handleQueueCommand, handleClearQueueCommand } from './queue.js';
+import { handleUndoCommand, handleRedoCommand } from './undo-redo.js';
+import { handleModelVariantCommand } from './model-variant.js';
+function createCommand({ channel, userDisplayName = 'SerhiiD', }) {
+    const options = {
+        getString: vi.fn(),
+        getInteger: vi.fn(),
+        getFocused: vi.fn(),
+        getFocusedTyped: vi.fn(),
+    };
+    const command = {
+        channel,
+        user: { id: 'user-1', displayName: userDisplayName },
+        options: {
+            getString: options.getString,
+            getInteger: options.getInteger,
+            getFocused: options.getFocused,
+            getFocusedTyped: options.getFocusedTyped,
+        },
+        deferReply: vi.fn(async (_arg) => undefined),
+        editReply: vi.fn(async (_arg) => undefined),
+        reply: vi.fn(async (_arg) => undefined),
+    };
+    return { command, options };
+}
+function createAutocompleteInteraction() {
+    return {
+        options: {
+            getFocused: vi.fn(),
+        },
+        respond: vi.fn(async (_arg) => undefined),
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetVariantCascade.mockResolvedValue(null);
+    mockGetDefaultModel.mockResolvedValue(undefined);
+    mockGetSessionModel.mockResolvedValue(undefined);
+    mockGetChannelModel.mockResolvedValue(undefined);
+    mockGetGlobalModel.mockResolvedValue(undefined);
+    mockGetSessionAgent.mockResolvedValue(undefined);
+    mockGetChannelAgent.mockResolvedValue(undefined);
+});
+describe('/resume', () => {
+    test('resumes selected session in a new thread', async () => {
+        vi.spyOn(fs, 'existsSync').mockReturnValue(true);
+        const thread = {
+            id: 'thread-1',
+            members: { add: vi.fn(async () => undefined) },
+            toString: () => '<#thread-1>',
+        };
+        const textChannel = {
+            id: 'channel-1',
+            type: ChannelType.GuildText,
+            threads: {
+                create: vi.fn(async () => thread),
+            },
+        };
+        const { command, options } = createCommand({ channel: textChannel });
+        options.getString.mockReturnValue('ses-1');
+        mockGetChannelDirectory.mockResolvedValue({ directory: '/repo' });
+        mockInitializeOpencodeForDirectory.mockResolvedValue(() => {
+            return {
+                session: {
+                    get: vi.fn(async () => {
+                        return { data: { title: 'Saved Session', time: { created: 0 } } };
+                    }),
+                    messages: vi.fn(async () => {
+                        return { data: [] };
+                    }),
+                },
+            };
+        });
+        mockCollectSessionChunks.mockReturnValue({ chunks: [], skippedCount: 0 });
+        mockBatchChunksForDiscord.mockReturnValue([]);
+        mockSendThreadMessage.mockResolvedValue({ id: 'msg-1' });
+        await handleResumeCommand({
+            command: command,
+            appId: 'app-1',
+        });
+        expect(command.editReply).toHaveBeenCalledWith('Resumed session "Saved Session" in <#thread-1>');
+        expect(mockSetThreadSession).toHaveBeenCalledWith('thread-1', 'ses-1');
+        const resumeReply = 'Resumed session "Saved Session" in <#thread-1>';
+        expect(resumeReply).toMatchInlineSnapshot(`"Resumed session "Saved Session" in <#thread-1>"`);
+    });
+    test('returns autocomplete options for matching sessions only', async () => {
+        const interaction = createAutocompleteInteraction();
+        interaction.options.getFocused.mockReturnValue('alpha');
+        mockResolveProjectDirectoryFromAutocomplete.mockResolvedValue('/repo');
+        mockGetAllThreadSessionIds.mockResolvedValue(['ses-used']);
+        mockInitializeOpencodeForDirectory.mockResolvedValue(() => {
+            return {
+                session: {
+                    list: vi.fn(async () => {
+                        return {
+                            data: [
+                                {
+                                    id: 'ses-1',
+                                    title: 'Alpha task',
+                                    time: { updated: 0 },
+                                },
+                                {
+                                    id: 'ses-used',
+                                    title: 'Alpha existing',
+                                    time: { updated: 0 },
+                                },
+                                {
+                                    id: 'ses-2',
+                                    title: 'Beta task',
+                                    time: { updated: 0 },
+                                },
+                            ],
+                        };
+                    }),
+                },
+            };
+        });
+        await handleResumeAutocomplete({
+            interaction: interaction,
+            appId: 'app-1',
+        });
+        const respondCalls = interaction.respond.mock.calls;
+        const firstResponse = respondCalls[0]?.[0];
+        const choices = Array.isArray(firstResponse) ? firstResponse : [];
+        const values = choices.map((choice) => {
+            return choice.value;
+        });
+        expect(values.join(',')).toMatchInlineSnapshot('"ses-1"');
+    });
+});
+describe('/new-session', () => {
+    test('creates session thread and enqueues prompt with files', async () => {
+        vi.spyOn(fs, 'existsSync').mockReturnValue(true);
+        const thread = {
+            id: 'thread-1',
+            members: { add: vi.fn(async () => undefined) },
+            toString: () => '<#thread-1>',
+        };
+        const starterMessage = {
+            startThread: vi.fn(async () => thread),
+        };
+        const textChannel = {
+            id: 'channel-1',
+            type: ChannelType.GuildText,
+            send: vi.fn(async () => starterMessage),
+        };
+        const { command, options } = createCommand({ channel: textChannel });
+        options.getString.mockImplementation((name) => {
+            if (name === 'prompt') {
+                return 'Fix typing bug';
+            }
+            if (name === 'files') {
+                return 'src/a.ts, src/b.ts';
+            }
+            return null;
+        });
+        mockGetChannelDirectory.mockResolvedValue({ directory: '/repo' });
+        mockInitializeOpencodeForDirectory.mockResolvedValue(() => {
+            return {};
+        });
+        const enqueueIncoming = vi.fn(async () => undefined);
+        mockGetOrCreateRuntime.mockReturnValue({ enqueueIncoming });
+        await handleSessionCommand({
+            command: command,
+            appId: 'app-1',
+        });
+        expect(command.editReply).toHaveBeenCalledWith('Created new session in <#thread-1>');
+        const enqueueCalls = enqueueIncoming.mock.calls;
+        const enqueueInput = (enqueueCalls[0]?.[0] || {});
+        expect(enqueueInput.prompt || '').toMatchInlineSnapshot(`
+      "Fix typing bug
+
+      @src/a.ts @src/b.ts"
+    `);
+    });
+});
+describe('/abort', () => {
+    test('aborts active runtime in thread', async () => {
+        const thread = { id: 'thread-1', type: ChannelType.PublicThread };
+        const { command } = createCommand({ channel: thread });
+        mockResolveWorkingDirectory.mockResolvedValue({
+            projectDirectory: '/repo',
+            workingDirectory: '/repo',
+        });
+        mockGetThreadSession.mockResolvedValue('ses-1');
+        const abortActiveRun = vi.fn();
+        mockGetRuntime.mockReturnValue({ abortActiveRun });
+        await handleAbortCommand({ command: command, appId: 'app-1' });
+        expect(abortActiveRun).toHaveBeenCalledWith('user-requested');
+        const abortReply = 'Request **aborted**';
+        expect(abortReply).toMatchInlineSnapshot('"Request **aborted**"');
+    });
+});
+describe('/compact', () => {
+    test('compacts session using last user model', async () => {
+        const thread = { id: 'thread-1', type: ChannelType.PublicThread };
+        const { command } = createCommand({ channel: thread });
+        mockResolveWorkingDirectory.mockResolvedValue({
+            projectDirectory: '/repo',
+            workingDirectory: '/repo/wt',
+        });
+        mockGetThreadSession.mockResolvedValue('ses-1');
+        mockInitializeOpencodeForDirectory.mockResolvedValue(() => {
+            return {};
+        });
+        mockGetOpencodeClient.mockReturnValue({
+            session: {
+                messages: vi.fn(async () => {
+                    return {
+                        data: [
+                            {
+                                info: {
+                                    role: 'user',
+                                    model: { providerID: 'openai', modelID: 'gpt-5' },
+                                },
+                            },
+                        ],
+                    };
+                }),
+                summarize: vi.fn(async () => {
+                    return { data: {} };
+                }),
+            },
+        });
+        await handleCompactCommand({ command: command, appId: 'app-1' });
+        const compactReply = '📦 Session **compacted** successfully';
+        expect(compactReply).toMatchInlineSnapshot('"📦 Session **compacted** successfully"');
+    });
+});
+describe('/model', () => {
+    test('shows providers and current channel override', async () => {
+        const textChannel = { id: 'channel-1', type: ChannelType.GuildText };
+        const { command } = createCommand({ channel: textChannel });
+        mockGetOttoMetadata.mockResolvedValue({ projectDirectory: '/repo' });
+        mockGetChannelModel.mockResolvedValue({ modelId: 'openai/gpt-5' });
+        mockInitializeOpencodeForDirectory.mockResolvedValue(() => {
+            return {
+                provider: {
+                    list: vi.fn(async () => {
+                        return {
+                            data: {
+                                all: [
+                                    {
+                                        id: 'openai',
+                                        name: 'OpenAI',
+                                        models: { 'gpt-5': { id: 'gpt-5', name: 'GPT-5' } },
+                                    },
+                                ],
+                                connected: ['openai'],
+                            },
+                        };
+                    }),
+                },
+            };
+        });
+        await handleModelCommand({
+            interaction: command,
+            appId: 'app-1',
+        });
+        const modelHeader = '**Set Model Preference**\n**Current (channel override):** `openai/gpt-5`\nSelect a provider:';
+        expect(modelHeader).toMatchInlineSnapshot(`
+      "**Set Model Preference**
+      **Current (channel override):** \`openai/gpt-5\`
+      Select a provider:"
+    `);
+    });
+});
+describe('/agent', () => {
+    test('shows selectable agents and current channel override', async () => {
+        const textChannel = { id: 'channel-1', type: ChannelType.GuildText };
+        const { command } = createCommand({ channel: textChannel });
+        mockGetOttoMetadata.mockResolvedValue({ projectDirectory: '/repo' });
+        mockGetChannelAgent.mockResolvedValue('plan');
+        mockInitializeOpencodeForDirectory.mockResolvedValue(() => {
+            return {
+                app: {
+                    agents: vi.fn(async () => {
+                        return {
+                            data: [
+                                { name: 'plan', mode: 'primary', description: 'Planning' },
+                                { name: 'build', mode: 'primary', description: 'Building' },
+                            ],
+                        };
+                    }),
+                },
+            };
+        });
+        await handleAgentCommand({
+            interaction: command,
+            appId: 'app-1',
+        });
+        const agentHeader = '**Set Agent Preference**\n**Current (channel override):** `plan`\nSelect an agent:';
+        expect(agentHeader).toMatchInlineSnapshot(`
+      "**Set Agent Preference**
+      **Current (channel override):** \`plan\`
+      Select an agent:"
+    `);
+    });
+});
+describe('/queue and /clear-queue', () => {
+    test('/queue enqueues message and confirms queue position', async () => {
+        const thread = {
+            id: 'thread-1',
+            parentId: 'channel-1',
+            type: ChannelType.PublicThread,
+        };
+        const { command, options } = createCommand({ channel: thread });
+        options.getString.mockReturnValue('Run tests after this');
+        mockGetThreadSession.mockResolvedValue('ses-1');
+        mockResolveWorkingDirectory.mockResolvedValue({
+            projectDirectory: '/repo',
+            workingDirectory: '/repo',
+        });
+        mockGetOrCreateRuntime.mockReturnValue({
+            enqueueIncoming: vi.fn(async () => {
+                return { queued: true, position: 2 };
+            }),
+        });
+        await handleQueueCommand({ command: command, appId: 'app-1' });
+        const queueReply = 'Queued message (position 2)';
+        expect(queueReply).toMatchInlineSnapshot('"Queued message (position 2)"');
+    });
+    test('/clear-queue removes specific position', async () => {
+        const thread = { id: 'thread-1', type: ChannelType.PublicThread };
+        const { command, options } = createCommand({ channel: thread });
+        options.getInteger.mockReturnValue(2);
+        mockGetRuntime.mockReturnValue({
+            getQueueLength: () => 3,
+            removeQueuePosition: () => true,
+        });
+        await handleClearQueueCommand({ command: command, appId: 'app-1' });
+        const clearQueueReply = 'Cleared queued message at position 2';
+        expect(clearQueueReply).toMatchInlineSnapshot('"Cleared queued message at position 2"');
+    });
+});
+describe('/undo and /redo', () => {
+    test('/undo reverts to previous assistant message', async () => {
+        const thread = { id: 'thread-1', type: ChannelType.PublicThread };
+        const { command } = createCommand({ channel: thread });
+        mockResolveWorkingDirectory.mockResolvedValue({
+            projectDirectory: '/repo',
+            workingDirectory: '/repo',
+        });
+        mockGetThreadSession.mockResolvedValue('ses-1');
+        const client = {
+            session: {
+                get: vi.fn(async () => {
+                    return { data: { revert: undefined } };
+                }),
+                status: vi.fn(async () => {
+                    return { data: {} };
+                }),
+                messages: vi.fn(async () => {
+                    return {
+                        data: [
+                            { info: { id: 'u1', role: 'user' } },
+                            { info: { id: 'a1', role: 'assistant', parentID: 'u1' } },
+                        ],
+                    };
+                }),
+                revert: vi.fn(async () => {
+                    return { data: { revert: { diff: '' } } };
+                }),
+            },
+        };
+        mockInitializeOpencodeForDirectory.mockResolvedValue(() => client);
+        await handleUndoCommand({ command: command, appId: 'app-1' });
+        const undoReply = 'Undone - reverted last assistant message';
+        expect(undoReply).toMatchInlineSnapshot('"Undone - reverted last assistant message"');
+    });
+    test('/redo reports when nothing can be redone', async () => {
+        const thread = { id: 'thread-1', type: ChannelType.PublicThread };
+        const { command } = createCommand({ channel: thread });
+        mockResolveWorkingDirectory.mockResolvedValue({
+            projectDirectory: '/repo',
+            workingDirectory: '/repo',
+        });
+        mockGetThreadSession.mockResolvedValue('ses-1');
+        const client = {
+            session: {
+                get: vi.fn(async () => {
+                    return { data: { revert: undefined } };
+                }),
+            },
+        };
+        mockInitializeOpencodeForDirectory.mockResolvedValue(() => client);
+        await handleRedoCommand({ command: command, appId: 'app-1' });
+        const redoReply = 'Nothing to redo - no previous undo found';
+        expect(redoReply).toMatchInlineSnapshot('"Nothing to redo - no previous undo found"');
+    });
+});
+describe('/model-variant', () => {
+    test('returns message when no model is configured', async () => {
+        const textChannel = { id: 'channel-1', type: ChannelType.GuildText };
+        const { command } = createCommand({ channel: textChannel });
+        mockGetOttoMetadata.mockResolvedValue({ projectDirectory: '/repo' });
+        mockInitializeOpencodeForDirectory.mockResolvedValue(() => {
+            return {
+                provider: {
+                    list: vi.fn(async () => {
+                        return { data: { all: [], connected: [] } };
+                    }),
+                },
+            };
+        });
+        await handleModelVariantCommand({
+            interaction: command,
+            appId: 'app-1',
+        });
+        const noModelReply = 'No model configured. Use `/model` to set one first.';
+        expect(noModelReply).toMatchInlineSnapshot('"No model configured. Use `/model` to set one first."');
+    });
+    test('shows variant and scope menus for current model', async () => {
+        const textChannel = { id: 'channel-1', type: ChannelType.GuildText };
+        const { command } = createCommand({ channel: textChannel });
+        mockGetOttoMetadata.mockResolvedValue({ projectDirectory: '/repo' });
+        mockGetChannelModel.mockResolvedValue({ modelId: 'openai/gpt-5' });
+        mockGetVariantCascade.mockResolvedValue('high');
+        mockGetThinkingValuesForModel.mockReturnValue(['low', 'high']);
+        mockInitializeOpencodeForDirectory.mockResolvedValue(() => {
+            return {
+                provider: {
+                    list: vi.fn(async () => {
+                        return {
+                            data: {
+                                all: [
+                                    {
+                                        id: 'openai',
+                                        name: 'OpenAI',
+                                        models: {
+                                            'gpt-5': {
+                                                id: 'gpt-5',
+                                                name: 'GPT-5',
+                                                release_date: '2026-01-01',
+                                            },
+                                        },
+                                    },
+                                ],
+                                connected: ['openai'],
+                            },
+                        };
+                    }),
+                },
+            };
+        });
+        await handleModelVariantCommand({
+            interaction: command,
+            appId: 'app-1',
+        });
+        const variantHeader = '**Current model:** `openai/gpt-5` (high) — channel override\nSelect a thinking level and where to apply it:';
+        expect(variantHeader).toMatchInlineSnapshot(`
+      "**Current model:** \`openai/gpt-5\` (high) — channel override
+      Select a thinking level and where to apply it:"
+    `);
+    });
+});