pybao-cli 1.4.47 → 1.4.49

package/dist/{chunk-QWQWWAWY.js → chunk-6Y4OSP3J.js}

@@ -29,16 +29,16 @@ import {
   hasReadPermission,
   hasWritePermission,
   query
-} from "./chunk-43NXI3DK.js";
+} from "./chunk-I5H5PGD5.js";
 import {
   queryLLM
-} from "./chunk-G2M7GOGN.js";
+} from "./chunk-EXEPX5H2.js";
 import {
   FallbackToolUseRejectedMessage,
   MCPTool,
   getClients,
   getMCPTools
-} from "./chunk-T65BVES2.js";
+} from "./chunk-AWML3QPK.js";
 import {
   TaskStoreConflictError,
   createTask,
@@ -46,48 +46,47 @@ import {
   generateAgentId,
   getTask,
   getTaskListPaths,
-  getTaskNextId,
   listTasks,
   updateTask
-} from "./chunk-3SWMMKPJ.js";
+} from "./chunk-MCP52ZSD.js";
 import {
   getActiveAgents,
   getAgentByType,
   getAvailableAgentTypes
-} from "./chunk-BIUZILAD.js";
+} from "./chunk-LZT5LZKG.js";
 import {
   INTERRUPT_MESSAGE,
   createAssistantMessage,
   createUserMessage,
   getLastAssistantMessageId
-} from "./chunk-GVI5S5UP.js";
+} from "./chunk-SHIPHOMT.js";
 import {
   formatDuration,
   formatNumber
 } from "./chunk-OUXHGDLH.js";
 import {
   getAbsolutePath
-} from "./chunk-PLCXOKAE.js";
+} from "./chunk-QW4VX3FW.js";
 import {
   LspFacade,
   formatDiagnosticsPretty
-} from "./chunk-XSCWKXBG.js";
+} from "./chunk-IQ3KORSP.js";
 import {
   getModelManager
-} from "./chunk-WFAQLNLO.js";
+} from "./chunk-GFDV6FUG.js";
 import {
   getContext
-} from "./chunk-ZSJFUCVZ.js";
+} from "./chunk-NZTVG7YS.js";
 import {
   filesToTree,
   ripGrepWithStatus
-} from "./chunk-LRSON7AD.js";
+} from "./chunk-XZNXY65J.js";
 import {
   getTheme
-} from "./chunk-F5RAKG24.js";
+} from "./chunk-55QJI7OQ.js";
 import {
   debug
-} from "./chunk-FPGPMXBY.js";
+} from "./chunk-XHGUMYRL.js";
 import {
   BunShell,
   getCwd,
@@ -98,7 +97,7 @@ import {
   overwriteLog,
   readTaskOutput,
   resolveXdgDataPath
-} from "./chunk-6K5FVPGV.js";
+} from "./chunk-UUGWQSET.js";
 
 // src/tools/index.ts
 import { memoize as memoize2 } from "lodash-es";
