shipdeck/lib/ultimate/quality-gates/example-usage.js

Ship MVPs in 48 hours. Fix bugs in 30 seconds. The command deck for developers who ship.

/**
 * Quality Gates System - Example Usage
 * 
 * Demonstrates how to use the comprehensive Quality Gates System
 * with 54 embedded rules organized into 3 tiers for the 48-hour MVP guarantee.
 */

const { QualityGatesSystem } = require('./index');

async function demonstrateQualityGates() {
  console.log('🛡️ Shipdeck Ultimate - Quality Gates System Demo');
  console.log('================================================\n');
  
  // Initialize the Quality Gates System
  const qualityGates = new QualityGatesSystem({
    // Tier settings
    tier1AutoFix: true,
    tier2MaxRetries: 3,
    tier3RequireApproval: true,
    
    // Performance thresholds
    maxGateProcessingTime: 5000, // 5 seconds
    falsePositiveThreshold: 0.01, // <1%
    
    // Success targets
    targetSuccessRate: 0.95, // 95% success rate
    
    // Integration
    dagWorkflowIntegration: true,
    rollbackOnCriticalFailure: true,
    
    // Security scanning
    enableStaticAnalysis: true,
    enableDependencyScanning: true,
    enableSecretsDetection: true,
    
    // Performance validation
    maxBundleSize: 2048, // 2MB
    maxInitialLoadTime: 3000, // 3 seconds
    minPerformanceScore: 90,
    
    // Test coverage
    minLineCoverage: 80,
    minBranchCoverage: 75,
    requireEdgeCaseCoverage: true,
    
    // Rollback triggers
    enableAutoRollback: true,
    rollbackOnCriticalSecurity: true,
    rollbackOnBreakingChanges: true
  });
  
  // Example 1: Processing good quality code
  console.log('📝 Example 1: Processing high-quality code');
  console.log('=========================================');
  
  const goodCodeArtifact = {
    type: 'react-component',
    content: `
'use client';

import React, { useMemo } from 'react';
import { cn } from '@/lib/utils';

interface UserProfileProps {
  userId: string;
  className?: string;
}

export const metadata = {
  title: 'User Profile',
  description: 'User profile component'
};

export default async function UserProfile({ userId, className }: UserProfileProps) {
  const userData = useMemo(() => {
    // Memoized computation
    return fetchUserData(userId);
  }, [userId]);
  
  const handleUserUpdate = (data: UserData): void => {
    if (!data?.id) {
      throw new Error('Invalid user data');
    }
    
    updateUser(data);
  };
  
  return (
    <div className={cn('user-profile', className)}>
      <h1>User Profile</h1>
      {userData && <UserDetails user={userData} onUpdate={handleUserUpdate} />}
    </div>
  );
}

async function fetchUserData(userId: string): Promise<UserData | null> {
  try {
    const response = await fetch(\`/api/users/\${userId}\`);
    return response.json();
  } catch (error) {
    console.error('Failed to fetch user:', error);
    return null;
  }
}
    `,
    files: [
      {
        name: 'components/UserProfile.tsx',
        content: '// Main component content above'
      },
      {
        name: 'components/UserProfile.test.tsx',
        content: `
import { render, screen } from '@testing-library/react';
import UserProfile from './UserProfile';

describe('UserProfile', () => {
  it('renders user profile correctly', async () => {
    render(<UserProfile userId="123" />);
    expect(screen.getByText('User Profile')).toBeInTheDocument();
  });
  
  it('handles invalid user data', () => {
    expect(() => handleUserUpdate(null)).toThrow('Invalid user data');
  });
  
  it('handles fetch errors gracefully', async () => {
    // Mock fetch to fail
    global.fetch = jest.fn().mockRejectedValue(new Error('Network error'));
    
    const result = await fetchUserData('123');
    expect(result).toBeNull();
  });
});
        `
      },
      {
        name: 'package.json',
        content: JSON.stringify({
          name: 'quality-gates-demo',
          version: '1.0.0',
          dependencies: {
            react: '^18.2.0',
            'next': '^14.0.0'
          },
          devDependencies: {
            '@testing-library/react': '^13.4.0',
            jest: '^29.0.0',
            typescript: '^5.0.0'
          }
        }, null, 2)
      }
    ]
  };
  
  try {
    const result1 = await qualityGates.applyQualityGates(goodCodeArtifact, {
      environment: 'development',
      author: 'developer@example.com',
      pullRequest: 'PR-123'
    });
    
    console.log(`✅ Result: ${result1.success ? 'PASSED' : 'FAILED'}`);
    console.log(`📊 Processing time: ${result1.processingTime}ms`);
    if (result1.gateResults) {
      console.log(`🔧 Tier 1 fixes: ${result1.gateResults.filter(r => r.tier === 1).reduce((sum, r) => sum + (r.fixedCount || 0), 0)}`);
      console.log(`🔄 Tier 2 retries: ${result1.gateResults.filter(r => r.tier === 2).reduce((sum, r) => sum + (r.retryCount || 0), 0)}`);
      console.log(`⚠️  Tier 3 approvals: ${result1.gateResults.filter(r => r.tier === 3).reduce((sum, r) => sum + (r.approvalCount || 0), 0)}`);
    }
    
  } catch (error) {
    console.error(`❌ Processing failed: ${error.message}`);
  }
  
  console.log('\n');
  
  // Example 2: Processing problematic code
  console.log('⚠️  Example 2: Processing code with violations');
  console.log('=============================================');
  
  const problematicCodeArtifact = {
    type: 'react-component',
    content: `
// Missing 'use client' directive for interactive component
import React from 'react';

// Using 'any' type (Tier 1 violation)
function processData(data: any) {
  // Hardcoded API key (Tier 3 violation - critical security)
  const apiKey = 'sk_live_abcd1234567890';
  
  // SQL injection vulnerability (Tier 3 violation)
  const query = 'SELECT * FROM users WHERE id = ' + data.userId;
  
  // No error handling (Tier 2 violation)
  const result = fetch('/api/data?query=' + query);
  return result;
}

// Async client component (Tier 1 violation)
export default async function ProblematicComponent({ data }) {
  // Missing return type (Tier 2 violation)
  const handleClick = () => {
    // Expensive operation without memoization (Tier 2 violation)
    const processed = data.items.map(item => 
      item.values.filter(v => v.active).reduce((sum, v) => sum + v.amount, 0)
    );
    
    processData({ userId: processed[0] });
  };
  
  // Inline styles instead of cn() (Tier 2 violation)
  return (
    <div style={{ backgroundColor: 'red', padding: '10px' }}>
      <button onClick={handleClick}>Process Data</button>
    </div>
  );
}
    `,
    files: [
      {
        name: 'components/ProblematicComponent.tsx',
        content: '// Main component content above'
      }
      // Note: No test file (Tier 2 violation)
    ]
  };
  
  try {
    const result2 = await qualityGates.applyQualityGates(problematicCodeArtifact, {
      environment: 'production',
      author: 'developer@example.com',
      pullRequest: 'PR-456'
    });
    
    console.log(`${result2.success ? '✅' : '❌'} Result: ${result2.success ? 'PASSED' : 'FAILED'}`);
    console.log(`📊 Processing time: ${result2.processingTime}ms`);
    
    if (result2.pending) {
      console.log(`⏳ Status: PENDING (awaiting human approval)`);
      console.log(`🆔 Approval ID: ${result2.approvalId}`);
    }
    
    if (result2.gateResults) {
      result2.gateResults.forEach(gateResult => {
        console.log(`\n🛡️  Tier ${gateResult.tier} Results:`);
        if (gateResult.fixedCount) console.log(`  ✅ Fixed: ${gateResult.fixedCount} issues`);
        if (gateResult.retryCount) console.log(`  🔄 Retries: ${gateResult.retryCount}`);
        if (gateResult.approvalCount) console.log(`  ⚠️  Approvals: ${gateResult.approvalCount}`);
        if (gateResult.remainingViolations?.length) {
          console.log(`  🚫 Remaining: ${gateResult.remainingViolations.length} violations`);
        }
      });
    }
    
    // If pending approval, simulate approval decision
    if (result2.pending && result2.approvalId) {
      console.log('\n🔄 Simulating human approval decision...');
      
      // Simulate reviewer decision (in real implementation, this would come from UI)
      const approvalDecision = {
        approver: 'senior-developer@example.com',
        approved: false, // Reject due to critical security issues
        reason: 'Critical security vulnerabilities detected: hardcoded API keys and SQL injection risks. Please fix before deployment.',
        modifiedArtifact: null // No modifications provided
      };
      
      const finalResult = await qualityGates.resumePendingGate(result2.approvalId, approvalDecision);
      console.log(`${finalResult.success ? '✅' : '❌'} Final Result: ${finalResult.success ? 'APPROVED' : 'DENIED'}`);
      console.log(`📝 Reason: ${finalResult.message}`);
    }
    
  } catch (error) {
    console.error(`❌ Processing failed: ${error.message}`);
  }
  
  console.log('\n');
  
  // Example 3: Generate quality report
  console.log('📊 Example 3: Quality reporting');
  console.log('===============================');
  
  const report = await qualityGates.generateQualityReport({
    type: 'dashboard',
    format: 'markdown',
    timeRange: '24h',
    includeExecutiveSummary: true,
    includeTrends: true,
    includeRecommendations: true
  });
  
  if (report.success) {
    console.log('📋 Quality Dashboard Report Generated:');
    console.log('-------------------------------------');
    console.log(report.report.substring(0, 500) + '...\n');
  }
  
  // Example 4: System statistics
  console.log('📈 Example 4: System statistics');
  console.log('==============================');
  
  const stats = qualityGates.getStatistics();
  console.log(`📊 Quality Gates Statistics:`);
  console.log(`   Total Checks: ${stats.totalChecks}`);
  console.log(`   Success Rate: ${Math.round(stats.successRate * 100)}%`);
  console.log(`   Tier 1 Fixes: ${stats.tier1Fixes}`);
  console.log(`   Tier 2 Retries: ${stats.tier2Retries}`);
  console.log(`   Tier 3 Approvals: ${stats.tier3Approvals}`);
  console.log(`   Critical Blocks: ${stats.criticalBlocks}`);
  console.log(`   Avg Processing Time: ${Math.round(stats.averageProcessingTime)}ms`);
  console.log(`   Health Status: ${stats.healthStatus.toUpperCase()}`);
  
  console.log('\n');
  
  // Example 5: DAG Workflow Integration
  console.log('🔄 Example 5: DAG Workflow Integration');
  console.log('====================================');
  
  // Create a simple workflow
  const { DAGWorkflow } = require('../workflow/dag-workflow');
  const workflow = new DAGWorkflow('mvp-deployment', {
    name: 'MVP Deployment Pipeline',
    description: 'Complete MVP deployment with quality gates'
  });
  
  // Add workflow nodes
  workflow.addNode({
    id: 'code-generation',
    name: 'Generate MVP Code',
    agent: 'rapid-prototyper',
    prompt: 'Generate a complete MVP for the requested features'
  });
  
  workflow.addNode({
    id: 'quality-gates',
    name: 'Apply Quality Gates',
    agent: 'quality-gates',
    dependencies: ['code-generation'],
    prompt: 'Apply comprehensive quality gates to the generated MVP code'
  });
  
  workflow.addNode({
    id: 'deployment',
    name: 'Deploy MVP',
    agent: 'devops-automator',
    dependencies: ['quality-gates'],
    prompt: 'Deploy the quality-approved MVP to production'
  });
  
  // Integrate quality gates with the workflow
  const integratedWorkflow = qualityGates.createWorkflowIntegration(workflow);
  
  if (integratedWorkflow) {
    console.log(`✅ Workflow integrated with quality gates`);
    console.log(`📈 Total nodes: ${integratedWorkflow.nodes.size}`);
    console.log(`🛡️  Quality gate nodes: ${Array.from(integratedWorkflow.nodes.keys()).filter(id => id.includes('quality-gate')).length}`);
  }
  
  console.log('\n🎉 Quality Gates System Demo Complete!');
  console.log('\n📋 Summary:');
  console.log('===========');
  console.log('✅ 54 embedded rules organized into 3 tiers');
  console.log('✅ Automatic Tier 1 fixes (formatting, imports, syntax)');
  console.log('✅ Intelligent Tier 2 retries with AI feedback');
  console.log('✅ Human approval workflow for Tier 3 critical issues');
  console.log('✅ Comprehensive security scanning with OWASP compliance');
  console.log('✅ Performance validation with Core Web Vitals');
  console.log('✅ Test coverage verification with quality scoring');
  console.log('✅ Automatic rollback triggers for critical failures');
  console.log('✅ Real-time quality reporting and metrics dashboard');
  console.log('✅ DAG workflow engine integration');
  console.log('✅ 95%+ success rate target for 48-hour MVP guarantee');
  
  console.log('\n🚀 Ready for production use in Shipdeck Ultimate!');
}

// Run the demonstration
if (require.main === module) {
  demonstrateQualityGates().catch(console.error);
}

module.exports = {
  demonstrateQualityGates
};