--- name: contextual-pattern-learning description: Advanced contextual pattern recognition with project fingerprinting, semantic similarity analysis, and cross-domain pattern matching for enhanced learning capabilities version: 1.0.0 --- ## Contextual Pattern Learning Skill Provides advanced pattern recognition capabilities that understand project context, compute semantic similarities, and identify transferable patterns across different codebases and domains. ## Core Capabilities ### Project Fingerprinting **Multi-dimensional Project Analysis**: - **Technology Stack Detection**: Languages, frameworks, libraries, build tools - **Architectural Patterns**: MVC, microservices, monolith, serverless, etc. - **Code Structure Analysis**: Module organization, dependency patterns, coupling metrics - **Team Patterns**: Coding conventions, commit patterns, testing strategies - **Domain Classification**: Business domain, problem space, user type **Fingerprint Generation**: ```python project_fingerprint = { "technology_hash": sha256(sorted(languages + frameworks + libraries)), "architecture_hash": sha256(architectural_patterns + structural_metrics), "domain_hash": sha256(business_domain + problem_characteristics), "team_hash": sha256(coding_conventions + workflow_patterns), "composite_hash": combine_all_hashes_with_weights() } ``` ### Context Similarity Analysis **Multi-factor Similarity Calculation**: 1. **Technology Similarity (40%)**: Language/framework overlap 2. **Architectural Similarity (25%)**: Structure and design patterns 3. **Domain Similarity (20%)**: Business context and problem type 4. **Scale Similarity (10%)**: Project size and complexity 5. **Team Similarity (5%)**: Development practices and conventions **Semantic Context Understanding**: - **Intent Recognition**: What the code is trying to accomplish - **Problem Space Analysis**: What category of problem being solved - **Solution Pattern Matching**: How similar problems are typically solved - **Contextual Constraints**: Performance, security, maintainability requirements ### Pattern Classification System **Primary Classifications**: - **Implementation Patterns**: Feature addition, API development, UI components - **Refactoring Patterns**: Code cleanup, optimization, architectural changes - **Debugging Patterns**: Bug fixing, issue resolution, problem diagnosis - **Testing Patterns**: Test creation, coverage improvement, test maintenance - **Integration Patterns**: Third-party services, databases, external APIs - **Security Patterns**: Authentication, authorization, vulnerability fixes **Secondary Attributes**: - **Complexity Level**: Simple, moderate, complex, expert - **Risk Level**: Low, medium, high, critical - **Time Sensitivity**: Quick fix, planned work, research task - **Collaboration Required**: Solo, pair, team, cross-team ### Cross-Domain Pattern Transfer **Pattern Transferability Assessment**: ```python def calculate_transferability(pattern, target_context): technology_match = calculate_tech_overlap(pattern.tech, target_context.tech) domain_similarity = calculate_domain_similarity(pattern.domain, target_context.domain) complexity_match = assess_complexity_compatibility(pattern.complexity, target_context.complexity) transferability = ( technology_match * 0.4 + domain_similarity * 0.3 + complexity_match * 0.2 + pattern.success_rate * 0.1 ) return transferability ``` **Adaptation Strategies**: - **Direct Transfer**: Pattern applies without modification - **Technology Adaptation**: Same logic, different implementation - **Architectural Adaptation**: Same approach, different structure - **Conceptual Transfer**: High-level concept, complete reimplementation ## Pattern Matching Algorithm ### Context-Aware Similarity **Weighted Similarity Scoring**: ```python def calculate_contextual_similarity(source_pattern, target_context): # Technology alignment (40%) tech_score = calculate_technology_similarity( source_pattern.technologies, target_context.technologies ) # Problem type alignment (30%) problem_score = calculate_problem_similarity( source_pattern.problem_type, target_context.problem_type ) # Scale and complexity alignment (20%) scale_score = calculate_scale_similarity( source_pattern.scale_metrics, target_context.scale_metrics ) # Domain relevance (10%) domain_score = calculate_domain_relevance( source_pattern.domain, target_context.domain ) return ( tech_score * 0.4 + problem_score * 0.3 + scale_score * 0.2 + domain_score * 0.1 ) ``` ### Pattern Quality Assessment **Multi-dimensional Quality Metrics**: 1. **Outcome Quality**: Final result quality score (0-100) 2. **Process Efficiency**: Time taken vs. expected time 3. **Error Rate**: Number and severity of errors encountered 4. **Reusability**: How easily the pattern can be applied elsewhere 5. **Adaptability**: How much modification was needed for reuse **Quality Evolution Tracking**: - **Initial Quality**: Quality when first captured - **Evolved Quality**: Updated quality after multiple uses - **Context Quality**: Quality in specific contexts - **Time-based Quality**: How quality changes over time ## Learning Strategies ### Progressive Pattern Refinement **1. Pattern Capture**: ```python def capture_pattern(task_execution): pattern = { "id": generate_unique_id(), "timestamp": current_time(), "context": extract_rich_context(task_execution), "execution": extract_execution_details(task_execution), "outcome": extract_outcome_metrics(task_execution), "insights": extract_learning_insights(task_execution), "relationships": extract_pattern_relationships(task_execution) } return refine_pattern_with_learning(pattern) ``` **2. Pattern Validation**: - **Immediate Validation**: Check pattern completeness and consistency - **Cross-validation**: Compare with similar existing patterns - **Predictive Validation**: Test pattern predictive power - **Temporal Validation**: Monitor pattern performance over time **3. Pattern Evolution**: ```python def evolve_pattern(pattern_id, new_execution_data): existing_pattern = load_pattern(pattern_id) # Update success metrics update_success_rates(existing_pattern, new_execution_data) # Refine context understanding refine_context_similarity(existing_pattern, new_execution_data) # Update transferability scores update_transferability_assessment(existing_pattern, new_execution_data) # Generate new insights generate_new_insights(existing_pattern, new_execution_data) save_evolved_pattern(existing_pattern) ``` ### Relationship Mapping **Pattern Relationships**: - **Sequential Patterns**: Patterns that often follow each other - **Alternative Patterns**: Different approaches to similar problems - **Prerequisite Patterns**: Patterns that enable other patterns - **Composite Patterns**: Multiple patterns used together - **Evolutionary Patterns**: Patterns that evolve into other patterns **Relationship Discovery**: ```python def discover_pattern_relationships(patterns): relationships = {} for pattern_a in patterns: for pattern_b in patterns: if pattern_a.id == pattern_b.id: continue # Sequential relationship if often_sequential(pattern_a, pattern_b): relationships[f"{pattern_a.id} -> {pattern_b.id}"] = { "type": "sequential", "confidence": calculate_sequential_confidence(pattern_a, pattern_b) } # Alternative relationship if are_alternatives(pattern_a, pattern_b): relationships[f"{pattern_a.id} <> {pattern_b.id}"] = { "type": "alternative", "confidence": calculate_alternative_confidence(pattern_a, pattern_b) } return relationships ``` ## Context Extraction Techniques ### Static Analysis Context **Code Structure Analysis**: - **Module Organization**: How code is organized into modules/packages - **Dependency Patterns**: How modules depend on each other - **Interface Design**: How components communicate - **Design Patterns**: GoF patterns, architectural patterns used - **Code Complexity**: Cyclomatic complexity, cognitive complexity **Technology Stack Analysis**: ```python def extract_technology_context(project_root): technologies = { "languages": detect_languages(project_root), "frameworks": detect_frameworks(project_root), "databases": detect_databases(project_root), "build_tools": detect_build_tools(project_root), "testing_frameworks": detect_testing_frameworks(project_root), "deployment_tools": detect_deployment_tools(project_root) } return analyze_technology_relationships(technologies) ``` ### Dynamic Context Analysis **Runtime Behavior Patterns**: - **Performance Characteristics**: Speed, memory usage, scalability - **Error Patterns**: Common errors and their contexts - **Usage Patterns**: How the code is typically used - **Interaction Patterns**: How components interact at runtime **Development Workflow Patterns**: ```python def extract_workflow_context(git_history): return { "commit_patterns": analyze_commit_patterns(git_history), "branching_strategy": detect_branching_strategy(git_history), "release_patterns": analyze_release_patterns(git_history), "collaboration_patterns": analyze_collaboration(git_history), "code_review_patterns": analyze_review_patterns(git_history) } ``` ### Semantic Context Analysis **Domain Understanding**: - **Business Domain**: E-commerce, finance, healthcare, education - **Problem Category**: Data processing, user interface, authentication, reporting - **User Type**: End-user, admin, developer, system - **Performance Requirements**: Real-time, batch, high-throughput, low-latency **Intent Recognition**: ```python def extract_intent_context(task_description, code_changes): intent_indicators = { "security": detect_security_intent(task_description, code_changes), "performance": detect_performance_intent(task_description, code_changes), "usability": detect_usability_intent(task_description, code_changes), "maintainability": detect_maintainability_intent(task_description, code_changes), "functionality": detect_functionality_intent(task_description, code_changes) } return rank_intent_by_confidence(intent_indicators) ``` ## Adaptation Learning ### Success Pattern Recognition **What Makes Patterns Successful**: 1. **Context Alignment**: How well the pattern fits the context 2. **Execution Quality**: How well the pattern was executed 3. **Outcome Quality**: The quality of the final result 4. **Efficiency**: Time and resource usage 5. **Adaptability**: How easily the pattern can be modified **Success Factor Analysis**: ```python def analyze_success_factors(pattern): factors = {} # Context alignment factors["context_alignment"] = calculate_context_fit_score(pattern) # Execution quality factors["execution_quality"] = analyze_execution_process(pattern) # Team skill match factors["skill_alignment"] = analyze_team_skill_match(pattern) # Tooling support factors["tooling_support"] = analyze_tooling_effectiveness(pattern) # Environmental factors factors["environment_fit"] = analyze_environmental_fit(pattern) return rank_factors_by_importance(factors) ``` ### Failure Pattern Learning **Common Failure Modes**: 1. **Context Mismatch**: Pattern applied in wrong context 2. **Skill Gap**: Required skills not available 3. **Tooling Issues**: Required tools not available or not working 4. **Complexity Underestimation**: Pattern more complex than expected 5. **Dependency Issues**: Required dependencies not available **Failure Prevention**: ```python def predict_pattern_success(pattern, context): risk_factors = [] # Check context alignment if calculate_context_similarity(pattern.context, context) < 0.6: risk_factors.append({ "type": "context_mismatch", "severity": "high", "mitigation": "consider alternative patterns or adapt context" }) # Check skill requirements required_skills = pattern.execution.skills_required available_skills = context.team_skills missing_skills = set(required_skills) - set(available_skills) if missing_skills: risk_factors.append({ "type": "skill_gap", "severity": "medium", "mitigation": f"acquire skills: {', '.join(missing_skills)}" }) return { "success_probability": calculate_success_probability(pattern, context), "risk_factors": risk_factors, "recommendations": generate_mitigation_recommendations(risk_factors) } ``` ## Pattern Transfer Strategies ### Technology Adaptation **Language-Agnostic Patterns**: - **Algorithmic Patterns**: Logic independent of language syntax - **Architectural Patterns**: Structure independent of implementation - **Process Patterns**: Workflow independent of technology - **Design Patterns**: Object-oriented design principles **Technology-Specific Adaptation**: ```python def adapt_pattern_to_technology(pattern, target_technology): adaptation_rules = load_adaptation_rules(pattern.source_technology, target_technology) adapted_pattern = { "original_pattern": pattern, "target_technology": target_technology, "adaptations": [], "confidence": 0.0 } for rule in adaptation_rules: if rule.applicable(pattern): adaptation = rule.apply(pattern, target_technology) adapted_pattern.adaptations.append(adaptation) adapted_pattern.confidence += adaptation.confidence_boost return validate_adapted_pattern(adapted_pattern) ``` ### Scale Adaptation **Complexity Scaling**: - **Pattern Simplification**: Reduce complexity for simpler contexts - **Pattern Enhancement**: Add complexity for more demanding contexts - **Pattern Modularity**: Break complex patterns into reusable components - **Pattern Composition**: Combine simple patterns for complex solutions **Scale Factor Analysis**: ```python def adapt_pattern_for_scale(pattern, target_scale): current_scale = pattern.scale_context scale_factor = calculate_scale_factor(current_scale, target_scale) if scale_factor > 2.0: # Need to scale up return enhance_pattern_for_scale(pattern, target_scale) elif scale_factor < 0.5: # Need to scale down return simplify_pattern_for_scale(pattern, target_scale) else: # Scale is compatible return pattern.with_scale_adjustments(target_scale) ``` ## Continuous Improvement ### Learning Feedback Loops **1. Immediate Feedback**: - Pattern quality assessment - Success/failure recording - Context accuracy validation - Prediction accuracy tracking **2. Short-term Learning** (Daily/Weekly): - Pattern performance trending - Context similarity refinement - Success factor correlation - Failure pattern identification **3. Long-term Learning** (Monthly): - Cross-domain pattern transfer - Technology evolution adaptation - Team learning integration - Best practice extraction ### Meta-Learning **Learning About Learning**: ```python def analyze_learning_effectiveness(): learning_metrics = { "pattern_accuracy": measure_pattern_prediction_accuracy(), "context_comprehension": measure_context_understanding_quality(), "adaptation_success": measure_pattern_adaptation_success_rate(), "knowledge_transfer": measure_cross_project_knowledge_transfer(), "prediction_improvement": measure_prediction_accuracy_over_time() } return generate_learning_insights(learning_metrics) ``` **Adaptive Learning Strategies**: - **Confidence Adjustment**: Adjust prediction confidence based on accuracy - **Context Weighting**: Refine context importance weights - **Pattern Selection**: Improve pattern selection algorithms - **Feedback Integration**: Better integrate user feedback ## Usage Guidelines ### When to Apply This Skill **Trigger Conditions**: - Starting a new task in an unfamiliar codebase - Need to understand project context quickly - Looking for similar solutions in other projects - Adapting patterns from one technology to another - Estimating task complexity based on historical patterns **Optimal Contexts**: - Multi-language or multi-framework projects - Large codebases with established patterns - Teams working on multiple similar projects - Projects requiring frequent adaptation of solutions - Knowledge sharing across teams or organizations ### Expected Outcomes **Primary Benefits**: - **Faster Context Understanding**: Quickly grasp project structure and conventions - **Better Pattern Matching**: Find more relevant solutions from past experience - **Improved Adaptation**: More successful adaptation of patterns to new contexts - **Cross-Project Learning**: Leverage knowledge from previous projects - **Predictive Insights**: Better predictions of task complexity and success **Quality Metrics**: - **Context Similarity Accuracy**: >85% accurate context matching - **Pattern Transfer Success**: >75% successful pattern adaptation - **Prediction Accuracy**: >80% accurate outcome predictions - **Learning Velocity**: Continuous improvement in pattern quality ## Integration with Other Skills ### Complementary Skills **code-analysis**: - Provides detailed code structure analysis for context extraction - Helps identify design patterns and architectural decisions - Contributes to technology stack detection **quality-standards**: - Provides quality metrics for pattern assessment - Helps establish quality thresholds for pattern selection - Contributes to best practice identification **pattern-learning** (basic): - Provides foundation pattern storage and retrieval - Enhanced by contextual understanding and similarity analysis - Benefits from advanced classification and relationship mapping ### Data Flow ```python # Context extraction context = code_analysis.extract_structure() + contextual_pattern_learning.extract_semantic_context() # Pattern matching matches = contextual_pattern_learning.find_similar_patterns(context, code_analysis.get_quality_metrics()) # Quality assessment quality_score = quality_standards.assess_pattern_quality(matches) # Learning integration contextual_pattern_learning.capture_pattern_with_context(execution_data, context, quality_score) ``` This skill creates a comprehensive contextual understanding system that dramatically improves pattern matching, adaptation, and learning capabilities by considering the rich context in which patterns are created and applied.