@dev-blinq/cucumber_client 1.0.1721-dev → 1.0.1723-dev

package/bin/client/code_cleanup/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/code_cleanup/codemod/find_misstructured_elements.js

@@ -0,0 +1,164 @@
+#!/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 IGNORE_DIRS = new Set(["node_modules", ".git", ".idea"]);
+
+const results = [];
+
+const traverse = typeof traverseImport === "function" ? traverseImport : traverseImport.default;
+
+function propName(prop) {
+  if (prop.type !== "ObjectProperty") return undefined;
+  const key = prop.key;
+  if (key.type === "Identifier") return key.name;
+  if (key.type === "StringLiteral") return key.value;
+  if (key.type === "NumericLiteral") return String(key.value);
+  return undefined;
+}
+
+function isNumericKey(name) {
+  return typeof name === "string" && /^\d+$/.test(name);
+}
+
+function getElementLabel(props) {
+  const labelProp = props.find(
+    (p) => p.type === "ObjectProperty" && ["element_name", "element_key"].includes(propName(p))
+  );
+  if (!labelProp) return undefined;
+
+  const value = labelProp.value;
+  if (value.type === "StringLiteral") return value.value;
+  if (value.type === "TemplateLiteral") {
+    return value.quasis.map((q) => q.value.cooked ?? q.value.raw).join("${}");
+  }
+  return undefined;
+}
+
+function reportIssue({ file, line, element, numericCount }) {
+  results.push({ file, line, element: element ?? "<unknown>", numericCount });
+}
+
+function analyzeAst(filePath, code) {
+  const ast = parse(code, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript", "classProperties", "optionalChaining", "nullishCoalescingOperator", "topLevelAwait"],
+  });
+
+  traverse(ast, {
+    ObjectExpression(pathObj) {
+      const props = pathObj.node.properties.filter((p) => p.type === "ObjectProperty");
+      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) {
+        const element = getElementLabel(props);
+        const line = pathObj.node.loc?.start.line ?? 0;
+        reportIssue({ file: filePath, line, element, 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) {
+  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;
+    }
+
+    const keys = Object.keys(node);
+    const hasElementMeta = "element_name" in node || "element_key" in node;
+    const hasLocators = "locators" in node;
+    const numericKeys = keys.filter(isNumericKey);
+
+    if (hasElementMeta && !hasLocators && numericKeys.length > 0) {
+      const element = node.element_name || node.element_key || "<unknown>";
+      const line = findLineNumber(content, element);
+      reportIssue({ file: filePath, line, element, numericCount: numericKeys.length });
+    }
+
+    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);
+      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);
+      } catch (err) {
+        console.error(`Failed to analyze ${resolved}:`, err.message);
+      }
+    } else if (entry.name.endsWith(".json")) {
+      const content = await fs.readFile(resolved, "utf8");
+      try {
+        analyzeJson(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 misstructured elements found (numeric keys without locators).");
+    return;
+  }
+
+  for (const r of results) {
+    console.log(`${r.file}:${r.line} — ${r.element} (${r.numericCount} numeric keys, missing locators)`);
+  }
+
+  process.exitCode = 1;
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/bin/client/code_cleanup/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/code_cleanup/codemod/fix_misstructured_elements.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+/**
+ * Low-noise codemod: fixes objects with numeric keys but no `locators` by splicing text in place.
+ * - Clones the workspace; originals untouched.
+ * - For each flagged object, inserts a `locators` array built from numeric keys and removes those keys.
+ * - Preserves surrounding formatting; only the object literal text is changed.
+ *
+ * Usage:
+ *   node find-misstructured-elements.mjs | node fix-misstructured-elements.mjs
+ */
+
+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 ROOT = process.cwd();
+
+const INPUT = await readStdin();
+if (!INPUT.trim()) {
+  console.error("No input provided. Pipe find-misstructured-elements.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 = fixJsPreserveFormat(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 isNumericKey(key) {
+  return typeof key === "string" && /^\d+$/.test(key);
+}
+
+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;
+  if (k.type === "NumericLiteral") return String(k.value);
+  return undefined;
+}
+
+function stringifyValue(node, source) {
+  // Slice raw text to preserve formatting
+  if (typeof node.start === "number" && typeof node.end === "number") {
+    return source.slice(node.start, node.end);
+  }
+  return JSON.stringify(null);
+}
+
+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) {
+  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 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 objectText = code.slice(pathObj.node.start, pathObj.node.end);
+      const leading = leadingWhitespace(code, pathObj.node.start);
+
+      const otherProps = props.filter((p) => !numericProps.includes(p));
+      const otherTexts = otherProps.map((p) => code.slice(p.start, p.end));
+
+      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) {
+  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);
+
+    const keys = Object.keys(node);
+    const hasMeta = "element_name" in node || "element_key" in node;
+    const hasLoc = "locators" in node;
+    const nums = keys.filter(isNumericKey);
+
+    if (hasMeta && !hasLoc && nums.length) {
+      node.locators = nums.sort((a, b) => Number(a) - Number(b)).map((k) => node[k]);
+      nums.forEach((k) => delete node[k]);
+      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) {
+  // Skip if already a repo
+  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));
+  });
+}
+
+function leadingWhitespace(text, index) {
+  const lineStart = text.lastIndexOf("\n", index - 1) + 1;
+  const m = text.slice(lineStart, index).match(/^[ \t]*/);
+  return m ? m[0] : "";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dev-blinq/cucumber_client",
-  "version": "1.0.1721-dev",
+  "version": "1.0.1723-dev",
   "description": " ",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",
@@ -39,7 +39,7 @@
     "@babel/traverse": "^7.27.1",
     "@babel/types": "^7.27.1",
     "@cucumber/tag-expressions": "^6.1.1",
-    "@dev-blinq/cucumber-js": "1.0.220-dev",
+    "@dev-blinq/cucumber-js": "1.0.221-dev",
     "@faker-js/faker": "^8.4.1",
     "automation_model": "1.0.928-dev",
     "axios": "^1.7.4",