@playq/core 0.2.77

package/src/exec/featureFilePreProcess.ts

@@ -0,0 +1,239 @@
+// Replace legacy '@playq' alias with local global exports
+import { config, vars } from "../global";
+import fs from "fs";
+import path from "path";
+import xlsx from "@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)
+ */
+export function preprocessFeatureFile(
+  srcFeaturePath: string
+): string | undefined {
+  try {
+    const rawContent = fs.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.join("_Temp/execution");
+    const relativePath = path.relative("tests/bdd/scenarios", srcFeaturePath);
+    const outputPath = path.join(outputDir, relativePath);
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, processedContent, "utf-8");
+    if (config?.cucumber?.featureFileCache || 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: string): string {
+  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
+
+export function expandStepGroups(featureText: string): string {
+  const cachePath = path.join("_Temp", ".cache", "stepGroup_cache.json");
+  if (!fs.existsSync(cachePath)) {
+    console.warn(`⚠️ Step group cache not found at ${cachePath}`);
+    return featureText;
+  }
+
+  const stepGroupCache = JSON.parse(fs.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: string): string {
+  // 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: string, filePath: string): string {
+  const tag = `@file(${path.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: string,
+  dataDir = "test-data"
+): string {
+  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: Record<string, any> = {};
+      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.join(dataDir, path.basename(dataFile || ""));
+      const ext = path.extname(fullPath).toLowerCase();
+      console.log(`🔄 Preprocessing feature == FULL PATH == file: ${fullPath}`);
+      console.log(`🔄 Preprocessing feature == EXT == file: ${ext}`);
+
+      if (!fs.existsSync(fullPath)) return match;
+
+      const isNumeric = (val: any) =>
+        typeof val === "string" && val.trim() !== "" && !isNaN(Number(val));
+      const substituteFilter = (filter: string, row: Record<string, any>) =>
+        filter.replace(/\b[_a-zA-Z][_a-zA-Z0-9]*\b/g, (key) => {
+          const raw = row[key] ?? row[`_${key}`];
+          if (raw === undefined) return key;
+          return isNumeric(raw) ? raw.trim() : JSON.stringify(raw);
+        });
+
+      let rows: Record<string, any>[] = [];
+      console.log(`🔍 Checking file existence: fullPath='${fullPath}'`);
+      if (!fs.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.readFile(fullPath);
+        console.log(`📄 Workbook sheets: ${workbook.SheetNames.join(", ")}`);
+        const sheet = sheetName || workbook.SheetNames[0];
+        console.log(`📋 Using sheet: ${sheet}`);
+        const sheetData = xlsx.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.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: Record<string, any> = {};
+          headers.forEach((h, j) => {
+            row[h] = values[j]?.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/src/exec/preLoader.ts

@@ -0,0 +1,72 @@
+// // Replaced legacy '@playq' alias import with direct relative import from public globals
+// import { config, vars } from "../global";
+
+// // 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");
+
+
+
+import { config, vars } from "../global";
+import path from "path";
+import fs from "fs";
+
+// Use minimal addons.json for discovery, config for logic
+const projectRoot = process.env.PLAYQ_PROJECT_ROOT || process.cwd();
+const addonsJsonPath = path.join(projectRoot, "playq", "addons", "addons.json");
+let addonList: Array<{ name: string; description: string }> = [];
+
+try {
+  const raw = fs.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 = config?.addons?.[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:", 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(vars.getConfigValue(`addons.${addonKey}.enable`)).toLowerCase().trim();
+    const versionStr = String(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 {
+        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/src/exec/preProcessEntry.ts

@@ -0,0 +1,59 @@
+import fs from 'fs';
+import path from 'path';
+import { sync } from 'glob';
+import * as vars from '../helper/bundle/vars';
+const config: any = {};
+
+import { generateStepGroupsIfNeeded } from './sgGenerator';
+import {
+  getCachedFeatureFilePath,
+  shouldUseCachedFeature,
+  updateFeatureCacheMeta
+} from './featureFileCache';
+import { preprocessFeatureFile } from './featureFilePreProcess';
+
+const featureFileCache = config?.cucumber?.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}`);
+
+generateStepGroupsIfNeeded(isForce);
+
+const featureFiles = 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.join('_Temp', 'execution');
+if (fs.existsSync(executionDir)) {
+  fs.rmSync(executionDir, { recursive: true, force: true });
+  console.log(`🧹 Cleaned up execution folder: ${executionDir}`);
+}
+
+for (const originalPath of featureFiles) {
+  console.log(`🔧 Processing: ${originalPath}`);
+  const cachedPath = getCachedFeatureFilePath(originalPath);
+  console.log(`📄 Cached path: ${cachedPath}`);
+
+  if (featureFileCache && !isForce && shouldUseCachedFeature(originalPath, cachedPath)) {
+    console.log(`✅ Using cached feature file: ${cachedPath}`);
+    continue;
+  }
+
+  const updatedContent = 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.mkdirSync(path.dirname(cachedPath), { recursive: true });
+  fs.writeFileSync(cachedPath, updatedContent, 'utf-8');
+  console.log(`📥 Updated cached feature file: ${cachedPath}`);
+
+  if (featureFileCache) {
+    updateFeatureCacheMeta(originalPath, cachedPath);
+  }
+}

package/src/exec/preProcess_old_todelete.ts

@@ -0,0 +1,289 @@
+import fs from 'fs';
+import path from 'path';
+import csv from 'csv-parser';
+// import xlsx from 'xlsx';
+import xlsx from '@e965/xlsx';
+import crypto from 'crypto';
+import { generateStepGroups } from './sgGenerator';
+const config: any = {};
+
+function loadStepGroupCache(): Record<string, { description: string; steps: string[] }> {
+  const cachePath = path.resolve('_Temp/.cache/stepGroup_cache.json');
+  if (!fs.existsSync(cachePath)) {
+    console.error(`❌ Step group JSON cache not found. Please run sgGenerator.ts first.`);
+    return {};
+  }
+
+  return JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+}
+const args = process.argv.slice(2);
+const isForced = args.includes('--force');
+
+function sha256(content: string): string {
+  return crypto.createHash('sha256').update(content).digest('hex');
+}
+
+const featureCachePath = path.resolve('_Temp/.cache/featureMeta.json');
+const featureCache: Record<string, string> = fs.existsSync(featureCachePath)
+  ? JSON.parse(fs.readFileSync(featureCachePath, 'utf8'))
+  : {};
+
+const sourceDir = path.resolve('test/features');
+const outputDir = path.resolve('_Temp/execution');
+const dataDir = path.resolve('test-data');
+
+function findFeatureFiles(dir: string): string[] {
+  let results: string[] = [];
+  fs.readdirSync(dir).forEach(file => {
+    const fullPath = path.join(dir, file);
+    const stat = fs.statSync(fullPath);
+    if (stat.isDirectory()) {
+      results = results.concat(findFeatureFiles(fullPath));
+    } else if (file.endsWith('.feature')) {
+      results.push(fullPath);
+    }
+  });
+  return results;
+}
+
+function ensureOutputPath(featurePath: string): string {
+  const relativePath = path.relative(sourceDir, featurePath);
+  const targetPath = path.join(outputDir, relativePath);
+  const dir = path.dirname(targetPath);
+  fs.mkdirSync(dir, { recursive: true });
+  return targetPath;
+}
+
+function isNumeric(val: any): boolean {
+  return typeof val === 'string' && val.trim() !== '' && !isNaN(Number(val));
+}
+
+function validateIdentifiers(filter: string, inputPath: string): boolean {
+  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: string, row: Record<string, any>): string {
+  const allKeys = Object.keys(row);
+  const pattern = /\b[_a-zA-Z][_a-zA-Z0-9]*\b/g;
+  return filter.replace(pattern, (key) => {
+    const raw = row[key] ?? row[`_${key}`];
+    if (raw === undefined) return key; // leave as-is if not found
+    return isNumeric(raw) ? raw.trim() : JSON.stringify(raw);
+  });
+}
+
+function preprocessFeatureFile(
+  inputPath: string,
+  outputPath: string,
+  stepGroupCache: Record<string, { description: string; steps: string[] }>,
+  stepGroupCacheHash: string
+) {
+  const relativePath = path.relative(sourceDir, inputPath);
+  let featureHashInput = fs.readFileSync(inputPath, 'utf-8') + stepGroupCacheHash;
+  const featureText = fs.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.extname(dataFile).toLowerCase();
+    fullPath = path.join(dataDir, path.basename(dataFile));
+    if (fs.existsSync(fullPath)) {
+      // For CSV, read as utf-8; for XLSX, hash the file buffer.
+      if (ext === '.csv') {
+        featureHashInput += fs.readFileSync(fullPath, 'utf-8');
+      } else if (ext === '.xlsx') {
+        featureHashInput += fs.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.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.extname(dataFile).toLowerCase();
+  const rows: Record<string, any>[] = [];
+
+  const buildExamplesFile = () => {
+    if (rows.length === 0) {
+      console.log(`❌ No matching rows found in ${dataFile}`);
+      fs.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.writeFileSync(outputPath, finalLines, 'utf-8');
+    featureCache[relativePath] = currentHash;
+    console.log(`✅ Processed: ${outputPath}`);
+  };
+
+  if (ext === '.csv') {
+    fs.createReadStream(fullPath)
+      .pipe(csv())
+      .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.readFile(fullPath);
+    const sheet = sheetName || workbook.SheetNames[0];
+    const sheetData = xlsx.utils.sheet_to_json(workbook.Sheets[sheet]);
+    sheetData.forEach((row: any) => {
+      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.writeFileSync(outputPath, featureText, 'utf-8');
+    featureCache[relativePath] = currentHash;
+  }
+}
+
+function run() {
+  console.log("🔄 Generating step group definitions from sgGenerator...");
+  generateStepGroups({ force: isForced }); // Regenerate stepGroup_steps.ts before preprocessing
+
+  // if (fs.existsSync(outputDir)) {
+  //   fs.rmSync(outputDir, { recursive: true, force: true });
+  // }
+  fs.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.mkdirSync(path.dirname(featureCachePath), { recursive: true });
+  fs.writeFileSync(featureCachePath, JSON.stringify(featureCache, null, 2), 'utf8');
+}
+
+function expandStepGroups(
+  lines: string[],
+  inputPath: string,
+  stepGroupCache: Record<string, { description: string; steps: string[] }>
+): string[] {
+  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();