@dev-blinq/cucumber_client 1.0.1722-dev → 1.0.1724-dev

package/bin/client/code_gen/code_inversion.js

@@ -604,15 +604,14 @@ const invertStableCommand = (call, elements, stepParams) => {
 
   // Set locators if element exists
   if (step.element && elements[step.element.key]) {
-    /** @type {LocatorBundle | Locator[] | undefined} */
-    const locBundle = elements[step.element.key]?.locators;
+    const locBundle = elements[step.element.key];
     step.locators = locBundle;
   }
 
   if (step.type === Types.CLICK) {
     // handle click with parametric locators
     // check if locators are parametric , i.e. contains `{variable}`
-    if (step.locators && !Array.isArray(step.locators) && Array.isArray(step.locators.locators)) {
+    if (step.locators && step.locators.locators && Array.isArray(step.locators.locators)) {
       let hasParametricLocators = false;
       let variable = "";
       const regex = /{([^}]+)}/g;

package/bin/client/code_gen/page_reflection.js

@@ -567,16 +567,12 @@ export class CodePage {
         if (!element || !element.locators)
             return element;
         const clone = JSON.parse(JSON.stringify(element));
-        const locatorsArray = Array.isArray(clone.locators)
-            ? clone.locators
-            : (clone.locators.locators ?? []);
+        const locatorsArray = Array.isArray(clone.locators) ? clone.locators : [];
         for (let i = 0; i < locatorsArray.length; i++) {
             if (locatorsArray[i].score)
                 delete locatorsArray[i].score;
         }
-        clone.locators = Array.isArray(clone.locators)
-            ? locatorsArray
-            : { ...clone.locators, locators: locatorsArray };
+        clone.locators = Array.isArray(clone.locators) ? locatorsArray : [];
         return clone;
     }
     insertElements(elements) {

package/bin/client/codemod/find_harcoded_locators.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse } from "@babel/parser";
+import traverseImport from "@babel/traverse";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const ROOT = process.cwd();
+const ALLOWED_HARDCODE_RATIO = 0.2;
+const IGNORED_RATIO = 1.0;
+const PLACEHOLDER_REGEX = /{[^}]+}/;
+const IGNORE_DIRS = new Set(["node_modules", ".git", ".idea"]);
+
+const results = [];
+
+function hasPlaceholder(str) {
+  return PLACEHOLDER_REGEX.test(str);
+}
+
+function stringFromNode(node) {
+  if (!node) return undefined;
+  if (node.type === "StringLiteral") return node.value;
+  if (node.type === "TemplateLiteral") {
+    const raw = node.quasis.map((q) => q.value.cooked ?? q.value.raw).join("${}");
+    return raw;
+  }
+  return undefined;
+}
+
+function locatorIsParameterized(objNode) {
+  if (objNode.type !== "ObjectExpression") return false;
+  return objNode.properties.some((prop) => {
+    if (prop.type !== "ObjectProperty") return false;
+    const valueString = stringFromNode(prop.value);
+    return typeof valueString === "string" && hasPlaceholder(valueString);
+  });
+}
+
+function analyzeMjsFile(filePath, code) {
+  const ast = parse(code, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript", "classProperties", "optionalChaining", "nullishCoalescingOperator", "topLevelAwait"],
+  });
+
+  const traverse = typeof traverseImport === "function" ? traverseImport : traverseImport.default;
+
+  traverse(ast, {
+    ObjectExpression(pathObj) {
+      const props = pathObj.node.properties;
+      const locatorProp = props.find(
+        (p) =>
+          p.type === "ObjectProperty" &&
+          ((p.key.type === "Identifier" && p.key.name === "locators") ||
+            (p.key.type === "StringLiteral" && p.key.value === "locators"))
+      );
+      if (!locatorProp || locatorProp.value.type !== "ArrayExpression") return;
+
+      const locators = locatorProp.value.elements.filter(Boolean);
+      if (locators.length === 0) return;
+
+      const total = locators.length;
+      const hardcoded = locators.filter((loc) => !locatorIsParameterized(loc)).length;
+      if (hardcoded / total === IGNORED_RATIO) return; // Skip if all locators are hardcoded (likely a non-locator object)
+      if (hardcoded / total <= ALLOWED_HARDCODE_RATIO) return;
+
+      const nameProp = props.find(
+        (p) =>
+          p.type === "ObjectProperty" &&
+          ((p.key.type === "Identifier" && (p.key.name === "element_name" || p.key.name === "element_key")) ||
+            (p.key.type === "StringLiteral" && (p.key.value === "element_name" || p.key.value === "element_key")))
+      );
+      const elementNameValue = nameProp ? stringFromNode(nameProp.value) : undefined;
+      const loc = pathObj.node.loc?.start;
+      results.push({
+        file: filePath,
+        line: loc?.line ?? 0,
+        element: elementNameValue ?? "<unknown>",
+        hardcoded,
+        total,
+      });
+    },
+  });
+}
+
+function locatorIsParameterizedJson(locator) {
+  if (locator && typeof locator === "object") {
+    return Object.values(locator).some((val) => typeof val === "string" && hasPlaceholder(val));
+  }
+  return false;
+}
+
+function findLineNumber(content, searchValue) {
+  const idx = content.indexOf(searchValue);
+  if (idx === -1) return 0;
+  return content.slice(0, idx).split("\n").length;
+}
+
+function analyzeJsonFile(filePath, content) {
+  let data;
+  try {
+    data = JSON.parse(content);
+  } catch (err) {
+    console.warn(`Skipping ${filePath}: invalid JSON`);
+    return;
+  }
+
+  const visit = (node) => {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+
+    if (Array.isArray(node.locators) && node.locators.length > 0) {
+      const total = node.locators.length;
+      const hardcoded = node.locators.filter((loc) => !locatorIsParameterizedJson(loc)).length;
+
+      if (hardcoded / total > ALLOWED_HARDCODE_RATIO) {
+        if (hardcoded / total === IGNORED_RATIO) return; // Skip if all locators are hardcoded (likely a non-locator object)
+        const name = node.element_name || node.element_key || "<unknown>";
+        const line = findLineNumber(content, name);
+        results.push({ file: filePath, line, element: name, hardcoded, total });
+      }
+    }
+
+    Object.values(node).forEach(visit);
+  };
+
+  visit(data);
+}
+
+async function walk(dir) {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (IGNORE_DIRS.has(entry.name)) continue;
+    const resolved = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walk(resolved);
+    } else if (entry.isFile() && (entry.name.endsWith(".mjs") || entry.name.endsWith(".json"))) {
+      const content = await fs.readFile(resolved, "utf8");
+      try {
+        if (entry.name.endsWith(".mjs")) {
+          analyzeMjsFile(resolved, content);
+        } else {
+          analyzeJsonFile(resolved, content);
+        }
+      } catch (err) {
+        console.error(`Failed to analyze ${resolved}:`, err.message);
+      }
+    }
+  }
+}
+
+async function main() {
+  await walk(ROOT);
+  if (results.length === 0) {
+    console.log("No elements exceeded 20% hardcoded locator threshold.");
+    return;
+  }
+
+  for (const r of results) {
+    console.log(`${r.file}:${r.line} — ${r.element} (${r.hardcoded}/${r.total} hardcoded)`);
+  }
+  process.exitCode = 1;
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/bin/client/codemod/fix_hardcoded_locators.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+/**
+ * Codemod to drop hardcoded locators flagged by find_harcoded_locators.mjs.
+ * - Default: clones workspace to a temp dir, git init + baseline commit, applies fixes, prints diffs.
+ * - --inplace: modifies files in the current workspace.
+ *
+ * Behavior:
+ *   For each reported file, in every object with a `locators` array,
+ *   remove locator entries that contain no placeholders ({...}).
+ *   If all locators are hardcoded, the array is left unchanged to avoid emptying it.
+ *   JSON files are handled similarly.
+ *
+ * Usage:
+ *   node find_harcoded_locators.mjs | node fix-hardcoded-locators.mjs
+ *   node find_harcoded_locators.mjs | node fix-hardcoded-locators.mjs --inplace
+ */
+
+import fs from "node:fs";
+import { promises as fsPromises } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { parse } from "@babel/parser";
+import traverseImport from "@babel/traverse";
+import { spawnSync } from "node:child_process";
+
+const traverse = typeof traverseImport === "function" ? traverseImport : traverseImport.default;
+const PLACEHOLDER_REGEX = /{[^}]+}/;
+const ROOT = process.cwd();
+
+const INPUT = await readStdin();
+if (!INPUT.trim()) {
+  console.error("No input provided. Pipe find_harcoded_locators.mjs into this script.");
+  process.exit(1);
+}
+
+const filesToFix = parseInputLines(INPUT);
+if (filesToFix.size === 0) {
+  console.log("No actionable lines detected.");
+  process.exit(0);
+}
+
+const INPLACE = process.argv.includes("--inplace");
+const { cloneRoot, mapper } = INPLACE ? { cloneRoot: ROOT, mapper: (p) => p } : await cloneWorkspace(ROOT);
+if (!INPLACE) {
+  console.log(`Cloned workspace to: ${cloneRoot}`);
+  await initGitRepo(cloneRoot);
+} else {
+  console.log("Running in-place (original files will be modified).");
+}
+
+const changes = [];
+
+for (const originalPath of filesToFix) {
+  const clonedPath = mapper(originalPath);
+  const ext = path.extname(clonedPath).toLowerCase();
+  const original = await fsPromises.readFile(clonedPath, "utf8");
+  let fixed = original;
+
+  if (ext === ".json") {
+    fixed = fixJson(original);
+  } else if (ext === ".mjs" || ext === ".js") {
+    fixed = fixJs(original);
+  }
+
+  if (fixed === original) continue;
+
+  const diff = makeDiff(originalPath, clonedPath, fixed);
+  await fsPromises.writeFile(clonedPath, fixed, "utf8");
+  changes.push({ filePath: originalPath, diff });
+}
+
+if (changes.length === 0) {
+  console.log("No changes needed.");
+  process.exit(0);
+}
+
+for (const { filePath, diff } of changes) {
+  console.log(`\n=== ${filePath} (cloned) ===`);
+  console.log(diff.trimEnd());
+}
+
+process.exit(1);
+
+// ---------- helpers ----------
+
+function parseInputLines(text) {
+  const set = new Set();
+  for (const line of text.split(/\r?\n/)) {
+    const m = line.match(/^(.*?):\d+ — /);
+    if (m) set.add(m[1]);
+  }
+  return set;
+}
+
+function hasPlaceholder(str) {
+  return PLACEHOLDER_REGEX.test(str);
+}
+
+function locatorHasPlaceholderNode(node) {
+  if (!node || node.type !== "ObjectExpression") return false;
+  return node.properties.some((prop) => {
+    if (prop.type !== "ObjectProperty") return false;
+    const val = prop.value;
+    if (val.type === "StringLiteral") return hasPlaceholder(val.value);
+    if (val.type === "TemplateLiteral") {
+      const raw = val.quasis.map((q) => q.value.cooked ?? q.value.raw).join("${}");
+      return hasPlaceholder(raw);
+    }
+    return false;
+  });
+}
+
+function propName(prop) {
+  if (prop.type !== "ObjectProperty") return undefined;
+  const k = prop.key;
+  if (k.type === "Identifier") return k.name;
+  if (k.type === "StringLiteral") return k.value;
+  return undefined;
+}
+
+function leadingWhitespace(text, index) {
+  const lineStart = text.lastIndexOf("\n", index - 1) + 1;
+  const m = text.slice(lineStart, index).match(/^[ \t]*/);
+  return m ? m[0] : "";
+}
+
+function fixJs(code) {
+  let touched = false;
+  const replacements = [];
+
+  const ast = parse(code, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript", "classProperties", "optionalChaining", "nullishCoalescingOperator", "topLevelAwait"],
+    ranges: true,
+  });
+
+  traverse(ast, {
+    ObjectExpression(pathObj) {
+      const props = pathObj.node.properties.filter((p) => p.type === "ObjectProperty");
+      if (!props.length) return;
+      const locProp = props.find((p) => propName(p) === "locators" && p.value.type === "ArrayExpression");
+      if (!locProp) return;
+      const elements = locProp.value.elements.filter(Boolean);
+      if (elements.length === 0) return;
+
+      const keep = elements.filter(locatorHasPlaceholderNode);
+      if (keep.length === elements.length) return;
+      if (keep.length === 0) return; // avoid emptying; leave as-is
+
+      if (typeof locProp.value.start !== "number" || typeof locProp.value.end !== "number") return;
+
+      const valueStart = locProp.value.start;
+      const valueEnd = locProp.value.end;
+      const indent = leadingWhitespace(code, valueStart) + "  ";
+      const keepTexts = keep.map((el) => code.slice(el.start, el.end));
+      const newArray =
+        "[\n" + keepTexts.map((t) => indent + t.trim()).join(",\n") + "\n" + leadingWhitespace(code, valueStart) + "]";
+
+      replacements.push({ start: valueStart, end: valueEnd, text: newArray });
+      touched = true;
+    },
+  });
+
+  if (!touched) return code;
+
+  let out = code;
+  replacements
+    .sort((a, b) => b.start - a.start)
+    .forEach(({ start, end, text }) => {
+      out = out.slice(0, start) + text + out.slice(end);
+    });
+  return out;
+}
+
+function locatorHasPlaceholderJson(locator) {
+  if (locator && typeof locator === "object") {
+    return Object.values(locator).some((val) => typeof val === "string" && hasPlaceholder(val));
+  }
+  return false;
+}
+
+function fixJson(content) {
+  let data;
+  try {
+    data = JSON.parse(content);
+  } catch {
+    return content;
+  }
+  let touched = false;
+
+  const visit = (node) => {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) return node.forEach(visit);
+
+    if (Array.isArray(node.locators) && node.locators.length > 0) {
+      const keep = node.locators.filter(locatorHasPlaceholderJson);
+      if (keep.length > 0 && keep.length < node.locators.length) {
+        node.locators = keep;
+        touched = true;
+      }
+    }
+    Object.values(node).forEach(visit);
+  };
+
+  visit(data);
+  return touched ? JSON.stringify(data, null, 2) + "\n" : content;
+}
+
+async function cloneWorkspace(root) {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "codemod-clone-"));
+  const cloneRoot = path.join(tmpDir, path.basename(root));
+
+  if (fsPromises.cp) {
+    await fsPromises.cp(root, cloneRoot, { recursive: true, force: true });
+  } else {
+    const res = spawnSync("cp", ["-R", ".", cloneRoot], { cwd: root, stdio: "inherit" });
+    if (res.status !== 0) throw new Error("Failed to clone workspace");
+  }
+
+  const mapper = (orig) => path.join(cloneRoot, path.relative(root, orig));
+  return { cloneRoot, mapper };
+}
+
+async function initGitRepo(cloneRoot) {
+  if (fs.existsSync(path.join(cloneRoot, ".git"))) return;
+  const run = (args) => spawnSync("git", args, { cwd: cloneRoot, stdio: "inherit" });
+  run(["init"]);
+  run(["add", "."]);
+  run(["commit", "-m", "chore: baseline before codemod"]);
+}
+
+function makeDiff(originalPath, clonedPath, fixed) {
+  const tmpOutDir = fs.mkdtempSync(path.join(os.tmpdir(), "codemod-out-"));
+  const fixedPath = path.join(tmpOutDir, path.basename(clonedPath));
+  fs.writeFileSync(fixedPath, fixed, "utf8");
+  const diff = spawnSync("diff", ["-u", originalPath, fixedPath], { encoding: "utf8" });
+  return diff.stdout || diff.stderr || "";
+}
+
+async function readStdin() {
+  return await new Promise((resolve) => {
+    let d = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (c) => (d += c));
+    process.stdin.on("end", () => resolve(d));
+  });
+}

