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

package/dist/env/task/tools/index.js

@@ -0,0 +1,344 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// packages/core/src/env/task/tools/task-types.ts
+import { z } from "zod";
+var CreateTaskToolSchema = z.object({
+  title: z.string().describe("Task title"),
+  description: z.string().optional().describe("Task description"),
+  priority: z.enum(["low", "medium", "high"]).optional().describe("Task priority"),
+  goals_and_expected_deliverables: z.string().optional().describe("Goals and expected deliverables"),
+  due_date: z.string().optional().describe("Due date (ISO format)"),
+  tags: z.array(z.string()).optional().describe("Task tags (for search, stored in task.tags JSON field)")
+});
+var GetTaskToolSchema = z.object({
+  task_id: z.number().describe("Task ID"),
+  include_operations: z.boolean().optional().default(false).describe("Include operation records")
+});
+var ListTasksToolSchema = z.object({
+  status: z.enum(["todo", "active", "completed", "paused", "cancelled"]).optional(),
+  priority: z.enum(["low", "medium", "high"]).optional(),
+  limit: z.number().optional().default(20),
+  offset: z.number().optional().default(0)
+});
+var UpdateTaskToolSchema = z.object({
+  task_id: z.number().describe("Task ID"),
+  title: z.string().optional(),
+  description: z.string().optional(),
+  status: z.enum(["todo", "active", "completed", "paused", "cancelled"]).optional(),
+  priority: z.enum(["low", "medium", "high"]).optional(),
+  progress: z.number().min(0).max(100).optional(),
+  current_status: z.string().optional(),
+  goals_and_expected_deliverables: z.string().optional(),
+  due_date: z.string().optional(),
+  tags: z.array(z.string()).optional()
+});
+var DeleteTaskToolSchema = z.object({
+  task_id: z.number().describe("Task ID")
+});
+
+// packages/core/src/env/task/tools/create-tool.ts
+function createTaskTool(taskComponent) {
+  return {
+    name: "task_create",
+    description: "Create a new task. The task will be associated with the current session.",
+    parameters: CreateTaskToolSchema,
+    execute: async (args, ctx) => {
+      const params = CreateTaskToolSchema.parse(args);
+      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 }
+        };
+      }
+    }
+  };
+}
+// packages/core/src/env/task/tools/get-tool.ts
+function getTaskTool(taskComponent) {
+  return {
+    name: "task_get",
+    description: "Get task details by ID. Optionally include operation records.",
+    parameters: GetTaskToolSchema,
+    execute: async (args, ctx) => {
+      const params = GetTaskToolSchema.parse(args);
+      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 }
+        };
+      }
+    }
+  };
+}
+// packages/core/src/env/task/tools/list-tool.ts
+function listTasksTool(taskComponent) {
+  return {
+    name: "task_list",
+    description: "List tasks with optional filters for status and priority.",
+    parameters: ListTasksToolSchema,
+    execute: async (args, ctx) => {
+      const params = ListTasksToolSchema.parse(args);
+      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 }
+        };
+      }
+    }
+  };
+}
+// packages/core/src/env/task/tools/update-tool.ts
+function updateTaskTool(taskComponent) {
+  return {
+    name: "task_update",
+    description: "Update an existing task's properties. Status and progress changes will create operation records.",
+    parameters: UpdateTaskToolSchema,
+    execute: async (args, ctx) => {
+      const params = UpdateTaskToolSchema.parse(args);
+      const sessionId = ctx.session_id || "unknown";
+      try {
+        const task = await taskComponent.updateTask(params.task_id, {
+          title: params.title,
+          description: params.description,
+          status: params.status,
+          priority: params.priority,
+          progress: params.progress,
+          current_status: params.current_status,
+          goals_and_expected_deliverables: params.goals_and_expected_deliverables,
+          due_date: params.due_date,
+          tags: params.tags
+        });
+        if (!task) {
+          return {
+            success: false,
+            output: "",
+            error: `Task not found: ${params.task_id}`,
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        if (params.status || params.progress !== undefined || params.current_status) {
+          await taskComponent.createOperation({
+            taskId: params.task_id,
+            sessionId,
+            actionType: "progress",
+            actionTitle: params.current_status || `Updated: ${params.status || `${params.progress}%`}`,
+            actionDescription: JSON.stringify({
+              status: params.status,
+              progress: params.progress,
+              current_status: params.current_status
+            })
+          });
+        }
+        return {
+          success: true,
+          output: `Task updated: #${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 }
+        };
+      }
+    }
+  };
+}
+// packages/core/src/env/task/tools/delete-tool.ts
+function deleteTaskTool(taskComponent) {
+  return {
+    name: "task_delete",
+    description: "Delete a task and all its operation records.",
+    parameters: DeleteTaskToolSchema,
+    execute: async (args, ctx) => {
+      const params = DeleteTaskToolSchema.parse(args);
+      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 }
+        };
+      }
+    }
+  };
+}
+// packages/core/src/env/task/tools/complete-tool.ts
+function completeTaskTool(taskComponent) {
+  return {
+    name: "task_complete",
+    description: "Mark a task as completed (progress=100, status=completed). Creates an operation record.",
+    parameters: DeleteTaskToolSchema,
+    execute: async (args, ctx) => {
+      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 }
+        };
+      }
+    }
+  };
+}
+export {
+  updateTaskTool,
+  listTasksTool,
+  getTaskTool,
+  deleteTaskTool,
+  createTaskTool,
+  completeTaskTool
+};

package/dist/env/task/tools/operation/index.js

@@ -0,0 +1,270 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// packages/core/src/env/task/tools/operation/operation-types.ts
+import { z } from "zod";
+var ActionTypeEnum = z.enum([
+  "create",
+  "progress",
+  "milestone",
+  "problem",
+  "solution",
+  "decision",
+  "review",
+  "completed"
+]);
+var 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")
+});
+var GetOperationToolSchema = z.object({
+  operation_id: z.number().describe("Operation ID")
+});
+var 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)
+});
+var UpdateOperationToolSchema = z.object({
+  operation_id: z.number().describe("Operation ID"),
+  action_title: z.string().optional(),
+  action_description: z.string().optional()
+});
+var DeleteOperationToolSchema = z.object({
+  operation_id: z.number().describe("Operation ID")
+});
+
+// packages/core/src/env/task/tools/operation/create-tool.ts
+function createOperationTool(taskComponent) {
+  return {
+    name: "task_operation_create",
+    description: "Create an operation record for a task. Tracks progress, milestones, problems, etc.",
+    parameters: CreateOperationToolSchema,
+    execute: async (args, ctx) => {
+      const params = CreateOperationToolSchema.parse(args);
+      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 }
+        };
+      }
+    }
+  };
+}
+// packages/core/src/env/task/tools/operation/get-tool.ts
+function getOperationTool(taskComponent) {
+  return {
+    name: "task_operation_get",
+    description: "Get a single operation record by ID.",
+    parameters: GetOperationToolSchema,
+    execute: async (args, ctx) => {
+      const params = GetOperationToolSchema.parse(args);
+      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 }
+        };
+      }
+    }
+  };
+}
+// packages/core/src/env/task/tools/operation/list-tool.ts
+function listOperationsTool(taskComponent) {
+  return {
+    name: "task_operation_list",
+    description: "List operation records for a task with optional filters.",
+    parameters: ListOperationsToolSchema,
+    execute: async (args, ctx) => {
+      const params = ListOperationsToolSchema.parse(args);
+      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 }
+        };
+      }
+    }
+  };
+}
+// packages/core/src/env/task/tools/operation/update-tool.ts
+function updateOperationTool(taskComponent) {
+  return {
+    name: "task_operation_update",
+    description: "Update an operation record's title or description.",
+    parameters: UpdateOperationToolSchema,
+    execute: async (args, ctx) => {
+      const params = UpdateOperationToolSchema.parse(args);
+      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 }
+        };
+      }
+    }
+  };
+}
+// packages/core/src/env/task/tools/operation/delete-tool.ts
+function deleteOperationTool(taskComponent) {
+  return {
+    name: "task_operation_delete",
+    description: "Delete an operation record.",
+    parameters: DeleteOperationToolSchema,
+    execute: async (args, ctx) => {
+      const params = DeleteOperationToolSchema.parse(args);
+      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 }
+        };
+      }
+    }
+  };
+}
+export {
+  updateOperationTool,
+  listOperationsTool,
+  getOperationTool,
+  deleteOperationTool,
+  createOperationTool
+};