@ai-setting/roy-agent-core 1.5.15-test → 1.5.17-beta.1

package/dist/shared/@ai-setting/roy-agent-core-3jywqmdd.js

@@ -0,0 +1,393 @@
+import {
+  TaskHookPoints
+} from "./roy-agent-core-92z6t4he.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-44hnfb02.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-wft9ra24.js");
+        this.ensureDataDir();
+        const db = sqlite.getDatabase();
+        sqlite.initializeTables();
+        const { WorkflowRepository } = await import("./roy-agent-core-bcbqy27c.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-3rr5k71j.js

@@ -0,0 +1,200 @@
+import {
+  getDatabase
+} from "./roy-agent-core-zpn0bqa8.js";
+import {
+  exports_search_query_parser,
+  init_search_query_parser
+} from "./roy-agent-core-rvxg1wps.js";
+import {
+  __toCommonJS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/storage/workflow-repo.ts
+import { randomUUID } from "crypto";
+function rowToWorkflow(row) {
+  const metadata = JSON.parse(row.metadata);
+  if (row.task_id !== null) {
+    metadata.taskId = row.task_id;
+  }
+  return {
+    id: row.id,
+    name: row.name,
+    version: row.version,
+    description: row.description || undefined,
+    definition: JSON.parse(row.definition),
+    config: JSON.parse(row.config),
+    metadata,
+    tags: JSON.parse(row.tags),
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at)
+  };
+}
+
+class WorkflowRepository {
+  db;
+  constructor(db) {
+    this.db = db || getDatabase();
+  }
+  create(workflow) {
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    const stmt = this.db.prepare(`
+      INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, task_id, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(id, workflow.name, workflow.version, workflow.description || null, JSON.stringify(workflow.definition), JSON.stringify(workflow.config), JSON.stringify(workflow.metadata), JSON.stringify(workflow.tags), workflow.metadata?.taskId || null, now, now);
+    return {
+      ...workflow,
+      id,
+      createdAt: new Date(now),
+      updatedAt: new Date(now)
+    };
+  }
+  createFromDefinition(definition, options) {
+    const workflow = {
+      name: definition.name,
+      version: definition.version,
+      description: definition.description,
+      definition,
+      config: options?.config || definition.config || {},
+      metadata: options?.metadata || definition.metadata || {},
+      tags: options?.tags || definition.metadata?.tags || []
+    };
+    return this.create(workflow);
+  }
+  getById(id) {
+    const row = this.db.prepare("SELECT * FROM workflows WHERE id = ?").get(id);
+    if (!row)
+      return;
+    return rowToWorkflow(row);
+  }
+  getByName(name) {
+    const row = this.db.prepare("SELECT * FROM workflows WHERE name = ? ORDER BY updated_at DESC LIMIT 1").get(name);
+    if (!row)
+      return;
+    return rowToWorkflow(row);
+  }
+  getByNameAndVersion(name, version) {
+    const row = this.db.prepare("SELECT * FROM workflows WHERE name = ? AND version = ?").get(name, version);
+    if (!row)
+      return;
+    return rowToWorkflow(row);
+  }
+  list(options) {
+    let sql = "SELECT * FROM workflows";
+    const params = [];
+    const conditions = [];
+    if (options?.tag) {
+      conditions.push("tags LIKE ?");
+      params.push(`%${options.tag}%`);
+    }
+    if (options?.taskId !== undefined) {
+      conditions.push("task_id = ?");
+      params.push(options.taskId);
+    }
+    if (conditions.length > 0) {
+      sql += " WHERE " + conditions.join(" AND ");
+    }
+    const orderBy = options?.orderBy || "updated_at";
+    const order = options?.order || "desc";
+    sql += ` ORDER BY ${orderBy} ${order.toUpperCase()}`;
+    if (options?.limit !== undefined) {
+      sql += " LIMIT ?";
+      params.push(options.limit);
+    }
+    if (options?.offset !== undefined) {
+      sql += " OFFSET ?";
+      params.push(options.offset);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    let workflows = rows.map(rowToWorkflow);
+    if (options?.search) {
+      const { parseSearchQuery, matchesQuery } = (init_search_query_parser(), __toCommonJS(exports_search_query_parser));
+      const query = parseSearchQuery(options.search);
+      workflows = workflows.filter((w) => {
+        const descMatch = w.description ? matchesQuery(w.description, query) : false;
+        const tagsMatch = w.tags.some((tag) => matchesQuery(tag, query));
+        return descMatch || tagsMatch;
+      });
+    }
+    return workflows;
+  }
+  listVersions(name) {
+    const rows = this.db.prepare("SELECT * FROM workflows WHERE name = ? ORDER BY version DESC").all(name);
+    return rows.map(rowToWorkflow);
+  }
+  update(id, updates) {
+    const existing = this.getById(id);
+    if (!existing)
+      return;
+    const now = new Date().toISOString();
+    const setClauses = ["updated_at = ?"];
+    const params = [now];
+    if (updates.name !== undefined) {
+      setClauses.push("name = ?");
+      params.push(updates.name);
+    }
+    if (updates.version !== undefined) {
+      setClauses.push("version = ?");
+      params.push(updates.version);
+    }
+    if (updates.description !== undefined) {
+      setClauses.push("description = ?");
+      params.push(updates.description);
+    }
+    if (updates.definition !== undefined) {
+      setClauses.push("definition = ?");
+      params.push(JSON.stringify(updates.definition));
+    }
+    if (updates.config !== undefined) {
+      setClauses.push("config = ?");
+      params.push(JSON.stringify(updates.config));
+    }
+    if (updates.metadata !== undefined) {
+      setClauses.push("metadata = ?");
+      params.push(JSON.stringify(updates.metadata));
+      if (updates.metadata.taskId !== undefined) {
+        setClauses.push("task_id = ?");
+        params.push(updates.metadata.taskId);
+      }
+    }
+    if (updates.tags !== undefined) {
+      setClauses.push("tags = ?");
+      params.push(JSON.stringify(updates.tags));
+    }
+    params.push(id);
+    this.db.prepare(`UPDATE workflows SET ${setClauses.join(", ")} WHERE id = ?`).run(...params);
+    return this.getById(id);
+  }
+  delete(id) {
+    const existing = this.getById(id);
+    if (!existing)
+      return false;
+    this.db.prepare("DELETE FROM workflows WHERE id = ?").run(id);
+    return true;
+  }
+  exists(id) {
+    const result = this.db.prepare("SELECT 1 FROM workflows WHERE id = ?").get(id);
+    return result !== undefined;
+  }
+  existsByNameAndVersion(name, version) {
+    const result = this.db.prepare("SELECT 1 FROM workflows WHERE name = ? AND version = ?").get(name, version);
+    return result !== undefined;
+  }
+  count() {
+    const result = this.db.prepare("SELECT COUNT(*) as count FROM workflows").get();
+    return result.count;
+  }
+  search(query, limit) {
+    let sql = "SELECT * FROM workflows WHERE name LIKE ? ORDER BY updated_at DESC";
+    const params = [`%${query}%`];
+    if (limit !== undefined) {
+      sql += " LIMIT ?";
+      params.push(limit);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map(rowToWorkflow);
+  }
+}
+
+export { rowToWorkflow, WorkflowRepository };