shipdeck/lib/ultimate/agents/demo.js

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

/**
 * Task Orchestrator Demo (No Dependencies)
 * Demonstrates orchestrator functionality without requiring API keys
 */

// Mock the dependencies 
const mockAgentRoles = {
  'backend-architect': { systemPrompt: 'Backend architect', temperature: 0.1, maxTokens: 4000 },
  'frontend-developer': { systemPrompt: 'Frontend developer', temperature: 0.2, maxTokens: 4000 },
  'ai-engineer': { systemPrompt: 'AI engineer', temperature: 0.1, maxTokens: 4000 },
  'test-writer-fixer': { systemPrompt: 'Test writer', temperature: 0.1, maxTokens: 3000 },
  'devops-automator': { systemPrompt: 'DevOps automator', temperature: 0.1, maxTokens: 3500 }
};

const mockAgentExecutor = {
  executeAgent: async (agent, prompt, options) => {
    // Simulate some processing time
    await new Promise(resolve => setTimeout(resolve, Math.random() * 100));
    
    return {
      content: [{ text: `Mock response from ${agent}: Successfully processed "${prompt.substring(0, 50)}..."` }],
      metadata: { agent, mockCall: true, sessionId: options.sessionId },
      usage: { inputTokens: 100, outputTokens: 200 },
      hasTests: agent === 'backend-architect' || agent === 'frontend-developer'
    };
  }
};

// Define mappings directly (copied from orchestrator)
const TASK_AGENT_MAPPING = {
  'api': 'backend-architect',
  'database': 'backend-architect', 
  'auth': 'backend-architect',
  'security': 'backend-architect',
  'server': 'backend-architect',
  'backend': 'backend-architect',
  'microservice': 'backend-architect',
  'ui': 'frontend-developer',
  'component': 'frontend-developer',
  'react': 'frontend-developer',
  'frontend': 'frontend-developer',
  'interface': 'frontend-developer',
  'dashboard': 'frontend-developer',
  'form': 'frontend-developer',
  'ai': 'ai-engineer',
  'ml': 'ai-engineer',
  'llm': 'ai-engineer',
  'prompt': 'ai-engineer',
  'intelligence': 'ai-engineer',
  'chatbot': 'ai-engineer',
  'test': 'test-writer-fixer',
  'testing': 'test-writer-fixer',
  'unittest': 'test-writer-fixer',
  'integration': 'test-writer-fixer',
  'coverage': 'test-writer-fixer',
  'deploy': 'devops-automator',
  'deployment': 'devops-automator',
  'ci': 'devops-automator',
  'cd': 'devops-automator',
  'docker': 'devops-automator',
  'infrastructure': 'devops-automator',
  'pipeline': 'devops-automator'
};

const COMPLEXITY_INDICATORS = {
  simple: ['button', 'link', 'text', 'basic', 'simple', 'quick'],
  medium: ['form', 'table', 'chart', 'integration', 'auth', 'crud'],
  complex: ['dashboard', 'analytics', 'workflow', 'payment', 'system', 'architecture']
};

// Create a demo orchestrator without dependencies
class DemoOrchestrator {
  constructor() {
    this.executionHistory = new Map();
    this.activeExecutions = new Map();
  }

  selectAgent(taskType, params) {
    // Direct mapping first
    if (TASK_AGENT_MAPPING[taskType.toLowerCase()]) {
      return TASK_AGENT_MAPPING[taskType.toLowerCase()];
    }

    // Content-based detection
    const description = params.description.toLowerCase();
    
    for (const [keywords, agent] of Object.entries(TASK_AGENT_MAPPING)) {
      if (description.includes(keywords)) {
        return agent;
      }
    }

    // Pattern-based detection
    if (description.includes('test') || description.includes('spec')) {
      return 'test-writer-fixer';
    }
    
    if (description.includes('deploy') || description.includes('build')) {
      return 'devops-automator';
    }
    
    if (description.includes('component') || description.includes('ui') || description.includes('interface')) {
      return 'frontend-developer';
    }
    
    if (description.includes('api') || description.includes('server') || description.includes('database')) {
      return 'backend-architect';
    }
    
    if (description.includes('ai') || description.includes('intelligent') || description.includes('llm')) {
      return 'ai-engineer';
    }

    return 'backend-architect'; // Default
  }

  estimateComplexity(description) {
    const desc = description.toLowerCase();
    
    for (const [level, indicators] of Object.entries(COMPLEXITY_INDICATORS)) {
      if (indicators.some(indicator => desc.includes(indicator))) {
        return level;
      }
    }

    if (desc.length < 50) return 'simple';
    if (desc.length < 200) return 'medium';
    return 'complex';
  }

  getAvailableAgents() {
    return Object.keys(mockAgentRoles).map(agentType => ({
      type: agentType,
      description: mockAgentRoles[agentType].systemPrompt,
      config: {
        temperature: mockAgentRoles[agentType].temperature,
        maxTokens: mockAgentRoles[agentType].maxTokens
      }
    }));
  }
}

function demonstrateOrchestrator() {
  console.log('🚀 Task Orchestrator Demo\n');
  
  const orchestrator = new DemoOrchestrator();
  
  console.log('🤖 Available Agents:');
  const agents = orchestrator.getAvailableAgents();
  agents.forEach(agent => {
    console.log(`   - ${agent.type}: ${agent.description}`);
  });
  
  console.log('\n🎯 Task Routing Examples:');
  const examples = [
    'Create a REST API for user management',
    'Build a responsive login form component',
    'Write comprehensive tests for the payment module', 
    'Set up Docker deployment pipeline',
    'Integrate OpenAI GPT for smart search',
    'Design PostgreSQL database schema',
    'Create mobile-first dashboard UI',
    'Implement secure authentication system',
    'Build analytics dashboard with charts',
    'Create simple button component'
  ];

  examples.forEach(description => {
    const agent = orchestrator.selectAgent('unknown', { description });
    const complexity = orchestrator.estimateComplexity(description);
    const emoji = {
      'backend-architect': '🏗️',
      'frontend-developer': '🎨', 
      'ai-engineer': '🧠',
      'test-writer-fixer': '🧪',
      'devops-automator': '🚀'
    }[agent];
    
    console.log(`   ${emoji} "${description}"`);
    console.log(`      → Agent: ${agent} | Complexity: ${complexity}`);
  });

  console.log('\n📊 Task-Agent Mapping Rules:');
  console.log('   Keywords → Agents:');
  Object.entries(TASK_AGENT_MAPPING).forEach(([keyword, agent]) => {
    console.log(`   - "${keyword}" → ${agent}`);
  });

  console.log('\n🔧 Complexity Estimation Rules:');
  Object.entries(COMPLEXITY_INDICATORS).forEach(([level, indicators]) => {
    console.log(`   - ${level}: ${indicators.join(', ')}`);
  });

  console.log('\n✅ Demo completed! The orchestrator is ready for use.');
  console.log('\n📝 To use with real API calls:');
  console.log('   1. Install dependencies: npm install @anthropic-ai/sdk');
  console.log('   2. Set environment variable: ANTHROPIC_API_KEY');
  console.log('   3. Import TaskOrchestrator from orchestrator.js');
  console.log('   4. Call executeTask() with your tasks');
}

// Run demo if this file is executed directly
if (require.main === module) {
  demonstrateOrchestrator();
}

module.exports = { demonstrateOrchestrator, DemoOrchestrator };