@ai-setting/roy-agent-core 1.0.0

package/src/env/task/task-config-registration.ts

@@ -0,0 +1,37 @@
+/**
+ * @fileoverview Task Component 配置注册
+ * 
+ * 使用 ConfigComponent.registerComponent() 机制统一管理配置
+ */
+
+import type { ComponentRegistration } from "../../config/config-component";
+
+/**
+ * Task Component 默认配置值
+ * 
+ * 注意：键使用完整格式（带 "task." 前缀），在 registerConfig 中手动设置
+ * 注意：dbPath 的默认值由 SQLiteTaskStore 决定，放在这里是为了让 show-config 能显示
+ */
+export const TASK_DEFAULTS: Record<string, unknown> = {
+  "task.storage.type": "sqlite",
+  "task.storage.dbPath": undefined, // 由 SQLiteTaskStore 使用默认路径
+};
+
+/**
+ * Task Component 配置注册常量
+ * 
+ * 定义了所有 Task 相关的配置项和来源
+ */
+export const TASK_CONFIG_REGISTRATION: ComponentRegistration = {
+  name: "task",
+  
+  sources: [
+    { type: "env", envPrefix: "TASK", priority: 20, watch: false },
+  ],
+  
+  keys: [
+    { key: "task.storage.type", sources: ["env", "file"] },
+    { key: "task.storage.dbPath", sources: ["env", "file"] },
+  ],
+  // 注意：不使用 defaults 字段，默认值在 registerConfig 中手动 set
+};

package/src/env/task/task-types.test.ts

@@ -0,0 +1,137 @@
+/**
+ * @fileoverview Task Types Tests
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+  TaskStatusEnum,
+  TaskPriorityEnum,
+  ActionTypeEnum,
+  Task,
+  TaskOperation,
+} from "./types";
+
+describe("Task Types", () => {
+  describe("TaskStatusEnum", () => {
+    it("should accept valid status values", () => {
+      expect(TaskStatusEnum.parse("todo")).toBe("todo");
+      expect(TaskStatusEnum.parse("active")).toBe("active");
+      expect(TaskStatusEnum.parse("completed")).toBe("completed");
+      expect(TaskStatusEnum.parse("paused")).toBe("paused");
+      expect(TaskStatusEnum.parse("cancelled")).toBe("cancelled");
+    });
+
+    it("should reject invalid status values", () => {
+      expect(() => TaskStatusEnum.parse("invalid")).toThrow();
+      expect(() => TaskStatusEnum.parse("pending")).toThrow();
+    });
+  });
+
+  describe("TaskPriorityEnum", () => {
+    it("should accept valid priority values", () => {
+      expect(TaskPriorityEnum.parse("low")).toBe("low");
+      expect(TaskPriorityEnum.parse("medium")).toBe("medium");
+      expect(TaskPriorityEnum.parse("high")).toBe("high");
+    });
+
+    it("should reject invalid priority values", () => {
+      expect(() => TaskPriorityEnum.parse("urgent")).toThrow();
+      expect(() => TaskPriorityEnum.parse("critical")).toThrow();
+    });
+  });
+
+  describe("ActionTypeEnum", () => {
+    it("should accept valid action types", () => {
+      expect(ActionTypeEnum.parse("create")).toBe("create");
+      expect(ActionTypeEnum.parse("progress")).toBe("progress");
+      expect(ActionTypeEnum.parse("milestone")).toBe("milestone");
+      expect(ActionTypeEnum.parse("problem")).toBe("problem");
+      expect(ActionTypeEnum.parse("solution")).toBe("solution");
+      expect(ActionTypeEnum.parse("decision")).toBe("decision");
+      expect(ActionTypeEnum.parse("review")).toBe("review");
+      expect(ActionTypeEnum.parse("completed")).toBe("completed");
+    });
+
+    it("should reject invalid action types", () => {
+      expect(() => ActionTypeEnum.parse("update")).toThrow();
+      expect(() => ActionTypeEnum.parse("delete")).toThrow();
+    });
+  });
+
+  describe("Task interface", () => {
+    it("should have correct structure", () => {
+      const task: Task = {
+        id: 1,
+        title: "Test Task",
+        description: "Description",
+        status: "todo",
+        priority: "high",
+        progress: 0,
+        current_status: "",
+        goals_and_expected_deliverables: "",
+        createdAt: "2026-04-01T00:00:00.000Z",
+        updatedAt: "2026-04-01T00:00:00.000Z",
+      };
+
+      expect(task.id).toBe(1);
+      expect(task.title).toBe("Test Task");
+      expect(task.status).toBe("todo");
+    });
+
+    it("should allow optional fields", () => {
+      const task: Task = {
+        id: 1,
+        title: "Test Task",
+        description: "",
+        status: "todo",
+        priority: "medium",
+        progress: 0,
+        current_status: "",
+        goals_and_expected_deliverables: "",
+        createdAt: "2026-04-01T00:00:00.000Z",
+        updatedAt: "2026-04-01T00:00:00.000Z",
+        parent_task_id: 5,
+        due_date: "2026-04-30T00:00:00.000Z",
+        tags: ["feature", "urgent"],
+      };
+
+      expect(task.parent_task_id).toBe(5);
+      expect(task.due_date).toBe("2026-04-30T00:00:00.000Z");
+      expect(task.tags).toEqual(["feature", "urgent"]);
+    });
+  });
+
+  describe("TaskOperation interface", () => {
+    it("should have correct structure with required sessionId", () => {
+      const op: TaskOperation = {
+        id: 1,
+        taskId: 100,
+        sessionId: "sess_abc123",  // 必填！
+        actionType: "create",
+        actionTitle: "Task created",
+        actionDescription: "",
+        timestamp: "2026-04-01T00:00:00.000Z",
+      };
+
+      expect(op.id).toBe(1);
+      expect(op.taskId).toBe(100);
+      expect(op.sessionId).toBe("sess_abc123");
+      expect(op.actionType).toBe("create");
+    });
+
+    it("should allow optional mdPath", () => {
+      const op: TaskOperation = {
+        id: 1,
+        taskId: 100,
+        sessionId: "sess_abc123",
+        actionType: "progress",
+        actionTitle: "Made progress",
+        actionDescription: "Completed feature X",
+        timestamp: "2026-04-01T00:00:00.000Z",
+        mdPath: "/path/to/operation.md",
+      };
+
+      expect(op.mdPath).toBe("/path/to/operation.md");
+    });
+  });
+});

package/src/env/task/tools/complete-tool.ts

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview Task Complete Tool
+ */
+
+import type { Tool, ToolContext, ToolResult } from "../../tool/types";
+import { DeleteTaskToolSchema } from "./task-types";
+import type { TaskComponent } from "../task-component";
+
+export function completeTaskTool(taskComponent: TaskComponent): Tool {
+  return {
+    name: "task_complete",
+    description: "Mark a task as completed (progress=100, status=completed). Creates an operation record.",
+    parameters: DeleteTaskToolSchema, // reuse same schema
+    execute: async (args: unknown, ctx: ToolContext): Promise<ToolResult> => {
+      const params = DeleteTaskToolSchema.parse(args);
+      const sessionId = ctx.session_id || "unknown";
+      
+      try {
+        const task = await taskComponent.completeTask(params.task_id, sessionId);
+        if (!task) {
+          return { 
+            success: false, 
+            output: "", 
+            error: `Task not found: ${params.task_id}`,
+            metadata: { execution_time_ms: 0 },
+          };
+        }
+        
+        return {
+          success: true,
+          output: `Task completed: #${task.id} - ${task.title}`,
+          metadata: { execution_time_ms: 0, task },
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 },
+        };
+      }
+    },
+  };
+}

