qa360 1.4.5 → 2.0.1

package/dist/commands/init.js

@@ -5,6 +5,7 @@
  *   qa360 init
  *   qa360 init --template api-basic
  *   qa360 init --output custom-pack.yml
+ *   qa360 init --beginner    # Guided mode for first-time users
  */
 import { existsSync, writeFileSync, mkdirSync } from 'fs';
 import { join, resolve } from 'path';
@@ -19,41 +20,243 @@ export const TEMPLATES = {
         name: 'API Basic',
         description: 'Simple API smoke tests (REST/GraphQL)',
         gates: ['api_smoke'],
+        icon: '🔌',
     },
     'ui-basic': {
         name: 'UI Basic',
         description: 'Basic UI/E2E browser tests',
         gates: ['ui'],
+        icon: '🌐',
     },
     'fullstack': {
         name: 'Full Stack',
         description: 'API + UI + Performance tests',
         gates: ['api_smoke', 'ui', 'perf'],
+        icon: '🎯',
     },
     'security': {
         name: 'Security',
         description: 'SAST, DAST, secrets scanning, dependency checks',
         gates: ['sast', 'dast', 'secrets', 'deps'],
+        icon: '🛡️',
     },
     'complete': {
         name: 'Complete',
         description: 'All quality gates (API, UI, Performance, Security, Accessibility)',
         gates: ['api_smoke', 'ui', 'a11y', 'perf', 'sast', 'dast', 'secrets', 'deps'],
+        icon: '✨',
     },
 };
 /**
- * Gate descriptions
+ * Gate descriptions with beginner-friendly explanations
  */
 export const GATE_DESCRIPTIONS = {
-    api_smoke: 'API smoke tests (REST/GraphQL health checks)',
-    ui: 'UI/E2E tests (browser automation)',
-    a11y: 'Accessibility tests (WCAG compliance)',
-    perf: 'Performance tests (load/stress testing)',
-    sast: 'Static security analysis (code scanning)',
-    dast: 'Dynamic security testing (runtime scanning)',
-    secrets: 'Secrets detection (credential scanning)',
-    deps: 'Dependency vulnerability checks',
+    api_smoke: {
+        short: 'API smoke tests (REST/GraphQL health checks)',
+        beginner: 'Tests if your API is alive and responds correctly. Like checking if the server is up.',
+        example: 'Checks if GET /api/health returns 200 OK',
+        icon: '🔌',
+    },
+    ui: {
+        short: 'UI/E2E tests (browser automation)',
+        beginner: 'Tests your website in a real browser. Checks if pages load and buttons work.',
+        example: 'Opens your site and verifies the login form appears',
+        icon: '🌐',
+    },
+    a11y: {
+        short: 'Accessibility tests (WCAG compliance)',
+        beginner: 'Tests if your site is usable by people with disabilities (screen readers, color blindness).',
+        example: 'Checks if images have alt text for blind users',
+        icon: '♿',
+    },
+    perf: {
+        short: 'Performance tests (load/stress testing)',
+        beginner: 'Tests if your site stays fast when many people visit at once.',
+        example: 'Simulates 100 users visiting simultaneously',
+        icon: '⚡',
+    },
+    sast: {
+        short: 'Static security analysis (code scanning)',
+        beginner: 'Analyzes your source code for security vulnerabilities without running it.',
+        example: 'Finds hardcoded passwords or unsafe functions',
+        icon: '🔍',
+    },
+    dast: {
+        short: 'Dynamic security testing (runtime scanning)',
+        beginner: 'Attacks your running application to find security weaknesses.',
+        example: 'Tries common attacks like SQL injection',
+        icon: '⚔️',
+    },
+    secrets: {
+        short: 'Secrets detection (credential scanning)',
+        beginner: 'Scans for accidentally committed passwords, API keys, or tokens.',
+        example: 'Finds AWS keys in your code',
+        icon: '🔑',
+    },
+    deps: {
+        short: 'Dependency vulnerability checks',
+        beginner: 'Checks if your libraries have known security issues.',
+        example: 'Checks if you use an old version of a package with bugs',
+        icon: '📦',
+    },
 };
