claude-code-subagents-orchestrator/dist/core/enhanced-dependency-tracker.d.ts

Claude Code Sub-agents Orchestrator - A powerful MCP server for orchestrating multiple AI sub-agents for complex task execution in Claude Code

import { EventEmitter } from 'events';
import { DependencyGraph, ArtifactContent } from '../types/filesystem.js';
export declare class EnhancedDependencyTracker extends EventEmitter {
    private dependencyGraph;
    private analysisCache;
    private circularDependencies;
    private criticalPath;
    private lastAnalysisTime;
    constructor();
    initialize(): Promise<void>;
    cleanup(): Promise<void>;
    buildDependencyGraph(artifacts: ArtifactContent[]): Promise<DependencyGraph>;
    detectCircularDependencies(): CircularDependency[];
    calculateCriticalPath(): string[];
    findParallelizableWork(): string[][];
    identifyBlockers(): string[];
    suggestWorkOrder(): WorkOrderSuggestion;
    analyzeDependencyImpact(nodeId: string): DependencyImpactAnalysis;
    getDependencyStatistics(): DependencyStatistics;
    validateGraphIntegrity(): GraphValidationResult;
    private clearGraph;
    private clearAnalysisCache;
    private createNodesFromArtifacts;
    private createEdgesFromDependencies;
    private performDependencyAnalysis;
    private dfsDetectCycles;
    private getTopologicalOrder;
    private calculateDependencyLevels;
    private subdivideParallelGroups;
    private categorizeDuration;
    private calculateNodeRiskScore;
    private calculateBlockerImpact;
    private findReadyNodes;
    private calculateNodePriority;
    private generateWorkPhases;
    private identifyOptimizationOpportunities;
    private generateNodeId;
    private calculateCycleSeverity;
    private calculateCycleImpact;
    private generateCycleResolutionSuggestions;
    private calculateTimelineImpact;
    private calculateRiskPropagation;
    private generateMitigationSuggestions;
    private calculateMaxDependencyDepth;
    private calculateStatusDistribution;
    private calculateComplexityDistribution;
    private categorizeNodeComplexity;
    private calculateRiskDistribution;
    private calculateParallelizationPotential;
    private estimateProjectCompletion;
    private assessProjectRisks;
    private generateWorkOrderRecommendations;
    private calculateParallelizationSavings;
    private findRedundantDependencies;
    private findMergeCandidates;
    private identifyCriticalRisks;
    private prioritizeRiskMitigation;
    private calculateGraphHealth;
    private generateValidationRecommendations;
}
interface CircularDependency {
    nodes: string[];
    severity: 'low' | 'medium' | 'high';
    impactedNodes: string[];
    resolutionSuggestions: string[];
}
interface WorkOrderSuggestion {
    immediateActions: string[];
    workPhases: WorkPhase[];
    parallelOpportunities: string[][];
    optimizations: OptimizationOpportunity[];
    estimatedCompletionTime: number;
    riskAssessment: ProjectRiskAssessment;
    recommendations: string[];
}
interface WorkPhase {
    name: string;
    nodes: string[];
    estimatedDuration: number;
    parallelizable: boolean;
    priority: 'low' | 'medium' | 'high' | 'critical';
}
interface OptimizationOpportunity {
    type: 'parallelization' | 'dependency_optimization' | 'task_merging';
    description: string;
    impact: 'low' | 'medium' | 'high';
    estimatedTimeSaving: number;
    nodes: string[];
}
interface DependencyImpactAnalysis {
    nodeId: string;
    directDependents: string[];
    indirectDependents: string[];
    totalImpactedNodes: string[];
    impactedCount: number;
    timelineImpact: number;
    riskPropagation: number;
    criticalPathImpact: boolean;
    mitigationSuggestions: string[];
}
interface DependencyStatistics {
    totalNodes: number;
    totalEdges: number;
    circularDependencies: number;
    criticalPathLength: number;
    maxDependencyDepth: number;
    averageDependenciesPerNode: number;
    statusDistribution: Record<string, number>;
    complexityDistribution: Record<string, number>;
    riskDistribution: Record<string, number>;
    parallelizationPotential: number;
    lastAnalysisTime: Date | null;
}
interface ProjectRiskAssessment {
    overallRisk: 'low' | 'medium' | 'high';
    criticalRisks: string[];
    mitigationPriority: string[];
    riskFactors: Record<string, number>;
}
interface GraphValidationResult {
    isValid: boolean;
    health: 'excellent' | 'good' | 'fair' | 'poor';
    issues: string[];
    warnings: string[];
    orphanedNodes: string[];
    circularDependencies: CircularDependency[];
    recommendations: string[];
    timestamp: Date;
}
export {};
//# sourceMappingURL=enhanced-dependency-tracker.d.ts.map