moai-adk 0.25.4__py3-none-any.whl → 0.41.0__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-workflow-testing/modules/ai-debugging.md

@@ -0,0 +1,302 @@
+# AI-Powered Debugging Integration
+
+> Module: Comprehensive AI debugging with Context7 integration and intelligent error analysis
+> Complexity: Advanced
+> Time: 20+ minutes
+> Dependencies: Python 3.8+, Context7 MCP, asyncio, traceback, dataclasses
+
+## Overview
+
+AI-powered debugging system that combines intelligent error classification, Context7 documentation integration, and pattern recognition to provide comprehensive error analysis and solution generation.
+
+### Core Capabilities
+
+Error Classification: AI-enhanced error categorization with context-aware type mapping and severity assessment
+
+Context7 Integration: Automatic retrieval of latest debugging patterns and best practices from official documentation
+
+Pattern Matching: Comprehensive regex-based error pattern recognition with confidence scoring
+
+Solution Generation: Multi-source solution generation from patterns, Context7, and AI-generated fixes
+
+Learning System: Self-improving debugger that learns from successful fixes over time
+
+### Key Features
+
+Intelligent Classification: Multi-heuristic error classification using type mapping, message analysis, and context awareness
+
+Comprehensive Solutions: Pattern-based, Context7-sourced, and AI-generated solutions with confidence scoring
+
+Prevention Strategies: Type-specific prevention strategies and related error detection for proactive debugging
+
+Performance Monitoring: Built-in statistics tracking, error frequency analysis, and cache optimization
+
+---
+
+## Quick Reference
+
+### Error Type Classification
+
+System supports comprehensive error type categorization:
+
+- Syntax Errors: SYNTAX - Syntax and indentation issues
+- Import Errors: IMPORT - Module import and dependency issues
+- Runtime Errors: RUNTIME - General runtime exceptions
+- Type Errors: TYPE_ERROR - Data type mismatches
+- Value Errors: VALUE_ERROR - Invalid value conversions
+- Attribute Errors: ATTRIBUTE_ERROR - Object attribute access issues
+- Key Errors: KEY_ERROR - Dictionary key access issues
+- Network Errors: NETWORK - Connection and timeout issues
+- Database Errors: DATABASE - SQL and database operation issues
+- Memory Errors: MEMORY - Memory allocation and heap issues
+- Concurrency Errors: CONCURRENCY - Thread and locking issues
+- Unknown Errors: UNKNOWN - Uncategorized or novel errors
+
+### Data Structures
+
+Core data classes for error analysis:
+
+```python
+from dataclasses import dataclass
+from enum import Enum
+
+class ErrorType(Enum):
+    """Classification of error types for intelligent handling."""
+    SYNTAX = "syntax_error"
+    RUNTIME = "runtime_error"
+    IMPORT = "import_error"
+    TYPE_ERROR = "type_error"
+    VALUE_ERROR = "value_error"
+    ATTRIBUTE_ERROR = "attribute_error"
+    KEY_ERROR = "key_error"
+    NETWORK = "network_error"
+    DATABASE = "database_error"
+    MEMORY = "memory_error"
+    CONCURRENCY = "concurrency_error"
+    UNKNOWN = "unknown_error"
+
+@dataclass
+class ErrorAnalysis:
+    """Analysis of an error with classification and metadata."""
+    type: ErrorType
+    confidence: float
+    message: str
+    traceback: str
+    context: Dict[str, Any]
+    frequency: int
+    severity: str  # "low", "medium", "high", "critical"
+    likely_causes: List[str]
+    suggested_fixes: List[str]
+
+@dataclass
+class Solution:
+    """Proposed solution for an error."""
+    type: str  # "context7_pattern", "ai_generated", "known_fix"
+    description: str
+    code_example: str
+    confidence: float
+    impact: str  # "low", "medium", "high"
+    dependencies: List[str]
+
+@dataclass
+class DebugAnalysis:
+    """Complete debug analysis with solutions and prevention strategies."""
+    error_type: ErrorType
+    confidence: float
+    context7_patterns: Dict[str, Any]
+    solutions: List[Solution]
+    prevention_strategies: List[str]
+    related_errors: List[str]
+    estimated_fix_time: str
+```
+
+### Basic Usage Pattern
+
+Standard debugging workflow implementation:
+
+```python
+debugger = AIDebugger(context7_client=context7)
+
+try:
+    result = some_risky_operation()
+except Exception as e:
+    analysis = await debugger.debug_with_context7_patterns(
+        e,
+        {'file': __file__, 'function': 'some_risky_operation', 'language': 'python'},
+        '/project/src'
+    )
+
+    print(f"Error type: {analysis.error_type}")
+    print(f"Confidence: {analysis.confidence}")
+    print(f"Solutions found: {len(analysis.solutions)}")
+
+    for i, solution in enumerate(analysis.solutions, 1):
+        print(f"\nSolution {i}:")
+        print(f" Description: {solution.description}")
+        print(f" Confidence: {solution.confidence}")
+        print(f" Impact: {solution.impact}")
+        if solution.code_example:
+            print(f" Example:\n{solution.code_example}")
+```
+
+---
+
+## Implementation Guide
+
+### Module Structure
+
+The AI debugging system is organized into progressive modules:
+
+Main Module (Current File): Overview and quick reference with data structures and usage patterns
+
+Core Implementation: [debugging-workflows.md](./debugging/debugging-workflows.md) - Complete AIDebugger class with initialization, error patterns, main debugging method, error classification, Context7 integration, and learning extensions
+
+Advanced Analysis: [error-analysis.md](./debugging/error-analysis.md) - Pattern matching, solution generation, code examples, severity assessment, prevention strategies, fix time estimation, and statistics tracking
+
+### Core Implementation Workflow
+
+Complete AIDebugger class implementation with Context7 integration:
+
+Step 1: Initialize debugger with Context7 client and load error patterns database
+
+Step 2: Classify error using AI-enhanced pattern recognition with context awareness
+
+Step 3: Retrieve Context7 patterns for latest debugging documentation and best practices
+
+Step 4: Match error against known patterns using regex matching and solution lookup
+
+Step 5: Generate comprehensive solutions from patterns, Context7, and AI sources
+
+Step 6: Suggest prevention strategies and estimate fix time based on error complexity
+
+### Error Classification Process
+
+Multi-heuristic error classification using three analysis layers:
+
+Layer 1 - Direct Type Mapping: Maps standard Python exceptions to ErrorType categories using direct type name matching
+
+Layer 2 - Message Pattern Analysis: Analyzes error message content for network, database, memory, and concurrency keywords
+
+Layer 3 - Context-Based Classification: Uses operation context from provided metadata for enhanced accuracy
+
+### Context7 Integration Pattern
+
+Automatic documentation retrieval for debugging patterns:
+
+Build Context7 Queries: Construct queries based on error type, language, and framework context
+
+Retrieve Documentation: Fetch latest debugging patterns from Context7 with intelligent caching
+
+Apply Best Practices: Integrate official documentation solutions into analysis results
+
+### Solution Generation Strategy
+
+Multi-source solution generation with confidence scoring:
+
+Pattern-Based Solutions: High-confidence solutions from known error patterns with code examples
+
+Context7 Solutions: Latest best practices from official documentation with moderate confidence
+
+AI-Generated Solutions: Fallback AI-generated solutions when limited patterns available
+
+Prioritization: Solutions sorted by confidence and impact with top 5 recommendations returned
+
+---
+
+## Advanced Modules
+
+### Debugging Workflows Implementation
+
+Complete AIDebugger class implementation with initialization, error classification, Context7 integration, and learning extensions: [debugging-workflows.md](./debugging/debugging-workflows.md)
+
+Key Features:
+- AIDebugger class structure with comprehensive error patterns database
+- Main debugging workflow with end-to-end error analysis pipeline
+- AI-enhanced error classification with multi-heuristic approach
+- Context7 integration with intelligent query building and caching
+- Learning debugger extension with successful fix tracking
+- Enhanced context collection with stack frame analysis
+- Complete usage examples for common debugging scenarios
+
+### Error Analysis and Solution Patterns
+
+Comprehensive error categorization, solution generation, and prevention strategies: [error-analysis.md](./debugging/error-analysis.md)
+
+Key Features:
+- Pattern matching system with regex support for error messages
+- Multi-source solution generation with confidence scoring
+- Code example generation for common error patterns
+- Severity assessment based on context and frequency
+- Likely causes analysis for root cause identification
+- Quick fix generation for immediate resolution
+- Type-specific prevention strategies for proactive debugging
+- Related error detection and fix time estimation
+- Debug statistics and error frequency tracking
+- Cache management and confidence calculation
+
+---
+
+## Best Practices
+
+Context Collection: Always provide comprehensive context including file paths, function names, language, framework, operation type, and environment indicators
+
+Error Categorization: Use specific error types for better pattern matching and solution relevance
+
+Solution Validation: Test proposed solutions in isolated environment before applying to production code
+
+Learning Integration: Record successful fixes with error signatures to improve pattern recognition over time
+
+Performance Monitoring: Track debugging session performance with statistics, cache efficiency, and error frequency analysis
+
+Prevention Strategy Implementation: Prioritize prevention strategies based on error frequency, severity, and systematic impact
+
+Pattern Database Maintenance: Regularly update error patterns with new solutions and Context7 topics for continuous improvement
+
+---
+
+## Module Statistics
+
+Current Module: ai-debugging.md (overview and quick reference)
+- Lines: 245 (within 500-line limit)
+- Purpose: Entry point with data structures and usage patterns
+
+Core Implementation: debugging/debugging-workflows.md
+- Lines: 350 (within 500-line limit)
+- Purpose: Complete AIDebugger class with initialization and Context7 integration
+
+Advanced Analysis: debugging/error-analysis.md
+- Lines: 350 (within 500-line limit)
+- Purpose: Pattern matching, solution generation, and prevention strategies
+
+---
+
+## Works Well With
+
+Context7 MCP: Latest documentation retrieval for debugging patterns and best practices
+
+Python Testing: Integration with pytest, unittest, and async test frameworks
+
+Error Tracking: Compatibility with Sentry, Rollbar, and error monitoring systems
+
+IDE Integration: Works with VS Code, PyCharm, and debugger integrations
+
+Performance Optimization: Complements performance profiling and bottleneck analysis
+
+Smart Refactoring: Coordinates with code refactoring workflows for systematic improvements
+
+---
+
+## Related Modules
+
+Smart Refactoring: [smart-refactoring.md](./smart-refactoring.md) - AI-assisted code refactoring with pattern matching
+
+Performance Optimization: [performance-optimization.md](./performance-optimization.md) - Performance profiling and optimization patterns
+
+Automated Code Review: [automated-code-review.md](./automated-code-review.md) - Code quality analysis with Context7 integration
+
+---
+
+Module: modules/ai-debugging.md
+Version: 2.0.0 (Modular Architecture)
+Last Updated: 2025-12-07
+Lines: 245 (within 500-line limit)

