claude-flow-novice 1.6.1 → 1.6.3

package/.claude-flow-novice/dist/src/coordination/v2/dependency/dependency-manager.js

@@ -0,0 +1,439 @@
+/**
+ * Agent Coordination V2 - Dependency Manager Implementation
+ *
+ * Coordinates dependency resolution using topological sorting and graph analysis.
+ * Provides high-level API for managing agent task dependencies.
+ *
+ * @module coordination/v2/dependency/dependency-manager
+ */ import { DependencyGraph } from '../core/dependency-graph.js';
+import { DependencyNodeStatus, DependencyNodeImpl } from '../core/dependency-node.js';
+import { TopologicalSort } from './topological-sort.js';
+/**
+ * Dependency Manager for Agent Coordination.
+ *
+ * Provides high-level dependency management operations:
+ * - Task registration with dependency tracking
+ * - Topological resolution for execution ordering
+ * - Incremental batch resolution for concurrent execution
+ * - Status tracking and propagation
+ * - Cycle detection and validation
+ *
+ * @example
+ * ```typescript
+ * const manager = new DependencyManager();
+ *
+ * // Register tasks with dependencies
+ * manager.registerTask({
+ *   id: 'task-1',
+ *   agentId: 'agent-a',
+ *   taskId: 'implement-auth',
+ *   dependencies: []
+ * });
+ *
+ * manager.registerTask({
+ *   id: 'task-2',
+ *   agentId: 'agent-b',
+ *   taskId: 'test-auth',
+ *   dependencies: ['task-1']
+ * });
+ *
+ * // Resolve dependencies
+ * const resolution = manager.resolveDependencies({
+ *   agentId: 'agent-b',
+ *   taskId: 'test-auth'
+ * });
+ *
+ * console.log('Execution order:', resolution.executionOrder);
+ * console.log('Ready tasks:', resolution.readyTasks);
+ * ```
+ */ export class DependencyManager {
+    graph;
+    sorter;
+    config;
+    completedTasks;
+    /**
+   * Creates a new dependency manager.
+   *
+   * @param config - Manager configuration
+   */ constructor(config){
+        this.config = {
+            maxGraphSize: config?.maxGraphSize ?? 10000,
+            autoValidate: config?.autoValidate ?? true,
+            trackPerformance: config?.trackPerformance ?? false
+        };
+        this.graph = new DependencyGraph({
+            maxSize: this.config.maxGraphSize,
+            autoValidate: this.config.autoValidate
+        });
+        this.sorter = new TopologicalSort(this.graph);
+        this.completedTasks = new Set();
+    }
+    // ============================================
+    // Task Registration
+    // ============================================
+    /**
+   * Registers a new task with its dependencies.
+   *
+   * @param config - Task configuration
+   * @throws {DependencyNodeValidationError} If task configuration is invalid
+   * @throws {DependencyGraphError} If adding task would create cycle
+   */ registerTask(config) {
+        const startTime = this.config.trackPerformance ? performance.now() : 0;
+        // Create dependency node
+        const node = new DependencyNodeImpl({
+            id: config.id,
+            agentId: config.agentId,
+            taskId: config.taskId,
+            dependencies: config.dependencies || [],
+            priority: config.priority,
+            metadata: config.metadata
+        });
+        // Add to graph
+        this.graph.addNode(node);
+        // Add dependency edges
+        if (config.dependencies && config.dependencies.length > 0) {
+            for (const depId of config.dependencies){
+                this.graph.addDependency(config.id, depId);
+            }
+        }
+        if (this.config.trackPerformance) {
+            const duration = performance.now() - startTime;
+            console.debug(`[DependencyManager] registerTask(${config.id}): ${duration.toFixed(2)}ms`);
+        }
+    }
+    /**
+   * Unregisters a task from the dependency graph.
+   *
+   * @param taskId - Task ID to unregister
+   * @returns True if task was removed, false if not found
+   */ unregisterTask(taskId) {
+        const removed = this.graph.removeNode(taskId);
+        if (removed) {
+            this.completedTasks.delete(taskId);
+        }
+        return removed;
+    }
+    /**
+   * Adds a dependency between two tasks.
+   *
+   * @param fromId - Task that depends on another
+   * @param toId - Task that is depended upon
+   * @throws {DependencyGraphError} If dependency would create cycle
+   */ addDependency(fromId, toId) {
+        this.graph.addDependency(fromId, toId);
+    }
+    /**
+   * Removes a dependency between two tasks.
+   *
+   * @param fromId - Dependent task ID
+   * @param toId - Dependency task ID
+   * @returns True if dependency was removed
+   */ removeDependency(fromId, toId) {
+        return this.graph.removeDependency(fromId, toId);
+    }
+    // ============================================
+    // Dependency Resolution
+    // ============================================
+    /**
+   * Resolves dependencies for a task and returns execution plan.
+   *
+   * Uses topological sorting to compute valid execution order.
+   * Returns ready tasks for immediate execution and execution levels
+   * for parallel processing.
+   *
+   * @param request - Resolution request
+   * @returns Resolution response with execution plan
+   */ resolveDependencies(request) {
+        const startTime = this.config.trackPerformance ? performance.now() : 0;
+        // Perform topological sort
+        const sortResult = this.sorter.sort();
+        if (!sortResult.success) {
+            // Cycle detected - cannot resolve
+            return {
+                success: false,
+                executionOrder: [],
+                readyTasks: [],
+                blockedTasks: [],
+                error: sortResult.error,
+                cycles: sortResult.cycles
+            };
+        }
+        // Get ready tasks (all dependencies satisfied)
+        const readyTasks = this.graph.getReadyTasks();
+        // Get blocked tasks (waiting on dependencies)
+        const blockedTasks = this.graph.getBlockedTasks();
+        // Compute execution levels (for parallel execution)
+        const levels = this.sorter.computeLevels();
+        // Apply concurrency limit if specified
+        let readyForExecution = readyTasks;
+        if (request.maxConcurrency && request.maxConcurrency > 0) {
+            readyForExecution = readyTasks.slice(0, request.maxConcurrency);
+        }
+        if (this.config.trackPerformance) {
+            const duration = performance.now() - startTime;
+            console.debug(`[DependencyManager] resolveDependencies(): ${duration.toFixed(2)}ms`);
+        }
+        return {
+            success: true,
+            executionOrder: sortResult.order,
+            readyTasks: readyForExecution,
+            blockedTasks,
+            levels
+        };
+    }
+    /**
+   * Gets the next batch of ready tasks for execution.
+   *
+   * This is useful for incremental execution without re-sorting entire graph.
+   *
+   * @param maxConcurrency - Maximum tasks to return
+   * @returns Array of ready tasks
+   */ getNextBatch(maxConcurrency = 1) {
+        const ready = this.sorter.getReadyNodes(this.completedTasks);
+        // Get node objects and apply concurrency limit
+        const readyNodes = ready.slice(0, maxConcurrency).map((id)=>this.graph.getNode(id)).filter((node)=>node !== undefined);
+        return readyNodes;
+    }
+    /**
+   * Resolves dependencies for a specific agent's tasks only.
+   *
+   * @param agentId - Agent ID to resolve for
+   * @returns Execution order for agent's tasks
+   */ resolveForAgent(agentId) {
+        // Get all tasks for this agent
+        const agentTasks = this.graph.getAllNodes().filter((node)=>node.agentId === agentId).map((node)=>node.id);
+        // Compute subset topological order
+        const order = this.sorter.sortSubset(new Set(agentTasks));
+        return order ?? [];
+    }
+    // ============================================
+    // Status Management
+    // ============================================
+    /**
+   * Updates the status of a task.
+   *
+   * @param update - Status update
+   */ updateTaskStatus(update) {
+        this.graph.updateStatus(update.taskId, update.status);
+        // Track completed tasks
+        if (update.status === DependencyNodeStatus.COMPLETED) {
+            this.completedTasks.add(update.taskId);
+        } else {
+            this.completedTasks.delete(update.taskId);
+        }
+    }
+    /**
+   * Marks a task as completed.
+   *
+   * @param taskId - Task ID to complete
+   */ completeTask(taskId) {
+        this.updateTaskStatus({
+            taskId,
+            status: DependencyNodeStatus.COMPLETED,
+            timestamp: Date.now()
+        });
+    }
+    /**
+   * Marks a task as failed.
+   *
+   * @param taskId - Task ID to mark as failed
+   */ failTask(taskId) {
+        this.updateTaskStatus({
+            taskId,
+            status: DependencyNodeStatus.FAILED,
+            timestamp: Date.now()
+        });
+    }
+    /**
+   * Gets all tasks that are blocked due to failed dependencies.
+   *
+   * @returns Array of task IDs that cannot proceed
+   */ getUnresolvableTasks() {
+        const failedNodes = new Set(this.graph.getAllNodes().filter((node)=>node.status === DependencyNodeStatus.FAILED).map((node)=>node.id));
+        const unresolvable = [];
+        for (const node of this.graph.getAllNodes()){
+            if (failedNodes.has(node.id)) continue;
+            const chain = this.graph.getDependencyChain(node.id);
+            for (const depId of chain){
+                if (failedNodes.has(depId)) {
+                    unresolvable.push(node.id);
+                    break;
+                }
+            }
+        }
+        return unresolvable;
+    }
+    // ============================================
+    // Graph Queries
+    // ============================================
+    /**
+   * Checks if graph contains cycles.
+   *
+   * @returns True if cycles exist
+   */ hasCycles() {
+        return !this.sorter.isDAG();
+    }
+    /**
+   * Gets detailed cycle information.
+   *
+   * @returns Cycle detection result
+   */ getCycles() {
+        return this.graph.detectCycles().cycles;
+    }
+    /**
+   * Gets execution levels (nodes at same depth can run in parallel).
+   *
+   * @returns Array of execution levels
+   */ getExecutionLevels() {
+        return this.sorter.computeLevels();
+    }
+    /**
+   * Gets maximum parallelization factor (max concurrent tasks).
+   *
+   * @returns Maximum number of tasks that can run concurrently
+   */ getMaxParallelism() {
+        const levels = this.sorter.computeLevels();
+        return Math.max(...levels.map((level)=>level.length), 0);
+    }
+    /**
+   * Gets graph statistics.
+   *
+   * @returns Graph metrics
+   */ getStatistics() {
+        const stats = this.graph.getStatistics();
+        return {
+            totalTasks: stats.nodeCount,
+            completedTasks: stats.completedNodeCount,
+            readyTasks: stats.readyNodeCount,
+            blockedTasks: stats.blockedNodeCount,
+            failedTasks: this.graph.getAllNodes().filter((n)=>n.status === DependencyNodeStatus.FAILED).length,
+            maxParallelism: this.getMaxParallelism(),
+            hasCycles: this.hasCycles()
+        };
+    }
+    /**
+   * Gets a specific task node.
+   *
+   * @param taskId - Task ID
+   * @returns Task node or undefined
+   */ getTask(taskId) {
+        return this.graph.getNode(taskId);
+    }
+    /**
+   * Gets all tasks.
+   *
+   * @returns Array of all task nodes
+   */ getAllTasks() {
+        return this.graph.getAllNodes();
+    }
+    /**
+   * Gets dependencies for a task.
+   *
+   * @param taskId - Task ID
+   * @returns Set of dependency task IDs
+   */ getDependencies(taskId) {
+        return this.graph.getDependencies(taskId);
+    }
+    /**
+   * Gets dependents for a task (tasks that depend on it).
+   *
+   * @param taskId - Task ID
+   * @returns Set of dependent task IDs
+   */ getDependents(taskId) {
+        return this.graph.getDependents(taskId);
+    }
+    /**
+   * Gets the full dependency chain for a task (transitive dependencies).
+   *
+   * @param taskId - Task ID
+   * @returns Array of task IDs in dependency order
+   */ getDependencyChain(taskId) {
+        return this.graph.getDependencyChain(taskId);
+    }
+    // ============================================
+    // Validation
+    // ============================================
+    /**
+   * Validates graph integrity.
+   *
+   * @returns Array of validation errors (empty if valid)
+   */ validate() {
+        const errors = this.graph.validate();
+        // Additional manager-level validations
+        if (this.hasCycles()) {
+            const cycles = this.getCycles();
+            errors.push(`Graph contains ${cycles.length} cycle(s): ${JSON.stringify(cycles)}`);
+        }
+        return errors;
+    }
+    /**
+   * Checks if graph is in valid state for execution.
+   *
+   * @returns True if graph can be executed
+   */ canExecute() {
+        const errors = this.validate();
+        return errors.length === 0;
+    }
+    // ============================================
+    // Utility Methods
+    // ============================================
+    /**
+   * Clears all tasks from the manager.
+   */ clear() {
+        this.graph.clear();
+        this.completedTasks.clear();
+    }
+    /**
+   * Gets the number of tasks in the graph.
+   *
+   * @returns Task count
+   */ size() {
+        return this.graph.size();
+    }
+    /**
+   * Exports graph to DOT format for visualization.
+   *
+   * @returns DOT format string
+   */ toDOT() {
+        let dot = 'digraph DependencyGraph {\n';
+        dot += '  rankdir=LR;\n';
+        dot += '  node [shape=box];\n\n';
+        // Add nodes with status colors
+        for (const node of this.graph.getAllNodes()){
+            const color = this.getNodeColor(node.status);
+            dot += `  "${node.id}" [label="${node.taskId}\\n(${node.agentId})" style=filled fillcolor="${color}"];\n`;
+        }
+        dot += '\n';
+        // Add edges
+        for (const node of this.graph.getAllNodes()){
+            const deps = this.graph.getDependencies(node.id);
+            for (const depId of deps){
+                dot += `  "${depId}" -> "${node.id}";\n`;
+            }
+        }
+        dot += '}\n';
+        return dot;
+    }
+    /**
+   * Gets color for node based on status.
+   *
+   * @param status - Node status
+   * @returns Color code
+   */ getNodeColor(status) {
+        switch(status){
+            case DependencyNodeStatus.COMPLETED:
+                return 'lightgreen';
+            case DependencyNodeStatus.EXECUTING:
+                return 'lightblue';
+            case DependencyNodeStatus.READY:
+                return 'lightyellow';
+            case DependencyNodeStatus.FAILED:
+                return 'lightcoral';
+            case DependencyNodeStatus.PENDING:
+            default:
+                return 'lightgray';
+        }
+    }
+}
+
+//# sourceMappingURL=dependency-manager.js.map

