qa360 2.3.1 → 2.3.3

package/dist/commands/ask.js

@@ -184,33 +184,42 @@ export class QA360Ask {
         console.log(chalk.gray(`Analyse: "${query}"`));
         // Detection de patterns simples (Phase 1 - deterministe)
         const patterns = {
-            api: /\b(api|rest|graphql|endpoint|swagger|openapi)\b/i,
-            web: /\b(web|ui|interface|page|site|browser)\b/i,
-            performance: /\b(performance|perf|load|stress|speed|latency)\b/i,
+            complete: /\b(complete|full|comprehensive|end-to-end|e2e|suite|tout)\b/i,
             security: /\b(security|sécurité|secu|dast|vuln|scan|pentest|zap)\b/i,
+            performance: /\b(performance|perf|load|stress|speed|latency|charge|charge)\b/i,
             accessibility: /\b(accessibility|a11y|accessible|wcag)\b/i,
-            complete: /\b(complete|full|comprehensive|end-to-end|e2e|suite)\b/i
+            web: /\b(web|ui|interface|page|site|browser|login|auth|signin|signup|registration|connexion|inscription)\b/i,
+            api: /\b(api|rest|graphql|endpoint|swagger|openapi)\b/i
         };
         // URL extraction
         const urlMatch = query.match(/https?:\/\/[^\s]+/);
         const target = urlMatch ? urlMatch[0] : 'https://httpbin.org';
-        // Type detection with priority for complete and security
-        let type = 'api'; // default
-        // Check for complete first (highest priority)
+        // Type detection with priority order
+        let type = 'web'; // default to web (UI) for generic queries like "login tests"
+        // Check patterns in priority order
         if (patterns.complete.test(query)) {
             type = 'complete';
         }
         else if (patterns.security.test(query)) {
             type = 'security';
         }
-        else {
-            // Check other patterns
-            for (const [key, pattern] of Object.entries(patterns)) {
-                if (key !== 'complete' && key !== 'security' && pattern.test(query)) {
-                    type = key;
-                    break;
-                }
-            }
+        else if (patterns.performance.test(query)) {
+            type = 'performance';
+        }
+        else if (patterns.accessibility.test(query)) {
+            type = 'accessibility';
+        }
+        else if (patterns.web.test(query)) {
+            type = 'web';
+        }
+        else if (patterns.api.test(query)) {
+            type = 'api';
+        }
+        // If no pattern matched, default to 'web' for login-like scenarios, otherwise 'api'
+        // Special handling for login/auth scenarios - default to web (UI) tests
+        const loginKeywords = /\b(login|auth|authentication|signin|signup|register|connexion|inscription|form)\b/i;
+        if (loginKeywords.test(query) && type === 'api') {
+            type = 'web';
         }
         // Pack name from query
         const name = query.toLowerCase()
@@ -316,6 +325,29 @@ export class QA360Ask {
     }
     generateWebPack(name, description, baseUrl, authConfig) {
         const auth = buildAuthConfig(authConfig);
+        // Check if this is a login/auth scenario based on name or description
+        const isLoginScenario = /\b(login|auth|signin|signup|connexion|inscription)\b/i.test(name + ' ' + description);
+        // Build pages based on scenario type
+        const pages = isLoginScenario ? [
+            {
+                url: '/login',
+                expectedElements: ['input[type="email"]', 'input[type="password"]', 'button[type="submit"]'],
+                actions: [
+                    { type: 'fill', selector: 'input[type="email"]', value: '${TEST_EMAIL}' },
+                    { type: 'fill', selector: 'input[type="password"]', value: '${TEST_PASSWORD}' },
+                    { type: 'click', selector: 'button[type="submit"]' }
+                ]
+            },
+            {
+                url: '/',
+                expectedElements: ['header', 'nav']
+            }
+        ] : [
+            {
+                url: '/',
+                expectedElements: ['body', 'main']
+            }
+        ];
         return {
             version: 2,
             name,
@@ -328,12 +360,7 @@ export class QA360Ask {
                     auth: auth.profileName,
                     config: {
                         baseUrl,
-                        pages: [
-                            {
-                                url: '/',
-                                expectedElements: ['body', 'main']
-                            }
-                        ]
+                        pages
                     }
                 },
                 'a11y': {
@@ -343,7 +370,7 @@ export class QA360Ask {
                         baseUrl,
                         pages: [
                             {
-                                url: '/',
+                                url: isLoginScenario ? '/login' : '/',
                                 a11yRules: ['wcag2a', 'wcag2aa']
                             }
                         ]

package/dist/commands/coverage.js

@@ -18,7 +18,14 @@ coverageCommand
     .option('--verbose', 'Show detailed file-by-file coverage')
     .action(async (options) => {
     if (!options.file && !options.run) {
-        console.error('Error: Please specify --file or --run');
+        console.error('Error: Please specify --file or --run to show coverage\n');
+        console.error('Usage: qa360 coverage show --file <path>');
+        console.error('   or: qa360 coverage show --run <id>\n');
+        console.error('Examples:');
+        console.error('  qa360 coverage show --file coverage/coverage-final.json');
+        console.error('  qa360 coverage show --file coverage/lcov.info');
+        console.error('  qa360 coverage show --run abc123\n');
+        console.error('Tip: Use "qa360 coverage list" to find available coverage files in your project.');
         process.exit(1);
     }
     const collector = new CoverageCollector();
@@ -82,7 +89,10 @@ coverageCommand
     .option('--json', 'Output as JSON')
     .action(async (options) => {
     if (!options.file) {
-        console.error('Error: Please specify --file');
+        console.error('Error: Please specify --file to analyze coverage\n');
+        console.error('Usage: qa360 coverage analyze --file <path>\n');
+        console.error('Example: qa360 coverage analyze --file coverage/coverage-final.json\n');
+        console.error('Tip: Use "qa360 coverage list" to find available coverage files in your project.');
         process.exit(1);
     }
     if (!existsSync(options.file)) {
@@ -218,7 +228,10 @@ coverageCommand
     .option('--fail', 'Exit with error code if thresholds not met')
     .action(async (options) => {
     if (!options.file) {
-        console.error('Error: Please specify --file');
+        console.error('Error: Please specify --file to check coverage\n');
+        console.error('Usage: qa360 coverage check --file <path>\n');
+        console.error('Example: qa360 coverage check --file coverage/coverage-final.json\n');
+        console.error('Tip: Use "qa360 coverage list" to find available coverage files in your project.');
         process.exit(1);
     }
     if (!existsSync(options.file)) {

package/dist/commands/generate.js

@@ -91,10 +91,17 @@ export async function generateCommand(source, options = {}) {
         const { available, models, recommended } = await checkGenerationAvailability();
         if (!available) {
             spinner.fail('Ollama not available');
-            console.log(chalk.red('\nOllama is not running'));
-            console.log(chalk.yellow('\nStart Ollama:'));
-            console.log(chalk.gray('  ollama serve'));
-            console.log(chalk.yellow('\nInstall Ollama:'));
+            console.log(chalk.red('\n❌ Ollama is not running or not reachable'));
+            console.log(chalk.yellow('\n🔧 Troubleshooting:'));
+            console.log(chalk.gray('  1. Check if Ollama is running:'));
+            console.log(chalk.cyan('     ollama list'));
+            console.log(chalk.gray('  2. Start Ollama if needed:'));
+            console.log(chalk.cyan('     ollama serve'));
+            console.log(chalk.gray('  3. Test QA360 connection to Ollama:'));
+            console.log(chalk.cyan('     qa360 ollama test'));
+            console.log(chalk.gray('  4. Set custom Ollama URL if needed:'));
+            console.log(chalk.cyan('     qa360 ollama config --set-url http://localhost:11434'));
+            console.log(chalk.yellow('\n📦 Install Ollama:'));
             console.log(chalk.gray('  brew install ollama  # macOS'));
             console.log(chalk.gray('  # Or visit: https://ollama.com\n'));
             return;

package/dist/commands/ollama.js

@@ -19,12 +19,20 @@ export async function ollamaTestCommand(options = {}) {
         const check = await checkOllamaSetup(model);
         if (!check.available) {
             spinner.fail('Ollama is not available');
-            console.log(chalk.red('\n❌ Ollama is not running or not installed'));
+            console.log(chalk.red('\n❌ Ollama is not running or not reachable'));
+            console.log(chalk.yellow('\n🔧 Troubleshooting steps:'));
+            console.log(chalk.gray('\n  1. Verify Ollama is running:'));
+            console.log(chalk.cyan('     ollama list'));
+            console.log(chalk.gray('\n  2. Start Ollama if not running:'));
+            console.log(chalk.cyan('     ollama serve'));
+            console.log(chalk.gray('\n  3. Check Ollama is listening on default port:'));
+            console.log(chalk.cyan('     curl http://localhost:11434/api/tags'));
+            console.log(chalk.gray('\n  4. Set custom URL if Ollama is on different port/host:'));
+            console.log(chalk.cyan('     qa360 ollama config --set-url http://localhost:11434'));
+            console.log(chalk.gray('\n  5. Check for firewall/proxy issues blocking localhost:11434'));
             console.log(chalk.yellow('\n📦 To install Ollama:'));
             console.log(chalk.gray('  brew install ollama     # macOS'));
-            console.log(chalk.gray('  # Or visit: https://ollama.com'));
-            console.log(chalk.yellow('\n🚀 To start Ollama:'));
-            console.log(chalk.gray('  ollama serve'));
+            console.log(chalk.gray('  # Or visit: https://ollama.com\n'));
             return;
         }
         spinner.succeed('Ollama is running!');
@@ -175,7 +183,7 @@ export async function ollamaGenerateCommand(prompt, options = {}) {
 export async function ollamaConfigCommand(options = {}) {
     const config = loadQA360Config();
     const ollamaConfig = config.ollama || {};
-    const defaultBaseUrl = 'http://localhost:11434';
+    const defaultBaseUrl = 'http://127.0.0.1:11434';
     const defaultModel = 'deepseek-coder';
     // Update config if options provided
     if (options.setUrl || options.setModel) {

package/dist/commands/run.d.ts

@@ -39,3 +39,7 @@ export declare function displayResults(result: Phase3RunResult): void;
  */
 export declare function runCommand(packArg?: string, options?: RunOptions): Promise<void>;
 export default runCommand;
+/**
+ * Preflight command - Validate pack without executing tests
+ */
+export declare function preflightCommand(packArg?: string): Promise<void>;

package/dist/commands/run.js

@@ -170,3 +170,89 @@ export async function runCommand(packArg, options = {}) {
 }
 // Export for CLI integration
 export default runCommand;
+/**
+ * Preflight command - Validate pack without executing tests
+ */
+export async function preflightCommand(packArg) {
+    try {
+        console.log(chalk.blue('\n🔍 QA360 Preflight - Dry-run validation\n'));
+        // Step 1: Find pack file
+        const packPath = findPackFile(packArg);
+        console.log(chalk.gray(`Pack file: ${packPath}`));
+        // Step 2: Load and validate pack
+        const pack = await loadPack(packPath);
+        console.log(chalk.green(`✅ Pack: ${pack.name} v${pack.version}`));
+        // Step 3: Validate structure
+        const issues = [];
+        // Check required fields
+        if (!pack.name) {
+            issues.push('Missing required field: name');
+        }
+        if (!pack.version) {
+            issues.push('Missing required field: version');
+        }
+        if (!pack.gates || Object.keys(pack.gates).length === 0) {
+            issues.push('No gates defined - nothing to test');
+        }
+        // Validate gates
+        const gateNames = Object.keys(pack.gates || {});
+        if (gateNames.length > 0) {
+            console.log(chalk.gray(`\nGates (${gateNames.length}):`));
+            for (const [gateName, gateConfig] of Object.entries(pack.gates || {})) {
+                const gate = gateConfig;
+                const status = gate.enabled === false ? chalk.yellow('(disabled)') : chalk.green('(enabled)');
+                console.log(`  ${status} ${chalk.cyan(gateName)}`);
+                if (!gate.adapter) {
+                    issues.push(`  ⚠️  Gate "${gateName}" missing adapter`);
+                }
+                else {
+                    console.log(`     Adapter: ${gate.adapter}`);
+                }
+                // Show pages/config summary
+                if (gate.config?.pages) {
+                    const pages = gate.config.pages;
+                    const pageCount = Array.isArray(pages) ? pages.length : Object.keys(pages).length;
+                    console.log(`     Pages: ${pageCount}`);
+                }
+                if (gate.config?.smoke) {
+                    const smoke = gate.config.smoke;
+                    const testCount = Array.isArray(smoke) ? smoke.length : 1;
+                    console.log(`     Smoke tests: ${testCount}`);
+                }
+            }
+        }
+        // Validate auth config (only for v2 packs)
+        if (pack.version === 2 && pack.auth) {
+            const auth = pack.auth;
+            console.log(chalk.gray('\nAuthentication:'));
+            if (auth.api) {
+                console.log(`  API: ${auth.api}`);
+            }
+            if (auth.ui) {
+                console.log(`  UI: ${auth.ui}`);
+            }
+            if (auth.profiles) {
+                const profileNames = Object.keys(auth.profiles);
+                console.log(`  Profiles: ${profileNames.join(', ') || 'none'}`);
+            }
+        }
+        // Summary
+        console.log(chalk.bold('\n' + '─'.repeat(50)));
+        if (issues.length === 0) {
+            console.log(chalk.green('✅ Preflight check passed'));
+            console.log(chalk.gray('   Run "qa360 run" to execute tests'));
+        }
+        else {
+            console.log(chalk.yellow('⚠️  Issues found:'));
+            for (const issue of issues) {
+                console.log(chalk.yellow(`   ${issue}`));
+            }
+        }
+        console.log('');
+    }
+    catch (error) {
+        console.error(chalk.red('\n❌ Preflight validation failed:'));
+        console.error(chalk.red(`   ${error instanceof Error ? error.message : 'Unknown error'}`));
+        process.exit(1);
+    }
+}

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

@@ -159,6 +159,12 @@ export declare class PlaywrightUiAdapter {
      * Test page with actions (for user journeys)
      */
     private testPageWithActions;
+    /**
+     * Smart click with automatic hover/scroll fallback for invisible elements
+     * Handles dropdown menus that require hover to reveal clickable items
+     */
+    private smartClick;
+    private sleep;
     /**
      * Execute a single page action
      */

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

@@ -1474,6 +1474,70 @@ export class PlaywrightUiAdapter {
             };
         }
     }
+    /**
+     * Smart click with automatic hover/scroll fallback for invisible elements
+     * Handles dropdown menus that require hover to reveal clickable items
+     */
+    async smartClick(selector, timeout) {
+        const page = this.page;
+        const maxRetries = 3;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                // First, try a direct click
+                await page.click(selector, { timeout: timeout / maxRetries, force: false });
+                return;
+            }
+            catch (error) {
+                // If direct click failed, try fallback strategies
+                const isVisible = await page.isVisible(selector).catch(() => false);
+                const isAttached = await page.locator(selector).count().then(c => c > 0).catch(() => false);
+                if (!isAttached) {
+                    throw error; // Element doesn't exist, no point retrying
+                }
+                if (!isVisible) {
+                    // Strategy 1: Scroll into view
+                    try {
+                        await page.locator(selector).first().scrollIntoViewIfNeeded({ timeout: 1000 });
+                        await this.sleep(200); // Wait for scroll to complete
+                    }
+                    catch { /* Ignore scroll errors */ }
+                    // Strategy 2: Try to hover on parent to reveal dropdown
+                    try {
+                        // Extract parent selector (remove last pseudo-class or attribute)
+                        const parentSelectors = [
+                            selector.replace(/::.+$/, ''), // Remove pseudo-class
+                            selector.replace(/\[\w+=.+\]$/, ''), // Remove attribute
+                        ];
+                        for (const parent of parentSelectors) {
+                            if (parent !== selector) {
+                                const isParentVisible = await page.isVisible(parent).catch(() => false);
+                                if (isParentVisible) {
+                                    await page.locator(parent).first().hover({ timeout: 1000 });
+                                    await this.sleep(300); // Wait for dropdown animation
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    catch { /* Ignore hover errors */ }
+                    // Strategy 3: Force click after revealing
+                    try {
+                        await page.click(selector, { timeout: 2000, force: true });
+                        return;
+                    }
+                    catch { /* Continue to next attempt */ }
+                }
+                // Last attempt: force click
+                if (attempt === maxRetries - 1) {
+                    await page.click(selector, { timeout, force: true });
+                    return;
+                }
+            }
+        }
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
     /**
      * Execute a single page action
      */
@@ -1488,7 +1552,7 @@ export class PlaywrightUiAdapter {
                 if (!action.selector) {
                     throw new Error('Click action requires a selector');
                 }
-                await this.page.click(action.selector, { timeout });
+                await this.smartClick(action.selector, timeout);
                 break;
             case 'fill':
                 if (!action.selector) {
@@ -1536,6 +1600,26 @@ export class PlaywrightUiAdapter {
                     }
                 }
                 break;
+            case 'press':
+                if (action.value) {
+                    if (action.selector) {
+                        await this.page.locator(action.selector).press(action.value, { timeout });
+                    }
+                    else {
+                        await this.page.keyboard.press(action.value);
+                    }
+                }
+                break;
+            case 'waitForSelector':
+                if (action.selector) {
+                    await this.page.waitForSelector(action.selector, { timeout });
+                }
+                break;
+            case 'hover':
+                if (action.selector) {
+                    await this.page.hover(action.selector, { timeout });
+                }
+                break;
             default:
                 console.warn(`Unknown action type: ${action.type}`);
         }

package/dist/core/ai/ollama-provider.d.ts

@@ -26,6 +26,10 @@ export declare class OllamaProvider implements LLMProvider {
     private readonly timeout;
     constructor(config?: OllamaConfig);
     isAvailable(): Promise<boolean>;
+    /**
+     * Ensure URL has valid format (http:// prefix)
+     */
+    private ensureValidUrl;
     generate(request: GenerationRequest): Promise<GenerationResponse>;
     stream(request: GenerationRequest): AsyncIterable<string>;
     countTokens(text: string): number;

package/dist/core/ai/ollama-provider.js

@@ -26,17 +26,20 @@ export class OllamaProvider {
     defaultModel;
     timeout;
     constructor(config = {}) {
-        this.baseUrl = config.baseUrl || process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
+        // Use 127.0.0.1 instead of localhost to avoid IPv6 resolution issues
+        this.baseUrl = config.baseUrl || process.env.OLLAMA_BASE_URL || 'http://127.0.0.1:11434';
         this.defaultModel = config.model || process.env.OLLAMA_MODEL || 'deepseek-coder';
         this.timeout = config.timeout || 120000; // 2 minutes default
     }
     async isAvailable() {
         try {
+            // Ensure URL has proper format
+            const url = this.ensureValidUrl(this.baseUrl);
             // Use a longer timeout (15 seconds) to accommodate slower systems
             // Ollama can take time to respond, especially on first run or with many models
             const controller = new AbortController();
             const timeoutId = setTimeout(() => controller.abort(), 15000);
-            const response = await fetch(`${this.baseUrl}/api/tags`, {
+            const response = await fetch(`${url}/api/tags`, {
                 signal: controller.signal,
             });
             clearTimeout(timeoutId);
@@ -49,21 +52,37 @@ export class OllamaProvider {
                     // Timeout - Ollama is slow to respond
                     console.debug(`[Ollama] Connection to ${this.baseUrl} timed out after 15s`);
                 }
+                else if (error.message.includes('ECONNREFUSED')) {
+                    console.debug(`[Ollama] Connection refused - Ollama may not be running at ${this.baseUrl}`);
+                }
+                else if (error.message.includes('ENOTFOUND')) {
+                    console.debug(`[Ollama] Host not found - check Ollama URL: ${this.baseUrl}`);
+                }
                 else {
-                    // Other error (ECONNREFUSED, ENOTFOUND, etc.)
+                    // Other error
                     console.debug(`[Ollama] Connection error: ${error.message}`);
                 }
             }
             return false;
         }
     }
+    /**
+     * Ensure URL has valid format (http:// prefix)
+     */
+    ensureValidUrl(url) {
+        if (!url.startsWith('http://') && !url.startsWith('https://')) {
+            return `http://${url}`;
+        }
+        return url;
+    }
     async generate(request) {
         const fullPrompt = this.buildFullPrompt(request);
+        const url = this.ensureValidUrl(this.baseUrl);
         // Use timeout with AbortController for compatibility
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
         try {
-            const response = await fetch(`${this.baseUrl}/api/generate`, {
+            const response = await fetch(`${url}/api/generate`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 signal: controller.signal,
@@ -101,7 +120,8 @@ export class OllamaProvider {
     }
     async *stream(request) {
         const fullPrompt = this.buildFullPrompt(request);
-        const response = await fetch(`${this.baseUrl}/api/generate`, {
+        const url = this.ensureValidUrl(this.baseUrl);
+        const response = await fetch(`${url}/api/generate`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
@@ -153,7 +173,8 @@ export class OllamaProvider {
      * List available models from Ollama
      */
     async listModels() {
-        const response = await fetch(`${this.baseUrl}/api/tags`);
+        const url = this.ensureValidUrl(this.baseUrl);
+        const response = await fetch(`${url}/api/tags`);
         if (!response.ok) {
             throw new OllamaError('Failed to list models');
         }

package/dist/core/crawler/consent-handler.d.ts

@@ -5,6 +5,8 @@
  * Supports all major Consent Management Platforms (CMPs).
  *
  * Philosophy: "80% of EU sites block interaction with consent banners"
+ *
+ * NEW: Continuous monitoring mode for async-loaded banners
  */
 import type { Page } from '@playwright/test';
 /**
@@ -17,6 +19,8 @@ export interface ConsentOptions {
     timeout?: number;
     /** Custom selector override */
     customSelector?: string;
+    /** Enable continuous monitoring (watches for banners appearing during session) */
+    continuous?: boolean;
 }
 /**
  * Consent Handler - Auto-detects and handles GDPR/CCPA banners
@@ -30,6 +34,19 @@ export declare class ConsentHandler {
      * @returns true if a banner was found and handled, false otherwise
      */
     static handleConsent(page: Page, options?: ConsentOptions): Promise<boolean>;
+    /**
+     * Start continuous monitoring for consent banners
+     * Uses MutationObserver to detect banners that appear after page load
+     */
+    private static startContinuousMonitoring;
+    /**
+     * Stop continuous monitoring for a page
+     */
+    static stopContinuousMonitoring(page: Page): void;
+    /**
+     * Stop all continuous monitoring
+     */
+    static stopAllMonitoring(): void;
     /**
      * Try a specific CMP
      */

package/dist/core/crawler/consent-handler.js

@@ -5,7 +5,13 @@
  * Supports all major Consent Management Platforms (CMPs).
  *
  * Philosophy: "80% of EU sites block interaction with consent banners"
+ *
+ * NEW: Continuous monitoring mode for async-loaded banners
+ */
+/**
+ * Active monitoring sessions (used to stop continuous monitoring)
  */
+const activeMonitors = new Map();
 /**
  * CMP (Consent Management Platform) Selectors
  */
@@ -82,51 +88,121 @@ const CONSENT_SELECTORS = {
     // === GENERIC PATTERNS (fallback for unknown CMPs) ===
     generic: {
         accept: [
+            // Attribute-based patterns
             '[id*="cookie"][id*="accept"]',
             '[id*="cookie"][id*="agree"]',
+            '[id*="cookie"][id*="allow"]',
             '[class*="cookie"][class*="accept"]',
             '[class*="cookie"][class*="agree"]',
+            '[class*="cookie"][class*="allow"]',
+            '[data-cookie*="accept"]',
+            '[data-cookie*="agree"]',
             '[id*="consent"][id*="accept"]',
             '[class*="consent"][class*="accept"]',
+            // Text-based patterns (English)
             'button:has-text("Accept")',
             'button:has-text("Accept All")',
-            'button:has-text("Accepter")',
-            'button:has-text("Tout accepter")',
-            "button:has-text(\"J'accepte\")",
+            'button:has-text("Accept Cookies")',
             'button:has-text("I agree")',
+            'button:has-text("I accept")',
+            'button:has-text("Agree")',
             'button:has-text("OK")',
             'button:has-text("Got it")',
+            // Text-based patterns (French)
+            'button:has-text("Accepter")',
+            'button:has-text("Tout accepter")',
+            "button:has-text(\"J'accepte\")",
             'button:has-text("Accepter les cookies")',
+            'button:has-text("Tout accepter")',
+            // Text-based patterns (German)
+            'button:has-text("Akzeptieren")',
+            'button:has-text("Alle akzeptieren")',
+            'button:has-text("Zustimmen")',
+            'button:has-text("OK")',
+            // Text-based patterns (Spanish)
+            'button:has-text("Aceptar")',
+            'button:has-text("Aceptar todo")',
+            'button:has-text("Aceptar cookies")',
+            // Common button classes
+            '.btn-accept',
+            '.btn-agree',
+            '.btn-allow',
+            '.accept-btn',
+            '.agree-btn',
+            '#btn-accept',
+            '#btn-agree',
+            // Data attributes
+            '[data-action="accept"]',
+            '[data-action="agree"]',
+            '[data-consent="accept"]',
+            '[data-cy="cookie-accept"]',
         ],
         reject: [
             '[id*="cookie"][id*="reject"]',
             '[id*="cookie"][id*="decline"]',
             '[id*="cookie"][id*="refuse"]',
+            '[id*="cookie"][id*="deny"]',
             '[class*="cookie"][class*="reject"]',
+            '[class*="cookie"][class*="decline"]',
+            '[class*="cookie"][class*="refuse"]',
             'button:has-text("Reject")',
+            'button:has-text("Reject All")',
             'button:has-text("Refuser")',
-            'button:has-text("Decline")',
             'button:has-text("Tout refuser")',
+            'button:has-text("Decline")',
+            'button:has-text("Decline All")',
+            'button:has-text("Refuser tout")',
+            '.btn-reject',
+            '.btn-decline',
+            '#btn-reject',
         ],
         banner: [
+            // ID-based patterns
             '[id*="cookie-banner"]',
             '[id*="cookie-consent"]',
             '[id*="cookie-notice"]',
-            '[id*="gdpr"]',
+            '[id*="gdpr-banner"]',
+            '[id*="gdpr-consent"]',
             '[id*="consent-banner"]',
             '[id*="consent-notice"]',
+            '[id*="privacy-banner"]',
+            '[id*="privacy-notice"]',
+            // Class-based patterns
             '[class*="cookie-banner"]',
             '[class*="cookie-consent"]',
+            '[class*="cookie-notice"]',
+            '[class*="cookie-popup"]',
             '[class*="gdpr-banner"]',
+            '[class*="gdpr-consent"]',
             '[class*="consent-banner"]',
+            '[class*="consent-popup"]',
+            '[class*="privacy-banner"]',
+            // ARIA-based patterns
             '[aria-label*="cookie"]',
             '[aria-label*="consent"]',
+            '[aria-label*="gdpr"]',
+            '[aria-describedby*="cookie"]',
             '[role="dialog"][id*="cookie"]',
+            '[role="dialog"][id*="consent"]',
+            '[role="alertdialog"][id*="cookie"]',
+            // Common banner IDs/classes
             '.cookie-banner',
             '.cookie-consent',
+            '.cookie-notice',
             '.gdpr-banner',
+            '.consent-banner',
+            '.consent-popup',
             '#cookie-banner',
             '#cookie-consent',
+            '#gdpr-banner',
+            '#consent-banner',
+            // Data attributes
+            '[data-cookie-banner]',
+            '[data-consent-banner]',
+            '[data-gdpr-banner]',
+            // Fixed position elements (common for banners)
+            '[style*="position: fixed"][class*="cookie"]',
+            '[style*="position:fixed"][class*="cookie"]',
         ],
         name: 'Generic',
     },
@@ -143,7 +219,7 @@ export class ConsentHandler {
      * @returns true if a banner was found and handled, false otherwise
      */
     static async handleConsent(page, options = {}) {
-        const { action = 'accept', timeout = 3000, customSelector } = options;
+        const { action = 'accept', timeout = 15000, customSelector, continuous = false } = options;
         if (action === 'ignore') {
             return false;
         }
@@ -152,11 +228,13 @@ export class ConsentHandler {
             return await this.handleCustom(page, customSelector, timeout);
         }
         // Try each known CMP
+        let handled = false;
         for (const [cmpName, selectors] of Object.entries(CONSENT_SELECTORS)) {
             try {
-                const handled = await this.tryCMP(page, cmpName, selectors, action, timeout);
-                if (handled) {
-                    return true;
+                const result = await this.tryCMP(page, cmpName, selectors, action, timeout);
+                if (result) {
+                    handled = true;
+                    break; // Found and handled, no need to try other CMPs
                 }
             }
             catch {
@@ -164,7 +242,95 @@ export class ConsentHandler {
                 continue;
             }
         }
-        return false; // No consent banner found
+        // Start continuous monitoring if requested
+        if (continuous) {
+            this.startContinuousMonitoring(page, action);
+        }
+        return handled;
+    }
+    /**
+     * Start continuous monitoring for consent banners
+     * Uses MutationObserver to detect banners that appear after page load
+     */
+    static startContinuousMonitoring(page, action) {
+        // Stop existing monitor for this page if any
+        if (activeMonitors.has(page)) {
+            return; // Already monitoring
+        }
+        let attempts = 0;
+        const maxAttempts = 30; // Check for up to 30 seconds (30 * 1000ms)
+        const checkInterval = setInterval(async () => {
+            attempts++;
+            try {
+                // Quick check if any consent banner is present
+                const hasBanner = await page.evaluate(() => {
+                    const selectors = [
+                        // OneTrust
+                        '#onetrust-banner-sdk, #onetrust-consent-sdk',
+                        // Cookiebot
+                        '#CybotCookiebotDialog, .CookieDialog',
+                        // Generic patterns
+                        '[id*="cookie-banner"], [id*="cookie-consent"], [id*="gdpr"]',
+                        '[class*="cookie-banner"], [class*="cookie-consent"], [class*="gdpr-banner"]',
+                        '[aria-label*="cookie"], [aria-label*="consent"]',
+                        '#cookie-banner, #cookie-consent, .cookie-banner, .cookie-consent',
+                    ];
+                    for (const sel of selectors) {
+                        const el = document.querySelector(sel);
+                        if (el) {
+                            const rect = el.getBoundingClientRect();
+                            // Check if visible (has dimensions and not hidden)
+                            if (rect.width > 0 && rect.height > 0) {
+                                const style = window.getComputedStyle(el);
+                                if (style.display !== 'none' && style.visibility !== 'hidden') {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                    return false;
+                });
+                if (hasBanner) {
+                    console.log('  🍪 Consent banner detected (continuous monitoring)');
+                    // Try to handle it
+                    const handled = await this.handleConsent(page, { action, timeout: 5000 });
+                    if (handled) {
+                        console.log('  ✅ Consent banner handled (continuous monitoring)');
+                    }
+                }
+            }
+            catch {
+                // Page might be closed, ignore
+            }
+            // Stop after max attempts
+            if (attempts >= maxAttempts) {
+                clearInterval(checkInterval);
+                activeMonitors.delete(page);
+            }
+        }, 1000); // Check every second
+        // Store cleanup function
+        activeMonitors.set(page, () => {
+            clearInterval(checkInterval);
+        });
+    }
+    /**
+     * Stop continuous monitoring for a page
+     */
+    static stopContinuousMonitoring(page) {
+        const cleanup = activeMonitors.get(page);
+        if (cleanup) {
+            cleanup();
+            activeMonitors.delete(page);
+        }
+    }
+    /**
+     * Stop all continuous monitoring
+     */
+    static stopAllMonitoring() {
+        for (const cleanup of activeMonitors.values()) {
+            cleanup();
+        }
+        activeMonitors.clear();
     }
     /**
      * Try a specific CMP

package/dist/core/crawler/intelligent-selector-generator.js

@@ -119,7 +119,9 @@ const GENERATED_ID_PATTERNS = [
     // === NEW - Generic ===
     /^[a-f0-9]{8}-[a-f0-9]{4}-/, // UUID prefix
     /^\w+-[a-f0-9]{6,}$/, // name-hash
-    /^_?[a-zA-Z]+_[a-z0-9]{5,}$/, // CSS Modules
+    /^_?[a-zA-Z]+_[a-z0-9]{5,}$/, // CSS Modules (basic)
+    /^[\w-]+-module__[\w]+--[\w-]+$/, // CSS Modules (GitHub-style: Component-module__element--hash)
+    /^[\w]+__[\w]+--[\w-]+$/, // CSS Modules BEM with hash: Block__Element--modifier-hash
     /^[a-f0-9]{32}$/, // MD5 hash
     /^[a-f0-9]{40}$/, // SHA1 hash
 ];

package/dist/core/crawler/journey-generator.js

@@ -248,6 +248,9 @@ export class JourneyGenerator {
                 });
                 // Fill form fields
                 for (const field of form.fields) {
+                    // Skip radio/checkbox here - they're handled separately below
+                    if (field.inputType === 'radio' || field.inputType === 'checkbox')
+                        continue;
                     if (!field.required && Math.random() > 0.5)
                         continue;
                     const step = {
@@ -256,7 +259,7 @@ export class JourneyGenerator {
                         action: field.inputType === 'select-one' ? 'select' : 'fill',
                         selector: field.selector,
                     };
-                    // Set appropriate test value
+                    // Set appropriate test value based on input type
                     if (field.inputType === 'email') {
                         step.value = 'test@example.com';
                     }
@@ -269,17 +272,66 @@ export class JourneyGenerator {
                         const num = typeof min === 'number' ? min + 1 : 1;
                         step.value = String(typeof max === 'number' ? Math.min(num, max - 1) : num);
                     }
+                    else if (field.inputType === 'time') {
+                        step.value = '13:30'; // Valid time format
+                    }
+                    else if (field.inputType === 'date') {
+                        step.value = '2024-01-15'; // Valid date format
+                    }
+                    else if (field.inputType === 'datetime-local') {
+                        step.value = '2024-01-15T13:30'; // Valid datetime format
+                    }
+                    else if (field.inputType === 'url') {
+                        step.value = 'https://example.com';
+                    }
+                    else if (field.inputType === 'color') {
+                        step.value = '#ff0000';
+                    }
+                    else if (field.inputType === 'range') {
+                        const min = field.validation?.min || 0;
+                        const max = field.validation?.max || 100;
+                        step.value = String((Number(min) + Number(max)) / 2);
+                    }
                     else if (field.inputType === 'select-one' && field.options && field.options.length > 0) {
                         step.value = field.options[0];
                     }
-                    else if (field.inputType === 'checkbox') {
-                        step.action = 'check';
-                    }
                     else {
                         step.value = 'Test value';
                     }
                     steps.push(step);
                 }
+                // Handle radio buttons (select one option per radio group)
+                const radioGroups = new Map();
+                for (const field of form.fields) {
+                    if (field.inputType === 'radio' && field.name) {
+                        if (!radioGroups.has(field.name)) {
+                            radioGroups.set(field.name, []);
+                        }
+                        radioGroups.get(field.name).push(field);
+                    }
+                }
+                for (const [groupName, radios] of radioGroups) {
+                    // Select the first radio option
+                    if (radios.length > 0) {
+                        steps.push({
+                            order: steps.length + 1,
+                            description: `Select ${groupName} option`,
+                            action: 'check',
+                            selector: radios[0].selector,
+                        });
+                    }
+                }
+                // Handle checkboxes (check all required ones)
+                for (const field of form.fields) {
+                    if (field.inputType === 'checkbox' && field.required) {
+                        steps.push({
+                            order: steps.length + 1,
+                            description: `Check ${field.name || 'checkbox'}`,
+                            action: 'check',
+                            selector: field.selector,
+                        });
+                    }
+                }
                 // Submit form
                 if (form.submitButton) {
                     // Wait for submit button

package/dist/core/crawler/page-analyzer.d.ts

@@ -89,9 +89,15 @@ export declare class PageAnalyzer {
      */
     private analyzeNavigation;
     /**
-     * Run accessibility scan using axe-core
+     * Run accessibility scan using axe-core with native ARIA fallback
+     * When CSP blocks external scripts, falls back to native ARIA inspection
      */
     private runAccessibilityScan;
+    /**
+     * Native ARIA accessibility scan (fallback when axe-core is blocked)
+     * Uses browser's built-in ARIA inspection capabilities
+     */
+    private runNativeAriaScan;
     /**
      * Detect page type
      */

package/dist/core/crawler/page-analyzer.js

@@ -10,7 +10,7 @@
  */
 import { chromium } from '@playwright/test';
 import { generateSelectorFromElement, SiteProfiler, initializeSelectorGenerator, } from './selector-generator.js';
-import { handleConsent } from './consent-handler.js';
+import { handleConsent, ConsentHandler } from './consent-handler.js';
 /**
  * Page Analyzer class
  */
@@ -491,8 +491,13 @@ export class PageAnalyzer {
             // PART 4: HANDLE GDPR/COOKIE CONSENT BANNERS
             // ═══════════════════════════════════════════════════════════════════════════════
             const consentAction = this.options.consentAction || 'accept';
-            const consentTimeout = this.options.consentTimeout || 3000;
-            await handleConsent(this.page, { action: consentAction, timeout: consentTimeout });
+            const consentTimeout = this.options.consentTimeout || 15000;
+            const continuousConsent = this.options.continuousConsent !== false; // true by default
+            await handleConsent(this.page, {
+                action: consentAction,
+                timeout: consentTimeout,
+                continuous: continuousConsent,
+            });
             // ═══════════════════════════════════════════════════════════════════════════════
             // INTELLIGENT SITE PROFILING (First page only)
             // ═══════════════════════════════════════════════════════════════════════════════
@@ -1045,7 +1050,8 @@ export class PageAnalyzer {
         return navigation;
     }
     /**
-     * Run accessibility scan using axe-core
+     * Run accessibility scan using axe-core with native ARIA fallback
+     * When CSP blocks external scripts, falls back to native ARIA inspection
      */
     async runAccessibilityScan() {
         try {
@@ -1095,6 +1101,119 @@ export class PageAnalyzer {
                 incomplete: axeResults.incomplete?.length || 0,
             };
         }
+        catch (error) {
+            // CSP fallback: Native ARIA inspection when axe-core is blocked
+            console.log('    ⚠️  axe-core blocked by CSP, using native ARIA inspection');
+            return await this.runNativeAriaScan();
+        }
+    }
+    /**
+     * Native ARIA accessibility scan (fallback when axe-core is blocked)
+     * Uses browser's built-in ARIA inspection capabilities
+     */
+    async runNativeAriaScan() {
+        try {
+            const results = await this.page.evaluate(() => {
+                const violations = [];
+                // Check 1: Images without alt text
+                const imagesWithoutAlt = document.querySelectorAll('img:not([alt])');
+                if (imagesWithoutAlt.length > 0) {
+                    violations.push({
+                        id: 'image-alt',
+                        impact: 'serious',
+                        description: 'Images must have alternate text',
+                        nodes: Array.from(imagesWithoutAlt).slice(0, 10).map(img => ({
+                            target: [img.tagName + (img.id ? `#${img.id}` : '')],
+                        })),
+                    });
+                }
+                // Check 2: Links without accessible name
+                const linksWithoutText = Array.from(document.querySelectorAll('a')).filter(a => !a.textContent?.trim() && !a.getAttribute('aria-label') && !a.getAttribute('aria-labelledby'));
+                if (linksWithoutText.length > 0) {
+                    violations.push({
+                        id: 'link-name',
+                        impact: 'serious',
+                        description: 'Links must have discernible text',
+                        nodes: linksWithoutText.slice(0, 10).map(a => ({
+                            target: [`a${a.id ? `#${a.id}` : ''}`],
+                        })),
+                    });
+                }
+                // Check 3: Form fields without labels
+                const inputsWithoutLabels = Array.from(document.querySelectorAll('input, select, textarea')).filter(el => {
+                    if (el.type === 'hidden')
+                        return false;
+                    const id = el.id;
+                    const hasLabel = document.querySelector(`label[for="${id}"]`);
+                    const hasAriaLabel = el.getAttribute('aria-label') || el.getAttribute('aria-labelledby');
+                    const hasParentLabel = el.closest('label');
+                    return !hasLabel && !hasAriaLabel && !hasParentLabel;
+                });
+                if (inputsWithoutLabels.length > 0) {
+                    violations.push({
+                        id: 'label',
+                        impact: 'serious',
+                        description: 'Form fields must have labels',
+                        nodes: inputsWithoutLabels.slice(0, 10).map(el => ({
+                            target: [`${el.tagName}${el.id ? `#${el.id}` : ''}`],
+                        })),
+                    });
+                }
+                // Check 4: Buttons without accessible name
+                const buttonsWithoutText = Array.from(document.querySelectorAll('button')).filter(btn => !btn.textContent?.trim() && !btn.getAttribute('aria-label') && !btn.getAttribute('aria-labelledby'));
+                if (buttonsWithoutText.length > 0) {
+                    violations.push({
+                        id: 'button-name',
+                        impact: 'serious',
+                        description: 'Buttons must have discernible text',
+                        nodes: buttonsWithoutText.slice(0, 10).map(btn => ({
+                            target: [`button${btn.id ? `#${btn.id}` : ''}`],
+                        })),
+                    });
+                }
+                // Check 5: Empty headings
+                const emptyHeadings = Array.from(document.querySelectorAll('h1, h2, h3, h4, h5, h6')).filter(h => !h.textContent?.trim());
+                if (emptyHeadings.length > 0) {
+                    violations.push({
+                        id: 'empty-heading',
+                        impact: 'moderate',
+                        description: 'Headings must not be empty',
+                        nodes: emptyHeadings.slice(0, 10).map(h => ({
+                            target: [`${h.tagName}${h.id ? `#${h.id}` : ''}`],
+                        })),
+                    });
+                }
+                // Count positive checks (passes)
+                const allImages = document.querySelectorAll('img').length;
+                const allLinks = document.querySelectorAll('a').length;
+                const allButtons = document.querySelectorAll('button').length;
+                const allInputs = document.querySelectorAll('input:not([type="hidden"]), select, textarea').length;
+                const allHeadings = document.querySelectorAll('h1, h2, h3, h4, h5, h6').length;
+                const passes = (allImages - imagesWithoutAlt.length) +
+                    (allLinks - linksWithoutText.length) +
+                    (allButtons - buttonsWithoutText.length) +
+                    (allInputs - inputsWithoutLabels.length) +
+                    (allHeadings - emptyHeadings.length);
+                return { violations, passes };
+            });
+            // Calculate score from native scan results
+            const criticalCount = results.violations.filter((v) => v.impact === 'critical').length;
+            const seriousCount = results.violations.filter((v) => v.impact === 'serious').length;
+            const moderateCount = results.violations.filter((v) => v.impact === 'moderate').length;
+            const score = Math.max(0, 100 - (criticalCount * 25 + seriousCount * 10 + moderateCount * 5));
+            return {
+                score: Math.round(score),
+                violations: results.violations.map((v) => ({
+                    id: v.id,
+                    impact: v.impact || 'moderate',
+                    description: v.description,
+                    nodes: v.nodes?.length || 0,
+                    selectors: (v.nodes || []).slice(0, 5).map((n) => n.target?.[0] || '').filter(Boolean),
+                })),
+                passes: results.passes || 0,
+                incomplete: 0,
+            };
+        }
         catch {
             return undefined;
         }
@@ -1147,6 +1266,10 @@ export class PageAnalyzer {
      */
     async cleanup() {
         try {
+            // Stop continuous consent monitoring
+            if (this.page) {
+                ConsentHandler.stopContinuousMonitoring(this.page);
+            }
             if (this.page)
                 await this.page.close();
             if (this.context)

package/dist/core/generation/crawler-pack-generator.js

@@ -88,7 +88,21 @@ function generatePackFromCrawlResult(crawlResult, options) {
         // Only include HTML pages (filter out CSS, JS, images, etc.)
         return !/\.(css|js|json|xml|pdf|zip|jpg|jpeg|png|gif|svg|ico|woff|woff2|ttf|eot)$/i.test(url);
     });
-    const pages = htmlPages.map(p => `${baseUrl}${p.path.startsWith('/') ? '' : '/'}${p.path}`);
+    // Build pages array - use full URL if available, otherwise construct from baseUrl + path
+    const pages = htmlPages.map(p => {
+        // If page has a full URL, use it directly
+        if (p.url && p.url.startsWith('http')) {
+            return p.url;
+        }
+        // Otherwise, construct from baseUrl (being careful not to duplicate paths)
+        const pagePath = p.path;
+        // If baseUrl already ends with the page path, just use baseUrl
+        if (baseUrl.endsWith(pagePath) || pagePath === '/' || pagePath === '') {
+            return baseUrl;
+        }
+        // Otherwise append the path
+        return `${baseUrl}${pagePath.startsWith('/') ? '' : '/'}${pagePath}`;
+    });
     // Generate YAML (v2 format)
     let yaml = `# QA360 Pack v2 - Generated by crawler
 # Source: ${options.baseUrl}
@@ -136,39 +150,43 @@ ${pages.map(p => `        - "${p}"`).join('\n')}
             const gateName = journey.name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
             // Build page objects with actions from journey steps
             const pageMap = new Map();
+            let currentUrl = journey.entryPoint;
+            // Initialize with entry point
+            const absoluteEntryPoint = currentUrl.startsWith('http') ? currentUrl : `${baseUrl}${currentUrl.startsWith('/') ? '' : '/'}${currentUrl}`;
+            pageMap.set(absoluteEntryPoint, { url: absoluteEntryPoint, actions: [] });
             for (const step of journey.steps) {
                 const stepTyped = step;
-                const url = stepTyped.expected?.url || stepTyped.url;
-                if (url && url !== 'undefined') {
-                    // Convert relative URLs to absolute
-                    const absoluteUrl = url.startsWith('http') ? url : `${baseUrl}${url.startsWith('/') ? '' : '/'}${url}`;
-                    if (!pageMap.has(absoluteUrl)) {
-                        pageMap.set(absoluteUrl, { url: absoluteUrl, actions: [] });
+                const actionType = stepTyped.action || 'navigate';
+                // For navigate actions, update current URL from step.value
+                if (actionType === 'navigate') {
+                    const navigateUrl = stepTyped.value || stepTyped.expected?.url || stepTyped.url;
+                    if (navigateUrl && navigateUrl !== 'undefined') {
+                        currentUrl = navigateUrl.startsWith('http') ? navigateUrl : `${baseUrl}${navigateUrl.startsWith('/') ? '' : '/'}${navigateUrl}`;
+                        if (!pageMap.has(currentUrl)) {
+                            pageMap.set(currentUrl, { url: currentUrl, actions: [] });
+                        }
                     }
-                    // Add action to the page
-                    const page = pageMap.get(absoluteUrl);
-                    const actionType = stepTyped.action || 'navigate';
+                }
+                // Add action to the current page
+                if (pageMap.has(currentUrl)) {
+                    const page = pageMap.get(currentUrl);
                     // Map journey actions to page actions
                     const pageAction = { type: actionType };
                     if (stepTyped.selector) {
                         pageAction.selector = stepTyped.selector;
                     }
-                    if (stepTyped.value) {
+                    if (stepTyped.value && actionType !== 'navigate') {
                         pageAction.value = stepTyped.value;
                     }
                     if (stepTyped.wait) {
                         pageAction.options = { timeout: stepTyped.wait };
                     }
-                    // Add action if it's meaningful (skip simple navigation)
-                    if (actionType !== 'navigate' || stepTyped.selector || stepTyped.value) {
+                    // Add action if it's meaningful (skip empty navigate)
+                    if (actionType !== 'navigate' || stepTyped.selector) {
                         page.actions.push(pageAction);
                     }
                 }
             }
-            // If no pages found, use entry point
-            if (pageMap.size === 0) {
-                pageMap.set(journey.entryPoint, { url: journey.entryPoint, actions: [] });
-            }
             const pages = Array.from(pageMap.values());
             // Generate YAML for pages with actions
             if (pages.every((p) => p.actions.length === 0)) {

package/dist/index.js

@@ -35,7 +35,7 @@ import { doctorCommand } from './commands/doctor.js';
 import { askCommand } from './commands/ask.js';
 import { initCommand } from './commands/init.js';
 import { examplesListCommand, examplesCopyCommand, examplesShowCommand } from './commands/examples.js';
-import { runCommand } from './commands/run.js';
+import { runCommand, preflightCommand } from './commands/run.js';
 import { reportCommand } from './commands/report.js';
 import { verifyCommand } from './commands/verify.js';
 import { explainCommand } from './commands/explain.js';
@@ -125,8 +125,7 @@ program
     .command('preflight [pack]')
     .description('Dry-run validation without execution')
     .action(async (pack) => {
-    console.log(chalk.blue('🔍 QA360 Preflight - Validation'));
-    console.log(chalk.yellow('⚠️  Phase 2 implementation coming soon...'));
+    await preflightCommand(pack);
 });
 program
     .command('report')

package/dist/utils/config.js

@@ -109,7 +109,31 @@ function parseYaml(content) {
         if (listMatch) {
             const value = listMatch[1].trim();
             if (Array.isArray(parent)) {
-                parent.push(parseValue(value));
+                // Check if this is an object item (key: value) or a simple value
+                const colonIdx = value.indexOf(':');
+                if (colonIdx > 0 && !value.startsWith("'") && !value.startsWith('"')) {
+                    // Object item like "- url: /" or "- key: value"
+                    const objKey = value.slice(0, colonIdx).trim();
+                    let objValue = value.slice(colonIdx + 1).trim();
+                    // Check if next line is more indented (nested object properties)
+                    if (i < lines.length - 1) {
+                        const nextIndent = lines[i + 1].search(/\S|$/);
+                        if (nextIndent > indent) {
+                            // This is the start of a nested object
+                            const obj = {};
+                            obj[objKey] = parseValue(objValue);
+                            parent.push(obj);
+                            stack.push({ obj, indent });
+                            continue;
+                        }
+                    }
+                    // Single-line object item
+                    parent.push({ [objKey]: parseValue(objValue) });
+                }
+                else {
+                    // Simple value item
+                    parent.push(parseValue(value));
+                }
             }
             continue;
         }
@@ -144,6 +168,9 @@ function parseYaml(content) {
         if (i < lines.length - 1) {
             const nextIndent = lines[i + 1].search(/\S|$/);
             if (nextIndent > indent) {
+                const nextLine = lines[i + 1].trim();
+                // Check if next line starts a list (array) or a key-value (object)
+                const isList = nextLine.startsWith('-');
                 if (Array.isArray(parent[key])) {
                     // Already an array
                 }
@@ -151,12 +178,18 @@ function parseYaml(content) {
                     // Nested object
                     stack.push({ obj: parent[key], indent });
                 }
-                else {
-                    // Start of array
+                else if (isList) {
+                    // Start of array (next line is a list item)
                     const arr = [];
                     parent[key] = arr;
                     stack.push({ obj: arr, indent });
                 }
+                else {
+                    // Start of object (next line is a key-value pair)
+                    const obj = {};
+                    parent[key] = obj;
+                    stack.push({ obj, indent });
+                }
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qa360",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "description": "QA360 Proof CLI - Quality as Cryptographic Proof",
   "type": "module",
   "main": "dist/index.js",