agentic-qe 3.3.2 → 3.3.4

package/v3/dist/mcp/handlers/domain-handlers.js

@@ -8,1066 +8,195 @@
  * - Learning feedback confirming pattern updates
  * - Worker efficiency and load balance stats
  * - Complexity analysis
+ *
+ * Refactored in Milestone 1.3 to use the handler factory pattern,
+ * reducing code from ~1,578 lines to ~400 lines.
+ *
+ * @module mcp/handlers/domain-handlers
  */
-import { randomUUID } from 'crypto';
-import { getFleetState, isFleetInitialized } from './core-handlers';
-import { createTaskExecutor } from '../../coordination/task-executor';
-import { MetricsCollector } from '../metrics';
-import { getTaskRouter } from '../services/task-router';
-// ============================================================================
-// V2-Compatible Response Helpers
-// ============================================================================
-function generateTestId() {
-    // Use crypto.randomUUID() for cryptographically secure unique IDs
-    return `test-${randomUUID()}`;
-}
-function generateAgentId(type) {
-    // Use crypto.randomUUID() for cryptographically secure unique IDs
-    return `${type}-${randomUUID()}`;
-}
+import { createDomainHandler, resetTaskExecutor as resetExecutor } from './handler-factory';
+import { testGenerateConfig, testExecuteConfig, coverageAnalyzeConfig, qualityAssessConfig, securityScanConfig, contractValidateConfig, accessibilityTestConfig, chaosTestConfig, defectPredictConfig, requirementsValidateConfig, codeIndexConfig, } from './domain-handler-configs';
 // ============================================================================
-// ADR-051: Task Routing Integration
+// Task Executor Management
 // ============================================================================
 /**
- * Route a domain task through the Model Router
- * Returns routing decision with model tier recommendation
+ * Reset executor when fleet is reinitialized
  */
-async function routeDomainTask(taskDescription, domain, codeContext) {
-    try {
-        const router = await getTaskRouter();
-        const result = await router.routeTask({
-            task: taskDescription,
-            domain,
-            codeContext,
-            agentType: `qe-${domain}`,
-        });
-        return result;
-    }
-    catch (error) {
-        // Log but don't fail - routing is advisory
-        console.error(`[DomainHandlers] Routing failed for ${domain}: ${error}`);
-        return null;
-    }
-}
-// ============================================================================
-// V2-Compatible Response Helpers
-// ============================================================================
-function analyzeComplexity(sourceCode) {
-    const lines = sourceCode.split('\n').length;
-    const branches = (sourceCode.match(/if|switch|for|while|catch/g) || []).length;
-    const score = lines + branches * 2;
-    return {
-        score,
-        level: branches > 5 ? 'high' : branches > 2 ? 'medium' : 'low'
-    };
-}
-function generateV2Tests(sourceCode, testType, language, count) {
-    const tests = [];
-    const funcRegex = /(?:function\s+(\w+)|const\s+(\w+)\s*=|def\s+(\w+)|func\s+(\w+))/g;
-    const functions = [];
-    let match;
-    while ((match = funcRegex.exec(sourceCode)) !== null) {
-        const funcName = match[1] || match[2] || match[3] || match[4];
-        if (funcName)
-            functions.push(funcName);
-    }
-    // Generate tests for each function
-    for (let i = 0; i < Math.min(functions.length, count); i++) {
-        const funcName = functions[i] || `exampleFunction`;
-        tests.push({
-            id: generateTestId(),
-            name: `test_${funcName}_${i}`,
-            type: testType,
-            parameters: [],
-            assertions: [`${funcName}() === null`],
-            expectedResult: null,
-            estimatedDuration: testType === 'integration' ? 2000 : 1000,
-            aiGenerated: true,
-        });
-    }
-    // Add integration test if needed
-    if (testType === 'integration' || count > functions.length) {
-        tests.push({
-            id: generateTestId(),
-            name: `integration_ComponentA_${tests.length}`,
-            type: 'integration',
-            parameters: [],
-            assertions: ['ComponentA integration test passes'],
-            expectedResult: null,
-            estimatedDuration: 2000,
-            aiGenerated: true,
-        });
-    }
-    // Add edge case tests
-    const edgeCases = ['high-complexity', 'deep-nesting', 'null-handling', 'empty-input'];
-    for (let i = tests.length; i < count && i - tests.length < edgeCases.length; i++) {
-        tests.push({
-            id: generateTestId(),
-            name: `edge_case_${edgeCases[i - tests.length]}_${i}`,
-            type: 'unit',
-            parameters: [],
-            assertions: [`${edgeCases[i - tests.length]} edge case handled`],
-            expectedResult: null,
-            estimatedDuration: 1500,
-            aiGenerated: true,
-        });
-    }
-    return tests;
-}
-function generateV2AIInsights(complexity, testType) {
-    const recommendations = [];
-    if (complexity.level === 'high') {
-        recommendations.push('Consider refactoring complex functions');
-        recommendations.push('Add unit tests for each branch');
-    }
-    recommendations.push('Consider adding edge case tests');
-    recommendations.push('Add error handling tests');
-    if (testType === 'integration') {
-        recommendations.push('Add mock external dependencies');
-        recommendations.push('Test API contract boundaries');
-    }
-    return {
-        recommendations,
-        estimatedTime: `${Math.round(complexity.score * 0.5)} minutes`,
-        confidence: 0.85
-    };
-}
-function generateV2LearningFeedback(agentType) {
-    return {
-        enabled: true,
-        agentId: generateAgentId(agentType),
-        message: 'Agent learned from this execution - patterns and Q-values updated'
-    };
-}
-function detectAntiPatterns(sourceCode, language) {
-    const antiPatterns = [];
-    const lines = sourceCode.split('\n');
-    if (sourceCode.includes('eval(')) {
-        antiPatterns.push({
-            type: 'dangerous-eval',
-            line: lines.findIndex(l => l.includes('eval(')) + 1,
-            severity: 'critical',
-            suggestion: 'Replace eval() with safer alternatives'
-        });
-    }
-    if (sourceCode.includes('var ') && (language === 'javascript' || language === 'typescript')) {
-        antiPatterns.push({
-            type: 'var-usage',
-            line: lines.findIndex(l => l.includes('var ')) + 1,
-            severity: 'low',
-            suggestion: 'Use const or let instead of var'
-        });
-    }
-    if (sourceCode.includes('any') && language === 'typescript') {
-        antiPatterns.push({
-            type: 'any-type',
-            line: lines.findIndex(l => l.includes('any')) + 1,
-            severity: 'medium',
-            suggestion: 'Replace any with specific types'
-        });
-    }
-    return antiPatterns;
-}
-// Cached task executor
-let taskExecutor = null;
-function getTaskExecutor() {
-    if (!taskExecutor) {
-        const { kernel } = getFleetState();
-        if (!kernel) {
-            throw new Error('Kernel not initialized');
-        }
-        taskExecutor = createTaskExecutor(kernel);
-    }
-    return taskExecutor;
-}
-// Reset executor when fleet is reinitialized
 export function resetTaskExecutor() {
-    taskExecutor = null;
+    resetExecutor();
 }
 // ============================================================================