package/.claude-flow-novice/dist/src/coordination/v2/dependency/dependency-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/coordination/v2/dependency/dependency-manager.ts"],"names":["DependencyGraph","DependencyNodeStatus","DependencyNodeImpl","TopologicalSort","DependencyManager","graph","sorter","config","completedTasks","maxGraphSize","autoValidate","trackPerformance","maxSize","Set","registerTask","startTime","performance","now","node","id","agentId","taskId","dependencies","priority","metadata","addNode","length","depId","addDependency","duration","console","debug","toFixed","unregisterTask","removed","removeNode","delete","fromId","toId","removeDependency","resolveDependencies","request","sortResult","sort","success","executionOrder","readyTasks","blockedTasks","error","cycles","getReadyTasks","getBlockedTasks","levels","computeLevels","readyForExecution","maxConcurrency","slice","order","getNextBatch","ready","getReadyNodes","readyNodes","map","getNode","filter","undefined","resolveForAgent","agentTasks","getAllNodes","sortSubset","updateTaskStatus","update","updateStatus","status","COMPLETED","add","completeTask","timestamp","Date","failTask","FAILED","getUnresolvableTasks","failedNodes","unresolvable","has","chain","getDependencyChain","push","hasCycles","isDAG","getCycles","detectCycles","getExecutionLevels","getMaxParallelism","Math","max","level","getStatistics","stats","totalTasks","nodeCount","completedNodeCount","readyNodeCount","blockedNodeCount","failedTasks","n","maxParallelism","getTask","getAllTasks","getDependencies","getDependents","validate","errors","JSON","stringify","canExecute","clear","size","toDOT","dot","color","getNodeColor","deps","EXECUTING","READY","PENDING"],"mappings":"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"}

