opencode-telegram-group-topics-bot 0.11.2

package/dist/summary/formatter.js

@@ -0,0 +1,417 @@
+import * as path from "path";
+import { convert } from "telegram-markdown-v2";
+import { config } from "../config.js";
+import { logger } from "../utils/logger.js";
+import { t } from "../i18n/index.js";
+import { getCurrentProject } from "../settings/manager.js";
+const TELEGRAM_MESSAGE_LIMIT = 4096;
+function splitText(text, maxLength) {
+    const parts = [];
+    let currentIndex = 0;
+    while (currentIndex < text.length) {
+        let endIndex = currentIndex + maxLength;
+        if (endIndex >= text.length) {
+            parts.push(text.slice(currentIndex));
+            break;
+        }
+        const breakPoint = text.lastIndexOf("\n", endIndex);
+        if (breakPoint > currentIndex) {
+            endIndex = breakPoint + 1;
+        }
+        parts.push(text.slice(currentIndex, endIndex));
+        currentIndex = endIndex;
+    }
+    return parts;
+}
+function isCodeFenceLine(line) {
+    return line.trimStart().startsWith("```");
+}
+function isHorizontalRuleLine(line) {
+    const normalized = line.trim();
+    if (!normalized) {
+        return false;
+    }
+    return /^([-*_])(?:\s*\1){2,}$/.test(normalized);
+}
+function isHeadingLine(line) {
+    return /^\s{0,3}#{1,6}\s+\S/.test(line);
+}
+function normalizeHeadingLine(line) {
+    const match = line.match(/^\s{0,3}#{1,6}\s+(.+?)\s*$/);
+    if (!match) {
+        return line;
+    }
+    return `**${match[1]}**`;
+}
+function normalizeChecklistLine(line) {
+    const match = line.match(/^(\s*)(?:[-+*]|\d+\.)\s+\[( |x|X)\]\s+(.*)$/);
+    if (!match) {
+        return null;
+    }
+    const marker = match[2].toLowerCase() === "x" ? "✅" : "🔲";
+    return `${match[1]}${marker} ${match[3]}`;
+}
+function preprocessMarkdownForTelegram(text) {
+    const lines = text.split("\n");
+    const output = [];
+    let inCodeFence = false;
+    let inQuote = false;
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        if (isCodeFenceLine(line)) {
+            inCodeFence = !inCodeFence;
+            inQuote = false;
+            output.push(line);
+            continue;
+        }
+        if (inCodeFence) {
+            output.push(line);
+            continue;
+        }
+        if (!line.trim()) {
+            inQuote = false;
+            output.push(line);
+            continue;
+        }
+        if (isHeadingLine(line)) {
+            output.push(normalizeHeadingLine(line));
+            inQuote = false;
+            continue;
+        }
+        if (isHorizontalRuleLine(line)) {
+            output.push("──────────");
+            inQuote = false;
+            continue;
+        }
+        const trimmedLeft = line.trimStart();
+        if (trimmedLeft.startsWith(">")) {
+            inQuote = true;
+            const quoteContent = trimmedLeft.replace(/^>\s?/, "");
+            const normalizedChecklistInQuote = normalizeChecklistLine(quoteContent);
+            output.push(normalizedChecklistInQuote ? `> ${normalizedChecklistInQuote.trimStart()}` : trimmedLeft);
+            continue;
+        }
+        const normalizedChecklist = normalizeChecklistLine(line);
+        if (normalizedChecklist) {
+            output.push(inQuote ? `> ${normalizedChecklist.trimStart()}` : normalizedChecklist);
+            continue;
+        }
+        if (inQuote) {
+            output.push(`> ${trimmedLeft}`);
+            continue;
+        }
+        output.push(line);
+    }
+    return output.join("\n");
+}
+export function normalizePathForDisplay(filePath, projectWorktree) {
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    const worktree = projectWorktree ?? getCurrentProject()?.worktree;
+    if (!worktree) {
+        return normalizedPath;
+    }
+    const normalizedWorktree = worktree.replace(/\\/g, "/").replace(/\/+$/, "");
+    if (!normalizedWorktree) {
+        return normalizedPath;
+    }
+    const pathForCompare = process.platform === "win32" ? normalizedPath.toLowerCase() : normalizedPath;
+    const worktreeForCompare = process.platform === "win32" ? normalizedWorktree.toLowerCase() : normalizedWorktree;
+    if (pathForCompare === worktreeForCompare) {
+        return ".";
+    }
+    const worktreePrefix = `${worktreeForCompare}/`;
+    if (pathForCompare.startsWith(worktreePrefix)) {
+        return normalizedPath.slice(normalizedWorktree.length + 1);
+    }
+    return normalizedPath;
+}
+export function formatSummary(text) {
+    return formatSummaryWithMode(text, config.bot.messageFormatMode);
+}
+export function getAssistantParseMode() {
+    if (config.bot.messageFormatMode === "markdown") {
+        return "MarkdownV2";
+    }
+    return undefined;
+}
+function formatMarkdownForTelegram(text) {
+    try {
+        const preprocessed = preprocessMarkdownForTelegram(text);
+        return convert(preprocessed, "keep");
+    }
+    catch (error) {
+        logger.warn("[Formatter] Failed to convert markdown summary, falling back to raw text", error);
+        return text;
+    }
+}
+export function formatSummaryWithMode(text, mode) {
+    if (!text || text.trim().length === 0) {
+        return [];
+    }
+    const parts = splitText(text, TELEGRAM_MESSAGE_LIMIT);
+    const formattedParts = [];
+    for (const part of parts) {
+        const trimmed = part.trim();
+        if (!trimmed) {
+            continue;
+        }
+        if (mode === "markdown") {
+            const converted = formatMarkdownForTelegram(trimmed);
+            const convertedParts = splitText(converted, TELEGRAM_MESSAGE_LIMIT);
+            for (const convertedPart of convertedParts) {
+                const normalizedPart = convertedPart.trim();
+                if (normalizedPart) {
+                    formattedParts.push(normalizedPart);
+                }
+            }
+            continue;
+        }
+        if (parts.length > 1) {
+            formattedParts.push(`\`\`\`\n${trimmed}\n\`\`\``);
+        }
+        else {
+            formattedParts.push(trimmed);
+        }
+    }
+    return formattedParts;
+}
+function getToolDetails(tool, input, projectWorktree) {
+    if (!input) {
+        return "";
+    }
+    // First, check fields specific to known tools
+    switch (tool) {
+        case "read":
+        case "edit":
+        case "write":
+        case "apply_patch":
+            const filePath = input.path || input.filePath;
+            if (typeof filePath === "string")
+                return normalizePathForDisplay(filePath, projectWorktree);
+            break;
+        case "bash":
+            if (typeof input.command === "string")
+                return input.command;
+            break;
+        case "grep":
+        case "glob":
+            if (typeof input.pattern === "string")
+                return input.pattern;
+            break;
+    }
+    // Generic search for MCP and other tools
+    // Look for common fields: query, url, name, prompt
+    const commonFields = ["query", "url", "name", "prompt", "text"];
+    for (const field of commonFields) {
+        if (typeof input[field] === "string") {
+            return input[field];
+        }
+    }
+    // If nothing matched but string fields exist, take the first one (except description)
+    for (const [key, value] of Object.entries(input)) {
+        if (key !== "description" && typeof value === "string" && value.length > 0) {
+            return value;
+        }
+    }
+    return "";
+}
+function getToolIcon(tool) {
+    switch (tool) {
+        case "read":
+            return "📖";
+        case "write":
+            return "✍️";
+        case "edit":
+            return "✏️";
+        case "apply_patch":
+            return "🩹";
+        case "bash":
+            return "💻";
+        case "glob":
+            return "📁";
+        case "grep":
+            return "🔍";
+        case "task":
+            return "🤖";
+        case "question":
+            return "❓";
+        case "todoread":
+            return "📋";
+        case "todowrite":
+            return "📝";
+        case "webfetch":
+            return "🌐";
+        case "web-search_tavily_search":
+            return "🔎";
+        case "web-search_tavily_extract":
+            return "📄";
+        case "skill":
+            return "🎓";
+        default:
+            return "🛠️";
+    }
+}
+function formatTodos(todos) {
+    const MAX_TODOS = 20;
+    const statusToMarker = {
+        completed: "✅",
+        in_progress: "🔄",
+        pending: "🔲",
+    };
+    const formattedTodos = [];
+    for (let i = 0; i < Math.min(todos.length, MAX_TODOS); i++) {
+        const todo = todos[i];
+        const marker = statusToMarker[todo.status] ?? "🔲";
+        formattedTodos.push(`${marker} ${todo.content}`);
+    }
+    let result = formattedTodos.join("\n");
+    if (todos.length > MAX_TODOS) {
+        result += `\n${t("tool.todo.overflow", { count: todos.length - MAX_TODOS })}`;
+    }
+    return result;
+}
+function formatDiffLineInfo(filediff) {
+    const parts = [];
+    if (filediff.additions && filediff.additions > 0)
+        parts.push(`+${filediff.additions}`);
+    if (filediff.deletions && filediff.deletions > 0)
+        parts.push(`-${filediff.deletions}`);
+    return parts.length > 0 ? ` (${parts.join(" ")})` : "";
+}
+function countDiffChangesFromText(text) {
+    let additions = 0;
+    let deletions = 0;
+    for (const line of text.split("\n")) {
+        if (line.startsWith("+") && !line.startsWith("+++")) {
+            additions++;
+            continue;
+        }
+        if (line.startsWith("-") && !line.startsWith("---")) {
+            deletions++;
+        }
+    }
+    return { additions, deletions };
+}
+function extractFirstUpdatedFileFromTitle(title) {
+    for (const rawLine of title.split("\n")) {
+        const line = rawLine.trim();
+        if (line.length >= 3 && line[1] === " " && /[AMDURC]/.test(line[0])) {
+            return line.slice(2).trim();
+        }
+    }
+    return "";
+}
+export function formatToolInfo(toolInfo, projectWorktree) {
+    const { tool, input, title } = toolInfo;
+    logger.debug(`[Formatter] formatToolInfo: tool=${tool}, hasMetadata=${!!toolInfo.metadata}, hasFilediff=${!!toolInfo.metadata?.filediff}`);
+    if (tool === "todowrite" && toolInfo.metadata?.todos) {
+        const todos = toolInfo.metadata.todos;
+        const toolIcon = getToolIcon(tool);
+        const todosList = formatTodos(todos);
+        return `${toolIcon} ${tool} (${todos.length})\n${todosList}`;
+    }
+    let details = title || getToolDetails(tool, input, projectWorktree);
+    const toolIcon = getToolIcon(tool);
+    let description = "";
+    if (input && typeof input.description === "string") {
+        description = `${input.description}\n`;
+    }
+    if (tool === "bash" && input && typeof input.command === "string") {
+        details = input.command;
+    }
+    if (tool === "apply_patch") {
+        const filediff = toolInfo.metadata && "filediff" in toolInfo.metadata
+            ? toolInfo.metadata.filediff
+            : undefined;
+        if (filediff?.file) {
+            details = normalizePathForDisplay(filediff.file, projectWorktree);
+        }
+        else if (title) {
+            const fileFromTitle = extractFirstUpdatedFileFromTitle(title);
+            if (fileFromTitle) {
+                details = normalizePathForDisplay(fileFromTitle, projectWorktree);
+            }
+        }
+    }
+    const detailsStr = details ? ` ${details}` : "";
+    let lineInfo = "";
+    if (tool === "write" && input && "content" in input && typeof input.content === "string") {
+        const lines = countLines(input.content);
+        lineInfo = ` (+${lines})`;
+    }
+    if ((tool === "edit" || tool === "apply_patch") &&
+        toolInfo.metadata &&
+        "filediff" in toolInfo.metadata) {
+        const filediff = toolInfo.metadata.filediff;
+        logger.debug("[Formatter] Diff metadata:", JSON.stringify(toolInfo.metadata, null, 2));
+        lineInfo = formatDiffLineInfo(filediff);
+    }
+    if (tool === "apply_patch" && !lineInfo) {
+        const diffText = toolInfo.metadata && typeof toolInfo.metadata.diff === "string"
+            ? toolInfo.metadata.diff
+            : input && typeof input.patchText === "string"
+                ? input.patchText
+                : "";
+        if (diffText) {
+            lineInfo = formatDiffLineInfo(countDiffChangesFromText(diffText));
+        }
+    }
+    return `${toolIcon} ${description}${tool}${detailsStr}${lineInfo}`;
+}
+function countLines(text) {
+    return text.split("\n").length;
+}
+function formatDiff(diff) {
+    const lines = diff.split("\n");
+    const formattedLines = [];
+    for (const line of lines) {
+        if (line.startsWith("@@")) {
+            continue;
+        }
+        if (line.startsWith("---") || line.startsWith("+++")) {
+            continue;
+        }
+        if (line.startsWith("Index:")) {
+            continue;
+        }
+        if (line.startsWith("===") && line.includes("=")) {
+            continue;
+        }
+        if (line.startsWith("\\ No newline")) {
+            continue;
+        }
+        if (line.startsWith(" ")) {
+            formattedLines.push(" " + line.slice(1));
+        }
+        else if (line.startsWith("+")) {
+            formattedLines.push("+ " + line.slice(1));
+        }
+        else if (line.startsWith("-")) {
+            formattedLines.push("- " + line.slice(1));
+        }
+        else {
+            formattedLines.push(line);
+        }
+    }
+    return formattedLines.join("\n");
+}
+export function prepareCodeFile(content, filePath, operation, projectWorktree) {
+    const displayPath = normalizePathForDisplay(filePath, projectWorktree);
+    let processedContent = content;
+    if (operation === "edit") {
+        processedContent = formatDiff(content);
+    }
+    const sizeKb = Buffer.byteLength(processedContent, "utf8") / 1024;
+    if (sizeKb > config.files.maxFileSizeKb) {
+        logger.debug(`[Formatter] File too large: ${displayPath} (${sizeKb.toFixed(2)} KB > ${config.files.maxFileSizeKb} KB)`);
+        return null;
+    }
+    const header = operation === "write"
+        ? t("tool.file_header.write", { path: displayPath })
+        : t("tool.file_header.edit", { path: displayPath });
+    const fullContent = header + processedContent;
+    const buffer = Buffer.from(fullContent, "utf8");
+    const basename = path.basename(filePath);
+    const filename = `${operation}_${basename}.txt`;
+    return { buffer, filename, caption: "" };
+}

