qa360 2.2.12 → 2.2.14

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

@@ -32,16 +32,28 @@ export class OllamaProvider {
     }
     async isAvailable() {
         try {
-            // Use timeout with AbortSignal - wrap for compatibility
+            // 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(), 5000);
+            const timeoutId = setTimeout(() => controller.abort(), 15000);
             const response = await fetch(`${this.baseUrl}/api/tags`, {
                 signal: controller.signal,
             });
             clearTimeout(timeoutId);
             return response.ok;
         }
-        catch {
+        catch (error) {
+            // Log the error for debugging (will be visible in verbose mode)
+            if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    // Timeout - Ollama is slow to respond
+                    console.debug(`[Ollama] Connection to ${this.baseUrl} timed out after 15s`);
+                }
+                else {
+                    // Other error (ECONNREFUSED, ENOTFOUND, etc.)
+                    console.debug(`[Ollama] Connection error: ${error.message}`);
+                }
+            }
             return false;
         }
     }

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

@@ -50,9 +50,12 @@ export function generateSelector(element) {
     if (className && !isGenericClass(className)) {
         const classes = className.split(' ').filter(c => !isGenericClass(c));
         if (classes.length > 0) {
-            const classSelector = classes.map(c => `.${escapeCss(c)}`).join('');
-            // Qualify with tag if available
-            return tagName ? `${tagName}${classSelector}` : classSelector;
+            // Smart class selection: prioritize meaningful classes
+            const meaningfulClasses = selectMeaningfulClasses(classes);
+            const classSelector = meaningfulClasses.map(c => `.${escapeCss(c)}`).join('');
+            // Limit total selector length
+            const qualifiedSelector = tagName ? `${tagName}${classSelector}` : classSelector;
+            return truncateSelector(qualifiedSelector, 200);
         }
     }
     // 7. Tag + text content (for buttons, links)
@@ -169,6 +172,72 @@ function isSelectorStable(selector) {
 function escapeCss(str) {
     return str.replace(/(["\\])/g, '\\$1').replace(/"/g, '\\"');
 }
+/**
+ * Select the most meaningful classes from a class list
+ * Prioritizes: unique identifiers, component names, action-oriented classes
+ * Deprioritizes: utility classes (spacing, colors, sizing)
+ */
+function selectMeaningfulClasses(classes) {
+    // Tailwind and other utility class patterns to deprioritize
+    const utilityPatterns = [
+        /^(p|m|px|py|pt|pb|pl|pr)-/, // spacing
+        /^(mt|mb|ml|mr)-/, // margin spacing
+        /^(text|bg|border)-/, // colors
+        /^(w|h)-/, // sizing
+        /^(flex|grid|block|inline)/, // display
+        /^(justify|items|self)/, // flexbox/grid
+        /^(rounded|shadow|opacity)/, // styling
+        /^gap-/, // flex gap
+        /^(line-)?height-/, // height
+        /^(font|weight|size)/, // typography
+    ];
+    // Score each class by "meaningfulness"
+    const scored = classes.map(cls => {
+        let score = 50; // base score
+        // Bonus: component-like names (contain meaningful words)
+        if (/[A-Z][a-z]+/.test(cls))
+            score += 30; // CamelCase components
+        if (/button|btn|input|form|card|modal|nav|header|footer|sidebar|menu|dropdown/i.test(cls))
+            score += 25;
+        // Bonus: contains numbers (likely unique)
+        if (/\d+/.test(cls))
+            score += 15;
+        // Penalty: utility classes
+        for (const pattern of utilityPatterns) {
+            if (pattern.test(cls)) {
+                score -= 40;
+                break;
+            }
+        }
+        return { class: cls, score };
+    });
+    // Sort by score (descending) and take top 5
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, 5).map(s => s.class);
+}
+/**
+ * Truncate selector to max length while keeping it valid
+ * Preserves the most specific parts
+ */
+function truncateSelector(selector, maxLength) {
+    if (selector.length <= maxLength)
+        return selector;
+    // For class-based selectors, remove classes from the middle
+    const classMatch = selector.match(/^(\w+)((\.[\w-]+)+)$/);
+    if (classMatch) {
+        const tag = classMatch[1];
+        const classes = classMatch[2].split('.').filter(c => c); // Remove empty strings
+        // Keep first 2 and last 2 classes (most specific)
+        if (classes.length > 4) {
+            const kept = [...classes.slice(0, 2), ...classes.slice(-2)];
+            const truncated = `${tag}.${kept.join('.')}`;
+            if (truncated.length <= maxLength)
+                return truncated;
+        }
+    }
+    // Final fallback: just truncate (may not be valid CSS but prevents overflow)
+    return selector.substring(0, maxLength - 3) + '...';
+}
 /**
  * Optimize selector for resiliency
  */

package/cli/dist/core/generation/crawler-pack-generator.d.ts

@@ -1,7 +1,7 @@
 /**
  * QA360 Crawler Pack Generator
  *
- * Crawls a website and generates a complete pack.yml with E2E tests
+ * Crawls a website and generates a complete pack.yml in v2 format
  */
 import type { CrawlOptions, CrawlResult } from '../crawler/index.js';
 /**

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

@@ -1,7 +1,7 @@
 /**
  * QA360 Crawler Pack Generator
  *
- * Crawls a website and generates a complete pack.yml with E2E tests
+ * Crawls a website and generates a complete pack.yml in v2 format
  */
 import { writeFileSync, mkdirSync, existsSync } from 'fs';
 import { resolve, dirname } from 'path';
@@ -56,165 +56,53 @@ export async function generatePackFromCrawl(options) {
     }
 }
 /**
- * Generate pack.yml YAML from crawl result
+ * Generate pack.yml YAML from crawl result (v2 format)
  */
 function generatePackFromCrawlResult(crawlResult, options) {
     const { siteMap, userJourneys, forms } = crawlResult;
     const packName = options.packName || `${new URL(options.baseUrl).hostname.replace(/\./g, '-')}-tests`;
-    // Build gates array
-    const gates = ['ui'];
-    if (options.includeA11y)
-        gates.push('a11y');
-    // Build UI tests from user journeys
-    const uiTests = userJourneys.map((journey, index) => ({
-        name: options.journeyNames?.[journey.name] || journey.name,
-        description: journey.description,
-        path: new URL(journey.entryPoint).pathname,
-        steps: journey.steps.map((step, stepIndex) => journeyStepToUiTestStep(step, stepIndex)),
-    }));
-    // Also add form-based tests
-    for (const form of forms) {
-        if (form.purpose !== 'login' && form.purpose !== 'signup') {
-            uiTests.push({
-                name: `${form.purpose.charAt(0).toUpperCase() + form.purpose.slice(1)} Form Test`,
-                description: `Test the ${form.purpose} form`,
-                path: siteMap.pages.find(p => p.elements.forms.includes(form))?.path || '/',
-                steps: generateFormTestSteps(form),
-            });
-        }
-    }
-    // Generate YAML
-    let yaml = `# QA360 Pack - Generated by crawler
+    // Build full URLs for pages
+    const baseUrl = options.baseUrl.replace(/\/$/, '');
+    const pages = siteMap.pages.map(p => `${baseUrl}${p.path.startsWith('/') ? '' : '/'}${p.path}`);
+    // Generate YAML (v2 format)
+    let yaml = `# QA360 Pack v2 - Generated by crawler
 # Source: ${options.baseUrl}
 # Generated: ${new Date().toISOString()}
 
-version: 1
+version: 2
 name: "${packName}"
 description: "Auto-generated E2E tests for ${new URL(options.baseUrl).hostname}"
 
-gates:
-${gates.map(g => `  - ${g}`).join('\n')}
-
-targets:
-  web:
-    baseUrl: "${options.baseUrl}"
-    headless: true
-    screenshot: "only-on-fail"
-    video: "retain-on-fail"
-
-    # Pages discovered by crawler
-    pages:
-${siteMap.pages.map(p => `      - "${p.path}"`).join('\n')}
+execution:
+  default_timeout: 30000
+  default_retries: 2
+  on_failure: continue
 
-    # E2E UI tests generated from discovered user journeys
-    uiTests:
-${uiTests.map(test => generateUiTestYaml(test)).join('\n')}
+gates:
+  ui:
+    adapter: playwright-ui
+    enabled: true
+    config:
+      baseUrl: "${options.baseUrl}"
+      pages:
+${pages.map(p => `        - "${p}"`).join('\n')}
 `;
-    if (siteMap.metadata.pagesCrawled > 0) {
+    // Add a11y gate if requested
+    if (options.includeA11y) {
         yaml += `
-budgets:
-  a11y_min: 80
-  perf_p95_ms: ${Math.round(siteMap.metadata.avgLoadTime * 1.5)}
+  a11y:
+    adapter: playwright-ui
+    enabled: true
+    config:
+      baseUrl: "${options.baseUrl}"
+      pages:
+${pages.map(p => `        - "${p}"`).join('\n')}
+      budgets:
+        a11y_min: 80
 `;
     }
     return yaml;
 }
-/**
- * Convert journey step to UI test step
- */
-function journeyStepToUiTestStep(step, index) {
-    const uiStep = {
-        order: index + 1,
-        action: step.action,
-        description: step.description,
-        selector: step.selector,
-        value: step.value,
-        wait: 500,
-    };
-    if (step.expected) {
-        uiStep.expected = {};
-        if (step.expected.url)
-            uiStep.expected.url = step.expected.url;
-        if (step.expected.visible)
-            uiStep.expected.visible = step.expected.visible;
-    }
-    return uiStep;
-}
-/**
- * Generate test steps for a form
- */
-function generateFormTestSteps(form) {
-    const steps = [];
-    // Navigate to form
-    steps.push({
-        order: 1,
-        action: 'navigate',
-        description: 'Navigate to form',
-        value: form.selector,
-    });
-    // Fill form fields
-    for (const field of form.fields) {
-        if (field.required) {
-            const step = {
-                order: steps.length + 1,
-                action: field.inputType === 'select-one' ? 'select' : 'fill',
-                description: `Fill ${field.name || field.inputType}`,
-                selector: field.selector,
-            };
-            if (field.inputType === 'select-one' && field.options && field.options.length > 0) {
-                step.value = field.options[0];
-            }
-            else if (field.inputType === 'email') {
-                step.value = 'test@example.com';
-            }
-            else if (field.inputType === 'tel') {
-                step.value = '+1234567890';
-            }
-            else if (field.inputType === 'checkbox') {
-                step.action = 'check';
-            }
-            else {
-                step.value = 'Test value';
-            }
-            steps.push(step);
-        }
-    }
-    // Submit form
-    if (form.submitButton) {
-        steps.push({
-            order: steps.length + 1,
-            action: 'click',
-            description: 'Submit form',
-            selector: form.submitButton.selector,
-            wait: 1000,
-        });
-    }
-    return steps;
-}
-/**
- * Generate YAML for a UI test definition
- */
-function generateUiTestYaml(test) {
-    const steps = test.steps.map(step => {
-        let yaml = `      - action: ${step.action}`;
-        if (step.description)
-            yaml += `\n        description: "${step.description}"`;
-        if (step.selector)
-            yaml += `\n        selector: "${step.selector}"`;
-        if (step.value)
-            yaml += `\n        value: "${step.value}"`;
-        if (step.expected)
-            yaml += `\n        expected: ${JSON.stringify(step.expected)}`;
-        if (step.wait)
-            yaml += `\n        wait: ${step.wait}`;
-        return yaml;
-    }).join('\n');
-    return `    - name: "${test.name}"
-      description: "${test.description || ''}"
-      path: "${test.path || '/'}"
-      steps:
-${steps}`;
-}
 /**
  * Quick crawl - generates pack without detailed analysis
  */

package/cli/dist/core/pack/validator.js

@@ -22,8 +22,8 @@ export class PackValidator {
         const __dirname = dirname(__filename);
         // Check multiple paths to handle both development and bundled npm environments
         // From cli/dist/core/pack/validator.js, we need to reach core/schemas/pack.schema.json
-        const path1 = join(__dirname, '../../schemas/pack.schema.json');                      // bundled (cli/dist/core/schemas/)
-        const path2 = join(__dirname, '../../../../core/schemas/pack.schema.json');  // npm package (core/schemas/)
+        const path1 = join(__dirname, '../../schemas/pack.schema.json'); // bundled (cli/dist/core/schemas/)
+        const path2 = join(__dirname, '../../../../core/schemas/pack.schema.json'); // npm package (core/schemas/)
         let schemaPath = existsSync(path1) ? path1 : path2;
         // Final fallback: throw error if no schema found
         if (!existsSync(schemaPath)) {

package/cli/dist/core/pack-v2/migrator.d.ts

@@ -41,12 +41,17 @@ export declare class PackMigrator {
      * Migrate targets to gate configs
      */
     private migrateTargetsToGates;
+    /**
+     * Transform relative page paths to full URLs
+     */
+    private transformPagesToFullUrls;
     /**
      * Find a secret in environment variables by trying common names
      */
     private findSecretInEnv;
     /**
      * Sanitize gate name for v2 format
+     * Handles both strings and objects (from YAML parsing edge cases)
      */
     private sanitizeGateName;
     /**

package/cli/dist/core/pack-v2/migrator.js

@@ -395,14 +395,57 @@ export class PackMigrator {
             gate.config.baseUrl = v1Pack.targets.api.baseUrl;
             gate.config.smoke = v1Pack.targets.api.smoke;
         }
-        // Web target
-        if (v1Pack.targets.web && v2Pack.gates['ui']) {
-            const gate = v2Pack.gates['ui'];
-            gate.config = gate.config || {};
-            gate.config.baseUrl = v1Pack.targets.web.baseUrl;
-            gate.config.pages = v1Pack.targets.web.pages;
+        // Web target - migrate to both ui and a11y gates
+        if (v1Pack.targets.web) {
+            const baseUrl = v1Pack.targets.web.baseUrl;
+            const pages = this.transformPagesToFullUrls(v1Pack.targets.web.pages || [], baseUrl);
+            // ui gate
+            if (v2Pack.gates['ui']) {
+                const gate = v2Pack.gates['ui'];
+                gate.config = gate.config || {};
+                gate.config.baseUrl = baseUrl;
+                gate.config.pages = pages;
+            }
+            // a11y gate - also needs pages and baseUrl
+            if (v2Pack.gates['a11y']) {
+                const gate = v2Pack.gates['a11y'];
+                gate.config = gate.config || {};
+                gate.config.baseUrl = baseUrl;
+                gate.config.pages = pages;
+            }
         }
     }
+    /**
+     * Transform relative page paths to full URLs
+     */
+    transformPagesToFullUrls(pages, baseUrl) {
+        if (!pages || pages.length === 0)
+            return [];
+        if (!baseUrl)
+            return pages;
+        const base = baseUrl.replace(/\/$/, '');
+        return pages.map((page) => {
+            // Handle string pages (e.g., "/", "/products")
+            if (typeof page === 'string') {
+                if (page.startsWith('http')) {
+                    return page; // Already a full URL
+                }
+                return `${base}${page.startsWith('/') ? '' : '/'}${page}`;
+            }
+            // Handle object pages (e.g., { url: "/", ... })
+            if (page && typeof page === 'object' && page.url) {
+                const url = page.url;
+                if (url.startsWith('http')) {
+                    return page; // Already a full URL
+                }
+                return {
+                    ...page,
+                    url: `${base}${url.startsWith('/') ? '' : '/'}${url}`
+                };
+            }
+            return page;
+        });
+    }
     /**
      * Find a secret in environment variables by trying common names
      */
@@ -424,8 +467,33 @@ export class PackMigrator {
     }
     /**
      * Sanitize gate name for v2 format
+     * Handles both strings and objects (from YAML parsing edge cases)
      */
     sanitizeGateName(gate) {
+        // Handle edge case where gate might be an object from YAML parsing
+        if (typeof gate !== 'string') {
+            // If gate is an object, try to extract a name
+            if (gate && typeof gate === 'object') {
+                // Try common property names
+                const possibleName = gate.name || gate.id || gate.gate;
+                if (typeof possibleName === 'string') {
+                    gate = possibleName;
+                }
+                else {
+                    // Fallback: stringify the object keys
+                    const keys = Object.keys(gate);
+                    if (keys.length === 1) {
+                        gate = keys[0];
+                    }
+                    else {
+                        throw new Error(`Invalid gate format: expected string, got object with keys: ${keys.join(', ')}`);
+                    }
+                }
+            }
+            else {
+                throw new Error(`Invalid gate format: expected string, got ${typeof gate}`);
+            }
+        }
         // Map v1 gate names to v2 conventions
         const nameMap = {
             'api_smoke': 'smoke',

package/cli/dist/core/pack-v2/validator.js

@@ -370,7 +370,8 @@ export class PackValidatorV2 {
             // Validate auth profile reference
             if (gate.auth) {
                 // Will be validated against profiles in auth section
-                if (!gate.adapter?.includes('api') && !gate.adapter?.includes('ui')) {
+                const adapter = typeof gate.adapter === 'string' ? gate.adapter : '';
+                if (adapter && !adapter.includes('api') && !adapter.includes('ui')) {
                     warnings.push({
                         code: 'QP2V019',
                         message: `Auth profile specified but adapter may not support auth`,
@@ -593,7 +594,7 @@ export class PackValidatorV2 {
             return { errors, warnings };
         }
         // Check for API gate with api auth but no auth profile
-        const apiGates = Object.entries(pack.gates).filter(([_, g]) => g.adapter?.includes('api'));
+        const apiGates = Object.entries(pack.gates).filter(([_, g]) => typeof g.adapter === 'string' && g.adapter.includes('api'));
         if (apiGates.length > 0 && !pack.auth?.api && !pack.auth?.profiles) {
             warnings.push({
                 code: 'QP2V034',
@@ -603,7 +604,7 @@ export class PackValidatorV2 {
             });
         }
         // Check for UI gate with ui auth but no auth profile
-        const uiGates = Object.entries(pack.gates).filter(([_, g]) => g.adapter?.includes('ui'));
+        const uiGates = Object.entries(pack.gates).filter(([_, g]) => typeof g.adapter === 'string' && g.adapter.includes('ui'));
         if (uiGates.length > 0 && !pack.auth?.ui && !pack.auth?.profiles) {
             warnings.push({
                 code: 'QP2V035',

package/cli/dist/core/runner/phase3-runner.js

@@ -881,10 +881,21 @@ export class Phase3Runner {
      * Run UI gate (includes basic accessibility)
      */
     async runUiGate() {
-        const target = this.getTargetWeb();
+        let target = this.getTargetWeb();
         if (!target) {
             throw new Error('UI gate requires targets.web configuration or gate config with baseUrl');
         }
+        // Transform relative pages to full URLs for v1 packs
+        if (target.pages && target.baseUrl && !this.isPackV2(this.pack)) {
+            const baseUrl = target.baseUrl.replace(/\/$/, '');
+            target.pages = target.pages.map((p) => {
+                const pageStr = typeof p === 'object' && p.url ? p.url : p;
+                if (typeof pageStr === 'string' && !pageStr.startsWith('http')) {
+                    return `${baseUrl}${pageStr.startsWith('/') ? '' : '/'}${pageStr}`;
+                }
+                return p;
+            });
+        }
         const credentials = await this.getCredentialsForGate('ui');
         const adapter = new PlaywrightUiAdapter();
         return await adapter.runSmokeTests({

package/cli/package.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qa360",
-  "version": "2.2.12",
+  "version": "2.2.14",
   "description": "Transform software testing into verifiable, signed, and traceable proofs",
   "type": "module",
   "packageManager": "pnpm@9.12.2",

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

@@ -1,101 +0,0 @@
-/**
- * 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 {};