+/**
+ * Beginner mode - Step by step guided experience
+ */
+async function beginnerMode() {
+    console.log(chalk.bold.cyan('\n╔════════════════════════════════════════════════════════════╗'));
+    console.log(chalk.bold.cyan('║       👋 Welcome to QA360 - Your Quality Assistant!          ║'));
+    console.log(chalk.bold.cyan('║                                                              ║'));
+    console.log(chalk.bold.cyan('║   Let\'s create your first test pack together, step by step.    ║'));
+    console.log(chalk.bold.cyan('╚════════════════════════════════════════════════════════════╝\n'));
+    console.log(chalk.gray('📦 What is a "test pack"?'));
+    console.log(chalk.white('   A test pack defines WHAT to test (your API, website) and HOW (smoke tests, security scans).\n'));
+    // Step 1: Project name
+    console.log(chalk.bold('Step 1️⃣  - Project Name'));
+    console.log(chalk.gray('   Give your test pack a memorable name.\n'));
+    const { name } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'What should we call your test pack?',
+            default: 'my-first-tests',
+            validate: (input) => input.length > 0 || 'Name is required',
+        },
+    ]);
+    console.log(chalk.green(`   ✓ Great! Your test pack is called "${name}"\n`));
+    // Step 2: What to test?
+    console.log(chalk.bold('Step 2️⃣  - What do you want to test?'));
+    console.log(chalk.gray('   Select the type of application you want to test.\n'));
+    const { appType } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'appType',
+            message: 'What type of application are you testing?',
+            choices: [
+                { name: '🔌 API / Backend - REST or GraphQL API', value: 'api' },
+                { name: '🌐 Website / Frontend - Web application', value: 'web' },
+                { name: '🎯 Full Stack - Both API and Website', value: 'fullstack' },
+                { name: '🛡️ Security Scan - Check for vulnerabilities', value: 'security' },
+                { name: '✨ Everything - All tests enabled', value: 'complete' },
+            ],
+        },
+    ]);
+    console.log(chalk.green(`   ✓ You chose: ${appType}\n`));
+    // Step 3: Gates explanation and selection
+    const suggestedGates = TEMPLATES[appType === 'complete' ? 'complete' : appType === 'fullstack' ? 'fullstack' : appType === 'api' ? 'api-basic' : appType === 'web' ? 'ui-basic' : 'security']?.gates || [];
+    console.log(chalk.bold('Step 3️⃣  - Quality Gates'));
+    console.log(chalk.gray('   Gates are different types of tests. We\'ll suggest some based on your choice.\n'));
+    console.log(chalk.cyan('   Suggested gates for you:\n'));
+    for (const gate of suggestedGates) {
+        const info = GATE_DESCRIPTIONS[gate];
+        console.log(chalk.cyan(`     ${info?.icon} ${gate}`));
+        console.log(chalk.gray(`       ${info?.beginner}`));
+        console.log(chalk.gray(`       Example: ${info?.example}\n`));
+    }
+    const { useSuggested } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'useSuggested',
+            message: 'Use the suggested gates?',
+            default: true,
+        },
+    ]);
+    let gates = suggestedGates;
+    if (!useSuggested) {
+        const { customGates } = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'customGates',
+                message: 'Select the gates you want:',
+                choices: Object.entries(GATE_DESCRIPTIONS).map(([key, info]) => ({
+                    name: `${info?.icon} ${key} - ${info?.short}`,
+                    value: key,
+                })),
+                validate: (input) => input.length > 0 || 'Select at least one gate',
+            },
+        ]);
+        gates = customGates;
+    }
+    console.log(chalk.green(`   ✓ Selected gates: ${gates.join(', ')}\n`));
+    // Step 4: URLs
+    console.log(chalk.bold('Step 4️⃣  - Application URLs'));
+    console.log(chalk.gray('   Where is your application running?\n'));
+    const targets = {};
+    if (gates.includes('api_smoke')) {
+        console.log(chalk.cyan('   📡 API Configuration'));
+        const apiAnswers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'apiUrl',
+                message: 'What is your API base URL?',
+                default: 'https://api.example.com',
+                validate: (input) => input.startsWith('http') || 'Must start with http:// or https://',
+            },
+            {
+                type: 'input',
+                name: 'smokeTests',
+                message: 'Which endpoints should we test? (format: "METHOD /path -> status")',
+                default: 'GET /health -> 200',
+            },
+        ]);
+        targets.api = {
+            baseUrl: apiAnswers.apiUrl,
+            smoke: [apiAnswers.smokeTests],
+        };
+        console.log(chalk.green(`   ✓ API: ${apiAnswers.apiUrl}\n`));
+    }
+    if (gates.includes('ui') || gates.includes('a11y')) {
+        console.log(chalk.cyan('   🌐 Website Configuration'));
+        const uiAnswers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'webUrl',
+                message: 'What is your website URL?',
+                default: 'https://example.com',
+                validate: (input) => input.startsWith('http') || 'Must start with http:// or https://',
+            },
+        ]);
+        targets.web = {
+            baseUrl: uiAnswers.webUrl,
+            pages: [uiAnswers.webUrl],
+        };
+        console.log(chalk.green(`   ✓ Website: ${uiAnswers.webUrl}\n`));
+    }
+    // Build pack
+    const pack = {
+        version: 1,
+        name,
+        gates: gates,
+        targets,
+    };
+    // Add budgets
+    if (gates.includes('perf') || gates.includes('a11y')) {
+        pack.budgets = {};
+        if (gates.includes('perf')) {
+            pack.budgets.perf_p95_ms = 2000;
+        }
+        if (gates.includes('a11y')) {
+            pack.budgets.a11y_min = 90;
+        }
+    }
+    // Add security config
+    if (gates.some((g) => ['sast', 'dast', 'secrets', 'deps'].includes(g))) {
+        pack.security = {};
+        if (gates.includes('sast')) {
+            pack.security.sast = { max_critical: 0, max_high: 3 };
+        }
+        if (gates.includes('dast')) {
+            pack.security.dast = { max_high: 5 };
+        }
+    }
+    // Final summary
+    console.log(chalk.bold.cyan('\n✨ Almost done! Here\'s your test pack summary:\n'));
+    console.log(chalk.white(`   Name: ${chalk.bold(name)}`));
+    console.log(chalk.white(`   Gates: ${gates.map(g => `${GATE_DESCRIPTIONS[g]?.icon} ${g}`).join(', ')}`));
+    console.log(chalk.white(`   API: ${targets.api?.baseUrl || 'N/A'}`));
+    console.log(chalk.white(`   Website: ${targets.web?.baseUrl || 'N/A'}`));
+    return pack;
+}
 /**
  * Interactive prompts
  */
