@codebolt/codeboltjs 2.2.1 → 2.2.3

package/dist/modules/task.js

@@ -4,289 +4,438 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const websocket_1 = __importDefault(require("../core/websocket"));
+const crypto_1 = require("crypto");
 /**
- * Enhanced task planner with agent-based organization and comprehensive task management.
+ * Enhanced task service with comprehensive task and step management.
+ * This module provides a modern API for task management based on the new task service schemas.
  */
-const taskplaner = {
+const taskService = {
     /**
-     * Adds a new task with enhanced parameters.
-     * @param {TaskCreateOptions} params - The task parameters including title, agentId, description, etc.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the add task event.
+     * Creates a new task with comprehensive options.
+     * @param {CreateTaskOptions} options - The task creation parameters
+     * @returns {Promise<CreateTaskResponse>} A promise that resolves with the task creation response
      */
-    addTask: async (params) => {
-        const { title, agentId = 'default-agent', description, phase, category, priority, tags } = params;
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "addTask",
-            agentId: agentId,
-            message: {
-                title: title,
-                description: description,
-                phase: phase,
-                category: category,
-                priority: priority,
-                tags: tags
-            }
-        }, "addTaskResponse");
+    createTask: async (options) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'createTask',
+            requestId,
+            agentId: options.threadId, // Using threadId as agentId for now
+            threadId: options.threadId,
+            message: options
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'createTaskResponse');
     },
     /**
-     * Adds a task using simple string parameter (legacy support).
-     * @param {string} task - The task title.
-     * @param {string} agentId - The agent ID (optional, defaults to 'default-agent').
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the add task event.
+     * Creates a simple task with minimal parameters (legacy compatibility).
+     * @param {string} taskName - The task name
+     * @param {string} threadId - The thread ID (defaults to 'default-thread')
+     * @returns {Promise<CreateTaskResponse>} A promise that resolves with the task creation response
      */
-    addSimpleTask: async (task, agentId = 'default-agent') => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "addTask",
-            agentId: agentId,
-            message: {
-                task: task
-            }
-        }, "addTaskResponse");
+    createSimpleTask: async (taskName, threadId = 'default-thread') => {
+        const options = {
+            threadId,
+            name: taskName,
+            taskType: 'interactive',
+            executionType: 'manual',
+            environmentType: 'local',
+            startOption: 'manual'
+        };
+        return taskService.createTask(options);
     },
     /**
-     * Retrieves all tasks with optional filtering.
-     * @param {TaskFilterOptions} filters - Optional filters for agentId, category, phase, etc.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the get tasks event.
+     * Retrieves a list of tasks with optional filtering.
+     * @param {GetTaskListOptions} options - Optional filters for tasks
+     * @returns {Promise<GetTaskListResponse>} A promise that resolves with the task list response
      */
-    getTasks: async (filters = {}) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "getTasks",
-            message: filters
-        }, "getTasksResponse");
+    getTaskList: async (options = {}) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'getTaskList',
+            requestId,
+            message: options
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'getTaskListResponse');
     },
     /**
-     * Retrieves tasks for a specific agent.
-     * @param {string} agentId - The agent ID.
-     * @returns {Promise<TaskResponse>} A promise that resolves with tasks for the specified agent.
+     * Retrieves detailed information about a specific task.
+     * @param {GetTaskDetailOptions} options - The task detail options
+     * @returns {Promise<GetTaskDetailResponse>} A promise that resolves with the task detail response
      */
-    getTasksByAgent: async (agentId) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "getTasksByAgent",
-            message: {
-                agentId: agentId
-            }
-        }, "getTasksByAgentResponse");
+    getTaskDetail: async (options) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'getTaskDetail',
+            requestId,
+            message: options
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'getTaskDetailResponse');
     },
     /**
-     * Retrieves tasks by category.
-     * @param {string} category - The category name.
-     * @returns {Promise<TaskResponse>} A promise that resolves with tasks in the specified category.
+     * Adds a step to an existing task.
+     * @param {AddStepToTaskOptions} options - The step addition options
+     * @returns {Promise<AddStepToTaskResponse>} A promise that resolves with the step addition response
      */
-    getTasksByCategory: async (category) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "getTasksByCategory",
-            message: {
-                category: category
-            }
-        }, "getTasksByCategoryResponse");
+    addStepToTask: async (options) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'addStepToTask',
+            requestId,
+            message: options
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'addStepToTaskResponse');
     },
     /**
-     * Retrieves all available agents.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the list of all agents.
+     * Retrieves messages for a specific task.
+     * @param {GetTaskMessagesOptions} options - The task messages options
+     * @returns {Promise<GetTaskMessagesResponse>} A promise that resolves with the task messages response
      */
