qa360 1.4.5 → 2.0.1

package/dist/commands/ollama.js

@@ -0,0 +1,301 @@
+/**
+ * QA360 Ollama Command
+ *
+ * Manage Ollama integration for AI-powered test generation.
+ * This command handles connection testing, model management, and configuration.
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { checkOllamaSetup, OllamaProvider, OllamaError } from '../core/index.js';
+/**
+ * Test Ollama connection
+ */
+export async function ollamaTestCommand(options = {}) {
+    const spinner = ora('Testing Ollama connection...').start();
+    const model = options.model || 'deepseek-coder';
+    try {
+        const check = await checkOllamaSetup(model);
+        if (!check.available) {
+            spinner.fail('Ollama is not available');
+            console.log(chalk.red('\n❌ Ollama is not running or not installed'));
+            console.log(chalk.yellow('\n📦 To install Ollama:'));
+            console.log(chalk.gray('  brew install ollama     # macOS'));
+            console.log(chalk.gray('  # Or visit: https://ollama.com'));
+            console.log(chalk.yellow('\n🚀 To start Ollama:'));
+            console.log(chalk.gray('  ollama serve'));
+            return;
+        }
+        spinner.succeed('Ollama is running!');
+        console.log(chalk.green('\n✅ Ollama is available\n'));
+        if (check.models.length === 0) {
+            console.log(chalk.yellow('⚠️  No models found'));
+            console.log(chalk.yellow('\n📥 Pull DeepSeek Coder (recommended for code generation):'));
+            console.log(chalk.gray('  ollama pull deepseek-coder'));
+            return;
+        }
+        console.log(chalk.bold(`Found ${check.models.length} model(s):\n`));
+        for (const modelName of check.models) {
+            const isInstalled = modelName.includes(model);
+            const icon = isInstalled ? '✅' : '  ';
+            const color = isInstalled ? chalk.green : chalk.gray;
+            console.log(color(`  ${icon} ${modelName}`));
+        }
+        if (!check.modelInstalled) {
+            console.log(chalk.yellow(`\n⚠️  Model "${model}" is not installed`));
+            console.log(chalk.yellow(`\n📥 To install: ollama pull ${model}`));
+        }
+        else {
+            console.log(chalk.green(`\n✅ Model "${model}" is ready!`));
+        }
+    }
+    catch (error) {
+        spinner.fail('Connection test failed');
+        if (error instanceof OllamaError) {
+            console.error(chalk.red(error.message));
+        }
+        else {
+            console.error(chalk.red('Unknown error:', error));
+        }
+    }
+}
+/**
+ * List available models
+ */
+export async function ollamaListCommand() {
+    const spinner = ora('Connecting to Ollama...').start();
+    try {
+        const provider = new OllamaProvider();
+        const models = await provider.listModels();
+        spinner.succeed(`Found ${models.length} model(s)\n`);
+        console.log(chalk.bold('Available Models:\n'));
+        for (const model of models) {
+            const sizeGB = (model.size / 1024 / 1024 / 1024).toFixed(1);
+            console.log(chalk.cyan(`  ${model.name}`));
+            console.log(chalk.gray(`    Size: ${sizeGB} GB`));
+            console.log(chalk.gray(`    Modified: ${new Date(model.modifiedAt).toISOString()}\n`));
+        }
+        console.log(chalk.yellow('💡 Recommended for code generation:'));
+        console.log(chalk.gray('  • deepseek-coder (6.7GB) - Best for code'));
+        console.log(chalk.gray('  • codellama (34GB) - Also good'));
+        console.log(chalk.gray('  • llama3.2 (3-4GB) - General purpose\n'));
+        console.log(chalk.yellow('📥 To install a model:'));
+        console.log(chalk.gray('  ollama pull <model-name>\n'));
+    }
+    catch (error) {
+        spinner.fail('Failed to list models');
+        if (error instanceof OllamaError) {
+            console.error(chalk.red(error.message));
+        }
+        else {
+            console.error(chalk.red('Unknown error:', error));
+        }
+    }
+}
+/**
+ * Pull a model
+ */
+export async function ollamaPullCommand(model) {
+    console.log(chalk.cyan(`📥 Pulling model: ${model}\n`));
+    console.log(chalk.yellow('This may take a while depending on your connection...\n'));
+    console.log(chalk.gray('Alternatively, run this command in another terminal:\n'));
+    console.log(chalk.bold(`  ollama pull ${model}\n`));
+    try {
+        const provider = new OllamaProvider();
+        const models = await provider.listModels();
+        if (models.some(m => m.name === model)) {
+            console.log(chalk.green(`✅ Model "${model}" is already installed\n`));
+            return;
+        }
+        console.log(chalk.yellow('💡 Use the command above in a separate terminal to download the model.'));
+        console.log(chalk.gray('Large models (several GB) can take 10-30 minutes depending on your internet.\n'));
+    }
+    catch (error) {
+        if (error instanceof OllamaError) {
+            console.error(chalk.red(error.message));
+        }
+        else {
+            console.error(chalk.red('Unknown error:', error));
+        }
+    }
+}
+/**
+ * Generate tests using Ollama
+ */
+export async function ollamaGenerateCommand(prompt, options = {}) {
+    const spinner = ora('Connecting to Ollama...').start();
+    const model = options.model || 'deepseek-coder';
+    const type = options.type || 'api';
+    try {
+        const provider = new OllamaProvider({ model });
+        // Check availability
+        const available = await provider.isAvailable();
+        if (!available) {
+            spinner.fail('Ollama not available');
+            console.log(chalk.red('\n❌ Ollama is not running'));
+            console.log(chalk.yellow('\nStart Ollama with: ollama serve'));
+            return;
+        }
+        spinner.succeed('Connected to Ollama');
+        // Build system prompt based on type
+        const systemPrompt = buildSystemPrompt(type);
+        const genSpinner = ora(`Generating ${type} tests...`).start();
+        const response = await provider.generate({
+            systemPrompt,
+            prompt,
+            maxTokens: 4096,
+            temperature: 0.7,
+        });
+        genSpinner.succeed('Tests generated!\n');
+        if (options.json) {
+            console.log(JSON.stringify({ content: response.content, usage: response.usage }, null, 2));
+        }
+        else {
+            console.log(chalk.bold('Generated Tests:\n'));
+            console.log(chalk.gray('─'.repeat(60)));
+            console.log(response.content);
+            console.log(chalk.gray('─'.repeat(60)));
+            console.log(chalk.gray(`\n📊 Tokens: ${response.usage.totalTokens} (${response.usage.promptTokens} prompt + ${response.usage.completionTokens} completion)`));
+        }
+    }
+    catch (error) {
+        spinner.fail('Generation failed');
+        if (error instanceof OllamaError) {
+            console.error(chalk.red(error.message));
+        }
+        else {
+            console.error(chalk.red('Unknown error:', error));
+        }
+    }
+}
+/**
+ * Show Ollama configuration
+ */
+export async function ollamaConfigCommand(options = {}) {
+    // TODO: Implement config file persistence
+    console.log(chalk.cyan('Ollama Configuration:\n'));
+    console.log(chalk.gray('  Base URL: http://localhost:11434 (default)'));
+    console.log(chalk.gray('  Model: deepseek-coder (default)\n'));
+    console.log(chalk.yellow('💡 Configuration will be persisted in .qa360/config.yml'));
+}
+/**
+ * Build system prompt for test generation
+ */
+function buildSystemPrompt(type) {
+    const basePrompt = `You are QA360, an expert QA test generator.
+Generate production-ready, well-structured test code following best practices.
+
+Rules:
+- Generate COMPLETE, working code (no "...", no comments saying "to be implemented")
+- Include proper imports and setup
+- Handle errors gracefully
+- Use modern async/await patterns
+- Add helpful comments for complex logic
+- Return ONLY the code, no explanations before or after`;
+    const typePrompts = {
+        api: `${basePrompt}
+
+For API tests using Playwright:
+- Use @playwright/test
+- Use test() and expect() from Playwright
+- Test REST API endpoints (GET, POST, PUT, DELETE)
+- Include proper assertions for status codes, headers, and response body
+- Handle both success and error cases`,
+        ui: `${basePrompt}
+
+For UI/E2E tests using Playwright:
+- Use @playwright/test
+- Use page.goto(), page.click(), page.fill(), etc.
+- Include explicit waits where needed (waitForLoadState, waitForSelector)
+- Add assertions for page content
+- Use data-testid attributes when possible`,
+        perf: `${basePrompt}
+
+For performance tests using K6:
+- Use k6/http module
+- Define thresholds for response times and error rates
+- Include realistic user scenarios
+- Use options for VUs and duration`,
+        a11y: `${basePrompt}
+
+For accessibility tests:
+- Use @axe-core/playwright
+- Test WCAG compliance
+- Check for common a11y issues`,
+    };
+    return typePrompts[type] || typePrompts.api;
+}
+/**
+ * Create Ollama commands
+ */
+export function createOllamaCommands() {
+    const ollamaCmd = new Command('ollama')
+        .description('Manage Ollama AI integration for test generation');
+    ollamaCmd
+        .command('test')
+        .description('Test Ollama connection and availability')
+        .option('-m, --model <model>', 'Model to test', 'deepseek-coder')
+        .action(async (options) => {
+        try {
+            await ollamaTestCommand(options);
+        }
+        catch (error) {
+            console.error(chalk.red('Error testing Ollama:'), error.message);
+            process.exit(1);
+        }
+    });
+    ollamaCmd
+        .command('list')
+        .description('List available Ollama models')
+        .action(async () => {
+        try {
+            await ollamaListCommand();
+        }
+        catch (error) {
+            console.error(chalk.red('Error listing models:'), error.message);
+            process.exit(1);
+        }
+    });
+    ollamaCmd
+        .command('pull <model>')
+        .description('Pull a model from Ollama registry')
+        .action(async (model) => {
+        try {
+            await ollamaPullCommand(model);
+        }
+        catch (error) {
+            console.error(chalk.red('Error pulling model:'), error.message);
+            process.exit(1);
+        }
+    });
+    ollamaCmd
+        .command('generate <prompt>')
+        .description('Generate tests using Ollama (preview)')
+        .option('-m, --model <model>', 'Model to use', 'deepseek-coder')
+        .option('-t, --type <type>', 'Test type (api, ui, perf)', 'api')
+        .option('--json', 'Output as JSON')
+        .action(async (prompt, options) => {
+        try {
+            await ollamaGenerateCommand(prompt, options);
+        }
+        catch (error) {
+            console.error(chalk.red('Error generating tests:'), error.message);
+            process.exit(1);
+        }
+    });
+    ollamaCmd
+        .command('config')
+        .description('Show or set Ollama configuration')
+        .option('--set-url <url>', 'Set Ollama base URL')
+        .option('--set-model <model>', 'Set default model')
+        .action(async (options) => {
+        try {
+            await ollamaConfigCommand(options);
+        }
+        catch (error) {
+            console.error(chalk.red('Error showing config:'), error.message);
+            process.exit(1);
+        }
+    });
+    return ollamaCmd;
+}

