Automation Script Generator MCP Server

Instructions

Implementation Reference

• index.js:330-335 (registration)

  Registers all tools including process_test_scenario by returning the toolConfigs array in ListTools handler

  this.server.setRequestHandler(ListToolsRequestSchema, async () => {
      return {
          tools: toolConfigs,
      };
  });

• index.js:336-374 (registration)

  Registers the call handler for tools with switch case dispatching to processTestScenario for 'process_test_scenario'

      this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
          const { name, arguments: args } = request.params;
  
          try {
              // Validate arguments against schema
              this.validateArgs(name, args || {});
  
              switch (name) {
                  case 'process_test_scenario':
                      return await this.processTestScenario(args);
                  case 'analyze_repository_patterns':
                      return await this.analyzeRepositoryPatterns(args);
                  case 'generate_feature_file':
                      return await this.generateFeatureFile(args);
                  case 'generate_steps_file':
                      return await this.generateStepsFile(args);
                  case 'generate_page_file':
                      return await this.generatePageFile(args);
                  case 'generate_component_file':
                      return await this.generateComponentFile(args);
                  case 'review_and_enhance_code':
                      return await this.reviewAndEnhanceCode(args);
                  default:
                      throw new McpError(
                          ErrorCode.MethodNotFound,
                          `Unknown tool: ${name}`
                      );
              }
          } catch (error) {
              if (error instanceof McpError) {
                  throw error;
              }
              throw new McpError(
                  ErrorCode.InternalError,
                  `Error executing tool ${name}: ${error.message}`
              );
          }
      });
  }

• index.js:108-150 (schema)

  Input schema definition for process_test_scenario tool

  {
      name: 'process_test_scenario',
      description: 'Process a test scenario provided directly by the user and generate complete WDIO test files',
      inputSchema: {
          type: 'object',
          properties: {
              scenario_title: {
                  type: 'string',
                  description: 'Title of the test scenario',
                  minLength: 1,
              },
              tags: {
                  type: 'array',
                  items: { type: 'string' },
                  description: 'Test ID tags for the scenario (e.g., ["@login", "@smoke", "@TEST-001"])',
              },
              gherkin_syntax: {
                  type: 'string',
                  description: 'Complete Gherkin syntax with Given/When/Then steps',
                  minLength: 1,
              },
              selectors: {
                  type: 'object',
                  description: 'UI element selectors as key-value pairs (e.g., {"usernameInput": "#username", "loginButton": "[data-testid=login-btn]"})',
              },
              data_items: {
                  type: 'object',
                  description: 'Test data items and configurations (optional)',
              },
              output_directory: {
                  type: 'string',
                  description: 'Base directory where all generated files should be saved',
                  minLength: 1,
              },
              repo_path: {
                  type: 'string',
                  description: 'Path to existing repository for pattern analysis (optional)',
              },
          },
          required: ['scenario_title', 'gherkin_syntax', 'selectors', 'output_directory'],
          additionalProperties: false,
      },
  },

• index.js:376-453 (handler)

  Primary handler function for process_test_scenario tool. Validates input, performs repo analysis if provided, determines intelligent create/update strategy for files, generates/updates WDIO test files (feature, steps, page, data), applies code review and enhancements.

  async processTestScenario(args) {
      const {
          scenario_title,
          tags = [],
          gherkin_syntax,
          selectors,
          data_items = null,
          output_directory,
          repo_path
      } = args;
  
      try {
          const results = {
              scenario_title,
              tags,
              files_generated: [],
              files_updated: [],
              analysis: null,
              decisions: []
          };
  
          // Step 1: Analyze repository patterns if repo_path provided
          if (repo_path) {
              console.error(`Analyzing repository patterns at: ${repo_path}`);
              const analysisResult = await this.analyzeRepositoryPatterns({
                  repo_path,
                  pattern_types: ['features', 'steps', 'pages', 'components']
              });
              results.analysis = analysisResult.content[0].text;
          }
  
          // Step 2: Analyze existing files and determine strategy
          const fileStrategy = await this.analyzeExistingFiles(
              output_directory,
              scenario_title,
              gherkin_syntax,
              selectors,
              repo_path
          );
          results.decisions = fileStrategy.decisions;
  
          // Step 3: Process files based on strategy
          await this.executeFileStrategy(fileStrategy, {
              scenario_title,
              tags,
              gherkin_syntax,
              selectors,
              data_items,
              output_directory,
              repo_path
          });
  
          results.files_generated = fileStrategy.filesToCreate;
          results.files_updated = fileStrategy.filesToUpdate;
  
          // Step 4: Review and enhance all processed files
          console.error('Reviewing and enhancing generated/updated code...');
          const allFiles = [...results.files_generated, ...results.files_updated];
          if (allFiles.length > 0) {
              await this.reviewAndEnhanceCode({
                  file_paths: allFiles,
                  review_criteria: ['docs', 'pom', 'functions', 'utils', 'format', 'existing_steps'],
                  repo_path
              });
          }
  
          return {
              content: [
                  {
                      type: 'text',
                      text: this.formatProcessingResults(results),
                  },
              ],
          };
      } catch (error) {
          throw new Error(`Failed to process test scenario: ${error.message}`);
      }
  }

