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

package/bin/client/recorderv3/step_utils.js

@@ -1,14 +1,16 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import path from "path";
 import url from "url";
 import logger from "../../logger.js";
-import { CodePage } from "../code_gen/page_reflection.js";
+import { CodePage, getAiConfig } from "../code_gen/page_reflection.js";
 import { generateCode, generatePageName } from "../code_gen/playwright_codeget.js";
 import { invertCodeToCommand } from "../code_gen/code_inversion.js";
 import { Step } from "../cucumber/feature.js";
-import { StepsDefinitions } from "../cucumber/steps_definitions.js";
+import { locateDefinitionPath, StepsDefinitions } from "../cucumber/steps_definitions.js";
 import { Recording } from "../recording.js";
 import { generateApiCode } from "../code_gen/api_codegen.js";
+import { tmpdir } from "os";
+import { createHash } from "crypto";
 
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 
@@ -69,19 +71,72 @@ function makeStepTextUnique(step, stepsDefinitions) {
 }
 
 export async function saveRecording({ step, cucumberStep, codePage, projectDir, stepsDefinitions }) {
-  // console.log("saveRecording", step.text);
+  let routesPath = path.join(tmpdir(), "blinq_temp_routes");
+
+  if (process.env.TEMP_RUN) {
+    if (existsSync(routesPath)) {
+      rmSync(routesPath, { recursive: true });
+    }
+    mkdirSync(routesPath, { recursive: true });
+    saveRoutes({ step, folderPath: routesPath });
+  } else {
+    if (existsSync(routesPath)) {
+      // remove the folder
+      try {
+        rmSync(routesPath, { recursive: true });
+        // console.log("Removed temp_routes_folder:", routesPath);
+      } catch (error) {
+        // console.error("Error removing temp_routes folder", error);
+      }
+      routesPath = path.join(projectDir, "data", "routes");
+      if (!existsSync(routesPath)) {
+        mkdirSync(routesPath, { recursive: true });
+      }
+      saveRoutes({ step, folderPath: routesPath });
+    }
+  }
+
   if (step.isImplementedWhileRecording && !process.env.TEMP_RUN) {
     return;
   }
+
   if (step.isImplemented && step.shouldOverride) {
     let stepDef = stepsDefinitions.findMatchingStep(step.text);
     codePage = getCodePage(stepDef.file);
   } else {
     const isUtilStep = makeStepTextUnique(step, stepsDefinitions);
+
     if (isUtilStep) {
       return;
     }
   }
+  if (process.env.TEMP_RUN === "true") {
+    // console.log("Save routes in temp folder for running:", routesPath);
+    if (existsSync(routesPath)) {
+      // console.log("Removing existing temp_routes_folder:", routesPath);
+      rmSync(routesPath, { recursive: true });
+    }
+    mkdirSync(routesPath, { recursive: true });
+    // console.log("Created temp_routes_folder:", routesPath);
+    saveRoutes({ step, folderPath: routesPath });
+  } else {
+    // console.log("Saving routes in project directory:", projectDir);
+    if (existsSync(routesPath)) {
+      // remove the folder
+      try {
+        rmSync(routesPath, { recursive: true });
+        // console.log("Removed temp_routes_folder:", routesPath);
+      } catch (error) {
+        // console.error("Error removing temp_routes folder", error);
+      }
+    }
+    routesPath = path.join(projectDir, "data", "routes");
+    // console.log("Saving routes to:", routesPath);
+    if (!existsSync(routesPath)) {
+      mkdirSync(routesPath, { recursive: true });
+    }
+    saveRoutes({ step, folderPath: routesPath });
+  }
   cucumberStep.text = step.text;
   const recording = new Recording();
   const steps = step.commands;
@@ -108,6 +163,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       isStaticToken,
       status,
     } = step.commands[0].value;
+
     const result = await generateApiCode(
       {
         url,
@@ -132,11 +188,15 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       step.keyword,
       stepsDefinitions
     );
-    stepsDefinitions.addStep({
-      name: step.text,
-      file: result.codePage.sourceFileName,
-      source: "recorder",
-    });
+
+    if (!step.isImplemented) {
+      stepsDefinitions.addStep({
+        name: step.text,
+        file: result.codePage.sourceFileName,
+        source: "recorder",
+      });
+    }
+
     cucumberStep.methodName = result.methodName;
     return result.codePage;
   } else {
@@ -164,7 +224,13 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       path
     );
     const keyword = (cucumberStep.keywordAlias ?? cucumberStep.keyword).trim();