-    getAllAgents: async () => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "getAllAgents"
-        }, "getAllAgentsResponse");
+    getTaskMessages: async (options) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'getTaskMessages',
+            requestId,
+            message: options
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'getTaskMessagesResponse');
     },
     /**
      * Updates an existing task.
-     * @param {TaskUpdateOptions} params - The task update parameters.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
+     * @param {string} taskId - The task ID to update
+     * @param {UpdateTaskOptions} updates - The task update parameters
+     * @returns {Promise<UpdateTaskResponse>} A promise that resolves with the task update response
      */
-    updateTask: async (params) => {
-        const { taskId, ...updates } = params;
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "updateTask",
+    updateTask: async (taskId, updates) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'updateTask',
+            requestId,
             message: {
-                taskId: taskId,
+                taskId,
                 ...updates
             }
-        }, "updateTasksResponse");
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'updateTaskResponse');
     },
     /**
-     * Updates an existing task using legacy string parameter.
-     * @param {string} taskId - The task ID.
-     * @param {string} task - The updated task information.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
+     * Updates a task with simple name change (legacy compatibility).
+     * @param {string} taskId - The task ID
+     * @param {string} taskName - The new task name
+     * @returns {Promise<UpdateTaskResponse>} A promise that resolves with the task update response
      */
-    updateSimpleTask: async (taskId, task) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "updateTask",
-            message: {
-                taskId: taskId,
-                task: task
-            }
-        }, "updateTasksResponse");
+    updateSimpleTask: async (taskId, taskName) => {
+        return taskService.updateTask(taskId, {
+            name: taskName
+        });
     },
     /**
      * Deletes a task.
-     * @param {string} taskId - The task ID to delete.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the delete task event.
+     * @param {string} taskId - The task ID to delete
+     * @returns {Promise<DeleteTaskResponse>} A promise that resolves with the task deletion response
      */
     deleteTask: async (taskId) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "deleteTask",
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'deleteTask',
+            requestId,
             message: {
-                taskId: taskId
+                taskId
             }
-        }, "deleteTaskResponse");
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'deleteTaskResponse');
     },
     /**
-     * Adds a subtask to an existing task.
-     * @param {AddSubTaskOptions} params - The subtask parameters.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the add subtask event.
+     * Completes a task.
+     * @param {string} taskId - The task ID to complete
+     * @returns {Promise<CompleteTaskResponse>} A promise that resolves with the task completion response
      */
-    addSubTask: async (params) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "addSubTask",
-            message: params
-        }, "addSubTaskResponse");
+    completeTask: async (taskId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'completeTask',
+            requestId,
+            message: {
+                taskId
+            }
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'completeTaskResponse');
+    },
+    /**
+     * Starts a task.
+     * @param {string} taskId - The task ID to start
+     * @returns {Promise<StartTaskResponse>} A promise that resolves with the task start response
+     */
+    startTask: async (taskId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'startTask',
+            requestId,
+            message: {
+                taskId
+            }
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'startTaskResponse');
     },
     /**
-     * Updates an existing subtask.
-     * @param {UpdateSubTaskOptions} params - The subtask update parameters.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update subtask event.
+     * Retrieves all steps with optional filtering.
+     * @param {GetAllStepsOptions} options - Optional filters for steps
+     * @returns {Promise<GetAllStepsResponse>} A promise that resolves with the steps response
      */
-    updateSubTask: async (params) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "updateSubTask",
-            message: params
-        }, "updateSubTaskResponse");
+    getAllSteps: async (options = {}) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'getAllSteps',
+            requestId,
+            message: options
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'getAllStepsResponse');
     },
     /**
-     * Deletes a subtask.
-     * @param {string} taskId - The parent task ID.
-     * @param {string} subtaskId - The subtask ID to delete.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the delete subtask event.
+     * Gets the currently running step for a task or agent.
+     * @param {GetActiveStepOptions} options - Options for getting active step
+     * @returns {Promise<GetCurrentRunningStepResponse>} A promise that resolves with the active step response
      */
