@re-shell/cli/dist/core/dependency-conflict-detector.d.ts

Full-stack development platform uniting microservices and microfrontends. Build complete applications with .NET (ASP.NET Core Web API, Minimal API), Java (Spring Boot, Quarkus, Micronaut, Vert.x), Rust (Actix-Web, Warp, Rocket, Axum), Python (FastAPI, Dja

import { EventEmitter } from 'events';
export interface Dependency {
    name: string;
    version: string;
    resolved?: string;
    dependencies?: Record<string, string>;
    peerDependencies?: Record<string, string>;
    optionalDependencies?: Record<string, string>;
    devDependencies?: Record<string, string>;
    source?: 'dependencies' | 'devDependencies' | 'peerDependencies' | 'optionalDependencies';
    parent?: string;
    depth?: number;
}
export interface DependencyConflict {
    name: string;
    type: ConflictType;
    severity: 'critical' | 'high' | 'medium' | 'low';
    packages: ConflictingPackage[];
    description: string;
    impact: string[];
    resolutions: Resolution[];
    autoResolvable: boolean;
}
export declare enum ConflictType {
    VERSION_MISMATCH = "version_mismatch",
    PEER_DEPENDENCY_UNMET = "peer_dependency_unmet",
    DUPLICATE_PACKAGE = "duplicate_package",
    CIRCULAR_DEPENDENCY = "circular_dependency",
    INCOMPATIBLE_ENGINES = "incompatible_engines",
    LICENSE_CONFLICT = "license_conflict",
    SECURITY_VULNERABILITY = "security_vulnerability",
    DEPRECATED_PACKAGE = "deprecated_package"
}
export interface ConflictingPackage {
    name: string;
    version: string;
    requiredBy: string[];
    location?: string;
    constraints?: string[];
}
export interface Resolution {
    type: 'upgrade' | 'downgrade' | 'override' | 'alias' | 'remove' | 'replace';
    description: string;
    command?: string;
    config?: any;
    risk: 'low' | 'medium' | 'high';
    automated: boolean;
    steps?: string[];
}
export interface DependencyTree {
    name: string;
    version: string;
    dependencies: Map<string, DependencyTree>;
    parent?: DependencyTree;
    conflicts?: DependencyConflict[];
}
export interface ConflictDetectionOptions {
    checkPeerDependencies?: boolean;
    checkEngines?: boolean;
    checkLicenses?: boolean;
    checkSecurity?: boolean;
    checkCircular?: boolean;
    maxDepth?: number;
    includeDevDependencies?: boolean;
    includeOptionalDependencies?: boolean;
    strictVersioning?: boolean;
}
export interface ConflictReport {
    conflicts: DependencyConflict[];
    summary: {
        total: number;
        critical: number;
        high: number;
        medium: number;
        low: number;
        autoResolvable: number;
    };
    dependencyTree?: DependencyTree;
    recommendations: string[];
    healthScore: number;
}
export interface PackageInfo {
    name: string;
    version: string;
    description?: string;
    engines?: Record<string, string>;
    license?: string;
    deprecated?: boolean;
    repository?: string;
    dependencies?: Record<string, string>;
    peerDependencies?: Record<string, string>;
    devDependencies?: Record<string, string>;
    optionalDependencies?: Record<string, string>;
}
export declare class DependencyConflictDetector extends EventEmitter {
    private packageCache;
    private dependencyTree?;
    private visitedPackages;
    private licenseCompatibility;
    private readonly defaultOptions;
    constructor();
    private initializeLicenseCompatibility;
    detectConflicts(projectPath: string, options?: ConflictDetectionOptions): Promise<ConflictReport>;
    private buildDependencyTree;
    private getPackageInfo;
    private getNpmPackageInfo;
    private detectVersionConflicts;
    private collectVersions;
    private findIncompatibleVersions;
    private calculateVersionConflictSeverity;
    private generateVersionResolutions;
    private findCompatibleRange;
    private detectPeerDependencyConflicts;
    private collectPeerDependencies;
    private findInstalledVersion;
    private generatePeerDependencyResolutions;
    private findSatisfyingVersion;
    private detectDuplicatePackages;
    private collectPackageLocations;
    private generateDuplicationResolutions;
    private detectCircularDependencies;
    private detectCycles;
    private generateCircularDependencyResolutions;
    private detectEngineConflicts;
    private collectEngineRequirements;
    private getNpmVersion;
    private generateEngineResolutions;
    private detectLicenseConflicts;
    private collectLicenses;
    private normalizeLicense;
    private findIncompatibleLicenses;
    private generateLicenseResolutions;
    private detectSecurityVulnerabilities;
    private mapAuditSeverity;
    private generateSecurityResolutions;
    private generateReport;
    private generateRecommendations;
    private calculateHealthScore;
    resolveConflicts(conflicts: DependencyConflict[], options?: {
        autoOnly?: boolean;
        interactive?: boolean;
        dryRun?: boolean;
    }): Promise<{
        resolved: string[];
        failed: string[];
        skipped: string[];
    }>;
    exportReport(report: ConflictReport, format?: 'json' | 'markdown'): string;
}
export declare function getDependencyConflictDetector(): DependencyConflictDetector;
export declare function detectDependencyConflicts(projectPath: string, options?: ConflictDetectionOptions): Promise<ConflictReport>;