opencode-discord-bot 0.0.11 → 0.2.0

package/src/Discord/DiscordRest.ts

@@ -0,0 +1,78 @@
+import { Duration, Effect } from "effect"
+import { DiscordError } from "./DiscordPort.ts"
+
+export type RawDiscordOptions = {
+  readonly botToken: string
+  readonly apiUrl?: string | undefined
+  readonly nicknameCacheTtlMs?: number | undefined
+}
+
+const isRecord = (value: unknown): value is Readonly<Record<string, unknown>> =>
+  typeof value === "object" && value !== null && !Array.isArray(value)
+
+const retryAfterHeader = (response: Response) => {
+  const value = response.headers.get("retry-after")
+  if (value === null) return undefined
+  const seconds = Number(value)
+  return Number.isFinite(seconds) && seconds >= 0 ? Duration.millis(seconds * 1000) : undefined
+}
+
+const retryAfterBody = (body: unknown) => {
+  if (!isRecord(body)) return undefined
+  const retryAfter = body.retry_after
+  return typeof retryAfter === "number" && Number.isFinite(retryAfter) && retryAfter >= 0 ? Duration.millis(retryAfter * 1000) : undefined
+}
+
+export const rawDiscordRequest = async (options: RawDiscordOptions | undefined, path: string, init: RequestInit): Promise<unknown> => {
+  if (options === undefined) throw new Error("Discord adapter does not expose this operation")
+  const response = await fetch(`${options.apiUrl ?? "https://discord.com/api/v10"}${path}`, {
+    ...init,
+    headers: {
+      authorization: `Bot ${options.botToken}`,
+      "content-type": "application/json",
+      ...init.headers
+    }
+  })
+  if (!response.ok) {
+    throw new DiscordError({
+      message: `Discord REST ${response.status}: ${await response.text()}`,
+      retryAfter: retryAfterHeader(response)
+    })
+  }
+  if (response.status === 204) return {}
+  return await response.json()
+}
+
+export const rawDiscordSearchRequest = async (options: RawDiscordOptions | undefined, path: string): Promise<unknown> => {
+  if (options === undefined) throw new Error("Discord adapter does not expose this operation")
+  const response = await fetch(`${options.apiUrl ?? "https://discord.com/api/v10"}${path}`, {
+    method: "GET",
+    headers: {
+      authorization: `Bot ${options.botToken}`,
+      "content-type": "application/json"
+    }
+  })
+  if (response.status === 202) {
+    const body = await response.json().catch(() => ({}))
+    throw new DiscordError({
+      message: "Discord search index is not ready yet; retry the search later",
+      retryAfter: retryAfterBody(body) ?? retryAfterHeader(response)
+    })
+  }
+  if (!response.ok) {
+    throw new DiscordError({
+      message: `Discord REST ${response.status}: ${await response.text()}`,
+      retryAfter: retryAfterHeader(response)
+    })
+  }
+  return await response.json()
+}
+
+export const rawDiscord = (options: RawDiscordOptions | undefined, path: string, init: RequestInit): Effect.Effect<unknown, DiscordError> =>
+  Effect.tryPromise({
+    try: () => rawDiscordRequest(options, path, init),
+    catch: (cause) =>
+      cause instanceof DiscordError
+        ? cause
+        : new DiscordError({ message: cause instanceof Error ? cause.message : "Discord REST operation failed" })
+  })

package/src/Discord/DiscordSearchRest.ts

