opencode-discord-bot 0.1.0 → 0.2.0

package/src/Discord/SearchQueryDates.ts

@@ -0,0 +1,43 @@
+export type DiscordSearchDateKey = "before" | "after" | "during"
+
+export type DiscordSearchDateResult =
+  | { readonly ok: true; readonly minId?: string; readonly maxId?: string }
+  | { readonly ok: false; readonly error: string }
+
+const discordEpochMs = 1_420_070_400_000n
+const dayMs = 24 * 60 * 60 * 1000
+const dateOnlyPattern = /^(\d{4})-(\d{2})-(\d{2})$/
+
+const parseTimestampMs = (input: string): number | undefined => {
+  const dateOnly = dateOnlyPattern.exec(input.trim())
+  if (dateOnly !== null) {
+    const year = Number(dateOnly[1])
+    const month = Number(dateOnly[2])
+    const day = Number(dateOnly[3])
+    const value = Date.UTC(year, month - 1, day)
+    return Number.isFinite(value) ? value : undefined
+  }
+  const value = Date.parse(input)
+  return Number.isFinite(value) ? value : undefined
+}
+
+const startOfUtcDay = (ms: number): number => {
+  const date = new Date(ms)
+  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate())
+}
+
+export const timestampMsToDiscordSnowflake = (ms: number): string => {
+  const timestamp = BigInt(Math.max(0, Math.trunc(ms)))
+  const value = (timestamp - discordEpochMs) << 22n
+  return (value > 0n ? value : 0n).toString()
+}
+
+export const discordSearchDateFilter = (key: DiscordSearchDateKey, value: string): DiscordSearchDateResult => {
+  const ms = parseTimestampMs(value)
+  if (ms === undefined) return { ok: false, error: `Invalid ${key}: date ${value}` }
+  if (key === "during") {
+    const start = startOfUtcDay(ms)
+    return { ok: true, minId: timestampMsToDiscordSnowflake(start), maxId: timestampMsToDiscordSnowflake(start + dayMs) }
+  }
+  return key === "before" ? { ok: true, maxId: timestampMsToDiscordSnowflake(ms) } : { ok: true, minId: timestampMsToDiscordSnowflake(ms) }
+}

package/src/Discord/SearchQueryTokens.ts

