@khalilgharbaoui/opencode-claude-code-plugin 0.4.22 → 0.4.23

package/dist/index.js

@@ -124,6 +124,91 @@ var log = {
   }
 };
 
+// src/todo-ledger.ts
+var ledgers = /* @__PURE__ */ new Map();
+var PENDING_CREATE_TTL_MS = 6e4;
+var TASK_CREATED_PATTERN = /Task\s*#?\s*(\d+)\s+created/i;
+var VALID_STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress", "completed"]);
+function getOrCreate(sessionId) {
+  let ledger = ledgers.get(sessionId);
+  if (!ledger) {
+    ledger = { todos: /* @__PURE__ */ new Map(), pendingCreates: /* @__PURE__ */ new Map() };
+    ledgers.set(sessionId, ledger);
+  }
+  return ledger;
+}
+function prunePending(ledger) {
+  const cutoff = Date.now() - PENDING_CREATE_TTL_MS;
+  for (const [id, pending] of ledger.pendingCreates) {
+    if (pending.createdAt < cutoff) ledger.pendingCreates.delete(id);
+  }
+}
+function materialize(ledger) {
+  return Array.from(ledger.todos.values());
+}
+function resolveSubject(input) {
+  const subject = typeof input?.subject === "string" ? input.subject.trim() : "";
+  if (subject) return subject;
+  const description = typeof input?.description === "string" ? input.description.trim() : "";
+  if (description) return description;
+  return "(no subject)";
+}
+function applyTaskCreateToolUse(sessionId, toolUseId, input) {
+  if (!sessionId || !toolUseId) return;
+  const ledger = getOrCreate(sessionId);
+  prunePending(ledger);
+  ledger.pendingCreates.set(toolUseId, {
+    subject: resolveSubject(input),
+    createdAt: Date.now()
+  });
+}
+function applyTaskCreateToolResult(sessionId, toolUseId, resultText) {
+  if (!sessionId || !toolUseId) return null;
+  const ledger = ledgers.get(sessionId);
+  if (!ledger) return null;
+  const pending = ledger.pendingCreates.get(toolUseId);
+  if (!pending) return null;
+  ledger.pendingCreates.delete(toolUseId);
+  const match = typeof resultText === "string" ? resultText.match(TASK_CREATED_PATTERN) : null;
+  if (!match) {
+    log.debug("TaskCreate result did not match expected format", { sessionId, toolUseId, resultText });
+    return null;
+  }
+  const claudeId = match[1];
+  if (ledger.todos.has(claudeId)) {
+    log.debug("TaskCreate result for already-known claude id; overwriting", { sessionId, claudeId });
+  }
+  ledger.todos.set(claudeId, { id: claudeId, content: pending.subject, status: "pending" });
+  return materialize(ledger);
+}
+function applyTaskUpdate(sessionId, input) {
+  if (!sessionId) return null;
+  const taskId = typeof input?.taskId === "string" ? input.taskId : null;
+  if (!taskId) return null;
+  const ledger = ledgers.get(sessionId);
+  if (!ledger) return null;
+  const entry = ledger.todos.get(taskId);
+  if (!entry) {
+    log.debug("TaskUpdate for unknown task id", { sessionId, taskId });
+    return null;
+  }
+  if (input?.status === "deleted") {
+    ledger.todos.delete(taskId);
+    return materialize(ledger);
+  }
+  if (typeof input?.status === "string" && VALID_STATUSES.has(input.status)) {
+    entry.status = input.status;
+  }
+  if (typeof input?.subject === "string" && input.subject.trim().length > 0) {
+    entry.content = input.subject.trim();
+  }
+  return materialize(ledger);
+}
+function clearLedger(sessionId) {
+  if (!sessionId) return;
+  ledgers.delete(sessionId);
+}
+
 // src/tool-mapping.ts
 function mapToolInput(name, input) {
   if (!input) return input;
@@ -199,17 +284,42 @@ var CLAUDE_INTERNAL_TOOLS = /* @__PURE__ */ new Set([
   "ToolSearch",
   "Agent",
   "AskFollowupQuestion",
-  "TaskCreate",
-  "TaskUpdate",
   "TaskList",
   "TaskGet",
   "TaskStop"
 ]);
+function emitTodoWrite(todos) {
+  return {
+    name: "todowrite",
+    input: {
+      todos: todos.map((todo) => ({
+        id: todo.id,
+        content: todo.content,
+        status: todo.status,
+        priority: "medium"
+      }))
+    },
+    executed: false
+  };
+}
 function mapTool(name, input, opts) {
   if (CLAUDE_INTERNAL_TOOLS.has(name)) {
     log.debug("skipping Claude CLI internal tool", { name });
     return { name, input, executed: true, skip: true };
   }
+  if (name === "TaskCreate") {
+    if (opts?.sessionId && opts?.toolUseId) {
+      applyTaskCreateToolUse(opts.sessionId, opts.toolUseId, input);
+    }
+    return { name, input, executed: true, skip: true };
+  }
+  if (name === "TaskUpdate") {
+    if (opts?.sessionId) {
+      const list = applyTaskUpdate(opts.sessionId, input);
+      if (list !== null) return emitTodoWrite(list);
+    }
+    return { name, input, executed: true, skip: true };
+  }
   if (name === "EnterPlanMode") return { name: "plan_enter", input: {}, executed: false };
   if (name === "ExitPlanMode") return { name: "plan_exit", input, executed: false };
   if (name === "TodoWrite") {
@@ -1181,6 +1291,8 @@ function setClaudeSessionId(key, sessionId) {
   claudeSessions.set(key, sessionId);
 }
 function deleteClaudeSessionId(key) {
+  const claudeSessionId = claudeSessions.get(key);
+  if (claudeSessionId) clearLedger(claudeSessionId);
   claudeSessions.delete(key);
 }
 function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcpHash, systemPromptFile) {
@@ -2703,7 +2815,11 @@ ${plan}
         input: mappedInput,
         executed,
         skip
-      } = mapTool(tc.name, tc.args, { webSearch: this.config.webSearch });
+      } = mapTool(tc.name, tc.args, {
+        webSearch: this.config.webSearch,
+        sessionId: getClaudeSessionId(sk),
+        toolUseId: tc.id
+      });
       if (skip) continue;
       content.push({
         type: "tool-call",
@@ -3146,7 +3262,11 @@ ${plan}
                     const { name: mappedName, skip, executed } = mapTool(
                       block.name,
                       void 0,
-                      { webSearch: self.config.webSearch }
+                      {
+                        webSearch: self.config.webSearch,
+                        sessionId: getClaudeSessionId(sk),
+                        toolUseId: block.id
+                      }
                     );
                     if (!skip) {
                       controller.enqueue({
@@ -3280,7 +3400,11 @@ ${plan}
                       input: mappedInput,
                       executed,
                       skip
-                    } = mapTool(tc.name, parsedInput, { webSearch: self.config.webSearch });
+                    } = mapTool(tc.name, parsedInput, {
+                      webSearch: self.config.webSearch,
+                      sessionId: getClaudeSessionId(sk),
+                      toolUseId: tc.id
+                    });
                     if (!skip) {
                       toolCallsById.set(tc.id, {
                         id: tc.id,
@@ -3446,7 +3570,11 @@ ${plan}
                         input: mappedInput,
                         executed,
                         skip
-                      } = mapTool(block.name, parsedInput, { webSearch: self.config.webSearch });
+                      } = mapTool(block.name, parsedInput, {
+                        webSearch: self.config.webSearch,
+                        sessionId: getClaudeSessionId(sk),
+                        toolUseId: block.id
+                      });
                       if (!skip) {
                         if (!executed) skipResultForIds.add(block.id);
                         controller.enqueue({
@@ -3487,16 +3615,48 @@ ${plan}
                       });
                       continue;
                     }
+                    let resultText = "";
+                    if (typeof block.content === "string") {
+                      resultText = block.content;
+                    } else if (Array.isArray(block.content)) {
+                      resultText = block.content.filter(
+                        (c) => c.type === "text" && typeof c.text === "string"
+                      ).map((c) => c.text).join("\n");
+                    }
+                    const claudeSessionId = getClaudeSessionId(sk);
+                    if (claudeSessionId) {
+                      const list = applyTaskCreateToolResult(
+                        claudeSessionId,
+                        block.tool_use_id,
+                        resultText
+                      );
+                      if (list) {
+                        const synthId = `todowrite_${block.tool_use_id}`;
+                        controller.enqueue({
+                          type: "tool-input-start",
+                          id: synthId,
+                          toolName: "todowrite",
+                          providerExecuted: false
+                        });
+                        controller.enqueue({
+                          type: "tool-call",
+                          toolCallId: synthId,
+                          toolName: "todowrite",
+                          input: JSON.stringify({
+                            todos: list.map((t) => ({
+                              id: t.id,
+                              content: t.content,
+                              status: t.status,
+                              priority: "medium"
+                            }))
+                          }),
+                          providerExecuted: false
+                        });
+                        noteToolActivity();
+                      }
+                    }
                     const toolCall = toolCallsById.get(block.tool_use_id);
                     if (toolCall) {
-                      let resultText = "";
-                      if (typeof block.content === "string") {
-                        resultText = block.content;
-                      } else if (Array.isArray(block.content)) {
-                        resultText = block.content.filter(
-                          (c) => c.type === "text" && typeof c.text === "string"
-                        ).map((c) => c.text).join("\n");
-                      }
                       controller.enqueue({
                         type: "tool-result",
                         toolCallId: block.tool_use_id,