@democratize-quality/mcp-server 1.1.7 → 1.1.8

package/README.md

@@ -18,7 +18,7 @@ npx @democratize-quality/mcp-server@latest --agents
 
 **What this does:**
 - ✅ Installs the MCP server
-- ✅ Sets up 3 AI-powered testing skills
+- ✅ Sets up 4 AI-powered testing skills
 - ✅ Configures VS Code integration automatically
 - ✅ Creates project folders (`.agents/skills/`, `.github/skills/`, `.claude/skills/`, `.vscode/`)
 - ✅ Works with: GitHub Copilot, Codex CLI, Claude Code, Cursor, and 10+ other tools
@@ -292,7 +292,7 @@ This MCP server provides **7 powerful tools** for comprehensive API testing:
 
 ## 🌐 Agent Skills (Universal AI Capabilities)
 
-When you install with `--agents`, you get 3 intelligent testing skills that work across all major AI coding tools:
+When you install with `--agents`, you get 4 intelligent testing skills that work across all major AI coding tools:
 
 ### 1. 📋 /api-planning - The Strategist
 
@@ -378,7 +378,114 @@ Sample Collection includes:
 Import into Postman and start testing!
 ```
 
-### 3. 🔬 /test-healing - The Fixer
+### 3. ⚡ /test-execution - The Runner
+
+**What it does:** Executes API tests directly from test plans without code
+
+**Best for:**
+- Running tests immediately after planning
+- Quick API validation without writing code
+- Executing specific test sections
+- Generating comprehensive HTML test reports
+
+**Example: Execute Tests from Plan**
+```
+1. After creating a test plan, type /test-execution or mention test execution
+   
+You: Execute tests from section 1 of the test plan
+
+2. Skill: I'll execute the tests from section 1 of your test plan using the api_request tool with a unique session ID. After execution, I'll generate an HTML report with all results.
+
+3. When prompted, allow the tool call "Run api_request democratize-quality (MCP Server)"
+
+Execution Results:
+✅ GET /api/v1/Books - List all books (200 OK, 145ms)
+✅ GET /api/v1/Books/1 - Get book by ID (200 OK, 98ms)
+✅ POST /api/v1/Books - Create new book (201 Created, 203ms)
+✅ PUT /api/v1/Books/1 - Update book (200 OK, 156ms)
+✅ DELETE /api/v1/Books/1 - Delete book (204 No Content, 87ms)
+
+Test Summary:
+- Total: 5 tests
+- Passed: 5 (100%)
+- Failed: 0 (0%)
+- Total Time: 689ms
+
+📊 HTML Report: ./api-test-reports/test-execution-1739597400000-report.html
+```
+
+**Example: Execute Full Test Plan**
+```
+You: /test-execution run all tests from the test plan and generate a report
+
+Skill: Executing entire test plan...
+
+Progress:
+📋 Section 1: Books API (5 tests)
+  ✅ GET /api/v1/Books
+  ✅ GET /api/v1/Books/{id}
+  ✅ POST /api/v1/Books
+  ✅ PUT /api/v1/Books/{id}
+  ✅ DELETE /api/v1/Books/{id}
+
+📋 Section 2: Authors API (4 tests)
+  ✅ GET /api/v1/Authors
+  ✅ GET /api/v1/Authors/{id}
+  ✅ POST /api/v1/Authors
+  ✅ DELETE /api/v1/Authors/{id}
+
+📋 Section 3: Users API (4 tests)  
+  ✅ GET /api/v1/Users
+  ✅ POST /api/v1/Users
+  ❌ PUT /api/v1/Users/{id} - 404 Not Found
+  ✅ DELETE /api/v1/Users/{id}
+
+Final Summary:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Total: 13 tests
+Passed: 12 (92.3%)
+Failed: 1 (7.7%)
+Total Time: 1.8s
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📊 Comprehensive HTML Report Generated:
+./api-test-reports/full-plan-execution-report.html
+
+Open in browser for:
+- Detailed request/response logs
+- Timing analysis and charts
+- Visual pass/fail indicators
+- Validation results
+```
+
+**Example: Execute with CRUD Workflow**
+```
+You: /test-execution run the Books CRUD tests with request chaining
+
+Skill: Executing CRUD workflow with request chaining...
+
+Step 1: CREATE book
+  ✅ POST /api/v1/Books
+  📌 Extracted: bookId = 42
+
+Step 2: READ created book
+  ✅ GET /api/v1/Books/42
+  📌 Verified: Book exists with correct data
+
+Step 3: UPDATE book
+  ✅ PUT /api/v1/Books/42
+  📌 Verified: Book updated successfully
+
+Step 4: DELETE book
+  ✅ DELETE /api/v1/Books/42
+  📌 Verified: Book deleted (204 No Content)
+
+Workflow Complete: All 4 operations successful! ✅
+
+📊 Report: ./api-test-reports/crud-workflow-report.html
+```
+
+### 4. 🔬 /test-healing - The Fixer
 
 **What it does:** Automatically diagnoses and repairs failing tests
 
@@ -540,13 +647,56 @@ Import the generated collection into Postman and start testing!
 
 **Result:** Professional Postman collection ready to share with your team
 
+### Scenario 3: Quick API Validation Without Code
+
+**Goal:** Execute API tests immediately without generating code files
+
+```
+Step 1:
+/api-planning create test plan from 
+https://fakerestapi.azurewebsites.net/swagger/v1/swagger.json
+focusing on Books and Users endpoints
+
+Step 2:
+/test-execution run all tests from the test plan and generate HTML report
+
+Step 3:
+Open the generated HTML report to see detailed results!
+```
+
+**What you get:**
+- ⚡ Instant test execution without writing code
+- 📊 Interactive HTML report with:
+  - Pass/fail indicators for each endpoint
+  - Request/response details
+  - Response timing analysis
+  - Visual charts and statistics
+- ✅ Quick validation of API before writing automated tests
+- 🔄 Easy to re-run for regression testing
+
+**Use cases:**
+- Quick API health checks
+- Validating API after deployments
+- API exploration and documentation
+- Testing APIs before committing to test code
+- Sharing test results with non-technical stakeholders
+
+**Alternative workflow with specific sections:**
+```
+You: /test-execution execute section 1 (Books API) from the test plan
+
+Result:
+✅ 5/5 tests passed
+📊 Report: ./api-test-reports/books-section-report.html
+```
+
 ---
 
 ## 🔧 Calling Individual Tools
 
 ### When to Use Individual Tools
 
-**Use skills (/api-planning, /test-generation, /test-healing) when:**
+**Use skills (/api-planning, /test-generation, /test-execution, /test-healing) when:**
 - You want AI assistance and recommendations
 - You're working on complex, multi-step workflows
 - You need explanations and best practices

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@democratize-quality/mcp-server",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "main": "mcpServer.js",
   "bin": {
     "democratize-quality-mcp": "cli.js",

package/src/skills/test-execution/SKILL.md

@@ -0,0 +1,728 @@
+````skill
+---
+name: test-execution
+description: Execute API tests directly from test plans using actual API requests. Run tests section-by-section or entirely, validate responses, chain requests, and generate comprehensive HTML reports. Use when user wants to run tests, execute API calls from test plan, validate endpoints, or create test execution reports.
+---
+
+# API Test Execution Skill
+
+Use this skill to execute API tests directly from test plans without writing code. Run comprehensive test sequences, validate responses, and generate visual HTML reports.
+
+## When to Use This Skill
+
+- User has a test plan and wants to execute tests immediately
+- User mentions running tests without generating code
+- User needs to validate API endpoints from test plan
+- User wants to execute specific sections of a test plan
+- User requests test execution reports or validation results
+- User needs quick API testing without setup
+
+## Core Workflow
+
+### Step 1: Load Test Plan
+
+**Read the test plan file** that was generated by `api_planner`:
+
+```javascript
+// User provides test plan path
+const testPlanPath = "./api-test-reports/api-test-plan.md";
+
+// Read the test plan content
+const testPlanContent = await readFile(testPlanPath);
+
+// Parse sections using markdown headers (##)
+// Each section represents a testable API endpoint or feature
+```
+
+### Step 2: Select Section or Full Execution
+
+**Ask user what to execute** (if not specified):
+
+```javascript
+// Parse test plan sections
+const sections = parseTestPlanSections(testPlanContent);
+
+// User can specify:
+// - "Execute section 1" or "Run tests for GET /api/v1/Books"
+// - "Execute all sections" or "Run entire test plan"
+// - "Run sections 1, 3, and 5"
+
+// Section structure example:
+// ## 1. GET /api/v1/Books - Retrieve all books
+// - Endpoint: GET /api/v1/Books
+// - Expected Status: 200
+// - Sample Request: [details]
+// - Expected Response: [structure]
+```
+
+**Section Selection Examples:**
+- Section number: "Execute section 1"
+- Endpoint match: "Run tests for Books API"
+- Multiple sections: "Execute sections 1, 2, and 4"
+- Full plan: "Run all tests" or "Execute entire test plan"
+
+### Step 3: Parse Test Data from Section
+
+**Extract test information** from the selected section(s):
+
+```javascript
+// For each test section, extract:
+const testData = {
+  method: "GET",              // HTTP method
+  endpoint: "/api/v1/Books",  // API endpoint
+  baseUrl: "https://api.example.com",  // From test plan overview
+  expectedStatus: 200,        // Expected HTTP status
+  headers: {                  // Authentication and headers
+    "Content-Type": "application/json",
+    "Authorization": "Bearer token-if-needed"
+  },
+  data: {                     // Request body (for POST/PUT/PATCH)
+    // Parsed from sample request in test plan
+  },
+  expectedResponse: {         // Expected response structure
+    // Parsed from expected response section
+  }
+}
+```
+
+**Parsing Rules:**
+- Extract HTTP method from section title or endpoint line
+- Get endpoint URL from "Endpoint:" line
+- Parse expected status from "Expected Status:" or "Status Code:" line
+- Extract request body from "Sample Request:" or "Request Body:" section
+- Get expected response from "Expected Response:" or "Response Structure:" section
+- Identify authentication requirements from test plan
+
+### Step 4: Execute Tests with Unique Session ID
+
+**Create a unique session** and execute tests:
+
+```javascript
+// Generate unique session ID
+const sessionId = `test-execution-${Date.now()}`;
+// Or use meaningful name: `test-execution-books-api-${Date.now()}`
+
+// Execute each test in the section
+for (const test of testsInSection) {
+  await tools.api_request({
+    sessionId: sessionId,
+    method: test.method,
+    url: `${test.baseUrl}${test.endpoint}`,
+    headers: test.headers,
+    data: test.data,  // Only for POST/PUT/PATCH/DELETE
+    expect: {
+      status: test.expectedStatus,
+      // Optional: Add response validation
+      body: {
+        // Expected fields from test plan
+      }
+    },
+    extract: {
+      // Extract data for chained requests
+      // Example: { "bookId": "id" } to use in next request
+    }
+  })
+  
+  console.log(`✅ Test passed: ${test.method} ${test.endpoint}`);
+}
+```
+
+**Request Chaining Example:**
+```javascript
+// Step 1: Create a book and extract its ID
+await tools.api_request({
+  sessionId: sessionId,
+  method: "POST",
+  url: "https://api.example.com/api/v1/Books",
+  data: {
+    title: "Test Book",
+    author: "Test Author"
+  },
+  expect: { status: 201 },
+  extract: { "bookId": "id" }  // Save book ID for next request
+})
+
+// Step 2: Use extracted bookId in next request
+await tools.api_request({
+  sessionId: sessionId,
+  method: "GET",
+  url: "https://api.example.com/api/v1/Books/{{bookId}}",  // Uses extracted ID
+  expect: { status: 200 }
+})
+
+// Step 3: Update the book
+await tools.api_request({
+  sessionId: sessionId,
+  method: "PUT",
+  url: "https://api.example.com/api/v1/Books/{{bookId}}",
+  data: {
+    title: "Updated Test Book",
+    author: "Test Author"
+  },
+  expect: { status: 200 }
+})
+
+// Step 4: Delete the book
+await tools.api_request({
+  sessionId: sessionId,
+  method: "DELETE",
+  url: "https://api.example.com/api/v1/Books/{{bookId}}",
+  expect: { status: 204 }
+})
+```
+
+### Step 5: Generate HTML Test Report
+
+**After all tests execute**, generate comprehensive report:
+
+```javascript
+await tools.api_session_report({
+  sessionId: sessionId,
+  outputPath: `./api-test-reports/${sessionId}-report.html`
+})
+
+// Optionally check final status
+await tools.api_session_status({
+  sessionId: sessionId
+})
+```
+
+## Execution Modes
+
+### Mode 1: Single Section Execution
+```javascript
+// User: "Execute section 1 from the test plan"
+
+// 1. Parse test plan
+// 2. Extract section 1
+// 3. Execute all tests in section 1
+// 4. Generate report
+```
+
+### Mode 2: Multiple Sections Execution
+```javascript
+// User: "Run tests for sections 1, 3, and 5"
+
+// 1. Parse test plan
+// 2. Extract sections 1, 3, and 5
+// 3. Execute tests sequentially
+// 4. Generate single comprehensive report
+```
+
+### Mode 3: Full Plan Execution
+```javascript
+// User: "Execute all tests from the test plan"
+
+// 1. Parse entire test plan
+// 2. Execute all sections in order
+// 3. Handle dependencies between tests
+// 4. Generate comprehensive report with all results
+```
+
+### Mode 4: Filtered Execution
+```javascript
+// User: "Run only GET and POST tests"
+
+// 1. Parse test plan
+// 2. Filter tests by HTTP method
+// 3. Execute filtered tests
+// 4. Generate filtered report
+```
+
+## Test Plan Parsing
+
+### Expected Test Plan Structure
+
+```markdown
+# API Test Plan
+
+## Overview
+- Base URL: https://api.example.com
+- Authentication: Bearer Token
+- API Version: v1
+
+## 1. GET /api/v1/Books - Retrieve all books
+
+### Endpoint
+GET /api/v1/Books
+
+### Expected Status
+200 OK
+
+### Request Headers
+- Content-Type: application/json
+- Authorization: Bearer {{authToken}}
+
+### Sample Request
+No request body required
+
+### Expected Response
+```json
+[
+  {
+    "id": 1,
+    "title": "Book Title",
+    "author": "Author Name",
+    "isbn": "978-3-16-148410-0"
+  }
+]
+```
+
+### Validation Criteria
+- Response is an array
+- Each book has id, title, author fields
+- Status code is 200
+
+## 2. POST /api/v1/Books - Create new book
+
+### Endpoint
+POST /api/v1/Books
+
+### Expected Status
+201 Created
+
+### Request Headers
+- Content-Type: application/json
+- Authorization: Bearer {{authToken}}
+
+### Sample Request
+```json
+{
+  "title": "New Book Title",
+  "author": "Author Name",
+  "isbn": "978-3-16-148410-0",
+  "publishedDate": "2026-02-15"
+}
+```
+
+### Expected Response
+```json
+{
+  "id": 42,
+  "title": "New Book Title",
+  "author": "Author Name",
+  "isbn": "978-3-16-148410-0",
+  "publishedDate": "2026-02-15",
+  "createdAt": "2026-02-15T10:30:00Z"
+}
+```
+```
+
+### Parsing Strategy
+
+**1. Extract Base Configuration:**
+- Find "Base URL" or "API Base URL" in overview section
+- Extract authentication method and headers
+- Identify API version
+
+**2. Identify Test Sections:**
+- Look for markdown headers (##) that contain HTTP methods
+- Pattern: `## N. METHOD /endpoint - Description`
+- Examples: `## 1. GET /api/v1/Books`, `## 2. POST /api/v1/Users`
+
+**3. Parse Section Content:**
+- Extract endpoint URL
+- Parse expected status code
+- Find request headers
+- Extract request body from code blocks
+- Parse expected response from code blocks
+- Identify validation criteria
+
+**4. Handle Code Blocks:**
+```javascript
+// JSON code blocks contain sample data
+// Look for: ```json [content] ```
+// Parse as JSON for request/response data
+```
+
+## Error Handling and Validation
+
+### Test Failure Handling
+
+```javascript
+try {
+  await tools.api_request({
+    sessionId: sessionId,
+    method: "GET",
+    url: "https://api.example.com/api/v1/Books",
+    expect: { status: 200 }
+  })
+  console.log(`✅ Test passed: GET /api/v1/Books`);
+} catch (error) {
+  console.error(`❌ Test failed: GET /api/v1/Books`);
+  console.error(`   Error: ${error.message}`);
+  // Continue with remaining tests
+}
+```
+
+### Validation Options
+
+**Basic Status Validation:**
+```javascript
+expect: { status: 200 }
+```
+
+**Expected vs Actual Validation:**
+```javascript
+expect: {
+  status: 200,
+  body: {
+    "items": expectedResponseFromTestPlan,
+    "count": "{{any}}"  // Allow any value
+  }
+}
+```
+
+**Flexible Validation:**
+```javascript
+expect: {
+  status: [200, 201],  // Accept either status
+  body: {
+    "id": "{{number}}",      // Must be a number
+    "title": "{{string}}",   // Must be a string
+    "items": "{{array}}"     // Must be an array
+  }
+}
+```
+
+## Session Management
+
+### Tracking Test Execution
+
+```javascript
+// Check test progress
+await tools.api_session_status({
+  sessionId: sessionId
+})
+
+// Output includes:
+// - Total requests made
+// - Successful requests
+// - Failed requests
+// - Extracted variables
+// - Request history
+```
+
+### Session Naming Conventions
+
+**Descriptive Session IDs:**
+```javascript
+// Format: test-execution-<feature>-<timestamp>
+const sessionId = `test-execution-books-api-${Date.now()}`;
+const sessionId = `test-execution-full-plan-${Date.now()}`;
+const sessionId = `test-execution-section-1-${Date.now()}`;
+
+// Benefits:
+// - Easy to identify in reports
+// - Helps organize multiple test runs
+// - Clear audit trail
+```
+
+## Report Generation
+
+### HTML Report Features
+
+The `api_session_report` tool generates:
+
+- **Test Summary**
+  - Total tests executed
+  - Pass/fail statistics
+  - Execution duration
+  - Success rate percentage
+
+- **Request Details**
+  - Each API call made
+  - Request method, URL, headers, body
+  - Response status, headers, body
+  - Timing information (response time)
+
+- **Validation Results**
+  - Expected vs Actual comparisons
+  - Detailed failure messages
+  - Status code validation
+  - Response body validation
+
+- **Visual Elements**
+  - Color-coded pass/fail indicators (✅/❌)
+  - Expandable request/response sections
+  - Timing charts
+  - Interactive HTML with filtering
+
+### Report Example
+
+```javascript
+// Generate comprehensive report
+await tools.api_session_report({
+  sessionId: "test-execution-books-api-1739597400000",
+  outputPath: "./api-test-reports/books-api-execution-report.html"
+})
+
+// Report file created at:
+// ./api-test-reports/books-api-execution-report.html
+
+// Open in browser to view:
+// - 15 total requests
+// - 13 passed (86.7%)
+// - 2 failed (13.3%)
+// - Average response time: 145ms
+// - Total execution time: 2.3s
+```
+
+## Advanced Scenarios
+
+### Scenario 1: Testing with Authentication
+
+```javascript
+// Step 1: Authenticate first
+await tools.api_request({
+  sessionId: sessionId,
+  method: "POST",
+  url: "https://api.example.com/auth/login",
+  data: {
+    email: "test@example.com",
+    password: "password123"
+  },
+  expect: { status: 200 },
+  extract: { "authToken": "access_token" }
+})
+
+// Step 2: Use token in subsequent requests
+await tools.api_request({
+  sessionId: sessionId,
+  method: "GET",
+  url: "https://api.example.com/api/v1/protected-resource",
+  headers: {
+    "Authorization": "Bearer {{authToken}}"  // Uses extracted token
+  },
+  expect: { status: 200 }
+})
+```
+
+### Scenario 2: Testing CRUD Operations
+
+```javascript
+const sessionId = `test-execution-crud-${Date.now()}`;
+
+// CREATE
+await tools.api_request({
+  sessionId: sessionId,
+  method: "POST",
+  url: "https://api.example.com/api/v1/Books",
+  data: { title: "Test Book", author: "Test Author" },
+  expect: { status: 201 },
+  extract: { "newBookId": "id" }
+})
+
+// READ
+await tools.api_request({
+  sessionId: sessionId,
+  method: "GET",
+  url: "https://api.example.com/api/v1/Books/{{newBookId}}",
+  expect: { status: 200 }
+})
+
+// UPDATE
+await tools.api_request({
+  sessionId: sessionId,
+  method: "PUT",
+  url: "https://api.example.com/api/v1/Books/{{newBookId}}",
+  data: { title: "Updated Book", author: "Test Author" },
+  expect: { status: 200 }
+})
+
+// DELETE
+await tools.api_request({
+  sessionId: sessionId,
+  method: "DELETE",
+  url: "https://api.example.com/api/v1/Books/{{newBookId}}",
+  expect: { status: 204 }
+})
+
+// Generate report showing complete CRUD workflow
+await tools.api_session_report({
+  sessionId: sessionId,
+  outputPath: "./api-test-reports/crud-test-report.html"
+})
+```
+
+### Scenario 3: Parallel Execution (Multiple Sessions)
+
+```javascript
+// Execute different sections in parallel
+const session1 = `test-execution-books-${Date.now()}`;
+const session2 = `test-execution-users-${Date.now()}`;
+const session3 = `test-execution-orders-${Date.now()}`;
+
+// Run tests for different sections independently
+// Note: These should be awaited sequentially or use Promise.all if truly parallel
+
+// Generate individual reports
+await tools.api_session_report({
+  sessionId: session1,
+  outputPath: "./api-test-reports/books-report.html"
+})
+
+await tools.api_session_report({
+  sessionId: session2,
+  outputPath: "./api-test-reports/users-report.html"
+})
+
+await tools.api_session_report({
+  sessionId: session3,
+  outputPath: "./api-test-reports/orders-report.html"
+})
+```
+
+## Best Practices
+
+### DO:
+- Use unique, descriptive session IDs for each test run
+- Parse test plan systematically (base URL, auth, sections)
+- Execute tests in logical order (auth first, dependencies second)
+- Use request chaining for dependent tests (extract/reuse IDs)
+- Generate comprehensive HTML reports after execution
+- Handle test failures gracefully (continue with remaining tests)
+- Provide clear progress updates to user during execution
+- Validate responses using expect parameters
+- Use consistent session naming conventions
+
+### DON'T:
+- Don't reuse session IDs across different test runs
+- Don't skip authentication if test plan requires it
+- Don't execute dependent tests out of order
+- Don't forget to generate the final HTML report
+- Don't stop execution on first failure (unless critical)
+- Don't ignore validation criteria from test plan
+- Don't execute tests without parsing test plan structure first
+- Don't forget to extract base URL from test plan
+
+## Expected Output
+
+After successful test execution, provide user with:
+
+1. **Execution Summary:**
+```
+Test Execution Summary:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Session ID: test-execution-books-api-1739597400000
+Total Tests: 15
+Passed: 13 (86.7%)
+Failed: 2 (13.3%)
+Execution Time: 2.3s
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Test Results:
+✅ GET /api/v1/Books - List all books
+✅ GET /api/v1/Books/{id} - Get book by ID
+✅ POST /api/v1/Books - Create new book
+❌ PUT /api/v1/Books/{id} - Update book (404 Not Found)
+✅ DELETE /api/v1/Books/{id} - Delete book
+...
+
+📊 HTML Report Generated:
+./api-test-reports/books-api-execution-report.html
+
+Open this file in a browser for detailed analysis!
+```
+
+2. **Failed Test Details:**
+```
+Failed Tests:
+
+❌ PUT /api/v1/Books/{id}
+   Expected: 200 OK
+   Actual: 404 Not Found
+   Response: {"error": "Book not found"}
+   
+   Possible causes:
+   - Book ID may have been deleted
+   - Endpoint URL may have changed
+   - Authentication may have expired
+```
+
+3. **Next Steps:**
+```
+Next Steps:
+1. Open HTML report for detailed analysis
+2. Review failed tests and fix issues
+3. Re-run failed tests or use /test-healing skill
+4. Update test plan if API has changed
+```
+
+## Integration with Other Skills
+
+### After API Planning → Execute Tests
+```
+1. User: /api-planning create test plan for API
+   → Test plan generated
+
+2. User: /test-execution run tests from section 1
+   → Tests executed, report generated
+```
+
+### Execute → Heal → Re-execute
+```
+1. User: /test-execution run all tests
+   → Some tests fail
+
+2. User: /test-healing fix failed tests  
+   → Tests updated with fixes
+
+3. User: /test-execution re-run failed tests
+   → All tests pass now
+```
+
+### Execute → Generate Code → Execute Again
+```
+1. User: /test-execution run quick validation
+   → Quick API validation completed
+
+2. User: /test-generation create Playwright tests
+   → Executable test code generated
+
+3. User: Run generated Playwright tests
+   → Automated test suite running
+```
+
+## Troubleshooting
+
+### Issue: Base URL not found in test plan
+- Check test plan overview section
+- Ask user to provide base URL
+- Look for API URL in first few sections
+
+### Issue: Cannot parse test sections
+- Verify test plan uses markdown headers (##)
+- Check section titles include HTTP method
+- Ensure sections have required fields (endpoint, status)
+
+### Issue: Authentication failures (401/403)
+- Extract auth requirements from test plan
+- Execute auth endpoint first
+- Use extracted tokens in subsequent requests
+
+### Issue: Request chaining not working
+- Verify extract parameter is used correctly
+- Check variable naming matches between requests
+- Ensure extracted data exists in response
+
+### Issue: Tests fail with timeouts
+- Check API availability
+- Verify network connectivity
+- Consider increasing timeout in api_request
+
+### Issue: Report not generated
+- Ensure session ID is correct
+- Verify api_session_report is called after all tests
+- Check output path is valid
+
+## Additional Tools Available
+
+Use these tools as needed:
+- `api_request` - Execute individual API requests
+- `api_session_status` - Check test execution progress
+- `api_session_report` - Generate HTML test reports
+- `search/readFile` - Read test plan files
+- `search/listDirectory` - Find test plan files
+
+````

package/src/utils/agentInstaller.js

@@ -32,10 +32,13 @@ class AgentInstaller {
             // Step 1: Install Agent Skills
             await this.installSkills();
             
-            // Step 2: Setup MCP configuration
+            // Step 2: Install Chat Modes
+            await this.installChatModes();
+            
+            // Step 3: Setup MCP configuration
             await this.setupMCPConfiguration();
             
-            // Step 3: Show completion message
+            // Step 4: Show completion message
             this.showCompletionMessage();
             
         } catch (error) {
@@ -180,6 +183,62 @@ class AgentInstaller {
         console.log('');
     }
 
+    /**
+     * Install Chat Modes to .github/agents/
+     */
+    async installChatModes() {
+        console.log('💬 Installing Chat Modes...');
+        
+        const sourceChatModesDir = path.join(this.sourceDir, 'src', 'chatmodes');
+        const targetAgentsDir = path.join(this.targetDir, '.github', 'agents');
+        
+        // Create .github/agents directory
+        try {
+            await mkdir(targetAgentsDir, { recursive: true });
+        } catch (error) {
+            if (error.code !== 'EEXIST') {
+                throw new Error(`Failed to create .github/agents directory: ${error.message}`);
+            }
+        }
+        
+        // Get list of chatmode files
+        let chatModeFiles;
+        try {
+            const allItems = await readdir(sourceChatModesDir);
+            // Filter for .chatmode.md files only
+            chatModeFiles = allItems.filter(item => item.endsWith('.chatmode.md'));
+        } catch (error) {
+            if (error.code === 'ENOENT') {
+                console.log('   ⚠️  No chatmodes directory found, skipping...');
+                console.log('');
+                return;
+            }
+            throw new Error(`Failed to read source chatmodes directory: ${error.message}`);
+        }
+        
+        if (chatModeFiles.length === 0) {
+            console.log('   ⚠️  No chatmode files found to install');
+            console.log('');
+            return;
+        }
+        
+        // Copy each chatmode file
+        for (const chatModeFile of chatModeFiles) {
+            const sourcePath = path.join(sourceChatModesDir, chatModeFile);
+            const targetPath = path.join(targetAgentsDir, chatModeFile);
+            
+            try {
+                await copyFile(sourcePath, targetPath);
+                console.log(`   ✅ ${chatModeFile}`);
+            } catch (error) {
+                console.error(`   ❌ Failed to copy ${chatModeFile}: ${error.message}`);
+                throw error;
+            }
+        }
+        
+        console.log('');
+    }
+
     /**
      * Setup MCP configuration in .vscode/mcp.json
      */
@@ -316,10 +375,16 @@ class AgentInstaller {
         console.log('📁 Agent Skills installed to:');
         console.log('   → .agents/skills/api-planning/');
         console.log('   → .agents/skills/test-generation/');
+        console.log('   → .agents/skills/test-execution/');
         console.log('   → .agents/skills/test-healing/');
         console.log('   → .github/skills/ (symlink for GitHub Copilot)');
         console.log('   → .claude/skills/ (symlink for Claude Code)\n');
         
+        console.log('💬 Chat Modes installed to:');
+        console.log('   → .github/agents/🌐 api-planner.chatmode.md');
+        console.log('   → .github/agents/🌐 api-generator.chatmode.md');
+        console.log('   → .github/agents/🌐 api-healer.chatmode.md\n');
+        
         console.log('⚙️  MCP configuration updated:');
         console.log('   → .vscode/mcp.json (democratize-quality server added/updated)\n');
         
@@ -328,6 +393,7 @@ class AgentInstaller {
         console.log('   2. Use skills in your AI coding assistant:');
         console.log('      • /api-planning - Create comprehensive API test plans');
         console.log('      • /test-generation - Generate executable API tests');
+        console.log('      • /test-execution - Execute API tests from test plans');
         console.log('      • /test-healing - Debug and fix failing API tests');
         console.log('   3. Skills work automatically when you mention relevant tasks!');
         console.log('   4. Example: "Help me create an API test plan for my REST API"\n');
@@ -336,7 +402,6 @@ class AgentInstaller {
         console.log('   • GitHub Copilot (VS Code, CLI)');
         console.log('   • Codex CLI (OpenAI)');
         console.log('   • Claude Code');
-        console.log('   • Cursor, Roo Code, and 10+ other tools\n');
         
         console.log('📚 For more information, visit: https://github.com/uppadhyayraj/democratize-quality-mcp-server');
     }