moai-foundation-quality skill

---
name: moai-foundation-quality
description: Enterprise code quality orchestrator with TRUST 5 validation, proactive analysis, and automated best practices enforcement
version: 2.0.0
modularized: true
scripts_enabled: true
allowed-tools: Read, Write, Edit, Bash, Grep, Glob, TodoWrite, mcp__context7__resolve-library-id, mcp__context7__get-library-docs
last_updated: 2025-11-30
compliance_score: 90
auto_trigger_keywords:
  - foundation
  - quality
scripts:
  - name: quality-gate.sh
    purpose: Enterprise Code Quality Gate Script
    type: shell
    command: bash .claude/skills/moai-foundation-quality/scripts/quality-gate.sh
    zero_context: false
    version: 1.0.0
    last_updated: 2025-11-30
color: red
---

# Enterprise Code Quality Orchestrator

Enterprise-grade code quality management system that combines systematic code review, proactive improvement suggestions, and automated best practices enforcement. Provides comprehensive quality assurance through TRUST 5 framework validation with Context7 integration for real-time best practices.

## Quick Reference (30 seconds)

**Core Capabilities**:
- **TRUST 5 Validation**: Testable, Readable, Unified, Secured, Trackable quality gates
- **Proactive Analysis**: Automated issue detection and improvement suggestions
- **Best Practices Enforcement**: Context7-powered real-time standards validation
- **Multi-Language Support**: 25+ programming languages with specialized rules
- **Enterprise Integration**: CI/CD pipelines, quality metrics, reporting

**Key Patterns**:
1. **Quality Gate Pipeline** → Automated validation with configurable thresholds
2. **Proactive Scanner** → Continuous analysis with improvement recommendations
3. **Best Practices Engine** → Context7-driven standards enforcement
4. **Quality Metrics Dashboard** → Comprehensive reporting and trend analysis

**When to Use**:
- Code review automation and quality gate enforcement
- Proactive code quality improvement and technical debt reduction
- Enterprise coding standards enforcement and compliance validation
- CI/CD pipeline integration with automated quality checks

**Quick Access**:
- TRUST 5 Framework → [trust5-validation.md](modules/trust5-validation.md)
- Proactive Analysis → [proactive-analysis.md](modules/proactive-analysis.md)
- Best Practices → [best-practices.md](modules/best-practices.md)
- Integration Patterns → [integration-patterns.md](modules/integration-patterns.md)

## Implementation Guide

### Getting Started

**Basic Quality Validation**:
```python
# Initialize quality orchestrator
quality_orchestrator = QualityOrchestrator(
    trust5_enabled=True,
    proactive_analysis=True,
    best_practices_enforcement=True,
    context7_integration=True
)

# Run comprehensive quality analysis
result = await quality_orchestrator.analyze_codebase(
    path="src/",
    languages=["python", "javascript", "typescript"],
    quality_threshold=0.85
)

# Quality gate validation with TRUST 5
quality_gate = QualityGate()
validation_result = await quality_gate.validate_trust5(
    codebase_path="src/",
    test_coverage_threshold=0.90,
    complexity_threshold=10
)
```

**Proactive Quality Analysis**:
```python
# Initialize proactive scanner
proactive_scanner = ProactiveQualityScanner(
    context7_client=context7_client,
    rule_engine=BestPracticesEngine()
)

# Scan for improvement opportunities
improvements = await proactive_scanner.scan_codebase(
    path="src/",
    scan_types=["security", "performance", "maintainability", "testing"]
)

# Generate improvement recommendations
recommendations = await proactive_scanner.generate_recommendations(
    issues=improvements,
    priority="high",
    auto_fix=True
)
```

### Core Components

#### 1. Quality Orchestration Engine

