pybao-cli 1.4.86 → 1.4.88

package/dist/{chunk-TUQG5JPN.js → chunk-VX76OKFG.js}

@@ -10,6 +10,7 @@ import {
   GlobTool,
   GrepTool,
   KillShellTool,
+  MessageResponse,
   NotebookEditTool,
   SkillTool,
   SlashCommandTool,
@@ -33,57 +34,60 @@ import {
   runWithTaskListEnv,
   runWithTaskListId,
   updateTask
-} from "./chunk-OXIP2DAD.js";
+} from "./chunk-I3Z4C5AC.js";
+import {
+  getCurrentSessionId
+} from "./chunk-XKYHFZEC.js";
 import {
   queryLLM
-} from "./chunk-OOLRCWS2.js";
+} from "./chunk-JPJAU5JW.js";
 import {
   FallbackToolUseRejectedMessage,
   MCPTool,
   getClients,
   getMCPTools
-} from "./chunk-XBM24YJM.js";
+} from "./chunk-SY4QMAAQ.js";
 import {
   emitReminderEvent
-} from "./chunk-X472W3BH.js";
+} from "./chunk-QW3B6I6E.js";
 import {
   getActiveAgents,
   getAgentByType,
   getAvailableAgentTypes
-} from "./chunk-7UFU3WAO.js";
+} from "./chunk-6SQZWXWO.js";
 import {
   INTERRUPT_MESSAGE,
   createAssistantMessage,
   createUserMessage,
   getLastAssistantMessageId
-} from "./chunk-LZV5TCLM.js";
+} from "./chunk-JHHE7BO3.js";
 import {
   formatDuration,
   formatNumber
 } from "./chunk-OUXHGDLH.js";
 import {
   getAbsolutePath
-} from "./chunk-TOHWB6HI.js";
+} from "./chunk-FPY7JUJY.js";
 import {
   LspFacade,
   formatDiagnosticsPretty
-} from "./chunk-XYYAVY4Z.js";
+} from "./chunk-QGEZGMIE.js";
 import {
   getModelManager
-} from "./chunk-GSPJ4GS3.js";
+} from "./chunk-SKT3BY7F.js";
 import {
   getContext
-} from "./chunk-Z3VN6WKQ.js";
+} from "./chunk-UYI7DYIU.js";
 import {
   filesToTree,
   ripGrepWithStatus
-} from "./chunk-2O3X5IWT.js";
+} from "./chunk-RGMF3LVN.js";
 import {
   getTheme
-} from "./chunk-3JIUIDM2.js";
+} from "./chunk-IIAJFPXS.js";
 import {
   debug
-} from "./chunk-N775QA2Y.js";
+} from "./chunk-BQRQDLGU.js";
 import {
   BunShell,
   getCwd,
@@ -94,7 +98,7 @@ import {
   overwriteLog,
   readTaskOutput,
   resolveXdgDataPath
-} from "./chunk-NZCROE5X.js";
+} from "./chunk-WCDTF6NW.js";
 
 // src/tools/index.ts
 import { memoize as memoize2 } from "lodash-es";
@@ -773,7 +777,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-GXNXV4HP.js");
+      const { getSessionRoot: getSessionRoot2 } = await import("./state-USMPO4SG.js");
       const lines = output.split("\n");
       const uniqueFiles = /* @__PURE__ */ new Set();
       const lspSuggestions = [];
