agentic-qe 1.0.0 → 1.0.1

package/dist/mcp/tools.js

@@ -452,6 +452,1211 @@ exports.agenticQETools = [
             },
             required: ['optimization']
         }
+    },
+    // Enhanced Test Tools
+    {
+        name: 'mcp__agentic_qe__test_generate_enhanced',
+        description: 'Enhanced AI-powered test generation with pattern recognition and anti-pattern detection',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sourceCode: {
+                    type: 'string',
+                    description: 'Source code to analyze and generate tests for'
+                },
+                language: {
+                    type: 'string',
+                    enum: ['javascript', 'typescript', 'python', 'java', 'go'],
+                    description: 'Programming language'
+                },
+                testType: {
+                    type: 'string',
+                    enum: ['unit', 'integration', 'e2e', 'property-based', 'mutation'],
+                    description: 'Type of tests to generate'
+                },
+                aiEnhancement: {
+                    type: 'boolean',
+                    default: true,
+                    description: 'Enable AI-powered analysis and generation'
+                },
+                coverageGoal: {
+                    type: 'number',
+                    minimum: 0,
+                    maximum: 100,
+                    description: 'Target coverage percentage'
+                },
+                detectAntiPatterns: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Detect and report code anti-patterns'
+                }
+            },
+            required: ['sourceCode', 'language', 'testType']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__test_execute_parallel',
+        description: 'Execute tests in parallel with worker pools, retry logic, and load balancing',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                testFiles: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'List of test files to execute'
+                },
+                parallelism: {
+                    type: 'number',
+                    minimum: 1,
+                    maximum: 16,
+                    default: 4,
+                    description: 'Number of parallel workers'
+                },
+                timeout: {
+                    type: 'number',
+                    default: 5000,
+                    description: 'Test execution timeout in milliseconds'
+                },
+                retryFailures: {
+                    type: 'boolean',
+                    default: true,
+                    description: 'Retry failed tests'
+                },
+                maxRetries: {
+                    type: 'number',
+                    default: 3,
+                    minimum: 0,
+                    maximum: 5,
+                    description: 'Maximum retry attempts'
+                },
+                retryDelay: {
+                    type: 'number',
+                    default: 1000,
+                    description: 'Delay between retries in milliseconds'
+                },
+                continueOnFailure: {
+                    type: 'boolean',
+                    default: true,
+                    description: 'Continue execution if a test fails'
+                },
+                loadBalancing: {
+                    type: 'string',
+                    enum: ['round-robin', 'least-loaded', 'random'],
+                    default: 'round-robin',
+                    description: 'Load balancing strategy'
+                },
+                collectCoverage: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Collect coverage data during execution'
+                }
+            },
+            required: ['testFiles']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__test_optimize_sublinear',
+        description: 'Optimize test suites using sublinear algorithms (JL, temporal advantage, redundancy detection)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                testSuite: {
+                    type: 'object',
+                    properties: {
+                        tests: {
+                            type: 'array',
+                            description: 'Array of tests to optimize'
+                        }
+                    },
+                    required: ['tests']
+                },
+                algorithm: {
+                    type: 'string',
+                    enum: ['johnson-lindenstrauss', 'temporal-advantage', 'redundancy-detection', 'sublinear'],
+                    description: 'Optimization algorithm'
+                },
+                targetReduction: {
+                    type: 'number',
+                    minimum: 0.1,
+                    maximum: 0.9,
+                    description: 'Target reduction ratio (0.3 = reduce to 30%)'
+                },
+                maintainCoverage: {
+                    type: 'number',
+                    minimum: 0,
+                    maximum: 1,
+                    description: 'Minimum coverage to maintain (0-1)'
+                },
+                predictFailures: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Enable failure prediction'
+                },
+                metrics: {
+                    type: 'boolean',
+                    default: true,
+                    description: 'Calculate complexity metrics'
+                },
+                preserveCritical: {
+                    type: 'boolean',
+                    default: true,
+                    description: 'Preserve critical priority tests'
+                }
+            },
+            required: ['testSuite', 'algorithm']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__test_report_comprehensive',
+        description: 'Generate comprehensive test reports in multiple formats (HTML, JSON, JUnit, Markdown, PDF)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                results: {
+                    type: 'object',
+                    properties: {
+                        total: { type: 'number' },
+                        passed: { type: 'number' },
+                        failed: { type: 'number' },
+                        skipped: { type: 'number' },
+                        duration: { type: 'number' },
+                        suites: { type: 'array' }
+                    },
+                    required: ['total', 'passed', 'failed']
+                },
+                format: {
+                    type: 'string',
+                    enum: ['html', 'json', 'junit', 'markdown', 'pdf'],
+                    description: 'Report output format'
+                },
+                includeCharts: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Include visual charts'
+                },
+                includeTrends: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Include trend analysis'
+                },
+                includeSummary: {
+                    type: 'boolean',
+                    default: true,
+                    description: 'Include summary section'
+                },
+                includeDetails: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Include detailed test information'
+                },
+                structured: {
+                    type: 'boolean',
+                    default: true,
+                    description: 'Use structured output (for JSON)'
+                },
+                historicalData: {
+                    type: 'array',
+                    description: 'Historical test data for trends'
+                }
+            },
+            required: ['results', 'format']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__test_coverage_detailed',
+        description: 'Detailed coverage analysis with gap detection, prioritization, and improvement suggestions',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                coverageData: {
+                    type: 'object',
+                    properties: {
+                        files: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    path: { type: 'string' },
+                                    lines: { type: 'object' },
+                                    branches: { type: 'object' },
+                                    functions: { type: 'object' },
+                                    importance: {
+                                        type: 'string',
+                                        enum: ['low', 'medium', 'high', 'critical']
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    required: ['files']
+                },
+                analysisType: {
+                    type: 'string',
+                    enum: ['line', 'branch', 'function', 'comprehensive'],
+                    description: 'Type of coverage analysis'
+                },
+                detailLevel: {
+                    type: 'string',
+                    enum: ['basic', 'detailed', 'comprehensive'],
+                    default: 'detailed',
+                    description: 'Level of detail in analysis'
+                },
+                identifyGaps: {
+                    type: 'boolean',
+                    default: true,
+                    description: 'Identify coverage gaps'
+                },
+                prioritizeGaps: {
+                    type: 'boolean',
+                    default: true,
+                    description: 'Prioritize gaps by importance'
+                },
+                generateSuggestions: {
+                    type: 'boolean',
+                    default: true,
+                    description: 'Generate improvement suggestions'
+                },
+                comparePrevious: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Compare with previous coverage'
+                },
+                historicalData: {
+                    type: 'array',
+                    description: 'Historical coverage data'
+                }
+            },
+            required: ['coverageData', 'analysisType']
+        }
+    },
+    // Memory Management Tools
+    {
+        name: 'mcp__agentic_qe__memory_store',
+        description: 'Store QE data with TTL support and namespacing for agent coordination',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                key: {
+                    type: 'string',
+                    description: 'Memory key'
+                },
+                value: {
+                    description: 'Value to store (any type)'
+                },
+                namespace: {
+                    type: 'string',
+                    default: 'default',
+                    description: 'Memory namespace for isolation'
+                },
+                ttl: {
+                    type: 'number',
+                    description: 'Time to live in seconds (0 for persistent)'
+                },
+                metadata: {
+                    type: 'object',
+                    description: 'Additional metadata'
+                },
+                persist: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Persist to database'
+                }
+            },
+            required: ['key', 'value']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__memory_retrieve',
+        description: 'Retrieve QE data from memory with optional metadata',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                key: {
+                    type: 'string',
+                    description: 'Memory key'
+                },
+                namespace: {
+                    type: 'string',
+                    default: 'default',
+                    description: 'Memory namespace'
+                },
+                includeMetadata: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Include metadata in response'
+                },
+                agentId: {
+                    type: 'string',
+                    description: 'Agent ID for access tracking'
+                }
+            },
+            required: ['key']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__memory_query',
+        description: 'Query memory system with pattern matching and filtering',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                namespace: {
+                    type: 'string',
+                    description: 'Filter by namespace'
+                },
+                pattern: {
+                    type: 'string',
+                    description: 'Key pattern (supports wildcards)'
+                },
+                startTime: {
+                    type: 'number',
+                    description: 'Filter by start timestamp'
+                },
+                endTime: {
+                    type: 'number',
+                    description: 'Filter by end timestamp'
+                },
+                limit: {
+                    type: 'number',
+                    default: 100,
+                    minimum: 1,
+                    maximum: 1000,
+                    description: 'Maximum results'
+                },
+                offset: {
+                    type: 'number',
+                    default: 0,
+                    minimum: 0,
+                    description: 'Pagination offset'
+                },
+                includeExpired: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Include expired entries'
+                }
+            }
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__memory_share',
+        description: 'Share memory between agents with access control',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sourceKey: {
+                    type: 'string',
+                    description: 'Source memory key'
+                },
+                sourceNamespace: {
+                    type: 'string',
+                    description: 'Source namespace'
+                },
+                targetAgents: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Target agent IDs'
+                },
+                targetNamespace: {
+                    type: 'string',
+                    default: 'shared',
+                    description: 'Target namespace'
+                },
+                permissions: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    default: ['read'],
+                    description: 'Access permissions'
+                },
+                ttl: {
+                    type: 'number',
+                    description: 'Time to live for shared memory'
+                }
+            },
+            required: ['sourceKey', 'sourceNamespace', 'targetAgents']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__memory_backup',
+        description: 'Backup and restore memory namespaces',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    enum: ['create', 'restore', 'list', 'delete'],
+                    description: 'Backup operation'
+                },
+                namespace: {
+                    type: 'string',
+                    description: 'Namespace to backup/restore'
+                },
+                backupId: {
+                    type: 'string',
+                    description: 'Backup identifier'
+                },
+                targetNamespace: {
+                    type: 'string',
+                    description: 'Target namespace for restore'
+                }
+            },
+            required: ['action']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__blackboard_post',
+        description: 'Post coordination hints to blackboard pattern',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                topic: {
+                    type: 'string',
+                    description: 'Coordination topic'
+                },
+                message: {
+                    type: 'string',
+                    description: 'Hint message'
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['low', 'medium', 'high', 'critical'],
+                    description: 'Hint priority'
+                },
+                agentId: {
+                    type: 'string',
+                    description: 'Source agent ID'
+                },
+                metadata: {
+                    type: 'object',
+                    description: 'Additional metadata'
+                },
+                ttl: {
+                    type: 'number',
+                    default: 0,
+                    description: 'Time to live in seconds'
+                }
+            },
+            required: ['topic', 'message', 'priority', 'agentId']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__blackboard_read',
+        description: 'Read coordination hints from blackboard',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                topic: {
+                    type: 'string',
+                    description: 'Coordination topic'
+                },
+                agentId: {
+                    type: 'string',
+                    description: 'Reading agent ID'
+                },
+                minPriority: {
+                    type: 'string',
+                    enum: ['low', 'medium', 'high', 'critical'],
+                    description: 'Minimum priority filter'
+                },
+                since: {
+                    type: 'number',
+                    description: 'Filter hints after timestamp'
+                },
+                limit: {
+                    type: 'number',
+                    default: 50,
+                    minimum: 1,
+                    maximum: 100,
+                    description: 'Maximum hints to return'
+                }
+            },
+            required: ['topic', 'agentId']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__consensus_propose',
+        description: 'Create consensus proposal for multi-agent decision making',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                proposalId: {
+                    type: 'string',
+                    description: 'Unique proposal identifier'
+                },
+                topic: {
+                    type: 'string',
+                    description: 'Proposal topic'
+                },
+                proposal: {
+                    description: 'Proposal content (any type)'
+                },
+                votingAgents: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Agents authorized to vote'
+                },
+                quorum: {
+                    type: 'number',
+                    minimum: 0,
+                    maximum: 1,
+                    description: 'Quorum threshold (0-1)'
+                },
+                timeout: {
+                    type: 'number',
+                    default: 300,
+                    description: 'Voting timeout in seconds'
+                },
+                metadata: {
+                    type: 'object',
+                    description: 'Additional metadata'
+                }
+            },
+            required: ['proposalId', 'topic', 'proposal', 'votingAgents', 'quorum']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__consensus_vote',
+        description: 'Vote on consensus proposal with quorum checking',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                proposalId: {
+                    type: 'string',
+                    description: 'Proposal identifier'
+                },
+                agentId: {
+                    type: 'string',
+                    description: 'Voting agent ID'
+                },
+                vote: {
+                    type: 'string',
+                    enum: ['approve', 'reject', 'abstain'],
+                    description: 'Vote decision'
+                },
+                rationale: {
+                    type: 'string',
+                    description: 'Vote rationale'
+                },
+                checkConsensus: {
+                    type: 'boolean',
+                    default: true,
+                    description: 'Check if consensus reached'
+                }
+            },
+            required: ['proposalId', 'agentId', 'vote']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__artifact_manifest',
+        description: 'Manage artifact manifests for QE outputs',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    enum: ['create', 'get', 'list', 'update', 'delete'],
+                    description: 'Manifest operation'
+                },
+                manifestId: {
+                    type: 'string',
+                    description: 'Manifest identifier'
+                },
+                artifacts: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            type: { type: 'string' },
+                            path: { type: 'string' },
+                            metadata: { type: 'object' }
+                        },
+                        required: ['type', 'path']
+                    },
+                    description: 'Artifact list'
+                },
+                updates: {
+                    type: 'object',
+                    description: 'Manifest updates'
+                },
+                filterBy: {
+                    type: 'object',
+                    description: 'Filter criteria for list'
+                }
+            },
+            required: ['action']
+        }
+    },
+    // Coordination Tools (Phase 1)
+    {
+        name: 'mcp__agentic_qe__workflow_create',
+        description: 'Create QE workflow with checkpoints and dependency management',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Workflow name'
+                },
+                description: {
+                    type: 'string',
+                    description: 'Workflow description'
+                },
+                steps: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            id: { type: 'string' },
+                            name: { type: 'string' },
+                            type: { type: 'string' },
+                            dependencies: { type: 'array', items: { type: 'string' } },
+                            timeout: { type: 'number' },
+                            config: { type: 'object' }
+                        },
+                        required: ['id', 'name', 'type', 'dependencies']
+                    },
+                    description: 'Workflow steps with dependencies'
+                },
+                checkpoints: {
+                    type: 'object',
+                    properties: {
+                        enabled: { type: 'boolean' },
+                        frequency: {
+                            type: 'string',
+                            enum: ['manual', 'after-each-step', 'on-failure', 'timed']
+                        },
+                        interval: { type: 'number' }
+                    }
+                }
+            },
+            required: ['name', 'steps']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__workflow_execute',
+        description: 'Execute workflow with OODA loop integration',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workflowId: {
+                    type: 'string',
+                    description: 'Workflow ID to execute'
+                },
+                context: {
+                    type: 'object',
+                    properties: {
+                        environment: { type: 'string' },
+                        dryRun: { type: 'boolean' },
+                        variables: { type: 'object' }
+                    }
+                },
+                oodaEnabled: {
+                    type: 'boolean',
+                    default: true,
+                    description: 'Enable OODA loop coordination'
+                },
+                autoCheckpoint: {
+                    type: 'boolean',
+                    default: true,
+                    description: 'Automatically create checkpoints'
+                }
+            },
+            required: ['workflowId']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__workflow_checkpoint',
+        description: 'Save workflow state to checkpoint',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                executionId: {
+                    type: 'string',
+                    description: 'Execution ID to checkpoint'
+                },
+                reason: {
+                    type: 'string',
+                    description: 'Reason for checkpoint'
+                },
+                metadata: {
+                    type: 'object',
+                    description: 'Additional metadata'
+                }
+            },
+            required: ['executionId']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__workflow_resume',
+        description: 'Resume workflow from checkpoint',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                checkpointId: {
+                    type: 'string',
+                    description: 'Checkpoint ID to resume from'
+                },
+                context: {
+                    type: 'object',
+                    properties: {
+                        skipFailedSteps: { type: 'boolean' },
+                        overrideVariables: { type: 'object' }
+                    }
+                }
+            },
+            required: ['checkpointId']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__task_status',
+        description: 'Check task status and progress',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                taskId: {
+                    type: 'string',
+                    description: 'Task or orchestration ID'
+                },
+                includeDetails: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Include detailed information'
+                },
+                includeTimeline: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Include timeline events'
+                }
+            },
+            required: ['taskId']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__event_emit',
+        description: 'Emit coordination event to event bus',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                event: {
+                    type: 'string',
+                    description: 'Event name (e.g., test:started, agent:ready)'
+                },
+                data: {
+                    type: 'object',
+                    description: 'Event data payload'
+                },
+                metadata: {
+                    type: 'object',
+                    properties: {
+                        source: { type: 'string' },
+                        priority: {
+                            type: 'string',
+                            enum: ['low', 'medium', 'high', 'critical']
+                        }
+                    }
+                }
+            },
+            required: ['event', 'data']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__event_subscribe',
+        description: 'Subscribe to coordination event stream',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                events: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Event patterns to subscribe to (supports wildcards like agent:*)'
+                },
+                filter: {
+                    type: 'object',
+                    description: 'Filter criteria for events'
+                },
+                action: {
+                    type: 'string',
+                    enum: ['subscribe', 'unsubscribe'],
+                    description: 'Action to perform'
+                },
+                subscriptionId: {
+                    type: 'string',
+                    description: 'Subscription ID (for unsubscribe)'
+                }
+            }
+        }
+    },
+    // Quality Gate Tools
+    {
+        name: 'mcp__agentic_qe__quality_gate_execute',
+        description: 'Execute quality gate with policy enforcement',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectId: { type: 'string' },
+                buildId: { type: 'string' },
+                environment: {
+                    type: 'string',
+                    enum: ['development', 'staging', 'production']
+                },
+                policy: { type: 'object' },
+                metrics: {
+                    type: 'object',
+                    properties: {
+                        coverage: { type: 'object' },
+                        testResults: { type: 'object' },
+                        security: { type: 'object' },
+                        performance: { type: 'object' },
+                        codeQuality: { type: 'object' }
+                    },
+                    required: ['coverage', 'testResults', 'security']
+                },
+                context: { type: 'object' }
+            },
+            required: ['projectId', 'buildId', 'environment', 'metrics']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__quality_validate_metrics',
+        description: 'Validate quality metrics against thresholds',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                metrics: { type: 'object', description: 'Quality metrics to validate' },
+                thresholds: { type: 'object', description: 'Validation thresholds' },
+                strict: { type: 'boolean', default: false }
+            },
+            required: ['metrics', 'thresholds']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__quality_risk_assess',
+        description: 'Assess risk level for quality metrics',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                metrics: { type: 'object' },
+                context: { type: 'object' },
+                historicalData: { type: 'array', items: { type: 'object' } }
+            },
+            required: ['metrics']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__quality_decision_make',
+        description: 'Make go/no-go decision based on quality analysis',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                analysisId: { type: 'string' },
+                data: { type: 'object' },
+                policy: { type: 'object' }
+            },
+            required: ['analysisId', 'data']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__quality_policy_check',
+        description: 'Check compliance with quality policies',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                policyId: { type: 'string' },
+                projectId: { type: 'string' },
+                metrics: { type: 'object' }
+            },
+            required: ['policyId', 'projectId', 'metrics']
+        }
+    },
+    // Prediction & Analysis Tools
+    {
+        name: 'mcp__agentic_qe__flaky_test_detect',
+        description: 'Detect flaky tests using pattern recognition',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                testData: {
+                    type: 'object',
+                    properties: {
+                        testResults: { type: 'array', items: { type: 'object' } },
+                        minRuns: { type: 'number', default: 5 },
+                        timeWindow: { type: 'number', default: 30 }
+                    },
+                    required: ['testResults']
+                },
+                analysisConfig: { type: 'object' },
+                reportConfig: { type: 'object' }
+            },
+            required: ['testData']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__predict_defects_ai',
+        description: 'Predict defects using AI/ML models',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                codeChanges: { type: 'object' },
+                modelConfig: { type: 'object' },
+                historicalData: { type: 'array' }
+            },
+            required: ['codeChanges']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__regression_risk_analyze',
+        description: 'Analyze regression risk for code changes',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                changes: { type: 'array', items: { type: 'object' } },
+                baselineMetrics: { type: 'object' },
+                threshold: { type: 'number', default: 0.1 }
+            },
+            required: ['changes']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__visual_test_regression',
+        description: 'Detect visual regression in UI tests',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                baselineImages: { type: 'array', items: { type: 'string' } },
+                currentImages: { type: 'array', items: { type: 'string' } },
+                threshold: { type: 'number', default: 0.05 }
+            },
+            required: ['baselineImages', 'currentImages']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__deployment_readiness_check',
+        description: 'Check deployment readiness with comprehensive analysis',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectId: { type: 'string' },
+                environment: { type: 'string' },
+                checks: { type: 'array', items: { type: 'string' } }
+            },
+            required: ['projectId', 'environment']
+        }
+    },
+    // Analysis Tools
+    {
+        name: 'mcp__agentic_qe__coverage_analyze_sublinear',
+        description: 'Analyze coverage with O(log n) sublinear algorithms',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sourceFiles: { type: 'array', items: { type: 'string' } },
+                coverageThreshold: { type: 'number', default: 0.8 },
+                useJohnsonLindenstrauss: { type: 'boolean', default: true },
+                targetDimension: { type: 'number' },
+                includeUncoveredLines: { type: 'boolean', default: true }
+            },
+            required: ['sourceFiles']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__coverage_gaps_detect',
+        description: 'Detect coverage gaps and prioritize them',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                coverageData: { type: 'object' },
+                prioritization: {
+                    type: 'string',
+                    enum: ['complexity', 'criticality', 'change-frequency'],
+                    default: 'complexity'
+                }
+            },
+            required: ['coverageData']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__performance_benchmark_run',
+        description: 'Run performance benchmarks',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                benchmarkSuite: { type: 'string' },
+                iterations: { type: 'number', default: 100 },
+                warmupIterations: { type: 'number', default: 10 }
+            },
+            required: ['benchmarkSuite']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__performance_monitor_realtime',
+        description: 'Monitor performance metrics in real-time',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                target: { type: 'string' },
+                duration: { type: 'number', default: 60 },
+                interval: { type: 'number', default: 5 }
+            },
+            required: ['target']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__security_scan_comprehensive',
+        description: 'Comprehensive security scanning',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                scanType: {
+                    type: 'string',
+                    enum: ['sast', 'dast', 'dependency', 'comprehensive'],
+                    default: 'comprehensive'
+                },
+                target: { type: 'string' },
+                depth: { type: 'string', enum: ['basic', 'standard', 'deep'], default: 'standard' }
+            },
+            required: ['target']
+        }
+    },
+    // Advanced MCP Tools - Requirements & Production Intelligence
+    {
+        name: 'mcp__agentic_qe__requirements_validate',
+        description: 'Validate requirements testability with NLP analysis',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                requirements: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Requirements to validate'
+                },
+                strictMode: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Enable strict validation mode'
+                },
+                generateTestSuggestions: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Generate test suggestions'
+                }
+            },
+            required: ['requirements']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__requirements_generate_bdd',
+        description: 'Generate BDD scenarios from requirements',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                requirement: { type: 'string', description: 'Requirement text' },
+                format: {
+                    type: 'string',
+                    enum: ['gherkin', 'cucumber', 'plain'],
+                    default: 'gherkin'
+                },
+                includeEdgeCases: { type: 'boolean', default: false },
+                generateTestCode: { type: 'boolean', default: false },
+                framework: {
+                    type: 'string',
+                    enum: ['jest', 'mocha', 'jasmine', 'cucumber-js'],
+                    default: 'jest'
+                },
+                extractTestData: { type: 'boolean', default: false }
+            },
+            required: ['requirement']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__production_incident_replay',
+        description: 'Replay production incidents as tests',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                incident: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string' },
+                        timestamp: { type: 'string' },
+                        type: { type: 'string', enum: ['error', 'performance', 'security', 'availability'] },
+                        message: { type: 'string' },
+                        stackTrace: { type: 'string' },
+                        context: { type: 'object' },
+                        metrics: { type: 'object' },
+                        sourceCode: { type: 'string' }
+                    },
+                    required: ['id', 'timestamp', 'type', 'message']
+                },
+                analyzeRootCause: { type: 'boolean', default: false },
+                generateRegressionTests: { type: 'boolean', default: false },
+                linkSimilarIncidents: { type: 'boolean', default: false }
+            },
+            required: ['incident']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__production_rum_analyze',
+        description: 'Analyze Real User Monitoring data',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                rumData: {
+                    type: 'object',
+                    properties: {
+                        sessionId: { type: 'string' },
+                        userActions: { type: 'array' },
+                        metrics: { type: 'object' }
+                    },
+                    required: ['sessionId', 'userActions']
+                },
+                detectBottlenecks: { type: 'boolean', default: false },
+                generateTests: { type: 'boolean', default: false },
+                analyzeBehavior: { type: 'boolean', default: false }
+            },
+            required: ['rumData']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__api_breaking_changes',
+        description: 'Detect API breaking changes with AST analysis',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                oldAPI: { type: 'string', description: 'Old API source code' },
+                newAPI: { type: 'string', description: 'New API source code' },
+                language: {
+                    type: 'string',
+                    enum: ['typescript', 'javascript', 'python', 'java'],
+                    default: 'typescript'
+                },
+                calculateSemver: { type: 'boolean', default: false },
+                generateMigrationGuide: { type: 'boolean', default: false }
+            },
+            required: ['oldAPI', 'newAPI']
+        }
+    },
+    {
+        name: 'mcp__agentic_qe__mutation_test_execute',
+        description: 'Execute mutation testing with real mutations',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sourceCode: { type: 'string', description: 'Source code to mutate' },
+                testCode: { type: 'string', description: 'Test code' },
+                language: {
+                    type: 'string',
+                    enum: ['javascript', 'typescript', 'python'],
+                    default: 'javascript'
+                },
+                operators: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    default: ['arithmetic', 'logical', 'relational']
+                },
+                timeout: { type: 'number', default: 5000 },
+                calculateCoverage: { type: 'boolean', default: false },
+                generateSuggestions: { type: 'boolean', default: false }
+            },
+            required: ['sourceCode', 'testCode']
+        }
     }
 ];
 /**
@@ -466,6 +1671,56 @@ exports.TOOL_NAMES = {
     PREDICT_DEFECTS: 'mcp__agentic_qe__predict_defects',
     FLEET_STATUS: 'mcp__agentic_qe__fleet_status',
     TASK_ORCHESTRATE: 'mcp__agentic_qe__task_orchestrate',
-    OPTIMIZE_TESTS: 'mcp__agentic_qe__optimize_tests'
+    OPTIMIZE_TESTS: 'mcp__agentic_qe__optimize_tests',
+    // Enhanced test tools
+    TEST_GENERATE_ENHANCED: 'mcp__agentic_qe__test_generate_enhanced',
+    TEST_EXECUTE_PARALLEL: 'mcp__agentic_qe__test_execute_parallel',
+    TEST_OPTIMIZE_SUBLINEAR: 'mcp__agentic_qe__test_optimize_sublinear',
+    TEST_REPORT_COMPREHENSIVE: 'mcp__agentic_qe__test_report_comprehensive',
+    TEST_COVERAGE_DETAILED: 'mcp__agentic_qe__test_coverage_detailed',
+    // Memory tools
+    MEMORY_STORE: 'mcp__agentic_qe__memory_store',
+    MEMORY_RETRIEVE: 'mcp__agentic_qe__memory_retrieve',
+    MEMORY_QUERY: 'mcp__agentic_qe__memory_query',
+    MEMORY_SHARE: 'mcp__agentic_qe__memory_share',
+    MEMORY_BACKUP: 'mcp__agentic_qe__memory_backup',
+    BLACKBOARD_POST: 'mcp__agentic_qe__blackboard_post',
+    BLACKBOARD_READ: 'mcp__agentic_qe__blackboard_read',
+    CONSENSUS_PROPOSE: 'mcp__agentic_qe__consensus_propose',
+    CONSENSUS_VOTE: 'mcp__agentic_qe__consensus_vote',
+    ARTIFACT_MANIFEST: 'mcp__agentic_qe__artifact_manifest',
+    // Coordination tools (Phase 1)
+    WORKFLOW_CREATE: 'mcp__agentic_qe__workflow_create',
+    WORKFLOW_EXECUTE: 'mcp__agentic_qe__workflow_execute',
+    WORKFLOW_CHECKPOINT: 'mcp__agentic_qe__workflow_checkpoint',
+    WORKFLOW_RESUME: 'mcp__agentic_qe__workflow_resume',
+    TASK_STATUS: 'mcp__agentic_qe__task_status',
+    EVENT_EMIT: 'mcp__agentic_qe__event_emit',
+    EVENT_SUBSCRIBE: 'mcp__agentic_qe__event_subscribe',
+    // Quality gate tools
+    QUALITY_GATE_EXECUTE: 'mcp__agentic_qe__quality_gate_execute',
+    QUALITY_VALIDATE_METRICS: 'mcp__agentic_qe__quality_validate_metrics',
+    QUALITY_RISK_ASSESS: 'mcp__agentic_qe__quality_risk_assess',
+    QUALITY_DECISION_MAKE: 'mcp__agentic_qe__quality_decision_make',
+    QUALITY_POLICY_CHECK: 'mcp__agentic_qe__quality_policy_check',
+    // Prediction and analysis tools
+    FLAKY_TEST_DETECT: 'mcp__agentic_qe__flaky_test_detect',
+    PREDICT_DEFECTS_AI: 'mcp__agentic_qe__predict_defects_ai',
+    REGRESSION_RISK_ANALYZE: 'mcp__agentic_qe__regression_risk_analyze',
+    VISUAL_TEST_REGRESSION: 'mcp__agentic_qe__visual_test_regression',
+    DEPLOYMENT_READINESS_CHECK: 'mcp__agentic_qe__deployment_readiness_check',
+    // Analysis tools
+    COVERAGE_ANALYZE_SUBLINEAR: 'mcp__agentic_qe__coverage_analyze_sublinear',
+    COVERAGE_GAPS_DETECT: 'mcp__agentic_qe__coverage_gaps_detect',
+    PERFORMANCE_BENCHMARK_RUN: 'mcp__agentic_qe__performance_benchmark_run',
+    PERFORMANCE_MONITOR_REALTIME: 'mcp__agentic_qe__performance_monitor_realtime',
+    SECURITY_SCAN_COMPREHENSIVE: 'mcp__agentic_qe__security_scan_comprehensive',
+    // Advanced tools
+    REQUIREMENTS_VALIDATE: 'mcp__agentic_qe__requirements_validate',
+    REQUIREMENTS_GENERATE_BDD: 'mcp__agentic_qe__requirements_generate_bdd',
+    PRODUCTION_INCIDENT_REPLAY: 'mcp__agentic_qe__production_incident_replay',
+    PRODUCTION_RUM_ANALYZE: 'mcp__agentic_qe__production_rum_analyze',
+    API_BREAKING_CHANGES: 'mcp__agentic_qe__api_breaking_changes',
+    MUTATION_TEST_EXECUTE: 'mcp__agentic_qe__mutation_test_execute'
 };
 //# sourceMappingURL=tools.js.map