clawmatrix 0.4.2 → 0.5.0

package/src/index.ts

@@ -18,6 +18,9 @@ import { createClusterTerminalTool } from "./tools/cluster-terminal.ts";
 import { createClusterToolInvokeTool } from "./tools/cluster-tool.ts";
 import { createClusterTransferTool } from "./tools/cluster-transfer.ts";
 import { createClusterNotifyTool } from "./tools/cluster-notify.ts";
+import { createClusterKanbanTool } from "./tools/cluster-kanban.ts";
+import { createClusterQueryTool } from "./tools/cluster-query.ts";
+import { nanoid } from "nanoid";
 import { spawnProcess } from "./compat.ts";
 
 /**
@@ -80,6 +83,33 @@ function discoverModels(
   return result;
 }
 
+/**
+ * Auto-discover agents from OpenClaw's agents.list config.
+ * Only used when no agents are explicitly configured in ClawMatrix.
+ */
+function discoverAgents(
+  openclawConfig: OpenClawConfig,
+): ClawMatrixConfig["agents"] {
+  const cfg = openclawConfig as Record<string, unknown>;
+  const agentsConfig = cfg.agents as { list?: Array<{ id: string; name?: string }> } | undefined;
+  if (!agentsConfig?.list?.length) return [];
+
+  const result: ClawMatrixConfig["agents"] = [];
+  for (const a of agentsConfig.list) {
+    if (!a.id || typeof a.id !== "string") continue;
+    result.push({
+      id: a.id,
+      description: a.name ?? a.id,
+      tags: [],
+    });
+  }
+
+  if (result.length > 0) {
+    debug("agents", `Auto-discovered ${result.length} agent(s) from OpenClaw config: ${result.map((a) => a.id).join(", ")}`);
+  }
+  return result;
+}
+
 const plugin = {
   id: "clawmatrix",
   name: "ClawMatrix",
@@ -106,6 +136,14 @@ const plugin = {
       return;
     }
 
+    // Auto-discover agents from OpenClaw config when none explicitly configured
+    if (config.agents.length === 0) {
+      const discovered = discoverAgents(api.config);
+      if (discovered.length > 0) {
+        config = { ...config, agents: discovered };
+      }
+    }
+
     // Auto-discover models from OpenClaw providers and merge with explicit config
     {
       const discovered = discoverModels(api.config, config);
@@ -305,6 +343,8 @@ const plugin = {
     api.registerTool(createClusterToolInvokeTool(), { optional: true });
     api.registerTool(createClusterTransferTool(), { optional: true });
     api.registerTool(createClusterNotifyTool(), { optional: true });
+    api.registerTool(createClusterKanbanTool(), { optional: true });
+    api.registerTool(createClusterQueryTool(), { optional: true });
 
     // Wire up peer approval with OpenClaw channel API
     if (config.peerApproval.enabled) {
@@ -326,7 +366,7 @@ const plugin = {
               to: params.to,
               message: params.message,
               channel: params.channel,
-              idempotencyKey: crypto.randomUUID(),
+              idempotencyKey: nanoid(),
             };
             if (params.accountId) sendParams.accountId = params.accountId;
             if (params.threadId) sendParams.threadId = params.threadId;
@@ -687,14 +727,14 @@ const plugin = {
       ({ params, respond }: GatewayRequestHandlerOptions) => {
         try {
           const runtime = getClusterRuntime();
-          if (!runtime.webHandler) {
-            respond(false, { error: "Events not enabled (web.enabled = false)" });
+          if (!runtime.apiHandler) {
+            respond(false, { error: "Events not available (listen mode not enabled)" });
             return;
           }
           const { type, source, since, unconsumed, limit } = (params ?? {}) as {
             type?: string; source?: string; since?: number; unconsumed?: boolean; limit?: number;
           };
-          const events = runtime.webHandler.queryEvents({
+          const events = runtime.apiHandler.queryEvents({
             type,
             source,
             since,
@@ -713,8 +753,8 @@ const plugin = {
       ({ params, respond }: GatewayRequestHandlerOptions) => {
         try {
           const runtime = getClusterRuntime();
-          if (!runtime.webHandler) {
-            respond(false, { error: "Events not enabled (web.enabled = false)" });
+          if (!runtime.apiHandler) {
+            respond(false, { error: "Events not available (listen mode not enabled)" });
             return;
           }
           const { ids } = (params ?? {}) as { ids?: string[] };
@@ -722,7 +762,7 @@ const plugin = {
             respond(false, { error: "Missing required param: ids (array of event IDs)" });
             return;
           }
-          const consumed = runtime.webHandler.consumeEvents(ids);
+          const consumed = runtime.apiHandler.consumeEvents(ids);
           respond(true, { consumed, ids });
         } catch {
           respond(false, { error: "ClawMatrix service not running" });
@@ -1174,6 +1214,329 @@ const plugin = {
       },
     );
 
+    // ── Kanban board gateway methods ──────────────────────────────────
+
+    api.registerGatewayMethod(
+      "clawmatrix.board.summary",
+      ({ respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.kanbanManager) {
+            respond(false, { error: "Kanban not enabled" });
+            return;
+          }
+          respond(true, runtime.kanbanManager.getSummary());
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.board.list",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.kanbanManager) {
+            respond(false, { error: "Kanban not enabled" });
+            return;
+          }
+          const { stage, label, assignedNode, priority } = (params ?? {}) as {
+            stage?: string; label?: string; assignedNode?: string; priority?: string;
+          };
+          const cards = runtime.kanbanManager.listCards({
+            stage: stage as import("./types.ts").CardStage | undefined,
+            label,
+            assignedNode,
+            priority: priority as import("./types.ts").CardPriority | undefined,
+          });
+          respond(true, cards);
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.board.get",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.kanbanManager) {
+            respond(false, { error: "Kanban not enabled" });
+            return;
+          }
+          const { cardId } = (params ?? {}) as { cardId?: string };
+          if (!cardId) {
+            respond(false, { error: "Missing required param: cardId" });
+            return;
+          }
+          const card = runtime.kanbanManager.getCard(cardId);
+          if (!card) {
+            respond(false, { error: `Card not found: ${cardId}` });
+            return;
+          }
+          respond(true, card);
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.board.create",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.kanbanManager) {
+            respond(false, { error: "Kanban not enabled" });
+            return;
+          }
+          const { title, description, priority, targetNode, targetAgent, cwd, labels } = (params ?? {}) as {
+            title?: string; description?: string; priority?: string;
+            targetNode?: string; targetAgent?: string; cwd?: string; labels?: string[];
+          };
+          if (!title) {
+            respond(false, { error: "Missing required param: title" });
+            return;
+          }
+          const card = runtime.kanbanManager.createCard({
+            title,
+            description,
+            priority: priority as import("./types.ts").CardPriority | undefined,
+            targetNode,
+            targetAgent,
+            cwd,
+            labels,
+          });
+          respond(true, card);
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.board.claim",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.kanbanManager) {
+            respond(false, { error: "Kanban not enabled" });
+            return;
+          }
+          const { cardId, agent } = (params ?? {}) as { cardId?: string; agent?: string };
+          if (!cardId) {
+            respond(false, { error: "Missing required param: cardId" });
+            return;
+          }
+          const card = runtime.kanbanManager.claimCard(
+            cardId,
+            runtime.config.nodeId,
+            agent ?? runtime.config.agents[0]?.id ?? "unknown",
+          );
+          if (!card) {
+            respond(false, { error: `Cannot claim card ${cardId}` });
+            return;
+          }
+          respond(true, card);
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.board.move",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.kanbanManager) {
+            respond(false, { error: "Kanban not enabled" });
+            return;
+          }
+          const { cardId, stage } = (params ?? {}) as { cardId?: string; stage?: string };
+          if (!cardId || !stage) {
+            respond(false, { error: "Missing required params: cardId, stage" });
+            return;
+          }
+          const card = runtime.kanbanManager.moveCard(cardId, stage as import("./types.ts").CardStage);
+          if (!card) {
+            respond(false, { error: `Cannot move card ${cardId}` });
+            return;
+          }
+          respond(true, card);
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.board.annotate",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.kanbanManager) {
+            respond(false, { error: "Kanban not enabled" });
+            return;
+          }
+          const { cardId, content, annotationType, agent } = (params ?? {}) as {
+            cardId?: string; content?: string; annotationType?: string; agent?: string;
+          };
+          if (!cardId || !content) {
+            respond(false, { error: "Missing required params: cardId, content" });
+            return;
+          }
+          const card = runtime.kanbanManager.annotateCard(cardId, {
+            nodeId: runtime.config.nodeId,
+            agent: agent ?? runtime.config.agents[0]?.id ?? "unknown",
+            type: (annotationType ?? "note") as import("./types.ts").CardAnnotation["type"],
+            content,
+          });
+          if (!card) {
+            respond(false, { error: `Card not found: ${cardId}` });
+            return;
+          }
+          respond(true, card);
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.board.delete",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.kanbanManager) {
+            respond(false, { error: "Kanban not enabled" });
+            return;
+          }
+          const { cardId } = (params ?? {}) as { cardId?: string };
+          if (!cardId) {
+            respond(false, { error: "Missing required param: cardId" });
+            return;
+          }
+          const ok = runtime.kanbanManager.deleteCard(cardId);
+          respond(true, { deleted: ok, cardId });
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    // ── Knowledge sync gateway methods ──────────────────────────────
+
+    api.registerGatewayMethod(
+      "clawmatrix.kb.files",
+      ({ respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.knowledgeSync) {
+            respond(false, { error: "Knowledge sync not enabled" });
+            return;
+          }
+          respond(true, runtime.knowledgeSync.listSyncedFiles());
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.kb.history",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.knowledgeSync) {
+            respond(false, { error: "Knowledge sync not enabled" });
+            return;
+          }
+          const { path } = (params ?? {}) as { path?: string };
+          if (!path) {
+            respond(false, { error: "Missing required param: path" });
+            return;
+          }
+          const rawHistory = runtime.knowledgeSync.getFileHistory(path);
+          const history = rawHistory.map((entry) => {
+            let nodeId: string | undefined;
+            let agentId: string | undefined;
+            let agentType: string | undefined;
+            let sessionKey: string | undefined;
+            try {
+              const parsed = JSON.parse(entry.message);
+              nodeId = parsed.nodeId;
+              agentId = parsed.agentId;
+              agentType = parsed.agentType;
+              sessionKey = parsed.sessionKey;
+            } catch {
+              // message is not JSON
+            }
+            return {
+              timestamp: entry.timestamp,
+              actor: entry.actor,
+              ...(nodeId ? { nodeId } : {}),
+              ...(agentId ? { agentId } : {}),
+              ...(agentType ? { agentType } : {}),
+              ...(sessionKey ? { sessionKey } : {}),
+            };
+          });
+          respond(true, { path, history });
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.kb.blame",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.knowledgeSync) {
+            respond(false, { error: "Knowledge sync not enabled" });
+            return;
+          }
+          const { path } = (params ?? {}) as { path?: string };
+          if (!path) {
+            respond(false, { error: "Missing required param: path" });
+            return;
+          }
+          const blame = runtime.knowledgeSync.getFileBlame(path);
+          if (!blame) {
+            respond(false, { error: "File not found in sync" });
+            return;
+          }
+          // Parse JSON attribution from message field
+          const enriched = blame.map((entry) => {
+            let nodeId: string | undefined;
+            let agentId: string | undefined;
+            let agentType: string | undefined;
+            let sessionKey: string | undefined;
+            try {
+              const parsed = JSON.parse(entry.message);
+              nodeId = parsed.nodeId;
+              agentId = parsed.agentId;
+              agentType = parsed.agentType;
+              sessionKey = parsed.sessionKey;
+            } catch { /* not JSON */ }
+            return {
+              ...entry,
+              ...(nodeId ? { nodeId } : {}),
+              ...(agentId ? { agentId } : {}),
+              ...(agentType ? { agentType } : {}),
+              ...(sessionKey ? { sessionKey } : {}),
+            };
+          });
+          respond(true, { path, blame: enriched });
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
     // Log model selection on each LLM call (fire-and-forget)
     api.on("llm_input", (event) => {
       api.logger.debug(`[clawmatrix] llm_input: provider=${event.provider} model=${event.model}`);
@@ -1256,7 +1619,6 @@ const plugin = {
 
     let cachedPeerCount = -1;
     let cachedSystemContext = "";
-
     api.on("before_prompt_build", () => {
       try {
         const runtime = getClusterRuntime();
@@ -1274,21 +1636,47 @@ const plugin = {
         }
 
         // Per-turn: only push pending events (agent must react proactively)
-        const pendingEvents = runtime.webHandler?.getUnconsumedEvents(5) ?? [];
-        let prependContext: string | undefined;
+        const pendingEvents = runtime.apiHandler?.getUnconsumedEvents(5) ?? [];
+        const contextLines: string[] = [];
+
         if (pendingEvents.length > 0) {
-          const evtLines = ["Pending events (use cluster_events to query details or consume):"];
+          contextLines.push("Pending events (use cluster_events to query details or consume):");
           for (const evt of pendingEvents) {
             const age = Math.floor((Date.now() - evt.ts) / 1000);
             const dataStr = Object.entries(evt.data)
               .map(([k, v]) => `${k}:${typeof v === "string" ? v : JSON.stringify(v)}`)
               .join(",");
             const truncated = dataStr.length > 120 ? dataStr.slice(0, 120) + "…" : dataStr;
-            evtLines.push(`  [${evt.type}] ${evt.source} (${age}s,id:${evt.id}): ${truncated}`);
+            contextLines.push(`  [${evt.type}] ${evt.source} (${age}s,id:${evt.id}): ${truncated}`);
+          }
+        }
+
+        // Kanban board summary
+        if (runtime.kanbanManager) {
+          const claimable = runtime.kanbanManager.getClaimableCards(config.nodeId).length;
+          const inProgress = runtime.kanbanManager.listCards({ stage: "in_progress", assignedNode: config.nodeId }).length;
+          if (claimable > 0 || inProgress > 0) {
+            const parts: string[] = [];
+            if (claimable > 0) parts.push(`${claimable} claimable`);
+            if (inProgress > 0) parts.push(`${inProgress} in-progress`);
+            contextLines.push(`[Kanban] ${parts.join(", ")} card(s). Use cluster_kanban tool to interact.`);
           }
-          prependContext = evtLines.join("\n");
         }
 
+        // Knowledge base hint
+        if (runtime.knowledgeSync) {
+          const syncPaths = config.knowledge?.paths ?? [];
+          if (syncPaths.length > 0) {
+            contextLines.push(
+              `[Knowledge Base] Files in synced paths (${syncPaths.join(", ")}) are shared across all cluster nodes via CRDT.` +
+              ` When producing docs, analysis, or plans, save to a synced path so other nodes can access them.` +
+              ` For project-specific docs, write in the project directory and suggest the user sync to the knowledge base if useful.`,
+            );
+          }
+        }
+
+        const prependContext = contextLines.length > 0 ? contextLines.join("\n") : undefined;
+
         return {
           prependSystemContext: cachedSystemContext,
           ...(prependContext ? { prependContext } : {}),
@@ -1297,6 +1685,26 @@ const plugin = {
         return;
       }
     });
+
+    // Track file write attribution for knowledge-sync CRDT history
+    api.on("after_tool_call", (event, ctx) => {
+      try {
+        const runtime = getClusterRuntime();
+        if (!runtime.knowledgeSync) return;
+        const toolName = (event.toolName || "").toLowerCase();
+        if (toolName !== "write" && toolName !== "edit") return;
+        const filePath = (event.params?.file_path ?? event.params?.path) as string | undefined;
+        if (!filePath) return;
+        runtime.knowledgeSync.setPendingAttribution(filePath, {
+          nodeId: config.nodeId,
+          agentId: ctx.agentId ?? "unknown",
+          agentType: "OpenClaw",
+          sessionKey: ctx.sessionKey,
+        });
+      } catch {
+        // non-critical, silently ignore
+      }
+    });
   },
 };