qa360 2.1.2 → 2.1.4

package/dist/commands/generate.js

@@ -1,438 +0,0 @@
-/**
- * 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/history.d.ts

@@ -1,76 +0,0 @@
-/**
- * QA360 History Commands
- * CLI interface for Evidence Vault querying and management
- */
-import { Command } from 'commander';
-export interface HistoryListOptions {
-    limit?: number;
-    status?: string;
-    gate?: string;
-    since?: string;
-    json?: boolean;
-    format?: string;
-}
-export interface HistoryGetOptions {
-    json?: boolean;
-}
-export interface HistoryDiffOptions {
-    json?: boolean;
-}
-export interface HistoryTrendOptions {
-    gate?: string;
-    window?: number;
-    json?: boolean;
-    csv?: string;
-}
-export interface HistoryExportOptions {
-    bundle: string;
-}
-export interface HistoryGCOptions {
-    keepLast?: number;
-    maxBytes?: string;
-    dryRun?: boolean;
-}
-export declare class QA360History {
-    private vault?;
-    constructor();
-    /**
-     * Initialize vault connection
-     */
-    private getVault;
-    /**
-     * List runs with filters
-     */
-    list(options: HistoryListOptions): Promise<void>;
-    /**
-     * Get detailed run information
-     */
-    get(runId: string, options: HistoryGetOptions): Promise<void>;
-    /**
-     * Compare two runs
-     */
-    diff(runIdA: string, runIdB: string, options: HistoryDiffOptions): Promise<void>;
-    /**
-     * Show trends over time
-     */
-    trend(options: HistoryTrendOptions): Promise<void>;
-    /**
-     * Export run bundle
-     */
-    export(runId: string, options: HistoryExportOptions): Promise<void>;
-    /**
-     * Garbage collection
-     */
-    gc(options: HistoryGCOptions): Promise<void>;
-    /**
-     * Pin/unpin run
-     */
-    pin(runId: string, unpin?: boolean): Promise<void>;
-    private formatStatus;
-    private formatSeverity;
-    private formatBytes;
-    private diffGates;
-    private diffFindings;
-    private exportTrendCSV;
-}
-export declare function createHistoryCommands(): Command;