@emqo/claudebridge 0.3.0 → 0.4.0

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/adapters/discord.d.ts

@@ -9,10 +9,13 @@ export declare class DiscordAdapter implements Adapter {
     private locale;
     private client;
     private reminderTimer?;
+    private autoTimer?;
+    private autoRunning;
     constructor(engine: AgentEngine, store: Store, config: DiscordConfig, locale?: string);
     private setup;
     private handlePrompt;
     start(): Promise<void>;
     stop(): void;
     private checkReminders;
+    private processAutoTasks;
 }

package/dist/adapters/discord.js

@@ -12,6 +12,8 @@ export class DiscordAdapter {
     locale;
     client;
     reminderTimer;
+    autoTimer;
+    autoRunning = false;
     constructor(engine, store, config, locale = "en") {
         this.engine = engine;
         this.store = store;
@@ -164,10 +166,13 @@ export class DiscordAdapter {
         await this.client.login(this.config.token);
         console.log(`[discord] logged in as ${this.client.user?.tag}`);
         this.reminderTimer = setInterval(() => this.checkReminders(), 30000);
+        this.autoTimer = setInterval(() => this.processAutoTasks(), 60000);
     }
     stop() {
         if (this.reminderTimer)
             clearInterval(this.reminderTimer);
+        if (this.autoTimer)
+            clearInterval(this.autoTimer);
         this.client.destroy();
     }
     async checkReminders() {
@@ -184,4 +189,42 @@ export class DiscordAdapter {
             console.error("[discord] reminder error:", e);
         }
     }
+    async processAutoTasks() {
+        if (this.autoRunning)
+            return;
+        const task = this.store.getNextAutoTask("discord");
+        if (!task)
+            return;
+        this.autoRunning = true;
+        this.store.markTaskRunning(task.id);
+        try {
+            const ch = await this.client.channels.fetch(task.chat_id);
+            if (!ch?.isTextBased() || !("send" in ch))
+                throw new Error("channel not found");
+            const channel = ch;
+            await channel.send(t(this.locale, "auto_starting", { id: task.id, desc: task.description }));
+            console.log(`[discord] auto-task #${task.id} for ${task.user_id}`);
+            const res = await this.engine.runStream(task.user_id, task.description, "discord", task.chat_id);
+            this.store.markTaskResult(task.id, "done");
+            const maxLen = this.config.chunk_size || 1900;
+            const chunks = chunkText(res.text || "(no output)", maxLen);
+            await channel.send(t(this.locale, "auto_done", { id: task.id, cost: (res.cost || 0).toFixed(4) }));
+            for (const c of chunks)
+                await channel.send(c);
+        }
+        catch (err) {
+            this.store.markTaskResult(task.id, "failed");
+            console.error(`[discord] auto-task #${task.id} failed:`, err);
+            try {
+                const ch = await this.client.channels.fetch(task.chat_id);
+                if (ch?.isTextBased() && "send" in ch) {
+                    await ch.send(t(this.locale, "auto_failed", { id: task.id, err: err.message || "unknown" }));
+                }
+            }
+            catch { }
+        }
+        finally {
+            this.autoRunning = false;
+        }
+    }
 }

package/dist/adapters/telegram.js

@@ -364,7 +364,7 @@ export class TelegramAdapter {
     async processAutoTasks() {
         if (this.autoRunning)
             return;
-        const task = this.store.getNextAutoTask();
+        const task = this.store.getNextAutoTask("telegram");
         if (!task)
             return;
         this.autoRunning = true;

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/core/store.d.ts

@@ -46,7 +46,7 @@ export declare class Store {
         description: string;
     }[];
     markReminderSent(taskId: number): void;
-    getNextAutoTask(): {
+    getNextAutoTask(platform?: string): {
         id: number;
         user_id: string;
         platform: string;

package/dist/core/store.js

@@ -135,7 +135,10 @@ export class Store {
     markReminderSent(taskId) {
         this.db.prepare("UPDATE tasks SET reminder_sent = 1 WHERE id = ?").run(taskId);
     }
-    getNextAutoTask() {
+    getNextAutoTask(platform) {
+        if (platform) {
+            return this.db.prepare("SELECT id, user_id, platform, chat_id, description FROM tasks WHERE status = 'auto' AND platform = ? ORDER BY created_at ASC LIMIT 1").get(platform) ?? null;
+        }
         return this.db.prepare("SELECT id, user_id, platform, chat_id, description FROM tasks WHERE status = 'auto' ORDER BY created_at ASC LIMIT 1").get() ?? null;
     }
     markTaskRunning(taskId) {

package/dist/skills/bridge.js

@@ -40,6 +40,25 @@ 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. "运行测试验证所有修改，提交代码，生成优化报告"`,
+            ``,
+            `### 跨任务记忆传递`,
+            `- 每个 auto-task 完成关键分析后，用 memory add 保存结论`,
+            `- 下一个 auto-task 会自动加载记忆，可以读取前序任务的成果`,
+            `- 示例：分析完成后调用 \`${ctl} memory add ${ctx.userId} "模块A优化点：1.重构API 2.添加缓存 3.修复N+1查询"\``,
+            `- 最后一个 auto-task 完成后，清理临时工作记忆（可选）`,
+            `- 重要：描述中包含"先用 memory list 查看前序任务的分析结果"可确保链式上下文不断`,
         ].join("\n");
     }
     return [
@@ -76,5 +95,24 @@ 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"`,
+        ``,
+        `### Cross-Task Memory Bridging`,
+        `- After completing key analysis in an auto-task, save conclusions via memory add`,
+        `- The next auto-task automatically loads memories, accessing prior task findings`,
+        `- Example: after analysis, call \`${ctl} memory add ${ctx.userId} "Module A needs: 1.refactor API 2.add cache 3.fix N+1 queries"\``,
+        `- Optionally clean up temporary work memories after the final auto-task`,
+        `- Tip: include "first run memory list to review prior task findings" in descriptions to ensure chain continuity`,
     ].join("\n");
 }

package/package.json

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