@playq/core 0.2.77

package/dist/exec/preProcessEntry.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const glob_1 = require("glob");
+const vars = __importStar(require("../helper/bundle/vars"));
+const config = {};
+const sgGenerator_1 = require("./sgGenerator");
+const featureFileCache_1 = require("./featureFileCache");
+const featureFilePreProcess_1 = require("./featureFilePreProcess");
+const featureFileCache = ((_a = config === null || config === void 0 ? void 0 : config.cucumber) === null || _a === void 0 ? void 0 : _a.featureFileCache) || (vars.getConfigValue('cucumber.featureFileCache') || false);
+const isForce = process.argv.includes('--force');
+console.log('🚀 Running preProcessEntry.ts...');
+console.log(`⚙️ featureFileCache enabled: ${featureFileCache}`);
+console.log(`⚙️ Force flag: ${isForce}`);
+(0, sgGenerator_1.generateStepGroupsIfNeeded)(isForce);
+const featureFiles = (0, glob_1.sync)('test/features/**/*.feature');
+if (!featureFiles.length) {
+    console.warn('⚠️ No feature files found under features/**/*.feature');
+}
+// Clean up execution folder before generating new feature files
+const executionDir = path_1.default.join('_Temp', 'execution');
+if (fs_1.default.existsSync(executionDir)) {
+    fs_1.default.rmSync(executionDir, { recursive: true, force: true });
+    console.log(`🧹 Cleaned up execution folder: ${executionDir}`);
+}
+for (const originalPath of featureFiles) {
+    console.log(`🔧 Processing: ${originalPath}`);
+    const cachedPath = (0, featureFileCache_1.getCachedFeatureFilePath)(originalPath);
+    console.log(`📄 Cached path: ${cachedPath}`);
+    if (featureFileCache && !isForce && (0, featureFileCache_1.shouldUseCachedFeature)(originalPath, cachedPath)) {
+        console.log(`✅ Using cached feature file: ${cachedPath}`);
+        continue;
+    }
+    const updatedContent = (0, featureFilePreProcess_1.preprocessFeatureFile)(originalPath);
+    if (!updatedContent || !updatedContent.trim().startsWith('Feature')) {
+        console.warn(`❌ Skipping cache write for ${originalPath}: Invalid content. Preview:\n${(updatedContent || '').substring(0, 100)}`);
+        continue;
+    }
+    fs_1.default.mkdirSync(path_1.default.dirname(cachedPath), { recursive: true });
+    fs_1.default.writeFileSync(cachedPath, updatedContent, 'utf-8');
+    console.log(`📥 Updated cached feature file: ${cachedPath}`);
+    if (featureFileCache) {
+        (0, featureFileCache_1.updateFeatureCacheMeta)(originalPath, cachedPath);
+    }
+}

package/dist/exec/preProcess_old_todelete.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/exec/preProcess_old_todelete.js