package/src/env/task/tools/create-tool.ts

@@ -0,0 +1,49 @@
+/**
+ * @fileoverview Task Create Tool
+ */
+
+import type { Tool, ToolContext, ToolResult } from "../../tool/types";
+import { CreateTaskToolSchema, type CreateTaskToolParams } from "./task-types";
+import type { TaskComponent } from "../task-component";
+
+export function createTaskTool(taskComponent: TaskComponent): Tool {
+  return {
+    name: "task_create",
+    description: "Create a new task. The task will be associated with the current session.",
+    parameters: CreateTaskToolSchema,
+    execute: async (args: unknown, ctx: ToolContext): Promise<ToolResult> => {
+      const params = CreateTaskToolSchema.parse(args) as CreateTaskToolParams;
+      const sessionId = ctx.session_id || "unknown";
+      
+      try {
+        const task = await taskComponent.createTask({
+          title: params.title,
+          description: params.description,
+          priority: params.priority,
+          goals_and_expected_deliverables: params.goals_and_expected_deliverables,
+          due_date: params.due_date,
+          tags: params.tags,
+          sessionId,
+        });
+        
+        return {
+          success: true,
+          output: `Task created successfully: #${task.id} - ${task.title}`,
+          metadata: {
+            execution_time_ms: 0,
+            task_id: task.id,
+            status: task.status,
+            createdAt: task.createdAt,
+          },
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 },
+        };
+      }
+    },
+  };
+}

package/src/env/task/tools/delete-tool.ts

