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

moai_adk/templates/.claude/skills/moai-workflow-testing/modules/automated-code-review/trust5-framework/safety-analysis.md

@@ -0,0 +1,148 @@
+# Safety Analysis - TRUST 5 Framework
+
+> Module: Safety category deep dive with security vulnerabilities and error handling
+> Parent: [TRUST 5 Framework](./trust5-framework.md)
+> Complexity: Advanced
+> Time: 15+ minutes
+> Dependencies: Python 3.8+, ast, Context7 MCP
+
+## Overview
+
+Safety (20% weight) validates security and error handling through security vulnerability detection, error handling validation, resource safety checks, and input validation analysis.
+
+## Advanced Security Analysis
+
+### Comprehensive Security Scan
+
+```python
+async def perform_advanced_security_analysis(
+    self, file_path: str, content: str, tree: ast.AST
+) -> List[CodeIssue]:
+    """Perform advanced security analysis."""
+
+    issues = []
+
+    # Load latest security patterns from Context7
+    security_patterns = await self.load_category_patterns()
+    safety_patterns = security_patterns.get('safety', {})
+
+    # Check for race conditions
+    race_conditions = self._detect_race_conditions(tree)
+    issues.extend(race_conditions)
+
+    # Check for resource leaks
+    resource_leaks = self._detect_resource_leaks(tree)
+    issues.extend(resource_leaks)
+
+    # Check for improper error handling
+    error_handling = self._analyze_error_handling(tree)
+    issues.extend(error_handling)
+
+    # Check for input validation issues
+    validation_issues = await self._check_input_validation(
+        file_path, content, safety_patterns
+    )
+    issues.extend(validation_issues)
+
+    return issues
+```
+
+### Resource Leak Detection
+
+```python
+def _detect_resource_leaks(self, tree: ast.AST) -> List[CodeIssue]:
+    """Detect potential resource leaks."""
+
+    issues = []
+
+    # Check for file handles without context managers
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Call):
+            if isinstance(node.func, ast.Name) and node.func.id == 'open':
+                # Check if wrapped in with statement
+                if not self._is_in_with_statement(node):
+                    issue = CodeIssue(
+                        id=f"resource_leak_{node.lineno}",
+                        category=TrustCategory.SAFETY,
+                        severity="medium",
+                        issue_type="code_smell",
+                        title="Potential Resource Leak",
+                        description="File opened without context manager",
+                        file_path=file_path,
+                        line_number=node.lineno,
+                        column_number=node.col_offset,
+                        code_snippet="# File handle may not be properly closed",
+                        suggested_fix="Use 'with open(...)' to ensure proper resource cleanup",
+                        confidence=0.7,
+                        rule_violated="RESOURCE_LEAK"
+                    )
+                    issues.append(issue)
+
+    return issues
+```
+
+## Detection Patterns
+
+### Common Safety Issues
+
+1. **SQL Injection**: Unsanitized input in database queries
+2. **XSS Vulnerabilities**: Unescaped output in web contexts
+3. **Resource Leaks**: Unclosed files, connections, handles
+4. **Race Conditions**: Concurrent access without synchronization
+5. **Missing Error Handling**: Uncaught exceptions
+6. **Weak Cryptography**: Insecure algorithms or key sizes
+7. **Hardcoded Secrets**: Passwords, API keys in source
+
+### Context7 Integration
+
+```python
+# Load safety patterns
+safety = await self.context7.get_library_docs(
+    context7_library_id="/security/owasp",
+    topic="security vulnerability detection 2025",
+    tokens=5000
+)
+```
+
+## Error Handling Analysis
+
+```python
+def _analyze_error_handling(self, tree: ast.AST) -> List[CodeIssue]:
+    """Analyze error handling patterns."""
+
+    issues = []
+
+    # Check for bare except clauses
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ExceptHandler):
+            if node.type is None:
+                issue = CodeIssue(
+                    id=f"bare_except_{node.lineno}",
+                    category=TrustCategory.SAFETY,
+                    severity="medium",
+                    issue_type="code_smell",
+                    title="Bare Except Clause",
+                    description="Catches all exceptions, including system exits",
+                    file_path=file_path,
+                    line_number=node.lineno,
+                    suggested_fix="Specify exception types to catch",
+                    confidence=0.8,
+                    rule_violated="BARE_EXCEPT"
+                )
+                issues.append(issue)
+
+    return issues
+```
+
+## Best Practices
+
+1. Security First: Apply security-by-default principles
+2. Context Managers: Always use context managers for resources
+3. Input Validation: Validate all external input
+4. Error Propagation: Let exceptions propagate to appropriate handlers
+5. Regular Updates: Keep security patterns current
+
+---
+
+Version: 1.0.0
+Last Updated: 2026-01-06