```python
class QualityOrchestrator:
    """Enterprise quality orchestration with TRUST 5 framework"""

    def __init__(self, config: QualityConfig):
        self.trust5_validator = TRUST5Validator()
        self.proactive_scanner = ProactiveScanner()
        self.best_practices_engine = BestPracticesEngine()
        self.context7_client = Context7Client()
        self.metrics_collector = QualityMetricsCollector()

    async def analyze_codebase(self, request: QualityAnalysisRequest) -> QualityResult:
        """Comprehensive codebase quality analysis"""

        # Phase 1: TRUST 5 Validation
        trust5_result = await self.trust5_validator.validate(
            codebase=request.path,
            thresholds=request.quality_thresholds
        )

        # Phase 2: Proactive Analysis
        proactive_result = await self.proactive_scanner.scan(
            codebase=request.path,
            focus_areas=request.focus_areas
        )

        # Phase 3: Best Practices Check
        practices_result = await self.best_practices_engine.validate(
            codebase=request.path,
            languages=request.languages,
            context7_docs=True
        )

        # Phase 4: Metrics Collection
        metrics = await self.metrics_collector.collect_comprehensive_metrics(
            codebase=request.path,
            analysis_results=[trust5_result, proactive_result, practices_result]
        )

        return QualityResult(
            trust5_validation=trust5_result,
            proactive_analysis=proactive_result,
            best_practices=practices_result,
            metrics=metrics,
            overall_score=self._calculate_overall_quality_score([
                trust5_result, proactive_result, practices_result
            ])
        )
```

