@specverse/mcp/resources/examples/api-calls/orchestrator-workflow-example.js

SpecVerse MCP Server - Universal AI assistance for all environments

/**
 * SpecVerse Orchestrator API Example
 * Demonstrates library-aware AI specification generation through API
 */

import { LibraryAwareOrchestrator } from '@specverse/lang/orchestrator';

async function generateSpecificationWithLibraries() {
  console.log('🚀 SpecVerse Library-Aware Orchestrator Example');
  
  // Initialize enhanced orchestrator with library support
  const orchestrator = new LibraryAwareOrchestrator({
    libraryPath: 'libs/catalog.yaml',
    promptTemplatesPath: 'prompts/core/',
    contextOptimization: true
  });

  await orchestrator.initialize();

  // Define workflow specification request
  const specificationRequest = {
    projectType: 'healthcare-management',
    description: 'Patient management system for small clinic with appointments, medical records, billing',
    requirements: [
      'Patient registration and profiles',
      'Appointment scheduling',
      'Medical record management', 
      'HIPAA compliance required',
      'Integration with existing billing system'
    ],
    scale: 'small-to-medium',
    compliance: ['HIPAA'],
    technology_preferences: ['database', 'web_app'],
    constraints: {
      budget: 'moderate',
      team_size: '2-3 developers',
      timeline: '3 months'
    }
  };

  try {
    // Step 1: Analyze project and generate library recommendations
    console.log('\n📊 Analyzing project requirements...');
    const analysis = await orchestrator.analyse('.', specificationRequest);
    
    console.log('Library Recommendations:');
    analysis.libraryRecommendations.forEach(rec => {
      console.log(`  ✅ ${rec.type}: ${rec.name} - ${rec.rationale}`);
    });

    // Step 2: Create library-enhanced specification
    console.log('\n🏗️ Generating specification with library integration...');
    const creation = await orchestrator.create(specificationRequest, {
      includeLibraryContext: true,
      optimizeForTokens: true,
      generatePrompts: true
    });

    console.log('Generated Specification:');
    console.log(JSON.stringify(creation.specification, null, 2));
    
    console.log('\n📈 Library Usage Analysis:');
    console.log(`  Libraries Used: ${creation.libraryUsage.count}`);
    console.log(`  Expansion Factor: ${creation.expansionFactor}x`);
    console.log(`  Code Reduction: ${creation.libraryUsage.codeReductionPercent}%`);

    // Step 3: Generate contextual prompts for different ecosystems
    console.log('\n🎯 Generated Ecosystem Prompts:');
    
    console.log('\n💻 Terminal/Chat Prompt:');
    console.log(creation.prompts.terminal);
    
    console.log('\n🔧 Claude Code Integration Prompt:');
    console.log(creation.prompts.claude);
    
    console.log('\n⚙️ API Integration Context:');
    console.log(creation.prompts.api);

    // Step 4: Materialize with library-aware context
    console.log('\n🚀 Materializing complete specification...');
    const materialization = await orchestrator.materialise(creation.specification, {
      includeLibraryExpansions: true,
      generateDocumentation: true,
      createDeploymentConfig: true
    });

    console.log('\nMaterialization Results:');
    console.log(`  Total Files Generated: ${materialization.files.length}`);
    console.log(`  Documentation Pages: ${materialization.documentation?.pages || 0}`);
    console.log(`  Deployment Configs: ${materialization.deploymentConfigs?.length || 0}`);

    // Step 5: Validate library integration
    console.log('\n✅ Validating library integration...');
    const validation = await orchestrator.validate(materialization.specification);
    
    console.log('Validation Results:');
    console.log(`  Schema Valid: ${validation.schemaValid}`);
    console.log(`  Library Compatibility: ${validation.libraryCompatibility}`);
    console.log(`  Expansion Applied: ${validation.expansionApplied}`);
    
    if (validation.issues?.length > 0) {
      console.log('\n⚠️ Validation Issues:');
      validation.issues.forEach(issue => {
        console.log(`  - ${issue.severity}: ${issue.message}`);
      });
    }

    // Generate final orchestrator report
    const report = {
      projectAnalysis: analysis,
      specification: creation,
      materialization: materialization,
      validation: validation,
      summary: {
        librariesUsed: creation.libraryUsage.libraries,
        expansionAchieved: `${creation.expansionFactor}x`,
        codeReduction: `${creation.libraryUsage.codeReductionPercent}%`,
        complianceRequirements: specificationRequest.compliance,
        estimatedDevelopmentTime: creation.metadata?.estimatedTime || 'Not calculated'
      }
    };

    console.log('\n📋 Final Orchestrator Report:');
    console.log('==========================================');
    console.log(`Project: ${specificationRequest.projectType}`);
    console.log(`Libraries Integrated: ${report.summary.librariesUsed.join(', ')}`);
    console.log(`Specification Expansion: ${report.summary.expansionAchieved}`);
    console.log(`Code Reduction: ${report.summary.codeReduction}`);
    console.log(`Compliance: ${report.summary.complianceRequirements.join(', ')}`);
    console.log('==========================================');

    return report;

  } catch (error) {
    console.error('❌ Orchestrator workflow failed:', error);
    throw error;
  }
}

// Example usage patterns for different integration scenarios
async function demonstrateIntegrationPatterns() {
  console.log('\n🔄 Integration Pattern Examples');
  
  const orchestrator = new LibraryAwareOrchestrator();
  await orchestrator.initialize();

  // Pattern 1: CI/CD Pipeline Integration
  console.log('\n1️⃣ CI/CD Pipeline Integration:');
  const cicdSpec = await orchestrator.generateFromTemplate('api-pipeline', {
    triggerOn: 'git-push',
    includeLibraryContext: true,
    outputFormat: 'json'
  });
  console.log('   ✅ Generated pipeline-ready specification');

  // Pattern 2: Development Tool Integration  
  console.log('\n2️⃣ Development Tool Integration:');
  const devToolSpec = await orchestrator.generateContextualPrompt('healthcare-app', 'vscode');
  console.log('   ✅ Generated VSCode-optimized prompts');

  // Pattern 3: Automated Workflow Orchestration
  console.log('\n3️⃣ Automated Workflow:');
  const workflowResult = await orchestrator.executeWorkflow({
    name: 'generate-and-validate',
    steps: ['analyze', 'create', 'materialize', 'validate'],
    libraryAware: true
  });
  console.log('   ✅ Executed complete automated workflow');

  console.log('\n🎯 All integration patterns completed successfully!');
}

// Execute examples
async function runExamples() {
  try {
    await generateSpecificationWithLibraries();
    await demonstrateIntegrationPatterns();
    
    console.log('\n🎉 All orchestrator examples completed successfully!');
    console.log('\nKey Benefits Demonstrated:');
    console.log('  ✅ Library-aware specification generation');
    console.log('  ✅ Multi-ecosystem prompt generation');
    console.log('  ✅ Automated workflow orchestration');
    console.log('  ✅ Context optimization for tokens');
    console.log('  ✅ Compliance and validation integration');
    
  } catch (error) {
    console.error('❌ Example execution failed:', error);
    process.exit(1);
  }
}

// Export for use as module
export {
  generateSpecificationWithLibraries,
  demonstrateIntegrationPatterns,
  runExamples
};

// Run if executed directly
if (import.meta.url === `file://${process.argv[1]}`) {
  runExamples();
}