@grinev/opencode-telegram-bot 0.15.0 → 0.16.1

package/dist/telegram/render/chunker.js

@@ -0,0 +1,281 @@
+import { logger } from "../../utils/logger.js";
+import { validateTelegramEntities } from "./validator.js";
+const DEFAULT_MAX_PART_LENGTH = 4096;
+const DEFAULT_BLOCK_SEPARATOR = "\n\n";
+const ENTITY_TYPE_PRIORITY = {
+    bold: 1,
+    italic: 2,
+    underline: 3,
+    strikethrough: 4,
+    spoiler: 5,
+    code: 6,
+    pre: 7,
+    text_link: 8,
+    mention: 100,
+    hashtag: 101,
+    cashtag: 102,
+    bot_command: 103,
+    url: 104,
+    email: 105,
+    phone_number: 106,
+    blockquote: 107,
+    expandable_blockquote: 108,
+    text_mention: 109,
+    custom_emoji: 110,
+};
+function isHighSurrogate(codeUnit) {
+    return codeUnit >= 0xd800 && codeUnit <= 0xdbff;
+}
+function isLowSurrogate(codeUnit) {
+    return codeUnit >= 0xdc00 && codeUnit <= 0xdfff;
+}
+function isSafeUtf16Boundary(text, index) {
+    if (index <= 0 || index >= text.length) {
+        return true;
+    }
+    return !(isHighSurrogate(text.charCodeAt(index - 1)) && isLowSurrogate(text.charCodeAt(index)));
+}
+function isEntityBoundary(entities, index) {
+    if (!entities?.length) {
+        return true;
+    }
+    return !entities.some((entity) => entity.offset < index && index < entity.offset + entity.length);
+}
+function compareEntities(left, right) {
+    if (left.offset !== right.offset) {
+        return left.offset - right.offset;
+    }
+    if (left.length !== right.length) {
+        return right.length - left.length;
+    }
+    return ENTITY_TYPE_PRIORITY[left.type] - ENTITY_TYPE_PRIORITY[right.type];
+}
+function sortEntities(entities) {
+    return [...entities].sort(compareEntities);
+}
+function normalizeOptions(options) {
+    return {
+        maxPartLength: Math.max(2, Math.floor(options?.maxPartLength ?? DEFAULT_MAX_PART_LENGTH)),
+        blockSeparator: options?.blockSeparator ?? DEFAULT_BLOCK_SEPARATOR,
+    };
+}
+function createRenderedPart(text, fallbackText, entities) {
+    const normalizedEntities = entities?.length ? sortEntities(entities) : undefined;
+    if (normalizedEntities) {
+        const validation = validateTelegramEntities(text, normalizedEntities);
+        if (!validation.ok) {
+            throw new Error(validation.issues.map((issue) => issue.message).join("; "));
+        }
+    }
+    return {
+        text,
+        entities: normalizedEntities,
+        fallbackText,
+        source: normalizedEntities?.length ? "entities" : "plain",
+    };
+}
+function clonePart(part) {
+    return {
+        text: part.text,
+        entities: part.entities ? [...part.entities] : undefined,
+        fallbackText: part.fallbackText,
+        source: part.source,
+    };
+}
+function isWhitespaceBoundary(text, index) {
+    return index > 0 && /\s/.test(text[index - 1]);
+}
+function findSplitBoundary(text, start, maxLength, entities) {
+    const hardEnd = Math.min(text.length, start + maxLength);
+    if (hardEnd >= text.length) {
+        return text.length;
+    }
+    let whitespaceBoundary = null;
+    let fallbackBoundary = null;
+    for (let index = hardEnd; index > start; index--) {
+        if (!isSafeUtf16Boundary(text, index) || !isEntityBoundary(entities, index)) {
+            continue;
+        }
+        if (text[index - 1] === "\n") {
+            return index;
+        }
+        if (whitespaceBoundary === null && isWhitespaceBoundary(text, index)) {
+            whitespaceBoundary = index;
+        }
+        if (fallbackBoundary === null) {
+            fallbackBoundary = index;
+        }
+    }
+    return whitespaceBoundary ?? fallbackBoundary;
+}
+function rebaseSliceEntities(entities, start, end) {
+    if (!entities?.length) {
+        return [];
+    }
+    return entities
+        .filter((entity) => entity.offset >= start && entity.offset + entity.length <= end)
+        .map((entity) => ({
+        ...entity,
+        offset: entity.offset - start,
+    }));
+}
+function splitPlainText(text, maxLength) {
+    if (!text) {
+        return [];
+    }
+    const chunks = [];
+    let start = 0;
+    while (start < text.length) {
+        const end = findSplitBoundary(text, start, maxLength);
+        if (!end || end <= start) {
+            throw new Error("Unable to split plain text on a safe UTF-16 boundary");
+        }
+        chunks.push(text.slice(start, end));
+        start = end;
+    }
+    return chunks;
+}
+function isFullRangePreEntity(block) {
+    if (block.entities?.length !== 1) {
+        return null;
+    }
+    const [entity] = block.entities;
+    if (entity.type !== "pre" || entity.offset !== 0 || entity.length !== block.text.length) {
+        return null;
+    }
+    return entity;
+}
+function splitPreformattedBlock(block, maxLength, preEntity) {
+    const parts = [];
+    let start = 0;
+    while (start < block.text.length) {
+        const end = findSplitBoundary(block.text, start, maxLength);
+        if (!end || end <= start) {
+            throw new Error(`Unable to split preformatted ${block.blockType} block`);
+        }
+        const text = block.text.slice(start, end);
+        parts.push(createRenderedPart(text, text, [
+            {
+                type: "pre",
+                offset: 0,
+                length: text.length,
+                ...(preEntity.language ? { language: preEntity.language } : {}),
+            },
+        ]));
+        start = end;
+    }
+    logger.debug("[TelegramRender] Preformatted block chunked", {
+        blockType: block.blockType,
+        textLength: block.text.length,
+        maxLength,
+        partCount: parts.length,
+    });
+    return parts;
+}
+function splitRichBlock(block, maxLength) {
+    if (!block.entities?.length) {
+        return null;
+    }
+    const parts = [];
+    let start = 0;
+    while (start < block.text.length) {
+        const end = findSplitBoundary(block.text, start, maxLength, block.entities);
+        if (!end || end <= start) {
+            return null;
+        }
+        const entities = rebaseSliceEntities(block.entities, start, end);
+        const text = block.text.slice(start, end);
+        parts.push(createRenderedPart(text, text, entities));
+        start = end;
+    }
+    if (parts.length > 1) {
+        logger.debug("[TelegramRender] Rich block chunked", {
+            blockType: block.blockType,
+            textLength: block.text.length,
+            entityCount: block.entities.length,
+            maxLength,
+            partCount: parts.length,
+        });
+    }
+    return parts;
+}
+function splitBlockToParts(block, maxLength) {
+    if (!block.text) {
+        return [];
+    }
+    if (block.text.length <= maxLength) {
+        return [createRenderedPart(block.text, block.fallbackText, block.entities)];
+    }
+    const preEntity = isFullRangePreEntity(block);
+    if (preEntity) {
+        return splitPreformattedBlock(block, maxLength, preEntity);
+    }
+    if (block.entities?.length) {
+        const richParts = splitRichBlock(block, maxLength);
+        if (richParts) {
+            return richParts;
+        }
+        logger.debug("[TelegramRender] Rich block downgraded to plain during chunking", {
+            blockType: block.blockType,
+            textLength: block.text.length,
+            entityCount: block.entities.length,
+            maxLength,
+        });
+    }
+    return splitPlainText(block.fallbackText, maxLength).map((text) => createRenderedPart(text, text));
+}
+function createBuilder() {
+    return {
+        text: "",
+        fallbackText: "",
+        entities: [],
+    };
+}
+function appendToBuilder(builder, chunk, prefix) {
+    const offset = builder.text.length + prefix.length;
+    builder.text += `${prefix}${chunk.text}`;
+    builder.fallbackText += `${prefix}${chunk.fallbackText}`;
+    if (chunk.entities?.length) {
+        builder.entities.push(...chunk.entities.map((entity) => ({
+            ...entity,
+            offset: entity.offset + offset,
+        })));
+    }
+}
+function finalizeBuilder(builder) {
+    if (!builder || !builder.text) {
+        return null;
+    }
+    return createRenderedPart(builder.text, builder.fallbackText, builder.entities);
+}
+export function chunkTelegramRenderedBlocks(blocks, options) {
+    const { maxPartLength, blockSeparator } = normalizeOptions(options);
+    const blockGroups = blocks
+        .map((block) => splitBlockToParts(block, maxPartLength))
+        .filter((group) => group.length > 0);
+    const parts = [];
+    let current = createBuilder();
+    for (const blockParts of blockGroups) {
+        for (let index = 0; index < blockParts.length; index++) {
+            const chunk = blockParts[index];
+            const needsSeparator = index === 0 && current.text.length > 0;
+            const prefix = needsSeparator ? blockSeparator : "";
+            if (current.text.length > 0 &&
+                current.text.length + prefix.length + chunk.text.length > maxPartLength) {
+                const finalized = finalizeBuilder(current);
+                if (finalized) {
+                    parts.push(finalized);
+                }
+                current = createBuilder();
+                appendToBuilder(current, chunk, "");
+                continue;
+            }
+            appendToBuilder(current, chunk, prefix);
+        }
+    }
+    const finalized = finalizeBuilder(current);
+    if (finalized) {
+        parts.push(finalized);
+    }
+    return parts.map(clonePart);
+}

