agent-messenger 2.8.0 → 2.9.0

package/src/platforms/discordbot/commands/snapshot.ts

@@ -10,6 +10,7 @@ import { getClient } from './shared'
 interface SnapshotOption extends BotOption {
   channelsOnly?: boolean
   usersOnly?: boolean
+  full?: boolean
   limit?: number
 }
 
@@ -31,6 +32,7 @@ interface SnapshotResult {
     username: string
     global_name: string | null
   }>
+  hint?: string
   error?: string
 }
 
@@ -43,53 +45,66 @@ export async function snapshotAction(options: SnapshotOption): Promise<SnapshotR
     }
 
     const client = await getClient(options)
-    const limit = options.limit ?? 5
 
-    if (options.usersOnly) {
-      const users = await client.listUsers(serverId)
-      return {
-        server_id: serverId,
-        users: users.map((u) => ({
-          id: u.id,
-          username: u.username,
-          global_name: u.global_name ?? null,
-        })),
+    const isFull = options.full || options.channelsOnly || options.usersOnly
+    if (isFull) {
+      const limit = options.limit ?? 5
+
+      if (options.usersOnly) {
+        const users = await client.listUsers(serverId)
+        return {
+          server_id: serverId,
+          users: users.map((u) => ({
+            id: u.id,
+            username: u.username,
+            global_name: u.global_name ?? null,
+          })),
+        }
       }
-    }
 
-    const allChannels = await client.listChannels(serverId)
-    const textChannels = allChannels.filter((ch) => ch.type === 0)
+      const allChannels = await client.listChannels(serverId)
+      const textChannels = allChannels.filter((ch) => ch.type === 0)
+
+      if (options.channelsOnly) {
+        return {
+          server_id: serverId,
+          channels: textChannels.map((ch) => ({
+            id: ch.id,
+            name: ch.name,
+            type: ch.type,
+          })),
+        }
+      }
+
+      const channelsWithMessages = await Promise.all(
+        textChannels.map(async (ch) => {
+          const messages = await client.getMessages(ch.id, limit)
+          return {
+            id: ch.id,
+            name: ch.name,
+            messages: messages.map((msg) => ({
+              id: msg.id,
+              author: msg.author.username,
+              content: msg.content,
+              timestamp: msg.timestamp,
+            })),
+          }
+        }),
+      )
 
-    if (options.channelsOnly) {
       return {
         server_id: serverId,
-        channels: textChannels.map((ch) => ({
-          id: ch.id,
-          name: ch.name,
-          type: ch.type,
-        })),
+        channels: channelsWithMessages,
       }
     }
 
-    const channelsWithMessages = await Promise.all(
-      textChannels.map(async (ch) => {
-        const messages = await client.getMessages(ch.id, limit)
-        return {
-          id: ch.id,
-          name: ch.name,
-          messages: messages.map((msg) => ({
-            id: msg.id,
-            author: msg.author.username,
-            content: msg.content,
-            timestamp: msg.timestamp,
-          })),
-        }
-      }),
-    )
+    const allChannels = await client.listChannels(serverId)
+    const textChannels = allChannels.filter((ch) => ch.type === 0)
 
     return {
       server_id: serverId,
-      channels: channelsWithMessages,
+      channels: textChannels.map((ch) => ({ id: ch.id, name: ch.name })),
+      hint: "Use 'message list <channel>' for messages, 'channel info <channel>' for channel details, 'user list' for members.",
     }
   } catch (error) {
     return { error: (error as Error).message }
@@ -97,10 +112,11 @@ export async function snapshotAction(options: SnapshotOption): Promise<SnapshotR
 }
 
 export const snapshotCommand = new Command('snapshot')
-  .description('Server overview for AI agent context')
+  .description('Server overview for AI agents (brief by default, use --full for comprehensive data)')
+  .option('--full', 'Include messages and members (verbose)')
   .option('--channels-only', 'List channels only, skip messages')
   .option('--users-only', 'List users only')
-  .option('--limit <n>', 'Messages per channel (default: 5)', '5')
+  .option('--limit <n>', 'Messages per channel with --full (default: 5)', '5')
   .option('--server <id>', 'Use specific server')
   .option('--bot <id>', 'Use specific bot')
   .option('--pretty', 'Pretty print JSON output')
@@ -108,6 +124,7 @@ export const snapshotCommand = new Command('snapshot')
     try {
       const result = await snapshotAction({
         ...options,
+        full: options.full,
         limit: parseInt(options.limit, 10),
       })
       console.log(formatOutput(result, options.pretty))

package/src/platforms/slack/commands/snapshot.test.ts

@@ -34,6 +34,12 @@ test('snapshot command has --limit option', () => {
   expect(hasLimit).toBe(true)
 })
 
+test('snapshot command has --full option', () => {
+  const options = snapshotCommand.options
+  const hasFull = options.some((opt: any) => opt.long === '--full')
+  expect(hasFull).toBe(true)
+})
+
 // Test snapshot logic using spyOn (no global mock pollution)
 let credManagerSpy: ReturnType<typeof spyOn>
 let clientTestAuthSpy: ReturnType<typeof spyOn>
@@ -147,11 +153,66 @@ afterEach(() => {
   clientGetMessagesSpy?.mockRestore()
 })
 
+test('brief snapshot (default) returns workspace, channels as {id, name}, and hint', async () => {
+  const client = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
+
+  const auth = await client.testAuth()
+  const channels = await client.listChannels()
+  const active = channels.filter((ch) => !ch.is_archived)
+
+  const snapshot = {
+    workspace: {
+      id: auth.team_id,
+      name: auth.team,
+    },
+    channels: active.map((ch) => ({ id: ch.id, name: ch.name })),
+    hint: "Use 'message list <channel>' for messages, 'channel info <channel>' for channel details, 'user list' for users, 'usergroup list' for groups.",
+  }
+
+  expect(snapshot.workspace).toBeDefined()
+  expect(snapshot.workspace.id).toBe('T123')
+  expect(snapshot.workspace.name).toBe('Test Workspace')
+
+  expect(snapshot.channels).toBeDefined()
+  expect(snapshot.channels.length).toBe(2)
+  expect(snapshot.channels[0]).toEqual({ id: 'C123', name: 'general' })
+  expect(snapshot.channels[1]).toEqual({ id: 'C456', name: 'random' })
+
+  expect((snapshot as any).recent_messages).toBeUndefined()
+  expect((snapshot as any).users).toBeUndefined()
+  expect((snapshot as any).usergroups).toBeUndefined()
+
+  expect(snapshot.hint).toContain('message list')
+})
+
+test('brief snapshot excludes archived channels', async () => {
+  const channelsWithArchived: SlackChannel[] = [
+    ...mockChannels,
+    {
+      id: 'C789',
+      name: 'old-channel',
+      is_private: false,
+      is_archived: true,
+      created: 1234567800,
+      creator: 'U123',
+      topic: { value: 'Archived', creator: 'U123', last_set: 1234567800 },
+      purpose: { value: 'Old channel', creator: 'U123', last_set: 1234567800 },
+    },
+  ]
+
+  clientListChannelsSpy.mockResolvedValue(channelsWithArchived)
+
+  const client = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
+  const channels = await client.listChannels()
+  const active = channels.filter((ch) => !ch.is_archived)
+
+  expect(active.length).toBe(2)
+  expect(active.every((ch) => !ch.is_archived)).toBe(true)
+})
+
 test('full snapshot returns workspace, channels, messages, and users', async () => {
-  const credManager = new CredentialManager()
   const client = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
 
-  const _workspace = await credManager.getWorkspace()
   const auth = await client.testAuth()
   const channels = await client.listChannels()
   const users = await client.listUsers()
@@ -218,10 +279,8 @@ test('full snapshot returns workspace, channels, messages, and users', async ()
 })
 
 test('snapshot with --channels-only excludes messages and users', async () => {
-  const credManager = new CredentialManager()
   const client = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
 
-  const _workspace = await credManager.getWorkspace()
   const auth = await client.testAuth()
   const channels = await client.listChannels()
 
@@ -249,10 +308,8 @@ test('snapshot with --channels-only excludes messages and users', async () => {
 })
 
 test('snapshot with --users-only excludes channels and messages', async () => {
-  const credManager = new CredentialManager()
   const client = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
 
-  const _workspace = await credManager.getWorkspace()
   const auth = await client.testAuth()
   const users = await client.listUsers()
 
@@ -279,10 +336,8 @@ test('snapshot with --users-only excludes channels and messages', async () => {
 })
 
 test('snapshot respects --limit option for messages', async () => {
-  const credManager = new CredentialManager()
   const client = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
 
-  const _workspace = await credManager.getWorkspace()
   const auth = await client.testAuth()
   const channels = await client.listChannels()
 

package/src/platforms/slack/commands/snapshot.ts

@@ -11,6 +11,7 @@ import type { SlackChannel } from '../types'
 async function snapshotAction(options: {
   channelsOnly?: boolean
   usersOnly?: boolean
+  full?: boolean
   limit?: number
   pretty?: boolean
 }): Promise<void> {
@@ -26,7 +27,6 @@ async function snapshotAction(options: {
     const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
 
     const auth = await client.testAuth()
-    const messageLimit = options.limit || 20
 
     const snapshot: Record<string, any> = {
       workspace: {
@@ -35,88 +35,120 @@ async function snapshotAction(options: {
       },
     }
 
-    if (!options.usersOnly) {
-      const channels = await client.listChannels()
-
-      snapshot.channels = channels.map((ch) => ({
-        id: ch.id,
-        name: ch.name,
-        is_private: ch.is_private,
-        is_archived: ch.is_archived,
-        created: ch.created,
-        topic: ch.topic?.value,
-        purpose: ch.purpose?.value,
-      }))
-
-      if (!options.channelsOnly) {
-        const activeChannels = channels.filter((ch) => !ch.is_archived)
-
-        const channelMessages = await parallelMap(
-          activeChannels,
-          async (channel: SlackChannel) => {
-            const messages = await client.getMessages(channel.id, messageLimit)
-            return messages.map((msg) => ({
-              ...msg,
-              channel_id: channel.id,
-              channel_name: channel.name,
-            }))
-          },
-          5,
-        )
-
-        snapshot.recent_messages = channelMessages.flat().map((msg) => ({
-          channel_id: msg.channel_id,
-          channel_name: msg.channel_name,
-          ts: msg.ts,
-          text: msg.text,
-          user: msg.user,
-          username: msg.username,
-          thread_ts: msg.thread_ts,
-        }))
-      }
+    const isFull = options.full || options.channelsOnly || options.usersOnly
+    if (isFull) {
+      await buildFullSnapshot(client, snapshot, options)
+    } else {
+      await buildBriefSnapshot(client, snapshot, options)
     }
 
-    if (!options.channelsOnly) {
-      const users = await client.listUsers()
-
-      snapshot.users = users.map((u) => ({
-        id: u.id,
-        name: u.name,
-        real_name: u.real_name,
-        is_admin: u.is_admin,
-        is_bot: u.is_bot,
-        profile: u.profile,
-      }))
-    }
+    console.log(formatOutput(snapshot, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
 
-    if (!options.channelsOnly && !options.usersOnly) {
-      const usergroups = await client.listUsergroups({ includeUsers: true, includeCount: true })
+async function buildBriefSnapshot(
+  client: SlackClient,
+  snapshot: Record<string, any>,
+  options: { channelsOnly?: boolean; usersOnly?: boolean },
+): Promise<void> {
+  if (!options.usersOnly) {
+    const channels = await client.listChannels()
+    const active = channels.filter((ch) => !ch.is_archived)
+    snapshot.channels = active.map((ch) => ({ id: ch.id, name: ch.name }))
+  }
 
-      snapshot.usergroups = usergroups.map((ug) => ({
-        id: ug.id,
-        name: ug.name,
-        handle: ug.handle,
-        description: ug.description,
-        user_count: ug.user_count,
-        users: ug.users,
+  snapshot.hint =
+    "Use 'message list <channel>' for messages, 'channel info <channel>' for channel details, 'user list' for users, 'usergroup list' for groups."
+}
+
+async function buildFullSnapshot(
+  client: SlackClient,
+  snapshot: Record<string, any>,
+  options: { channelsOnly?: boolean; usersOnly?: boolean; limit?: number },
+): Promise<void> {
+  const messageLimit = options.limit || 20
+
+  if (!options.usersOnly) {
+    const channels = await client.listChannels()
+
+    snapshot.channels = channels.map((ch) => ({
+      id: ch.id,
+      name: ch.name,
+      is_private: ch.is_private,
+      is_archived: ch.is_archived,
+      created: ch.created,
+      topic: ch.topic?.value,
+      purpose: ch.purpose?.value,
+    }))
+
+    if (!options.channelsOnly) {
+      const activeChannels = channels.filter((ch) => !ch.is_archived)
+
+      const channelMessages = await parallelMap(
+        activeChannels,
+        async (channel: SlackChannel) => {
+          const messages = await client.getMessages(channel.id, messageLimit)
+          return messages.map((msg) => ({
+            ...msg,
+            channel_id: channel.id,
+            channel_name: channel.name,
+          }))
+        },
+        5,
+      )
+
+      snapshot.recent_messages = channelMessages.flat().map((msg) => ({
+        channel_id: msg.channel_id,
+        channel_name: msg.channel_name,
+        ts: msg.ts,
+        text: msg.text,
+        user: msg.user,
+        username: msg.username,
+        thread_ts: msg.thread_ts,
       }))
     }
+  }
 
-    console.log(formatOutput(snapshot, options.pretty))
-  } catch (error) {
-    handleError(error as Error)
+  if (!options.channelsOnly) {
+    const users = await client.listUsers()
+
+    snapshot.users = users.map((u) => ({
+      id: u.id,
+      name: u.name,
+      real_name: u.real_name,
+      is_admin: u.is_admin,
+      is_bot: u.is_bot,
+      profile: u.profile,
+    }))
+  }
+
+  if (!options.channelsOnly && !options.usersOnly) {
+    const usergroups = await client.listUsergroups({ includeUsers: true, includeCount: true })
+
+    snapshot.usergroups = usergroups.map((ug) => ({
+      id: ug.id,
+      name: ug.name,
+      handle: ug.handle,
+      description: ug.description,
+      user_count: ug.user_count,
+      users: ug.users,
+    }))
   }
 }
 
 export const snapshotCommand = new Command('snapshot')
-  .description('Get comprehensive workspace state for AI agents')
+  .description('Get workspace overview for AI agents (brief by default, use --full for comprehensive data)')
+  .option('--full', 'Include messages, users, and user groups (verbose)')
   .option('--channels-only', 'Include only channels (exclude messages and users)')
   .option('--users-only', 'Include only users (exclude channels and messages)')
-  .option('--limit <n>', 'Number of recent messages per channel (default: 20)', '20')
+  .option('--limit <n>', 'Number of recent messages per channel with --full (default: 20)', '20')
   .action(async (options) => {
     await snapshotAction({
       channelsOnly: options.channelsOnly,
       usersOnly: options.usersOnly,
+      full: options.full,
       limit: parseInt(options.limit, 10),
       pretty: options.pretty,
     })

package/src/platforms/teams/commands/snapshot.test.ts

@@ -8,7 +8,7 @@ test('snapshot: command is defined', () => {
 })
 
 test('snapshot: command has correct description', () => {
-  expect(snapshotCommand.description()).toContain('team state')
+  expect(snapshotCommand.description()).toContain('team overview')
 })
 
 test('snapshot: command has --channels-only option', () => {

package/src/platforms/teams/commands/snapshot.ts

@@ -11,6 +11,7 @@ import type { TeamsChannel } from '../types'
 export async function snapshotAction(options: {
   channelsOnly?: boolean
   usersOnly?: boolean
+  full?: boolean
   limit?: number
   teamId?: string
   pretty?: boolean
@@ -34,7 +35,6 @@ export async function snapshotAction(options: {
     }
 
     const client = await new TeamsClient().login({ token: cred.token, tokenExpiresAt: cred.tokenExpiresAt })
-    const messageLimit = options.limit || 20
 
     const snapshot: Record<string, unknown> = {}
 
@@ -45,47 +45,60 @@ export async function snapshotAction(options: {
       description: team.description,
     }
 
-    if (!options.usersOnly) {
-      const channels = await client.listChannels(teamId)
+    const isFull = options.full || options.channelsOnly || options.usersOnly
+    if (isFull) {
+      const messageLimit = options.limit || 20
 
-      snapshot.channels = channels.map((ch) => ({
-        id: ch.id,
-        name: ch.name,
-        type: ch.type,
-      }))
+      if (!options.usersOnly) {
+        const channels = await client.listChannels(teamId)
 
-      if (!options.channelsOnly) {
-        const channelMessages = await parallelMap(
-          channels,
-          async (channel: TeamsChannel) => {
-            const messages = await client.getMessages(teamId, channel.id, messageLimit)
-            return messages.map((msg) => ({
-              ...msg,
-              channel_name: channel.name,
-            }))
-          },
-          5,
-        )
-
-        snapshot.recent_messages = channelMessages.flat().map((msg) => ({
-          channel_id: msg.channel_id,
-          channel_name: msg.channel_name,
-          id: msg.id,
-          author: msg.author.displayName,
-          content: msg.content,
-          timestamp: msg.timestamp,
+        snapshot.channels = channels.map((ch) => ({
+          id: ch.id,
+          name: ch.name,
+          type: ch.type,
         }))
+
+        if (!options.channelsOnly) {
+          const channelMessages = await parallelMap(
+            channels,
+            async (channel: TeamsChannel) => {
+              const messages = await client.getMessages(teamId, channel.id, messageLimit)
+              return messages.map((msg) => ({
+                ...msg,
+                channel_name: channel.name,
+              }))
+            },
+            5,
+          )
+
+          snapshot.recent_messages = channelMessages.flat().map((msg) => ({
+            channel_id: msg.channel_id,
+            channel_name: msg.channel_name,
+            id: msg.id,
+            author: msg.author.displayName,
+            content: msg.content,
+            timestamp: msg.timestamp,
+          }))
+        }
       }
-    }
 
-    if (!options.channelsOnly) {
-      const users = await client.listUsers(teamId)
+      if (!options.channelsOnly) {
+        const users = await client.listUsers(teamId)
+
+        snapshot.members = users.map((u) => ({
+          id: u.id,
+          displayName: u.displayName,
+          email: u.email || null,
+        }))
+      }
+    } else {
+      if (!options.usersOnly) {
+        const channels = await client.listChannels(teamId)
+        snapshot.channels = channels.map((ch) => ({ id: ch.id, name: ch.name }))
+      }
 
-      snapshot.members = users.map((u) => ({
-        id: u.id,
-        displayName: u.displayName,
-        email: u.email || null,
-      }))
+      snapshot.hint =
+        "Use 'message list <channel>' for messages, 'channel info <channel>' for channel details, 'user list' for members."
     }
 
     console.log(formatOutput(snapshot, options.pretty))
@@ -95,16 +108,18 @@ export async function snapshotAction(options: {
 }
 
 export const snapshotCommand = new Command('snapshot')
-  .description('Get comprehensive team state for AI agents')
+  .description('Get team overview for AI agents (brief by default, use --full for comprehensive data)')
+  .option('--full', 'Include messages and members (verbose)')
   .option('--channels-only', 'Include only channels (exclude messages and members)')
   .option('--users-only', 'Include only members (exclude channels and messages)')
-  .option('--limit <n>', 'Number of recent messages per channel (default: 20)', '20')
+  .option('--limit <n>', 'Number of recent messages per channel with --full (default: 20)', '20')
   .option('--team-id <id>', 'Team ID (defaults to current team)')
   .option('--pretty', 'Pretty print JSON output')
   .action(async (options) => {
     await snapshotAction({
       channelsOnly: options.channelsOnly,
       usersOnly: options.usersOnly,
+      full: options.full,
       limit: parseInt(options.limit, 10),
       teamId: options.teamId,
       pretty: options.pretty,

package/src/platforms/webex/commands/snapshot.test.ts

@@ -79,9 +79,21 @@ describe('snapshot command', () => {
     consoleSpy.mockRestore()
   })
 
-  test('returns spaces with id, title, type, lastActivity', async () => {
+  test('brief snapshot returns spaces with id and title only', async () => {
     await snapshotAction({})
 
+    expect(consoleSpy).toHaveBeenCalled()
+    const output = JSON.parse(consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0])
+    expect(output.spaces).toHaveLength(1)
+    expect(output.spaces[0].id).toBe('space-1')
+    expect(output.spaces[0].title).toBe('General')
+    expect(output.spaces[0].type).toBeUndefined()
+    expect(output.hint).toBeDefined()
+  })
+
+  test('full snapshot returns spaces with id, title, type, lastActivity', async () => {
+    await snapshotAction({ full: true })
+
     expect(consoleSpy).toHaveBeenCalled()
     const output = JSON.parse(consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0])
     expect(output.spaces).toHaveLength(1)
@@ -89,6 +101,7 @@ describe('snapshot command', () => {
     expect(output.spaces[0].title).toBe('General')
     expect(output.spaces[0].type).toBe('group')
     expect(output.spaces[0].lastActivity).toBe('2024-01-15T00:00:00.000Z')
+    expect(output.hint).toBeUndefined()
   })
 
   test('filters spaces to only those in my memberships', async () => {

package/src/platforms/webex/commands/snapshot.ts

@@ -5,7 +5,7 @@ import { formatOutput } from '@/shared/utils/output'
 
 import { WebexClient } from '../client'
 
-export async function snapshotAction(options: { pretty?: boolean }): Promise<void> {
+export async function snapshotAction(options: { full?: boolean; pretty?: boolean }): Promise<void> {
   try {
     const client = await new WebexClient().login()
 
@@ -15,13 +15,19 @@ export async function snapshotAction(options: { pretty?: boolean }): Promise<voi
     const allSpaces = await client.listSpaces({ max: 100 })
     const spaces = allSpaces.filter((s) => myRoomIds.has(s.id))
 
-    const snapshot = {
-      spaces: spaces.map((s) => ({
-        id: s.id,
-        title: s.title,
-        type: s.type,
-        lastActivity: s.lastActivity,
-      })),
+    const snapshot: Record<string, any> = {
+      spaces: options.full
+        ? spaces.map((s) => ({
+            id: s.id,
+            title: s.title,
+            type: s.type,
+            lastActivity: s.lastActivity,
+          }))
+        : spaces.map((s) => ({ id: s.id, title: s.title })),
+    }
+
+    if (!options.full) {
+      snapshot.hint = "Use 'message list <space>' for messages, 'space info <space>' for space details."
     }
 
     console.log(formatOutput(snapshot, options.pretty))
@@ -31,10 +37,12 @@ export async function snapshotAction(options: { pretty?: boolean }): Promise<voi
 }
 
 export const snapshotCommand = new Command('snapshot')
-  .description('Get workspace spaces overview for AI agents')
+  .description('Get workspace overview for AI agents (brief by default, use --full for comprehensive data)')
+  .option('--full', 'Include full space details (verbose)')
   .option('--pretty', 'Pretty print JSON output')
   .action(async (options) => {
     await snapshotAction({
+      full: options.full,
       pretty: options.pretty,
     })
   })