/**
 * Smart Security Tool - 83% Token Reduction
 *
 * Vulnerability scanning with intelligent caching:
 * - Pattern-based detection for common vulnerabilities
 * - Cached scan results with 24-hour TTL
 * - Incremental scanning (only changed files)
 * - Severity-based reporting with remediation suggestions
 * - <1 hour full scan requirement for daily TTL
 */
import { CacheEngine } from '../../core/cache-engine.js';
import { MetricsCollector } from '../../core/metrics.js';
import { TokenCounter } from '../../core/token-counter.js';
/**
 * Vulnerability severity levels
 */
type VulnerabilitySeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
/**
 * Vulnerability categories
 */
type VulnerabilityCategory = 'injection' | 'xss' | 'secrets' | 'crypto' | 'auth' | 'dos' | 'path-traversal' | 'unsafe-eval' | 'regex' | 'dependency' | 'config';
/**
 * Options for smart security scan
 */
export interface SmartSecurityOptions {
    /**
     * Force full scan (ignore cache)
     */
    force?: boolean;
    /**
     * Project root directory
     */
    projectRoot?: string;
    /**
     * Files or directories to scan (specific targets for incremental mode)
     */
    targets?: string[];
    /**
     * File patterns to exclude (glob patterns)
     */
    exclude?: string[];
    /**
     * Minimum severity level to report
     */
    minSeverity?: VulnerabilitySeverity;
    /**
     * Maximum cache age in seconds (default: 86400 = 24 hours)
     */
    maxCacheAge?: number;
    /**
     * Include low-severity findings
     */
    includeLowSeverity?: boolean;
}
/**
 * Smart security output (token-optimized)
 */
export interface SmartSecurityOutput {
    /**
     * Scan summary
     */
    summary: {
        success: boolean;
        filesScanned: number;
        filesFromCache: number;
        totalFindings: number;
        criticalCount: number;
        highCount: number;
        mediumCount: number;
        lowCount: number;
        duration: number;
        fromCache: boolean;
        incrementalMode: boolean;
    };
    /**
     * Findings grouped by severity
     */
    findingsBySeverity: Array<{
        severity: VulnerabilitySeverity;
        count: number;
        items: Array<{
            file: string;
            location: string;
            category: VulnerabilityCategory;
            message: string;
            remediation: string;
        }>;
    }>;
    /**
     * Findings grouped by category
     */
    findingsByCategory: Array<{
        category: VulnerabilityCategory;
        count: number;
        criticalCount: number;
        highCount: number;
        topFiles: string[];
    }>;
    /**
     * Critical remediation priorities
     */
    remediationPriorities: Array<{
        priority: number;
        category: VulnerabilityCategory;
        severity: VulnerabilitySeverity;
        count: number;
        impact: string;
        action: string;
    }>;
    /**
     * Token reduction metrics
     */
    metrics: {
        originalTokens: number;
        compactedTokens: number;
        reductionPercentage: number;
    };
}
export declare class SmartSecurity {
    private cache;
    private metrics;
    private cacheNamespace;
    private projectRoot;
    private fileHashes;
    constructor(cache: CacheEngine, _tokenCounter: TokenCounter, metrics: MetricsCollector, projectRoot?: string);
    /**
     * Run security scan with intelligent caching
     */
    run(options?: SmartSecurityOptions): Promise<SmartSecurityOutput>;
    /**
     * Discover files to scan
     */
    private discoverFiles;
    /**
     * Full security scan of all files
     */
    private fullScan;
    /**
     * Incremental scan - only scan changed files
     */
    private incrementalScan;
    /**
     * Scan a single file for vulnerabilities
     */
    private scanFile;
    /**
     * Build complete scan result
     */
    private buildScanResult;
    /**
     * Transform to token-optimized output
     */
    private transformOutput;
    /**
     * Group findings by severity
     */
    private groupBySeverity;
    /**
     * Group findings by category
     */
    private groupByCategory;
    /**
     * Generate remediation priorities
     */
    private generateRemediationPriorities;
    /**
     * Get impact description for category
     */
    private getCategoryImpact;
    /**
     * Get recommended action for category
     */
    private getCategoryAction;
    /**
     * Filter findings by minimum severity
     */
    private filterBySeverity;
    /**
     * Generate cache key based on file hashes
     */
    private generateCacheKey;
    /**
     * Generate hash for a single file
     */
    private generateFileHash;
    /**
     * Get cached result if available and fresh
     */
    private getCachedResult;
    /**
     * Cache scan result
     */
    private cacheResult;
    /**
     * Estimate original output size (full scan results)
     */
    private estimateOriginalOutputSize;
    /**
     * Estimate compact output size
     */
    private estimateCompactSize;
    /**
     * Close cache and cleanup
     */
    close(): void;
}
/**
 * Factory function to create SmartSecurity with dependency injection
 */
export declare function getSmartSecurityTool(cache: CacheEngine, tokenCounter: TokenCounter, metrics: MetricsCollector, projectRoot?: string): SmartSecurity;
/**
 * CLI-friendly function for running smart security scan
 */
export declare function runSmartSecurity(options?: SmartSecurityOptions): Promise<string>;
export declare const SMART_SECURITY_TOOL_DEFINITION: {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {
            force: {
                type: string;
                description: string;
                default: boolean;
            };
            projectRoot: {
                type: string;
                description: string;
            };
            targets: {
                type: string;
                description: string;
                items: {
                    type: string;
                };
            };
            exclude: {
                type: string;
                description: string;
                items: {
                    type: string;
                };
                default: string[];
            };
            minSeverity: {
                type: string;
                description: string;
                enum: string[];
                default: string;
            };
            maxCacheAge: {
                type: string;
                description: string;
                default: number;
            };
            includeLowSeverity: {
                type: string;
                description: string;
                default: boolean;
            };
        };
    };
};
export {};
//# sourceMappingURL=smart-security.d.ts.map