@testspectra/cli 1.0.70 → 1.1.0-rc.0

package/dist/commands/install.d.ts

@@ -0,0 +1,4 @@
+export declare function installCommand(item?: string, options?: {
+    force?: boolean;
+    cwd?: string;
+}): Promise<void>;

package/dist/commands/install.js

@@ -0,0 +1,59 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+import { RustCoreBridge } from '../runner/bridge.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export async function installCommand(item, options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const binPath = RustCoreBridge.resolveBinaryPath();
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    const globalDriversDir = path.join(home, '.testspectra', 'drivers');
+    const runnerEnv = {
+        ...process.env,
+        TEST_SPECTRA_DRIVER_CACHE: globalDriversDir,
+    };
+    const args = ['install'];
+    if (item) {
+        args.push(item);
+    }
+    return new Promise((resolve) => {
+        let child;
+        if (binPath === 'cargo') {
+            const workspaceRoot = path.resolve(__dirname, '../../..');
+            const cargoArgs = [
+                'run',
+                '--manifest-path',
+                'core/test-runner/Cargo.toml',
+                '--bin',
+                'testspectra-runner',
+                '--',
+                ...args,
+            ];
+            child = spawn('cargo', cargoArgs, {
+                cwd: workspaceRoot,
+                env: runnerEnv,
+                stdio: 'inherit',
+            });
+        }
+        else {
+            child = spawn(binPath, args, {
+                cwd,
+                env: runnerEnv,
+                stdio: 'inherit',
+            });
+        }
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                process.exit(code ?? 1);
+            }
+        });
+        child.on('error', (err) => {
+            console.error(`[TestSpectra Install Error] ${err.message}`);
+            process.exit(1);
+        });
+    });
+}

package/dist/commands/license.d.ts

@@ -0,0 +1,4 @@
+export interface LicenseCommandOptions {
+    json?: boolean;
+}
+export declare function licenseCommand(action?: string, key?: string, options?: LicenseCommandOptions): Promise<void>;

package/dist/commands/license.js

@@ -0,0 +1,30 @@
+import { spawn } from 'child_process';
+import { RustCoreBridge } from '../runner/bridge.js';
+export async function licenseCommand(action = 'status', key, options = {}) {
+    const binPath = RustCoreBridge.resolveBinaryPath();
+    const normalizedAction = action.toLowerCase().trim();
+    const args = ['license', normalizedAction];
+    if (key && normalizedAction === 'activate') {
+        args.push(key.trim());
+    }
+    if (options.json) {
+        args.push('--json');
+    }
+    return new Promise((resolve, reject) => {
+        const child = spawn(binPath, args, {
+            stdio: 'inherit',
+            env: process.env,
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                process.exit(code ?? 1);
+            }
+        });
+        child.on('error', (err) => {
+            reject(err);
+        });
+    });
+}

package/dist/commands/lint.d.ts

@@ -0,0 +1,5 @@
+import type { LintOptions } from '../linter/types.js';
+export interface LintCommandOptions extends LintOptions {
+    path?: string;
+}
+export declare function lintCommand(targetPath?: string, options?: LintCommandOptions): Promise<void>;

package/dist/commands/lint.js

@@ -0,0 +1,55 @@
+import path from 'path';
+import chalk from 'chalk';
+import { SpecLinter } from '../linter/spec-linter.js';
+export async function lintCommand(targetPath, options = {}) {
+    const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+    try {
+        const result = SpecLinter.validateWorkspace(cwd, targetPath);
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            if (!result.valid || (options.strict && result.stats.warningCount > 0)) {
+                process.exit(1);
+            }
+            return;
+        }
+        console.log(chalk.bold('\n🔍 TestSpectra Spec & Code Linter\n'));
+        // Group diagnostics by file
+        const diagnosticsByFile = new Map();
+        for (const diag of result.diagnostics) {
+            const relPath = path.relative(cwd, diag.filePath);
+            const list = diagnosticsByFile.get(relPath) || [];
+            list.push(diag);
+            diagnosticsByFile.set(relPath, list);
+        }
+        if (diagnosticsByFile.size === 0) {
+            console.log(chalk.green(`  ✓ ${result.stats.totalSpecs} specs and ${result.stats.totalSuites} suites verified.`));
+            console.log(chalk.green.bold('\n✓ All spec schemas are valid. 0 lint errors found.\n'));
+            return;
+        }
+        for (const [file, diags] of diagnosticsByFile.entries()) {
+            console.log(chalk.bold(`  ${file}`));
+            for (const diag of diags) {
+                const icon = diag.severity === 'error' ? chalk.red('✗') : chalk.yellow('⚠');
+                const codeTag = chalk.gray(`[${diag.code}]`);
+                const loc = chalk.dim(`:${diag.line}`);
+                console.log(`    ${icon} ${codeTag} ${diag.message} ${loc}`);
+            }
+            console.log();
+        }
+        const { errorCount, warningCount } = result.stats;
+        if (errorCount > 0) {
+            console.log(chalk.red.bold(`✖ ${errorCount} lint error${errorCount > 1 ? 's' : ''}${warningCount > 0 ? ` and ${warningCount} warning${warningCount > 1 ? 's' : ''}` : ''} found.\n`));
+            process.exit(1);
+        }
+        else if (warningCount > 0) {
+            console.log(chalk.yellow.bold(`⚠ ${warningCount} lint warning${warningCount > 1 ? 's' : ''} found.\n`));
+            if (options.strict) {
+                process.exit(1);
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`\n✖ Fatal error during linting: ${err?.message || err}\n`));
+        process.exit(2);
+    }
+}