package/.claude-flow-novice/dist/src/coordination/v2/dependency/dependency-request.js

@@ -0,0 +1,92 @@
+/**
+ * Agent Coordination V2 - Dependency Request Types
+ *
+ * Type-safe structures for dependency requests and resolutions.
+ * Enables agents to declare dependencies and track resolution state.
+ *
+ * @module coordination/v2/dependency/dependency-request
+ */ /**
+ * Dependency request priority levels
+ */ export var DependencyPriority = /*#__PURE__*/ function(DependencyPriority) {
+    /** Low priority - can be deferred */ DependencyPriority[DependencyPriority["LOW"] = 1] = "LOW";
+    /** Normal priority - standard processing */ DependencyPriority[DependencyPriority["NORMAL"] = 5] = "NORMAL";
+    /** High priority - expedite processing */ DependencyPriority[DependencyPriority["HIGH"] = 8] = "HIGH";
+    /** Critical priority - blocking agent progress */ DependencyPriority[DependencyPriority["CRITICAL"] = 10] = "CRITICAL";
+    return DependencyPriority;
+}({});
+/**
+ * Dependency request status
+ */ export var DependencyStatus = /*#__PURE__*/ function(DependencyStatus) {
+    /** Request created, awaiting processing */ DependencyStatus["PENDING"] = "pending";
+    /** Dependency being resolved */ DependencyStatus["RESOLVING"] = "resolving";
+    /** Dependency successfully resolved */ DependencyStatus["RESOLVED"] = "resolved";
+    /** Dependency resolution failed */ DependencyStatus["FAILED"] = "failed";
+    /** Request cancelled by requestor */ DependencyStatus["CANCELLED"] = "cancelled";
+    return DependencyStatus;
+}({});
+/**
+ * Type guard to check if request is pending
+ */ export function isPendingRequest(request) {
+    return request.status === "pending";
+}
+/**
+ * Type guard to check if request is resolved
+ */ export function isResolvedRequest(request) {
+    return request.status === "resolved" && request.resolution !== undefined;
+}
+/**
+ * Type guard to check if request is failed
+ */ export function isFailedRequest(request) {
+    return request.status === "failed";
+}
+/**
+ * Type guard to check if request is active (pending or resolving)
+ */ export function isActiveRequest(request) {
+    return request.status === "pending" || request.status === "resolving";
+}
+/**
+ * Create a new dependency request
+ */ export function createDependencyRequest(requestorId, sessionId, dependencyType, metadata, options) {
+    return {
+        requestId: `dep_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+        requestorId,
+        sessionId,
+        targetAgentId: options?.targetAgentId,
+        dependencyType,
+        priority: options?.priority ?? 5,
+        status: "pending",
+        metadata,
+        createdAt: new Date()
+    };
+}
+/**
+ * Create a dependency resolution
+ */ export function createDependencyResolution(resolverId, data, latencyMs) {
+    return {
+        resolutionId: `res_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+        resolverId,
+        resolvedAt: new Date(),
+        data,
+        latencyMs
+    };
+}
+/**
+ * Update request status
+ */ export function updateRequestStatus(request, status, resolution, error) {
+    const updated = {
+        ...request,
+        status
+    };
+    if (resolution) {
+        updated.resolution = resolution;
+    }
+    if (error) {
+        updated.error = {
+            ...error,
+            timestamp: new Date()
+        };
+    }
+    return updated;
+}
+
+//# sourceMappingURL=dependency-request.js.map

