opencode-claw 0.2.1 → 0.2.2

package/dist/channels/router.js

@@ -105,6 +105,12 @@ async function handleCommand(cmd, msg, deps, activeStreams) {
         }
     }
 }
+/** Turn raw MCP tool names like `websearch_web_search_exa` into `Web Search Exa`. */
+function humanizeToolName(raw) {
+    if (raw.includes(" "))
+        return raw;
+    return raw.replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
 async function routeMessage(msg, deps, activeStreams, pendingQuestions) {
     const adapter = deps.adapters.get(msg.channel);
     if (!adapter) {
@@ -175,7 +181,7 @@ async function routeMessage(msg, deps, activeStreams, pendingQuestions) {
     const progress = progressEnabled
         ? {
             onToolRunning: (_tool, title) => adapter.send(msg.peerId, {
-                text: `🔧 ${title}...`,
+                text: `🔧 ${humanizeToolName(title)}...`,
                 replyToId: msg.replyToId,
             }),
             onHeartbeat: async () => {

package/dist/channels/slack.js

@@ -1,5 +1,6 @@
 import { App } from "@slack/bolt";
 import { createReconnector } from "../utils/reconnect.js";
+import { splitMessage } from "./split-message.js";
 export function createSlackAdapter(config, logger) {
     const app = new App({
         token: config.botToken,
@@ -74,11 +75,14 @@ export function createSlackAdapter(config, logger) {
             logger.info("slack: app stopped");
         },
         async send(peerId, message) {
-            await app.client.chat.postMessage({
-                channel: peerId,
-                text: message.text,
-                thread_ts: message.threadId,
-            });
+            const chunks = splitMessage(message.text, 40000);
+            for (const chunk of chunks) {
+                await app.client.chat.postMessage({
+                    channel: peerId,
+                    text: chunk,
+                    thread_ts: message.threadId,
+                });
+            }
         },
         async sendTyping(_peerId) {
             // Slack has no general bot typing indicator API

package/dist/channels/split-message.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Split a message into chunks that fit within the given max length.
+ * Prefers splitting at double newlines (paragraphs), then single newlines,
+ * then spaces, and finally hard-cuts as a last resort.
+ */
+export declare function splitMessage(text: string, maxLength: number): string[];

package/dist/channels/split-message.js

@@ -0,0 +1,45 @@
+/**
+ * Split a message into chunks that fit within the given max length.
+ * Prefers splitting at double newlines (paragraphs), then single newlines,
+ * then spaces, and finally hard-cuts as a last resort.
+ */
+export function splitMessage(text, maxLength) {
+    if (text.length <= maxLength)
+        return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        if (remaining.length <= maxLength) {
+            chunks.push(remaining);
+            break;
+        }
+        const slice = remaining.slice(0, maxLength);
+        let splitAt = -1;
+        // Try splitting at last double newline (paragraph boundary)
+        const doubleNewline = slice.lastIndexOf("\n\n");
+        if (doubleNewline > maxLength * 0.3) {
+            splitAt = doubleNewline;
+        }
+        // Try splitting at last single newline
+        if (splitAt === -1) {
+            const singleNewline = slice.lastIndexOf("\n");
+            if (singleNewline > maxLength * 0.3) {
+                splitAt = singleNewline;
+            }
+        }
+        // Try splitting at last space
+        if (splitAt === -1) {
+            const space = slice.lastIndexOf(" ");
+            if (space > maxLength * 0.3) {
+                splitAt = space;
+            }
+        }
+        // Hard cut as last resort
+        if (splitAt === -1) {
+            splitAt = maxLength;
+        }
+        chunks.push(remaining.slice(0, splitAt));
+        remaining = remaining.slice(splitAt).replace(/^[\s]+/, "");
+    }
+    return chunks;
+}

package/dist/channels/telegram.js

@@ -1,5 +1,6 @@
 import { Bot } from "grammy";
 import { createReconnector } from "../utils/reconnect.js";
+import { splitMessage } from "./split-message.js";
 export function createTelegramAdapter(config, logger) {
     const bot = new Bot(config.botToken);
     let state = "disconnected";
@@ -68,9 +69,14 @@ export function createTelegramAdapter(config, logger) {
             logger.info("telegram: bot stopped");
         },
         async send(peerId, message) {
-            await bot.api.sendMessage(Number(peerId), message.text, {
-                reply_parameters: message.replyToId ? { message_id: Number(message.replyToId) } : undefined,
-            });
+            const chunks = splitMessage(message.text, 4096);
+            for (const chunk of chunks) {
+                await bot.api.sendMessage(Number(peerId), chunk, {
+                    reply_parameters: message.replyToId
+                        ? { message_id: Number(message.replyToId) }
+                        : undefined,
+                });
+            }
         },
         async sendTyping(peerId) {
             await bot.api.sendChatAction(Number(peerId), "typing");

package/dist/channels/whatsapp.js

@@ -1,4 +1,5 @@
 import { DisconnectReason, makeWASocket, useMultiFileAuthState, } from "@whiskeysockets/baileys";
+import { splitMessage } from "./split-message.js";
 export function createWhatsAppAdapter(config, logger) {
     let state = "disconnected";
     let handler;
@@ -127,7 +128,10 @@ export function createWhatsAppAdapter(config, logger) {
             if (!sock)
                 throw new Error("WhatsApp socket not connected");
             const jid = `${peerId}@s.whatsapp.net`;
-            await sock.sendMessage(jid, { text: message.text });
+            const chunks = splitMessage(message.text, 65536);
+            for (const chunk of chunks) {
+                await sock.sendMessage(jid, { text: chunk });
+            }
         },
         async sendTyping(peerId) {
             if (!sock)

package/dist/memory/plugin.js

@@ -53,10 +53,11 @@ function createMemoryPlugin(backend) {
                 limit: 5,
                 minRelevance: 0.05,
             });
-            if (memories.length === 0)
-                return;
-            const block = memories.map((m) => `- [${m.category}] ${m.content}`).join("\n");
-            output.system.push(`\n\n## Relevant Context from Memory\n${block}`);
+            if (memories.length > 0) {
+                const block = memories.map((m) => `- [${m.category}] ${m.content}`).join("\n");
+                output.system.push(`\n\n## Relevant Context from Memory\n${block}`);
+            }
+            output.system.push(`\n\n## Memory Instructions\nYou have access to persistent long-term memory across sessions via two tools:\n- **memory_search**: Look up stored facts about projects, workflows, and past experiences.\n- **memory_store**: Save important information so it persists across sessions.\n\n**When to search memory:**\n- At the start of any task involving a project — search for its location, build commands, test steps, and relationships to other projects.\n- When you are unsure about a project's structure or conventions.\n\n**When to store memory (do this proactively):**\n- Project facts: absolute path on disk, repo URL, language/stack, key entry points.\n- Dev workflows: how to build, run, lint, and format the project.\n- Test procedures: how to run tests locally, what test framework is used, any setup required.\n- Dependencies and relationships: which projects depend on each other, shared libraries, APIs consumed.\n- Architecture decisions: patterns used, notable design choices, known pitfalls.\n- Use category \`project\` for project-specific facts, \`knowledge\` for workflows and procedures, \`experience\` for lessons learned.\n\nStore facts at the granularity of one clear, self-contained statement per call.`);
         },
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-claw",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Wrap OpenCode with persistent memory, messaging channels, and cron jobs",
   "license": "MIT",
   "type": "module",