@@ -1146,7 +1150,7 @@ var DeleteTool = {
         }
         if (!force) {
           try {
-            const { LspFacade: LspFacade2 } = await import("./lsp-LZ2FQAEJ.js");
+            const { LspFacade: LspFacade2 } = await import("./lsp-QI3ZLTQV.js");
             const referenceDetail = await LspFacade2.checkFileReferences(fullPath);
             if (referenceDetail) {
               failedItems.push(
@@ -3879,6 +3883,336 @@ var TaskUpdateTool = {
   }
 };
 
+// src/tools/system/ThinkTool/ThinkTool.tsx
+import { z as z14 } from "zod";
+import React9 from "react";
+import { Text as Text9 } from "ink";
+
+// src/tools/system/ThinkTool/prompt.ts
+var DESCRIPTION10 = "A structured thinking tool for complex problem-solving through sequential reasoning, revision, and branching analysis. Supports step-by-step decomposition of complex problems with revision and alternative path exploration.";
+var PROMPT10 = `## Think Tool - Structured Sequential Thinking
+
+Use the Think tool for **structured, step-by-step reasoning** on complex problems. This tool helps you think systematically by breaking down complex problems into manageable steps, with support for revision and alternative path exploration.
+
+### \u{1F3AF} When to Use Sequential Thinking
+
+**Ideal scenarios:**
+- **Complex problem decomposition** - Breaking a large problem into logical steps
+- **Planning with uncertainty** - When the full solution path isn't clear initially
+- **Analysis requiring revision** - When you might need to correct your understanding mid-process
+- **Multi-approach comparison** - When you want to explore alternative solutions
+- **Cross-step context maintenance** - When you need to remember insights across multiple reasoning steps
+- **Hypothesis generation & verification** - Scientific reasoning, debugging complex issues
+
+**Do NOT use for:**
+- Simple factual questions (e.g., "What is 2+2?")
+- Tasks with clear, single-step answers
+- When you already have a complete solution in mind
+
+### \u{1F4CB} How to Use - Schema Fields
+
+**Required fields:**
+- \`thought\` (string): Your current thinking step
+
+**Recommended fields for sequential thinking:**
+- \`thoughtNumber\` (integer): Current thought number in sequence (1, 2, 3...)
+- \`totalThoughts\` (integer): Estimated total thoughts needed - **adjustable as understanding deepens**
+- \`nextThoughtNeeded\` (boolean): Whether more thinking is needed
+
+**Advanced fields:**
+- \`parentThought\` (integer): The existing thought number you are revising or branching from
+
+### \u{1F504} Sequential Thinking Workflow
+
+#### 1. Starting a Thinking Sequence
+
+\`\`\`json
+{
+  "thoughtNumber": 1,
+  "totalThoughts": 5,
+  "thought": "First, I need to understand the problem requirements. The user wants to...",
+  "nextThoughtNeeded": true
+}
+\`\`\`
+
+**Key points:**
+- Start with an initial estimate of total thoughts (e.g., 3-7)
+- Don't worry about being exact - you can adjust later
+- Clearly state what you're analyzing in this step
+
+#### 2. Continuing the Sequence
+
+\`\`\`json
+{
+  "thoughtNumber": 2,
+  "totalThoughts": 5,
+  "thought": "Now let me analyze the key constraints. I see three main factors:...",
+  "nextThoughtNeeded": true
+}
+\`\`\`
+
+**Key points:**
+- Build on previous thoughts
+- Each thought should have a clear focus
+- Keep \`nextThoughtNeeded: true\` while still reasoning
+
+#### 3. Revising Previous Thinking (When You Realize a Mistake)
+
+\`\`\`json
+{
+  "thoughtNumber": 3,
+  "totalThoughts": 6,
+  "thought": "Wait, I realize my analysis in thought #2 was incomplete. Let me reconsider...",
+  "parentThought": 2,
+  "nextThoughtNeeded": true
+}
+\`\`\`
+
+**Key points:**
+- **It's safe and encouraged to admit mistakes**
+- Explain what was wrong and your new understanding
+- You can increase \`totalThoughts\` to accommodate the revision
+
+#### 4. Exploring Alternative Paths (Branching)
+
+\`\`\`json
+{
+  "thoughtNumber": 4,
+  "totalThoughts": 6,
+  "thought": "Let me explore an alternative approach. What if we...?",
+  "parentThought": 2,
+  "nextThoughtNeeded": true
+}
+\`\`\`
+
+**Key points:**
+- Useful for comparing multiple solutions
+- Mark the branching point and give it an ID
+- You can return to the main path later
+
+#### 5. Completing the Thinking
+
+\`\`\`json
+{
+  "thoughtNumber": 6,
+  "totalThoughts": 6,
+  "thought": "Based on the analysis above, my conclusion is: [clear answer]. The key reasoning steps were: 1)..., 2)..., 3)...",
+  "nextThoughtNeeded": false
+}
+\`\`\`
+
+**Key points:**
+- Set \`nextThoughtNeeded: false\` only when truly done
+- Summarize the key insights and final conclusion
+- Ensure the reasoning chain is clear
+
+### \u{1F4CA} Best Practices
+
+**Do:**
+- \u2705 Start with a reasonable estimate (3-7 thoughts for most complex problems)
+- \u2705 Adjust \`totalThoughts\` up or down as your understanding deepens
+- \u2705 Use revision when you realize a mistake - **this is a strength, not a weakness**
+- \u2705 Keep each thought focused on one aspect
+- \u2705 Build logically on previous thoughts
+- \u2705 Set \`nextThoughtNeeded: false\` when you reach a satisfactory conclusion
+
+**Don't:**
+- \u274C Waste thoughts on trivialities (e.g., "I'm thinking...", "Let me continue...")
+- \u274C Feel locked into your initial \`totalThoughts\` estimate
+- \u274C Hide uncertainties - express them explicitly
+- \u274C Use for simple questions that don't need multi-step reasoning
+
+### \u{1F393} Complete Example
+
+**Problem**: "Design a caching strategy for a high-traffic API"
+
+**Step 1:**
+\`\`\`json
+{
+  "thoughtNumber": 1,
+  "totalThoughts": 5,
+  "thought": "First, I need to understand the requirements: high-traffic API means we need to minimize latency and database load. Key considerations: 1) What data to cache, 2) Cache invalidation strategy, 3) Cache tier (client/CDN/server/DB)",
+  "nextThoughtNeeded": true
+}
+\`\`\`
+
+**Step 2:**
+\`\`\`json
+{
+  "thoughtNumber": 2,
+  "totalThoughts": 5,
+  "thought": "For what data to cache: should cache read-heavy, slowly-changing data. Examples: user profiles, product catalogs, configuration. Should NOT cache: real-time data, user-specific sensitive data, frequently changing inventory",
+  "nextThoughtNeeded": true
+}
+\`\`\`
+
+**Step 3 (Revision):**
+\`\`\`json
+{
+  "thoughtNumber": 3,
+  "totalThoughts": 6,
+  "thought": "Wait, I need to reconsider thought #2. Actually, some user-specific data CAN be cached if properly keyed (e.g., user preferences). The key is cache key design, not blanket exclusion.",
+  "parentThought": 2,
+  "nextThoughtNeeded": true
+}
+\`\`\`
+
+**Step 4:**
+\`\`\`json
+{
+  "thoughtNumber": 4,
+  "totalThoughts": 6,
+  "thought": "For cache invalidation: need a multi-pronged approach: 1) TTL for stale data, 2) Event-driven invalidation on writes, 3) Version-based invalidation for config changes",
+  "nextThoughtNeeded": true
+}
+\`\`\`
+
+**Step 5:**
+\`\`\`json
+{
+  "thoughtNumber": 5,
+  "totalThoughts": 6,
+  "thought": "For cache tier strategy: recommend a multi-layer approach: L1 (in-memory, per-instance) for hot data, L2 (Redis cluster) for shared caching, L3 (CDN) for static assets",
+  "nextThoughtNeeded": true
+}
+\`\`\`
+
+**Step 6 (Conclusion):**
+\`\`\`json
+{
+  "thoughtNumber": 6,
+  "totalThoughts": 6,
+  "thought": "Final recommendation: Implement a 3-tier caching strategy with Redis as L2. Key design: 1) Cache read-heavy data with proper cache keys, 2) TTL + event-driven invalidation, 3) Multi-tier for different access patterns. Trade-offs: added complexity vs. 10x latency improvement for cached reads.",
+  "nextThoughtNeeded": false
+}
+\`\`\`
+
+### \u{1F527} Integration with Other Tools
+
+**Think \u2192 Plan workflow:**
+1. Use Think to analyze the problem and identify key factors
+2. Use Think to generate and compare multiple approaches
+3. Use Think to finalize the recommended solution
+4. Use Task/Write tools to implement the chosen approach
+
+**Think \u2192 Debug workflow:**
+1. Use Think to list hypotheses about the bug cause
+2. Use Think to design experiments to test each hypothesis
+3. Use Bash/Read tools to run experiments
+4. Use Think to analyze results and narrow down the cause
+
+**Think \u2192 Edit workflow:**
+1. Use Think to understand the code structure and plan the edit
+2. Use Think to identify potential side effects and risks
+3. Use Read tools to verify your understanding
+4. Use Edit tools to implement the changes
+
+### \u{1F3AF} Stopping Criteria
+
+Stop thinking (set \`nextThoughtNeeded: false\`) when:
+- You have a clear, justified conclusion
+- Further thinking would be repetitive
+- The cost of additional analysis exceeds the value
+- You've addressed all aspects of the problem
+
+Remember: **Quality of thinking > Quantity of thoughts**. A concise, insightful 3-thought analysis is better than a verbose 10-thought ramble.`;
+
+// src/tools/system/ThinkTool/ThinkTool.tsx
+var thinkToolSchema = z14.object({
+  thought: z14.string().describe("Your thoughts."),
+  thoughtNumber: z14.number().int().min(1).optional(),
+  totalThoughts: z14.number().int().min(1).optional(),
+  nextThoughtNeeded: z14.boolean().optional(),
+  parentThought: z14.number().int().min(1).optional()
+});
+var isEnabledFlag = (raw) => {
+  const normalized = String(raw ?? "").trim().toLowerCase();
+  if (!normalized) return true;
+  return normalized === "1" || normalized === "true" || normalized === "on" || normalized === "yes";
+};
+var thinkingSessions = /* @__PURE__ */ new Map();
+var resolveSessionKey = () => getCurrentSessionId() ?? "global";
+var getSessionThoughts = (sessionKey) => {
+  const existing = thinkingSessions.get(sessionKey);
+  if (existing) return existing;
+  const created = [];
+  thinkingSessions.set(sessionKey, created);
+  return created;
+};
+var validateParentThought = (parentThought, sessionThoughts) => {
+  if (parentThought < 1 || parentThought > sessionThoughts.length) {
+    throw new Error(
+      `parentThought must reference an existing thought between 1 and ${sessionThoughts.length}`
+    );
+  }
+};
+var computeRevisionNumber = (parentThought, sessionThoughts) => sessionThoughts.filter((entry) => entry.parentThought === parentThought).length + 1;
+var formatThinkToolUseMessage = (input) => {
+  const header = typeof input.thoughtNumber === "number" && typeof input.totalThoughts === "number" ? `#${input.thoughtNumber}/${input.totalThoughts}` : typeof input.thoughtNumber === "number" ? `#${input.thoughtNumber}` : "";
+  const body = typeof input.parentThought === "number" ? `revise #${input.parentThought}: ${input.thought}` : input.thought;
+  return header ? `${header} ${body}` : body;
+};
+var ThinkTool = {
+  name: "Think",
+  userFacingName: () => "Think",
+  description: async () => DESCRIPTION10,
+  inputSchema: thinkToolSchema,
+  isEnabled: async () => isEnabledFlag(process.env.PYB_THINK_TOOL),
+  isReadOnly: () => true,
+  isConcurrencySafe: () => false,
+  needsPermissions: () => false,
+  prompt: async () => PROMPT10,
+  async *call(input) {
+    const sessionKey = resolveSessionKey();
+    const sessionThoughts = getSessionThoughts(sessionKey);
+    const expectedNext = sessionThoughts.length + 1;
+    const providedThoughtNumber = typeof input.thoughtNumber === "number" ? input.thoughtNumber : expectedNext;
+    if (providedThoughtNumber !== expectedNext) {
+      throw new Error(
+        `Thought number mismatch: expected ${expectedNext}, got ${providedThoughtNumber}`
+      );
+    }
+    const totalThoughts = typeof input.totalThoughts === "number" ? Math.max(input.totalThoughts, expectedNext) : expectedNext;
+    const parentThought = typeof input.parentThought === "number" ? input.parentThought : void 0;
+    if (typeof parentThought === "number") {
+      validateParentThought(parentThought, sessionThoughts);
+    }
+    const revisionNumber = typeof parentThought === "number" ? computeRevisionNumber(parentThought, sessionThoughts) : void 0;
+    const entry = {
+      thought: input.thought,
+      thoughtNumber: providedThoughtNumber,
+      totalThoughts,
+      currentThought: expectedNext,
+      nextThoughtNeeded: input.nextThoughtNeeded ?? false,
+      parentThought,
+      revisionNumber,
+      timestamp: Date.now()
+    };
+    sessionThoughts.push(entry);
+    yield {
+      type: "result",
+      resultForAssistant: `Thought #${entry.currentThought} logged.`,
+      data: {
+        thought: entry.thought,
+        thoughtNumber: entry.thoughtNumber,
+        currentThought: entry.currentThought,
+        totalThoughts: entry.totalThoughts,
+        totalThoughtsInSession: sessionThoughts.length,
+        nextThoughtNeeded: entry.nextThoughtNeeded,
+        parentThought: entry.parentThought,
+        revisionNumber: entry.revisionNumber
+      }
+    };
+  },
+  renderToolUseMessage(input) {
+    return formatThinkToolUseMessage(input);
+  },
+  renderToolUseRejectedMessage() {
+    return /* @__PURE__ */ React9.createElement(MessageResponse, { children: /* @__PURE__ */ React9.createElement(Text9, { color: getTheme().error }, "Thought cancelled") });
+  },
+  renderResultForAssistant: () => "Your thought has been logged."
+};
+
 // src/tools/index.ts
 var getAllTools = () => [
   TaskTool,
@@ -3901,6 +4235,7 @@ var getAllTools = () => [
   TaskListTool,
   WebFetchTool,
   WebSearchTool,
+  ThinkTool,
   AskUserQuestionTool,
   SlashCommandTool,
   SkillTool,