package/bin/client/codemod/index.js

@@ -0,0 +1,8 @@
+import { locatorObjectToArray } from "./locators_array";
+export const codeMods = [
+    {
+        name: "Locator Object to Array",
+        description: "Converts locator objects with numeric keys to arrays.",
+        apply: locatorObjectToArray,
+    },
+];

package/bin/client/codemod/locators_array/find_misstructured_elements.js

@@ -0,0 +1,142 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+import * as t from "@babel/types";
+const IGNORE_DIRS = new Set(["node_modules", ".git", ".idea"]);
+function propName(prop) {
+    if (!t.isObjectProperty(prop))
+        return undefined;
+    const key = prop.key;
+    if (t.isIdentifier(key))
+        return key.name;
+    if (t.isStringLiteral(key))
+        return key.value;
+    if (t.isNumericLiteral(key))
+        return String(key.value);
+    return undefined;
+}
+function isNumericKey(name) {
+    return typeof name === "string" && /^\d+$/.test(name);
+}
+function getElementLabel(props) {
+    const labelProp = props.find((p) => ["element_name", "element_key"].includes(propName(p) ?? ""));
+    if (!labelProp)
+        return undefined;
+    const value = labelProp.value;
+    if (t.isStringLiteral(value))
+        return value.value;
+    if (t.isTemplateLiteral(value)) {
+        return value.quasis.map((q) => q.value.cooked ?? q.value.raw).join("${}");
+    }
+    return undefined;
+}
+function analyzeAst(filePath, code, results) {
+    const ast = parse(code, {
+        sourceType: "module",
+        plugins: ["jsx", "typescript", "classProperties", "optionalChaining", "nullishCoalescingOperator", "topLevelAwait"],
+    });
+    traverse(ast, {
+        ObjectExpression(pathObj) {
+            const props = pathObj.node.properties.filter(t.isObjectProperty);
+            if (props.length === 0)
+                return;
+            const names = props.map(propName).filter(Boolean);
+            const hasElementMeta = names.some((n) => n === "element_name" || n === "element_key");
+            if (!hasElementMeta)
+                return;
+            const hasLocators = names.includes("locators");
+            const numericProps = names.filter(isNumericKey);
+            if (!hasLocators && numericProps.length > 0) {
+                results.push({
+                    file: filePath,
+                    line: pathObj.node.loc?.start.line ?? 0,
+                    element: getElementLabel(props) ?? "<unknown>",
+                    numericCount: numericProps.length,
+                });
+            }
+        },
+    });
+}
+function findLineNumber(content, searchValue) {
+    if (!searchValue)
+        return 0;
+    const idx = content.indexOf(searchValue);
+    if (idx === -1)
+        return 0;
+    return content.slice(0, idx).split("\n").length;
+}
+function analyzeJson(filePath, content, results, logger) {
+    let data;
+    try {
+        data = JSON.parse(content);
+    }
+    catch {
+        logger.warn(`Skipping ${filePath}: invalid JSON`);
+        return;
+    }
+    const visit = (node) => {
+        if (!node || typeof node !== "object")
+            return;
+        if (Array.isArray(node)) {
+            node.forEach(visit);
+            return;
+        }
+        const record = node;
+        const keys = Object.keys(record);
+        const hasElementMeta = "element_name" in record || "element_key" in record;
+        const hasLocators = "locators" in record;
+        const numericKeys = keys.filter(isNumericKey);
+        if (hasElementMeta && !hasLocators && numericKeys.length > 0) {
+            results.push({
+                file: filePath,
+                line: findLineNumber(content, record.element_name ?? record.element_key),
+                element: record.element_name ?? record.element_key ?? "<unknown>",
+                numericCount: numericKeys.length,
+            });
+        }
+        Object.values(record).forEach(visit);
+    };
+    visit(data);
+}
+async function walk(dir, results, logger) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (IGNORE_DIRS.has(entry.name))
+            continue;
+        const resolved = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await walk(resolved, results, logger);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        if (entry.name.endsWith(".mjs") || entry.name.endsWith(".js")) {
+            const code = await fs.readFile(resolved, "utf8");
+            try {
+                analyzeAst(resolved, code, results);
+            }
+            catch (err) {
+                logger.error(`Failed to analyze ${resolved}: ${err.message}`);
+            }
+        }
+        else if (entry.name.endsWith(".json")) {
+            const content = await fs.readFile(resolved, "utf8");
+            try {
+                analyzeJson(resolved, content, results, logger);
+            }
+            catch (err) {
+                logger.error(`Failed to analyze ${resolved}: ${err.message}`);
+            }
+        }
+    }
+}
+/**
+ * Scans all JS/MJS/JSON files under `root` and returns an array of issues:
+ * [{ file, line, element, numericCount }]
+ */
+export async function findIssues(root, logger) {
+    const results = [];
+    await walk(root, results, logger);
+    return results;
+}