@@ -0,0 +1,258 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const csv_parser_1 = __importDefault(require("csv-parser"));
+// import xlsx from 'xlsx';
+const xlsx_1 = __importDefault(require("@e965/xlsx"));
+const crypto_1 = __importDefault(require("crypto"));
+const sgGenerator_1 = require("./sgGenerator");
+const config = {};
+function loadStepGroupCache() {
+    const cachePath = path_1.default.resolve('_Temp/.cache/stepGroup_cache.json');
+    if (!fs_1.default.existsSync(cachePath)) {
+        console.error(`❌ Step group JSON cache not found. Please run sgGenerator.ts first.`);
+        return {};
+    }
+    return JSON.parse(fs_1.default.readFileSync(cachePath, 'utf-8'));
+}
+const args = process.argv.slice(2);
+const isForced = args.includes('--force');
+function sha256(content) {
+    return crypto_1.default.createHash('sha256').update(content).digest('hex');
+}
+const featureCachePath = path_1.default.resolve('_Temp/.cache/featureMeta.json');
+const featureCache = fs_1.default.existsSync(featureCachePath)
+    ? JSON.parse(fs_1.default.readFileSync(featureCachePath, 'utf8'))
+    : {};
+const sourceDir = path_1.default.resolve('test/features');
+const outputDir = path_1.default.resolve('_Temp/execution');
+const dataDir = path_1.default.resolve('test-data');
+function findFeatureFiles(dir) {
+    let results = [];
+    fs_1.default.readdirSync(dir).forEach(file => {
+        const fullPath = path_1.default.join(dir, file);
+        const stat = fs_1.default.statSync(fullPath);
+        if (stat.isDirectory()) {
+            results = results.concat(findFeatureFiles(fullPath));
+        }
+        else if (file.endsWith('.feature')) {
+            results.push(fullPath);
+        }
+    });
+    return results;
+}
+function ensureOutputPath(featurePath) {
+    const relativePath = path_1.default.relative(sourceDir, featurePath);
+    const targetPath = path_1.default.join(outputDir, relativePath);
+    const dir = path_1.default.dirname(targetPath);
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    return targetPath;
+}
+function isNumeric(val) {
+    return typeof val === 'string' && val.trim() !== '' && !isNaN(Number(val));
+}
+function validateIdentifiers(filter, inputPath) {
+    const invalidIdentifiers = Array.from(filter.matchAll(/_([A-Z0-9_\-\.]+)/gi))
+        .map(match => match[1])
+        .filter(id => !/^[_a-zA-Z][_a-zA-Z0-9]*$/.test(`_${id}`));
+    if (invalidIdentifiers.length > 0) {
+        console.error(`❌ Invalid identifiers in filter: ${invalidIdentifiers.map(i => `"_${i}"`).join(', ')}`);
+        console.error(`   👉 Use only letters, numbers, and underscores (e.g., _SUB_STATUS)`);
+        console.error(`   ✋ Please fix this in feature file: ${inputPath}`);
+        return false;
+    }
+    return true;
+}
+function substituteFilter(filter, row) {
+    const allKeys = Object.keys(row);
+    const pattern = /\b[_a-zA-Z][_a-zA-Z0-9]*\b/g;
+    return filter.replace(pattern, (key) => {
+        var _a;
+        const raw = (_a = row[key]) !== null && _a !== void 0 ? _a : row[`_${key}`];
+        if (raw === undefined)
+            return key; // leave as-is if not found
+        return isNumeric(raw) ? raw.trim() : JSON.stringify(raw);
+    });
+}
+function preprocessFeatureFile(inputPath, outputPath, stepGroupCache, stepGroupCacheHash) {
+    const relativePath = path_1.default.relative(sourceDir, inputPath);
+    let featureHashInput = fs_1.default.readFileSync(inputPath, 'utf-8') + stepGroupCacheHash;
+    const featureText = fs_1.default.readFileSync(inputPath, 'utf-8');
+    const lines = featureText.split('\n');
+    let dataFile = '';
+    let filter = '';
+    let sheetName = '';
+    let exampleLineIndex = -1;
+    lines.forEach((line, index) => {
+        const exampleMatch = line.trim().startsWith('Examples:') && line.includes('{');
+        if (exampleMatch) {
+            exampleLineIndex = index;
+            const jsonStr = line.replace(/^Examples:\s*/, '').trim();
+            try {
+                const parsed = JSON.parse(jsonStr.replace(/'/g, '"'));
+                dataFile = parsed.dataFile;
+                filter = parsed.filter;
+                sheetName = parsed.sheetName;
+                if (!validateIdentifiers(filter, inputPath)) {
+                    return;
+                }
+                // Add to hash input: options for Examples
+                featureHashInput += JSON.stringify({ filter, sheetName, dataFile });
+            }
+            catch (err) {
+                console.error(`❌ Failed to parse Examples JSON in ${inputPath}:\n`, err);
+                return;
+            }
+        }
+    });
+    // If there is a data file, append its content to the hash input (if it exists)
+    let fullPath = '';
+    if (dataFile) {
+        const ext = path_1.default.extname(dataFile).toLowerCase();
+        fullPath = path_1.default.join(dataDir, path_1.default.basename(dataFile));
+        if (fs_1.default.existsSync(fullPath)) {
+            // For CSV, read as utf-8; for XLSX, hash the file buffer.
+            if (ext === '.csv') {
+                featureHashInput += fs_1.default.readFileSync(fullPath, 'utf-8');
+            }
+            else if (ext === '.xlsx') {
+                featureHashInput += fs_1.default.readFileSync(fullPath).toString('base64');
+            }
+        }
+    }
+    // Compute current hash
+    const currentHash = sha256(featureHashInput);
+    if (!isForced && featureCache[relativePath] && featureCache[relativePath] === currentHash) {
+        console.log(`⏩ Skipped (unchanged): ${relativePath}`);
+        return;
+    }
+    if (!dataFile || !filter || exampleLineIndex === -1) {
+        // No Examples, just expand step groups and write output
+        console.log("📣 No Examples detected. Proceeding with step group expansion only...");
+        const expandedLines = expandStepGroups(lines, inputPath, stepGroupCache);
+        const outputContent = expandedLines.join('\n');
+        fs_1.default.writeFileSync(outputPath, outputContent, 'utf-8');
+        featureCache[relativePath] = currentHash;
+        console.log(`📄 Preprocessed (no Examples): ${outputPath}`);
+        return;
+    }
+    // Has Examples with data
+    console.log("✔ Should generate examples (this line will NOT show if the block above returns)");
+    const ext = path_1.default.extname(dataFile).toLowerCase();
+    const rows = [];
+    const buildExamplesFile = () => {
+        if (rows.length === 0) {
+            console.log(`❌ No matching rows found in ${dataFile}`);
+            fs_1.default.writeFileSync(outputPath, featureText, 'utf-8');
+            featureCache[relativePath] = currentHash;
+            return;
+        }
+        const headers = Object.keys(rows[0]); // Include all headers including _ENV, _STATUS etc.
+        const examples = ['Examples:', `  | ${headers.join(' | ')} |`]
+            .concat(rows.map(r => {
+            const rowData = headers.map(h => r[h] || '');
+            return `  | ${rowData.join(' | ')} |`;
+        }));
+        const outputLines = [
+            ...lines.slice(0, exampleLineIndex),
+            ...examples,
+            ...lines.slice(exampleLineIndex + 1),
+        ];
+        // Expand Step Groups before processing Examples
+        const expandedLines = expandStepGroups(outputLines, inputPath, stepGroupCache);
+        // Rebuild Examples only after step groups are expanded
+        const finalLines = expandedLines.join('\n');
+        fs_1.default.writeFileSync(outputPath, finalLines, 'utf-8');
+        featureCache[relativePath] = currentHash;
+        console.log(`✅ Processed: ${outputPath}`);
+    };
+    if (ext === '.csv') {
+        fs_1.default.createReadStream(fullPath)
+            .pipe((0, csv_parser_1.default)())
+            .on('data', (row) => {
+            try {
+                if (eval(substituteFilter(filter, row))) {
+                    rows.push(row);
+                }
+            }
+            catch (e) {
+                console.warn(`⚠️ Skipping row due to filter error: ${e.message}`);
+            }
+        })
+            .on('end', buildExamplesFile);
+    }
+    else if (ext === '.xlsx') {
+        const workbook = xlsx_1.default.readFile(fullPath);
+        const sheet = sheetName || workbook.SheetNames[0];
+        const sheetData = xlsx_1.default.utils.sheet_to_json(workbook.Sheets[sheet]);
+        sheetData.forEach((row) => {
+            try {
+                if (eval(substituteFilter(filter, row))) {
+                    rows.push(row);
+                }
+            }
+            catch (e) {
+                console.warn(`⚠️ Skipping row due to filter error: ${e.message}`);
+            }
+        });
+        buildExamplesFile();
+    }
+    else {
+        console.error(`❌ Unsupported file type: ${ext}`);
+        fs_1.default.writeFileSync(outputPath, featureText, 'utf-8');
+        featureCache[relativePath] = currentHash;
+    }
+}
+function run() {
+    console.log("🔄 Generating step group definitions from sgGenerator...");
+    (0, sgGenerator_1.generateStepGroups)({ force: isForced }); // Regenerate stepGroup_steps.ts before preprocessing
+    // if (fs.existsSync(outputDir)) {
+    //   fs.rmSync(outputDir, { recursive: true, force: true });
+    // }
+    fs_1.default.mkdirSync(outputDir, { recursive: true });
+    // Load step group cache once
+    const stepGroupCache = loadStepGroupCache();
+    const stepGroupCacheHash = sha256(JSON.stringify(stepGroupCache));
+    const features = findFeatureFiles(sourceDir);
+    if (!features.length) {
+        console.log('No feature files found.');
+        return;
+    }
+    features.forEach(featurePath => {
+        // Skip the step group directory
+        if (featurePath.includes('_step_group') || featurePath.includes('step_group')) {
+            console.log(`🛑 Skipping step group directory: ${featurePath}`);
+            return;
+        }
+        const outPath = ensureOutputPath(featurePath);
+        preprocessFeatureFile(featurePath, outPath, stepGroupCache, stepGroupCacheHash);
+    });
+    // Save the feature cache at the end
+    fs_1.default.mkdirSync(path_1.default.dirname(featureCachePath), { recursive: true });
+    fs_1.default.writeFileSync(featureCachePath, JSON.stringify(featureCache, null, 2), 'utf8');
+}
+function expandStepGroups(lines, inputPath, stepGroupCache) {
+    return lines.flatMap(line => {
+        // const match = line.trim().match(/^\* Step Group: -([a-zA-Z0-9_.]+)-/);
+        const match = line.trim().match(/^(?:\*|Given|When|Then|And|But) Step Group: -([a-zA-Z0-9_.]+)-/);
+        if (match) {
+            const groupName = match[1];
+            const group = stepGroupCache[groupName];
+            if (!group) {
+                console.error(`❌ Step Group not found: ${groupName} (in ${inputPath})`);
+                process.exit(1);
+            }
+            return [
+                `* - Step Group - START: "${groupName}" Desc: "${group.description}"`,
+                ...group.steps.map(step => `  ${step}`),
+                `* - Step Group - END: "${groupName}"`
+            ];
+        }
+        return [line];
+    });
+}
+run();

package/dist/exec/runner.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/exec/runner.js

@@ -0,0 +1,221 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const env_1 = require("../helper/bundle/env");
+const path_1 = __importDefault(require("path"));
+// Note: remove stray invalid import; runner does not need faker
+// loadEnv();
+// console.log('  - Runner (PLAYQ_ENV):', process.env.PLAYQ_ENV );
+// console.log('  - Runner (PLAYQ_RUNNER):', process.env.PLAYQ_RUNNER );
+// console.log('  - Runner (PLAYQ_GREP):', process.env.PLAYQ_GREP );
+// console.log('  - Runner (PLAYQ_TAGS):', process.env.PLAYQ_TAGS );
+// console.log('  - Runner (PLAYQ_PROJECT):', process.env.PLAYQ_PROJECT );
+// console.log('  - Env (RUNNER - cc_card_type):', process.env['cc_card_type']);
+// console.log('  - Env (RUNNER - config.testExecution.timeout):', process.env['config.testExecution.timeout'] );
+if (process.env.PLAYQ_RUNNER && process.env.PLAYQ_RUNNER === 'cucumber') {
+    // Allow vars to initialize in the cucumber child process (do NOT set PLAYQ_NO_INIT_VARS here)
+    // Ensure legacy TEST_RUNNER flag used by helper code is set
+    process.env.TEST_RUNNER = 'cucumber';
+    // Provide a default browser type if none supplied via config/env
+    if (!process.env['PLAYQ__browser__browserType'] && !process.env['browser.browserType']) {
+        process.env.PLAYQ__browser__browserType = 'chromium';
+    }
+    (0, env_1.loadEnv)();
+    const cucumberArgs = [
+        'cucumber-js',
+        '--config',
+        'cucumber.js',
+        '--profile',
+        'default',
+    ];
+    if (process.env.PLAYQ_TAGS)
+        cucumberArgs.push('--tags', process.env.PLAYQ_TAGS);
+    const run = (0, child_process_1.spawn)('npx', cucumberArgs, {
+        stdio: 'inherit',
+        env: { ...process.env },
+        shell: true,
+    });
+    run.on('close', (code) => {
+        try {
+            const pkgPath = path_1.default.resolve(process.cwd(), 'package.json');
+            const pkg = require(pkgPath);
+            if (pkg.scripts && pkg.scripts['posttest:cucumber']) {
+                (0, child_process_1.execSync)('npm run posttest:cucumber', { stdio: 'inherit' });
+            }
+            else {
+                console.log('ℹ️ Skipping posttest:cucumber (script not defined)');
+            }
+        }
+        catch (err) {
+            console.log('ℹ️ Posttest check failed, continuing:', (err === null || err === void 0 ? void 0 : err.message) || err);
+        }
+        process.exit(code);
+    });
+}
+else {
+    if (process.env.PLAYQ_RUN_CONFIG) {
+        // Dynamically import the run_config object from the specified run config file
+        // Look for run config in the user's project root
+        const runConfigPath = path_1.default.resolve(process.cwd(), `resources/run-configs/${process.env.PLAYQ_RUN_CONFIG}.run`);
+        const runConfig = require(runConfigPath).default;
+        console.log('🌐 Running with runConfig:', JSON.stringify(runConfig));
+        for (const cfg of runConfig.runs) {
+            console.log(`    - Running test with grep: ${cfg.PLAYQ_GREP}, env: ${cfg.PLAYQ_ENV}`);
+            Object.keys(cfg).forEach(key => {
+                if (key.trim() == 'PLAYQ_RUNNER')
+                    throw new Error('PLAYQ_RUNNER is not allowed in run configs');
+                process.env[key] = cfg[key];
+                console.log(`Setting ${key} = ${cfg[key]}`);
+            });
+            process.env.PLAYQ_NO_INIT_VARS = '1';
+            (0, env_1.loadEnv)();
+            const command = `npx playwright test --config=playq/config/playwright/playwright.config.js${process.env.PLAYQ_GREP ? ` --grep="${process.env.PLAYQ_GREP}"` : ''}${process.env.PLAYQ_PROJECT ? ` --project="${process.env.PLAYQ_PROJECT}"` : ''}`;
+            const childEnv = { ...process.env };
+            // Ensure child initializes vars by removing the parent-side guard
+            delete childEnv.PLAYQ_NO_INIT_VARS;
+            const preload = '-r ts-node/register';
+            childEnv.NODE_OPTIONS = childEnv.NODE_OPTIONS
+                ? `${childEnv.NODE_OPTIONS} ${preload}`
+                : preload;
+            // Ensure core and project roots propagate to child
+            if (!childEnv.PLAYQ_CORE_ROOT)
+                childEnv.PLAYQ_CORE_ROOT = path_1.default.resolve(__dirname, '..');
+            if (!childEnv.PLAYQ_PROJECT_ROOT)
+                childEnv.PLAYQ_PROJECT_ROOT = process.cwd();
+            // Point ts-node to the project's tsconfig for path aliases
+            const projectTsConfig = path_1.default.resolve(process.cwd(), 'tsconfig.json');
+            childEnv.TS_NODE_PROJECT = projectTsConfig;
+            childEnv.TS_NODE_TRANSPILE_ONLY = childEnv.TS_NODE_TRANSPILE_ONLY || 'true';
+            const result = (0, child_process_1.spawnSync)(command, {
+                stdio: 'inherit',
+                shell: true,
+                env: childEnv,
+            });
+        }
+    }
+    else {
+        process.env.PLAYQ_NO_INIT_VARS = '1';
+        (0, env_1.loadEnv)();
+        const command = `npx playwright test --config=playq/config/playwright/playwright.config.js${process.env.PLAYQ_GREP ? ` --grep="${process.env.PLAYQ_GREP}"` : ''}${process.env.PLAYQ_PROJECT ? ` --project="${process.env.PLAYQ_PROJECT}"` : ''}`;
+        const childEnv = { ...process.env };
+        // Ensure child initializes vars by removing the parent-side guard
+        delete childEnv.PLAYQ_NO_INIT_VARS;
+        const preload = '-r ts-node/register';
+        childEnv.NODE_OPTIONS = childEnv.NODE_OPTIONS
+            ? `${childEnv.NODE_OPTIONS} ${preload}`
+            : preload;
+        // Ensure core and project roots propagate to child
+        if (!childEnv.PLAYQ_CORE_ROOT)
+            childEnv.PLAYQ_CORE_ROOT = path_1.default.resolve(__dirname, '..');
+        if (!childEnv.PLAYQ_PROJECT_ROOT)
+            childEnv.PLAYQ_PROJECT_ROOT = process.cwd();
+        // Point ts-node to the project's tsconfig for path aliases
+        const projectTsConfig = path_1.default.resolve(process.cwd(), 'tsconfig.json');
+        childEnv.TS_NODE_PROJECT = projectTsConfig;
+        childEnv.TS_NODE_TRANSPILE_ONLY = childEnv.TS_NODE_TRANSPILE_ONLY || 'true';
+        const result = (0, child_process_1.spawnSync)(command, {
+            stdio: 'inherit',
+            shell: true,
+            env: childEnv,
+        });
+    }
+}
+// console.log('  - Runner (PLAYQ_ENV):', process.env.PLAYQ_ENV );
+// console.log('  - Runner (PLAYQ_RUNNER):', process.env.PLAYQ_RUNNER );
+// console.log('  - Runner (PLAYQ_GREP):', process.env.PLAYQ_GREP );
+// console.log('  - Runner (PLAYQ_TAGS):', process.env.PLAYQ_TAGS );
+// console.log('  - Runner (PLAYQ_PROJECT):', process.env.PLAYQ_PROJECT );
+// console.log('  - Env (RUNNER - cc_card_type):', process.env.cc_card_type );
+// let runner = 'playwright';
+// let env = '';
+// let grep = '';
+// let tags = '';
+// let prj = '';
+// console.log('🌐 os.platform():', os.platform());
+// // Use minimist for all platforms for consistency
+// const args = minimist(process.argv.slice(2));
+// // Try npm_config_* first (for npm script context), then fall back to minimist
+// grep = process.env.npm_config_grep || args.grep || '';
+// env = process.env.npm_config_env || args.env || '';
+// tags = process.env.npm_config_tags || args.tags || '';
+// prj = process.env.npm_config_project || args.project || '';
+// runner = ['cucumber', 'bdd', 'cuke'].includes(
+//   (process.env.npm_config_runner || args.runner || '').toLowerCase()
+// )
+//   ? 'cucumber'
+//   : 'playwright';
+// console.log('🌐 grep:', grep);
+// console.log('🌐 env:', env);
+// console.log('🌐 tags:', tags);
+// console.log('🌐 prj:', prj);
+// console.log('🌐 runner:', runner);
+// // Debug information
+// console.log('🔍 Debug - process.argv:', process.argv);
+// console.log('🔍 Debug - minimist args:', args);
+// console.log('🔍 Debug - npm_config_env:', process.env.npm_config_env);
+// console.log('🔍 Debug - npm_config_grep:', process.env.npm_config_grep);
+// process.env.TS_NODE_PROJECT = './tsconfig.json';
+// require('tsconfig-paths').register();
+// console.log('🌐 Running tests with args:', process.argv);
+// console.log(process.platform);
+// console.log(process.env.npm_config_env);
+// process.env.TEST_RUNNER = runner;
+// if (tags) process.env.TAGS = tags;
+// if (grep) process.env.GREP = grep;
+// if (prj) process.env.PROJECT = prj;
+// if (env) {
+//   process.env.RUN_ENV = env;
+//   loadEnv(env);
+// }
+// if (runner === 'cucumber') {
+//   execSync('npm run pretest:cucumber', { stdio: 'inherit' });
+//   const cucumberArgs = [
+//     'cucumber-js',
+//     '--config',
+//     'cucumber.js',
+//     '--profile',
+//     'default',
+//   ];
+//   if (tags) cucumberArgs.push('--tags', tags);
+//   console.log(`🚀 Running Cucumber with args: ${cucumberArgs.join(' ')}`);
+//   console.log('📦 Final Cucumber command:', `npx ${cucumberArgs.join(' ')}`);
+//   const run = spawn('npx', cucumberArgs, {
+//     stdio: 'inherit',
+//     env: { ...process.env, RUN_ENV: env, PROJECT: prj },
+//     shell: true,
+//   });
+//   run.on('close', (code) => {
+//     execSync('npm run posttest:cucumber', { stdio: 'inherit' });
+//     process.exit(code);
+//   });
+// } else if (runner === 'playwright') {
+//   try {
+//     execSync('npm run pretest:playwright', { stdio: 'inherit' });
+//   } catch (error) {
+//     console.log(
+//       '⚠️  Pre-test cleanup had some issues, but continuing with tests...'
+//     );
+//   }
+//   const command = `npx playwright test --config=config/playwright/playwright.config.ts${
+//     grep ? ` --grep='${grep}'` : ''
+//   }${prj ? ` --project=${prj}` : ''}`;
+//   const result = spawnSync(command, {
+//     stdio: 'inherit',
+//     shell: true,
+//     env: { ...process.env, RUN_ENV: env, PROJECT: prj },
+//   });
+//   try {
+//     execSync('npm run posttest:playwright', { stdio: 'inherit' });
+//   } catch (error) {
+//     console.log(
+//       '⚠️  Post-test reporting had some issues, but test execution completed.'
+//     );
+//   }
+//   process.exit(result.status || 0);
+// } else {
+//   console.error(`❌ Unknown runner: ${runner}`);
+//   process.exit(1);
+// }

package/dist/exec/runner_orchestrator.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/exec/runner_orchestrator.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const child_process_2 = require("child_process");
+const yargs_1 = __importDefault(require("yargs"));
+const args = (0, yargs_1.default)(process.argv).argv;
+const runnerName = args.runner;
+if (!runnerName) {
+    console.error('❌ Missing --runner=<name>');
+    process.exit(1);
+}
+const runnerPath = path_1.default.resolve(`./resources/runners/${runnerName}.run.json`);
+if (!fs_1.default.existsSync(runnerPath)) {
+    console.error(`❌ Runner file not found: ${runnerPath}`);
+    process.exit(1);
+}
+const runnerConfig = JSON.parse(fs_1.default.readFileSync(runnerPath, 'utf-8'));
+const { runType, runs } = runnerConfig;
+(0, child_process_2.execSync)('npm run pretest:playwright', { stdio: 'inherit' });
+async function runOneTest(config) {
+    const env = config.env ? config.env : '';
+    const grep = config.grep ? `--grep="${config.grep}"` : '';
+    //   const env = config.env ? `--env="${config.env}"` : '';
+    const prj = config.project ? `--project=${config.project}"` : '';
+    const command = `npx playwright test --config=config/playwright/playwright.config.js ${grep} ${prj}`;
+    console.log(`🔹 Running: ${command}`);
+    const result = (0, child_process_1.spawnSync)(command, {
+        stdio: 'inherit',
+        shell: true,
+        env: { ...process.env, TEST_RUNNER: "playwright", RUN_ENV: env }
+        // env: { ...process.env }
+    });
+    if (result.status !== 0) {
+        console.error(`❌ Test failed: ${grep}`);
+        process.exit(result.status);
+    }
+}
+async function runTests() {
+    if (runType === 'sequential') {
+        for (const run of runs) {
+            await runOneTest(run);
+        }
+    }
+    else if (runType === 'parallel') {
+        const promises = runs.map(run => new Promise((resolve, reject) => {
+            const env = run.env ? run.env : '';
+            const grep = run.grep ? `--grep="${run.grep}"` : '';
+            // const env = run.env ? `--env="${run.env}"` : '';
+            const prj = run.project ? `--project=${run.project}"` : '';
+            const command = `npx playwright test --config=config/playwright/playwright.config.js ${grep} ${prj}`;
+            const proc = (0, child_process_1.spawnSync)(command, {
+                stdio: 'inherit',
+                shell: true,
+                env: { ...process.env, TEST_RUNNER: "playwright", RUN_ENV: env }
+            });
+            if (proc.status !== 0) {
+                reject(new Error(`Failed: ${command}`));
+            }
+            else {
+                resolve(true);
+            }
+        }));
+        try {
+            await Promise.all(promises);
+        }
+        catch (err) {
+            console.error('❌ One or more test batches failed.');
+            process.exit(1);
+        }
+    }
+    else {
+        console.error(`❌ Unknown runType: ${runType}`);
+        process.exit(1);
+    }
+}
+runTests().then(() => {
+    (0, child_process_2.execSync)('npm run posttest:playwright', { stdio: 'inherit' });
+    console.log('✅ All test runs completed.');
+    process.exit(0);
+});

package/dist/exec/sgGenerator.d.ts

@@ -0,0 +1,11 @@
+type StepGroup = {
+    name: string;
+    description: string;
+    steps: string[];
+};
+export declare function extractStepGroups(fileContent: string, filename: string): StepGroup[];
+declare function generateStepGroups(options?: {
+    force?: boolean;
+}): void;
+export { generateStepGroups };
+export declare function generateStepGroupsIfNeeded(force?: boolean): void;