@kodelyth/discord 2026.5.42 → 2026.6.2

package/src/chunk.test.ts

@@ -1,170 +0,0 @@
-import { countLines, hasBalancedFences } from "klaw/plugin-sdk/test-fixtures";
-import { describe, expect, it } from "vitest";
-import { chunkDiscordText, chunkDiscordTextWithMode } from "./chunk.js";
-
-describe("chunkDiscordText", () => {
-  it("splits tall messages even when under 2000 chars", () => {
-    const text = Array.from({ length: 45 }, (_, i) => `line-${i + 1}`).join("\n");
-    expect(text.length).toBeLessThan(2000);
-
-    const chunks = chunkDiscordText(text, { maxChars: 2000, maxLines: 20 });
-    expect(chunks.length).toBeGreaterThan(1);
-    for (const chunk of chunks) {
-      expect(countLines(chunk)).toBeLessThanOrEqual(20);
-    }
-  });
-
-  it("keeps fenced code blocks balanced across chunks", () => {
-    const body = Array.from({ length: 30 }, (_, i) => `console.log(${i});`).join("\n");
-    const text = `Here is code:\n\n\`\`\`js\n${body}\n\`\`\`\n\nDone.`;
-
-    const chunks = chunkDiscordText(text, { maxChars: 2000, maxLines: 10 });
-    expect(chunks.length).toBeGreaterThan(1);
-
-    for (const chunk of chunks) {
-      expect(hasBalancedFences(chunk)).toBe(true);
-      expect(chunk.length).toBeLessThanOrEqual(2000);
-    }
-
-    expect(chunks[0]).toContain("```js");
-    expect(chunks.at(-1)).toContain("Done.");
-  });
-
-  it("keeps fenced blocks intact when chunkMode is newline", () => {
-    const text = "```js\nconst a = 1;\nconst b = 2;\n```\nAfter";
-    const chunks = chunkDiscordTextWithMode(text, {
-      maxChars: 2000,
-      maxLines: 50,
-      chunkMode: "newline",
-    });
-    expect(chunks).toEqual([text]);
-  });
-
-  it("reserves space for closing fences when chunking", () => {
-    const body = "a".repeat(120);
-    const text = `\`\`\`txt\n${body}\n\`\`\``;
-
-    const chunks = chunkDiscordText(text, { maxChars: 50, maxLines: 50 });
-    expect(chunks.length).toBeGreaterThan(1);
-    for (const chunk of chunks) {
-      expect(chunk.length).toBeLessThanOrEqual(50);
-      expect(hasBalancedFences(chunk)).toBe(true);
-    }
-  });
-
-  it("preserves whitespace when splitting long lines", () => {
-    const text = Array.from({ length: 40 }, () => "word").join(" ");
-    const chunks = chunkDiscordText(text, { maxChars: 20, maxLines: 50 });
-    expect(chunks.length).toBeGreaterThan(1);
-    expect(chunks.join("")).toBe(text);
-  });
-
-  it("preserves mixed whitespace across chunk boundaries", () => {
-    const text = "alpha  beta\tgamma   delta epsilon  zeta";
-    const chunks = chunkDiscordText(text, { maxChars: 12, maxLines: 50 });
-    expect(chunks.length).toBeGreaterThan(1);
-    expect(chunks.join("")).toBe(text);
-  });
-
-  it("keeps leading whitespace when splitting long lines", () => {
-    const text = "    indented line with words that force splits";
-    const chunks = chunkDiscordText(text, { maxChars: 14, maxLines: 50 });
-    expect(chunks.length).toBeGreaterThan(1);
-    expect(chunks.join("")).toBe(text);
-  });
-
-  it("uses CJK punctuation as a safe long-line split point", () => {
-    const text = "一二三四五。六七八九十。甲乙丙丁戊。";
-    const chunks = chunkDiscordText(text, { maxChars: 10, maxLines: 50 });
-
-    expect(chunks).toEqual(["一二三四五。", "六七八九十。", "甲乙丙丁戊。"]);
-    expect(chunks.join("")).toBe(text);
-  });
-
-  it("still prefers whitespace before CJK punctuation", () => {
-    const text = "alpha beta。gamma delta";
-    const chunks = chunkDiscordText(text, { maxChars: 13, maxLines: 50 });
-
-    expect(chunks[0]).toBe("alpha");
-    expect(chunks.join("")).toBe(text);
-  });
-
-  it("does not split surrogate pairs at hard fallback boundaries", () => {
-    const text = "ab😀cd😀ef";
-    const chunks = chunkDiscordText(text, { maxChars: 3, maxLines: 50 });
-
-    expect(chunks).toEqual(["ab", "😀c", "d😀", "ef"]);
-    expect(chunks.join("")).toBe(text);
-  });
-
-  it("keeps reasoning italics balanced across chunks", () => {
-    const body = Array.from({ length: 25 }, (_, i) => `${i + 1}. line`).join("\n");
-    const text = `Reasoning:\n_${body}_`;
-
-    const chunks = chunkDiscordText(text, { maxLines: 10, maxChars: 2000 });
-    expect(chunks.length).toBeGreaterThan(1);
-
-    for (const chunk of chunks) {
-      // Each chunk should have balanced italics markers (even count).
-      const count = (chunk.match(/_/g) || []).length;
-      expect(count % 2).toBe(0);
-    }
-
-    // Ensure italics reopen on subsequent chunks
-    expect(chunks[0]).toContain("_1. line");
-    // Second chunk should reopen italics at the start
-    expect(chunks[1].trimStart().startsWith("_")).toBe(true);
-  });
-
-  it("keeps reasoning italics balanced when chunks split by char limit", () => {
-    const longLine = "This is a very long reasoning line that forces char splits.";
-    const body = Array.from({ length: 5 }, () => longLine).join("\n");
-    const text = `Reasoning:\n_${body}_`;
-
-    const chunks = chunkDiscordText(text, { maxChars: 80, maxLines: 50 });
-    expect(chunks.length).toBeGreaterThan(1);
-
-    for (const chunk of chunks) {
-      const underscoreCount = (chunk.match(/_/g) || []).length;
-      expect(underscoreCount % 2).toBe(0);
-    }
-  });
-
-  it("keeps thinking-prefixed reasoning italics balanced across chunks", () => {
-    const body = Array.from({ length: 25 }, (_, i) => `${i + 1}. line`).join("\n");
-    const text = `Thinking\n\n_${body}_`;
-
-    const chunks = chunkDiscordText(text, { maxLines: 10, maxChars: 2000 });
-    expect(chunks.length).toBeGreaterThan(1);
-
-    for (const chunk of chunks) {
-      const underscoreCount = (chunk.match(/_/g) || []).length;
-      expect(underscoreCount % 2).toBe(0);
-    }
-  });
-
-  it("reopens italics while preserving leading whitespace on following chunk", () => {
-    const body = [
-      "1. line",
-      "2. line",
-      "3. line",
-      "4. line",
-      "5. line",
-      "6. line",
-      "7. line",
-      "8. line",
-      "9. line",
-      "10. line",
-      "  11. indented line",
-      "12. line",
-    ].join("\n");
-    const text = `Reasoning:\n_${body}_`;
-
-    const chunks = chunkDiscordText(text, { maxLines: 10, maxChars: 2000 });
-    expect(chunks.length).toBeGreaterThan(1);
-
-    const second = chunks[1];
-    expect(second.startsWith("_")).toBe(true);
-    expect(second).toContain("  11. indented line");
-  });
-});

