zen-code 3.0.5 → 4.1.0

package/dist/subTasks-DRzFBQoV.mjs

@@ -0,0 +1,210 @@
+import { tool as p, HumanMessage as d, SystemMessage as m } from "langchain";
+import { Command as f, Annotation as b } from "@langchain/langgraph";
+import { z as i } from "zod";
+import { c as w, a as y } from "./graphBuilder-BSX1uOgk.mjs";
+import "@langchain/openai";
+const k = i.object({
+  task_store: i.record(i.string(), i.any()).default({})
+});
+w().build({
+  task_store: b({
+    reducer: (r, t) => ({ ...r, ...t }),
+    default: () => ({})
+  })
+});
+const _ = i.object({
+  task_id: i.string().optional().describe("The task id to ask the subagent, if not provided, will use the tool call id"),
+  subagent_type: i.string().describe(
+    "The type of subagent to use. Must be one of the available agent types listed in the tool description."
+  ),
+  task_description: i.string().describe("Describe the user state and what you want the subagent to do."),
+  data_transfer: i.any().optional().describe("Data to transfer to the subagent.")
+}), v = (r, t) => p(
+  async (e, s) => {
+    const a = s.state, o = e.task_id || s.toolCall.id;
+    let n = {
+      messages: []
+    };
+    o && a?.task_store?.[o] ? n = a?.task_store[o] : (n = JSON.parse(JSON.stringify(a)), n.messages = [], n.task_store = {});
+    const u = await r(o, e, a);
+    n.messages.push(new d({ content: e.task_description })), e.data_transfer && n.messages.push(
+      new d({
+        content: `Here is the data to help you complete the task: ${JSON.stringify(
+          e.data_transfer,
+          null,
+          2
+        )}`
+      })
+    );
+    const l = await u.invoke(n), g = l.messages.at(-1), c = {
+      task_store: {
+        ...a?.task_store || {},
+        [o]: l
+      },
+      messages: [
+        {
+          role: "tool",
+          content: `task_id: ${o}
+---
+` + (g?.text || ""),
+          tool_call_id: s.toolCall.id
+        }
+      ]
+    };
+    return t?.pass_through_keys?.forEach((h) => {
+      h in l && (c[h] = l[h]);
+    }), new f({
+      update: c
+    });
+  },
+  {
+    name: "task",
+    description: `Launch a new agent to handle complex, multi-step tasks autonomously. 
+
+Available agent types and the tools they have access to:
+- general-purpose: General-purpose agent for researching complex questions, searching for code, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. (Tools: *)
+- statusline-setup: Use this agent to configure the user's Claude Code status line setting. (Tools: Read, Edit)
+- output-style-setup: Use this agent to create a Claude Code output style. (Tools: Read, Write, Edit, Glob, LS, Grep)
+
+When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
+
+
+
+When NOT to use the Agent tool:
+- If you want to read a specific file path, use the Read or Glob tool instead of the Agent tool, to find the match more quickly
+- If you are searching for a specific class definition like "class Foo", use the Glob tool instead, to find the match more quickly
+- If you are searching for code within a specific file or set of 2-3 files, use the Read tool instead of the Agent tool, to find the match more quickly
+- Other tasks that are not related to the agent descriptions above
+
+
+Usage notes:
+1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
+2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
+3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
+4. The agent's outputs should generally be trusted
+5. Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
+6. If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
+
+Example usage:
+
+<example_agent_descriptions>
+"code-reviewer": use this agent after you are done writing a significant piece of code
+"greeting-responder": use this agent when to respond to user greetings with a friendly joke
+</example_agent_description>
+
+<example>
+user: "Please write a function that checks if a number is prime"
+assistant: Sure let me write a function that checks if a number is prime
+assistant: First let me use the Write tool to write a function that checks if a number is prime
+assistant: I'm going to use the Write tool to write the following code:
+<code>
+function isPrime(n) {
+  if (n <= 1) return false
+  for (let i = 2; i * i <= n; i++) {
+    if (n % i === 0) return false
+  }
+  return true
+}
+</code>
+<commentary>
+Since a signficant piece of code was written and the task was completed, now use the code-reviewer agent to review the code
+</commentary>
+assistant: Now let me use the code-reviewer agent to review the code
+assistant: Uses the Task tool to launch the with the code-reviewer agent 
+</example>
+
+<example>
+user: "Hello"
+<commentary>
+Since the user is greeting, use the greeting-responder agent to respond with a friendly joke
+</commentary>
+assistant: "I'm going to use the Task tool to launch the with the greeting-responder agent"
+</example>
+`,
+    schema: _
+  }
+), S = `
+
+## SubAgents System
+
+You have access to a subagent system that can delegate specialized tasks to other agents.
+
+**Available SubAgents:**
+
+{subagents_list}
+
+**How to Use SubAgents (Progressive Disclosure):**
+
+SubAgents follow a **progressive disclosure** pattern - you know they exist (name + description above), but you only delegate tasks when needed:
+
+1. **Recognize when to delegate**: Check if the user's task matches a subagent's specialization
+2. **Use the ask_subagents tool**: Call the tool with the subagent's ID and a clear task description
+3. **Provide context**: Use the \`data_transfer\` parameter to pass relevant information
+4. **Get results**: The subagent will process the task and return results
+
+**When to Use SubAgents:**
+- When the user's request requires specialized knowledge or workflows
+- When a task is complex and can be broken down into subtasks
+- When you need parallel processing or different expertise areas
+- When a subagent provides proven patterns for specific domains
+
+**SubAgent Tool Usage:**
+
+The \`ask_subagents\` tool is available for delegation:
+
+- **subagent_id**: The ID of the subagent to delegate to
+- **task_description**: Clear description of what needs to be done
+- **task_id** (optional): Identifier for tracking, it will automatically be generated after you run a subagent.
+- **data_transfer** (optional): Context/data to pass to the subagent
+
+**Example Workflow:**
+
+User: "Can you have the research agent look into quantum computing developments?"
+
+1. Check available subagents above → See "research" subagent with ID
+2. Use ask_subagents tool with appropriate parameters
+3. Provide clear task description and any necessary context
+4. Process the results from the subagent
+
+Remember: SubAgents are tools to distribute work and leverage specialized capabilities. When in doubt, check if a subagent exists for the task!
+`;
+class W {
+  name = "SubAgentsMiddleware";
+  stateSchema = k;
+  contextSchema = void 0;
+  tools = [];
+  agentList = Promise.resolve("");
+  constructor(t) {
+    this.agentList = this.formatSubAgentsList(t), this.tools.push(
+      v(
+        async (e, s, a) => await y("agents/default", t, a, {}, { subagent_id: e }),
+        {}
+      )
+    );
+  }
+  /**
+   * Format subagents metadata for display in system prompt.
+   */
+  async formatSubAgentsList(t) {
+    const e = [];
+    for (const s of await t.listAgents())
+      e.push(`- **${s.id}**: ${s.description}`), e.push(`  → Use ask_subagents with subagent_id: "${s.id}"`);
+    return e.join(`
+`);
+  }
+  async wrapModelCall(t, e) {
+    const s = await this.agentList, a = S.replace("{subagents_list}", s);
+    let o;
+    t.systemPrompt ? o = t.systemPrompt + `
+
+` + a : o = a;
+    const n = new m(o), u = {
+      ...t,
+      systemMessage: n
+    };
+    return await e(u);
+  }
+}
+export {
+  W as SubAgentsMiddleware
+};