@@ -0,0 +1,43 @@
+/**
+ * @fileoverview Task Delete Tool
+ */
+
+import type { Tool, ToolContext, ToolResult } from "../../tool/types";
+import { DeleteTaskToolSchema, type DeleteTaskToolParams } from "./task-types";
+import type { TaskComponent } from "../task-component";
+
+export function deleteTaskTool(taskComponent: TaskComponent): Tool {
+  return {
+    name: "task_delete",
+    description: "Delete a task and all its operation records.",
+    parameters: DeleteTaskToolSchema,
+    execute: async (args: unknown, ctx: ToolContext): Promise<ToolResult> => {
+      const params = DeleteTaskToolSchema.parse(args) as DeleteTaskToolParams;
+      
+      try {
+        const deleted = await taskComponent.deleteTask(params.task_id);
+        if (!deleted) {
+          return { 
+            success: false, 
+            output: "", 
+            error: `Task not found: ${params.task_id}`,
+            metadata: { execution_time_ms: 0 },
+          };
+        }
+        
+        return {
+          success: true,
+          output: `Task deleted: #${params.task_id}`,
+          metadata: { execution_time_ms: 0 },
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 },
+        };
+      }
+    },
+  };
+}

package/src/env/task/tools/get-tool.ts

@@ -0,0 +1,59 @@
+/**
+ * @fileoverview Task Get Tool
+ */
+
+import type { Tool, ToolContext, ToolResult } from "../../tool/types";
+import { GetTaskToolSchema, type GetTaskToolParams } from "./task-types";
+import type { TaskComponent } from "../task-component";
+
+export function getTaskTool(taskComponent: TaskComponent): Tool {
+  return {
+    name: "task_get",
+    description: "Get task details by ID. Optionally include operation records.",
+    parameters: GetTaskToolSchema,
+    execute: async (args: unknown, ctx: ToolContext): Promise<ToolResult> => {
+      const params = GetTaskToolSchema.parse(args) as GetTaskToolParams;
+      
+      try {
+        if (params.include_operations) {
+          const result = await taskComponent.getTaskWithOperations(params.task_id);
+          if (!result) {
+            return { 
+              success: false, 
+              output: "", 
+              error: `Task not found: ${params.task_id}`,
+              metadata: { execution_time_ms: 0 },
+            };
+          }
+          return {
+            success: true,
+            output: JSON.stringify(result, null, 2),
+            metadata: { execution_time_ms: 0 },
+          };
+        } else {
+          const task = await taskComponent.getTask(params.task_id);
+          if (!task) {
+            return { 
+              success: false, 
+              output: "", 
+              error: `Task not found: ${params.task_id}`,
+              metadata: { execution_time_ms: 0 },
+            };
+          }
+          return { 
+            success: true, 
+            output: JSON.stringify(task, null, 2),
+            metadata: { execution_time_ms: 0 },
+          };
+        }
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 },
+        };
+      }
+    },
+  };
+}

package/src/env/task/tools/index.ts

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview Task Tools Index
+ */
+
+export { createTaskTool } from "./create-tool";
+export { getTaskTool } from "./get-tool";
+export { listTasksTool } from "./list-tool";
+export { updateTaskTool } from "./update-tool";
+export { deleteTaskTool } from "./delete-tool";
+export { completeTaskTool } from "./complete-tool";

package/src/env/task/tools/list-tool.ts

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview Task List Tool
+ */
+
+import type { Tool, ToolContext, ToolResult } from "../../tool/types";
+import { ListTasksToolSchema, type ListTasksToolParams } from "./task-types";
+import type { TaskComponent } from "../task-component";
+
+export function listTasksTool(taskComponent: TaskComponent): Tool {
+  return {
+    name: "task_list",
+    description: "List tasks with optional filters for status and priority.",
+    parameters: ListTasksToolSchema,
+    execute: async (args: unknown, ctx: ToolContext): Promise<ToolResult> => {
+      const params = ListTasksToolSchema.parse(args) as ListTasksToolParams;
+      
+      try {
+        const tasks = await taskComponent.listTasks({
+          status: params.status,
+          priority: params.priority,
+          limit: params.limit,
+          offset: params.offset,
+        });
+        
+        return {
+          success: true,
+          output: JSON.stringify({ tasks, count: tasks.length }),
+          metadata: { execution_time_ms: 0 },
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 },
+        };
+      }
+    },
+  };
+}

package/src/env/task/tools/operation/create-tool.ts

