@ai-setting/roy-agent-core 1.4.13 → 1.4.15

package/dist/shared/{chunk-2b5kbhx3.js → @ai-setting/roy-agent-core-0rtxwr28.js}

@@ -1,119 +1,11 @@
+import {
+  DecoratorNode,
+  init_decorator_node
+} from "./roy-agent-core-1ce3fqrk.js";
 import {
   __esm,
   __export
-} from "./chunk-wbkh7wat.js";
-
-// src/env/workflow/decorators/decorator-node.ts
-class DecoratorNode {
-  type = "decorator";
-  id;
-  methodName;
-  instance;
-  dependsOn;
-  timeout;
-  retryConfig;
-  constructor(definition) {
-    const config = definition.config;
-    this.id = definition.id;
-    this.methodName = config._methodName;
-    this.instance = config._instance;
-    this.dependsOn = definition.depends_on || [];
-    this.timeout = definition.timeout;
-    this.retryConfig = definition.retry;
-  }
-  async execute(context) {
-    const startTime = Date.now();
-    const method = this.instance[this.methodName];
-    if (typeof method !== "function") {
-      return {
-        success: false,
-        error: `Method '${this.methodName}' is not a function`,
-        duration: Date.now() - startTime
-      };
-    }
-    const input = this.prepareInput(context);
-    const result = await this.executeWithRetry(input, context.abort);
-    return {
-      success: !result.error,
-      output: result.output,
-      error: result.error,
-      duration: Date.now() - startTime,
-      metadata: {
-        methodName: this.methodName
-      }
-    };
-  }
-  prepareInput(context) {
-    const nodeOutputs = context.nodeOutputs;
-    if (this.dependsOn.length === 0) {
-      return context.input || {};
-    }
-    const input = {};
-    for (const depId of this.dependsOn) {
-      const depOutput = nodeOutputs instanceof Map ? nodeOutputs.get(depId) : nodeOutputs?.[depId];
-      if (depOutput && typeof depOutput === "object") {
-        if ("output" in depOutput) {
-          input[depId] = depOutput.output;
-        } else {
-          input[depId] = depOutput;
-        }
-      }
-    }
-    return input;
-  }
-  async executeWithRetry(input, abort) {
-    const maxAttempts = this.retryConfig?.max_attempts ?? 1;
-    const backoff = this.retryConfig?.backoff ?? "exponential";
-    const initialDelay = this.retryConfig?.initial_delay ?? 1000;
-    let lastError;
-    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
-      if (abort?.aborted) {
-        return { error: "Execution aborted" };
-      }
-      try {
-        const output = await this.executeWithTimeout(input, abort);
-        return { output };
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
-        if (attempt < maxAttempts) {
-          const delay = this.calculateBackoff(backoff, initialDelay, attempt - 1);
-          await this.sleep(delay, abort);
-        }
-      }
-    }
-    return { error: lastError?.message || "Unknown error" };
-  }
-  async executeWithTimeout(input, abort) {
-    if (!this.timeout) {
-      return this.instance[this.methodName](input);
-    }
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => {
-        reject(new Error(`Execution timeout after ${this.timeout}ms`));
-      }, this.timeout);
-    });
-    return Promise.race([
-      this.instance[this.methodName](input),
-      timeoutPromise
-    ]);
-  }
-  calculateBackoff(backoff, initialDelay, attempt) {
-    if (backoff === "exponential") {
-      return initialDelay * Math.pow(2, attempt);
-    }
-    return initialDelay;
-  }
-  sleep(ms, abort) {
-    return new Promise((resolve) => {
-      const timeout = setTimeout(resolve, ms);
-      abort?.addEventListener("abort", () => {
-        clearTimeout(timeout);
-        resolve();
-      });
-    });
-  }
-}
-var init_decorator_node = () => {};
+} from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/workflow/nodes/condition-node.ts
 class ConditionNode {
@@ -363,4 +255,4 @@ var init_node_registry_helper = __esm(() => {
   init_merge_node();
 });
 
-export { init_decorator_node, registerDecoratorNodeType, hasDecoratorNodes, getDecoratorNodes, exports_node_registry_helper, init_node_registry_helper };
+export { registerDecoratorNodeType, hasDecoratorNodes, getDecoratorNodes, exports_node_registry_helper, init_node_registry_helper };

package/dist/shared/@ai-setting/roy-agent-core-0vbdz0x7.js

@@ -0,0 +1,36 @@
+import {
+  AskUserError,
+  init_workflow_hil
+} from "./roy-agent-core-e25xkv53.js";
+
+// src/env/workflow/tools/ask-user-tool.ts
+init_workflow_hil();
+import { z } from "zod";
+var AskUserInputSchema = z.object({
+  query: z.string().describe("The question or request to ask the user"),
+  options: z.array(z.string()).optional().describe("Optional choices for the user"),
+  required_confirm: z.boolean().optional().describe("If true, user must explicitly confirm")
+});
+var askUserTool = {
+  name: "ask_user",
+  description: "Ask user for input or confirmation. Use this tool when you need user input or validation to continue the workflow.",
+  parameters: AskUserInputSchema,
+  async execute(args, context) {
+    const runId = context.metadata?.runId || "unknown";
+    const sessionId = context.metadata?.sessionId || `workflow_${runId}`;
+    const nodeId = context.metadata?.nodeId || "unknown";
+    let fullQuery = args.query;
+    if (args.options && args.options.length > 0) {
+      fullQuery = `${args.query} (选项: ${args.options.join(", ")})`;
+    }
+    throw new AskUserError(runId, sessionId, nodeId, "agent", fullQuery);
+  },
+  metadata: {
+    category: "workflow",
+    tags: ["human-in-loop", "user-input"],
+    version: "1.0.0"
+  }
+};
+var askUserToolInstance = askUserTool;
+
+export { AskUserInputSchema, askUserTool, askUserToolInstance };

package/dist/shared/@ai-setting/roy-agent-core-12zkpda2.js

@@ -0,0 +1,393 @@
+import {
+  TaskHookPoints
+} from "./roy-agent-core-92z6t4he.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-j3wc4465.js";
+import {
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/task/plugins/task-plugin.ts
+class TaskPlugin {
+  config;
+  constructor(config = {}) {
+    this.config = { enabled: true, priority: 0, ...config };
+  }
+  getHookPoints() {
+    return this.hooks.map((h) => h.point);
+  }
+  getPriorityForHook(hookPoint) {
+    const hook = this.hooks.find((h) => h.point === hookPoint);
+    return hook?.priority ?? this.config.priority ?? 0;
+  }
+  isEnabled() {
+    return this.config.enabled ?? true;
+  }
+  setEnabled(enabled) {
+    this.config.enabled = enabled;
+  }
+}
+// src/env/task/plugins/task-tag-plugin.ts
+init_logger();
+
+// src/env/task/plugins/workflow-extractor-agent.ts
+var WORKFLOW_EXTRACTOR_PROMPT = `你是 Workflow 提取专家，负责将自然语言描述转换为符合规范的 Workflow YAML。
+
+## 提取原则
+
+1. **优先具象节点**：优先使用特定工具节点（如 read_file, write_file, grep, bash 等）
+2. **Fallback 到通用节点**：没有对应工具时，使用 agent/llm/bash 节点
+3. **避免条件分支**：不提取循环和条件判断，保持线性流程
+4. **泛化但可执行**：步骤描述可泛化，但节点类型和工具要具体
+
+## 构建流程
+
+**重要**：构建的 Workflow 必须通过 \`roy workflow validate\` 验证才能输出。
+
+\`\`\`
+1. 理解用户需求
+2. 参考 roy workflow nodes 查看可用节点类型
+3. 参考 roy workflow get <name> 查看已有 workflow 示例
+4. 生成 Workflow YAML
+5. 使用 roy workflow validate --yaml "<生成的YAML>" 验证
+6. 验证通过后输出最终结果
+\`\`\`
+
+## 验证检查清单
+
+完成 Workflow 构建后，必须使用以下命令验证：
+
+\`\`\`bash
+roy workflow validate --yaml "<your-yaml>"
+\`\`\`
+
+验证通过后（无错误输出）才输出最终结果。验证失败时根据错误信息修正后重新验证。
+
+## 可用的 Workflow 节点类型
+
+使用以下命令查看所有节点类型的详细配置：
+
+\`\`\`bash
+roy workflow nodes              # 列出所有节点类型
+roy workflow nodes <type>      # 查看特定节点详情（如 tool, agent, skill）
+\`\`\`
+
+**支持的节点类型：**
+- **tool**：执行工具（bash, read-file, write-file, grep 等）
+- **skill**：调用技能
+- **agent**：AI Agent
+- **workflow**：子工作流
+- **condition**：条件判断
+- **merge**：合并结果
+- **decorator**：装饰器方法
+
+## 查看已有 Workflow 示例
+
+使用以下命令查看已有 workflow 的 YAML 结构：
+
+\`\`\`bash
+roy workflow list              # 列出所有 workflow
+roy workflow get <name>       # 获取指定 workflow 详情（YAML 格式）
+\`\`\`
+
+## 输出要求
+
+验证通过后，输出符合以下格式的 YAML Workflow：
+
+\`\`\`yaml
+name: {泛化的任务名称}
+version: "1.0"
+description: {一句话描述}
+nodes:
+  - id: node-1
+    type: tool|skill|agent|workflow|condition|merge|decorator
+    name: {节点名称}
+    config:
+      # 根据类型配置必填字段：
+      # tool: tool, input/args
+      # skill: skill, input
+      # agent: agent_type, prompt, options
+      # workflow: workflow_name, input
+      # condition: condition
+      # merge: strategy, depends_on
+      # decorator: _methodName, _instance
+    depends_on: []
+outputs: []
+\`\`\`
+
+## 限制
+
+- 至少 2 个节点才有意义
+- 不要生成条件节点（if/else/switch）
+- 不要生成循环节点（while/for）
+- 每个节点要有清晰的名称和描述
+- 必须为 tool 节点指定 tool 名称
+- 必须为 agent 节点指定 agent_type 和 prompt`;
+function createWorkflowExtractorAgent() {
+  return {
+    type: "sub",
+    name: "workflow-extractor",
+    systemPrompt: WORKFLOW_EXTRACTOR_PROMPT,
+    maxIterations: 10,
+    filterHistory: false
+  };
+}
+function formatExtractorInput(params) {
+  const lines = [];
+  lines.push("# 任务信息");
+  lines.push(`- 标题: ${params.task.title}`);
+  if (params.task.description) {
+    lines.push(`- 描述: ${params.task.description}`);
+  }
+  if (params.task.goals_and_expected_deliverables) {
+    lines.push(`- 目标: ${params.task.goals_and_expected_deliverables}`);
+  }
+  lines.push("");
+  if (params.operations.length > 0) {
+    lines.push("# 操作记录");
+    for (const op of params.operations) {
+      lines.push(`- [${op.actionType}] ${op.actionTitle}`);
+      if (op.actionDescription) {
+        lines.push(`  ${op.actionDescription.slice(0, 200)}`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push("# Session 消息历史");
+  lines.push("(以下是相关的对话历史，请从中提取 Workflow)");
+  for (const msg of params.messages.slice(-50)) {
+    const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+    const truncated = content.slice(0, 500);
+    lines.push(`**${msg.role}**: ${truncated}${content.length > 500 ? "..." : ""}`);
+  }
+  lines.push("");
+  lines.push("## 任务");
+  lines.push("请分析以上信息，构建一个可复用的 Workflow。");
+  lines.push("使用迭代式流程：生成 YAML → validate 验证 → 修正错误 → 重复直到通过验证。");
+  return lines.join(`
+`);
+}
+function formatExtractorInputFromDescription(params) {
+  const lines = [];
+  lines.push("# Workflow 描述");
+  lines.push(params.description);
+  lines.push("");
+  lines.push("## 任务");
+  lines.push("请根据以上描述，构建一个可复用的 Workflow。");
+  lines.push("使用迭代式流程：生成 YAML → validate 验证 → 修正错误 → 重复直到通过验证。");
+  return lines.join(`
+`);
+}
+async function parseExtractorOutput(output) {
+  const yamlMatch = output.match(/```yaml\n?([\s\S]*?)\n?```/) || output.match(/```\n?([\s\S]*?)\n?```/) || output.match(/(\|[\s\S]*?)(?:\n\n|$)/);
+  const yamlContent = yamlMatch?.[1] || output;
+  try {
+    const YAML = await import("yaml");
+    const parsed = YAML.parse(yamlContent);
+    if (!parsed.name || !parsed.nodes || !Array.isArray(parsed.nodes)) {
+      return null;
+    }
+    if (parsed.nodes.length < 2) {
+      return null;
+    }
+    parsed.version = parsed.version || "1.0";
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+// src/env/task/plugins/task-tag-plugin.ts
+var logger = createLogger("task:plugin:tag");
+
+class TaskTagPlugin extends TaskPlugin {
+  name = "TaskTagPlugin";
+  hooks = [
+    { point: TaskHookPoints.DELEGATE_BEFORE, priority: 20 },
+    { point: TaskHookPoints.OPERATION_AFTER_CREATE, priority: 10 }
+  ];
+  taskComponent = null;
+  agentComponent = null;
+  constructor(config = {}) {
+    super({ enabled: true, priority: 0, ...config });
+  }
+  static getRequiredAgents() {
+    return [createWorkflowExtractorAgent()];
+  }
+  setComponents(_llmComponent, taskComponent) {
+    this.taskComponent = taskComponent;
+    if (taskComponent?.env) {
+      this.agentComponent = taskComponent.env.getComponent("agent");
+    }
+  }
+  async execute(ctx) {
+    if (!this.config.enabled)
+      return;
+    switch (ctx.hookPoint) {
+      case TaskHookPoints.DELEGATE_BEFORE:
+        await this.onDelegateBefore(ctx);
+        break;
+      case TaskHookPoints.OPERATION_AFTER_CREATE:
+        await this.onOperationAfterCreate(ctx);
+        break;
+    }
+  }
+  async onDelegateBefore(ctx) {
+    const { taskId, tagService, prompt } = ctx.data;
+    if (!taskId || !this.taskComponent) {
+      return;
+    }
+    try {
+      const currentTask = await this.taskComponent.getTask(taskId);
+      if (!currentTask)
+        return;
+      const keywords = this.extractKeywords(currentTask);
+      if (keywords.length === 0)
+        return;
+      const tagServiceForSearch = tagService;
+      const similarTasks = await tagServiceForSearch?.findSimilarTasksByKeywords?.(keywords, {
+        limit: 5,
+        excludeTaskId: taskId
+      }) ?? [];
+      if (similarTasks.length === 0)
+        return;
+      const hint = this.formatSimilarTasks(similarTasks);
+      ctx.data.prompt = `${hint}
+
+---
+
+## 用户指令
+
+${prompt}`;
+      logger.info(`[TaskTagPlugin] Injected ${similarTasks.length} similar tasks`);
+    } catch (error) {
+      logger.warn(`[TaskTagPlugin] Similar tasks injection failed: ${error}`);
+    }
+  }
+  extractKeywords(task) {
+    const keywords = [];
+    if (task.tags?.length) {
+      keywords.push(...task.tags);
+    }
+    if (task.title) {
+      const words = task.title.split(/[\s\-_,，。、#]+/).filter((w) => w.length > 2 && !/^\d+$/.test(w)).slice(0, 5);
+      keywords.push(...words);
+    }
+    return keywords;
+  }
+  formatSimilarTasks(tasks) {
+    const lines = [
+      "## \uD83D\uDD0D 类似任务参考",
+      "",
+      "_提示：可通过 `task_get <id>` 获取详情，`task_operation_list <id>` 获取操作记录_",
+      ""
+    ];
+    for (const task of tasks) {
+      lines.push(`### Task #${task.id}`);
+      lines.push(`**Title**: ${task.title}`);
+      if (task.description) {
+        const desc = task.description.slice(0, 100);
+        lines.push(`**Description**: ${desc}${task.description.length > 100 ? "..." : ""}`);
+      }
+      if (task.goals_and_expected_deliverables) {
+        const goal = task.goals_and_expected_deliverables.slice(0, 100);
+        lines.push(`**Goal**: ${goal}${task.goals_and_expected_deliverables.length > 100 ? "..." : ""}`);
+      }
+      lines.push("");
+    }
+    return lines.join(`
+`);
+  }
+  async onOperationAfterCreate(ctx) {
+    const data = ctx.data;
+    const operation = data?.operation ?? data?.data?.operation;
+    if (!operation || operation?.actionType !== "completed")
+      return;
+    await this.extractWorkflow(operation.taskId, operation.sessionId);
+  }
+  async extractWorkflow(taskId, sessionId) {
+    try {
+      const task = await this.taskComponent?.getTask(taskId);
+      if (!task)
+        return;
+      const operations = await this.taskComponent?.listOperations({ taskId }) ?? [];
+      const allSessionIds = [...new Set([sessionId, ...operations.map((op) => op.sessionId).filter(Boolean)])];
+      const sessionComponent = this.taskComponent?.env?.getComponent("session");
+      const allMessages = [];
+      for (const sid of allSessionIds) {
+        try {
+          const ctx = await sessionComponent?.getContext(sid, { fullHistory: false, minUserMessages: 200 });
+          if (ctx?.messages)
+            allMessages.push(...ctx.messages);
+        } catch {}
+      }
+      if (!this.agentComponent)
+        return;
+      const input = formatExtractorInput({ task, operations, messages: allMessages });
+      const result = await this.agentComponent.run("workflow-extractor", input);
+      const workflowDef = await parseExtractorOutput(result.finalText || "");
+      if (!workflowDef)
+        return;
+      const workflowRepo = await this.getWorkflowRepository();
+      if (!workflowRepo)
+        return;
+      let version = workflowDef.version || "1.0";
+      const existingWf = workflowRepo.getByName(workflowDef.name);
+      if (existingWf) {
+        const parts = existingWf.version?.split(".") ?? ["1", "0"];
+        version = `${parts[0]}.${parseInt(parts[1] || "0") + 1}`;
+      }
+      const workflow = workflowRepo.create({
+        name: workflowDef.name,
+        version,
+        description: workflowDef.description,
+        definition: workflowDef,
+        config: workflowDef.config || {},
+        metadata: { author: "workflow-extractor", created_at: new Date().toISOString() },
+        tags: [`task:${taskId}`]
+      });
+      await this.taskComponent?.createOperation({
+        taskId,
+        sessionId,
+        actionType: "workflow_extracted",
+        actionTitle: `Workflow extracted: ${workflow.name}`,
+        actionDescription: workflow.id
+      });
+      logger.info(`Workflow extracted: ${workflow.id}`);
+    } catch (error) {
+      logger.warn(`Workflow extraction failed: ${error}`);
+    }
+  }
+  async getWorkflowRepository() {
+    const workflowComponent = this.taskComponent?.env?.getComponent("workflow");
+    if (workflowComponent?.workflowService?.workflowRepository) {
+      return workflowComponent.workflowService.workflowRepository;
+    }
+    if (!this._workflowRepo) {
+      try {
+        const sqlite = await import("./roy-agent-core-q779wnwm.js");
+        this.ensureDataDir();
+        const db = sqlite.getDatabase();
+        sqlite.initializeTables();
+        const { WorkflowRepository } = await import("./roy-agent-core-rft3fmp0.js");
+        this._workflowRepo = new WorkflowRepository(db);
+        return this._workflowRepo;
+      } catch {
+        return null;
+      }
+    }
+    return this._workflowRepo;
+  }
+  ensureDataDir() {
+    const { join } = __require("path");
+    const { mkdirSync, existsSync } = __require("fs");
+    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+    const dataDir = join(home, ".local", "share", "roy-agent");
+    if (!existsSync(dataDir))
+      mkdirSync(dataDir, { recursive: true });
+  }
+  _workflowRepo = null;
+}
+export { TaskPlugin, WORKFLOW_EXTRACTOR_PROMPT, createWorkflowExtractorAgent, formatExtractorInput, formatExtractorInputFromDescription, parseExtractorOutput, TaskTagPlugin };

package/dist/shared/@ai-setting/roy-agent-core-1ce3fqrk.js

@@ -0,0 +1,117 @@
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/decorators/decorator-node.ts
+class DecoratorNode {
+  type = "decorator";
+  id;
+  methodName;
+  instance;
+  dependsOn;
+  timeout;
+  retryConfig;
+  constructor(definition) {
+    const config = definition.config;
+    this.id = definition.id;
+    this.methodName = config._methodName;
+    this.instance = config._instance;
+    this.dependsOn = definition.depends_on || [];
+    this.timeout = definition.timeout;
+    this.retryConfig = definition.retry;
+  }
+  async execute(context) {
+    const startTime = Date.now();
+    const method = this.instance[this.methodName];
+    if (typeof method !== "function") {
+      return {
+        success: false,
+        error: `Method '${this.methodName}' is not a function`,
+        duration: Date.now() - startTime
+      };
+    }
+    const input = this.prepareInput(context);
+    const result = await this.executeWithRetry(input, context.abort);
+    return {
+      success: !result.error,
+      output: result.output,
+      error: result.error,
+      duration: Date.now() - startTime,
+      metadata: {
+        methodName: this.methodName
+      }
+    };
+  }
+  prepareInput(context) {
+    const nodeOutputs = context.nodeOutputs;
+    if (this.dependsOn.length === 0) {
+      return context.input || {};
+    }
+    const input = {};
+    for (const depId of this.dependsOn) {
+      const depOutput = nodeOutputs instanceof Map ? nodeOutputs.get(depId) : nodeOutputs?.[depId];
+      if (depOutput && typeof depOutput === "object") {
+        if ("output" in depOutput) {
+          input[depId] = depOutput.output;
+        } else {
+          input[depId] = depOutput;
+        }
+      }
+    }
+    return input;
+  }
+  async executeWithRetry(input, abort) {
+    const maxAttempts = this.retryConfig?.max_attempts ?? 1;
+    const backoff = this.retryConfig?.backoff ?? "exponential";
+    const initialDelay = this.retryConfig?.initial_delay ?? 1000;
+    let lastError;
+    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+      if (abort?.aborted) {
+        return { error: "Execution aborted" };
+      }
+      try {
+        const output = await this.executeWithTimeout(input, abort);
+        return { output };
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < maxAttempts) {
+          const delay = this.calculateBackoff(backoff, initialDelay, attempt - 1);
+          await this.sleep(delay, abort);
+        }
+      }
+    }
+    return { error: lastError?.message || "Unknown error" };
+  }
+  async executeWithTimeout(input, abort) {
+    if (!this.timeout) {
+      return this.instance[this.methodName](input);
+    }
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Execution timeout after ${this.timeout}ms`));
+      }, this.timeout);
+    });
+    return Promise.race([
+      this.instance[this.methodName](input),
+      timeoutPromise
+    ]);
+  }
+  calculateBackoff(backoff, initialDelay, attempt) {
+    if (backoff === "exponential") {
+      return initialDelay * Math.pow(2, attempt);
+    }
+    return initialDelay;
+  }
+  sleep(ms, abort) {
+    return new Promise((resolve) => {
+      const timeout = setTimeout(resolve, ms);
+      abort?.addEventListener("abort", () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+    });
+  }
+}
+var init_decorator_node = () => {};
+
+export { DecoratorNode, init_decorator_node };

package/dist/shared/@ai-setting/roy-agent-core-2dhd60aw.js

@@ -0,0 +1,11 @@
+// src/env/hook/types.ts
+function createHook(meta, fn) {
+  return {
+    ...meta,
+    execute: fn
+  };
+}
+function createPriorityHook(name, fn, priority) {
+  return createHook({ name, priority }, fn);
+}
+export { createHook, createPriorityHook };