package/dist/tasks-D5CMeC2P.mjs

@@ -0,0 +1,237 @@
+import "micromatch";
+import "./index-DFARkGOA.mjs";
+import { Low as n } from "lowdb";
+import { JSONFile as d } from "lowdb/node";
+import "yaml";
+import r from "node:path";
+class h {
+  db;
+  dbPath;
+  constructor(t) {
+    this.dbPath = r.join(t, ".claude", "task.json");
+    const a = new d(this.dbPath);
+    this.db = new n(a, this.getDefaultData());
+  }
+  getDefaultData() {
+    return {
+      version: "1.0",
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      tasks: {},
+      history: [],
+      config: {
+        maxConcurrentAgents: 3,
+        retryLimit: 3,
+        autoResume: !1
+      }
+    };
+  }
+  /**
+   * 初始化数据库
+   */
+  async initialize() {
+    const t = await import("node:fs"), a = r.dirname(this.dbPath);
+    t.existsSync(a) || t.mkdirSync(a, { recursive: !0 }), await this.db.read(), this.db.data || (this.db.data = this.getDefaultData(), await this.db.write());
+  }
+  /**
+   * 获取单个任务
+   */
+  async getTask(t) {
+    return await this.db.read(), this.db.data.tasks[t];
+  }
+  /**
+   * 更新任务
+   */
+  async updateTask(t, a) {
+    await this.db.read();
+    const i = this.db.data.tasks[t];
+    return i ? (this.db.data.tasks[t] = {
+      ...i,
+      ...a
+    }, a.status && (a.status === "running" && !i.startedAt ? this.db.data.tasks[t].startedAt = (/* @__PURE__ */ new Date()).toISOString() : ["complete", "error", "review"].includes(a.status) && !i.completedAt && (this.db.data.tasks[t].completedAt = (/* @__PURE__ */ new Date()).toISOString())), this.db.data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString(), await this.db.write(), !0) : !1;
+  }
+  /**
+   * 批量添加任务（用于 Plan 初始化）
+   */
+  async addTasks(t) {
+    await this.db.read();
+    for (const a of t)
+      this.db.data.tasks[a.id] = a;
+    this.db.data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString(), await this.db.write();
+  }
+  /**
+   * 根据 status 获取任务列表
+   */
+  async getTasksByStatus(t) {
+    return await this.db.read(), Object.values(this.db.data.tasks).filter((a) => a.status === t);
+  }
+  /**
+   * 获取所有任务
+   */
+  async getAllTasks() {
+    return await this.db.read(), Object.values(this.db.data.tasks);
+  }
+  /**
+   * 添加执行记录
+   */
+  async addHistory(t) {
+    await this.db.read(), this.db.data.history.push(t), await this.db.write();
+  }
+  /**
+   * 获取执行历史
+   */
+  async getHistory(t) {
+    return await this.db.read(), t ? this.db.data.history.filter((a) => a.planId === t) : this.db.data.history;
+  }
+  /**
+   * 设置活跃 Plan ID
+   */
+  async setActivePlan(t) {
+    await this.db.read(), this.db.data.activePlanId = t, this.db.data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString(), await this.db.write();
+  }
+  /**
+   * 获取活跃 Plan ID
+   */
+  async getActivePlan() {
+    return await this.db.read(), this.db.data.activePlanId;
+  }
+  /**
+   * 更新配置
+   */
+  async updateConfig(t) {
+    await this.db.read(), this.db.data.config = {
+      ...this.db.data.config,
+      ...t
+    }, this.db.data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString(), await this.db.write();
+  }
+  /**
+   * 获取配置
+   */
+  async getConfig() {
+    return await this.db.read(), this.db.data.config;
+  }
+  /**
+   * 清空所有任务（慎用）
+   */
+  async clearAllTasks() {
+    await this.db.read(), this.db.data.tasks = {}, this.db.data.activePlanId = void 0, this.db.data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString(), await this.db.write();
+  }
+  /**
+   * 删除单个任务
+   */
+  async deleteTask(t) {
+    return await this.db.read(), this.db.data.tasks[t] ? (delete this.db.data.tasks[t], this.db.data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString(), await this.db.write(), !0) : !1;
+  }
+  /**
+   * 获取数据库路径（用于测试）
+   */
+  getDbPath() {
+    return this.dbPath;
+  }
+}
+class o {
+  store = null;
+  projectRoot;
+  constructor(t) {
+    this.projectRoot = t;
+  }
+  /**
+   * 初始化 Store
+   */
+  async initialize() {
+    this.store || (this.store = new h(this.projectRoot), await this.store.initialize());
+  }
+  /**
+   * 确保 Store 已初始化
+   */
+  ensureInitialized() {
+    if (!this.store)
+      throw new Error("TasksStore not initialized. Call initialize() first.");
+  }
+  /**
+   * 获取所有任务
+   */
+  async getAllTasks() {
+    return this.ensureInitialized(), await this.store.getAllTasks();
+  }
+  /**
+   * 根据 status 获取任务
+   */
+  async getTasksByStatus(t) {
+    return this.ensureInitialized(), await this.store.getTasksByStatus(t);
+  }
+  /**
+   * 获取单个任务
+   */
+  async getTask(t) {
+    return this.ensureInitialized(), await this.store.getTask(t);
+  }
+  /**
+   * 更新任务状态
+   */
+  async updateTaskStatus(t, a) {
+    return this.ensureInitialized(), await this.store.updateTask(t, { status: a });
+  }
+  /**
+   * 删除任务
+   */
+  async deleteTask(t) {
+    return this.ensureInitialized(), await this.store.deleteTask(t);
+  }
+  /**
+   * 批量添加任务
+   */
+  async addTasks(t) {
+    this.ensureInitialized(), await this.store.addTasks(t);
+  }
+  /**
+   * 获取活跃 Plan ID
+   */
+  async getActivePlan() {
+    return this.ensureInitialized(), await this.store.getActivePlan();
+  }
+  /**
+   * 设置活跃 Plan ID
+   */
+  async setActivePlan(t) {
+    this.ensureInitialized(), await this.store.setActivePlan(t);
+  }
+  /**
+   * 获取任务统计
+   */
+  async getTaskStats() {
+    const t = await this.getAllTasks();
+    return {
+      total: t.length,
+      pickup: t.filter((a) => a.status === "pickup").length,
+      running: t.filter((a) => a.status === "running").length,
+      complete: t.filter((a) => a.status === "complete").length,
+      error: t.filter((a) => a.status === "error").length,
+      review: t.filter((a) => a.status === "review").length,
+      feedback: t.filter((a) => a.status === "feedback").length
+    };
+  }
+  /**
+   * 获取执行历史
+   */
+  async getHistory(t) {
+    return this.ensureInitialized(), await this.store.getHistory(t);
+  }
+  /**
+   * 清空所有任务（慎用）
+   */
+  async clearAllTasks() {
+    this.ensureInitialized(), await this.store.clearAllTasks();
+  }
+}
+let e = null;
+function k(s) {
+  if (!e) {
+    if (!s)
+      throw new Error("projectRoot is required for first initialization");
+    e = new o(s);
+  }
+  return e;
+}
+export {
+  k as getTasksStore
+};

package/dist/zen-code.mjs

@@ -1,3 +1,3 @@
-import "./use-input-1eSjZocJ.mjs";
+import "./MultiLineTextInput-DjNvaZzA.mjs";
 import "chalk";
-import "./app-p0LqnAgS.mjs";
+import "./app-C-NaCZSh.mjs";