@playq/core 0.2.77

package/README.md

@@ -0,0 +1,41 @@
+# @playq/core (Alpha)
+
+Unified Playwright + Cucumber test runner and engine registry.
+
+## Quick Start
+```bash
+npm install @playq/core @playwright/test @cucumber/cucumber --save-dev
+npx playq util versions
+npx playq test               # runs Playwright specs by default
+npx playq test --cucumber    # runs Cucumber features
+```
+
+## Config Resolution
+Looks for `playq.config.(js|cjs|mjs|json)` in project root, merges with internal defaults, then applies env overrides like:
+```
+PLAYQ__browser__browserType=firefox
+PLAYQ__testExecution__parallel=true
+```
+
+## CLI Commands
+- `playq test [--cucumber] [--parallel N] [--grep pattern] [--tags expr]`
+- `playq util versions`
+- `playq report allure --open` (placeholder)
+- `playq init` (placeholder)
+
+## Engine API
+```ts
+import { registerEngine } from '@playq/core';
+registerEngine({ id: 'myEngine', init: async () => {/*...*/} });
+```
+
+## Environment Overrides
+Prefixed with `PLAYQ__` and mapped by `__` segments to nested config keys.
+
+## Roadmap
+- Implement real init scaffolder
+- Add allure integration
+- External engine auto-discovery
+- Hook system exposure
+
+Alpha: APIs may change.

