qa360 2.1.0 → 2.1.2

package/dist/commands/scan.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Scan Command - Discover UI elements from a web page
+ */
+import { Command } from 'commander';
+export declare const scanCommand: Command;

package/dist/commands/scan.js

@@ -0,0 +1,155 @@
+/**
+ * Scan Command - Discover UI elements from a web page
+ */
+import { Command } from 'commander';
+import { chromium } from '@playwright/test';
+import { DOMScanner } from '../scanners/dom-scanner.js';
+import { JSONReporter } from '../generators/json-reporter.js';
+import { TestGenerator } from '../generators/test-generator.js';
+import { resolve } from 'path';
+import { mkdirSync } from 'fs';
+export const scanCommand = new Command('scan');
+scanCommand
+    .description('Scan a web page for UI elements and generate test configurations')
+    .argument('<url>', 'URL of the page to scan')
+    .option('-o, --output <file>', 'Output file path (default: ".qa360/discovery/elements.json")')
+    .option('-i, --include <types>', 'Element types to include: buttons,links,forms,inputs,images,headings,all (default: "all")')
+    .option('-e, --exclude <selectors>', 'CSS selectors to exclude (comma-separated)')
+    .option('-s, --screenshot', 'Capture screenshots of elements (not yet implemented)')
+    .option('-a, --auto-generate-test', 'Auto-generate QA360 test file')
+    .option('-t, --timeout <ms>', 'Navigation timeout in milliseconds', '30000')
+    .option('--headed', 'Run in headed mode (show browser)')
+    .action(async (url, options) => {
+    const startTime = Date.now();
+    // Validate URL
+    try {
+        new URL(url);
+    }
+    catch {
+        console.error(`❌ Invalid URL: ${url}`);
+        process.exit(1);
+    }
+    // Parse include types
+    const includeTypes = options.include || 'all';
+    const include = includeTypes
+        .split(',')
+        .map((t) => t.trim().toLowerCase());
+    // Validate element types
+    const validTypes = ['buttons', 'links', 'forms', 'inputs', 'images', 'headings', 'all'];
+    for (const type of include) {
+        if (!validTypes.includes(type)) {
+            console.error(`❌ Invalid element type: ${type}`);
+            console.error(`   Valid types: ${validTypes.join(', ')}`);
+            process.exit(1);
+        }
+    }
+    // Parse exclude selectors
+    const exclude = options.exclude
+        ? options.exclude.split(',').map((s) => s.trim())
+        : [];
+    const scanOptions = {
+        url,
+        output: options.output || '.qa360/discovery/elements.json',
+        include,
+        exclude,
+        screenshot: options.screenshot || false,
+        autoGenerateTest: options.autoGenerateTest || false,
+        timeout: parseInt(options.timeout, 10) || 30000,
+        headless: !options.headed
+    };
+    console.log(`🔍 Scanning page: ${url}`);
+    console.log('━'.repeat(50));
+    let browser = null;
+    let context = null;
+    let page = null;
+    try {
+        // Launch browser
+        browser = await chromium.launch({
+            headless: scanOptions.headless
+        });
+        context = await browser.newContext({
+            viewport: { width: 1280, height: 720 }
+        });
+        page = await context.newPage();
+        // Navigate to URL
+        await page.goto(url, {
+            timeout: scanOptions.timeout,
+            waitUntil: 'networkidle'
+        });
+        // Run scan
+        const scanner = new DOMScanner(page, url);
+        const elements = await scanner.scan(scanOptions);
+        // Generate summary
+        const summary = {
+            totalElements: elements.length,
+            buttons: elements.filter(e => e.type === 'button').length,
+            links: elements.filter(e => e.type === 'link').length,
+            forms: elements.filter(e => e.type === 'form').length,
+            inputs: elements.filter(e => e.type === 'input').length,
+            images: elements.filter(e => e.type === 'image').length,
+            headings: elements.filter(e => e.type === 'heading').length
+        };
+        // Print summary
+        console.log(`✅ Buttons found:      ${summary.buttons}`);
+        console.log(`✅ Links found:        ${summary.links}`);
+        console.log(`✅ Forms found:        ${summary.forms}`);
+        console.log(`✅ Inputs found:       ${summary.inputs}`);
+        console.log(`✅ Images found:       ${summary.images}`);
+        console.log(`✅ Headings found:     ${summary.headings}`);
+        console.log('━'.repeat(50));
+        console.log(`📦 Total elements:     ${summary.totalElements}`);
+        console.log();
+        // Create output directory
+        const outputPath = resolve(scanOptions.output);
+        const outputDir = outputPath.substring(0, outputPath.lastIndexOf('/'));
+        mkdirSync(outputDir, { recursive: true });
+        // Generate scan result
+        const result = {
+            scanDate: new Date().toISOString(),
+            url,
+            duration: Date.now() - startTime,
+            summary,
+            elements
+        };
+        // Generate JSON report
+        const reporter = new JSONReporter();
+        await reporter.generate(result, outputPath);
+        console.log(`💾 Saved to: ${outputPath}`);
+        // Auto-generate test if requested
+        if (options.autoGenerateTest) {
+            const testGenerator = new TestGenerator();
+            const testPath = outputPath.replace('.json', '.yml');
+            await testGenerator.generate(result, testPath);
+            console.log(`📄 Test generated: ${testPath}`);
+        }
+        // Screenshots (placeholder for future implementation)
+        if (options.screenshot) {
+            console.log(`📸 Screenshots: ${outputDir}/screenshots/ (not yet implemented)`);
+        }
+        // Cleanup
+        await page.close();
+        await context.close();
+        await browser.close();
+        console.log();
+        console.log(`✨ Scan completed in ${((Date.now() - startTime) / 1000).toFixed(1)}s`);
+        console.log();
+        console.log('💡 Next steps:');
+        console.log(`   • Review the discovered elements`);
+        if (options.autoGenerateTest) {
+            console.log(`   • Run the auto-generated test: qa360 run ${outputPath.replace('.json', '.yml')}`);
+        }
+        console.log(`   • Edit the test to remove unwanted elements`);
+    }
+    catch (error) {
+        // Cleanup on error
+        if (page)
+            await page.close().catch(() => { });
+        if (context)
+            await context.close().catch(() => { });
+        if (browser)
+            await browser.close().catch(() => { });
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`❌ Scan failed: ${errorMessage}`);
+        process.exit(1);
+    }
+});

