@oliverpople/agency-x/src/configs/agentConfigs.ts

🚀 **Transform feature requests into production-ready code in seconds**

import { AgentDefinition } from '../utils/agentOrchestrator';
import { CRITICAL_RETRY_CONFIG, DEFAULT_RETRY_CONFIG } from '../utils/errorRecovery';

// Import all agent runners
import { runProductManager } from '../agents/productManager';
import { runFrontendDeveloper } from '../agents/frontendDeveloper';
import { runBackendDeveloper } from '../agents/backendDeveloper';
import { runFullstackIntegrator } from '../agents/fullstackIntegrator';
import { runQaEngineer } from '../agents/qaEngineer';
import { runDocumentationAgent } from '../agents/documentationAgent';
import { runInfraEngineer } from '../agents/infraEngineer';
import { runSecurityEngineer } from '../agents/securityEngineer';
import { runUxDesigner } from '../agents/uxDesigner';
import { runCopywriter } from '../agents/copywriter';
import { runReleaseManager } from '../agents/releaseManager';
import { runAiPromptEngineer } from '../agents/aiPromptEngineer';
import { runDataEngineer } from '../agents/dataEngineer';
import { runReviewerAgent } from '../agents/reviewerAgent';
import { runAssumptionChallenger } from '../agents/assumptionChallenger';
import { runUserEmpathyAgent } from '../agents/userEmpathyAgent';

export const AGENT_DEFINITIONS: AgentDefinition[] = [
  // Phase 1: Product Specification (Critical)
  {
    name: 'productManager',
    dependencies: [],
    critical: true,
    runner: runProductManager,
    config: {
      retryConfig: CRITICAL_RETRY_CONFIG,
      timeout: 120000, // 2 minutes for critical agent
    },
  },

  // Phase 2: Core Development (Parallel, both critical)
  {
    name: 'frontendDeveloper',
    dependencies: ['productManager'],
    critical: true,
    runner: runFrontendDeveloper,
    config: {
      retryConfig: CRITICAL_RETRY_CONFIG,
      timeout: 120000,
    },
  },
  {
    name: 'backendDeveloper',
    dependencies: ['productManager'],
    critical: true,
    runner: runBackendDeveloper,
    config: {
      retryConfig: CRITICAL_RETRY_CONFIG,
      timeout: 120000,
    },
  },

  // Phase 3: Integration (Critical, depends on both frontend and backend)
  {
    name: 'fullstackIntegrator',
    dependencies: ['frontendDeveloper', 'backendDeveloper'],
    critical: true,
    runner: runFullstackIntegrator,
    config: {
      retryConfig: CRITICAL_RETRY_CONFIG,
      timeout: 90000,
    },
  },

  // Phase 4: Testing (Critical, depends on integration)
  {
    name: 'qaEngineer',
    dependencies: ['fullstackIntegrator'],
    critical: true,
    runner: runQaEngineer,
    config: {
      retryConfig: CRITICAL_RETRY_CONFIG,
      timeout: 120000,
    },
  },

  // Phase 5: Parallel Support Tasks (Non-critical)
  {
    name: 'documentationAgent',
    dependencies: ['fullstackIntegrator'],
    critical: false,
    runner: runDocumentationAgent,
    config: {
      retryConfig: DEFAULT_RETRY_CONFIG,
      timeout: 90000,
    },
  },
  {
    name: 'infraEngineer',
    dependencies: ['fullstackIntegrator'],
    critical: false,
    runner: runInfraEngineer,
    config: {
      retryConfig: DEFAULT_RETRY_CONFIG,
      timeout: 90000,
    },
  },
  {
    name: 'securityEngineer',
    dependencies: ['fullstackIntegrator'],
    critical: false,
    runner: runSecurityEngineer,
    config: {
      retryConfig: DEFAULT_RETRY_CONFIG,
      timeout: 90000,
    },
  },
  {
    name: 'uxDesigner',
    dependencies: ['frontendDeveloper'],
    critical: false,
    runner: runUxDesigner,
    config: {
      retryConfig: DEFAULT_RETRY_CONFIG,
      timeout: 90000,
    },
  },

  // Phase 6: Content and Analysis (Parallel, non-critical)
  {
    name: 'copywriter',
    dependencies: ['frontendDeveloper'],
    critical: false,
    runner: runCopywriter,
    config: {
      retryConfig: DEFAULT_RETRY_CONFIG,
      timeout: 90000,
    },
  },
  {
    name: 'aiPromptEngineer',
    dependencies: ['qaEngineer'],
    critical: false,
    runner: runAiPromptEngineer,
    config: {
      retryConfig: DEFAULT_RETRY_CONFIG,
      timeout: 90000,
    },
  },
  {
    name: 'dataEngineer',
    dependencies: ['fullstackIntegrator'],
    critical: false,
    runner: runDataEngineer,
    config: {
      retryConfig: DEFAULT_RETRY_CONFIG,
      timeout: 90000,
    },
  },

  // Phase 7: Review and Analysis (Parallel, non-critical)
  {
    name: 'reviewerAgent',
    dependencies: ['qaEngineer', 'documentationAgent'],
    critical: false,
    runner: runReviewerAgent,
    config: {
      retryConfig: DEFAULT_RETRY_CONFIG,
      timeout: 90000,
    },
  },
  {
    name: 'assumptionChallenger',
    dependencies: ['qaEngineer'],
    critical: false,
    runner: runAssumptionChallenger,
    config: {
      retryConfig: DEFAULT_RETRY_CONFIG,
      timeout: 90000,
    },
  },
  {
    name: 'userEmpathyAgent',
    dependencies: ['uxDesigner'],
    critical: false,
    runner: runUserEmpathyAgent,
    config: {
      retryConfig: DEFAULT_RETRY_CONFIG,
      timeout: 90000,
    },
  },

  // Phase 8: Release Management (Final step, critical)
  {
    name: 'releaseManager',
    dependencies: ['qaEngineer', 'documentationAgent', 'infraEngineer', 'securityEngineer'],
    critical: true,
    runner: runReleaseManager,
    config: {
      retryConfig: CRITICAL_RETRY_CONFIG,
      timeout: 90000,
    },
  },
];

export const getAgentsByPhase = () => {
  const phases = new Map<number, string[]>();
  
  // Manually define phases based on dependencies for better visualization
  phases.set(1, ['productManager']);
  phases.set(2, ['frontendDeveloper', 'backendDeveloper']);
  phases.set(3, ['fullstackIntegrator']);
  phases.set(4, ['qaEngineer']);
  phases.set(5, ['documentationAgent', 'infraEngineer', 'securityEngineer', 'uxDesigner', 'copywriter']);
  phases.set(6, ['aiPromptEngineer', 'dataEngineer']);
  phases.set(7, ['reviewerAgent', 'assumptionChallenger', 'userEmpathyAgent']);
  phases.set(8, ['releaseManager']);
  
  return phases;
};

export const getCriticalAgents = (): string[] => {
  return AGENT_DEFINITIONS
    .filter(agent => agent.critical)
    .map(agent => agent.name);
};

export const getNonCriticalAgents = (): string[] => {
  return AGENT_DEFINITIONS
    .filter(agent => !agent.critical)
    .map(agent => agent.name);
};