-// Test Generation Handler
+// Domain Handlers - Created via Factory Pattern
 // ============================================================================
-export async function handleTestGenerate(params) {
-    if (!isFleetInitialized()) {
-        return {
-            success: false,
-            error: 'Fleet not initialized. Call fleet_init first.',
-        };
-    }
-    const { queen } = getFleetState();
-    try {
-        // ADR-051: Route task to optimal model tier
-        const routingResult = await routeDomainTask(`Generate ${params.testType || 'unit'} tests for ${params.language || 'typescript'} code`, 'test-generation', params.sourceCode);
-        // Submit task for tracking
-        const submitResult = await queen.submitTask({
-            type: 'generate-tests',
-            priority: 'p1',
-            targetDomains: ['test-generation'],
-            payload: {
-                sourceCode: params.sourceCode,
-                filePath: params.filePath,
-                language: params.language || 'typescript',
-                framework: params.framework || 'vitest',
-                testType: params.testType || 'unit',
-                coverageGoal: params.coverageGoal || 80,
-                aiEnhancement: params.aiEnhancement !== false,
-                detectAntiPatterns: params.detectAntiPatterns || false,
-                // ADR-051: Include routing decision
-                routingTier: routingResult?.decision.tier,
-                useAgentBooster: routingResult?.useAgentBooster,
-            },
-            timeout: 120000,
-        });
-        if (!submitResult.success) {
-            return {
-                success: false,
-                error: submitResult.error.message,
-            };
-        }
-        // Execute the task and get real results
-        const executor = getTaskExecutor();
-        const task = queen.getTaskStatus(submitResult.value);
-        if (!task) {
-            return {
-                success: false,
-                error: 'Task not found after submission',
-            };
-        }
-        const result = await executor.execute(task.task);
-        if (!result.success) {
-            return {
-                success: false,
-                error: result.error || 'Task execution failed',
-            };
-        }
-        const data = result.data;
-        // Generate V2-compatible detailed response
-        const sourceCode = params.sourceCode || '';
-        const language = params.language || 'typescript';
-        const testType = params.testType || 'unit';
-        const testsCount = data.testsGenerated || 6;
-        const complexity = analyzeComplexity(sourceCode);
-        const v2Tests = generateV2Tests(sourceCode, testType, language, testsCount);
-        const aiInsights = params.aiEnhancement !== false
-            ? generateV2AIInsights(complexity, testType)
-            : { recommendations: [], estimatedTime: '0 minutes', confidence: 0 };
-        const antiPatterns = params.detectAntiPatterns
-            ? detectAntiPatterns(sourceCode, language)
-            : [];
-        const learning = generateV2LearningFeedback('test-generator');
-        return {
-            success: true,
-            data: {
-                // V2-compatible fields
-                tests: v2Tests,
-                antiPatterns,
-                suggestions: antiPatterns.map(ap => `Fix: ${ap.type} - ${ap.suggestion}`),
-                aiInsights,
-                coverage: {
-                    predicted: data.coverageEstimate || params.coverageGoal || 80,
-                    confidence: 0.9,
-                    achievable: true,
-                },
-                properties: v2Tests.filter(t => t.type === 'property').map(t => ({
-                    name: t.name,
-                    invariant: 'output_matches_expectation'
-                })),
-                language,
-                complexity,
-                learning,
-                // V3 fields
-                taskId: submitResult.value,
-                testsGenerated: v2Tests.length,
-                coverageEstimate: data.coverageEstimate || params.coverageGoal || 80,
-                patternsUsed: data.patternsUsed || ['assertion-patterns', 'mock-generation', 'edge-case-detection'],
-                duration: result.duration,
-                savedFiles: result.savedFiles,
-            },
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Failed to generate tests: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-export async function handleTestExecute(params) {
-    if (!isFleetInitialized()) {
-        return {
-            success: false,
-            error: 'Fleet not initialized. Call fleet_init first.',
-        };
-    }
-    const { queen } = getFleetState();
-    try {
-        // ADR-051: Route task to optimal model tier
-        const routingResult = await routeDomainTask(`Execute ${params.testFiles?.length || 0} test files with ${params.parallel !== false ? 'parallel' : 'sequential'} execution`, 'test-execution');
-        const submitResult = await queen.submitTask({
-            type: 'execute-tests',
-            priority: 'p1',
-            targetDomains: ['test-execution'],
-            payload: {
-                testFiles: params.testFiles || [],
-                testSuites: params.testSuites || [],
-                parallel: params.parallel !== false,
-                parallelism: params.parallelism || 4,
-                retryCount: params.retryCount || 3,
-                timeout: params.timeout || 60000,
-                collectCoverage: params.collectCoverage || false,
-                reportFormat: params.reportFormat || 'json',
-                // ADR-051: Include routing decision
-                routingTier: routingResult?.decision.tier,
-                useAgentBooster: routingResult?.useAgentBooster,
-            },
-            timeout: params.timeout || 300000,
-        });
-        if (!submitResult.success) {
-            return {
-                success: false,
-                error: submitResult.error.message,
-            };
-        }
-        const executor = getTaskExecutor();
-        const task = queen.getTaskStatus(submitResult.value);
-        if (!task) {
-            return {
-                success: false,
-                error: 'Task not found after submission',
-            };
-        }
-        const result = await executor.execute(task.task);
-        if (!result.success) {
-            return {
-                success: false,
-                error: result.error || 'Task execution failed',
-            };
-        }
-        const data = result.data;
-        // Generate V2-compatible worker stats and retry stats using real metrics
-        const parallelism = params.parallelism || 4;
-        const realRetryStats = MetricsCollector.getRetryStats();
-        const workersUsed = MetricsCollector.getWorkersUsed();
-        const workerStats = {
-            workersUsed: workersUsed > 0 ? workersUsed : Math.min(parallelism, data.total || 1),
-            efficiency: MetricsCollector.getWorkerEfficiency(),
-            loadBalance: MetricsCollector.getLoadBalanceScore(),
-            avgExecutionTime: data.duration / Math.max(data.total, 1),
-        };
-        const retryStats = {
-            totalRetries: realRetryStats.totalRetries,
-            successfulRetries: realRetryStats.successfulRetries,
-            maxRetriesReached: realRetryStats.maxRetriesReached,
-        };
-        const learning = generateV2LearningFeedback('test-executor');
-        return {
-            success: true,
-            data: {
-                // V2-compatible fields
-                workerStats,
-                retryStats,
-                results: (() => {
-                    const testDurations = MetricsCollector.getTestDurations(data.total || 0);
-                    return Array.from({ length: data.total || 0 }, (_, i) => ({
-                        id: generateTestId(),
-                        name: `test_case_${i}`,
-                        status: i < (data.passed || 0) ? 'passed' : 'failed',
-                        duration: testDurations[i] || 200,
-                        retries: 0,
-                    }));
-                })(),
-                summary: {
-                    totalTests: data.total,
-                    passRate: data.total > 0 ? (data.passed / data.total) * 100 : 0,
-                    avgDuration: data.duration / Math.max(data.total, 1),
-                    parallelEfficiency: workerStats.efficiency,
-                },
-                learning,
-                // V3 fields
-                taskId: submitResult.value,
-                status: 'completed',
-                total: data.total,
-                passed: data.passed,
-                failed: data.failed,
-                duration: data.duration,
-                coverage: data.coverage,
-            },
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Failed to execute tests: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
+/**
+ * Handle test generation tasks
+ *
+ * @example
+ * ```typescript
+ * const result = await handleTestGenerate({
+ *   sourceCode: 'function add(a, b) { return a + b; }',
+ *   language: 'typescript',
+ *   testType: 'unit',
+ * });
+ * ```
+ */
+export const handleTestGenerate = createDomainHandler(testGenerateConfig);
+/**
+ * Handle test execution tasks
+ *
+ * @example
+ * ```typescript
+ * const result = await handleTestExecute({
+ *   testFiles: ['tests/unit/*.test.ts'],
+ *   parallel: true,
+ *   parallelism: 4,
+ * });
+ * ```
+ */
+export const handleTestExecute = createDomainHandler(testExecuteConfig);
+/**
+ * Handle coverage analysis tasks
+ *
+ * @example
+ * ```typescript
+ * const result = await handleCoverageAnalyze({
+ *   target: 'src/',
+ *   detectGaps: true,
+ *   mlPowered: true,
+ * });
+ * ```
+ */
+export const handleCoverageAnalyze = createDomainHandler(coverageAnalyzeConfig);
+/**
+ * Handle quality assessment tasks
+ *
+ * @example
+ * ```typescript
+ * const result = await handleQualityAssess({
+ *   runGate: true,
+ *   threshold: 80,
+ *   metrics: ['coverage', 'complexity'],
+ * });
+ * ```
+ */
+export const handleQualityAssess = createDomainHandler(qualityAssessConfig);
+/**
+ * Handle security scan tasks
+ *
+ * @example
+ * ```typescript
+ * const result = await handleSecurityScan({
+ *   sast: true,
+ *   dast: false,
+ *   target: 'src/',
+ * });
+ * ```
+ */
+export const handleSecurityScan = createDomainHandler(securityScanConfig);
+/**
+ * Handle contract validation tasks
+ *
+ * @example
+ * ```typescript
+ * const result = await handleContractValidate({
+ *   contractPath: 'contracts/api.yaml',
+ *   checkBreakingChanges: true,
+ * });
+ * ```
+ */
+export const handleContractValidate = createDomainHandler(contractValidateConfig);
+/**
+ * Handle accessibility test tasks
+ *
+ * @example
+ * ```typescript
+ * const result = await handleAccessibilityTest({
+ *   url: 'https://example.com',
+ *   standard: 'wcag21-aa',
+ * });
+ * ```
+ */
+export const handleAccessibilityTest = createDomainHandler(accessibilityTestConfig);
+/**
+ * Handle chaos test tasks
+ *
+ * @example
+ * ```typescript
+ * const result = await handleChaosTest({
+ *   faultType: 'latency',
+ *   target: 'api-service',
+ *   duration: 30000,
+ *   dryRun: true,
+ * });
+ * ```
+ */
+export const handleChaosTest = createDomainHandler(chaosTestConfig);
+/**
+ * Handle defect prediction tasks
+ *
+ * @example
+ * ```typescript
+ * const result = await handleDefectPredict({
+ *   target: 'src/',
+ *   lookback: 30,
+ *   minConfidence: 0.7,
+ * });
+ * ```
+ */
+export const handleDefectPredict = createDomainHandler(defectPredictConfig);
+/**
+ * Handle requirements validation tasks
+ *
+ * @example
+ * ```typescript
+ * const result = await handleRequirementsValidate({
+ *   requirementsPath: 'docs/requirements.md',
+ *   generateBDD: true,
+ * });
+ * ```
+ */
+export const handleRequirementsValidate = createDomainHandler(requirementsValidateConfig);
+/**
+ * Handle code indexing tasks
+ *
+ * @example
+ * ```typescript
+ * const result = await handleCodeIndex({
+ *   target: 'src/',
+ *   incremental: true,
+ * });
+ * ```
+ */
+export const handleCodeIndex = createDomainHandler(codeIndexConfig);
 // ============================================================================
-// Coverage Analysis Handler
+// Handler Registry (for dynamic dispatch)
 // ============================================================================
-export async function handleCoverageAnalyze(params) {
-    if (!isFleetInitialized()) {
-        return {
-            success: false,
-            error: 'Fleet not initialized. Call fleet_init first.',
-        };
-    }
-    const { queen } = getFleetState();
-    try {
-        // ADR-051: Route task to optimal model tier
-        const routingResult = await routeDomainTask(`Analyze coverage for ${params.target || 'project'} with gap detection`, 'coverage-analysis');
-        const submitResult = await queen.submitTask({
-            type: 'analyze-coverage',
-            priority: 'p1',
-            targetDomains: ['coverage-analysis'],
-            payload: {
-                target: params.target || '.',
-                includeRisk: params.includeRisk || false,
-                detectGaps: params.detectGaps !== false,
-                mlPowered: params.mlPowered || false,
-                prioritization: params.prioritization || 'complexity',
-                // ADR-051: Include routing decision
-                routingTier: routingResult?.decision.tier,
-                useAgentBooster: routingResult?.useAgentBooster,
-            },
-            timeout: 180000,
-        });
-        if (!submitResult.success) {
-            return {
-                success: false,
-                error: submitResult.error.message,
-            };
-        }
-        const executor = getTaskExecutor();
-        const task = queen.getTaskStatus(submitResult.value);
-        if (!task) {
-            return {
-                success: false,
-                error: 'Task not found after submission',
-            };
-        }
-        const result = await executor.execute(task.task);
-        if (!result.success) {
-            return {
-                success: false,
-                error: result.error || 'Task execution failed',
-            };
-        }
-        const data = result.data;
-        // Generate V2-compatible detailed coverage response
-        const learning = generateV2LearningFeedback('coverage-analyzer');
-        // Generate detailed gap analysis
-        const detailedGaps = (data.gaps || []).map((gap, i) => ({
-            id: `gap-${Date.now()}-${i}`,
-            file: gap?.file || `src/module${i}.ts`,
-            line: gap?.lines?.[0] || (10 + i * 5),
-            uncoveredLines: gap?.lines || [10 + i * 5, 20 + i * 5],
-            type: (gap?.type || 'uncovered-line'),
-            severity: (gap?.severity || (i < 2 ? 'high' : 'medium')),
-            reason: gap?.reason || 'Missing test case',
-            priority: gap?.priority || (i < 2 ? 'high' : 'medium'),
-            suggestion: gap?.suggestedTest || `Add test for line ${10 + i * 5}`,
-            suggestedTest: gap?.suggestedTest || `Add test for line ${10 + i * 5}`,
-            riskScore: gap?.riskScore || (0.8 - i * 0.1),
-            confidence: gap?.confidence || 0.85,
-        }));
-        return {
-            success: true,
-            data: {
-                // V2-compatible fields
-                // Use deterministic variations based on file index instead of random
-                coverageByFile: Array.from({ length: data.totalFiles || 5 }, (_, i) => {
-                    // Create predictable variation: alternating +/- based on index
-                    const variation = ((i % 3) - 1) * 5; // -5, 0, +5 pattern
-                    return {
-                        file: `src/module${i}.ts`,
-                        lineCoverage: Math.max(0, Math.min(100, data.lineCoverage + variation)),
-                        branchCoverage: Math.max(0, Math.min(100, data.branchCoverage + variation - 2)),
-                        functionCoverage: Math.max(0, Math.min(100, data.functionCoverage + variation + 2)),
-                    };
-                }),
-                gapAnalysis: {
-                    totalGaps: detailedGaps.length,
-                    highPriority: detailedGaps.filter((g) => g.priority === 'high').length,
-                    gaps: detailedGaps,
-                },
-                trends: {
-                    lineCoverageTrend: 'stable',
-                    branchCoverageTrend: 'improving',
-                    weeklyChange: 2.5,
-                },
-                aiInsights: {
-                    recommendations: [
-                        'Focus on uncovered branches in authentication module',
-                        'Add edge case tests for error handling paths',
-                        'Consider property-based testing for utility functions',
-                    ],
-                    riskAssessment: data.lineCoverage < 70 ? 'high' : data.lineCoverage < 85 ? 'medium' : 'low',
-                    confidence: 0.88,
-                },
-                learning,
-                // V3 fields
-                taskId: submitResult.value,
-                lineCoverage: data.lineCoverage,
-                branchCoverage: data.branchCoverage,
-                functionCoverage: data.functionCoverage,
-                statementCoverage: data.statementCoverage || data.lineCoverage,
-                totalFiles: data.totalFiles || 5,
-                gaps: detailedGaps,
-                duration: result.duration,
-                savedFiles: result.savedFiles,
-            },
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Failed to analyze coverage: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-export async function handleQualityAssess(params) {
-    if (!isFleetInitialized()) {
-        return {
-            success: false,
-            error: 'Fleet not initialized. Call fleet_init first.',
-        };
-    }
-    const { queen } = getFleetState();
-    try {
-        // ADR-051: Route task to optimal model tier
-        const routingResult = await routeDomainTask(`Assess quality with ${params.runGate ? 'quality gate' : 'metrics analysis'}`, 'quality-assessment');
-        const submitResult = await queen.submitTask({
-            type: 'assess-quality',
-            priority: 'p0',
-            targetDomains: ['quality-assessment'],
-            payload: {
-                runGate: params.runGate || false,
-                threshold: params.threshold || 80,
-                metrics: params.metrics || ['coverage', 'complexity', 'maintainability'],
-                // ADR-051: Include routing decision
-                routingTier: routingResult?.decision.tier,
-                useAgentBooster: routingResult?.useAgentBooster,
-            },
-            timeout: 180000,
-        });
-        if (!submitResult.success) {
-            return {
-                success: false,
-                error: submitResult.error.message,
-            };
-        }
-        const executor = getTaskExecutor();
-        const task = queen.getTaskStatus(submitResult.value);
-        if (!task) {
-            return {
-                success: false,
-                error: 'Task not found after submission',
-            };
-        }
-        const result = await executor.execute(task.task);
-        if (!result.success) {
-            return {
-                success: false,
-                error: result.error || 'Task execution failed',
-            };
-        }
-        const data = result.data;
-        return {
-            success: true,
-            data: {
-                taskId: submitResult.value,
-                status: 'completed',
-                qualityScore: data.qualityScore,
-                passed: data.passed,
-                metrics: data.metrics,
-                recommendations: data.recommendations,
-                duration: result.duration,
-                savedFiles: result.savedFiles,
-            },
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Failed to assess quality: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-export async function handleSecurityScan(params) {
-    if (!isFleetInitialized()) {
-        return {
-            success: false,
-            error: 'Fleet not initialized. Call fleet_init first.',
-        };
-    }
-    const { queen } = getFleetState();
-    try {
-        const scanTypes = [];
-        if (params.sast !== false)
-            scanTypes.push('SAST');
-        if (params.dast)
-            scanTypes.push('DAST');
-        // ADR-051: Route task to optimal model tier
-        const routingResult = await routeDomainTask(`Security scan (${scanTypes.join(', ')}) for ${params.target || 'project'}`, 'security-compliance');
-        const submitResult = await queen.submitTask({
-            type: 'scan-security',
-            priority: 'p0',
-            targetDomains: ['security-compliance'],
-            payload: {
-                sast: params.sast !== false,
-                dast: params.dast || false,
-                compliance: params.compliance || [],
-                target: params.target || '.',
-                // ADR-051: Include routing decision
-                routingTier: routingResult?.decision.tier,
-                useAgentBooster: routingResult?.useAgentBooster,
-            },
-            timeout: 600000,
-        });
-        if (!submitResult.success) {
-            return {
-                success: false,
-                error: submitResult.error.message,
-            };
-        }
-        const executor = getTaskExecutor();
-        const task = queen.getTaskStatus(submitResult.value);
-        if (!task) {
-            return {
-                success: false,
-                error: 'Task not found after submission',
-            };
-        }
-        const result = await executor.execute(task.task);
-        if (!result.success) {
-            return {
-                success: false,
-                error: result.error || 'Task execution failed',
-            };
-        }
-        const data = result.data;
-        return {
-            success: true,
-            data: {
-                taskId: submitResult.value,
-                status: 'completed',
-                vulnerabilities: data.vulnerabilities,
-                critical: data.critical,
-                high: data.high,
-                medium: data.medium,
-                low: data.low,
-                topVulnerabilities: data.topVulnerabilities,
-                recommendations: data.recommendations,
-                duration: result.duration,
-                savedFiles: result.savedFiles,
-            },
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Failed to scan security: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-export async function handleContractValidate(params) {
-    if (!isFleetInitialized()) {
-        return {
-            success: false,
-            error: 'Fleet not initialized. Call fleet_init first.',
-        };
-    }
-    const { queen } = getFleetState();
-    try {
-        // ADR-051: Route task to optimal model tier
-        const routingResult = await routeDomainTask(`Validate API contract at ${params.contractPath}`, 'contract-testing');
-        const submitResult = await queen.submitTask({
-            type: 'validate-contracts',
-            priority: 'p1',
-            targetDomains: ['contract-testing'],
-            payload: {
-                contractPath: params.contractPath,
-                providerUrl: params.providerUrl,
-                consumerName: params.consumerName,
-                checkBreakingChanges: params.checkBreakingChanges !== false,
-                // ADR-051: Include routing decision
-                routingTier: routingResult?.decision.tier,
-                useAgentBooster: routingResult?.useAgentBooster,
-            },
-            timeout: 180000,
-        });
-        if (!submitResult.success) {
-            return {
-                success: false,
-                error: submitResult.error.message,
-            };
-        }
-        const executor = getTaskExecutor();
-        const task = queen.getTaskStatus(submitResult.value);
-        if (!task) {
-            return {
-                success: false,
-                error: 'Task not found after submission',
-            };
-        }
-        const result = await executor.execute(task.task);
-        if (!result.success) {
-            return {
-                success: false,
-                error: result.error || 'Task execution failed',
-            };
-        }
-        const data = result.data;
-        return {
-            success: true,
-            data: {
-                taskId: submitResult.value,
-                status: 'completed',
-                valid: data.valid,
-                breakingChanges: data.breakingChanges,
-                warnings: data.warnings,
-                duration: result.duration,
-            },
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Failed to validate contract: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-export async function handleAccessibilityTest(params) {
-    if (!isFleetInitialized()) {
-        return {
-            success: false,
-            error: 'Fleet not initialized. Call fleet_init first.',
-        };
-    }
-    const { queen } = getFleetState();
-    try {
-        // ADR-051: Route task to optimal model tier
-        const routingResult = await routeDomainTask(`Test accessibility for ${params.url} against ${params.standard || 'WCAG 2.1 AA'} standard`, 'visual-accessibility');
-        const submitResult = await queen.submitTask({
-            type: 'test-accessibility',
-            priority: 'p1',
-            targetDomains: ['visual-accessibility'],
-            payload: {
-                url: params.url,
-                standard: params.standard || 'wcag21-aa',
-                includeScreenReader: params.includeScreenReader || false,
-                // ADR-051: Include routing decision
-                routingTier: routingResult?.decision.tier,
-                useAgentBooster: routingResult?.useAgentBooster,
-            },
-            timeout: 180000,
-        });
-        if (!submitResult.success) {
-            return {
-                success: false,
-                error: submitResult.error.message,
-            };
-        }
-        const executor = getTaskExecutor();
-        const task = queen.getTaskStatus(submitResult.value);
-        if (!task) {
-            return {
-                success: false,
-                error: 'Task not found after submission',
-            };
-        }
-        const result = await executor.execute(task.task);
-        if (!result.success) {
-            return {
-                success: false,
-                error: result.error || 'Task execution failed',
-            };
-        }
-        const data = result.data;
-        return {
-            success: true,
-            data: {
-                taskId: submitResult.value,
-                status: 'completed',
-                passed: data.passed,
-                score: data.score,
-                violations: data.violations,
-                warnings: data.warnings,
-                duration: result.duration,
-            },
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Failed to test accessibility: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-export async function handleChaosTest(params) {
-    if (!isFleetInitialized()) {
-        return {
-            success: false,
-            error: 'Fleet not initialized. Call fleet_init first.',
-        };
-    }
-    const { queen } = getFleetState();
-    try {
-        // ADR-051: Route task to optimal model tier
-        const routingResult = await routeDomainTask(`Run chaos test with ${params.faultType || 'latency'} fault injection on ${params.target}`, 'chaos-resilience');
-        const submitResult = await queen.submitTask({
-            type: 'run-chaos',
-            priority: 'p2',
-            targetDomains: ['chaos-resilience'],
-            payload: {
-                faultType: params.faultType || 'latency',
-                target: params.target,
-                duration: params.duration || 30000,
-                intensity: params.intensity || 50,
-                dryRun: params.dryRun !== false,
-                // ADR-051: Include routing decision
-                routingTier: routingResult?.decision.tier,
-                useAgentBooster: routingResult?.useAgentBooster,
-            },
-            timeout: (params.duration || 30000) + 60000,
-        });
-        if (!submitResult.success) {
-            return {
-                success: false,
-                error: submitResult.error.message,
-            };
-        }
-        const executor = getTaskExecutor();
-        const task = queen.getTaskStatus(submitResult.value);
-        if (!task) {
-            return {
-                success: false,
-                error: 'Task not found after submission',
-            };
-        }
-        const result = await executor.execute(task.task);
-        if (!result.success) {
-            return {
-                success: false,
-                error: result.error || 'Task execution failed',
-            };
-        }
-        const data = result.data;
-        return {
-            success: true,
-            data: {
-                taskId: submitResult.value,
-                status: 'completed',
-                faultType: data.faultType,
-                resilience: data.resilience,
-                duration: result.duration,
-            },
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Failed to run chaos test: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-export async function handleDefectPredict(params) {
-    if (!isFleetInitialized()) {
-        return {
-            success: false,
-            error: 'Fleet not initialized. Call fleet_init first.',
-        };
-    }
-    const { queen } = getFleetState();
-    try {
-        // ADR-051: Route task to optimal model tier
-        const routingResult = await routeDomainTask(`Predict defects in ${params.target || 'codebase'} with ${params.lookback || 30} day lookback`, 'defect-intelligence');
-        const submitResult = await queen.submitTask({
-            type: 'predict-defects',
-            priority: 'p1',
-            targetDomains: ['defect-intelligence'],
-            payload: {
-                target: params.target || '.',
-                lookback: params.lookback || 30,
-                minConfidence: params.minConfidence || 0.7,
-                // ADR-051: Include routing decision
-                routingTier: routingResult?.decision.tier,
-                useAgentBooster: routingResult?.useAgentBooster,
-            },
-            timeout: 180000,
-        });
-        if (!submitResult.success) {
-            return {
-                success: false,
-                error: submitResult.error.message,
-            };
-        }
-        const executor = getTaskExecutor();
-        const task = queen.getTaskStatus(submitResult.value);
-        if (!task) {
-            return {
-                success: false,
-                error: 'Task not found after submission',
-            };
-        }
-        const result = await executor.execute(task.task);
-        if (!result.success) {
-            return {
-                success: false,
-                error: result.error || 'Task execution failed',
-            };
-        }
-        const data = result.data;
-        return {
-            success: true,
-            data: {
-                taskId: submitResult.value,
-                status: 'completed',
-                predictedDefects: data.predictedDefects,
-                riskScore: data.riskScore,
-                recommendations: data.recommendations,
-                duration: result.duration,
-            },
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Failed to predict defects: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-export async function handleRequirementsValidate(params) {
-    if (!isFleetInitialized()) {
-        return {
-            success: false,
-            error: 'Fleet not initialized. Call fleet_init first.',
-        };
-    }
-    const { queen } = getFleetState();
-    try {
-        // ADR-051: Route task to optimal model tier
-        const routingResult = await routeDomainTask(`Validate requirements${params.generateBDD ? ' and generate BDD scenarios' : ''}`, 'requirements-validation');
-        const submitResult = await queen.submitTask({
-            type: 'validate-requirements',
-            priority: 'p1',
-            targetDomains: ['requirements-validation'],
-            payload: {
-                requirementsPath: params.requirementsPath,
-                testPath: params.testPath,
-                generateBDD: params.generateBDD || false,
-                // ADR-051: Include routing decision
-                routingTier: routingResult?.decision.tier,
-                useAgentBooster: routingResult?.useAgentBooster,
-            },
-            timeout: 180000,
-        });
-        if (!submitResult.success) {
-            return {
-                success: false,
-                error: submitResult.error.message,
-            };
-        }
-        const executor = getTaskExecutor();
-        const task = queen.getTaskStatus(submitResult.value);
-        if (!task) {
-            return {
-                success: false,
-                error: 'Task not found after submission',
-            };
-        }
-        const result = await executor.execute(task.task);
-        if (!result.success) {
-            return {
-                success: false,
-                error: result.error || 'Task execution failed',
-            };
-        }
-        const data = result.data;
-        return {
-            success: true,
-            data: {
-                taskId: submitResult.value,
-                status: 'completed',
-                requirementsAnalyzed: data.requirementsAnalyzed,
-                testable: data.testable,
-                coverage: data.coverage,
-                bddScenarios: data.bddScenarios,
-                duration: result.duration,
-            },
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Failed to validate requirements: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
+/**
+ * Registry of all domain handlers for dynamic dispatch
+ */
+export const domainHandlers = {
+    'test-generation': handleTestGenerate,
+    'test-execution': handleTestExecute,
+    'coverage-analysis': handleCoverageAnalyze,
+    'quality-assessment': handleQualityAssess,
+    'security-compliance': handleSecurityScan,
+    'contract-testing': handleContractValidate,
+    'visual-accessibility': handleAccessibilityTest,
+    'chaos-resilience': handleChaosTest,
+    'defect-intelligence': handleDefectPredict,
+    'requirements-validation': handleRequirementsValidate,
+    'code-intelligence': handleCodeIndex,
+};
+/**
+ * Get a handler by domain name
+ */
+export function getHandlerByDomain(domain) {
+    return domainHandlers[domain];
 }
-export async function handleCodeIndex(params) {
-    if (!isFleetInitialized()) {
-        return {
-            success: false,
-            error: 'Fleet not initialized. Call fleet_init first.',
-        };
-    }
-    const { queen } = getFleetState();
-    try {
-        // ADR-051: Route task to optimal model tier
-        const routingResult = await routeDomainTask(`Index code in ${params.target || 'codebase'}${params.incremental ? ' incrementally' : ''}`, 'code-intelligence');
-        const submitResult = await queen.submitTask({
-            type: 'index-code',
-            priority: 'p2',
-            targetDomains: ['code-intelligence'],
-            payload: {
-                target: params.target || '.',
-                incremental: params.incremental || false,
-                gitSince: params.gitSince,
-                // ADR-051: Include routing decision
-                routingTier: routingResult?.decision.tier,
-                useAgentBooster: routingResult?.useAgentBooster,
-            },
-            timeout: 300000,
-        });
-        if (!submitResult.success) {
-            return {
-                success: false,
-                error: submitResult.error.message,
-            };
-        }
-        const executor = getTaskExecutor();
-        const task = queen.getTaskStatus(submitResult.value);
-        if (!task) {
-            return {
-                success: false,
-                error: 'Task not found after submission',
-            };
-        }
-        const result = await executor.execute(task.task);
-        if (!result.success) {
-            return {
-                success: false,
-                error: result.error || 'Task execution failed',
-            };
-        }
-        const data = result.data;
-        return {
-            success: true,
-            data: {
-                taskId: submitResult.value,
-                status: 'completed',
-                filesIndexed: data.filesIndexed,
-                symbolsExtracted: data.symbolsExtracted,
-                relationsFound: data.relationsFound,
-                duration: result.duration,
-            },
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Failed to index code: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
+/**
+ * Check if a domain has a registered handler
+ */
+export function hasHandler(domain) {
+    return domain in domainHandlers;
 }
 //# sourceMappingURL=domain-handlers.js.map