moai_adk/templates/.claude/skills/moai-workflow-testing/modules/automated-code-review/trust5-framework/scoring-algorithms.md

@@ -0,0 +1,196 @@
+# Advanced Scoring Algorithms - TRUST 5 Framework
+
+> Module: Weighted scoring algorithms with complexity adjustment and trend analysis
+> Parent: [TRUST 5 Framework](./trust5-framework.md)
+> Complexity: Advanced
+> Time: 10+ minutes
+> Dependencies: Python 3.8+
+
+## Overview
+
+TRUST 5 scoring uses weighted category calculations (25%, 20%, 25%, 20%, 10%) with advanced factors including severity weighting, confidence scoring, complexity adjustment, and trend analysis for accurate quality assessment.
+
+## Weighted Category Scoring
+
+### Comprehensive Score Calculation
+
+```python
+def calculate_advanced_trust_scores(
+    self, issues: List[CodeIssue], metrics: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Calculate advanced TRUST 5 scores with weighted factors."""
+
+    category_scores = {}
+    category_weights = {
+        TrustCategory.TRUTHFULNESS: 0.25,
+        TrustCategory.RELEVANCE: 0.20,
+        TrustCategory.USABILITY: 0.25,
+        TrustCategory.SAFETY: 0.20,
+        TrustCategory.TIMELINESS: 0.10
+    }
+
+    # Calculate scores for each category
+    for category in TrustCategory:
+        category_issues = [i for i in issues if i.category == category]
+
+        # Base penalty calculation
+        penalty = 0.0
+        for issue in category_issues:
+            severity_weight = self._get_severity_weight(issue.severity)
+            confidence_factor = issue.confidence
+            impact_factor = self._get_impact_factor(issue, metrics)
+            penalty += severity_weight * confidence_factor * impact_factor
+
+        # Apply complexity adjustment
+        complexity_penalty = self._calculate_complexity_penalty(category, metrics)
+
+        # Apply trend factor (historical data)
+        trend_factor = self._calculate_trend_factor(category, category_issues)
+
+        # Calculate final score
+        total_penalty = penalty + complexity_penalty
+        trended_penalty = total_penalty * trend_factor
+        score = max(0.0, 1.0 - min(trended_penalty, 1.0))
+        category_scores[category] = score
+
+    # Calculate overall score
+    overall_score = sum(
+        category_scores[cat] * category_weights[cat]
+        for cat in TrustCategory
+    )
+
+    return {
+        'overall': overall_score,
+        'categories': category_scores,
+        'trend_factors': {cat: self._calculate_trend_factor(cat, [i for i in issues if i.category == cat]) for cat in TrustCategory}
+    }
+```
+
+## Scoring Factors
+
+### Severity Weighting
+
+```python
+def _get_severity_weight(self, severity: str) -> float:
+    """Get severity weight for penalty calculation."""
+
+    weights = {
+        'critical': 0.8,
+        'high': 0.6,
+        'medium': 0.4,
+        'low': 0.2
+    }
+    return weights.get(severity.lower(), 0.3)
+```
+
+### Confidence Factor
+
+Confidence factor (0.0-1.0) from detection algorithm:
+- High confidence (0.8+): Certain detections
+- Medium confidence (0.5-0.8): Probable issues
+- Low confidence (<0.5): Possible issues
+
+### Impact Factor
+
+```python
+def _get_impact_factor(
+    self, issue: CodeIssue, metrics: Dict[str, Any]
+) -> float:
+    """Calculate impact factor based on issue context."""
+
+    # Base impact
+    impact = 1.0
+
+    # Adjust for code complexity
+    if metrics.get('cyclomatic_complexity', 0) > 20:
+        impact *= 1.2
+
+    # Adjust for file size
+    if metrics.get('line_count', 0) > 500:
+        impact *= 1.1
+
+    return min(impact, 2.0)  # Cap at 2x
+```
+
+## Advanced Adjustments
+
+### Complexity Penalty
+
+```python
+def _calculate_complexity_penalty(
+    self, category: TrustCategory, metrics: Dict[str, Any]
+) -> float:
+    """Calculate complexity adjustment for category."""
+
+    base_penalty = 0.0
+
+    # High complexity increases penalty
+    if category == TrustCategory.USABILITY:
+        complexity = metrics.get('cyclomatic_complexity', 0)
+        if complexity > 15:
+            base_penalty += 0.1
+        if complexity > 25:
+            base_penalty += 0.1
+
+    return base_penalty
+```
+
+### Trend Factor
+
+```python
+def _calculate_trend_factor(
+    self, category: TrustCategory, issues: List[CodeIssue]
+) -> float:
+    """Calculate trend factor based on historical data."""
+
+    # Get historical issues for this category
+    historical = self._get_historical_issues(category)
+
+    if not historical:
+        return 1.0  # No trend data
+
+    current_count = len(issues)
+    historical_count = len(historical)
+
+    # Improving trend (fewer issues)
+    if current_count < historical_count:
+        return 0.95  # Boost score
+
+    # Declining trend (more issues)
+    elif current_count > historical_count:
+        return 1.05  # Penalty
+
+    return 1.0  # Stable
+```
+
+## Score Interpretation
+
+### Overall Score Ranges
+
+- **0.90-1.00**: Excellent quality
+- **0.75-0.89**: Good quality
+- **0.60-0.74**: Acceptable quality
+- **0.40-0.59**: Needs improvement
+- **0.00-0.39**: Critical issues
+
+### Category Score Analysis
+
+Individual category scores identify specific improvement areas:
+- **Truthfulness < 0.7**: Logic correctness issues
+- **Relevance < 0.7**: Requirements alignment problems
+- **Usability < 0.7**: Maintainability concerns
+- **Safety < 0.7**: Security vulnerabilities
+- **Timeliness < 0.7**: Performance optimization needed
+
+## Best Practices
+
+1. Baseline Establishment: Establish baseline scores for project
+2. Trend Monitoring: Track scores over time
+3. Threshold Setting: Set minimum score thresholds for CI/CD
+4. Weight Customization: Adjust weights based on project priorities
+5. Historical Analysis: Use trend data to identify patterns
+
+---
+
+Version: 1.0.0
+Last Updated: 2026-01-06

