import { EventEmitter } from 'events';
import type { ProjectContext } from '../types/index.js';
import { MCPManager } from './mcp-client.js';
import { AIToolIntegrationPlaybookService } from './ai-tool-integration-playbook.js';
export interface PatternDiscoveryConfig {
    cacheEnabled: boolean;
    cacheTTL: number;
    maxCacheSize: number;
    searchTimeoutMs: number;
    enableDeepResearch: boolean;
    preferredModel: 'exa-research' | 'exa-research-pro';
    patternRelevanceThreshold: number;
    enableCrossToolValidation: boolean;
    enablePatternLearning: boolean;
}
export interface PatternSearchQuery {
    id: string;
    category: PatternCategory;
    domain: string;
    query: string;
    context?: ProjectContext;
    priority: 'low' | 'medium' | 'high' | 'critical';
    searchDepth: 'basic' | 'comprehensive' | 'deep';
    filters?: SearchFilters;
    metadata?: Record<string, any>;
}
export interface SearchFilters {
    timeframe?: 'last_month' | 'last_quarter' | 'last_year' | 'last_2_years' | 'all_time';
    sources?: string[];
    excludeSources?: string[];
    minQualityScore?: number;
    technologies?: string[];
    complexity?: 'beginner' | 'intermediate' | 'advanced' | 'expert';
    includeExperimental?: boolean;
}
export type PatternCategory = 'ast_manipulation' | 'ai_enhanced_development' | 'performance_optimization' | 'security_patterns' | 'testing_strategies' | 'architectural_patterns' | 'code_generation' | 'developer_experience' | 'automation_patterns' | 'integration_patterns';
export interface DiscoveredPattern {
    id: string;
    category: PatternCategory;
    title: string;
    description: string;
    sourceUrl: string;
    sourceDomain: string;
    relevanceScore: number;
    qualityScore: number;
    confidenceScore: number;
    freshness: number;
    applicability: PatternApplicability;
    implementation: PatternImplementation;
    examples: CodeExample[];
    relatedPatterns: string[];
    tags: string[];
    metadata: PatternMetadata;
    discoveredAt: Date;
    lastValidated?: Date;
}
export interface PatternApplicability {
    languages: string[];
    frameworks: string[];
    domains: string[];
    complexity: 'beginner' | 'intermediate' | 'advanced' | 'expert';
    prerequisites: string[];
    constraints: string[];
    tradeoffs: string[];
    bestUseCases: string[];
    whenToAvoid: string[];
}
export interface PatternImplementation {
    overview: string;
    steps: ImplementationStep[];
    codeSnippets: CodeSnippet[];
    toolsRequired: string[];
    estimatedEffort: string;
    riskLevel: 'low' | 'medium' | 'high';
    validationApproach: string;
}
export interface ImplementationStep {
    order: number;
    title: string;
    description: string;
    codeExample?: string;
    checkpoints: string[];
    potentialIssues: string[];
}
export interface CodeSnippet {
    language: string;
    framework?: string;
    title: string;
    code: string;
    explanation: string;
    context: string;
}
export interface CodeExample {
    title: string;
    description: string;
    language: string;
    framework?: string;
    code: string;
    explanation: string;
    complexity: 'basic' | 'intermediate' | 'advanced';
    tags: string[];
}
export interface PatternMetadata {
    searchQuery: string;
    searchContext: string;
    extractionMethod: 'web_search' | 'deep_research' | 'crawling';
    validationStatus: 'pending' | 'validated' | 'outdated' | 'invalid';
    crossToolValidation?: CrossToolValidationResult;
    userFeedback?: UserFeedback[];
    usageStats?: PatternUsageStats;
    compositeScore?: number;
    officialDocumentation?: any;
    semanticValidation?: any;
    logicalValidation?: any;
}
export interface CrossToolValidationResult {
    context7Validation?: {
        officialDocumentationMatch: boolean;
        apiCompatibility: string;
        recommendedApproach?: string;
    };
    serenaValidation?: {
        semanticConsistency: number;
        codeQualityAssessment: string;
        patternMatches: string[];
    };
    sequentialThinkingValidation?: {
        logicalSoundness: number;
        stepByStepAnalysis: string;
        potentialIssues: string[];
    };
}
export interface UserFeedback {
    userId: string;
    rating: number;
    comment?: string;
    implementationSuccess: boolean;
    suggestedImprovements?: string[];
    timestamp: Date;
}
export interface PatternUsageStats {
    viewCount: number;
    implementationAttempts: number;
    successfulImplementations: number;
    lastUsed: Date;
    averageRating: number;
    popularityTrend: 'rising' | 'stable' | 'declining';
}
export interface PatternSearchResult {
    query: PatternSearchQuery;
    patterns: DiscoveredPattern[];
    totalFound: number;
    searchDuration: number;
    cacheHit: boolean;
    recommendations: PatternRecommendation[];
    relatedQueries: string[];
    qualityMetrics: SearchQualityMetrics;
}
export interface PatternRecommendation {
    type: 'alternative' | 'complementary' | 'prerequisite' | 'follow_up';
    pattern: DiscoveredPattern;
    reason: string;
    priority: number;
}
export interface SearchQualityMetrics {
    averageRelevance: number;
    sourceQuality: number;
    freshnessScore: number;
    comprehensiveness: number;
    practicalApplicability: number;
}
export interface PatternLearningProfile {
    userId?: string;
    preferredCategories: PatternCategory[];
    skillLevel: 'beginner' | 'intermediate' | 'advanced' | 'expert';
    technicalStack: string[];
    learningGoals: string[];
    implementedPatterns: string[];
    patternPreferences: Record<string, number>;
    lastUpdated: Date;
}
export interface SearchStrategy {
    name: string;
    description: string;
    queryTemplates: QueryTemplate[];
    searchDepthRules: SearchDepthRule[];
    filteringRules: FilteringRule[];
    prioritizationWeights: PrioritizationWeights;
}
export interface QueryTemplate {
    template: string;
    variables: string[];
    category: PatternCategory;
    priority: number;
    expectedResultTypes: string[];
}
export interface SearchDepthRule {
    condition: string;
    recommendedDepth: 'basic' | 'comprehensive' | 'deep';
    reasoning: string;
}
export interface FilteringRule {
    field: string;
    operation: 'include' | 'exclude' | 'prefer';
    values: any[];
    weight: number;
}
export interface PrioritizationWeights {
    relevance: number;
    quality: number;
    freshness: number;
    applicability: number;
    sourceAuthority: number;
}
export declare class ExaPatternDiscoveryService extends EventEmitter {
    private readonly logger;
    private mcpManager;
    private aiToolIntegration;
    private config;
    private patternCache;
    private searchCache;
    private learningProfiles;
    private searchStrategies;
    private searchStats;
    constructor(mcpManager: MCPManager, aiToolIntegration: AIToolIntegrationPlaybookService, config?: Partial<PatternDiscoveryConfig>);
    discoverPatterns(query: PatternSearchQuery): Promise<PatternSearchResult>;
    discoverSpecificPattern(patternName: string, category: PatternCategory, context?: ProjectContext): Promise<DiscoveredPattern | null>;
    discoverTrendingPatterns(category: PatternCategory, limit?: number): Promise<DiscoveredPattern[]>;
    private executeBasicSearch;
    private executeComprehensiveSearch;
    private executeDeepSearch;
    private extractPatternsFromSearchResult;
    private createPatternFromSearchItem;
    private extractPatternsFromDeepResearch;
    private extractPatternsFromCrawledContent;
    private performCrossToolValidation;
    private validateWithContext7;
    private validateWithSerena;
    private validateWithSequentialThinking;
    private filterAndRankPatterns;
    private removeDuplicatePatterns;
    private passesFilters;
    private calculateCompositeScore;
    private calculateRelevanceScore;
    private calculateQualityScore;
    private calculateConfidenceScore;
    private calculateFreshness;
    private calculateApplicabilityScore;
    private calculateSourceAuthorityScore;
    private mergeWithDefaultConfig;
    private initializeSearchStrategies;
    private createSearchStrategy;
    private generateQueryTemplates;
    private generateSearchDepthRules;
    private generateFilteringRules;
    private setupCacheManagement;
    private setupEventHandlers;
    private handlePatternsDiscovered;
    private handlePatternValidated;
    private handleCacheHit;
    private generateSearchQueries;
    private getSearchStrategy;
    private analyzeApplicability;
    private extractImplementationGuidance;
    private extractCodeExamples;
    private extractTags;
    private generateCacheKey;
    private isCacheValid;
    private manageCacheSize;
    private cleanupCache;
    private updateSearchStats;
    private validatePattern;
    private getEmptyQualityMetrics;
    private calculateQualityMetrics;
    private generatePatternId;
    private simpleHash;
    private cleanTitle;
    private extractDomain;
    private extractLanguages;
    private extractFrameworks;
    private getCategoryKeywords;
    private getSourceAuthorityScore;
    private isHighAuthoritySource;
    private containsCodeExamples;
    private calculateWordOverlap;
    private getMaxResultsForDepth;
    private generateDeduplicationKey;
    private generateRecommendations;
    private generateRelatedQueries;
    private updateLearningProfile;
    private generateDeepResearchInstructions;
    private pollDeepResearchResult;
    private parseDeepResearchResults;
    private createPatternFromResearchItem;
    private analyzeCrawledContent;
    private createPatternFromCrawledAnalysis;
    private identifyHighValueUrls;
    private shouldValidateWithContext7;
    private shouldValidateWithSerena;
    private shouldValidateWithSequentialThinking;
    private extractLibraryFromPattern;
    private determineValidationStatus;
    private inferComplexityFromContext;
    private extractTechnologiesFromContext;
    getPatternById(patternId: string): Promise<DiscoveredPattern | null>;
    searchPatternsByTag(tag: string): Promise<DiscoveredPattern[]>;
    getSearchStatistics(): typeof this.searchStats;
    optimizeSearchStrategies(): Promise<void>;
}
//# sourceMappingURL=exa-pattern-discovery.d.ts.map