@@ -777,7 +776,7 @@ async function analyzeOutputWithLsp(output, exitCode) {
   if (exitCode !== 0 || errorCount > 0 || warningCount > 0) {
     try {
       const { isAbsolute: isAbsolute3, resolve: resolve4 } = await import("path");
-      const { getSessionRoot: getSessionRoot2 } = await import("./state-LFVIOJ3N.js");
+      const { getSessionRoot: getSessionRoot2 } = await import("./state-3OM3WWZ2.js");
       const lines = output.split("\n");
       const uniqueFiles = /* @__PURE__ */ new Set();
       const lspSuggestions = [];
@@ -1150,7 +1149,7 @@ var DeleteTool = {
         }
         if (!force) {
           try {
-            const { LspFacade: LspFacade2 } = await import("./lsp-57NKMT4B.js");
+            const { LspFacade: LspFacade2 } = await import("./lsp-BDQVEVFK.js");
             const referenceDetail = await LspFacade2.checkFileReferences(fullPath);
             if (referenceDetail) {
               failedItems.push(
@@ -3043,7 +3042,7 @@ function createTaskToolError(params) {
 }
 
 // src/tools/interaction/TaskCreateTool/prompt.ts
-var DESCRIPTION6 = "Create a new task in the task list with optional status and dependencies.";
+var DESCRIPTION6 = "Create a new task in the task list with optional status.";
 var PROMPT6 = `Use this tool to create a new task in the current task list. It is the entry point for planning multi-step work.
 
 ## When to Use This Tool
@@ -3065,11 +3064,10 @@ NOTE that you should not use this tool if you are only updating status or detail
 ## Input Notes
 - subject is required.
 - listId is optional; omit to use the default list.
-- Dependencies are validated for cycles; invalid cycles will be rejected.
-- For multi-step plans, you need to create structured task list without blockedBy and add dependencies later via TaskUpdate.
+- TaskCreate only supports single-task creation; create multiple tasks one by one.
+- For multi-step plans, create the structured task list without dependencies and add blockedBy later via TaskUpdate.
 - status can be pending, in_progress, blocked, done, or archived.
 - activeForm is required and must not equal subject.
-- activeForm is required for each batch task.
 - blockedBy is always stored as an array (empty when not used).
 - description and blockedBy are kept separate in JSON; any joining is only for terminal rendering.
 - Task ordering relies on task id; do not use priority fields.
@@ -3078,35 +3076,17 @@ NOTE that you should not use this tool if you are only updating status or detail
 ## Field Guidance
 - subject: concise task name that reads like a goal.
 - activeForm: short verb phrase that describes the in-progress action, not a full sentence.
-- description: prefer a one-line overview plus bullet points for multi-step tasks; for very simple tasks a short sentence is fine.
+- description: prefer a one-line overview that introduces the bullets with "Including:" plus bullet points for multi-step tasks; for very simple tasks a short sentence is fine.
 
 Preferred single-task template:
 {
-  "subject": "Schema migration plan",
-  "description": "Define the migration scope and sequencing.
-- List impacted tables
-- Identify backfill steps
-- Note rollback plan",
-  "activeForm": "Planning schema migration"
-}
-
-## Batch Input Notes
-- Use tasks: [...] to create multiple tasks in one call.
-- Do not mix tasks with single-task fields like subject/description.
-- Auto dependency chaining only applies to batch creation when enabled and blockedBy is omitted.
-Batch example (auto chain enabled, blockedBy omitted):
-{
-  "tasks": [
-    { "subject": "Design schema", "activeForm": "Designing schema" },
-    { "subject": "Implement API", "activeForm": "Implementing API" }
-  ]
-}
-Batch example (explicit blockedBy, no override):
-{
-  "tasks": [
-    { "subject": "Migrate data", "activeForm": "Migrating data" },
-    { "subject": "Backfill indexes", "activeForm": "Backfilling indexes", "blockedBy": ["1"] }
-  ]
+  "subject": "Requirements clarification and scope definition",
+  "description": "Clarify the business goals, functional scope, and technical boundaries. Including:
+- Confirm supported languages
+- Define summary output format and quality bar
+- Specify performance targets (latency, throughput)
+- Identify stakeholders and acceptance criteria",
+  "activeForm": "Clarifying requirements and defining scope"
 }
 
 ## Status Notes
@@ -3116,7 +3096,7 @@ Batch example (explicit blockedBy, no override):
 
 <example>
 User: I need to implement user registration, product catalog, and checkout.
-Assistant: I will create tasks for each feature.
+Assistant: I will create tasks for each feature one by one.
 *Creates tasks:*
 1. User registration
 2. Product catalog
@@ -3134,22 +3114,8 @@ Assistant: I'll seed tasks for the refactor and verification steps.
 
 <example>
 User: The API task depends on database schema changes.
-Assistant: I'll create tasks with dependencies.
-*Creates tasks:*
-1. Update database schema
-2. Implement API endpoints (blockedBy: schema task)
-</example>
-
-<example>
-User: Create a two-step plan in one call.
-Assistant: I'll create tasks in batch with a dependency chain.
-*Creates tasks with tasks array, where the second task is blockedBy the first*
-</example>
-
-<example>
-User: Create three tasks at once, but I will specify blockedBy myself.
-Assistant: I'll create tasks in batch and keep your blockedBy values.
-*Creates tasks with tasks array and explicit blockedBy fields*
+Assistant: I'll create the tasks first, then add blockedBy using TaskUpdate.
+*Creates tasks without dependencies, then updates blockedBy*
 </example>
 
 <example>
@@ -3166,22 +3132,16 @@ Assistant: I'll create a single task.
 `;
 
 // src/tools/interaction/TaskCreateTool/TaskCreateTool.tsx
-var shouldAutoChainDependencies = () => {
-  const value = process.env.PYB_TASK_AUTOCHAIN?.toLowerCase();
-  return value === "true" || value === "1";
-};
-var getMissingBlockedBy = (blockedBy, ids) => (blockedBy ?? []).filter((id) => !ids.has(id));
-var taskInputSchema = z9.strictObject({
+var inputSchema9 = z9.strictObject({
+  listId: z9.string().optional(),
   subject: z9.string().min(1),
   description: z9.string().optional(),
-  activeForm: z9.string().min(1),
+  activeForm: z9.string({ required_error: "activeForm is required" }).min(1),
   status: z9.enum(["pending", "in_progress", "blocked", "done", "archived"]).optional(),
   tags: z9.array(z9.string()).optional(),
   assignee: z9.string().optional(),
   metadata: z9.record(z9.string()).optional(),
   archived: z9.boolean().optional(),
-  blocks: z9.array(z9.string()).optional(),
-  blockedBy: z9.array(z9.string()).optional(),
   parent: z9.string().optional(),
   related: z9.array(z9.string()).optional(),
   legacyTodoId: z9.string().optional()
@@ -3193,79 +3153,6 @@ var taskInputSchema = z9.strictObject({
     });
   }
 });
-var inputSchema9 = z9.strictObject({
-  listId: z9.string().optional(),
-  tasks: z9.array(taskInputSchema).min(1).optional(),
-  subject: z9.string().min(1).optional(),
-  description: z9.string().optional(),
-  activeForm: z9.string().optional(),
-  status: z9.enum(["pending", "in_progress", "blocked", "done", "archived"]).optional(),
-  tags: z9.array(z9.string()).optional(),
-  assignee: z9.string().optional(),
-  metadata: z9.record(z9.string()).optional(),
-  archived: z9.boolean().optional(),
-  blocks: z9.array(z9.string()).optional(),
-  blockedBy: z9.array(z9.string()).optional(),
-  parent: z9.string().optional(),
-  related: z9.array(z9.string()).optional(),
-  legacyTodoId: z9.string().optional()
-}).superRefine((value, ctx) => {
-  const hasTasks = Array.isArray(value.tasks);
-  const hasSubject = typeof value.subject === "string" && value.subject.length > 0;
-  if (hasTasks && hasSubject) {
-    ctx.addIssue({
-      code: z9.ZodIssueCode.custom,
-      message: "Use either tasks or subject, not both"
-    });
-    return;
-  }
-  if (!hasTasks && !hasSubject) {
-    ctx.addIssue({
-      code: z9.ZodIssueCode.custom,
-      message: "Either tasks or subject is required"
-    });
-    return;
-  }
-  if (hasTasks) {
-    const singleKeys = [
-      "subject",
-      "description",
-      "activeForm",
-      "status",
-      "tags",
-      "assignee",
-      "metadata",
-      "archived",
-      "blocks",
-      "blockedBy",
-      "parent",
-      "related",
-      "legacyTodoId"
-    ];
-    const hasSingleFields = singleKeys.some((key) => value[key] !== void 0);
-    if (hasSingleFields) {
-      ctx.addIssue({
-        code: z9.ZodIssueCode.custom,
-        message: "Do not mix batch tasks with single-task fields"
-      });
-    }
-  }
-  if (hasSubject) {
-    if (!value.activeForm || value.activeForm.length === 0) {
-      ctx.addIssue({
-        code: z9.ZodIssueCode.custom,
-        message: "activeForm is required"
-      });
-      return;
-    }
-    if (value.activeForm === value.subject) {
-      ctx.addIssue({
-        code: z9.ZodIssueCode.custom,
-        message: "activeForm \u4E0D\u5F97\u4E0E subject \u76F8\u540C"
-      });
-    }
-  }
-});
 var TaskCreateTool = {
   name: "TaskCreate",
   cachedDescription: DESCRIPTION6,
@@ -3305,178 +3192,7 @@ var TaskCreateTool = {
   },
   async *call(input) {
     try {
-      const tasks = listTasks({ listId: input.listId });
-      if (input.tasks) {
-        const autoChain = shouldAutoChainDependencies();
-        const startId = getTaskNextId({ listId: input.listId });
-        const now2 = Date.now();
-        const candidateTasks2 = [...tasks];
-        const candidateBatch = input.tasks.map((entry, index) => {
-          const autoBlockedBy = entry.blockedBy === void 0 && autoChain && input.tasks.length > 1 && index > 0 ? [String(startId + index - 1)] : entry.blockedBy;
-          const candidate = {
-            id: String(startId + index),
-            subject: entry.subject,
-            description: entry.description,
-            activeForm: entry.activeForm,
-            status: entry.status ?? "pending",
-            tags: entry.tags,
-            assignee: entry.assignee,
-            metadata: entry.metadata,
-            archived: entry.archived,
-            blocks: [],
-            blockedBy: autoBlockedBy,
-            parent: entry.parent,
-            related: entry.related,
-            createdAt: now2,
-            updatedAt: now2,
-            baseVersion: 1,
-            version: 1,
-            legacyTodoId: entry.legacyTodoId
-          };
-          candidateTasks2.push(candidate);
-          return candidate;
-        });
-        const { listId: listId2 } = getTaskListPaths(input.listId);
-        for (let index = 0; index < candidateBatch.length; index += 1) {
-          if (candidateBatch.length > 1 && index > 0 && (candidateBatch[index].blockedBy?.length ?? 0) === 0) {
-            emitReminderEvent("task.dependency_chain_missing", {
-              listId: listId2,
-              taskId: candidateBatch[index].id,
-              blockedBy: candidateBatch[index].blockedBy ?? [],
-              timestamp: Date.now()
-            });
-          }
-        }
-        const candidateIds2 = new Set(candidateTasks2.map((task2) => task2.id));
-        for (const task2 of candidateBatch) {
-          const missing2 = getMissingBlockedBy(task2.blockedBy, candidateIds2);
-          if (missing2.length > 0) {
-            yield {
-              type: "result",
-              data: createTaskToolError({
-                type: "validation",
-                code: "TASK_BLOCKEDBY_NOT_FOUND",
-                message: "BlockedBy tasks must exist in the same list",
-                details: { taskId: task2.id, listId: listId2, missingBlockedBy: missing2 }
-              })
-            };
-            return;
-          }
-        }
-        const cycles2 = findTaskCycles(buildTaskGraph(candidateTasks2));
-        if (cycles2.length > 0) {
-          yield {
-            type: "result",
-            data: createTaskToolError({
-              type: "validation",
-              code: "TASK_CYCLE_DETECTED",
-              message: "Task dependency cycle detected",
-              details: { cycles: cycles2 }
-            })
-          };
-          return;
-        }
-        const createdItems = [];
-        for (let index = 0; index < input.tasks.length; index += 1) {
-          const entry = input.tasks[index];
-          const task2 = createTask(
-            {
-              subject: entry.subject,
-              description: entry.description,
-              activeForm: entry.activeForm,
-              status: entry.status,
-              tags: entry.tags,
-              assignee: entry.assignee,
-              metadata: entry.metadata,
-              archived: entry.archived,
-              blockedBy: candidateBatch[index].blockedBy,
-              parent: entry.parent,
-              related: entry.related,
-              legacyTodoId: entry.legacyTodoId
-            },
-            { listId: input.listId }
-          );
-          emitReminderEvent("task.created", {
-            listId: listId2,
-            taskId: task2.id,
-            task: task2,
-            timestamp: Date.now()
-          });
-          createdItems.push(toTaskDetail(task2));
-        }
-        yield {
-          type: "result",
-          data: {
-            listId: listId2,
-            items: createdItems
-          }
-        };
-        return;
-      }
       const subject = input.subject;
-      const nextId = Math.max(
-        0,
-        ...tasks.map((task2) => Number(task2.id)).filter((value) => !Number.isNaN(value))
-      ) + 1;
-      const now = Date.now();
-      const candidateTask = {
-        id: String(nextId),
-        subject,
-        description: input.description,
-        activeForm: input.activeForm,
-        status: input.status ?? "pending",
-        tags: input.tags,
-        assignee: input.assignee,
-        metadata: input.metadata,
-        archived: input.archived,
-        blocks: [],
-        blockedBy: input.blockedBy,
-        parent: input.parent,
-        related: input.related,
-        createdAt: now,
-        updatedAt: now,
-        baseVersion: 1,
-        version: 1,
-        legacyTodoId: input.legacyTodoId
-      };
-      if (tasks.length > 0 && (input.blockedBy?.length ?? 0) === 0) {
-        const { listId: listId2 } = getTaskListPaths(input.listId);
-        emitReminderEvent("task.dependency_chain_missing", {
-          listId: listId2,
-          taskId: candidateTask.id,
-          blockedBy: candidateTask.blockedBy ?? [],
-          timestamp: Date.now()
-        });
-      }
-      const candidateTasks = [...tasks, candidateTask];
-      const candidateIds = new Set(candidateTasks.map((task2) => task2.id));
-      const missing = getMissingBlockedBy(candidateTask.blockedBy, candidateIds);
-      if (missing.length > 0) {
-        const { listId: listId2 } = getTaskListPaths(input.listId);
-        yield {
-          type: "result",
-          data: createTaskToolError({
-            type: "validation",
-            code: "TASK_BLOCKEDBY_NOT_FOUND",
-            message: "BlockedBy tasks must exist in the same list",
-            details: { taskId: candidateTask.id, listId: listId2, missingBlockedBy: missing }
-          })
-        };
-        return;
-      }
-      const cycles = findTaskCycles(buildTaskGraph(candidateTasks));
-      if (cycles.length > 0) {
-        yield {
-          type: "result",
-          data: createTaskToolError({
-            type: "validation",
-            code: "TASK_CYCLE_DETECTED",
-            message: "Task dependency cycle detected",
-            details: { cycles }
-          })
-        };
-        return;
-      }
       const task = createTask(
         {
           subject,
@@ -3487,7 +3203,6 @@ var TaskCreateTool = {
           assignee: input.assignee,
           metadata: input.metadata,
           archived: input.archived,
-          blockedBy: input.blockedBy,
           parent: input.parent,
           related: input.related,
           legacyTodoId: input.legacyTodoId
@@ -3845,7 +3560,7 @@ var getDepsSnapshot = (task) => ({
   parent: task.parent,
   related: task.related ?? []
 });
-var getMissingBlockedBy2 = (blockedBy, ids) => (blockedBy ?? []).filter((id) => !ids.has(id));
+var getMissingBlockedBy = (blockedBy, ids) => (blockedBy ?? []).filter((id) => !ids.has(id));
 var isPlanFinalized = (metadata) => metadata?.planFinalized === "true";
 var compareTaskId = (left, right) => {
   const leftValue = Number(left.id);
@@ -3960,7 +3675,7 @@ var TaskUpdateTool = {
       });
     }
     if (input.blockedBy) {
-      const missing = getMissingBlockedBy2(updatedTask.blockedBy, candidateIds);
+      const missing = getMissingBlockedBy(updatedTask.blockedBy, candidateIds);
       if (missing.length > 0) {
         yield {
           type: "result",
@@ -3993,7 +3708,7 @@ var TaskUpdateTool = {
       const ordered = [...activeTasks].sort(compareTaskId);
       const firstTaskId = ordered[0]?.id;
       for (const task of activeTasks) {
-        const missing = getMissingBlockedBy2(task.blockedBy, candidateIds);
+        const missing = getMissingBlockedBy(task.blockedBy, candidateIds);
         if (missing.length > 0) {
           yield {
             type: "result",