opencode-discord-bot 0.0.11 → 0.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-discord-bot",
-  "version": "0.0.11",
+  "version": "0.1.0",
   "description": "Discord bot bridge for a self-hosted opencode instance",
   "type": "module",
   "main": "src/Main.ts",

package/src/Discord/ChatSdkDiscord.ts

@@ -3,7 +3,7 @@ import { basename } from "node:path"
 import { createDiscordAdapter, type DiscordThreadId } from "@chat-adapter/discord"
 import type { AdapterPostableMessage, FetchOptions, FetchResult, Message, PostableRaw, RawMessage } from "chat"
 import { Duration, Effect } from "effect"
-import type { DiscordAttachment, DiscordMessage, DiscordScope } from "../Schema.ts"
+import type { DiscordAttachment, DiscordMessage, DiscordReaction, DiscordScope } from "../Schema.ts"
 import { DiscordError, type DiscordService } from "./DiscordPort.ts"
 
 type ChatDiscordAdapter = {
@@ -52,6 +52,23 @@ const attachments = (message: Message<unknown>): ReadonlyArray<DiscordAttachment
     url: item.url ?? ""
   }))
 
+const reactionEmoji = (value: unknown): string => {
+  if (!isRecord(value)) return "unknown"
+  const name = typeof value.name === "string" && value.name.length > 0 ? value.name : undefined
+  const id = typeof value.id === "string" && value.id.length > 0 ? value.id : undefined
+  if (id !== undefined && name !== undefined) return `${value.animated === true ? "a:" : ""}${name}:${id}`
+  return name ?? id ?? "unknown"
+}
+
+const reactions = (message: Message<unknown>): ReadonlyArray<DiscordReaction> => {
+  if (!isRecord(message.raw)) return []
+  const rawReactions: ReadonlyArray<unknown> = Array.isArray(message.raw.reactions) ? message.raw.reactions : []
+  return rawReactions.flatMap((item) => {
+    if (!isRecord(item) || typeof item.count !== "number" || !Number.isFinite(item.count) || item.count < 0) return []
+    return [{ emoji: reactionEmoji(item.emoji), count: item.count }]
+  })
+}
+
 const fromChatMessage = (scope: DiscordScope, message: Message<unknown>, nickname?: string | undefined): DiscordMessage => ({
   id: message.id,
   guildId: scope.guildId,
@@ -70,7 +87,7 @@ const fromChatMessage = (scope: DiscordScope, message: Message<unknown>, nicknam
   everyoneMention: message.text.includes("@everyone"),
   hereMention: message.text.includes("@here"),
   attachments: attachments(message),
-  reactions: [],
+  reactions: reactions(message),
   channelType: "guild"
 })
 

package/src/Discord/ChatSdkDiscordReactions.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, test } from "bun:test"
+import type { DiscordThreadId } from "@chat-adapter/discord"
+import type { AdapterPostableMessage, FetchOptions, FetchResult, RawMessage } from "chat"
+import { Message, parseMarkdown } from "chat"
+import { Effect } from "effect"
+import type { DiscordScope } from "../Schema.ts"
+import { makeChatSdkDiscord } from "./ChatSdkDiscord.ts"
+
+const scope: DiscordScope = { guildId: "g1", channelId: "c1" }
+
+const makeMessage = (threadId: string, raw: unknown): Message<unknown> =>
+  new Message({
+    id: "m1",
+    threadId,
+    text: "hello",
+    formatted: parseMarkdown("hello"),
+    raw,
+    author: { userId: "u1", userName: "alice", fullName: "Alice", isBot: false, isMe: false },
+    metadata: { dateSent: new Date("2026-06-05T14:03:00.000Z"), edited: false },
+    attachments: []
+  })
+
+class ReactionAdapter {
+  encodeThreadId(input: DiscordThreadId): string {
+    return `discord:${input.guildId}:${input.channelId}`
+  }
+
+  fetchMessages(threadId: string, _options?: FetchOptions): Promise<FetchResult<unknown>> {
+    return Promise.resolve({
+      messages: [
+        makeMessage(threadId, {
+          reactions: [
+            { count: 3, emoji: { id: null, name: "\u{1F680}" } },
+            { count: 2, emoji: { id: "custom1", name: "party_blob", animated: false } },
+            { count: 1, emoji: { id: "anim1", name: "dance", animated: true } },
+            { count: "bad", emoji: { id: null, name: "ignored" } },
+            { count: -1, emoji: { id: null, name: "ignored" } }
+          ]
+        })
+      ]
+    })
+  }
+
+  postMessage(threadId: string, _message: AdapterPostableMessage): Promise<RawMessage<unknown>> {
+    return Promise.resolve({ id: "posted", raw: {}, threadId })
+  }
+
+  editMessage(threadId: string, messageId: string, _message: AdapterPostableMessage): Promise<RawMessage<unknown>> {
+    return Promise.resolve({ id: messageId, raw: {}, threadId })
+  }
+
+  deleteMessage(_threadId: string, _messageId: string): Promise<void> {
+    return Promise.resolve()
+  }
+
+  startTyping(_threadId: string, _status?: string): Promise<void> {
+    return Promise.resolve()
+  }
+
+  addReaction(_threadId: string, _messageId: string, _emoji: string): Promise<void> {
+    return Promise.resolve()
+  }
+}
+
+describe("makeChatSdkDiscord reactions", () => {
+  test("maps aggregate reactions from raw Discord messages", async () => {
+    const discord = makeChatSdkDiscord(new ReactionAdapter())
+
+    const context = await Effect.runPromise(discord.fetchContext(scope, 30))
+
+    expect(context[0]?.reactions).toEqual([
+      { emoji: "\u{1F680}", count: 3 },
+      { emoji: "party_blob:custom1", count: 2 },
+      { emoji: "a:dance:anim1", count: 1 }
+    ])
+  })
+})