package/bin/client/codemod/locators_array/fix_misstructured_elements.js

@@ -0,0 +1,140 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+import * as t from "@babel/types";
+function isNumericKey(key) {
+    return typeof key === "string" && /^\d+$/.test(key);
+}
+function propName(prop) {
+    if (!t.isObjectProperty(prop))
+        return undefined;
+    const k = prop.key;
+    if (t.isIdentifier(k))
+        return k.name;
+    if (t.isStringLiteral(k))
+        return k.value;
+    if (t.isNumericLiteral(k))
+        return String(k.value);
+    return undefined;
+}
+function stringifyValue(node, source) {
+    if (typeof node.start === "number" && typeof node.end === "number") {
+        return source.slice(node.start, node.end);
+    }
+    return JSON.stringify(null);
+}
+function leadingWhitespace(text, index) {
+    const lineStart = text.lastIndexOf("\n", index - 1) + 1;
+    const match = text.slice(lineStart, index).match(/^[ \t]*/);
+    return match ? match[0] : "";
+}
+function buildLocatorsArray(numericProps, source, indent) {
+    const elements = numericProps
+        .sort((a, b) => Number(propName(a)) - Number(propName(b)))
+        .map((p) => `${indent}  ${stringifyValue(p.value, source)}`);
+    if (elements.length === 0)
+        return "locators: []";
+    return [indent + "locators: [", elements.join(",\n"), indent + "]"].join("\n");
+}
+function fixJsPreserveFormat(code, logger) {
+    let touched = false;
+    const replacements = [];
+    const ast = parse(code, {
+        sourceType: "module",
+        plugins: ["jsx", "typescript", "classProperties", "optionalChaining", "nullishCoalescingOperator", "topLevelAwait"],
+        ranges: true,
+    });
+    traverse(ast, {
+        ObjectExpression(pathObj) {
+            const props = pathObj.node.properties.filter(t.isObjectProperty);
+            if (!props.length)
+                return;
+            const names = props.map(propName).filter(Boolean);
+            const hasElementMeta = names.some((n) => n === "element_name" || n === "element_key");
+            if (!hasElementMeta)
+                return;
+            const hasLocators = names.includes("locators");
+            const numericProps = props.filter((p) => isNumericKey(propName(p)));
+            if (hasLocators || numericProps.length === 0)
+                return;
+            if (typeof pathObj.node.start !== "number" || typeof pathObj.node.end !== "number")
+                return;
+            const leading = leadingWhitespace(code, pathObj.node.start);
+            const otherProps = props.filter((p) => !numericProps.includes(p));
+            const otherTexts = otherProps.map((p) => code.slice(p.start ?? 0, p.end ?? 0));
+            const locatorsText = buildLocatorsArray(numericProps, code, `${leading}  `);
+            const pieces = [locatorsText, ...otherTexts];
+            const baseIndent = `${leading}  `;
+            const normalized = pieces.map((p) => (p.startsWith(baseIndent) ? p : baseIndent + p));
+            const newObjectText = "{\n" + normalized.join(",\n") + "\n" + leading + "}";
+            replacements.push({ start: pathObj.node.start, end: pathObj.node.end, text: newObjectText });
+            touched = true;
+        },
+    });
+    if (!touched)
+        return code;
+    let out = code;
+    replacements
+        .sort((a, b) => b.start - a.start)
+        .forEach(({ start, end, text }) => {
+        out = out.slice(0, start) + text + out.slice(end);
+    });
+    return out;
+}
+function fixJson(content, logger) {
+    let data;
+    try {
+        data = JSON.parse(content);
+    }
+    catch {
+        return content;
+    }
+    let touched = false;
+    const visit = (node, logger) => {
+        if (!node || typeof node !== "object")
+            return;
+        if (Array.isArray(node))
+            return node.forEach((n) => visit(n, logger));
+        const record = node;
+        const keys = Object.keys(record);
+        const hasMeta = "element_name" in record || "element_key" in record;
+        const hasLoc = "locators" in record;
+        const nums = keys.filter(isNumericKey);
+        if (hasMeta && !hasLoc && nums.length) {
+            record.locators = nums.sort((a, b) => Number(a) - Number(b)).map((k) => record[k]);
+            nums.forEach((k) => delete record[k]);
+            touched = true;
+        }
+        Object.values(record).forEach((v) => visit(v, logger));
+    };
+    visit(data, logger);
+    return touched ? `${JSON.stringify(data, null, 2)}\n` : content;
+}
+/**
+ * Fixes all files referenced in `issues` under `root`.
+ * `issues` is the array returned by findIssues().
+ * Returns an array of { filePath, original, fixed } for files that changed.
+ */
+export async function fixIssues(issues, root, logger) {
+    // Deduplicate — multiple issues can point to the same file
+    const filePaths = [...new Set(issues.map((i) => i.file))];
+    const changes = [];
+    for (const filePath of filePaths) {
+        const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(root, filePath);
+        const ext = path.extname(absolutePath).toLowerCase();
+        const original = await fs.readFile(absolutePath, "utf8");
+        let fixed = original;
+        if (ext === ".json") {
+            fixed = fixJson(original, logger);
+        }
+        else if (ext === ".mjs" || ext === ".js") {
+            fixed = fixJsPreserveFormat(original, logger);
+        }
+        if (fixed === original)
+            continue;
+        await fs.writeFile(absolutePath, fixed, "utf8");
+        changes.push({ filePath: absolutePath, original, fixed });
+    }
+    return changes;
+}

