qa360 2.2.1 → 2.2.13

package/cli/src/commands/generate.ts

@@ -1,566 +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 type { GenerationSource } from 'qa360-core';
-import {
-  generateTests,
-  generateApiTestsFromOpenAPI,
-  generateUiTestsFromUrl,
-  generatePerfTests,
-  generateUnitTests,
-  checkGenerationAvailability,
-  TestOptimizer,
-} from 'qa360-core';
-
-/**
- * Create generate commands group
- */
-export function createGenerateCommands(): Command {
-  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: string,
-  options: {
-    type?: 'openapi' | 'har' | 'url' | 'code';
-    output?: string;
-    framework?: 'playwright' | 'k6' | 'vitest' | 'jest';
-    optimize?: boolean;
-    model?: string;
-    format?: boolean;
-  } = {}
-): Promise<void> {
-  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: string,
-  options: {
-    output?: string;
-    model?: string;
-    optimize?: boolean;
-  } = {}
-): Promise<void> {
-  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: string,
-  options: {
-    output?: string;
-    model?: string;
-    optimize?: boolean;
-  } = {}
-): Promise<void> {
-  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: string,
-  options: {
-    output?: string;
-    model?: string;
-    duration?: string;
-    vus?: number;
-  } = {}
-): Promise<void> {
-  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: string,
-  options: {
-    language?: string;
-    output?: string;
-    model?: string;
-    optimize?: boolean;
-  } = {}
-): Promise<void> {
-  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: string): 'openapi' | 'har' | 'url' | 'code' {
-  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: string): string {
-  const ext = filePath.split('.').pop()?.toLowerCase();
-  const languageMap: Record<string, string> = {
-    '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: string,
-  type: string,
-  options: { type?: string; framework?: string }
-): GenerationSource {
-  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: any[],
-  outputDir?: string
-): Promise<string[]> {
-  const savedFiles: string[] = [];
-
-  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: any, savedFiles: string[]): void {
-  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: string): string {
-  const prompts: Record<string, string> = {
-    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(): Promise<void> {
-  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)));
-  }
-}