package/src/chunk.ts

@@ -1,321 +0,0 @@
-import { chunkMarkdownTextWithMode, type ChunkMode } from "klaw/plugin-sdk/reply-chunking";
-
-type ChunkDiscordTextOpts = {
-  /** Max characters per Discord message. Default: 2000. */
-  maxChars?: number;
-  /**
-   * Soft max line count per message. Default: 17.
-   *
-   * Discord clients can clip/collapse very tall messages in the UI; splitting
-   * by lines keeps long multi-paragraph replies readable.
-   */
-  maxLines?: number;
-};
-
-type OpenFence = {
-  indent: string;
-  markerChar: string;
-  markerLen: number;
-  openLine: string;
-};
-
-const DEFAULT_MAX_CHARS = 2000;
-const DEFAULT_MAX_LINES = 17;
-const FENCE_RE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
-const CJK_PUNCTUATION_BREAK_AFTER_RE = /[、。，．！？；：）］｝〉》」』】〕〗〙]/u;
-
-function countLines(text: string) {
-  if (!text) {
-    return 0;
-  }
-  return text.split("\n").length;
-}
-
-function parseFenceLine(line: string): OpenFence | null {
-  const match = line.match(FENCE_RE);
-  if (!match) {
-    return null;
-  }
-  const indent = match[1] ?? "";
-  const marker = match[2] ?? "";
-  return {
-    indent,
-    markerChar: marker[0] ?? "`",
-    markerLen: marker.length,
-    openLine: line,
-  };
-}
-
-function closeFenceLine(openFence: OpenFence) {
-  return `${openFence.indent}${openFence.markerChar.repeat(openFence.markerLen)}`;
-}
-
-function closeFenceIfNeeded(text: string, openFence: OpenFence | null) {
-  if (!openFence) {
-    return text;
-  }
-  const closeLine = closeFenceLine(openFence);
-  if (!text) {
-    return closeLine;
-  }
-  if (!text.endsWith("\n")) {
-    return `${text}\n${closeLine}`;
-  }
-  return `${text}${closeLine}`;
-}
-
-function isHighSurrogate(code: number) {
-  return code >= 0xd800 && code <= 0xdbff;
-}
-
-function isLowSurrogate(code: number) {
-  return code >= 0xdc00 && code <= 0xdfff;
-}
-
-function clampToCodePointBoundary(text: string, index: number) {
-  const boundary = Math.min(Math.max(0, index), text.length);
-  if (boundary <= 0 || boundary >= text.length) {
-    return boundary;
-  }
-  const previous = text.charCodeAt(boundary - 1);
-  const next = text.charCodeAt(boundary);
-  if (isHighSurrogate(previous) && isLowSurrogate(next)) {
-    return boundary > 1 ? boundary - 1 : boundary + 1;
-  }
-  return boundary;
-}
-
-function findWhitespaceBreak(window: string) {
-  for (let i = window.length - 1; i >= 0; i--) {
-    if (/\s/.test(window[i])) {
-      // Return the separator index so whitespace stays with the next segment.
-      return i;
-    }
-  }
-  return -1;
-}
-
-function findCjkPunctuationBreak(window: string) {
-  for (let end = window.length; end > 0; ) {
-    const code = window.charCodeAt(end - 1);
-    const start = isLowSurrogate(code) && end > 1 ? end - 2 : end - 1;
-    const char = window.slice(start, end);
-    if (start > 0 && CJK_PUNCTUATION_BREAK_AFTER_RE.test(char)) {
-      // Return the exclusive end so CJK punctuation stays with the current segment.
-      return end;
-    }
-    end = start;
-  }
-  return -1;
-}
-
-function splitLongLine(
-  line: string,
-  maxChars: number,
-  opts: { preserveWhitespace: boolean },
-): string[] {
-  const limit = Math.max(1, Math.floor(maxChars));
-  if (line.length <= limit) {
-    return [line];
-  }
-  const out: string[] = [];
-  let remaining = line;
-  while (remaining.length > limit) {
-    if (opts.preserveWhitespace) {
-      const breakIdx = clampToCodePointBoundary(remaining, limit);
-      out.push(remaining.slice(0, breakIdx));
-      remaining = remaining.slice(breakIdx);
-      continue;
-    }
-    const window = remaining.slice(0, limit);
-    let breakIdx = findWhitespaceBreak(window);
-    if (breakIdx <= 0) {
-      breakIdx = findCjkPunctuationBreak(window);
-    }
-    if (breakIdx <= 0) {
-      breakIdx = clampToCodePointBoundary(remaining, limit);
-    }
-    out.push(remaining.slice(0, breakIdx));
-    // Keep the separator for the next segment so words don't get glued together.
-    remaining = remaining.slice(breakIdx);
-  }
-  if (remaining.length) {
-    out.push(remaining);
-  }
-  return out;
-}
-
-/**
- * Chunks outbound Discord text by both character count and (soft) line count,
- * while keeping fenced code blocks balanced across chunks.
- */
-export function chunkDiscordText(text: string, opts: ChunkDiscordTextOpts = {}): string[] {
-  const maxChars = Math.max(1, Math.floor(opts.maxChars ?? DEFAULT_MAX_CHARS));
-  const maxLines = Math.max(1, Math.floor(opts.maxLines ?? DEFAULT_MAX_LINES));
-
-  const body = text ?? "";
-  if (!body) {
-    return [];
-  }
-
-  const alreadyOk = body.length <= maxChars && countLines(body) <= maxLines;
-  if (alreadyOk) {
-    return [body];
-  }
-
-  const lines = body.split("\n");
-  const chunks: string[] = [];
-
-  let current = "";
-  let currentLines = 0;
-  let openFence: OpenFence | null = null;
-
-  const flush = () => {
-    if (!current) {
-      return;
-    }
-    const payload = closeFenceIfNeeded(current, openFence);
-    if (payload.trim().length) {
-      chunks.push(payload);
-    }
-    current = "";
-    currentLines = 0;
-    if (openFence) {
-      current = openFence.openLine;
-      currentLines = 1;
-    }
-  };
-
-  for (const originalLine of lines) {
-    const fenceInfo = parseFenceLine(originalLine);
-    const wasInsideFence = openFence !== null;
-    let nextOpenFence: OpenFence | null = openFence;
-    if (fenceInfo) {
-      if (!openFence) {
-        nextOpenFence = fenceInfo;
-      } else if (
-        openFence.markerChar === fenceInfo.markerChar &&
-        fenceInfo.markerLen >= openFence.markerLen
-      ) {
-        nextOpenFence = null;
-      }
-    }
-
-    const reserveChars = nextOpenFence ? closeFenceLine(nextOpenFence).length + 1 : 0;
-    const reserveLines = nextOpenFence ? 1 : 0;
-    const effectiveMaxChars = maxChars - reserveChars;
-    const effectiveMaxLines = maxLines - reserveLines;
-    const charLimit = effectiveMaxChars > 0 ? effectiveMaxChars : maxChars;
-    const lineLimit = effectiveMaxLines > 0 ? effectiveMaxLines : maxLines;
-    const prefixLen = current.length > 0 ? current.length + 1 : 0;
-    const segmentLimit = Math.max(1, charLimit - prefixLen);
-    const segments = splitLongLine(originalLine, segmentLimit, {
-      preserveWhitespace: wasInsideFence,
-    });
-
-    for (let segIndex = 0; segIndex < segments.length; segIndex++) {
-      const segment = segments[segIndex];
-      const isLineContinuation = segIndex > 0;
-      const delimiter = isLineContinuation ? "" : current.length > 0 ? "\n" : "";
-      const addition = `${delimiter}${segment}`;
-      const nextLen = current.length + addition.length;
-      const nextLines = currentLines + (isLineContinuation ? 0 : 1);
-
-      const wouldExceedChars = nextLen > charLimit;
-      const wouldExceedLines = nextLines > lineLimit;
-
-      if ((wouldExceedChars || wouldExceedLines) && current.length > 0) {
-        flush();
-      }
-
-      if (current.length > 0) {
-        current += addition;
-        if (!isLineContinuation) {
-          currentLines += 1;
-        }
-      } else {
-        current = segment;
-        currentLines = 1;
-      }
-    }
-
-    openFence = nextOpenFence;
-  }
-
-  if (current.length) {
-    const payload = closeFenceIfNeeded(current, openFence);
-    if (payload.trim().length) {
-      chunks.push(payload);
-    }
-  }
-
-  return rebalanceReasoningItalics(text, chunks);
-}
-
-export function chunkDiscordTextWithMode(
-  text: string,
-  opts: ChunkDiscordTextOpts & { chunkMode?: ChunkMode },
-): string[] {
-  const chunkMode = opts.chunkMode ?? "length";
-  if (chunkMode !== "newline") {
-    return chunkDiscordText(text, opts);
-  }
-  const lineChunks = chunkMarkdownTextWithMode(
-    text,
-    Math.max(1, Math.floor(opts.maxChars ?? DEFAULT_MAX_CHARS)),
-    "newline",
-  );
-  const chunks: string[] = [];
-  for (const line of lineChunks) {
-    const nested = chunkDiscordText(line, opts);
-    if (!nested.length && line) {
-      chunks.push(line);
-      continue;
-    }
-    chunks.push(...nested);
-  }
-  return chunks;
-}
-
-// Keep italics intact for reasoning payloads that are wrapped once with `_…_`.
-// When Discord chunking splits the message, we close italics at the end of
-// each chunk and reopen at the start of the next so every chunk renders
-// consistently.
-function rebalanceReasoningItalics(source: string, chunks: string[]): string[] {
-  if (chunks.length <= 1) {
-    return chunks;
-  }
-
-  const opensWithReasoningItalics =
-    /^(?:Reasoning:|Thinking\.{0,3})\n+_/u.test(source) && source.trimEnd().endsWith("_");
-  if (!opensWithReasoningItalics) {
-    return chunks;
-  }
-
-  const adjusted = [...chunks];
-  for (let i = 0; i < adjusted.length; i++) {
-    const isLast = i === adjusted.length - 1;
-    const current = adjusted[i];
-
-    // Ensure current chunk closes italics so Discord renders it italicized.
-    const needsClosing = !current.trimEnd().endsWith("_");
-    if (needsClosing) {
-      adjusted[i] = `${current}_`;
-    }
-
-    if (isLast) {
-      break;
-    }
-
-    // Re-open italics on the next chunk if needed.
-    const next = adjusted[i + 1];
-    const leadingWhitespaceLen = next.length - next.trimStart().length;
-    const leadingWhitespace = next.slice(0, leadingWhitespaceLen);
-    const nextBody = next.slice(leadingWhitespaceLen);
-    if (!nextBody.startsWith("_")) {
-      adjusted[i + 1] = `${leadingWhitespace}_${nextBody}`;
-    }
-  }
-
-  return adjusted;
-}

