@ai-setting/roy-agent-core 1.0.0

package/src/env/task/plugins/task-tag-plugin.test.ts

@@ -0,0 +1,377 @@
+/**
+ * @fileoverview TaskTagPlugin Tests
+ * 
+ * 测试覆盖（简化版）：
+ * 1. Hook 注册和执行
+ * 2. delegateBefore: 类似任务信息注入（仅 ID、描述、目标）
+ */
+
+import { describe, test, expect, vi, beforeEach } from "bun:test";
+import { TaskTagPlugin } from "./task-tag-plugin";
+import { TaskHookPoints } from "../hooks";
+import type { HookContext } from "../../hook/types";
+import type { TaskDelegateContext } from "../hooks/contexts";
+
+// Mock logger
+vi.mock("../../log-trace/logger", () => ({
+  createLogger: () => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+  }),
+}));
+
+describe("TaskTagPlugin", () => {
+  let plugin: TaskTagPlugin;
+  let mockTagService: any;
+  let mockTaskComponent: any;
+
+  beforeEach(() => {
+    plugin = new TaskTagPlugin();
+    
+    mockTagService = {
+      findSimilarTasksByKeywords: vi.fn().mockResolvedValue([]),
+    };
+    
+    mockTaskComponent = {
+      getTask: vi.fn(),
+      listOperations: vi.fn().mockResolvedValue([]),
+      createOperation: vi.fn(),
+      env: {
+        getComponent: vi.fn().mockReturnValue(null),
+      },
+    };
+    
+    plugin.setComponents(null, mockTaskComponent);
+  });
+
+  // ========================================================================
+  // Hook 注册测试
+  // ========================================================================
+
+  test("should have correct name and hooks", () => {
+    expect(plugin.name).toBe("TaskTagPlugin");
+    expect(plugin.hooks).toHaveLength(2);
+    expect(plugin.hooks.map(h => h.point)).toContain(TaskHookPoints.DELEGATE_BEFORE);
+    expect(plugin.hooks.map(h => h.point)).toContain(TaskHookPoints.OPERATION_AFTER_CREATE);
+  });
+
+  test("should have static getRequiredAgents method", () => {
+    expect(typeof (TaskTagPlugin as any).getRequiredAgents).toBe("function");
+    const agents = (TaskTagPlugin as any).getRequiredAgents();
+    expect(agents).toHaveLength(1);
+    expect(agents[0].name).toBe("workflow-extractor");
+  });
+
+  test("should skip execution when disabled", async () => {
+    const disabledPlugin = new TaskTagPlugin({ enabled: false });
+    disabledPlugin.setComponents(null, mockTaskComponent);
+    
+    const ctx: HookContext<TaskDelegateContext> = {
+      component: { name: "task", version: "1.0.0" },
+      data: {
+        taskId: 123,
+        prompt: "Test prompt",
+        subagentType: "general",
+        background: false,
+        tagService: mockTagService,
+      },
+      metadata: {},
+      phase: "before",
+      hookPoint: TaskHookPoints.DELEGATE_BEFORE,
+    };
+    
+    await disabledPlugin.execute(ctx);
+    
+    expect(mockTaskComponent.getTask).not.toHaveBeenCalled();
+  });
+
+  // ========================================================================
+  // delegateBefore 类似任务注入测试
+  // ========================================================================
+
+  test("should skip when no taskId", async () => {
+    const ctx: HookContext<TaskDelegateContext> = {
+      component: { name: "task", version: "1.0.0" },
+      data: {
+        taskId: undefined,
+        prompt: "Test prompt",
+        tagService: mockTagService,
+      },
+      metadata: {},
+      phase: "before",
+      hookPoint: TaskHookPoints.DELEGATE_BEFORE,
+    };
+    
+    await plugin.execute(ctx);
+    
+    expect(mockTaskComponent.getTask).not.toHaveBeenCalled();
+  });
+
+  test("should skip when task not found", async () => {
+    mockTaskComponent.getTask.mockResolvedValue(undefined);
+    
+    const ctx: HookContext<TaskDelegateContext> = {
+      component: { name: "task", version: "1.0.0" },
+      data: {
+        taskId: 123,
+        prompt: "Test prompt",
+        tagService: mockTagService,
+      },
+      metadata: {},
+      phase: "before",
+      hookPoint: TaskHookPoints.DELEGATE_BEFORE,
+    };
+    
+    await plugin.execute(ctx);
+    
+    expect(mockTagService.findSimilarTasksByKeywords).not.toHaveBeenCalled();
+  });
+
+  test("should skip when no keywords available", async () => {
+    mockTaskComponent.getTask.mockResolvedValue({
+      id: 123,
+      title: "123",
+      tags: undefined,
+    });
+    
+    const ctx: HookContext<TaskDelegateContext> = {
+      component: { name: "task", version: "1.0.0" },
+      data: {
+        taskId: 123,
+        prompt: "Test prompt",
+        tagService: mockTagService,
+      },
+      metadata: {},
+      phase: "before",
+      hookPoint: TaskHookPoints.DELEGATE_BEFORE,
+    };
+    
+    await plugin.execute(ctx);
+    
+    expect(mockTagService.findSimilarTasksByKeywords).not.toHaveBeenCalled();
+  });
+
+  test("should search using tags as keywords", async () => {
+    mockTaskComponent.getTask.mockResolvedValue({
+      id: 123,
+      title: "Fix login bug",
+      tags: ["bug", "authentication"],
+    });
+    
+    const ctx: HookContext<TaskDelegateContext> = {
+      component: { name: "task", version: "1.0.0" },
+      data: {
+        taskId: 123,
+        prompt: "Test prompt",
+        tagService: mockTagService,
+      },
+      metadata: {},
+      phase: "before",
+      hookPoint: TaskHookPoints.DELEGATE_BEFORE,
+    };
+    
+    await plugin.execute(ctx);
+    
+    expect(mockTagService.findSimilarTasksByKeywords).toHaveBeenCalledWith(
+      expect.arrayContaining(["bug", "authentication"]),
+      { limit: 5, excludeTaskId: 123 }
+    );
+  });
+
+  test("should search using title words as keywords", async () => {
+    mockTaskComponent.getTask.mockResolvedValue({
+      id: 123,
+      title: "Fix login bug",
+      tags: [],
+    });
+    
+    const ctx: HookContext<TaskDelegateContext> = {
+      component: { name: "task", version: "1.0.0" },
+      data: {
+        taskId: 123,
+        prompt: "Test prompt",
+        tagService: mockTagService,
+      },
+      metadata: {},
+      phase: "before",
+      hookPoint: TaskHookPoints.DELEGATE_BEFORE,
+    };
+    
+    await plugin.execute(ctx);
+    
+    expect(mockTagService.findSimilarTasksByKeywords).toHaveBeenCalledWith(
+      expect.arrayContaining(["login", "bug"]),
+      { limit: 5, excludeTaskId: 123 }
+    );
+  });
+
+  test("should skip when no similar tasks found", async () => {
+    mockTaskComponent.getTask.mockResolvedValue({
+      id: 123,
+      title: "Fix bug",
+      tags: ["bug"],
+    });
+    
+    const ctx: HookContext<TaskDelegateContext> = {
+      component: { name: "task", version: "1.0.0" },
+      data: {
+        taskId: 123,
+        prompt: "Test prompt",
+        tagService: mockTagService,
+      },
+      metadata: {},
+      phase: "before",
+      hookPoint: TaskHookPoints.DELEGATE_BEFORE,
+    };
+    
+    await plugin.execute(ctx);
+    
+    expect(ctx.data.prompt).toBe("Test prompt");
+  });
+
+  test("should inject similar tasks info (simplified)", async () => {
+    const similarTasks = [
+      { id: 10, title: "Fix similar bug #1", description: "Bug description", goals_and_expected_deliverables: "Goal 1" },
+      { id: 11, title: "Fix similar bug #2", description: "Another bug" },
+    ];
+    mockTaskComponent.getTask.mockResolvedValue({
+      id: 123,
+      title: "Fix bug",
+      tags: ["bug"],
+    });
+    mockTagService.findSimilarTasksByKeywords.mockResolvedValue(similarTasks);
+    
+    const ctx: HookContext<TaskDelegateContext> = {
+      component: { name: "task", version: "1.0.0" },
+      data: {
+        taskId: 123,
+        prompt: "Fix this bug",
+        subagentType: "general",
+        background: false,
+        tagService: mockTagService,
+      },
+      metadata: {},
+      phase: "before",
+      hookPoint: TaskHookPoints.DELEGATE_BEFORE,
+    };
+    
+    await plugin.execute(ctx);
+    
+    // 验证 prompt 被修改，包含类似任务信息
+    expect(ctx.data.prompt).toContain("类似任务参考");
+    expect(ctx.data.prompt).toContain("Task #10");
+    expect(ctx.data.prompt).toContain("Task #11");
+    expect(ctx.data.prompt).toContain("Description");
+    expect(ctx.data.prompt).toContain("Goal");
+    expect(ctx.data.prompt).toContain("task_operation_list"); // 提醒获取操作记录
+    expect(ctx.data.prompt).toContain("Fix this bug"); // 原 prompt 保留
+  });
+
+  // ========================================================================
+  // 关键词提取测试
+  // ========================================================================
+
+  test("should combine tags and title words", async () => {
+    mockTaskComponent.getTask.mockResolvedValue({
+      id: 123,
+      title: "Implement user authentication",
+      tags: ["backend", "security"],
+    });
+    
+    const ctx: HookContext<TaskDelegateContext> = {
+      component: { name: "task", version: "1.0.0" },
+      data: {
+        taskId: 123,
+        prompt: "Test prompt",
+        tagService: mockTagService,
+      },
+      metadata: {},
+      phase: "before",
+      hookPoint: TaskHookPoints.DELEGATE_BEFORE,
+    };
+    
+    await plugin.execute(ctx);
+    
+    const calledKeywords = mockTagService.findSimilarTasksByKeywords.mock.calls[0][0];
+    expect(calledKeywords).toContain("backend");
+    expect(calledKeywords).toContain("security");
+    expect(calledKeywords).toContain("user");
+    expect(calledKeywords).toContain("authentication");
+  });
+
+  test("should filter numeric-only title words", async () => {
+    mockTaskComponent.getTask.mockResolvedValue({
+      id: 123,
+      title: "Fix issue #1234",
+      tags: ["bug"],
+    });
+    
+    const ctx: HookContext<TaskDelegateContext> = {
+      component: { name: "task", version: "1.0.0" },
+      data: {
+        taskId: 123,
+        prompt: "Test prompt",
+        tagService: mockTagService,
+      },
+      metadata: {},
+      phase: "before",
+      hookPoint: TaskHookPoints.DELEGATE_BEFORE,
+    };
+    
+    await plugin.execute(ctx);
+    
+    const calledKeywords = mockTagService.findSimilarTasksByKeywords.mock.calls[0][0];
+    expect(calledKeywords).not.toContain("1234");
+    expect(calledKeywords).toContain("bug");
+  });
+
+  // ========================================================================
+  // 错误处理测试
+  // ========================================================================
+
+  test("should handle getTask error gracefully", async () => {
+    mockTaskComponent.getTask.mockRejectedValue(new Error("DB error"));
+    
+    const ctx: HookContext<TaskDelegateContext> = {
+      component: { name: "task", version: "1.0.0" },
+      data: {
+        taskId: 123,
+        prompt: "Test prompt",
+        tagService: mockTagService,
+      },
+      metadata: {},
+      phase: "before",
+      hookPoint: TaskHookPoints.DELEGATE_BEFORE,
+    };
+    
+    await plugin.execute(ctx);
+    
+    expect(ctx.data.prompt).toBe("Test prompt");
+  });
+
+  test("should handle search error gracefully", async () => {
+    mockTaskComponent.getTask.mockResolvedValue({
+      id: 123,
+      title: "Fix bug",
+      tags: ["bug"],
+    });
+    mockTagService.findSimilarTasksByKeywords.mockRejectedValue(new Error("Search error"));
+    
+    const ctx: HookContext<TaskDelegateContext> = {
+      component: { name: "task", version: "1.0.0" },
+      data: {
+        taskId: 123,
+        prompt: "Test prompt",
+        tagService: mockTagService,
+      },
+      metadata: {},
+      phase: "before",
+      hookPoint: TaskHookPoints.DELEGATE_BEFORE,
+    };
+    
+    await plugin.execute(ctx);
+    
+    expect(ctx.data.prompt).toBe("Test prompt");
+  });
+});

