@emqo/claudebridge 0.3.0 → 0.3.1

package/dist/adapters/base.d.ts

@@ -8,5 +8,5 @@ export interface Adapter {
     start(): Promise<void>;
     stop(): void;
 }
-/** Split long text into chunks respecting newlines */
+/** Split long text into chunks respecting newlines, with code-block-aware balancing */
 export declare function chunkText(text: string, maxLen: number): string[];

package/dist/adapters/base.js

@@ -1,7 +1,8 @@
-/** Split long text into chunks respecting newlines */
+/** Split long text into chunks respecting newlines, with code-block-aware balancing */
 export function chunkText(text, maxLen) {
     if (text.length <= maxLen)
         return [text];
+    // Phase 1: split by newlines (existing logic)
     const chunks = [];
     let remaining = text;
     while (remaining.length > 0) {
@@ -15,5 +16,35 @@ export function chunkText(text, maxLen) {
         chunks.push(remaining.slice(0, cut));
         remaining = remaining.slice(cut).replace(/^\n/, "");
     }
+    // Phase 2: balance code fences across chunks
+    // Ensures each chunk is self-contained valid MarkdownV2
+    let inCode = false;
+    let lang = "";
+    for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        const startsInCode = inCode;
+        // Scan fences in original chunk to determine end state and track language
+        const fenceRegex = /```(\w*)/g;
+        let toggleState = startsInCode;
+        let m;
+        while ((m = fenceRegex.exec(chunk)) !== null) {
+            // Opening fence (not in code) → track language
+            if (!toggleState && m[1]) {
+                lang = m[1];
+            }
+            toggleState = !toggleState;
+        }
+        inCode = toggleState;
+        // Apply fixes: reopen/close code blocks as needed
+        let fixed = chunk;
+        if (startsInCode) {
+            fixed = "```" + lang + "\n" + fixed;
+        }
+        if (inCode) {
+            fixed = fixed + "\n```";
+            // inCode stays true — next chunk's content is still logically inside code
+        }
+        chunks[i] = fixed;
+    }
     return chunks;
 }

package/dist/core/markdown.d.ts

@@ -2,6 +2,7 @@
 export declare function escapeMarkdownV2(text: string): string;
 /**
  * Convert standard markdown to Telegram MarkdownV2.
- * Handles code blocks (preserve as-is), inline code, bold, italic, links.
+ * Uses iterative scanning for code blocks instead of regex split,
+ * properly handling unclosed blocks and multiple consecutive blocks.
  */
 export declare function toTelegramMarkdown(text: string): string;

package/dist/core/markdown.js