@@ -0,0 +1,25 @@
+export const tokenizeDiscordSearch = (input: string): ReadonlyArray<string> => {
+  const matches = input.match(/(?:[^\s"'\\]+|\\.|"(?:\\.|[^"])*"|'(?:\\.|[^'])*')+/g)
+  if (matches === null) return []
+  return matches.map((token) =>
+    token
+      .replace(/(["'])((?:\\.|(?!\1).)*)\1/g, (_match, _quote: string, body: string) => body.replace(/\\(.)/g, "$1"))
+      .replace(/\\(.)/g, "$1")
+  )
+}
+
+export const splitValues = (input: string): ReadonlyArray<string> =>
+  input
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean)
+
+export const splitKeyValue = (token: string): readonly [string, string] | undefined => {
+  const index = token.indexOf(":")
+  if (index <= 0) return undefined
+  const key = token.slice(0, index).trim().toLowerCase().replaceAll("-", "_")
+  const value = token.slice(index + 1).trim()
+  return key.length === 0 || value.length === 0 ? undefined : [key, value]
+}
+
+export const unique = <A>(items: ReadonlyArray<A>): ReadonlyArray<A> => [...new Set(items)]

package/src/Main.test.ts

@@ -115,7 +115,7 @@ describe("makeApplication startup", () => {
   test("swallows failed message turns from gateway dispatch", async () => {
     const failingDiscord: DiscordService = {
       fetchContext: () => Effect.fail(new DiscordError({ message: "context failed" })),
-      fetchHistory: () => Effect.succeed([]),
+      searchMessages: () => Effect.succeed({ totalResults: 0, offset: 0, hasMore: false, messages: [] }),
       sendTyping: () => Effect.void,
       postMessage: () => Effect.succeed({ id: "posted" }),
       editMessage: () => Effect.void,

package/src/Schema.ts

@@ -50,6 +50,42 @@ export type DiscordMessage = {
   readonly isSystem?: boolean
 }
 
+export type DiscordSearchQuery = {
+  readonly content?: string
+  readonly authors: ReadonlyArray<string>
+  readonly authorNames: ReadonlyArray<string>
+  readonly authorTypes: ReadonlyArray<string>
+  readonly channels: ReadonlyArray<string>
+  readonly channelNames: ReadonlyArray<string>
+  readonly mentions: ReadonlyArray<string>
+  readonly mentionNames: ReadonlyArray<string>
+  readonly roleMentions: ReadonlyArray<string>
+  readonly repliedToUsers: ReadonlyArray<string>
+  readonly repliedToUserNames: ReadonlyArray<string>
+  readonly repliedToMessages: ReadonlyArray<string>
+  readonly has: ReadonlyArray<string>
+  readonly embedTypes: ReadonlyArray<string>
+  readonly embedProviders: ReadonlyArray<string>
+  readonly linkHostnames: ReadonlyArray<string>
+  readonly attachmentFilenames: ReadonlyArray<string>
+  readonly attachmentExtensions: ReadonlyArray<string>
+  readonly maxId?: string
+  readonly minId?: string
+  readonly slop?: number
+  readonly pinned?: boolean
+  readonly mentionEveryone?: boolean
+  readonly sortBy?: "timestamp" | "relevance"
+  readonly sortOrder?: "asc" | "desc"
+  readonly includeNsfw?: boolean
+}
+
+export type DiscordSearchResult = {
+  readonly totalResults: number
+  readonly offset: number
+  readonly hasMore: boolean
+  readonly messages: ReadonlyArray<DiscordMessage>
+}
+
 export type ToolTarget = {
   readonly guildId?: string | undefined
   readonly channelId?: string | undefined

package/src/Tools/DiscordSearchMessagesTool.ts

@@ -0,0 +1,35 @@
+import { tool } from "@opencode-ai/plugin"
+
+const loopbackToolUrl = "__OPENCODE_DISCORD_BOT_LOOPBACK_URL__/tool"
+
+const targetSchema = tool.schema
+  .object({
+    guildId: tool.schema.string().describe("Discord guild/server ID to search within."),
+    channelId: tool.schema.string().optional().describe("Optional active channel ID. Search is guild-wide unless the query uses in:."),
+    threadId: tool.schema.string().optional().describe("Optional active thread ID. Search is guild-wide unless the query uses in:.")
+  })
+  .describe("Discord guild target for message search.")
+
+export default tool({
+  description:
+    "Search Discord message history using Discord-style search syntax. Use free text plus operators like from:<@user>, mentions:<@user>, in:<#channel>, has:link, has:file, before:YYYY-MM-DD, after:YYYY-MM-DD, during:YYYY-MM-DD, pinned:true, sort:relevance, order:desc. Returns matching messages and total count. The active turn already includes recent messages by default; use this tool for older or specific messages.",
+  args: {
+    target: targetSchema,
+    query: tool.schema.string().describe("Discord search query string, using the same operators a Discord user would type."),
+    limit: tool.schema.number().int().positive().optional().describe("Results per page, 1-25. Default 25."),
+    offset: tool.schema.number().int().optional().describe("Pagination offset. Default 0; Discord supports offsets up to 9975.")
+  },
+  async execute(request) {
+    const response = await fetch(loopbackToolUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        action: "searchMessages",
+        target: request.target,
+        args: { query: request.query, limit: request.limit, offset: request.offset }
+      })
+    })
+    const payload = await response.json()
+    return JSON.stringify(payload, null, 2) ?? String(payload)
+  }
+})

package/src/Tools/Scaffolding.test.ts

@@ -4,11 +4,11 @@ import { tmpdir } from "node:os"
 import { join } from "node:path"
 import { ensureDiscordTools, renderDiscordToolFile } from "./Scaffolding.ts"
 
-const toolFiles = ["discord-add-reaction.ts", "discord-fetch-history.ts", "discord-attach-file.ts", "discord-create-thread.ts"] as const
+const toolFiles = ["discord-add-reaction.ts", "discord-search-messages.ts", "discord-attach-file.ts", "discord-create-thread.ts"] as const
 
 const sourceUrls = [
   new URL("./DiscordAddReactionTool.ts", import.meta.url),
-  new URL("./DiscordFetchHistoryTool.ts", import.meta.url),
+  new URL("./DiscordSearchMessagesTool.ts", import.meta.url),
   new URL("./DiscordAttachFileTool.ts", import.meta.url),
   new URL("./DiscordCreateThreadTool.ts", import.meta.url)
 ] as const
@@ -38,10 +38,11 @@ describe("Discord tool scaffolding", () => {
     }
 
     expect(combined).toContain('action: "addReaction"')
-    expect(combined).toContain('action: "fetchHistory"')
+    expect(combined).toContain('action: "searchMessages"')
     expect(combined).toContain('action: "attachFile"')
     expect(combined).toContain('action: "createThread"')
     expect(combined).toContain("emoji:")
+    expect(combined).toContain("query:")
     expect(combined).toContain("limit:")
     expect(combined).toContain("path:")
     expect(combined).toContain("name:")
@@ -74,12 +75,15 @@ describe("Discord tool scaffolding", () => {
       expect(await readFile(toolPaths[0] ?? "", "utf8")).not.toContain("// operator file")
 
       const deprecatedToolPath = join(projectDir, ".opencode", "tools", "discord-bridge.ts")
+      const deprecatedHistoryToolPath = join(projectDir, ".opencode", "tools", "discord-fetch-history.ts")
       await writeFile(deprecatedToolPath, "// Generated by opencode-discord-bot. DO NOT EDIT.\nexport const parameters = {}\n")
+      await writeFile(deprecatedHistoryToolPath, "// Generated by opencode-discord-bot. DO NOT EDIT.\nexport default {}\n")
       const migrated = await ensureDiscordTools({ projectDir, bridgePort: 6666, enabled: true, autoInstall: true })
 
       expect(migrated).toEqual(toolPaths)
       for (const toolPath of toolPaths) expect(await readFile(toolPath, "utf8")).toContain("http://127.0.0.1:6666/tool")
       expect(await exists(deprecatedToolPath)).toBe(false)
+      expect(await exists(deprecatedHistoryToolPath)).toBe(false)
     } finally {
       await rm(projectDir, { recursive: true, force: true })
     }

package/src/Tools/Scaffolding.ts

@@ -3,11 +3,11 @@ import { join } from "node:path"
 
 const header = "// Generated by opencode-discord-bot. DO NOT EDIT."
 const loopbackUrlPlaceholder = "__OPENCODE_DISCORD_BOT_LOOPBACK_URL__"
-const deprecatedDiscordBridgeFile = "discord-bridge.ts"
+const deprecatedDiscordBridgeFiles = ["discord-bridge.ts", "discord-fetch-history.ts"] as const
 
 const discordToolSources = [
   { fileName: "discord-add-reaction.ts", sourceUrl: new URL("./DiscordAddReactionTool.ts", import.meta.url) },
-  { fileName: "discord-fetch-history.ts", sourceUrl: new URL("./DiscordFetchHistoryTool.ts", import.meta.url) },
+  { fileName: "discord-search-messages.ts", sourceUrl: new URL("./DiscordSearchMessagesTool.ts", import.meta.url) },
   { fileName: "discord-attach-file.ts", sourceUrl: new URL("./DiscordAttachFileTool.ts", import.meta.url) },
   { fileName: "discord-create-thread.ts", sourceUrl: new URL("./DiscordCreateThreadTool.ts", import.meta.url) }
 ] as const
@@ -22,12 +22,14 @@ export type ToolScaffoldOptions = {
 const isMissingFile = (cause: unknown): boolean => typeof cause === "object" && cause !== null && "code" in cause && cause.code === "ENOENT"
 
 const removeDeprecatedGeneratedTool = async (toolsDir: string): Promise<void> => {
-  const toolPath = join(toolsDir, deprecatedDiscordBridgeFile)
-  try {
-    const current = await readFile(toolPath, "utf8")
-    if (current.startsWith(header)) await unlink(toolPath)
-  } catch (cause) {
-    if (!isMissingFile(cause)) throw cause
+  for (const fileName of deprecatedDiscordBridgeFiles) {
+    const toolPath = join(toolsDir, fileName)
+    try {
+      const current = await readFile(toolPath, "utf8")
+      if (current.startsWith(header)) await unlink(toolPath)
+    } catch (cause) {
+      if (!isMissingFile(cause)) throw cause
+    }
   }
 }
 

package/src/Tools/DiscordFetchHistoryTool.ts

@@ -1,28 +0,0 @@
-import { tool } from "@opencode-ai/plugin"
-
-const loopbackToolUrl = "__OPENCODE_DISCORD_BOT_LOOPBACK_URL__/tool"
-
-const targetSchema = tool.schema
-  .object({
-    guildId: tool.schema.string().describe("Discord guild ID."),
-    channelId: tool.schema.string().describe("Discord channel ID."),
-    threadId: tool.schema.string().optional().describe("Discord thread ID, when targeting a thread.")
-  })
-  .describe("Discord channel or thread target for history fetching.")
-
-export default tool({
-  description: "Fetch recent Discord message history through the local opencode-discord-bot process.",
-  args: {
-    target: targetSchema,
-    limit: tool.schema.number().int().positive().optional().describe("Maximum number of recent messages to fetch.")
-  },
-  async execute(request) {
-    const response = await fetch(loopbackToolUrl, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ action: "fetchHistory", target: request.target, args: { limit: request.limit } })
-    })
-    const payload = await response.json()
-    return JSON.stringify(payload, null, 2) ?? String(payload)
-  }
-})