@@ -0,0 +1,48 @@
+/**
+ * @fileoverview Operation Create Tool
+ */
+
+import type { Tool, ToolContext, ToolResult } from "../../../tool/types";
+import { CreateOperationToolSchema, type CreateOperationToolParams } from "./operation-types";
+import type { TaskComponent } from "../../task-component";
+
+export function createOperationTool(taskComponent: TaskComponent): Tool {
+  return {
+    name: "task_operation_create",
+    description: "Create an operation record for a task. Tracks progress, milestones, problems, etc.",
+    parameters: CreateOperationToolSchema,
+    execute: async (args: unknown, ctx: ToolContext): Promise<ToolResult> => {
+      const params = CreateOperationToolSchema.parse(args) as CreateOperationToolParams;
+      const sessionId = ctx.session_id || "unknown";
+      
+      try {
+        const operation = await taskComponent.createOperation({
+          taskId: params.task_id,
+          sessionId,
+          actionType: params.action_type,
+          actionTitle: params.action_title,
+          actionDescription: params.action_description,
+          mdPath: params.md_path,
+        });
+        
+        return {
+          success: true,
+          output: `Operation created: #${operation.id} for task #${operation.taskId}`,
+          metadata: {
+            execution_time_ms: 0,
+            operation_id: operation.id,
+            task_id: operation.taskId,
+            session_id: operation.sessionId,
+          },
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 },
+        };
+      }
+    },
+  };
+}

package/src/env/task/tools/operation/delete-tool.ts

@@ -0,0 +1,43 @@
+/**
+ * @fileoverview Operation Delete Tool
+ */
+
+import type { Tool, ToolContext, ToolResult } from "../../../tool/types";
+import { DeleteOperationToolSchema, type DeleteOperationToolParams } from "./operation-types";
+import type { TaskComponent } from "../../task-component";
+
+export function deleteOperationTool(taskComponent: TaskComponent): Tool {
+  return {
+    name: "task_operation_delete",
+    description: "Delete an operation record.",
+    parameters: DeleteOperationToolSchema,
+    execute: async (args: unknown, ctx: ToolContext): Promise<ToolResult> => {
+      const params = DeleteOperationToolSchema.parse(args) as DeleteOperationToolParams;
+      
+      try {
+        const deleted = await taskComponent.deleteOperation(params.operation_id);
+        if (!deleted) {
+          return { 
+            success: false, 
+            output: "", 
+            error: `Operation not found: ${params.operation_id}`,
+            metadata: { execution_time_ms: 0 },
+          };
+        }
+        
+        return {
+          success: true,
+          output: `Operation deleted: #${params.operation_id}`,
+          metadata: { execution_time_ms: 0 },
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 },
+        };
+      }
+    },
+  };
+}

package/src/env/task/tools/operation/get-tool.ts

@@ -0,0 +1,43 @@
+/**
+ * @fileoverview Operation Get Tool
+ */
+
+import type { Tool, ToolContext, ToolResult } from "../../../tool/types";
+import { GetOperationToolSchema, type GetOperationToolParams } from "./operation-types";
+import type { TaskComponent } from "../../task-component";
+
+export function getOperationTool(taskComponent: TaskComponent): Tool {
+  return {
+    name: "task_operation_get",
+    description: "Get a single operation record by ID.",
+    parameters: GetOperationToolSchema,
+    execute: async (args: unknown, ctx: ToolContext): Promise<ToolResult> => {
+      const params = GetOperationToolSchema.parse(args) as GetOperationToolParams;
+      
+      try {
+        const operation = await taskComponent.getOperation(params.operation_id);
+        if (!operation) {
+          return { 
+            success: false, 
+            output: "", 
+            error: `Operation not found: ${params.operation_id}`,
+            metadata: { execution_time_ms: 0 },
+          };
+        }
+        
+        return { 
+          success: true, 
+          output: JSON.stringify(operation, null, 2),
+          metadata: { execution_time_ms: 0 },
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 },
+        };
+      }
+    },
+  };
+}

package/src/env/task/tools/operation/index.ts

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview Operation Tools Index
+ */
+
+export { createOperationTool } from "./create-tool";
+export { getOperationTool } from "./get-tool";
+export { listOperationsTool } from "./list-tool";
+export { updateOperationTool } from "./update-tool";
+export { deleteOperationTool } from "./delete-tool";

package/src/env/task/tools/operation/list-tool.ts

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview Operation List Tool
+ */
+
+import type { Tool, ToolContext, ToolResult } from "../../../tool/types";
+import { ListOperationsToolSchema, type ListOperationsToolParams } from "./operation-types";
+import type { TaskComponent } from "../../task-component";
+
+export function listOperationsTool(taskComponent: TaskComponent): Tool {
+  return {
+    name: "task_operation_list",
+    description: "List operation records for a task with optional filters.",
+    parameters: ListOperationsToolSchema,
+    execute: async (args: unknown, ctx: ToolContext): Promise<ToolResult> => {
+      const params = ListOperationsToolSchema.parse(args) as ListOperationsToolParams;
+      
+      try {
+        const operations = await taskComponent.listOperations({
+          taskId: params.task_id,
+          actionType: params.action_type,
+          limit: params.limit,
+          offset: params.offset,
+        });
+        
+        return {
+          success: true,
+          output: JSON.stringify({ operations, count: operations.length }),
+          metadata: { execution_time_ms: 0 },
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 },
+        };
+      }
+    },
+  };
+}