claude-flow-novice 1.6.4 → 1.6.5

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/core/state-transition.js

@@ -0,0 +1,153 @@
+/**
+ * Agent Coordination V2 - State Transition System
+ *
+ * Defines event structures and transition validation logic for the state machine.
+ * Ensures type-safe state transitions with runtime validation.
+ *
+ * @module coordination/v2/core/state-transition
+ */ import { AgentState } from './agent-state.js';
+/**
+ * State transition event types.
+ * Maps to specific agent lifecycle events from SDK sessions.
+ */ export var TransitionEventType = /*#__PURE__*/ function(TransitionEventType) {
+    /** Task assigned to agent */ TransitionEventType["TASK_ASSIGNED"] = "task_assigned";
+    /** Agent started execution */ TransitionEventType["EXECUTION_STARTED"] = "execution_started";
+    /** Agent completed task successfully */ TransitionEventType["EXECUTION_COMPLETED"] = "execution_completed";
+    /** Agent encountered error */ TransitionEventType["EXECUTION_FAILED"] = "execution_failed";
+    /** Agent waiting on dependency */ TransitionEventType["DEPENDENCY_BLOCKED"] = "dependency_blocked";
+    /** Dependency resolved, agent can resume */ TransitionEventType["DEPENDENCY_RESOLVED"] = "dependency_resolved";
+    /** Agent requested to help another agent */ TransitionEventType["HELP_REQUESTED"] = "help_requested";
+    /** Agent finished helping and returning to own work */ TransitionEventType["HELP_COMPLETED"] = "help_completed";
+    /** Agent deadlocked or requires intervention */ TransitionEventType["DEADLOCK_DETECTED"] = "deadlock_detected";
+    /** Agent recovered from error and ready to retry */ TransitionEventType["ERROR_RECOVERED"] = "error_recovered";
+    return TransitionEventType;
+}({});
+/**
+ * Validates a state transition against allowed transitions.
+ *
+ * @param fromState - Current agent state
+ * @param toState - Target agent state
+ * @param allowedTransitions - Map of allowed state transitions
+ * @returns Validation result with error details if invalid
+ *
+ * @example
+ * ```typescript
+ * const result = validateTransition(
+ *   AgentState.IDLE,
+ *   AgentState.WORKING,
+ *   STATE_TRANSITIONS
+ * );
+ * if (!result.isValid) {
+ *   throw new Error(result.error);
+ * }
+ * ```
+ */ export function validateTransition(fromState, toState, allowedTransitions) {
+    const startTime = Date.now();
+    // Check if fromState exists in transition map
+    const allowedStates = allowedTransitions[fromState];
+    if (!allowedStates) {
+        return {
+            isValid: false,
+            error: `Invalid source state: ${fromState}`
+        };
+    }
+    // Check if transition to toState is allowed
+    if (!allowedStates.includes(toState)) {
+        return {
+            isValid: false,
+            error: `Invalid transition from ${fromState} to ${toState}. Allowed: ${allowedStates.join(', ')}`
+        };
+    }
+    // Validate performance requirement: <1ms
+    const duration = Date.now() - startTime;
+    const warnings = [];
+    if (duration >= 1) {
+        warnings.push(`Transition validation took ${duration}ms (target: <1ms)`);
+    }
+    return {
+        isValid: true,
+        warnings: warnings.length > 0 ? warnings : undefined
+    };
+}
+/**
+ * Creates a state transition event with proper timestamp and validation.
+ *
+ * @param type - Event type
+ * @param agentId - Agent triggering the transition
+ * @param fromState - Current state
+ * @param toState - Target state
+ * @param metadata - Optional event-specific metadata
+ * @returns Validated transition event
+ *
+ * @example
+ * ```typescript
+ * const event = createTransitionEvent(
+ *   TransitionEventType.TASK_ASSIGNED,
+ *   'agent-123',
+ *   AgentState.IDLE,
+ *   AgentState.WORKING,
+ *   { taskId: 'task-456', taskType: 'coder' }
+ * );
+ * ```
+ */ export function createTransitionEvent(type, agentId, fromState, toState, metadata) {
+    if (!agentId || agentId.trim().length === 0) {
+        throw new Error('agentId is required and cannot be empty');
+    }
+    return {
+        type,
+        agentId,
+        timestamp: new Date().toISOString(),
+        fromState,
+        toState,
+        metadata
+    };
+}
+/**
+ * Type guard to check if an event is a specific transition event type.
+ *
+ * @param event - Event to check
+ * @param type - Expected event type
+ * @returns True if event matches the specified type
+ *
+ * @example
+ * ```typescript
+ * if (isEventType(event, TransitionEventType.TASK_ASSIGNED)) {
+ *   // TypeScript knows event is TaskAssignedEvent
+ *   console.log(event.metadata.taskId);
+ * }
+ * ```
+ */ export function isEventType(event, type) {
+    return event.type === type;
+}
+/**
+ * Checks if a transition event represents an error condition.
+ *
+ * @param event - Transition event to check
+ * @returns True if event represents an error
+ *
+ * @example
+ * ```typescript
+ * if (isErrorEvent(event)) {
+ *   handleError(event);
+ * }
+ * ```
+ */ export function isErrorEvent(event) {
+    return event.type === "execution_failed" || event.type === "deadlock_detected" || event.toState === AgentState.ERROR || event.toState === AgentState.BLOCKED;
+}
+/**
+ * Checks if a transition event represents a terminal state change.
+ *
+ * @param event - Transition event to check
+ * @returns True if event leads to terminal state
+ *
+ * @example
+ * ```typescript
+ * if (isTerminalEvent(event)) {
+ *   finalizeAgent(event.agentId);
+ * }
+ * ```
+ */ export function isTerminalEvent(event) {
+    return event.toState === AgentState.COMPLETED || event.toState === AgentState.TERMINATED || event.toState === AgentState.ERROR;
+}
+
+//# sourceMappingURL=state-transition.js.map

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/core/state-transition.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../src/coordination/archives/v2-sdk-typescript/v2/core/state-transition.ts"],"names":["AgentState","TransitionEventType","validateTransition","fromState","toState","allowedTransitions","startTime","Date","now","allowedStates","isValid","error","includes","join","duration","warnings","push","length","undefined","createTransitionEvent","type","agentId","metadata","trim","Error","timestamp","toISOString","isEventType","event","isErrorEvent","ERROR","BLOCKED","isTerminalEvent","COMPLETED","TERMINATED"],"mappings":"AAAA;;;;;;;CAOC,GAED,SAASA,UAAU,QAAQ,mBAAmB;AAE9C;;;CAGC,GACD,OAAO,IAAA,AAAKC,6CAAAA;IACV,2BAA2B;IAG3B,4BAA4B;IAG5B,sCAAsC;IAGtC,4BAA4B;IAG5B,gCAAgC;IAGhC,0CAA0C;IAG1C,0CAA0C;IAG1C,qDAAqD;IAGrD,8CAA8C;IAG9C,kDAAkD;WA5BxCA;MA8BX;AAgHD;;;;;;;;;;;;;;;;;;;CAmBC,GACD,OAAO,SAASC,mBACdC,SAAqB,EACrBC,OAAmB,EACnBC,kBAAoD;IAEpD,MAAMC,YAAYC,KAAKC,GAAG;IAE1B,8CAA8C;IAC9C,MAAMC,gBAAgBJ,kBAAkB,CAACF,UAAU;IACnD,IAAI,CAACM,eAAe;QAClB,OAAO;YACLC,SAAS;YACTC,OAAO,CAAC,sBAAsB,EAAER,WAAW;QAC7C;IACF;IAEA,4CAA4C;IAC5C,IAAI,CAACM,cAAcG,QAAQ,CAACR,UAAU;QACpC,OAAO;YACLM,SAAS;YACTC,OAAO,CAAC,wBAAwB,EAAER,UAAU,IAAI,EAAEC,QAAQ,WAAW,EAAEK,cAAcI,IAAI,CAAC,OAAO;QACnG;IACF;IAEA,yCAAyC;IACzC,MAAMC,WAAWP,KAAKC,GAAG,KAAKF;IAC9B,MAAMS,WAAqB,EAAE;IAC7B,IAAID,YAAY,GAAG;QACjBC,SAASC,IAAI,CAAC,CAAC,2BAA2B,EAAEF,SAAS,iBAAiB,CAAC;IACzE;IAEA,OAAO;QACLJ,SAAS;QACTK,UAAUA,SAASE,MAAM,GAAG,IAAIF,WAAWG;IAC7C;AACF;AAEA;;;;;;;;;;;;;;;;;;;;CAoBC,GACD,OAAO,SAASC,sBACdC,IAAyB,EACzBC,OAAe,EACflB,SAAqB,EACrBC,OAAmB,EACnBkB,QAAkC;IAElC,IAAI,CAACD,WAAWA,QAAQE,IAAI,GAAGN,MAAM,KAAK,GAAG;QAC3C,MAAM,IAAIO,MAAM;IAClB;IAEA,OAAO;QACLJ;QACAC;QACAI,WAAW,IAAIlB,OAAOmB,WAAW;QACjCvB;QACAC;QACAkB;IACF;AACF;AAEA;;;;;;;;;;;;;;CAcC,GACD,OAAO,SAASK,YACdC,KAA2B,EAC3BR,IAAO;IAEP,OAAOQ,MAAMR,IAAI,KAAKA;AACxB;AAEA;;;;;;;;;;;;CAYC,GACD,OAAO,SAASS,aAAaD,KAA2B;IACtD,OACEA,MAAMR,IAAI,2BACVQ,MAAMR,IAAI,4BACVQ,MAAMxB,OAAO,KAAKJ,WAAW8B,KAAK,IAClCF,MAAMxB,OAAO,KAAKJ,WAAW+B,OAAO;AAExC;AAEA;;;;;;;;;;;;CAYC,GACD,OAAO,SAASC,gBAAgBJ,KAA2B;IACzD,OACEA,MAAMxB,OAAO,KAAKJ,WAAWiC,SAAS,IACtCL,MAAMxB,OAAO,KAAKJ,WAAWkC,UAAU,IACvCN,MAAMxB,OAAO,KAAKJ,WAAW8B,KAAK;AAEtC"}

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/core/task-scheduler.js