moai_adk/templates/.claude/skills/moai-workflow-testing/modules/automated-code-review/trust5-framework/timeliness-analysis.md

@@ -0,0 +1,168 @@
+# Timeliness Analysis - TRUST 5 Framework
+
+> Module: Timeliness category deep dive with performance optimization and modern practices
+> Parent: [TRUST 5 Framework](./trust5-framework.md)
+> Complexity: Advanced
+> Time: 10+ minutes
+> Dependencies: Python 3.8+, ast
+
+## Overview
+
+Timeliness (10% weight) validates performance and modern practices through optimization opportunity identification, deprecated code detection, performance standards validation, and technology currency checks.
+
+## Performance Optimization Detection
+
+### Comprehensive Performance Analysis
+
+```python
+def analyze_performance_opportunities(
+    self, file_path: str, content: str, tree: ast.AST
+) -> List[CodeIssue]:
+    """Identify performance optimization opportunities."""
+
+    issues = []
+
+    # Check for inefficient data structures
+    data_structure_issues = self._check_inefficient_data_structures(tree)
+    issues.extend(data_structure_issues)
+
+    # Check for missing caching opportunities
+    caching_opportunities = self._identify_caching_opportunities(tree)
+    issues.extend(caching_opportunities)
+
+    # Check for suboptimal algorithms
+    algorithm_issues = self._check_algorithm_efficiency(tree)
+    issues.extend(algorithm_issues)
+
+    # Check for I/O optimization opportunities
+    io_issues = self._check_io_optimization(tree)
+    issues.extend(io_issues)
+
+    return issues
+```
+
+### Caching Opportunity Detection
+
+```python
+def _identify_caching_opportunities(self, tree: ast.AST) -> List[CodeIssue]:
+    """Identify functions that could benefit from caching."""
+
+    issues = []
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            # Check for pure functions (no side effects)
+            if self._is_pure_function(node) and not self._has_decorator(node, 'lru_cache'):
+                # Check if function is called frequently
+                if self._is_frequently_called(node, tree):
+                    issue = CodeIssue(
+                        id=f"caching_opportunity_{node.lineno}",
+                        category=TrustCategory.TIMELINESS,
+                        severity="low",
+                        issue_type="performance_issue",
+                        title="Caching Opportunity",
+                        description=f"Function '{node.name}' could benefit from caching",
+                        file_path=file_path,
+                        line_number=node.lineno,
+                        column_number=1,
+                        code_snippet=f"def {node.name}(...):",
+                        suggested_fix=f"Consider adding @lru_cache to '{node.name}'",
+                        confidence=0.6,
+                        rule_violated="CACHING_OPPORTUNITY"
+                    )
+                    issues.append(issue)
+
+    return issues
+```
+
+## Detection Patterns
+
+### Common Timeliness Issues
+
+1. **Inefficient Data Structures**: Using lists where sets/dicts would be better
+2. **Missing Caching**: Repeated expensive calculations without memoization
+3. **String Concatenation**: Inefficient string building in loops
+4. **Global Variables**: Excessive global variable usage
+5. **Deprecated APIs**: Use of deprecated functions/modules
+6. **Unoptimized Loops**: Nested loops without early exit
+7. **Missing Async**: Blocking I/O without async/await
+
+### Technology Currency Checks
+
+```python
+def check_technology_currency(
+    self, file_path: str, content: str
+) -> List[CodeIssue]:
+    """Check for outdated technology usage."""
+
+    issues = []
+
+    # Check for deprecated imports
+    deprecated = [
+        'from threading import Timer',  # Use asyncio instead
+        'import time',  # Consider time.perf_counter()
+    ]
+
+    for dep in deprecated:
+        if dep in content:
+            issue = CodeIssue(
+                id=f"deprecated_{dep}",
+                category=TrustCategory.TIMELINESS,
+                severity="low",
+                issue_type="code_smell",
+                title="Deprecated Pattern",
+                description=f"Consider modern alternatives to '{dep}'",
+                file_path=file_path,
+                suggested_fix="Update to current best practices",
+                confidence=0.7,
+                rule_violated="DEPRECATED_PATTERN"
+            )
+            issues.append(issue)
+
+    return issues
+```
+
+## Performance Best Practices
+
+### Algorithmic Efficiency
+
+```python
+def _check_algorithm_efficiency(self, tree: ast.AST) -> List[CodeIssue]:
+    """Check for suboptimal algorithm choices."""
+
+    issues = []
+
+    # Check for O(n^2) operations in loops
+    for node in ast.walk(tree):
+        if isinstance(node, ast.For):
+            if self._has_nested_linear_search(node):
+                issue = CodeIssue(
+                    id=f"inefficient_search_{node.lineno}",
+                    category=TrustCategory.TIMELINESS,
+                    severity="medium",
+                    issue_type="performance_issue",
+                    title="Inefficient Search",
+                    description="Linear search in nested loop",
+                    file_path=file_path,
+                    line_number=node.lineno,
+                    suggested_fix="Use set/dict for O(1) lookup",
+                    confidence=0.8,
+                    rule_violated="INEFFICIENT_ALGORITHM"
+                )
+                issues.append(issue)
+
+    return issues
+```
+
+## Best Practices
+
+1. Profile First: Measure before optimizing
+2. Data Structures: Choose appropriate data structures
+3. Caching: Apply caching to pure functions
+4. I/O Bound: Use async for I/O operations
+5. Regular Updates: Stay current with best practices
+
+---
+
+Version: 1.0.0
+Last Updated: 2026-01-06

