@ai-setting/roy-agent-core 1.3.9 → 1.3.11

package/src/env/task/tools/operation/operation-tools.test.ts

@@ -1,274 +0,0 @@
-/**
- * @fileoverview Operation Tools Tests
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { TaskComponent } from "../../task-component";
-import { ConfigComponent } from "../../../../config/config-component";
-import { tmpdir } from "os";
-import { join } from "path";
-import { createTaskTool } from "../create-tool";
-import { 
-  createOperationTool, 
-  getOperationTool, 
-  listOperationsTool, 
-  updateOperationTool, 
-  deleteOperationTool 
-} from "./index";
-
-describe("Operation Tools", () => {
-  let taskComponent: TaskComponent;
-  let taskId: number;
-  
-  beforeEach(async () => {
-    const configComponent = new ConfigComponent();
-    taskComponent = new TaskComponent();
-    await taskComponent.init({
-      options: {
-        configComponent,
-        config: {
-          storage: {
-            type: "sqlite",
-            dbPath: join(tmpdir(), `operation-tools-test-${Date.now()}.db`),
-          },
-        },
-      },
-    });
-    
-    // Create a task for testing operations
-    const createTool = createTaskTool(taskComponent);
-    const result = await createTool.execute(
-      { title: "Test Task" },
-      { session_id: "sess_123" }
-    );
-    taskId = result.metadata?.task_id as number;
-  });
-  
-  afterEach(async () => {
-    await taskComponent.stop();
-  });
-  
-  describe("task_operation_create", () => {
-    it("should create an operation record", async () => {
-      const tool = createOperationTool(taskComponent);
-      const result = await tool.execute(
-        {
-          task_id: taskId,
-          action_type: "progress",
-          action_title: "Made progress",
-          action_description: "Completed feature X",
-        },
-        { session_id: "sess_456" }
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.output).toContain("Operation created");
-      expect(result.metadata?.operation_id).toBeGreaterThan(0);
-      expect(result.metadata?.session_id).toBe("sess_456");
-    });
-    
-    it("should track sessionId from context", async () => {
-      const tool = createOperationTool(taskComponent);
-      const result = await tool.execute(
-        {
-          task_id: taskId,
-          action_type: "milestone",
-          action_title: "Reached milestone",
-        },
-        { session_id: "sess_789" }
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.metadata?.session_id).toBe("sess_789");
-    });
-  });
-  
-  describe("task_operation_get", () => {
-    it("should get operation by id", async () => {
-      // Create an operation first
-      const createTool = createOperationTool(taskComponent);
-      const createResult = await createTool.execute(
-        { task_id: taskId, action_type: "progress", action_title: "Test" },
-        { session_id: "sess_123" }
-      );
-      
-      const opId = createResult.metadata?.operation_id as number;
-      
-      // Get it
-      const tool = getOperationTool(taskComponent);
-      const result = await tool.execute(
-        { operation_id: opId },
-        { session_id: "sess_123" }
-      );
-      
-      expect(result.success).toBe(true);
-      const op = JSON.parse(result.output as string);
-      expect(op.actionType).toBe("progress");
-      expect(op.sessionId).toBe("sess_123");
-    });
-    
-    it("should return error for non-existent operation", async () => {
-      const tool = getOperationTool(taskComponent);
-      const result = await tool.execute(
-        { operation_id: 99999 },
-        { session_id: "sess_123" }
-      );
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("not found");
-    });
-  });
-  
-  describe("task_operation_list", () => {
-    it("should list operations for a task", async () => {
-      // Create multiple operations
-      const createTool = createOperationTool(taskComponent);
-      await createTool.execute(
-        { task_id: taskId, action_type: "create", action_title: "Created" },
-        { session_id: "sess_1" }
-      );
-      await createTool.execute(
-        { task_id: taskId, action_type: "progress", action_title: "Progress 1" },
-        { session_id: "sess_2" }
-      );
-      await createTool.execute(
-        { task_id: taskId, action_type: "progress", action_title: "Progress 2" },
-        { session_id: "sess_3" }
-      );
-      
-      // List them
-      const tool = listOperationsTool(taskComponent);
-      const result = await tool.execute(
-        { task_id: taskId },
-        { session_id: "sess_123" }
-      );
-      
-      expect(result.success).toBe(true);
-      const data = JSON.parse(result.output as string);
-      expect(data.count).toBeGreaterThanOrEqual(3);
-    });
-    
-    it("should filter by action_type", async () => {
-      const createTool = createOperationTool(taskComponent);
-      await createTool.execute(
-        { task_id: taskId, action_type: "progress", action_title: "P1" },
-        { session_id: "sess_1" }
-      );
-      await createTool.execute(
-        { task_id: taskId, action_type: "milestone", action_title: "M1" },
-        { session_id: "sess_2" }
-      );
-      await createTool.execute(
-        { task_id: taskId, action_type: "progress", action_title: "P2" },
-        { session_id: "sess_3" }
-      );
-      
-      const tool = listOperationsTool(taskComponent);
-      const result = await tool.execute(
-        { task_id: taskId, action_type: "progress" },
-        { session_id: "sess_123" }
-      );
-      
-      expect(result.success).toBe(true);
-      const data = JSON.parse(result.output as string);
-      expect(data.operations.every((op: any) => op.actionType === "progress")).toBe(true);
-    });
-  });
-  
-  describe("task_operation_update", () => {
-    it("should update operation", async () => {
-      // Create an operation
-      const createTool = createOperationTool(taskComponent);
-      const createResult = await createTool.execute(
-        { task_id: taskId, action_type: "progress", action_title: "Original" },
-        { session_id: "sess_123" }
-      );
-      
-      const opId = createResult.metadata?.operation_id as number;
-      
-      // Update it
-      const tool = updateOperationTool(taskComponent);
-      const result = await tool.execute(
-        { operation_id: opId, action_title: "Updated", action_description: "New description" },
-        { session_id: "sess_123" }
-      );
-      
-      expect(result.success).toBe(true);
-      
-      // Verify
-      const getTool = getOperationTool(taskComponent);
-      const getResult = await getTool.execute(
-        { operation_id: opId },
-        { session_id: "sess_123" }
-      );
-      const op = JSON.parse(getResult.output as string);
-      expect(op.actionTitle).toBe("Updated");
-      expect(op.actionDescription).toBe("New description");
-    });
-  });
-  
-  describe("task_operation_delete", () => {
-    it("should delete operation", async () => {
-      // Create an operation
-      const createTool = createOperationTool(taskComponent);
-      const createResult = await createTool.execute(
-        { task_id: taskId, action_type: "progress", action_title: "Delete me" },
-        { session_id: "sess_123" }
-      );
-      
-      const opId = createResult.metadata?.operation_id as number;
-      
-      // Delete it
-      const tool = deleteOperationTool(taskComponent);
-      const result = await tool.execute(
-        { operation_id: opId },
-        { session_id: "sess_123" }
-      );
-      
-      expect(result.success).toBe(true);
-      
-      // Verify it's gone
-      const getTool = getOperationTool(taskComponent);
-      const getResult = await getTool.execute(
-        { operation_id: opId },
-        { session_id: "sess_123" }
-      );
-      expect(getResult.success).toBe(false);
-    });
-  });
-  
-  describe("cross-session tracking", () => {
-    it("should track operations from multiple sessions", async () => {
-      const createTool = createOperationTool(taskComponent);
-      
-      await createTool.execute(
-        { task_id: taskId, action_type: "create", action_title: "Session 1" },
-        { session_id: "sess_alpha" }
-      );
-      
-      await createTool.execute(
-        { task_id: taskId, action_type: "progress", action_title: "Session 2" },
-        { session_id: "sess_beta" }
-      );
-      
-      await createTool.execute(
-        { task_id: taskId, action_type: "milestone", action_title: "Session 3" },
-        { session_id: "sess_gamma" }
-      );
-      
-      // List and check sessions
-      const tool = listOperationsTool(taskComponent);
-      const result = await tool.execute(
-        { task_id: taskId },
-        { session_id: "sess_123" }
-      );
-      
-      const data = JSON.parse(result.output as string);
-      const sessions = new Set(data.operations.map((op: any) => op.sessionId));
-      
-      expect(sessions.has("sess_alpha")).toBe(true);
-      expect(sessions.has("sess_beta")).toBe(true);
-      expect(sessions.has("sess_gamma")).toBe(true);
-    });
-  });
-});

package/src/env/task/tools/operation/operation-types.ts

@@ -1,75 +0,0 @@
-/**
- * @fileoverview Operation Tool Parameter Schemas
- */
-
-import { z } from "zod";
-
-/**
- * Action type enum
- */
-const ActionTypeEnum = z.enum([
-  "create",
-  "progress",
-  "milestone",
-  "problem",
-  "solution",
-  "decision",
-  "review",
-  "completed",
-]);
-
-export { ActionTypeEnum };
-
-/**
- * task_operation_create tool parameters
- */
-export const CreateOperationToolSchema = z.object({
-  task_id: z.number().describe("Task ID"),
-  action_type: ActionTypeEnum.describe("Type of action"),
-  action_title: z.string().describe("Title of the action"),
-  action_description: z.string().optional().describe("Detailed description"),
-  md_path: z.string().optional().describe("Path to detailed markdown documentation"),
-});
-
-export type CreateOperationToolParams = z.infer<typeof CreateOperationToolSchema>;
-
-/**
- * task_operation_get tool parameters
- */
-export const GetOperationToolSchema = z.object({
-  operation_id: z.number().describe("Operation ID"),
-});
-
-export type GetOperationToolParams = z.infer<typeof GetOperationToolSchema>;
-
-/**
- * task_operation_list tool parameters
- */
-export const ListOperationsToolSchema = z.object({
-  task_id: z.number().describe("Task ID"),
-  action_type: ActionTypeEnum.optional(),
-  limit: z.number().optional().default(20),
-  offset: z.number().optional().default(0),
-});
-
-export type ListOperationsToolParams = z.infer<typeof ListOperationsToolSchema>;
-
-/**
- * task_operation_update tool parameters
- */
-export const UpdateOperationToolSchema = z.object({
-  operation_id: z.number().describe("Operation ID"),
-  action_title: z.string().optional(),
-  action_description: z.string().optional(),
-});
-
-export type UpdateOperationToolParams = z.infer<typeof UpdateOperationToolSchema>;
-
-/**
- * task_operation_delete tool parameters
- */
-export const DeleteOperationToolSchema = z.object({
-  operation_id: z.number().describe("Operation ID"),
-});
-
-export type DeleteOperationToolParams = z.infer<typeof DeleteOperationToolSchema>;

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