package/dist/commands/refactor.d.ts

@@ -0,0 +1,9 @@
+import { RefactorResult } from '../refactor/refactor-engine.js';
+export interface RefactorCommandOptions {
+    cwd?: string;
+    dryRun?: boolean;
+    json?: boolean;
+    from?: string;
+    to?: string;
+}
+export declare function refactorCommand(entityType?: string, oldName?: string, newName?: string, options?: RefactorCommandOptions): Promise<RefactorResult>;

package/dist/commands/refactor.js

@@ -0,0 +1,172 @@
+import path from 'path';
+import { RefactorEngine } from '../refactor/refactor-engine.js';
+export async function refactorCommand(entityType, oldName, newName, options = {}) {
+    const workspaceRoot = options.cwd ? path.resolve(options.cwd) : process.cwd();
+    let targetType = 'page-object';
+    let fromSymbol = oldName || '';
+    let toSymbol = newName || '';
+    // 1. Path-based refactoring via --from and --to flags
+    if (options.from || options.to) {
+        if (!options.from || !options.to) {
+            const errorMsg = 'Both --from and --to must be specified for path-based refactoring.';
+            const result = {
+                status: 'failed',
+                entityType: 'page-object',
+                oldSymbol: options.from || '',
+                newSymbol: options.to || '',
+                modifiedFiles: [],
+                occurrencesReplaced: 0,
+                error: errorMsg,
+            };
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.error(`\x1b[31m✗ ${errorMsg}\x1b[0m`);
+            }
+            process.exitCode = 1;
+            return result;
+        }
+        const pathResult = await RefactorEngine.renameFromPaths({
+            workspaceRoot,
+            fromPath: options.from,
+            toPath: options.to,
+            dryRun: options.dryRun,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(pathResult, null, 2));
+            if (pathResult.status === 'failed') {
+                process.exitCode = 1;
+            }
+            return pathResult;
+        }
+        if (pathResult.status === 'success') {
+            const modeStr = options.dryRun ? '[Dry-Run] ' : '';
+            console.log(`\x1b[32m✓ ${modeStr}Refactored ${pathResult.entityType} "${pathResult.oldSymbol}" → "${pathResult.newSymbol}"\x1b[0m`);
+            console.log(`  Modified files: ${pathResult.modifiedFiles.length}`);
+            console.log(`  Occurrences replaced: ${pathResult.occurrencesReplaced}`);
+            for (const f of pathResult.modifiedFiles) {
+                console.log(`    ↳ ${f}`);
+            }
+        }
+        else {
+            console.error(`\x1b[31m✗ Refactoring failed: ${pathResult.error}\x1b[0m`);
+            process.exitCode = 1;
+        }
+        return pathResult;
+    }
+    // 2. Also support positional path syntax: spectra refactor <fromPath> <toPath>
+    if (entityType && oldName && !newName && RefactorEngine.parseEntityFromPath(entityType)) {
+        const pathResult = await RefactorEngine.renameFromPaths({
+            workspaceRoot,
+            fromPath: entityType,
+            toPath: oldName,
+            dryRun: options.dryRun,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(pathResult, null, 2));
+            if (pathResult.status === 'failed') {
+                process.exitCode = 1;
+            }
+            return pathResult;
+        }
+        if (pathResult.status === 'success') {
+            const modeStr = options.dryRun ? '[Dry-Run] ' : '';
+            console.log(`\x1b[32m✓ ${modeStr}Refactored ${pathResult.entityType} "${pathResult.oldSymbol}" → "${pathResult.newSymbol}"\x1b[0m`);
+            console.log(`  Modified files: ${pathResult.modifiedFiles.length}`);
+            console.log(`  Occurrences replaced: ${pathResult.occurrencesReplaced}`);
+            for (const f of pathResult.modifiedFiles) {
+                console.log(`    ↳ ${f}`);
+            }
+        }
+        else {
+            console.error(`\x1b[31m✗ Refactoring failed: ${pathResult.error}\x1b[0m`);
+            process.exitCode = 1;
+        }
+        return pathResult;
+    }
+    // 3. Positional syntax: spectra refactor <entityType> <oldName> <newName>
+    if (!entityType || !oldName || !newName) {
+        const errorMsg = 'Usage: spectra refactor <page-object|step|action|fixture> <oldName> <newName> or spectra refactor --from <path> --to <path>';
+        const result = {
+            status: 'failed',
+            entityType: 'page-object',
+            oldSymbol: oldName || '',
+            newSymbol: newName || '',
+            modifiedFiles: [],
+            occurrencesReplaced: 0,
+            error: errorMsg,
+        };
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.error(errorMsg);
+        }
+        process.exitCode = 1;
+        return result;
+    }
+    const normalized = entityType.toLowerCase().replace(/_/g, '-');
+    if (['page-object', 'po', 'page', 'pageobject'].includes(normalized)) {
+        targetType = 'page-object';
+    }
+    else if (['step', 'steps'].includes(normalized)) {
+        targetType = 'step';
+    }
+    else if (['action', 'actions'].includes(normalized)) {
+        targetType = 'action';
+    }
+    else if (['fixture', 'fixtures'].includes(normalized)) {
+        targetType = 'fixture';
+    }
+    else {
+        const errorMsg = `Unknown refactor entity type: "${entityType}". Valid types: page-object, step, action, fixture.`;
+        const result = {
+            status: 'failed',
+            entityType: 'page-object',
+            oldSymbol: oldName,
+            newSymbol: newName,
+            modifiedFiles: [],
+            occurrencesReplaced: 0,
+            error: errorMsg,
+        };
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.error(`\x1b[31m✗ ${errorMsg}\x1b[0m`);
+        }
+        process.exitCode = 1;
+        return result;
+    }
+    fromSymbol = oldName;
+    toSymbol = newName;
+    const result = await RefactorEngine.renameSymbol({
+        workspaceRoot,
+        type: targetType,
+        oldName: fromSymbol,
+        newName: toSymbol,
+        dryRun: options.dryRun,
+    });
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        if (result.status === 'failed') {
+            process.exitCode = 1;
+        }
+        return result;
+    }
+    if (result.status === 'success') {
+        const modeStr = options.dryRun ? '[Dry-Run] ' : '';
+        console.log(`\x1b[32m✓ ${modeStr}Refactored ${result.entityType} "${result.oldSymbol}" → "${result.newSymbol}"\x1b[0m`);
+        console.log(`  Modified files: ${result.modifiedFiles.length}`);
+        console.log(`  Occurrences replaced: ${result.occurrencesReplaced}`);
+        for (const f of result.modifiedFiles) {
+            console.log(`    ↳ ${f}`);
+        }
+    }
+    else {
+        console.error(`\x1b[31m✗ Refactoring failed: ${result.error}\x1b[0m`);
+        process.exitCode = 1;
+    }
+    return result;
+}