-    deleteSubTask: async (taskId, subtaskId) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "deleteSubTask",
+    getCurrentRunningStep: async (options = {}) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'getCurrentRunningStep',
+            requestId,
+            message: options
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'getCurrentRunningStepResponse');
+    },
+    /**
+     * Updates the status of a specific step.
+     * @param {UpdateStepStatusOptions} options - The step status update options
+     * @returns {Promise<UpdateStepStatusResponse>} A promise that resolves with the step update response
+     */
+    updateStepStatus: async (options) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'updateStepStatus',
+            requestId,
+            message: options
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'updateStepStatusResponse');
+    },
+    /**
+     * Completes a specific step.
+     * @param {CompleteStepOptions} options - The step completion options
+     * @returns {Promise<CompleteStepResponse>} A promise that resolves with the step completion response
+     */
+    completeStep: async (options) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'completeStep',
+            requestId,
+            message: options
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'completeStepResponse');
+    },
+    /**
+     * Sends a steering message to a running step.
+     * @param {SendSteeringMessageOptions} options - The steering message options
+     * @returns {Promise<SendSteeringMessageResponse>} A promise that resolves with the steering message response
+     */
+    sendSteeringMessage: async (options) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'sendSteeringMessage',
+            requestId,
+            message: options
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'sendSteeringMessageResponse');
+    },
+    /**
+     * Checks if a task can start based on its dependencies.
+     * @param {string} taskId - The task ID to check
+     * @returns {Promise<CanTaskStartResponse>} A promise that resolves with the task start capability response
+     */
+    canTaskStart: async (taskId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'canTaskStart',
+            requestId,
+            message: {
+                taskId
+            }
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'canTaskStartResponse');
+    },
+    /**
+     * Gets tasks that depend on a specific task.
+     * @param {string} taskId - The task ID to check dependencies for
+     * @returns {Promise<GetTasksDependentOnResponse>} A promise that resolves with the dependent tasks response
+     */
+    getTasksDependentOn: async (taskId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'getTasksDependentOn',
+            requestId,
             message: {
-                taskId: taskId,
-                subtaskId: subtaskId
+                taskId
             }
-        }, "deleteSubTaskResponse");
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'getTasksDependentOnResponse');
     },
     /**
-     * Creates tasks from markdown content.
-     * @param {TaskMarkdownImportOptions} params - The markdown parameters including content, agentId, phase, and category.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the create tasks from markdown event.
+     * Gets tasks that are ready to start.
+     * @param {GetTasksReadyToStartOptions} options - Optional filters for ready tasks
+     * @returns {Promise<GetTasksReadyToStartResponse>} A promise that resolves with the ready tasks response
      */
-    createTasksFromMarkdown: async (params) => {
-        const { markdown, agentId = 'default-agent', phase, category } = params;
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "createTasksFromMarkdown",
-            agentId: agentId,
+    getTasksReadyToStart: async (options = {}) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'getTasksReadyToStart',
+            requestId,
+            message: options
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'getTasksReadyToStartResponse');
+    },
+    /**
+     * Gets the dependency chain for a specific task.
+     * @param {string} taskId - The task ID to get dependency chain for
+     * @returns {Promise<GetTaskDependencyChainResponse>} A promise that resolves with the dependency chain response
+     */
+    getTaskDependencyChain: async (taskId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'getTaskDependencyChain',
+            requestId,
             message: {
-                markdown: markdown,
-                phase: phase,
-                category: category
+                taskId
             }
-        }, "createTasksFromMarkdownResponse");
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'getTaskDependencyChainResponse');
     },
     /**
-     * Exports tasks to markdown format.
-     * @param {TaskMarkdownExportOptions} params - The export parameters including optional phase, agentId, and category filters.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the markdown content.
+     * Gets task statistics.
+     * @param {GetTaskStatsOptions} options - Optional filters for task stats
+     * @returns {Promise<GetTaskStatsResponse>} A promise that resolves with the task stats response
      */
-    exportTasksToMarkdown: async (params = {}) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "exportTasksToMarkdown",
-            message: params
-        }, "exportTasksToMarkdownResponse");
+    getTaskStats: async (options = {}) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'getTaskStats',
+            requestId,
+            message: options
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'getTaskStatsResponse');
     },