@@ -1,47 +0,0 @@
-/**
- * @fileoverview Operation Update Tool
- */
-
-import type { Tool, ToolContext, ToolResult } from "../../../tool/types";
-import { UpdateOperationToolSchema, type UpdateOperationToolParams } from "./operation-types";
-import type { TaskComponent } from "../../task-component";
-
-export function updateOperationTool(taskComponent: TaskComponent): Tool {
-  return {
-    name: "task_operation_update",
-    description: "Update an operation record's title or description.",
-    parameters: UpdateOperationToolSchema,
-    execute: async (args: unknown, ctx: ToolContext): Promise<ToolResult> => {
-      const params = UpdateOperationToolSchema.parse(args) as UpdateOperationToolParams;
-      
-      try {
-        const operation = await taskComponent.updateOperation(params.operation_id, {
-          actionTitle: params.action_title,
-          actionDescription: params.action_description,
-        });
-        
-        if (!operation) {
-          return { 
-            success: false, 
-            output: "", 
-            error: `Operation not found: ${params.operation_id}`,
-            metadata: { execution_time_ms: 0 },
-          };
-        }
-        
-        return {
-          success: true,
-          output: `Operation updated: #${operation.id}`,
-          metadata: { execution_time_ms: 0, operation },
-        };
-      } catch (error) {
-        return {
-          success: false,
-          output: "",
-          error: error instanceof Error ? error.message : String(error),
-          metadata: { execution_time_ms: 0 },
-        };
-      }
-    },
-  };
-}

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