@@ -263,7 +466,11 @@ export async function initCommand(options = {}) {
         }
         // Generate pack config
         let pack;
-        if (options.template) {
+        if (options.beginner) {
+            // Beginner guided mode
+            pack = await beginnerMode();
+        }
+        else if (options.template) {
             // Use template directly
             pack = generateFromTemplate(options.template);
             console.log(chalk.green(`✅ Using template: ${TEMPLATES[options.template]?.name || options.template}`));

package/dist/commands/monitor.d.ts

@@ -0,0 +1,27 @@
+/**
+ * CLI Commands for TUI and Dashboard monitoring
+ * Phase 8: Real-time test execution visualization
+ */
+import { Command } from 'commander';
+/**
+ * Monitor command - Run tests with TUI
+ */
+export declare const monitorCommand: (pack: string | undefined, options: {
+    mode?: string;
+    retries?: string;
+    timeout?: string;
+    docker?: boolean;
+}) => Promise<void>;
+/**
+ * Dashboard command - Run tests with web dashboard
+ */
+export declare const dashboardCommand: (pack: string | undefined, options: {
+    port?: string;
+    host?: string;
+    autoOpen?: boolean;
+}) => Promise<void>;
+/**
+ * Create monitor and dashboard commands
+ */
+export declare function createMonitorCommands(): Command;
+export declare function createDashboardCommand(): Command;

package/dist/commands/monitor.js

@@ -0,0 +1,225 @@
+/**
+ * CLI Commands for TUI and Dashboard monitoring
+ * Phase 8: Real-time test execution visualization
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { TUIMonitor } from '../core/index.js';
+import { DashboardServer, EvidenceVault } from '../core/index.js';
+import { Phase3Runner } from '../core/index.js';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { loadPackConfig } from '../utils/config.js';
+/**
+ * Monitor command - Run tests with TUI
+ */
+export const monitorCommand = async (pack, options) => {
+    const packPath = pack || findDefaultPack();
+    if (!packPath) {
+        console.error(chalk.red('Error: No pack file found. Specify a pack file or run qa360 init.'));
+        process.exit(1);
+    }
+    // Load pack config
+    const packConfig = await loadPackConfig(packPath);
+    const workingDir = process.cwd();
+    // Get gate names
+    const gateNames = getGateNames(packConfig);
+    // Create TUI monitor
+    const monitor = new TUIMonitor({
+        refreshRate: 500,
+        colors: true,
+        compact: false
+    });
+    monitor.start(gateNames.length);
+    try {
+        // Create runner with event emission
+        const runner = new Phase3Runner({
+            workingDir,
+            pack: packConfig
+        });
+        // Emit events to monitor
+        monitor.emit({
+            type: 'phase_start',
+            timestamp: Date.now(),
+            data: { phase: 'Initializing' }
+        });
+        // Run tests (simplified - in real implementation, Phase3Runner would emit events)
+        const result = await runner.run();
+        // Update monitor with results
+        for (const gate of result.gates) {
+            monitor.emit({
+                type: 'gate_start',
+                timestamp: Date.now(),
+                data: { gate: gate.gate }
+            });
+            monitor.emit({
+                type: 'gate_end',
+                timestamp: Date.now(),
+                data: {
+                    gate: gate.gate,
+                    success: gate.success,
+                    results: {
+                        total: gate.results?.summary?.total || 0,
+                        passed: gate.results?.summary?.passed || 0,
+                        failed: gate.results?.summary?.failed || 0
+                    }
+                }
+            });
+        }
+        monitor.complete();
+    }
+    catch (error) {
+        monitor.emit({
+            type: 'error',
+            timestamp: Date.now(),
+            data: { error: error instanceof Error ? error.message : String(error) }
+        });
+    }
+};
+/**
+ * Dashboard command - Run tests with web dashboard
+ */
+export const dashboardCommand = async (pack, options) => {
+    const packPath = pack || findDefaultPack();
+    if (!packPath) {
+        console.error(chalk.red('Error: No pack file found. Specify a pack file or run qa360 init.'));
+        process.exit(1);
+    }
+    const port = options.port ? parseInt(options.port) : 8080;
+    const host = options.host || '127.0.0.1';
+    const workingDir = process.cwd();
+    // Load pack config
+    const packConfig = await loadPackConfig(packPath);
+    const gateNames = getGateNames(packConfig);
+    // Open vault for flakiness data
+    const vaultPath = join(workingDir, '.qa360');
+    const vault = await EvidenceVault.open(vaultPath);
+    // Create dashboard server
+    const dashboard = new DashboardServer({
+        port,
+        host,
+        autoOpen: options.autoOpen ?? true,
+        refreshRate: 1000
+    });
+    // Connect vault to dashboard for flakiness data
+    dashboard.setVault(vault);
+    await dashboard.start();
+    dashboard.setGates(gateNames);
+    console.log(chalk.green('✓ Dashboard started'));
+    console.log(chalk.gray(`   Open http://${host}:${port} in your browser`));
+    // Run tests with dashboard updates
+    try {
+        const runner = new Phase3Runner({
+            workingDir,
+            pack: packConfig
+        });
+        dashboard.emit({
+            type: 'start',
+            timestamp: Date.now(),
+            data: { phase: 'Running tests' }
+        });
+        const result = await runner.run();
+        // Set run ID for flakiness tracking
+        if (result.runId) {
+            dashboard.setRunId(result.runId);
+        }
+        // Update dashboard with gate results
+        for (const gate of result.gates) {
+            dashboard.emit({
+                type: 'gate_start',
+                timestamp: Date.now(),
+                data: { gate: gate.gate }
+            });
+            dashboard.emit({
+                type: 'gate_end',
+                timestamp: Date.now(),
+                data: {
+                    gate: gate.gate,
+                    success: gate.success,
+                    duration: gate.duration,
+                    results: {
+                        total: gate.results?.summary?.total || 0,
+                        passed: gate.results?.summary?.passed || 0,
+                        failed: gate.results?.summary?.failed || 0
+                    }
+                }
+            });
+        }
+        await dashboard.emit({
+            type: 'complete',
+            timestamp: Date.now(),
+            data: {}
+        });
+        console.log(chalk.green('✓ Tests completed. Dashboard will remain open.'));
+        console.log(chalk.gray('Press Ctrl+C to exit.'));
+    }
+    catch (error) {
+        await dashboard.emit({
+            type: 'error',
+            timestamp: Date.now(),
+            data: { error: error instanceof Error ? error.message : String(error) }
+        });
+    }
+    // Keep dashboard open until user exits
+    // Vault stays open for flakiness data access
+    try {
+        await keepAlive();
+    }
+    finally {
+        // Close vault when user exits
+        await vault.close();
+        await dashboard.stop();
+    }
+};
+/**
+ * Create monitor and dashboard commands
+ */
+export function createMonitorCommands() {
+    const cmd = new Command('monitor');
+    cmd
+        .description('Run tests with terminal UI monitoring')
+        .argument('[pack]', 'Path to pack file')
+        .option('--mode <mode>', 'Execution mode: soft or strict', 'soft')
+        .option('--retries <number>', 'Number of retries for failed tests', '2')
+        .option('--timeout <ms>', 'Global timeout in milliseconds', '30000')
+        .option('--docker', 'Use Docker fallback for missing tools')
+        .action(monitorCommand);
+    return cmd;
+}
+export function createDashboardCommand() {
+    const cmd = new Command('dashboard');
+    cmd
+        .description('Run tests with web dashboard')
+        .argument('[pack]', 'Path to pack file')
+        .option('--port <number>', 'Dashboard port', '8080')
+        .option('--host <address>', 'Dashboard host', '127.0.0.1')
+        .option('--no-auto-open', 'Do not auto-open browser')
+        .action(dashboardCommand);
+    return cmd;
+}
+// Helper functions
+function findDefaultPack() {
+    const candidates = ['qa360.yml', 'qa360.yaml', 'pack.yml', 'pack.yaml', '.qa360/pack.yml'];
+    for (const candidate of candidates) {
+        if (existsSync(join(process.cwd(), candidate))) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function getGateNames(packConfig) {
+    if (packConfig.version === 2 && packConfig.gates) {
+        // v2: gates is an object
+        return Object.keys(packConfig.gates);
+    }
+    else if (packConfig.gates && Array.isArray(packConfig.gates)) {
+        // v1: gates is an array
+        return packConfig.gates;
+    }
+    return [];
+}
+async function keepAlive() {
+    return new Promise(() => {
+        // Keep process alive
+    });
+}

package/dist/commands/ollama.d.ts

@@ -0,0 +1,40 @@
+/**
+ * QA360 Ollama Command
+ *
+ * Manage Ollama integration for AI-powered test generation.
+ * This command handles connection testing, model management, and configuration.
+ */
+import { Command } from 'commander';
+/**
+ * Test Ollama connection
+ */
+export declare function ollamaTestCommand(options?: {
+    model?: string;
+}): Promise<void>;
+/**
+ * List available models
+ */
+export declare function ollamaListCommand(): Promise<void>;
+/**
+ * Pull a model
+ */
+export declare function ollamaPullCommand(model: string): Promise<void>;
+/**
+ * Generate tests using Ollama
+ */
+export declare function ollamaGenerateCommand(prompt: string, options?: {
+    model?: string;
+    type?: string;
+    json?: boolean;
+}): Promise<void>;
+/**
+ * Show Ollama configuration
+ */
+export declare function ollamaConfigCommand(options?: {
+    setUrl?: string;
+    setModel?: string;
+}): Promise<void>;
+/**
+ * Create Ollama commands
+ */
+export declare function createOllamaCommands(): Command;