qa360 1.4.5 → 2.0.1

package/dist/commands/generate.js

@@ -0,0 +1,438 @@
+/**
+ * QA360 Generate Command
+ *
+ * AI-powered test generation using Ollama.
+ * Generates tests from OpenAPI specs, HAR files, URLs, or code.
+ *
+ * Phase 4 - AI Test Generation
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { generateTests, generateApiTestsFromOpenAPI, generateUiTestsFromUrl, generatePerfTests, generateUnitTests, checkGenerationAvailability, } from '../core/index.js';
+/**
+ * Create generate commands group
+ */
+export function createGenerateCommands() {
+    const generateCmd = new Command('generate')
+        .description('AI-powered test generation (Phase 4)');
+    // Main generate command
+    generateCmd
+        .argument('<source>', 'Source: OpenAPI spec, HAR file, URL, or description')
+        .option('--type <type>', 'Source type: openapi, har, url, code')
+        .option('-o, --output <dir>', 'Output directory', './tests/generated')
+        .option('--framework <name>', 'Target framework: playwright, k6, vitest, jest')
+        .option('--model <name>', 'Ollama model to use')
+        .option('--optimize', 'Optimize generated tests')
+        .option('--no-format', 'Skip code formatting')
+        .action(async (source, options) => {
+        await generateCommand(source, options);
+    });
+    // API tests subcommand
+    generateCmd
+        .command('api <spec>')
+        .description('Generate API tests from OpenAPI spec')
+        .option('-o, --output <dir>', 'Output directory', './tests/api')
+        .option('--model <name>', 'Ollama model to use')
+        .option('--optimize', 'Optimize generated tests')
+        .action(async (spec, options) => {
+        await generateApiCommand(spec, options);
+    });
+    // UI tests subcommand
+    generateCmd
+        .command('ui <url>')
+        .description('Generate UI tests from URL')
+        .option('-o, --output <dir>', 'Output directory', './tests/ui')
+        .option('--model <name>', 'Ollama model to use')
+        .option('--optimize', 'Optimize generated tests')
+        .action(async (url, options) => {
+        await generateUiCommand(url, options);
+    });
+    // Performance tests subcommand
+    generateCmd
+        .command('perf <spec>')
+        .description('Generate performance tests from OpenAPI spec')
+        .option('-o, --output <dir>', 'Output directory', './tests/performance')
+        .option('--model <name>', 'Ollama model to use')
+        .option('--duration <time>', 'Test duration', '30s')
+        .option('--vus <number>', 'Virtual users', '10')
+        .action(async (spec, options) => {
+        await generatePerfCommand(spec, options);
+    });
+    // Unit tests subcommand
+    generateCmd
+        .command('unit <file>')
+        .description('Generate unit tests from source code')
+        .option('-l, --language <lang>', 'Source language (typescript, javascript, go, python)')
+        .option('-o, --output <dir>', 'Output directory', './tests/unit')
+        .option('--model <name>', 'Ollama model to use')
+        .option('--optimize', 'Optimize generated tests')
+        .action(async (file, options) => {
+        await generateUnitCommand(file, options);
+    });
+    // Check availability subcommand
+    generateCmd
+        .command('check')
+        .description('Check if Ollama is available for generation')
+        .action(async () => {
+        await checkCommand();
+    });
+    return generateCmd;
+}
+/**
+ * Generate tests command handler
+ */
+export async function generateCommand(source, options = {}) {
+    const spinner = ora('Initializing QA360 AI Test Generator...').start();
+    try {
+        // Check Ollama availability
+        const { available, models, recommended } = await checkGenerationAvailability();
+        if (!available) {
+            spinner.fail('Ollama not available');
+            console.log(chalk.red('\nOllama is not running'));
+            console.log(chalk.yellow('\nStart Ollama:'));
+            console.log(chalk.gray('  ollama serve'));
+            console.log(chalk.yellow('\nInstall Ollama:'));
+            console.log(chalk.gray('  brew install ollama  # macOS'));
+            console.log(chalk.gray('  # Or visit: https://ollama.com\n'));
+            return;
+        }
+        spinner.succeed('Connected to Ollama');
+        // Show using model
+        console.log(chalk.gray(`Using: ${options.model || recommended}\n`));
+        // Determine source type
+        const sourceType = options.type || detectSourceType(source);
+        // Build generation source
+        const generationSource = buildGenerationSource(source, sourceType, options);
+        // Generate tests
+        const genSpinner = ora(`Generating ${sourceType} tests...`).start();
+        const result = await generateTests(generationSource, {
+            model: options.model,
+            outputDir: options.output || './tests/generated',
+            formatCode: options.format !== false,
+            optimize: options.optimize,
+            promptOptions: {
+                includeComments: true,
+                includeDetailedAssertions: true,
+                includeRetryLogic: true,
+                codeStyle: 'clean',
+            },
+        });
+        if (!result.success) {
+            genSpinner.fail('Generation failed');
+            console.log(chalk.red('\nErrors:'));
+            for (const error of result.errors || []) {
+                console.log(chalk.red(`  - ${error}`));
+            }
+            return;
+        }
+        genSpinner.succeed(`Generated ${result.tests.length} test files\n`);
+        // Save tests
+        const savedFiles = await saveTests(result.tests, options.output);
+        // Show summary
+        showGenerationSummary(result, savedFiles);
+        if (result.warnings && result.warnings.length > 0) {
+            console.log(chalk.yellow('\nWarnings:'));
+            for (const warning of result.warnings) {
+                console.log(chalk.yellow(`  - ${warning}`));
+            }
+        }
+        console.log(chalk.green('\nTest generation complete!'));
+    }
+    catch (error) {
+        spinner.fail('Generation error');
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    }
+}
+/**
+ * Generate API tests from OpenAPI spec
+ */
+export async function generateApiCommand(specPath, options = {}) {
+    const spinner = ora('Generating API tests from OpenAPI spec...').start();
+    try {
+        const result = await generateApiTestsFromOpenAPI(specPath, {
+            model: options.model,
+            outputDir: options.output || './tests/api',
+            formatCode: true,
+            optimize: options.optimize,
+        });
+        if (!result.success) {
+            spinner.fail('Generation failed');
+            for (const error of result.errors || []) {
+                console.log(chalk.red(`  - ${error}`));
+            }
+            return;
+        }
+        spinner.succeed(`Generated ${result.tests.length} API test files\n`);
+        const savedFiles = await saveTests(result.tests, options.output || './tests/api');
+        showGenerationSummary(result, savedFiles);
+    }
+    catch (error) {
+        spinner.fail('Generation error');
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    }
+}
+/**
+ * Generate UI tests from URL
+ */
+export async function generateUiCommand(url, options = {}) {
+    const spinner = ora('Generating UI tests from URL...').start();
+    try {
+        const result = await generateUiTestsFromUrl(url, {
+            model: options.model,
+            outputDir: options.output || './tests/ui',
+            formatCode: true,
+            optimize: options.optimize,
+        });
+        if (!result.success) {
+            spinner.fail('Generation failed');
+            for (const error of result.errors || []) {
+                console.log(chalk.red(`  - ${error}`));
+            }
+            return;
+        }
+        spinner.succeed(`Generated ${result.tests.length} UI test files\n`);
+        const savedFiles = await saveTests(result.tests, options.output || './tests/ui');
+        showGenerationSummary(result, savedFiles);
+    }
+    catch (error) {
+        spinner.fail('Generation error');
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    }
+}
+/**
+ * Generate performance tests
+ */
+export async function generatePerfCommand(specPath, options = {}) {
+    const spinner = ora('Generating performance tests...').start();
+    try {
+        const result = await generatePerfTests(specPath, {
+            model: options.model,
+            outputDir: options.output || './tests/performance',
+            formatCode: true,
+            optimize: false, // Don't optimize perf tests
+        });
+        if (!result.success) {
+            spinner.fail('Generation failed');
+            for (const error of result.errors || []) {
+                console.log(chalk.red(`  - ${error}`));
+            }
+            return;
+        }
+        spinner.succeed(`Generated ${result.tests.length} performance test files\n`);
+        const savedFiles = await saveTests(result.tests, options.output || './tests/performance');
+        showGenerationSummary(result, savedFiles);
+    }
+    catch (error) {
+        spinner.fail('Generation error');
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    }
+}
+/**
+ * Generate unit tests from code
+ */
+export async function generateUnitCommand(filePath, options = {}) {
+    const spinner = ora('Generating unit tests...').start();
+    try {
+        // Read source code
+        const { readFileSync } = await import('fs');
+        const code = readFileSync(filePath, 'utf-8');
+        const language = options.language || detectLanguage(filePath);
+        const result = await generateUnitTests(code, language, {
+            model: options.model,
+            outputDir: options.output || './tests/unit',
+            formatCode: true,
+            optimize: options.optimize,
+        });
+        if (!result.success) {
+            spinner.fail('Generation failed');
+            for (const error of result.errors || []) {
+                console.log(chalk.red(`  - ${error}`));
+            }
+            return;
+        }
+        spinner.succeed(`Generated ${result.tests.length} unit test files\n`);
+        const savedFiles = await saveTests(result.tests, options.output || './tests/unit');
+        showGenerationSummary(result, savedFiles);
+    }
+    catch (error) {
+        spinner.fail('Generation error');
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    }
+}
+/**
+ * Detect source type from string
+ */
+function detectSourceType(source) {
+    if (source.endsWith('.json') || source.endsWith('.yaml') || source.endsWith('.yml')) {
+        return 'openapi';
+    }
+    if (source.endsWith('.har')) {
+        return 'har';
+    }
+    if (source.startsWith('http://') || source.startsWith('https://')) {
+        return 'url';
+    }
+    return 'code';
+}
+/**
+ * Detect language from file path
+ */
+function detectLanguage(filePath) {
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    const languageMap = {
+        'ts': 'typescript',
+        'tsx': 'typescript',
+        'js': 'javascript',
+        'jsx': 'javascript',
+        'go': 'go',
+        'py': 'python',
+        'rs': 'rust',
+    };
+    return languageMap[ext || ''] || 'typescript';
+}
+/**
+ * Build generation source from input
+ */
+function buildGenerationSource(source, type, options) {
+    switch (type) {
+        case 'openapi':
+            return { type: 'openapi', urlOrPath: source };
+        case 'har':
+            return { type: 'har', filePath: source };
+        case 'url':
+            return { type: 'url', url: source };
+        case 'code':
+            return { type: 'description', description: source };
+        default:
+            return { type: 'description', description: source };
+    }
+}
+/**
+ * Save generated tests to files
+ */
+async function saveTests(tests, outputDir) {
+    const savedFiles = [];
+    for (const test of tests) {
+        const filePath = resolve(test.filePath);
+        // Create directory if needed
+        const dir = dirname(filePath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        // Write file
+        writeFileSync(filePath, test.code, 'utf-8');
+        savedFiles.push(filePath);
+    }
+    return savedFiles;
+}
+/**
+ * Show generation summary
+ */
+function showGenerationSummary(result, savedFiles) {
+    console.log(chalk.bold('\nGeneration Summary\n'));
+    // Metadata
+    console.log(chalk.gray(`  Duration: ${result.metadata.duration}ms`));
+    console.log(chalk.gray(`  Tokens: ${result.metadata.tokensUsed}\n`));
+    // Tests
+    console.log(chalk.bold('  Generated Tests:'));
+    let totalTests = 0;
+    let totalAssertions = 0;
+    for (const test of result.tests) {
+        console.log(chalk.cyan(`    - ${test.name}`));
+        console.log(chalk.gray(`      Framework: ${test.framework}`));
+        console.log(chalk.gray(`      Language: ${test.language}`));
+        console.log(chalk.gray(`      Tests: ${test.summary.testCount}`));
+        if (test.summary.assertionCount) {
+            console.log(chalk.gray(`      Assertions: ${test.summary.assertionCount}`));
+        }
+        console.log(chalk.gray(`      Lines: ${test.summary.lines}`));
+        console.log(chalk.gray(`      File: ${test.filePath}\n`));
+        totalTests += test.summary.testCount || 0;
+        totalAssertions += test.summary.assertionCount || 0;
+    }
+    console.log(chalk.bold('  Totals:'));
+    console.log(chalk.green(`    Files: ${result.tests.length}`));
+    console.log(chalk.green(`    Test Cases: ${totalTests}`));
+    console.log(chalk.green(`    Assertions: ${totalAssertions}\n`));
+    // Saved files
+    console.log(chalk.bold('  Saved Files:'));
+    for (const file of savedFiles) {
+        console.log(chalk.gray(`    - ${file}`));
+    }
+    console.log('');
+}
+/**
+ * Build system prompt for test type
+ */
+export function buildSystemPrompt(type) {
+    const prompts = {
+        api: `You are an expert API test generator. Generate comprehensive Playwright API tests in TypeScript.
+
+Requirements:
+- Use test.describe() for grouping
+- Include happy path and error cases
+- Add proper assertions for status codes and response schemas
+- Handle authentication properly
+- Use fetch() or axios for HTTP requests`,
+        ui: `You are an expert UI/E2E test generator. Generate comprehensive Playwright UI tests in TypeScript.
+
+Requirements:
+- Use test.describe() for grouping
+- Include page object pattern where appropriate
+- Add explicit waits (waitForSelector, waitForURL)
+- Test user interactions and assertions
+- Handle dynamic content properly`,
+        perf: `You are an expert performance test generator. Generate K6 performance tests in JavaScript.
+
+Requirements:
+- Define realistic scenarios
+- Add thresholds for response times
+- Use proper load stages (ramp up, sustain, ramp down)
+- Include error rate checks
+- Model realistic user behavior`,
+        unit: `You are an expert unit test generator. Generate Vitest tests in TypeScript.
+
+Requirements:
+- Test all functions/classes
+- Include edge cases and error conditions
+- Mock external dependencies
+- Use describe/it blocks
+- Aim for high coverage`,
+    };
+    return prompts[type] || prompts.api;
+}
+/**
+ * Check if generation is available
+ */
+export async function checkCommand() {
+    const spinner = ora('Checking AI generation availability...').start();
+    try {
+        const { available, models, recommended } = await checkGenerationAvailability();
+        if (!available) {
+            spinner.fail('Ollama not available');
+            console.log(chalk.red('\nOllama is not running'));
+            console.log(chalk.yellow('\nStart Ollama:'));
+            console.log(chalk.gray('  ollama serve'));
+            console.log(chalk.yellow('\nInstall Ollama:'));
+            console.log(chalk.gray('  brew install ollama  # macOS'));
+            console.log(chalk.gray('  # Or visit: https://ollama.com\n'));
+            return;
+        }
+        spinner.succeed('AI generation is available!\n');
+        console.log(chalk.bold('  Available Models:'));
+        for (const model of models) {
+            const isRecommended = model === recommended || model.includes(recommended);
+            const icon = isRecommended ? '*' : ' ';
+            const color = isRecommended ? chalk.green : chalk.gray;
+            console.log(color(`  ${icon} ${model}`));
+        }
+        console.log(chalk.green(`\nReady to generate tests using: ${recommended}\n`));
+    }
+    catch (error) {
+        spinner.fail('Availability check failed');
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    }
+}

package/dist/commands/init.d.ts

@@ -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
  */
 /**
  * CLI options for init command
@@ -14,6 +15,7 @@ export interface InitOptions {
     output?: string;
     force?: boolean;
     yes?: boolean;
+    beginner?: boolean;
 }
 /**
  * Available templates
@@ -23,40 +25,85 @@ export declare const TEMPLATES: {
         name: string;
         description: string;
         gates: string[];
+        icon: string;
     };
     'ui-basic': {
         name: string;
         description: string;
         gates: string[];
+        icon: string;
     };
     fullstack: {
         name: string;
         description: string;
         gates: string[];
+        icon: string;
     };
     security: {
         name: string;
         description: string;
         gates: string[];
+        icon: string;
     };
     complete: {
         name: string;
         description: string;
         gates: string[];
+        icon: string;
     };
 };
 /**
- * Gate descriptions
+ * Gate descriptions with beginner-friendly explanations
  */
 export declare const GATE_DESCRIPTIONS: {
-    api_smoke: string;
-    ui: string;
-    a11y: string;
-    perf: string;
-    sast: string;
-    dast: string;
-    secrets: string;
-    deps: string;
+    api_smoke: {
+        short: string;
+        beginner: string;
+        example: string;
+        icon: string;
+    };
+    ui: {
+        short: string;
+        beginner: string;
+        example: string;
+        icon: string;
+    };
+    a11y: {
+        short: string;
+        beginner: string;
+        example: string;
+        icon: string;
+    };
+    perf: {
+        short: string;
+        beginner: string;
+        example: string;
+        icon: string;
+    };
+    sast: {
+        short: string;
+        beginner: string;
+        example: string;
+        icon: string;
+    };
+    dast: {
+        short: string;
+        beginner: string;
+        example: string;
+        icon: string;
+    };
+    secrets: {
+        short: string;
+        beginner: string;
+        example: string;
+        icon: string;
+    };
+    deps: {
+        short: string;
+        beginner: string;
+        example: string;
+        icon: string;
+    };
 };
 /**
  * Main init command