@democratize-quality/mcp-server 1.2.0 → 1.2.1

package/src/tools/api/api-session-status.js

@@ -0,0 +1,414 @@
+/**
+ * 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/>.
+ */
+
+const ToolBase = require('../base/ToolBase');
+
+/**
+ * API Session Status Tool - Query API test session status and results
+ */
+class ApiSessionStatusTool extends ToolBase {
+    static definition = {
+        name: "api_session_status",
+        description: "Query API test session status, logs, and results by sessionId. Provides detailed information about request history and validation results.",
+        input_schema: {
+            type: "object",
+            properties: {
+                sessionId: {
+                    type: "string",
+                    description: "The session ID to query"
+                },
+                includeDetails: {
+                    type: "boolean",
+                    default: true,
+                    description: "Whether to include detailed request/response data"
+                },
+                filterByType: {
+                    type: "string",
+                    enum: ["single", "request", "chain", "all"],
+                    default: "all",
+                    description: "Filter logs by request type"
+                },
+                limit: {
+                    type: "number",
+                    default: 50,
+                    description: "Maximum number of log entries to return"
+                }
+            },
+            required: ["sessionId"]
+        },
+        output_schema: {
+            type: "object",
+            properties: {
+                success: { type: "boolean", description: "Whether the session was found" },
+                found: { type: "boolean", description: "Whether the session exists" },
+                session: {
+                    type: "object",
+                    properties: {
+                        sessionId: { type: "string" },
+                        status: { type: "string" },
+                        startTime: { type: "string" },
+                        endTime: { type: "string" },
+                        executionTime: { type: "number" },
+                        error: { type: "string" }
+                    },
+                    description: "Session metadata"
+                },
+                summary: {
+                    type: "object",
+                    properties: {
+                        totalRequests: { type: "number" },
+                        successfulRequests: { type: "number" },
+                        failedRequests: { type: "number" },
+                        chainSteps: { type: "number" },
+                        logEntries: { type: "number" }
+                    },
+                    description: "Session summary statistics"
+                },
+                logs: {
+                    type: "array",
+                    description: "Session log entries (filtered and limited)"
+                },
+                validationSummary: {
+                    type: "object",
+                    properties: {
+                        passedValidations: { type: "number" },
+                        failedValidations: { type: "number" },
+                        validationRate: { type: "number" }
+                    },
+                    description: "Validation statistics"
+                }
+            },
+            required: ["success", "found"]
+        }
+    };
+
+    constructor() {
+        super();
+        // Access the global session store
+        if (!global.__API_SESSION_STORE__) {
+            global.__API_SESSION_STORE__ = new Map();
+        }
+        this.sessionStore = global.__API_SESSION_STORE__;
+    }
+
+    async execute(parameters) {
+        const {
+            sessionId,
+            includeDetails = true,
+            filterByType = "all",
+            limit = 50
+        } = parameters;
+
+        const session = this.sessionStore.get(sessionId);
+        
+        if (!session) {
+            return {
+                success: false,
+                found: false,
+                message: `Session not found: ${sessionId}`,
+                availableSessions: Array.from(this.sessionStore.keys())
+            };
+        }
+
+        // Filter logs by type
+        let filteredLogs = session.logs || [];
+        if (filterByType !== "all") {
+            filteredLogs = filteredLogs.filter(log => log.type === filterByType);
+        }
+
+        // Apply limit
+        const logs = filteredLogs.slice(-limit);
+
+        // Generate summary statistics
+        const summary = this.generateSummary(session.logs || []);
+        const validationSummary = this.generateValidationSummary(session.logs || []);
+
+        // Prepare session metadata (without sensitive details if not requested)
+        const sessionMetadata = {
+            sessionId: session.sessionId,
+            status: session.status,
+            startTime: session.startTime,
+            endTime: session.endTime,
+            executionTime: session.executionTime,
+            error: session.error
+        };
+
+        // Optionally strip detailed request/response data
+        const processedLogs = includeDetails 
+            ? logs 
+            : logs.map(log => this.stripSensitiveData(log));
+
+        return {
+            success: true,
+            found: true,
+            session: sessionMetadata,
+            summary,
+            validationSummary,
+            logs: processedLogs,
+            logCount: logs.length,
+            totalLogCount: (session.logs || []).length
+        };
+    }
+
+    /**
+     * Generate summary statistics for the session
+     */
+    generateSummary(logs) {
+        const summary = {
+            totalRequests: 0,
+            successfulRequests: 0,
+            failedRequests: 0,
+            chainSteps: 0,
+            singleRequests: 0,
+            logEntries: logs.length
+        };
+
+        for (const log of logs) {
+            switch (log.type) {
+                case 'single':
+                    summary.totalRequests++;
+                    summary.singleRequests++;
+                    if (this.isRequestSuccessful(log)) {
+                        summary.successfulRequests++;
+                    } else {
+                        summary.failedRequests++;
+                    }
+                    break;
+                    
+                case 'request':
+                    summary.totalRequests++;
+                    summary.chainSteps++;
+                    if (this.isRequestSuccessful(log)) {
+                        summary.successfulRequests++;
+                    } else {
+                        summary.failedRequests++;
+                    }
+                    break;
+                    
+                case 'chain':
+                    // Chain logs contain summary of multiple steps
+                    if (log.steps) {
+                        summary.chainSteps += log.steps.length;
+                    }
+                    break;
+            }
+        }
+
+        return summary;
+    }
+
+    /**
+     * Generate validation summary statistics
+     */
+    generateValidationSummary(logs) {
+        let passedValidations = 0;
+        let failedValidations = 0;
+        let totalValidations = 0;
+
+        for (const log of logs) {
+            if (log.validation && log.bodyValidation) {
+                totalValidations++;
+                
+                const isValid = log.validation.status && 
+                               log.validation.contentType && 
+                               log.bodyValidation.matched;
+                
+                if (isValid) {
+                    passedValidations++;
+                } else {
+                    failedValidations++;
+                }
+            }
+            
+            // Also check chain steps
+            if (log.type === 'chain' && log.steps) {
+                for (const step of log.steps) {
+                    if (step.validation && step.bodyValidation) {
+                        totalValidations++;
+                        
+                        const isValid = step.validation.status && 
+                                       step.validation.contentType && 
+                                       step.bodyValidation.matched;
+                        
+                        if (isValid) {
+                            passedValidations++;
+                        } else {
+                            failedValidations++;
+                        }
+                    }
+                }
+            }
+        }
+
+        return {
+            passedValidations,
+            failedValidations,
+            totalValidations,
+            validationRate: totalValidations > 0 
+                ? Math.round((passedValidations / totalValidations) * 100) / 100 
+                : 0
+        };
+    }
+
+    /**
+     * Check if a request was successful based on validation
+     */
+    isRequestSuccessful(log) {
+        return log.validation && 
+               log.bodyValidation &&
+               log.validation.status && 
+               log.validation.contentType && 
+               log.bodyValidation.matched;
+    }
+
+    /**
+     * Remove sensitive data from logs when details are not requested
+     */
+    stripSensitiveData(log) {
+        const stripped = {
+            type: log.type,
+            timestamp: log.timestamp
+        };
+
+        if (log.request) {
+            stripped.request = {
+                method: log.request.method,
+                url: log.request.url,
+                hasHeaders: !!(log.request.headers && Object.keys(log.request.headers).length > 0),
+                hasData: !!log.request.data
+            };
+        }
+
+        if (log.response) {
+            stripped.response = {
+                status: log.response.status,
+                contentType: log.response.contentType,
+                hasBody: !!log.response.body
+            };
+        }
+
+        if (log.validation) {
+            stripped.validation = log.validation;
+        }
+
+        if (log.bodyValidation) {
+            stripped.bodyValidation = {
+                matched: log.bodyValidation.matched,
+                reason: log.bodyValidation.reason
+            };
+        }
+
+        // Handle chain steps
+        if (log.steps) {
+            stripped.steps = log.steps.map(step => this.stripSensitiveData({
+                type: 'request',
+                request: step.request || {
+                    method: step.method,
+                    url: step.url,
+                    headers: step.headers,
+                    data: step.data
+                },
+                response: {
+                    status: step.status,
+                    contentType: step.contentType,
+                    body: step.body
+                },
+                validation: step.validation,
+                bodyValidation: step.bodyValidation
+            }));
+        }
+
+        return stripped;
+    }
+
+    /**
+     * Get detailed analysis of a specific request by index
+     */
+    getRequestDetails(sessionId, requestIndex) {
+        const session = this.sessionStore.get(sessionId);
+        if (!session || !session.logs) {
+            return null;
+        }
+
+        const requestLogs = session.logs.filter(log => 
+            log.type === 'single' || log.type === 'request'
+        );
+
+        if (requestIndex >= requestLogs.length) {
+            return null;
+        }
+
+        return requestLogs[requestIndex];
+    }
+
+    /**
+     * Get session timing analysis
+     */
+    getTimingAnalysis(sessionId) {
+        const session = this.sessionStore.get(sessionId);
+        if (!session || !session.logs) {
+            return null;
+        }
+
+        const requests = session.logs.filter(log => 
+            log.type === 'single' || log.type === 'request'
+        );
+
+        if (requests.length === 0) {
+            return { message: 'No requests found for timing analysis' };
+        }
+
+        // Calculate request intervals
+        const timings = [];
+        for (let i = 0; i < requests.length; i++) {
+            const current = new Date(requests[i].timestamp);
+            const previous = i > 0 ? new Date(requests[i - 1].timestamp) : new Date(session.startTime);
+            
+            timings.push({
+                requestIndex: i,
+                timestamp: requests[i].timestamp,
+                intervalMs: current.getTime() - previous.getTime()
+            });
+        }
+
+        return {
+            totalRequests: requests.length,
+            sessionDuration: session.executionTime || 0,
+            averageInterval: timings.reduce((sum, t) => sum + t.intervalMs, 0) / timings.length,
+            timings
+        };
+    }
+
+    /**
+     * List all available sessions
+     */
+    listAllSessions() {
+        return Array.from(this.sessionStore.entries()).map(([id, session]) => ({
+            sessionId: id,
+            status: session.status,
+            startTime: session.startTime,
+            requestCount: (session.logs || []).filter(log => 
+                log.type === 'single' || log.type === 'request'
+            ).length,
+            logCount: (session.logs || []).length
+        }));
+    }
+}
+
+module.exports = ApiSessionStatusTool;

