@democratize-quality/mcp-server 1.1.9 → 1.2.0

package/src/tools/api/prompts/validation-rules.js

@@ -1,339 +0,0 @@
-/**
- * Validation Rules for Generated Test Code
- * 
- * These rules validate generated test code before writing to files.
- * Catches common issues and triggers healing if needed.
- */
-
-module.exports = {
-  /**
-   * Validate Playwright test code
-   */
-  playwright: {
-    /**
-     * Check if code has required imports
-     */
-    hasRequiredImports: (code, language) => {
-      if (language === 'typescript') {
-        return code.includes('import { test, expect }') || code.includes("import { test, expect }");
-      }
-      return code.includes('require(') || !code.includes('import');
-    },
-
-    /**
-     * Check if code uses proper async/await
-     */
-    hasProperAsync: (code) => {
-      if (code.includes('request.')) {
-        return code.includes('await request.');
-      }
-      return true;
-    },
-
-    /**
-     * Check if code has proper URL construction
-     */
-    hasProperUrlConstruction: (code) => {
-      // Should use template literals with ${baseUrl}, not string concatenation
-      const hasTemplateUrl = code.includes('`${baseUrl}') || code.includes("'http");
-      const hasWrongUrl = code.includes("'${baseUrl}"); // This is the escaping bug!
-      
-      return hasTemplateUrl && !hasWrongUrl;
-    },
-
-    /**
-     * Check if code has assertions
-     */
-    hasAssertions: (code) => {
-      return code.includes('expect(') && code.includes('.toBe(');
-    },
-
-    /**
-     * Check for common syntax errors
-     */
-    noSyntaxErrors: (code) => {
-      // Basic checks - full validation would require parsing
-      const balancedBraces = (code.match(/\{/g) || []).length === (code.match(/\}/g) || []).length;
-      const balancedParens = (code.match(/\(/g) || []).length === (code.match(/\)/g) || []).length;
-      const balancedBrackets = (code.match(/\[/g) || []).length === (code.match(/\]/g) || []).length;
-      
-      return balancedBraces && balancedParens && balancedBrackets;
-    },
-
-    /**
-     * Check if GraphQL request is properly structured
-     */
-    hasGraphQLRequestStructure: (code) => {
-      // If code contains GraphQL query, check structure
-      if (code.includes('query:') || code.includes('mutation:') || code.includes('subscription:')) {
-        const hasQueryField = code.includes('query:') || code.includes('mutation:');
-        const hasDataObject = code.includes('data: {') && hasQueryField;
-        return hasQueryField && hasDataObject;
-      }
-      return true; // Not GraphQL, skip
-    },
-
-    /**
-     * Check if GraphQL response validation is present
-     */
-    hasGraphQLResponseValidation: (code) => {
-      // If it's a GraphQL test, must validate data or errors
-      if (code.includes('query:') || code.includes('mutation:')) {
-        const hasDataCheck = code.includes('.toHaveProperty(\'data\')');
-        const hasErrorsCheck = code.includes('.toHaveProperty(\'errors\')');
-        return hasDataCheck || hasErrorsCheck;
-      }
-      return true; // Not GraphQL
-    },
-
-    /**
-     * Run all validations
-     */
-    validateAll: (code, language, isGraphQL) => {
-      const issues = [];
-      
-      // Note: We're validating generated TEST BODY code, not full files
-      // So we don't check for imports in the body
-      
-      if (!module.exports.playwright.hasProperAsync(code)) {
-        issues.push({
-          severity: 'error',
-          message: 'Missing await keyword for async API calls',
-          fix: 'Add await before request.* calls'
-        });
-      }
-      
-      if (!module.exports.playwright.hasProperUrlConstruction(code)) {
-        issues.push({
-          severity: 'critical',
-          message: 'Incorrect URL construction - template literal escaping issue',
-          fix: 'Use backticks for template literals: `${baseUrl}/endpoint` not \'${baseUrl}/endpoint\''
-        });
-      }
-      
-      if (!module.exports.playwright.hasAssertions(code)) {
-        issues.push({
-          severity: 'warning',
-          message: 'No assertions found in test',
-          fix: 'Add expect() assertions to validate response'
-        });
-      }
-      
-      if (!module.exports.playwright.noSyntaxErrors(code)) {
-        issues.push({
-          severity: 'error',
-          message: 'Possible syntax error - unbalanced brackets/braces/parens',
-          fix: 'Check code for balanced brackets, braces, and parentheses'
-        });
-      }
-      
-      // NEW: GraphQL-specific validations
-      if (isGraphQL) {
-        if (!module.exports.playwright.hasGraphQLRequestStructure(code)) {
-          issues.push({
-            severity: 'error',
-            message: 'GraphQL request structure incorrect',
-            fix: 'Use: data: { query: "...", variables: {...} }'
-          });
-        }
-        
-        if (!module.exports.playwright.hasGraphQLResponseValidation(code)) {
-          issues.push({
-            severity: 'warning',
-            message: 'Missing GraphQL response validation',
-            fix: 'Add: expect(responseData).toHaveProperty(\'data\') or .toHaveProperty(\'errors\')'
-          });
-        }
-      }
-      
-      return {
-        valid: issues.filter(i => i.severity === 'error' || i.severity === 'critical').length === 0,
-        issues: issues
-      };
-    }
-  },
-
-  /**
-   * Validate Jest test code
-   */
-  jest: {
-    /**
-     * Check if code uses API utils correctly
-     */
-    hasProperApiCall: (code) => {
-      return code.includes('apiUtils.makeRequest') && code.includes('await');
-    },
-
-    /**
-     * Check if code has assertions
-     */
-    hasAssertions: (code) => {
-      return code.includes('expect(');
-    },
-
-    /**
-     * Check for common syntax errors
-     */
-    noSyntaxErrors: (code) => {
-      const balancedBraces = (code.match(/\{/g) || []).length === (code.match(/\}/g) || []).length;
-      const balancedParens = (code.match(/\(/g) || []).length === (code.match(/\)/g) || []).length;
-      const balancedBrackets = (code.match(/\[/g) || []).length === (code.match(/\]/g) || []).length;
-      
-      return balancedBraces && balancedParens && balancedBrackets;
-    },
-
-    /**
-     * Check if GraphQL request is properly structured (Jest/axios style)
-     */
-    hasGraphQLRequestStructure: (code) => {
-      if (code.includes('query:') || code.includes('mutation:') || code.includes('subscription:')) {
-        const hasQueryField = code.includes('query:') || code.includes('mutation:');
-        const hasDataObject = code.includes('data: {') && hasQueryField;
-        return hasQueryField && hasDataObject;
-      }
-      return true;
-    },
-
-    /**
-     * Check if GraphQL response validation is present (Jest style)
-     */
-    hasGraphQLResponseValidation: (code) => {
-      if (code.includes('query:') || code.includes('mutation:')) {
-        const hasDataCheck = code.includes('.toHaveProperty(\'data\')');
-        const hasErrorsCheck = code.includes('.toHaveProperty(\'errors\')');
-        return hasDataCheck || hasErrorsCheck;
-      }
-      return true;
-    },
-
-    /**
-     * Run all validations
-     */
-    validateAll: (code, language, isGraphQL) => {
-      const issues = [];
-      
-      if (!module.exports.jest.hasProperApiCall(code)) {
-        issues.push({
-          severity: 'error',
-          message: 'Missing or incorrect API call using apiUtils.makeRequest',
-          fix: 'Use await apiUtils.makeRequest({ method, url, ... })'
-        });
-      }
-      
-      if (!module.exports.jest.hasAssertions(code)) {
-        issues.push({
-          severity: 'warning',
-          message: 'No assertions found in test',
-          fix: 'Add expect() assertions to validate response'
-        });
-      }
-      
-      if (!module.exports.jest.noSyntaxErrors(code)) {
-        issues.push({
-          severity: 'error',
-          message: 'Possible syntax error - unbalanced brackets/braces/parens',
-          fix: 'Check code for balanced brackets, braces, and parentheses'
-        });
-      }
-      
-      // NEW: GraphQL-specific validations for Jest
-      if (isGraphQL) {
-        if (!module.exports.jest.hasGraphQLRequestStructure(code)) {
-          issues.push({
-            severity: 'error',
-            message: 'GraphQL request structure incorrect',
-            fix: 'Use: data: { query: "...", variables: {...} } in makeRequest()'
-          });
-        }
-        
-        if (!module.exports.jest.hasGraphQLResponseValidation(code)) {
-          issues.push({
-            severity: 'warning',
-            message: 'Missing GraphQL response validation',
-            fix: 'Add: expect(response.data).toHaveProperty(\'data\') or .toHaveProperty(\'errors\')'
-          });
-        }
-      }
-      
-      return {
-        valid: issues.filter(i => i.severity === 'error' || i.severity === 'critical').length === 0,
-        issues: issues
-      };
-    }
-  },
-
-  /**
-   * Validate Postman collection structure
-   */
-  postman: {
-    /**
-     * Validate collection has required fields
-     */
-    hasRequiredFields: (collection) => {
-      return collection.info && 
-             collection.info.name && 
-             collection.info.schema &&
-             Array.isArray(collection.item);
-    },
-
-    /**
-     * Validate request structure
-     */
-    hasValidRequests: (collection) => {
-      if (!collection.item || collection.item.length === 0) return false;
-      
-      // Check first item as sample
-      const firstItem = collection.item[0];
-      if (firstItem.item && Array.isArray(firstItem.item)) {
-        // It's a folder, check its items
-        return firstItem.item.every(req => req.name && req.request);
-      }
-      
-      return firstItem.name && firstItem.request;
-    },
-
-    /**
-     * Run all validations
-     */
-    validateAll: (collection) => {
-      const issues = [];
-      
-      if (!module.exports.postman.hasRequiredFields(collection)) {
-        issues.push({
-          severity: 'error',
-          message: 'Missing required collection fields (info, name, schema, item)',
-          fix: 'Ensure collection has proper Postman v2.1 structure'
-        });
-      }
-      
-      if (!module.exports.postman.hasValidRequests(collection)) {
-        issues.push({
-          severity: 'error',
-          message: 'Invalid request structure in collection',
-          fix: 'Ensure each request has name and request object'
-        });
-      }
-      
-      return {
-        valid: issues.filter(i => i.severity === 'error' || i.severity === 'critical').length === 0,
-        issues: issues
-      };
-    }
-  },
-
-  /**
-   * Get validator for output format
-   */
-  getValidator: (format) => {
-    switch(format) {
-      case 'playwright':
-        return module.exports.playwright;
-      case 'jest':
-        return module.exports.jest;
-      case 'postman':
-        return module.exports.postman;
-      default:
-        throw new Error(`Unknown format: ${format}`);
-    }
-  }
-};

