@qate/cli 1.0.0 → 1.1.0

package/dist/cli.js

@@ -46,6 +46,7 @@ const RestApiExecutor_1 = require("./RestApiExecutor");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
+const JunitXmlGenerator_1 = require("./JunitXmlGenerator");
 const VERSION = '1.0.0';
 const program = new commander_1.Command();
 // Helper to handle API errors with detailed feedback
@@ -126,6 +127,39 @@ function getConfig(options) {
     }
     return { apiKey, baseUrl };
 }
+/**
+ * Detect PR number from CI environment variables.
+ * Supports GitHub Actions, GitLab CI, Bitbucket Pipelines, Azure DevOps, Jenkins, CircleCI.
+ */
+function detectPRFromEnvironment() {
+    // GitHub Actions: GITHUB_REF = refs/pull/123/merge
+    const githubRef = process.env.GITHUB_REF;
+    if (githubRef?.includes('/pull/')) {
+        const match = githubRef.match(/\/pull\/(\d+)\//);
+        if (match)
+            return parseInt(match[1]);
+    }
+    // GitLab CI
+    if (process.env.CI_MERGE_REQUEST_IID)
+        return parseInt(process.env.CI_MERGE_REQUEST_IID);
+    // Bitbucket Pipelines
+    if (process.env.BITBUCKET_PR_ID)
+        return parseInt(process.env.BITBUCKET_PR_ID);
+    // Azure DevOps
+    if (process.env.SYSTEM_PULLREQUEST_PULLREQUESTNUMBER)
+        return parseInt(process.env.SYSTEM_PULLREQUEST_PULLREQUESTNUMBER);
+    // Jenkins
+    if (process.env.CHANGE_ID)
+        return parseInt(process.env.CHANGE_ID);
+    // CircleCI: CIRCLE_PULL_REQUEST = https://github.com/org/repo/pull/123
+    const circlePR = process.env.CIRCLE_PULL_REQUEST;
+    if (circlePR) {
+        const match = circlePR.match(/\/(\d+)$/);
+        if (match)
+            return parseInt(match[1]);
+    }
+    return null;
+}
 // Helper to display execution status
 function displayStatus(status, type) {
     const name = type === 'testset' ? status.testSetName : status.sequenceName;
@@ -172,171 +206,422 @@ program
     .name('qate')
     .description('Qate CLI for CI/CD pipeline integration\n\nGenerate and run Playwright tests from your Qate test definitions.')
     .version(VERSION)
-    .addHelpText('after', `
-Examples:
-  $ qate list                                    List all test sets
-  $ qate generate -n "My Tests" -o ./e2e         Generate Playwright tests (web apps)
-  $ qate run -n "API Tests" --wait               Run REST/SOAP tests locally
-  $ qate export:testset -n "Tests" -o ./out      Export as Playwright or Axios tests
-  $ qate status -e ci_xxx_xxx                    Check execution status
-
-Documentation:
-  https://docs.qate.io/cli
-
-Environment Variables:
-  QATE_API_KEY     Your Qate API key (required)
-  QATE_API_URL     Qate API URL (default: https://api.qate.ai)
+    .addHelpText('after', `
+Examples:
+  $ qate list                                    List all test sets
+  $ qate generate -n "My Tests" -o ./e2e         Generate Playwright tests (web apps)
+  $ qate run -n "API Tests" --wait               Run REST/SOAP tests locally
+  $ qate export:testset -n "Tests" -o ./out      Export as Playwright or Axios tests
+  $ qate status -e ci_xxx_xxx                    Check execution status
+
+Documentation:
+  https://docs.qate.io/cli
+
+Environment Variables:
+  QATE_API_KEY     Your Qate API key (required)
+  QATE_API_URL     Qate API URL (default: https://api.qate.ai)
 `);
 // ================== TEST SET COMMANDS ==================
 program
     .command('run:testset')
     .alias('run')
     .description('Execute a test set locally (REST API and SOAP only - use "generate" for web apps)')
-    .requiredOption('-n, --name <name>', 'Name of the test set to execute')
+    .option('-n, --name <name>', 'Name of the test set to execute')
     .option('-a, --api-key <key>', 'API key (or use QATE_API_KEY env var)')
     .option('-u, --url <url>', 'Qate API URL (or use QATE_API_URL env var)')
-    .option('--app <applicationId>', 'Application ID (if test set name is not unique)')
+    .option('--app <applicationId>', 'Application ID (required for --smart, optional otherwise)')
+    .option('--smart', 'Use AI to select tests based on PR changes')
+    .option('--pr <number>', 'PR number (auto-detected from CI environment if not specified)')
+    .option('--repo-type <type>', 'Repository type for --smart: frontend or backend', 'frontend')
     .option('-w, --wait', 'Wait for execution to complete')
     .option('--timeout <seconds>', 'Timeout for waiting (default: 600)', '600')
     .option('--json', 'Output results as JSON')
+    .option('--junit <path>', 'Write JUnit XML report to file')
     .option('-v, --verbose', 'Show detailed step-by-step output')
     .action(async (options) => {
     try {
+        // Validate: either --name or --smart is required
+        if (!options.smart && !options.name) {
+            console.error(chalk_1.default.red('Error: Either --name <test-set-name> or --smart is required.'));
+            console.error(chalk_1.default.gray('  Use --name to run a specific test set'));
+            console.error(chalk_1.default.gray('  Use --smart to let AI select tests based on PR changes'));
+            process.exit(1);
+        }
+        if (options.smart && !options.app) {
+            console.error(chalk_1.default.red('Error: --app <applicationId> is required when using --smart.'));
+            console.error(chalk_1.default.gray('  Find your application ID in Qate: Settings > Applications'));
+            process.exit(1);
+        }
         const { apiKey, baseUrl } = getConfig(options);
         const client = new client_1.QateClient(baseUrl, apiKey);
-        if (!options.json) {
-            console.log(chalk_1.default.blue(`Fetching test set: ${options.name}`));
-        }
-        // First, export the test set to check application type
-        const exportData = await client.exportTestSet(options.name, options.app);
-        const appType = exportData.application?.type || 'web';
-        // REST API apps execute locally in the CLI
-        if ((0, RestApiExecutor_1.isRestApiApp)(appType)) {
+        if (options.smart) {
+            // Smart run: AI-powered test selection based on PR changes
+            const prNumber = options.pr ? parseInt(options.pr) : detectPRFromEnvironment();
+            if (!prNumber) {
+                console.error(chalk_1.default.red('Error: Could not detect PR number from CI environment.'));
+                console.error(chalk_1.default.gray('  Use --pr <number> to specify the PR number explicitly.'));
+                console.error(chalk_1.default.gray('  Auto-detection supports: GitHub Actions, GitLab CI, Bitbucket Pipelines,'));
+                console.error(chalk_1.default.gray('  Azure DevOps, Jenkins, CircleCI'));
+                process.exit(1);
+            }
             if (!options.json) {
-                console.log(chalk_1.default.cyan(`REST API application detected - executing locally`));
-                console.log(chalk_1.default.gray(`Application: ${exportData.application.name}`));
-                console.log(chalk_1.default.gray(`Base URL: ${exportData.application.url}`));
-                console.log(chalk_1.default.gray(`Tests: ${exportData.tests.length}`));
-                console.log();
+                console.log(chalk_1.default.blue(`Smart run: analyzing PR #${prNumber}...`));
+                console.log(chalk_1.default.gray(`  Application: ${options.app}`));
+                console.log(chalk_1.default.gray(`  Repository type: ${options.repoType}`));
+                console.log(chalk_1.default.gray('  Analyzing PR changes with AI...'));
             }
-            // Create execution record for tracking
-            let executionId;
-            try {
-                const generateResult = await client.createGenerateExecution(options.name, undefined, options.app, 'cli');
-                executionId = generateResult.executionId;
-                if (!options.json) {
-                    console.log(chalk_1.default.gray(`Execution ID: ${executionId}`));
+            // Call smart-generate to get AI-selected tests (also checks execution limits + token balance)
+            const exportData = await client.smartGenerate(options.app, prNumber, options.repoType);
+            const executionId = exportData.executionId;
+            if (exportData.tests.length === 0) {
+                if (options.json) {
+                    console.log(JSON.stringify({
+                        status: 'skipped',
+                        message: 'AI analysis found no tests to execute for this PR',
+                    }, null, 2));
                 }
-            }
-            catch (err) {
-                if (!options.json) {
-                    console.log(chalk_1.default.yellow('Note: Could not create execution record'));
+                else {
+                    console.log(chalk_1.default.yellow('\nAI analysis found no tests to execute for this PR.'));
                 }
+                process.exit(0);
             }
-            // Execute tests locally
             if (!options.json) {
-                console.log(chalk_1.default.blue(`\nExecuting ${exportData.tests.length} tests...\n`));
+                console.log(chalk_1.default.green(`\nAI selected ${exportData.tests.length} test(s) to execute`));
             }
-            const results = await (0, RestApiExecutor_1.executeTests)(exportData.tests, exportData.application.url, { verbose: options.verbose }, 
-            // Test progress callback
-            (testResult, index, total) => {
+            const appType = exportData.application?.type || 'web';
+            if ((0, RestApiExecutor_1.isRestApiApp)(appType)) {
+                // REST API / SOAP: execute locally
                 if (!options.json) {
-                    console.log((0, RestApiExecutor_1.formatTestResult)(testResult, options.verbose));
+                    console.log(chalk_1.default.cyan(`\nREST API application detected - executing locally`));
+                    console.log(chalk_1.default.gray(`Application: ${exportData.application.name}`));
+                    console.log(chalk_1.default.gray(`Base URL: ${exportData.application.url}`));
+                    console.log(chalk_1.default.gray(`Tests: ${exportData.tests.length}`));
+                    if (executionId) {
+                        console.log(chalk_1.default.gray(`Execution ID: ${executionId}`));
+                    }
+                    console.log();
                 }
-            }, 
-            // Step progress callback (for verbose mode)
-            options.verbose ? (progress, stepResult) => {
-                // Already handled in formatTestResult
-            } : undefined);
-            // Calculate summary
-            const summary = (0, RestApiExecutor_1.calculateSummary)(results);
-            // Report results to backend
-            if (executionId) {
-                try {
-                    await client.reportResults(executionId, results, summary, 'cli', {
-                        os: os.platform(),
-                        nodeVersion: process.version
-                    });
+                if (!options.json) {
+                    console.log(chalk_1.default.blue(`Executing ${exportData.tests.length} tests...\n`));
+                }
+                const results = await (0, RestApiExecutor_1.executeTests)(exportData.tests, exportData.application.url, { verbose: options.verbose, client, applicationId: exportData.application.id }, (testResult, index, total) => {
                     if (!options.json) {
-                        console.log(chalk_1.default.gray(`\nResults reported to Qate`));
+                        console.log((0, RestApiExecutor_1.formatTestResult)(testResult, options.verbose));
+                    }
+                }, options.verbose ? (progress, stepResult) => { } : undefined);
+                const summary = (0, RestApiExecutor_1.calculateSummary)(results);
+                // Report results to backend (pass applicationId for smart execution)
+                if (executionId) {
+                    try {
+                        await client.reportResults(executionId, results, summary, 'cli', { os: os.platform(), nodeVersion: process.version }, exportData.application.id);
+                        if (!options.json) {
+                            console.log(chalk_1.default.gray(`\nResults reported to Qate`));
+                        }
+                    }
+                    catch (err) {
+                        if (!options.json) {
+                            console.log(chalk_1.default.yellow('Note: Could not report results to backend'));
+                        }
                     }
                 }
-                catch (err) {
-                    if (!options.json) {
-                        console.log(chalk_1.default.yellow('Note: Could not report results to backend'));
+                // Write JUnit XML report if requested
+                if (options.junit) {
+                    try {
+                        const junitXml = (0, JunitXmlGenerator_1.generateJunitXml)(results, 'Smart PR Analysis');
+                        const junitPath = path.resolve(options.junit);
+                        const junitDir = path.dirname(junitPath);
+                        if (!fs.existsSync(junitDir)) {
+                            fs.mkdirSync(junitDir, { recursive: true });
+                        }
+                        fs.writeFileSync(junitPath, junitXml, 'utf-8');
+                        if (!options.json) {
+                            console.log(chalk_1.default.gray(`JUnit XML report written to: ${junitPath}`));
+                        }
+                    }
+                    catch (err) {
+                        if (!options.json) {
+                            console.log(chalk_1.default.yellow(`Warning: Could not write JUnit XML report: ${err.message || err}`));
+                        }
                     }
                 }
+                // Display final summary
+                if (options.json) {
+                    console.log(JSON.stringify({
+                        executionId,
+                        mode: 'smart',
+                        prNumber,
+                        status: summary.status,
+                        summary: {
+                            total: summary.total,
+                            passed: summary.passed,
+                            failed: summary.failed,
+                            error: summary.error
+                        },
+                        tests: results.map(r => ({
+                            testId: r.testId,
+                            testName: r.testName,
+                            status: r.status,
+                            duration: r.duration
+                        }))
+                    }, null, 2));
+                }
+                else {
+                    console.log();
+                    console.log(chalk_1.default.blue(`Summary`));
+                    console.log(chalk_1.default.gray(`─────────────────────────────────────`));
+                    console.log(`  Total: ${summary.total}`);
+                    console.log(`  Passed: ${chalk_1.default.green(summary.passed.toString())}`);
+                    console.log(`  Failed: ${chalk_1.default.red(summary.failed.toString())}`);
+                    console.log(`  Error: ${chalk_1.default.red(summary.error.toString())}`);
+                    console.log();
+                    const statusColor = summary.status === 'passed' ? chalk_1.default.green : chalk_1.default.red;
+                    console.log(`Status: ${statusColor(summary.status.toUpperCase())}`);
+                }
+                process.exit(summary.status === 'passed' ? 0 : 1);
             }
-            // Display final summary
-            if (options.json) {
-                console.log(JSON.stringify({
-                    executionId,
-                    testSetName: exportData.testSet?.name,
-                    status: summary.status,
-                    summary: {
-                        total: summary.total,
-                        passed: summary.passed,
-                        failed: summary.failed,
-                        error: summary.error
-                    },
-                    tests: results.map(r => ({
-                        testId: r.testId,
-                        testName: r.testName,
-                        status: r.status,
-                        duration: r.duration
-                    }))
-                }, null, 2));
+            else if (appType === 'desktop') {
+                // Desktop: trigger remote execution via smart-execute endpoint
+                if (!options.json) {
+                    console.log(chalk_1.default.cyan('\nDesktop application detected - executing via connected agent'));
+                    console.log(chalk_1.default.gray(`Application: ${exportData.application.name}`));
+                }
+                const testIds = exportData.tests.map(t => t.id);
+                const result = await client.smartExecute(options.app, testIds, prNumber);
+                if (!options.json) {
+                    console.log(chalk_1.default.gray(`Execution ID: ${result.executionId}`));
+                    console.log(chalk_1.default.blue('\nWaiting for execution to complete...\n'));
+                }
+                const timeoutMs = parseInt(options.timeout) * 1000;
+                // MUST pass testCount as expectedCount or polling hangs forever
+                const status = await client.pollExecution(result.executionId, 'testset', timeoutMs, 5000, result.testCount);
+                // Write JUnit XML report if requested
+                if (options.junit) {
+                    try {
+                        const junitXml = (0, JunitXmlGenerator_1.generateJunitXmlFromStatus)(status, 'Smart PR Analysis');
+                        const junitPath = path.resolve(options.junit);
+                        const junitDir = path.dirname(junitPath);
+                        if (!fs.existsSync(junitDir)) {
+                            fs.mkdirSync(junitDir, { recursive: true });
+                        }
+                        fs.writeFileSync(junitPath, junitXml, 'utf-8');
+                        if (!options.json) {
+                            console.log(chalk_1.default.gray(`JUnit XML report written to: ${junitPath}`));
+                        }
+                    }
+                    catch (err) {
+                        if (!options.json) {
+                            console.log(chalk_1.default.yellow(`Warning: Could not write JUnit XML report: ${err.message || err}`));
+                        }
+                    }
+                }
+                if (options.json) {
+                    console.log(JSON.stringify({ ...status, mode: 'smart', prNumber }, null, 2));
+                }
+                else {
+                    displayStatus(status, 'testset');
+                }
+                process.exit(status.status === 'passed' ? 0 : 1);
             }
             else {
+                // Web apps should use 'qate generate --smart'
+                console.error(chalk_1.default.red('\nError: "qate run --smart" is not supported for web applications.'));
                 console.log();
-                console.log(chalk_1.default.blue(`Summary`));
-                console.log(chalk_1.default.gray(`─────────────────────────────────────`));
-                console.log(`  Total: ${summary.total}`);
-                console.log(`  Passed: ${chalk_1.default.green(summary.passed.toString())}`);
-                console.log(`  Failed: ${chalk_1.default.red(summary.failed.toString())}`);
-                console.log(`  Error: ${chalk_1.default.red(summary.error.toString())}`);
+                console.log(chalk_1.default.yellow('For web applications, use "qate generate --smart" to create Playwright tests:'));
                 console.log();
-                const statusColor = summary.status === 'passed' ? chalk_1.default.green :
-                    summary.status === 'failed' ? chalk_1.default.red : chalk_1.default.red;
-                console.log(`Status: ${statusColor(summary.status.toUpperCase())}`);
+                console.log(chalk_1.default.white(`  qate generate --smart --app ${options.app} -o ./e2e`));
+                console.log(chalk_1.default.white(`  cd ./e2e && npm install`));
+                console.log(chalk_1.default.white(`  npx playwright test`));
+                console.log();
+                console.log(chalk_1.default.gray('This generates Playwright test files that you can run locally or in CI/CD.'));
+                process.exit(1);
             }
-            process.exit(summary.status === 'passed' ? 0 : 1);
         }
-        else if (appType === 'desktop') {
-            // Desktop apps: trigger server-side execution via connected agent, then poll
+        else {
+            // Normal flow (--name provided)
             if (!options.json) {
-                console.log(chalk_1.default.cyan('Desktop application detected - executing via connected agent'));
-                console.log(chalk_1.default.gray(`Application: ${exportData.application.name}`));
+                console.log(chalk_1.default.blue(`Fetching test set: ${options.name}`));
             }
-            const result = await client.executeTestSet(options.name, options.app);
-            if (!options.json) {
-                console.log(chalk_1.default.gray(`Execution ID: ${result.executionId}`));
-                console.log(chalk_1.default.blue('\nWaiting for execution to complete...\n'));
+            // First, export the test set to check application type
+            const exportData = await client.exportTestSet(options.name, options.app);
+            const appType = exportData.application?.type || 'web';
+            // REST API apps execute locally in the CLI
+            if ((0, RestApiExecutor_1.isRestApiApp)(appType)) {
+                if (!options.json) {
+                    console.log(chalk_1.default.cyan(`REST API application detected - executing locally`));
+                    console.log(chalk_1.default.gray(`Application: ${exportData.application.name}`));
+                    console.log(chalk_1.default.gray(`Base URL: ${exportData.application.url}`));
+                    console.log(chalk_1.default.gray(`Tests: ${exportData.tests.length}`));
+                    console.log();
+                }
+                // Create execution record for tracking
+                let executionId;
+                try {
+                    const generateResult = await client.createGenerateExecution(options.name, undefined, options.app, 'cli');
+                    executionId = generateResult.executionId;
+                    if (!options.json) {
+                        console.log(chalk_1.default.gray(`Execution ID: ${executionId}`));
+                    }
+                }
+                catch (err) {
+                    if (err.response?.status === 429 || err.response?.status === 402) {
+                        const msg = err.response?.data?.message || 'Execution not allowed';
+                        if (options.json) {
+                            console.log(JSON.stringify({ error: err.response?.data?.error || 'limit_reached', message: msg }));
+                        }
+                        else {
+                            console.error(chalk_1.default.red(msg));
+                        }
+                        process.exit(1);
+                    }
+                    if (!options.json) {
+                        console.log(chalk_1.default.yellow('Note: Could not create execution record'));
+                    }
+                }
+                // Execute tests locally
+                if (!options.json) {
+                    console.log(chalk_1.default.blue(`\nExecuting ${exportData.tests.length} tests...\n`));
+                }
+                const results = await (0, RestApiExecutor_1.executeTests)(exportData.tests, exportData.application.url, { verbose: options.verbose, client, applicationId: exportData.application.id }, 
+                // Test progress callback
+                (testResult, index, total) => {
+                    if (!options.json) {
+                        console.log((0, RestApiExecutor_1.formatTestResult)(testResult, options.verbose));
+                    }
+                }, 
+                // Step progress callback (for verbose mode)
+                options.verbose ? (progress, stepResult) => {
+                    // Already handled in formatTestResult
+                } : undefined);
+                // Calculate summary
+                const summary = (0, RestApiExecutor_1.calculateSummary)(results);
+                // Report results to backend
+                if (executionId) {
+                    try {
+                        await client.reportResults(executionId, results, summary, 'cli', {
+                            os: os.platform(),
+                            nodeVersion: process.version
+                        });
+                        if (!options.json) {
+                            console.log(chalk_1.default.gray(`\nResults reported to Qate`));
+                        }
+                    }
+                    catch (err) {
+                        if (!options.json) {
+                            console.log(chalk_1.default.yellow('Note: Could not report results to backend'));
+                        }
+                    }
+                }
+                // Write JUnit XML report if requested
+                if (options.junit) {
+                    try {
+                        const junitXml = (0, JunitXmlGenerator_1.generateJunitXml)(results, exportData.testSet?.name || options.name);
+                        const junitPath = path.resolve(options.junit);
+                        const junitDir = path.dirname(junitPath);
+                        if (!fs.existsSync(junitDir)) {
+                            fs.mkdirSync(junitDir, { recursive: true });
+                        }
+                        fs.writeFileSync(junitPath, junitXml, 'utf-8');
+                        if (!options.json) {
+                            console.log(chalk_1.default.gray(`JUnit XML report written to: ${junitPath}`));
+                        }
+                    }
+                    catch (err) {
+                        if (!options.json) {
+                            console.log(chalk_1.default.yellow(`Warning: Could not write JUnit XML report: ${err.message || err}`));
+                        }
+                    }
+                }
+                // Display final summary
+                if (options.json) {
+                    console.log(JSON.stringify({
+                        executionId,
+                        testSetName: exportData.testSet?.name,
+                        status: summary.status,
+                        summary: {
+                            total: summary.total,
+                            passed: summary.passed,
+                            failed: summary.failed,
+                            error: summary.error
+                        },
+                        tests: results.map(r => ({
+                            testId: r.testId,
+                            testName: r.testName,
+                            status: r.status,
+                            duration: r.duration
+                        }))
+                    }, null, 2));
+                }
+                else {
+                    console.log();
+                    console.log(chalk_1.default.blue(`Summary`));
+                    console.log(chalk_1.default.gray(`─────────────────────────────────────`));
+                    console.log(`  Total: ${summary.total}`);
+                    console.log(`  Passed: ${chalk_1.default.green(summary.passed.toString())}`);
+                    console.log(`  Failed: ${chalk_1.default.red(summary.failed.toString())}`);
+                    console.log(`  Error: ${chalk_1.default.red(summary.error.toString())}`);
+                    console.log();
+                    const statusColor = summary.status === 'passed' ? chalk_1.default.green :
+                        summary.status === 'failed' ? chalk_1.default.red : chalk_1.default.red;
+                    console.log(`Status: ${statusColor(summary.status.toUpperCase())}`);
+                }
+                process.exit(summary.status === 'passed' ? 0 : 1);
             }
-            const timeoutMs = parseInt(options.timeout) * 1000;
-            const status = await client.pollExecution(result.executionId, 'testset', timeoutMs);
-            if (options.json) {
-                console.log(JSON.stringify(status, null, 2));
+            else if (appType === 'desktop') {
+                // Desktop apps: trigger server-side execution via connected agent, then poll
+                if (!options.json) {
+                    console.log(chalk_1.default.cyan('Desktop application detected - executing via connected agent'));
+                    console.log(chalk_1.default.gray(`Application: ${exportData.application.name}`));
+                }
+                const result = await client.executeTestSet(options.name, options.app);
+                if (!options.json) {
+                    console.log(chalk_1.default.gray(`Execution ID: ${result.executionId}`));
+                    console.log(chalk_1.default.blue('\nWaiting for execution to complete...\n'));
+                }
+                const timeoutMs = parseInt(options.timeout) * 1000;
+                const status = await client.pollExecution(result.executionId, 'testset', timeoutMs);
+                // Write JUnit XML report if requested
+                if (options.junit) {
+                    try {
+                        const junitXml = (0, JunitXmlGenerator_1.generateJunitXmlFromStatus)(status, exportData.testSet?.name || options.name);
+                        const junitPath = path.resolve(options.junit);
+                        const junitDir = path.dirname(junitPath);
+                        if (!fs.existsSync(junitDir)) {
+                            fs.mkdirSync(junitDir, { recursive: true });
+                        }
+                        fs.writeFileSync(junitPath, junitXml, 'utf-8');
+                        if (!options.json) {
+                            console.log(chalk_1.default.gray(`JUnit XML report written to: ${junitPath}`));
+                        }
+                    }
+                    catch (err) {
+                        if (!options.json) {
+                            console.log(chalk_1.default.yellow(`Warning: Could not write JUnit XML report: ${err.message || err}`));
+                        }
+                    }
+                }
+                if (options.json) {
+                    console.log(JSON.stringify(status, null, 2));
+                }
+                else {
+                    displayStatus(status, 'testset');
+                }
+                process.exit(status.status === 'passed' ? 0 : 1);
             }
             else {
-                displayStatus(status, 'testset');
+                // Web apps should use 'qate generate' to create Playwright tests
+                console.error(chalk_1.default.red('\nError: "qate run" is not supported for web applications.'));
+                console.log();
+                console.log(chalk_1.default.yellow('For web applications, use "qate generate" to create Playwright tests:'));
+                console.log();
+                console.log(chalk_1.default.white(`  qate generate -n "${options.name}" -o ./e2e`));
+                console.log(chalk_1.default.white(`  cd ./e2e && npm install`));
+                console.log(chalk_1.default.white(`  npx playwright test`));
+                console.log();
+                console.log(chalk_1.default.gray('This generates Playwright test files that you can run locally or in CI/CD.'));
+                console.log(chalk_1.default.gray('Results are automatically reported back to Qate.'));
+                process.exit(1);
             }
-            process.exit(status.status === 'passed' ? 0 : 1);
-        }
-        else {
-            // Web apps should use 'qate generate' to create Playwright tests
-            console.error(chalk_1.default.red('\nError: "qate run" is not supported for web applications.'));
-            console.log();
-            console.log(chalk_1.default.yellow('For web applications, use "qate generate" to create Playwright tests:'));
-            console.log();
-            console.log(chalk_1.default.white(`  qate generate -n "${options.name}" -o ./e2e`));
-            console.log(chalk_1.default.white(`  cd ./e2e && npm install`));
-            console.log(chalk_1.default.white(`  npx playwright test`));
-            console.log();
-            console.log(chalk_1.default.gray('This generates Playwright test files that you can run locally or in CI/CD.'));
-            console.log(chalk_1.default.gray('Results are automatically reported back to Qate.'));
-            process.exit(1);
-        }
+        } // end normal flow else
     }
     catch (error) {
         handleApiError(error);
@@ -429,8 +714,7 @@ program
                 outputDir: options.output,
                 provider: 'local',
                 orchestration: 'websocket',
-                browsers: ['chromium'],
-                browser: 'chrome',
+                browser: 'chromium',
                 browserVersion: 'latest',
                 os: 'windows',
                 osVersion: '11',
@@ -485,6 +769,7 @@ program
     .option('-w, --wait', 'Wait for execution to complete')
     .option('--timeout <seconds>', 'Timeout for waiting (default: 600)', '600')
     .option('--json', 'Output results as JSON')
+    .option('--junit <path>', 'Write JUnit XML report to file')
     .option('-v, --verbose', 'Show detailed step-by-step output')
     .action(async (options) => {
     try {
@@ -515,6 +800,16 @@ program
                 }
             }
             catch (err) {
+                if (err.response?.status === 429 || err.response?.status === 402) {
+                    const msg = err.response?.data?.message || 'Execution not allowed';
+                    if (options.json) {
+                        console.log(JSON.stringify({ error: err.response?.data?.error || 'limit_reached', message: msg }));
+                    }
+                    else {
+                        console.error(chalk_1.default.red(msg));
+                    }
+                    process.exit(1);
+                }
                 if (!options.json) {
                     console.log(chalk_1.default.yellow('Note: Could not create execution record'));
                 }
@@ -527,7 +822,7 @@ program
             let stoppedEarly = false;
             for (let i = 0; i < exportData.tests.length; i++) {
                 const test = exportData.tests[i];
-                const testResults = await (0, RestApiExecutor_1.executeTests)([test], exportData.application.url, { verbose: options.verbose }, (testResult) => {
+                const testResults = await (0, RestApiExecutor_1.executeTests)([test], exportData.application.url, { verbose: options.verbose, client, applicationId: exportData.application.id }, (testResult) => {
                     if (!options.json) {
                         console.log((0, RestApiExecutor_1.formatTestResult)(testResult, options.verbose));
                     }
@@ -561,6 +856,26 @@ program
                     }
                 }
             }
+            // Write JUnit XML report if requested
+            if (options.junit) {
+                try {
+                    const junitXml = (0, JunitXmlGenerator_1.generateJunitXml)(results, exportData.testSequence?.name || options.name);
+                    const junitPath = path.resolve(options.junit);
+                    const junitDir = path.dirname(junitPath);
+                    if (!fs.existsSync(junitDir)) {
+                        fs.mkdirSync(junitDir, { recursive: true });
+                    }
+                    fs.writeFileSync(junitPath, junitXml, 'utf-8');
+                    if (!options.json) {
+                        console.log(chalk_1.default.gray(`JUnit XML report written to: ${junitPath}`));
+                    }
+                }
+                catch (err) {
+                    if (!options.json) {
+                        console.log(chalk_1.default.yellow(`Warning: Could not write JUnit XML report: ${err.message || err}`));
+                    }
+                }
+            }
             // Display final summary
             if (options.json) {
                 console.log(JSON.stringify({
@@ -616,6 +931,26 @@ program
             }
             const timeoutMs = parseInt(options.timeout) * 1000;
             const status = await client.pollExecution(result.executionId, 'sequence', timeoutMs);
+            // Write JUnit XML report if requested
+            if (options.junit) {
+                try {
+                    const junitXml = (0, JunitXmlGenerator_1.generateJunitXmlFromStatus)(status, exportData.testSequence?.name || options.name);
+                    const junitPath = path.resolve(options.junit);
+                    const junitDir = path.dirname(junitPath);
+                    if (!fs.existsSync(junitDir)) {
+                        fs.mkdirSync(junitDir, { recursive: true });
+                    }
+                    fs.writeFileSync(junitPath, junitXml, 'utf-8');
+                    if (!options.json) {
+                        console.log(chalk_1.default.gray(`JUnit XML report written to: ${junitPath}`));
+                    }
+                }
+                catch (err) {
+                    if (!options.json) {
+                        console.log(chalk_1.default.yellow(`Warning: Could not write JUnit XML report: ${err.message || err}`));
+                    }
+                }
+            }
             if (options.json) {
                 console.log(JSON.stringify(status, null, 2));
             }
@@ -729,8 +1064,7 @@ program
                 outputDir: options.output,
                 provider: 'local',
                 orchestration: 'websocket',
-                browsers: ['chromium'],
-                browser: 'chrome',
+                browser: 'chromium',
                 browserVersion: 'latest',
                 os: 'windows',
                 osVersion: '11',
@@ -1018,39 +1352,88 @@ function writeAxiosFiles(files, outputDir, silent = false) {
 program
     .command('generate:testset')
     .alias('generate')
-    .description('Generate Playwright test files from a test set')
-    .requiredOption('-n, --name <name>', 'Name of the test set')
+    .description('Generate Playwright test files from a test set or AI-selected tests')
+    .option('-n, --name <name>', 'Name of the test set')
     .requiredOption('-o, --output <dir>', 'Output directory for generated files')
     .option('-a, --api-key <key>', 'API key (or use QATE_API_KEY env var)')
     .option('-u, --url <url>', 'Qate API URL (or use QATE_API_URL env var)')
-    .option('--app <applicationId>', 'Application ID (if name is not unique)')
+    .option('--app <applicationId>', 'Application ID (required for --smart, optional otherwise)')
+    .option('--smart', 'Use AI to select tests based on PR changes')
+    .option('--pr <number>', 'PR number (auto-detected from CI environment if not specified)')
+    .option('--repo-type <type>', 'Repository type for --smart: frontend or backend', 'frontend')
     .option('--provider <provider>', 'Test provider: local, browserstack, saucelabs, lambdatest', 'local')
     .option('--orchestration <mode>', 'Orchestration mode: websocket (run from CI) or cli (provider orchestrates)', 'websocket')
-    .option('--browsers <browsers>', 'Comma-separated list of browsers (for local provider)', 'chromium')
-    .option('--browser <browser>', 'Browser for cloud providers: chrome, firefox, safari, edge', 'chrome')
+    .option('--browser <browser>', 'Browser: chromium, firefox, webkit (local) or chrome, firefox, safari, edge (cloud)', 'chromium')
     .option('--browser-version <version>', 'Browser version for cloud providers', 'latest')
     .option('--os <os>', 'Operating system for cloud providers: windows, macos', 'windows')
     .option('--os-version <version>', 'OS version for cloud providers (e.g., 11, Sonoma)', '11')
+    .option('--device <name>', 'Playwright device name for mobile emulation (e.g. "iPhone 14", "Pixel 7")')
     .option('--no-tracking', 'Disable result reporting to Qate')
     .action(async (options) => {
     try {
+        // Validate: either --name or --smart is required
+        if (!options.smart && !options.name) {
+            console.error(chalk_1.default.red('Error: Either --name <test-set-name> or --smart is required.'));
+            console.error(chalk_1.default.gray('  Use --name to generate from a specific test set'));
+            console.error(chalk_1.default.gray('  Use --smart to let AI select tests based on PR changes'));
+            process.exit(1);
+        }
+        if (options.smart && !options.app) {
+            console.error(chalk_1.default.red('Error: --app <applicationId> is required when using --smart.'));
+            console.error(chalk_1.default.gray('  Find your application ID in Qate: Settings > Applications'));
+            process.exit(1);
+        }
         const { apiKey, baseUrl } = getConfig(options);
         const client = new client_1.QateClient(baseUrl, apiKey);
-        console.log(chalk_1.default.blue(`Fetching test set: ${options.name}`));
-        // Create execution record for tracking (unless disabled)
+        let exportData;
         let executionId;
-        if (options.tracking !== false) {
-            try {
-                const generateResult = await client.createGenerateExecution(options.name, undefined, options.app, options.provider);
-                executionId = generateResult.executionId;
-                console.log(chalk_1.default.gray(`Execution ID: ${executionId}`));
+        if (options.smart) {
+            // Smart generate: AI-powered test selection based on PR changes
+            const prNumber = options.pr ? parseInt(options.pr) : detectPRFromEnvironment();
+            if (!prNumber) {
+                console.error(chalk_1.default.red('Error: Could not detect PR number from CI environment.'));
+                console.error(chalk_1.default.gray('  Use --pr <number> to specify the PR number explicitly.'));
+                console.error(chalk_1.default.gray('  Auto-detection supports: GitHub Actions, GitLab CI, Bitbucket Pipelines,'));
+                console.error(chalk_1.default.gray('  Azure DevOps, Jenkins, CircleCI'));
+                process.exit(1);
             }
-            catch (err) {
-                console.log(chalk_1.default.yellow('Note: Could not create execution record for tracking'));
-                console.log(chalk_1.default.gray('  Results will not be reported to Qate'));
+            console.log(chalk_1.default.blue(`Smart generating tests for PR #${prNumber}...`));
+            console.log(chalk_1.default.gray(`  Application: ${options.app}`));
+            console.log(chalk_1.default.gray(`  Repository type: ${options.repoType}`));
+            console.log(chalk_1.default.gray('  Analyzing PR changes with AI...'));
+            exportData = await client.smartGenerate(options.app, prNumber, options.repoType);
+            executionId = exportData.executionId;
+            if (exportData.tests.length === 0) {
+                console.log(chalk_1.default.yellow('\nAI analysis found no tests to execute for this PR.'));
+                process.exit(0);
+            }
+            console.log(chalk_1.default.green(`\nAI selected ${exportData.tests.length} test(s) to execute`));
+            if (executionId) {
+                console.log(chalk_1.default.gray(`  Execution ID: ${executionId}`));
             }
         }
-        const exportData = await client.exportTestSet(options.name, options.app);
+        else {
+            // Normal flow: generate from named test set
+            console.log(chalk_1.default.blue(`Fetching test set: ${options.name}`));
+            // Create execution record for tracking (unless disabled)
+            if (options.tracking !== false) {
+                try {
+                    const generateResult = await client.createGenerateExecution(options.name, undefined, options.app, options.provider, options.browser, options.device);
+                    executionId = generateResult.executionId;
+                    console.log(chalk_1.default.gray(`Execution ID: ${executionId}`));
+                }
+                catch (err) {
+                    if (err.response?.status === 429 || err.response?.status === 402) {
+                        const msg = err.response?.data?.message || 'Execution not allowed';
+                        console.error(chalk_1.default.red(msg));
+                        process.exit(1);
+                    }
+                    console.log(chalk_1.default.yellow('Note: Could not create execution record for tracking'));
+                    console.log(chalk_1.default.gray('  Results will not be reported to Qate'));
+                }
+            }
+            exportData = await client.exportTestSet(options.name, options.app);
+        }
         // Show summary
         console.log((0, PlaywrightGenerator_1.generateSummary)(exportData));
         // Generate files with execution ID for result reporting
@@ -1058,13 +1441,13 @@ program
             outputDir: options.output,
             provider: options.provider,
             orchestration: options.orchestration,
-            browsers: options.browsers.split(',').map((b) => b.trim()),
             browser: options.browser,
             browserVersion: options.browserVersion,
             os: options.os,
             osVersion: options.osVersion,
             executionId,
             apiUrl: baseUrl,
+            device: options.device,
         };
         const files = (0, PlaywrightGenerator_1.generatePlaywrightTests)(exportData, generatorOptions);
         // Write files
@@ -1119,11 +1502,11 @@ program
     .option('--app <applicationId>', 'Application ID (if name is not unique)')
     .option('--provider <provider>', 'Test provider: local, browserstack, saucelabs, lambdatest', 'local')
     .option('--orchestration <mode>', 'Orchestration mode: websocket (run from CI) or cli (provider orchestrates)', 'websocket')
-    .option('--browsers <browsers>', 'Comma-separated list of browsers (for local provider)', 'chromium')
-    .option('--browser <browser>', 'Browser for cloud providers: chrome, firefox, safari, edge', 'chrome')
+    .option('--browser <browser>', 'Browser: chromium, firefox, webkit (local) or chrome, firefox, safari, edge (cloud)', 'chromium')
     .option('--browser-version <version>', 'Browser version for cloud providers', 'latest')
     .option('--os <os>', 'Operating system for cloud providers: windows, macos', 'windows')
     .option('--os-version <version>', 'OS version for cloud providers (e.g., 11, Sonoma)', '11')
+    .option('--device <name>', 'Playwright device name for mobile emulation (e.g. "iPhone 14", "Pixel 7")')
     .option('--no-tracking', 'Disable result reporting to Qate')
     .action(async (options) => {
     try {
@@ -1134,11 +1517,16 @@ program
         let executionId;
         if (options.tracking !== false) {
             try {
-                const generateResult = await client.createGenerateExecution(undefined, options.name, options.app, options.provider);
+                const generateResult = await client.createGenerateExecution(undefined, options.name, options.app, options.provider, options.browser, options.device);
                 executionId = generateResult.executionId;
                 console.log(chalk_1.default.gray(`Execution ID: ${executionId}`));
             }
             catch (err) {
+                if (err.response?.status === 429 || err.response?.status === 402) {
+                    const msg = err.response?.data?.message || 'Execution not allowed';
+                    console.error(chalk_1.default.red(msg));
+                    process.exit(1);
+                }
                 console.log(chalk_1.default.yellow('Note: Could not create execution record for tracking'));
                 console.log(chalk_1.default.gray('  Results will not be reported to Qate'));
             }
@@ -1151,13 +1539,13 @@ program
             outputDir: options.output,
             provider: options.provider,
             orchestration: options.orchestration,
-            browsers: options.browsers.split(',').map((b) => b.trim()),
             browser: options.browser,
             browserVersion: options.browserVersion,
             os: options.os,
             osVersion: options.osVersion,
             executionId,
             apiUrl: baseUrl,
+            device: options.device,
         };
         const files = (0, PlaywrightGenerator_1.generatePlaywrightTests)(exportData, generatorOptions);
         // Write files