package/dist/commands/run.d.ts

@@ -1,10 +1,31 @@
 export interface RunCommandOptions {
     spec?: string;
-    target?: "web" | "android" | "ios" | "common";
+    target?: 'web' | 'android' | 'ios' | 'common' | 'mobile';
     device?: string;
+    devices?: string;
+    allDevices?: boolean;
+    multiDevice?: boolean;
     headless?: boolean;
+    headed?: boolean;
+    stepDelay?: string | number;
+    delay?: string | number;
     workdir?: string;
     output?: string;
     demo?: boolean;
+    failed?: boolean | string;
+    concurrency?: string | number;
+    licenseKey?: string;
 }
-export declare function runCommand(specPath?: string, options?: RunCommandOptions): Promise<void>;
+export declare function renderTimingBreakdown(performance: {
+    masterBootLatencyMs?: number;
+    avgContextCreationMs?: number;
+    avgCdpHandshakeMs?: number;
+    avgTestExecutionMs?: number;
+    totalTestExecutionMs?: number;
+    runnerOverheadMs?: number;
+    avgTeardownMs?: number;
+    wallClockDurationMs?: number;
+    totalTests?: number;
+    duration?: string;
+}, platform?: string): void;
+export declare function runCommand(specPaths?: string[], options?: RunCommandOptions): Promise<void>;