@dev-blinq/cucumber_client 1.0.1276-dev → 1.0.1276-stage

package/bin/client/code_gen/page_reflection.js

@@ -1,925 +1,861 @@
+// code_page.ts
 import { writeFileSync, readFileSync, existsSync, mkdirSync } from "fs";
-import Walker from "node-source-walk";
+// @ts-expect-error no type defs
+import Walker from "node-source-walk"; // No official types; treated as 'any'
 import path from "node:path";
 import vm from "vm";
 import logger from "../../logger.js";
 import { convertToIdentifier } from "./utils.js";
 import prettier from "prettier";
-import url from "url";
+import * as url from "url";
 import { getDefaultPrettierConfig } from "../code_cleanup/utils.js";
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-const CodeStatus = {
-  ADD: "add",
-  NO_CHANGE: "no_change",
-  UPDATED: "updated",
-};
+export var CodeStatus;
+(function (CodeStatus) {
+    CodeStatus["ADD"] = "add";
+    CodeStatus["NO_CHANGE"] = "no_change";
+    CodeStatus["UPDATED"] = "updated";
+})(CodeStatus || (CodeStatus = {}));
 function escapeForComment(text) {
-  return text
-    .replace(/\\/g, "\\\\") // Escape backslashes
-    .replace(/\*\//g, "*\\/"); // Escape comment-closing sequence
+    return text
+        .replace(/\\/g, "\\\\") // Escape backslashes
+        .replace(/\*\//g, "*\\/"); // Escape comment-closing sequence
 }
 function unescapeFromComment(text) {
-  return text
-    .replace(/\*\\/g, "*/") // Unescape comment-closing sequence
-    .replace(/\\\\/g, "\\"); // Unescape backslashes
+    return text.replace(/\*\\/g, "*/").replace(/\\\\/g, "\\");
 }
 let ai_config = null;
 export function getAiConfig() {
-  if (ai_config) {
-    return ai_config;
-  }
-  try {
-    ai_config = JSON.parse(readFileSync("ai_config.json", "utf8"));
-  } catch (e) {
-    ai_config = {};
-  }
-  if (!ai_config.locatorsMetadataDir) {
-    ai_config.locatorsMetadataDir = "features/step_definitions/locators";
-  }
-  return ai_config;
-}
-class CodePage {
-  constructor(sourceFileName = null) {
-    this.sourceFileName = sourceFileName;
-    this.cleanFileName = sourceFileName && path.basename(sourceFileName).split(".")[0];
-    this._init();
-  }
-  _init() {
-    this.nextCodePartIndex = 0;
-    this.fileContent = null;
-    this.imports = [];
-    this.importsObjects = [];
-    //this.pageClass = null;
-    //this.classProperties = [];
-    this.methods = [];
-    this.variables = [];
-    this.expressions = [];
-    this.orderedCodeParts = [];
-    this.cucumberCalls = [];
-  }
-  async save() {
-    if (this.sourceFileName !== null) {
-      // format the code before saving
-      try {
-        const fileContentNew = await prettier.format(this.fileContent, getDefaultPrettierConfig());
-        this._init();
-        this.generateModel(fileContentNew);
-      } catch (e) {
-        logger.info("failed to format the code");
-        logger.debug(e);
-      }
-      if (!existsSync(this.sourceFileName)) {
-        const stepDefinitionFolderPath = path.dirname(this.sourceFileName);
-        if (!existsSync(stepDefinitionFolderPath)) {
-          mkdirSync(stepDefinitionFolderPath, { recursive: true });
-        }
-      }
-      writeFileSync(this.sourceFileName, this.fileContent, "utf8");
-      return true;
-    } else {
-      logger.error("sourceFileName is null");
-      return false;
-    }
-  }
-
-  generateModel(fileContent = null) {
-    if (fileContent !== null) {
-      this.fileContent = fileContent;
-    } else {
-      if (!existsSync(this.sourceFileName)) {
-        const templateFilePath = path.join(__dirname, "../../assets", "templates", "page_template.txt");
-        const content = readFileSync(templateFilePath, "utf8");
-        this.fileContent = content;
-      } else {
-        this.fileContent = readFileSync(this.sourceFileName, "utf8");
-      }
-    }
-    const walker = new Walker();
-    let rootNode = null;
-    walker.walk(this.fileContent, (node) => {
-      if (
-        node.constructor.name === "SourceLocation" ||
-        node.constructor.name === "Position" ||
-        node.constructor.name === "Object"
-      ) {
-        return;
-      }
-      switch (node.type) {
-        case "ImportDeclaration":
-          this.addCodePart(node);
-          if (rootNode === null) {
-            rootNode = node;
-          }
-          break;
-        case "ExpressionStatement":
-        case "VariableDeclaration":
-          if (node.parent && node.parent.filter && node.parent.filter((n) => n === rootNode).length > 0) {
-            this.addCodePart(node);
-          }
-          break;
-        case "ClassDeclaration":
-        case "ClassProperty":
-          this.addCodePart(node);
-          break;
-        case "FunctionDeclaration":
-          this.addCodePart(node);
-          break;
-        default:
-          //console.log("node", node);
-          break;
-      }
-    });
-  }
-  addCodePart(node) {
-    const codePart = new CodePart(node, this.fileContent, this.nextCodePartIndex);
-    this.nextCodePartIndex++;
-    if (node.type === "ImportDeclaration") {
-      this.imports.push(codePart);
-      /*
-      Example of import object
-      this.imports[1].node.specifiers[0].type
-'ImportSpecifier'
-this.imports[2].node.specifiers[0].type
-'ImportDefaultSpecifier'
-this.imports[2].node.specifiers[0].local.name
-'fs'
-this.imports[1].node.specifiers[0].local.name
-'closeContext'
-this.imports[1].node.specifiers[0].imported.name
-'closeContext'
-this.imports[1].node.source.value
-'automation_model'
-this.imports[2].node.source.value
-'fs'
-      */
-      // extract the imports and initialize the importsObjects, create an object for each import specifiers
-      if (node.specifiers) {
-        const importsObjects = node.specifiers.map((specifier) => {
-          const importObject = {
-            type: specifier.type,
-            local: specifier.local.name,
-            imported: specifier.imported ? specifier.imported.name : null,
-            source: node.source.value,
-          };
-          return importObject;
-        });
-        this.importsObjects.push(...importsObjects);
-      }
-    } else if (node.type === "ExpressionStatement") {
-      if (
-        node.expression &&
-        node.expression.type === "CallExpression" &&
-        node.expression.callee &&
-        node.expression.arguments &&
-        (node.expression.arguments.length === 2 || node.expression.arguments.length === 3) &&
-        (node.expression.callee.name === "Given" ||
-          node.expression.callee.name === "When" ||
-          node.expression.callee.name === "Then" ||
-          node.expression.callee.name === "defineStep")
-      ) {
-        codePart.keyword = node.expression.callee.name;
-        codePart.pattern = node.expression.arguments[0].value
-          ? node.expression.arguments[0].value
-          : node.expression.arguments[0].pattern;
-        codePart.methodName = node.expression.arguments[node.expression.arguments.length - 1].name;
-        codePart.stepType = node.expression.callee.name;
-        this.cucumberCalls.push(codePart);
-      }
-      this.expressions.push(codePart);
-    } else if (node.type === "ClassDeclaration") {
-      //this.pageClass = codePart;
-    } else if (node.type === "ClassProperty") {
-      //this.classProperties.push(codePart);
-    } else if (node.type === "VariableDeclaration") {
-      if (
-        node.declarations &&
-        node.declarations.length > 0 &&
-        node.declarations[0].init &&
-        node.declarations[0].init.type === "ArrowFunctionExpression"
-      ) {
-        codePart.name = node.declarations[0].id.name;
-        this.methods.push(codePart);
-      } else {
-        this.variables.push(codePart);
-      }
-    } else if (node.type === "FunctionDeclaration" && node.id) {
-      this.methods.push(codePart);
-      codePart.name = node.id.name;
-    }
-  }
-  collectAllTemplates() {
-    const templates = [];
-    if (this.cucumberCalls.length > 0) {
-      for (let i = 0; i < this.cucumberCalls.length; i++) {
-        const cucumberCall = this.cucumberCalls[i];
-        let pattern = cucumberCall.pattern;
-        let methodName = cucumberCall.methodName;
-        let foundMethod = false;
-        let params = [];
-        let stepType = cucumberCall.stepType;
-        let firstFind = true;
-        let stepPaths = [];
-        for (let j = 0; j < this.methods.length; j++) {
-          const method = this.methods[j];
-          if (method.name === methodName) {
-            if (firstFind) {
-              foundMethod = true;
-              let paramsObj = method.node.params;
-              if (paramsObj && paramsObj.length > 0) {
-                params = paramsObj.map((param) => param.name);
-              }
-              firstFind = false;
-            }
-            stepPaths.push(method.path);
-          }
-        }
-        if (foundMethod) {
-          templates.push({ pattern, methodName, params, stepType, paths: stepPaths });
-        }
-      }
-    }
-    return templates;
-  }
-  getExpectedTimeout(expectedNumofCmds) {
-    return expectedNumofCmds * 60 * 1000;
-  }
-  addCucumberStep(type, cucumberLine, method, expectedNumofCmds) {
-    const result = {};
-    let code = "\n";
-    code += `${type}(${JSON.stringify(cucumberLine)}, ${expectedNumofCmds ? `{ timeout: ${this.getExpectedTimeout(expectedNumofCmds)}}, ` : ""}${method});\n`;
-    let existCodePart = null;
-    for (let i = 0; i < this.cucumberCalls.length; i++) {
-      if (
-        this.cucumberCalls[i].pattern === cucumberLine
-        //this.cucumberCalls[i].methodName === method &&
-        //this.cucumberCalls[i].keyword === type
-      ) {
-        existCodePart = this.cucumberCalls[i];
-        break;
-      }
-    }
-    result.cucumberLine = cucumberLine;
-    if (existCodePart) {
-      if (existCodePart.keyword === type || existCodePart.methodName === method) {
-        logger.debug(`step ${cucumberLine} already exist with the same code`);
-        result.status = CodeStatus.NO_CHANGE;
-        return result;
-      }
-      result.status = CodeStatus.UPDATED;
-      result.oldCode = existCodePart.codePart.trim();
-      result.newCode = code.trim();
-      logger.debug(`conflict in step ${result.cucumberLine}}`);
-      logger.debug("old code\n", result.oldCode);
-      logger.debug("new code\n", result.newCode);
-      this._replaceCode(code, existCodePart.start, existCodePart.end);
-      return result;
-    } else {
-      let injectIndex = this._getCucumberInjectionIndex();
-      this._insertCode(code, injectIndex);
-      result.status = CodeStatus.ADD;
-      result.newCode = code.trim();
-      return result;
-    }
-  }
-  addInfraCommand(methodName, description, stepVarables, stepCodeLines, protectStep = false, source = null, path = "") {
-    let code = "\n";
-    code += "/**\n";
-    code += ` * ${description}\n`;
-    //const keys = Object.keys(stepParameters);
-    let stepParametersMap = {};
-    // remove duplicates
-    let i = 1;
-    stepVarables.forEach((key) => {
-      if (stepParametersMap[key]) {
-        while (stepParametersMap[`${key}${i}`]) {
-          i++;
-        }
-        key = `${key}${i}`;
-      }
-      stepParametersMap[key] = key;
-    });
-    let stepVarablesNoDuplications = Object.keys(stepParametersMap).map((key) => "_" + convertToIdentifier(key));
-    if (stepVarables.length > stepVarablesNoDuplications.length) {
-      const varName = "dummy";
-      i = 1;
-      while (stepVarablesNoDuplications.length !== stepVarables.length) {
-        if (!stepVarablesNoDuplications.includes(`${varName}${i}`)) {
-          stepVarablesNoDuplications.push(`${varName}${i}`);
-        }
-        i++;
-      }
-    }
-
-    stepVarablesNoDuplications.forEach((key) => {
-      code += ` * @param {string} ${key} ${key.replaceAll("_", " ")}\n`;
-    });
-    let tags = [];
-    if (protectStep) {
-      tags.push("@protect");
-    }
-    if (source) {
-      tags.push(`@${source}`);
-    }
-    if (tags.length > 0) {
-      code += ` * ${tags.join(" ")}\n`;
-    }
-    if (path !== null) {
-      code += ` * @path=${escapeForComment(path)}\n`;
-    }
-    code += " */\n";
-    code += `async function ${methodName} (${stepVarablesNoDuplications.join(", ")}){\n`;
-    code += `// source: ${source}\n`;
-    code += `// implemented_at: ${new Date().toISOString()}\n`;
-    if (stepCodeLines.length > 0) {
-      code += `  const _params = { ${stepVarablesNoDuplications.join(", ")} };\n`;
-    } else {
-      code += "  const _params = {};\n";
-    }
-
-    // code += "  await navigate(path);\n";
-    stepCodeLines.forEach((line) => {
-      code += `  ${line}\n`;
-    });
-    code += "}\n";
-
-    return this._injectMethod(methodName, code);
-  }
-
-  _injectMethod(methodName, code) {
-    const result = {};
-    code = code.trim();
-    let existMethod = null;
-    for (let i = 0; i < this.methods.length; i++) {
-      if (this.methods[i].name === methodName) {
-        existMethod = this.methods[i];
-        break;
-      }
-    }
-    result.methodName = methodName;
-    if (existMethod) {
-      let oldCode = existMethod.codePart.trim();
-      if (oldCode === code) {
-        logger.debug(`method ${methodName} already exist with the same code`);
-        result.status = CodeStatus.NO_CHANGE;
-        return result;
-      }
-      logger.debug(`conflict in method ${methodName}}`);
-      logger.debug("old code\n", oldCode);
-      logger.debug("new code\n", code.trim());
-      this._replaceCode(code, existMethod.start, existMethod.end);
-      result.status = CodeStatus.UPDATED;
-      result.oldCode = oldCode;
-      result.newCode = code;
-      return result;
-    } else {
-      let injectIndex = this._getMethodInjectionIndex();
-      this._insertCode(code, injectIndex);
-      result.status = CodeStatus.ADD;
-      result.newCode = code;
-      return result;
-    }
-  }
-  isHumanMethod(methodName) {
-    // check if the fileSourceName end with utils.mjs
-    if (path.basename(this.sourceFileName) === "utils.mjs") {
-      return true;
-    }
-    let existMethod = null;
-    for (let i = 0; i < this.methods.length; i++) {
-      if (this.methods[i].name === methodName) {
-        existMethod = this.methods[i];
-        break;
-      }
-    }
-    if (!existMethod) {
-      return false;
-    }
-    const methodCode = existMethod.getCode();
-    if (methodCode && (methodCode.includes("@protect") || methodCode.includes("@human"))) {
-      return true;
-    }
-    return false;
-  }
-
-  _insertCode(code, injectIndex) {
-    let newFileContent =
-      this.fileContent.substring(0, injectIndex) + "\n" + code + this.fileContent.substring(injectIndex);
-
-    this._init();
+    if (ai_config)
+        return ai_config;
     try {
-      this.generateModel(newFileContent);
-    } catch (e) {
-      logger.error("new code ####\n" + newFileContent);
-      throw e;
-    }
-  }
-
-  _elementToCode(key, element) {
-    let code = "";
-    code += `  ${key}:${JSON.stringify(element)}`;
-
-    return code;
-  }
-
-  _removeScoresFromElement(element) {
-    if (!element || !element.locators) {
-      return element;
-    }
-    // clone the element
-    element = JSON.parse(JSON.stringify(element));
-    for (let i = 0; i < element.locators.length; i++) {
-      let locator = element.locators[i];
-      if (locator.score) {
-        delete locator.score;
-      }
-    }
-    return element;
-  }
-  insertElements(elements) {
-    let code = "const elements = {\n";
-    const keys = Object.keys(elements);
-    const lines = [];
-    keys.forEach((key) => {
-      let element = this._removeScoresFromElement(elements[key]);
-      lines.push(this._elementToCode(key, element));
-    });
-    code += lines.join(",\n");
-    code += "\n};";
-    let startEnd = this._getVariableStartEnd("elements");
-    this._replaceCode(code, startEnd[0], startEnd[1]);
-  }
-  removeUnusedElements() {
-    const usedElementsKeys = this.getUsedElementsKeys();
-    const elements = this.getVariableDeclarationAsObject("elements");
-    const keys = Object.keys(elements);
-    const unusedKeys = keys.filter((key) => !usedElementsKeys.includes(key));
-    if (unusedKeys.length === 0) {
-      return;
-    }
-    for (let i = 0; i < unusedKeys.length; i++) {
-      delete elements[unusedKeys[i]];
-    }
-    this.insertElements(elements);
-  }
-
-  getUsedElementsKeys() {
-    const regexp = /elements\[[\n\r\W]*"([^"]+)"[\n\r\W]*\]/g;
-    const keys = [];
-    let match;
-    while ((match = regexp.exec(this.fileContent)) !== null) {
-      keys.push(match[1]);
-    }
-    return keys;
-  }
-  _replaceCode(code, injectIndexStart, injectIndexEnd) {
-    let newFileContent =
-      this.fileContent.substring(0, injectIndexStart) + code + this.fileContent.substring(injectIndexEnd);
-    this._init();
-    this.generateModel(newFileContent);
-  }
-  _getMethodInjectionIndex() {
-    return this.fileContent.length;
-  }
-  _getCucumberInjectionIndex() {
-    return this.fileContent.length;
-  }
-  addLocatorsMetadata(locatorsMetadata) {
-    // create a file name based on the source file name replace .mjs with .json
-    let locatorsMetadataFileName = this.sourceFileName.replace(".mjs", ".json");
-    const config = getAiConfig();
-    if (config && config.locatorsMetadataDir) {
-      // if config.locatorsMetadataDir is set, use it to create the file path
-      locatorsMetadataFileName = path.join(config.locatorsMetadataDir, path.basename(locatorsMetadataFileName));
-      // check if the directory exists, if not create it
-      if (!existsSync(path.dirname(locatorsMetadataFileName))) {
-        mkdirSync(path.dirname(locatorsMetadataFileName), { recursive: true });
-      }
-    }
-    let metadata = {};
-    // try to read the file to metadata, protect with try catch
-    try {
-      // if the file exist read the content and parse it
-      if (existsSync(locatorsMetadataFileName)) {
-        metadata = JSON.parse(readFileSync(locatorsMetadataFileName, "utf8"));
-      }
-    } catch (e) {
-      logger.info("failed to read locators metadata file", locatorsMetadataFileName);
-    }
-    // merge the locatorsMetadata with the metadata
-    // go over all the keys in locatorsMetadata and add them to metadata
-    const keys = Object.keys(locatorsMetadata);
-    keys.forEach((key) => {
-      metadata[key] = locatorsMetadata[key];
-    });
-    // save the metadata back to the file
-    try {
-      writeFileSync(locatorsMetadataFileName, JSON.stringify(metadata, null, 2), "utf8");
-    } catch (e) {
-      logger.info("failed to write locators metadata file", locatorsMetadataFileName);
-    }
-  }
-  _getVariableStartEnd(variableName) {
-    const codePart = this.variables.filter((cp) => cp.node.declarations[0].id.name === variableName)[0];
-    if (codePart === undefined) {
-      return null;
-    }
-    return [codePart.node.start, codePart.node.end];
-  }
-  getVariableDeclarationCode(variableName) {
-    const codePart = this.variables.filter((cp) => cp.node.declarations[0].id.name === variableName)[0];
-    if (codePart === undefined) {
-      return null;
-    }
-    return codePart.codePart;
-  }
-  getVariableDeclarationAsObject(variableName) {
-    const code = this.getVariableDeclarationCode(variableName);
-    if (code === null) {
-      return null;
-    }
-    let value = null;
-    let vmContext = {
-      console: console,
-      value: value,
-    };
-    vm.createContext(vmContext);
-    vm.runInContext(code + "\nvalue = " + variableName + ";", vmContext);
-    //console.log("value", vmContext.value);
-    return vmContext.value;
-  }
-  getName() {
-    let base = path.parse(this.sourceFileName).base.split(".")[0];
-    if (base.endsWith("_page")) {
-      base = base.substring(0, base.length - 5);
-    }
-    return base;
-  }
-
-  getMethodsNames() {
-    const methods = [];
-    this.methods.forEach((codePart) => {
-      if (this.codePart.name && !codePart.name.startsWith("_")) {
-        methods.push(codePart.name);
-      }
-    });
-    return methods;
-  }
-  getMethodParametersValues(methodName, parameters) {
-    const params = this.getMethodParameters(methodName);
-    const values = [];
-    for (let i = 0; i < params.length; i++) {
-      const param = params[i];
-      values.push(parameters[param]);
-    }
-    return values;
-  }
-
-  getMethodParameters(methodName) {
-    const codePart = this.methods.find((cp) => cp.name === methodName);
-
-    if (!codePart) {
-      // Handle the case where methodName is not found
-      return [];
-    }
-
-    const params = codePart.node.value.params;
-    return params.map((param) => param.name);
-  }
-  /*
-  importsObjects example
-  {
-  type: 'ImportSpecifier',
-  local: 'Given',
-  imported: 'Given',
-  source: '@dev-blinq/cucumber-js'
-  }
-  code example
-  const fs = await import('fs');
-  */
-  getImportCode(excludeSources = []) {
-    let code = "";
-    this.importsObjects.forEach((importObject) => {
-      if (excludeSources.includes(importObject.source)) {
-        return;
-      }
-      if (importObject.type === "ImportSpecifier") {
-        code += `const { ${importObject.local} } = require('${importObject.source}');\n`;
-      } else if (importObject.type === "ImportDefaultSpecifier") {
-        code += `const ${importObject.local} = require('${importObject.source}');\n`;
-      }
-    });
-    return code;
-  }
-
-  getCodeWithoutImports(removeCucumber = true) {
-    let text = this.fileContent;
-    if (removeCucumber) {
-      const expressionsLoc = [];
-      this.expressions.forEach((codePart) => {
-        expressionsLoc.push([codePart.start, codePart.end]);
-      });
-      text = cutSubString(text, expressionsLoc);
-    }
-    let lastImportEnd = 0;
-    this.imports.forEach((codePart) => {
-      lastImportEnd = codePart.end;
-    });
-
-    text = text.substring(lastImportEnd);
-
-    // if a line starts with export follow by async or function, remove the export
-    text = text.replace(/^\s*export\s+(?=async\s+function|function)/gm, "");
-    return text;
-  }
-  hasMethod(methodName) {
-    return this.methods.filter((cp) => cp.name === methodName).length > 0;
-  }
-  _getMethodComments(methodName) {
-    const codePart = this.methods.filter((cp) => cp.name === methodName)[0];
-    if (codePart === undefined) {
-      return null;
-    }
-    const comments = codePart.node.leadingComments;
-    if (comments === undefined || comments.length === 0) {
-      return null;
-    }
-    const commentsValues = comments.map((comment) => comment.value);
-    return commentsValues.join("\n");
-  }
-  /**
-   * get the description and parameters of a method
-   * @param {string} methodName
-   * @returns a dictionary with name, description and params
-   */
-  getMethodCommentsData(methodName) {
-    const codePart = this.methods.filter((cp) => cp.name === methodName)[0];
-    if (codePart === undefined) {
-      return null;
-    }
-    const comments = codePart.node.leadingComments;
-    if (comments === undefined || comments.length === 0) {
-      return null;
-    }
-    const commentsValues = comments.map((comment) => comment.value);
-    const fullCommentText = commentsValues.join("\n");
-    // split trim and remove * if exist from the beginning of each line
-    const commentLines = fullCommentText.split("\n").map((line) => line.trim().replace(/^\*/, "").trim());
-    const descriptions = [];
-    for (let i = 0; i < commentLines.length; i++) {
-      const line = commentLines[i];
-      if (!line) {
-        continue;
-      }
-      if (line.startsWith("@")) {
-        break;
-      }
-      descriptions.push(line);
-    }
-    // join the descriptions into one line seperated by '.' and replace 2 dots with 1
-    const description = descriptions.join(".").replace("..", ".");
-    // extract parameters from the comment
-    const params = [];
-    for (let i = 0; i < commentLines.length; i++) {
-      const line = commentLines[i];
-      if (line.startsWith("@param")) {
-        params.push(this._processParametersLine(line));
-      }
-    }
-    return { name: methodName, description, params };
-  }
-
-  /**
-   * get the method in a format that can be used in the gpt prompt
-   * @param {string} methodName
-   * @returns a string formated to be used in the commands gpt prompt
-   */
-  getMethodInCommandFormat(methodName) {
-    const methodComment = this.getMethodCommentsData(methodName);
-    if (methodComment === null) {
-      return null;
-    }
-    return `${methodName}: ${methodComment.description}, args: ${methodComment.params
-      .map((p) => `"${p.name}": "<${p.description.replaceAll(" ", "_")}>"`)
-      .join(", ")}`;
-  }
-
-  _processParametersLine(paramLine) {
-    // split by multiple spaces
-    const paramParts = paramLine.split(/\s+/);
-    // remove @param
-    paramParts.shift();
-    // remove type
-    let type = null;
-    if (paramParts.length > 0 && paramParts[0].startsWith("{") && paramParts[0].endsWith("}")) {
-      type = paramParts.shift().replace("{", "").replace("}", "");
-    }
-    let name = null;
-    if (paramParts.length > 0) {
-      name = paramParts.shift();
-    }
-    let description = null;
-    if (paramParts.length > 0) {
-      description = paramParts.join(" ");
-    }
-    return { type, name, description };
-  }
-  getMethodCodePart(methodName) {
-    const codePart = this.methods.filter((cp) => cp.name === methodName)[0];
-    if (codePart === undefined) {
-      return null;
-    }
-    return codePart;
-  }
-
-  getStepDefinitionBreakdown(methodName) {
-    const codePart = this.methods.filter((cp) => cp.name === methodName)[0];
-    if (codePart === undefined) {
-      return null;
-    }
-    const parametersNames = [];
-    if (codePart.node && codePart.node.body && codePart.node.body.parent && codePart.node.body.parent.params) {
-      codePart.node.body.parent.params.forEach((param) => {
-        parametersNames.push(param.name);
-      });
-    }
-
-    const commands = [];
-    if (
-      codePart.node &&
-      codePart.node.type === "FunctionDeclaration" &&
-      codePart.node.body &&
-      codePart.node.body.body &&
-      codePart.node.body.body.length > 0
-    ) {
-      const codeBody = codePart.node.body.body;
-      for (let i = 0; i < codeBody.length; i++) {
-        const code = codeBody[i];
-        commands.push({
-          type: code.type,
-          code: this.fileContent.substring(code.start, code.end),
-        });
-      }
-    }
-    return { codeCommands: commands, parametersNames };
-  }
-  hasStep(step) {
-    // go over expressions for, looking for expression that starts with Given, When or Then
-    // Then you can find white spaces or new lines, follow by double quotes and the step
-    // For example:
-    // "When(\n  \"create new opportunity, account: {string}, name: {string}, close date: {string}, stage: {string}, forcast: {string}\",\n  create_new_opportunity_account_account_name_name_close_date_closedate_stage_stage_forcast_forcast\n);"
-    // the step is everything between the double quotes
-    const regexp = new RegExp(`"${step}"`, "g");
-    for (let i = 0; i < this.cucumberCalls.length; i++) {
-      const expression = this.cucumberCalls[i];
-      if (expression.codePart) {
-        if (expression.codePart.match(regexp)) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-  hasFunctionName(functionName) {
-    // go over all the methods and compare the name field to the functionName
-    for (let i = 0; i < this.methods.length; i++) {
-      if (this.methods[i].name === functionName) {
-        return true;
-      }
-      return false;
+        ai_config = JSON.parse(readFileSync("ai_config.json", "utf8"));
+    }
+    catch {
+        ai_config = {};
+    }
+    if (!ai_config.locatorsMetadataDir) {
+        ai_config.locatorsMetadataDir = "features/step_definitions/locators";
     }
-  }
+    return ai_config;
 }
-
 function getPath(comment) {
-  const index = comment.indexOf("@path=");
-  if (index === -1) {
-    return null;
-  }
-  return comment.substring(index).split("\n")[0].substring(6);
+    const index = comment.indexOf("@path=");
+    if (index === -1)
+        return null;
+    return comment.substring(index).split("\n")[0].substring(6);
 }
-
 class CodePart {
-  constructor(node, fileContent, index, codePart = null) {
-    this.node = node;
-    this.name = null;
-    this.keyword = null;
-    this.pattern = null;
-    this.methodName = null;
-    this.fileContent = fileContent;
-    if (this.node !== null) {
-      this.start = node.loc.start.index;
-      if (node.leadingComments && node.leadingComments.length > 0) {
-        this.start = node.leadingComments[0].start;
-        this.path = getPath(node.leadingComments[0].value);
-      }
-      this.end = node.loc.end.index;
-      this.codePart = fileContent.substring(this.start, this.end);
-      if (this.declarations && this.declarations.length > 0 && this.declarations[0].id) {
-        this.name = this.declarations[0].id.name;
-      }
-    } else {
-      this.pagePart = codePart;
-      this.start = -1;
-      this.end = -1;
-    }
-    this.index = index;
-  }
-  getCode() {
-    if (this.start === -1 || this.end === -1) {
-      return null;
-    }
-    return this.fileContent.substring(this.start, this.end);
-  }
-  equals(codePart) {
-    const maskedCodePart = this.codePart
-      .replace(this.methodName, "")
-      .replace(this.name, "")
-      .replaceAll(/\s/g, "")
-      .trim();
-    const maskedCodePart2 = codePart.codePart
-      .replace(codePart.methodName, "")
-      .replace(codePart.name, "")
-      .replaceAll(/\s/g, "")
-      .trim();
-    return {
-      status: maskedCodePart === maskedCodePart2,
-      line: maskedCodePart,
-      lineRef: maskedCodePart2,
-    };
-  }
-  getMethodType() {
-    // use regex to find the following patern: // source: api
-    const patern = /\s+source:\s*([a-zA-Z]+)/;
-    if (this.codePart.match(patern)) {
-      return this.codePart.match(patern)[1];
-    }
-    return null;
-  }
-  getVariableDeclerationObject(declaratinName) {
-    if (!this.node || !this.node.body || !this.node.body.body || this.node.body.body.length === 0) {
-      return null;
-    }
-    const body = this.node.body.body;
-    for (let i = 0; i < body.length; i++) {
-      const code = body[i];
-      if (code.type === "VariableDeclaration") {
-        if (!code.declarations || code.declarations.length === 0) {
-          continue;
-        }
-        const declaration = code.declarations[0];
-        if (declaration.id && declaration.id.name === declaratinName) {
-          const declerationCode = this.fileContent.substring(declaration.start, declaration.end);
-          let value = null;
-          let vmContext = {
-            console: console,
-            value: value,
-          };
-          vm.createContext(vmContext);
-          vm.runInContext("value = " + declerationCode + ";", vmContext);
-          //console.log("value", vmContext.value);
-          return vmContext.value;
-        }
-      }
-    }
-    return null;
-  }
+    node;
+    name = null;
+    keyword = null;
+    pattern = null;
+    methodName = null;
+    fileContent;
+    start = -1;
+    end = -1;
+    codePart = "";
+    index;
+    path;
+    stepType;
+    constructor(node, fileContent, index, codePart = null) {
+        this.node = node;
+        this.fileContent = fileContent;
+        if (this.node !== null) {
+            this.start = this.node.loc.start.index;
+            if (this.node.leadingComments && this.node.leadingComments.length > 0) {
+                this.start = this.node.leadingComments[0].start;
+                this.path = getPath(this.node.leadingComments[0].value);
+            }
+            this.end = this.node.loc.end.index;
+            this.codePart = fileContent.substring(this.start, this.end);
+            // NOTE: the original code checked this.declarations etc.; keeping equivalent behavior is tricky here.
+            // Those properties exist on VariableDeclaration nodes, not on CodePart.
+            // We leave 'name' to be assigned in CodePage.addCodePart where appropriate.
+        }
+        else {
+            this.codePart = codePart ?? "";
+            this.start = -1;
+            this.end = -1;
+        }
+        this.index = index;
+    }
+    getCode() {
+        if (this.start === -1 || this.end === -1)
+            return null;
+        return this.fileContent.substring(this.start, this.end);
+    }
+    equals(other) {
+        const maskedA = this.codePart
+            .replace(this.methodName ?? "", "")
+            .replace(this.name ?? "", "")
+            .replaceAll(/\s/g, "")
+            .trim();
+        const maskedB = other.codePart
+            .replace(other.methodName ?? "", "")
+            .replace(other.name ?? "", "")
+            .replaceAll(/\s/g, "")
+            .trim();
+        return { status: maskedA === maskedB, line: maskedA, lineRef: maskedB };
+    }
+    getMethodType() {
+        const pattern = /\s+source:\s*([a-zA-Z]+)/;
+        const match = this.codePart.match(pattern);
+        return match ? match[1] : null;
+    }
+    getVariableDeclerationObject(declaratinName) {
+        if (!this.node || !this.node.body || !this.node.body.body || this.node.body.body.length === 0)
+            return null;
+        const body = this.node.body.body;
+        for (let i = 0; i < body.length; i++) {
+            const code = body[i];
+            if (code.type === "VariableDeclaration") {
+                if (!code.declarations || code.declarations.length === 0)
+                    continue;
+                const declaration = code.declarations[0];
+                if (declaration.id && declaration.id.name === declaratinName) {
+                    const declerationCode = this.fileContent.substring(declaration.start, declaration.end);
+                    const vmContext = { console, value: null };
+                    vm.createContext(vmContext);
+                    vm.runInContext("value = " + declerationCode + ";", vmContext);
+                    return vmContext.value;
+                }
+            }
+        }
+        return null;
+    }
 }
-
 const cutSubString = (str, substrings) => {
-  let result = str;
-  let offset = 0;
-  substrings.forEach((substring) => {
-    const start = substring[0];
-    const end = substring[1];
-    result = result.substring(0, start - offset) + result.substring(end - offset);
-    offset += end - start;
-  });
-  return result;
+    let result = str;
+    let offset = 0;
+    substrings.forEach(([start, end]) => {
+        result = result.substring(0, start - offset) + result.substring(end - offset);
+        offset += end - start;
+    });
+    return result;
 };
-
-// function stringifyObject(obj, indent = 4, currentIndent = "") {
-//   if (typeof obj !== "object" || obj === null) {
-//     return JSON.stringify(obj);
-//   }
-
-//   if (Array.isArray(obj)) {
-//     const items = obj.map(
-//       (item) =>
-//         `${currentIndent}${" ".repeat(indent)}${stringifyObject(item, indent, currentIndent + " ".repeat(indent))}`
-//     );
-//     return `[\n${items.join(",\n")}\n${currentIndent}]`;
-//   }
-
-//   const keys = Object.keys(obj);
-//   const keyValues = keys.map(
-//     (key) =>
-//       `${currentIndent}${" ".repeat(indent)}${key}: ${stringifyObject(
-//         obj[key],
-//         indent,
-//         currentIndent + " ".repeat(indent)
-//       )}`
-//   );
-
-//   return `{\n${keyValues.join(",\n")}\n${currentIndent}}`;
-// }
-export { CodePage, CodeStatus };
+export class CodePage {
+    sourceFileName;
+    cleanFileName;
+    nextCodePartIndex;
+    fileContent;
+    imports;
+    importsObjects;
+    methods;
+    variables;
+    expressions;
+    orderedCodeParts;
+    cucumberCalls;
+    constructor(sourceFileName = null) {
+        this.sourceFileName = sourceFileName;
+        this.cleanFileName = sourceFileName && path.basename(sourceFileName).split(".")[0];
+        this._init();
+    }
+    _init() {
+        this.nextCodePartIndex = 0;
+        this.fileContent = ""; // will be set in generateModel
+        this.imports = [];
+        this.importsObjects = [];
+        this.methods = [];
+        this.variables = [];
+        this.expressions = [];
+        this.orderedCodeParts = [];
+        this.cucumberCalls = [];
+    }
+    async save() {
+        if (this.sourceFileName !== null) {
+            try {
+                const fileContentNew = await prettier.format(this.fileContent, getDefaultPrettierConfig());
+                this._init();
+                this.generateModel(fileContentNew);
+            }
+            catch (e) {
+                logger.info("failed to format the code");
+                logger.debug(e);
+            }
+            if (!existsSync(this.sourceFileName)) {
+                const stepDefinitionFolderPath = path.dirname(this.sourceFileName);
+                if (!existsSync(stepDefinitionFolderPath)) {
+                    mkdirSync(stepDefinitionFolderPath, { recursive: true });
+                }
+            }
+            writeFileSync(this.sourceFileName, this.fileContent, "utf8");
+            return true;
+        }
+        else {
+            logger.error("sourceFileName is null");
+            return false;
+        }
+    }
+    generateModel(fileContent = null) {
+        if (fileContent !== null) {
+            this.fileContent = fileContent;
+        }
+        else {
+            if (!this.sourceFileName || !existsSync(this.sourceFileName)) {
+                const templateFilePath = path.join(__dirname, "../../assets", "templates", "page_template.txt");
+                const content = readFileSync(templateFilePath, "utf8");
+                this.fileContent = content;
+            }
+            else {
+                this.fileContent = readFileSync(this.sourceFileName, "utf8");
+            }
+        }
+        const walker = new Walker();
+        let rootNode = null;
+        walker.walk(this.fileContent, (node) => {
+            if (node.constructor.name === "SourceLocation" ||
+                node.constructor.name === "Position" ||
+                node.constructor.name === "Object") {
+                return;
+            }
+            switch (node.type) {
+                case "ImportDeclaration":
+                    this.addCodePart(node);
+                    if (rootNode === null) {
+                        rootNode = node;
+                    }
+                    break;
+                case "ExpressionStatement":
+                case "VariableDeclaration":
+                    if (node.parent && node.parent.filter && node.parent.filter((n) => n === rootNode).length > 0) {
+                        this.addCodePart(node);
+                    }
+                    break;
+                case "ClassDeclaration":
+                case "ClassProperty":
+                case "FunctionDeclaration":
+                    this.addCodePart(node);
+                    break;
+                default:
+                    break;
+            }
+        });
+    }
+    addCodePart(node) {
+        const codePart = new CodePart(node, this.fileContent, this.nextCodePartIndex);
+        this.nextCodePartIndex++;
+        if (node.type === "ImportDeclaration") {
+            this.imports.push(codePart);
+            // Build ImportObject(s)
+            if (node.specifiers) {
+                const importsObjects = node.specifiers.map((specifier) => {
+                    const importObject = {
+                        type: specifier.type,
+                        local: specifier.local.name,
+                        imported: specifier.imported ? specifier.imported.name : null,
+                        source: node.source.value,
+                    };
+                    return importObject;
+                });
+                this.importsObjects.push(...importsObjects);
+            }
+        }
+        else if (node.type === "ExpressionStatement") {
+            if (node.expression &&
+                node.expression.type === "CallExpression" &&
+                node.expression.callee &&
+                node.expression.arguments &&
+                (node.expression.arguments.length === 2 || node.expression.arguments.length === 3) &&
+                (node.expression.callee.name === "Given" ||
+                    node.expression.callee.name === "When" ||
+                    node.expression.callee.name === "Then" ||
+                    node.expression.callee.name === "defineStep")) {
+                codePart.keyword = node.expression.callee.name;
+                codePart.pattern = node.expression.arguments[0].value
+                    ? node.expression.arguments[0].value
+                    : node.expression.arguments[0].pattern;
+                codePart.methodName = node.expression.arguments[node.expression.arguments.length - 1].name;
+                codePart.stepType = node.expression.callee.name;
+                this.cucumberCalls.push(codePart);
+            }
+            this.expressions.push(codePart);
+        }
+        else if (node.type === "VariableDeclaration") {
+            if (node.declarations &&
+                node.declarations.length > 0 &&
+                node.declarations[0].init &&
+                node.declarations[0].init.type === "ArrowFunctionExpression") {
+                codePart.name = node.declarations[0].id.name;
+                this.methods.push(codePart);
+            }
+            else {
+                this.variables.push(codePart);
+            }
+        }
+        else if (node.type === "FunctionDeclaration" && node.id) {
+            this.methods.push(codePart);
+            codePart.name = node.id.name;
+        }
+    }
+    collectAllTemplates() {
+        const templates = [];
+        if (this.cucumberCalls.length > 0) {
+            for (let i = 0; i < this.cucumberCalls.length; i++) {
+                const cucumberCall = this.cucumberCalls[i];
+                const pattern = (cucumberCall.pattern ?? "");
+                const methodName = (cucumberCall.methodName ?? "");
+                let foundMethod = false;
+                let params = [];
+                const stepType = cucumberCall["stepType"];
+                let firstFind = true;
+                const stepPaths = [];
+                for (let j = 0; j < this.methods.length; j++) {
+                    const method = this.methods[j];
+                    if (method.name === methodName) {
+                        if (firstFind) {
+                            foundMethod = true;
+                            const paramsObj = (method.node?.params ?? []);
+                            if (paramsObj && paramsObj.length > 0) {
+                                params = paramsObj.map((p) => p.name);
+                            }
+                            firstFind = false;
+                        }
+                        stepPaths.push(method.path ?? "");
+                    }
+                }
+                if (foundMethod) {
+                    templates.push({ pattern, methodName, params, stepType, paths: stepPaths });
+                }
+            }
+        }
+        return templates;
+    }
+    getExpectedTimeout(expectedNumofCmds, finalTimeout) {
+        const timeoutNum = typeof finalTimeout === "string" ? parseFloat(finalTimeout) : finalTimeout;
+        if (finalTimeout !== undefined && !isNaN(timeoutNum)) {
+            return -1;
+        }
+        return (expectedNumofCmds ?? 0) * 60 * 1000;
+    }
+    addCucumberStep(type, cucumberLine, method, expectedNumofCmds, finalTimeout) {
+        let result = {};
+        let code = "\n";
+        code += `${type}(${JSON.stringify(cucumberLine)}, ${expectedNumofCmds ? `{ timeout: ${this.getExpectedTimeout(expectedNumofCmds, finalTimeout)}}, ` : ""}${method});\n`;
+        let existCodePart = null;
+        for (let i = 0; i < this.cucumberCalls.length; i++) {
+            if (this.cucumberCalls[i].pattern === cucumberLine) {
+                existCodePart = this.cucumberCalls[i];
+                break;
+            }
+        }
+        result.cucumberLine = cucumberLine;
+        if (existCodePart) {
+            if (existCodePart.keyword === type || existCodePart.methodName === method) {
+                logger.debug(`step ${cucumberLine} already exist with the same code`);
+                result.status = CodeStatus.NO_CHANGE;
+                return result;
+            }
+            result.status = CodeStatus.UPDATED;
+            result.oldCode = existCodePart.codePart.trim();
+            result.newCode = code.trim();
+            logger.debug(`conflict in step ${result.cucumberLine}}`);
+            logger.debug("old code\n", result.oldCode);
+            logger.debug("new code\n", result.newCode);
+            this._replaceCode(code, existCodePart.start, existCodePart.end);
+            return result;
+        }
+        else {
+            const injectIndex = this._getCucumberInjectionIndex();
+            this._insertCode(code, injectIndex);
+            result.status = CodeStatus.ADD;
+            result.newCode = code.trim();
+            return result;
+        }
+    }
+    addInfraCommand(methodName, description, stepVarables, stepCodeLines, protectStep = false, source = null, codePath = "") {
+        let code = "\n";
+        code += "/**\n";
+        code += ` * ${description}\n`;
+        const stepParametersMap = {};
+        let i = 1;
+        stepVarables.forEach((origKey) => {
+            let key = origKey;
+            if (stepParametersMap[key]) {
+                while (stepParametersMap[`${key}${i}`])
+                    i++;
+                key = `${key}${i}`;
+            }
+            stepParametersMap[key] = key;
+        });
+        const stepVarablesNoDuplications = Object.keys(stepParametersMap).map((k) => "_" + convertToIdentifier(k));
+        if (stepVarables.length > stepVarablesNoDuplications.length) {
+            const varName = "dummy";
+            i = 1;
+            while (stepVarablesNoDuplications.length !== stepVarables.length) {
+                if (!stepVarablesNoDuplications.includes(`${varName}${i}`)) {
+                    stepVarablesNoDuplications.push(`${varName}${i}`);
+                }
+                i++;
+            }
+        }
+        stepVarablesNoDuplications.forEach((k) => {
+            code += ` * @param {string} ${k} ${k.replaceAll("_", " ")}\n`;
+        });
+        const tags = [];
+        if (protectStep)
+            tags.push("@protect");
+        if (source)
+            tags.push(`@${source}`);
+        if (tags.length > 0)
+            code += ` * ${tags.join(" ")}\n`;
+        if (codePath !== null)
+            code += ` * @path=${escapeForComment(codePath)}\n`;
+        code += " */\n";
+        code += `async function ${methodName} (${stepVarablesNoDuplications.join(", ")}){\n`;
+        code += `// source: ${source}\n`;
+        code += `// implemented_at: ${new Date().toISOString()}\n`;
+        if (stepCodeLines.length > 0) {
+            code += `  const _params = { ${stepVarablesNoDuplications.join(", ")} };\n`;
+        }
+        else {
+            code += "  const _params = {};\n";
+        }
+        stepCodeLines.forEach((line) => (code += `  ${line}\n`));
+        code += "}\n";
+        return this._injectMethod(methodName, code);
+    }
+    _injectMethod(methodName, code) {
+        const result = { methodName };
+        code = code.trim();
+        let existMethod = null;
+        for (let i = 0; i < this.methods.length; i++) {
+            if (this.methods[i].name === methodName) {
+                existMethod = this.methods[i];
+                break;
+            }
+        }
+        if (existMethod) {
+            const oldCode = existMethod.codePart.trim();
+            if (oldCode === code) {
+                logger.debug(`method ${methodName} already exist with the same code`);
+                result.status = CodeStatus.NO_CHANGE;
+                return result;
+            }
+            logger.debug(`conflict in method ${methodName}}`);
+            logger.debug("old code\n", oldCode);
+            logger.debug("new code\n", code.trim());
+            this._replaceCode(code, existMethod.start, existMethod.end);
+            result.status = CodeStatus.UPDATED;
+            result.oldCode = oldCode;
+            result.newCode = code;
+            return result;
+        }
+        else {
+            const injectIndex = this._getMethodInjectionIndex();
+            this._insertCode(code, injectIndex);
+            result.status = CodeStatus.ADD;
+            result.newCode = code;
+            return result;
+        }
+    }
+    isHumanMethod(methodName) {
+        if (this.sourceFileName && path.basename(this.sourceFileName) === "utils.mjs")
+            return true;
+        let existMethod = null;
+        for (let i = 0; i < this.methods.length; i++) {
+            if (this.methods[i].name === methodName) {
+                existMethod = this.methods[i];
+                break;
+            }
+        }
+        if (!existMethod)
+            return false;
+        const methodCode = existMethod.getCode();
+        if (methodCode && (methodCode.includes("@protect") || methodCode.includes("@human"))) {
+            return true;
+        }
+        return false;
+    }
+    _insertCode(code, injectIndex) {
+        const newFileContent = this.fileContent.substring(0, injectIndex) + "\n" + code + this.fileContent.substring(injectIndex);
+        this._init();
+        try {
+            this.generateModel(newFileContent);
+        }
+        catch (e) {
+            logger.error("new code ####\n" + newFileContent);
+            throw e;
+        }
+    }
+    _elementToCode(key, element) {
+        let code = "";
+        code += `  ${key}:${JSON.stringify(element)}`;
+        return code;
+    }
+    _removeScoresFromElement(element) {
+        if (!element || !element.locators)
+            return element;
+        const clone = JSON.parse(JSON.stringify(element));
+        for (let i = 0; i < (clone.locators?.length ?? 0); i++) {
+            const locator = clone.locators[i];
+            if (locator.score)
+                delete locator.score;
+        }
+        return clone;
+    }
+    insertElements(elements) {
+        let code = "const elements = {\n";
+        const keys = Object.keys(elements);
+        const lines = [];
+        keys.forEach((key) => {
+            const element = this._removeScoresFromElement(elements[key]);
+            lines.push(this._elementToCode(key, element));
+        });
+        code += lines.join(",\n");
+        code += "\n};";
+        const startEnd = this._getVariableStartEnd("elements");
+        if (startEnd) {
+            this._replaceCode(code, startEnd[0], startEnd[1]);
+        }
+    }
+    mergeSimilarElements() {
+        const elements = this.getVariableDeclarationAsObject("elements");
+        if (elements === null)
+            return;
+        const keys = Object.keys(elements);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (!elements[key].element_key) {
+                elements[key].element_key = key;
+            }
+        }
+        const replacedKeys = {};
+        const mergedElements = {};
+        for (let i = keys.length - 1; i >= 0; i--) {
+            const currentElement = elements[keys[i]];
+            let foundMatch = false;
+            for (let j = i - 1; j >= 0; j--) {
+                const nextElement = elements[keys[j]];
+                if (this._isSimilarElement(currentElement, nextElement)) {
+                    mergedElements[currentElement.element_key] = currentElement;
+                    replacedKeys[nextElement.element_key] = currentElement.element_key;
+                    foundMatch = true;
+                    keys.splice(j, 1);
+                    i--;
+                    j++;
+                }
+            }
+            if (!foundMatch) {
+                mergedElements[currentElement.element_key] = currentElement;
+            }
+        }
+        if (Object.keys(replacedKeys).length === 0)
+            return;
+        for (const key in replacedKeys) {
+            const regexp = new RegExp(`elements\\[\\s*["']${key}["']\\s*\\]`, "g");
+            this.fileContent = this.fileContent.replace(regexp, () => `elements["${replacedKeys[key]}"]`);
+        }
+        this.insertElements(mergedElements);
+    }
+    _isSimilarElement(element1, element2) {
+        if (!element1 || !element2)
+            return false;
+        const locs1 = Array.isArray(element1.locators) ? element1.locators : [];
+        const locs2 = Array.isArray(element2.locators) ? element2.locators : [];
+        if (locs1.length === 0 && locs2.length === 0)
+            return false;
+        if (locs1.length === 0 || locs2.length === 0)
+            return false;
+        const moreLocatorsElement = locs1.length >= locs2.length ? locs1 : locs2;
+        const lessLocatorsElement = locs1.length >= locs2.length ? locs2 : locs1;
+        const locatorIncludes = (hay, needle) => {
+            if (hay == null || needle == null)
+                return false;
+            const KEYS = ["css", "index", "text", "climb"];
+            for (const k of KEYS) {
+                if (needle[k] !== undefined) {
+                    if (!(k in hay))
+                        return false;
+                    if (hay[k] !== needle[k])
+                        return false;
+                }
+            }
+            return true;
+        };
+        for (const less of lessLocatorsElement) {
+            const match = moreLocatorsElement.some((more) => locatorIncludes(more, less));
+            if (!match)
+                return false;
+        }
+        return true;
+    }
+    removeUnusedElements() {
+        const usedElementsKeys = this.getUsedElementsKeys();
+        const elements = this.getVariableDeclarationAsObject("elements");
+        if (!elements)
+            return;
+        const keys = Object.keys(elements);
+        const unusedKeys = keys.filter((key) => !usedElementsKeys.includes(key));
+        if (unusedKeys.length === 0)
+            return;
+        for (let i = 0; i < unusedKeys.length; i++) {
+            delete elements[unusedKeys[i]];
+        }
+        this.insertElements(elements);
+    }
+    getUsedElementsKeys() {
+        const regexp = /elements\[[\n\r\W]*"([^"]+)"[\n\r\W]*\]/g;
+        const keys = [];
+        let match;
+        while ((match = regexp.exec(this.fileContent)) !== null) {
+            keys.push(match[1]);
+        }
+        return keys;
+    }
+    _replaceCode(code, injectIndexStart, injectIndexEnd) {
+        const newFileContent = this.fileContent.substring(0, injectIndexStart) + code + this.fileContent.substring(injectIndexEnd);
+        this._init();
+        this.generateModel(newFileContent);
+    }
+    _getMethodInjectionIndex() {
+        return this.fileContent.length;
+    }
+    _getCucumberInjectionIndex() {
+        return this.fileContent.length;
+    }
+    addLocatorsMetadata(locatorsMetadata) {
+        if (!this.sourceFileName)
+            return;
+        let locatorsMetadataFileName = this.sourceFileName.replace(".mjs", ".json");
+        const config = getAiConfig();
+        if (config && config.locatorsMetadataDir) {
+            locatorsMetadataFileName = path.join(config.locatorsMetadataDir, path.basename(locatorsMetadataFileName));
+            if (!existsSync(path.dirname(locatorsMetadataFileName))) {
+                mkdirSync(path.dirname(locatorsMetadataFileName), { recursive: true });
+            }
+        }
+        let metadata = {};
+        try {
+            if (existsSync(locatorsMetadataFileName)) {
+                metadata = JSON.parse(readFileSync(locatorsMetadataFileName, "utf8"));
+            }
+        }
+        catch {
+            logger.info("failed to read locators metadata file", locatorsMetadataFileName);
+        }
+        const keys = Object.keys(locatorsMetadata);
+        keys.forEach((key) => {
+            metadata[key] = locatorsMetadata[key];
+        });
+        try {
+            writeFileSync(locatorsMetadataFileName, JSON.stringify(metadata, null, 2), "utf8");
+        }
+        catch {
+            logger.info("failed to write locators metadata file", locatorsMetadataFileName);
+        }
+    }
+    _getVariableStartEnd(variableName) {
+        const codePart = this.variables.filter((cp) => cp.node.declarations[0].id.name === variableName)[0];
+        if (codePart === undefined)
+            return null;
+        return [codePart.node.start, codePart.node.end];
+    }
+    getVariableDeclarationCode(variableName) {
+        const codePart = this.variables.filter((cp) => cp.node.declarations[0].id.name === variableName)[0];
+        if (codePart === undefined)
+            return null;
+        return codePart.codePart;
+    }
+    getVariableDeclarationAsObject(variableName) {
+        const code = this.getVariableDeclarationCode(variableName);
+        if (code === null)
+            return null;
+        const vmContext = { console, value: null };
+        vm.createContext(vmContext);
+        vm.runInContext(code + "\nvalue = " + variableName + ";", vmContext);
+        return vmContext.value;
+    }
+    getName() {
+        let base = path.parse(this.sourceFileName ?? "").base.split(".")[0];
+        if (base.endsWith("_page"))
+            base = base.substring(0, base.length - 5);
+        return base;
+    }
+    getMethodsNames() {
+        const methods = [];
+        this.methods.forEach((codePart) => {
+            if (codePart.name && !codePart.name.startsWith("_")) {
+                methods.push(codePart.name);
+            }
+        });
+        return methods;
+    }
+    getMethodParametersValues(methodName, parameters) {
+        const params = this.getMethodParameters(methodName);
+        const values = [];
+        for (let i = 0; i < params.length; i++) {
+            const param = params[i];
+            values.push(parameters[param]);
+        }
+        return values;
+    }
+    getMethodParameters(methodName) {
+        const codePart = this.methods.find((cp) => cp.name === methodName);
+        if (!codePart)
+            return [];
+        const params = codePart.node.value?.params ?? [];
+        return params.map((param) => param.name);
+    }
+    getImportCode(excludeSources = []) {
+        let code = "";
+        this.importsObjects.forEach((importObject) => {
+            if (excludeSources.includes(importObject.source))
+                return;
+            if (importObject.type === "ImportSpecifier") {
+                code += `const { ${importObject.local} } = require('${importObject.source}');\n`;
+            }
+            else if (importObject.type === "ImportDefaultSpecifier") {
+                code += `const ${importObject.local} = require('${importObject.source}');\n`;
+            }
+        });
+        return code;
+    }
+    getCodeWithoutImports(removeCucumber = true) {
+        let text = this.fileContent;
+        if (removeCucumber) {
+            const expressionsLoc = [];
+            this.expressions.forEach((codePart) => {
+                expressionsLoc.push([codePart.start, codePart.end]);
+            });
+            text = cutSubString(text, expressionsLoc);
+        }
+        let lastImportEnd = 0;
+        this.imports.forEach((codePart) => {
+            lastImportEnd = codePart.end;
+        });
+        text = text.substring(lastImportEnd);
+        text = text.replace(/^\s*export\s+(?=async\s+function|function)/gm, "");
+        return text;
+    }
+    hasMethod(methodName) {
+        return this.methods.filter((cp) => cp.name === methodName).length > 0;
+    }
+    _getMethodComments(methodName) {
+        const codePart = this.methods.filter((cp) => cp.name === methodName)[0];
+        if (codePart === undefined)
+            return null;
+        const comments = codePart.node.leadingComments;
+        if (!comments || comments.length === 0)
+            return null;
+        const commentsValues = comments.map((c) => c.value);
+        return commentsValues.join("\n");
+    }
+    /**
+     * get the description and parameters of a method
+     * @param methodName
+     * @returns a dictionary with name, description and params
+     */
+    getMethodCommentsData(methodName) {
+        const codePart = this.methods.filter((cp) => cp.name === methodName)[0];
+        if (codePart === undefined)
+            return null;
+        const comments = codePart.node.leadingComments;
+        if (!comments || comments.length === 0)
+            return null;
+        const commentsValues = comments.map((c) => c.value);
+        const fullCommentText = commentsValues.join("\n");
+        const commentLines = fullCommentText.split("\n").map((line) => line.trim().replace(/^\*/, "").trim());
+        const descriptions = [];
+        for (let i = 0; i < commentLines.length; i++) {
+            const line = commentLines[i];
+            if (!line)
+                continue;
+            if (line.startsWith("@"))
+                break;
+            descriptions.push(line);
+        }
+        const description = descriptions.join(".").replace("..", ".");
+        const params = [];
+        for (let i = 0; i < commentLines.length; i++) {
+            const line = commentLines[i];
+            if (line.startsWith("@param")) {
+                params.push(this._processParametersLine(line));
+            }
+        }
+        return { name: methodName, description, params };
+    }
+    /**
+     * get the method in a format that can be used in the gpt prompt
+     * @param methodName
+     * @returns a string formatted to be used in the commands gpt prompt
+     */
+    getMethodInCommandFormat(methodName) {
+        const methodComment = this.getMethodCommentsData(methodName);
+        if (methodComment === null)
+            return null;
+        return `${methodName}: ${methodComment.description}, args: ${methodComment.params
+            .map((p) => `"${p.name}": "<${(p.description ?? "").replaceAll(" ", "_")}>"`)
+            .join(", ")}`;
+    }
+    _processParametersLine(paramLine) {
+        const paramParts = paramLine.split(/\s+/);
+        paramParts.shift(); // @param
+        let type = null;
+        if (paramParts.length > 0 && paramParts[0].startsWith("{") && paramParts[0].endsWith("}")) {
+            type = paramParts.shift().replace("{", "").replace("}", "");
+        }
+        let name = null;
+        if (paramParts.length > 0) {
+            name = paramParts.shift() ?? null;
+        }
+        let description = null;
+        if (paramParts.length > 0) {
+            description = paramParts.join(" ");
+        }
+        return { type, name, description };
+    }
+    getMethodCodePart(methodName) {
+        const codePart = this.methods.filter((cp) => cp.name === methodName)[0];
+        return codePart ?? null;
+    }
+    getStepDefinitionBreakdown(methodName) {
+        const codePart = this.methods.filter((cp) => cp.name === methodName)[0];
+        if (codePart === undefined)
+            return null;
+        const parametersNames = [];
+        if (codePart.node && codePart.node.body && codePart.node.body.parent && codePart.node.body.parent.params) {
+            codePart.node.body.parent.params.forEach((param) => {
+                parametersNames.push(param.name);
+            });
+        }
+        const commands = [];
+        if (codePart.node &&
+            codePart.node.type === "FunctionDeclaration" &&
+            codePart.node.body &&
+            codePart.node.body.body &&
+            codePart.node.body.body.length > 0) {
+            const codeBody = codePart.node.body.body;
+            for (let i = 0; i < codeBody.length; i++) {
+                const code = codeBody[i];
+                commands.push({
+                    type: code.type,
+                    code: this.fileContent.substring(code.start, code.end),
+                });
+            }
+        }
+        return { codeCommands: commands, parametersNames };
+    }
+    hasStep(step) {
+        const regexp = new RegExp(`"${step}"`, "g");
+        for (let i = 0; i < this.cucumberCalls.length; i++) {
+            const expression = this.cucumberCalls[i];
+            if (expression.codePart) {
+                if (expression.codePart.match(regexp)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    hasFunctionName(functionName) {
+        for (let i = 0; i < this.methods.length; i++) {
+            if (this.methods[i].name === functionName) {
+                return true;
+            }
+            return false; // (Preserved original behavior)
+        }
+        return false;
+    }
+}
+export { escapeForComment, unescapeFromComment };