package/src/env/task/plugins/task-tag-plugin.ts

@@ -0,0 +1,319 @@
+/**
+ * @fileoverview TaskTagPlugin - 类似任务信息注入
+ * 
+ * Hook 逻辑实现：
+ * - delegateBefore: 注入类似任务信息（使用 keywords 检索，最多 5 个）
+ * - operationAfterCreate: 任务完成时提取 Workflow
+ * 
+ * 改造说明：
+ * - 移除 beforeCreate hook 中的 tag 替换逻辑
+ * - 移除 afterCreate hook 中的 tag 同步逻辑
+ * - 简化 delegateBefore：只注入任务 ID、描述和目标，不注入操作记录
+ * - 提示可通过 task_get 命令获取详细信息
+ */
+
+import { TaskPlugin, type TaskPluginConfig } from "./task-plugin";
+import type { HookContext } from "../../hook/types";
+import { TaskHookPoints } from "../hooks";
+import type { 
+  TaskDelegateContext,
+  TaskOperationCreateResultContext 
+} from "../hooks/contexts";
+import { createLogger } from "../../log-trace/logger";
+import type { AgentComponent } from "../../agent/agent-component";
+import type { SessionComponent } from "../../session/session-component";
+import {
+  createWorkflowExtractorAgent,
+  formatExtractorInput,
+  parseExtractorOutput,
+} from "./workflow-extractor-agent";
+import type { Task } from "../types";
+
+const logger = createLogger("task:plugin:tag");
+
+// ========================================================================
+// 接口定义
+// ========================================================================
+
+interface TaskComponentLike {
+  getTask(id: number): Promise<Task | undefined>;
+  listOperations(options: { taskId: number; limit?: number }): Promise<Array<{
+    id: number;
+    taskId: number;
+    actionType: string;
+    actionTitle: string;
+    actionDescription: string;
+  }>>;
+  createOperation(options: any): Promise<any>;
+  env?: {
+    getComponent(name: string): unknown;
+  };
+}
+
+interface TagServiceLike {
+  findSimilarTasksByKeywords(keywords: string[], options?: { limit?: number; excludeTaskId?: number }): Promise<Task[]>;
+}
+
+// ========================================================================
+// TaskTagPlugin
+// ========================================================================
+
+export class TaskTagPlugin extends TaskPlugin {
+  readonly name = "TaskTagPlugin";
+  readonly hooks = [
+    { point: TaskHookPoints.DELEGATE_BEFORE, priority: 20 },
+    { point: TaskHookPoints.OPERATION_AFTER_CREATE, priority: 10 },
+  ];
+  
+  private taskComponent: TaskComponentLike | null = null;
+  private agentComponent: AgentComponent | null = null;
+  
+  constructor(config: TaskPluginConfig = {}) {
+    super({ enabled: true, priority: 0, ...config });
+  }
+  
+  static getRequiredAgents() {
+    return [createWorkflowExtractorAgent()];
+  }
+  
+  setComponents(_llmComponent: unknown, taskComponent: TaskComponentLike | null): void {
+    this.taskComponent = taskComponent;
+    if (taskComponent?.env) {
+      this.agentComponent = taskComponent.env.getComponent("agent") as AgentComponent | null;
+    }
+  }
+  
+  async execute(ctx: any): Promise<void> {
+    if (!this.config.enabled) return;
+    
+    switch (ctx.hookPoint) {
+      case TaskHookPoints.DELEGATE_BEFORE:
+        await this.onDelegateBefore(ctx as HookContext<TaskDelegateContext>);
+        break;
+      case TaskHookPoints.OPERATION_AFTER_CREATE:
+        await this.onOperationAfterCreate(ctx as HookContext<TaskOperationCreateResultContext>);
+        break;
+    }
+  }
+  
+  // ========================================================================
+  // delegateBefore: 注入类似任务信息（简洁版）
+  // ========================================================================
+  
+  /**
+   * 委派前：注入类似任务信息
+   * 
+   * 1. 从 task.tags 和 title 提取关键词
+   * 2. 检索最多 5 个类似任务
+   * 3. 只注入任务 ID、描述和目标
+   * 4. 提示可通过 task_get 获取详细信息
+   */
+  private async onDelegateBefore(ctx: HookContext<TaskDelegateContext>): Promise<void> {
+    const { taskId, tagService, prompt } = ctx.data as any;
+    
+    if (!taskId || !this.taskComponent) {
+      return;
+    }
+    
+    try {
+      // 1. 获取当前 task
+      const currentTask = await this.taskComponent.getTask(taskId);
+      if (!currentTask) return;
+      
+      // 2. 提取关键词
+      const keywords = this.extractKeywords(currentTask);
+      if (keywords.length === 0) return;
+      
+      // 3. 检索类似任务（最多 5 个）
+      const tagServiceForSearch = tagService as TagServiceLike;
+      const similarTasks = await tagServiceForSearch?.findSimilarTasksByKeywords?.(keywords, {
+        limit: 5,
+        excludeTaskId: taskId,
+      }) ?? [];
+      
+      if (similarTasks.length === 0) return;
+      
+      // 4. 构建提示
+      const hint = this.formatSimilarTasks(similarTasks);
+      
+      // 5. 修改 prompt - 类似任务在前，用户指令在后
+      (ctx.data as any).prompt = `${hint}
+
+---
+
+## 用户指令
+
+${prompt}`;
+      
+      logger.info(`[TaskTagPlugin] Injected ${similarTasks.length} similar tasks`);
+    } catch (error) {
+      logger.warn(`[TaskTagPlugin] Similar tasks injection failed: ${error}`);
+    }
+  }
+  
+  /**
+   * 从 task 提取关键词
+   */
+  private extractKeywords(task: Task): string[] {
+    const keywords: string[] = [];
+    
+    // 添加 tags
+    if (task.tags?.length) {
+      keywords.push(...task.tags);
+    }
+    
+    // 从 title 提取有意义的词
+    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;
+  }
+  
+  /**
+   * 格式化类似任务（简洁版）
+   * 
+   * 注入格式：
+   * - Task ID: 用于引用和检索
+   * - Title: 任务标题
+   * - Description: 任务描述（截断至 100 字符）
+   * - Goal: 目标（截断至 100 字符）
+   * - 提醒：通过 task_get 和 task_operation_list 获取详细信息
+   */
+  private formatSimilarTasks(tasks: Task[]): string {
+    const lines = [
+      "## 🔍 类似任务参考",
+      "",
+      "_提示：可通过 `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("\n");
+  }
+  
+  // ========================================================================
+  // operationAfterCreate: 任务完成时提取 Workflow
+  // ========================================================================
+  
+  private async onOperationAfterCreate(ctx: HookContext<TaskOperationCreateResultContext>): Promise<void> {
+    const data = ctx.data as any;
+    const operation = data?.operation ?? data?.data?.operation;
+    
+    if (!operation || operation?.actionType !== "completed") return;
+    
+    await this.extractWorkflow(operation.taskId, operation.sessionId);
+  }
+  
+  private async extractWorkflow(taskId: number, sessionId?: string): Promise<void> {
+    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: any) => op.sessionId).filter(Boolean)])];
+      
+      const sessionComponent = this.taskComponent?.env?.getComponent("session") as SessionComponent | undefined;
+      const allMessages: any[] = [];
+      
+      for (const sid of allSessionIds) {
+        try {
+          const ctx = await sessionComponent?.getContext(sid, { fullHistory: false, minUserMessages: 200 });
+          if (ctx?.messages) allMessages.push(...ctx.messages);
+        } catch { /* skip */ }
+      }
+      
+      if (!this.agentComponent) return;
+      
+      const input = formatExtractorInput({ task, operations: operations as any, 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}`);
+    }
+  }
+  
+  private async getWorkflowRepository(): Promise<any> {
+    const workflowComponent = this.taskComponent?.env?.getComponent("workflow") as any;
+    if (workflowComponent?.workflowService?.workflowRepository) {
+      return workflowComponent.workflowService.workflowRepository;
+    }
+    
+    if (!this._workflowRepo) {
+      try {
+        const sqlite = await import("../../workflow/storage/sqlite");
+        this.ensureDataDir();
+        const db = sqlite.getDatabase();
+        sqlite.initializeTables();
+        const { WorkflowRepository } = await import("../../workflow/storage/workflow-repo");
+        this._workflowRepo = new WorkflowRepository(db);
+        return this._workflowRepo;
+      } catch {
+        return null;
+      }
+    }
+    return this._workflowRepo;
+  }
+  
+  private ensureDataDir(): void {
+    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 });
+  }
+  
+  private _workflowRepo: any = null;
+}