package/dist/commands/pack.d.ts

@@ -1,19 +1,31 @@
 /**
  * QA360 Pack Commands
+ *
  * Implements pack validate, lint, and migrate commands
+ * Supports both v1 and v2 pack formats
  */
 export declare class QA360Pack {
     private qa360Dir;
     private packPath;
-    private validator;
-    private migrator;
+    private validatorV1;
+    private migratorV1;
     /**
-     * Validate pack.yml against v1 schema
+     * Validate pack.yml (auto-detects v1 or v2)
      */
-    validate(packPath?: string): Promise<{
+    validate(packPath?: string, options?: {
+        checkFiles?: boolean;
+    }): Promise<{
         valid: boolean;
         exitCode: number;
     }>;
+    /**
+     * Validate v1 pack
+     */
+    private validateV1;
+    /**
+     * Validate v2 pack
+     */
+    private validateV2;
     /**
      * Lint and auto-fix pack.yml
      */
@@ -22,21 +34,37 @@ export declare class QA360Pack {
         exitCode: number;
     }>;
     /**
-     * Migrate legacy pack to v1
+     * Migrate pack to v2
      */
-    migrate(packPath?: string): Promise<{
+    migrate(packPath?: string, options?: {
+        output?: string;
+        dryRun?: boolean;
+    }): Promise<{
         success: boolean;
         exitCode: number;
     }>;
+    /**
+     * Detect pack version
+     */
+    private detectPackVersion;
     /**
      * Apply automatic fixes to pack
      */
     private applyAutoFixes;
     /**
-     * Show pack summary
+     * Show v1 pack summary
      */
     private showPackSummary;
+    /**
+     * Show v2 pack summary
+     */
+    private showPackV2Summary;
 }
-export declare function packValidateCommand(packPath?: string): Promise<void>;
+export declare function packValidateCommand(packPath?: string, options?: {
+    checkFiles?: boolean;
+}): Promise<void>;
 export declare function packLintCommand(packPath?: string): Promise<void>;
-export declare function packMigrateCommand(packPath?: string): Promise<void>;
+export declare function packMigrateCommand(packPath?: string, options?: {
+    output?: string;
+    dryRun?: boolean;
+}): Promise<void>;