package/dist/summary/tool-message-batcher.js

@@ -0,0 +1,277 @@
+import { logger } from "../utils/logger.js";
+const DEFAULT_INTERVAL_SECONDS = 5;
+const TELEGRAM_MESSAGE_MAX_LENGTH = 4096;
+function normalizeIntervalSeconds(value) {
+    if (!Number.isFinite(value)) {
+        return DEFAULT_INTERVAL_SECONDS;
+    }
+    const normalized = Math.floor(value);
+    if (normalized < 0) {
+        return DEFAULT_INTERVAL_SECONDS;
+    }
+    return normalized;
+}
+export class ToolMessageBatcher {
+    intervalSeconds;
+    sendText;
+    sendFile;
+    queues = new Map();
+    timers = new Map();
+    sessionTasks = new Map();
+    generation = 0;
+    constructor(options) {
+        this.intervalSeconds = normalizeIntervalSeconds(options.intervalSeconds);
+        this.sendText = options.sendText;
+        this.sendFile = options.sendFile;
+    }
+    setIntervalSeconds(nextIntervalSeconds) {
+        const normalized = normalizeIntervalSeconds(nextIntervalSeconds);
+        if (this.intervalSeconds === normalized) {
+            return;
+        }
+        this.intervalSeconds = normalized;
+        logger.info(`[ToolBatcher] Interval updated: ${normalized}s`);
+        if (normalized === 0) {
+            void this.flushAll("interval_updated");
+            return;
+        }
+        const sessionIds = Array.from(this.queues.keys());
+        for (const sessionId of sessionIds) {
+            this.restartTimer(sessionId);
+        }
+    }
+    getIntervalSeconds() {
+        return this.intervalSeconds;
+    }
+    enqueue(sessionId, message) {
+        this.enqueueTextInternal(sessionId, message);
+    }
+    enqueueUniqueByPrefix(sessionId, message, prefix) {
+        this.enqueueTextInternal(sessionId, message, prefix);
+    }
+    enqueueFile(sessionId, fileData) {
+        if (!sessionId) {
+            return;
+        }
+        if (this.intervalSeconds === 0) {
+            const expectedGeneration = this.generation;
+            logger.debug(`[ToolBatcher] Sending immediate file message: session=${sessionId}`);
+            void this.enqueueTask(sessionId, () => this.sendFileSafe(sessionId, fileData, "immediate", expectedGeneration));
+            return;
+        }
+        const queue = this.queues.get(sessionId) ?? [];
+        queue.push({ kind: "file", fileData });
+        this.queues.set(sessionId, queue);
+        logger.debug(`[ToolBatcher] Queued file message: session=${sessionId}, queueSize=${queue.length}, interval=${this.intervalSeconds}s`);
+        this.ensureTimer(sessionId);
+    }
+    async flushSession(sessionId, reason) {
+        await this.enqueueTask(sessionId, () => this.flushSessionInternal(sessionId, reason));
+    }
+    async flushAll(reason) {
+        for (const sessionId of Array.from(this.timers.keys())) {
+            this.clearTimer(sessionId);
+        }
+        const sessionIds = Array.from(this.queues.keys());
+        for (const sessionId of sessionIds) {
+            await this.flushSession(sessionId, reason);
+        }
+    }
+    clearSession(sessionId, reason) {
+        this.generation++;
+        this.clearTimer(sessionId);
+        if (this.queues.delete(sessionId)) {
+            logger.debug(`[ToolBatcher] Cleared session queue: session=${sessionId}, reason=${reason}`);
+        }
+    }
+    clearAll(reason) {
+        this.generation++;
+        for (const timer of this.timers.values()) {
+            clearTimeout(timer);
+        }
+        const queuedSessions = this.queues.size;
+        this.timers.clear();
+        this.queues.clear();
+        if (queuedSessions > 0) {
+            logger.debug(`[ToolBatcher] Cleared all queued tool messages: sessions=${queuedSessions}, reason=${reason}`);
+        }
+    }
+    clearTimer(sessionId) {
+        const timer = this.timers.get(sessionId);
+        if (!timer) {
+            return;
+        }
+        clearTimeout(timer);
+        this.timers.delete(sessionId);
+    }
+    ensureTimer(sessionId) {
+        if (this.timers.has(sessionId)) {
+            return;
+        }
+        this.restartTimer(sessionId);
+    }
+    restartTimer(sessionId) {
+        this.clearTimer(sessionId);
+        const timer = setTimeout(() => {
+            this.timers.delete(sessionId);
+            void this.flushSession(sessionId, "interval_elapsed");
+        }, this.intervalSeconds * 1000);
+        this.timers.set(sessionId, timer);
+    }
+    enqueueTask(sessionId, task) {
+        const previousTask = this.sessionTasks.get(sessionId) ?? Promise.resolve();
+        const nextTask = previousTask
+            .catch(() => undefined)
+            .then(task)
+            .finally(() => {
+            if (this.sessionTasks.get(sessionId) === nextTask) {
+                this.sessionTasks.delete(sessionId);
+            }
+        });
+        this.sessionTasks.set(sessionId, nextTask);
+        return nextTask;
+    }
+    enqueueTextInternal(sessionId, message, uniquePrefix) {
+        const normalizedMessage = message.trim();
+        if (!sessionId || normalizedMessage.length === 0) {
+            return;
+        }
+        if (this.intervalSeconds === 0) {
+            const expectedGeneration = this.generation;
+            logger.debug(`[ToolBatcher] Sending immediate text message: session=${sessionId}`);
+            void this.enqueueTask(sessionId, () => this.sendTextSafe(sessionId, normalizedMessage, "immediate", expectedGeneration));
+            return;
+        }
+        const normalizedPrefix = uniquePrefix?.trim();
+        const queue = this.queues.get(sessionId) ?? [];
+        if (normalizedPrefix) {
+            const existingUniqueMessage = queue.find((item) => item.kind === "text" && item.text.startsWith(normalizedPrefix));
+            if (existingUniqueMessage) {
+                existingUniqueMessage.text = normalizedMessage;
+                this.queues.set(sessionId, queue);
+                logger.debug(`[ToolBatcher] Updated queued unique text message: session=${sessionId}, prefix=${normalizedPrefix}, interval=${this.intervalSeconds}s`);
+                this.ensureTimer(sessionId);
+                return;
+            }
+        }
+        queue.push({ kind: "text", text: normalizedMessage });
+        this.queues.set(sessionId, queue);
+        logger.debug(`[ToolBatcher] Queued text message: session=${sessionId}, queueSize=${queue.length}, interval=${this.intervalSeconds}s`);
+        this.ensureTimer(sessionId);
+    }
+    async flushSessionInternal(sessionId, reason) {
+        const expectedGeneration = this.generation;
+        this.clearTimer(sessionId);
+        const queuedItems = this.queues.get(sessionId);
+        if (!queuedItems || queuedItems.length === 0) {
+            return;
+        }
+        this.queues.delete(sessionId);
+        const flushItems = this.buildFlushItems(queuedItems);
+        logger.debug(`[ToolBatcher] Flushing ${queuedItems.length} queued items as ${flushItems.length} Telegram sends (session=${sessionId}, reason=${reason})`);
+        for (const item of flushItems) {
+            if (item.kind === "text") {
+                await this.sendTextSafe(sessionId, item.text, reason, expectedGeneration);
+            }
+            else {
+                await this.sendFileSafe(sessionId, item.fileData, reason, expectedGeneration);
+            }
+        }
+    }
+    async sendTextSafe(sessionId, text, reason, expectedGeneration) {
+        if (this.generation !== expectedGeneration) {
+            logger.debug(`[ToolBatcher] Dropping stale tool text message: session=${sessionId}, reason=${reason}`);
+            return;
+        }
+        try {
+            await this.sendText(sessionId, text);
+        }
+        catch (err) {
+            logger.error(`[ToolBatcher] Failed to send tool text message: session=${sessionId}, reason=${reason}`, err);
+        }
+    }
+    async sendFileSafe(sessionId, fileData, reason, expectedGeneration) {
+        if (this.generation !== expectedGeneration) {
+            logger.debug(`[ToolBatcher] Dropping stale tool file message: session=${sessionId}, reason=${reason}`);
+            return;
+        }
+        try {
+            await this.sendFile(sessionId, fileData);
+        }
+        catch (err) {
+            logger.error(`[ToolBatcher] Failed to send tool file message: session=${sessionId}, reason=${reason}`, err);
+        }
+    }
+    buildFlushItems(entries) {
+        const result = [];
+        const textBuffer = [];
+        const flushTextBuffer = () => {
+            if (textBuffer.length === 0) {
+                return;
+            }
+            const packedTextMessages = this.packMessages(textBuffer);
+            for (const text of packedTextMessages) {
+                result.push({ kind: "text", text });
+            }
+            textBuffer.length = 0;
+        };
+        for (const entry of entries) {
+            if (entry.kind === "text") {
+                textBuffer.push(entry.text);
+            }
+            else {
+                flushTextBuffer();
+                result.push({ kind: "file", fileData: entry.fileData });
+            }
+        }
+        flushTextBuffer();
+        return result;
+    }
+    packMessages(messages) {
+        const normalizedEntries = messages
+            .flatMap((message) => this.splitLongText(message, TELEGRAM_MESSAGE_MAX_LENGTH))
+            .filter((entry) => entry.length > 0);
+        if (normalizedEntries.length === 0) {
+            return [];
+        }
+        const result = [];
+        let current = "";
+        const joinSeparator = normalizedEntries.length >= 8 ? "\n" : "\n\n";
+        for (const entry of normalizedEntries) {
+            if (!current) {
+                current = entry;
+                continue;
+            }
+            const candidate = `${current}${joinSeparator}${entry}`;
+            if (candidate.length <= TELEGRAM_MESSAGE_MAX_LENGTH) {
+                current = candidate;
+                continue;
+            }
+            result.push(current);
+            current = entry;
+        }
+        if (current) {
+            result.push(current);
+        }
+        return result;
+    }
+    splitLongText(text, limit) {
+        if (text.length <= limit) {
+            return [text];
+        }
+        const chunks = [];
+        let remaining = text;
+        while (remaining.length > limit) {
+            let splitIndex = remaining.lastIndexOf("\n", limit);
+            if (splitIndex <= 0 || splitIndex < Math.floor(limit * 0.5)) {
+                splitIndex = limit;
+            }
+            chunks.push(remaining.slice(0, splitIndex));
+            remaining = remaining.slice(splitIndex).replace(/^\n+/, "");
+        }
+        if (remaining.length > 0) {
+            chunks.push(remaining);
+        }
+        return chunks;
+    }
+}

package/dist/topic/colors.js

@@ -0,0 +1,8 @@
+export const TOPIC_COLORS = {
+    BLUE: 0x6fb9f0,
+    YELLOW: 0xffd67e,
+    PURPLE: 0xcb86db,
+    GREEN: 0x8eee98,
+    PINK: 0xff93b2,
+    RED: 0xfb6f5f,
+};