@democratize-quality/mcp-server 1.1.0 → 1.1.2

package/src/tools/api/prompts/healing-prompts.js

@@ -0,0 +1,143 @@
+/**
+ * Healing Prompts - Fix issues in generated code
+ * 
+ * These prompts are used to fix validation errors in generated code.
+ * Applied when validation fails, with specific feedback about issues.
+ */
+
+module.exports = {
+  /**
+   * Heal Playwright test code issues
+   */
+  playwrightHealing: {
+    system: `You are a code fixing expert. Fix the issues in the generated Playwright test code while maintaining functionality.
+
+Requirements:
+- Fix ONLY the reported issues
+- Maintain all existing functionality
+- Keep the same code structure
+- Use proper indentation (6 spaces for test body)
+- Return ONLY the fixed code, no explanations
+- DO NOT create any additional files
+- DO NOT generate README, SUMMARY, or documentation`,
+
+    user: (context) => {
+      const { originalCode, issues, scenario } = context;
+      
+      let prompt = `Fix the following issues in this Playwright test code:
+
+**Original Code:**
+\`\`\`typescript
+${originalCode}
+\`\`\`
+
+**Issues Found:**
+${issues.map((issue, i) => `${i + 1}. [${issue.severity.toUpperCase()}] ${issue.message}
+   Fix: ${issue.fix}`).join('\n')}
+
+**Original Scenario Context:**
+- Method: ${scenario.method}
+- Endpoint: ${scenario.endpoint}
+- Expected Status: ${scenario.expect?.status || 200}
+
+**Instructions:**
+1. Fix ALL reported issues
+2. Maintain the same functionality
+3. Keep proper indentation (6 spaces)
+4. For URL construction, use template literals: \`\${baseUrl}/endpoint\`
+5. Ensure await is used for all async calls
+6. Return ONLY the fixed code, starting at line 1 of the test body
+
+DO NOT:
+- Add explanations or comments about fixes
+- Change the test logic
+- Add or remove functionality
+- Include test() wrapper or imports
+- Create any additional files (README, SUMMARY, GUIDE, etc.)
+- Suggest file creation
+
+Return the complete fixed test body code.`;
+
+      return prompt;
+    }
+  },
+
+  /**
+   * Heal Jest test code issues
+   */
+  jestHealing: {
+    system: `You are a code fixing expert. Fix the issues in the generated Jest test code while maintaining functionality.
+
+Requirements:
+- Fix ONLY the reported issues
+- Maintain all existing functionality
+- Keep the same code structure
+- Use proper indentation (6 spaces for test body)
+- Return ONLY the fixed code, no explanations
+- DO NOT create any additional files
+- DO NOT generate README, SUMMARY, or documentation`,
+
+    user: (context) => {
+      const { originalCode, issues, scenario } = context;
+      
+      let prompt = `Fix the following issues in this Jest test code:
+
+**Original Code:**
+\`\`\`typescript
+${originalCode}
+\`\`\`
+
+**Issues Found:**
+${issues.map((issue, i) => `${i + 1}. [${issue.severity.toUpperCase()}] ${issue.message}
+   Fix: ${issue.fix}`).join('\n')}
+
+**Original Scenario Context:**
+- Method: ${scenario.method}
+- Endpoint: ${scenario.endpoint}
+- Expected Status: ${scenario.expect?.status || 200}
+
+**Instructions:**
+1. Fix ALL reported issues
+2. Maintain the same functionality
+3. Keep proper indentation (6 spaces)
+4. Use apiUtils.makeRequest() correctly
+5. Ensure await is used for all async calls
+6. Return ONLY the fixed code, starting at line 1 of the test body
+
+DO NOT:
+- Add explanations or comments about fixes
+- Change the test logic
+- Add or remove functionality
+- Include test() wrapper or imports
+- Create any additional files (README, SUMMARY, GUIDE, etc.)
+- Suggest file creation
+
+Return the complete fixed test body code.`;
+
+      return prompt;
+    }
+  },
+
+  /**
+   * Generic healing prompt for any format
+   */
+  genericHealing: {
+    system: `You are a code fixing expert. Fix the reported issues in the code while maintaining all functionality.`,
+
+    user: (context) => {
+      const { originalCode, issues, format, language } = context;
+      
+      return `Fix these issues in ${format} ${language} code:
+
+**Issues:**
+${issues.map((issue, i) => `${i + 1}. ${issue.message} - Fix: ${issue.fix}`).join('\n')}
+
+**Code:**
+\`\`\`${language}
+${originalCode}
+\`\`\`
+
+Return the fixed code only, no explanations.`;
+    }
+  }
+};

