/**
 * Smart Package.json Tool - 83% Token Reduction
 *
 * Provides intelligent package.json parsing and analysis:
 * - Dependency resolution and version conflict detection
 * - Outdated package identification
 * - Security vulnerability scanning
 * - Dependency tree visualization
 * - Update suggestions with impact analysis
 * - Cached results with file hash invalidation (24-hour TTL)
 */
import { CacheEngine } from '../../core/cache-engine.js';
import { TokenCounter } from '../../core/token-counter.js';
import { MetricsCollector } from '../../core/metrics.js';
interface SmartPackageJsonOptions {
    /**
     * Project root directory
     */
    projectRoot?: string;
    /**
     * Force refresh (ignore cache)
     */
    force?: boolean;
    /**
     * Check for outdated packages
     */
    checkOutdated?: boolean;
    /**
     * Scan for security vulnerabilities
     */
    checkSecurity?: boolean;
    /**
     * Include dependency tree
     */
    includeDependencyTree?: boolean;
    /**
     * Maximum cache age in seconds (default: 86400 = 24 hours)
     */
    maxCacheAge?: number;
    /**
     * Maximum tree depth to display
     */
    maxTreeDepth?: number;
}
interface SmartPackageJsonOutput {
    /**
     * Package summary
     */
    summary: {
        name: string;
        version: string;
        packageManager: string;
        totalPackages: number;
        outdated: number;
        vulnerabilities: number;
        conflicts: number;
        fromCache: boolean;
    };
    /**
     * Package statistics
     */
    stats: {
        dependencies: number;
        devDependencies: number;
        peerDependencies: number;
        outdatedPackages: number;
    };
    /**
     * Version conflicts
     */
    conflicts: Array<{
        package: string;
        versions: string[];
        requiredBy: string[];
        severity: string;
        resolution: string;
    }>;
    /**
     * Security vulnerabilities
     */
    security: Array<{
        package: string;
        currentVersion: string;
        severity: string;
        vulnerabilities: number;
        fixedIn?: string;
        recommendation: string;
    }>;
    /**
     * Outdated packages
     */
    outdated: Array<{
        package: string;
        current: string;
        latest: string;
        type: string;
        updateRecommendation: string;
    }>;
    /**
     * Dependency tree (limited depth)
     */
    dependencyTree?: Array<{
        name: string;
        version: string;
        depth: number;
        children: number;
    }>;
    /**
     * Update suggestions
     */
    suggestions: Array<{
        type: 'security' | 'maintenance' | 'optimization';
        message: string;
        impact: 'high' | 'medium' | 'low';
        command?: string;
    }>;
    /**
     * Token reduction metrics
     */
    metrics: {
        originalTokens: number;
        compactedTokens: number;
        reductionPercentage: number;
    };
}
export declare class SmartPackageJson {
    private cache;
    private tokenCounter;
    private metrics;
    private cacheNamespace;
    private projectRoot;
    constructor(cache: CacheEngine, tokenCounter: TokenCounter, metrics: MetricsCollector, projectRoot?: string);
    /**
     * Parse package.json with intelligent analysis
     */
    run(options?: SmartPackageJsonOptions): Promise<SmartPackageJsonOutput>;
    /**
     * Detect which package manager is in use
     */
    private detectPackageManager;
    /**
     * Parse all packages from package.json
     */
    private parsePackages;
    /**
     * Build dependency tree with depth limit
     */
    private buildDependencyTree;
    /**
     * Parse dependency tree output from package manager
     */
    private parseDependencyTreeOutput;
    /**
     * Convert npm tree format to DependencyNode array
     */
    private convertNpmTreeToNodes;
    /**
     * Parse yarn tree output
     */
    private parseYarnTree;
    /**
     * Convert pnpm tree format to DependencyNode array
     */
    private convertPnpmTreeToNodes;
    /**
     * Detect version conflicts in dependencies
     */
    private detectVersionConflicts;
    /**
     * Determine if version conflict is breaking
     */
    private isBreakingConflict;
    /**
     * Suggest resolution for version conflict
     */
    private suggestConflictResolution;
    /**
     * Scan for security vulnerabilities
     */
    private scanSecurityIssues;
    /**
     * Parse security audit output
     */
    private parseSecurityOutput;
    /**
     * Normalize severity levels
     */
    private normalizeSeverity;
    /**
     * Check for outdated packages
     */
    private checkOutdatedPackages;
    /**
     * Mark packages as outdated based on audit data
     */
    private markOutdatedPackages;
    /**
     * Calculate package statistics
     */
    private calculateStats;
    /**
     * Generate file hash
     */
    private generateFileHash;
    /**
     * Generate cache key
     */
    private generateCacheKey;
    /**
     * Get cached result
     */
    private getCachedResult;
    /**
     * Cache result with file hash
     */
    private cacheResult;
    /**
     * Estimate tokens saved by caching
     */
    private estimateTokensSaved;
    /**
     * Generate update suggestions
     */
    private generateSuggestions;
    /**
     * Transform to smart output with token reduction
     */
    private transformOutput;
    /**
     * Get update recommendation based on version change
     */
    private getUpdateRecommendation;
    /**
     * Estimate original output size
     */
    private estimateOriginalSize;
    /**
     * Estimate compact output size
     */
    private estimateCompactSize;
    /**
     * Record metrics
     */
    private recordMetrics;
    /**
     * Close resources
     */
    close(): void;
}
/**
 * Factory function for shared resources (benchmarks)
 */
export declare function getSmartPackageJson(cache: CacheEngine, tokenCounter: TokenCounter, metrics: MetricsCollector, projectRoot?: string): SmartPackageJson;
/**
 * CLI-friendly function for running smart package.json analysis
 */
export declare function runSmartPackageJson(options?: SmartPackageJsonOptions): Promise<string>;
/**
 * Tool definition for MCP server registration
 */
export declare const SMART_PACKAGE_JSON_TOOL_DEFINITION: {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {
            projectRoot: {
                type: string;
                description: string;
            };
            force: {
                type: string;
                description: string;
                default: boolean;
            };
            checkOutdated: {
                type: string;
                description: string;
                default: boolean;
            };
            checkSecurity: {
                type: string;
                description: string;
                default: boolean;
            };
            includeDependencyTree: {
                type: string;
                description: string;
                default: boolean;
            };
            maxCacheAge: {
                type: string;
                description: string;
                default: number;
            };
            maxTreeDepth: {
                type: string;
                description: string;
                default: number;
            };
        };
    };
};
export {};
//# sourceMappingURL=smart-package-json.d.ts.map