@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/compatibility/config-migrator.ts

@@ -1,334 +0,0 @@
-/**
- * Config Migrator - Migrates V2 configuration to V3 format
- */
-
-import { V2Config, V3Config, ConfigMigrationResult } from './types';
-
-/**
- * Default V3 configuration values
- */
-const DEFAULT_V3_CONFIG: V3Config = {
-  v3: {
-    version: '3.0.0',
-    domains: [
-      'test-generation',
-      'test-execution',
-      'coverage-analysis',
-      'quality-assessment',
-      'defect-intelligence',
-      'code-intelligence',
-      'requirements-validation',
-      'security-compliance',
-      'contract-testing',
-      'visual-accessibility',
-      'chaos-resilience',
-      'learning-optimization',
-    ],
-    agents: {
-      maxConcurrent: 15,
-      timeout: 300000,
-      retryOnFailure: true,
-      maxRetries: 3,
-    },
-    memory: {
-      backend: 'hybrid',
-      sqlite: { path: '.agentic-qe/memory.db' },
-      agentdb: { enabled: true },
-      hnsw: {
-        enabled: true,
-        M: 16,
-        efConstruction: 200,
-        efSearch: 100,
-      },
-    },
-    learning: {
-      enabled: true,
-      neuralLearning: true,
-      patternRetention: 180,
-      transferEnabled: true,
-    },
-    coverage: {
-      algorithm: 'sublinear',
-      thresholds: {
-        statements: 80,
-        branches: 75,
-        functions: 85,
-        lines: 80,
-      },
-      riskWeighted: true,
-    },
-    qualityGates: {
-      coverage: { min: 80, blocking: true },
-      complexity: { max: 15, blocking: false },
-      vulnerabilities: { critical: 0, high: 0, blocking: true },
-    },
-  },
-};
-
-/**
- * Config Migrator class for V2 to V3 configuration migration
- */
-export class ConfigMigrator {
-  /**
-   * Migrate a V2 configuration to V3 format
-   */
-  migrate(v2Config: V2Config): ConfigMigrationResult {
-    const warnings: string[] = [];
-    const unmappedKeys: string[] = [];
-
-    // Start with defaults
-    const v3Config: V3Config = JSON.parse(JSON.stringify(DEFAULT_V3_CONFIG));
-
-    // Migrate version
-    if (v2Config.version) {
-      warnings.push(
-        `V2 version "${v2Config.version}" detected. Migrating to v3.0.0`
-      );
-    }
-
-    // Migrate memory backend
-    if (v2Config.memory?.backend) {
-      const backend = v2Config.memory.backend.toLowerCase();
-      if (backend === 'sqlite') {
-        v3Config.v3.memory.backend = 'sqlite';
-        v3Config.v3.memory.agentdb = { enabled: false };
-        warnings.push(
-          'Memory backend "sqlite" preserved. Consider upgrading to "hybrid" for better performance.'
-        );
-      } else if (backend === 'agentdb') {
-        v3Config.v3.memory.backend = 'agentdb';
-      }
-      // 'hybrid' is default
-    }
-
-    // Migrate memory path
-    if (v2Config.memory?.path) {
-      v3Config.v3.memory.sqlite = { path: v2Config.memory.path };
-    }
-
-    // Migrate learning settings
-    if (v2Config.learning !== undefined) {
-      if (typeof v2Config.learning === 'object') {
-        if (v2Config.learning.enabled !== undefined) {
-          v3Config.v3.learning.enabled = v2Config.learning.enabled;
-        }
-        if (v2Config.learning.patternRetention !== undefined) {
-          v3Config.v3.learning.patternRetention =
-            v2Config.learning.patternRetention;
-        }
-      }
-    }
-
-    // Migrate coverage threshold
-    if (v2Config.coverage?.threshold) {
-      const threshold = v2Config.coverage.threshold;
-      v3Config.v3.coverage.thresholds = {
-        statements: threshold,
-        branches: Math.max(threshold - 5, 50),
-        functions: threshold,
-        lines: threshold,
-      };
-      v3Config.v3.qualityGates.coverage.min = threshold;
-    }
-
-    // Migrate agents list (convert to domains)
-    if (v2Config.agents && Array.isArray(v2Config.agents)) {
-      const domains = this.inferDomainsFromAgents(v2Config.agents);
-      if (domains.length > 0) {
-        v3Config.v3.domains = domains;
-        warnings.push(
-          `Inferred ${domains.length} domains from v2 agent list.`
-        );
-      }
-    }
-
-    // Check for unmapped keys
-    const knownKeys = [
-      'version',
-      'agents',
-      'memory',
-      'learning',
-      'coverage',
-    ];
-    for (const key of Object.keys(v2Config)) {
-      if (!knownKeys.includes(key)) {
-        unmappedKeys.push(key);
-      }
-    }
-
-    if (unmappedKeys.length > 0) {
-      warnings.push(
-        `The following v2 config keys were not migrated: ${unmappedKeys.join(', ')}`
-      );
-    }
-
-    return {
-      success: true,
-      v3Config,
-      warnings,
-      unmappedKeys,
-    };
-  }
-
-  /**
-   * Infer domains from v2 agent list
-   */
-  private inferDomainsFromAgents(agents: string[]): string[] {
-    const domainSet = new Set<string>();
-
-    const agentToDomain: Record<string, string> = {
-      'qe-test-generator': 'test-generation',
-      'qe-test-executor': 'test-execution',
-      'qe-coverage-analyzer': 'coverage-analysis',
-      'qe-quality-gate': 'quality-assessment',
-      'qe-quality-analyzer': 'quality-assessment',
-      'qe-regression-risk-analyzer': 'defect-intelligence',
-      'qe-code-intelligence': 'code-intelligence',
-      'qe-requirements-validator': 'requirements-validation',
-      'qe-security-scanner': 'security-compliance',
-      'qe-api-contract-validator': 'contract-testing',
-      'qe-visual-tester': 'visual-accessibility',
-      'qe-a11y-ally': 'visual-accessibility',
-      'qe-chaos-engineer': 'chaos-resilience',
-      'qe-performance-tester': 'chaos-resilience',
-      'qe-production-intelligence': 'learning-optimization',
-    };
-
-    for (const agent of agents) {
-      const domain = agentToDomain[agent.toLowerCase()];
-      if (domain) {
-        domainSet.add(domain);
-      }
-    }
-
-    // If domains were detected, ensure we have the full set
-    if (domainSet.size > 0) {
-      return DEFAULT_V3_CONFIG.v3.domains;
-    }
-
-    return [];
-  }
-
-  /**
-   * Validate a V3 configuration
-   */
-  validate(config: V3Config): { valid: boolean; errors: string[] } {
-    const errors: string[] = [];
-
-    if (!config.v3) {
-      errors.push('Missing "v3" root key');
-      return { valid: false, errors };
-    }
-
-    if (!config.v3.version) {
-      errors.push('Missing version');
-    }
-
-    if (
-      !config.v3.domains ||
-      !Array.isArray(config.v3.domains) ||
-      config.v3.domains.length === 0
-    ) {
-      errors.push('Missing or empty domains array');
-    }
-
-    if (!config.v3.agents?.maxConcurrent) {
-      errors.push('Missing agents.maxConcurrent');
-    } else if (
-      config.v3.agents.maxConcurrent < 1 ||
-      config.v3.agents.maxConcurrent > 50
-    ) {
-      errors.push('agents.maxConcurrent must be between 1 and 50');
-    }
-
-    if (!config.v3.memory?.backend) {
-      errors.push('Missing memory.backend');
-    } else if (
-      !['sqlite', 'agentdb', 'hybrid'].includes(config.v3.memory.backend)
-    ) {
-      errors.push(
-        'memory.backend must be one of: sqlite, agentdb, hybrid'
-      );
-    }
-
-    return { valid: errors.length === 0, errors };
-  }
-
-  /**
-   * Generate a default V3 configuration
-   */
-  generateDefault(): V3Config {
-    return JSON.parse(JSON.stringify(DEFAULT_V3_CONFIG));
-  }
-
-  /**
-   * Merge a partial config with defaults
-   */
-  mergeWithDefaults(partial: Partial<V3Config>): V3Config {
-    const defaults = this.generateDefault();
-    return this.deepMerge(
-      defaults as unknown as Record<string, unknown>,
-      partial as unknown as Record<string, unknown>
-    ) as unknown as V3Config;
-  }
-
-  /**
-   * Deep merge two objects
-   */
-  private deepMerge(
-    target: Record<string, unknown>,
-    source: Record<string, unknown>
-  ): Record<string, unknown> {
-    const result = { ...target };
-
-    for (const key of Object.keys(source)) {
-      if (
-        source[key] &&
-        typeof source[key] === 'object' &&
-        !Array.isArray(source[key])
-      ) {
-        result[key] = this.deepMerge(
-          (target[key] as Record<string, unknown>) || {},
-          source[key] as Record<string, unknown>
-        );
-      } else {
-        result[key] = source[key];
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Generate YAML representation of V3 config
-   */
-  toYAML(config: V3Config): string {
-    // Simple YAML generation (in production, use a proper YAML library)
-    return this.objectToYAML(config, 0);
-  }
-
-  private objectToYAML(obj: unknown, indent: number): string {
-    const spaces = '  '.repeat(indent);
-    let yaml = '';
-
-    if (Array.isArray(obj)) {
-      for (const item of obj) {
-        if (typeof item === 'object') {
-          yaml += `${spaces}-\n${this.objectToYAML(item, indent + 1)}`;
-        } else {
-          yaml += `${spaces}- ${item}\n`;
-        }
-      }
-    } else if (typeof obj === 'object' && obj !== null) {
-      for (const [key, value] of Object.entries(obj)) {
-        if (typeof value === 'object' && value !== null) {
-          yaml += `${spaces}${key}:\n${this.objectToYAML(value, indent + 1)}`;
-        } else {
-          yaml += `${spaces}${key}: ${value}\n`;
-        }
-      }
-    }
-
-    return yaml;
-  }
-}

package/src/compatibility/index.ts

@@ -1,112 +0,0 @@
-/**
- * V2 Compatibility Layer
- *
- * Provides backward compatibility for v2 APIs, allowing gradual migration to v3.
- * - Agent name mapping (v2 → v3)
- * - CLI command forwarding
- * - MCP tool adaptation
- * - Configuration migration
- *
- * @module compatibility
- */
-
-export * from './types';
-export * from './agent-mapper';
-export * from './cli-adapter';
-export * from './mcp-adapter';
-export * from './config-migrator';
-
-import { AgentMapper } from './agent-mapper';
-import { CLIAdapter } from './cli-adapter';
-import { MCPAdapter } from './mcp-adapter';
-import { ConfigMigrator } from './config-migrator';
-
-/**
- * V2 Compatibility Layer singleton
- */
-export class V2CompatibilityLayer {
-  private static instance: V2CompatibilityLayer;
-
-  public readonly agents: AgentMapper;
-  public readonly cli: CLIAdapter;
-  public readonly mcp: MCPAdapter;
-  public readonly config: ConfigMigrator;
-
-  private deprecationWarnings: Set<string> = new Set();
-  private warningsEnabled: boolean = true;
-
-  private constructor() {
-    this.agents = new AgentMapper();
-    this.cli = new CLIAdapter(this.agents);
-    this.mcp = new MCPAdapter(this.agents);
-    this.config = new ConfigMigrator();
-  }
-
-  static getInstance(): V2CompatibilityLayer {
-    if (!V2CompatibilityLayer.instance) {
-      V2CompatibilityLayer.instance = new V2CompatibilityLayer();
-    }
-    return V2CompatibilityLayer.instance;
-  }
-
-  /**
-   * Enable or disable deprecation warnings
-   */
-  setWarningsEnabled(enabled: boolean): void {
-    this.warningsEnabled = enabled;
-  }
-
-  /**
-   * Emit a deprecation warning (once per unique message)
-   */
-  warnDeprecation(v2Feature: string, v3Alternative: string): void {
-    if (!this.warningsEnabled) return;
-
-    const key = `${v2Feature}:${v3Alternative}`;
-    if (this.deprecationWarnings.has(key)) return;
-
-    this.deprecationWarnings.add(key);
-    console.warn(
-      `[AQE Deprecation] "${v2Feature}" is deprecated. Use "${v3Alternative}" instead.`
-    );
-  }
-
-  /**
-   * Check if running in compatibility mode
-   */
-  isCompatibilityMode(): boolean {
-    return process.env.AQE_COMPATIBILITY_MODE === 'true';
-  }
-
-  /**
-   * Get migration status report
-   */
-  getMigrationStatus(): MigrationStatus {
-    return {
-      v2FeaturesUsed: this.deprecationWarnings.size,
-      warnings: Array.from(this.deprecationWarnings),
-      recommendedActions: this.getRecommendedActions(),
-    };
-  }
-
-  private getRecommendedActions(): string[] {
-    const actions: string[] = [];
-
-    if (this.deprecationWarnings.size > 0) {
-      actions.push('Update agent names to v3 format (v3-qe-*)');
-      actions.push('Migrate CLI commands to aqe-v3 format');
-      actions.push('Update configuration to v3 schema');
-    }
-
-    return actions;
-  }
-}
-
-interface MigrationStatus {
-  v2FeaturesUsed: number;
-  warnings: string[];
-  recommendedActions: string[];
-}
-
-// Default export
-export const compatibility = V2CompatibilityLayer.getInstance();

package/src/compatibility/mcp-adapter.ts

@@ -1,248 +0,0 @@
-/**
- * MCP Adapter - Adapts V2 MCP tool calls to V3 format
- */
-
-import { MCPToolMapping, MCPResolution } from './types';
-import { AgentMapper } from './agent-mapper';
-
-/**
- * V2 to V3 MCP tool mappings
- */
-const MCP_MAPPINGS: MCPToolMapping[] = [
-  // Test generation tools
-  {
-    v2Tool: 'mcp__agentic-qe__test_generate_enhanced',
-    v3Tool: 'mcp__agentic-qe__v3_test_generate',
-    paramMapping: {
-      sourceCode: 'sourceCode',
-      language: 'language',
-      testType: 'testType',
-      coverageGoal: 'coverageTarget',
-    },
-    deprecated: true,
-  },
-
-  // Test execution tools
-  {
-    v2Tool: 'mcp__agentic-qe__test_execute',
-    v3Tool: 'mcp__agentic-qe__v3_test_execute',
-    paramMapping: {
-      testSuites: 'testSuites',
-      parallelExecution: 'parallel',
-      retryCount: 'maxRetries',
-    },
-    deprecated: true,
-  },
-  {
-    v2Tool: 'mcp__agentic-qe__test_execute_parallel',
-    v3Tool: 'mcp__agentic-qe__v3_test_execute',
-    paramMapping: {
-      testFiles: 'testSuites',
-      parallelism: 'workers',
-      maxRetries: 'maxRetries',
-    },
-    deprecated: true,
-  },
-
-  // Fleet/Agent tools
-  {
-    v2Tool: 'mcp__agentic-qe__fleet_init',
-    v3Tool: 'mcp__agentic-qe__v3_fleet_init',
-    deprecated: true,
-  },
-  {
-    v2Tool: 'mcp__agentic-qe__agent_spawn',
-    v3Tool: 'mcp__agentic-qe__v3_agent_spawn',
-    paramMapping: {
-      type: 'agentType',
-      capabilities: 'capabilities',
-    },
-    deprecated: true,
-  },
-  {
-    v2Tool: 'mcp__agentic-qe__fleet_status',
-    v3Tool: 'mcp__agentic-qe__v3_fleet_status',
-    deprecated: true,
-  },
-
-  // Memory tools
-  {
-    v2Tool: 'mcp__agentic-qe__memory_store',
-    v3Tool: 'mcp__agentic-qe__v3_memory_store',
-    deprecated: true,
-  },
-  {
-    v2Tool: 'mcp__agentic-qe__memory_retrieve',
-    v3Tool: 'mcp__agentic-qe__v3_memory_retrieve',
-    deprecated: true,
-  },
-  {
-    v2Tool: 'mcp__agentic-qe__memory_query',
-    v3Tool: 'mcp__agentic-qe__v3_memory_query',
-    deprecated: true,
-  },
-
-  // Task orchestration
-  {
-    v2Tool: 'mcp__agentic-qe__task_orchestrate',
-    v3Tool: 'mcp__agentic-qe__v3_task_orchestrate',
-    deprecated: true,
-  },
-  {
-    v2Tool: 'mcp__agentic-qe__task_status',
-    v3Tool: 'mcp__agentic-qe__v3_task_status',
-    deprecated: true,
-  },
-
-  // Report generation
-  {
-    v2Tool: 'mcp__agentic-qe__test_report_comprehensive',
-    v3Tool: 'mcp__agentic-qe__v3_test_report',
-    deprecated: true,
-  },
-];
-
-/**
- * MCP Adapter class for V2 to V3 tool call translation
- */
-export class MCPAdapter {
-  private mappings: Map<string, MCPToolMapping>;
-  private agentMapper: AgentMapper;
-
-  constructor(agentMapper: AgentMapper) {
-    this.agentMapper = agentMapper;
-    this.mappings = new Map();
-
-    for (const mapping of MCP_MAPPINGS) {
-      this.mappings.set(mapping.v2Tool.toLowerCase(), mapping);
-    }
-  }
-
-  /**
-   * Resolve an MCP tool call from v2 to v3 format
-   */
-  resolve(
-    toolName: string,
-    params: Record<string, unknown> = {}
-  ): MCPResolution {
-    const normalized = toolName.toLowerCase();
-
-    // Already v3 format
-    if (normalized.includes('__v3_')) {
-      return {
-        resolved: true,
-        v3Tool: toolName,
-        v3Params: params,
-        wasV2: false,
-      };
-    }
-
-    // Try to find mapping
-    const mapping = this.mappings.get(normalized);
-    if (mapping) {
-      const v3Params = this.translateParams(params, mapping.paramMapping);
-
-      // Handle agent type translation in params
-      if (v3Params.agentType && typeof v3Params.agentType === 'string') {
-        const agentResolution = this.agentMapper.resolve(
-          v3Params.agentType as string
-        );
-        if (agentResolution.resolved && agentResolution.v3Agent) {
-          v3Params.agentType = agentResolution.v3Agent;
-        }
-      }
-
-      return {
-        resolved: true,
-        v3Tool: mapping.v3Tool,
-        v3Params,
-        wasV2: true,
-        deprecationWarning: `MCP tool "${toolName}" is deprecated. Use "${mapping.v3Tool}" instead.`,
-      };
-    }
-
-    return {
-      resolved: false,
-      v3Tool: null,
-      v3Params: params,
-      wasV2: false,
-    };
-  }
-
-  /**
-   * Translate v2 parameters to v3 format
-   */
-  private translateParams(
-    params: Record<string, unknown>,
-    mapping?: Record<string, string>
-  ): Record<string, unknown> {
-    if (!mapping) return { ...params };
-
-    const translated: Record<string, unknown> = {};
-
-    for (const [key, value] of Object.entries(params)) {
-      const newKey = mapping[key] || key;
-      translated[newKey] = value;
-    }
-
-    return translated;
-  }
-
-  /**
-   * Check if a tool name is v2 format
-   */
-  isV2Tool(toolName: string): boolean {
-    const normalized = toolName.toLowerCase();
-    return (
-      normalized.includes('mcp__agentic-qe__') &&
-      !normalized.includes('__v3_') &&
-      this.mappings.has(normalized)
-    );
-  }
-
-  /**
-   * Get all MCP mappings
-   */
-  getAllMappings(): MCPToolMapping[] {
-    return MCP_MAPPINGS;
-  }
-
-  /**
-   * Forward a v2 tool call to v3 implementation
-   */
-  async forward(
-    toolName: string,
-    params: Record<string, unknown>,
-    v3Handler: (
-      tool: string,
-      params: Record<string, unknown>
-    ) => Promise<unknown>
-  ): Promise<unknown> {
-    const resolution = this.resolve(toolName, params);
-
-    if (!resolution.resolved || !resolution.v3Tool) {
-      throw new Error(`Unknown MCP tool: ${toolName}`);
-    }
-
-    if (resolution.deprecationWarning) {
-      console.warn(`[AQE Deprecation] ${resolution.deprecationWarning}`);
-    }
-
-    return v3Handler(resolution.v3Tool, resolution.v3Params);
-  }
-
-  /**
-   * Generate MCP migration guide
-   */
-  generateMigrationGuide(): string {
-    let guide = '# MCP Tool Migration Guide\n\n';
-    guide += '| V2 Tool | V3 Tool |\n';
-    guide += '|---------|----------|\n';
-
-    for (const mapping of MCP_MAPPINGS) {
-      guide += `| \`${mapping.v2Tool}\` | \`${mapping.v3Tool}\` |\n`;
-    }
-
-    return guide;
-  }
-}