@@ -0,0 +1,360 @@
+/**
+ * Agent Coordination V2 - Task Scheduler Implementation
+ *
+ * Priority-based task scheduler with:
+ * - Event-driven architecture (task:assigned, task:completed, task:failed)
+ * - 3 priority strategies: strict, balanced, loose
+ * - Configurable retry logic with retry limits
+ * - Comprehensive metrics tracking
+ * - Polling-based task assignment
+ *
+ * @module coordination/v2/core/task-scheduler
+ */ import { EventEmitter } from 'events';
+import { DependencyResolver } from './dependency-resolver.js';
+import { DependencyNodeStatus } from './dependency-node.js';
+/**
+ * Task Scheduler - Priority-based scheduling with dependency resolution.
+ *
+ * Provides:
+ * - Automatic task assignment based on dependency readiness
+ * - Three priority weighting strategies
+ * - Event-driven notifications for task lifecycle
+ * - Retry logic with configurable limits
+ * - Real-time metrics tracking
+ *
+ * @example
+ * ```typescript
+ * const scheduler = new TaskScheduler(graph, {
+ *   maxConcurrency: 5,
+ *   pollInterval: 100,
+ *   retryLimit: 3,
+ *   priorityWeighting: 'balanced'
+ * });
+ *
+ * scheduler.on('task:assigned', ({ taskId, task }) => {
+ *   console.log(`Task ${taskId} assigned for execution`);
+ * });
+ *
+ * scheduler.on('task:completed', ({ taskId }) => {
+ *   console.log(`Task ${taskId} completed`);
+ * });
+ *
+ * scheduler.start();
+ * ```
+ */ export class TaskScheduler extends EventEmitter {
+    graph;
+    config;
+    resolver;
+    runningTasks;
+    schedulerInterval;
+    retryCounters;
+    taskOwners;
+    /**
+   * Creates a new task scheduler.
+   *
+   * @param graph - Dependency graph containing tasks
+   * @param config - Scheduler configuration
+   */ constructor(graph, config){
+        super(), this.graph = graph, this.config = config;
+        this.resolver = new DependencyResolver(graph);
+        this.runningTasks = new Set();
+        this.retryCounters = new Map();
+        this.taskOwners = new Map(); // SEC-005: Initialize ownership map
+    }
+    // ============================================
+    // Lifecycle Management
+    // ============================================
+    /**
+   * Starts the task scheduler.
+   *
+   * Begins polling for ready tasks at the configured interval.
+   */ start() {
+        if (this.schedulerInterval) {
+            throw new Error('Scheduler is already running');
+        }
+        this.schedulerInterval = setInterval(()=>{
+            this.scheduleTasks();
+        }, this.config.pollInterval);
+        // Run initial scheduling immediately
+        this.scheduleTasks();
+    }
+    /**
+   * Stops the task scheduler.
+   *
+   * Cancels the polling interval but does not affect running tasks.
+   */ stop() {
+        if (this.schedulerInterval) {
+            clearInterval(this.schedulerInterval);
+            this.schedulerInterval = undefined;
+        }
+    }
+    // ============================================
+    // Task Scheduling
+    // ============================================
+    /**
+   * Adds a task to the scheduler queue.
+   *
+   * The task is added to the dependency graph and scheduling is triggered immediately.
+   * If the scheduler is running, the task will be picked up in the next polling cycle.
+   *
+   * @param task - Task to schedule
+   */ scheduleTask(task) {
+        // Normalize task: ensure taskId is set (use id if taskId not provided)
+        const normalizedTask = {
+            ...task,
+            taskId: task.taskId || task.id || task.id
+        };
+        this.graph.addNode(normalizedTask);
+        this.scheduleTasks(); // Trigger immediate scheduling check
+        this.emit('task:queued', {
+            taskId: normalizedTask.taskId
+        });
+    }
+    /**
+   * Schedules tasks based on dependency readiness and concurrency limits.
+   *
+   * Called automatically at each poll interval.
+   * @private
+   */ scheduleTasks() {
+        const tasks = this.selectNextTasks();
+        for (const task of tasks){
+            this.assignTask(task);
+        }
+    }
+    /**
+   * Selects next tasks to run based on priority strategy.
+   *
+   * @returns Array of tasks to assign
+   * @private
+   */ selectNextTasks() {
+        // Get ready tasks from resolver
+        const ready = this.resolver.getNextBatch(this.config.maxConcurrency - this.runningTasks.size);
+        if (ready.length === 0) {
+            return [];
+        }
+        // Apply priority weighting strategy
+        switch(this.config.priorityWeighting){
+            case 'strict':
+                return this.strictPrioritySelection(ready);
+            case 'balanced':
+                return this.balancedSelection(ready);
+            case 'loose':
+                return this.loosePrioritySelection(ready);
+            default:
+                return ready;
+        }
+    }
+    /**
+   * Strict priority selection: Always choose highest priority tasks.
+   *
+   * @param ready - Array of ready tasks
+   * @returns Selected tasks
+   * @private
+   */ strictPrioritySelection(ready) {
+        // Tasks are already sorted by priority (highest first) from graph.getReadyTasks()
+        return ready;
+    }
+    /**
+   * Balanced selection: Mix high priority with longest-waiting tasks.
+   *
+   * Algorithm:
+   * - 70% high priority tasks
+   * - 30% longest waiting tasks (by createdAt timestamp)
+   *
+   * @param ready - Array of ready tasks
+   * @returns Selected tasks
+   * @private
+   */ balancedSelection(ready) {
+        if (ready.length <= 2) {
+            return ready; // Too few to balance
+        }
+        const available = this.config.maxConcurrency - this.runningTasks.size;
+        const highPriorityCount = Math.ceil(available * 0.7);
+        const longWaitingCount = available - highPriorityCount;
+        // Get high priority tasks (already sorted)
+        const highPriority = ready.slice(0, highPriorityCount);
+        // Get longest waiting tasks (sort by createdAt)
+        const remaining = ready.slice(highPriorityCount);
+        const longWaiting = remaining.sort((a, b)=>a.createdAt - b.createdAt).slice(0, longWaitingCount);
+        return [
+            ...highPriority,
+            ...longWaiting
+        ];
+    }
+    /**
+   * Loose priority selection: Favor fairness over strict priority.
+   *
+   * Algorithm:
+   * - Round-robin selection across priority levels
+   * - Prevents high-priority task monopolization
+   *
+   * @param ready - Array of ready tasks
+   * @returns Selected tasks
+   * @private
+   */ loosePrioritySelection(ready) {
+        // Group tasks by priority level
+        const priorityGroups = new Map();
+        for (const task of ready){
+            const priority = task.priority;
+            if (!priorityGroups.has(priority)) {
+                priorityGroups.set(priority, []);
+            }
+            priorityGroups.get(priority).push(task);
+        }
+        // Round-robin selection across priority groups
+        const selected = [];
+        const available = this.config.maxConcurrency - this.runningTasks.size;
+        const priorities = Array.from(priorityGroups.keys()).sort((a, b)=>b - a);
+        let index = 0;
+        while(selected.length < available && selected.length < ready.length){
+            const priority = priorities[index % priorities.length];
+            const group = priorityGroups.get(priority);
+            if (group.length > 0) {
+                selected.push(group.shift());
+            }
+            index++;
+            // Remove empty groups
+            if (group.length === 0) {
+                priorityGroups.delete(priority);
+                priorities.splice(priorities.indexOf(priority), 1);
+            }
+            if (priorities.length === 0) {
+                break;
+            }
+        }
+        return selected;
+    }
+    /**
+   * Assigns a task for execution.
+   *
+   * @param task - Task to assign
+   * @private
+   */ assignTask(task) {
+        // Mark as running
+        this.runningTasks.add(task.taskId);
+        this.taskOwners.set(task.taskId, task.agentId); // SEC-005: Track ownership
+        this.graph.updateStatus(task.taskId, DependencyNodeStatus.EXECUTING);
+        // Emit assignment event
+        this.emit('task:assigned', {
+            taskId: task.taskId,
+            task
+        });
+    }
+    // ============================================
+    // Task Lifecycle Handlers
+    // ============================================
+    /**
+   * Handles task completion.
+   *
+   * Called by external execution system when a task finishes successfully.
+   *
+   * @param taskId - ID of the completed task
+   * @param callerId - Optional caller ID for authorization (SEC-005)
+   */ onTaskCompleted(taskId, callerId) {
+        if (!this.runningTasks.has(taskId)) {
+            console.warn(`Task ${taskId} completed but was not tracked as running`);
+            return;
+        }
+        // SEC-005: Validate caller is task owner
+        const owner = this.taskOwners.get(taskId);
+        if (callerId && callerId !== owner) {
+            throw new Error(`Unauthorized task completion: ${callerId} is not owner of ${taskId} (owner: ${owner})`);
+        }
+        // Remove from running set
+        this.runningTasks.delete(taskId);
+        this.taskOwners.delete(taskId); // SEC-005: Cleanup ownership
+        // Update graph status
+        this.graph.updateStatus(taskId, DependencyNodeStatus.COMPLETED);
+        // Clear retry counter
+        this.retryCounters.delete(taskId);
+        // Emit completion event
+        this.emit('task:completed', {
+            taskId
+        });
+        // Trigger immediate scheduling check (dependent tasks may now be ready)
+        this.scheduleTasks();
+    }
+    /**
+   * Handles task failure.
+   *
+   * Implements retry logic with configurable retry limit.
+   * If retries exhausted, marks task as FAILED.
+   *
+   * @param taskId - ID of the failed task
+   * @param error - Error that caused the failure
+   * @param callerId - Optional caller ID for authorization (SEC-005)
+   */ onTaskFailed(taskId, error, callerId) {
+        if (!this.runningTasks.has(taskId)) {
+            console.warn(`Task ${taskId} failed but was not tracked as running`);
+            return;
+        }
+        // SEC-005: Validate caller is task owner
+        const owner = this.taskOwners.get(taskId);
+        if (callerId && callerId !== owner) {
+            throw new Error(`Unauthorized task failure report: ${callerId} is not owner of ${taskId} (owner: ${owner})`);
+        }
+        // Remove from running set
+        this.runningTasks.delete(taskId);
+        this.taskOwners.delete(taskId); // SEC-005: Cleanup ownership
+        // Get/increment retry counter
+        const retryCount = (this.retryCounters.get(taskId) ?? 0) + 1;
+        this.retryCounters.set(taskId, retryCount);
+        // Check retry limit
+        if (retryCount < this.config.retryLimit) {
+            // Retry: reset to READY status
+            this.graph.updateStatus(taskId, DependencyNodeStatus.READY);
+            // Emit failure event with retry indication
+            this.emit('task:failed', {
+                taskId,
+                error,
+                retryCount
+            });
+        // Schedule retry on next poll
+        // (task will be picked up automatically as READY)
+        } else {
+            // Retries exhausted: mark as FAILED
+            this.graph.updateStatus(taskId, DependencyNodeStatus.FAILED);
+            // Emit failure event
+            this.emit('task:failed', {
+                taskId,
+                error,
+                retryCount
+            });
+        }
+    }
+    // ============================================
+    // Metrics
+    // ============================================
+    /**
+   * Gets current scheduler metrics.
+   *
+   * @returns Scheduler metrics snapshot
+   */ getMetrics() {
+        const readyTasks = this.graph.getReadyTasks();
+        const blockedTasks = this.graph.getBlockedTasks();
+        return {
+            totalTasks: this.graph.size(),
+            completed: this.graph.completedTasks.size,
+            running: this.runningTasks.size,
+            ready: readyTasks.length,
+            blocked: blockedTasks.length
+        };
+    }
+    /**
+   * Gets the set of currently running task IDs.
+   *
+   * @returns Set of running task IDs
+   */ getRunningTasks() {
+        return new Set(this.runningTasks);
+    }
+    /**
+   * Gets the retry count for a specific task.
+   *
+   * @param taskId - Task ID
+   * @returns Retry count (0 if no retries)
+   */ getRetryCount(taskId) {
+        return this.retryCounters.get(taskId) ?? 0;
+    }
+}
+
+//# sourceMappingURL=task-scheduler.js.map

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/core/task-scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../src/coordination/archives/v2-sdk-typescript/v2/core/task-scheduler.ts"],"names":["EventEmitter","DependencyResolver","DependencyNodeStatus","TaskScheduler","resolver","runningTasks","schedulerInterval","retryCounters","taskOwners","graph","config","Set","Map","start","Error","setInterval","scheduleTasks","pollInterval","stop","clearInterval","undefined","scheduleTask","task","normalizedTask","taskId","id","addNode","emit","tasks","selectNextTasks","assignTask","ready","getNextBatch","maxConcurrency","size","length","priorityWeighting","strictPrioritySelection","balancedSelection","loosePrioritySelection","available","highPriorityCount","Math","ceil","longWaitingCount","highPriority","slice","remaining","longWaiting","sort","a","b","createdAt","priorityGroups","priority","has","set","get","push","selected","priorities","Array","from","keys","index","group","shift","delete","splice","indexOf","add","agentId","updateStatus","EXECUTING","onTaskCompleted","callerId","console","warn","owner","COMPLETED","onTaskFailed","error","retryCount","retryLimit","READY","FAILED","getMetrics","readyTasks","getReadyTasks","blockedTasks","getBlockedTasks","totalTasks","completed","completedTasks","running","blocked","getRunningTasks","getRetryCount"],"mappings":"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"}