pybao-cli 1.4.96 → 1.4.98

package/dist/{chunk-IAFDLMER.js → chunk-5SASDPJI.js}

@@ -21,8 +21,10 @@ import {
   createTask,
   findTaskCycles,
   generateTaskListId,
+  getAgentMemoryDir,
   getAgentPrompt,
   getMaxThinkingTokens,
+  getProjectMemoryDir,
   getTask,
   getTaskListPaths,
   hasPermissionsToUseTool,
@@ -30,62 +32,67 @@ import {
   hasWritePermission,
   listTasks,
   query,
+  recordFileEdit,
+  resolveAutoMemoryFlags,
+  resolveMemoryPath,
+  resolveProjectId,
   runWithTaskListEnv,
   runWithTaskListId,
   updateTask
-} from "./chunk-2KWRWCZO.js";
+} from "./chunk-KJLAOYAB.js";
 import {
   queryLLM
-} from "./chunk-W2YU6ZJG.js";
+} from "./chunk-XFAWFKEO.js";
 import {
   FallbackToolUseRejectedMessage,
   MCPTool,
   getClients,
   getMCPTools
-} from "./chunk-V3I6BY55.js";
+} from "./chunk-7HPC6NEL.js";
 import {
   emitReminderEvent
-} from "./chunk-ZWWEN5JT.js";
+} from "./chunk-7YOXNCGC.js";
 import {
   getActiveAgents,
   getAgentByType,
   getAvailableAgentTypes
-} from "./chunk-NUVWA6CG.js";
+} from "./chunk-6W4QXF5T.js";
 import {
   INTERRUPT_MESSAGE,
   createAssistantMessage,
   createUserMessage,
   getLastAssistantMessageId
-} from "./chunk-XJEOCTTA.js";
+} from "./chunk-5FPVUG76.js";
 import {
   formatDuration,
   formatNumber
 } from "./chunk-OUXHGDLH.js";
 import {
   getAbsolutePath
-} from "./chunk-SXCGPQ3R.js";
+} from "./chunk-VFEFTBAX.js";
 import {
   LspFacade,
   formatDiagnosticsPretty
-} from "./chunk-RXJNQXGH.js";
+} from "./chunk-Y56ETINA.js";
 import {
   getModelManager
-} from "./chunk-73JVPKCJ.js";
+} from "./chunk-MSUD3TJP.js";
 import {
   getContext
-} from "./chunk-VYTXJQMG.js";
+} from "./chunk-6CZGZTTR.js";
 import {
   filesToTree,
   ripGrepWithStatus
-} from "./chunk-65ADQNJL.js";
+} from "./chunk-ZT2EDUJ5.js";
 import {
   getTheme
-} from "./chunk-SWUVTC7Q.js";
+} from "./chunk-ELZOI2EN.js";
 import {
   debug
-} from "./chunk-T4LDHDO5.js";
+} from "./chunk-G2NDX3AE.js";
 import {
   BunShell,
+  MEMORY_DIR,
   getCwd,
   getMessagesPath,
   getNextAvailableLogSidechainNumber,
@@ -94,7 +101,7 @@ import {
   overwriteLog,
   readTaskOutput,
   resolveXdgDataPath
-} from "./chunk-BZJ63VLB.js";
+} from "./chunk-57TUHQTK.js";
 
 // src/tools/index.ts
 import { memoize as memoize2 } from "lodash-es";
@@ -773,7 +780,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-7D3EAZYW.js");
+      const { getSessionRoot: getSessionRoot2 } = await import("./state-BNEI4WAC.js");
       const lines = output.split("\n");
       const uniqueFiles = /* @__PURE__ */ new Set();
       const lspSuggestions = [];