package/dist/telegram/render/inline-renderer.js

@@ -0,0 +1,128 @@
+import { validateTelegramEntities } from "./validator.js";
+const ENTITY_TYPE_PRIORITY = {
+    bold: 1,
+    italic: 2,
+    underline: 3,
+    strikethrough: 4,
+    spoiler: 5,
+    code: 6,
+    text_link: 7,
+    mention: 100,
+    hashtag: 101,
+    cashtag: 102,
+    bot_command: 103,
+    url: 104,
+    email: 105,
+    phone_number: 106,
+    blockquote: 107,
+    expandable_blockquote: 108,
+    pre: 109,
+    text_mention: 110,
+    custom_emoji: 111,
+};
+function appendText(state, text) {
+    if (!text) {
+        return;
+    }
+    state.text += text;
+}
+function pushEntity(state, entity) {
+    if (entity.length <= 0) {
+        return;
+    }
+    state.entities.push(entity);
+}
+function renderIntoState(state, nodes) {
+    for (const node of nodes) {
+        switch (node.type) {
+            case "text":
+                appendText(state, node.text);
+                break;
+            case "bold": {
+                const offset = state.text.length;
+                renderIntoState(state, node.children);
+                pushEntity(state, { type: "bold", offset, length: state.text.length - offset });
+                break;
+            }
+            case "italic": {
+                const offset = state.text.length;
+                renderIntoState(state, node.children);
+                pushEntity(state, { type: "italic", offset, length: state.text.length - offset });
+                break;
+            }
+            case "strike": {
+                const offset = state.text.length;
+                renderIntoState(state, node.children);
+                pushEntity(state, {
+                    type: "strikethrough",
+                    offset,
+                    length: state.text.length - offset,
+                });
+                break;
+            }
+            case "underline": {
+                const offset = state.text.length;
+                renderIntoState(state, node.children);
+                pushEntity(state, { type: "underline", offset, length: state.text.length - offset });
+                break;
+            }
+            case "spoiler": {
+                const offset = state.text.length;
+                renderIntoState(state, node.children);
+                pushEntity(state, { type: "spoiler", offset, length: state.text.length - offset });
+                break;
+            }
+            case "code": {
+                const offset = state.text.length;
+                appendText(state, node.text);
+                pushEntity(state, { type: "code", offset, length: state.text.length - offset });
+                break;
+            }
+            case "link": {
+                const offset = state.text.length;
+                renderIntoState(state, node.text);
+                pushEntity(state, {
+                    type: "text_link",
+                    offset,
+                    length: state.text.length - offset,
+                    url: node.url,
+                });
+                break;
+            }
+            default: {
+                const exhaustiveCheck = node;
+                throw new Error(`Unsupported inline node: ${JSON.stringify(exhaustiveCheck)}`);
+            }
+        }
+    }
+}
+function compareEntities(left, right) {
+    if (left.offset !== right.offset) {
+        return left.offset - right.offset;
+    }
+    if (left.length !== right.length) {
+        return right.length - left.length;
+    }
+    return ENTITY_TYPE_PRIORITY[left.type] - ENTITY_TYPE_PRIORITY[right.type];
+}
+export function renderInlineNodes(nodes) {
+    const state = {
+        text: "",
+        entities: [],
+    };
+    renderIntoState(state, nodes);
+    state.entities.sort(compareEntities);
+    return {
+        text: state.text,
+        entities: state.entities,
+    };
+}
+export function renderInlineNodesValidated(nodes) {
+    const rendered = renderInlineNodes(nodes);
+    const validation = validateTelegramEntities(rendered.text, rendered.entities);
+    if (!validation.ok) {
+        const summary = validation.issues.map((issue) => issue.message).join("; ");
+        throw new Error(`Invalid Telegram inline entities: ${summary}`);
+    }
+    return rendered;
+}