@@ -0,0 +1,232 @@
+import type { DiscordAttachment, DiscordMessage, DiscordScope, DiscordSearchQuery, DiscordSearchResult } from "../Schema.ts"
+import { DiscordError } from "./DiscordPort.ts"
+import { type RawDiscordOptions, rawDiscordRequest, rawDiscordSearchRequest } from "./DiscordRest.ts"
+
+type NicknameResolver = (scope: DiscordScope, userId: string) => Promise<string | undefined>
+
+const isRecord = (value: unknown): value is Readonly<Record<string, unknown>> =>
+  typeof value === "object" && value !== null && !Array.isArray(value)
+
+const stringField = (value: unknown, key: string): string | undefined => {
+  if (!isRecord(value)) return undefined
+  const field = value[key]
+  return typeof field === "string" && field.length > 0 ? field : undefined
+}
+
+const userIdFromMemberSearch = (data: unknown): string | undefined => {
+  if (!Array.isArray(data)) return undefined
+  const first = data[0]
+  if (!isRecord(first)) return undefined
+  return stringField(first.user, "id")
+}
+
+const channelIdFromGuildChannels = (data: unknown, name: string): string | undefined => {
+  if (!Array.isArray(data)) return undefined
+  const normalized = name.toLowerCase().replace(/^#/, "")
+  for (const channel of data) {
+    if (!isRecord(channel)) continue
+    const channelName = stringField(channel, "name")
+    if (channelName?.toLowerCase() === normalized) return stringField(channel, "id")
+  }
+  return undefined
+}
+
+const resolveUserName = async (raw: RawDiscordOptions | undefined, scope: DiscordScope, name: string): Promise<string> => {
+  const params = new URLSearchParams({ query: name, limit: "1" })
+  const result = await rawDiscordRequest(raw, `/guilds/${scope.guildId}/members/search?${params}`, { method: "GET" })
+  const id = userIdFromMemberSearch(result)
+  if (id === undefined) throw new DiscordError({ message: `Unable to resolve Discord user ${name}; use an ID or mention` })
+  return id
+}
+
+const resolveChannelName = async (raw: RawDiscordOptions | undefined, scope: DiscordScope, name: string): Promise<string> => {
+  const result = await rawDiscordRequest(raw, `/guilds/${scope.guildId}/channels`, { method: "GET" })
+  const id = channelIdFromGuildChannels(result, name)
+  if (id === undefined) throw new DiscordError({ message: `Unable to resolve Discord channel ${name}; use an ID or channel mention` })
+  return id
+}
+
+const resolveSearchQuery = async (
+  raw: RawDiscordOptions | undefined,
+  scope: DiscordScope,
+  query: DiscordSearchQuery
+): Promise<DiscordSearchQuery> => {
+  const [authors, channels, mentions, repliedToUsers] = await Promise.all([
+    Promise.all(query.authorNames.map((name) => resolveUserName(raw, scope, name))),
+    Promise.all(query.channelNames.map((name) => resolveChannelName(raw, scope, name))),
+    Promise.all(query.mentionNames.map((name) => resolveUserName(raw, scope, name))),
+    Promise.all(query.repliedToUserNames.map((name) => resolveUserName(raw, scope, name)))
+  ])
+  return {
+    ...query,
+    authors: [...query.authors, ...authors],
+    authorNames: [],
+    channels: [...query.channels, ...channels],
+    channelNames: [],
+    mentions: [...query.mentions, ...mentions],
+    mentionNames: [],
+    repliedToUsers: [...query.repliedToUsers, ...repliedToUsers],
+    repliedToUserNames: []
+  }
+}
+
+const rawAttachment = (item: unknown): DiscordAttachment | undefined => {
+  if (!isRecord(item)) return undefined
+  const id = stringField(item, "id")
+  const filename = stringField(item, "filename")
+  const url = stringField(item, "url") ?? ""
+  const size = typeof item.size === "number" && Number.isFinite(item.size) && item.size >= 0 ? item.size : 0
+  const contentType = stringField(item, "content_type")
+  if (id === undefined || filename === undefined) return undefined
+  return { id, filename, ...(contentType === undefined ? {} : { contentType }), size, url }
+}
+
+const rawUserIds = (items: unknown): ReadonlyArray<string> =>
+  Array.isArray(items)
+    ? items.flatMap((item) => {
+        const id = stringField(item, "id")
+        return id === undefined ? [] : [id]
+      })
+    : []
+
+const rawStringArray = (items: unknown): ReadonlyArray<string> =>
+  Array.isArray(items) ? items.flatMap((item) => (typeof item === "string" ? [item] : [])) : []
+
+const threadParents = (items: unknown): ReadonlyMap<string, string> => {
+  const result = new Map<string, string>()
+  if (!Array.isArray(items)) return result
+  for (const thread of items) {
+    const id = stringField(thread, "id")
+    const parentId = stringField(thread, "parent_id")
+    if (id !== undefined && parentId !== undefined) result.set(id, parentId)
+  }
+  return result
+}
+
+const fromRawDiscordMessage = (
+  scope: DiscordScope,
+  data: unknown,
+  threadParentById: ReadonlyMap<string, string>
+): DiscordMessage | undefined => {
+  if (!isRecord(data)) return undefined
+  const id = stringField(data, "id")
+  const channelId = stringField(data, "channel_id")
+  const timestamp = stringField(data, "timestamp")
+  const author = data.author
+  const authorId = stringField(author, "id")
+  if (id === undefined || channelId === undefined || timestamp === undefined || authorId === undefined) return undefined
+  const parentId = threadParentById.get(channelId)
+  const content = typeof data.content === "string" ? data.content : ""
+  const attachments = Array.isArray(data.attachments) ? data.attachments : []
+  return {
+    id,
+    guildId: scope.guildId,
+    channelId: parentId ?? channelId,
+    ...(parentId === undefined ? {} : { threadId: channelId }),
+    author: {
+      id: authorId,
+      displayName: stringField(author, "global_name") ?? stringField(author, "username") ?? authorId,
+      isBot: isRecord(author) && author.bot === true
+    },
+    content,
+    timestamp,
+    mentions: rawUserIds(data.mentions),
+    roleMentions: rawStringArray(data.mention_roles),
+    everyoneMention: data.mention_everyone === true,
+    hereMention: content.includes("@here"),
+    attachments: attachments.flatMap((item) => {
+      const attachment = rawAttachment(item)
+      return attachment === undefined ? [] : [attachment]
+    }),
+    reactions: [],
+    channelType: "guild",
+    ...(typeof data.type === "number" && data.type !== 0 ? { isSystem: true } : {})
+  }
+}
+
+const flatSearchMessages = (data: unknown): ReadonlyArray<unknown> => {
+  if (!isRecord(data) || !Array.isArray(data.messages)) return []
+  return data.messages.flatMap((group) => (Array.isArray(group) ? group : []))
+}
+
+const searchTotalResults = (data: unknown): number =>
+  isRecord(data) && typeof data.total_results === "number" && Number.isFinite(data.total_results) && data.total_results >= 0
+    ? data.total_results
+    : 0
+
+const appendAll = (params: URLSearchParams, key: string, values: ReadonlyArray<string>): void => {
+  for (const value of values) params.append(key, value)
+}
+
+const searchParams = (query: DiscordSearchQuery, limit: number, offset: number): URLSearchParams => {
+  const params = new URLSearchParams()
+  params.set("limit", String(Math.max(1, Math.min(25, limit))))
+  params.set("offset", String(Math.max(0, Math.min(9975, offset))))
+  if (query.content !== undefined) params.set("content", query.content)
+  if (query.maxId !== undefined) params.set("max_id", query.maxId)
+  if (query.minId !== undefined) params.set("min_id", query.minId)
+  if (query.slop !== undefined) params.set("slop", String(query.slop))
+  if (query.pinned !== undefined) params.set("pinned", String(query.pinned))
+  if (query.mentionEveryone !== undefined) params.set("mention_everyone", String(query.mentionEveryone))
+  if (query.sortBy !== undefined) params.set("sort_by", query.sortBy)
+  if (query.sortOrder !== undefined) params.set("sort_order", query.sortOrder)
+  if (query.includeNsfw !== undefined) params.set("include_nsfw", String(query.includeNsfw))
+  appendAll(params, "channel_id", query.channels)
+  appendAll(params, "author_id", query.authors)
+  appendAll(params, "author_type", query.authorTypes)
+  appendAll(params, "mentions", query.mentions)
+  appendAll(params, "mentions_role_id", query.roleMentions)
+  appendAll(params, "replied_to_user_id", query.repliedToUsers)
+  appendAll(params, "replied_to_message_id", query.repliedToMessages)
+  appendAll(params, "has", query.has)
+  appendAll(params, "embed_type", query.embedTypes)
+  appendAll(params, "embed_provider", query.embedProviders)
+  appendAll(params, "link_hostname", query.linkHostnames)
+  appendAll(params, "attachment_filename", query.attachmentFilenames)
+  appendAll(params, "attachment_extension", query.attachmentExtensions)
+  return params
+}
+
+const enrichNicknames = async (
+  scope: DiscordScope,
+  messages: ReadonlyArray<DiscordMessage>,
+  resolveNickname: NicknameResolver
+): Promise<ReadonlyArray<DiscordMessage>> => {
+  const nicknames = new Map<string, string | undefined>()
+  for (const userId of [...new Set(messages.map((message) => message.author.id))]) {
+    nicknames.set(userId, await resolveNickname(scope, userId))
+  }
+  return messages.map((message) => {
+    const nickname = nicknames.get(message.author.id)
+    return nickname === undefined ? message : { ...message, author: { ...message.author, nickname } }
+  })
+}
+
+const collectMessages = (scope: DiscordScope, data: unknown): ReadonlyArray<DiscordMessage> => {
+  const parents = isRecord(data) ? threadParents(data.threads) : new Map<string, string>()
+  const seen = new Set<string>()
+  const messages: Array<DiscordMessage> = []
+  for (const rawMessage of flatSearchMessages(data)) {
+    const message = fromRawDiscordMessage(scope, rawMessage, parents)
+    if (message === undefined || seen.has(message.id)) continue
+    seen.add(message.id)
+    messages.push(message)
+  }
+  return messages
+}
+
+export const searchDiscordMessages = async (
+  raw: RawDiscordOptions | undefined,
+  scope: DiscordScope,
+  query: DiscordSearchQuery,
+  paging: { readonly limit: number; readonly offset: number },
+  resolveNickname: NicknameResolver
+): Promise<DiscordSearchResult> => {
+  const resolvedQuery = await resolveSearchQuery(raw, scope, query)
+  const params = searchParams(resolvedQuery, paging.limit, paging.offset)
+  const data = await rawDiscordSearchRequest(raw, `/guilds/${scope.guildId}/messages/search?${params}`)
+  const messages = await enrichNicknames(scope, collectMessages(scope, data), resolveNickname)
+  const totalResults = searchTotalResults(data)
+  const offset = Math.max(0, Math.min(9975, paging.offset))
+  return { totalResults, offset, hasMore: offset + messages.length < totalResults, messages }
+}

package/src/Discord/MemoryDiscord.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test"
 import { Effect } from "effect"
 import type { DiscordMessage, DiscordScope } from "../Schema.ts"
 import { makeMemoryDiscord } from "./MemoryDiscord.ts"
+import { parseDiscordSearchQuery } from "./SearchQuery.ts"
 
 const scope: DiscordScope = { guildId: "g1", channelId: "c1" }
 
@@ -26,14 +27,17 @@ describe("makeMemoryDiscord", () => {
     const discord = makeMemoryDiscord({ context: [message("1"), message("2")] })
 
     const context = await Effect.runPromise(discord.fetchContext(scope, 1))
-    const history = await Effect.runPromise(discord.fetchHistory(scope, 2))
+    const query = parseDiscordSearchQuery("content:2 from:Alice")
+    if (!query.ok) throw new Error(query.error)
+    const search = await Effect.runPromise(discord.searchMessages(scope, query.query, { limit: 2, offset: 0 }))
     const posted = await Effect.runPromise(discord.postMessage(scope, "hello"))
     await Effect.runPromise(discord.editMessage(scope, posted.id, "updated"))
     await Effect.runPromise(discord.addReaction(scope, "m1", "rocket"))
     const attached = await Effect.runPromise(discord.attachFile(scope, "/repo/out.txt"))
 
     expect(context.map((item) => item.id)).toEqual(["2"])
-    expect(history.map((item) => item.id)).toEqual(["1", "2"])
+    expect(search.messages.map((item) => item.id)).toEqual(["2"])
+    expect(search.totalResults).toBe(1)
     expect(posted).toEqual({ id: "posted-1" })
     expect(discord.messages).toEqual([{ scope, content: "hello" }])
     expect(discord.edits).toEqual([{ scope, messageId: "posted-1", content: "updated" }])

package/src/Discord/MemoryDiscord.ts

@@ -1,11 +1,48 @@
 import { Effect } from "effect"
-import type { DiscordMessage, DiscordScope } from "../Schema.ts"
+import type { DiscordMessage, DiscordScope, DiscordSearchQuery, DiscordSearchResult } from "../Schema.ts"
 import type { DiscordPostedMessage, DiscordService } from "./DiscordPort.ts"
 
 type MemoryOptions = {
   readonly context?: ReadonlyArray<DiscordMessage>
 }
 
+const lowerIncludes = (value: string, expected: string): boolean => value.toLowerCase().includes(expected.toLowerCase())
+
+const matchesContent = (message: DiscordMessage, query: DiscordSearchQuery): boolean =>
+  query.content === undefined || lowerIncludes(message.content, query.content)
+
+const matchesAuthor = (message: DiscordMessage, query: DiscordSearchQuery): boolean =>
+  (query.authors.length === 0 || query.authors.includes(message.author.id)) &&
+  (query.authorNames.length === 0 || query.authorNames.some((name) => lowerIncludes(message.author.displayName, name)))
+
+const matchesChannel = (message: DiscordMessage, query: DiscordSearchQuery): boolean =>
+  query.channels.length === 0 || query.channels.some((id) => id === message.channelId || id === message.threadId)
+
+const matchesMentions = (message: DiscordMessage, query: DiscordSearchQuery): boolean =>
+  (query.mentions.length === 0 || query.mentions.every((id) => message.mentions.includes(id))) &&
+  (query.roleMentions.length === 0 || query.roleMentions.every((id) => message.roleMentions.includes(id))) &&
+  (query.mentionEveryone === undefined || message.everyoneMention === query.mentionEveryone)
+
+const matchesHas = (message: DiscordMessage, query: DiscordSearchQuery): boolean =>
+  (!query.has.includes("file") || message.attachments.length > 0) && (!query.has.includes("link") || /https?:\/\//i.test(message.content))
+
+const matchesSearch = (message: DiscordMessage, scope: DiscordScope, query: DiscordSearchQuery): boolean => {
+  if (message.guildId !== scope.guildId) return false
+  return [matchesContent, matchesAuthor, matchesChannel, matchesMentions, matchesHas].every((matches) => matches(message, query))
+}
+
+const memorySearch = (
+  context: ReadonlyArray<DiscordMessage>,
+  scope: DiscordScope,
+  query: DiscordSearchQuery,
+  limit: number,
+  offset: number
+): DiscordSearchResult => {
+  const matching = context.filter((message) => matchesSearch(message, scope, query))
+  const messages = matching.slice(offset, offset + limit)
+  return { totalResults: matching.length, offset, hasMore: offset + messages.length < matching.length, messages }
+}
+
 export type MemoryDiscord = DiscordService & {
   readonly context: Array<DiscordMessage>
   readonly typingScopes: Array<DiscordScope>
@@ -52,7 +89,7 @@ export const makeMemoryDiscord = (options: MemoryOptions = {}): MemoryDiscord =>
       }),
     editMessage: (scope, messageId, content) => Effect.sync(() => edits.push({ scope, messageId, content })).pipe(Effect.asVoid),
     addReaction: (scope, messageId, emoji) => Effect.sync(() => reactions.push({ scope, messageId, emoji, op: "add" })).pipe(Effect.asVoid),
-    fetchHistory: (_scope, limit) => Effect.succeed(context.slice(Math.max(0, context.length - limit))),
+    searchMessages: (scope, query, paging) => Effect.succeed(memorySearch(context, scope, query, paging.limit, paging.offset)),
     attachFile: (scope, path) =>
       Effect.sync(() => {
         attachments.push({ scope, path })

package/src/Discord/SearchQuery.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "bun:test"
+import { parseDiscordSearchQuery, timestampMsToDiscordSnowflake } from "./SearchQuery.ts"
+
+describe("parseDiscordSearchQuery", () => {
+  test("parses Discord-style search operators", () => {
+    const result = parseDiscordSearchQuery(
+      '"release notes" from:<@123> mentions:<@!456> in:<#789> has:link pinned:true sort:relevance order:asc'
+    )
+    if (!result.ok) throw new Error(result.error)
+
+    expect(result.query).toMatchObject({
+      content: "release notes",
+      authors: ["123"],
+      mentions: ["456"],
+      channels: ["789"],
+      has: ["link"],
+      pinned: true,
+      sortBy: "relevance",
+      sortOrder: "asc"
+    })
+  })
+
+  test("supports name references and raw API filter aliases", () => {
+    const result = parseDiscordSearchQuery(
+      "from:Alice in:#general author_type:bot attachment_extension:ts link_hostname:example.com embed_type:image mention_everyone:false"
+    )
+    if (!result.ok) throw new Error(result.error)
+
+    expect(result.query.authorNames).toEqual(["Alice"])
+    expect(result.query.channelNames).toEqual(["general"])
+    expect(result.query.authorTypes).toEqual(["bot"])
+    expect(result.query.attachmentExtensions).toEqual(["ts"])
+    expect(result.query.linkHostnames).toEqual(["example.com"])
+    expect(result.query.embedTypes).toEqual(["image"])
+    expect(result.query.mentionEveryone).toBe(false)
+  })
+
+  test("converts date filters to Discord snowflake IDs", () => {
+    const result = parseDiscordSearchQuery("after:2026-06-05 during:2026-06-06")
+    if (!result.ok) throw new Error(result.error)
+
+    expect(result.query.minId).toBe(timestampMsToDiscordSnowflake(Date.UTC(2026, 5, 6)))
+    expect(result.query.maxId).toBe(timestampMsToDiscordSnowflake(Date.UTC(2026, 5, 7)))
+  })
+
+  test("rejects invalid operators", () => {
+    expect(parseDiscordSearchQuery("pinned:maybe")).toEqual({ ok: false, error: "Invalid pinned: value maybe" })
+    expect(parseDiscordSearchQuery("role:moderators")).toEqual({
+      ok: false,
+      error: "Role search requires a role ID or role mention: moderators"
+    })
+  })
+})