qa360 2.2.1 → 2.2.13

package/cli/src/index.ts

@@ -1,289 +0,0 @@
-#!/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

@@ -1,360 +0,0 @@
-/**
- * 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

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