@dev-blinq/cucumber_client 1.0.1723-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/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.1723-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",

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

@@ -1,164 +0,0 @@
-#!/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_misstructured_elements.js

@@ -1,246 +0,0 @@
-#!/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] : "";
-}