package/bin/client/codemod/locators_array/index.js

@@ -0,0 +1,114 @@
+import { findIssues } from "./find_misstructured_elements";
+import { fixIssues } from "./fix_misstructured_elements";
+/**
+ * Converts legacy locator objects that use numeric keys (e.g., `{ 0: {...}, 1: {...} }`)
+ * into a `locators` array, across all JS/MJS/JSON files under a codebase root.
+ * The codemod is idempotent, preserves formatting where possible, and reports timing metrics.
+ *
+ * @param clonedRoot Absolute path to the cloned project directory to scan and fix.
+ * @param logger Logger instance used for progress, issue, and summary output.
+ * @returns Structured codemod run result containing issues found, file changes written, and metrics.
+ *
+ * @example Running the codemod standalone:
+ * ```ts
+ * import { locatorObjectToArray } from "./code_cleanup/codemod/locators_array";
+ * import { consoleLogger } from "./logger";
+ *
+ * const result = await locatorObjectToArray("/tmp/repo", consoleLogger);
+ * console.log(result.message); // e.g., "Fixed 3 file(s)"
+ * ```
+ *
+ * @example Running multiple codemods in sequence:
+ * ```ts
+ * const codemods = [locatorObjectToArray]; // add other codemods as needed
+ * for (const mod of codemods) {
+ *   const outcome = await mod("/tmp/repo", consoleLogger);
+ *   if (!outcome.success) throw new Error(outcome.message);
+ * }
+ * ```
+ */
+async function locatorObjectToArray(clonedRoot, logger) {
+    const start = Date.now();
+    logger.info(`Scanning ${clonedRoot} for misstructured locator objects...`);
+    const findStart = Date.now();
+    const issues = [];
+    try {
+        issues.push(...(await findIssues(clonedRoot, logger)));
+    }
+    catch (error) {
+        const metricsOnFindError = {
+            issueCount: 0,
+            affectedFiles: 0,
+            findDurationMs: Date.now() - findStart,
+            fixDurationMs: 0,
+            filesFixed: 0,
+            wasAffected: false,
+            totalDurationMs: Date.now() - start,
+        };
+        logger.error(`Error during issue finding: ${error.message}`);
+        return {
+            name: "Locator Object to Array",
+            description: "Converts locator objects with numeric keys to arrays.",
+            success: false,
+            message: `Failed to find issues: ${error.message}`,
+            details: { issues: [], changes: [], metrics: metricsOnFindError },
+        };
+    }
+    const metricsBase = {
+        issueCount: issues.length,
+        affectedFiles: [...new Set(issues.map((i) => i.file))].length,
+        findDurationMs: Date.now() - findStart,
+        fixDurationMs: 0,
+        filesFixed: 0,
+        wasAffected: issues.length > 0,
+        totalDurationMs: 0,
+    };
+    if (issues.length === 0) {
+        metricsBase.totalDurationMs = Date.now() - start;
+        logger.info("No issues — nothing to fix");
+        logger.info(`Summary: issues=0 files=0 fixed=0 find=${metricsBase.findDurationMs}ms ` +
+            `fix=${metricsBase.fixDurationMs}ms total=${metricsBase.totalDurationMs}ms`);
+        return {
+            name: "Locator Object to Array",
+            description: "Converts locator objects with numeric keys to arrays.",
+            success: true,
+            message: "No issues found",
+            details: { issues: [], changes: [], metrics: metricsBase },
+        };
+    }
+    logger.info(`Found ${issues.length} issue(s) across ${metricsBase.affectedFiles} file(s)`);
+    issues.forEach((i) => logger.info(`  issue: ${i.file}:${i.line} — ${i.element} (${i.numericCount} numeric keys)`));
+    const fixStart = Date.now();
+    const changes = [];
+    try {
+        changes.push(...(await fixIssues(issues, clonedRoot, logger)));
+    }
+    catch (error) {
+        metricsBase.fixDurationMs = Date.now() - fixStart;
+        metricsBase.totalDurationMs = Date.now() - start;
+        logger.error(`Error during issue fixing: ${error.message}`);
+        return {
+            name: "Locator Object to Array",
+            description: "Converts locator objects with numeric keys to arrays.",
+            success: false,
+            message: `Failed to fix issues: ${error.message}`,
+            details: { issues, changes: [], metrics: metricsBase },
+        };
+    }
+    metricsBase.fixDurationMs = Date.now() - fixStart;
+    metricsBase.filesFixed = changes.length;
+    metricsBase.totalDurationMs = Date.now() - start;
+    logger.info(`Fixed ${changes.length} file(s) in ${metricsBase.fixDurationMs}ms`);
+    changes.forEach((c) => logger.info(`  fixed: ${c.filePath}`));
+    logger.info(`Summary: issues=${metricsBase.issueCount} files=${metricsBase.affectedFiles} ` +
+        `fixed=${metricsBase.filesFixed} find=${metricsBase.findDurationMs}ms ` +
+        `fix=${metricsBase.fixDurationMs}ms total=${metricsBase.totalDurationMs}ms`);
+    return {
+        name: "Locator Object to Array",
+        description: "Converts locator objects with numeric keys to arrays.",
+        success: true,
+        message: `Fixed ${changes.length} file(s)`,
+        details: { issues, changes, metrics: metricsBase },
+    };
+}
+export { locatorObjectToArray };