+    // ================================
+    // Utility Functions
+    // ================================
     /**
      * Utility function to toggle task completion status.
-     * @param {string} taskId - The task ID.
-     * @param {boolean} completed - The new completion status.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
+     * @param {string} taskId - The task ID
+     * @param {boolean} completed - The new completion status
+     * @returns {Promise<UpdateTaskResponse>} A promise that resolves with the task update response
      */
     toggleTaskCompletion: async (taskId, completed) => {
-        return taskplaner.updateTask({
-            taskId: taskId,
+        return taskService.updateTask(taskId, {
             completed: completed
         });
     },
     /**
-     * Utility function to toggle subtask completion status.
-     * @param {string} taskId - The parent task ID.
-     * @param {string} subtaskId - The subtask ID.
-     * @param {boolean} completed - The new completion status.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update subtask event.
+     * Utility function to create a quick task with minimal parameters.
+     * @param {string} name - The task name
+     * @param {string} threadId - The thread ID (defaults to 'default-thread')
+     * @returns {Promise<CreateTaskResponse>} A promise that resolves with the task creation response
      */
-    toggleSubTaskCompletion: async (taskId, subtaskId, completed) => {
-        return taskplaner.updateSubTask({
-            taskId: taskId,
-            subtaskId: subtaskId,
-            completed: completed
+    createQuickTask: async (name, threadId = 'default-thread') => {
+        return taskService.createTask({
+            threadId,
+            name,
+            taskType: 'interactive',
+            executionType: 'immediate',
+            environmentType: 'local',
+            startOption: 'immediately'
         });
     },
     /**
-     * Utility function to move a task to a different agent.
-     * @param {string} taskId - The task ID.
-     * @param {string} newAgentId - The new agent ID.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
+     * Gets tasks started by a specific user
+     * @param {string} userId - The user ID
+     * @param {GetTaskListOptions} options - Optional filters for tasks
+     * @returns {Promise<GetTaskListResponse>} A promise that resolves with the task list response
      */
-    moveTaskToAgent: async (taskId, newAgentId) => {
-        return taskplaner.updateTask({
-            taskId: taskId,
-            agentId: newAgentId
-        });
+    getTasksStartedByMe: async (userId, options = {}) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'getTasksStartedByMe',
+            requestId,
+            message: {
+                userId,
+                ...options
+            }
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'getTasksStartedByMeResponse');
     },
+    // ================================
+    // Legacy Compatibility Functions
+    // ================================
     /**
-     * Utility function to set task priority.
-     * @param {string} taskId - The task ID.
-     * @param {'low' | 'medium' | 'high'} priority - The priority level.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
+     * Legacy function: Adds a task (mapped to createTask)
+     * @deprecated Use createTask instead
      */
-    setTaskPriority: async (taskId, priority) => {
-        return taskplaner.updateTask({
-            taskId: taskId,
-            priority: priority
-        });
+    addTask: async (params) => {
+        const options = {
+            threadId: params.agentId || 'default-thread',
+            name: params.title,
+            taskType: 'interactive',
+            executionType: 'manual',
+            environmentType: 'local',
+            startOption: 'manual'
+        };
+        return taskService.createTask(options);
     },
     /**
-     * Utility function to add tags to a task.
-     * @param {string} taskId - The task ID.
-     * @param {string[]} tags - The tags to add.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
+     * Legacy function: Gets tasks (mapped to getTaskList)
+     * @deprecated Use getTaskList instead
      */
-    addTaskTags: async (taskId, tags) => {
-        return taskplaner.updateTask({
-            taskId: taskId,
-            tags: tags
-        });
+    getTasks: async (filters = {}) => {
+        const options = {
+            threadId: filters.agentId,
+            status: 'all'
+        };
+        return taskService.getTaskList(options);
     },
     /**
-     * Utility function to create a quick task with minimal parameters.
-     * @param {string} title - The task title.
-     * @param {string} agentId - The agent ID (optional, defaults to 'default-agent').
-     * @param {string} category - The category (optional).
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the add task event.
+     * Legacy function: Gets tasks by agent (mapped to getTaskList with threadId filter)
+     * @deprecated Use getTaskList with threadId filter instead
      */
-    createQuickTask: async (title, agentId = 'default-agent', category) => {
-        return taskplaner.addTask({
-            title: title,
-            agentId: agentId,
-            category: category,
-            priority: 'medium'
+    getTasksByAgent: async (agentId) => {
+        return taskService.getTaskList({
+            threadId: agentId
         });
+    },
+    /**
+     * Legacy function: Gets tasks by category (use getTaskList with custom filtering)
+     * @deprecated Use getTaskList instead
+     */
+    getTasksByCategory: async (category) => {
+        // Note: The new API doesn't have category filtering built-in
+        // This would need to be implemented as post-processing
+        return taskService.getTaskList();
     }
 };
-exports.default = taskplaner;
+exports.default = taskService;