package/bin/playq.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+// Lightweight CLI wrapper: maps flags to PLAYQ_* env vars and invokes compiled runner.js
+
+
+const minimist = require('minimist');
+const path = require('path');
+const fs = require('fs');
+
+// Version flag support
+if (process.argv.includes('--version') || process.argv.includes('-v')) {
+  const pkgPath = path.join(__dirname, '../package.json');
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+  console.log(pkg.version);
+  process.exit(0);
+}
+
+
+// If first argument is 'util' and -h/--help/help is present, print help and exit
+if (process.argv[2] === 'util' && (process.argv.includes('--help') || process.argv.includes('-h') || process.argv.includes('help'))) {
+  console.log(`PlayQ CLI - util
+Usage: playq util [options]
+
+Description:
+  Interactive utility for various PlayQ operations including encryption, 
+  decryption, key generation, TOTP codes, and API schema generation.
+
+Options:
+  --help     | -h     Show help
+
+Available Utilities:
+  1. Password Encryption    - Encrypt passwords using strong encryption
+  2. Text Encryption       - Encrypt any text using strong encryption  
+  3. Decryption           - Decrypt previously encrypted values
+  4. Generate 32bit Key   - Generate cryptographic keys for encryption
+  5. Generate TOTP Code   - Generate time-based one-time passwords
+  6. Generate API Schema  - Generate TypeScript schemas from OpenAPI specs
+  
+Examples:
+  npx playq util           # Launch interactive utility menu
+  npx playq util --help    # Show this help message
+`);
+  process.exit(0);
+}
+
+// If first argument is 'util', run the util script and exit
+if (process.argv[2] === 'util') {
+  const { spawnSync } = require('child_process');
+  const utilScript = path.join(__dirname, '../dist/scripts/util.js');
+  const result = spawnSync(process.execPath, [utilScript], { stdio: 'inherit' });
+  process.exit(result.status || 0);
+}
+
+
+// If first argument is 'generate' and -h/--help/help is present, print help and exit
+if (process.argv[2] === 'generate' && (process.argv.includes('--help') || process.argv.includes('-h') || process.argv.includes('help'))) {
+  console.log(`PlayQ CLI - generate
+Usage: playq generate [options]
+
+Options:
+  --stepgroup | -sg   Generate step group cache and step defs
+  --help     | -h     Show help
+
+Examples:
+  npx playq generate --stepgroup
+  npx playq generate -sg
+`);
+  process.exit(0);
+}
+
+// If first argument is 'generate' and --stepgroup or -sg is present, run the sgGenerator script and exit
+if (process.argv[2] === 'generate' && (process.argv.includes('--stepgroup') || process.argv.includes('-sg'))) {
+  const { spawnSync } = require('child_process');
+  const sgGenScript = path.join(__dirname, '../dist/exec/sgGenerator.js');
+  const result = spawnSync(process.execPath, [sgGenScript], { stdio: 'inherit' });
+  process.exit(result.status || 0);
+}
+
+
+// Only run test runner if 'test' subcommand is provided
+if (process.argv[2] === 'test') {
+
+  const args = minimist(process.argv.slice(3), {
+    string: ['grep', 'tags', 'runner', 'project', 'env', 'filter', 'key'],
+    alias: { g: 'grep', t: 'tags', r: 'runner', p: 'project', e: 'env', f: 'filter', k: 'key' }
+  });
+
+  // Support --key or -k for PLAYQ_SECRET_KEY
+  if (args.key) process.env.PLAYQ_SECRET_KEY = args.key;
+
+  if (args.grep) process.env.PLAYQ_GREP = args.grep;
+  if (args.tags) process.env.PLAYQ_TAGS = args.tags;
+  if (args.runner) process.env.PLAYQ_RUNNER = args.runner;
+  // Mirror to legacy TEST_RUNNER flag used by action helpers
+  if (args.runner) process.env.TEST_RUNNER = args.runner;
+  if (args.project) process.env.PLAYQ_PROJECT = args.project;
+  if (args.env) process.env.PLAYQ_ENV = args.env;
+
+  // --filter support: map to grep/tags based on runner
+  if (args.filter) {
+    const runner = args.runner || process.env.PLAYQ_RUNNER || 'playwright';
+    if (runner === 'cucumber') {
+      process.env.PLAYQ_TAGS = args.filter;
+    } else {
+      process.env.PLAYQ_GREP = args.filter;
+    }
+  }
+
+  // Provide defaults if not set
+  if (!process.env.PLAYQ_ENV) process.env.PLAYQ_ENV = 'default';
+  if (!process.env.PLAYQ_RUNNER) process.env.PLAYQ_RUNNER = 'playwright';
+  if (!process.env.TEST_RUNNER) process.env.TEST_RUNNER = process.env.PLAYQ_RUNNER;
+  // Core & project root hints for helpers
+  process.env.PLAYQ_CORE_ROOT = path.join(__dirname, '../dist');
+  process.env.PLAYQ_PROJECT_ROOT = process.cwd();
+
+  // Do NOT register ts-node or tsconfig-paths here; the test runner handles TypeScript via project config.
+
+  // Provide basic help for test subcommand
+  if (args.help || args.h) {
+    console.log(`PlayQ CLI (Phase 1)
+Usage: playq test [options]
+  --grep   | -g   Playwright grep filter
+  --tags   | -t   Cucumber tag expression
+  --filter | -f   Universal filter (maps to grep/tags by runner)
+  --runner | -r   playwright | cucumber (default playwright)
+  --project| -p   Playwright project name
+  --env    | -e   Environment name (mapped to PLAYQ_ENV)
+  --key    | -k   Secret key for crypto (sets PLAYQ_SECRET_KEY)
+
+  --help   | -h   Show help
+  --version| -v   Show PlayQ CLI version  
+
+Examples:
+  npx playq test --filter "Registration001"
+  npx playq test --filter "@smoke" --runner cucumber
+  npx playq test --grep "Registration001"
+  npx playq test --tags "@smoke" --runner cucumber
+  npx playq test --key "mysecret" --grep "Registration001"
+`);
+    process.exit(0);
+  }
+
+  const runnerJs = path.join(__dirname, '../dist/exec/runner.js');
+  require(runnerJs);
+}
+
+// Top-level help for all commands
+if (process.argv[2] === 'help' || process.argv[2] === '--help' || process.argv[2] === '-h' || !process.argv[2]) {
+  console.log(`PlayQ CLI (Phase 1)
+
+Usage: playq <command> [options]
+  --help   | -h   Show help
+  --version| -v   Show PlayQ CLI version
+
+Commands:
+  test                 Run PlayQ tests (Playwright or Cucumber)
+  util                 Run the PlayQ utility
+  generate --stepgroup | -sg   Generate step group cache and step defs
+
+For test options, run: npx playq test --help
+For util options, run: npx playq util --help
+For version, run: npx playq --version or npx playq -v
+
+Examples:
+  npx playq test --filter "Registration001"
+  npx playq test --filter "@smoke" --runner cucumber
+  npx playq test --grep "Registration001"
+  npx playq test --tags "@smoke" --runner cucumber
+  npx playq util
+  npx playq util --help
+  npx playq generate --stepgroup
+  npx playq generate -sg
+`);
+  process.exit(0);
+}

