agentic-qe
Version:
Agentic Quality Engineering Fleet System - AI-driven quality management platform
1,333 lines • 65.8 kB
JavaScript
"use strict";
/**
* MCP Tools for Agentic QE Fleet System
*
* This module defines the Model Context Protocol (MCP) tools for the Agentic Quality Engineering
* Fleet system. These tools enable Claude Flow coordination and orchestration of QE agents.
*
* @version 1.0.0
* @author Agentic QE Team
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.TOOL_NAMES = exports.agenticQETools = void 0;
/**
* Core MCP Tools for Agentic QE Fleet
* These tools enable Claude Flow to coordinate and manage QE agent fleets
*/
exports.agenticQETools = [
{
name: 'mcp__agentic_qe__fleet_init',
description: 'Initialize a new QE fleet with specified topology and configuration',
inputSchema: {
type: 'object',
properties: {
config: {
type: 'object',
properties: {
topology: {
type: 'string',
enum: ['hierarchical', 'mesh', 'ring', 'adaptive'],
description: 'Fleet coordination topology'
},
maxAgents: {
type: 'number',
minimum: 5,
maximum: 50,
description: 'Maximum number of agents in the fleet'
},
testingFocus: {
type: 'array',
items: { type: 'string' },
description: 'Areas of testing focus (unit, integration, performance, etc.)'
},
environments: {
type: 'array',
items: { type: 'string' },
description: 'Target environments for testing'
},
frameworks: {
type: 'array',
items: { type: 'string' },
description: 'Testing frameworks to support'
}
},
required: ['topology', 'maxAgents']
},
projectContext: {
type: 'object',
properties: {
repositoryUrl: { type: 'string' },
language: { type: 'string' },
buildSystem: { type: 'string' }
}
}
},
required: ['config']
}
},
{
name: 'mcp__agentic_qe__agent_spawn',
description: 'Spawn a specialized QE agent with specific capabilities',
inputSchema: {
type: 'object',
properties: {
spec: {
type: 'object',
properties: {
type: {
type: 'string',
enum: ['test-generator', 'coverage-analyzer', 'quality-gate', 'performance-tester', 'security-scanner', 'chaos-engineer', 'visual-tester'],
description: 'Type of specialized QE agent'
},
name: {
type: 'string',
description: 'Custom name for the agent'
},
capabilities: {
type: 'array',
items: { type: 'string' },
description: 'Specific capabilities for the agent'
},
resources: {
type: 'object',
properties: {
memory: { type: 'number', description: 'Memory allocation in MB' },
cpu: { type: 'number', description: 'CPU cores allocation' },
storage: { type: 'number', description: 'Storage allocation in MB' }
}
}
},
required: ['type', 'capabilities']
},
fleetId: {
type: 'string',
description: 'ID of the fleet to spawn the agent in'
}
},
required: ['spec']
}
},
{
name: 'mcp__agentic_qe__test_generate',
description: 'Generate comprehensive test suites using AI analysis',
inputSchema: {
type: 'object',
properties: {
spec: {
type: 'object',
properties: {
type: {
type: 'string',
enum: ['unit', 'integration', 'e2e', 'property-based', 'mutation'],
description: 'Type of tests to generate'
},
sourceCode: {
type: 'object',
properties: {
repositoryUrl: { type: 'string' },
branch: { type: 'string', default: 'main' },
language: { type: 'string' },
testPatterns: {
type: 'array',
items: { type: 'string' },
description: 'File patterns to include in analysis'
}
},
required: ['repositoryUrl', 'language']
},
coverageTarget: {
type: 'number',
minimum: 0,
maximum: 100,
description: 'Target code coverage percentage'
},
frameworks: {
type: 'array',
items: { type: 'string' },
description: 'Testing frameworks to use'
},
synthesizeData: {
type: 'boolean',
default: true,
description: 'Whether to synthesize realistic test data'
}
},
required: ['type', 'sourceCode', 'coverageTarget']
},
agentId: {
type: 'string',
description: 'ID of the test generator agent to use'
}
},
required: ['spec']
}
},
{
name: 'mcp__agentic_qe__test_execute',
description: 'Execute test suites with orchestrated parallel execution',
inputSchema: {
type: 'object',
properties: {
spec: {
type: 'object',
properties: {
testSuites: {
type: 'array',
items: { type: 'string' },
description: 'Test suites to execute'
},
environments: {
type: 'array',
items: { type: 'string' },
description: 'Target environments'
},
parallelExecution: {
type: 'boolean',
default: true,
description: 'Enable parallel test execution'
},
retryCount: {
type: 'number',
minimum: 0,
maximum: 5,
default: 3,
description: 'Number of retries for flaky tests'
},
timeoutSeconds: {
type: 'number',
minimum: 10,
default: 300,
description: 'Timeout for test execution'
},
reportFormat: {
type: 'string',
enum: ['junit', 'tap', 'json', 'html'],
default: 'json',
description: 'Test report format'
}
},
required: ['testSuites']
},
fleetId: {
type: 'string',
description: 'Fleet ID for coordinated execution'
}
},
required: ['spec']
}
},
{
name: 'mcp__agentic_qe__quality_analyze',
description: 'Analyze quality metrics and generate comprehensive reports',
inputSchema: {
type: 'object',
properties: {
params: {
type: 'object',
properties: {
scope: {
type: 'string',
enum: ['code', 'tests', 'performance', 'security', 'all'],
description: 'Scope of quality analysis'
},
metrics: {
type: 'array',
items: { type: 'string' },
description: 'Specific metrics to analyze'
},
thresholds: {
type: 'object',
additionalProperties: { type: 'number' },
description: 'Quality thresholds for pass/fail decisions'
},
generateRecommendations: {
type: 'boolean',
default: true,
description: 'Generate improvement recommendations'
},
historicalComparison: {
type: 'boolean',
default: false,
description: 'Compare with historical quality trends'
}
},
required: ['scope', 'metrics']
},
dataSource: {
type: 'object',
properties: {
testResults: { type: 'string', description: 'Path to test results' },
codeMetrics: { type: 'string', description: 'Path to code quality metrics' },
performanceData: { type: 'string', description: 'Path to performance data' }
}
}
},
required: ['params']
}
},
{
name: 'mcp__agentic_qe__predict_defects',
description: 'Predict potential defects using AI/ML models',
inputSchema: {
type: 'object',
properties: {
scope: {
type: 'object',
properties: {
analysisType: {
type: 'string',
enum: ['file', 'function', 'line', 'module'],
description: 'Granularity of defect prediction'
},
modelType: {
type: 'string',
enum: ['neural', 'statistical', 'hybrid'],
description: 'Type of prediction model to use'
},
confidenceThreshold: {
type: 'number',
minimum: 0.0,
maximum: 1.0,
default: 0.8,
description: 'Minimum confidence for predictions'
},
historicalDataDays: {
type: 'number',
minimum: 7,
maximum: 365,
default: 90,
description: 'Days of historical data to consider'
},
features: {
type: 'array',
items: { type: 'string' },
description: 'Code features to analyze for prediction'
}
},
required: ['analysisType', 'modelType']
},
codeChanges: {
type: 'object',
properties: {
repository: { type: 'string' },
commit: { type: 'string' },
files: {
type: 'array',
items: { type: 'string' },
description: 'Files to analyze for defect risk'
}
},
required: ['repository']
}
},
required: ['scope']
}
},
{
name: 'mcp__agentic_qe__fleet_status',
description: 'Get comprehensive status of QE fleet and agents',
inputSchema: {
type: 'object',
properties: {
fleetId: {
type: 'string',
description: 'Fleet ID to get status for'
},
includeMetrics: {
type: 'boolean',
default: true,
description: 'Include performance metrics'
},
includeAgentDetails: {
type: 'boolean',
default: false,
description: 'Include detailed agent information'
}
}
}
},
{
name: 'mcp__agentic_qe__task_orchestrate',
description: 'Orchestrate complex QE tasks across multiple agents',
inputSchema: {
type: 'object',
properties: {
task: {
type: 'object',
properties: {
type: {
type: 'string',
enum: ['comprehensive-testing', 'quality-gate', 'defect-prevention', 'performance-validation'],
description: 'Type of orchestrated task'
},
priority: {
type: 'string',
enum: ['low', 'medium', 'high', 'critical'],
default: 'medium',
description: 'Task priority level'
},
strategy: {
type: 'string',
enum: ['parallel', 'sequential', 'adaptive'],
default: 'adaptive',
description: 'Execution strategy'
},
maxAgents: {
type: 'number',
minimum: 1,
maximum: 10,
description: 'Maximum agents to use for task'
},
timeoutMinutes: {
type: 'number',
minimum: 1,
default: 30,
description: 'Task timeout in minutes'
}
},
required: ['type']
},
context: {
type: 'object',
properties: {
project: { type: 'string' },
branch: { type: 'string' },
environment: { type: 'string' },
requirements: {
type: 'array',
items: { type: 'string' },
description: 'Specific requirements for the task'
}
}
},
fleetId: {
type: 'string',
description: 'Fleet to orchestrate task within'
}
},
required: ['task']
}
},
{
name: 'mcp__agentic_qe__optimize_tests',
description: 'Optimize test suites using sublinear algorithms',
inputSchema: {
type: 'object',
properties: {
optimization: {
type: 'object',
properties: {
algorithm: {
type: 'string',
enum: ['sublinear', 'johnson-lindenstrauss', 'temporal-advantage'],
description: 'Optimization algorithm to use'
},
targetMetric: {
type: 'string',
enum: ['execution-time', 'coverage', 'cost', 'reliability'],
description: 'Primary optimization target'
},
constraints: {
type: 'object',
properties: {
maxExecutionTime: { type: 'number' },
minCoverage: { type: 'number' },
maxCost: { type: 'number' }
}
}
},
required: ['algorithm', 'targetMetric']
},
testSuite: {
type: 'object',
properties: {
size: { type: 'number' },
characteristics: {
type: 'array',
items: { type: 'string' }
},
historical_performance: { type: 'object' }
}
}
},
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',
inputSchem