claude-flow
Version:
Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration
185 lines • 4.48 kB
TypeScript
/**
* V3 Task Interfaces
* Domain-Driven Design - Task Bounded Context
*/
/**
* Task priority levels
*/
export type TaskPriority = 'critical' | 'high' | 'medium' | 'low';
/**
* Task status throughout its lifecycle
*/
export type TaskStatus = 'pending' | 'queued' | 'assigned' | 'running' | 'completed' | 'failed' | 'cancelled' | 'timeout';
/**
* Core task entity
*/
export interface ITask {
readonly id: string;
readonly type: string;
readonly description: string;
readonly priority: number;
readonly createdAt: Date;
status: TaskStatus;
assignedAgent?: string;
startedAt?: Date;
completedAt?: Date;
timeout?: number;
input?: Record<string, unknown>;
output?: Record<string, unknown>;
error?: Error;
metadata?: {
requiredCapabilities?: string[];
retryCount?: number;
maxRetries?: number;
critical?: boolean;
parentTaskId?: string;
childTaskIds?: string[];
tags?: string[];
[key: string]: unknown;
};
}
/**
* Task creation parameters
*/
export interface ITaskCreate {
type: string;
description: string;
priority?: number;
timeout?: number;
assignedAgent?: string;
input?: Record<string, unknown>;
metadata?: ITask['metadata'];
}
/**
* Task result after completion
*/
export interface ITaskResult {
taskId: string;
success: boolean;
output?: Record<string, unknown>;
error?: Error;
duration: number;
agentId?: string;
metrics?: {
tokensUsed?: number;
memoryPeakMb?: number;
retryCount?: number;
};
}
/**
* Task queue interface for managing task ordering and processing
*/
export interface ITaskQueue {
/**
* Add a task to the queue
*/
enqueue(task: ITask): Promise<void>;
/**
* Remove and return the highest priority task
*/
dequeue(): Promise<ITask | undefined>;
/**
* Peek at the next task without removing it
*/
peek(): Promise<ITask | undefined>;
/**
* Get the current queue size
*/
size(): number;
/**
* Check if the queue is empty
*/
isEmpty(): boolean;
/**
* Clear all tasks from the queue
*/
clear(): Promise<void>;
/**
* Get all queued tasks (for inspection)
*/
getAll(): Promise<ITask[]>;
/**
* Remove a specific task by ID
*/
remove(taskId: string): Promise<boolean>;
/**
* Update task priority
*/
updatePriority(taskId: string, priority: number): Promise<boolean>;
}
/**
* Task manager interface for lifecycle management
*/
export interface ITaskManager {
/**
* Create a new task
*/
createTask(params: ITaskCreate): Promise<ITask>;
/**
* Get a task by ID
*/
getTask(taskId: string): ITask | undefined;
/**
* Get all tasks matching optional filter
*/
getTasks(filter?: Partial<Pick<ITask, 'status' | 'type' | 'assignedAgent'>>): ITask[];
/**
* Assign a task to an agent
*/
assignTask(taskId: string, agentId: string): Promise<void>;
/**
* Start task execution
*/
startTask(taskId: string): Promise<void>;
/**
* Complete a task with result
*/
completeTask(taskId: string, result: ITaskResult): Promise<void>;
/**
* Fail a task with error
*/
failTask(taskId: string, error: Error): Promise<void>;
/**
* Cancel a task
*/
cancelTask(taskId: string, reason?: string): Promise<void>;
/**
* Retry a failed task
*/
retryTask(taskId: string): Promise<void>;
/**
* Get task metrics
*/
getMetrics(): TaskManagerMetrics;
/**
* Clean up old completed/failed tasks
*/
cleanup(olderThan: Date): Promise<number>;
}
/**
* Task manager metrics
*/
export interface TaskManagerMetrics {
totalTasks: number;
pendingTasks: number;
runningTasks: number;
completedTasks: number;
failedTasks: number;
cancelledTasks: number;
avgDuration: number;
avgWaitTime: number;
}
/**
* Task assignment strategy interface
*/
export interface ITaskAssignmentStrategy {
/**
* Select the best agent for a task
*/
selectAgent(task: ITask, availableAgents: string[]): Promise<string | undefined>;
/**
* Score an agent for a task (higher is better)
*/
scoreAgent(task: ITask, agentId: string): Promise<number>;
}
//# sourceMappingURL=task.interface.d.ts.map