package/dist/telegram/render/markdown-normalizer.js

@@ -0,0 +1,94 @@
+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 normalizeMarkdown(text, options) {
+    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(options.preserveBlockMarkup ? line : normalizeHeadingLine(line));
+            inQuote = false;
+            continue;
+        }
+        if (isHorizontalRuleLine(line)) {
+            output.push(options.preserveBlockMarkup ? line : "──────────");
+            inQuote = false;
+            continue;
+        }
+        const trimmedLeft = line.trimStart();
+        if (trimmedLeft.startsWith(">")) {
+            inQuote = true;
+            const quoteContent = trimmedLeft.replace(/^>\s?/, "");
+            const normalizedChecklistInQuote = normalizeChecklistLine(quoteContent);
+            output.push(normalizedChecklistInQuote && !options.preserveBlockMarkup
+                ? `> ${normalizedChecklistInQuote.trimStart()}`
+                : `> ${quoteContent.trimStart()}`);
+            continue;
+        }
+        const normalizedChecklist = normalizeChecklistLine(line);
+        if (normalizedChecklist) {
+            if (options.preserveBlockMarkup) {
+                output.push(inQuote ? `> ${trimmedLeft}` : line);
+            }
+            else {
+                output.push(inQuote ? `> ${normalizedChecklist.trimStart()}` : normalizedChecklist);
+            }
+            continue;
+        }
+        if (inQuote) {
+            output.push(`> ${trimmedLeft}`);
+            continue;
+        }
+        output.push(line);
+    }
+    return output.join("\n");
+}
+export function normalizeMarkdownForTelegramRendering(text) {
+    return normalizeMarkdown(text, { preserveBlockMarkup: false });
+}
+export function normalizeMarkdownForTelegramBlockParsing(text) {
+    return normalizeMarkdown(text, { preserveBlockMarkup: true });
+}

