qa360 2.1.7 → 2.2.0

package/packages/mcp/src/tools/pack.ts

@@ -0,0 +1,449 @@
+/**
+ * QA360 Pack Tools
+ * Generate, validate, and manage QA360 packs via MCP
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { MCPServerConfig, PackAskArgs, PackValidateArgs, PackAskResult, PackValidateResult } from '../types/index.js';
+import { PackValidator } from 'qa360-core';
+import { SecurityManager } from '../security/manager.js';
+import { AuditLogger } from '../security/audit.js';
+
+export class PackTools {
+  private config: MCPServerConfig;
+  private security: SecurityManager;
+  private audit: AuditLogger;
+
+  constructor(config: MCPServerConfig, security: SecurityManager, audit: AuditLogger) {
+    this.config = config;
+    this.security = security;
+    this.audit = audit;
+  }
+
+  async execute(toolName: string, args: any): Promise<any> {
+    switch (toolName) {
+      case 'qa360.pack.ask':
+        return await this.ask(args as PackAskArgs);
+      case 'qa360.pack.validate':
+        return await this.validate(args as PackValidateArgs);
+      case 'qa360.pack.lint':
+        return await this.lint(args as PackValidateArgs);
+      case 'qa360.pack.migrate':
+        return await this.migrate(args as PackValidateArgs);
+      default:
+        throw new Error(`Unknown pack tool: ${toolName}`);
+    }
+  }
+
+  /**
+   * Generate a pack from natural language query
+   */
+  private async ask(args: PackAskArgs): Promise<PackAskResult> {
+    const { query, context } = args;
+
+    // Analyze query to determine testing requirements
+    const analysis = this.analyzeQuery(query);
+    
+    // Generate pack YAML based on analysis
+    const pack = this.generatePack(analysis, context);
+
+    return {
+      pack,
+      hints: {
+        tools_needed: analysis.tools,
+        estimated_duration: analysis.estimatedDuration,
+        complexity: analysis.complexity
+      }
+    };
+  }
+
+  /**
+   * Validate a pack configuration
+   */
+  private async validate(args: PackValidateArgs): Promise<PackValidateResult> {
+    const packContent = await this.getPackContent(args);
+    
+    try {
+      const yaml = require('yaml');
+      const pack = yaml.parse(packContent);
+      
+      const errors: Array<{ code: string; message: string; line?: number; column?: number }> = [];
+      const warnings: Array<{ code: string; message: string; line?: number; column?: number }> = [];
+
+      // Basic structure validation
+      if (!pack) {
+        errors.push({
+          code: 'PACK_EMPTY',
+          message: 'Pack file is empty or invalid YAML'
+        });
+        return { valid: false, errors, warnings };
+      }
+
+      if (!pack.name) {
+        errors.push({
+          code: 'PACK_NO_NAME',
+          message: 'Pack must have a name field'
+        });
+      }
+
+      if (!pack.version) {
+        errors.push({
+          code: 'PACK_NO_VERSION',
+          message: 'Pack must have a version field'
+        });
+      }
+
+      if (!pack.gates || typeof pack.gates !== 'object') {
+        errors.push({
+          code: 'PACK_NO_GATES',
+          message: 'Pack must have a gates object'
+        });
+      } else {
+        // Validate gates
+        for (const [gateName, gateConfig] of Object.entries(pack.gates)) {
+          if (!gateConfig || typeof gateConfig !== 'object') {
+            errors.push({
+              code: 'GATE_INVALID',
+              message: `Gate '${gateName}' must be an object`
+            });
+            continue;
+          }
+
+          const gate = gateConfig as any;
+          if (!gate.adapter) {
+            errors.push({
+              code: 'GATE_NO_ADAPTER',
+              message: `Gate '${gateName}' must specify an adapter`
+            });
+          }
+
+          // Validate known adapters
+          const validAdapters = ['shell', 'playwright', 'semgrep', 'zap', 'gitleaks', 'osv', 'k6'];
+          if (gate.adapter && !validAdapters.includes(gate.adapter)) {
+            warnings.push({
+              code: 'GATE_UNKNOWN_ADAPTER',
+              message: `Gate '${gateName}' uses unknown adapter '${gate.adapter}'`
+            });
+          }
+
+          // Validate budgets
+          if (gate.budgets) {
+            if (gate.budgets.max_duration_ms && typeof gate.budgets.max_duration_ms !== 'number') {
+              errors.push({
+                code: 'BUDGET_INVALID_DURATION',
+                message: `Gate '${gateName}' budget max_duration_ms must be a number`
+              });
+            }
+          }
+        }
+      }
+
+      return {
+        valid: errors.length === 0,
+        errors,
+        warnings
+      };
+
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [{
+          code: 'PACK_PARSE_ERROR',
+          message: `Failed to parse pack: ${error instanceof Error ? error.message : 'Unknown error'}`
+        }],
+        warnings: []
+      };
+    }
+  }
+
+  /**
+   * Lint a pack and suggest improvements
+   */
+  private async lint(args: PackValidateArgs): Promise<PackValidateResult> {
+    const validation = await this.validate(args);
+    
+    // Add linting-specific suggestions
+    const autoFixes: string[] = [];
+    
+    if (validation.valid) {
+      try {
+        const packContent = await this.getPackContent(args);
+        const yaml = require('yaml');
+        const pack = yaml.parse(packContent);
+
+        // Suggest improvements
+        if (!pack.description) {
+          validation.warnings.push({
+            code: 'PACK_NO_DESCRIPTION',
+            message: 'Consider adding a description field to document the pack purpose'
+          });
+          autoFixes.push('Add description field');
+        }
+
+        if (!pack.metadata) {
+          validation.warnings.push({
+            code: 'PACK_NO_METADATA',
+            message: 'Consider adding metadata for better organization'
+          });
+          autoFixes.push('Add metadata section');
+        }
+
+        // Check for common patterns
+        const gateNames = Object.keys(pack.gates || {});
+        if (gateNames.length > 10) {
+          validation.warnings.push({
+            code: 'PACK_TOO_MANY_GATES',
+            message: 'Pack has many gates, consider splitting into multiple packs'
+          });
+        }
+
+        if (gateNames.some(name => name.includes(' '))) {
+          validation.warnings.push({
+            code: 'GATE_NAME_SPACES',
+            message: 'Gate names should use underscores or hyphens instead of spaces'
+          });
+          autoFixes.push('Normalize gate names');
+        }
+      } catch (error) {
+        // Ignore linting errors if pack is invalid
+      }
+    }
+
+    return {
+      ...validation,
+      auto_fixes: autoFixes
+    };
+  }
+
+  /**
+   * Migrate a pack to latest version
+   */
+  private async migrate(args: PackValidateArgs): Promise<PackValidateResult> {
+    const packContent = await this.getPackContent(args);
+    
+    try {
+      const yaml = require('yaml');
+      const pack = yaml.parse(packContent);
+      
+      if (!pack) {
+        throw new Error('Invalid pack content');
+      }
+
+      // Migration logic (simplified)
+      let migrated = false;
+      const migrations: string[] = [];
+
+      // Example migration: ensure version field exists
+      if (!pack.version) {
+        pack.version = '1.0.0';
+        migrated = true;
+        migrations.push('Added version field');
+      }
+
+      // Example migration: update old adapter names
+      if (pack.gates) {
+        for (const [gateName, gateConfig] of Object.entries(pack.gates)) {
+          const gate = gateConfig as any;
+          if (gate.adapter === 'browser' || gate.adapter === 'ui') {
+            gate.adapter = 'playwright';
+            migrated = true;
+            migrations.push(`Updated ${gateName} adapter to playwright`);
+          }
+        }
+      }
+
+      if (migrated) {
+        return {
+          valid: true,
+          errors: [],
+          warnings: [],
+          auto_fixes: migrations
+        };
+      } else {
+        return {
+          valid: true,
+          errors: [],
+          warnings: [{
+            code: 'PACK_UP_TO_DATE',
+            message: 'Pack is already using the latest format'
+          }]
+        };
+      }
+
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [{
+          code: 'MIGRATION_FAILED',
+          message: `Migration failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+        }],
+        warnings: []
+      };
+    }
+  }
+
+  /**
+   * Get pack content from args
+   */
+  private async getPackContent(args: PackValidateArgs): Promise<string> {
+    if (args.pack) {
+      return args.pack;
+    } else if (args.path) {
+      if (!existsSync(args.path)) {
+        throw new Error(`Pack file not found: ${args.path}`);
+      }
+      return readFileSync(args.path, 'utf8');
+    } else {
+      throw new Error('Either pack content or path must be provided');
+    }
+  }
+
+  /**
+   * Analyze natural language query to determine testing requirements
+   */
+  private analyzeQuery(query: string): {
+    tools: string[];
+    estimatedDuration: string;
+    complexity: 'simple' | 'medium' | 'complex';
+    gates: Array<{ name: string; adapter: string; config: any }>;
+  } {
+    const lowerQuery = query.toLowerCase();
+    const tools: string[] = [];
+    const gates: Array<{ name: string; adapter: string; config: any }> = [];
+
+    // Detect testing types from query
+    if (lowerQuery.includes('ui') || lowerQuery.includes('interface') || lowerQuery.includes('click') || lowerQuery.includes('form')) {
+      tools.push('playwright');
+      gates.push({
+        name: 'ui',
+        adapter: 'playwright',
+        config: {
+          budgets: { max_duration_ms: 30000 }
+        }
+      });
+    }
+
+    if (lowerQuery.includes('api') || lowerQuery.includes('endpoint') || lowerQuery.includes('rest') || lowerQuery.includes('graphql')) {
+      tools.push('k6');
+      gates.push({
+        name: 'api',
+        adapter: 'k6',
+        config: {
+          budgets: { max_duration_ms: 10000 }
+        }
+      });
+    }
+
+    if (lowerQuery.includes('security') || lowerQuery.includes('sast') || lowerQuery.includes('vulnerability')) {
+      tools.push('semgrep');
+      gates.push({
+        name: 'sast',
+        adapter: 'semgrep',
+        config: {
+          budgets: { max_duration_ms: 60000 }
+        }
+      });
+    }
+
+    if (lowerQuery.includes('performance') || lowerQuery.includes('load') || lowerQuery.includes('stress')) {
+      tools.push('k6');
+      if (!gates.some(g => g.name === 'perf')) {
+        gates.push({
+          name: 'perf',
+          adapter: 'k6',
+          config: {
+            budgets: { max_duration_ms: 120000 }
+          }
+        });
+      }
+    }
+
+    if (lowerQuery.includes('dependencies') || lowerQuery.includes('deps') || lowerQuery.includes('vulnerability')) {
+      tools.push('osv-scanner');
+      gates.push({
+        name: 'deps',
+        adapter: 'osv',
+        config: {
+          budgets: { max_duration_ms: 30000 }
+        }
+      });
+    }
+
+    // Default to basic UI test if nothing detected
+    if (gates.length === 0) {
+      tools.push('playwright');
+      gates.push({
+        name: 'basic',
+        adapter: 'playwright',
+        config: {
+          budgets: { max_duration_ms: 15000 }
+        }
+      });
+    }
+
+    // Determine complexity and duration
+    let complexity: 'simple' | 'medium' | 'complex' = 'simple';
+    let estimatedDuration = '30s';
+
+    if (gates.length > 3) {
+      complexity = 'complex';
+      estimatedDuration = '5-10min';
+    } else if (gates.length > 1) {
+      complexity = 'medium';
+      estimatedDuration = '1-3min';
+    }
+
+    return {
+      tools,
+      estimatedDuration,
+      complexity,
+      gates
+    };
+  }
+
+  /**
+   * Generate pack YAML from analysis
+   */
+  private generatePack(analysis: any, context?: any): string {
+    const pack = {
+      name: context?.name || 'generated-pack',
+      version: '1.0.0',
+      description: 'Generated QA360 pack from natural language query',
+      metadata: {
+        generated: true,
+        timestamp: new Date().toISOString(),
+        tools_needed: analysis.tools,
+        estimated_duration: analysis.estimatedDuration,
+        complexity: analysis.complexity
+      },
+      gates: {} as any
+    };
+
+    // Add gates from analysis
+    analysis.gates.forEach((gate: any) => {
+      pack.gates[gate.name] = {
+        adapter: gate.adapter,
+        ...gate.config
+      };
+
+      // Add adapter-specific configuration
+      switch (gate.adapter) {
+        case 'playwright':
+          pack.gates[gate.name].command = 'npx playwright test';
+          break;
+        case 'k6':
+          pack.gates[gate.name].script = './load-test.js';
+          break;
+        case 'semgrep':
+          pack.gates[gate.name].rules = 'auto';
+          break;
+        case 'osv':
+          pack.gates[gate.name].lockfile = './package-lock.json';
+          break;
+      }
+    });
+
+    const yaml = require('yaml');
+    return yaml.stringify(pack, { indent: 2 });
+  }
+}