@@ -1,203 +0,0 @@
-/**
- * @fileoverview Task Tools Tests
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { TaskComponent } from "../task-component";
-import { ConfigComponent } from "../../../config/config-component";
-import { tmpdir } from "os";
-import { join } from "path";
-import { createTaskTool, getTaskTool, listTasksTool, updateTaskTool, deleteTaskTool, completeTaskTool } from "./index";
-
-describe("Task Tools", () => {
-  let taskComponent: TaskComponent;
-  
-  beforeEach(async () => {
-    const configComponent = new ConfigComponent();
-    taskComponent = new TaskComponent();
-    await taskComponent.init({
-      options: {
-        configComponent,
-        config: {
-          storage: {
-            type: "sqlite",
-            dbPath: join(tmpdir(), `task-tools-test-${Date.now()}.db`),
-          },
-        },
-      },
-    });
-  });
-  
-  afterEach(async () => {
-    await taskComponent.stop();
-  });
-  
-  describe("task_create", () => {
-    it("should create a task", async () => {
-      const tool = createTaskTool(taskComponent);
-      const result = await tool.execute(
-        { title: "Test Task", description: "Test description" },
-        { session_id: "sess_123" }
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.output).toContain("Test Task");
-      expect(result.metadata?.task_id).toBeGreaterThan(0);
-    });
-    
-    it("should create task with priority", async () => {
-      const tool = createTaskTool(taskComponent);
-      const result = await tool.execute(
-        { title: "High Priority Task", priority: "high" },
-        { session_id: "sess_123" }
-      );
-      
-      expect(result.success).toBe(true);
-    });
-  });
-  
-  describe("task_get", () => {
-    it("should get task by id", async () => {
-      // First create a task
-      const createTool = createTaskTool(taskComponent);
-      const createResult = await createTool.execute(
-        { title: "Get Test Task" },
-        { session_id: "sess_123" }
-      );
-      
-      const taskId = createResult.metadata?.task_id as number;
-      
-      // Then get it
-      const getTool = getTaskTool(taskComponent);
-      const result = await getTool.execute(
-        { task_id: taskId },
-        { session_id: "sess_123" }
-      );
-      
-      expect(result.success).toBe(true);
-      const task = JSON.parse(result.output as string);
-      expect(task.title).toBe("Get Test Task");
-    });
-    
-    it("should return error for non-existent task", async () => {
-      const tool = getTaskTool(taskComponent);
-      const result = await tool.execute(
-        { task_id: 99999 },
-        { session_id: "sess_123" }
-      );
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("not found");
-    });
-  });
-  
-  describe("task_list", () => {
-    it("should list tasks", async () => {
-      // Create some tasks
-      const createTool = createTaskTool(taskComponent);
-      await createTool.execute({ title: "Task 1" }, { session_id: "sess_123" });
-      await createTool.execute({ title: "Task 2" }, { session_id: "sess_123" });
-      
-      // List them
-      const tool = listTasksTool(taskComponent);
-      const result = await tool.execute({}, { session_id: "sess_123" });
-      
-      expect(result.success).toBe(true);
-      const data = JSON.parse(result.output as string);
-      expect(data.count).toBeGreaterThanOrEqual(2);
-    });
-    
-    it("should filter by status", async () => {
-      const createTool = createTaskTool(taskComponent);
-      const createResult = await createTool.execute({ title: "Active Task" }, { session_id: "sess_123" });
-      
-      // Update to active
-      const updateTool = updateTaskTool(taskComponent);
-      await updateTool.execute(
-        { task_id: createResult.metadata?.task_id, status: "active" },
-        { session_id: "sess_123" }
-      );
-      
-      // List only active
-      const listTool = listTasksTool(taskComponent);
-      const result = await listTool.execute({ status: "active" }, { session_id: "sess_123" });
-      
-      expect(result.success).toBe(true);
-      const data = JSON.parse(result.output as string);
-      expect(data.tasks.every((t: any) => t.status === "active")).toBe(true);
-    });
-  });
-  
-  describe("task_update", () => {
-    it("should update task", async () => {
-      // Create a task
-      const createTool = createTaskTool(taskComponent);
-      const createResult = await createTool.execute({ title: "Original Title" }, { session_id: "sess_123" });
-      
-      // Update it
-      const tool = updateTaskTool(taskComponent);
-      const result = await tool.execute(
-        { 
-          task_id: createResult.metadata?.task_id, 
-          title: "Updated Title",
-          status: "active",
-          progress: 50,
-          current_status: "正在实现功能"
-        },
-        { session_id: "sess_123" }
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.output).toContain("Updated Title");
-    });
-  });
-  
-  describe("task_delete", () => {
-    it("should delete task", async () => {
-      // Create a task
-      const createTool = createTaskTool(taskComponent);
-      const createResult = await createTool.execute({ title: "Delete Me" }, { session_id: "sess_123" });
-      
-      // Delete it
-      const tool = deleteTaskTool(taskComponent);
-      const result = await tool.execute(
-        { task_id: createResult.metadata?.task_id },
-        { session_id: "sess_123" }
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.output).toContain("deleted");
-      
-      // Verify it's gone
-      const getTool = getTaskTool(taskComponent);
-      const getResult = await getTool.execute(
-        { task_id: createResult.metadata?.task_id },
-        { session_id: "sess_123" }
-      );
-      expect(getResult.success).toBe(false);
-    });
-  });
-  
-  describe("task_complete", () => {
-    it("should complete task", async () => {
-      // Create a task
-      const createTool = createTaskTool(taskComponent);
-      const createResult = await createTool.execute({ title: "Complete Me" }, { session_id: "sess_123" });
-      
-      // Complete it
-      const tool = completeTaskTool(taskComponent);
-      const result = await tool.execute(
-        { task_id: createResult.metadata?.task_id },
-        { session_id: "sess_123" }
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.output).toContain("completed");
-      
-      // Verify status
-      const task = result.metadata?.task as any;
-      expect(task.status).toBe("completed");
-      expect(task.progress).toBe(100);
-    });
-  });
-});

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

@@ -1,75 +0,0 @@
-/**
- * @fileoverview Test for task tool schemas
- */
-
-import { describe, expect, test } from "bun:test";
-import { CreateTaskToolSchema, UpdateTaskToolSchema } from "./task-types";
-
-describe("CreateTaskToolSchema", () => {
-  test("should accept task without tags (tags is optional)", () => {
-    // tags is now optional (for search, stored in task.tags JSON field)
-    const validParams = {
-      title: "Test task",
-    };
-    
-    const result = CreateTaskToolSchema.safeParse(validParams);
-    expect(result.success).toBe(true);
-  });
-  
-  test("should accept task with tags", () => {
-    const validParams = {
-      title: "Test task",
-      tags: ["test", "feature"],
-    };
-    
-    const result = CreateTaskToolSchema.safeParse(validParams);
-    expect(result.success).toBe(true);
-  });
-  
-  test("should accept empty tags array", () => {
-    // tags can be empty array
-    const params = {
-      title: "Test task",
-      tags: [],
-    };
-    
-    const result = CreateTaskToolSchema.safeParse(params);
-    expect(result.success).toBe(true);
-  });
-  
-  test("should accept all optional fields", () => {
-    const params = {
-      title: "Test task",
-      description: "Test description",
-      priority: "high" as const,
-      goals_and_expected_deliverables: "Test goals",
-      due_date: "2025-12-31",
-      tags: ["test"],
-    };
-    
-    const result = CreateTaskToolSchema.safeParse(params);
-    expect(result.success).toBe(true);
-  });
-});
-
-describe("UpdateTaskToolSchema", () => {
-  test("tags can be optional in update", () => {
-    const params = {
-      task_id: 1,
-      title: "Updated title",
-    };
-    
-    const result = UpdateTaskToolSchema.safeParse(params);
-    expect(result.success).toBe(true);
-  });
-  
-  test("should require task_id", () => {
-    const params = {
-      title: "Updated title",
-      tags: ["updated"],
-    };
-    
-    const result = UpdateTaskToolSchema.safeParse(params);
-    expect(result.success).toBe(false);
-  });
-});