Detailed implementations:
- [TRUST 5 Validator Implementation](modules/trust5-validation.md#trust-5-validator-implementation)
- [Proactive Scanner Implementation](modules/proactive-analysis.md#proactive-scanner-implementation)
- [Best Practices Engine Implementation](modules/best-practices.md#best-practices-engine-implementation)

### Configuration and Customization

**Quality Configuration**:
```yaml
# quality-config.yaml
quality_orchestration:
  trust5_framework:
    enabled: true
    thresholds:
      overall: 0.85
      testable: 0.90
      readable: 0.80
      unified: 0.85
      secured: 0.90
      trackable: 0.80

  proactive_analysis:
    enabled: true
    scan_frequency: "daily"
    focus_areas:
      - "performance"
      - "security"
      - "maintainability"
      - "technical_debt"

    auto_fix:
      enabled: true
      severity_threshold: "medium"
      confirmation_required: true

  best_practices:
    enabled: true
    context7_integration: true
    auto_update_standards: true
    compliance_target: 0.85

    language_rules:
      python:
        style_guide: "pep8"
        formatter: "black"
        linter: "ruff"
        type_checker: "mypy"

      javascript:
        style_guide: "airbnb"
        formatter: "prettier"
        linter: "eslint"

      typescript:
        style_guide: "google"
        formatter: "prettier"
        linter: "eslint"

  reporting:
    enabled: true
    metrics_retention_days: 90
    trend_analysis: true
    executive_dashboard: true

    notifications:
      quality_degradation: true
      security_vulnerabilities: true
      technical_debt_increase: true
```

**Integration Examples**:

See [Integration Patterns](modules/integration-patterns.md) for:
- CI/CD Pipeline Integration
- GitHub Actions Integration
- Quality-as-Service REST API
- Cross-Project Benchmarking

## Advanced Patterns

### 1. Custom Quality Rules

```python
class CustomQualityRule:
    """Define custom quality validation rules"""

    def __init__(self, name: str, validator: Callable, severity: str = "medium"):
        self.name = name
        self.validator = validator
        self.severity = severity

    async def validate(self, codebase: str) -> RuleResult:
        """Execute custom rule validation"""
        try:
            result = await self.validator(codebase)
            return RuleResult(
                rule_name=self.name,
                passed=result.passed,
                severity=self.severity,
                details=result.details,
                recommendations=result.recommendations
            )
        except Exception as e:
            return RuleResult(
                rule_name=self.name,
                passed=False,
                severity="error",
                details={"error": str(e)},
                recommendations=["Fix rule implementation"]
            )
```

See [Best Practices - Custom Rules](modules/best-practices.md#custom-quality-rules) for complete examples.

### 2. Machine Learning Quality Prediction

ML-powered quality issue prediction using code feature extraction and predictive models.

See [Proactive Analysis - ML Prediction](modules/proactive-analysis.md#machine-learning-quality-prediction) for implementation details.

### 3. Real-time Quality Monitoring

Continuous quality monitoring with automated alerting for quality degradation and security vulnerabilities.

See [Proactive Analysis - Real-time Monitoring](modules/proactive-analysis.md#real-time-quality-monitoring) for implementation details.

### 4. Cross-Project Quality Benchmarking

Compare project quality metrics against similar projects in your industry.

See [Integration Patterns - Benchmarking](modules/integration-patterns.md#cross-project-quality-benchmarking) for implementation details.

## Module Reference

### Core Modules

- **[TRUST 5 Validation](modules/trust5-validation.md)** - Comprehensive quality framework validation
- **[Proactive Analysis](modules/proactive-analysis.md)** - Automated issue detection and improvements
- **[Best Practices](modules/best-practices.md)** - Context7-powered standards enforcement
- **[Integration Patterns](modules/integration-patterns.md)** - CI/CD and enterprise integrations

### Key Components by Module

**TRUST 5 Validation**:
- `TRUST5Validator` - Five-pillar quality validation
- `TestableValidator` - Test coverage and quality
- `SecuredValidator` - Security and OWASP compliance
- Quality gate pipeline integration

**Proactive Analysis**:
- `ProactiveQualityScanner` - Automated issue detection
- `QualityPredictionEngine` - ML-powered predictions
- `RealTimeQualityMonitor` - Continuous monitoring
- Performance and maintainability analysis

**Best Practices**:
- `BestPracticesEngine` - Standards validation
- Context7 integration for latest docs
- Custom quality rules
- Language-specific validators

**Integration Patterns**:
- CI/CD pipeline integration
- GitHub Actions workflows
- Quality-as-Service REST API
- Cross-project benchmarking

## Context7 Library Mappings

Essential library mappings for quality analysis tools and frameworks.

See [Best Practices - Library Mappings](modules/best-practices.md#context7-library-mappings) for complete list.

## Works Well With

**Agents**:
- **core-planner** - Quality requirements planning
- **workflow-tdd** - TDD implementation validation
- **security-expert** - Security vulnerability analysis
- **code-backend** - Backend code quality
- **code-frontend** - Frontend code quality

**Skills**:
- **moai-foundation-core** - TRUST 5 framework reference
- **moai-tdd-implementation** - TDD workflow validation
- **moai-security-owasp** - Security compliance
- **moai-context7-integration** - Context7 best practices
- **moai-performance-optimization** - Performance analysis

**Commands**:
- `/moai:2-run` - TDD validation integration
- `/moai:3-sync` - Documentation quality checks
- `/moai:9-feedback` - Quality improvement feedback

## Quick Reference Summary

**Core Capabilities**: TRUST 5 validation, proactive scanning, Context7-powered best practices, multi-language support, enterprise integration

**Key Classes**: `QualityOrchestrator`, `TRUST5Validator`, `ProactiveQualityScanner`, `BestPracticesEngine`, `QualityMetricsCollector`

**Essential Methods**: `analyze_codebase()`, `validate_trust5()`, `scan_for_issues()`, `validate_best_practices()`, `generate_quality_report()`

**Integration Ready**: CI/CD pipelines, GitHub Actions, REST APIs, real-time monitoring, cross-project benchmarking

**Enterprise Features**: Custom rules, ML prediction, real-time monitoring, benchmarking, comprehensive reporting

**Quality Standards**: OWASP compliance, TRUST 5 framework, Context7 integration, automated improvement recommendations