vibe-coder-mcp/build/tools/vibe-task-manager/core/dependency-graph.d.ts

Production-ready MCP server with complete agent integration, multi-transport support, and comprehensive development automation tools for AI-assisted workflows.

import { AtomicTask } from '../types/task.js';
import { DependencyNode } from '../types/dependency.js';
export type ExtendedDependencyType = 'task' | 'package' | 'framework' | 'tool' | 'import' | 'environment';
export interface DependencyEdge {
    from: string;
    to: string;
    type: ExtendedDependencyType;
    weight: number;
    critical: boolean;
    description?: string;
}
export interface GraphMetrics {
    totalNodes: number;
    totalEdges: number;
    maxDepth: number;
    criticalPathLength: number;
    parallelBatches: number;
    cycleCount: number;
    orphanedNodes: number;
    averageDegree: number;
}
export interface ParallelBatch {
    batchId: number;
    taskIds: string[];
    estimatedDuration: number;
    dependencies: string[];
    canStartAfter: number[];
}
export interface CriticalPathAnalysis {
    paths: string[][];
    longestPath: string[];
    totalDuration: number;
    resourceWeightedDuration: number;
    bottleneckTasks: string[];
}
export interface DependencyImpact {
    taskId: string;
    directDependents: string[];
    indirectDependents: string[];
    impactRadius: number;
    riskLevel: 'low' | 'medium' | 'high' | 'critical';
    propagationChain: string[][];
}
export interface BottleneckAnalysis {
    taskId: string;
    bottleneckType: 'resource' | 'dependency' | 'critical-path' | 'parallel-constraint';
    severity: number;
    affectedTasks: string[];
    recommendations: string[];
}
export interface ResourceOptimization {
    optimalBatches: ParallelBatch[];
    resourceUtilization: number;
    timeReduction: number;
    parallelismOpportunities: {
        taskId: string;
        canRunWith: string[];
        estimatedSavings: number;
    }[];
}
export interface DependencyValidationResult {
    isValid: boolean;
    errors: ValidationError[];
    warnings: ValidationWarning[];
    suggestions: DependencySuggestion[];
}
export interface ValidationError {
    type: 'cycle' | 'missing-task' | 'invalid-type' | 'self-dependency' | 'conflict';
    severity: 'error' | 'warning';
    message: string;
    affectedTasks: string[];
    suggestedFix?: string;
}
export interface ValidationWarning {
    type: 'redundant' | 'inefficient' | 'potential-issue';
    message: string;
    affectedTasks: string[];
    recommendation?: string;
}
export interface DependencySuggestion {
    type: 'add' | 'remove' | 'modify' | 'reorder';
    fromTaskId: string;
    toTaskId: string;
    dependencyType: ExtendedDependencyType;
    reason: string;
    confidence: number;
    impact: 'low' | 'medium' | 'high';
}
export interface DependencyConflict {
    conflictType: 'circular' | 'incompatible-types' | 'resource-contention' | 'timing-conflict';
    description: string;
    involvedTasks: string[];
    involvedDependencies: string[];
    severity: 'low' | 'medium' | 'high' | 'critical';
    resolutionOptions: ConflictResolution[];
}
export interface ConflictResolution {
    strategy: 'remove-dependency' | 'change-type' | 'reorder-tasks' | 'split-task' | 'merge-tasks';
    description: string;
    impact: string;
    effort: 'low' | 'medium' | 'high';
}
export type GraphSerializationFormat = 'json' | 'yaml';
export interface SerializedGraph {
    version: string;
    projectId: string;
    timestamp: string;
    format: GraphSerializationFormat;
    checksum: string;
    nodes: Record<string, DependencyNode>;
    edges: Record<string, DependencyEdge>;
    adjacencyList: Record<string, string[]>;
    reverseIndex: Record<string, string[]>;
    metadata: {
        totalNodes: number;
        totalEdges: number;
        criticalPath: string[];
        topologicalOrder: string[];
        parallelBatches: ParallelBatch[];
        metrics: GraphMetrics;
    };
}
export interface GraphPersistenceResult {
    success: boolean;
    filePath?: string;
    format: GraphSerializationFormat;
    size: number;
    checksum: string;
    error?: string;
    timestamp: Date;
}
export interface GraphRecoveryResult {
    success: boolean;
    recovered: boolean;
    corruptionDetected: boolean;
    backupUsed?: string;
    validationErrors: string[];
    recoveryActions: string[];
    error?: string;
}
export interface GraphIntegrityResult {
    isValid: boolean;
    errors: string[];
    warnings: string[];
    checksumValid: boolean;
    structureValid: boolean;
    dataConsistent: boolean;
}
export interface GraphVersion {
    version: string;
    timestamp: Date;
    checksum: string;
    description: string;
    filePath: string;
    format: GraphSerializationFormat;
}
export declare class OptimizedDependencyGraph {
    private projectId;
    private adjacencyList;
    private reverseIndex;
    private nodes;
    private edges;
    private topologicalOrder;
    private criticalPath;
    private parallelBatches;
    private isDirty;
    private metrics;
    constructor(projectId: string);
    addTask(task: AtomicTask): void;
    addDependency(dependentTaskId: string, dependencyTaskId: string, type?: ExtendedDependencyType, weight?: number, critical?: boolean, description?: string): boolean;
    removeDependency(dependentTaskId: string, dependencyTaskId: string): boolean;
    getReadyTasks(): string[];
    detectCycles(): string[][];
    getTopologicalOrder(): string[];
    getCriticalPath(): string[];
    getParallelBatches(): ParallelBatch[];
    private wouldCreateCycle;
    private hasPath;
    private hasNoPendingDependencies;
    private markDirty;
    private updateMetrics;
    private calculateMaxDepth;
    private getOrphanedNodes;
    private calculateAverageDegree;
    getMetrics(): GraphMetrics;
    getNodes(): Map<string, DependencyNode>;
    getEdges(): Map<string, DependencyEdge>;
    clearCache(): void;
    reset(): void;
    getSize(): {
        nodes: number;
        edges: number;
    };
    analyzeCriticalPath(): CriticalPathAnalysis;
    analyzeDependencyImpact(taskId: string): DependencyImpact;
    detectBottlenecks(): BottleneckAnalysis[];
    optimizeResourceAllocation(): ResourceOptimization;
    private findAllCriticalPaths;
    private findSourceNodes;
    private findSinkNodes;
    private findAllPathsBetween;
    private calculatePathDuration;
    private calculateResourceWeightedDuration;
    private findIndirectDependents;
    private findPropagationChains;
    private calculateRiskLevel;
    private analyzeTaskBottleneck;
    private checkParallelConstraints;
    private optimizeParallelBatches;
    private balanceBatch;
    private identifyParallelismOpportunities;
    private findParallelizableTasks;
    private calculateParallelSavings;
    validateDependencies(): DependencyValidationResult;
    detectDependencyConflicts(): DependencyConflict[];
    generateDependencySuggestions(): DependencySuggestion[];
    validateDependencyBeforeAdd(dependentTaskId: string, dependencyTaskId: string, type: ExtendedDependencyType): DependencyValidationResult;
    private validateDependencyTypes;
    private checkTypeCompatibility;
    private detectIncompatibleTypes;
    private detectResourceContention;
    private checkBatchResourceConflicts;
    private detectTimingConflicts;
    private getCycleDependencies;
    private getTaskDependencyIds;
    private suggestMissingDependencies;
    private analyzePotentialDependencies;
    private suggestDependencyTypeImprovements;
    private suggestBetterDependencyType;
    private suggestParallelizationOpportunities;
    private couldBeParallelized;
    private detectRedundantDependencies;
    private isTransitiveDependency;
    serializeToJSON(): SerializedGraph;
    serializeToYAML(): SerializedGraph;
    saveToFile(filePath: string, format?: GraphSerializationFormat, createBackup?: boolean): Promise<GraphPersistenceResult>;
    loadFromFile(filePath: string): Promise<GraphRecoveryResult>;
    validateGraphIntegrity(serializedGraph: SerializedGraph): GraphIntegrityResult;
    createIncrementalUpdate(previousChecksum: string): Partial<SerializedGraph> | null;
    applyIncrementalUpdate(update: Partial<SerializedGraph>): boolean;
    createVersion(basePath: string, version: string, description?: string): Promise<GraphVersion | null>;
    listVersions(basePath: string): Promise<GraphVersion[]>;
    rollbackToVersion(versionPath: string): Promise<GraphRecoveryResult>;
    private createSerializedData;
    private calculateChecksum;
    private sortObjectKeysRecursively;
    private convertToYAML;
    private parseGraphContent;
    private parseYAMLContent;
    private loadFromSerializedData;
    private attemptRecovery;
    private createBackup;
    private calculateMetrics;
    private findOrphanedNodes;
    private fileExists;
    private readFile;
    private writeFile;
    autoDetectDependencies(tasks: AtomicTask[]): DependencySuggestion[];
    private analyzePotentialDependency;
    private detectDependencyPatterns;
    private detectSequentialDependency;
    private detectFileDependency;
    private detectFrameworkDependency;
    private detectTestingDependency;
    private detectEnvironmentDependency;
    private containsKeywords;
    private detectImportRelationship;
    private extractKeyTerms;
    applyIntelligentDependencyDetection(tasks: AtomicTask[]): {
        appliedDependencies: number;
        suggestions: DependencySuggestion[];
        warnings: string[];
    };
    private updateTaskDependencies;
    private detectResourceConflicts;
    getRecommendedExecutionOrder(): {
        topologicalOrder: string[];
        parallelBatches: ParallelBatch[];
        criticalPath: string[];
        estimatedDuration: number;
    };
    exportDependencyAnalysis(): {
        nodes: DependencyNode[];
        edges: DependencyEdge[];
        metrics: GraphMetrics;
        executionPlan: {
            topologicalOrder: string[];
            parallelBatches: ParallelBatch[];
            criticalPath: string[];
            estimatedDuration: number;
        };
    };
}
export declare function createDependencyGraph(projectId: string): OptimizedDependencyGraph;
export declare function getDependencyGraph(projectId: string): OptimizedDependencyGraph;
export declare function clearProjectDependencyGraph(projectId: string): void;
//# sourceMappingURL=dependency-graph.d.ts.map