package/cucumber.js

@@ -0,0 +1,10 @@
+module.exports = {
+  default: {
+    formatOptions: { snippetInterface: 'async-await' },
+    paths: [ './test/features/**/*.feature' ],
+    dryRun: false,
+    require: [ './test/steps/**/*.js' ],
+    format: [ 'progress-bar' ],
+    parallel: 1
+  }
+};

package/dist/exec/featureFileCache.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Returns the path to the cached feature file inside _Temp/execution/
+ */
+export declare function getCachedFeatureFilePath(originalPath: string): string;
+/**
+ * Determines if the cached feature should be used.
+ * Checks:
+ *  - config.cucumber.featureFileCache is enabled
+ *  - cached file and metadata exist
+ *  - cached timestamp is newer than original file
+ */
+export declare function shouldUseCachedFeature(originalPath: string, cachedPath: string): boolean;
+/**
+ * Updates the feature cache metadata file.
+ * Ensures _Temp/.cache/featureMeta.json exists, and writes { filePath, updatedAt }.
+ */
+export declare function updateFeatureCacheMeta(originalPath: string, cachedPath: string): void;
+/**
+ * Writes feature content to cache if valid.
+ */
+export declare function writeFeatureToCache(cachedPath: string, content: string): void;

package/dist/exec/featureFileCache.js

