create-backlist 10.0.2 → 10.0.4

package/src/qa/reporters/json.js

@@ -0,0 +1,49 @@
+// CI/CD JSON reporter — structured output for integrations
+import fs   from 'fs-extra';
+import path from 'node:path';
+import { VERSION } from '../qa-engine.js';
+
+export class JSONReporter {
+  #session;
+
+  constructor(session) { this.#session = session; }
+
+  async generate(reportDir) {
+    const summary  = this.#session.getSummary();
+    const filename = `${this.#session.id.toLowerCase()}.json`;
+    const filepath = path.join(reportDir, filename);
+
+    const output = {
+      meta: {
+        version    : VERSION,
+        runId      : this.#session.id,
+        generatedAt: new Date().toISOString(),
+        dataSource : 'real-runtime-testing',
+      },
+      urls      : this.#session.urls,
+      summary,
+      results   : this.#session.results,
+      bugs      : this.#session.bugs,
+      routeMap  : this.#session.routeMap,
+      apiLog    : this.#session.apiLog,
+      secFindings: this.#session.secFindings,
+      perfMetrics: this.#session.perfMetrics,
+      a11yResults: this.#session.a11yResults,
+      seoResults : this.#session.seoResults,
+      consoleErrors: this.#session.consoleErrors,
+      networkLog : this.#session.networkLog.filter(e => e.type === 'failed'),
+      screenshots: this.#session.screenshots,
+      // CI-friendly exit signals
+      ci: {
+        exitCode   : summary.failed > 0 || this.#session.bugs.some(b => b.severity === 'P0') ? 1 : 0,
+        p0BugCount : this.#session.bugs.filter(b => b.severity === 'P0').length,
+        p1BugCount : this.#session.bugs.filter(b => b.severity === 'P1').length,
+        passRate   : summary.passRate,
+        passed     : summary.passed === summary.total,
+      },
+    };
+
+    await fs.writeJson(filepath, output, { spaces: 2 });
+    return filepath;
+  }
+}

package/src/qa/reporters/terminal.js

@@ -0,0 +1,184 @@
+// Real-time terminal dashboard — shows ACTUAL test execution
+import chalk from 'chalk';
+import { formatDuration } from '../qa-engine.js';
+
+const ESC        = '\x1b[';
+const CLEAR_LINE = ESC + '2K\r';
+const CURSOR_UP  = (n) => ESC + `${n}A`;
+const CURSOR_HIDE = ESC + '?25l';
+const CURSOR_SHOW = ESC + '?25h';
+
+export class TerminalDashboard {
+  #session;
+  #lines      = 0;
+  #active     = false;
+  #startTime  = Date.now();
+  #phase      = 'Initializing...';
+  #currentTest = '';
+  #log        = [];
+  #timer      = null;
+
+  constructor(session) { this.#session = session; }
+
+  start() {
+    this.#active    = true;
+    this.#startTime = Date.now();
+    process.stdout.write(CURSOR_HIDE);
+    this.#render();
+    this.#timer = setInterval(() => this.#render(), 500);
+  }
+
+  stop() {
+    this.#active = false;
+    if (this.#timer) { clearInterval(this.#timer); this.#timer = null; }
+    process.stdout.write(CURSOR_SHOW);
+    this.#clear();
+    this.#printFinalSummary();
+  }
+
+  setPhase(phase)       { this.#phase = phase; this.log(chalk.cyan(phase)); }
+  setCurrentTest(name)  { this.#currentTest = name; }
+  addResult(result)     { this.#currentTest = ''; }
+
+  log(msg) {
+    const entry = `${chalk.gray(new Date().toLocaleTimeString())} ${msg}`;
+    this.#log.push(entry);
+    if (this.#log.length > 12) this.#log.shift();
+  }
+
+  #render() {
+    if (!this.#active) return;
+    this.#clear();
+
+    const lines   = this.#buildLines();
+    this.#lines   = lines.length;
+    process.stdout.write(lines.join('\n') + '\n');
+  }
+
+  #clear() {
+    if (this.#lines > 0) {
+      process.stdout.write(CURSOR_UP(this.#lines) + CLEAR_LINE);
+      for (let i = 1; i < this.#lines; i++) {
+        process.stdout.write('\n' + CLEAR_LINE);
+      }
+      process.stdout.write(CURSOR_UP(this.#lines - 1));
+    }
+    this.#lines = 0;
+  }
+
+  #buildLines() {
+    const elapsed  = ((Date.now() - this.#startTime) / 1000).toFixed(1);
+    const results  = this.#session.results;
+    const bugs     = this.#session.bugs;
+    const passed   = results.filter(r => r.status === 'PASS' || r.status === 'FLAKY').length;
+    const failed   = results.filter(r => r.status === 'FAIL').length;
+    const total    = results.length;
+    const passRate = total > 0 ? Math.round((passed / total) * 100) : 0;
+    const mem      = process.memoryUsage();
+    const heapMB   = (mem.heapUsed / 1024 / 1024).toFixed(0);
+
+    const w     = Math.min(process.stdout.columns || 80, 90);
+    const bar   = '─'.repeat(w - 2);
+    const lines = [];
+
+    const c1  = chalk.hex('#00F5FF');
+    const c2  = chalk.hex('#BF40FF');
+    const pad = (s) => String(s).padEnd(w - 2);
+
+    lines.push(c1(`┌${bar}┐`));
+    lines.push(c1('│') + c2.bold(pad(`  ⚡ BACKLIST ENTERPRISE QA v12.0 — REAL RUNTIME TESTING`)) + c1('│'));
+    lines.push(c1(`├${bar}┤`));
+    lines.push(c1('│') + pad(`  ${chalk.cyan('Phase:')} ${chalk.white(this.#phase.slice(0, w - 14))}`) + c1('│'));
+    lines.push(c1(`├${bar}┤`));
+
+    // Real metrics
+    const pBar = this.#progressBar(passRate, 28);
+    lines.push(c1('│') + pad(
+      `  ${chalk.green('✓')} ${chalk.bold(passed)} pass  ` +
+      `${chalk.red('✗')} ${chalk.bold(failed)} fail  ` +
+      `${chalk.cyan('🐛')} ${chalk.bold(bugs.length)} bugs  ` +
+      `${chalk.gray('⏱')} ${chalk.white(elapsed + 's')}  ` +
+      `${chalk.gray('Heap')} ${chalk.white(heapMB + 'MB')}`
+    ) + c1('│'));
+    lines.push(c1('│') + pad(
+      `  [${pBar}] ${chalk.bold(passRate + '%')} (${total} real tests)`
+    ) + c1('│'));
+    lines.push(c1(`├${bar}┤`));
+
+    // Current test
+    const ct = this.#currentTest
+      ? `  ${chalk.yellow('⟳')} ${chalk.yellow('Testing:')} ${chalk.white(this.#currentTest.slice(0, w - 18))}`
+      : `  ${chalk.gray('⊙  Awaiting next test...')}`;
+    lines.push(c1('│') + pad(ct) + c1('│'));
+    lines.push(c1(`├${bar}┤`));
+
+    // Discovered routes
+    const routeCount = this.#session.routeMap.length;
+    const apiCount   = this.#session.apiLog.length;
+    const screensCount = this.#session.screenshots.length;
+    lines.push(c1('│') + pad(
+      `  ${chalk.cyan('Routes:')} ${chalk.white(routeCount)}  ` +
+      `${chalk.cyan('APIs:')} ${chalk.white(apiCount)}  ` +
+      `${chalk.cyan('Screenshots:')} ${chalk.white(screensCount)}  ` +
+      `${chalk.cyan('Net errors:')} ${chalk.white(this.#session.networkLog.filter(e => e.type === 'failed').length)}`
+    ) + c1('│'));
+    lines.push(c1(`├${bar}┤`));
+
+    // Recent real results
+    lines.push(c1('│') + chalk.gray(pad('  Real Test Results:')) + c1('│'));
+    const recent = results.slice(-6);
+    for (const r of recent) {
+      const icon = r.status === 'PASS'  ? chalk.green('✓')
+                 : r.status === 'FAIL'  ? chalk.red('✗')
+                 : r.status === 'FLAKY' ? chalk.yellow('⚠')
+                 : chalk.gray('⊘');
+      const dur  = chalk.gray(formatDuration(r.duration || 0));
+      const name = r.name?.slice(0, w - 36) || '';
+      lines.push(c1('│') + pad(`  ${icon} ${chalk.gray('[' + (r.type || '').padEnd(12) + ']')} ${chalk.white(name)} ${dur}`) + c1('│'));
+    }
+    for (let i = recent.length; i < 6; i++) {
+      lines.push(c1('│') + pad('') + c1('│'));
+    }
+
+    // Log
+    lines.push(c1(`├${bar}┤`));
+    lines.push(c1('│') + chalk.gray(pad('  Live log:')) + c1('│'));
+    for (const entry of this.#log.slice(-5)) {
+      lines.push(c1('│') + ('  ' + entry).slice(0, w - 2).padEnd(w - 2) + c1('│'));
+    }
+    for (let i = this.#log.length; i < 5; i++) {
+      lines.push(c1('│') + pad('') + c1('│'));
+    }
+
+    lines.push(c1(`└${bar}┘`));
+    lines.push(chalk.dim(`  Real runtime data only · ${total} tests · ${bugs.length} bugs · Ctrl+C to stop`));
+
+    return lines;
+  }
+
+  #progressBar(pct, width = 20) {
+    const filled = Math.min(Math.round((pct / 100) * width), width);
+    const empty  = width - filled;
+    const color  = pct >= 90 ? chalk.green : pct >= 70 ? chalk.yellow : chalk.red;
+    return color('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+  }
+
+  #printFinalSummary() {
+    const summary = this.#session.getSummary();
+    const color   = Number(summary.passRate) >= 90 ? chalk.green
+                  : Number(summary.passRate) >= 70 ? chalk.yellow : chalk.red;
+
+    console.log('');
+    console.log(chalk.hex('#00F5FF').bold('  ── Real Runtime QA Results ─────────────────────────────'));
+    console.log(`  Tests run:  ${chalk.white.bold(summary.total)}`);
+    console.log(`  Passed:     ${chalk.green.bold(summary.passed)}`);
+    console.log(`  Failed:     ${chalk.red.bold(summary.failed)}`);
+    console.log(`  Flaky:      ${chalk.yellow.bold(summary.flaky)}`);
+    console.log(`  Pass rate:  ${color.bold(summary.passRate + '%')}`);
+    console.log(`  Bugs found: ${chalk.cyan.bold(this.#session.bugs.length)}`);
+    console.log(`  Duration:   ${chalk.white(formatDuration(summary.duration))}`);
+    console.log(`  Routes:     ${chalk.white(this.#session.routeMap.length)} discovered`);
+    console.log(`  Screenshots:${chalk.white(this.#session.screenshots.length)} captured`);
+    console.log('');
+  }
+}

package/src/qa/utils/ai-classifier.js

@@ -0,0 +1,98 @@
+// AI-assisted bug classification — pattern matching + heuristics
+// (Works without external API — pure local intelligence)
+
+const SEVERITY_PATTERNS = {
+  P0: [
+    /security|auth.*bypass|sql.inject|xss|rce|remote.code|exposed.*secret|password.*leak/i,
+    /crash|fatal|500.*error|server.*down|database.*connect.*fail/i,
+    /payment|transaction|data.*loss|corrupt/i,
+  ],
+  P1: [
+    /login.*fail|auth.*error|jwt|token.*invalid/i,
+    /api.*timeout|endpoint.*down|cors.*error/i,
+    /form.*broken|submit.*fail|validation.*miss/i,
+    /lcp|largest.*contentful|performance.*poor/i,
+    /wcag|accessibility.*critical|a11y.*serious/i,
+  ],
+  P2: [
+    /console.*error|js.*error|runtime.*error/i,
+    /network.*fail|fetch.*error|404/i,
+    /missing.*meta|seo.*issue|canonical/i,
+    /slow.*resource|image.*size|bundle.*large/i,
+  ],
+  P3: [
+    /warning|minor|style|layout|cosmetic/i,
+    /todo|typo|label|placeholder/i,
+    /p3|low.*priority/i,
+  ],
+};
+
+const CATEGORY_PATTERNS = {
+  'security'     : /security|csp|hsts|cors|xss|injection|auth|token|csrf/i,
+  'performance'  : /lcp|fcp|cls|fid|ttfb|tbt|slow|timeout|load.*time|render/i,
+  'accessibility': /wcag|a11y|aria|alt.*text|contrast|keyboard|screen.*reader/i,
+  'seo'          : /title|meta|description|canonical|sitemap|robots|og:|h1/i,
+  'api'          : /api|endpoint|status.*code|response|json|rest|graphql/i,
+  'javascript'   : /js.*error|console.*error|uncaught|undefined|null.*reference/i,
+  'network'      : /network|fetch|xhr|request.*fail|connection/i,
+  'form'         : /form|input|submit|validation|field|required/i,
+  'auth'         : /login|auth|token|session|password|credential|logout/i,
+  'ui'           : /layout|render|visual|style|component|button|link/i,
+};
+
+const RECOMMENDATIONS = {
+  'security'     : 'Review security configuration and conduct a penetration test',
+  'performance'  : 'Run Lighthouse audit and optimize assets/server response times',
+  'accessibility': 'Fix WCAG 2.1 AA violations — use aXe DevTools for details',
+  'seo'          : 'Fix meta tags and submit updated sitemap to Search Console',
+  'api'          : 'Check API contract, add proper error handling and status codes',
+  'javascript'   : 'Debug JavaScript errors in browser DevTools — add error boundaries',
+  'network'      : 'Check CDN, server logs, and network configuration',
+  'form'         : 'Add client-side and server-side validation to all forms',
+  'auth'         : 'Audit authentication flow — check JWT expiry and refresh logic',
+  'ui'           : 'Test across browsers and screen sizes — check CSS specificity',
+};
+
+export class AIClassifier {
+  async classify(bug, session) {
+    const text = `${bug.title} ${bug.description || ''}`.toLowerCase();
+
+    // Determine severity from patterns
+    let severity   = bug.severity || 'P3';
+    let confidence = 0.7;
+
+    for (const [sev, patterns] of Object.entries(SEVERITY_PATTERNS)) {
+      if (patterns.some(p => p.test(text))) {
+        severity   = sev;
+        confidence = 0.85;
+        break;
+      }
+    }
+
+    // Determine category
+    let category = bug.type || 'general';
+    for (const [cat, pattern] of Object.entries(CATEGORY_PATTERNS)) {
+      if (pattern.test(text)) {
+        category = cat;
+        break;
+      }
+    }
+
+    // Context from session
+    const relatedBugs = session.bugs.filter(b =>
+      b.id !== bug.id && b.type === bug.type
+    ).length;
+
+    if (relatedBugs > 3) {
+      // Systemic issue — upgrade severity
+      const order = ['P3','P2','P1','P0'];
+      const idx   = order.indexOf(severity);
+      if (idx > 0) { severity = order[idx - 1]; confidence = 0.9; }
+    }
+
+    const recommendation = RECOMMENDATIONS[category]
+      || 'Investigate and fix based on error details';
+
+    return { severity, category, recommendation, confidence };
+  }
+}