package/src/client.proxy.test.ts

@@ -1,177 +0,0 @@
-import http from "node:http";
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import { fetch as undiciFetch } from "undici";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { createDiscordRestClient } from "./client.js";
-import { createDiscordRequestClient } from "./proxy-request-client.js";
-
-const makeProxyFetchMock = vi.hoisted(() => vi.fn());
-
-vi.mock("klaw/plugin-sdk/fetch-runtime", async () => {
-  const actual = await vi.importActual<typeof import("klaw/plugin-sdk/fetch-runtime")>(
-    "klaw/plugin-sdk/fetch-runtime",
-  );
-  makeProxyFetchMock.mockImplementation((proxyUrl: string) => {
-    if (proxyUrl === "bad-proxy") {
-      throw new Error("bad proxy");
-    }
-    return actual.makeProxyFetch(proxyUrl);
-  });
-  return {
-    ...actual,
-    makeProxyFetch: makeProxyFetchMock,
-  };
-});
-
-describe("createDiscordRestClient proxy support", () => {
-  beforeEach(() => {
-    makeProxyFetchMock.mockClear();
-  });
-
-  it("injects a custom fetch into RequestClient when a Discord proxy is configured", () => {
-    const cfg = {
-      channels: {
-        discord: {
-          token: "Bot test-token",
-          proxy: "http://127.0.0.1:8080",
-        },
-      },
-    } as KlawConfig;
-
-    const { rest } = createDiscordRestClient({ cfg });
-    const requestClient = rest as unknown as {
-      customFetch?: typeof fetch;
-      options?: { fetch?: typeof fetch };
-    };
-
-    expect(makeProxyFetchMock).toHaveBeenCalledWith("http://127.0.0.1:8080");
-    expect(requestClient.options?.fetch).toBe(makeProxyFetchMock.mock.results[0]?.value);
-    expect(requestClient.customFetch).toBe(requestClient.options?.fetch);
-  });
-
-  it("does not inject fetch when no proxy is configured", () => {
-    const cfg = {
-      channels: {
-        discord: {
-          token: "Bot test-token",
-        },
-      },
-    } as KlawConfig;
-
-    const { rest } = createDiscordRestClient({ cfg });
-    const requestClient = rest as unknown as {
-      options?: { fetch?: typeof fetch };
-    };
-
-    expect(requestClient.options?.fetch).toBeUndefined();
-  });
-
-  it("falls back to direct fetch when the Discord proxy URL is invalid", () => {
-    const cfg = {
-      channels: {
-        discord: {
-          token: "Bot test-token",
-          proxy: "bad-proxy",
-        },
-      },
-    } as KlawConfig;
-
-    const { rest } = createDiscordRestClient({ cfg });
-    const requestClient = rest as unknown as {
-      options?: { fetch?: typeof fetch };
-    };
-
-    expect(makeProxyFetchMock).not.toHaveBeenCalledWith("bad-proxy");
-    expect(requestClient.options?.fetch).toBeUndefined();
-  });
-
-  it("falls back to direct fetch when the Discord proxy URL is remote", () => {
-    const cfg = {
-      channels: {
-        discord: {
-          token: "Bot test-token",
-          proxy: "http://proxy.test:8080",
-        },
-      },
-    } as KlawConfig;
-
-    const { rest } = createDiscordRestClient({ cfg });
-    const requestClient = rest as unknown as {
-      options?: { fetch?: typeof fetch };
-    };
-
-    expect(makeProxyFetchMock).not.toHaveBeenCalledWith("http://proxy.test:8080");
-    expect(requestClient.options?.fetch).toBeUndefined();
-  });
-
-  it("accepts IPv6 loopback Discord proxy URLs", () => {
-    const cfg = {
-      channels: {
-        discord: {
-          token: "Bot test-token",
-          proxy: "http://[::1]:8080",
-        },
-      },
-    } as KlawConfig;
-
-    const { rest } = createDiscordRestClient({ cfg });
-    const requestClient = rest as unknown as {
-      options?: { fetch?: typeof fetch };
-    };
-
-    expect(makeProxyFetchMock).toHaveBeenCalledWith("http://[::1]:8080");
-    expect(requestClient.options?.fetch).toBe(makeProxyFetchMock.mock.results[0]?.value);
-  });
-
-  it("serializes multipart media with undici-compatible FormData for proxy fetches", async () => {
-    const received = await new Promise<{
-      contentType: string | undefined;
-      body: string;
-    }>((resolve, reject) => {
-      const server = http.createServer((req, res) => {
-        const chunks: Buffer[] = [];
-        req.on("data", (chunk: Buffer) => chunks.push(chunk));
-        req.on("error", reject);
-        req.on("end", () => {
-          resolve({
-            contentType: req.headers["content-type"],
-            body: Buffer.concat(chunks).toString("utf8"),
-          });
-          res.setHeader("Content-Type", "application/json");
-          res.end(JSON.stringify({ id: "message-id", channel_id: "channel-id" }));
-          server.close();
-        });
-      });
-      server.on("error", reject);
-      server.listen(0, "127.0.0.1", () => {
-        const address = server.address();
-        if (!address || typeof address === "string") {
-          reject(new Error("failed to bind test server"));
-          server.close();
-          return;
-        }
-        const rest = createDiscordRequestClient("test-token", {
-          baseUrl: `http://127.0.0.1:${address.port}`,
-          fetch: undiciFetch as unknown as typeof fetch,
-          queueRequests: false,
-        });
-        void rest
-          .post("/channels/123/messages", {
-            body: {
-              content: "with image",
-              files: [{ data: Buffer.from("png-data"), name: "image.png" }],
-            },
-          })
-          .catch((err: unknown) => {
-            reject(err);
-            server.close();
-          });
-      });
-    });
-
-    expect(received.contentType).toMatch(/^multipart\/form-data; boundary=/);
-    expect(received.body).toContain('name="files[0]"; filename="image.png"');
-    expect(received.body).toContain('name="payload_json"');
-    expect(received.body).toContain('"attachments":[{"id":0,"filename":"image.png"}]');
-  });
-});