qa360 2.1.2 → 2.1.4

package/dist/index.js

@@ -1,246 +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/dist/scanners/dom-scanner.d.ts

@@ -1,52 +0,0 @@
-/**
- * DOM Element Scanner
- * Automatically discovers UI elements on a web page using Playwright
- */
-import type { Page } from '@playwright/test';
-import type { DiscoveredElement, ScanOptions } from '../types/scan.js';
-export declare class DOMScanner {
-    private page;
-    private url;
-    constructor(page: Page, url: string);
-    /**
-     * Scan the page for elements based on options
-     */
-    scan(options: ScanOptions): Promise<DiscoveredElement[]>;
-    /**
-     * Scan for buttons (button elements and elements with role="button")
-     */
-    private scanButtons;
-    /**
-     * Scan for links
-     */
-    private scanLinks;
-    /**
-     * Scan for forms
-     */
-    private scanForms;
-    /**
-     * Scan for inputs
-     */
-    private scanInputs;
-    /**
-     * Scan for images
-     */
-    private scanImages;
-    /**
-     * Scan for headings
-     */
-    private scanHeadings;
-    /**
-     * Generate a CSS selector for an element
-     * Priority: ID > first class > tag + attribute > tag
-     */
-    private generateSelector;
-    /**
-     * Check if a type should be included in the scan
-     */
-    private shouldInclude;
-    /**
-     * Filter out elements that match exclusion patterns
-     */
-    private filterExcluded;
-}

package/dist/scanners/dom-scanner.js

@@ -1,296 +0,0 @@
-/**
- * DOM Element Scanner
- * Automatically discovers UI elements on a web page using Playwright
- */
-export class DOMScanner {
-    page;
-    url;
-    constructor(page, url) {
-        this.page = page;
-        this.url = url;
-    }
-    /**
-     * Scan the page for elements based on options
-     */
-    async scan(options) {
-        const elements = [];
-        // 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")
-     */
-    async scanButtons() {
-        const elements = [];
-        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) => el.id || '').catch(() => '');
-                    className = await handle.evaluate((el) => 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
-     */
-    async scanLinks() {
-        const elements = [];
-        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) => el.id || '').catch(() => '');
-                className = await handle.evaluate((el) => 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
-     */
-    async scanForms() {
-        const elements = [];
-        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) => el.id || '').catch(() => '');
-                className = await handle.evaluate((el) => 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
-     */
-    async scanInputs() {
-        const elements = [];
-        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) => el.id || '').catch(() => '');
-                className = await handle.evaluate((el) => 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
-     */
-    async scanImages() {
-        const elements = [];
-        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) => el.id || '').catch(() => '');
-                className = await handle.evaluate((el) => 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
-     */
-    async scanHeadings() {
-        const elements = [];
-        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) => el.tagName?.toLowerCase() || '').catch(() => '');
-                id = await handle.evaluate((el) => el.id || '').catch(() => '');
-                className = await handle.evaluate((el) => 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
-     */
-    generateSelector(tag, id, className, extra) {
-        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
-     */
-    shouldInclude(type, include) {
-        if (!include || include.length === 0)
-            return true;
-        return include.includes(type) || include.includes('all');
-    }
-    /**
-     * Filter out elements that match exclusion patterns
-     */
-    filterExcluded(elements, exclude) {
-        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/dist/scanners/index.d.ts

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

package/dist/scanners/index.js

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