@grinev/opencode-telegram-bot 0.4.0 → 0.6.0

package/dist/summary/formatter.js

@@ -2,6 +2,7 @@ import * as path from "path";
 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 = [];
@@ -21,6 +22,27 @@ function splitText(text, maxLength) {
     }
     return parts;
 }
+export function normalizePathForDisplay(filePath) {
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    const project = getCurrentProject();
+    if (!project?.worktree) {
+        return normalizedPath;
+    }
+    const normalizedWorktree = project.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) {
     if (!text || text.trim().length === 0) {
         return [];
@@ -50,9 +72,10 @@ function getToolDetails(tool, input) {
         case "read":
         case "edit":
         case "write":
-            const path = input.path || input.filePath;
-            if (typeof path === "string")
-                return path;
+        case "apply_patch":
+            const filePath = input.path || input.filePath;
+            if (typeof filePath === "string")
+                return normalizePathForDisplay(filePath);
             break;
         case "bash":
             if (typeof input.command === "string")
@@ -88,6 +111,8 @@ function getToolIcon(tool) {
             return "✍️";
         case "edit":
             return "✏️";
+        case "apply_patch":
+            return "🩹";
         case "bash":
             return "💻";
         case "glob":
@@ -133,6 +158,37 @@ function formatTodos(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) {
     const { tool, input, title } = toolInfo;
     logger.debug(`[Formatter] formatToolInfo: tool=${tool}, hasMetadata=${!!toolInfo.metadata}, hasFilediff=${!!toolInfo.metadata?.filediff}`);
@@ -151,22 +207,41 @@ export function formatToolInfo(toolInfo) {
     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);
+        }
+        else if (title) {
+            const fileFromTitle = extractFirstUpdatedFileFromTitle(title);
+            if (fileFromTitle) {
+                details = normalizePathForDisplay(fileFromTitle);
+            }
+        }
+    }
     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" && toolInfo.metadata && "filediff" in toolInfo.metadata) {
+    if ((tool === "edit" || tool === "apply_patch") &&
+        toolInfo.metadata &&
+        "filediff" in toolInfo.metadata) {
         const filediff = toolInfo.metadata.filediff;
-        logger.debug("[Formatter] Edit metadata:", JSON.stringify(toolInfo.metadata, null, 2));
-        const parts = [];
-        if (filediff.additions && filediff.additions > 0)
-            parts.push(`+${filediff.additions}`);
-        if (filediff.deletions && filediff.deletions > 0)
-            parts.push(`-${filediff.deletions}`);
-        if (parts.length > 0) {
-            lineInfo = ` (${parts.join(" ")})`;
+        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}`;
@@ -209,18 +284,19 @@ function formatDiff(diff) {
     return formattedLines.join("\n");
 }
 export function prepareCodeFile(content, filePath, operation) {
+    const displayPath = normalizePathForDisplay(filePath);
     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: ${filePath} (${sizeKb.toFixed(2)} KB > ${config.files.maxFileSizeKb} KB)`);
+        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: filePath })
-        : t("tool.file_header.edit", { path: filePath });
+        ? 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);

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

@@ -0,0 +1,182 @@
+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;
+    sendMessage;
+    queues = new Map();
+    timers = new Map();
+    generation = 0;
+    constructor(options) {
+        this.intervalSeconds = normalizeIntervalSeconds(options.intervalSeconds);
+        this.sendMessage = options.sendMessage;
+    }
+    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) {
+        const normalizedMessage = message.trim();
+        if (!sessionId || normalizedMessage.length === 0) {
+            return;
+        }
+        if (this.intervalSeconds === 0) {
+            const expectedGeneration = this.generation;
+            logger.debug(`[ToolBatcher] Sending immediate message: session=${sessionId}`);
+            void this.sendMessageSafe(sessionId, normalizedMessage, "immediate", expectedGeneration);
+            return;
+        }
+        const queue = this.queues.get(sessionId) ?? [];
+        queue.push(normalizedMessage);
+        this.queues.set(sessionId, queue);
+        logger.debug(`[ToolBatcher] Queued message: session=${sessionId}, queueSize=${queue.length}, interval=${this.intervalSeconds}s`);
+        this.ensureTimer(sessionId);
+    }
+    async flushSession(sessionId, reason) {
+        const expectedGeneration = this.generation;
+        this.clearTimer(sessionId);
+        const queuedMessages = this.queues.get(sessionId);
+        if (!queuedMessages || queuedMessages.length === 0) {
+            return;
+        }
+        this.queues.delete(sessionId);
+        const batches = this.packMessages(queuedMessages);
+        logger.debug(`[ToolBatcher] Flushing ${queuedMessages.length} tool messages as ${batches.length} Telegram messages (session=${sessionId}, reason=${reason})`);
+        for (const batchMessage of batches) {
+            await this.sendMessageSafe(sessionId, batchMessage, reason, expectedGeneration);
+        }
+    }
+    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);
+    }
+    async sendMessageSafe(sessionId, text, reason, expectedGeneration) {
+        if (this.generation !== expectedGeneration) {
+            logger.debug(`[ToolBatcher] Dropping stale tool batch message: session=${sessionId}, reason=${reason}`);
+            return;
+        }
+        try {
+            await this.sendMessage(sessionId, text);
+        }
+        catch (err) {
+            logger.error(`[ToolBatcher] Failed to send tool batch message: session=${sessionId}, reason=${reason}`, err);
+        }
+    }
+    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 = "";
+        for (const entry of normalizedEntries) {
+            if (!current) {
+                current = entry;
+                continue;
+            }
+            const candidate = `${current}\n\n${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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grinev/opencode-telegram-bot",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",