moai_adk/templates/.claude/skills/moai-workflow-testing/modules/automated-code-review/trust5-framework/truthfulness-analysis.md

@@ -0,0 +1,136 @@
+# Truthfulness Analysis - TRUST 5 Framework
+
+> Module: Truthfulness category deep dive with logic correctness and data flow analysis
+> Parent: [TRUST 5 Framework](./trust5-framework.md)
+> Complexity: Advanced
+> Time: 10+ minutes
+> Dependencies: Python 3.8+, ast, Context7 MCP
+
+## Overview
+
+Truthfulness (25% weight) validates code correctness and logic accuracy through comprehensive analysis of algorithmic correctness, logic error detection, data flow integrity, and contract compliance.
+
+## Logic Correctness Validation
+
+### Tautology Detection
+
+```python
+def _detect_tautologies(self, tree: ast.AST) -> List[CodeIssue]:
+    """Detect tautological comparisons (always True)."""
+
+    issues = []
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Compare):
+            # Check for comparisons that are always True
+            # Example: x > -1 (where x is len(something))
+            if self._is_always_true_comparison(node):
+                issue = CodeIssue(
+                    id=f"tautology_{node.lineno}",
+                    category=TrustCategory.TRUTHFULNESS,
+                    severity="low",
+                    issue_type="code_smell",
+                    title="Tautological Comparison",
+                    description="Comparison is always True",
+                    file_path=file_path,
+                    line_number=node.lineno,
+                    column_number=node.col_offset,
+                    code_snippet="# Tautological comparison detected",
+                    suggested_fix="Remove unnecessary comparison or simplify logic",
+                    confidence=0.7,
+                    rule_violated="TAUTOLOGICAL_COMPARISON"
+                )
+                issues.append(issue)
+
+    return issues
+```
+
+### Comprehensive Logic Validation
+
+```python
+async def validate_logic_correctness(
+    self, file_path: str, tree: ast.AST
+) -> List[CodeIssue]:
+    """Comprehensive logic correctness validation."""
+
+    issues = []
+
+    # Check for tautological comparisons
+    tautologies = self._detect_tautologies(tree)
+    issues.extend(tautologies)
+
+    # Check for contradictory conditions
+    contradictions = self._detect_contradictions(tree)
+    issues.extend(contradictions)
+
+    # Check for constant conditions
+    constant_conditions = self._detect_constant_conditions(tree)
+    issues.extend(constant_conditions)
+
+    # Check for type confusion
+    type_issues = self._detect_type_confusion(tree)
+    issues.extend(type_issues)
+
+    return issues
+```
+
+## Data Flow Analysis
+
+### Variable Usage Validation
+
+```python
+def analyze_data_flow(self, file_path: str, tree: ast.AST) -> List[CodeIssue]:
+    """Analyze data flow for correctness issues."""
+
+    issues = []
+
+    # Check for undefined variables
+    undefined_vars = self._check_undefined_variables(tree)
+    issues.extend(undefined_vars)
+
+    # Check for unused variables
+    unused_vars = self._check_unused_variables(tree)
+    issues.extend(unused_vars)
+
+    # Check for variable shadowing
+    shadowing = self._check_variable_shadowing(tree)
+    issues.extend(shadowing)
+
+    return issues
+```
+
+## Detection Patterns
+
+### Common Truthfulness Issues
+
+1. **Tautological Comparisons**: Conditions that always evaluate to True/False
+2. **Contradictory Conditions**: Mutually exclusive conditions in same logic path
+3. **Constant Conditions**: Conditions using only constant values
+4. **Type Confusion**: Operations between incompatible types
+5. **Undefined Variables**: References to variables before definition
+6. **Unused Variables**: Variables defined but never read
+7. **Variable Shadowing**: Inner scope variables hiding outer scope
+
+### Context7 Integration
+
+```python
+# Load truthfulness patterns
+truthfulness = await self.context7.get_library_docs(
+    context7_library_id="/code-correctness/python",
+    topic="logic error detection patterns 2025",
+    tokens=3000
+)
+```
+
+## Best Practices
+
+1. Pattern Matching: Use AST patterns to detect logic errors
+2. Type Inference: Apply type inference to catch type confusion
+3. Flow Analysis: Track variable usage across scopes
+4. Context Awareness: Consider project-specific logic patterns
+5. False Positive Reduction: Use confidence scoring to reduce noise
+
+---
+
+Version: 1.0.0
+Last Updated: 2026-01-06