package/.claude-flow-novice/dist/src/coordination/v2/dependency/dependency-request.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/coordination/v2/dependency/dependency-request.ts"],"names":["DependencyPriority","DependencyStatus","isPendingRequest","request","status","isResolvedRequest","resolution","undefined","isFailedRequest","isActiveRequest","createDependencyRequest","requestorId","sessionId","dependencyType","metadata","options","requestId","Date","now","Math","random","toString","substring","targetAgentId","priority","createdAt","createDependencyResolution","resolverId","data","latencyMs","resolutionId","resolvedAt","updateRequestStatus","error","updated","timestamp"],"mappings":"AAAA;;;;;;;CAOC,GAID;;CAEC,GACD,OAAO,IAAA,AAAKA,4CAAAA;IACV,mCAAmC;IAGnC,0CAA0C;IAG1C,wCAAwC;IAGxC,gDAAgD;WAVtCA;MAYX;AAED;;CAEC,GACD,OAAO,IAAA,AAAKC,0CAAAA;IACV,yCAAyC;IAGzC,8BAA8B;IAG9B,qCAAqC;IAGrC,iCAAiC;IAGjC,mCAAmC;WAbzBA;MAeX;AAuFD;;CAEC,GACD,OAAO,SAASC,iBAAiBC,OAA0B;IACzD,OAAOA,QAAQC,MAAM;AACvB;AAEA;;CAEC,GACD,OAAO,SAASC,kBAAkBF,OAA0B;IAC1D,OAAOA,QAAQC,MAAM,mBAAkCD,QAAQG,UAAU,KAAKC;AAChF;AAEA;;CAEC,GACD,OAAO,SAASC,gBAAgBL,OAA0B;IACxD,OAAOA,QAAQC,MAAM;AACvB;AAEA;;CAEC,GACD,OAAO,SAASK,gBAAgBN,OAA0B;IACxD,OAAOA,QAAQC,MAAM,kBAAiCD,QAAQC,MAAM;AACtE;AAEA;;CAEC,GACD,OAAO,SAASM,wBACdC,WAAmB,EACnBC,SAAiB,EACjBC,cAAsB,EACtBC,QAA4B,EAC5BC,OAGC;IAED,OAAO;QACLC,WAAW,CAAC,IAAI,EAAEC,KAAKC,GAAG,GAAG,CAAC,EAAEC,KAAKC,MAAM,GAAGC,QAAQ,CAAC,IAAIC,SAAS,CAAC,IAAI;QACzEX;QACAC;QACAW,eAAeR,SAASQ;QACxBV;QACAW,UAAUT,SAASS;QACnBpB,MAAM;QACNU;QACAW,WAAW,IAAIR;IACjB;AACF;AAEA;;CAEC,GACD,OAAO,SAASS,2BACdC,UAAkB,EAClBC,IAAyB,EACzBC,SAAiB;IAEjB,OAAO;QACLC,cAAc,CAAC,IAAI,EAAEb,KAAKC,GAAG,GAAG,CAAC,EAAEC,KAAKC,MAAM,GAAGC,QAAQ,CAAC,IAAIC,SAAS,CAAC,IAAI;QAC5EK;QACAI,YAAY,IAAId;QAChBW;QACAC;IACF;AACF;AAEA;;CAEC,GACD,OAAO,SAASG,oBACd7B,OAA0B,EAC1BC,MAAwB,EACxBE,UAAiC,EACjC2B,KAAyC;IAEzC,MAAMC,UAAU;QAAE,GAAG/B,OAAO;QAAEC;IAAO;IAErC,IAAIE,YAAY;QACd4B,QAAQ5B,UAAU,GAAGA;IACvB;IAEA,IAAI2B,OAAO;QACTC,QAAQD,KAAK,GAAG;YACd,GAAGA,KAAK;YACRE,WAAW,IAAIlB;QACjB;IACF;IAEA,OAAOiB;AACT"}

