qa360 1.4.5 → 2.0.1

package/dist/utils/config.js

@@ -0,0 +1,136 @@
+/**
+ * Config loader utilities for CLI commands
+ */
+import { readFileSync } from 'fs';
+import { join } from 'path';
+export async function loadPackConfig(packPath) {
+    const fullPath = join(process.cwd(), packPath);
+    const content = readFileSync(fullPath, 'utf8');
+    // Try YAML parse
+    let config;
+    try {
+        // Simple YAML parser (basic implementation)
+        config = parseYaml(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse pack file: ${error}`);
+    }
+    // Validate version
+    if (config.version === 2) {
+        return config;
+    }
+    else if (config.version === 1 || !config.version) {
+        return config;
+    }
+    throw new Error(`Unsupported pack version: ${config.version}`);
+}
+/**
+ * Simple YAML parser for pack files
+ * This is a basic implementation that handles common cases
+ */
+function parseYaml(content) {
+    const lines = content.split('\n');
+    const result = {};
+    const stack = [{ obj: result, indent: -1 }];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trimRight();
+        // Skip empty lines and comments
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const indent = line.search(/\S|$/);
+        // Find parent in stack
+        while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+            stack.pop();
+        }
+        const parent = stack[stack.length - 1].obj;
+        const colonIndex = trimmed.indexOf(':');
+        if (colonIndex === -1) {
+            // List item (array continuation)
+            if (Array.isArray(parent)) {
+                parent.push(parseValue(trimmed));
+            }
+            continue;
+        }
+        const key = trimmed.slice(0, colonIndex).trim();
+        const rest = trimmed.slice(colonIndex + 1).trim();
+        if (!rest || rest.startsWith('#')) {
+            // Object or empty value
+            parent[key] = null;
+        }
+        else if (rest.startsWith('|') || rest.startsWith('>')) {
+            // Multi-line string
+            const valueLines = [];
+            for (let j = i + 1; j < lines.length; j++) {
+                const nextLine = lines[j];
+                if (nextLine.trim() && !nextLine.startsWith(' '))
+                    break;
+                valueLines.push(nextLine.trim());
+                i = j;
+            }
+            parent[key] = valueLines.join('\n');
+        }
+        else {
+            // Simple value
+            parent[key] = parseValue(rest);
+        }
+        // If next line is more indented, this key starts a nested object/array
+        if (i < lines.length - 1) {
+            const nextIndent = lines[i + 1].search(/\S|$/);
+            if (nextIndent > indent) {
+                if (Array.isArray(parent[key])) {
+                    // Already an array
+                }
+                else if (typeof parent[key] === 'object' && parent[key] !== null) {
+                    // Nested object
+                    stack.push({ obj: parent[key], indent });
+                }
+                else {
+                    // Start of array
+                    const arr = [];
+                    parent[key] = arr;
+                    stack.push({ obj: arr, indent });
+                }
+            }
+        }
+    }
+    return result;
+}
+function parseValue(value) {
+    value = value.trim();
+    // String
+    if (value.startsWith('"') || value.startsWith("'")) {
+        return value.slice(1, -1);
+    }
+    // Number
+    if (/^-?\d+$/.test(value))
+        return parseInt(value, 10);
+    if (/^-?\d+\.\d+$/.test(value))
+        return parseFloat(value);
+    // Boolean
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (value === 'null' || value === '~')
+        return null;
+    // Array
+    if (value.startsWith('[')) {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return value;
+        }
+    }
+    // Object
+    if (value.startsWith('{')) {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return value;
+        }
+    }
+    return value;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qa360",
-  "version": "1.4.5",
+  "version": "2.0.1",
   "description": "QA360 Proof CLI - Quality as Cryptographic Proof",
   "type": "module",
   "main": "dist/index.js",
@@ -37,10 +37,14 @@
     "ajv-draft-04": "^1.0.0",
     "ajv-formats": "^2.1.1",
     "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
     "commander": "^11.0.0",
+    "glob": "^10.4.5",
     "inquirer": "^8.2.7",
     "js-yaml": "^4.1.0",
+    "ollama": "^0.5.1",
     "ora": "^5.4.1",
+    "playwright": "^1.57.0",
     
     "sqlite3": "^5.1.6",
     "tweetnacl": "^1.0.3"

package/dist/core/adapters/playwright-api.d.ts

@@ -1,82 +0,0 @@
-/**
- * QA360 Playwright API Adapter (Socle OOTB)
- * Smoke tests for REST/GraphQL APIs with retry logic
- */
-import { ApiTarget, PackBudgets } from '../types/pack-v1.js';
-export interface ApiTestConfig {
-    target: ApiTarget;
-    budgets?: PackBudgets;
-    timeout?: number;
-    retries?: number;
-}
-export interface ApiTestResult {
-    endpoint: string;
-    method: string;
-    status: number;
-    responseTime: number;
-    success: boolean;
-    error?: string;
-    headers?: Record<string, string>;
-    body?: any;
-}
-export interface ApiSmokeResult {
-    success: boolean;
-    results: ApiTestResult[];
-    summary: {
-        total: number;
-        passed: number;
-        failed: number;
-        avgResponseTime: number;
-    };
-    junit?: string;
-    error?: string;
-}
-export declare class PlaywrightApiAdapter {
-    private browser?;
-    private context?;
-    private redactor;
-    constructor();
-    /**
-     * Execute API smoke tests
-     */
-    runSmokeTests(config: ApiTestConfig): Promise<ApiSmokeResult>;
-    /**
-     * Execute single API test with retry logic
-     */
-    private executeApiTest;
-    /**
-     * Parse test specification string
-     */
-    private parseTestSpec;
-    /**
-     * Check if error is retryable
-     */
-    private isRetryableError;
-    /**
-     * Calculate test summary
-     */
-    private calculateSummary;
-    /**
-     * Generate JUnit XML fragment
-     */
-    private generateJUnit;
-    /**
-     * Escape XML special characters
-     */
-    private escapeXml;
-    /**
-     * Setup browser context
-     */
-    private setupBrowser;
-    /**
-     * Cleanup browser resources
-     */
-    private cleanup;
-    /**
-     * Validate API target configuration
-     */
-    static validateConfig(target: ApiTarget): {
-        valid: boolean;
-        errors: string[];
-    };
-}

package/dist/core/adapters/playwright-api.js

@@ -1,264 +0,0 @@
-/**
- * QA360 Playwright API Adapter (Socle OOTB)
- * Smoke tests for REST/GraphQL APIs with retry logic
- */
-import { chromium } from '@playwright/test';
-import { SecurityRedactor } from '../security/redactor.js';
-export class PlaywrightApiAdapter {
-    browser;
-    context;
-    redactor;
-    constructor() {
-        this.redactor = SecurityRedactor.forLogs();
-    }
-    /**
-     * Execute API smoke tests
-     */
-    async runSmokeTests(config) {
-        try {
-            await this.setupBrowser();
-            const results = [];
-            const smokeTests = config.target.smoke || [`GET ${config.target.baseUrl}/health -> 200`];
-            console.log(`🌐 Running API smoke tests (${smokeTests.length} endpoints)`);
-            for (const test of smokeTests) {
-                const testResult = await this.executeApiTest(test, config);
-                results.push(testResult);
-                if (testResult.success) {
-                    console.log(`  ✅ ${testResult.method} ${testResult.endpoint} -> ${testResult.status} (${testResult.responseTime}ms)`);
-                }
-                else {
-                    // Show clear error message with actual vs expected
-                    const errorMsg = testResult.error || 'Request failed';
-                    console.log(`  ❌ ${testResult.method} ${testResult.endpoint} -> ${errorMsg}`);
-                }
-            }
-            const summary = this.calculateSummary(results);
-            const junit = this.generateJUnit(results);
-            // Generate error message from failed tests
-            let error;
-            if (summary.failed > 0) {
-                const failedTests = results.filter(r => !r.success);
-                const errorMessages = failedTests.map(t => t.error).filter(Boolean);
-                error = errorMessages.length > 0
-                    ? `${summary.failed} endpoint(s) failed: ${errorMessages[0]}${errorMessages.length > 1 ? ` (and ${errorMessages.length - 1} more)` : ''}`
-                    : `${summary.failed} endpoint(s) failed`;
-            }
-            return {
-                success: summary.failed === 0,
-                results,
-                summary,
-                junit,
-                error
-            };
-        }
-        finally {
-            await this.cleanup();
-        }
-    }
-    /**
-     * Execute single API test with retry logic
-     */
-    async executeApiTest(testSpec, config) {
-        const { method, endpoint, expectedStatus } = this.parseTestSpec(testSpec, config.target.baseUrl);
-        const maxRetries = config.retries || 1;
-        let lastError = '';
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            try {
-                const startTime = Date.now();
-                const response = await this.context.request.fetch(endpoint, {
-                    method: method,
-                    timeout: config.timeout || 10000,
-                    headers: {
-                        'User-Agent': 'QA360-API-Smoke/1.0',
-                        'Accept': 'application/json, text/plain, */*'
-                    }
-                });
-                const responseTime = Date.now() - startTime;
-                const status = response.status();
-                const success = status === expectedStatus;
-                // Get response body safely
-                let body;
-                try {
-                    const contentType = response.headers()['content-type'] || '';
-                    if (contentType.includes('application/json')) {
-                        body = await response.json();
-                    }
-                    else {
-                        const text = await response.text();
-                        body = text.substring(0, 200); // Limit body size
-                    }
-                }
-                catch {
-                    body = '[Response body not readable]';
-                }
-                return {
-                    endpoint,
-                    method,
-                    status,
-                    responseTime,
-                    success,
-                    error: success ? undefined : `Expected status ${expectedStatus}, got ${status}`,
-                    headers: response.headers(),
-                    body: this.redactor.redactObject(body)
-                };
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error.message : 'Unknown error';
-                // Check if this is a retryable error
-                const isRetryable = this.isRetryableError(lastError);
-                if (isRetryable && attempt < maxRetries) {
-                    console.log(`    🔄 Retry ${attempt + 1}/${maxRetries} for ${method} ${endpoint} (${lastError})`);
-                    await new Promise(resolve => setTimeout(resolve, 1000 * (attempt + 1))); // Exponential backoff
-                    continue;
-                }
-                break;
-            }
-        }
-        return {
-            endpoint,
-            method,
-            status: 0,
-            responseTime: 0,
-            success: false,
-            error: this.redactor.redact(lastError)
-        };
-    }
-    /**
-     * Parse test specification string
-     */
-    parseTestSpec(spec, baseUrl) {
-        // Format: "GET /path -> 200" or "POST /api/users -> 201"
-        const match = spec.match(/^(\w+)\s+(.+?)\s*->\s*(\d+)$/);
-        if (!match) {
-            throw new Error(`Invalid test spec format: ${spec}. Expected: "METHOD /path -> STATUS"`);
-        }
-        const [, method, path, statusStr] = match;
-        const expectedStatus = parseInt(statusStr, 10);
-        // Build full endpoint URL
-        let endpoint = path;
-        if (!path.startsWith('http')) {
-            endpoint = baseUrl.replace(/\/$/, '') + (path.startsWith('/') ? path : `/${path}`);
-        }
-        return {
-            method: method.toUpperCase(),
-            endpoint,
-            expectedStatus
-        };
-    }
-    /**
-     * Check if error is retryable
-     */
-    isRetryableError(error) {
-        const retryablePatterns = [
-            /ECONNRESET/,
-            /ETIMEDOUT/,
-            /ECONNREFUSED/,
-            /502 Bad Gateway/,
-            /503 Service Unavailable/,
-            /504 Gateway Timeout/,
-            /timeout/i,
-            /network/i
-        ];
-        return retryablePatterns.some(pattern => pattern.test(error));
-    }
-    /**
-     * Calculate test summary
-     */
-    calculateSummary(results) {
-        const total = results.length;
-        const passed = results.filter(r => r.success).length;
-        const failed = total - passed;
-        const avgResponseTime = total > 0 ?
-            Math.round(results.reduce((sum, r) => sum + r.responseTime, 0) / total) : 0;
-        return { total, passed, failed, avgResponseTime };
-    }
-    /**
-     * Generate JUnit XML fragment
-     */
-    generateJUnit(results) {
-        const summary = this.calculateSummary(results);
-        const timestamp = new Date().toISOString();
-        let junit = `<?xml version="1.0" encoding="UTF-8"?>
-<testsuite name="API Smoke Tests" tests="${summary.total}" failures="${summary.failed}" time="${summary.avgResponseTime / 1000}" timestamp="${timestamp}">
-`;
-        for (const result of results) {
-            const testName = `${result.method} ${result.endpoint}`;
-            const time = result.responseTime / 1000;
-            junit += `  <testcase name="${this.escapeXml(testName)}" time="${time}">
-`;
-            if (!result.success) {
-                junit += `    <failure message="${this.escapeXml(result.error || 'Test failed')}">${this.escapeXml(JSON.stringify(result, null, 2))}</failure>
-`;
-            }
-            junit += `  </testcase>
-`;
-        }
-        junit += `</testsuite>`;
-        return junit;
-    }
-    /**
-     * Escape XML special characters
-     */
-    escapeXml(str) {
-        return str
-            .replace(/&/g, '&amp;')
-            .replace(/</g, '&lt;')
-            .replace(/>/g, '&gt;')
-            .replace(/"/g, '&quot;')
-            .replace(/'/g, '&apos;');
-    }
-    /**
-     * Setup browser context
-     */
-    async setupBrowser() {
-        this.browser = await chromium.launch({
-            headless: true,
-            args: ['--no-sandbox', '--disable-dev-shm-usage']
-        });
-        this.context = await this.browser.newContext({
-            userAgent: 'QA360-API-Smoke/1.0',
-            extraHTTPHeaders: {
-                'Accept': 'application/json, text/plain, */*'
-            }
-        });
-    }
-    /**
-     * Cleanup browser resources
-     */
-    async cleanup() {
-        if (this.context) {
-            await this.context.close();
-        }
-        if (this.browser) {
-            await this.browser.close();
-        }
-    }
-    /**
-     * Validate API target configuration
-     */
-    static validateConfig(target) {
-        const errors = [];
-        if (!target.baseUrl) {
-            errors.push('API target requires baseUrl');
-        }
-        else {
-            try {
-                new URL(target.baseUrl);
-            }
-            catch {
-                errors.push('API target baseUrl must be a valid URL');
-            }
-        }
-        if (target.smoke) {
-            for (const test of target.smoke) {
-                if (!/^\w+\s+.+\s*->\s*\d+$/.test(test)) {
-                    errors.push(`Invalid smoke test format: ${test}. Expected: "METHOD /path -> STATUS"`);
-                }
-            }
-        }
-        return {
-            valid: errors.length === 0,
-            errors
-        };
-    }
-}