agent-messenger 1.0.0 → 1.2.0

package/src/platforms/discord/commands/member.ts

@@ -0,0 +1,59 @@
+import { Command } from 'commander'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+
+async function searchAction(
+  guildId: string,
+  query: string,
+  options: { limit?: string; pretty?: boolean }
+): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.token) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const client = new DiscordClient(config.token)
+    const limit = options.limit ? parseInt(options.limit, 10) : 10
+    const members = await client.searchMembers(guildId, query, limit)
+
+    const output = members.map((member) => ({
+      user: {
+        id: member.user.id,
+        username: member.user.username,
+        global_name: member.user.global_name,
+        avatar: member.user.avatar,
+        bot: member.user.bot,
+      },
+      nick: member.nick,
+      roles: member.roles,
+      joined_at: member.joined_at,
+      deaf: member.deaf,
+      mute: member.mute,
+      flags: member.flags,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const memberCommand = new Command('member')
+  .description('Member commands')
+  .addCommand(
+    new Command('search')
+      .description('Search guild members')
+      .argument('<guild-id>', 'Guild ID')
+      .argument('<query>', 'Search query')
+      .option('--limit <number>', 'Maximum number of results (default: 10)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(searchAction)
+  )

package/src/platforms/discord/commands/mention.test.ts

@@ -0,0 +1,129 @@
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+
+let clientGetMentionsSpy: ReturnType<typeof spyOn>
+let credManagerLoadSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  // Spy on DiscordClient.prototype methods
+  clientGetMentionsSpy = spyOn(DiscordClient.prototype, 'getMentions').mockResolvedValue([
+    {
+      id: 'msg-1',
+      channel_id: 'ch-1',
+      author: { id: 'user-1', username: 'alice' },
+      content: 'Hey @testuser check this out',
+      timestamp: '2024-01-29T10:00:00Z',
+      mention_everyone: false,
+      mentions: [{ id: 'user-me', username: 'testuser' }],
+      guild_id: 'guild-1',
+    },
+    {
+      id: 'msg-2',
+      channel_id: 'ch-2',
+      author: { id: 'user-2', username: 'bob' },
+      content: '@everyone important announcement',
+      timestamp: '2024-01-29T09:00:00Z',
+      mention_everyone: true,
+      mentions: [],
+      guild_id: 'guild-1',
+    },
+  ])
+
+  // Spy on DiscordCredentialManager.prototype methods
+  credManagerLoadSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue({
+    token: 'test-token',
+    current_server: 'server-1',
+    servers: {
+      'server-1': { server_id: 'server-1', server_name: 'Server One' },
+    },
+  })
+})
+
+afterEach(() => {
+  clientGetMentionsSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
+})
+
+test('getMentions: returns mentions', async () => {
+  // given: discord client
+  const client = new DiscordClient('test-token')
+
+  // when: getting mentions
+  const mentions = await client.getMentions()
+
+  // then: mentions are returned
+  expect(mentions).toBeDefined()
+  expect(mentions).toHaveLength(2)
+  expect(mentions[0].id).toBe('msg-1')
+  expect(mentions[0].author.username).toBe('alice')
+  expect(mentions[0].mentions).toHaveLength(1)
+  expect(mentions[1].mention_everyone).toBe(true)
+})
+
+test('getMentions: respects limit option', async () => {
+  // given: discord client with limit option
+  const client = new DiscordClient('test-token')
+  clientGetMentionsSpy.mockResolvedValue([
+    {
+      id: 'msg-1',
+      channel_id: 'ch-1',
+      author: { id: 'user-1', username: 'alice' },
+      content: 'Hey @testuser',
+      timestamp: '2024-01-29T10:00:00Z',
+      mention_everyone: false,
+      mentions: [{ id: 'user-me', username: 'testuser' }],
+    },
+  ])
+
+  // when: getting mentions with limit
+  const mentions = await client.getMentions({ limit: 1 })
+
+  // then: limit is respected
+  expect(mentions).toHaveLength(1)
+  expect(clientGetMentionsSpy).toHaveBeenCalledWith({ limit: 1 })
+})
+
+test('getMentions: respects guildId option', async () => {
+  // given: discord client with guildId option
+  const client = new DiscordClient('test-token')
+  clientGetMentionsSpy.mockResolvedValue([
+    {
+      id: 'msg-1',
+      channel_id: 'ch-1',
+      author: { id: 'user-1', username: 'alice' },
+      content: 'Hey @testuser',
+      timestamp: '2024-01-29T10:00:00Z',
+      mention_everyone: false,
+      mentions: [{ id: 'user-me', username: 'testuser' }],
+      guild_id: 'guild-1',
+    },
+  ])
+
+  // when: getting mentions with guildId
+  const mentions = await client.getMentions({ guildId: 'guild-1' })
+
+  // then: guildId is respected
+  expect(mentions).toHaveLength(1)
+  expect(mentions[0].guild_id).toBe('guild-1')
+  expect(clientGetMentionsSpy).toHaveBeenCalledWith({ guildId: 'guild-1' })
+})
+
+test('getMentions: includes mention metadata', async () => {
+  // given: discord client with mentions
+  const client = new DiscordClient('test-token')
+  const mentions = await client.getMentions()
+
+  // when: checking mention properties
+  const mention = mentions[0]
+
+  // then: mention has required fields
+  expect(mention.id).toBeDefined()
+  expect(mention.channel_id).toBeDefined()
+  expect(mention.author).toBeDefined()
+  expect(mention.author.username).toBeDefined()
+  expect(mention.content).toBeDefined()
+  expect(mention.timestamp).toBeDefined()
+  expect(mention.mention_everyone).toBeDefined()
+  expect(mention.mentions).toBeDefined()
+})

package/src/platforms/discord/commands/mention.ts

@@ -0,0 +1,59 @@
+import { Command } from 'commander'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+
+export async function listAction(options: {
+  limit?: number
+  guild?: string
+  pretty?: boolean
+}): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.token) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const client = new DiscordClient(config.token)
+    const mentions = await client.getMentions({
+      limit: options.limit,
+      guildId: options.guild,
+    })
+
+    const output = mentions.map((mention) => ({
+      id: mention.id,
+      channel_id: mention.channel_id,
+      author: mention.author.username,
+      content: mention.content,
+      timestamp: mention.timestamp,
+      mention_everyone: mention.mention_everyone,
+      mentioned_users: mention.mentions.map((u) => u.username),
+      guild_id: mention.guild_id || null,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const mentionCommand = new Command('mention').description('Mention commands').addCommand(
+  new Command('list')
+    .description('List mentions')
+    .option('--limit <n>', 'Number of mentions to fetch', '25')
+    .option('--guild <guild-id>', 'Filter by guild ID')
+    .option('--pretty', 'Pretty print JSON output')
+    .action((options) => {
+      listAction({
+        limit: options.limit ? parseInt(options.limit, 10) : undefined,
+        guild: options.guild,
+        pretty: options.pretty,
+      })
+    })
+)

package/src/platforms/discord/commands/message.test.ts

@@ -1,64 +1,97 @@
-import { beforeEach, expect, mock, test } from 'bun:test'
-import { deleteAction, getAction, listAction, sendAction } from './message'
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+import { ackAction, deleteAction, getAction, listAction, searchAction, sendAction } from './message'
+
+let clientSendMessageSpy: ReturnType<typeof spyOn>
+let clientGetMessagesSpy: ReturnType<typeof spyOn>
+let clientGetMessageSpy: ReturnType<typeof spyOn>
+let clientDeleteMessageSpy: ReturnType<typeof spyOn>
+let clientAckMessageSpy: ReturnType<typeof spyOn>
+let clientSearchMessagesSpy: ReturnType<typeof spyOn>
+let credManagerLoadSpy: ReturnType<typeof spyOn>
 
-mock.module('../client', () => ({
-  DiscordClient: mock(() => ({
-    sendMessage: mock(async () => ({
+beforeEach(() => {
+  // Spy on DiscordClient.prototype methods
+  clientSendMessageSpy = spyOn(DiscordClient.prototype, 'sendMessage').mockResolvedValue({
+    id: 'msg_123',
+    channel_id: 'ch_456',
+    author: { id: 'user_789', username: 'testuser' },
+    content: 'Hello world',
+    timestamp: '2025-01-29T10:00:00Z',
+  })
+
+  clientGetMessagesSpy = spyOn(DiscordClient.prototype, 'getMessages').mockResolvedValue([
+    {
       id: 'msg_123',
       channel_id: 'ch_456',
       author: { id: 'user_789', username: 'testuser' },
       content: 'Hello world',
       timestamp: '2025-01-29T10:00:00Z',
-    })),
-    getMessages: mock(async () => [
+    },
+    {
+      id: 'msg_124',
+      channel_id: 'ch_456',
+      author: { id: 'user_789', username: 'testuser' },
+      content: 'Second message',
+      timestamp: '2025-01-29T10:01:00Z',
+    },
+  ])
+
+  clientGetMessageSpy = spyOn(DiscordClient.prototype, 'getMessage').mockResolvedValue({
+    id: 'msg_123',
+    channel_id: 'ch_456',
+    author: { id: 'user_789', username: 'testuser' },
+    content: 'Hello world',
+    timestamp: '2025-01-29T10:00:00Z',
+  })
+
+  clientDeleteMessageSpy = spyOn(DiscordClient.prototype, 'deleteMessage').mockResolvedValue(
+    undefined
+  )
+
+  clientAckMessageSpy = spyOn(DiscordClient.prototype, 'ackMessage').mockResolvedValue(undefined)
+
+  clientSearchMessagesSpy = spyOn(DiscordClient.prototype, 'searchMessages').mockResolvedValue({
+    results: [
       {
-        id: 'msg_123',
+        id: 'msg_search_1',
         channel_id: 'ch_456',
-        author: { id: 'user_789', username: 'testuser' },
+        guild_id: 'server_123',
         content: 'Hello world',
+        author: { id: 'user_789', username: 'testuser' },
         timestamp: '2025-01-29T10:00:00Z',
+        hit: true,
       },
       {
-        id: 'msg_124',
+        id: 'msg_search_2',
         channel_id: 'ch_456',
+        guild_id: 'server_123',
+        content: 'Hello again',
         author: { id: 'user_789', username: 'testuser' },
-        content: 'Second message',
         timestamp: '2025-01-29T10:01:00Z',
+        hit: true,
       },
-    ]),
-    getMessage: mock(async () => ({
-      id: 'msg_123',
-      channel_id: 'ch_456',
-      author: { id: 'user_789', username: 'testuser' },
-      content: 'Hello world',
-      timestamp: '2025-01-29T10:00:00Z',
-    })),
-    deleteMessage: mock(async () => undefined),
-  })),
-}))
-
-mock.module('../credential-manager', () => ({
-  DiscordCredentialManager: mock(() => ({
-    load: mock(async () => ({
-      token: 'test_token',
-      current_guild: 'guild_123',
-      guilds: {},
-    })),
-  })),
-}))
-
-mock.module('../../../shared/utils/output', () => ({
-  formatOutput: (data: any, pretty?: boolean) => JSON.stringify(data, null, pretty ? 2 : 0),
-}))
-
-mock.module('../../../shared/utils/error-handler', () => ({
-  handleError: (error: Error) => {
-    console.error(error.message)
-  },
-}))
+    ],
+    total: 2,
+  })
+
+  // Spy on DiscordCredentialManager.prototype methods
+  credManagerLoadSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue({
+    token: 'test_token',
+    current_server: 'server_123',
+    servers: {},
+  })
+})
 
-beforeEach(() => {
-  mock.restore()
+afterEach(() => {
+  clientSendMessageSpy?.mockRestore()
+  clientGetMessagesSpy?.mockRestore()
+  clientGetMessageSpy?.mockRestore()
+  clientDeleteMessageSpy?.mockRestore()
+  clientAckMessageSpy?.mockRestore()
+  clientSearchMessagesSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
 })
 
 test('send: returns message with id', async () => {
@@ -105,3 +138,65 @@ test('delete: returns success', async () => {
   const output = consoleSpy.mock.calls[0][0]
   expect(output).toContain('deleted')
 })
+
+test('ack: returns success', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await ackAction('ch_456', 'msg_123', { pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('acknowledged')
+})
+
+test('search: returns search results with query', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await searchAction('Hello', { pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_search_1')
+  expect(output).toContain('msg_search_2')
+  expect(output).toContain('Hello world')
+})
+
+test('search: includes total_results in output', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await searchAction('Hello', { pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('total_results')
+  expect(output).toContain('2')
+})
+
+test('search: passes options to client', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await searchAction('test', {
+    channel: 'ch_specific',
+    author: 'user_specific',
+    has: 'image',
+    sort: 'timestamp',
+    sortDir: 'asc',
+    limit: 10,
+    offset: 5,
+    pretty: false,
+  })
+
+  expect(clientSearchMessagesSpy).toHaveBeenCalledWith('server_123', 'test', {
+    channelId: 'ch_specific',
+    authorId: 'user_specific',
+    has: 'image',
+    sortBy: 'timestamp',
+    sortOrder: 'asc',
+    limit: 10,
+    offset: 5,
+  })
+})

package/src/platforms/discord/commands/message.ts

@@ -3,7 +3,7 @@ import { handleError } from '../../../shared/utils/error-handler'
 import { formatOutput } from '../../../shared/utils/output'
 import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
-import type { DiscordMessage } from '../types'
+import type { DiscordMessage, DiscordSearchOptions } from '../types'
 
 export async function sendAction(
   channelId: string,
@@ -140,6 +140,106 @@ export async function deleteAction(
   }
 }
 
+export async function ackAction(
+  channelId: string,
+  messageId: string,
+  options: { pretty?: boolean }
+): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.token) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const client = new DiscordClient(config.token)
+    await client.ackMessage(channelId, messageId)
+
+    console.log(formatOutput({ acknowledged: messageId }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function searchAction(
+  query: string,
+  options: {
+    channel?: string
+    author?: string
+    has?: string
+    sort?: string
+    sortDir?: string
+    limit?: number
+    offset?: number
+    pretty?: boolean
+  }
+): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.token) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    if (!config.current_server) {
+      console.log(
+        formatOutput(
+          { error: 'No server selected. Run "server switch <server-id>" first.' },
+          options.pretty
+        )
+      )
+      process.exit(1)
+    }
+
+    const client = new DiscordClient(config.token)
+
+    const searchOptions: DiscordSearchOptions = {}
+    if (options.channel) searchOptions.channelId = options.channel
+    if (options.author) searchOptions.authorId = options.author
+    if (options.has) {
+      searchOptions.has = options.has as DiscordSearchOptions['has']
+    }
+    if (options.sort) {
+      searchOptions.sortBy = options.sort as DiscordSearchOptions['sortBy']
+    }
+    if (options.sortDir) {
+      searchOptions.sortOrder = options.sortDir as DiscordSearchOptions['sortOrder']
+    }
+    if (options.limit !== undefined) searchOptions.limit = options.limit
+    if (options.offset !== undefined) searchOptions.offset = options.offset
+
+    const { results, total } = await client.searchMessages(
+      config.current_server,
+      query,
+      searchOptions
+    )
+
+    const output = {
+      total_results: total,
+      results: results.map((msg) => ({
+        id: msg.id,
+        content: msg.content,
+        author_id: msg.author.id,
+        author_username: msg.author.username,
+        channel_id: msg.channel_id,
+        timestamp: msg.timestamp,
+      })),
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
 export const messageCommand = new Command('message')
   .description('Message commands')
   .addCommand(
@@ -180,3 +280,36 @@ export const messageCommand = new Command('message')
       .option('--pretty', 'Pretty print JSON output')
       .action(deleteAction)
   )
+  .addCommand(
+    new Command('ack')
+      .description('Mark message as read (acknowledge)')
+      .argument('<channel-id>', 'Channel ID')
+      .argument('<message-id>', 'Message ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(ackAction)
+  )
+  .addCommand(
+    new Command('search')
+      .description('Search messages in current server')
+      .argument('<query>', 'Search query')
+      .option('--channel <id>', 'Filter by channel ID')
+      .option('--author <id>', 'Filter by author ID')
+      .option('--has <type>', 'Filter by attachment type: file, image, video, embed, link, sticker')
+      .option('--sort <type>', 'Sort by: timestamp, relevance (default: timestamp)')
+      .option('--sort-dir <dir>', 'Sort direction: asc, desc (default: desc)')
+      .option('--limit <n>', 'Number of results (max 25)', '25')
+      .option('--offset <n>', 'Offset for pagination', '0')
+      .option('--pretty', 'Pretty print JSON output')
+      .action((query: string, options: any) => {
+        searchAction(query, {
+          channel: options.channel,
+          author: options.author,
+          has: options.has,
+          sort: options.sort,
+          sortDir: options.sortDir,
+          limit: parseInt(options.limit, 10),
+          offset: parseInt(options.offset, 10),
+          pretty: options.pretty,
+        })
+      })
+  )

package/src/platforms/discord/commands/note.test.ts

@@ -0,0 +1,84 @@
+import { expect, mock, test } from 'bun:test'
+
+// Mock DiscordClient
+const mockClient = {
+  getUserNote: mock(async (userId: string) => {
+    if (userId === 'user_with_note') {
+      return {
+        user_id: 'current_user_id',
+        note_user_id: userId,
+        note: 'This is a test note',
+      }
+    }
+    return null
+  }),
+  setUserNote: mock(async (userId: string, note: string) => {
+    return {
+      user_id: 'current_user_id',
+      note_user_id: userId,
+      note,
+    }
+  }),
+}
+
+test('get returns note when it exists', async () => {
+  // given: user with a note
+  const userId = 'user_with_note'
+
+  // when: getting user note
+  const result = await mockClient.getUserNote(userId)
+
+  // then: returns note object
+  expect(result).not.toBeNull()
+  expect(result?.note_user_id).toBe('user_with_note')
+  expect(result?.note).toBe('This is a test note')
+})
+
+test('get returns null when note does not exist', async () => {
+  // given: user without a note
+  const userId = 'user_without_note'
+
+  // when: getting user note
+  const result = await mockClient.getUserNote(userId)
+
+  // then: returns null
+  expect(result).toBeNull()
+})
+
+test('set creates or updates note', async () => {
+  // given: user id and note content
+  const userId = 'user123'
+  const noteContent = 'Important person to remember'
+
+  // when: setting user note
+  const result = await mockClient.setUserNote(userId, noteContent)
+
+  // then: returns updated note object
+  expect(result.note_user_id).toBe('user123')
+  expect(result.note).toBe('Important person to remember')
+})
+
+test('set can update existing note', async () => {
+  // given: user with existing note
+  const userId = 'user_with_note'
+  const newNote = 'Updated note content'
+
+  // when: updating user note
+  const result = await mockClient.setUserNote(userId, newNote)
+
+  // then: returns updated note object
+  expect(result.note_user_id).toBe('user_with_note')
+  expect(result.note).toBe('Updated note content')
+})
+
+test('set can clear note with empty string', async () => {
+  // given: user with existing note
+  const userId = 'user_with_note'
+
+  // when: clearing note
+  const result = await mockClient.setUserNote(userId, '')
+
+  // then: returns note object with empty note
+  expect(result.note_user_id).toBe('user_with_note')
+  expect(result.note).toBe('')
+})