@ai-setting/roy-agent-core 1.4.12 → 1.4.14

package/dist/shared/@ai-setting/roy-agent-core-04fm8177.js

@@ -0,0 +1,393 @@
+import {
+  TaskHookPoints
+} from "./roy-agent-core-pzk1syce.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-yn761yve.js";
+import {
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// packages/core/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;
+  }
+}
+// packages/core/src/env/task/plugins/task-tag-plugin.ts
+init_logger();
+
+// packages/core/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;
+  }
+}
+
+// packages/core/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-qhyerewk.js");
+        this.ensureDataDir();
+        const db = sqlite.getDatabase();
+        sqlite.initializeTables();
+        const { WorkflowRepository } = await import("./roy-agent-core-4vmcvkav.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-04qgbjbe.js

@@ -0,0 +1,172 @@
+import {
+  createLogger,
+  getMaxOutput,
+  init_logger,
+  simplifyFilePath
+} from "./roy-agent-core-yn761yve.js";
+import {
+  getTracerProvider,
+  init_tracer_provider
+} from "./roy-agent-core-1k28kg7h.js";
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// packages/core/src/env/log-trace/decorator.ts
+function Traced(options) {
+  return function(target, propertyKey, descriptor) {
+    const originalFn = descriptor.value;
+    const spanName = options?.name || propertyKey;
+    descriptor.value = wrapFunction(originalFn, spanName, {
+      recordParams: options?.recordParams ?? true,
+      recordResult: options?.recordResult ?? false,
+      recordError: options?.recordError ?? true,
+      log: options?.log ?? false,
+      maxLogSize: options?.maxLogSize,
+      paramFilter: options?.paramFilter
+    });
+    return descriptor;
+  };
+}
+function TracedAs(name, options) {
+  return Traced({ name, ...options });
+}
+function TracedLightweight(options) {
+  return Traced({ recordParams: false, recordResult: false, log: options?.log ?? false, maxLogSize: options?.maxLogSize });
+}
+function wrapFunction(fn, name, options) {
+  const shouldLog = options?.log ?? false;
+  const getMaxLogSize = () => {
+    if (options?.maxLogSize !== undefined) {
+      return options.maxLogSize;
+    }
+    const configMaxOutput = getMaxOutput();
+    return configMaxOutput !== undefined ? configMaxOutput : 500;
+  };
+  const truncate = (obj) => {
+    if (obj === undefined)
+      return;
+    if (obj === null)
+      return null;
+    const maxLogSize = getMaxLogSize();
+    let str;
+    try {
+      str = typeof obj === "string" ? obj : JSON.stringify(obj, null, 0).replace(/\n/g, "");
+    } catch (e) {
+      str = `[Object with circular reference: ${e instanceof Error ? e.message : String(e)}]`;
+    }
+    if (maxLogSize > 0 && str.length > maxLogSize) {
+      return str.slice(0, maxLogSize) + " [TRUNCATED]";
+    }
+    try {
+      return JSON.parse(str);
+    } catch {
+      return str;
+    }
+  };
+  const truncateString = (obj) => {
+    if (obj === undefined)
+      return "undefined";
+    if (obj === null)
+      return "null";
+    const maxLogSize = getMaxLogSize();
+    let str;
+    try {
+      str = typeof obj === "string" ? obj : JSON.stringify(obj, null, 0).replace(/\n/g, "");
+    } catch (e) {
+      str = `[Object with circular reference: ${e instanceof Error ? e.message : String(e)}]`;
+    }
+    return maxLogSize > 0 && str.length > maxLogSize ? str.slice(0, maxLogSize) + " [TRUNCATED]" : str;
+  };
+  const TRACE_LOG_PREFIX = "[TRACE]";
+  const getCallerLocation = () => {
+    const originalLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 15;
+    const err = new Error;
+    Error.captureStackTrace(err, getCallerLocation);
+    const stack = err.stack?.split(`
+`) || [];
+    Error.stackTraceLimit = originalLimit;
+    for (let i = 1;i < stack.length; i++) {
+      const line = stack[i];
+      if (line.includes("decorator.ts") || line.includes("decorator.js") || line.includes("logFn") || line.includes("getCallerLocation"))
+        continue;
+      const match = line.match(/at\s+.+\s+\((.+):(\d+):\d+\)/) || line.match(/at\s+(.+):(\d+):\d+/);
+      if (match) {
+        const filePath = match[1];
+        if (!filePath || filePath === "native")
+          continue;
+        const relativePath = simplifyFilePath(filePath);
+        return `${relativePath}:${match[2]}`;
+      }
+    }
+    return "";
+  };
+  const logFn = (event, argsOrData, callerLocation) => {
+    if (!shouldLog)
+      return;
+    const logger = createLogger("traced:" + name);
+    const tag = event === "enter" ? ">>>" : event === "quit" ? "<<<" : "!!!";
+    const prefix = `${TRACE_LOG_PREFIX} ${tag} ${name}`;
+    const originalFnLocation = callerLocation || getCallerLocation();
+    const logMessage = (msg, data) => {
+      if (data !== undefined) {
+        logger.info(`${prefix} ${msg}: ${truncateString(data)}`, { callerLocation: originalFnLocation });
+      } else {
+        logger.info(`${prefix} ${msg}`, { callerLocation: originalFnLocation });
+      }
+    };
+    if (event === "enter") {
+      logMessage("enter", argsOrData);
+    } else if (event === "quit") {
+      logMessage("quit", options?.recordResult ? argsOrData : undefined);
+    } else {
+      logMessage("error", argsOrData);
+    }
+  };
+  return function(...args) {
+    const tracer = getTracerProvider().getTracer("roy-tracer");
+    const attributes = {};
+    if (options?.recordParams !== false) {
+      if (options?.paramFilter) {
+        attributes["params"] = truncate(options.paramFilter(args));
+      } else {
+        attributes["params"] = truncate(args);
+      }
+    }
+    const callerLocation = getCallerLocation();
+    logFn("enter", args, callerLocation);
+    const span = tracer.startSpan(name, { attributes });
+    try {
+      const result = fn.call(this, ...args);
+      if (result && typeof result === "object" && typeof result.then === "function") {
+        return result.then((resolved) => {
+          span.setAttribute("result", JSON.stringify(truncate(resolved)));
+          span.end(resolved);
+          logFn("quit", options?.recordResult ? resolved : undefined, callerLocation);
+          return resolved;
+        }, (rejected) => {
+          span.setAttribute("error", String(rejected));
+          span.end(undefined, rejected instanceof Error ? rejected : new Error(String(rejected)));
+          logFn("error", rejected.message, callerLocation);
+          throw rejected;
+        });
+      }
+      span.setAttribute("result", JSON.stringify(truncate(result)));
+      span.end(result);
+      logFn("quit", options?.recordResult ? result : undefined, callerLocation);
+      return result;
+    } catch (error) {
+      span.setAttribute("error", String(error));
+      span.end(undefined, error instanceof Error ? error : new Error(String(error)));
+      logFn("error", error.message, callerLocation);
+      throw error;
+    }
+  };
+}
+var init_decorator = __esm(() => {
+  init_tracer_provider();
+  init_logger();
+});
+
+export { Traced, TracedAs, TracedLightweight, wrapFunction, init_decorator };

package/dist/shared/@ai-setting/roy-agent-core-084qqd7t.js

@@ -0,0 +1,11 @@
+// packages/core/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 };