-    const stepResult = codePage.addCucumberStep(keyword, cucumberStep.getTemplate(), methodName, steps.length);
+    const stepResult = codePage.addCucumberStep(
+      keyword,
+      cucumberStep.getTemplate(),
+      methodName,
+      steps.length,
+      step.finalTimeout
+    );
 
     if (!step.isImplemented) {
       stepsDefinitions.addStep({
@@ -185,7 +251,17 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
 
 const getLocatorsJson = (file) => {
   if (!file) return {};
-  const locatorsFilePath = file.replace(".mjs", ".json");
+  let locatorsFilePath = file.replace(".mjs", ".json");
+  const originLocatorsFilePath = locatorsFilePath;
+  const config = getAiConfig();
+  if (config && config.locatorsMetadataDir) {
+    // if config.locatorsMetadataDir is set, use it to create the file path
+    locatorsFilePath = path.join(config.locatorsMetadataDir, path.basename(locatorsFilePath));
+    if (!existsSync(locatorsFilePath)) {
+      // if the file does not exist in the config directory, use the original path
+      locatorsFilePath = originLocatorsFilePath;
+    }
+  }
   if (!existsSync(locatorsFilePath)) {
     return {};
   }
@@ -227,7 +303,7 @@ export const getCommandsForImplementedStep = (stepName, stepsDefinitions, stepPa
 
     isUtilStep = codePage.sourceFileName.endsWith("utils.mjs");
     for (const { code } of codeCommands) {
-      const command = invertCodeToCommand(code, elements, stepParams)[0];
+      const command = invertCodeToCommand(code, elements, stepParams, stepsDefinitions, codePage, stepName)[0];
       if (command === undefined || command.type === null) continue;
       if (command.element) {
         const key = command.element.key;
@@ -297,6 +373,7 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
   const steps = scenario.steps;
 
   const stepsDefinitions = new StepsDefinitions(projectDir);
+  const featureFolder = path.join(projectDir, "features");
   stepsDefinitions.load(false);
   // const parameters = scenario.parameters;
   // await saveRecordings({ steps, parameters, codePage, projectDir });
@@ -308,13 +385,41 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
       }
     }
     if ((step.isImplemented && !step.shouldOverride) || step.commands.length === 0) {
+      let routesPath = path.join(tmpdir(), `blinq_temp_routes`);
+      if (process.env.TEMP_RUN === "true") {
+        // console.log("Save routes in temp folder for running:", routesPath);
+        if (existsSync(routesPath)) {
+          // console.log("Removing existing temp_routes_folder:", routesPath);
+          rmSync(routesPath, { recursive: true });
+        }
+        mkdirSync(routesPath, { recursive: true });
+        // console.log("Created temp_routes_folder:", routesPath);
+        saveRoutes({ step, folderPath: routesPath });
+      } else {
+        // console.log("Saving routes in project directory:", projectDir);
+        if (existsSync(routesPath)) {
+          // remove the folder
+          try {
+            rmSync(routesPath, { recursive: true });
+            // console.log("Removed temp_routes_folder:", routesPath);
+          } catch (error) {
+            // console.error("Error removing temp_routes folder", error);
+          }
+        }
+        routesPath = path.join(projectDir, "data", "routes");
+        // console.log("Saving routes to:", routesPath);
+        if (!existsSync(routesPath)) {
+          mkdirSync(routesPath, { recursive: true });
+        }
+        saveRoutes({ step, folderPath: routesPath });
+      }
       continue;
     }
     const cucumberStep = getCucumberStep({ step });
     const pageName = generatePageName(step.startFrame?.url ?? "default");
-    const stepDefsFilePath = path.join(stepDefinitionFolderPath, pageName + "_page.mjs");
+    const stepDefsFilePath = locateDefinitionPath(featureFolder, pageName);
+    // path.join(stepDefinitionFolderPath, pageName + "_page.mjs");
     let codePage = getCodePage(stepDefsFilePath);
-
     codePage = await saveRecording({ step, cucumberStep, codePage, projectDir, stepsDefinitions });
     if (!codePage) {
       continue;
@@ -326,3 +431,43 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
   }
   writeFileSync(utilsFilePath, utilsContent, "utf8");
 }
+
+export function saveRoutes({ step, folderPath }) {
+  const routeItems = step.routeItems;
+  if (!routeItems || routeItems.length === 0) {
+    return;
+  }
+  const cucumberStep = getCucumberStep({ step });
+  const template = cucumberStep.getTemplate();
+  const stepNameHash = createHash("sha256").update(template).digest("hex");
+  // console.log("Saving routes for step:", step.text, "with hash:", stepNameHash);
+  const routeItemsWithFilters = routeItems.map((routeItem) => {
+    const oldFilters = routeItem.filters;
+    const queryParamsObject = {};
+    oldFilters.queryParams.forEach((queryParam) => {
+      queryParamsObject[queryParam.paramKey] = queryParam.paramValue;
+    });
+    const newFilters = { path: oldFilters.path, method: oldFilters.method, queryParams: queryParamsObject };
+    return {
+      ...routeItem,
+      filters: newFilters,
+    };
+  });
+
+  const routesFilePath = path.join(folderPath, stepNameHash + ".json");
+  // console.log("Routes file path:", routesFilePath);
+  const routesData = {
+    template,
+    routes: routeItemsWithFilters,
+  };
+  // console.log("Routes data to save:", routesData);
+  if (!existsSync(folderPath)) {
+    mkdirSync(folderPath, { recursive: true });
+  }
+  try {
+    writeFileSync(routesFilePath, JSON.stringify(routesData, null, 2), "utf8");
+    // console.log("Saved routes to", routesFilePath);
+  } catch (error) {
+    console.error("Failed to save routes to", routesFilePath, "Error:", error);
+  }
+}

package/bin/client/recorderv3/update_feature.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import path from "path";
-
+import { getDefaultPrettierConfig } from "../code_cleanup/utils.js";
+import prettier from "prettier";
 export function containsScenario({ featureFileContent, scenarioName }) {
   const lines = featureFileContent.split("\n");
   for (const line of lines) {
@@ -96,7 +97,7 @@ export function getCommandContent(command) {
       return `send a ${command.value.method} API request to ${command.value.url}`;
     }
     case "verify_page_snapshot": {
-      return `verify page snapshot stored in ${command.value}`;
+      return `verify page snapshot stored in ${command.parameters[0]}`;
     }
     default: {
       return "";
@@ -209,14 +210,12 @@ const GherkinToObject = (gherkin) => {
       steps: [],
     };
     while (idx < lines.length && lines[idx].startsWith("@")) {
-      skipEmptyLines();
       const tags = [...lines[idx].matchAll(/@([^@]+)/g)].map((match) => match[1].trim());
       scenario.tags.push(...(tags ?? []));
       idx++;
+      skipEmptyLines();
     }
 
-    skipEmptyLines();
-
     if (idx < lines.length && (lines[idx].startsWith("Scenario:") || lines[idx].startsWith("Scenario Outline:"))) {
       scenario.name = lines[idx].substring(lines[idx].indexOf(":") + 1).trim();
       idx++;
@@ -239,32 +238,32 @@ const GherkinToObject = (gherkin) => {
       !lines[idx].startsWith("@")
     ) {
       const line = lines[idx++];
-      if (line.startsWith("#")) {
-        const comment = line;
-        if (comment) {
-          const command = {
-            type: "comment",
-            text: comment,
-          };
-          scenario.steps.push(command);
-        }
-      } else if (line.startsWith("Examples:")) {
-        obj.hasParams = true;
-        const command = {
+      let command;
+      if (line.startsWith("Examples:")) {
+        scenario.hasParams = true;
+        command = {
           type: "examples",
           lines: [],
         };
-
         while (idx < lines.length && lines[idx].startsWith("|")) {
           const line = lines[idx++];
           command.lines.push(line);
         }
       } else {
-        scenario.steps.push({
-          type: "step",
-          text: line,
-        });
+        if (line.startsWith("#")) {
+          command = {
+            type: "comment",
+            text: line,
+          };
+        } else {
+          command = {
+            type: "step",
+            text: line,
+          };
+        }
       }
+      scenario.steps.push(command);
+      skipEmptyLines();
     }
 
     return scenario;
@@ -273,7 +272,6 @@ const GherkinToObject = (gherkin) => {
   while (idx < lines.length) {
     const scenario = getScenario();
     if (scenario === -1) break;
-
     if (scenario.error) {
       return {
         error: scenario.error,
@@ -299,8 +297,7 @@ function updateExistingScenario({ featureFileContent, scenarioName, scenarioCont
       skipScenarioIndex = i;
       continue;
     }
-    let scenarioContent = `${featureFileObject.hasParams ? "Scenario Outline" : "Scenario"}: ${scenario.name}`;
-
+    let scenarioContent = `${scenario.hasParams ? "Scenario Outline" : "Scenario"}: ${scenario.name}`;
     let tagsLine;
     if (scenario.tags?.length > 0) {
       tagsLine = `${scenario.tags.map((t) => `@${t}`).join(" ")}`;
@@ -323,7 +320,6 @@ function updateExistingScenario({ featureFileContent, scenarioName, scenarioCont
   if (skipScenarioIndex !== -1) {
     finalContent = results.join("\n") + "\n" + scenarioContent;
   }
-
   return finalContent;
 }
 export async function updateFeatureFile({ featureName, scenario, override, projectDir }) {
@@ -333,6 +329,8 @@ export async function updateFeatureFile({ featureName, scenario, override, proje
     { scenario },
     isFeatureFileExists ? GherkinToObject(readFileSync(featureFilePath, "utf8")) : undefined
   );
+  const prettierConfig = getDefaultPrettierConfig();
+  // Format the code using Prettier
 
   if (isFeatureFileExists) {
     const featureFileContent = readFileSync(featureFilePath, "utf8");
@@ -341,7 +339,7 @@ export async function updateFeatureFile({ featureName, scenario, override, proje
       if (!override) {
         throw new Error(`Scenario "${scenario.name}" already exists in feature "${featureName}"`);
       } else {
-        const updatedFeatureFileContent = updateExistingScenario({
+        let updatedFeatureFileContent = updateExistingScenario({
           featureFileContent,
           scenarioName: scenario.name,
           scenarioContent,
@@ -349,14 +347,41 @@ export async function updateFeatureFile({ featureName, scenario, override, proje
         if (updatedFeatureFileContent === "error") {
           throw new Error(`Error while parsing feature file: Invalid gherkin`);
         }
+        try {
+          updatedFeatureFileContent = await prettier.format(updatedFeatureFileContent, {
+            ...prettierConfig,
+            parser: "gherkin",
+            plugins: ["prettier-plugin-gherkin"],
+          });
+        } catch (error) {
+          console.error("Error formatting feature file content with Prettier:", error);
+        }
         writeFileSync(featureFilePath, updatedFeatureFileContent);
         return;
       }
     }
-    const updatedFeatureFileContent = featureFileContent + "\n" + scenarioContent;
+    let updatedFeatureFileContent = featureFileContent + "\n" + scenarioContent;
+    try {
+      updatedFeatureFileContent = await prettier.format(updatedFeatureFileContent, {
+        ...prettierConfig,
+        parser: "gherkin",
+        plugins: ["prettier-plugin-gherkin"],
+      });
+    } catch (error) {
+      console.error("Error formatting feature file content with Prettier:", error);
+    }
     writeFileSync(featureFilePath, updatedFeatureFileContent);
   } else {
-    const featureFileContent = `Feature: ${featureName}\n${scenarioContent}`;
+    let featureFileContent = `Feature: ${featureName}\n${scenarioContent}`;
+    try {
+      featureFileContent = await prettier.format(featureFileContent, {
+        ...prettierConfig,
+        parser: "gherkin",
+        plugins: ["prettier-plugin-gherkin"],
+      });
+    } catch (error) {
+      console.error("Error formatting feature file content with Prettier:", error);
+    }
     writeFileSync(featureFilePath, featureFileContent);
   }
 }

package/bin/client/recording.js

@@ -5,9 +5,14 @@ import { Step } from "../client/cucumber/feature.js";
 This list need to be in sync with the list exist in the commands.js file
 */
 const Types = {
+  API: "api",
   CLICK: "click_element",
   CLICK_SIMPLE: "click_simple",
+  PARAMETERIZED_CLICK: "parameterized_click",
+  CONTEXT_CLICK: "context_click",
   NAVIGATE: "navigate",
+  GO_BACK: "browser_go_back",
+  GO_FORWARD: "browser_go_forward",
   FILL: "fill_element",
   FILL_SIMPLE: "fill_simple",
   EXECUTE: "execute_page_method",
@@ -29,6 +34,7 @@ const Types = {
   SET_COMBO: "set_combo",
   HOVER: "hover_element",
   EXTRACT_ATTRIBUTE: "extract_attribute",
+  EXTRACT_PROPERTY: "extract_property",
   CLOSE_PAGE: "close_page",
   SET_DATE_TIME: "set_date_time",
   SET_VIEWPORT: "set_viewport",
@@ -40,11 +46,13 @@ const Types = {
   SET_INPUT: "set_input",
   WAIT_FOR_USER_INPUT: "wait_for_user_input",
   VERIFY_ATTRIBUTE: "verify_element_attribute",
+  VERIFY_PROPERTY: "verify_element_property",
   FILL_UNKNOWN: "fill_unknown",
   VERIFY_TEXT_RELATED_TO_TEXT: "verify_text_in_relation",
   VERIFY_FILE_EXISTS: "verify_file_exists",
   SET_INPUT_FILES: "set_input_files",
   VERIFY_PAGE_SNAPSHOT: "verify_page_snapshot",
+  CONDITIONAL_WAIT: "conditional_wait",
 };
 class Recording {
   steps = [];

package/bin/client/run_cucumber.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync } from "fs";
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
 import logger from "../logger.js";
 import path from "path";
 import { scenarioResolution } from "./cucumber/feature.js";
@@ -13,6 +13,77 @@ import crypto from "crypto";
 //import debug from "debug";
 process.env.NODE_TLS_REJECT_UNAUTHORIZED = 0;
 
+// Initialize the editorLogs array to collect all logs
+const editorLogs = [];
+
+// Store original console methods
+const originalConsoleLog = console.log;
+const originalConsoleError = console.error;
+
+// Store original process stdout and stderr write methods
+const originalStdoutWrite = process.stdout.write;
+const originalStderrWrite = process.stderr.write;
+
+// Override console.log
+console.log = function (...args) {
+  const logEntry = {
+    message: args.map((arg) => (typeof arg === "object" ? JSON.stringify(arg) : String(arg))).join(" "),
+  };
+
+  editorLogs.push(logEntry);
+  originalConsoleLog.apply(console, args);
+};
+
+// Override console.error
+console.error = function (...args) {
+  const logEntry = {
+    message: args.map((arg) => (typeof arg === "object" ? JSON.stringify(arg) : String(arg))).join(" "),
+  };
+
+  editorLogs.push(logEntry);
+  originalConsoleError.apply(console, args);
+};
+
+// Override process.stdout.write
+process.stdout.write = function (chunk, encoding, callback) {
+  const logEntry = {
+    message: chunk.toString(),
+  };
+
+  editorLogs.push(logEntry);
+  return originalStdoutWrite.apply(process.stdout, arguments);
+};
+
+// Override process.stderr.write
+process.stderr.write = function (chunk, encoding, callback) {
+  const logEntry = {
+    message: chunk.toString(),
+  };
+
+  editorLogs.push(logEntry);
+  return originalStderrWrite.apply(process.stderr, arguments);
+};
+
+// Function to write logs to file
+const writeLogsToFile = (filePath) => {
+  try {
+    const dirPath = path.dirname(filePath);
+
+    // Create directory if it doesn't exist
+    if (!existsSync(dirPath)) {
+      mkdirSync(dirPath, { recursive: true });
+    }
+
+    // Format logs as plain message on each line
+    const logText = editorLogs.map((log) => `${log.message}`).join("\n");
+
+    // Write logs to plain text file
+    writeFileSync(filePath, logText, { encoding: "utf8" });
+  } catch (error) {
+    logger.error(`Failed to write logs to file: ${error.message}`);
+  }
+};
+
 //do something when app is closing
 
 const runCucumber = async (
@@ -60,6 +131,10 @@ const runCucumber = async (
   } else if (!process.env.NODE_ENV_BLINQ) {
     serviceUrl = "https://logic.blinq.io";
     logger.info("Running in prod mode");
+  } else if (process.env.WHITELABEL === "true") {
+    // if it's a whitelabel it will use "api" instead of "logic"
+    serviceUrl = process.env.NODE_ENV_BLINQ;
+    logger.info("Running in custom mode: " + serviceUrl);
   } else {
     serviceUrl = process.env.NODE_ENV_BLINQ.replace("api", "logic");
     logger.info("Running in custom mode: " + serviceUrl);
@@ -93,7 +168,14 @@ const runCucumber = async (
       }
       return true;
     });
-    process.on("exit", async () => await aiAgent.endScenario());
+    process.on("exit", async () => {
+      // Write logs to file before exiting
+      if (result.scenarioPath) {
+        const logsFilePath = path.join(result.scenarioPath, "editorLogs.log");
+        writeLogsToFile(logsFilePath);
+      }
+      await aiAgent.endScenario();
+    });
     const context = {};
     result.context = context;
     if (process.env.E2E === "true") {
@@ -105,6 +187,9 @@ const runCucumber = async (
       envFile = await aiAgent.initProjectAndEnvironment(context);
     } catch (e) {
       logger.error(e.message);
+      // Write logs to file before exiting due to error
+      const logsFilePath = path.join(result.scenarioPath, "editorLogs.log");
+      writeLogsToFile(logsFilePath);
       if (exit) {
         process.exit(1);
       }
@@ -118,6 +203,9 @@ const runCucumber = async (
     }
     if (!existsSync(fullFeatureFilePath)) {
       logger.error("Feature file not found: " + fullFeatureFilePath);
+      // Write logs to file before exiting due to error
+      const logsFilePath = path.join(result.scenarioPath, "editorLogs.log");
+      writeLogsToFile(logsFilePath);
       if (exit) {
         process.exit(1);
       }
@@ -128,6 +216,9 @@ const runCucumber = async (
       feature = await scenarioResolution(fullFeatureFilePath);
     } catch (e) {
       logger.error("Error parsing feature file: " + fullFeatureFilePath);
+      // Write logs to file before exiting due to error
+      const logsFilePath = path.join(result.scenarioPath, "editorLogs.log");
+      writeLogsToFile(logsFilePath);
       if (exit) {
         process.exit(1);
       }
@@ -136,6 +227,9 @@ const runCucumber = async (
     const scenario = feature.getScenario(scenarioName);
     if (!scenario) {
       logger.error("Scenario not found: " + scenarioName);
+      // Write logs to file before exiting due to error
+      const logsFilePath = path.join(result.scenarioPath, "editorLogs.log");
+      writeLogsToFile(logsFilePath);
       if (exit) {
         process.exit(1);
       }
@@ -146,6 +240,15 @@ const runCucumber = async (
 
     let scenarioId = findNextIdInFolder("./reports");
     let scenarioPath = "./reports" + "/" + scenarioId;
+    const dataFilePath = path.join(scenarioPath, "data.json");
+    mkdirSync(path.dirname(dataFilePath), { recursive: true });
+    if (process.env.NODE_ENV_BLINQ === "local") {
+      let dataPath = aiAgent.project.rootFolder + "/data/data.json";
+      if (existsSync(dataPath)) {
+        const poolData = JSON.parse(readFileSync(dataPath, "utf-8"));
+        writeFileSync(dataFilePath, JSON.stringify(poolData, null, 2), "utf-8");
+      }
+    }
     result.scenarioPath = scenarioPath;
     aiAgent.initTestData(envFile, path.join(scenarioPath, "data.json"));
     let featureFileRelative = path.relative(projectDir, fullFeatureFilePath);
@@ -256,7 +359,7 @@ const runCucumber = async (
           await aiAgent.createNewStepLocal(
             featureName,
             cucumberStep,
-            feature,
+            feature.comments,
             userData,
             first,
             previousTasks,
@@ -283,6 +386,9 @@ const runCucumber = async (
       ) {
         aiAgent.evaluateScenario();
       }
+      // Write logs to file on successful completion
+      const logsFilePath = path.join(scenarioPath, "editorLogs.log");
+      writeLogsToFile(logsFilePath);
       await aiAgent.endScenario();
     } catch (e) {
       if (reconnect) {
@@ -303,7 +409,12 @@ const runCucumber = async (
         logger.error(e.stack);
         message = e.message + "\n" + e.stack;
       }
+      aiAgent.scenarioReport.updateLastCommand({ status: false, error: message });
+      // Write logs to file on error
+      const logsFilePath = path.join(result.scenarioPath, "editorLogs.log");
+      writeLogsToFile(logsFilePath);
       await aiAgent.endScenario();
+
       if (exit) {
         process.exit(1);
       }
@@ -316,4 +427,5 @@ const runCucumber = async (
     return result;
   }
 };
-export { runCucumber };
+
+export { runCucumber, editorLogs, writeLogsToFile };