package/src/tools/api/prompts/README.md

@@ -0,0 +1,293 @@
+# Prompt Orchestration System
+
+This directory contains the prompt orchestration system for AI-based test code generation.
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────┐
+│         ORCHESTRATION PIPELINE              │
+└─────────────────────────────────────────────┘
+
+1️⃣ PLANNING (Structured - Code)
+   ├─ Parse test plan markdown
+   ├─ Extract scenarios & context
+   └─ Build structured data
+
+2️⃣ GENERATION (AI-Driven)
+   ├─ Load generation prompts
+   ├─ Construct context
+   ├─ Call AI (GitHub Copilot API)
+   └─ Return generated code
+
+3️⃣ VALIDATION (Automated - Code)
+   ├─ Check syntax & structure
+   ├─ Validate patterns & conventions
+   └─ Report issues
+
+4️⃣ HEALING (AI-Driven - If Needed)
+   ├─ Load healing prompts
+   ├─ Include issue details
+   ├─ Call AI to fix issues
+   └─ Return fixed code
+
+5️⃣ OUTPUT
+   ├─ Write validated test files
+   └─ Report generation status
+```
+
+## Files
+
+### `generation-prompts.js`
+Contains all prompts for generating test code.
+
+**Exports:**
+- `playwrightScenario` - Generate Playwright API tests
+- `jestScenario` - Generate Jest/axios tests
+- `postmanTestScript` - Generate Postman test scripts
+
+**Usage:**
+```javascript
+const prompts = require('./generation-prompts');
+
+const context = {
+  scenario: { title, method, endpoint, data, expect },
+  baseUrl: 'https://api.example.com',
+  language: 'typescript',
+  options: { format: 'playwright' }
+};
+
+const systemPrompt = prompts.playwrightScenario.system;
+const userPrompt = prompts.playwrightScenario.user(context);
+```
+
+### `validation-rules.js`
+Validates generated code against quality rules.
+
+**Exports:**
+- `playwright` - Playwright validation rules
+- `jest` - Jest validation rules
+- `postman` - Postman validation rules
+- `getValidator(format)` - Get validator for format
+
+**Usage:**
+```javascript
+const validation = require('./validation-rules');
+
+const validator = validation.getValidator('playwright');
+const result = validator.validateAll(code, 'typescript');
+
+if (!result.valid) {
+  console.log('Issues:', result.issues);
+}
+```
+
+**Validation Checks:**
+- ✅ Proper async/await usage
+- ✅ Correct URL construction (no template literal escaping bugs!)
+- ✅ Required assertions present
+- ✅ Syntax correctness (balanced brackets/braces)
+- ✅ Framework-specific patterns
+
+### `healing-prompts.js`
+Prompts for fixing validation issues.
+
+**Exports:**
+- `playwrightHealing` - Fix Playwright test issues
+- `jestHealing` - Fix Jest test issues
+- `genericHealing` - Fix any code issues
+
+**Usage:**
+```javascript
+const healing = require('./healing-prompts');
+
+const context = {
+  originalCode: '...',
+  issues: [{ severity, message, fix }],
+  scenario: { ... }
+};
+
+const systemPrompt = healing.playwrightHealing.system;
+const userPrompt = healing.playwrightHealing.user(context);
+```
+
+### `orchestrator.js`
+Main orchestrator class that coordinates the workflow.
+
+**Usage:**
+```javascript
+const PromptOrchestrator = require('./orchestrator');
+
+const orchestrator = new PromptOrchestrator({
+  maxHealingAttempts: 3,
+  language: 'typescript',
+  outputFormat: 'playwright',
+  verbose: true
+});
+
+// Generate single test scenario
+const result = await orchestrator.generateTestCode(
+  { scenario, baseUrl },
+  aiGenerator
+);
+
+// Generate complete test file
+const fileContent = orchestrator.generateTestFile(
+  testBodies,
+  testPlan,
+  { format, language, sessionId }
+);
+```
+
+**Key Methods:**
+- `generateTestCode(context, aiGenerator)` - Generate & validate single test
+- `generateTestFile(testBodies, testPlan, options)` - Generate complete file
+- Internal: `_generateCode()`, `_validateCode()`, `_healCode()`
+
+## Workflow Example
+
+```javascript
+// 1. Create orchestrator
+const orchestrator = new PromptOrchestrator({
+  language: 'typescript',
+  outputFormat: 'playwright',
+  maxHealingAttempts: 3,
+  verbose: true
+});
+
+// 2. Generate test for each scenario
+const testBodies = {};
+for (const [sectionIdx, section] of testPlan.sections.entries()) {
+  for (const [scenarioIdx, scenario] of section.scenarios.entries()) {
+    const context = {
+      scenario,
+      baseUrl: testPlan.baseUrl
+    };
+    
+    // AI generates → validates → heals if needed
+    const result = await orchestrator.generateTestCode(context, aiGenerator);
+    
+    testBodies[`${sectionIdx}-${scenarioIdx}`] = result.code;
+    
+    if (!result.valid) {
+      console.warn(`⚠️  Test has issues:`, result.issues);
+    }
+  }
+}
+
+// 3. Generate complete file
+const fileContent = orchestrator.generateTestFile(testBodies, testPlan, {
+  format: 'playwright',
+  language: 'typescript',
+  sessionId: 'test-123'
+});
+
+// 4. Write file
+fs.writeFileSync('tests/api-tests.spec.ts', fileContent);
+```
+
+## Benefits
+
+### 🎯 **Separation of Concerns**
+- **Planning** = Deterministic logic (code handles this)
+- **Generation** = Creative task (AI handles this)
+- **Validation** = Quality gates (code handles this)
+- **Healing** = Error correction (AI handles this)
+
+### 🔄 **Self-Correcting**
+- Validation catches issues automatically
+- Healing fixes them without manual intervention
+- Up to 3 attempts to get perfect code
+- Graceful degradation if healing fails
+
+### 📝 **Easy Prompt Engineering**
+- All prompts in one place
+- Easy to iterate and improve
+- Version control for prompts
+- A/B testing different strategies
+
+### 🚀 **Future-Proof**
+- Swap AI providers easily
+- Add new output formats quickly
+- Extend validation rules
+- Improve prompts without code changes
+
+## Prompt Engineering Tips
+
+### For Generation Prompts
+1. **Be Specific**: Clear requirements and examples
+2. **Include Context**: Provide all necessary data
+3. **Set Constraints**: Specify what NOT to do
+4. **Use Examples**: Show desired output format
+5. **Iterate**: Test and refine based on results
+
+### For Healing Prompts
+1. **Include Original Code**: Show what needs fixing
+2. **List Specific Issues**: Enumerate all problems
+3. **Provide Fixes**: Suggest how to fix each issue
+4. **Maintain Context**: Reference original scenario
+5. **Keep It Focused**: Fix only reported issues
+
+## Extending the System
+
+### Add New Output Format
+1. Add generation prompt in `generation-prompts.js`
+2. Add validation rules in `validation-rules.js`
+3. Add healing prompt in `healing-prompts.js`
+4. Update orchestrator's `_getGenerationPrompt()` and `_getHealingPrompt()`
+5. Add file generation in `generateTestFile()`
+
+### Add New Validation Rule
+1. Open `validation-rules.js`
+2. Add new validation function to appropriate format
+3. Update `validateAll()` to include new check
+4. Test with sample code
+
+### Improve Prompts
+1. Edit prompt in respective file
+2. Test with real scenarios
+3. Compare before/after quality
+4. Iterate based on results
+
+## AI Generator Interface
+
+The orchestrator expects an AI generator with this interface:
+
+```javascript
+class AIGenerator {
+  /**
+   * Generate code from prompts
+   * @param {string} systemPrompt - System/role prompt
+   * @param {string} userPrompt - User request prompt
+   * @returns {Promise<string>} - Generated code
+   */
+  async generate(systemPrompt, userPrompt) {
+    // Call AI API (GitHub Copilot, OpenAI, etc.)
+    // Return generated code as string
+  }
+}
+```
+
+## Configuration
+
+**Orchestrator Options:**
+- `maxHealingAttempts` (default: 3) - Max healing retries
+- `language` (default: 'typescript') - Target language
+- `outputFormat` (default: 'playwright') - Test format
+- `verbose` (default: false) - Enable logging
+
+## Future Enhancements
+
+- [ ] Add LLM-specific prompt optimizations
+- [ ] Support streaming responses
+- [ ] Add prompt caching for performance
+- [ ] Implement prompt versioning
+- [ ] Add metrics and analytics
+- [ ] Support custom validation rules
+- [ ] Add prompt templates for common patterns
+- [ ] Implement prompt AB testing framework
+
+---
+
+**Generated by:** Democratize Quality MCP Server
+**Architecture:** Prompt Orchestration (Planning → Generation → Validation → Healing)