package/src/tools/base/ToolBase.js

@@ -1,230 +0,0 @@
-/**
- * Base class for all MCP tools
- * Provides common functionality and enforces a consistent interface
- */
-class ToolBase {
-    constructor() {
-        if (this.constructor === ToolBase) {
-            throw new Error("ToolBase is an abstract class and cannot be instantiated directly");
-        }
-        
-        // Validate that required static properties are defined
-        if (!this.constructor.definition) {
-            throw new Error(`Tool ${this.constructor.name} must define a static 'definition' property`);
-        }
-        
-        this.validateDefinition(this.constructor.definition);
-        
-        // Initialize configuration
-        this.config = require('../../config');
-        this.toolConfig = this._getToolConfig();
-    }
-
-    /**
-     * Get tool-specific configuration
-     * @returns {object} - Tool configuration
-     */
-    _getToolConfig() {
-        const toolName = this.constructor.definition.name;
-        const category = this._getToolCategory(toolName);
-        
-        // Get configuration in order of precedence:
-        // 1. Tool-specific config
-        // 2. Category config
-        // 3. Default config
-        return {
-            ...this.config.getToolConfig('default', {}),
-            ...this.config.getToolConfig(category, {}),
-            ...this.config.getToolConfig(category, toolName)
-        };
-    }
-
-    /**
-     * Get tool category from tool name
-     * @param {string} toolName - The tool name
-     * @returns {string} - The tool category
-     */
-    _getToolCategory(toolName) {
-        if (toolName.startsWith('browser_')) return 'browser';
-        if (toolName.startsWith('file_')) return 'file';
-        if (toolName.startsWith('network_')) return 'network';
-        return 'other';
-    }
-
-    /**
-     * Get a configuration value for this tool
-     * @param {string} key - Configuration key
-     * @param {any} defaultValue - Default value
-     * @returns {any} - Configuration value
-     */
-    getConfig(key, defaultValue = undefined) {
-        return this.toolConfig[key] !== undefined ? this.toolConfig[key] : defaultValue;
-    }
-
-    /**
-     * Validates the tool definition schema
-     * @param {object} definition - The tool definition object
-     */
-    validateDefinition(definition) {
-        const required = ['name', 'description', 'input_schema'];
-        for (const field of required) {
-            if (!definition[field]) {
-                throw new Error(`Tool definition missing required field: ${field}`);
-            }
-        }
-        
-        if (!definition.input_schema.type || definition.input_schema.type !== 'object') {
-            throw new Error("Tool input_schema must be of type 'object'");
-        }
-    }
-
-    /**
-     * Validates input parameters against the tool's schema
-     * @param {object} parameters - The input parameters to validate
-     */
-    validateParameters(parameters) {
-        const schema = this.constructor.definition.input_schema;
-        
-        // Check required parameters
-        if (schema.required) {
-            for (const required of schema.required) {
-                if (parameters[required] === undefined || parameters[required] === null) {
-                    throw new Error(`Missing required parameter: ${required}`);
-                }
-            }
-        }
-        
-        // Basic type checking for defined properties
-        if (schema.properties) {
-            for (const [key, value] of Object.entries(parameters)) {
-                if (schema.properties[key]) {
-                    const expectedType = schema.properties[key].type;
-                    const actualType = typeof value;
-                    
-                    if (expectedType === 'string' && actualType !== 'string') {
-                        throw new Error(`Parameter '${key}' must be a string, got ${actualType}`);
-                    }
-                    if (expectedType === 'number' && actualType !== 'number') {
-                        throw new Error(`Parameter '${key}' must be a number, got ${actualType}`);
-                    }
-                    if (expectedType === 'boolean' && actualType !== 'boolean') {
-                        throw new Error(`Parameter '${key}' must be a boolean, got ${actualType}`);
-                    }
-                    if (expectedType === 'object' && (actualType !== 'object' || Array.isArray(value))) {
-                        throw new Error(`Parameter '${key}' must be an object, got ${actualType}`);
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * Executes the tool with the given parameters
-     * This method must be implemented by subclasses
-     * @param {object} parameters - The input parameters
-     * @returns {Promise<any>} - The tool execution result
-     */
-    async execute(parameters) {
-        throw new Error("execute() method must be implemented by subclasses");
-    }
-
-    /**
-     * Wrapper method that handles validation, execution, and error handling
-     * @param {object} parameters - The input parameters
-     * @returns {Promise<object>} - Formatted MCP response
-     */
-    async run(parameters = {}) {
-        const toolName = this.constructor.definition.name;
-        const enableDebug = this.config.isFeatureEnabled('enableDebugMode');
-        
-        try {
-            if (enableDebug) {
-                console.error(`[Tool:${toolName}] Executing with parameters:`, JSON.stringify(parameters));
-            }
-            
-            // Validate input parameters if validation is enabled
-            if (this.getConfig('enableInputValidation', true)) {
-                this.validateParameters(parameters);
-            }
-            
-            // Execute the tool with timeout if configured
-            const timeout = this.getConfig('timeout', 30000);
-            const result = await this._executeWithTimeout(parameters, timeout);
-            
-            if (enableDebug) {
-                console.error(`[Tool:${toolName}] Execution successful`);
-            }
-            
-            // Return formatted MCP response
-            return {
-                content: [{
-                    type: "text",
-                    text: JSON.stringify(result)
-                }]
-            };
-            
-        } catch (error) {
-            const enableDetailedErrors = this.getConfig('enableDetailedErrors', true);
-            
-            if (enableDetailedErrors || enableDebug) {
-                console.error(`[Tool:${toolName}] Error during execution:`, error.message);
-            }
-            
-            // Throw properly formatted MCP error
-            throw {
-                code: -32000,
-                message: `Tool '${toolName}' execution failed: ${error.message}`,
-                data: enableDetailedErrors ? {
-                    tool_name: toolName,
-                    parameters: parameters,
-                    original_error: error.message,
-                    config: this.toolConfig
-                } : {
-                    tool_name: toolName,
-                    original_error: error.message
-                }
-            };
-        }
-    }
-
-    /**
-     * Execute the tool with a timeout
-     * @param {object} parameters - The input parameters
-     * @param {number} timeout - Timeout in milliseconds
-     * @returns {Promise<any>} - Execution result
-     */
-    async _executeWithTimeout(parameters, timeout) {
-        return new Promise(async (resolve, reject) => {
-            const timeoutId = setTimeout(() => {
-                reject(new Error(`Tool execution timed out after ${timeout}ms`));
-            }, timeout);
-            
-            try {
-                const result = await this.execute(parameters);
-                clearTimeout(timeoutId);
-                resolve(result);
-            } catch (error) {
-                clearTimeout(timeoutId);
-                reject(error);
-            }
-        });
-    }
-
-    /**
-     * Gets the tool definition
-     * @returns {object} - The tool definition
-     */
-    static getDefinition() {
-        return this.definition;
-    }
-
-    /**
-     * Gets the tool name from the definition
-     * @returns {string} - The tool name
-     */
-    static getName() {
-        return this.definition.name;
-    }
-}
-
-module.exports = ToolBase;