qa360 2.2.12 → 2.2.13

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.js

@@ -191,6 +191,20 @@ function generateFormTestSteps(form) {
     }
     return steps;
 }
+/**
+ * Escape a string value for YAML output
+ * Handles quotes, backslashes, and special characters
+ */
+function escapeYamlString(value) {
+    if (!value)
+        return '';
+    return value
+        .replace(/\\/g, '\\\\') // Backslashes first
+        .replace(/"/g, '\\"') // Double quotes
+        .replace(/\n/g, '\\n') // Newlines
+        .replace(/\r/g, '\\r') // Carriage returns
+        .replace(/\t/g, '\\t'); // Tabs
+}
 /**
  * Generate YAML for a UI test definition
  */
@@ -198,20 +212,20 @@ function generateUiTestYaml(test) {
     const steps = test.steps.map(step => {
         let yaml = `      - action: ${step.action}`;
         if (step.description)
-            yaml += `\n        description: "${step.description}"`;
+            yaml += `\n        description: "${escapeYamlString(step.description)}"`;
         if (step.selector)
-            yaml += `\n        selector: "${step.selector}"`;
+            yaml += `\n        selector: "${escapeYamlString(step.selector)}"`;
         if (step.value)
-            yaml += `\n        value: "${step.value}"`;
+            yaml += `\n        value: "${escapeYamlString(String(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 || '/'}"
+    return `    - name: "${escapeYamlString(test.name)}"
+      description: "${escapeYamlString(test.description || '')}"
+      path: "${escapeYamlString(test.path || '/')}"
       steps:
 ${steps}`;
 }

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

@@ -47,6 +47,7 @@ export declare class PackMigrator {
     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

@@ -424,8 +424,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.13",
   "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.13",
   "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 {};