@dev-blinq/cucumber_client 1.0.1689-dev → 1.0.1691-dev

package/bin/client/code_gen/page_reflection.js

@@ -455,6 +455,46 @@ export class CodePage {
         code += "}\n";
         return this._injectMethod(methodName, code);
     }
+    _replaceSelectedCode(code, injectIndexEnd) {
+        const newFileContent = this.fileContent.substring(0, injectIndexEnd - 2) +
+            "\n  " +
+            code +
+            "\n}\n" +
+            this.fileContent.substring(injectIndexEnd);
+        this._init();
+        this.generateModel(newFileContent);
+    }
+    _injectOneCommand(methodName, code) {
+        const result = { methodName };
+        code = code.trim();
+        const existMethod = this.methods.find((m) => m.name === methodName);
+        if (!existMethod) {
+            throw new Error(`method ${methodName} not found for injection`);
+        }
+        const oldCode = existMethod.codePart.trim();
+        this._replaceSelectedCode(code, existMethod.end);
+        result.status = CodeStatus.UPDATED;
+        result.oldCode = oldCode;
+        result.newCode = code;
+        return result;
+    }
+    _removeSelectedCode(commands, injectIndexStart, injectIndexEnd) {
+        let newFileContent = this.fileContent.substring(injectIndexStart, injectIndexEnd);
+        commands.forEach((cmd) => {
+            newFileContent = newFileContent.replace(cmd, "");
+        });
+        newFileContent =
+            this.fileContent.substring(0, injectIndexStart) + newFileContent + this.fileContent.substring(injectIndexEnd);
+        this._init();
+        this.generateModel(newFileContent);
+    }
+    _removeCommands(methodName, commands) {
+        const existMethod = this.methods.find((m) => m.name === methodName);
+        if (!existMethod) {
+            throw new Error(`method ${methodName} not found for removal`);
+        }
+        this._removeSelectedCode(commands, existMethod.start, existMethod.end);
+    }
     _injectMethod(methodName, code) {
         const result = { methodName };
         code = code.trim();

package/bin/client/code_gen/playwright_codeget.js

@@ -804,4 +804,4 @@ const generatePageName = (url) => {
     return "default";
   }
 };
-export { generateCode, generatePageName };
+export { generateCode, generatePageName, _generateCodeFromCommand };

package/bin/client/recorderv3/bvt_init.js

@@ -352,6 +352,21 @@ async function BVTRecorderInit({ envName, projectDir, roomId, TOKEN, socket = nu
     "recorderWindow.cleanup": async (input) => {
       return recorder.cleanup(input);
     },
+    "recorderWindow.getStepCodeByScenario": async (input) => {
+      return await recorder.getStepCodeByScenario(input);
+    },
+    "recorderWindow.setStepCodeByScenario": async (input) => {
+      return await recorder.setStepCodeByScenario(input);
+    },
+    "recorderWindow.getRecorderContext": async (input) => {
+      return await recorder.getContext();
+    },
+    "recorderWindow.addCommandToStepCode": async (input) => {
+      return await recorder.addCommandToStepCode(input);
+    },
+    "recorderWindow.deleteCommandFromStepCode": async (input) => {
+      return await recorder.deleteCommandFromStepCode(input);
+    },
   });
 
   socket.on("targetBrowser.command.event", async (input) => {

package/bin/client/recorderv3/bvt_recorder.js

@@ -1,22 +1,34 @@
 // define the jsdoc type for the input
 import { closeContext, initContext, _getDataFile, resetTestData } from "automation_model";
 import { existsSync, readdirSync, readFileSync, rmSync } from "fs";
+import { rm } from "fs/promises";
 import path from "path";
 import url from "url";
 import { getImplementedSteps, parseRouteFiles } from "./implemented_steps.js";
 import { NamesService, RemoteBrowserService, PublishService } from "./services.js";
 import { BVTStepRunner } from "./step_runner.js";
 import { readFile, writeFile } from "fs/promises";
-import { loadStepDefinitions, getCommandsForImplementedStep } from "./step_utils.js";
+import {
+  loadStepDefinitions,
+  getCommandsForImplementedStep,
+  updateStepDefinitions,
+  getCodePage,
+  getCucumberStep,
+  _toRecordingStep,
+  toMethodName,
+} from "./step_utils.js";
 import { parseStepTextParameters } from "../cucumber/utils.js";
 import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherkin";
 import chokidar from "chokidar";
 import { unEscapeNonPrintables } from "../cucumber/utils.js";
-import { findAvailablePort } from "../utils/index.js";
+import { findAvailablePort, getRunsServiceBaseURL } from "../utils/index.js";
 import socketLogger 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";
+import { Recording } from "../recording.js";
 
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 
@@ -1252,7 +1264,7 @@ export class BVTRecorder {
     }, 100);
     this.timerId = timerId;
   }
