@democratize-quality/mcp-server 1.2.0 → 1.2.1

package/src/config/tools/api.js

@@ -0,0 +1,86 @@
+/**
+ * Copyright (C) 2025 Democratize Quality
+ *
+ * This file is part of Democratize Quality MCP Server.
+ *
+ * Democratize Quality MCP Server is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Democratize Quality MCP Server is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Democratize Quality MCP Server. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * API Tools Configuration
+ * Configuration specific to API testing tools
+ */
+module.exports = {
+    // API Request Tool
+    api_request: {
+        // Session management
+        maxSessions: 50,
+        sessionTimeout: 600000, // 10 minutes
+        enableSessionPersistence: true,
+        
+        // Request settings
+        defaultTimeout: 30000,
+        maxRetries: 3,
+        retryDelay: 1000,
+        enableRedirects: true,
+        maxRedirects: 5,
+        
+        // Validation settings
+        enableResponseValidation: true,
+        enableBodyValidation: true,
+        strictContentTypeCheck: true,
+        
+        // Logging settings
+        enableRequestLogging: true,
+        enableResponseLogging: true,
+        logLevel: 'info',
+        
+        // Rate limiting
+        rateLimitEnabled: false,
+        maxRequestsPerSecond: 10
+    },
+    
+    // API Session Status Tool
+    api_session_status: {
+        enableRealTimeUpdates: true,
+        maxHistoryEntries: 1000,
+        includeDetailedLogs: true,
+        enableSessionMetrics: true
+    },
+    
+    // API Session Report Tool
+    api_session_report: {
+        defaultTheme: 'light',
+        includeRequestData: true,
+        includeResponseData: true,
+        includeTiming: true,
+        includeValidationResults: true,
+        
+        // Report generation settings
+        maxReportSize: 10485760, // 10MB
+        enableCompression: true,
+        compressionLevel: 6,
+        
+        // HTML report settings
+        enableInteractiveReports: true,
+        includeCharts: true,
+        enableSyntaxHighlighting: true,
+        
+        // Output settings
+        defaultOutputDir: process.env.API_REPORTS_DIR || 'output/reports',
+        enableTimestampInFilename: true,
+        enableAutoCleanup: true,
+        maxReportsToKeep: 100
+    }
+};

package/src/config/tools/browser.js

@@ -0,0 +1,109 @@
+/**
+ * Copyright (C) 2025 Democratize Quality
+ *
+ * This file is part of Democratize Quality MCP Server.
+ *
+ * Democratize Quality MCP Server is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Democratize Quality MCP Server is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Democratize Quality MCP Server. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Browser tool-specific configuration
+ * Settings for all browser automation tools
+ */
+module.exports = {
+    // Browser launch settings
+    browser_launch: {
+        defaultHeadless: true,
+        defaultPort: null, // Let chrome-launcher choose
+        maxInstances: 10,
+        launchTimeout: 30000,
+        chromeFlags: [
+            '--disable-gpu',
+            '--disable-setuid-sandbox',
+            '--no-sandbox',
+            '--disable-dev-shm-usage', // Prevent crashes in containerized environments
+            '--disable-background-timer-throttling',
+            '--disable-backgrounding-occluded-windows',
+            '--disable-renderer-backgrounding'
+        ],
+        userDataDirPrefix: 'browser-session-',
+        cleanupOnExit: true
+    },
+    
+    // Navigation settings
+    browser_navigate: {
+        pageLoadTimeout: 30000,
+        allowedProtocols: ['http:', 'https:'],
+        maxRedirects: 5,
+        waitForNetworkIdle: true,
+        networkIdleTimeout: 2000
+    },
+    
+    // Screenshot settings
+    browser_screenshot: {
+        defaultQuality: 80,
+        defaultFormat: 'png',
+        maxFileSize: '10MB',
+        allowedFormats: ['png', 'jpeg', 'webp'],
+        outputDirectory: require('path').resolve(__dirname, '../../../output'),
+        enableTimestamps: true,
+        compressionLevel: 6
+    },
+    
+    // DOM interaction settings
+    browser_dom: {
+        defaultWaitTimeout: 5000,
+        elementVisibilityTimeout: 3000,
+        scrollIntoView: true,
+        highlightElements: false, // Useful for debugging
+        enableRetries: true,
+        maxRetryAttempts: 3,
+        retryDelay: 500
+    },
+    
+    // Click settings
+    browser_click: {
+        waitForElement: true,
+        scrollIntoView: true,
+        doubleClickDelay: 100,
+        enableCoordinateValidation: true,
+        clickOffset: { x: 0, y: 0 } // Offset from element center
+    },
+    
+    // Type settings
+    browser_type: {
+        typingDelay: 10, // Milliseconds between keystrokes
+        clearBeforeType: true,
+        waitForFocus: true,
+        enableNaturalTyping: true, // Simulate human-like typing
+        maxTextLength: 10000
+    },
+    
+    // Close settings
+    browser_close: {
+        gracefulShutdown: true,
+        shutdownTimeout: 5000,
+        forceKillOnTimeout: true,
+        cleanupUserData: false // Keep user data by default
+    },
+    
+    // Global browser settings
+    global: {
+        maxConcurrentOperations: 5,
+        enableScreenshotOnError: false,
+        autoRecovery: true,
+        healthCheckInterval: 60000, // 1 minute
+        enablePerformanceMetrics: false
+    }
+};