package/bin/client/codemod/types.js

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

package/bin/client/recorderv3/bvt_recorder.js

@@ -16,7 +16,6 @@ import { unEscapeNonPrintables } from "../cucumber/utils.js";
 import { findAvailablePort, getRunsServiceBaseURL } from "../utils/index.js";
 import socketLogger, { getErrorMessage } from "../utils/socket_logger.js";
 import { tmpdir } from "os";
-import { faker } from "@faker-js/faker/locale/en_US";
 import { chromium } from "playwright-core";
 import { axiosClient } from "../utils/axiosClient.js";
 import { _generateCodeFromCommand } from "../code_gen/playwright_codeget.js";
@@ -1229,9 +1228,9 @@ export class BVTRecorder {
             datasets,
         };
     }
-    async generateLocatorSummaries({ allStrategyLocators, element_name }) {
+    async generateLocatorSummaries({ allStrategyLocators, element_name, }) {
         const input = {
-            [element_name ?? "element"]: allStrategyLocators
+            [element_name ?? "element"]: allStrategyLocators,
         };
         const result = await this.namesService.generateLocatorDescriptions({ locatorsObj: input });
         return result[element_name ?? "element"];
@@ -1583,29 +1582,30 @@ export class BVTRecorder {
             this.bvtContext.STORE_DETAILED_NETWORK_DATA = false;
         }
     }
-    async fakeParams(params) {
+    async fakeParams(params, faker) {
+        if (!faker) {
+            faker = await import("@faker-js/faker/locale/en_US").then((mod) => mod.faker);
+        }
         const newFakeParams = {};
-        Object.entries(params).forEach(([key, rawValue]) => {
-            if (!rawValue.startsWith("{{") || !rawValue.endsWith("}}")) {
-                newFakeParams[key] = rawValue;
+        Object.keys(params).forEach((key) => {
+            if (!params[key].startsWith("{{") || !params[key].endsWith("}}")) {
+                newFakeParams[key] = params[key];
                 return;
             }
             try {
                 const value = params[key].substring(2, params[key].length - 2).trim();
                 const faking = value.split("(")[0].split(".");
                 let argument = value.substring(value.indexOf("(") + 1, value.lastIndexOf(")"));
-                argument = isNaN(Number(argument)) || argument === "" ? argument : Number(argument);
+                argument = isNaN(Number(argument)) ? argument : Number(argument);
                 let fakeFunc = faker;
                 faking.forEach((f) => {
-                    //@ts-expect-error Trying to support both old and new faker versions
                     fakeFunc = fakeFunc[f];
                 });
-                //@ts-expect-error Trying to support both old and new faker versions
                 const newValue = fakeFunc(argument);
                 newFakeParams[key] = newValue;
             }
             catch (error) {
-                newFakeParams[key] = rawValue;
+                newFakeParams[key] = params[key];
             }
         });
         return newFakeParams;

package/bin/index.js

@@ -13,6 +13,7 @@ export * from "./client/cucumber/feature_data.js";
 export * from "./client/cucumber/steps_definitions.js";
 export * from "./client/profiler.js";
 export * from "./client/code_cleanup/utils.js";
+export * from "./client/codemod/index.js";
 export * from "./client/code_cleanup/find_step_definition_references.js";
 export * from "./client/recorderv3/bvt_init.js";
 export * from "./client/recorderv3/step_utils.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dev-blinq/cucumber_client",
-  "version": "1.0.1722-dev",
+  "version": "1.0.1724-dev",
   "description": " ",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",
@@ -62,6 +62,7 @@
     "winston-daily-rotate-file": "^4.7.1"
   },
   "devDependencies": {
+    "@types/babel__traverse": "^7.28.0",
     "@types/prettier": "^2.7.3",
     "chai": "^5.1.2",
     "cpx": "^1.5.0",