replicas-cli 0.2.206 → 0.2.208

package/dist/index.mjs

@@ -8981,9 +8981,9 @@ var AGENT_MODELS = {
 };
 var MODEL_LABELS = {
   sonnet: "Sonnet 4.5",
-  opus: "Opus 4.7",
-  [CLAUDE_OPUS_1M_MODEL]: "Opus 4.7 (1M)",
-  [LEGACY_CLAUDE_OPUS_1M_MODEL]: "Opus 4.7 (1M)",
+  opus: "Opus 4.8",
+  [CLAUDE_OPUS_1M_MODEL]: "Opus 4.8 (1M)",
+  [LEGACY_CLAUDE_OPUS_1M_MODEL]: "Opus 4.8 (1M)",
   haiku: "Haiku 4.5",
   "gpt-5.5": "GPT-5.5",
   "gpt-5.4": "GPT-5.4",
@@ -9384,6 +9384,129 @@ function parseCodexEvents(events) {
   return messages;
 }
 
+// ../shared/src/display-message/task-accumulator.ts
+function mapTaskStatus(status) {
+  if (status === "in_progress" || status === "completed") return status;
+  return "pending";
+}
+function toAccumulatorInput(input) {
+  if (typeof input === "string") {
+    try {
+      const parsed = JSON.parse(input);
+      return isRecord(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return isRecord(input) ? input : {};
+}
+function extractToolResultText(content, separator = "\n") {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const texts = [];
+  for (const part of content) {
+    if (isRecord(part) && part.type === "text" && typeof part.text === "string") {
+      texts.push(part.text);
+    }
+  }
+  return texts.join(separator);
+}
+function parseStringField(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+function parseCreateResultTaskId(resultText) {
+  try {
+    const parsed = JSON.parse(resultText);
+    if (isRecord(parsed) && isRecord(parsed.task)) {
+      return parseStringField(parsed.task.id);
+    }
+  } catch {
+  }
+  return resultText.match(/\bTask\s+#?([A-Za-z0-9_-]+)\s+created\b/i)?.[1] ?? null;
+}
+var TaskAccumulator = class {
+  constructor() {
+    this.tasksByTaskId = /* @__PURE__ */ new Map();
+    this.tasksByCreateToolUseId = /* @__PURE__ */ new Map();
+    this.orderedKeys = [];
+  }
+  processToolUse(toolName, toolUseId, input) {
+    if (toolName === "TaskCreate") {
+      const subject = parseStringField(input.subject);
+      if (!subject) return false;
+      this.tasksByCreateToolUseId.set(toolUseId, { subject, status: "pending" });
+      this.orderedKeys.push(toolUseId);
+      return true;
+    }
+    if (toolName === "TaskUpdate") {
+      const taskId = parseStringField(input.taskId);
+      if (!taskId) return false;
+      if (input.status === "deleted") {
+        if (!this.tasksByTaskId.delete(taskId)) return false;
+        const idx = this.orderedKeys.indexOf(taskId);
+        if (idx !== -1) this.orderedKeys.splice(idx, 1);
+        return true;
+      }
+      const existing = this.tasksByTaskId.get(taskId);
+      const subject = parseStringField(input.subject) ?? existing?.subject;
+      if (!subject) return false;
+      const status = input.status !== void 0 ? mapTaskStatus(input.status) : existing?.status ?? "pending";
+      this.tasksByTaskId.set(taskId, { subject, status });
+      if (!existing) this.orderedKeys.push(taskId);
+      return true;
+    }
+    if (toolName === "TaskList") {
+      if (!Array.isArray(input.tasks)) return false;
+      let changed = false;
+      for (const raw of input.tasks) {
+        if (!isRecord(raw)) continue;
+        const id = parseStringField(raw.id);
+        const subject = parseStringField(raw.subject);
+        if (!id || !subject) continue;
+        const existing = this.tasksByTaskId.get(id);
+        const next = { subject, status: mapTaskStatus(raw.status) };
+        if (existing && existing.subject === next.subject && existing.status === next.status) continue;
+        this.tasksByTaskId.set(id, next);
+        if (!existing) this.orderedKeys.push(id);
+        changed = true;
+      }
+      return changed;
+    }
+    return false;
+  }
+  processCreateResult(toolUseId, resultText) {
+    const pending = this.tasksByCreateToolUseId.get(toolUseId);
+    if (!pending) return false;
+    const taskId = parseCreateResultTaskId(resultText);
+    if (!taskId) return false;
+    this.tasksByTaskId.set(taskId, pending);
+    this.tasksByCreateToolUseId.delete(toolUseId);
+    const idx = this.orderedKeys.indexOf(toolUseId);
+    if (idx !== -1) this.orderedKeys.splice(idx, 1, taskId);
+    return true;
+  }
+  getTasks() {
+    const out = [];
+    for (const key of this.orderedKeys) {
+      const task = this.tasksByTaskId.get(key) ?? this.tasksByCreateToolUseId.get(key);
+      if (task && task.subject) out.push(task);
+    }
+    return out;
+  }
+  processContentBlock(block) {
+    if (!isRecord(block)) return false;
+    if (block.type === "tool_use" && typeof block.name === "string" && typeof block.id === "string") {
+      return this.processToolUse(block.name, block.id, toAccumulatorInput(block.input));
+    }
+    if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+      return this.processCreateResult(block.tool_use_id, extractToolResultText(block.content, ""));
+    }
+    return false;
+  }
+};
+
 // ../shared/src/display-message/parsers/mcp.ts
 function parseMcpToolName(name) {
   const prefix = "mcp__";
@@ -9398,14 +9521,6 @@ function parseMcpToolName(name) {
 }
 
 // ../shared/src/display-message/parsers/claude-parser.ts
-function extractToolResultContent(content) {
-  if (!content) return "";
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.filter((item) => item.type === "text").map((item) => item.text || "").join("\n");
-  }
-  return "";
-}
 function parseClaudeEvents(events, parentToolUseId) {
   const messages = [];
   const filterValue = parentToolUseId !== void 0 ? parentToolUseId : null;
@@ -9415,11 +9530,20 @@ function parseClaudeEvents(events, parentToolUseId) {
   });
   const toolCallMap = /* @__PURE__ */ new Map();
   const taskMessageMap = /* @__PURE__ */ new Map();
+  const taskAccumulator = new TaskAccumulator();
+  const taskSnapshot = () => taskAccumulator.getTasks().map((task) => ({
+    text: task.subject,
+    completed: task.status === "completed",
+    itemStatus: task.status
+  }));
   filteredEvents.forEach((event) => {
     if (event.type === "claude-user") {
       const content = event.payload.message?.content || [];
       const toolResult = content.find((c) => c.type === "tool_result");
       if (toolResult && toolResult.tool_use_id) {
+        if (!toolResult.is_error) {
+          taskAccumulator.processContentBlock(toolResult);
+        }
         return;
       }
       if (event.payload.isSynthetic) {
@@ -9540,18 +9664,14 @@ function parseClaudeEvents(events, parentToolUseId) {
               status: "in_progress",
               timestamp: event.timestamp
             });
-          } else if (toolName === "TodoWrite") {
-            const inputObj = typeof toolInput === "string" ? safeJsonParse(toolInput, {}) : toolInput;
-            const todos = Array.isArray(inputObj.todos) ? inputObj.todos : [];
-            const todoItems = todos.map((todo) => ({
-              text: todo.content,
-              completed: todo.status === "completed"
-            }));
-            if (todoItems.length > 0) {
+          } else if (toolName === "TaskCreate" || toolName === "TaskUpdate" || toolName === "TaskList") {
+            taskAccumulator.processContentBlock(block);
+            const snapshot = taskSnapshot();
+            if (snapshot.length > 0) {
               messages.push({
                 id: `todo-${event.timestamp}-${messages.length}`,
                 type: "todo_list",
-                items: todoItems,
+                items: snapshot,
                 status: "completed",
                 timestamp: event.timestamp
               });
@@ -9692,9 +9812,12 @@ function parseClaudeEvents(events, parentToolUseId) {
       if (toolResult && toolResult.tool_use_id) {
         const toolInfo = toolCallMap.get(toolResult.tool_use_id);
         if (!toolInfo) return;
-        const resultContent = extractToolResultContent(toolResult.content);
+        const resultContent = extractToolResultText(toolResult.content);
         const isError = toolResult.is_error || false;
         const status = isError ? "failed" : "completed";
+        if (toolInfo.toolName === "TaskCreate" && !isError) {
+          taskAccumulator.processContentBlock(toolResult);
+        }
         const message = messages[toolInfo.messageIndex];
         if (!message) return;
         if (message.type === "command") {
@@ -16800,7 +16923,7 @@ Repository start hooks (${response.repositories.length}):
 }
 
 // src/index.ts
-var CLI_VERSION = "0.2.206";
+var CLI_VERSION = "0.2.208";
 function parseBooleanOption(value) {
   if (value === "true") return true;
   if (value === "false") return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-cli",
-  "version": "0.2.206",
+  "version": "0.2.208",
   "description": "CLI for managing Replicas workspaces - SSH into cloud dev environments with automatic port forwarding",
   "main": "dist/index.mjs",
   "bin": {