@@ -0,0 +1,124 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCachedFeatureFilePath = getCachedFeatureFilePath;
+exports.shouldUseCachedFeature = shouldUseCachedFeature;
+exports.updateFeatureCacheMeta = updateFeatureCacheMeta;
+exports.writeFeatureToCache = writeFeatureToCache;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const vars = __importStar(require("../helper/bundle/vars"));
+const config = {};
+const FEATURE_META_PATH = path_1.default.resolve('_Temp/.cache/featureMeta.json');
+/**
+ * Returns the path to the cached feature file inside _Temp/execution/
+ */
+function getCachedFeatureFilePath(originalPath) {
+    const filename = path_1.default.basename(originalPath);
+    return path_1.default.resolve('_Temp/execution', filename);
+}
+/**
+ * Determines if the cached feature should be used.
+ * Checks:
+ *  - config.cucumber.featureFileCache is enabled
+ *  - cached file and metadata exist
+ *  - cached timestamp is newer than original file
+ */
+function shouldUseCachedFeature(originalPath, cachedPath) {
+    var _a;
+    // Logging for cache check
+    console.log(`🔍 Cache check started for: ${originalPath}`);
+    if (!((_a = config === null || config === void 0 ? void 0 : config.cucumber) === null || _a === void 0 ? void 0 : _a.featureFileCache) || vars.getConfigValue('cucumber.featureFileCache'))
+        return false;
+    if (!fs_1.default.existsSync(cachedPath))
+        return false;
+    if (!fs_1.default.existsSync(FEATURE_META_PATH))
+        return false;
+    try {
+        const meta = JSON.parse(fs_1.default.readFileSync(FEATURE_META_PATH, 'utf-8'));
+        const originalStats = fs_1.default.statSync(originalPath);
+        const cachedMeta = meta[originalPath];
+        console.log(`📄 Cached Meta:`, cachedMeta);
+        if (!cachedMeta)
+            return false;
+        const originalTime = originalStats.mtimeMs;
+        const metaTime = new Date(cachedMeta.updatedAt).getTime();
+        console.log(`📆 Original mtime: ${originalTime} | Cached updatedAt: ${metaTime}`);
+        console.log(`✅ Should use cache: ${metaTime >= originalTime}`);
+        return metaTime >= originalTime;
+    }
+    catch (err) {
+        console.warn(`⚠️ Cache check failed. Proceeding without cache.`, err);
+        return false;
+    }
+}
+/**
+ * Updates the feature cache metadata file.
+ * Ensures _Temp/.cache/featureMeta.json exists, and writes { filePath, updatedAt }.
+ */
+function updateFeatureCacheMeta(originalPath, cachedPath) {
+    const dir = path_1.default.dirname(FEATURE_META_PATH);
+    if (!fs_1.default.existsSync(dir)) {
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+    let meta = {};
+    if (fs_1.default.existsSync(FEATURE_META_PATH)) {
+        try {
+            meta = JSON.parse(fs_1.default.readFileSync(FEATURE_META_PATH, 'utf-8'));
+        }
+        catch {
+            console.warn('⚠️ Failed to parse featureMeta.json. Overwriting.');
+        }
+    }
+    meta[originalPath] = {
+        filePath: cachedPath,
+        updatedAt: new Date().toISOString()
+    };
+    fs_1.default.writeFileSync(FEATURE_META_PATH, JSON.stringify(meta, null, 2), 'utf-8');
+    console.log(`💾 Feature cache metadata updated for: ${originalPath}`);
+}
+/**
+ * Writes feature content to cache if valid.
+ */
+function writeFeatureToCache(cachedPath, content) {
+    if (!content.trim().startsWith('Feature')) {
+        console.warn(`❌ Skipping cache write: Content does not start with "Feature". Content preview:\n${content.substring(0, 100)}`);
+        return;
+    }
+    fs_1.default.writeFileSync(cachedPath, content, 'utf8');
+}

package/dist/exec/featureFilePreProcess.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Preprocesses a feature file using all transformation steps:
+ * - Variable replacement
+ * - Step group expansion
+ * - SmartIQ data injection
+ * - Tag injection
+ *
+ * @param srcFeaturePath Path to the source .feature file
+ * @returns Path to the preprocessed file (under _Temp/execution)
+ */
+export declare function preprocessFeatureFile(srcFeaturePath: string): string | undefined;
+export declare function expandStepGroups(featureText: string): string;

package/dist/exec/featureFilePreProcess.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preprocessFeatureFile = preprocessFeatureFile;
+exports.expandStepGroups = expandStepGroups;
+// Replace legacy '@playq' alias with local global exports
+const global_1 = require("../global");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const xlsx_1 = __importDefault(require("@e965/xlsx"));
+/**
+ * Preprocesses a feature file using all transformation steps:
+ * - Variable replacement
+ * - Step group expansion
+ * - SmartIQ data injection
+ * - Tag injection
+ *
+ * @param srcFeaturePath Path to the source .feature file
+ * @returns Path to the preprocessed file (under _Temp/execution)
+ */
+function preprocessFeatureFile(srcFeaturePath) {
+    var _a;
+    try {
+        const rawContent = fs_1.default.readFileSync(srcFeaturePath, "utf-8");
+        // Step 1: Replace variables like ${url}, ${user}
+        let processedContent = replaceVariablesInString(rawContent);
+        // Step 2: Replacing examples with data file and filter
+        processedContent = processExamplesWithFilter(processedContent); // <-- Add this
+        // Step 3: Expand Step Groups
+        processedContent = expandStepGroups(processedContent);
+        // Step 4: Inject SmartIQ data or resolve special steps
+        processedContent = processSmartData(processedContent);
+        // Step 5: Inject scenario-level tags if needed
+        processedContent = injectScenarioTag(processedContent, srcFeaturePath);
+        // Write processed file
+        const outputDir = path_1.default.join("_Temp/execution");
+        const relativePath = path_1.default.relative("tests/bdd/scenarios", srcFeaturePath);
+        const outputPath = path_1.default.join(outputDir, relativePath);
+        fs_1.default.mkdirSync(path_1.default.dirname(outputPath), { recursive: true });
+        fs_1.default.writeFileSync(outputPath, processedContent, "utf-8");
+        if (((_a = global_1.config === null || global_1.config === void 0 ? void 0 : global_1.config.cucumber) === null || _a === void 0 ? void 0 : _a.featureFileCache) || global_1.vars.getConfigValue('cucumber.featureFileCache')) {
+            const { updateFeatureCacheMeta } = require("./featureFileCache");
+            updateFeatureCacheMeta(srcFeaturePath, outputPath);
+        }
+        return outputPath;
+    }
+    catch (err) {
+        console.error(`❌ Error preprocessing feature file: ${err}`);
+        return undefined;
+    }
+}
+// 🔁 Placeholder replacement
+function replaceVariablesInString(content) {
+    return content.replace(/Examples\s*:\s*({[^}]*})/g, (match, jsonPart) => {
+        const replaced = jsonPart.replace(/\${env\.([\w]+)}/g, (_, key) => {
+            const val = process.env[key] || "";
+            console.log(`🔄 Replacing variable env.${key} -> ${val}`);
+            return val;
+        });
+        return `Examples:${replaced}`;
+    });
+}
+// 🔁 Expand Step Groups
+function expandStepGroups(featureText) {
+    const cachePath = path_1.default.join("_Temp", ".cache", "stepGroup_cache.json");
+    if (!fs_1.default.existsSync(cachePath)) {
+        console.warn(`⚠️ Step group cache not found at ${cachePath}`);
+        return featureText;
+    }
+    const stepGroupCache = JSON.parse(fs_1.default.readFileSync(cachePath, "utf8"));
+    const stepGroupRegex = /^\s*\*\s*Step\s*Group:\s*-(.+?)-\s*-(.+?)-\s*$/gm;
+    const updatedText = featureText.replace(stepGroupRegex, (_match, groupIdRaw, groupDescRaw) => {
+        const groupId = groupIdRaw.trim();
+        const groupDesc = groupDescRaw.trim();
+        const cachedGroup = stepGroupCache[groupId];
+        if (!cachedGroup || !Array.isArray(cachedGroup.steps)) {
+            console.warn(`❌ Step group "${groupId}" not found or steps invalid`);
+            return _match;
+        }
+        const steps = cachedGroup.steps.join("\n");
+        const replacement = [
+            `\n* - Step Group - START: "${groupId}" Desc: "${groupDesc}"`,
+            steps,
+            `* - Step Group - END: "${groupId}"`,
+        ].join("\n");
+        return replacement;
+    });
+    return updatedText;
+}
+// 🔁 Process Smart Data (e.g., inject data-driven values or SmartIQ rules)
+function processSmartData(content) {
+    // Example: Replace [[SMART:...]] with resolved steps
+    return content.replace(/\[\[SMART:(.*?)\]\]/g, (_, expr) => {
+        console.log(`🧠 Processing SMART: ${expr}`);
+        return `# Processed SMART step: ${expr}`;
+    });
+}
+// 🔁 Inject scenario-level tags
+function injectScenarioTag(content, filePath) {
+    const tag = `@file(${path_1.default.basename(filePath)})`;
+    const lines = content.split("\n");
+    const processedLines = lines.map((line, i) => {
+        if (line.trim().startsWith("Scenario") &&
+            (i === 0 || !lines[i - 1].trim().startsWith("@"))) {
+            return `${tag}\n${line}`;
+        }
+        return line;
+    });
+    return processedLines.join("\n");
+}
+function processExamplesWithFilter(content, dataDir = "test-data") {
+    return content.replace(/(^|\n)\s*Examples\s*:?\s*({[^}]*})/g, (match, prefix, jsonStr) => {
+        console.log(`🔄 FOUND Examples block: [${jsonStr}]`);
+        console.log(`🔄 Preprocessing feature == MATCH == file: ${match}`);
+        console.log(`🔄 Preprocessing feature == MATCH END == file:`);
+        console.log(`🔄 Preprocessing feature == PREFIX == file: ${prefix}`);
+        console.log(`🔄 Preprocessing feature == jsonStr == file: ${jsonStr}`);
+        const obj = JSON.parse(jsonStr.replace(/'/g, '"'));
+        const normalized = {};
+        for (const [k, v] of Object.entries(obj)) {
+            normalized[k.toLowerCase()] = v;
+        }
+        const dataFile = normalized["datafile"];
+        const filter = normalized["filter"];
+        const sheetName = normalized["sheetname"];
+        console.log(`🔄 Preprocessing feature == dataFile == file: ${dataFile}`);
+        console.log(`🔄 Preprocessing feature == filter == file: ${filter}`);
+        console.log(`🔄 Preprocessing feature == sheetName == file: ${sheetName}`);
+        const fullPath = path_1.default.join(dataDir, path_1.default.basename(dataFile || ""));
+        const ext = path_1.default.extname(fullPath).toLowerCase();
+        console.log(`🔄 Preprocessing feature == FULL PATH == file: ${fullPath}`);
+        console.log(`🔄 Preprocessing feature == EXT == file: ${ext}`);
+        if (!fs_1.default.existsSync(fullPath))
+            return match;
+        const isNumeric = (val) => typeof val === "string" && val.trim() !== "" && !isNaN(Number(val));
+        const substituteFilter = (filter, row) => filter.replace(/\b[_a-zA-Z][_a-zA-Z0-9]*\b/g, (key) => {
+            var _a;
+            const raw = (_a = row[key]) !== null && _a !== void 0 ? _a : row[`_${key}`];
+            if (raw === undefined)
+                return key;
+            return isNumeric(raw) ? raw.trim() : JSON.stringify(raw);
+        });
+        let rows = [];
+        console.log(`🔍 Checking file existence: fullPath='${fullPath}'`);
+        if (!fs_1.default.existsSync(fullPath)) {
+            console.error(`❌ File not found: ${fullPath}`);
+            return match;
+        }
+        if (ext === ".xlsx") {
+            console.log(`✔️ File found: ${fullPath}, now reading with xlsx`);
+            const workbook = xlsx_1.default.readFile(fullPath);
+            console.log(`📄 Workbook sheets: ${workbook.SheetNames.join(", ")}`);
+            const sheet = sheetName || workbook.SheetNames[0];
+            console.log(`📋 Using sheet: ${sheet}`);
+            const sheetData = xlsx_1.default.utils.sheet_to_json(workbook.Sheets[sheet]);
+            console.log(`🔢 Read ${sheetData.length} rows from sheet`);
+            rows = sheetData.filter((row) => {
+                try {
+                    console.log("🔍 Row raw:", row);
+                    return eval(substituteFilter(filter, row));
+                }
+                catch {
+                    console.warn("⚠️ Row filter error, skipping.");
+                    return false;
+                }
+            });
+        }
+        else if (ext === ".csv") {
+            console.log(`📋 ENTER CSV:`);
+            const csvData = fs_1.default.readFileSync(fullPath, "utf-8").split("\n");
+            console.log(`📋 Using csvData: ${csvData}`);
+            const headers = csvData[0].split(",").map((h) => h.trim());
+            console.log(`📋 Using headers: ${headers}`);
+            for (let i = 1; i < csvData.length; i++) {
+                const values = csvData[i].split(",");
+                if (values.length !== headers.length)
+                    continue;
+                const row = {};
+                headers.forEach((h, j) => {
+                    var _a;
+                    row[h] = (_a = values[j]) === null || _a === void 0 ? void 0 : _a.trim();
+                });
+                try {
+                    if (eval(substituteFilter(filter, row)))
+                        rows.push(row);
+                }
+                catch { }
+            }
+        }
+        else {
+            return match; // unsupported file
+        }
+        console.log(`🔍 Filtered row count: ${rows.length}`);
+        if (!rows.length) {
+            console.error(`❌ No matching rows found. Returning fallback Examples block.`);
+            throw new Error(`❌ No matching rows found. Returning fallback Examples block.`);
+        }
+        const headers = Object.keys(rows[0]);
+        const lines = ["\n\nExamples:", `  | ${headers.join(" | ")} |`];
+        for (const r of rows) {
+            const rowLine = `  | ${headers.map((h) => r[h] || "").join(" | ")} |`;
+            lines.push(rowLine);
+        }
+        return lines.join("\n");
+    });
+}

package/dist/exec/preLoader.d.ts

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

package/dist/exec/preLoader.js

@@ -0,0 +1,72 @@
+"use strict";
+// // Replaced legacy '@playq' alias import with direct relative import from public globals
+// import { config, vars } from "../global";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+// // Loading D365 CRM pattern
+// const d365CrmEnable = config?.addons?.d365Crm?.enable || vars.getConfigValue('addons.d365Crm.enable').toLowerCase().trim() === 'true';
+// const d365CrmVersion = config?.addons?.d365Crm?.version || vars.getConfigValue('addons.d365Crm.version').toLowerCase().trim();
+// // Updated: Look for D365 pattern in playq/addons/d365Crm/pattern/ (new path)
+// if (d365CrmEnable && d365CrmVersion.startsWith("v")) vars.loadFileEntries(`playq/addons/d365Crm/pattern/d365CrmPattern_${d365CrmVersion}.ts`, "d365CrmLocPatterns", "pattern.d365crm");
+const global_1 = require("../global");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+// Use minimal addons.json for discovery, config for logic
+const projectRoot = process.env.PLAYQ_PROJECT_ROOT || process.cwd();
+const addonsJsonPath = path_1.default.join(projectRoot, "playq", "addons", "addons.json");
+let addonList = [];
+try {
+    const raw = fs_1.default.readFileSync(addonsJsonPath, "utf-8");
+    addonList = JSON.parse(raw);
+}
+catch (e) {
+    console.warn("No addons.json found or failed to load:", e);
+}
+for (const addon of addonList) {
+    console.log("[PLAYQ DEBUG] Processing addon:", addon.name);
+    const addonKey = addon.name;
+    let configEntry = (_a = global_1.config === null || global_1.config === void 0 ? void 0 : global_1.config.addons) === null || _a === void 0 ? void 0 : _a[addonKey];
+    let enabled = false;
+    let version = "";
+    // Debug: print configEntry and its type
+    console.log(`[PLAYQ DEBUG] configEntry for ${addonKey}:`, configEntry, 'type:', typeof configEntry);
+    console.log("[PLAYQ DEBUG] config object:", global_1.config);
+    if (configEntry && typeof configEntry === 'object') {
+        enabled = configEntry.enable === true || String(configEntry.enable).toLowerCase() === "true";
+        version = configEntry.version || "";
+        console.log(`[PLAYQ DEBUG] (object) enabled:`, enabled, 'version:', version);
+    }
+    else {
+        // Use vars.getConfigValue for enable/version as string
+        const enableStr = String(global_1.vars.getConfigValue(`addons.${addonKey}.enable`)).toLowerCase().trim();
+        const versionStr = String(global_1.vars.getConfigValue(`addons.${addonKey}.version`)).toLowerCase().trim();
+        enabled = enableStr === 'true';
+        version = versionStr;
+        console.log(`[PLAYQ DEBUG] (vars) enableStr:`, enableStr, 'versionStr:', versionStr);
+    }
+    console.log("[PLAYQ DEBUG] Before if condition addon:", enabled, " >> ", version);
+    if (enabled && version.startsWith("v")) {
+        console.log("[PLAYQ DEBUG] After if condition addon:", enabled, " >> ", version);
+        try {
+            global_1.vars.loadFileEntries(`playq/addons/${addonKey}/pattern/${addonKey}Pattern_${version}.ts`, `${addonKey}LocPatterns`, `pattern.${addonKey.toLowerCase()}`);
+        }
+        catch (e) {
+            console.warn(`Pattern file for ${addonKey} not found or failed to load:`, e);
+        }
+        // Prefer .js if exists, else .ts
+        // const basePatternPath = path.join(projectRoot, "playq", "addons", addonKey, "pattern", `${addonKey}Pattern_${version}`);
+        // let patternPath = basePatternPath + ".js";
+        // if (!fs.existsSync(patternPath)) {
+        //   patternPath = basePatternPath + ".ts";
+        // }
+        // try {
+        //   vars.loadFileEntries(patternPath, `${addonKey}LocPatterns`, `pattern.${addonKey.toLowerCase()}`);
+        // } catch (e) {
+        //   console.warn(`Pattern file for ${addonKey} not found or failed to load:`, e);
+        // }
+        // Optionally, perform other addon-specific initialization here
+    }
+}

package/dist/exec/preProcessEntry.d.ts

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