qa360 2.2.14 → 2.2.18

package/cli/dist/commands/ai.js

@@ -10,7 +10,7 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import ora from 'ora';
 import Table from 'cli-table3';
-import { createBest, getProviderInfo, getProviderStatus, createLLMProvider, DeepSeekProvider, DeepSeekError, OllamaProvider, OllamaError, OpenAIProvider, OpenAIError, AnthropicProvider, AnthropicError } from '../core/index.js';
+import { createBest, getProviderInfo, getProviderStatus, createLLMProvider, DeepSeekProvider, DeepSeekError, OllamaProvider, OllamaError, OpenAIProvider, OpenAIError, AnthropicProvider, AnthropicError } from 'qa360-core';
 /**
  * List all available AI providers
  */

package/cli/dist/commands/ask.js

@@ -49,9 +49,136 @@ export class QA360Ask {
                 name: 'target',
                 message: 'URL ou endpoint cible:',
                 validate: (input) => input.length > 0 || 'URL requise'
+            },
+            {
+                type: 'confirm',
+                name: 'needsAuth',
+                message: 'L\'API require-t-elle une authentification?',
+                default: false
             }
         ]);
-        return this.generatePackFromAnswers(answers);
+        // Ask for authentication details if needed
+        let authConfig;
+        if (answers.needsAuth) {
+            authConfig = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'type',
+                    message: 'Type d\'authentification:',
+                    choices: [
+                        { name: 'Bearer Token (JWT, OAuth2)', value: 'bearer' },
+                        { name: 'API Key (x-api-key, etc.)', value: 'api_key' },
+                        { name: 'Basic Auth (username/password)', value: 'basic' },
+                        { name: 'Custom Header', value: 'custom' }
+                    ]
+                },
+                {
+                    type: 'input',
+                    name: 'bearerToken',
+                    message: 'Bearer Token (laissez vide pour utiliser variable):',
+                    default: '${API_TOKEN}',
+                    when: (answers) => answers.type === 'bearer'
+                },
+                {
+                    type: 'input',
+                    name: 'headerName',
+                    message: 'Nom du header (ex: x-api-key):',
+                    default: 'x-api-key',
+                    when: (answers) => answers.type === 'api_key' || answers.type === 'custom'
+                },
+                {
+                    type: 'input',
+                    name: 'tokenPrefix',
+                    message: 'Prefix du token (ex: "Bearer " pour "Bearer xxx"):',
+                    default: 'Bearer ',
+                    when: (answers) => answers.type === 'custom'
+                },
+                {
+                    type: 'input',
+                    name: 'apiKey',
+                    message: 'Valeur de la cle API (laissez vide pour variable):',
+                    default: '${API_KEY}',
+                    when: (answers) => answers.type === 'api_key'
+                },
+                {
+                    type: 'input',
+                    name: 'username',
+                    message: 'Nom d\'utilisateur:',
+                    when: (answers) => answers.type === 'basic'
+                },
+                {
+                    type: 'password',
+                    name: 'password',
+                    message: 'Mot de passe:',
+                    mask: '*',
+                    when: (answers) => answers.type === 'basic'
+                }
+            ]);
+        }
+        // Ask for specific endpoints if API type
+        let endpoints = [];
+        if (answers.type === 'api' || answers.type === 'complete') {
+            const addEndpoints = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'addEndpoints',
+                    message: 'Voulez-vous specifier des endpoints specifiques a tester?',
+                    default: true
+                }
+            ]);
+            if (addEndpoints.addEndpoints) {
+                let adding = true;
+                while (adding) {
+                    const endpoint = await inquirer.prompt([
+                        {
+                            type: 'list',
+                            name: 'method',
+                            message: 'Methode HTTP:',
+                            choices: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
+                            default: 'GET'
+                        },
+                        {
+                            type: 'input',
+                            name: 'path',
+                            message: 'Chemin (ex: /api/users):',
+                            validate: (input) => input.length > 0 || 'Chemin requis'
+                        },
+                        {
+                            type: 'number',
+                            name: 'expectedStatus',
+                            message: 'Code HTTP attendu:',
+                            default: 200
+                        },
+                        {
+                            type: 'confirm',
+                            name: 'addBodyValidation',
+                            message: 'Voulez-vous valider le corps de la reponse?',
+                            default: false
+                        },
+                        {
+                            type: 'input',
+                            name: 'bodyValidation',
+                            message: 'Champ JSON a valider (ex: data.users.0.email, ou "status:ok" pour valeur exacte):',
+                            when: (answers) => answers.addBodyValidation
+                        },
+                        {
+                            type: 'confirm',
+                            name: 'addAnother',
+                            message: 'Ajouter un autre endpoint?',
+                            default: false
+                        }
+                    ]);
+                    endpoints.push({
+                        method: endpoint.method,
+                        path: endpoint.path,
+                        expectedStatus: endpoint.expectedStatus,
+                        bodyValidation: endpoint.bodyValidation
+                    });
+                    adding = endpoint.addAnother;
+                }
+            }
+        }
+        return this.generatePackFromAnswers({ ...answers, authConfig, endpoints });
     }
     async parseNaturalLanguage(query) {
         console.log(chalk.gray(`Analyse: "${query}"`));
@@ -101,36 +228,77 @@ export class QA360Ask {
         const baseUrl = `\${BASE_URL:-${answers.target}}`;
         switch (answers.type) {
             case 'api':
-                return this.generateApiPack(answers.name, answers.description, baseUrl);
+                return this.generateApiPack(answers.name, answers.description, baseUrl, answers.authConfig, answers.endpoints);
             case 'web':
-                return this.generateWebPack(answers.name, answers.description, baseUrl);
+                return this.generateWebPack(answers.name, answers.description, baseUrl, answers.authConfig);
             case 'performance':
-                return this.generatePerformancePack(answers.name, answers.description, baseUrl);
+                return this.generatePerformancePack(answers.name, answers.description, baseUrl, answers.authConfig);
             case 'security':
-                return this.generateSecurityPack(answers.name, answers.description, baseUrl);
+                return this.generateSecurityPack(answers.name, answers.description, baseUrl, answers.authConfig);
             case 'accessibility':
-                return this.generateAccessibilityPack(answers.name, answers.description, baseUrl);
+                return this.generateAccessibilityPack(answers.name, answers.description, baseUrl, answers.authConfig);
             case 'complete':
-                return this.generateCompletePack(answers.name, answers.description, baseUrl);
+                return this.generateCompletePack(answers.name, answers.description, baseUrl, answers.authConfig, answers.endpoints);
             default:
-                return this.generateApiPack(answers.name, answers.description, baseUrl);
+                return this.generateApiPack(answers.name, answers.description, baseUrl, answers.authConfig, answers.endpoints);
         }
     }
-    generateApiPack(name, description, baseUrl) {
+    generateApiPack(name, description, baseUrl, authConfig, endpoints) {
+        // Build smoke tests from provided endpoints or use defaults
+        let smokeTests;
+        let requests;
+        if (endpoints && endpoints.length > 0) {
+            // User provided specific endpoints - use both smoke format and request format with validation
+            smokeTests = endpoints.map(e => `${e.method} ${e.path} -> ${e.expectedStatus}`);
+            // Also build request format with response validation
+            requests = endpoints.map(e => {
+                const request = {
+                    method: e.method,
+                    path: e.path,
+                    expect: {
+                        status: e.expectedStatus
+                    }
+                };
+                // Add body validation if specified
+                if (e.bodyValidation) {
+                    // Parse body validation - could be "field:value" or "field.nested.path:value"
+                    const colonIndex = e.bodyValidation.indexOf(':');
+                    if (colonIndex !== -1) {
+                        const fieldPath = e.bodyValidation.substring(0, colonIndex);
+                        const expectedValue = e.bodyValidation.substring(colonIndex + 1);
+                        request.expect.body = parseBodyValidation(fieldPath, expectedValue);
+                    }
+                    else {
+                        // If no colon, just check field exists
+                        request.expect.body = parseBodyValidation(e.bodyValidation, null);
+                    }
+                }
+                return request;
+            });
+        }
+        else {
+            // Use default generic endpoints
+            smokeTests = [
+                'GET /health -> 200',
+                'GET /status -> 200',
+            ];
+        }
+        // Build auth config
+        const auth = buildAuthConfig(authConfig);
         return {
             version: 2,
             name,
             description,
+            auth: auth.config,
             gates: {
                 'api-health': {
                     adapter: 'playwright-api',
                     enabled: true,
+                    auth: auth.profileName,
                     config: {
                         baseUrl,
-                        smoke: [
-                            'GET /health -> 200',
-                            'GET /status -> 200',
-                        ]
+                        smoke: smokeTests,
+                        ...(requests && requests.length > 0 ? { requests } : {})
                     },
                     options: {
                         timeout: 10000,
@@ -146,15 +314,18 @@ export class QA360Ask {
             }
         };
     }
-    generateWebPack(name, description, baseUrl) {
+    generateWebPack(name, description, baseUrl, authConfig) {
+        const auth = buildAuthConfig(authConfig);
         return {
             version: 2,
             name,
             description,
+            auth: auth.config,
             gates: {
                 'ui-smoke': {
                     adapter: 'playwright-ui',
                     enabled: true,
+                    auth: auth.profileName,
                     config: {
                         baseUrl,
                         pages: [
@@ -190,15 +361,18 @@ export class QA360Ask {
             }
         };
     }
-    generatePerformancePack(name, description, baseUrl) {
+    generatePerformancePack(name, description, baseUrl, authConfig) {
+        const auth = buildAuthConfig(authConfig);
         return {
             version: 2,
             name,
             description,
+            auth: auth.config,
             gates: {
                 'api-health': {
                     adapter: 'playwright-api',
                     enabled: true,
+                    auth: auth.profileName,
                     config: {
                         baseUrl,
                         smoke: ['GET /health -> 200']
@@ -242,15 +416,18 @@ export default function () {
             }
         };
     }
-    generateSecurityPack(name, description, baseUrl) {
+    generateSecurityPack(name, description, baseUrl, authConfig) {
+        const auth = buildAuthConfig(authConfig);
         return {
             version: 2,
             name,
             description,
+            auth: auth.config,
             gates: {
                 'api-health': {
                     adapter: 'playwright-api',
                     enabled: true,
+                    auth: auth.profileName,
                     config: {
                         baseUrl,
                         smoke: ['GET / -> 200']
@@ -301,15 +478,18 @@ export default function () {
             }
         };
     }
-    generateAccessibilityPack(name, description, baseUrl) {
+    generateAccessibilityPack(name, description, baseUrl, authConfig) {
+        const auth = buildAuthConfig(authConfig);
         return {
             version: 2,
             name,
             description,
+            auth: auth.config,
             gates: {
                 'ui-smoke': {
                     adapter: 'playwright-ui',
                     enabled: true,
+                    auth: auth.profileName,
                     config: {
                         baseUrl,
                         pages: [
@@ -343,34 +523,64 @@ export default function () {
             }
         };
     }
-    generateCompletePack(name, description, baseUrl) {
+    generateCompletePack(name, description, baseUrl, authConfig, endpoints) {
+        const auth = buildAuthConfig(authConfig);
+        // Build smoke tests from provided endpoints or use defaults
+        let apiSmokeTests;
+        let apiCrudTests;
+        let requests;
+        if (endpoints && endpoints.length > 0) {
+            // User provided specific endpoints
+            apiSmokeTests = endpoints.filter(e => e.method === 'GET').map(e => `${e.method} ${e.path} -> ${e.expectedStatus}`);
+            apiCrudTests = endpoints.map(e => `${e.method} ${e.path} -> ${e.expectedStatus}`);
+            // Build request format with response validation
+            requests = endpoints.map(e => {
+                const request = {
+                    method: e.method,
+                    path: e.path,
+                    expect: {
+                        status: e.expectedStatus
+                    }
+                };
+                if (e.bodyValidation) {
+                    const colonIndex = e.bodyValidation.indexOf(':');
+                    if (colonIndex !== -1) {
+                        const fieldPath = e.bodyValidation.substring(0, colonIndex);
+                        const expectedValue = e.bodyValidation.substring(colonIndex + 1);
+                        request.expect.body = parseBodyValidation(fieldPath, expectedValue);
+                    }
+                    else {
+                        request.expect.body = parseBodyValidation(e.bodyValidation, null);
+                    }
+                }
+                return request;
+            });
+        }
+        else {
+            // Use default generic endpoints
+            apiSmokeTests = ['GET /health -> 200', 'GET /api/v1/status -> 200'];
+            apiCrudTests = [
+                'GET /api/v1/users -> 200',
+                'POST /api/v1/users -> 201',
+                'PUT /api/v1/users/1 -> 200',
+                'DELETE /api/v1/users/1 -> 204'
+            ];
+        }
         return {
             version: 2,
             name,
             description,
-            auth: {
-                api: 'default-bearer',
-                profiles: {
-                    'default-bearer': {
-                        type: 'bearer',
-                        config: {
-                            token: '${API_TOKEN:-your-token-here}'
-                        }
-                    }
-                }
-            },
+            auth: auth.config,
             gates: {
                 // API Health Check
                 'api-health': {
                     adapter: 'playwright-api',
                     enabled: true,
-                    auth: 'default-bearer',
+                    auth: auth.profileName,
                     config: {
                         baseUrl,
-                        smoke: [
-                            'GET /health -> 200',
-                            'GET /api/v1/status -> 200'
-                        ]
+                        smoke: apiSmokeTests.length > 0 ? apiSmokeTests : ['GET /health -> 200', 'GET /api/v1/status -> 200'],
+                        ...(requests && requests.length > 0 ? { requests } : {})
                     },
                     options: {
                         timeout: 5000,
@@ -381,10 +591,10 @@ export default function () {
                 'api-crud': {
                     adapter: 'playwright-api',
                     enabled: true,
-                    auth: 'default-bearer',
+                    auth: auth.profileName,
                     config: {
                         baseUrl,
-                        smoke: [
+                        smoke: apiCrudTests.length > 0 ? apiCrudTests : [
                             'GET /api/v1/users -> 200',
                             'POST /api/v1/users -> 201',
                             'PUT /api/v1/users/1 -> 200',
@@ -566,6 +776,122 @@ export default function () {
         }
     }
 }
+/**
+ * Build auth config from user answers
+ */
+function buildAuthConfig(authConfig) {
+    if (!authConfig || !authConfig.type) {
+        return { config: undefined, profileName: undefined };
+    }
+    const profiles = {};
+    let profileName = 'default-auth';
+    switch (authConfig.type) {
+        case 'bearer':
+            profileName = 'bearer-auth';
+            profiles[profileName] = {
+                type: 'bearer',
+                config: {
+                    token: authConfig.bearerToken || '${API_TOKEN}'
+                }
+            };
+            break;
+        case 'api_key':
+            profileName = 'api-key-auth';
+            profiles[profileName] = {
+                type: 'api_key',
+                config: {
+                    header_name: authConfig.headerName || 'x-api-key',
+                    value: authConfig.apiKey || '${API_KEY}'
+                }
+            };
+            break;
+        case 'basic':
+            profileName = 'basic-auth';
+            profiles[profileName] = {
+                type: 'basic',
+                config: {
+                    username: authConfig.username || '${BASIC_USERNAME}',
+                    password: authConfig.password || '${BASIC_PASSWORD}'
+                }
+            };
+            break;
+        case 'custom':
+            profileName = 'custom-auth';
+            profiles[profileName] = {
+                type: 'bearer',
+                config: {
+                    token: authConfig.tokenPrefix ? `${authConfig.tokenPrefix}\${CUSTOM_TOKEN}` : '${CUSTOM_TOKEN}'
+                },
+                cache: {
+                    enabled: true,
+                    ttl: 300
+                }
+            };
+            break;
+    }
+    return {
+        config: {
+            api: profileName,
+            profiles
+        },
+        profileName
+    };
+}
+/**
+ * Parse body validation string into nested object
+ * Format: "field.nested.path:value" or just "field.nested.path"
+ *
+ * Examples:
+ *   - "data.users.0.email" -> checks if field exists
+ *   - "status:ok" -> checks if status == "ok"
+ *   - "data.count:5" -> checks if data.count == 5
+ *   - "data.items.length:>0" -> checks if data.items.length > 0
+ */
+function parseBodyValidation(fieldPath, expectedValue) {
+    const parts = fieldPath.split('.');
+    const result = {};
+    // Build nested object from path
+    let current = result;
+    for (let i = 0; i < parts.length - 1; i++) {
+        current[parts[i]] = {};
+        current = current[parts[i]];
+    }
+    // Set the final value
+    const lastKey = parts[parts.length - 1];
+    if (expectedValue === null) {
+        // Just check field exists - use special sentinel
+        current[lastKey] = '__exists__';
+    }
+    else if (expectedValue.startsWith('>')) {
+        // Greater than comparison
+        const numValue = parseFloat(expectedValue.substring(1));
+        current[lastKey] = { $gt: isNaN(numValue) ? expectedValue.substring(1) : numValue };
+    }
+    else if (expectedValue.startsWith('<')) {
+        // Less than comparison
+        const numValue = parseFloat(expectedValue.substring(1));
+        current[lastKey] = { $lt: isNaN(numValue) ? expectedValue.substring(1) : numValue };
+    }
+    else if (expectedValue === 'true') {
+        current[lastKey] = true;
+    }
+    else if (expectedValue === 'false') {
+        current[lastKey] = false;
+    }
+    else if (/^\d+$/.test(expectedValue)) {
+        // Numeric value
+        current[lastKey] = parseInt(expectedValue, 10);
+    }
+    else if (/^\d+\.\d+$/.test(expectedValue)) {
+        // Float value
+        current[lastKey] = parseFloat(expectedValue);
+    }
+    else {
+        // String value
+        current[lastKey] = expectedValue;
+    }
+    return result;
+}
 export async function askCommand(query) {
     const ask = new QA360Ask();
     try {

package/cli/dist/commands/coverage.js

@@ -5,7 +5,7 @@
  */
 import { Command } from 'commander';
 import { existsSync } from 'fs';
-import { CoverageCollector, CoverageAnalyzer, parseCoverageThreshold, formatCoverageThreshold } from '../core/index.js';
+import { CoverageCollector, CoverageAnalyzer, parseCoverageThreshold, formatCoverageThreshold } from 'qa360-core';
 export const coverageCommand = new Command('coverage');
 coverageCommand.description('Coverage analytics and reporting');
 // Show coverage for a specific file or run

package/cli/dist/commands/crawl.js

@@ -6,7 +6,7 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import ora from 'ora';
-import { generatePackFromCrawl, quickCrawl } from '../core/index.js';
+import { generatePackFromCrawl, quickCrawl } from 'qa360-core';
 /**
  * Create crawl command
  */

package/cli/dist/commands/doctor.js

@@ -255,7 +255,7 @@ export class QA360Doctor {
     }
     async checkProofKeys() {
         try {
-            const { ensureProofKeys } = await import('../core/index.js');
+            const { ensureProofKeys } = await import('qa360-core');
             const result = await ensureProofKeys(this.qa360Dir);
             // Validate result
             if (!result) {
@@ -300,7 +300,7 @@ export class QA360Doctor {
     }
     async checkProofRoundtrip() {
         try {
-            const coreModule = await import('../core/index.js');
+            const coreModule = await import('qa360-core');
             const { generateKeys, createProofBundle, verifyProofBundle } = coreModule;
             // Guard: Verify exports are functions
             if (typeof generateKeys !== 'function') {

package/cli/dist/commands/explain.js

@@ -17,8 +17,8 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { join } from 'path';
 import { existsSync } from 'fs';
-import { createBest, createLLMProvider } from '../core/index.js';
-import { EvidenceVault } from '../core/index.js';
+import { createBest, createLLMProvider } from 'qa360-core';
+import { EvidenceVault } from 'qa360-core';
 /**
  * Static error code database
  */

package/cli/dist/commands/flakiness.js

@@ -8,7 +8,7 @@ import chalk from 'chalk';
 import Table from 'cli-table3';
 import { join } from 'path';
 import { existsSync } from 'fs';
-import { EvidenceVault, FLAKINESS_CATEGORIES } from '../core/index.js';
+import { EvidenceVault, FLAKINESS_CATEGORIES } from 'qa360-core';
 /**
  * Get the vault directory path
  */

package/cli/dist/commands/generate.js

@@ -11,7 +11,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { writeFileSync, mkdirSync, existsSync } from 'fs';
 import { dirname, resolve } from 'path';
-import { generateTests, generateApiTestsFromOpenAPI, generateUiTestsFromUrl, generatePerfTests, generateUnitTests, checkGenerationAvailability, } from '../core/index.js';
+import { generateTests, generateApiTestsFromOpenAPI, generateUiTestsFromUrl, generatePerfTests, generateUnitTests, checkGenerationAvailability, } from 'qa360-core';
 /**
  * Create generate commands group
  */

package/cli/dist/commands/history.js

@@ -7,7 +7,7 @@ import { existsSync, createWriteStream, readFileSync, statSync, readdirSync, unl
 import { join } from 'path';
 import chalk from 'chalk';
 import AdmZip from 'adm-zip';
-import { EvidenceVault } from '../core/index.js';
+import { EvidenceVault } from 'qa360-core';
 export class QA360History {
     vault;
     constructor() { }

package/cli/dist/commands/monitor.js

@@ -4,9 +4,9 @@
  */
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { TUIMonitor } from '../core/index.js';
-import { DashboardServer, EvidenceVault } from '../core/index.js';
-import { Phase3Runner } from '../core/index.js';
+import { TUIMonitor } from 'qa360-core';
+import { DashboardServer, EvidenceVault } from 'qa360-core';
+import { Phase3Runner } from 'qa360-core';
 import { existsSync } from 'fs';
 import { join } from 'path';
 import { loadPackConfig } from '../utils/config.js';

package/cli/dist/commands/ollama.js

@@ -7,7 +7,7 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import ora from 'ora';
-import { checkOllamaSetup, OllamaProvider, OllamaError } from '../core/index.js';
+import { checkOllamaSetup, OllamaProvider, OllamaError } from 'qa360-core';
 import { loadQA360Config, updateQA360Config, getConfigPath } from '../utils/config.js';
 /**
  * Test Ollama connection

package/cli/dist/commands/pack.js

@@ -9,8 +9,8 @@ import { resolve } from 'path';
 import chalk from 'chalk';
 import ora from 'ora';
 import * as yaml from 'js-yaml';
-import { PackValidator, PackMigrator as PackMigratorV1 } from '../core/index.js';
-import { PackValidatorV2, PackMigrator, PackLoaderV2 } from '../core/index.js';
+import { PackValidator, PackMigrator as PackMigratorV1 } from 'qa360-core';
+import { PackValidatorV2, PackMigrator, PackLoaderV2 } from 'qa360-core';
 export class QA360Pack {
     qa360Dir = resolve(process.cwd(), '.qa360');
     packPath = resolve(this.qa360Dir, 'pack.yml');

package/cli/dist/commands/regression.js

@@ -4,7 +4,7 @@
  * CLI command for regression detection and analysis.
  */
 import { Command } from 'commander';
-import { createRegressionDetector, createRegressionTrendAnalyzer } from '../core/index.js';
+import { createRegressionDetector, createRegressionTrendAnalyzer } from 'qa360-core';
 export const regressionCommand = new Command('regression');
 regressionCommand.description('Regression detection and analysis');
 // Detect regressions

package/cli/dist/commands/repair.js

@@ -7,7 +7,7 @@ import { Command } from 'commander';
 import { readFile } from 'fs/promises';
 import { existsSync } from 'fs';
 import { resolve } from 'path';
-import { TestRepairer, analyzeTestErrors, getQuickFixes } from '../core/index.js';
+import { TestRepairer, analyzeTestErrors, getQuickFixes } from 'qa360-core';
 /**
  * Parse test output to extract errors
  */