@@ -3,49 +3,84 @@ export function escapeMarkdownV2(text) {
     // Characters that must be escaped outside code blocks
     return text.replace(/([_*\[\]()~`>#+\-=|{}.!\\])/g, "\\$1");
 }
+/**
+ * Process inline markdown: inline code, links, bold, italic, strikethrough.
+ * Order: extract protected elements → escape → restore formatted elements → restore placeholders.
+ */
+function processInline(text) {
+    let s = text;
+    // 1. Extract inline code → placeholders (before escaping)
+    const inlineCodes = [];
+    s = s.replace(/`([^`]+)`/g, (_, code) => {
+        const escaped = code.replace(/([\\`])/g, "\\$1");
+        inlineCodes.push(`\`${escaped}\``);
+        return `\x00IC${inlineCodes.length - 1}\x00`;
+    });
+    // 2. Extract markdown links [text](url) → placeholders (before escaping)
+    //    Handles one level of nested parens in URLs, e.g. wiki/Rust_(programming_language)
+    const links = [];
+    s = s.replace(/\[([^\]]+)\]\(([^()]*(?:\([^()]*\))*[^()]*)\)/g, (_, linkText, url) => {
+        const escapedText = escapeMarkdownV2(linkText);
+        // Inside MarkdownV2 link URL, only \ and ) need escaping
+        const escapedUrl = url.replace(/\\/g, "\\\\").replace(/\)/g, "\\)");
+        links.push(`[${escapedText}](${escapedUrl})`);
+        return `\x00LK${links.length - 1}\x00`;
+    });
+    // 3. Escape all remaining special chars
+    s = escapeMarkdownV2(s);
+    // 4. Restore bold **text** → *text* (MarkdownV2 single asterisk)
+    s = s.replace(/\\\*\\\*([\s\S]+?)\\\*\\\*/g, "*$1*");
+    // 5. Restore italic _text_ → _text_
+    s = s.replace(/\\_(.+?)\\_/g, "_$1_");
+    // 6. Restore strikethrough ~~text~~ → ~text~
+    s = s.replace(/\\~\\~(.+?)\\~\\~/g, "~$1~");
+    // 7. Restore link placeholders
+    s = s.replace(/\x00LK(\d+)\x00/g, (_, i) => links[Number(i)]);
+    // 8. Restore inline code placeholders
+    s = s.replace(/\x00IC(\d+)\x00/g, (_, i) => inlineCodes[Number(i)]);
+    return s;
+}
 /**
  * Convert standard markdown to Telegram MarkdownV2.
- * Handles code blocks (preserve as-is), inline code, bold, italic, links.
+ * Uses iterative scanning for code blocks instead of regex split,
+ * properly handling unclosed blocks and multiple consecutive blocks.
  */
 export function toTelegramMarkdown(text) {
-    const parts = [];
-    // Split by code blocks first (``` ... ```)
-    const segments = text.split(/(```[\s\S]*?```)/g);
-    for (const seg of segments) {
-        if (seg.startsWith("```")) {
-            // Code block: extract lang and content, only escape backslash and backtick inside
-            const match = seg.match(/^```(\w*)\n?([\s\S]*?)```$/);
-            if (match) {
-                const lang = match[1];
-                const code = match[2].replace(/([\\`])/g, "\\$1");
-                parts.push(`\`\`\`${lang}\n${code}\`\`\``);
-            }
-            else {
-                parts.push(seg);
-            }
+    const result = [];
+    let pos = 0;
+    while (pos < text.length) {
+        // Find next code fence ```
+        const fenceStart = text.indexOf("```", pos);
+        if (fenceStart === -1) {
+            // No more code blocks — process rest as inline
+            result.push(processInline(text.slice(pos)));
+            break;
+        }
+        // Process text before code block as inline
+        if (fenceStart > pos) {
+            result.push(processInline(text.slice(pos, fenceStart)));
         }
-        else {
-            // Process inline elements
-            let s = seg;
-            // Protect inline code first
-            const inlineCodes = [];
-            s = s.replace(/`([^`]+)`/g, (_, code) => {
-                const escaped = code.replace(/([\\`])/g, "\\$1");
-                inlineCodes.push(`\`${escaped}\``);
-                return `\x00IC${inlineCodes.length - 1}\x00`;
-            });
-            // Escape special chars in normal text
-            s = escapeMarkdownV2(s);
-            // Restore bold **text** → *text*
-            s = s.replace(/\\\*\\\*(.+?)\\\*\\\*/g, "*$1*");
-            // Restore italic _text_ (single underscore)
-            s = s.replace(/\\_(.+?)\\_/g, "_$1_");
-            // Restore links [text](url)
-            s = s.replace(/\\\[(.+?)\\\]\\\((.+?)\\\)/g, "[$1]($2)");
-            // Restore inline codes
-            s = s.replace(/\x00IC(\d+)\x00/g, (_, i) => inlineCodes[Number(i)]);
-            parts.push(s);
+        // Find closing ```
+        const afterOpen = fenceStart + 3;
+        const fenceEnd = text.indexOf("```", afterOpen);
+        if (fenceEnd === -1) {
+            // Unclosed code block — auto-close it
+            const raw = text.slice(afterOpen);
+            const langMatch = raw.match(/^(\w*)\n?/);
+            const lang = langMatch ? langMatch[1] : "";
+            const contentStart = langMatch ? langMatch[0].length : 0;
+            const code = raw.slice(contentStart).replace(/([\\`])/g, "\\$1");
+            result.push(`\`\`\`${lang}\n${code}\n\`\`\``);
+            break;
         }
+        // Complete code block — extract lang and content, escape only \ and `
+        const raw = text.slice(afterOpen, fenceEnd);
+        const langMatch = raw.match(/^(\w*)\n?/);
+        const lang = langMatch ? langMatch[1] : "";
+        const contentStart = langMatch ? langMatch[0].length : 0;
+        const code = raw.slice(contentStart).replace(/([\\`])/g, "\\$1");
+        result.push(`\`\`\`${lang}\n${code}\`\`\``);
+        pos = fenceEnd + 3;
     }
-    return parts.join("");
+    return result.join("");
 }

package/dist/skills/bridge.js

@@ -40,6 +40,18 @@ export function generateSkillDoc(ctx) {
             `- 用户要添加任务/待办 → 使用 task add`,
             `- 命令输出 JSON，请用自然语言向用户回复结果，不要直接展示 JSON`,
             `- 提醒会由 Bridge 定时器自动推送，你只需创建即可`,
+            ``,
+            `### 高级用法：任务自动分解`,
+            `- 遇到复杂/大型任务时，必须拆分为多个 auto-task 分步执行`,
+            `- 每个 auto-task 应该是独立可完成的小任务（预算内可完成）`,
+            `- auto-task 按创建顺序排队，每60秒执行一个`,
+            `- 在 auto-task 执行中可以创建新的 auto-task（链式执行）`,
+            `- 每个 auto-task 的描述要足够详细，因为它会在全新会话中执行`,
+            `- 示例：用户说"优化整个项目" → 创建多个 auto-task:`,
+            `  1. "分析项目结构，列出所有需要优化的模块和具体改进点"`,
+            `  2. "优化模块A：[具体描述，包含文件路径和修改内容]"`,
+            `  3. "优化模块B：[具体描述]"`,
+            `  4. "运行测试验证所有修改，提交代码，生成优化报告"`,
         ].join("\n");
     }
     return [
@@ -76,5 +88,17 @@ export function generateSkillDoc(ctx) {
         `- User wants to add a task/todo → use task add`,
         `- Commands output JSON. Respond to the user in natural language, do not dump raw JSON.`,
         `- Reminders are automatically pushed by Bridge timers — you only need to create them.`,
+        ``,
+        `### Advanced: Auto-Task Decomposition`,
+        `- For complex/large tasks, decompose into multiple auto-tasks`,
+        `- Each auto-task should be independently completable within budget`,
+        `- Auto-tasks execute in FIFO order, one every 60 seconds`,
+        `- An auto-task can create new auto-tasks (chaining)`,
+        `- Each description must be detailed enough for a fresh session`,
+        `- Example: user says "optimize the project" → create:`,
+        `  1. "Analyze project structure, list modules needing optimization"`,
+        `  2. "Optimize module A: [specific file paths and changes]"`,
+        `  3. "Optimize module B: [specific description]"`,
+        `  4. "Run tests, commit changes, generate optimization report"`,
     ].join("\n");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emqo/claudebridge",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Bridge Claude Code Agent SDK to chat platforms (Telegram, Discord, etc.)",
   "main": "dist/index.js",
   "bin": {