testeranto 0.202.0 → 0.203.0

package/src/PM/main.ts

@@ -10,18 +10,189 @@ import fs from "fs";
 import { ConsoleMessage } from "puppeteer-core";
 import ansiC from "ansi-colors";
 
-import { IFinalResults, ITTestResourceConfiguration } from "../lib/index.js";
+import {
+  IFinalResults,
+  ITTestResourceConfiguration,
+  IRunTime,
+} from "../lib/index.js";
 import { webEvaluator } from "../utils";
 import { Queue } from "../utils/queue.js";
 
 import { createLogStreams, statusMessagePretty } from "./utils.js";
-import { PM_WithProcesses } from "./PM_WithProcesses.js";
+import { PM_WithHelpo } from "./PM_WithHelpo.js";
+import path from "node:path";
 
 const files: Record<string, Set<string>> = {};
 const screenshots: Record<string, Promise<Uint8Array>[]> = {};
 
-export class PM_Main extends PM_WithProcesses {
+export class PM_Main extends PM_WithHelpo {
+  private async setupTestEnvironment(
+    src: string,
+    runtime: IRunTime
+  ): Promise<{
+    reportDest: string;
+    testConfig: any;
+    testConfigResource: any;
+    portsToUse: string[];
+    testResources: string;
+  }> {
+    this.bddTestIsRunning(src);
+
+    const reportDest = `testeranto/reports/${this.name}/${src
+      .split(".")
+      .slice(0, -1)
+      .join(".")}/${runtime}`;
+
+    if (!fs.existsSync(reportDest)) {
+      fs.mkdirSync(reportDest, { recursive: true });
+    }
+
+    const testConfig = this.configs.tests.find((t) => t[0] === src);
+    if (!testConfig) {
+      console.log(
+        ansiC.inverse(`missing test config! Exiting ungracefully for '${src}'`)
+      );
+      process.exit(-1);
+    }
+
+    const testConfigResource = testConfig[2];
+    const portsToUse: string[] = [];
+    let testResources = "";
+
+    if (testConfigResource.ports === 0) {
+      testResources = JSON.stringify({
+        name: src,
+        ports: [],
+        fs: reportDest,
+        browserWSEndpoint: this.browser.wsEndpoint(),
+      });
+    } else if (testConfigResource.ports > 0) {
+      const openPorts = Object.entries(this.ports).filter(
+        ([, status]) => status === ""
+      );
+
+      if (openPorts.length >= testConfigResource.ports) {
+        for (let i = 0; i < testConfigResource.ports; i++) {
+          portsToUse.push(openPorts[i][0]);
+          this.ports[openPorts[i][0]] = src;
+        }
+
+        testResources = JSON.stringify({
+          scheduled: true,
+          name: src,
+          ports: portsToUse,
+          fs: reportDest,
+          browserWSEndpoint: this.browser.wsEndpoint(),
+        });
+      } else {
+        console.log(
+          ansiC.red(
+            `${runtime}: cannot run ${src} because there are no open ports ATM. This job will be enqueued and run again when a port is available`
+          )
+        );
+        this.queue.push(src);
+        throw new Error("No ports available");
+      }
+    } else {
+      console.error("negative port makes no sense", src);
+      process.exit(-1);
+    }
+
+    return {
+      reportDest,
+      testConfig,
+      testConfigResource,
+      portsToUse,
+      testResources,
+    };
+  }
+
+  private cleanupPorts(portsToUse: string[]) {
+    portsToUse.forEach((port) => {
+      this.ports[port] = "";
+    });
+  }
+
+  private createIpcServer(
+    onData: (data: Buffer) => void,
+    ipcfile: string
+  ): Promise<net.Server> {
+    return new Promise((resolve, reject) => {
+      const server = net.createServer((socket) => {
+        socket.on("data", onData);
+      });
+
+      server.listen(ipcfile, (err) => {
+        if (err) reject(err);
+        else resolve(server);
+      });
+
+      server.on("error", reject);
+    });
+  }
+
+  private handleChildProcess(
+    child: ChildProcess,
+    logs: LogStreams,
+    reportDest: string,
+    src: string,
+    runtime: IRunTime
+  ): Promise<void> {
+    return new Promise((resolve, reject) => {
+      child.stdout?.on("data", (data) => {
+        logs.stdout?.write(data);
+      });
+
+      child.stderr?.on("data", (data) => {
+        logs.stderr?.write(data);
+      });
+
+      child.on("close", (code) => {
+        const exitCode = code === null ? -1 : code;
+        if (exitCode < 0) {
+          logs.writeExitCode(
+            exitCode,
+            new Error("Process crashed or was terminated")
+          );
+        } else {
+          logs.writeExitCode(exitCode);
+        }
+        logs.closeAll();
+
+        if (exitCode === 0) {
+          this.bddTestIsNowDone(src, 0);
+          statusMessagePretty(0, src, runtime);
+          resolve();
+        } else {
+          console.log(
+            ansiColors.red(
+              `${runtime} ! ${src} failed to execute. Check ${reportDest}/stderr.log for more info`
+            )
+          );
+          this.bddTestIsNowDone(src, exitCode);
+          statusMessagePretty(exitCode, src, runtime);
+          reject(new Error(`Process exited with code ${exitCode}`));
+        }
+      });
+
+      child.on("error", (e) => {
+        console.log(
+          ansiC.red(
+            ansiC.inverse(
+              `${src} errored with: ${e.name}. Check error logs for more info`
+            )
+          )
+        );
+        this.bddTestIsNowDone(src, -1);
+        statusMessagePretty(-1, src, runtime);
+        reject(e);
+      });
+    });
+  }
+
   launchPure = async (src: string, dest: string) => {
+    console.log(ansiC.green(ansiC.inverse(`pure < ${src}`)));
+
     const processId = `pure-${src}-${Date.now()}`;
     const command = `pure test: ${src}`;
 
@@ -102,6 +273,8 @@ export class PM_Main extends PM_WithProcesses {
               return defaultModule
                 .receiveTestResourceConfig(argz)
                 .then(async (results: IFinalResults) => {
+                  // Ensure the test results are properly processed
+                  // The receiveTestResourceConfig should handle creating tests.json
                   statusMessagePretty(results.fails, src, "pure");
                   this.bddTestIsNowDone(src, results.fails);
                   return results.fails;
@@ -114,6 +287,24 @@ export class PM_Main extends PM_WithProcesses {
                 )
               );
 
+              // Create a minimal tests.json even on failure
+              const testsJsonPath = `${reportDest}/tests.json`;
+              if (!fs.existsSync(testsJsonPath)) {
+                fs.writeFileSync(
+                  testsJsonPath,
+                  JSON.stringify(
+                    {
+                      tests: [],
+                      features: [],
+                      givens: [],
+                      fullPath: src,
+                    },
+                    null,
+                    2
+                  )
+                );
+              }
+
               logs.exit.write(e2.stack);
               logs.exit.write(-1);
               this.bddTestIsNowDone(src, -1);
@@ -122,6 +313,24 @@ export class PM_Main extends PM_WithProcesses {
             });
         });
       } catch (e3) {
+        // Create a minimal tests.json even on uncaught errors
+        const testsJsonPath = `${reportDest}/tests.json`;
+        if (!fs.existsSync(testsJsonPath)) {
+          fs.writeFileSync(
+            testsJsonPath,
+            JSON.stringify(
+              {
+                tests: [],
+                features: [],
+                givens: [],
+                fullPath: src,
+              },
+              null,
+              2
+            )
+          );
+        }
+
         logs.writeExitCode(-1, e3);
         console.log(
           ansiC.red(
@@ -137,6 +346,9 @@ export class PM_Main extends PM_WithProcesses {
         statusMessagePretty(-1, src, "pure");
         throw e3;
       } finally {
+        // Generate prompt files for Pure tests
+        await this.generatePromptFiles(reportDest, src);
+
         for (let i = 0; i <= portsToUse.length; i++) {
           if (portsToUse[i]) {
             this.ports[portsToUse[i]] = ""; // port is open again
@@ -157,211 +369,84 @@ export class PM_Main extends PM_WithProcesses {
   };
 
   launchNode = async (src: string, dest: string) => {
+    console.log(ansiC.green(ansiC.inverse(`node < ${src}`)));
+
     const processId = `node-${src}-${Date.now()}`;
     const command = `node test: ${src}`;
 
-    // Create the promise
     const nodePromise = (async () => {
-      this.bddTestIsRunning(src);
-
-      const reportDest = `testeranto/reports/${this.name}/${src
-        .split(".")
-        .slice(0, -1)
-        .join(".")}/node`;
-
-      if (!fs.existsSync(reportDest)) {
-        fs.mkdirSync(reportDest, { recursive: true });
-      }
-
-      let testResources = "";
-
-      const testConfig = this.configs.tests.find((t) => {
-        return t[0] === src;
-      });
-
-      if (!testConfig) {
-        console.log(
-          ansiC.inverse(
-            `missing test config! Exiting ungracefully for '${src}'`
-          )
-        );
-        process.exit(-1);
-      }
-
-      const testConfigResource = testConfig[2];
-
-      const portsToUse: string[] = [];
-
-      if (testConfigResource.ports === 0) {
-        const t: ITTestResourceConfiguration = {
-          name: src,
-          ports: [],
-          fs: reportDest,
-          browserWSEndpoint: this.browser.wsEndpoint(),
-        };
-
-        testResources = JSON.stringify(t);
-      } else if (testConfigResource.ports > 0) {
-        const openPorts: [string, string][] = Object.entries(this.ports).filter(
-          ([portnumber, portopen]) => portopen === ""
-        );
-
-        if (openPorts.length >= testConfigResource.ports) {
-          for (let i = 0; i < testConfigResource.ports; i++) {
-            portsToUse.push(openPorts[i][0]);
-
-            this.ports[openPorts[i][0]] = src; // port is now claimed
-          }
-
-          testResources = JSON.stringify({
-            scheduled: true,
-            name: src,
-            ports: portsToUse,
-            fs: reportDest,
-            browserWSEndpoint: this.browser.wsEndpoint(),
-          });
-        } else {
-          console.log(
-            ansiC.red(
-              `node: cannot run ${src} because there are no open ports ATM. This job will be enqueued and run again run a port is available`
-            )
-          );
-          this.queue.push(src);
-          return [Math.random(), testResources];
-        }
-      } else {
-        console.error("negative port makes no sense", src);
-        process.exit(-1);
-      }
-
-      const builtfile = dest;
-
-      let haltReturns = false;
-
-      const ipcfile = "/tmp/tpipe_" + Math.random();
-      const child = spawn("node", [builtfile, testResources, ipcfile], {
-        stdio: ["pipe", "pipe", "pipe", "ipc"],
-      });
+      try {
+        const { reportDest, testResources, portsToUse } =
+          await this.setupTestEnvironment(src, "node");
 
-      let buffer: Buffer<ArrayBufferLike> = new Buffer("");
+        const builtfile = dest;
+        const ipcfile = "/tmp/tpipe_" + Math.random();
+        const logs = createLogStreams(reportDest, "node");
 
-      const server = net.createServer((socket) => {
+        let buffer = Buffer.from("");
         const queue = new Queue<string[]>();
 
-        socket.on("data", (data) => {
+        const onData = (data: Buffer) => {
           buffer = Buffer.concat([buffer, data]);
 
+          // Process complete JSON messages
           for (let b = 0; b < buffer.length + 1; b++) {
             const c = buffer.slice(0, b);
-            let d;
             try {
-              d = JSON.parse(c.toString());
-
+              const d = JSON.parse(c.toString());
               queue.enqueue(d);
-              buffer = buffer.slice(b, buffer.length + 1);
+              buffer = buffer.slice(b);
               b = 0;
             } catch (e) {
-              // b++;
+              // Continue processing
             }
           }
 
+          // Process messages
           while (queue.size() > 0) {
             const message = queue.dequeue();
-
             if (message) {
-              // set up the "node" listeners
               this.mapping().forEach(async ([command, func]) => {
                 if (message[0] === command) {
-                  const x = message.slice(1, -1);
-                  const r = await this[command](...x);
-
-                  if (!haltReturns) {
+                  const args = message.slice(1, -1);
+                  try {
+                    const result = await (this as any)[command](...args);
                     child.send(
                       JSON.stringify({
-                        payload: r,
+                        payload: result,
                         key: message[message.length - 1],
                       })
                     );
+                  } catch (error) {
+                    console.error(`Error handling command ${command}:`, error);
                   }
                 }
               });
             }
           }
-        });
-      });
-
-      const logs = createLogStreams(reportDest, "node");
-
-      return new Promise<void>((resolve, reject) => {
-        server.listen(ipcfile, () => {
-          child.stdout?.on("data", (data) => {
-            logs.stdout?.write(data);
-          });
-
-          child.stderr?.on("data", (data) => {
-            logs.stderr?.write(data);
-          });
-
-          child.on("close", (code) => {
-            const exitCode = code === null ? -1 : code;
-            if (exitCode < 0) {
-              logs.writeExitCode(
-                exitCode,
-                new Error("Process crashed or was terminated")
-              );
-            } else {
-              logs.writeExitCode(exitCode);
-            }
-            logs.closeAll();
-            server.close();
+        };
 
-            if (exitCode === 255) {
-              console.log(
-                ansiColors.red(
-                  `node ! ${src} failed to execute. No "tests.json" file was generated. Check ${reportDest}/stderr.log for more info`
-                )
-              );
-              this.bddTestIsNowDone(src, -1);
-              statusMessagePretty(-1, src, "node");
-              reject(new Error(`Process exited with code ${exitCode}`));
-            } else if (exitCode === 0) {
-              this.bddTestIsNowDone(src, 0);
-              statusMessagePretty(0, src, "node");
-              resolve();
-            } else {
-              this.bddTestIsNowDone(src, exitCode);
-              statusMessagePretty(exitCode, src, "node");
-              reject(new Error(`Process exited with code ${exitCode}`));
-            }
+        const server = await this.createIpcServer(onData, ipcfile);
+        const child = spawn("node", [builtfile, testResources, ipcfile], {
+          stdio: ["pipe", "pipe", "pipe", "ipc"],
+        });
 
-            haltReturns = true;
-          });
+        try {
+          await this.handleChildProcess(child, logs, reportDest, src, "node");
 
-          child.on("error", (e) => {
-            console.log("error");
-            haltReturns = true;
-            console.log(
-              ansiC.red(
-                ansiC.inverse(
-                  `${src} errored with: ${e.name}. Check error logs for more info`
-                )
-              )
-            );
-            this.bddTestIsNowDone(src, -1);
-            statusMessagePretty(-1, src, "node");
-            reject(e);
-          });
-        });
-      }).finally(() => {
-        for (let i = 0; i <= portsToUse.length; i++) {
-          if (portsToUse[i]) {
-            this.ports[portsToUse[i]] = ""; //port is open again
-          }
+          // Generate prompt files for Node tests
+          await this.generatePromptFiles(reportDest, src);
+        } finally {
+          server.close();
+          this.cleanupPorts(portsToUse);
         }
-      });
+      } catch (error) {
+        if (error.message !== "No ports available") {
+          throw error;
+        }
+      }
     })();
 
-    // Add to process manager
     this.addPromiseProcess(
       processId,
       nodePromise,
@@ -373,6 +458,8 @@ export class PM_Main extends PM_WithProcesses {
   };
 
   launchWeb = async (src: string, dest: string) => {
+    console.log(ansiC.green(ansiC.inverse(`web < ${src}`)));
+
     const processId = `web-${src}-${Date.now()}`;
     const command = `web test: ${src}`;
 
@@ -491,10 +578,31 @@ export class PM_Main extends PM_WithProcesses {
                     )
                   )
                 );
+
+                // Create a minimal tests.json even on failure
+                const testsJsonPath = `${reportDest}/tests.json`;
+                if (!fs.existsSync(testsJsonPath)) {
+                  fs.writeFileSync(
+                    testsJsonPath,
+                    JSON.stringify(
+                      {
+                        tests: [],
+                        features: [],
+                        givens: [],
+                        fullPath: src,
+                      },
+                      null,
+                      2
+                    )
+                  );
+                }
+
                 this.bddTestIsNowDone(src, -1);
                 reject(e);
               })
-              .finally(() => {
+              .finally(async () => {
+                // Generate prompt files for Web tests
+                await this.generatePromptFiles(reportDest, src);
                 close();
               });
           })
@@ -516,138 +624,87 @@ export class PM_Main extends PM_WithProcesses {
   };
 
   launchPython = async (src: string, dest: string) => {
+    console.log(ansiC.green(ansiC.inverse(`python < ${src}`)));
+
     const processId = `python-${src}-${Date.now()}`;
     const command = `python test: ${src}`;
 
     const pythonPromise = (async () => {
-      this.bddTestIsRunning(src);
-
-      const reportDest = `testeranto/reports/${this.name}/${src
-        .split(".")
-        .slice(0, -1)
-        .join(".")}/python`;
-
-      if (!fs.existsSync(reportDest)) {
-        fs.mkdirSync(reportDest, { recursive: true });
-      }
-
-      let testResources = "";
+      try {
+        const { reportDest, testResources, portsToUse } =
+          await this.setupTestEnvironment(src, "python");
 
-      const testConfig = this.configs.tests.find((t) => t[0] === src);
-      if (!testConfig) {
-        console.log(
-          ansiColors.inverse(
-            `missing test config! Exiting ungracefully for '${src}'`
-          )
-        );
-        process.exit(-1);
-      }
+        const logs = createLogStreams(reportDest, "python");
 
-      const testConfigResource = testConfig[2];
-      const portsToUse: string[] = [];
+        // Determine Python command
+        const venvPython = `./venv/bin/python3`;
+        const pythonCommand = fs.existsSync(venvPython)
+          ? venvPython
+          : "python3";
 
-      if (testConfigResource.ports === 0) {
-        testResources = JSON.stringify({
-          scheduled: true,
-          name: src,
-          ports: portsToUse,
-          fs: reportDest,
-          browserWSEndpoint: this.browser.wsEndpoint(),
+        const ipcfile = "/tmp/tpipe_python_" + Math.random();
+        const child = spawn(pythonCommand, [src, testResources, ipcfile], {
+          stdio: ["pipe", "pipe", "pipe", "ipc"],
         });
-      } else if (testConfigResource.ports > 0) {
-        const openPorts = Object.entries(this.ports).filter(
-          ([, status]) => status === ""
-        );
 
-        if (openPorts.length >= testConfigResource.ports) {
-          for (let i = 0; i < testConfigResource.ports; i++) {
-            portsToUse.push(openPorts[i][0]);
-            this.ports[openPorts[i][0]] = src;
-          }
-
-          testResources = JSON.stringify({
-            scheduled: true,
-            name: src,
-            ports: portsToUse,
-            fs: reportDest,
-            browserWSEndpoint: this.browser.wsEndpoint(),
-          });
-        } else {
-          console.log(
-            ansiColors.red(
-              `python: cannot run ${src} because there are no open ports ATM. This job will be enqueued and run again when a port is available`
-            )
-          );
-          this.queue.push(src);
-          return;
-        }
-      } else {
-        console.error("negative port makes no sense", src);
-        process.exit(-1);
-      }
+        // IPC server setup is similar to Node
+        let buffer = Buffer.from("");
+        const queue = new Queue<string[]>();
 
-      const logs = createLogStreams(reportDest, "python");
+        const onData = (data: Buffer) => {
+          buffer = Buffer.concat([buffer, data]);
 
-      // For Python, we'll just run the script directly and pass test resources as an argument
-      // Python tests need to handle their own IPC if needed
-      const child = spawn("python3", [src, testResources], {
-        stdio: ["pipe", "pipe", "pipe"],
-      });
+          for (let b = 0; b < buffer.length + 1; b++) {
+            const c = buffer.slice(0, b);
+            try {
+              const d = JSON.parse(c.toString());
+              queue.enqueue(d);
+              buffer = buffer.slice(b);
+              b = 0;
+            } catch (e) {
+              // Continue processing
+            }
+          }
 
-      return new Promise<void>((resolve, reject) => {
-        child.stdout?.on("data", (data) => {
-          logs.stdout?.write(data);
-        });
+          while (queue.size() > 0) {
+            const message = queue.dequeue();
+            if (message) {
+              this.mapping().forEach(async ([command, func]) => {
+                if (message[0] === command) {
+                  const args = message.slice(1, -1);
+                  try {
+                    const result = await (this as any)[command](...args);
+                    child.send(
+                      JSON.stringify({
+                        payload: result,
+                        key: message[message.length - 1],
+                      })
+                    );
+                  } catch (error) {
+                    console.error(`Error handling command ${command}:`, error);
+                  }
+                }
+              });
+            }
+          }
+        };
 
-        child.stderr?.on("data", (data) => {
-          logs.stderr?.write(data);
-        });
+        const server = await this.createIpcServer(onData, ipcfile);
 
-        child.on("close", (code) => {
-          const exitCode = code === null ? -1 : code;
-          if (exitCode < 0) {
-            logs.writeExitCode(
-              exitCode,
-              new Error("Process crashed or was terminated")
-            );
-          } else {
-            logs.writeExitCode(exitCode);
-          }
-          logs.closeAll();
-
-          if (exitCode === 0) {
-            this.bddTestIsNowDone(src, 0);
-            statusMessagePretty(0, src, "python");
-            resolve();
-          } else {
-            console.log(
-              ansiColors.red(
-                `python ! ${src} failed to execute. Check ${reportDest}/stderr.log for more info`
-              )
-            );
-            this.bddTestIsNowDone(src, exitCode);
-            statusMessagePretty(exitCode, src, "python");
-            reject(new Error(`Process exited with code ${exitCode}`));
-          }
-        });
+        try {
+          await this.handleChildProcess(child, logs, reportDest, src, "python");
 
-        child.on("error", (e) => {
-          console.log(
-            ansiColors.red(
-              ansiColors.inverse(
-                `python: ${src} errored with: ${e.name}. Check error logs for more info`
-              )
-            )
-          );
-          this.bddTestIsNowDone(src, -1);
-          statusMessagePretty(-1, src, "python");
-          reject(e);
-        });
-      }).finally(() => {
-        portsToUse.forEach(port => {
-          this.ports[port] = "";
-        });
-      });
+          // Generate prompt files for Python tests
+          await this.generatePromptFiles(reportDest, src);
+        } finally {
+          server.close();
+          this.cleanupPorts(portsToUse);
+        }
+      } catch (error) {
+        if (error.message !== "No ports available") {
+          throw error;
+        }
+      }
     })();
 
     this.addPromiseProcess(
@@ -661,180 +718,124 @@ export class PM_Main extends PM_WithProcesses {
   };
 
   launchGolang = async (src: string, dest: string) => {
+    console.log(ansiC.green(ansiC.inverse(`goland < ${src}`)));
+
     const processId = `golang-${src}-${Date.now()}`;
     const command = `golang test: ${src}`;
 
     const golangPromise = (async () => {
-      this.bddTestIsRunning(src);
-
-      const reportDest = `testeranto/reports/${this.name}/${src
-        .split(".")
-        .slice(0, -1)
-        .join(".")}/golang`;
+      try {
+        const { reportDest, testResources, portsToUse } =
+          await this.setupTestEnvironment(src, "golang");
 
-      if (!fs.existsSync(reportDest)) {
-        fs.mkdirSync(reportDest, { recursive: true });
-      }
+        const logs = createLogStreams(reportDest, "golang");
 
-      let testResources = "";
+        // Create IPC file path
+        const ipcfile =
+          "/tmp/tpipe_golang_" + Math.random().toString(36).substring(2);
 
-      const testConfig = this.configs.tests.find((t) => t[0] === src);
-      if (!testConfig) {
-        console.log(
-          ansiColors.inverse(
-            `golang: missing test config! Exiting ungracefully for '${src}'`
-          )
-        );
-        process.exit(-1);
-      }
-
-      const testConfigResource = testConfig[2];
-      const portsToUse: string[] = [];
+        let buffer = Buffer.from("");
+        const queue = new Queue<string[]>();
 
-      if (testConfigResource.ports === 0) {
-        testResources = JSON.stringify({
-          scheduled: true,
-          name: src,
-          ports: portsToUse,
-          fs: reportDest,
-          browserWSEndpoint: this.browser.wsEndpoint(),
-        });
-      } else if (testConfigResource.ports > 0) {
-        const openPorts = Object.entries(this.ports).filter(
-          ([, status]) => status === ""
-        );
+        const onData = (data: Buffer) => {
+          buffer = Buffer.concat([buffer, data]);
 
-        if (openPorts.length >= testConfigResource.ports) {
-          for (let i = 0; i < testConfigResource.ports; i++) {
-            portsToUse.push(openPorts[i][0]);
-            this.ports[openPorts[i][0]] = src;
+          // Process complete JSON messages
+          for (let b = 0; b < buffer.length + 1; b++) {
+            const c = buffer.slice(0, b);
+            try {
+              const d = JSON.parse(c.toString());
+              queue.enqueue(d);
+              buffer = buffer.slice(b);
+              b = 0;
+            } catch (e) {
+              // Continue processing
+            }
           }
 
-          testResources = JSON.stringify({
-            scheduled: true,
-            name: src,
-            ports: portsToUse,
-            fs: reportDest,
-            browserWSEndpoint: this.browser.wsEndpoint(),
-          });
-        } else {
-          console.log(
-            ansiColors.red(
-              `golang: cannot run ${src} because there are no open ports ATM. This job will be enqueued and run again when a port is available`
-            )
-          );
-          this.queue.push(src);
-          return;
-        }
-      } else {
-        console.error("negative port makes no sense", src);
-        process.exit(-1);
-      }
-
-      // Compile the Go test first
-      const buildDir = path.dirname(dest);
-      const binaryName = path.basename(dest, '.go');
-      const binaryPath = path.join(buildDir, binaryName);
-      
-      const logs = createLogStreams(reportDest, "golang");
+          // Process messages
+          while (queue.size() > 0) {
+            const message = queue.dequeue();
+            if (message) {
+              this.mapping().forEach(async ([command, func]) => {
+                if (message[0] === command) {
+                  const args = message.slice(1, -1);
+                  try {
+                    const result = await (this as any)[command](...args);
+                    // Send response back through IPC
+                    // This would need to be implemented based on your IPC protocol
+                  } catch (error) {
+                    console.error(`Error handling command ${command}:`, error);
+                  }
+                }
+              });
+            }
+          }
+        };
 
-      // First, compile the Go program
-      const compileProcess = spawn("go", ["build", "-o", binaryPath, dest]);
-      
-      return new Promise<void>((resolve, reject) => {
-        compileProcess.stdout?.on("data", (data) => {
-          logs.stdout?.write(data);
-        });
+        // Create IPC server like in launchNode
+        const server = await this.createIpcServer(onData, ipcfile);
 
-        compileProcess.stderr?.on("data", (data) => {
-          logs.stderr?.write(data);
-        });
+        // For Go tests, we need to run from the directory containing the go.mod file
+        // Find the nearest go.mod file by walking up the directory tree
+        let currentDir = path.dirname(src);
+        let goModDir = null;
 
-        compileProcess.on("close", (compileCode) => {
-          if (compileCode !== 0) {
-            console.log(
-              ansiColors.red(
-                `golang ! ${src} failed to compile. Check ${reportDest}/stderr.log for more info`
-              )
-            );
-            this.bddTestIsNowDone(src, compileCode || -1);
-            statusMessagePretty(compileCode || -1, src, "golang");
-            reject(new Error(`Compilation failed with code ${compileCode}`));
-            return;
+        while (currentDir !== path.parse(currentDir).root) {
+          if (fs.existsSync(path.join(currentDir, "go.mod"))) {
+            goModDir = currentDir;
+            break;
           }
+          currentDir = path.dirname(currentDir);
+        }
 
-          // Now run the compiled binary
-          const child = spawn(binaryPath, [testResources], {
-            stdio: ["pipe", "pipe", "pipe"],
-          });
+        if (!goModDir) {
+          console.error(`Could not find go.mod file for test ${src}`);
+          // Try running from the test file's directory as a fallback
+          goModDir = path.dirname(src);
+          console.error(`Falling back to: ${goModDir}`);
+        }
 
-          child.stdout?.on("data", (data) => {
-            logs.stdout?.write(data);
-          });
+        // Get the relative path to the test file from the go.mod directory
+        const relativeTestPath = path.relative(goModDir, src);
 
-          child.stderr?.on("data", (data) => {
-            logs.stderr?.write(data);
-          });
+        // Run go test from the directory containing go.mod
+        const child = spawn(
+          "go",
+          ["test", "-v", "-json", "./" + path.dirname(relativeTestPath)],
+          {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: {
+              ...process.env,
+              TEST_RESOURCES: testResources,
+              IPC_FILE: ipcfile,
+              GO111MODULE: "on",
+            },
+            cwd: goModDir,
+          }
+        );
 
-          child.on("close", (code) => {
-            const exitCode = code === null ? -1 : code;
-            if (exitCode < 0) {
-              logs.writeExitCode(
-                exitCode,
-                new Error("Process crashed or was terminated")
-              );
-            } else {
-              logs.writeExitCode(exitCode);
-            }
-            logs.closeAll();
+        await this.handleChildProcess(child, logs, reportDest, src, "golang");
 
-            if (exitCode === 0) {
-              this.bddTestIsNowDone(src, 0);
-              statusMessagePretty(0, src, "golang");
-              resolve();
-            } else {
-              console.log(
-                ansiColors.red(
-                  `golang ! ${src} failed to execute. Check ${reportDest}/stderr.log for more info`
-                )
-              );
-              this.bddTestIsNowDone(src, exitCode);
-              statusMessagePretty(exitCode, src, "golang");
-              reject(new Error(`Process exited with code ${exitCode}`));
-            }
-          });
+        // Generate prompt files for Golang tests
+        await this.generatePromptFiles(reportDest, src);
 
-          child.on("error", (e) => {
-            console.log(
-              ansiColors.red(
-                ansiColors.inverse(
-                  `golang: ${src} errored with: ${e.name}. Check error logs for more info`
-                )
-              )
-            );
-            this.bddTestIsNowDone(src, -1);
-            statusMessagePretty(-1, src, "golang");
-            reject(e);
-          });
-        });
+        // Ensure tests.json exists by parsing the go test JSON output
+        await this.processGoTestOutput(reportDest, src);
 
-        compileProcess.on("error", (e) => {
-          console.log(
-            ansiColors.red(
-              ansiColors.inverse(
-                `golang: ${src} compilation errored with: ${e.name}. Check error logs for more info`
-              )
-            )
-          );
-          this.bddTestIsNowDone(src, -1);
-          statusMessagePretty(-1, src, "golang");
-          reject(e);
-        });
-      }).finally(() => {
-        portsToUse.forEach(port => {
-          this.ports[port] = "";
-        });
-      });
+        // Clean up
+        server.close();
+        try {
+          fs.unlinkSync(ipcfile);
+        } catch (e) {
+          // Ignore errors during cleanup
+        }
+        this.cleanupPorts(portsToUse);
+      } catch (error) {
+        if (error.message !== "No ports available") {
+          throw error;
+        }
+      }
     })();
 
     this.addPromiseProcess(
@@ -846,4 +847,135 @@ export class PM_Main extends PM_WithProcesses {
       "golang"
     );
   };
+
+  private async processGoTestOutput(
+    reportDest: string,
+    src: string
+  ): Promise<void> {
+    const testsJsonPath = `${reportDest}/tests.json`;
+
+    // Parse the stdout.log to extract test results from JSON output
+    const stdoutPath = `${reportDest}/stdout.log`;
+    if (fs.existsSync(stdoutPath)) {
+      try {
+        const stdoutContent = fs.readFileSync(stdoutPath, "utf-8");
+        const lines = stdoutContent.split("\n").filter((line) => line.trim());
+
+        const testResults = {
+          tests: [],
+          features: [],
+          givens: [],
+          fullPath: path.resolve(process.cwd(), src),
+        };
+
+        // Parse each JSON line from go test output
+        for (const line of lines) {
+          try {
+            const event = JSON.parse(line);
+            if (event.Action === "pass" || event.Action === "fail") {
+              testResults.tests.push({
+                name: event.Test || event.Package,
+                status: event.Action === "pass" ? "passed" : "failed",
+                time: event.Elapsed ? `${event.Elapsed}s` : "0s",
+              });
+            }
+          } catch (e) {
+            // Skip non-JSON lines
+          }
+        }
+
+        fs.writeFileSync(testsJsonPath, JSON.stringify(testResults, null, 2));
+        return;
+      } catch (error) {
+        console.error("Error processing go test output:", error);
+      }
+    }
+
+    // Fallback: create a basic tests.json if processing fails
+    const basicTestResult = {
+      tests: [],
+      features: [],
+      givens: [],
+      fullPath: path.resolve(process.cwd(), src),
+    };
+    fs.writeFileSync(testsJsonPath, JSON.stringify(basicTestResult, null, 2));
+  }
+
+  private async generatePromptFiles(
+    reportDest: string,
+    src: string
+  ): Promise<void> {
+    try {
+      // Ensure the report directory exists
+      if (!fs.existsSync(reportDest)) {
+        fs.mkdirSync(reportDest, { recursive: true });
+      }
+
+      // Create message.txt
+      const messagePath = `${reportDest}/message.txt`;
+      const messageContent = `There are 3 types of test reports.
+1) bdd (highest priority)
+2) type checker
+3) static analysis (lowest priority)
+
+"tests.json" is the detailed result of the bdd tests.
+if these files do not exist, then something has gone badly wrong and needs to be addressed.
+
+"type_errors.txt" is the result of the type checker.
+if this file does not exist, then type check passed without errors;
+
+"lint_errors.txt" is the result of the static analysis.
+if this file does not exist, then static analysis passed without errors;
+
+BDD failures are the highest priority. Focus on passing BDD tests before addressing other concerns.
+Do not add error throwing/catching to the tests themselves.`;
+
+      fs.writeFileSync(messagePath, messageContent);
+
+      // Create prompt.txt
+      const promptPath = `${reportDest}/prompt.txt`;
+
+      const promptContent = `/read node_modules/testeranto/docs/index.md
+/read node_modules/testeranto/docs/style.md
+/read node_modules/testeranto/docs/testing.ai.txt
+/read node_modules/testeranto/src/CoreTypes.ts
+
+/read ${reportDest}/tests.json
+/read ${reportDest}/type_errors.txt
+/read ${reportDest}/lint_errors.txt
+
+/read ${reportDest}/stdout.log
+/read ${reportDest}/stderr.log
+/read ${reportDest}/exit.log
+/read ${reportDest}/message.txt`;
+
+      fs.writeFileSync(promptPath, promptContent);
+    } catch (error) {
+      console.error(`Failed to generate prompt files for ${src}:`, error);
+    }
+  }
+
+  private getGolangSourceFiles(src: string): string[] {
+    // Get all .go files in the same directory as the test
+    const testDir = path.dirname(src);
+    const files: string[] = [];
+
+    try {
+      const dirContents = fs.readdirSync(testDir);
+      dirContents.forEach((file) => {
+        if (file.endsWith(".go")) {
+          files.push(path.join(testDir, file));
+        }
+      });
+    } catch (error) {
+      console.error(`Error reading directory ${testDir}:`, error);
+    }
+
+    // Always include the main test file
+    if (!files.includes(src)) {
+      files.push(src);
+    }
+
+    return files;
+  }
 }