qa360 2.1.2 → 2.1.4

package/cli/src/index.ts

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+
+/**
+ * QA360 Core CLI - Zero friction quality proof runner
+ * 
+ * Transform software testing into verifiable, signed, and traceable proofs.
+ * One command, one file, one proof.
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf8'));
+const version = packageJson.version;
+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 { reportCommand } from './commands/report.js';
+import { verifyCommand } from './commands/verify.js';
+import { explainCommand } from './commands/explain.js';
+import { packValidateCommand, packLintCommand, packMigrateCommand } from './commands/pack.js';
+import { secretsAddCommand, secretsListCommand, secretsRemoveCommand, secretsDoctorCommand, secretsExportCommand } from './commands/secrets.js';
+import { createHistoryCommands } from './commands/history.js';
+import { createAICommands } from './commands/ai.js';
+import { createFlakinessCommands } from './commands/flakiness.js';
+import { createDashboardCommand } from './commands/monitor.js';
+import { coverageCommand } from './commands/coverage.js';
+import { sloCommand } from './commands/slo.js';
+import { regressionCommand } from './commands/regression.js';
+import { createRetryCommands } from './commands/retry.js';
+import { createCrawlCommand } from './commands/crawl.js';
+// import { createMonitorCommands } from './commands/monitor.js'; // TODO: Re-enable monitor imports
+// import { createOllamaCommands } from './commands/ollama.js'; // TODO: Re-enable when Ollama exports from core are fixed
+import { createGenerateCommands } from './commands/generate.js';
+// import { createRepairCommand } from './commands/repair.js'; // TODO: fix repair imports
+import { scanCommand } from './commands/scan.js';
+
+const program = new Command();
+
+program
+  .name('qa360')
+  .description('Transform software testing into verifiable, signed, and traceable proofs')
+  .version(version);
+
+// Core commands (Phase 1)
+program
+  .command('doctor')
+  .description('Health check and auto-fix issues')
+  .option('--fix', 'Automatically fix detected issues')
+  .option('--json', 'Output results as JSON')
+  .option('--strict', 'Exit with code 1 on any error')
+  .action(async (options) => {
+    await doctorCommand(options);
+  });
+
+program
+  .command('init')
+  .description('Generate pack.yml interactively')
+  .option('--template <name>', 'Use template: api-basic, ui-basic, fullstack, security, complete')
+  .option('--output <file>', 'Output file path', 'qa360.yml')
+  .option('--force', 'Overwrite existing file')
+  .option('-y, --yes', 'Skip prompts and use defaults')
+  .option('--beginner', 'Guided mode for first-time users with step-by-step explanations')
+  .action(async (options) => {
+    await initCommand(options);
+  });
+
+// Examples commands
+const examplesCommand = program
+  .command('examples')
+  .description('Manage example templates');
+
+examplesCommand
+  .command('list')
+  .description('List all available example templates')
+  .action(async () => {
+    await examplesListCommand();
+  });
+
+examplesCommand
+  .command('copy <template>')
+  .description('Copy example template to current directory')
+  .option('--output <file>', 'Output file path', 'qa360.yml')
+  .option('--force', 'Overwrite existing file')
+  .action(async (template, options) => {
+    await examplesCopyCommand(template, options);
+  });
+
+examplesCommand
+  .command('show <template>')
+  .description('Show example template content')
+  .action(async (template) => {
+    await examplesShowCommand(template);
+  });
+
+program
+  .command('ask [query]')
+  .description('Natural language test requests - generates pack.yml')
+  .action(async (query) => {
+    await askCommand(query);
+  });
+
+program
+  .command('run [pack]')
+  .description('Execute test pack')
+  .option('--mode <mode>', 'Execution mode: soft (continue on error) or strict (stop on first error)', 'soft')
+  .option('--retries <number>', 'Number of retries for failed tests', '2')
+  .option('--timeout <ms>', 'Global timeout for tests in milliseconds', '30000')
+  .option('--docker', 'Use Docker fallback for missing tools')
+  .option('--headed', 'Run UI tests in headed mode (visible browser)')
+  .action(async (pack, options) => {
+    await runCommand(pack, options);
+  });
+
+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...'));
+  });
+
+program
+  .command('report')
+  .description('Generate signed proof from latest run')
+  .option('--sign', 'Sign the proof with cryptographic signature')
+  .option('--format <format>', 'Output format: pdf, json, or both', 'both')
+  .option('--run-id <id>', 'Specific run ID to generate report for')
+  .action(async (options) => {
+    await reportCommand(options);
+  });
+
+program
+  .command('verify [proof]')
+  .description('Verify proof authenticity and integrity')
+  .option('--json', 'Output results as JSON')
+  .option('--verbose', 'Show detailed verification information')
+  .action(async (proof, options) => {
+    await verifyCommand(proof, options);
+  });
+
+program
+  .command('explain [input]')
+  .description('Explain errors, failures, and test results with AI')
+  .option('--ai', 'Use AI-powered explanation')
+  .option('-P, --provider <provider>', 'AI provider to use (deepseek, ollama, openai, anthropic)')
+  .option('--run <id>', 'Explain a specific test run')
+  .option('--gate <name>', 'Explain gate-specific failures')
+  .option('--json', 'Output as JSON')
+  .action(async (input, options) => {
+    await explainCommand(input, options);
+  });
+
+// Pack commands (Phase 2)
+const packCommand = program
+  .command('pack')
+  .description('Pack configuration management');
+
+packCommand
+  .command('validate [pack]')
+  .description('Validate pack.yml (auto-detects v1 or v2)')
+  .option('--check-files', 'Verify that referenced test files exist')
+  .action(async (pack, options) => {
+    await packValidateCommand(pack, options);
+  });
+
+packCommand
+  .command('lint [pack]')
+  .description('Auto-fix pack.yml formatting and structure')
+  .action(async (pack) => {
+    await packLintCommand(pack);
+  });
+
+packCommand
+  .command('migrate [pack]')
+  .description('Migrate pack v1 to v2 format')
+  .option('--output <file>', 'Output file path')
+  .option('--dry-run', 'Preview changes without writing files')
+  .action(async (pack, options) => {
+    await packMigrateCommand(pack, options);
+  });
+
+// Secrets commands (Phase 2)
+const secretsCommand = program
+  .command('secrets')
+  .description('Encrypted secrets management');
+
+secretsCommand
+  .command('add [name]')
+  .description('Add or update a secret')
+  .option('-v, --value <value>', 'Secret value (for non-interactive mode)')
+  .option('-n, --non-interactive', 'Disable all prompts and confirmations')
+  .action(async (name, options) => {
+    await secretsAddCommand(name, options);
+  });
+
+secretsCommand
+  .command('list')
+  .description('List all configured secrets')
+  .action(async () => {
+    await secretsListCommand();
+  });
+
+secretsCommand
+  .command('remove [name]')
+  .description('Remove a secret')
+  .action(async (name) => {
+    await secretsRemoveCommand(name);
+  });
+
+secretsCommand
+  .command('doctor')
+  .description('Check secrets system health')
+  .action(async () => {
+    await secretsDoctorCommand();
+  });
+
+secretsCommand
+  .command('export')
+  .description('Export secrets in redacted format')
+  .option('--redacted', 'Export with redacted values (default)', true)
+  .action(async (options) => {
+    await secretsExportCommand(options);
+  });
+
+program
+  .command('proof')
+  .description('Generate complete proof bundle (pack + results + signature)')
+  .action(async () => {
+    console.log(chalk.blue('📦 QA360 Proof Bundle'));
+    console.log(chalk.yellow('⚠️  Phase 3 implementation coming soon...'));
+  });
+
+// History commands (Evidence Vault)
+program.addCommand(createHistoryCommands());
+
+// Flakiness commands (Test reliability tracking)
+program.addCommand(createFlakinessCommands());
+
+// AI commands (DeepSeek, Ollama, OpenAI, Anthropic)
+program.addCommand(createAICommands());
+// program.addCommand(createOllamaCommands()); // TODO: Re-enable when Ollama exports from core are fixed
+
+// Generate AI commands (Phase 4)
+program.addCommand(createGenerateCommands());
+
+// Repair Commands (Phase 7 - Auto-Repair)
+// program.addCommand(createRepairCommand()); // TODO: Re-enable after fixing imports
+
+// Monitor Commands (Phase 8 - TUI & Dashboard)
+// program.addCommand(createMonitorCommands()); // TODO: Re-enable after fixing imports
+program.addCommand(createDashboardCommand());
+
+// Coverage Commands (Vision 2.0 - Phase 2 - F11)
+program.addCommand(coverageCommand);
+
+// SLO/SLI Commands (Vision 2.0 - Phase 2)
+program.addCommand(sloCommand);
+
+// Regression Commands (Vision 2.0 - Phase 2 - F12)
+program.addCommand(regressionCommand);
+
+// Retry Commands (Vision 2.0 - Phase 2 - F8 Smart Retry)
+program.addCommand(createRetryCommands());
+
+// Crawl Command (UI Testing 100% - Auto-generate packs from websites)
+program.addCommand(createCrawlCommand());
+
+// Scan Command (DOM Element Discovery)
+program.addCommand(scanCommand);
+
+// Show banner
+console.log(chalk.bold.blue('QA360 Core v' + version));
+console.log(chalk.gray('Transform software testing into verifiable, signed, and traceable proofs\n'));
+
+// Parse arguments
+program.parse();
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/cli/src/scanners/dom-scanner.ts

@@ -0,0 +1,360 @@
+/**
+ * DOM Element Scanner
+ * Automatically discovers UI elements on a web page using Playwright
+ */
+
+import type { Page } from '@playwright/test';
+import type { DiscoveredElement, ElementType, ScanOptions } from '../types/scan.js';
+
+export class DOMScanner {
+  private page: Page;
+  private url: string;
+
+  constructor(page: Page, url: string) {
+    this.page = page;
+    this.url = url;
+  }
+
+  /**
+   * Scan the page for elements based on options
+   */
+  async scan(options: ScanOptions): Promise<DiscoveredElement[]> {
+    const elements: DiscoveredElement[] = [];
+
+    // Scan based on included types
+    if (this.shouldInclude('buttons', options.include)) {
+      const buttons = await this.scanButtons();
+      elements.push(...buttons);
+    }
+
+    if (this.shouldInclude('links', options.include)) {
+      const links = await this.scanLinks();
+      elements.push(...links);
+    }
+
+    if (this.shouldInclude('forms', options.include)) {
+      const forms = await this.scanForms();
+      elements.push(...forms);
+    }
+
+    if (this.shouldInclude('inputs', options.include)) {
+      const inputs = await this.scanInputs();
+      elements.push(...inputs);
+    }
+
+    if (this.shouldInclude('images', options.include)) {
+      const images = await this.scanImages();
+      elements.push(...images);
+    }
+
+    if (this.shouldInclude('headings', options.include)) {
+      const headings = await this.scanHeadings();
+      elements.push(...headings);
+    }
+
+    // Apply exclusions
+    return this.filterExcluded(elements, options.exclude || []);
+  }
+
+  /**
+   * Scan for buttons (button elements and elements with role="button")
+   */
+  private async scanButtons(): Promise<DiscoveredElement[]> {
+    const elements: DiscoveredElement[] = [];
+    const selectors = [
+      'button',
+      '[role="button"]',
+      'input[type="submit"]',
+      'input[type="button"]'
+    ];
+
+    for (const baseSelector of selectors) {
+      const locators = await this.page.locator(baseSelector).all();
+
+      for (const locator of locators) {
+        const isVisible = await locator.isVisible().catch(() => false);
+        if (!isVisible) continue;
+
+        const box = await locator.boundingBox();
+        const text = await locator.textContent().catch(() => '');
+        const handle = await locator.elementHandle();
+
+        let id = '';
+        let className = '';
+
+        if (handle) {
+          id = await handle.evaluate((el: any) => el.id || '').catch(() => '');
+          className = await handle.evaluate((el: any) => el.className || '').catch(() => '');
+        }
+
+        elements.push({
+          type: 'button',
+          selector: this.generateSelector('button', id, className, baseSelector),
+          text: text?.trim() || undefined,
+          position: box || { x: 0, y: 0, width: 0, height: 0 },
+          visible: true,
+          page: this.url
+        });
+      }
+    }
+
+    return elements;
+  }
+
+  /**
+   * Scan for links
+   */
+  private async scanLinks(): Promise<DiscoveredElement[]> {
+    const elements: DiscoveredElement[] = [];
+    const locators = await this.page.locator('a[href]').all();
+
+    for (const locator of locators) {
+      const isVisible = await locator.isVisible().catch(() => false);
+      if (!isVisible) continue;
+
+      const box = await locator.boundingBox();
+      const text = await locator.textContent().catch(() => '');
+      const href = await locator.getAttribute('href').catch(() => '');
+      const handle = await locator.elementHandle();
+
+      let id = '';
+      let className = '';
+
+      if (handle) {
+        id = await handle.evaluate((el: any) => el.id || '').catch(() => '');
+        className = await handle.evaluate((el: any) => el.className || '').catch(() => '');
+      }
+
+      elements.push({
+        type: 'link',
+        selector: this.generateSelector('a', id, className),
+        text: text?.trim() || undefined,
+        attributes: { href: href || '' },
+        position: box || { x: 0, y: 0, width: 0, height: 0 },
+        visible: true,
+        page: this.url
+      });
+    }
+
+    return elements;
+  }
+
+  /**
+   * Scan for forms
+   */
+  private async scanForms(): Promise<DiscoveredElement[]> {
+    const elements: DiscoveredElement[] = [];
+    const locators = await this.page.locator('form').all();
+
+    for (const locator of locators) {
+      const isVisible = await locator.isVisible().catch(() => false);
+      if (!isVisible) continue;
+
+      const handle = await locator.elementHandle();
+      const action = await locator.getAttribute('action').catch(() => '');
+
+      let id = '';
+      let className = '';
+
+      if (handle) {
+        id = await handle.evaluate((el: any) => el.id || '').catch(() => '');
+        className = await handle.evaluate((el: any) => el.className || '').catch(() => '');
+      }
+
+      elements.push({
+        type: 'form',
+        selector: this.generateSelector('form', id, className),
+        attributes: { action: action || '' },
+        position: { x: 0, y: 0, width: 0, height: 0 },
+        visible: true,
+        page: this.url
+      });
+    }
+
+    return elements;
+  }
+
+  /**
+   * Scan for inputs
+   */
+  private async scanInputs(): Promise<DiscoveredElement[]> {
+    const elements: DiscoveredElement[] = [];
+    const locators = await this.page.locator('input, textarea, select').all();
+
+    for (const locator of locators) {
+      const isVisible = await locator.isVisible().catch(() => false);
+      if (!isVisible) continue;
+
+      const box = await locator.boundingBox();
+      const handle = await locator.elementHandle();
+
+      let type = '';
+      let name = '';
+      let id = '';
+      let className = '';
+      let placeholder = '';
+
+      if (handle) {
+        type = await locator.getAttribute('type').catch(() => 'text') || 'text';
+        name = await locator.getAttribute('name').catch(() => '') || '';
+        placeholder = await locator.getAttribute('placeholder').catch(() => '') || '';
+        id = await handle.evaluate((el: any) => el.id || '').catch(() => '');
+        className = await handle.evaluate((el: any) => el.className || '').catch(() => '');
+      }
+
+      elements.push({
+        type: 'input',
+        selector: this.generateSelector('input', id, className, `[type="${type}"]`),
+        text: placeholder || undefined,
+        attributes: {
+          type,
+          name,
+          placeholder
+        },
+        position: box || { x: 0, y: 0, width: 0, height: 0 },
+        visible: true,
+        page: this.url
+      });
+    }
+
+    return elements;
+  }
+
+  /**
+   * Scan for images
+   */
+  private async scanImages(): Promise<DiscoveredElement[]> {
+    const elements: DiscoveredElement[] = [];
+    const locators = await this.page.locator('img').all();
+
+    for (const locator of locators) {
+      const isVisible = await locator.isVisible().catch(() => false);
+      if (!isVisible) continue;
+
+      const box = await locator.boundingBox();
+      const handle = await locator.elementHandle();
+
+      let src = '';
+      let alt = '';
+      let id = '';
+      let className = '';
+
+      if (handle) {
+        src = await locator.getAttribute('src').catch(() => '') || '';
+        alt = await locator.getAttribute('alt').catch(() => '') || '';
+        id = await handle.evaluate((el: any) => el.id || '').catch(() => '');
+        className = await handle.evaluate((el: any) => el.className || '').catch(() => '');
+      }
+
+      elements.push({
+        type: 'image',
+        selector: this.generateSelector('img', id, className, `[src="${src}"]`),
+        text: alt || undefined,
+        attributes: {
+          src,
+          alt
+        },
+        position: box || { x: 0, y: 0, width: 0, height: 0 },
+        visible: true,
+        page: this.url
+      });
+    }
+
+    return elements;
+  }
+
+  /**
+   * Scan for headings
+   */
+  private async scanHeadings(): Promise<DiscoveredElement[]> {
+    const elements: DiscoveredElement[] = [];
+    const locators = await this.page.locator('h1, h2, h3, h4, h5, h6').all();
+
+    for (const locator of locators) {
+      const isVisible = await locator.isVisible().catch(() => false);
+      if (!isVisible) continue;
+
+      const box = await locator.boundingBox();
+      const text = await locator.textContent().catch(() => '');
+      const handle = await locator.elementHandle();
+
+      let tag = '';
+      let id = '';
+      let className = '';
+
+      if (handle) {
+        tag = await handle.evaluate((el: any) => el.tagName?.toLowerCase() || '').catch(() => '');
+        id = await handle.evaluate((el: any) => el.id || '').catch(() => '');
+        className = await handle.evaluate((el: any) => el.className || '').catch(() => '');
+      }
+
+      elements.push({
+        type: 'heading',
+        selector: this.generateSelector(tag || 'h1', id, className),
+        text: text?.trim() || undefined,
+        attributes: { level: tag || 'h1' },
+        position: box || { x: 0, y: 0, width: 0, height: 0 },
+        visible: true,
+        page: this.url
+      });
+    }
+
+    return elements;
+  }
+
+  /**
+   * Generate a CSS selector for an element
+   * Priority: ID > first class > tag + attribute > tag
+   */
+  private generateSelector(
+    tag: string,
+    id: string,
+    className: string,
+    extra?: string
+  ): string {
+    if (id) {
+      return `#${id}`;
+    }
+
+    const classes = className.split(' ').filter(c => c.length > 0);
+    if (classes.length > 0) {
+      return `${tag}.${classes[0]}`;
+    }
+
+    if (extra) {
+      return `${tag}${extra}`;
+    }
+
+    return tag;
+  }
+
+  /**
+   * Check if a type should be included in the scan
+   */
+  private shouldInclude(type: ElementType, include?: ElementType[]): boolean {
+    if (!include || include.length === 0) return true;
+    return include.includes(type) || include.includes('all');
+  }
+
+  /**
+   * Filter out elements that match exclusion patterns
+   */
+  private filterExcluded(
+    elements: DiscoveredElement[],
+    exclude: string[]
+  ): DiscoveredElement[] {
+    if (exclude.length === 0) return elements;
+
+    return elements.filter(el => {
+      return !exclude.some(pattern => {
+        // Convert simple glob pattern to regex
+        const regexPattern = pattern
+          .replace(/\*/g, '.*')
+          .replace(/\?/g, '.');
+
+        const regex = new RegExp(regexPattern);
+        return regex.test(el.selector);
+      });
+    });
+  }
+}

package/cli/src/scanners/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Scanner exports
+ */
+
+export { DOMScanner } from './dom-scanner.js';