moai_adk/templates/.claude/skills/moai-workflow-testing/modules/automated-code-review/context7-integration.md

@@ -0,0 +1,286 @@
+# Context7 MCP Integration
+
+> Module: Context7 integration patterns for real-time security and quality analysis
+> Parent: [Automated Code Review](../automated-code-review.md)
+> Complexity: Advanced
+> Time: 20+ minutes
+> Dependencies: Python 3.8+, Context7 MCP client
+
+## Quick Reference
+
+### Context7 Integration Overview
+
+Context7 MCP provides real-time access to:
+- OWASP Top 10 security vulnerability patterns
+- Semgrep security detection rules
+- SonarQube code quality standards
+- Performance optimization libraries
+- TRUST 5 validation frameworks
+
+### Core Integration Pattern
+
+```python
+class Context7CodeAnalyzer:
+    """Integration with Context7 for code analysis patterns."""
+
+    def __init__(self, context7_client=None):
+        self.context7 = context7_client
+        self.analysis_patterns = {}
+        self.security_patterns = {}
+        self.performance_patterns = {}
+
+    async def load_analysis_patterns(self, language: str = "python") -> Dict[str, Any]:
+        """Load code analysis patterns from Context7."""
+
+        if not self.context7:
+            return self._get_default_analysis_patterns()
+
+        try:
+            # Load security analysis patterns
+            security_patterns = await self.context7.get_library_docs(
+                context7_library_id="/security/semgrep",
+                topic="security vulnerability detection patterns 2025",
+                tokens=4000
+            )
+            self.security_patterns = security_patterns
+
+            # Load performance analysis patterns
+            performance_patterns = await self.context7.get_library_docs(
+                context7_library_id="/performance/python-profiling",
+                topic="performance anti-patterns code analysis 2025",
+                tokens=3000
+            )
+            self.performance_patterns = performance_patterns
+
+            # Load code quality patterns
+            quality_patterns = await self.context7.get_library_docs(
+                context7_library_id="/code-quality/sonarqube",
+                topic="code quality best practices smells detection 2025",
+                tokens=4000
+            )
+
+            # Load TRUST 5 validation patterns
+            trust_patterns = await self.context7.get_library_docs(
+                context7_library_id="/code-review/trust-framework",
+                topic="TRUST 5 code validation framework patterns 2025",
+                tokens=3000
+            )
+
+            return {
+                'security': security_patterns,
+                'performance': performance_patterns,
+                'quality': quality_patterns,
+                'trust': trust_patterns
+            }
+
+        except Exception as e:
+            print(f"Failed to load Context7 patterns: {e}")
+            return self._get_default_analysis_patterns()
+```
+
+---
+
+## Security Pattern Integration
+
+### OWASP Top 10 Patterns
+
+```python
+async def load_owasp_patterns(self) -> Dict[str, Any]:
+    """Load OWASP Top 10 vulnerability patterns."""
+
+    owasp_patterns = await self.context7.get_library_docs(
+        context7_library_id="/security/owasp",
+        topic="OWASP Top 10 2021 vulnerability detection patterns",
+        tokens=5000
+    )
+
+    return {
+        'a01_injection': owasp_patterns.get('injection', []),
+        'a02_broken_auth': owasp_patterns.get('authentication', []),
+        'a03_injection_data': owasp_patterns.get('data_injection', []),
+        'a04_xss': owasp_patterns.get('xss', []),
+        'a05_security_misconfig': owasp_patterns.get('misconfiguration', []),
+        'a06_old_components': owasp_patterns.get('outdated', []),
+        'a07_auth_failures': owasp_patterns.get('auth_failure', []),
+        'a08_data_failures': owasp_patterns.get('data_failure', []),
+        'a09_security_logging': owasp_patterns.get('logging', []),
+        'a10_ssrf': owasp_patterns.get('ssrf', [])
+    }
+```
+
+### Semgrep Rule Integration
+
+```python
+async def load_semgrep_rules(self) -> Dict[str, Any]:
+    """Load Semgrep security rules."""
+
+    semgrep_rules = await self.context7.get_library_docs(
+        context7_library_id="/security/semgrep",
+        topic="Semgrep Python security rules 2025",
+        tokens=6000
+    )
+
+    return {
+        'injection_rules': semgrep_rules.get('injection', []),
+        'crypto_rules': semgrep_rules.get('crypto', []),
+        'authentication_rules': semgrep_rules.get('auth', []),
+        'resource_rules': semgrep_rules.get('resource', []),
+        'serialization_rules': semgrep_rules.get('serialization', [])
+    }
+```
+
+---
+
+## Quality Pattern Integration
+
+### SonarQube Quality Rules
+
+```python
+async def load_sonarqube_rules(self) -> Dict[str, Any]:
+    """Load SonarQube code quality rules."""
+
+    sonarqube_rules = await self.context7.get_library_docs(
+        context7_library_id="/code-quality/sonarqube",
+        topic="SonarQube Python quality rules code smells 2025",
+        tokens=5000
+    )
+
+    return {
+        'complexity_rules': sonarqube_rules.get('complexity', []),
+        'maintainability_rules': sonarqube_rules.get('maintainability', []),
+        'reliability_rules': sonarqube_rules.get('reliability', []),
+        'security_rules': sonarqube_rules.get('security', []),
+        'style_rules': sonarqube_rules.get('style', [])
+    }
+```
+
+---
+
+## Performance Pattern Integration
+
+### Profiling Best Practices
+
+```python
+async def load_performance_patterns(self) -> Dict[str, Any]:
+    """Load performance optimization patterns."""
+
+    performance_patterns = await self.context7.get_library_docs(
+        context7_library_id="/performance/python-profiling",
+        topic="Python performance profiling optimization patterns 2025",
+        tokens=5000
+    )
+
+    return {
+        'anti_patterns': performance_patterns.get('anti_patterns', []),
+        'optimization_techniques': performance_patterns.get('optimizations', []),
+        'profiling_strategies': performance_patterns.get('profiling', []),
+        'benchmarking_methods': performance_patterns.get('benchmarking', [])
+    }
+```
+
+---
+
+## Error Handling and Fallbacks
+
+```python
+def _get_default_analysis_patterns(self) -> Dict[str, Any]:
+    """Get default analysis patterns when Context7 is unavailable."""
+
+    return {
+        'security': {
+            'sql_injection': [
+                r"execute\([^)]*\+[^)]*\)",
+                r"format\s*\(",
+                r"%\s*[^,]*s"
+            ],
+            'command_injection': [
+                r"os\.system\(",
+                r"subprocess\.call\(",
+                r"eval\("
+            ],
+            'path_traversal': [
+                r"open\([^)]*\+[^)]*\)",
+                r"\.\.\/"
+            ]
+        },
+        'performance': {
+            'inefficient_loops': [
+                r"for.*in.*range\(len\(",
+                r"while.*len\("
+            ],
+            'memory_leaks': [
+                r"global\s+",
+                r"\.append\(.*\)\s*\.append\("
+            ]
+        },
+        'quality': {
+            'long_functions': {'max_lines': 50},
+            'complex_conditionals': {'max_complexity': 10},
+            'deep_nesting': {'max_depth': 4}
+        }
+    }
+```
+
+---
+
+## Caching Strategy
+
+```python
+class CachedContext7Analyzer(Context7CodeAnalyzer):
+    """Context7 analyzer with pattern caching."""
+
+    def __init__(self, context7_client=None, cache_duration_hours=24):
+        super().__init__(context7_client)
+        self.cache_duration = cache_duration_hours * 3600
+        self.pattern_cache = {}
+
+    async def load_analysis_patterns(self, language: str = "python") -> Dict[str, Any]:
+        """Load patterns with caching."""
+
+        cache_key = f"{language}_patterns"
+        cached_data = self.pattern_cache.get(cache_key)
+
+        # Check if cache is valid
+        if cached_data:
+            cache_age = time.time() - cached_data['timestamp']
+            if cache_age < self.cache_duration:
+                return cached_data['patterns']
+
+        # Load fresh patterns
+        patterns = await super().load_analysis_patterns(language)
+
+        # Cache the patterns
+        self.pattern_cache[cache_key] = {
+            'patterns': patterns,
+            'timestamp': time.time()
+        }
+
+        return patterns
+```
+
+---
+
+## Best Practices
+
+1. Fallback Patterns: Always provide default patterns when Context7 unavailable
+2. Caching: Implement caching to reduce Context7 API calls
+3. Token Management: Use appropriate token allocation for each pattern type
+4. Error Handling: Implement robust error handling for Context7 failures
+5. Pattern Updates: Refresh patterns periodically for latest security/quality standards
+6. Gradual Loading: Load patterns on-demand to reduce initial load time
+7. Custom Patterns: Allow project-specific pattern customization
+8. Documentation: Document pattern sources and update frequencies
+
+---
+
+## Related Modules
+
+- [Security Analysis](../security-analysis.md): Security pattern usage
+- [Quality Metrics](../quality-metrics.md): Quality pattern integration
+- [trust5-framework.md](./trust5-framework.md): TRUST 5 pattern loading
+
+---
+
+Version: 1.0.0
+Last Updated: 2026-01-06
+Module: `modules/automated-code-review/context7-integration.md`