@grinev/opencode-telegram-bot 0.1.0-rc.1

package/dist/utils/formatting.js

@@ -0,0 +1,237 @@
+import { config } from "../config.js";
+import { logger } from "./logger.js";
+function normalizeParseMode(value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return "MarkdownV2";
+    }
+    const raw = value.trim();
+    const normalized = raw.toLowerCase();
+    switch (normalized) {
+        case "markdownv2":
+            return "MarkdownV2";
+        case "markdown":
+            return "Markdown";
+        case "html":
+            return "HTML";
+        case "none":
+            return "None";
+        default:
+            logger.warn(`[Formatting] Invalid TELEGRAM_PARSE_MODE="${raw}", falling back to MarkdownV2`);
+            return "MarkdownV2";
+    }
+}
+export function getParseMode() {
+    return normalizeParseMode(config.telegram.parseMode);
+}
+export function sendMessageOptions() {
+    const mode = getParseMode();
+    if (mode === "None") {
+        return {};
+    }
+    return { parse_mode: mode };
+}
+function escapeHtml(text) {
+    return text
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+function escapeMarkdownV2Text(text) {
+    let result = text.replaceAll("\\", "\\\\");
+    const specialChars = [
+        "_",
+        "*",
+        "[",
+        "]",
+        "(",
+        ")",
+        "~",
+        "`",
+        ">",
+        "#",
+        "+",
+        "-",
+        "=",
+        "|",
+        "{",
+        "}",
+        ".",
+        "!",
+    ];
+    for (const char of specialChars) {
+        result = result.split(char).join(`\\${char}`);
+    }
+    return result;
+}
+function escapeMarkdownText(text) {
+    let result = text.replaceAll("\\", "\\\\");
+    const specialChars = ["_", "*", "`", "[", "]"];
+    for (const char of specialChars) {
+        result = result.split(char).join(`\\${char}`);
+    }
+    return result;
+}
+function escapeMarkdownV2Code(text) {
+    return text.replaceAll("\\", "\\\\").replaceAll("`", "\\`");
+}
+function escapeMarkdownCode(text) {
+    return text.replaceAll("\\", "\\\\").replaceAll("`", "\\`");
+}
+export function escapeText(text) {
+    const mode = getParseMode();
+    switch (mode) {
+        case "MarkdownV2":
+            return escapeMarkdownV2Text(text);
+        case "Markdown":
+            return escapeMarkdownText(text);
+        case "HTML":
+            return escapeHtml(text);
+        case "None":
+            return text;
+        default:
+            return text;
+    }
+}
+export function formatBold(text) {
+    const mode = getParseMode();
+    switch (mode) {
+        case "MarkdownV2":
+            return `*${escapeMarkdownV2Text(text)}*`;
+        case "Markdown":
+            return `*${escapeMarkdownText(text)}*`;
+        case "HTML":
+            return `<b>${escapeHtml(text)}</b>`;
+        case "None":
+            return text;
+        default:
+            return text;
+    }
+}
+export function formatItalic(text) {
+    const mode = getParseMode();
+    switch (mode) {
+        case "MarkdownV2":
+            return `_${escapeMarkdownV2Text(text)}_`;
+        case "Markdown":
+            return `_${escapeMarkdownText(text)}_`;
+        case "HTML":
+            return `<i>${escapeHtml(text)}</i>`;
+        case "None":
+            return text;
+        default:
+            return text;
+    }
+}
+export function formatCode(text) {
+    const mode = getParseMode();
+    switch (mode) {
+        case "MarkdownV2":
+            return `\`${escapeMarkdownV2Code(text)}\``;
+        case "Markdown":
+            return `\`${escapeMarkdownCode(text)}\``;
+        case "HTML":
+            return `<code>${escapeHtml(text)}</code>`;
+        case "None":
+            return text;
+        default:
+            return text;
+    }
+}
+export function formatCodeBlock(text) {
+    const mode = getParseMode();
+    switch (mode) {
+        case "MarkdownV2":
+            return `\`\`\`\n${text}\n\`\`\``;
+        case "Markdown":
+            return `\`\`\`\n${text}\n\`\`\``;
+        case "HTML":
+            return `<pre><code>${escapeHtml(text)}</code></pre>`;
+        case "None":
+            return text;
+        default:
+            return text;
+    }
+}
+function formatInlineMarkdownLike(text) {
+    const mode = getParseMode();
+    if (mode === "None") {
+        return text;
+    }
+    const boldRe = /\*\*([^*]+)\*\*/g;
+    const codeRe = /`([^`]+)`/g;
+    let i = 0;
+    let out = "";
+    while (i < text.length) {
+        const boldMatch = boldRe.exec(text);
+        const codeMatch = codeRe.exec(text);
+        const nextBoldStart = boldMatch ? boldMatch.index : Number.POSITIVE_INFINITY;
+        const nextCodeStart = codeMatch ? codeMatch.index : Number.POSITIVE_INFINITY;
+        const nextStart = Math.min(nextBoldStart, nextCodeStart);
+        if (nextStart === Number.POSITIVE_INFINITY) {
+            out += escapeText(text.slice(i));
+            break;
+        }
+        if (nextStart > i) {
+            out += escapeText(text.slice(i, nextStart));
+            i = nextStart;
+        }
+        if (nextStart === nextCodeStart && codeMatch) {
+            out += formatCode(codeMatch[1]);
+            i = codeMatch.index + codeMatch[0].length;
+            boldRe.lastIndex = i;
+            codeRe.lastIndex = i;
+            continue;
+        }
+        if (nextStart === nextBoldStart && boldMatch) {
+            out += formatBold(boldMatch[1]);
+            i = boldMatch.index + boldMatch[0].length;
+            boldRe.lastIndex = i;
+            codeRe.lastIndex = i;
+            continue;
+        }
+    }
+    return out;
+}
+/**
+ * Converts common Markdown (LLM/GitHub-like) into Telegram-compatible formatting.
+ * This is not a full Markdown parser; it focuses on a safe subset:
+ * - Headings (#, ##, ...) -> bold line
+ * - **bold** -> bold
+ * - `code` -> inline code
+ * - ```code blocks``` -> code block
+ */
+export function formatMarkdownLike(text) {
+    const mode = getParseMode();
+    if (mode === "None") {
+        return text;
+    }
+    const fenceRe = /```[^\n]*\n([\s\S]*?)```/g;
+    let lastIndex = 0;
+    let out = "";
+    let match;
+    while ((match = fenceRe.exec(text)) !== null) {
+        const before = text.slice(lastIndex, match.index);
+        out += formatMarkdownLikePlain(before);
+        const code = match[1] ?? "";
+        out += formatCodeBlock(code.replace(/\n$/, ""));
+        lastIndex = match.index + match[0].length;
+    }
+    out += formatMarkdownLikePlain(text.slice(lastIndex));
+    return out;
+}
+function formatMarkdownLikePlain(text) {
+    const lines = text.split("\n");
+    const outLines = [];
+    for (const line of lines) {
+        const headingMatch = /^(#{1,6})\s+(.*)$/.exec(line);
+        if (headingMatch) {
+            const title = headingMatch[2]?.trim() ?? "";
+            outLines.push(title ? formatBold(title) : "");
+            continue;
+        }
+        outLines.push(formatInlineMarkdownLike(line));
+    }
+    return outLines.join("\n");
+}

package/dist/utils/logger.js

@@ -0,0 +1,59 @@
+import { config } from "../config.js";
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+function normalizeLogLevel(value) {
+    if (value in LOG_LEVELS) {
+        return value;
+    }
+    return "info";
+}
+function formatPrefix(level) {
+    return `[${new Date().toISOString()}] [${level.toUpperCase()}]`;
+}
+function formatArg(arg) {
+    if (arg instanceof Error) {
+        return arg.stack ?? `${arg.name}: ${arg.message}`;
+    }
+    return arg;
+}
+function withPrefix(level, args) {
+    const formattedArgs = args.map((arg) => formatArg(arg));
+    const prefix = formatPrefix(level);
+    if (formattedArgs.length === 0) {
+        return [prefix];
+    }
+    if (typeof formattedArgs[0] === "string") {
+        return [`${prefix} ${formattedArgs[0]}`, ...formattedArgs.slice(1)];
+    }
+    return [prefix, ...formattedArgs];
+}
+function shouldLog(level) {
+    const configLevel = normalizeLogLevel(config.server.logLevel);
+    return LOG_LEVELS[level] >= LOG_LEVELS[configLevel];
+}
+export const logger = {
+    debug: (...args) => {
+        if (shouldLog("debug")) {
+            console.log(...withPrefix("debug", args));
+        }
+    },
+    info: (...args) => {
+        if (shouldLog("info")) {
+            console.log(...withPrefix("info", args));
+        }
+    },
+    warn: (...args) => {
+        if (shouldLog("warn")) {
+            console.warn(...withPrefix("warn", args));
+        }
+    },
+    error: (...args) => {
+        if (shouldLog("error")) {
+            console.error(...withPrefix("error", args));
+        }
+    },
+};

package/dist/utils/safe-background-task.js

@@ -0,0 +1,33 @@
+import { logger } from "./logger.js";
+function runHookSafely(taskName, hookName, hook, value) {
+    if (!hook) {
+        return;
+    }
+    try {
+        void Promise.resolve(hook(value)).catch((hookError) => {
+            logger.error(`[safeBackgroundTask] ${taskName}: ${hookName} failed:`, hookError);
+        });
+    }
+    catch (hookError) {
+        logger.error(`[safeBackgroundTask] ${taskName}: ${hookName} failed:`, hookError);
+    }
+}
+export function safeBackgroundTask({ taskName, task, onSuccess, onError, }) {
+    const handleError = (error) => {
+        logger.error(`[safeBackgroundTask] ${taskName} failed:`, error);
+        runHookSafely(taskName, "onError", onError, error);
+    };
+    try {
+        const taskPromise = task();
+        void taskPromise
+            .then((result) => {
+            runHookSafely(taskName, "onSuccess", onSuccess, result);
+        })
+            .catch((error) => {
+            handleError(error);
+        });
+    }
+    catch (error) {
+        handleError(error);
+    }
+}

package/dist/variant/manager.js

@@ -0,0 +1,103 @@
+/**
+ * Variant Manager - manages model variants (reasoning modes)
+ */
+import { opencodeClient } from "../opencode/client.js";
+import { getCurrentModel, setCurrentModel } from "../settings/manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Get available variants for a model from OpenCode API
+ * @param providerID Provider ID
+ * @param modelID Model ID
+ * @returns Array of available variants
+ */
+export async function getAvailableVariants(providerID, modelID) {
+    try {
+        const { data, error } = await opencodeClient.config.providers();
+        if (error || !data) {
+            logger.warn("[VariantManager] Failed to fetch providers:", error);
+            return [{ id: "default" }];
+        }
+        const provider = data.providers.find((p) => p.id === providerID);
+        if (!provider) {
+            logger.warn(`[VariantManager] Provider ${providerID} not found`);
+            return [{ id: "default" }];
+        }
+        const model = provider.models[modelID];
+        if (!model) {
+            logger.warn(`[VariantManager] Model ${modelID} not found in provider ${providerID}`);
+            return [{ id: "default" }];
+        }
+        // Start with default variant (always present)
+        const variants = [{ id: "default" }];
+        if (model.variants) {
+            // Add other variants from API (excluding default if it's already there)
+            const apiVariants = Object.entries(model.variants)
+                .filter(([id]) => id !== "default")
+                .map(([id, info]) => ({
+                id,
+                disabled: info.disabled,
+            }));
+            variants.push(...apiVariants);
+            logger.debug(`[VariantManager] Found ${variants.length} variants for ${providerID}/${modelID} (including default)`);
+        }
+        else {
+            logger.debug(`[VariantManager] No variants found for ${providerID}/${modelID}, using default only`);
+        }
+        return variants;
+    }
+    catch (err) {
+        logger.error("[VariantManager] Error fetching variants:", err);
+        return [{ id: "default" }];
+    }
+}
+/**
+ * Get current variant from settings
+ * @returns Current variant ID (defaults to "default")
+ */
+export function getCurrentVariant() {
+    const currentModel = getCurrentModel();
+    return currentModel?.variant || "default";
+}
+/**
+ * Set current variant in settings
+ * @param variantId Variant ID to set
+ */
+export function setCurrentVariant(variantId) {
+    const currentModel = getCurrentModel();
+    if (!currentModel) {
+        logger.warn("[VariantManager] Cannot set variant: no current model");
+        return;
+    }
+    currentModel.variant = variantId;
+    setCurrentModel(currentModel);
+    logger.info(`[VariantManager] Variant set to: ${variantId}`);
+}
+/**
+ * Format variant for button display
+ * @param variantId Variant ID (e.g., "default", "low", "high")
+ * @returns Formatted string "💭 Default", "💭 Low", etc.
+ */
+export function formatVariantForButton(variantId) {
+    const capitalized = variantId.charAt(0).toUpperCase() + variantId.slice(1);
+    return `💭 ${capitalized}`;
+}
+/**
+ * Format variant for display in messages
+ * @param variantId Variant ID
+ * @returns Formatted string with capitalized first letter
+ */
+export function formatVariantForDisplay(variantId) {
+    return variantId.charAt(0).toUpperCase() + variantId.slice(1);
+}
+/**
+ * Validate if a model supports a specific variant
+ * @param providerID Provider ID
+ * @param modelID Model ID
+ * @param variantId Variant ID to validate
+ * @returns true if variant is supported, false otherwise
+ */
+export async function validateVariantForModel(providerID, modelID, variantId) {
+    const variants = await getAvailableVariants(providerID, modelID);
+    const found = variants.find((v) => v.id === variantId && !v.disabled);
+    return found !== undefined;
+}

package/dist/variant/types.js

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

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@grinev/opencode-telegram-bot",
+  "version": "0.1.0-rc.1",
+  "description": "",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "opencode-telegram": "dist/cli.js"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    ".env.example"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "npm run build && npm start",
+    "list-providers": "tsx scripts/list-providers.ts",
+    "lint": "eslint src --ext .ts --max-warnings=0",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/grinev/my-telegram-opencode-bot.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/grinev/my-telegram-opencode-bot/issues"
+  },
+  "homepage": "https://github.com/grinev/my-telegram-opencode-bot#readme",
+  "dependencies": {
+    "@grammyjs/menu": "^1.3.1",
+    "@opencode-ai/sdk": "^1.1.21",
+    "dotenv": "^17.2.3",
+    "grammy": "^1.39.2",
+    "pino": "^10.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.8",
+    "@typescript-eslint/eslint-plugin": "^8.53.0",
+    "@typescript-eslint/parser": "^8.53.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "eslint": "^8.57.1",
+    "eslint-config-prettier": "^10.1.8",
+    "pino-pretty": "^13.1.3",
+    "prettier": "^3.8.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  }
+}