• index.js:458-540 (helper)

  Helper that implements smart analysis to decide create new files or update existing based on content similarity (features >60%, selectors overlap, step reuse >80%)

  async analyzeExistingFiles(output_directory, scenario_title, gherkin_syntax, selectors, repo_path) {
      const strategy = {
          decisions: [],
          filesToCreate: [],
          filesToUpdate: [],
          similarFeatures: [],
          matchingPages: [],
          existingSteps: []
      };
  
      try {
          // Check if output directory exists
          const dirExists = await fs.pathExists(output_directory);
          if (!dirExists) {
              strategy.decisions.push('Output directory does not exist - will create new files');
              return this.createNewFilesStrategy(output_directory, scenario_title);
          }
  
          // Analyze existing feature files
          const existingFeatures = await this.findSimilarFeatures(output_directory, scenario_title, gherkin_syntax);
          strategy.similarFeatures = existingFeatures;
  
          // Analyze existing page objects
          const matchingPages = await this.findMatchingPageObjects(output_directory, selectors);
          strategy.matchingPages = matchingPages;
  
          // Analyze existing step definitions
          const existingSteps = await this.findReusableSteps(output_directory, gherkin_syntax, repo_path);
          strategy.existingSteps = existingSteps;
  
          // Determine strategy based on analysis
          if (existingFeatures.length > 0) {
              // Similar feature found - update existing
              strategy.decisions.push(`Found similar feature: ${existingFeatures[0].file} - will add new scenario`);
              strategy.filesToUpdate.push(existingFeatures[0].path);
  
              // Check if we need to update corresponding steps file
              const stepsFile = existingFeatures[0].path.replace(/\.feature$/, '.steps.js').replace('/features/', '/step-definitions/');
              if (await fs.pathExists(stepsFile)) {
                  strategy.filesToUpdate.push(stepsFile);
                  strategy.decisions.push(`Will update corresponding steps file: ${path.basename(stepsFile)}`);
              }
          } else {
              // No similar feature - create new feature file
              const featureFileName = this.generateFileName(scenario_title, 'feature');
              const featurePath = path.join(output_directory, 'features', featureFileName);
              strategy.filesToCreate.push(featurePath);
              strategy.decisions.push('No similar feature found - will create new feature file');
          }
  
          // Handle page objects
          if (matchingPages.length > 0) {
              // Update existing page object with new selectors
              strategy.filesToUpdate.push(matchingPages[0].path);
              strategy.decisions.push(`Found matching page object: ${matchingPages[0].file} - will add new selectors`);
          } else {
              // Create new page object
              const pageFileName = this.generateFileName(scenario_title, 'page');
              const pagePath = path.join(output_directory, 'pageobjects', pageFileName);
              strategy.filesToCreate.push(pagePath);
              strategy.decisions.push('No matching page object found - will create new page file');
          }
  
          // Handle step definitions
          if (strategy.filesToUpdate.some(f => f.includes('.steps.js'))) {
              // Already updating steps file with feature
              strategy.decisions.push('Step definitions will be updated with feature scenarios');
          } else {
              // Create new steps file
              const stepsFileName = this.generateFileName(scenario_title, 'steps');
              const stepsPath = path.join(output_directory, 'step-definitions', stepsFileName);
              strategy.filesToCreate.push(stepsPath);
              strategy.decisions.push('Will create new step definitions file');
          }
  
          return strategy;
  
      } catch (error) {
          console.warn(`Error analyzing existing files: ${error.message}`);
          strategy.decisions.push('Analysis failed - defaulting to create new files');
          return this.createNewFilesStrategy(output_directory, scenario_title);
      }
  }