@@ -1146,7 +1153,7 @@ var DeleteTool = {
         }
         if (!force) {
           try {
-            const { LspFacade: LspFacade2 } = await import("./lsp-2SCBURX2.js");
+            const { LspFacade: LspFacade2 } = await import("./lsp-YT4SHOXN.js");
             const referenceDetail = await LspFacade2.checkFileReferences(fullPath);
             if (referenceDetail) {
               failedItems.push(
@@ -2331,6 +2338,12 @@ import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
 
 // src/utils/agent/storage.ts
 import { randomUUID as randomUUID2 } from "crypto";
+function getDefaultAgentId() {
+  return "default";
+}
+function resolveAgentId(agentId) {
+  return agentId || getDefaultAgentId();
+}
 function generateAgentId() {
   return randomUUID2();
 }
@@ -2829,6 +2842,7 @@ var TaskTool = {
                     options: queryOptions,
                     messageId: getLastAssistantMessageId(bgMessages),
                     agentId,
+                    agentType: input.subagent_type,
                     readFileTimestamps,
                     setToolJSX: () => {
                     }
@@ -2964,6 +2978,7 @@ var TaskTool = {
             options: queryOptions,
             messageId: getLastAssistantMessageId(messagesForQuery),
             agentId,
+            agentType: input.subagent_type,
             readFileTimestamps,
             setToolJSX: () => {
             }
@@ -3894,6 +3909,299 @@ var TaskUpdateTool = {
   }
 };
 
+// src/tools/memory/MemoryReadTool/MemoryReadTool.tsx
+import { existsSync as existsSync5, lstatSync, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "fs";
+import { Box as Box9, Text as Text9 } from "ink";
+import { join as join2 } from "path";
+import * as React9 from "react";
+import { z as z14 } from "zod";
+
+// src/tools/memory/MemoryReadTool/prompt.ts
+var DESCRIPTION10 = "Read agent memory files from the local filesystem.";
+var PROMPT10 = `Reads agent memory files from the local filesystem.
+
+Usage:
+- The file_path parameter must be a path relative to the agent's memory directory
+- By default, it reads a specific memory file if file_path is provided
+- If no file_path is specified, it returns an index of all memory files for the current agent
+- Memory files are stored under ~/.pyb/memory/projects/{projectId}/memory
+- Use this tool to access previously stored agent memories and task execution details
+
+Examples:
+- To read a specific memory file: {"file_path": "task-123-summary.md"}
+- To get memory index: {} (empty input)
+
+Security:
+- File paths are validated to ensure they are within the agent's memory directory
+- Only files within the agent's designated memory space can be accessed
+`;
+
+// src/tools/memory/MemoryReadTool/MemoryReadTool.tsx
+var inputSchema13 = z14.strictObject({
+  file_path: z14.string().optional().describe("Optional path to a specific memory file to read")
+});
+var MemoryReadTool = {
+  name: "MemoryRead",
+  async description() {
+    return DESCRIPTION10;
+  },
+  async prompt() {
+    return PROMPT10;
+  },
+  inputSchema: inputSchema13,
+  userFacingName() {
+    return "Read Memory";
+  },
+  async isEnabled() {
+    return resolveAutoMemoryFlags().enabled;
+  },
+  isReadOnly() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  needsPermissions() {
+    return false;
+  },
+  renderResultForAssistant({ content }) {
+    return content;
+  },
+  renderToolUseMessage(input) {
+    return Object.entries(input).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(", ");
+  },
+  renderToolUseRejectedMessage() {
+    return /* @__PURE__ */ React9.createElement(FallbackToolUseRejectedMessage, null);
+  },
+  renderToolResultMessage(output) {
+    return /* @__PURE__ */ React9.createElement(Box9, { justifyContent: "space-between", overflowX: "hidden", width: "100%" }, /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "row" }, /* @__PURE__ */ React9.createElement(Text9, null, "\xA0\xA0\uFFFD?\xA0"), /* @__PURE__ */ React9.createElement(Text9, null, output.content)));
+  },
+  async validateInput({ file_path }, context) {
+    const cwd = getCwd();
+    const projectId = await resolveProjectId(cwd);
+    const projectMemoryDir = getProjectMemoryDir(MEMORY_DIR, projectId);
+    const agentId = resolveAgentId(context?.agentId);
+    const agentMemoryDir = getAgentMemoryDir(projectMemoryDir, {
+      agentId,
+      agentType: context?.agentType
+    });
+    if (file_path) {
+      const resolved = resolveMemoryPath(agentMemoryDir, file_path);
+      if (!resolved.ok) {
+        return { result: false, message: "Invalid memory file path" };
+      }
+      if (!existsSync5(resolved.fullPath)) {
+        return { result: false, message: "Memory file does not exist" };
+      }
+    }
+    return { result: true };
+  },
+  async *call({ file_path }, context) {
+    const cwd = getCwd();
+    const projectId = await resolveProjectId(cwd);
+    const projectMemoryDir = getProjectMemoryDir(MEMORY_DIR, projectId);
+    const agentId = resolveAgentId(context?.agentId);
+    const agentMemoryDir = getAgentMemoryDir(projectMemoryDir, {
+      agentId,
+      agentType: context?.agentType
+    });
+    mkdirSync2(agentMemoryDir, { recursive: true });
+    if (file_path) {
+      const resolved = resolveMemoryPath(agentMemoryDir, file_path);
+      if (!resolved.ok) {
+        throw new Error("Invalid memory file path");
+      }
+      const fullPath = resolved.fullPath;
+      if (!existsSync5(fullPath)) {
+        throw new Error("Memory file does not exist");
+      }
+      const content2 = readFileSync4(fullPath, "utf-8");
+      yield {
+        type: "result",
+        data: {
+          content: content2
+        },
+        resultForAssistant: this.renderResultForAssistant({ content: content2 })
+      };
+      return;
+    }
+    const files = readdirSync2(agentMemoryDir, { recursive: true }).map((f) => join2(agentMemoryDir, f.toString())).filter((f) => !lstatSync(f).isDirectory()).map((f) => `- ${f}`).join("\n");
+    const indexPath = join2(agentMemoryDir, "index.md");
+    const index = existsSync5(indexPath) ? readFileSync4(indexPath, "utf-8") : "";
+    const quotes = "'''";
+    const content = `Here are the contents of the agent memory file, \`${indexPath}\`:
+${quotes}
+${index}
+${quotes}
+
+Files in the agent memory directory:
+${files}`;
+    yield {
+      type: "result",
+      data: { content },
+      resultForAssistant: this.renderResultForAssistant({ content })
+    };
+  }
+};
+
+// src/tools/memory/MemoryWriteTool/MemoryWriteTool.tsx
+import { Box as Box10, Text as Text10 } from "ink";
+import * as React10 from "react";
+import { z as z15 } from "zod";
+
+// src/services/memory/write.ts
+import {
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync5,
+  renameSync,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { dirname as dirname2 } from "path";
+var defaultFsDeps = {
+  mkdirSync: mkdirSync3,
+  existsSync: existsSync6,
+  readFileSync: readFileSync5,
+  writeFileSync: writeFileSync2,
+  renameSync,
+  rmSync: rmSync2
+};
+function mergeContent(existing, incoming, mode) {
+  if (mode === "replace") return incoming;
+  if (!existing) return incoming;
+  if (!incoming) return existing;
+  return `${existing}
+${incoming}`;
+}
+function writeMemoryFile(input, deps) {
+  const fs = { ...defaultFsDeps, ...deps || {} };
+  const mode = input.mode || "replace";
+  const filePath = input.filePath;
+  const tempPath = `${filePath}.tmp`;
+  fs.mkdirSync(dirname2(filePath), { recursive: true });
+  const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : "";
+  const nextContent = mergeContent(existing, input.content, mode);
+  fs.writeFileSync(tempPath, nextContent, "utf8");
+  try {
+    fs.renameSync(tempPath, filePath);
+  } catch {
+    fs.writeFileSync(filePath, nextContent, "utf8");
+    if (fs.existsSync(tempPath)) {
+      fs.rmSync(tempPath, { force: true });
+    }
+  }
+}
+
+// src/tools/memory/MemoryWriteTool/prompt.ts
+var DESCRIPTION11 = "Write agent memory files to the local filesystem.";
+var PROMPT11 = `Write agent memory files to the local filesystem.
+
+Usage:
+- The file_path parameter is required and specifies the memory file to write
+- The content parameter is required and contains the content to write
+- The optional mode parameter supports append or replace (default replace)
+- Memory files are stored under ~/.pyb/memory/projects/{projectId}/memory
+- Use this tool to store agent memories and task execution details
+- In replace mode existing file content is overwritten
+- In append mode content is appended to the existing file
+
+Security:
+- File paths are validated to ensure they are within the agent's memory directory
+- Only files within the agent's designated memory space can be written
+- Directory structure is automatically created if it doesn't exist
+
+Example:
+{
+  "file_path": "task-123-summary.md",
+  "content": "# Task Summary
+
+This is the summary of the task execution...",
+  "mode": "append"
+}
+`;
+
+// src/tools/memory/MemoryWriteTool/MemoryWriteTool.tsx
+var inputSchema14 = z15.strictObject({
+  file_path: z15.string().describe("Path to the memory file to write"),
+  content: z15.string().describe("Content to write to the file"),
+  mode: z15.enum(["append", "replace"]).optional().describe("Write mode: append adds to existing content, replace overwrites")
+});
+var MemoryWriteTool = {
+  name: "MemoryWrite",
+  async description() {
+    return DESCRIPTION11;
+  },
+  async prompt() {
+    return PROMPT11;
+  },
+  inputSchema: inputSchema14,
+  userFacingName() {
+    return "Write Memory";
+  },
+  async isEnabled() {
+    return resolveAutoMemoryFlags().enabled;
+  },
+  isReadOnly() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return false;
+  },
+  needsPermissions() {
+    return false;
+  },
+  renderResultForAssistant(content) {
+    return content;
+  },
+  renderToolUseMessage(input) {
+    return Object.entries(input).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(", ");
+  },
+  renderToolUseRejectedMessage() {
+    return /* @__PURE__ */ React10.createElement(FallbackToolUseRejectedMessage, null);
+  },
+  renderToolResultMessage() {
+    return /* @__PURE__ */ React10.createElement(Box10, { justifyContent: "space-between", overflowX: "hidden", width: "100%" }, /* @__PURE__ */ React10.createElement(Box10, { flexDirection: "row" }, /* @__PURE__ */ React10.createElement(Text10, null, "  ", "\uFFFD?Updated memory")));
+  },
+  async validateInput({ file_path }, context) {
+    const cwd = getCwd();
+    const projectId = await resolveProjectId(cwd);
+    const projectMemoryDir = getProjectMemoryDir(MEMORY_DIR, projectId);
+    const agentId = resolveAgentId(context?.agentId);
+    const agentMemoryDir = getAgentMemoryDir(projectMemoryDir, {
+      agentId,
+      agentType: context?.agentType
+    });
+    const resolved = resolveMemoryPath(agentMemoryDir, file_path);
+    if (!resolved.ok) {
+      return { result: false, message: "Invalid memory file path" };
+    }
+    return { result: true };
+  },
+  async *call({ file_path, content, mode }, context) {
+    const cwd = getCwd();
+    const projectId = await resolveProjectId(cwd);
+    const projectMemoryDir = getProjectMemoryDir(MEMORY_DIR, projectId);
+    const agentId = resolveAgentId(context?.agentId);
+    const agentMemoryDir = getAgentMemoryDir(projectMemoryDir, {
+      agentId,
+      agentType: context?.agentType
+    });
+    const resolved = resolveMemoryPath(agentMemoryDir, file_path);
+    if (!resolved.ok) {
+      throw new Error("Invalid memory file path");
+    }
+    const fullPath = resolved.fullPath;
+    writeMemoryFile({ filePath: fullPath, content, mode });
+    recordFileEdit(fullPath, content);
+    yield {
+      type: "result",
+      data: "Saved",
+      resultForAssistant: "Saved"
+    };
+  }
+};
+
 // src/tools/index.ts
 var getAllTools = () => [
   TaskTool,
@@ -3919,6 +4227,8 @@ var getAllTools = () => [
   AskUserQuestionTool,
   SlashCommandTool,
   SkillTool,
+  MemoryReadTool,
+  MemoryWriteTool,
   ListMcpResourcesTool,
   ReadMcpResourceTool,
   MCPTool