/**
 * Best Practice Evolution System
 * Claude AI-powered system that learns from project implementations and evolves best practices
 */
export interface BestPractice {
    id: string;
    name: string;
    category: 'architecture' | 'security' | 'performance' | 'maintainability' | 'testing' | 'documentation';
    version: string;
    description: string;
    reasoning: string;
    implementation: {
        code?: string;
        configuration?: any;
        documentation?: string;
    };
    evidence: Evidence[];
    applicability: {
        frameworks: string[];
        projectTypes: string[];
        conditions: string[];
    };
    metrics: {
        adoptionRate: number;
        successRate: number;
        impactScore: number;
        confidenceLevel: number;
    };
    evolution: {
        previousVersions: string[];
        lastUpdated: Date;
        learningData: LearningDataPoint[];
    };
}
export interface Evidence {
    type: 'performance-improvement' | 'bug-reduction' | 'developer-satisfaction' | 'code-quality';
    source: string;
    metrics: Record<string, number>;
    description: string;
    confidence: number;
}
export interface LearningDataPoint {
    project: string;
    implementation: string;
    outcome: 'success' | 'failure' | 'partial';
    metrics: Record<string, number>;
    feedback: string;
    timestamp: Date;
}
export interface EvolutionInsight {
    practice: string;
    insight: string;
    confidence: number;
    evidence: Evidence[];
    suggestedChange: {
        type: 'update' | 'deprecate' | 'split' | 'merge';
        description: string;
        implementation: string;
    };
}
export interface ClaudeMdEvolution {
    currentRules: string[];
    proposedChanges: RuleEvolution[];
    newRules: NewRule[];
    deprecatedRules: DeprecatedRule[];
    reasoning: string;
}
export interface RuleEvolution {
    ruleId: string;
    currentContent: string;
    proposedContent: string;
    changes: RuleChange[];
    reasoning: string;
    confidence: number;
}
export interface RuleChange {
    type: 'add' | 'modify' | 'remove';
    section: string;
    content: string;
    reasoning: string;
}
export interface NewRule {
    id: string;
    name: string;
    content: string;
    category: string;
    reasoning: string;
    priority: 'high' | 'medium' | 'low';
}
export interface DeprecatedRule {
    id: string;
    reason: string;
    replacement?: string;
    migrationPath: string;
}
export declare class BestPracticeEvolution {
    private practices;
    private learningData;
    /**
     * Analyze project implementations to extract learnings
     */
    analyzeProjectImplementations(projects: ProjectImplementation[]): Promise<EvolutionInsight[]>;
    /**
     * Evolve CLAUDE.md rules based on learning data
     */
    evolveClaudeMdRules(projects: ProjectImplementation[]): Promise<ClaudeMdEvolution>;
    /**
     * Learn from a specific project implementation
     */
    learnFromProject(project: ProjectImplementation): Promise<LearningResult>;
    /**
     * Recommend best practices for a specific project context
     */
    recommendPractices(context: ProjectContext): Promise<BestPracticeRecommendation[]>;
    /**
     * Generate updated CLAUDE.md content based on evolution
     */
    generateEvolvedClaudeMd(evolution: ClaudeMdEvolution, projectContext: ProjectContext): Promise<string>;
    private groupProjectsByPatterns;
    private analyzePatternEvolution;
    private analyzeCrossCuttingConcerns;
    private getCurrentClaudeMdRules;
    private isRelevantToRule;
    private evolveRule;
    private identifyNewRuleOpportunities;
    private identifyDeprecatedRules;
    private generateEvolutionReasoning;
    private identifyImplementedPractices;
    private evaluateImplementation;
    private updatePracticeFromLearning;
    private extractInsights;
    private isApplicable;
    private generateRecommendation;
    private extractCommonPattern;
    private buildEvidence;
    private analyzeSecurityPatterns;
    private analyzePerformancePatterns;
    private analyzeTestingPatterns;
}
interface ProjectImplementation {
    name: string;
    framework: string;
    codePatterns: string[];
    metrics: {
        successRate: number;
        performanceScore: number;
        maintainabilityScore: number;
        bugRate: number;
    };
    practices: string[];
}
interface LearningResult {
    project: string;
    learningPoints: LearningDataPoint[];
    practiceUpdates: BestPracticeUpdate[];
    insights: string[];
}
interface BestPracticeUpdate {
    practice: string;
    changes: string[];
    reasoning: string;
}
interface BestPracticeRecommendation {
    practice: string;
    relevance: number;
    impact: number;
    confidence: number;
    description: string;
    implementation: any;
    reasoning: string;
}
interface ProjectContext {
    name: string;
    framework: string;
    type: string;
    size: 'small' | 'medium' | 'large';
    team: 'solo' | 'small' | 'large';
}
export {};
//# sourceMappingURL=best-practice-evolution.d.ts.map