-  async runStep({ step, parametersMap, tags, isFirstStep, listenNetwork }, options) {
+  async runStep({ step, parametersMap, tags, isFirstStep, listenNetwork, AICode }, options) {
     const { skipAfter = true, skipBefore = !isFirstStep } = options || {};
 
     const env = path.basename(this.envName, ".json");
@@ -1294,6 +1306,7 @@ export class BVTRecorder {
           envPath: this.envName,
           tags,
           config: this.config,
+          AICode,
         },
         this.bvtContext,
         {
@@ -1313,7 +1326,7 @@ export class BVTRecorder {
       this.bvtContext.navigate = false;
     }
   }
-  async saveScenario({ scenario, featureName, override, isSingleStep, branch, isEditing, env }) {
+  async saveScenario({ scenario, featureName, override, isSingleStep, branch, isEditing, env, AICode }) {
     // await updateStepDefinitions({ scenario, featureName, projectDir: this.projectDir }); // updates mjs files
     // if (!isSingleStep) await updateFeatureFile({ featureName, scenario, override, projectDir: this.projectDir }); // updates gherkin files
     const res = await this.workspaceService.saveScenario({
@@ -1325,6 +1338,7 @@ export class BVTRecorder {
       isEditing,
       projectId: path.basename(this.projectDir),
       env: env ?? this.envName,
+      AICode,
     });
     if (res.success) {
       await this.cleanup({ tags: scenario.tags });
@@ -1580,6 +1594,266 @@ export class BVTRecorder {
     }
     return result;
   }
+  async setStepCodeByScenario({
+    function_name,
+    mjs_file_content,
+    user_request,
+    selectedTarget,
+    page_context,
+    AIMemory,
+  }) {
+    const runsURL = getRunsServiceBaseURL();
+    const url = `${runsURL}/process-user-request/generate-code-with-context`;
+    try {
+      const result = await axiosClient({
+        url,
+        method: "POST",
+        data: {
+          function_name,
+          mjs_file_content,
+          user_request,
+          selectedTarget,
+          page_context,
+          AIMemory,
+        },
+        headers: {
+          Authorization: `Bearer ${this.TOKEN}`,
+          "X-Source": "recorder",
+        },
+      });
+      if (result.status !== 200) {
+        return { success: false, message: "Error while fetching code changes" };
+      }
+      return { success: true, data: result.data };
+    } catch (error) {
+      // @ts-ignore
+      const reason = error?.response?.data?.error || "";
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Failed to fetch code changes: ${errorMessage} \n ${reason}`);
+    }
+  }
+
+  async getStepCodeByScenario({ featureName, scenarioName, projectId, branch }) {
+    try {
+      const runsURL = getRunsServiceBaseURL();
+      const ssoURL = runsURL.replace("/runs", "/auth");
+      const privateRepoURL = `${ssoURL}/isRepoPrivate?project_id=${projectId}`;
+
+      const isPrivateRepoReq = await axiosClient({
+        url: privateRepoURL,
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${this.TOKEN}`,
+          "X-Source": "recorder",
+        },
+      });
+
+      if (isPrivateRepoReq.status !== 200) {
+        return { success: false, message: "Error while checking repo privacy" };
+      }
+
+      const isPrivateRepo = isPrivateRepoReq.data.isPrivate ? isPrivateRepoReq.data.isPrivate : false;
+
+      const workspaceURL = runsURL.replace("/runs", "/workspace");
+      const url = `${workspaceURL}/get-step-code-by-scenario`;
+
+      const result = await axiosClient({
+        url,
+        method: "POST",
+        data: {
+          scenarioName,
+          featureName,
+          projectId,
+          isPrivateRepo,
+          branch,
+        },
+        headers: {
+          Authorization: `Bearer ${this.TOKEN}`,
+          "X-Source": "recorder",
+        },
+      });
+      if (result.status !== 200) {
+        return { success: false, message: "Error while getting step code" };
+      }
+      return { success: true, data: result.data.stepInfo };
+    } catch (error) {
+      const reason = error?.response?.data?.error || "";
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Failed to get step code: ${errorMessage} \n ${reason}`);
+    }
+  }
+  async getContext() {
+    return await this.page.evaluate(() => {
+      return document.documentElement.outerHTML;
+    });
+  }
+  async deleteCommandFromStepCode({ scenario, AICode, command }) {
+    if (!AICode || AICode.length === 0) {
+      console.log("No AI code available to delete.");
+      return;
+    }
+
+    const __temp_features_FolderName = "__temp_features" + Math.random().toString(36).substring(2, 7);
+    const tempFolderPath = path.join(this.projectDir, __temp_features_FolderName);
+    process.env.tempFeaturesFolderPath = __temp_features_FolderName;
+    process.env.TESTCASE_REPORT_FOLDER_PATH = tempFolderPath;
+
+    try {
+      await this.stepRunner.copyCodetoTempFolder({ tempFolderPath, AICode });
+      await this.stepRunner.writeWrapperCode(tempFolderPath);
+      const codeView = AICode.find((f) => f.stepName === scenario.step.text);
+
+      if (!codeView) {
+        throw new Error("Step code not found for step: " + scenario.step.text);
+      }
+
+      const functionName = codeView.functionName;
+      const mjsPath = path
+        .normalize(codeView.mjsFile)
+        .split(path.sep)
+        .filter((part) => part !== "features")
+        .join(path.sep);
+      const codePath = path.join(tempFolderPath, mjsPath);
+
+      if (!existsSync(codePath)) {
+        throw new Error("Step code file not found: " + codePath);
+      }
+
+      const codePage = getCodePage(codePath);
+
+      const elements = codePage.getVariableDeclarationAsObject("elements");
+
+      const cucumberStep = getCucumberStep({ step: scenario.step });
+      cucumberStep.text = scenario.step.text;
+      const stepCommands = scenario.step.commands;
+      const cmd = _toRecordingStep(command, scenario.step.name);
+
+      const recording = new Recording();
+      recording.loadFromObject({ steps: stepCommands, step: cucumberStep });
+      const step = { ...recording.steps[0], ...cmd };
+      const result = _generateCodeFromCommand(step, elements, {});
+
+      codePage._removeCommands(functionName, result.codeLines);
+      codePage.removeUnusedElements();
+      codePage.save();
+
+      await rm(tempFolderPath, { recursive: true, force: true });
+
+      return { code: codePage.fileContent, mjsFile: codeView.mjsFile };
+    } catch (error) {
+      await rm(tempFolderPath, { recursive: true, force: true });
+      throw error;
+    }
+  }
+  async addCommandToStepCode({ scenario, AICode }) {
+    if (!AICode || AICode.length === 0) {
+      console.log("No AI code available to add.");
+      return;
+    }
+
+    const __temp_features_FolderName = "__temp_features" + Math.random().toString(36).substring(2, 7);
+    const tempFolderPath = path.join(this.projectDir, __temp_features_FolderName);
+    process.env.tempFeaturesFolderPath = __temp_features_FolderName;
+    process.env.TESTCASE_REPORT_FOLDER_PATH = tempFolderPath;
+
+    try {
+      await this.stepRunner.copyCodetoTempFolder({ tempFolderPath, AICode });
+      await this.stepRunner.writeWrapperCode(tempFolderPath);
+
+      let codeView = AICode.find((f) => f.stepName === scenario.step.text);
+
+      if (codeView) {
+        scenario.step.commands = [scenario.step.commands.pop()];
+        const functionName = codeView.functionName;
+        const mjsPath = path
+          .normalize(codeView.mjsFile)
+          .split(path.sep)
+          .filter((part) => part !== "features")
+          .join(path.sep);
+        const codePath = path.join(tempFolderPath, mjsPath);
+
+        if (!existsSync(codePath)) {
+          throw new Error("Step code file not found: " + codePath);
+        }
+
+        const codePage = getCodePage(codePath);
+        const elements = codePage.getVariableDeclarationAsObject("elements");
+
+        const cucumberStep = getCucumberStep({ step: scenario.step });
+        cucumberStep.text = scenario.step.text;
+        const stepCommands = scenario.step.commands;
+        const cmd = _toRecordingStep(scenario.step.commands[0], scenario.step.name);
+
+        const recording = new Recording();
+        recording.loadFromObject({ steps: stepCommands, step: cucumberStep });
+        const step = { ...recording.steps[0], ...cmd };
+
+        const result = _generateCodeFromCommand(step, elements, {});
+        codePage.insertElements(result.elements);
+
+        codePage._injectOneCommand(functionName, result.codeLines.join("\n"));
+        codePage.save();
+
+        await rm(tempFolderPath, { recursive: true, force: true });
+
+        return { code: codePage.fileContent, newStep: false, mjsFile: codeView.mjsFile };
+      }
+      console.log("Step code not found for step: ", scenario.step.text);
+
+      codeView = AICode[0];
+      const functionName = toMethodName(scenario.step.text);
+      const codeLines = [];
+      const mjsPath = path
+        .normalize(codeView.mjsFile)
+        .split(path.sep)
+        .filter((part) => part !== "features")
+        .join(path.sep);
+      const codePath = path.join(tempFolderPath, mjsPath);
+
+      if (!existsSync(codePath)) {
+        throw new Error("Step code file not found: " + codePath);
+      }
+
+      const codePage = getCodePage(codePath);
+      const elements = codePage.getVariableDeclarationAsObject("elements");
+      let newElements = { ...elements };
+
+      const cucumberStep = getCucumberStep({ step: scenario.step });
+      cucumberStep.text = scenario.step.text;
+      const stepCommands = scenario.step.commands;
+      stepCommands.forEach((command) => {
+        const cmd = _toRecordingStep(command, scenario.step.name);
+
+        const recording = new Recording();
+        recording.loadFromObject({ steps: stepCommands, step: cucumberStep });
+        const step = { ...recording.steps[0], ...cmd };
+        const result = _generateCodeFromCommand(step, elements, {});
+        newElements = { ...result.elements };
+        codeLines.push(...result.codeLines);
+      });
+
+      codePage.insertElements(newElements);
+      codePage.addInfraCommand(
+        functionName,
+        cucumberStep.text,
+        cucumberStep.getVariablesList(),
+        codeLines,
+        false,
+        "recorder"
+      );
+
+      const keyword = (cucumberStep.keywordAlias ?? cucumberStep.keyword).trim();
+      codePage.addCucumberStep(keyword, cucumberStep.getTemplate(), functionName, stepCommands.length);
+      codePage.save();
+
+      await rm(tempFolderPath, { recursive: true, force: true });
+
+      return { code: codePage.fileContent, newStep: true, functionName, mjsFile: codeView.mjsFile };
+    } catch (error) {
+      await rm(tempFolderPath, { recursive: true, force: true });
+      throw error;
+    }
+  }
   async cleanup({ tags }) {
     const noopStep = {
       text: "Noop",

package/bin/client/recorderv3/services.js

@@ -153,7 +153,7 @@ export class PublishService {
     constructor(TOKEN) {
         this.TOKEN = TOKEN;
     }
-    async saveScenario({ scenario, featureName, override, branch, isEditing, projectId, env }) {
+    async saveScenario({ scenario, featureName, override, branch, isEditing, projectId, env, AICode }) {
         const runsURL = getRunsServiceBaseURL();
         const workspaceURL = runsURL.replace("/runs", "/workspace");
         const url = `${workspaceURL}/publish-recording`;
@@ -166,6 +166,7 @@ export class PublishService {
                     featureName,
                     override,
                     env,
+                    AICode,
                 },
                 params: {
                     branch,

package/bin/client/recorderv3/step_runner.js

@@ -73,7 +73,7 @@ export class BVTStepRunner {
     }
   }
 
-  async copyCodetoTempFolder({ step, parametersMap, tempFolderPath }) {
+  async copyCodetoTempFolder({ step, parametersMap, tempFolderPath, AICode }) {
     if (!fs.existsSync(tempFolderPath)) {
       fs.mkdirSync(tempFolderPath);
     }
@@ -84,6 +84,18 @@ export class BVTStepRunner {
       overwrite: true,
       recursive: true,
     });
+
+    // If AICode is provided, save it as well
+    if (AICode) {
+      for (const { mjsFileContent, mjsFile } of AICode) {
+        const mjsPath = path
+          .normalize(mjsFile)
+          .split(path.sep)
+          .filter((part) => part !== "features")
+          .join(path.sep);
+        writeFileSync(path.join(tempFolderPath, mjsPath), mjsFileContent);
+      }
+    }
   }
 
   async writeTempFeatureFile({ step, parametersMap, tempFolderPath, tags }) {
@@ -250,7 +262,7 @@ export class BVTStepRunner {
     return { result, info };
   }
 
-  async runStep({ step, parametersMap, envPath, tags, config }, bvtContext, options) {
+  async runStep({ step, parametersMap, envPath, tags, config, AICode }, bvtContext, options) {
     // Create a new AbortController for this specific step execution
     this.#currentStepController = new AbortController();
     const { signal } = this.#currentStepController;
@@ -304,7 +316,7 @@ export class BVTStepRunner {
       process.env.tempFeaturesFolderPath = __temp_features_FolderName;
       process.env.TESTCASE_REPORT_FOLDER_PATH = tempFolderPath;
 
-      await this.copyCodetoTempFolder({ step, parametersMap, tempFolderPath });
+      await this.copyCodetoTempFolder({ step, parametersMap, tempFolderPath, AICode });
 
       // Write abort wrapper code with this step's signal
       await this.writeWrapperCode(tempFolderPath, signal);

package/bin/client/recorderv3/step_utils.js

@@ -48,7 +48,7 @@ const replaceLastOccurence = (str, search, replacement) => {
   return str.substring(0, lastIndex) + replacement + str.substring(lastIndex + search.length);
 };
 
-const _toRecordingStep = (cmd, stepText) => {
+export const _toRecordingStep = (cmd, stepText) => {
   switch (cmd.type) {
     case "hover_element": {
       return {
@@ -535,7 +535,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
     const isUtilStep = makeStepTextUnique(step, stepsDefinitions);
 
     if (isUtilStep) {
-      if (!step.renamedText) {
+      if (!step.renamedText || step.renamedText === step.text) {
         return;
       }
       step.text = step.text.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dev-blinq/cucumber_client",
-  "version": "1.0.1689-dev",
+  "version": "1.0.1691-dev",
   "description": " ",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",