package/src/tools/api/prompts/index.js

@@ -0,0 +1,25 @@
+/**
+ * Prompt Orchestration System
+ * 
+ * Exports all components of the prompt orchestration system for AI-based test generation.
+ * 
+ * @module prompts
+ */
+
+const generationPrompts = require('./generation-prompts');
+const validationRules = require('./validation-rules');
+const healingPrompts = require('./healing-prompts');
+const PromptOrchestrator = require('./orchestrator');
+
+module.exports = {
+  // Main orchestrator class
+  PromptOrchestrator,
+  
+  // Individual components
+  generationPrompts,
+  validationRules,
+  healingPrompts,
+  
+  // Convenience factory
+  createOrchestrator: (options) => new PromptOrchestrator(options)
+};

package/src/tools/api/prompts/orchestrator.js

@@ -0,0 +1,333 @@
+/**
+ * Prompt Orchestrator
+ * 
+ * Coordinates the Planning → Generation → Validation → Healing workflow
+ * for AI-based test code generation.
+ */
+
+const generationPrompts = require('./generation-prompts');
+const validationRules = require('./validation-rules');
+const healingPrompts = require('./healing-prompts');
+
+class PromptOrchestrator {
+  constructor(options = {}) {
+    this.maxHealingAttempts = options.maxHealingAttempts || 3;
+    this.language = options.language || 'typescript';
+    this.outputFormat = options.outputFormat || 'playwright';
+    this.verbose = options.verbose || false;
+  }
+
+  /**
+   * Generate test code with validation and healing
+   * 
+   * Workflow:
+   * 1. Generate code using AI
+   * 2. Validate generated code
+   * 3. If invalid, heal and retry (up to maxHealingAttempts)
+   * 4. Return validated code or fallback
+   */
+  async generateTestCode(context, aiGenerator) {
+    const { scenario, baseUrl } = context;
+    
+    this.log(`📝 Generating ${this.outputFormat} test for: ${scenario.title}`);
+    
+    // Step 1: Generate initial code
+    let generatedCode = await this._generateCode(context, aiGenerator);
+    
+    // Step 1.5: Validate single file output (SAFETY NET)
+    // Some helpful AI models try to create README, SUMMARY, etc.
+    generatedCode = this._validateSingleFileOutput(generatedCode, context.targetFile);
+    
+    // Step 2: Validate
+    let validation = this._validateCode(generatedCode);
+    
+    // Step 3: Heal if needed (up to maxHealingAttempts)
+    let healingAttempt = 0;
+    while (!validation.valid && healingAttempt < this.maxHealingAttempts) {
+      healingAttempt++;
+      this.log(`🔧 Healing attempt ${healingAttempt}/${this.maxHealingAttempts}...`);
+      this.log(`   Issues: ${validation.issues.map(i => i.message).join(', ')}`);
+      
+      generatedCode = await this._healCode(generatedCode, validation.issues, context, aiGenerator);
+      validation = this._validateCode(generatedCode);
+      
+      if (validation.valid) {
+        this.log(`✅ Code healed successfully!`);
+      }
+    }
+    
+    // Step 4: Return result
+    if (!validation.valid) {
+      this.log(`⚠️  Warning: Code still has issues after ${healingAttempt} healing attempts`);
+      this.log(`   Remaining issues: ${validation.issues.map(i => i.message).join(', ')}`);
+    }
+    
+    return {
+      code: generatedCode,
+      valid: validation.valid,
+      issues: validation.issues,
+      healingAttempts: healingAttempt,
+      metadata: {
+        scenario: scenario.title,
+        format: this.outputFormat,
+        language: this.language
+      }
+    };
+  }
+
+  /**
+   * Generate code using AI
+   */
+  async _generateCode(context, aiGenerator) {
+    const promptConfig = this._getGenerationPrompt();
+    
+    const systemPrompt = promptConfig.system;
+    const userPrompt = promptConfig.user({
+      ...context,
+      language: this.language,
+      options: { format: this.outputFormat }
+    });
+    
+    this.log(`💭 Sending generation prompt to AI...`);
+    
+    // Call AI generator (this would be GitHub Copilot API, OpenAI, etc.)
+    const code = await aiGenerator.generate(systemPrompt, userPrompt);
+    
+    return code.trim();
+  }
+
+  /**
+   * Validate generated code
+   */
+  _validateCode(code) {
+    this.log(`🔍 Validating generated code...`);
+    
+    const validator = validationRules.getValidator(this.outputFormat);
+    const validation = validator.validateAll(code, this.language);
+    
+    if (validation.valid) {
+      this.log(`✅ Code validation passed!`);
+    } else {
+      this.log(`❌ Code validation failed with ${validation.issues.length} issues`);
+    }
+    
+    return validation;
+  }
+
+  /**
+   * Heal code issues using AI
+   */
+  async _healCode(originalCode, issues, context, aiGenerator) {
+    const healingConfig = this._getHealingPrompt();
+    
+    const systemPrompt = healingConfig.system;
+    const userPrompt = healingConfig.user({
+      originalCode,
+      issues,
+      scenario: context.scenario,
+      format: this.outputFormat,
+      language: this.language
+    });
+    
+    this.log(`🏥 Sending healing prompt to AI...`);
+    
+    // Call AI generator for healing
+    const healedCode = await aiGenerator.generate(systemPrompt, userPrompt);
+    
+    return healedCode.trim();
+  }
+
+  /**
+   * Get generation prompt for current format
+   */
+  _getGenerationPrompt() {
+    switch(this.outputFormat) {
+      case 'playwright':
+        return generationPrompts.playwrightScenario;
+      case 'jest':
+        return generationPrompts.jestScenario;
+      case 'postman':
+        return generationPrompts.postmanTestScript;
+      default:
+        throw new Error(`Unknown output format: ${this.outputFormat}`);
+    }
+  }
+
+  /**
+   * Get healing prompt for current format
+   */
+  _getHealingPrompt() {
+    switch(this.outputFormat) {
+      case 'playwright':
+        return healingPrompts.playwrightHealing;
+      case 'jest':
+        return healingPrompts.jestHealing;
+      default:
+        return healingPrompts.genericHealing;
+    }
+  }
+
+  /**
+   * Log helper
+   */
+  log(message) {
+    if (this.verbose) {
+      console.log(message);
+    }
+  }
+
+  /**
+   * Generate full test file (with imports and structure)
+   */
+  generateTestFile(testBodies, testPlan, options = {}) {
+    const { format, language, sessionId } = options;
+    
+    switch(format) {
+      case 'playwright':
+        return this._generatePlaywrightFile(testBodies, testPlan, language, sessionId);
+      case 'jest':
+        return this._generateJestFile(testBodies, testPlan, language, sessionId);
+      default:
+        throw new Error(`Unknown format: ${format}`);
+    }
+  }
+
+  /**
+   * Generate complete Playwright test file
+   */
+  _generatePlaywrightFile(testBodies, testPlan, language, sessionId) {
+    const isTS = language === 'typescript';
+    const imports = isTS 
+      ? `import { test, expect } from '@playwright/test';`
+      : `const { test, expect } = require('@playwright/test');`;
+
+    const testCases = testPlan.sections.flatMap((section, sectionIndex) => 
+      section.scenarios.map((scenario, scenarioIndex) => {
+        const testBody = testBodies[`${sectionIndex}-${scenarioIndex}`];
+        return `
+  test('${scenario.title}', async ({ request }) => {
+${testBody}
+  });`;
+      }).join('\n')
+    );
+
+    return `// Generated API Tests for: ${testPlan.title}
+// Generated by Democratize Quality MCP Server (AI-Generated)
+// Session ID: ${sessionId}
+// Language: ${language}
+
+${imports}
+
+test.describe('${testPlan.title} - API Tests', () => {
+  const baseUrl = '${testPlan.baseUrl}';
+${testCases}
+});`;
+  }
+
+  /**
+   * Generate complete Jest test file
+   */
+  _generateJestFile(testBodies, testPlan, language, sessionId) {
+    const isTS = language === 'typescript';
+    const imports = isTS
+      ? `import axios from 'axios';\nimport { ApiTestUtils } from './test-utils';`
+      : `const axios = require('axios');\nconst { ApiTestUtils } = require('./test-utils');`;
+    
+    const typeAnnotation = isTS ? ': ApiTestUtils' : '';
+
+    const testCases = testPlan.sections.flatMap((section, sectionIndex) => 
+      section.scenarios.map((scenario, scenarioIndex) => {
+        const testBody = testBodies[`${sectionIndex}-${scenarioIndex}`];
+        return `
+    test('${scenario.title}', async () => {
+${testBody}
+    });`;
+      }).join('\n')
+    );
+
+    return `// Generated Jest API Tests for: ${testPlan.title}
+// Generated by Democratize Quality MCP Server (AI-Generated)
+// Session ID: ${sessionId}
+// Language: ${language}
+
+${imports}
+
+describe('${testPlan.title} API Tests', () => {
+  let apiUtils${typeAnnotation};
+  const baseUrl = '${testPlan.baseUrl}';
+
+  beforeAll(async () => {
+    apiUtils = new ApiTestUtils(baseUrl);
+    console.log('Test suite initialized');
+  });
+
+  afterAll(async () => {
+    await apiUtils.cleanup();
+    console.log('Test suite completed');
+  });
+
+  describe('Test Scenarios', () => {${testCases}
+  });
+});`;
+  }
+
+  /**
+   * Validate that AI generated ONLY the requested file
+   * Some helpful models try to create READMEs, summaries, etc.
+   * This is a safety net in case prompts are ignored.
+   * 
+   * @param {string} generatedCode - The generated code from AI
+   * @param {string} targetFileName - The expected file name
+   * @returns {string} - Filtered code with only the test file
+   */
+  _validateSingleFileOutput(generatedCode, targetFileName) {
+    // Check for multiple file indicators
+    const multiFilePatterns = [
+      /(?:create|generate|add)\s+(?:a\s+)?(?:README|SUMMARY|GUIDE|NOTES)/i,
+      /(?:also|additionally),?\s+(?:create|generate|write)/i,
+      /^#+\s+(?:README|SUMMARY|Quick Reference|Guide)/m,
+      /File:\s+[A-Z_-]+\.md/i,
+      /```[a-z]*\s*\n#+\s+(?:README|Summary)/i,
+      /\*\*File:\*\*\s+(?:README|SUMMARY|GUIDE)/i
+    ];
+
+    for (const pattern of multiFilePatterns) {
+      if (pattern.test(generatedCode)) {
+        this.log(`⚠️  Warning: AI attempted to create additional files - filtering...`);
+        // Extract just the test code, ignore suggestions
+        return this._extractTestCodeOnly(generatedCode);
+      }
+    }
+
+    return generatedCode;
+  }
+
+  /**
+   * Extract only the actual test code from AI output
+   * Remove any file creation suggestions or documentation
+   * 
+   * @param {string} output - The full AI output
+   * @returns {string} - Extracted test code only
+   */
+  _extractTestCodeOnly(output) {
+    // Look for code fence or actual code
+    const codeFenceMatch = output.match(/```(?:typescript|javascript|ts|js)?\n([\s\S]+?)```/);
+    if (codeFenceMatch) {
+      this.log(`✅ Extracted test code from code fence`);
+      return codeFenceMatch[1];
+    }
+    
+    // Try to find the test code by looking for test.describe or describe
+    const testDescribeMatch = output.match(/((?:test\.)?describe\(['"`][\s\S]+?\n\}\);)/);
+    if (testDescribeMatch) {
+      this.log(`✅ Extracted test code by pattern matching`);
+      return testDescribeMatch[1];
+    }
+    
+    // If no extraction possible, return as-is but warn
+    this.log(`⚠️  Could not extract test code - returning full output`);
+    return output;
+  }
+}
+
+module.exports = PromptOrchestrator;