@otto-assistant/otto 0.1.2 → 0.7.16

package/src/commands/discord-commands-group-b.test.ts

@@ -0,0 +1,648 @@
+import { ChannelType, MessageFlags, type ChatInputCommandInteraction } 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,
+}: {
+  channel: ChatInputCommandInteraction['channel']
+  guildId?: string | null
+  getString?: (name: string, required?: boolean) => string | null
+}) {
+  const reply = vi.fn(async (_options: unknown) => {
+    return {}
+  })
+  const editReply = vi.fn(async (_options: unknown) => {
+    return {}
+  })
+  const deferReply = vi.fn(async (_options: unknown) => {
+    return {}
+  })
+
+  return {
+    command: {
+      channel,
+      guildId,
+      channelId: channel?.id || 'chan-1',
+      user: {
+        id: 'user-1',
+        displayName: 'SerhiiD',
+      },
+      client: { rest: {} },
+      options: {
+        getString: vi.fn((name: string, required?: boolean) => {
+          if (getString) {
+            return getString(name, required)
+          }
+          return null
+        }),
+      },
+      reply,
+      editReply,
+      deferReply,
+    } as unknown as ChatInputCommandInteraction,
+    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 } as never,
+      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 } as never,
+      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() as never,
+      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() as never,
+    })
+    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() as never,
+    })
+    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() as never,
+      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() as never,
+    })
+    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 } as never,
+    })
+    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
+        }),
+      },
+    } as never)
+    const { command, reply } = createCommand({
+      channel: { id: 'chan-1', type: ChannelType.GuildText } as never,
+    })
+    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 as never)
+    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/*'],
+      } as never,
+      requestIds: ['perm-1'],
+      directory: '/repo',
+      permissionDirectory: '/repo',
+      thread: { id: 'thread-1' } as never,
+      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() as never,
+    })
+    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() as never,
+    })
+    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,
+      } as never,
+    })
+    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,
+      } as never,
+      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,
+      }
+    `)
+  })
+})