package/dist/commands/secrets.d.ts

@@ -8,7 +8,10 @@ export declare class QA360Secrets {
     /**
      * Add a secret
      */
-    add(secretName?: string): Promise<{
+    add(secretName?: string, options?: {
+        value?: string;
+        nonInteractive?: boolean;
+    }): Promise<{
         success: boolean;
         exitCode: number;
     }>;
@@ -43,7 +46,10 @@ export declare class QA360Secrets {
         exitCode: number;
     }>;
 }
-export declare function secretsAddCommand(secretName?: string): Promise<void>;
+export declare function secretsAddCommand(secretName?: string, options?: {
+    value?: string;
+    nonInteractive?: boolean;
+}): Promise<void>;
 export declare function secretsListCommand(): Promise<void>;
 export declare function secretsRemoveCommand(secretName?: string): Promise<void>;
 export declare function secretsDoctorCommand(): Promise<void>;

package/dist/commands/secrets.js

@@ -14,12 +14,17 @@ export class QA360Secrets {
     /**
      * Add a secret
      */
-    async add(secretName) {
+    async add(secretName, options = {}) {
         try {
             let name = secretName;
             let value;
-            // Interactive mode if no name provided
+            // Interactive mode if no name provided (and not non-interactive)
             if (!name) {
+                if (options.nonInteractive) {
+                    console.log(chalk.red('❌ Nom du secret requis en mode non-interactif'));
+                    console.log(chalk.yellow('💡 Usage: qa360 secrets add <NOM> --value <VALUE> --non-interactive'));
+                    return { success: false, exitCode: 1 };
+                }
                 const nameAnswer = await inquirer.prompt([{
                         type: 'input',
                         name: 'secretName',
@@ -39,22 +44,29 @@ export class QA360Secrets {
                 console.log(chalk.yellow('💡 Format requis: MAJUSCULES_AVEC_UNDERSCORES (ex: API_TOKEN)'));
                 return { success: false, exitCode: 1 };
             }
-            // Get secret value securely
-            const valueAnswer = await inquirer.prompt([{
-                    type: 'password',
-                    name: 'secretValue',
-                    message: `Valeur pour ${name}:`,
-                    mask: '*',
-                    validate: (input) => {
-                        if (!input.trim()) {
-                            return 'La valeur ne peut pas être vide';
+            // Get secret value
+            if (options.value) {
+                // Non-interactive mode: value provided via option
+                value = options.value;
+            }
+            else {
+                // Interactive mode: prompt for value
+                const valueAnswer = await inquirer.prompt([{
+                        type: 'password',
+                        name: 'secretValue',
+                        message: `Valeur pour ${name}:`,
+                        mask: '*',
+                        validate: (input) => {
+                            if (!input.trim()) {
+                                return 'La valeur ne peut pas être vide';
+                            }
+                            return true;
                         }
-                        return true;
-                    }
-                }]);
-            value = valueAnswer.secretValue;
-            // Check if it looks like a secret
-            if (!SecretsCrypto.looksLikeSecret(value)) {
+                    }]);
+                value = valueAnswer.secretValue;
+            }
+            // Check if it looks like a secret (skip in non-interactive mode)
+            if (!options.nonInteractive && !SecretsCrypto.looksLikeSecret(value)) {
                 const confirmAnswer = await inquirer.prompt([{
                         type: 'confirm',
                         name: 'confirm',
@@ -250,9 +262,9 @@ export class QA360Secrets {
     }
 }
 // Command handlers
-export async function secretsAddCommand(secretName) {
+export async function secretsAddCommand(secretName, options) {
     const secrets = new QA360Secrets();
-    const result = await secrets.add(secretName);
+    const result = await secrets.add(secretName, options);
     process.exit(result.exitCode);
 }
 export async function secretsListCommand() {

package/dist/core/core/coverage/analyzer.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Coverage Analyzer
+ *
+ * Analyzes coverage data to provide insights, trends, and recommendations.
+ */
+import type { FileCoverage, CoverageMetrics, CoverageResult, CoverageTrend, CoverageGap, CoverageComparison, CoverageThreshold, CoverageType, CoverageReport } from './types.js';
+/**
+ * Historical coverage data point
+ */
+interface HistoricalCoverage {
+    runId: string;
+    timestamp: number;
+    metrics: CoverageMetrics;
+}
+/**
+ * Coverage Analyzer class
+ */
+export declare class CoverageAnalyzer {
+    private history;
+    /**
+     * Analyze coverage and generate insights
+     */
+    analyze(result: CoverageResult, threshold?: CoverageThreshold): CoverageReport;
+    /**
+     * Check if coverage meets thresholds
+     */
+    checkThresholds(metrics: CoverageMetrics, threshold?: CoverageThreshold): boolean;
+    /**
+     * Check if a single file meets thresholds
+     */
+    checkFileThresholds(file: FileCoverage, threshold?: CoverageThreshold): boolean;
+    /**
+     * Find coverage gaps
+     */
+    findGaps(files: Record<string, FileCoverage>, threshold?: CoverageThreshold): CoverageGap[];
+    /**
+     * Calculate priority for covering a file
+     */
+    private calculatePriority;
+    /**
+     * Estimate effort to cover a file
+     */
+    private estimateEffort;
+    /**
+     * Generate test suggestions for a file
+     */
+    private generateSuggestions;
+    /**
+     * Group consecutive numbers into ranges
+     */
+    private groupConsecutiveNumbers;
+    /**
+     * Get top and bottom files by coverage
+     */
+    getTopFiles(files: Record<string, FileCoverage>, limit?: number): Array<{
+        path: string;
+        coverage: number;
+        type: 'best' | 'worst';
+    }>;
+    /**
+     * Compare two coverage results
+     */
+    compare(baseResult: CoverageResult, compareResult: CoverageResult): CoverageComparison;
+    /**
+     * Add historical coverage data
+     */
+    addHistory(key: string, data: HistoricalCoverage): void;
+    /**
+     * Get coverage trends
+     */
+    getTrends(key: string, type?: CoverageType, limit?: number): CoverageTrend[];
+    /**
+     * Calculate trend direction
+     */
+    getTrendDirection(trends: CoverageTrend[]): 'improving' | 'stable' | 'declining';
+    /**
+     * Predict future coverage based on trends
+     */
+    predictCoverage(key: string, type: CoverageType | undefined, targetCoverage: number): {
+        predictedReach: number | null;
+        projectedCoverage: number;
+        confidence: 'high' | 'medium' | 'low';
+    };
+    /**
+     * Generate coverage summary text
+     */
+    generateSummary(metrics: CoverageMetrics): string;
+    /**
+     * Format coverage percentage with color indicator
+     */
+    formatCoverage(percentage: number, threshold?: number): string;
+    /**
+     * Clear history
+     */
+    clearHistory(key?: string): void;
+}
+/**
+ * Create a coverage analyzer
+ */
+export declare function createCoverageAnalyzer(): CoverageAnalyzer;
+export {};