NuGet Compatibility Checking

// From nugetCompatibilityChecker.ts:98
public async checkCompatibility(
    packageName: string,
    packageVersion: string | undefined,
    targetFramework: string
): Promise<CompatibilityIssue | null> {
    // Check if checks are enabled
    if (!this.config.get<boolean>('nugetCheckEnabled', true)) {
        return null;
    }

    // Check cache first
    if (this.config.get<boolean>('nugetCacheEnabled', true)) {
        const cached = this.getCachedResult(cacheKey);
        if (cached !== undefined) {
            return cached;
        }
    }

    // Try API lookup if enabled
    if (this.config.get<boolean>('nugetApiEnabled', true)) {
        issue = await this.checkCompatibilityViaAPI(...);
    }

    // Fall back to local rules
    issue = this.checkCompatibilityLocal(...);
}

// From nugetCompatibilityChecker.ts:805
export interface EnhancedCompatibilityIssue extends CompatibilityIssue {
    suggestedVersion?: string;
    alternativePackage?: {
        name: string;
        version?: string;
        reason?: string;
    };
    transitiveIssues?: Array<{
        packageName: string;
        version?: string;
        message: string;
    }>;
}

// From nugetCompatibilityChecker.ts:273
private async fetchPackageInfo(packageName: string, timeout: number): Promise<NuGetPackageInfoExtended | null> {
    const url = `https://api.nuget.org/v3-flatcontainer/${packageName.toLowerCase()}/index.json`;
    
    // Fetches available versions from NuGet.org
    const json = JSON.parse(data);
    const versions = json.versions || [];
    
    return {
        packageId: packageName,
        versions: versions,
        deprecated: false
    };
}

// From nugetCompatibilityChecker.ts:907
private async suggestAlternative(
    packageName: string,
    targetFramework: string
): Promise<{ name: string; version?: string; reason?: string } | undefined> {
    const alternatives: Record<string, { name: string; reason: string }[]> = {
        'EntityFramework': [
            { name: 'Microsoft.EntityFrameworkCore', 
              reason: 'Modern Entity Framework Core for .NET Core/.NET 5+' }
        ],
        // ... more alternatives
    };
}

// From nugetCompatibilityChecker.ts:1165
public async suggestFrameworkUpgrade(
    targetFramework: string,
    packageReferences: Array<{ Include: string; Version?: string }>
): Promise<{ suggestedFramework: string; reason: string; packagesSupporting: string[] } | null> {
    const upgradePaths: Record<string, string[]> = {
        'netcoreapp3.1': ['net5.0', 'net6.0', 'net7.0', 'net8.0'],
        'net6.0': ['net7.0', 'net8.0'],
        'net7.0': ['net8.0']
    };
    
    // Checks all packages for compatibility with newer frameworks
    // Returns highest framework where all packages are compatible
}

{
    packageName: 'Microsoft.AspNetCore.Mvc',
    supportedFrameworks: [
        'netcoreapp2.0', 'netcoreapp2.1', 'netcoreapp2.2', 
        'netcoreapp3.1', 'net5.0', 'net6.0', 'net7.0', 'net8.0'
    ],
    versionRules: {
        frameworkVersions: {
            'netcoreapp2.1': { min: '2.1.0', max: '2.1.x' },
            'net8.0': { min: '8.0.0' }
        }
    }
}

// From nugetCompatibilityChecker.ts:966
private async checkTransitiveDependencies(
    packageName: string,
    packageVersion: string,
    targetFramework: string
): Promise<Array<{ packageName: string; version?: string; message: string }>> {
    const packageMetadata = await this.fetchPackageMetadata(packageName, packageVersion);
    const dependencies = packageMetadata.dependencies || [];

    for (const dependency of dependencies) {
        const depIssue = await this.checkCompatibility(
            dependency.id,
            depVersion,
            targetFramework
        );
        // Reports issues with transitive dependencies
    }
}

// From nugetCompatibilityChecker.ts:338
private getCachedResult(key: string): CompatibilityIssue | null | undefined {
    const entry = this.cache.get(key);
    if (!entry) {
        return undefined;
    }

    const expiry = this.config.get<number>('nugetCacheExpiry', 3600) * 1000;
    const now = Date.now();
    
    if (now - entry.timestamp > expiry) {
        this.cache.delete(key);
        return undefined;
    }

    return entry.value;
}

// From nugetCompatibilityChecker.ts:315
private isPackageIgnored(packageName: string): boolean {
    const ignoredPackages = this.config.get<string[]>('nugetIgnoredPackages', []);
    
    for (const pattern of ignoredPackages) {
        // Exact match
        if (pattern === packageName) {
            return true;
        }
        
        // Pattern match (simple wildcard support)
        const regexPattern = pattern
            .replace(/\./g, '\\.')
            .replace(/\*/g, '.*');
        
        const regex = new RegExp(`^${regexPattern}$`, 'i');
        if (regex.test(packageName)) {
            return true;
        }
    }
}

{
  "dotnetBuildBuddy.nugetIgnoredPackages": [
    "MyCompany.Internal.Package",  // Exact match
    "MyCompany.Internal.*",         // Wildcard match
    "*.PrivatePackage"              // Suffix match
  ]
}

// From nugetCompatibilityChecker.ts:503
private getFrameworkType(framework: string): string {
    const lower = framework.toLowerCase();
    if (lower.startsWith('netframework') || lower.match(/^net[1-4]\./)) {
        return 'netframework';
    }
    if (lower.startsWith('netcoreapp')) {
        return 'netcoreapp';
    }
    if (lower.startsWith('netstandard')) {
        return 'netstandard';
    }
    if (lower.startsWith('net')) {
        return 'net';  // Modern .NET (5+)
    }
    return 'unknown';
}