package/src/config/tools/default.js

@@ -0,0 +1,51 @@
+/**
+ * Copyright (C) 2025 Democratize Quality
+ *
+ * This file is part of Democratize Quality MCP Server.
+ *
+ * Democratize Quality MCP Server is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Democratize Quality MCP Server is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Democratize Quality MCP Server. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Default tool configuration
+ * These settings apply to all tools unless overridden by specific tool configs
+ */
+module.exports = {
+    // Common tool settings
+    timeout: 30000,
+    retryAttempts: 3,
+    retryDelay: 1000,
+    
+    // Validation settings
+    enableInputValidation: true,
+    enableOutputValidation: false,
+    strictMode: true,
+    
+    // Performance settings
+    enableCaching: false,
+    maxCacheSize: 100,
+    cacheTimeout: 300000, // 5 minutes
+    
+    // Error handling
+    enableDetailedErrors: process.env.NODE_ENV !== 'production',
+    logErrors: true,
+    throwOnValidationError: true,
+    
+    // Rate limiting (per tool)
+    rateLimit: {
+        enabled: false,
+        maxRequests: 100,
+        windowMs: 60000 // 1 minute
+    }
+};

package/src/docs/Agent_README.md

@@ -0,0 +1,310 @@
+# � API Testing Skills - User Guide
+
+Welcome to the **Democratize Quality API Testing Skills**! These powerful AI skills help you plan, generate, and heal API tests automatically, working across multiple AI coding tools (GitHub Copilot, Codex CLI, Claude Code, Cursor, and more).
+
+## 🎯 Overview
+
+The API Testing Skills provide a complete workflow for API quality assurance:
+
+1. **📋 /api-planning** - Analyzes API schemas and creates comprehensive test plans
+2. **🔧 /test-generation** - Generates executable tests (Playwright, Jest, Postman)
+3. **🔬 /test-healing** - Debugs and fixes failing API tests automatically
+
+## 🚀 Getting Started
+
+### Prerequisites
+- **AI Coding Tool** with Agent Skills support:
+  - GitHub Copilot (VS Code or CLI)
+  - Codex CLI (OpenAI)
+  - Claude Code (Anthropic)
+  - Cursor, Roo Code, or other compatible tools
+- **Node.js 14+** for running generated tests
+- **API documentation** (OpenAPI/Swagger preferred) or API endpoint access
+
+### Quick Setup
+1. Install the Democratize Quality MCP Server with skills: `npx @democratize-quality/mcp-server --agents`
+2. Start a conversation with your AI coding tool
+3. Use skills by typing `/api-planning`, `/test-generation`, or `/test-healing`, or mention relevant tasks
+
+---
+
+## 📋 /api-planning Skill
+
+**Purpose**: Analyze API schemas and create comprehensive test plans covering functional, security, and edge case testing.
+
+### When to Use the API Planning Skill
+
+#### Scenario 1: You have an OpenAPI/Swagger schema
+```
+I need to create a comprehensive test plan for my REST API. I have the OpenAPI schema at https://petstore.swagger.io/v2/swagger.json - can you analyze it and generate a detailed test plan covering all endpoints, authentication, and edge cases?
+```
+
+#### Scenario 2: You have API documentation but no schema
+```
+I have a user management API at https://api.myapp.com with endpoints for registration, login, user CRUD operations, and admin functions. Can you help me create a comprehensive test plan that covers happy paths, error scenarios, and security testing?
+```
+
+#### Scenario 3: GraphQL API planning
+```
+I have a GraphQL API with user, product, and order operations. Can you help me create a test plan that covers queries, mutations, authentication, and data validation scenarios?
+```
+
+### Example Skill Prompts
+
+**Basic Schema Analysis:**
+```
+Help me analyze my OpenAPI schema and create a test plan. The schema is at https://api.example.com/docs/swagger.json and I want to include security testing and error handling scenarios.
+```
+
+**Custom Test Categories:**
+```
+I need an API test plan for my e-commerce API. Please focus on functional testing, security testing, and integration scenarios. The API base URL is https://shop-api.example.com and I have the schema content ready to share.
+```
+
+**Manual API Exploration:**
+```
+I don't have an API schema but need to create a test plan for my authentication API. The endpoints are /login, /register, /refresh-token, and /logout. Can you help me explore these endpoints and create a comprehensive test plan?
+```
+
+### Expected Outputs
+- **Comprehensive test plan** in markdown format
+- **Endpoint analysis** with request/response examples
+- **Security test scenarios** (SQL injection, XSS, auth bypasses)
+- **Edge case coverage** (boundary conditions, error handling)
+- **Integration test workflows** with request chaining
+
+---
+
+## 🔧 /test-generation Skill
+
+**Purpose**: Convert test plans into executable tests in multiple formats (Playwright, Jest, Postman collections).
+
+### When to Use the Test Generation Skill
+
+#### Scenario 1: Generate from existing test plan
+```
+I have an API test plan in ./docs/api-test-plan.md. Can you generate executable Jest tests and Postman collections from this plan? I want to include authentication setup and use https://api.myapp.com as the base URL.
+```
+
+#### Scenario 2: Generate specific test format
+```
+Please create Playwright tests from my test plan. I need the tests to include proper authentication handling and session management for my REST API testing.
+```
+
+#### Scenario 3: Batch generation for CI/CD
+```
+I need to generate all test formats (Jest, Playwright, and Postman) from my API test plan for our CI/CD pipeline. The tests should include setup/teardown and be ready for automated execution.
+```
+
+### Example Skill Prompts
+
+**Complete Test Suite Generation:**
+```
+Create a complete test suite from my test plan. Generate Jest tests, Playwright tests, and Postman collections. Include authentication setup and organize the tests for easy maintenance.
+```
+
+**Framework-Specific Generation:**
+```
+I need Jest API tests generated from my test plan with proper axios configuration, error handling, and session management. The base URL should be configurable via environment variables.
+```
+
+**Integration with Existing Tests:**
+```
+Can you generate Playwright API tests that integrate with my existing test structure? I want to add these to my current test suite without conflicts.
+```
+
+### Expected Outputs
+- **Executable test files** in requested formats
+- **Test utilities and helpers** for authentication and data management
+- **Configuration files** for test runners
+- **Setup/teardown scripts** for test environment management
+- **Documentation** for running and maintaining tests
+
+---
+
+## 🔬 /test-healing Skill
+
+**Purpose**: Debug and automatically fix failing API tests using intelligent analysis and healing strategies.
+
+### When to Use the Test Healing Skill
+
+#### Scenario 1: Tests failing after API changes
+```
+My API tests in ./tests/api-tests.spec.js are failing after our latest API deployment. Can you analyze the failures and fix the tests automatically? I want to keep backups of the original files.
+```
+
+#### Scenario 2: Authentication issues
+```
+My Jest tests are failing with 401 errors - it seems like our authentication method changed. Can you help heal these tests and update the auth configuration?
+```
+
+#### Scenario 3: Bulk test healing
+```
+I have multiple test files that are broken after API schema changes. Can you fix all tests in my ./tests/ directory and provide a report of what was changed?
+```
+
+### Example Skill Prompts
+
+**Automated Healing:**
+```
+Please fix my failing API tests. The test files are in ./tests/ and I want automatic healing with backup creation. Focus on authentication and endpoint issues.
+```
+
+**Analysis Before Fixing:**
+```
+My API tests are failing and I need to understand why before applying fixes. Can you analyze the test failures first and then suggest healing strategies?
+```
+
+**Targeted Healing:**
+```
+I have specific authentication failures in my tests. Please focus on auth-repair and endpoint-fix strategies only.
+```
+
+### Expected Outputs
+- **Detailed failure analysis** with categorized error types
+- **Automatically fixed test files** with applied healing strategies
+- **Backup files** of original tests before modifications
+- **Healing report** showing what was changed and why
+- **Recommendations** for preventing similar issues
+
+---
+
+## 🔄 Complete Workflow Examples
+
+### Workflow 1: From Schema to Working Tests
+```
+I have a new API with OpenAPI schema at https://api.newproject.com/docs/swagger.json. 
+
+1. First, analyze the schema and create a comprehensive test plan
+2. Then create Jest and Postman tests from the plan
+3. Finally, help me set up the test environment and run the tests
+
+I want full coverage including security testing and edge cases.
+```
+
+### Workflow 2: Fixing Legacy Tests
+```
+I inherited a project with broken API tests in ./legacy-tests/. The API has evolved but the tests weren't updated.
+
+1. Analyze what's broken in the tests
+2. Automatically fix the tests where possible
+3. For unfixable issues, help me understand what manual changes are needed
+4. Generate a report of all changes made
+
+Please create backups before making any changes.
+```
+
+### Workflow 3: Building Test Suite from Scratch
+```
+I need to build a complete API test suite for my microservices architecture. I have 3 services with different authentication methods.
+
+1. Help me plan comprehensive test scenarios for each service
+2. Generate tests that work together for integration testing
+3. Set up proper test data management and cleanup
+4. Create a maintenance strategy for keeping tests updated
+
+The services are: user-service, order-service, and payment-service.
+```
+
+## 🛠️ Advanced Usage Tips
+
+### 1. Combining Skills Effectively
+```
+Can you create a complete API testing solution by:
+1. Analyzing my OpenAPI schema and creating a test plan
+2. Generating comprehensive test suites
+3. Setting up automated healing for CI/CD
+```
+
+### 2. Custom Configuration
+```
+I need tests generated with specific configurations:
+- Custom authentication headers
+- Environment-specific base URLs
+- Special error handling for rate limiting
+- Integration with my existing test framework
+
+Can you help customize the generated tests?
+```
+
+### 3. Maintenance and Updates
+```
+My API evolves frequently. Can you help me set up a process where:
+1. Schema changes trigger automatic test plan updates
+2. Tests are regenerated when needed
+3. Healing runs automatically in CI/CD
+4. I get reports on what changed and why
+```
+
+## 🎯 Best Practices
+
+### For /api-planning Skill:
+- **Provide complete schemas** when available for best results
+- **Specify security requirements** explicitly
+- **Include business logic context** for better test scenarios
+- **Request specific test categories** if you have preferences
+
+### For /test-generation Skill:
+- **Choose appropriate test format** for your use case
+- **Specify authentication details** early in the process
+- **Include environment configuration** requirements
+- **Request helper utilities** for complex scenarios
+
+### For /test-healing Skill:
+- **Always enable backups** when healing tests
+- **Start with analysis-only mode** for critical tests
+- **Specify healing strategies** if you know the issue type
+- **Review healing reports** to understand changes
+
+## 🔧 Troubleshooting
+
+### Common Issues and Solutions
+
+**Skill Not Responding:**
+```
+I'm trying to analyze an OpenAPI schema but getting errors. Can you help me troubleshoot?
+```
+
+**Tests Not Generating Properly:**
+```
+The generated tests don't match my test plan. Can you help me understand what went wrong and regenerate them correctly?
+```
+
+**Healing Not Working:**
+```
+The healing process made changes but my tests are still failing. Can you analyze what additional fixes are needed?
+```
+
+## 📚 Additional Resources
+
+### Related Tools
+- Use `api_request` for manual API testing and validation
+- Use `api_session_status` to monitor test execution
+- Use `api_session_report` to generate detailed test reports
+
+### Integration Examples
+```
+Can you show me how to integrate these generated tests with:
+1. GitHub Actions for CI/CD
+2. Jest for local development
+3. Postman for manual testing
+4. Playwright for browser-based API testing
+```
+
+---
+
+## 🤝 Getting Help
+
+If you need assistance with any of these skills:
+
+1. **Be specific** about your API type, authentication, and requirements
+2. **Provide context** about your existing test setup
+3. **Share error messages** when things don't work as expected
+4. **Ask for explanations** of generated code or healing decisions
+
+**Example Help Request:**
+```
+I'm new to API testing and have a REST API with JWT authentication. Can you walk me through using all three skills to create a complete testing solution? I want to understand each step and the generated code.
+```
+
+Remember: These skills are designed to work together seamlessly. Start with planning, move to generation, and use healing to maintain your tests as your API evolves!