package/.claude-flow-novice/dist/src/coordination/v2/dependency/index.js

@@ -0,0 +1,21 @@
+/**
+ * Agent Coordination V2 - Dependency Module Exports
+ *
+ * Unified exports for dependency management system.
+ * Provides DAG data structures, cycle detection, and request/resolution types.
+ *
+ * @module coordination/v2/dependency
+ */ // Dependency request types
+export { DependencyPriority, DependencyStatus, isPendingRequest, isResolvedRequest, isFailedRequest, isActiveRequest, createDependencyRequest, createDependencyResolution, updateRequestStatus } from './dependency-request.js';
+// Dependency graph (DAG)
+export { DependencyGraph } from './dependency-graph.js';
+// Cycle detection
+export { CycleDetector, detectCycle, wouldCreateCycle } from './cycle-detector.js';
+// Artifact storage backend
+export { DependencyArtifactStorage } from './artifact-storage.js';
+// Topological sort (Kahn's algorithm)
+export { TopologicalSort } from './topological-sort.js';
+// Dependency manager (coordination)
+export { DependencyManager } from './dependency-manager.js';
+
+//# sourceMappingURL=index.js.map

package/.claude-flow-novice/dist/src/coordination/v2/dependency/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/coordination/v2/dependency/index.ts"],"names":["DependencyPriority","DependencyStatus","isPendingRequest","isResolvedRequest","isFailedRequest","isActiveRequest","createDependencyRequest","createDependencyResolution","updateRequestStatus","DependencyGraph","CycleDetector","detectCycle","wouldCreateCycle","DependencyArtifactStorage","TopologicalSort","DependencyManager"],"mappings":"AAAA;;;;;;;CAOC,GAED,2BAA2B;AAC3B,SACEA,kBAAkB,EAClBC,gBAAgB,EAIhBC,gBAAgB,EAChBC,iBAAiB,EACjBC,eAAe,EACfC,eAAe,EACfC,uBAAuB,EACvBC,0BAA0B,EAC1BC,mBAAmB,QACd,0BAA0B;AAEjC,yBAAyB;AACzB,SAKEC,eAAe,QACV,wBAAwB;AAE/B,kBAAkB;AAClB,SAGEC,aAAa,EACbC,WAAW,EACXC,gBAAgB,QACX,sBAAsB;AAE7B,2BAA2B;AAC3B,SACEC,yBAAyB,QACpB,wBAAwB;AAE/B,sCAAsC;AACtC,SACEC,eAAe,QAEV,wBAAwB;AAE/B,oCAAoC;AACpC,SACEC,iBAAiB,QAKZ,0BAA0B"}