/**
 * Pattern Matching and Learning System
 * Detects patterns across projects and learns from successful implementations
 */
import { ProjectAnalysis } from './project-analyzer';
export interface PatternAnalysis {
    patterns: DetectedPattern[];
    similarities: ProjectSimilarity[];
    learnings: Learning[];
    improvements: PatternImprovement[];
    crossProjectInsights: CrossProjectInsight[];
    evolutionOpportunities: EvolutionOpportunity[];
    confidence: number;
}
export interface DetectedPattern {
    id: string;
    name: string;
    type: PatternType;
    category: PatternCategory;
    description: string;
    signature: PatternSignature;
    occurrences: PatternOccurrence[];
    effectiveness: number;
    reusability: number;
    complexity: number;
    maintainability: number;
    performance: number;
    security: number;
    testability: number;
    documentation: number;
    evolution: PatternEvolution;
}
export interface ProjectSimilarity {
    projectA: string;
    projectB: string;
    similarity: number;
    commonPatterns: string[];
    differences: PatternDifference[];
    recommendations: SimilarityRecommendation[];
}
export interface Learning {
    id: string;
    title: string;
    description: string;
    type: LearningType;
    source: LearningSource;
    evidence: Evidence[];
    confidence: number;
    applicability: Applicability;
    impact: ImpactMetrics;
    implementation: ImplementationGuidance;
}
export interface PatternImprovement {
    patternId: string;
    improvementType: ImprovementType;
    description: string;
    benefitAnalysis: BenefitAnalysis;
    implementationPlan: ImplementationStep[];
    riskAssessment: RiskAssessment;
    successMetrics: SuccessMetric[];
}
export interface CrossProjectInsight {
    id: string;
    title: string;
    description: string;
    projects: string[];
    patternIds: string[];
    insights: Insight[];
    actionableRecommendations: ActionableRecommendation[];
    businessValue: number;
    technicalImpact: number;
}
export interface EvolutionOpportunity {
    type: EvolutionType;
    description: string;
    currentState: string;
    proposedState: string;
    evolutionPath: EvolutionStep[];
    benefits: string[];
    risks: string[];
    timeline: string;
    effort: 'low' | 'medium' | 'high';
    priority: 'critical' | 'high' | 'medium' | 'low';
}
export type PatternType = 'architectural' | 'design' | 'implementation' | 'configuration' | 'testing' | 'deployment' | 'security' | 'performance';
export type PatternCategory = 'frontend' | 'backend' | 'fullstack' | 'infrastructure' | 'tooling' | 'process' | 'documentation';
export type LearningType = 'best-practice' | 'anti-pattern' | 'optimization' | 'security-finding' | 'performance-insight' | 'maintainability-lesson';
export type ImprovementType = 'performance' | 'security' | 'maintainability' | 'scalability' | 'developer-experience' | 'code-quality';
export type EvolutionType = 'rule-enhancement' | 'new-pattern' | 'deprecated-pattern' | 'best-practice-update' | 'tool-upgrade' | 'process-improvement';
export interface PatternSignature {
    files: FileSignature[];
    dependencies: DependencySignature[];
    configurations: ConfigurationSignature[];
    codeStructures: CodeStructureSignature[];
    testPatterns: TestPatternSignature[];
}
export interface PatternOccurrence {
    projectPath: string;
    projectName: string;
    files: string[];
    quality: QualityMetrics;
    context: PatternContext;
    variations: PatternVariation[];
    outcomes: PatternOutcome[];
}
export interface PatternEvolution {
    firstSeen: string;
    lastSeen: string;
    versions: PatternVersion[];
    improvements: string[];
    deprecations: string[];
    migrations: MigrationPath[];
}
export interface PatternDifference {
    aspect: string;
    projectA: any;
    projectB: any;
    significance: number;
    recommendation?: string;
}
export interface SimilarityRecommendation {
    type: 'adopt-pattern' | 'improve-implementation' | 'consider-alternative';
    description: string;
    benefit: string;
    effort: 'low' | 'medium' | 'high';
    priority: number;
}
export interface LearningSource {
    type: 'success-analysis' | 'failure-analysis' | 'performance-study' | 'security-audit' | 'code-review' | 'user-feedback';
    projects: string[];
    timeframe: string;
    methodology: string;
}
export interface Evidence {
    type: 'metric' | 'observation' | 'measurement' | 'feedback' | 'outcome';
    description: string;
    data: any;
    reliability: number;
}
export interface Applicability {
    projectTypes: string[];
    frameworks: string[];
    teamSizes: string[];
    complexityLevels: string[];
    constraints: string[];
}
export interface ImpactMetrics {
    developmentSpeed: number;
    codeQuality: number;
    maintainability: number;
    performance: number;
    security: number;
    teamSatisfaction: number;
    userSatisfaction: number;
}
export interface ImplementationGuidance {
    steps: ImplementationStep[];
    prerequisites: string[];
    considerations: string[];
    commonPitfalls: string[];
    successIndicators: string[];
}
export interface BenefitAnalysis {
    quantifiedBenefits: QuantifiedBenefit[];
    qualitativeBenefits: string[];
    timeToValue: string;
    roi: number;
    riskMitigation: string[];
}
export interface RiskAssessment {
    risks: Risk[];
    mitigationStrategies: MitigationStrategy[];
    rollbackPlan: RollbackStep[];
    monitoringApproach: string;
}
export interface SuccessMetric {
    name: string;
    description: string;
    baseline: number;
    target: number;
    measurement: string;
    frequency: string;
}
export interface Insight {
    type: 'correlation' | 'causation' | 'trend' | 'anomaly' | 'opportunity';
    description: string;
    strength: number;
    supporting_evidence: string[];
}
export interface ActionableRecommendation {
    title: string;
    description: string;
    action: string;
    priority: number;
    effort: 'low' | 'medium' | 'high';
    expectedOutcome: string;
}
export interface EvolutionStep {
    step: number;
    description: string;
    duration: string;
    dependencies: string[];
    deliverables: string[];
    risks: string[];
}
export interface FileSignature {
    path: string;
    type: string;
    patterns: string[];
    dependencies: string[];
    exports: string[];
    complexity: number;
}
export interface DependencySignature {
    name: string;
    version: string;
    type: 'production' | 'development';
    usage: 'direct' | 'indirect';
    purpose: string;
}
export interface ConfigurationSignature {
    file: string;
    type: string;
    keys: string[];
    patterns: string[];
    values: any[];
}
export interface CodeStructureSignature {
    type: 'class' | 'function' | 'component' | 'hook' | 'service' | 'util';
    name: string;
    parameters: number;
    complexity: number;
    patterns: string[];
}
export interface TestPatternSignature {
    type: 'unit' | 'integration' | 'e2e';
    coverage: number;
    patterns: string[];
    frameworks: string[];
}
export interface QualityMetrics {
    maintainability: number;
    reliability: number;
    security: number;
    performance: number;
    testability: number;
    readability: number;
}
export interface PatternContext {
    projectType: string;
    framework: string;
    teamSize: number;
    timelineConstraints: string;
    qualityRequirements: string[];
    businessContext: string;
}
export interface PatternVariation {
    id: string;
    description: string;
    differences: string[];
    suitability: string[];
}
export interface PatternOutcome {
    metric: string;
    value: number;
    timestamp: string;
    context: string;
}
export interface PatternVersion {
    version: string;
    date: string;
    changes: string[];
    effectiveness: number;
    adoption: number;
}
export interface MigrationPath {
    from: string;
    to: string;
    steps: string[];
    effort: string;
    risks: string[];
}
export interface ImplementationStep {
    step: number;
    title: string;
    description: string;
    duration: string;
    prerequisites: string[];
    deliverables: string[];
}
export interface QuantifiedBenefit {
    metric: string;
    improvement: number;
    unit: string;
    confidence: number;
}
export interface Risk {
    description: string;
    probability: number;
    impact: number;
    category: string;
}
export interface MitigationStrategy {
    risk: string;
    strategy: string;
    effectiveness: number;
    effort: string;
}
export interface RollbackStep {
    step: number;
    description: string;
    trigger: string;
    duration: string;
}
export declare class PatternMatcher {
    private patterns;
    private projectAnalyses;
    private learnings;
    constructor();
    /**
     * Analyze patterns across multiple projects
     */
    analyzePatterns(projectPaths: string[]): Promise<PatternAnalysis>;
    /**
     * Learn from a successful implementation
     */
    learnFromSuccess(projectPath: string, patternId: string, outcomes: PatternOutcome[]): Promise<void>;
    /**
     * Learn from a failed implementation
     */
    learnFromFailure(projectPath: string, attemptedPatternId: string, issues: string[], resolution?: string): Promise<void>;
    /**
     * Get pattern recommendations for a project
     */
    getPatternRecommendations(projectAnalysis: ProjectAnalysis): Promise<PatternRecommendation[]>;
    private initializeBuiltInPatterns;
    private createAuthenticationPattern;
    private createStateManagementPattern;
    private createTestingPattern;
    private createPerformanceOptimizationPattern;
    private createSecurityPattern;
    private detectPatterns;
    private detectProjectPatterns;
    private matchPattern;
    private calculateTypeAlignment;
    private findSimilarities;
    private calculateProjectSimilarity;
    private extractLearnings;
    private identifyImprovements;
    private generateCrossProjectInsights;
    private identifyEvolutionOpportunities;
    private updatePatternEffectiveness;
    private calculatePatternApplicability;
    private findExistingImplementation;
    private calculateExpectedBenefits;
    private calculateImprovementBenefits;
    private estimateImplementationEffort;
    private calculateOverallConfidence;
}
export interface PatternMatch {
    confidence: number;
    files: string[];
    quality: QualityMetrics;
    reasons: string[];
}
export interface PatternRecommendation {
    patternId: string;
    pattern: DetectedPattern;
    type: 'adopt' | 'improve' | 'consider';
    reason: string;
    confidence: number;
    expectedBenefits: ImpactMetrics;
    implementationEffort: 'low' | 'medium' | 'high';
}
export default PatternMatcher;
//# sourceMappingURL=pattern-matcher.d.ts.map