package/src/docs/QUICK_REFERENCE.md

@@ -0,0 +1,111 @@
+# 🚀 API Testing Skills Quick Reference
+
+## 📋 Quick Prompts for AI Coding Tools
+
+### 📋 /api-planning Skill
+
+**Schema Analysis:**
+```
+Analyze my OpenAPI schema at [URL] and create a comprehensive test plan with security testing.
+```
+
+**Manual Exploration:**
+```
+I need an API test plan for my [API_TYPE] API with endpoints [LIST_ENDPOINTS]. Include authentication, error handling, and edge cases.
+```
+
+**Custom Categories:**
+```
+Create an API test plan focusing on [functional/security/performance/integration] testing for my API at [BASE_URL].
+```
+
+### 🔧 /test-generation Skill
+
+**Complete Generation:**
+```
+Create [jest/playwright/postman/all] tests from my test plan at [PATH]. Include authentication setup.
+```
+
+**Framework Specific:**
+```
+Generate [FRAMEWORK] tests from my API test plan with proper error handling and session management.
+```
+
+**Batch Generation:**
+```
+Generate all test formats (Jest, Playwright, Postman) from my test plan for CI/CD integration.
+```
+
+### 🔬 /test-healing Skill
+
+**Auto-Healing:**
+```
+Fix my failing tests in [PATH]. Create backups and focus on [auth/endpoint/assertion] issues.
+```
+
+**Analysis First:**
+```
+Analyze my failing API tests in [PATH] before applying fixes. I want to understand what's broken.
+```
+
+**Bulk Healing:**
+```
+Heal all API tests in my [DIRECTORY] after API changes. Use all healing strategies and provide a detailed report.
+```
+
+## 🔄 Complete Workflows
+
+**New API Testing:**
+```
+I have a new API with schema at [URL]. Please:
+1. Create a test plan
+2. Generate Jest and Postman tests  
+3. Help me set up test execution
+```
+
+**Legacy Test Fixing:**
+```
+My API tests in [PATH] are broken after API updates. Please:
+1. Analyze failures
+2. Automatically fix what's possible
+3. Report what needs manual attention
+```
+
+**Complete Test Suite:**
+```
+Build a complete testing solution for my [DESCRIPTION] API:
+1. Plan comprehensive test scenarios
+2. Generate executable tests in multiple formats
+3. Set up automated healing for maintenance
+```
+
+## 🎯 One-Liner Prompts
+
+| Task | Prompt |
+|------|--------|
+| **Quick Schema Analysis** | `Analyze my OpenAPI schema at [URL] and create a test plan` |
+| **Generate Jest Tests** | `Generate Jest tests from my test plan with authentication setup` |
+| **Fix Failing Tests** | `Fix my failing tests in [PATH] automatically` |
+| **Create Postman Collection** | `Generate a Postman collection from my API test plan` |
+| **Security Testing Plan** | `Create an API security test plan for my REST API at [URL]` |
+| **Integration Tests** | `Generate integration tests that chain multiple API calls` |
+| **Auth Issues** | `Fix authentication failures in my API tests automatically` |
+| **All Formats** | `Generate Jest, Playwright, and Postman tests from my plan` |
+
+## 🔧 Variables to Replace
+
+- `[URL]` - Your API schema URL or base URL
+- `[PATH]` - File path to your test plan or test files
+- `[FRAMEWORK]` - jest, playwright, postman
+- `[API_TYPE]` - REST, GraphQL, etc.
+- `[LIST_ENDPOINTS]` - Comma-separated list of endpoints
+- `[BASE_URL]` - Your API's base URL
+- `[DIRECTORY]` - Directory containing test files
+- `[DESCRIPTION]` - Brief description of your API
+
+## 📱 Mobile-Friendly Quick Commands
+
+**Plan:** `Create API test plan for [YOUR_API]`
+**Generate:** `Generate [FORMAT] tests from plan`  
+**Heal:** `Fix failing tests in [PATH]`
+**All:** `Complete API testing solution for [API]`