package/dist/telegram/render/pipeline.js

@@ -0,0 +1,9 @@
+import { parseTelegramBlocks } from "./block-parser.js";
+import { renderTelegramBlockWithFallback } from "./block-fallback.js";
+import { chunkTelegramRenderedBlocks } from "./chunker.js";
+export function renderTelegramBlocks(markdown) {
+    return parseTelegramBlocks(markdown).map(renderTelegramBlockWithFallback);
+}
+export function renderTelegramParts(markdown, options) {
+    return chunkTelegramRenderedBlocks(renderTelegramBlocks(markdown), options);
+}

package/dist/telegram/render/types.js

@@ -0,0 +1 @@
+export {};

package/dist/telegram/render/validator.js

@@ -0,0 +1,160 @@
+const SUPPORTED_ENTITY_TYPES = new Set([
+    "bold",
+    "italic",
+    "underline",
+    "strikethrough",
+    "spoiler",
+    "code",
+    "pre",
+    "text_link",
+]);
+const STYLE_ENTITY_TYPES = new Set([
+    "bold",
+    "italic",
+    "underline",
+    "strikethrough",
+    "spoiler",
+]);
+function getRange(entity) {
+    return {
+        start: entity.offset,
+        end: entity.offset + entity.length,
+    };
+}
+function rangesEqual(left, right) {
+    return left.offset === right.offset && left.length === right.length;
+}
+function rangesOverlap(left, right) {
+    const leftRange = getRange(left);
+    const rightRange = getRange(right);
+    return leftRange.start < rightRange.end && rightRange.start < leftRange.end;
+}
+function isFullyNested(left, right) {
+    const leftRange = getRange(left);
+    const rightRange = getRange(right);
+    return leftRange.start <= rightRange.start && leftRange.end >= rightRange.end;
+}
+function isPartialOverlap(left, right) {
+    if (!rangesOverlap(left, right) || rangesEqual(left, right)) {
+        return false;
+    }
+    return !isFullyNested(left, right) && !isFullyNested(right, left);
+}
+function isStyleEntity(entity) {
+    return STYLE_ENTITY_TYPES.has(entity.type);
+}
+function isValidLinkUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return ["http:", "https:", "tg:", "mailto:"].includes(parsed.protocol);
+    }
+    catch {
+        return false;
+    }
+}
+function validateEntityShape(textLength, entity, entityIndex) {
+    const issues = [];
+    if (!SUPPORTED_ENTITY_TYPES.has(entity.type)) {
+        issues.push({
+            code: "unsupported_entity_type",
+            message: `Unsupported Telegram entity type: ${entity.type}`,
+            entityIndex,
+        });
+    }
+    if (!Number.isInteger(entity.offset) || entity.offset < 0) {
+        issues.push({
+            code: "invalid_offset",
+            message: `Entity offset must be a non-negative integer, got ${entity.offset}`,
+            entityIndex,
+        });
+    }
+    if (!Number.isInteger(entity.length) || entity.length <= 0) {
+        issues.push({
+            code: "invalid_length",
+            message: `Entity length must be a positive integer, got ${entity.length}`,
+            entityIndex,
+        });
+    }
+    if (entity.offset + entity.length > textLength) {
+        issues.push({
+            code: "range_out_of_bounds",
+            message: `Entity range ${entity.offset}-${entity.offset + entity.length} exceeds text length ${textLength}`,
+            entityIndex,
+        });
+    }
+    if (entity.type === "text_link" && !isValidLinkUrl(entity.url)) {
+        issues.push({
+            code: "invalid_link_url",
+            message: `Invalid Telegram text_link URL: ${entity.url}`,
+            entityIndex,
+        });
+    }
+    return issues;
+}
+function validateEntityPair(left, leftIndex, right, rightIndex) {
+    const issues = [];
+    if (!rangesOverlap(left, right)) {
+        return issues;
+    }
+    if (left.type === right.type && rangesEqual(left, right)) {
+        issues.push({
+            code: "duplicate_entity_range",
+            message: `Duplicate ${left.type} entities share the same range ${left.offset}-${left.offset + left.length}`,
+            entityIndex: rightIndex,
+        });
+        return issues;
+    }
+    if (isPartialOverlap(left, right)) {
+        issues.push({
+            code: "partial_overlap",
+            message: `Entities ${left.type} and ${right.type} partially overlap`,
+            entityIndex: rightIndex,
+        });
+        return issues;
+    }
+    if (left.type === "code" ||
+        right.type === "code" ||
+        left.type === "pre" ||
+        right.type === "pre") {
+        issues.push({
+            code: left.type === "pre" || right.type === "pre" ? "pre_overlap" : "code_overlap",
+            message: `${left.type === "pre" || right.type === "pre" ? "Pre" : "Code"} entities cannot overlap with ${left.type === "code" || left.type === "pre" ? right.type : left.type}`,
+            entityIndex: left.type === "code" || left.type === "pre" ? rightIndex : leftIndex,
+        });
+        return issues;
+    }
+    if (left.type === "text_link" && right.type === "text_link") {
+        issues.push({
+            code: "nested_link",
+            message: "text_link entities cannot be nested or share the same range",
+            entityIndex: rightIndex,
+        });
+        return issues;
+    }
+    const styleAndLinkNestingAllowed = (left.type === "text_link" && isStyleEntity(right)) ||
+        (right.type === "text_link" && isStyleEntity(left));
+    if (!styleAndLinkNestingAllowed && !(isStyleEntity(left) && isStyleEntity(right))) {
+        issues.push({
+            code: "unsupported_overlap",
+            message: `Unsupported overlap between ${left.type} and ${right.type}`,
+            entityIndex: rightIndex,
+        });
+    }
+    return issues;
+}
+export function validateTelegramEntities(text, entities) {
+    const issues = [];
+    const textLength = text.length;
+    entities.forEach((entity, entityIndex) => {
+        issues.push(...validateEntityShape(textLength, entity, entityIndex));
+    });
+    for (let leftIndex = 0; leftIndex < entities.length; leftIndex++) {
+        for (let rightIndex = leftIndex + 1; rightIndex < entities.length; rightIndex++) {
+            issues.push(...validateEntityPair(entities[leftIndex], leftIndex, entities[rightIndex], rightIndex));
+        }
+    }
+    return {
+        ok: issues.length === 0,
+        issues,
+    };
+}