testeranto 0.202.0 → 0.203.0

package/dist/prebuild/testeranto.mjs

@@ -10,7 +10,7 @@ var __export = (target, all) => {
 };
 
 // src/utils.ts
-import path2 from "path";
+import path from "path";
 var webEvaluator, tscPather, lintPather, promptPather, getRunnables;
 var init_utils = __esm({
   "src/utils.ts"() {
@@ -27,7 +27,7 @@ import('${d}').then(async (x) => {
 `;
     };
     tscPather = (entryPoint, platform, projectName) => {
-      return path2.join(
+      return path.join(
         "testeranto",
         "reports",
         projectName,
@@ -37,7 +37,7 @@ import('${d}').then(async (x) => {
       );
     };
     lintPather = (entryPoint, platform, projectName) => {
-      return path2.join(
+      return path.join(
         "testeranto",
         "reports",
         projectName,
@@ -47,7 +47,7 @@ import('${d}').then(async (x) => {
       );
     };
     promptPather = (entryPoint, platform, projectName) => {
-      return path2.join(
+      return path.join(
         "testeranto",
         "reports",
         projectName,
@@ -82,42 +82,42 @@ import('${d}').then(async (x) => {
       };
       return tests.reduce((pt, cv, cndx, cry) => {
         if (cv[1] === "node") {
-          pt.nodeEntryPoints[cv[0]] = path2.resolve(
+          pt.nodeEntryPoints[cv[0]] = path.resolve(
             `./testeranto/bundles/node/${projectName}/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
           );
         } else if (cv[1] === "web") {
-          pt.webEntryPoints[cv[0]] = path2.resolve(
+          pt.webEntryPoints[cv[0]] = path.resolve(
             `./testeranto/bundles/web/${projectName}/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
           );
         } else if (cv[1] === "pure") {
-          pt.pureEntryPoints[cv[0]] = path2.resolve(
+          pt.pureEntryPoints[cv[0]] = path.resolve(
             `./testeranto/bundles/pure/${projectName}/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
           );
         } else if (cv[1] === "golang") {
-          pt.golangEntryPoints[cv[0]] = path2.resolve(cv[0]);
+          pt.golangEntryPoints[cv[0]] = path.resolve(cv[0]);
         } else if (cv[1] === "python") {
-          pt.pythonEntryPoints[cv[0]] = path2.resolve(cv[0]);
+          pt.pythonEntryPoints[cv[0]] = path.resolve(cv[0]);
         }
         cv[3].filter((t) => t[1] === "node").forEach((t) => {
-          pt.nodeEntryPointSidecars[`${t[0]}`] = path2.resolve(
+          pt.nodeEntryPointSidecars[`${t[0]}`] = path.resolve(
             `./testeranto/bundles/node/${projectName}/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
           );
         });
         cv[3].filter((t) => t[1] === "web").forEach((t) => {
-          pt.webEntryPointSidecars[`${t[0]}`] = path2.resolve(
+          pt.webEntryPointSidecars[`${t[0]}`] = path.resolve(
             `./testeranto/bundles/web/${projectName}/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
           );
         });
         cv[3].filter((t) => t[1] === "pure").forEach((t) => {
-          pt.pureEntryPointSidecars[`${t[0]}`] = path2.resolve(
+          pt.pureEntryPointSidecars[`${t[0]}`] = path.resolve(
             `./testeranto/bundles/pure/${projectName}/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
           );
         });
         cv[3].filter((t) => t[1] === "golang").forEach((t) => {
-          pt.golangEntryPointSidecars[`${t[0]}`] = path2.resolve(t[0]);
+          pt.golangEntryPointSidecars[`${t[0]}`] = path.resolve(t[0]);
         });
         cv[3].filter((t) => t[1] === "python").forEach((t) => {
-          pt.pythonEntryPointSidecars[`${t[0]}`] = path2.resolve(t[0]);
+          pt.pythonEntryPointSidecars[`${t[0]}`] = path.resolve(t[0]);
         });
         return pt;
       }, initializedPayload);
@@ -125,6 +125,872 @@ import('${d}').then(async (x) => {
   }
 });
 
+// src/utils/golingvuMetafile.ts
+import fs3 from "fs";
+import path4 from "path";
+import { execSync } from "child_process";
+function runGoList(pattern) {
+  try {
+    let processedPattern = pattern;
+    if (fs3.existsSync(pattern) && pattern.endsWith(".go")) {
+      const dir = path4.dirname(pattern);
+      processedPattern = dir;
+    }
+    const output = execSync(`go list -mod=readonly -json ${processedPattern}`, {
+      encoding: "utf-8",
+      cwd: process.cwd(),
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const objects = [];
+    let buffer = "";
+    let depth = 0;
+    let inString = false;
+    let escapeNext = false;
+    for (const char of output) {
+      if (escapeNext) {
+        buffer += char;
+        escapeNext = false;
+        continue;
+      }
+      if (char === "\\") {
+        escapeNext = true;
+        buffer += char;
+        continue;
+      }
+      if (char === '"') {
+        inString = !inString;
+      }
+      if (!inString) {
+        if (char === "{") {
+          depth++;
+        } else if (char === "}") {
+          depth--;
+          if (depth === 0) {
+            try {
+              objects.push(JSON.parse(buffer + char));
+              buffer = "";
+              continue;
+            } catch (e) {
+              console.warn("Failed to parse JSON object:", buffer + char);
+              buffer = "";
+            }
+          }
+        }
+      }
+      if (depth > 0 || buffer.length > 0) {
+        buffer += char;
+      }
+    }
+    return objects;
+  } catch (error) {
+    console.warn(`Error running 'go list -json ${pattern}':`, error);
+    try {
+      const output = execSync(`go list -mod=readonly -json .`, {
+        encoding: "utf-8",
+        cwd: process.cwd(),
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const objects = [];
+      let buffer = "";
+      let depth = 0;
+      let inString = false;
+      let escapeNext = false;
+      for (const char of output) {
+        if (escapeNext) {
+          buffer += char;
+          escapeNext = false;
+          continue;
+        }
+        if (char === "\\") {
+          escapeNext = true;
+          buffer += char;
+          continue;
+        }
+        if (char === '"') {
+          inString = !inString;
+        }
+        if (!inString) {
+          if (char === "{") {
+            depth++;
+          } else if (char === "}") {
+            depth--;
+            if (depth === 0) {
+              try {
+                objects.push(JSON.parse(buffer + char));
+                buffer = "";
+                continue;
+              } catch (e) {
+                console.warn("Failed to parse JSON object:", buffer + char);
+                buffer = "";
+              }
+            }
+          }
+        }
+        if (depth > 0 || buffer.length > 0) {
+          buffer += char;
+        }
+      }
+      return objects;
+    } catch (fallbackError) {
+      console.warn("Fallback go list also failed:", fallbackError);
+      return [];
+    }
+  }
+}
+function findGoFilesInProject() {
+  const packages = runGoList("./...");
+  const goFiles = [];
+  for (const pkg of packages) {
+    if (pkg.GoFiles) {
+      for (const file of pkg.GoFiles) {
+        goFiles.push(path4.join(pkg.Dir, file));
+      }
+    }
+    if (pkg.CgoFiles) {
+      for (const file of pkg.CgoFiles) {
+        goFiles.push(path4.join(pkg.Dir, file));
+      }
+    }
+  }
+  return goFiles;
+}
+function collectGoDependencies(filePath, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(filePath))
+    return [];
+  visited.add(filePath);
+  const dependencies = [filePath];
+  const dir = path4.dirname(filePath);
+  try {
+    const files3 = fs3.readdirSync(dir);
+    for (const file of files3) {
+      if (file.endsWith(".go") && file !== path4.basename(filePath)) {
+        const fullPath = path4.join(dir, file);
+        dependencies.push(fullPath);
+      }
+    }
+  } catch (error) {
+    console.warn(`Could not read directory ${dir}:`, error);
+  }
+  try {
+    const content = fs3.readFileSync(filePath, "utf-8");
+    const importRegex = /import\s*(?:\(\s*([\s\S]*?)\s*\)|"([^"]+)")/g;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      if (match[2]) {
+        const importPath = match[2].trim();
+        processImport(importPath, dir, dependencies, visited);
+      } else if (match[1]) {
+        const importBlock = match[1];
+        const importLines = importBlock.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("//"));
+        for (const line of importLines) {
+          const lineMatch = line.match(/"([^"]+)"/);
+          if (lineMatch) {
+            const importPath = lineMatch[1].trim();
+            processImport(importPath, dir, dependencies, visited);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    console.warn(`Could not read file ${filePath} for import parsing:`, error);
+  }
+  return [...new Set(dependencies)];
+}
+function processImport(importPath, currentDir, dependencies, visited) {
+  const firstPathElement = importPath.split("/")[0];
+  const isExternal = firstPathElement.includes(".");
+  if (!isExternal) {
+    const potentialPaths = [
+      path4.join(process.cwd(), "vendor", importPath),
+      path4.join(currentDir, importPath),
+      path4.join(process.cwd(), importPath),
+      path4.join(process.cwd(), "src", importPath)
+    ];
+    for (const potentialPath of potentialPaths) {
+      if (fs3.existsSync(potentialPath) && fs3.statSync(potentialPath).isDirectory()) {
+        try {
+          const files3 = fs3.readdirSync(potentialPath);
+          for (const file of files3) {
+            if (file.endsWith(".go") && !file.endsWith("_test.go")) {
+              const fullPath = path4.join(potentialPath, file);
+              dependencies.push(...collectGoDependencies(fullPath, visited));
+            }
+          }
+          break;
+        } catch (error) {
+          console.warn(`Could not read directory ${potentialPath}:`, error);
+        }
+      }
+      const goFilePath = potentialPath + ".go";
+      if (fs3.existsSync(goFilePath)) {
+        dependencies.push(...collectGoDependencies(goFilePath, visited));
+        break;
+      }
+    }
+  }
+}
+function parseGoImports(filePath) {
+  const dir = path4.dirname(filePath);
+  const packages = runGoList(dir);
+  if (packages.length === 0) {
+    return [];
+  }
+  const pkg = packages[0];
+  const imports = [];
+  if (pkg.Imports) {
+    for (const importPath of pkg.Imports) {
+      const firstPathElement = importPath.split("/")[0];
+      const isExternal = firstPathElement.includes(".");
+      imports.push({
+        path: importPath,
+        kind: "import-statement",
+        external: isExternal
+      });
+    }
+  }
+  try {
+    const content = fs3.readFileSync(filePath, "utf-8");
+    const importRegex = /import\s*(?:\(\s*([\s\S]*?)\s*\)|"([^"]+)")/g;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      if (match[2]) {
+        const importPath = match[2].trim();
+        const firstPathElement = importPath.split("/")[0];
+        const isExternal = firstPathElement.includes(".");
+        if (!imports.some((imp) => imp.path === importPath)) {
+          imports.push({
+            path: importPath,
+            kind: "import-statement",
+            external: isExternal
+          });
+        }
+      } else if (match[1]) {
+        const importBlock = match[1];
+        const importLines = importBlock.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("//"));
+        for (const line of importLines) {
+          const lineMatch = line.match(/"([^"]+)"/);
+          if (lineMatch) {
+            const importPath = lineMatch[1].trim();
+            const firstPathElement = importPath.split("/")[0];
+            const isExternal = firstPathElement.includes(".");
+            if (!imports.some((imp) => imp.path === importPath)) {
+              imports.push({
+                path: importPath,
+                kind: "import-statement",
+                external: isExternal
+              });
+            }
+          }
+        }
+      }
+    }
+  } catch (error) {
+    console.warn(`Could not read file ${filePath} for import parsing:`, error);
+  }
+  return imports;
+}
+function findProjectRoot() {
+  let currentDir = process.cwd();
+  while (currentDir !== path4.parse(currentDir).root) {
+    const packageJsonPath = path4.join(currentDir, "package.json");
+    if (fs3.existsSync(packageJsonPath)) {
+      return currentDir;
+    }
+    currentDir = path4.dirname(currentDir);
+  }
+  return process.cwd();
+}
+function isGoAvailable() {
+  try {
+    execSync("go version", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function generateGolingvuMetafile(testName2, entryPoints) {
+  if (generationQueue) {
+    console.log("Generation already in progress, waiting...");
+    return generationQueue;
+  }
+  generationQueue = (async () => {
+    console.log(`Generating Golang metafile for test: ${testName2}`);
+    console.log(`Entry points provided: ${JSON.stringify(entryPoints)}`);
+    console.log(`Current working directory: ${process.cwd()}`);
+    const inputs = {};
+    const outputs = {};
+    const signature = Date.now().toString(36);
+    if (!isGoAvailable()) {
+      console.warn("Go toolchain is not available. Using fallback method.");
+      return {
+        errors: [],
+        warnings: [],
+        metafile: {
+          inputs: {},
+          outputs: {}
+        }
+      };
+    }
+    const filteredEntryPoints = [];
+    for (const entryPoint of entryPoints) {
+      const fileName = path4.basename(entryPoint);
+      if (fileName.includes("_test.go") || fileName.endsWith(".test.go")) {
+        console.warn(`Skipping Go test file: ${fileName}`);
+        continue;
+      }
+      filteredEntryPoints.push(entryPoint);
+    }
+    entryPoints = filteredEntryPoints;
+    if (entryPoints.length === 0) {
+      const allGoFiles = findGoFilesInProject();
+      entryPoints = allGoFiles.filter((file) => {
+        const fileName = path4.basename(file);
+        return !fileName.includes("_test.go") && !fileName.endsWith(".test.go");
+      });
+      if (entryPoints.length === 0) {
+        console.warn("No non-test Go files found in the project");
+      } else {
+        console.log(
+          `Found ${entryPoints.length} non-test Go files:`,
+          entryPoints
+        );
+      }
+    }
+    for (let i = 0; i < entryPoints.length; i++) {
+      let entryPoint = entryPoints[i];
+      let resolvedPath = entryPoint;
+      if (!path4.isAbsolute(entryPoint)) {
+        resolvedPath = path4.join(process.cwd(), entryPoint);
+      }
+      if (!fs3.existsSync(resolvedPath)) {
+        console.warn(
+          `Entry point ${entryPoint} does not exist at ${resolvedPath}`
+        );
+        const fileName2 = path4.basename(entryPoint);
+        const potentialPaths = [
+          path4.join(process.cwd(), "example", fileName2),
+          path4.join(process.cwd(), fileName2),
+          path4.join(process.cwd(), "src", "example", fileName2),
+          path4.join(process.cwd(), "src", fileName2)
+        ];
+        let foundPath = "";
+        for (const potentialPath of potentialPaths) {
+          if (fs3.existsSync(potentialPath)) {
+            foundPath = potentialPath;
+            console.log(`Found ${fileName2} at: ${foundPath}`);
+            break;
+          }
+        }
+        if (!foundPath) {
+          console.warn(`Could not find ${fileName2} in any common locations`);
+          continue;
+        }
+        entryPoints[i] = foundPath;
+        entryPoint = foundPath;
+      } else {
+        entryPoints[i] = resolvedPath;
+        entryPoint = resolvedPath;
+      }
+      const fileName = path4.basename(entryPoint);
+      if (fileName.includes("_test.go") || fileName.endsWith(".test.go")) {
+        console.log(`Skipping Go test file: ${fileName}`);
+        continue;
+      }
+      const allDependencies = collectGoDependencies(entryPoint);
+      for (const dep of allDependencies) {
+        if (!inputs[dep]) {
+          const bytes = fs3.statSync(dep).size;
+          const imports = parseGoImports(dep);
+          inputs[dep] = {
+            bytes,
+            imports,
+            format: "esm"
+            // Go doesn't use ES modules, but we'll use this for consistency
+          };
+        }
+      }
+      const entryPointName = path4.basename(entryPoint, ".go");
+      const baseName = entryPointName;
+      const outputKey = `golang/core/${baseName}.golingvu.go`;
+      const inputBytes = {};
+      let totalBytes = 0;
+      for (const dep of allDependencies) {
+        const bytes = fs3.statSync(dep).size;
+        inputBytes[dep] = { bytesInOutput: bytes };
+        totalBytes += bytes;
+      }
+      outputs[outputKey] = {
+        imports: [],
+        exports: [],
+        entryPoint,
+        inputs: inputBytes,
+        bytes: totalBytes,
+        signature
+      };
+    }
+    if (Object.keys(inputs).length === 0) {
+      try {
+        const files3 = fs3.readdirSync(process.cwd());
+        const goFiles = files3.filter((file) => file.endsWith(".go"));
+        if (goFiles.length > 0) {
+          const firstGoFile = path4.join(process.cwd(), goFiles[0]);
+          const bytes = fs3.statSync(firstGoFile).size;
+          const imports = parseGoImports(firstGoFile);
+          inputs[firstGoFile] = {
+            bytes,
+            imports,
+            format: "esm"
+          };
+          outputs[`golang/core/${goFiles[0]}`] = {
+            imports: [],
+            exports: [],
+            entryPoint: firstGoFile,
+            inputs: {
+              [firstGoFile]: {
+                bytesInOutput: bytes
+              }
+            },
+            bytes,
+            signature
+          };
+        } else {
+          const goModPath = path4.join(process.cwd(), "go.mod");
+          if (fs3.existsSync(goModPath)) {
+            console.warn("Found go.mod but no Go files could be processed");
+            inputs["placeholder.go"] = {
+              bytes: 0,
+              imports: [],
+              format: "esm"
+            };
+            outputs["testeranto/bundles/golang/core/placeholder.go"] = {
+              imports: [],
+              exports: [],
+              entryPoint: "placeholder.go",
+              inputs: {
+                "placeholder.go": {
+                  bytesInOutput: 0
+                }
+              },
+              bytes: 0,
+              signature
+            };
+          } else {
+            console.warn("No Go files found and not in a Go project");
+          }
+        }
+      } catch (error) {
+        console.warn("Error finding Go files:", error);
+        const goModPath = path4.join(process.cwd(), "go.mod");
+        if (fs3.existsSync(goModPath)) {
+          inputs["placeholder.go"] = {
+            bytes: 0,
+            imports: [],
+            format: "esm"
+          };
+          outputs["golang/core/placeholder.go"] = {
+            imports: [],
+            exports: [],
+            entryPoint: "placeholder.go",
+            inputs: {
+              "placeholder.go": {
+                bytesInOutput: 0
+              }
+            },
+            bytes: 0,
+            signature
+          };
+        }
+      }
+    }
+    const result = {
+      errors: [],
+      warnings: [],
+      metafile: {
+        inputs,
+        outputs
+      }
+    };
+    generationQueue = null;
+    return result;
+  })();
+  return generationQueue;
+}
+function writeGolingvuMetafile(testName2, metafile) {
+  writeGolingvuMetafileCallCount++;
+  console.log(`writeGolingvuMetafile called ${writeGolingvuMetafileCallCount} times`);
+  console.log("process.cwd()", process.cwd());
+  console.log("testName:", testName2);
+  const projectRoot = findProjectRoot();
+  const metafilePath = path4.join(
+    projectRoot,
+    "testeranto",
+    "metafiles",
+    "golang",
+    "core.json"
+  );
+  const metafileDir = path4.dirname(metafilePath);
+  if (!fs3.existsSync(metafileDir)) {
+    fs3.mkdirSync(metafileDir, { recursive: true });
+  }
+  fs3.writeFileSync(metafilePath, JSON.stringify(metafile, null, 2));
+  console.log(`Golang metafile written to: ${metafilePath}`);
+  const outputDir = path4.join(
+    projectRoot,
+    "testeranto",
+    "bundles",
+    "golang",
+    "core"
+  );
+  console.log("Output directory:", outputDir);
+  if (!fs3.existsSync(outputDir)) {
+    fs3.mkdirSync(outputDir, { recursive: true });
+  }
+  for (const [outputPath, outputInfo] of Object.entries(
+    metafile.metafile.outputs
+  )) {
+    const fileName = path4.basename(outputPath);
+    const fullOutputPath = path4.join(outputDir, fileName);
+    const outputDirPath = path4.dirname(fullOutputPath);
+    if (!fs3.existsSync(outputDirPath)) {
+      fs3.mkdirSync(outputDirPath, { recursive: true });
+    }
+    const entryPoint = outputInfo.entryPoint;
+    const signature = outputInfo.signature;
+    const entryDir = path4.dirname(entryPoint);
+    const entryDirName = path4.basename(entryDir);
+    let importPath;
+    if (entryDirName === "example") {
+      importPath = "../example";
+    } else {
+      const relativePathToEntry = path4.relative(outputDir, entryDir);
+      importPath = relativePathToEntry ? `./${relativePathToEntry}` : ".";
+    }
+    const entryPointBaseName = path4.basename(entryPoint, ".go");
+    const content = `//go:build testeranto
+// +build testeranto
+
+// This file is auto-generated by testeranto
+// Signature: ${signature}
+// It imports and tests: ${entryPoint}
+
+package testeranto_test
+
+import (
+	"fmt"
+	"os"
+	"testing"
+	
+	// Import the original implementation
+	"${importPath}"
+)
+
+func TestCalculatorOperations(t *testing.T) {
+	// Create an instance of the Calculator
+	calc := &${entryPointBaseName}.Calculator{}
+	
+	// Test basic operations
+	// This is where testeranto would run its test scenarios
+	
+	// Example test: test that a new calculator has empty display
+	if calc.GetDisplay() != "" {
+		t.Errorf("Expected empty display, got: %s", calc.GetDisplay())
+	}
+	
+	// Example test: test pressing buttons
+	calc.Press("2")
+	if calc.GetDisplay() != "2" {
+		t.Errorf("Expected '2', got: %s", calc.GetDisplay())
+	}
+	
+	// Add more test scenarios based on the testeranto specification
+	fmt.Println("Testeranto tests completed")
+}
+
+func main() {
+	// This allows the file to be run as a standalone program
+	// while keeping it in the testeranto_test package
+	testing.Main(func(pat, str string) (bool, error) { return true, nil },
+		[]testing.InternalTest{
+			{
+				Name: "TestCalculatorOperations",
+				F:    TestCalculatorOperations,
+			},
+		},
+		[]testing.InternalBenchmark{},
+		[]testing.InternalExample{})
+}
+`;
+    fs3.writeFileSync(fullOutputPath, content);
+    console.log(`Generated Golingvu wrapper: ${fullOutputPath}`);
+  }
+}
+var generationQueue, writeGolingvuMetafileCallCount;
+var init_golingvuMetafile = __esm({
+  "src/utils/golingvuMetafile.ts"() {
+    "use strict";
+    generationQueue = null;
+    writeGolingvuMetafileCallCount = 0;
+  }
+});
+
+// src/utils/golingvuWatcher.ts
+import chokidar2 from "chokidar";
+import path5 from "path";
+import fs4 from "fs";
+var GolingvuWatcher;
+var init_golingvuWatcher = __esm({
+  "src/utils/golingvuWatcher.ts"() {
+    "use strict";
+    init_golingvuMetafile();
+    GolingvuWatcher = class {
+      constructor(testName2, entryPoints) {
+        this.watcher = null;
+        this.onChangeCallback = null;
+        this.debounceTimer = null;
+        this.testName = testName2;
+        this.entryPoints = entryPoints;
+      }
+      async start() {
+        const goFilesPattern = "**/*.go";
+        this.watcher = chokidar2.watch(goFilesPattern, {
+          persistent: true,
+          ignoreInitial: true,
+          cwd: process.cwd(),
+          ignored: [
+            "**/node_modules/**",
+            "**/.git/**",
+            "**/testeranto/bundles/**",
+            "**/testeranto/reports/**"
+          ],
+          usePolling: true,
+          interval: 1e3,
+          binaryInterval: 1e3,
+          depth: 99,
+          followSymlinks: false,
+          atomic: false
+        });
+        this.watcher.on("add", (filePath) => {
+          console.log(`File added: ${filePath}`);
+          this.handleFileChange("add", filePath);
+        }).on("change", (filePath) => {
+          console.log(`File changed: ${filePath}`);
+          this.handleFileChange("change", filePath);
+        }).on("unlink", (filePath) => {
+          console.log(`File removed: ${filePath}`);
+          this.handleFileChange("unlink", filePath);
+        }).on("addDir", (dirPath) => {
+          console.log(`Directory added: ${dirPath}`);
+        }).on("unlinkDir", (dirPath) => {
+          console.log(`Directory removed: ${dirPath}`);
+        }).on("error", (error) => {
+          console.error(`Source watcher error: ${error}`);
+        }).on("ready", () => {
+          console.log(
+            "Initial golang source file scan complete. Ready for changes."
+          );
+          const watched = this.watcher?.getWatched();
+          console.log(
+            "Number of watched directories:",
+            Object.keys(watched || {}).length
+          );
+          if (Object.keys(watched || {}).length === 0) {
+            console.error("WARNING: No directories are being watched!");
+            console.error("Trying to manually find and watch .go files...");
+            const findAllGoFiles = (dir) => {
+              let results = [];
+              const list = fs4.readdirSync(dir);
+              list.forEach((file) => {
+                const filePath = path5.join(dir, file);
+                const stat = fs4.statSync(filePath);
+                if (stat.isDirectory()) {
+                  if (file === "node_modules" || file === ".git" || file === "testeranto") {
+                    return;
+                  }
+                  results = results.concat(findAllGoFiles(filePath));
+                } else if (file.endsWith(".go")) {
+                  results.push(filePath);
+                }
+              });
+              return results;
+            };
+            try {
+              const allGoFiles = findAllGoFiles(process.cwd());
+              console.log(`Found ${allGoFiles.length} Go files manually:`);
+              allGoFiles.forEach((file) => console.log(`  ${file}`));
+              allGoFiles.forEach((file) => {
+                this.watcher?.add(file);
+              });
+            } catch (error) {
+              console.error("Error manually finding Go files:", error);
+            }
+          } else {
+            for (const [dir, files3] of Object.entries(watched || {})) {
+              console.log(`Directory: ${dir}`);
+              console.log(`Files: ${files3.join(", ")}`);
+            }
+          }
+        }).on("raw", (event, path14, details) => {
+          console.log(`Raw event: ${event} on path: ${path14}`);
+        });
+        const outputDir = path5.join(
+          process.cwd(),
+          "testeranto",
+          "bundles",
+          "golang",
+          "core"
+        );
+        if (!fs4.existsSync(outputDir)) {
+          fs4.mkdirSync(outputDir, { recursive: true });
+        }
+        console.log(`Watching bundle directory: ${outputDir}`);
+        const lastSignatures = /* @__PURE__ */ new Map();
+        const bundleWatcher = chokidar2.watch(
+          [path5.join(outputDir, "*.go"), path5.join(outputDir, "*.golingvu.go")],
+          {
+            persistent: true,
+            ignoreInitial: false,
+            // We want to capture initial files to establish baseline
+            awaitWriteFinish: {
+              stabilityThreshold: 100,
+              pollInterval: 50
+            }
+          }
+        );
+        bundleWatcher.on("add", (filePath) => {
+          this.readAndCheckSignature(filePath, lastSignatures);
+        }).on("change", (filePath) => {
+          this.readAndCheckSignature(filePath, lastSignatures);
+        }).on("error", (error) => console.error(`Bundle watcher error: ${error}`));
+        await this.regenerateMetafile();
+      }
+      async handleFileChange(event, filePath) {
+        if (this.debounceTimer) {
+          clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(async () => {
+          const fullPath = path5.join(process.cwd(), filePath);
+          await new Promise((resolve) => setTimeout(resolve, 100));
+          if (fs4.existsSync(fullPath)) {
+            try {
+              const stats = fs4.statSync(fullPath);
+              console.log(`File ${filePath} changed (${stats.size} bytes)`);
+            } catch (error) {
+              console.error(`Error reading file: ${error}`);
+            }
+          }
+          console.log("Regenerating metafile due to file change...");
+          await this.regenerateMetafile();
+          if (this.onChangeCallback) {
+            this.onChangeCallback();
+          }
+        }, 300);
+      }
+      readAndCheckSignature(filePath, lastSignatures) {
+        try {
+          const content = fs4.readFileSync(filePath, "utf-8");
+          const signatureMatch = content.match(/\/\/ Signature: (\w+)/);
+          if (signatureMatch && signatureMatch[1]) {
+            const currentSignature = signatureMatch[1];
+            const lastSignature = lastSignatures.get(filePath);
+            if (lastSignature === void 0) {
+              lastSignatures.set(filePath, currentSignature);
+            } else if (lastSignature !== currentSignature) {
+              lastSignatures.set(filePath, currentSignature);
+              const fileName = path5.basename(filePath);
+              const originalFileName = fileName.replace(".golingvu.go", ".go");
+              const originalEntryPoint = this.entryPoints.find(
+                (ep) => path5.basename(ep) === originalFileName
+              );
+              if (originalEntryPoint) {
+                if (this.onChangeCallback) {
+                  this.onChangeCallback();
+                }
+              }
+            }
+          }
+        } catch (error) {
+          console.error(`Error reading bundle file ${filePath}:`, error);
+        }
+      }
+      async regenerateMetafile() {
+        console.log("regenerateMetafile!");
+        try {
+          const metafile = await generateGolingvuMetafile(
+            this.testName,
+            this.entryPoints
+          );
+          writeGolingvuMetafile(this.testName, metafile);
+        } catch (error) {
+          console.error("Error regenerating golingvu metafile:", error);
+        }
+      }
+      onMetafileChange(callback) {
+        this.onChangeCallback = callback;
+      }
+      stop() {
+        if (this.debounceTimer) {
+          clearTimeout(this.debounceTimer);
+          this.debounceTimer = null;
+        }
+        if (this.watcher) {
+          this.watcher.close();
+          this.watcher = null;
+        }
+      }
+    };
+  }
+});
+
+// src/PM/golingvuBuild.ts
+var golingvuBuild_exports = {};
+__export(golingvuBuild_exports, {
+  GolingvuBuild: () => GolingvuBuild
+});
+var GolingvuBuild;
+var init_golingvuBuild = __esm({
+  "src/PM/golingvuBuild.ts"() {
+    "use strict";
+    init_golingvuMetafile();
+    init_golingvuWatcher();
+    GolingvuBuild = class {
+      constructor(config, testName2) {
+        this.watcher = null;
+        this.config = config;
+        this.testName = testName2;
+      }
+      async build() {
+        const golangTests = this.config.tests.filter((test) => test[1] === "golang");
+        const hasGolangTests = golangTests.length > 0;
+        if (hasGolangTests) {
+          const golangEntryPoints = golangTests.map((test) => test[0]);
+          const metafile = await generateGolingvuMetafile(this.testName, golangEntryPoints);
+          writeGolingvuMetafile(this.testName, metafile);
+          this.watcher = new GolingvuWatcher(this.testName, golangEntryPoints);
+          await this.watcher.start();
+          return golangEntryPoints;
+        }
+        return [];
+      }
+      async rebuild() {
+        if (this.watcher) {
+          await this.watcher.regenerateMetafile();
+        }
+      }
+      stop() {
+        if (this.watcher) {
+          this.watcher.stop();
+          this.watcher = null;
+        }
+      }
+      onBundleChange(callback) {
+        if (this.watcher) {
+          this.watcher.onMetafileChange(callback);
+        }
+      }
+    };
+  }
+});
+
 // src/utils/queue.ts
 var Queue;
 var init_queue = __esm({
@@ -167,38 +1033,44 @@ var init_queue = __esm({
 
 // src/PM/utils.ts
 import ansiC from "ansi-colors";
-import path3 from "path";
-import fs from "fs";
+import path6 from "path";
+import fs5 from "fs";
 import crypto from "node:crypto";
 function runtimeLogs(runtime, reportDest) {
   const safeDest = reportDest || `testeranto/reports/default_${Date.now()}`;
   try {
-    if (!fs.existsSync(safeDest)) {
-      fs.mkdirSync(safeDest, { recursive: true });
+    if (!fs5.existsSync(safeDest)) {
+      fs5.mkdirSync(safeDest, { recursive: true });
     }
     if (runtime === "node") {
       return {
-        stdout: fs.createWriteStream(`${safeDest}/stdout.log`),
-        stderr: fs.createWriteStream(`${safeDest}/stderr.log`),
-        exit: fs.createWriteStream(`${safeDest}/exit.log`)
+        stdout: fs5.createWriteStream(`${safeDest}/stdout.log`),
+        stderr: fs5.createWriteStream(`${safeDest}/stderr.log`),
+        exit: fs5.createWriteStream(`${safeDest}/exit.log`)
       };
     } else if (runtime === "web") {
       return {
-        info: fs.createWriteStream(`${safeDest}/info.log`),
-        warn: fs.createWriteStream(`${safeDest}/warn.log`),
-        error: fs.createWriteStream(`${safeDest}/error.log`),
-        debug: fs.createWriteStream(`${safeDest}/debug.log`),
-        exit: fs.createWriteStream(`${safeDest}/exit.log`)
+        info: fs5.createWriteStream(`${safeDest}/info.log`),
+        warn: fs5.createWriteStream(`${safeDest}/warn.log`),
+        error: fs5.createWriteStream(`${safeDest}/error.log`),
+        debug: fs5.createWriteStream(`${safeDest}/debug.log`),
+        exit: fs5.createWriteStream(`${safeDest}/exit.log`)
       };
     } else if (runtime === "pure") {
       return {
-        exit: fs.createWriteStream(`${safeDest}/exit.log`)
+        exit: fs5.createWriteStream(`${safeDest}/exit.log`)
       };
-    } else if (runtime === "pitono") {
+    } else if (runtime === "python") {
       return {
-        stdout: fs.createWriteStream(`${safeDest}/stdout.log`),
-        stderr: fs.createWriteStream(`${safeDest}/stderr.log`),
-        exit: fs.createWriteStream(`${safeDest}/exit.log`)
+        stdout: fs5.createWriteStream(`${safeDest}/stdout.log`),
+        stderr: fs5.createWriteStream(`${safeDest}/stderr.log`),
+        exit: fs5.createWriteStream(`${safeDest}/exit.log`)
+      };
+    } else if (runtime === "golang") {
+      return {
+        stdout: fs5.createWriteStream(`${safeDest}/stdout.log`),
+        stderr: fs5.createWriteStream(`${safeDest}/stderr.log`),
+        exit: fs5.createWriteStream(`${safeDest}/exit.log`)
       };
     } else {
       throw `unknown runtime: ${runtime}`;
@@ -209,13 +1081,13 @@ function runtimeLogs(runtime, reportDest) {
   }
 }
 function createLogStreams(reportDest, runtime) {
-  if (!fs.existsSync(reportDest)) {
-    fs.mkdirSync(reportDest, { recursive: true });
+  if (!fs5.existsSync(reportDest)) {
+    fs5.mkdirSync(reportDest, { recursive: true });
   }
   const safeDest = reportDest || `testeranto/reports/default_${Date.now()}`;
   try {
-    if (!fs.existsSync(safeDest)) {
-      fs.mkdirSync(safeDest, { recursive: true });
+    if (!fs5.existsSync(safeDest)) {
+      fs5.mkdirSync(safeDest, { recursive: true });
     }
     const streams = runtimeLogs(runtime, safeDest);
     return {
@@ -248,13 +1120,13 @@ ${error.stack}
 async function fileHash(filePath, algorithm = "md5") {
   return new Promise((resolve, reject) => {
     const hash = crypto.createHash(algorithm);
-    const fileStream = fs.createReadStream(filePath);
+    const fileStream = fs5.createReadStream(filePath);
     fileStream.on("data", (data) => {
       hash.update(data);
     });
     fileStream.on("end", () => {
-      const fileHash2 = hash.digest("hex");
-      resolve(fileHash2);
+      const fileHash3 = hash.digest("hex");
+      resolve(fileHash3);
     });
     fileStream.on("error", (error) => {
       reject(`Error reading file: ${error.message}`);
@@ -262,10 +1134,10 @@ async function fileHash(filePath, algorithm = "md5") {
   });
 }
 async function writeFileAndCreateDir(filePath, data) {
-  const dirPath = path3.dirname(filePath);
+  const dirPath = path6.dirname(filePath);
   try {
-    await fs.promises.mkdir(dirPath, { recursive: true });
-    await fs.writeFileSync(filePath, data);
+    await fs5.promises.mkdir(dirPath, { recursive: true });
+    await fs5.writeFileSync(filePath, data);
   } catch (error) {
     console.error(`Error writing file: ${error}`);
   }
@@ -278,10 +1150,10 @@ function isValidUrl(string) {
     return false;
   }
 }
-async function pollForFile(path12, timeout = 2e3) {
+async function pollForFile(path14, timeout = 2e3) {
   const intervalObj = setInterval(function() {
-    const file = path12;
-    const fileExists = fs.existsSync(file);
+    const file = path14;
+    const fileExists = fs5.existsSync(file);
     if (fileExists) {
       clearInterval(intervalObj);
     }
@@ -311,8 +1183,8 @@ var init_utils2 = __esm({
     filesHash = async (files3, algorithm = "md5") => {
       return new Promise((resolve, reject) => {
         resolve(
-          files3.reduce(async (mm, f2) => {
-            return await mm + await fileHash(f2);
+          files3.reduce(async (mm, f) => {
+            return await mm + await fileHash(f);
           }, Promise.resolve(""))
         );
       });
@@ -390,7 +1262,7 @@ var init_esbuildConfigs = __esm({
 });
 
 // src/esbuildConfigs/inputFilesPlugin.ts
-import fs2 from "fs";
+import fs6 from "fs";
 var otherInputs, register, inputFilesPlugin_default;
 var init_inputFilesPlugin = __esm({
   "src/esbuildConfigs/inputFilesPlugin.ts"() {
@@ -403,9 +1275,9 @@ var init_inputFilesPlugin = __esm({
       sources.forEach((s) => otherInputs[entrypoint].add(s));
     };
     inputFilesPlugin_default = (platform, testName2) => {
-      const f2 = `testeranto/metafiles/${platform}/${testName2}.json`;
-      if (!fs2.existsSync(`testeranto/metafiles/${platform}`)) {
-        fs2.mkdirSync(`testeranto/metafiles/${platform}`, { recursive: true });
+      const f = `testeranto/metafiles/${platform}/${testName2}.json`;
+      if (!fs6.existsSync(`testeranto/metafiles/${platform}`)) {
+        fs6.mkdirSync(`testeranto/metafiles/${platform}`, { recursive: true });
       }
       return {
         register,
@@ -413,7 +1285,7 @@ var init_inputFilesPlugin = __esm({
           name: "metafileWriter",
           setup(build) {
             build.onEnd((result) => {
-              fs2.writeFileSync(f2, JSON.stringify(result, null, 2));
+              fs6.writeFileSync(f, JSON.stringify(result, null, 2));
             });
           }
         }
@@ -423,7 +1295,7 @@ var init_inputFilesPlugin = __esm({
 });
 
 // src/esbuildConfigs/featuresPlugin.ts
-import path4 from "path";
+import path7 from "path";
 var featuresPlugin_default;
 var init_featuresPlugin = __esm({
   "src/esbuildConfigs/featuresPlugin.ts"() {
@@ -435,7 +1307,7 @@ var init_featuresPlugin = __esm({
           if (args.resolveDir === "")
             return;
           return {
-            path: path4.isAbsolute(args.path) ? args.path : path4.join(args.resolveDir, args.path),
+            path: path7.isAbsolute(args.path) ? args.path : path7.join(args.resolveDir, args.path),
             namespace: "feature-markdown"
           };
         });
@@ -462,7 +1334,7 @@ var init_featuresPlugin = __esm({
 });
 
 // src/esbuildConfigs/rebuildPlugin.ts
-import fs3 from "fs";
+import fs7 from "fs";
 var rebuildPlugin_default;
 var init_rebuildPlugin = __esm({
   "src/esbuildConfigs/rebuildPlugin.ts"() {
@@ -474,7 +1346,7 @@ var init_rebuildPlugin = __esm({
           build.onEnd((result) => {
             console.log(`${r} > build ended with ${result.errors.length} errors`);
             if (result.errors.length > 0) {
-              fs3.writeFileSync(
+              fs7.writeFileSync(
                 `./testeranto/reports${r}_build_errors`,
                 JSON.stringify(result, null, 2)
               );
@@ -504,7 +1376,7 @@ var init_node = __esm({
         ...esbuildConfigs_default(config),
         splitting: true,
         outdir: `testeranto/bundles/node/${testName2}/`,
-        inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
+        // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
         metafile: true,
         supported: {
           "dynamic-import": true
@@ -532,7 +1404,7 @@ var init_node = __esm({
 
 // src/esbuildConfigs/web.ts
 import { polyfillNode } from "esbuild-plugin-polyfill-node";
-import path5 from "path";
+import path8 from "path";
 var web_default;
 var init_web = __esm({
   "src/esbuildConfigs/web.ts"() {
@@ -551,7 +1423,7 @@ var init_web = __esm({
         treeShaking: true,
         outdir: `testeranto/bundles/web/${testName2}`,
         alias: {
-          react: path5.resolve("./node_modules/react")
+          react: path8.resolve("./node_modules/react")
         },
         metafile: true,
         external: [
@@ -596,7 +1468,7 @@ var init_web = __esm({
 });
 
 // src/esbuildConfigs/consoleDetectorPlugin.ts
-import fs4 from "fs";
+import fs8 from "fs";
 var consoleDetectorPlugin;
 var init_consoleDetectorPlugin = __esm({
   "src/esbuildConfigs/consoleDetectorPlugin.ts"() {
@@ -605,7 +1477,7 @@ var init_consoleDetectorPlugin = __esm({
       name: "console-detector",
       setup(build) {
         build.onLoad({ filter: /\.(js|ts)$/ }, async (args) => {
-          const contents = await fs4.promises.readFile(args.path, "utf8");
+          const contents = await fs8.promises.readFile(args.path, "utf8");
           const consolePattern = /console\.(log|error|warn|info|debug|trace|dir|dirxml|table|group|groupEnd|clear|count|countReset|assert|profile|profileEnd|time|timeLog|timeEnd|timeStamp|context|memory)/g;
           const matches = contents.match(consolePattern);
           if (matches) {
@@ -700,8 +1572,8 @@ var init_pure = __esm({
 });
 
 // src/PM/base.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs9 from "fs";
+import path9 from "path";
 var fileStreams3, fPaths, files, recorders, screenshots, PM_Base;
 var init_base = __esm({
   "src/PM/base.ts"() {
@@ -824,8 +1696,8 @@ var init_base = __esm({
       }
       async screencast(ssOpts, testName2, page) {
         const p = ssOpts.path;
-        const dir = path6.dirname(p);
-        fs5.mkdirSync(dir, {
+        const dir = path9.dirname(p);
+        fs9.mkdirSync(dir, {
           recursive: true
         });
         if (!files[testName2]) {
@@ -845,8 +1717,8 @@ var init_base = __esm({
       }
       async customScreenShot(ssOpts, testName2, pageUid) {
         const p = ssOpts.path;
-        const dir = path6.dirname(p);
-        fs5.mkdirSync(dir, {
+        const dir = path9.dirname(p);
+        fs9.mkdirSync(dir, {
           recursive: true
         });
         if (!files[testName2]) {
@@ -872,11 +1744,11 @@ var init_base = __esm({
         return true;
       }
       existsSync(destFolder) {
-        return fs5.existsSync(destFolder);
+        return fs9.existsSync(destFolder);
       }
       async mkdirSync(fp) {
-        if (!fs5.existsSync(fp)) {
-          return fs5.mkdirSync(fp, {
+        if (!fs9.existsSync(fp)) {
+          return fs9.mkdirSync(fp, {
             recursive: true
           });
         }
@@ -887,27 +1759,27 @@ var init_base = __esm({
         const contents = x[1];
         const testName2 = x[2];
         return new Promise(async (res) => {
-          fs5.mkdirSync(path6.dirname(filepath), {
+          fs9.mkdirSync(path9.dirname(filepath), {
             recursive: true
           });
           if (!files[testName2]) {
             files[testName2] = /* @__PURE__ */ new Set();
           }
           files[testName2].add(filepath);
-          await fs5.writeFileSync(filepath, contents);
+          await fs9.writeFileSync(filepath, contents);
           res(true);
         });
       }
       async createWriteStream(filepath, testName2) {
         const folder = filepath.split("/").slice(0, -1).join("/");
         return new Promise((res) => {
-          if (!fs5.existsSync(folder)) {
-            return fs5.mkdirSync(folder, {
+          if (!fs9.existsSync(folder)) {
+            return fs9.mkdirSync(folder, {
               recursive: true
             });
           }
-          const f2 = fs5.createWriteStream(filepath);
-          fileStreams3.push(f2);
+          const f = fs9.createWriteStream(filepath);
+          fileStreams3.push(f);
           if (!files[testName2]) {
             files[testName2] = /* @__PURE__ */ new Set();
           }
@@ -920,15 +1792,15 @@ var init_base = __esm({
           callback(
             new Promise((res, rej) => {
               tLog("testArtiFactory =>", fPath);
-              const cleanPath = path6.resolve(fPath);
+              const cleanPath = path9.resolve(fPath);
               fPaths.push(cleanPath.replace(process.cwd(), ``));
               const targetDir = cleanPath.split("/").slice(0, -1).join("/");
-              fs5.mkdir(targetDir, { recursive: true }, async (error) => {
+              fs9.mkdir(targetDir, { recursive: true }, async (error) => {
                 if (error) {
                   console.error(`\u2757\uFE0FtestArtiFactory failed`, targetDir, error);
                 }
-                fs5.writeFileSync(
-                  path6.resolve(
+                fs9.writeFileSync(
+                  path9.resolve(
                     targetDir.split("/").slice(0, -1).join("/"),
                     "manifest"
                   ),
@@ -939,16 +1811,16 @@ var init_base = __esm({
                   }
                 );
                 if (Buffer.isBuffer(value)) {
-                  fs5.writeFileSync(fPath, value, "binary");
+                  fs9.writeFileSync(fPath, value, "binary");
                   res();
                 } else if (`string` === typeof value) {
-                  fs5.writeFileSync(fPath, value.toString(), {
+                  fs9.writeFileSync(fPath, value.toString(), {
                     encoding: "utf-8"
                   });
                   res();
                 } else {
                   const pipeStream = value;
-                  const myFile = fs5.createWriteStream(fPath);
+                  const myFile = fs9.createWriteStream(fPath);
                   pipeStream.pipe(myFile);
                   pipeStream.on("close", () => {
                     myFile.close();
@@ -1029,7 +1901,7 @@ var init_base = __esm({
 
 // src/PM/PM_WithWebSocket.ts
 import { spawn } from "node:child_process";
-import fs6 from "fs";
+import fs10 from "fs";
 import http from "http";
 import url from "url";
 import mime from "mime-types";
@@ -1054,7 +1926,18 @@ var init_PM_WithWebSocket = __esm({
           ws.on("message", (data) => {
             try {
               const message = JSON.parse(data.toString());
-              if (message.type === "executeCommand") {
+              if (message.type === "chatMessage") {
+                console.log(`Received chat message: ${message.content}`);
+                if (this.handleChatMessage) {
+                  this.handleChatMessage(message.content);
+                } else {
+                  console.log("PM_WithHelpo not available - message not processed");
+                }
+                return;
+              }
+              if (message.type === "listDirectory") {
+                this.handleWebSocketListDirectory(ws, message);
+              } else if (message.type === "executeCommand") {
                 const executeMessage = message;
                 if (message.command && message.command.trim().startsWith("aider")) {
                   console.log(`Executing command: ${message.command}`);
@@ -1220,6 +2103,21 @@ var init_PM_WithWebSocket = __esm({
                     processExists: !!childProcess
                   });
                 }
+              } else if (message.type === "getChatHistory") {
+                if (this.getChatHistory) {
+                  this.getChatHistory().then((history) => {
+                    ws.send(JSON.stringify({
+                      type: "chatHistory",
+                      messages: history
+                    }));
+                  }).catch((error) => {
+                    console.error("Error getting chat history:", error);
+                    ws.send(JSON.stringify({
+                      type: "error",
+                      message: "Failed to get chat history"
+                    }));
+                  });
+                }
               }
             } catch (error) {
               console.error("Error handling WebSocket message:", error);
@@ -1240,8 +2138,12 @@ var init_PM_WithWebSocket = __esm({
         });
       }
       requestHandler(req, res) {
-        const parsedUrl = url.parse(req.url || "/");
+        const parsedUrl = url.parse(req.url || "/", true);
         const pathname = parsedUrl.pathname || "/";
+        if (pathname?.startsWith("/api/files/")) {
+          this.handleFilesApi(req, res);
+          return;
+        }
         if (pathname === "/health") {
           res.writeHead(200, { "Content-Type": "application/json" });
           res.end(
@@ -1269,7 +2171,7 @@ var init_PM_WithWebSocket = __esm({
           ];
           let foundPath = null;
           for (const possiblePath of possiblePaths) {
-            if (fs6.existsSync(possiblePath)) {
+            if (fs10.existsSync(possiblePath)) {
               foundPath = possiblePath;
               break;
             }
@@ -1279,7 +2181,7 @@ var init_PM_WithWebSocket = __esm({
           } else {
             const indexPath = this.findIndexHtml();
             if (indexPath) {
-              fs6.readFile(indexPath, (err, data) => {
+              fs10.readFile(indexPath, (err, data) => {
                 if (err) {
                   res.writeHead(404, { "Content-Type": "text/plain" });
                   res.end("404 Not Found");
@@ -1296,12 +2198,12 @@ var init_PM_WithWebSocket = __esm({
             }
           }
         }
-        fs6.exists(filePath, (exists) => {
+        fs10.exists(filePath, (exists) => {
           if (!exists) {
             if (!processedPathname.includes(".") && processedPathname !== "/") {
               const indexPath = this.findIndexHtml();
               if (indexPath) {
-                fs6.readFile(indexPath, (err, data) => {
+                fs10.readFile(indexPath, (err, data) => {
                   if (err) {
                     res.writeHead(404, { "Content-Type": "text/plain" });
                     res.end("404 Not Found");
@@ -1328,7 +2230,7 @@ var init_PM_WithWebSocket = __esm({
             res.end("404 Not Found");
             return;
           }
-          fs6.readFile(filePath, (err, data) => {
+          fs10.readFile(filePath, (err, data) => {
             if (err) {
               res.writeHead(500, { "Content-Type": "text/plain" });
               res.end("500 Internal Server Error");
@@ -1359,6 +2261,121 @@ var init_PM_WithWebSocket = __esm({
           });
         });
       }
+      handleFilesApi(req, res) {
+        const parsedUrl = url.parse(req.url || "/", true);
+        const pathname = parsedUrl.pathname || "/";
+        const query = parsedUrl.query || {};
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        if (req.method === "OPTIONS") {
+          res.writeHead(200);
+          res.end();
+          return;
+        }
+        try {
+          if (pathname === "/api/files/list" && req.method === "GET") {
+            this.handleListDirectory(req, res, query);
+          } else if (pathname === "/api/files/read" && req.method === "GET") {
+            this.handleReadFile(req, res, query);
+          } else if (pathname === "/api/files/exists" && req.method === "GET") {
+            this.handleFileExists(req, res, query);
+          } else {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Not found" }));
+          }
+        } catch (error) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Internal server error" }));
+        }
+      }
+      async handleListDirectory(req, res, query) {
+        const path14 = query.path;
+        if (!path14) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Path parameter required" }));
+          return;
+        }
+        try {
+          const fullPath = this.resolvePath(path14);
+          const items = await this.listDirectory(fullPath);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(items));
+        } catch (error) {
+          console.error("Error listing directory:", error);
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Failed to list directory" }));
+        }
+      }
+      async handleReadFile(req, res, query) {
+        const path14 = query.path;
+        if (!path14) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Path parameter required" }));
+          return;
+        }
+        try {
+          const fullPath = this.resolvePath(path14);
+          const content = await fs10.promises.readFile(fullPath, "utf-8");
+          res.writeHead(200, { "Content-Type": "text/plain" });
+          res.end(content);
+        } catch (error) {
+          console.error("Error reading file:", error);
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Failed to read file" }));
+        }
+      }
+      async handleFileExists(req, res, query) {
+        const path14 = query.path;
+        if (!path14) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Path parameter required" }));
+          return;
+        }
+        try {
+          const fullPath = this.resolvePath(path14);
+          const exists = fs10.existsSync(fullPath);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ exists }));
+        } catch (error) {
+          console.error("Error checking file existence:", error);
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Failed to check file existence" }));
+        }
+      }
+      resolvePath(requestedPath) {
+        const normalizedPath = requestedPath.replace(/\.\./g, "").replace(/^\//, "").replace(/\/+/g, "/");
+        return `${process.cwd()}/${normalizedPath}`;
+      }
+      async listDirectory(dirPath) {
+        try {
+          const items = await fs10.promises.readdir(dirPath, { withFileTypes: true });
+          const result = [];
+          for (const item of items) {
+            if (item.name.startsWith("."))
+              continue;
+            const fullPath = `${dirPath}/${item.name}`;
+            const relativePath = fullPath.replace(process.cwd(), "").replace(/^\//, "");
+            if (item.isDirectory()) {
+              result.push({
+                name: item.name,
+                type: "folder",
+                path: "/" + relativePath
+              });
+            } else if (item.isFile()) {
+              result.push({
+                name: item.name,
+                type: "file",
+                path: "/" + relativePath
+              });
+            }
+          }
+          return result;
+        } catch (error) {
+          console.error("Error listing directory:", error);
+          throw error;
+        }
+      }
       findIndexHtml() {
         const possiblePaths = [
           "dist/index.html",
@@ -1366,9 +2383,9 @@ var init_PM_WithWebSocket = __esm({
           "../dist/index.html",
           "./index.html"
         ];
-        for (const path12 of possiblePaths) {
-          if (fs6.existsSync(path12)) {
-            return path12;
+        for (const path14 of possiblePaths) {
+          if (fs10.existsSync(path14)) {
+            return path14;
           }
         }
         return null;
@@ -1449,6 +2466,31 @@ var init_PM_WithWebSocket = __esm({
         });
         return processId;
       }
+      async handleWebSocketListDirectory(ws, message) {
+        try {
+          const path14 = message.path;
+          if (!path14) {
+            ws.send(JSON.stringify({
+              type: "error",
+              message: "Path parameter required"
+            }));
+            return;
+          }
+          const fullPath = this.resolvePath(path14);
+          const items = await this.listDirectory(fullPath);
+          ws.send(JSON.stringify({
+            type: "directoryListing",
+            path: path14,
+            items
+          }));
+        } catch (error) {
+          console.error("Error handling WebSocket directory listing:", error);
+          ws.send(JSON.stringify({
+            type: "error",
+            message: "Failed to list directory"
+          }));
+        }
+      }
       broadcast(message) {
         const data = typeof message === "string" ? message : JSON.stringify(message);
         this.clients.forEach((client) => {
@@ -1576,7 +2618,9 @@ var init_PM_WithBuild = __esm({
                   runtime
                 );
               }
-              console.log(`Starting ${runtime} build for ${entryPointKeys.length} entry points`);
+              console.log(
+                `Starting ${runtime} build for ${entryPointKeys.length} entry points`
+              );
               if (self.broadcast) {
                 self.broadcast({
                   type: "buildEvent",
@@ -1598,9 +2642,13 @@ var init_PM_WithBuild = __esm({
                 warnings: result.warnings.length
               };
               if (result.errors.length > 0) {
-                console.error(`Build ${runtime} failed with ${result.errors.length} errors`);
+                console.error(
+                  `Build ${runtime} failed with ${result.errors.length} errors`
+                );
                 if (self.currentBuildReject) {
-                  self.currentBuildReject(new Error(`Build failed with ${result.errors.length} errors`));
+                  self.currentBuildReject(
+                    new Error(`Build failed with ${result.errors.length} errors`)
+                  );
                 }
               } else {
                 console.log(`Build ${runtime} completed successfully`);
@@ -1622,15 +2670,18 @@ var init_PM_WithBuild = __esm({
           plugins: [...baseConfig.plugins || [], buildProcessTrackerPlugin]
         };
         try {
-          const ctx = await esbuild.context(configWithPlugin);
           if (this.mode === "dev") {
+            const ctx = await esbuild.context(configWithPlugin);
+            await ctx.rebuild();
             await ctx.watch();
           } else {
-            const result = await ctx.rebuild();
-            await ctx.dispose();
+            const result = await esbuild.build(configWithPlugin);
+            if (result.errors.length === 0) {
+              console.log(`Successfully built ${runtime} bundle`);
+            }
           }
         } catch (error) {
-          console.error(`Failed to start ${runtime} build context:`, error);
+          console.error(`Failed to build ${runtime}:`, error);
           if (this.broadcast) {
             this.broadcast({
               type: "buildEvent",
@@ -1642,6 +2693,7 @@ var init_PM_WithBuild = __esm({
               message: error.message
             });
           }
+          throw error;
         }
       }
     };
@@ -1691,8 +2743,16 @@ var init_logFiles = __esm({
         WARN: "warn.log",
         DEBUG: "debug.log"
       },
-      pure: {}
+      pure: {},
       // No runtime-specific logs for pure
+      python: {
+        STDOUT: "stdout.log",
+        STDERR: "stderr.log"
+      },
+      golang: {
+        STDOUT: "stdout.log",
+        STDERR: "stderr.log"
+      }
     };
     ALL_LOGS = {
       ...STANDARD_LOGS,
@@ -1708,8 +2768,8 @@ var init_logFiles = __esm({
 });
 
 // src/utils/makePrompt.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs11 from "fs";
+import path10 from "path";
 var makePrompt, makePromptInternal;
 var init_makePrompt = __esm({
   "src/utils/makePrompt.ts"() {
@@ -1720,23 +2780,23 @@ var init_makePrompt = __esm({
     makePrompt = async (summary, name, entryPoint, addableFiles, runtime) => {
       summary[entryPoint].prompt = "?";
       const promptPath = promptPather(entryPoint, runtime, name);
-      const testDir = path7.join(
+      const testDir = path10.join(
         "testeranto",
         "reports",
         name,
         entryPoint.split(".").slice(0, -1).join("."),
         runtime
       );
-      if (!fs7.existsSync(testDir)) {
-        fs7.mkdirSync(testDir, { recursive: true });
+      if (!fs11.existsSync(testDir)) {
+        fs11.mkdirSync(testDir, { recursive: true });
       }
-      const testPaths = path7.join(testDir, LOG_FILES.TESTS);
-      const lintPath = path7.join(testDir, LOG_FILES.LINT_ERRORS);
-      const typePath = path7.join(testDir, LOG_FILES.TYPE_ERRORS);
-      const messagePath = path7.join(testDir, LOG_FILES.MESSAGE);
+      const testPaths = path10.join(testDir, LOG_FILES.TESTS);
+      const lintPath = path10.join(testDir, LOG_FILES.LINT_ERRORS);
+      const typePath = path10.join(testDir, LOG_FILES.TYPE_ERRORS);
+      const messagePath = path10.join(testDir, LOG_FILES.MESSAGE);
       try {
         await Promise.all([
-          fs7.promises.writeFile(
+          fs11.promises.writeFile(
             promptPath,
             `
 ${addableFiles.map((x) => {
@@ -1752,10 +2812,10 @@ ${addableFiles.map((x) => {
 /read ${typePath}
 /read ${lintPath}
 
-/read ${getLogFilesForRuntime(runtime).map((p) => `${testDir}/${p}`).join(" ")}
+/read ${getLogFilesForRuntime(runtime).map((p) => `${testDir}/${p}`).join("\n/read ")}
 `
           ),
-          fs7.promises.writeFile(
+          fs11.promises.writeFile(
             messagePath,
             `
 There are 3 types of test reports.
@@ -1794,13 +2854,20 @@ Do not add error throwing/catching to the tests themselves.
       if (runTime === "pure") {
         return makePrompt(summary, name, entryPoint, addableFiles, "pure");
       }
+      if (runTime === "golang") {
+        return makePrompt(summary, name, entryPoint, addableFiles, "golang");
+      }
+      if (runTime === "python") {
+        return makePrompt(summary, name, entryPoint, addableFiles, "python");
+      }
+      throw `unknown runTime: ${runTime}`;
     };
   }
 });
 
 // src/PM/PM_WithEslintAndTsc.ts
 import ts from "typescript";
-import fs8 from "fs";
+import fs12 from "fs";
 import ansiC2 from "ansi-colors";
 import { ESLint } from "eslint";
 import tsc from "tsc-prog";
@@ -1863,7 +2930,7 @@ var init_PM_WithEslintAndTsc = __esm({
                 );
               }
             });
-            fs8.writeFileSync(tscPath, results.join("\n"));
+            fs12.writeFileSync(tscPath, results.join("\n"));
             this.typeCheckIsNowDone(entrypoint, results.length);
             return results.length;
           })();
@@ -1889,15 +2956,15 @@ var init_PM_WithEslintAndTsc = __esm({
               throw new Error(`Error in eslintCheck: ${e.message}`);
             }
             const filepath = lintPather(entrypoint, platform, this.name);
-            if (fs8.existsSync(filepath))
-              fs8.rmSync(filepath);
+            if (fs12.existsSync(filepath))
+              fs12.rmSync(filepath);
             const results = (await eslint.lintFiles(addableFiles)).filter((r) => r.messages.length).filter((r) => {
               return r.messages[0].ruleId !== null;
             }).map((r) => {
               delete r.source;
               return r;
             });
-            fs8.writeFileSync(filepath, await formatter.format(results));
+            fs12.writeFileSync(filepath, await formatter.format(results));
             this.lintIsNowDone(entrypoint, results.length);
             return results.length;
           })();
@@ -1984,7 +3051,7 @@ var init_PM_WithEslintAndTsc = __esm({
         this.writeBigBoard = () => {
           const summaryPath = `./testeranto/reports/${this.name}/summary.json`;
           const summaryData = JSON.stringify(this.summary, null, 2);
-          fs8.writeFileSync(summaryPath, summaryData);
+          fs12.writeFileSync(summaryPath, summaryData);
           this.broadcast({
             type: "summaryUpdate",
             data: this.summary
@@ -2017,6 +3084,7 @@ var init_PM_WithEslintAndTsc = __esm({
 });
 
 // src/PM/PM_WithGit.ts
+import fs13 from "fs";
 import url2 from "url";
 var PM_WithGit;
 var init_PM_WithGit = __esm({
@@ -2121,14 +3189,14 @@ var init_PM_WithGit = __esm({
         const parsedUrl = url2.parse(req.url || "/");
         const query = parsedUrl.query || "";
         const params = new URLSearchParams(query);
-        const path12 = params.get("path");
-        if (!path12) {
+        const path14 = params.get("path");
+        if (!path14) {
           res.writeHead(400, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ error: "Path parameter required" }));
           return;
         }
         try {
-          const status = await this.getGitFileStatus(path12);
+          const status = await this.getGitFileStatus(path14);
           res.writeHead(200, { "Content-Type": "application/json" });
           res.end(JSON.stringify(status));
         } catch (error) {
@@ -2230,10 +3298,10 @@ var init_PM_WithGit = __esm({
           res.end(JSON.stringify({ error: "Failed to get remote status" }));
         }
       }
-      async getGitFileStatus(path12) {
+      async getGitFileStatus(path14) {
         try {
           const changes2 = await this.getGitChanges();
-          const fileChange = changes2.find((change) => change.path === path12);
+          const fileChange = changes2.find((change) => change.path === path14);
           if (fileChange) {
             return { status: fileChange.status };
           }
@@ -2386,11 +3454,12 @@ ${description}` : message;
           const { exec } = await import("child_process");
           return new Promise((resolve, reject) => {
             exec(
-              "git status --porcelain",
+              "git status --porcelain=v1",
               { cwd: process.cwd() },
-              (error, stdout, stderr) => {
+              async (error, stdout, stderr) => {
+                if (stderr) {
+                }
                 if (error) {
-                  console.error("Error getting git changes:", error);
                   resolve([]);
                   return;
                 }
@@ -2399,23 +3468,40 @@ ${description}` : message;
                 for (const line of lines) {
                   if (!line.trim())
                     continue;
-                  const status = line.substring(0, 2).trim();
-                  const path12 = line.substring(3).trim();
+                  const match = line.match(/^(.{2}) (.*)$/);
+                  if (!match) {
+                    continue;
+                  }
+                  const status = match[1];
+                  let path14 = match[2];
+                  if (status === "R " && path14.includes(" -> ")) {
+                    const parts = path14.split(" -> ");
+                    path14 = parts[parts.length - 1];
+                  }
+                  path14 = path14.trim();
                   let fileStatus = "unchanged";
-                  if (status.startsWith("M")) {
+                  const firstChar = status.charAt(0);
+                  if (firstChar === "M" || firstChar === " ") {
                     fileStatus = "modified";
-                  } else if (status.startsWith("A")) {
+                  } else if (firstChar === "A") {
                     fileStatus = "added";
-                  } else if (status.startsWith("D")) {
+                  } else if (firstChar === "D") {
                     fileStatus = "deleted";
-                  } else if (status.startsWith("U") || status.includes("U")) {
+                  } else if (firstChar === "U") {
                     fileStatus = "conflicted";
-                  } else if (status.startsWith("??")) {
+                  } else if (status === "??") {
                     fileStatus = "added";
+                  } else if (status === "R ") {
+                    fileStatus = "modified";
                   }
                   if (fileStatus !== "unchanged") {
+                    const fullPath = `${process.cwd()}/${path14}`;
+                    try {
+                      await fs13.promises.access(fullPath);
+                    } catch (error2) {
+                    }
                     changes2.push({
-                      path: path12,
+                      path: path14,
                       status: fileStatus
                     });
                   }
@@ -2425,7 +3511,6 @@ ${description}` : message;
             );
           });
         } catch (error) {
-          console.error("Failed to get git changes:", error);
           return [];
         }
       }
@@ -2478,25 +3563,24 @@ ${description}` : message;
 });
 
 // src/PM/PM_WithProcesses.ts
-import fs9, { watch } from "fs";
-import path8 from "path";
+import fs14, { watch } from "fs";
+import path11 from "path";
 import puppeteer, { executablePath as executablePath2 } from "puppeteer-core";
 import ansiC3 from "ansi-colors";
-var fileHashes, changes, PM_WithProcesses;
+var changes, PM_WithProcesses;
 var init_PM_WithProcesses = __esm({
   async "src/PM/PM_WithProcesses.ts"() {
     "use strict";
     init_utils();
     init_utils2();
     await init_PM_WithGit();
-    fileHashes = {};
     changes = {};
     PM_WithProcesses = class extends PM_WithGit {
       constructor(configs, name, mode2) {
         super(configs, name, mode2);
         this.logStreams = {};
         this.receiveFeaturesV2 = (reportDest, srcTest, platform) => {
-          const featureDestination = path8.resolve(
+          const featureDestination = path11.resolve(
             process.cwd(),
             "reports",
             "features",
@@ -2504,25 +3588,25 @@ var init_PM_WithProcesses = __esm({
             srcTest.split(".").slice(0, -1).join(".") + ".features.txt"
           );
           const testReportPath = `${reportDest}/tests.json`;
-          if (!fs9.existsSync(testReportPath)) {
+          if (!fs14.existsSync(testReportPath)) {
             console.error(`tests.json not found at: ${testReportPath}`);
             return;
           }
-          const testReport = JSON.parse(fs9.readFileSync(testReportPath, "utf8"));
+          const testReport = JSON.parse(fs14.readFileSync(testReportPath, "utf8"));
           if (testReport.tests) {
             testReport.tests.forEach((test) => {
-              test.fullPath = path8.resolve(process.cwd(), srcTest);
+              test.fullPath = path11.resolve(process.cwd(), srcTest);
             });
           }
-          testReport.fullPath = path8.resolve(process.cwd(), srcTest);
-          fs9.writeFileSync(testReportPath, JSON.stringify(testReport, null, 2));
+          testReport.fullPath = path11.resolve(process.cwd(), srcTest);
+          fs14.writeFileSync(testReportPath, JSON.stringify(testReport, null, 2));
           testReport.features.reduce(async (mm, featureStringKey) => {
             const accum = await mm;
             const isUrl = isValidUrl(featureStringKey);
             if (isUrl) {
               const u = new URL(featureStringKey);
               if (u.protocol === "file:") {
-                const newPath = `${process.cwd()}/testeranto/features/internal/${path8.relative(
+                const newPath = `${process.cwd()}/testeranto/features/internal/${path11.relative(
                   process.cwd(),
                   u.pathname
                 )}`;
@@ -2534,17 +3618,17 @@ var init_PM_WithProcesses = __esm({
                 accum.files.push(newPath);
               }
             } else {
-              await fs9.promises.mkdir(path8.dirname(featureDestination), {
+              await fs14.promises.mkdir(path11.dirname(featureDestination), {
                 recursive: true
               });
               accum.strings.push(featureStringKey);
             }
             return accum;
           }, Promise.resolve({ files: [], strings: [] })).then(({ files: files3, strings }) => {
-            fs9.writeFileSync(
+            fs14.writeFileSync(
               `testeranto/reports/${this.name}/${srcTest.split(".").slice(0, -1).join(".")}/${platform}/featurePrompt.txt`,
-              files3.map((f2) => {
-                return `/read ${f2}`;
+              files3.map((f) => {
+                return `/read ${f}`;
               }).join("\n")
             );
           });
@@ -2616,6 +3700,15 @@ var init_PM_WithProcesses = __esm({
           this.ports[element] = "";
         });
       }
+      bddTestIsRunning(src) {
+        this.summary[src] = {
+          prompt: "?",
+          runTimeErrors: "?",
+          staticErrors: "?",
+          typeErrors: "?",
+          failingFeatures: {}
+        };
+      }
       async metafileOutputs(platform) {
         let metafilePath;
         if (platform === "python") {
@@ -2623,19 +3716,9 @@ var init_PM_WithProcesses = __esm({
         } else {
           metafilePath = `./testeranto/metafiles/${platform}/${this.name}.json`;
         }
-        if (!fs9.existsSync(metafilePath)) {
-          if (platform === "python") {
-            console.log(
-              ansiC3.yellow(
-                ansiC3.inverse(`Pitono metafile not found yet: ${metafilePath}`)
-              )
-            );
-          }
-          return;
-        }
         let metafile;
         try {
-          const fileContent = fs9.readFileSync(metafilePath).toString();
+          const fileContent = fs14.readFileSync(metafilePath).toString();
           const parsedData = JSON.parse(fileContent);
           if (platform === "python") {
             metafile = parsedData.metafile || parsedData;
@@ -2653,12 +3736,6 @@ var init_PM_WithProcesses = __esm({
           return;
         }
         const outputs = metafile.outputs;
-        if (!outputs || typeof outputs !== "object") {
-          console.log(
-            ansiC3.yellow(ansiC3.inverse(`No outputs found in metafile at ${metafilePath}`))
-          );
-          return;
-        }
         Object.keys(outputs).forEach(async (k) => {
           const pattern = `testeranto/bundles/${platform}/${this.name}/${this.configs.src}`;
           if (!k.startsWith(pattern)) {
@@ -2669,7 +3746,7 @@ var init_PM_WithProcesses = __esm({
             return;
           }
           const addableFiles = Object.keys(output.inputs).filter((i) => {
-            if (!fs9.existsSync(i))
+            if (!fs14.existsSync(i))
               return false;
             if (i.startsWith("node_modules"))
               return false;
@@ -2677,27 +3754,162 @@ var init_PM_WithProcesses = __esm({
               return false;
             return true;
           });
-          const f2 = `${k.split(".").slice(0, -1).join(".")}/`;
-          if (!fs9.existsSync(f2)) {
-            fs9.mkdirSync(f2, { recursive: true });
+          const f = `${k.split(".").slice(0, -1).join(".")}/`;
+          if (!fs14.existsSync(f)) {
+            fs14.mkdirSync(f, { recursive: true });
           }
-          const entrypoint = output.entryPoint;
+          let entrypoint = output.entryPoint;
           if (entrypoint) {
+            entrypoint = path11.normalize(entrypoint);
             const changeDigest = await filesHash(addableFiles);
             if (changeDigest === changes[entrypoint]) {
             } else {
               changes[entrypoint] = changeDigest;
-              this.tscCheck({
-                platform,
-                addableFiles,
-                entrypoint
-              });
-              this.eslintCheck(entrypoint, platform, addableFiles);
+              if (platform === "node" || platform === "web" || platform === "pure") {
+                this.tscCheck({
+                  platform,
+                  addableFiles,
+                  entrypoint
+                });
+                this.eslintCheck(entrypoint, platform, addableFiles);
+              } else if (platform === "python") {
+                this.pythonLintCheck(entrypoint, addableFiles);
+                this.pythonTypeCheck(entrypoint, addableFiles);
+              }
               this.makePrompt(entrypoint, addableFiles, platform);
+              const testName2 = this.findTestNameByEntrypoint(entrypoint, platform);
+              if (testName2) {
+                console.log(
+                  ansiC3.green(
+                    ansiC3.inverse(
+                      `Source files changed, re-queueing test: ${testName2}`
+                    )
+                  )
+                );
+                this.addToQueue(testName2, platform);
+              } else {
+                console.error(
+                  `Could not find test for entrypoint: ${entrypoint} (${platform})`
+                );
+                process.exit(-1);
+              }
             }
           }
         });
       }
+      findTestNameByEntrypoint(entrypoint, platform) {
+        const runnables = getRunnables(this.configs.tests, this.name);
+        let entryPointsMap;
+        switch (platform) {
+          case "node":
+            entryPointsMap = runnables.nodeEntryPoints;
+            break;
+          case "web":
+            entryPointsMap = runnables.webEntryPoints;
+            break;
+          case "pure":
+            entryPointsMap = runnables.pureEntryPoints;
+            break;
+          case "python":
+            entryPointsMap = runnables.pythonEntryPoints;
+            break;
+          case "golang":
+            entryPointsMap = runnables.golangEntryPoints;
+            break;
+          default:
+            throw "wtf";
+        }
+        if (!entryPointsMap) {
+          console.error("idk");
+        }
+        if (!entryPointsMap[entrypoint]) {
+          console.error("idk2");
+        }
+        return entryPointsMap[entrypoint];
+      }
+      async pythonLintCheck(entrypoint, addableFiles) {
+        const reportDest = `testeranto/reports/${this.name}/${entrypoint.split(".").slice(0, -1).join(".")}/python`;
+        if (!fs14.existsSync(reportDest)) {
+          fs14.mkdirSync(reportDest, { recursive: true });
+        }
+        const lintErrorsPath = `${reportDest}/lint_errors.txt`;
+        try {
+          const { spawn: spawn4 } = await import("child_process");
+          const child = spawn4("flake8", [entrypoint, "--max-line-length=88"], {
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+          let stderr = "";
+          child.stderr.on("data", (data) => {
+            stderr += data.toString();
+          });
+          let stdout = "";
+          child.stdout.on("data", (data) => {
+            stdout += data.toString();
+          });
+          return new Promise((resolve) => {
+            child.on("close", (code) => {
+              const output = stdout + stderr;
+              if (output.trim()) {
+                fs14.writeFileSync(lintErrorsPath, output);
+                this.summary[entrypoint].staticErrors = output.split("\n").length;
+              } else {
+                if (fs14.existsSync(lintErrorsPath)) {
+                  fs14.unlinkSync(lintErrorsPath);
+                }
+                this.summary[entrypoint].staticErrors = 0;
+              }
+              resolve();
+            });
+          });
+        } catch (error) {
+          console.error(`Error running flake8 on ${entrypoint}:`, error);
+          fs14.writeFileSync(
+            lintErrorsPath,
+            `Error running flake8: ${error.message}`
+          );
+          this.summary[entrypoint].staticErrors = -1;
+        }
+      }
+      async pythonTypeCheck(entrypoint, addableFiles) {
+        const reportDest = `testeranto/reports/${this.name}/${entrypoint.split(".").slice(0, -1).join(".")}/python`;
+        if (!fs14.existsSync(reportDest)) {
+          fs14.mkdirSync(reportDest, { recursive: true });
+        }
+        const typeErrorsPath = `${reportDest}/type_errors.txt`;
+        try {
+          const { spawn: spawn4 } = await import("child_process");
+          const child = spawn4("mypy", [entrypoint], {
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+          let stderr = "";
+          child.stderr.on("data", (data) => {
+            stderr += data.toString();
+          });
+          let stdout = "";
+          child.stdout.on("data", (data) => {
+            stdout += data.toString();
+          });
+          return new Promise((resolve) => {
+            child.on("close", (code) => {
+              const output = stdout + stderr;
+              if (output.trim()) {
+                fs14.writeFileSync(typeErrorsPath, output);
+                this.summary[entrypoint].typeErrors = output.split("\n").length;
+              } else {
+                if (fs14.existsSync(typeErrorsPath)) {
+                  fs14.unlinkSync(typeErrorsPath);
+                }
+                this.summary[entrypoint].typeErrors = 0;
+              }
+              resolve();
+            });
+          });
+        } catch (error) {
+          console.error(`Error running mypy on ${entrypoint}:`, error);
+          fs14.writeFileSync(typeErrorsPath, `Error running mypy: ${error.message}`);
+          this.summary[entrypoint].typeErrors = -1;
+        }
+      }
       async start() {
         try {
           await this.startBuildProcesses();
@@ -2709,8 +3921,8 @@ var init_PM_WithProcesses = __esm({
         this.mapping().forEach(async ([command, func]) => {
           globalThis[command] = func;
         });
-        if (!fs9.existsSync(`testeranto/reports/${this.name}`)) {
-          fs9.mkdirSync(`testeranto/reports/${this.name}`);
+        if (!fs14.existsSync(`testeranto/reports/${this.name}`)) {
+          fs14.mkdirSync(`testeranto/reports/${this.name}`);
         }
         try {
           this.browser = await puppeteer.launch(puppeteerConfigs);
@@ -2721,132 +3933,92 @@ var init_PM_WithProcesses = __esm({
             executablePath2
           );
         }
+        const runnables = getRunnables(this.configs.tests, this.name);
         const {
           nodeEntryPoints,
           webEntryPoints,
           pureEntryPoints,
           pythonEntryPoints,
           golangEntryPoints
-        } = getRunnables(this.configs.tests, this.name);
+        } = runnables;
+        console.log(
+          ansiC3.blue(
+            `Runnables for ${this.name}:
+Node: ${JSON.stringify(nodeEntryPoints, null, 2)}
+Web: ${JSON.stringify(webEntryPoints, null, 2)}
+Pure: ${JSON.stringify(pureEntryPoints, null, 2)}
+Python: ${JSON.stringify(pythonEntryPoints, null, 2)}
+Golang: ${JSON.stringify(golangEntryPoints, null, 2)}`
+          )
+        );
         [
-          [
-            nodeEntryPoints,
-            this.launchNode,
-            "node",
-            (w) => {
-              this.nodeMetafileWatcher = w;
-            }
-          ],
-          [
-            webEntryPoints,
-            this.launchWeb,
-            "web",
-            (w) => {
-              this.webMetafileWatcher = w;
-            }
-          ],
-          [
-            pureEntryPoints,
-            this.launchPure,
-            "pure",
-            (w) => {
-              this.importMetafileWatcher = w;
-            }
-          ],
-          [
-            pythonEntryPoints,
-            this.launchPython,
-            "python",
-            (w) => {
-              this.pitonoMetafileWatcher = w;
+          ["node", nodeEntryPoints],
+          ["web", webEntryPoints],
+          ["pure", pureEntryPoints],
+          ["python", pythonEntryPoints],
+          ["golang", golangEntryPoints]
+        ].forEach(([runtime, entryPoints]) => {
+          Object.keys(entryPoints).forEach((entryPoint) => {
+            const reportDest = `testeranto/reports/${this.name}/${entryPoint.split(".").slice(0, -1).join(".")}/${runtime}`;
+            if (!fs14.existsSync(reportDest)) {
+              fs14.mkdirSync(reportDest, { recursive: true });
             }
-          ],
-          [
-            golangEntryPoints,
-            this.launchGolang,
-            "golang",
-            (w) => {
-            }
-          ]
+            this.addToQueue(entryPoint, runtime);
+          });
+        });
+        [
+          ["node", nodeEntryPoints],
+          ["web", webEntryPoints],
+          ["pure", pureEntryPoints],
+          ["python", pythonEntryPoints],
+          ["golang", golangEntryPoints]
         ].forEach(
-          async ([eps, launcher, runtime, watcher]) => {
-            let metafile;
-            if (runtime === "python") {
-              metafile = `./testeranto/metafiles/python/core.json`;
-              const metafileDir = path8.dirname(metafile);
-              if (!fs9.existsSync(metafileDir)) {
-                fs9.mkdirSync(metafileDir, { recursive: true });
-              }
-            } else {
-              metafile = `./testeranto/metafiles/${runtime}/${this.name}.json`;
-            }
-            if (runtime !== "python") {
+          async ([runtime, entryPoints]) => {
+            if (Object.keys(entryPoints).length === 0)
+              return;
+            const metafile = `./testeranto/metafiles/${runtime}/${this.name}.json`;
+            try {
               await pollForFile(metafile);
-            }
-            Object.entries(eps).forEach(
-              async ([inputFile, outputFile]) => {
-                this.launchers[inputFile] = () => launcher(inputFile, outputFile);
-                this.launchers[inputFile]();
-                try {
-                  if (fs9.existsSync(outputFile)) {
-                    watch(outputFile, async (e, filename) => {
-                      const hash = await fileHash(outputFile);
-                      if (fileHashes[inputFile] !== hash) {
-                        fileHashes[inputFile] = hash;
-                        console.log(
-                          ansiC3.yellow(ansiC3.inverse(`< ${e} ${filename}`))
-                        );
-                        this.launchers[inputFile]();
-                      }
-                    });
-                  } else {
-                    console.log(
-                      ansiC3.yellow(
-                        ansiC3.inverse(
-                          `File not found, skipping watch: ${outputFile}`
-                        )
-                      )
-                    );
-                  }
-                } catch (e) {
-                  console.error(e);
-                }
-              }
-            );
-            this.metafileOutputs(runtime);
-            if (runtime === "python") {
-              const checkFileExists = () => {
-                if (fs9.existsSync(metafile)) {
+              let timeoutId;
+              const watcher = watch(metafile, async (e, filename) => {
+                clearTimeout(timeoutId);
+                timeoutId = setTimeout(async () => {
                   console.log(
-                    ansiC3.green(ansiC3.inverse(`Pitono metafile found: ${metafile}`))
-                  );
-                  watcher(
-                    watch(metafile, async (e, filename) => {
-                      console.log(
-                        ansiC3.yellow(
-                          ansiC3.inverse(`< ${e} ${filename} (${runtime})`)
-                        )
-                      );
-                      this.metafileOutputs(runtime);
-                    })
+                    ansiC3.yellow(ansiC3.inverse(`< ${e} ${filename} (${runtime})`))
                   );
-                  this.metafileOutputs(runtime);
-                } else {
-                  setTimeout(checkFileExists, 1e3);
-                }
-              };
-              checkFileExists();
-            } else {
-              if (fs9.existsSync(metafile)) {
-                watcher(
-                  watch(metafile, async (e, filename) => {
+                  try {
+                    await this.metafileOutputs(runtime);
                     console.log(
-                      ansiC3.yellow(ansiC3.inverse(`< ${e} ${filename} (${runtime})`))
+                      ansiC3.blue(
+                        `Metafile processed, checking queue for tests to run`
+                      )
                     );
-                    this.metafileOutputs(runtime);
-                  })
-                );
+                    this.checkQueue();
+                  } catch (error) {
+                    console.error(`Error processing metafile changes:`, error);
+                  }
+                }, 300);
+              });
+              switch (runtime) {
+                case "node":
+                  this.nodeMetafileWatcher = watcher;
+                  break;
+                case "web":
+                  this.webMetafileWatcher = watcher;
+                  break;
+                case "pure":
+                  this.importMetafileWatcher = watcher;
+                  break;
+                case "python":
+                  this.pitonoMetafileWatcher = watcher;
+                  break;
+                case "golang":
+                  this.golangMetafileWatcher = watcher;
+                  break;
               }
+              await this.metafileOutputs(runtime);
+            } catch (error) {
+              console.error(`Error setting up watcher for ${runtime}:`, error);
             }
           }
         );
@@ -2890,78 +4062,159 @@ var init_PM_WithProcesses = __esm({
           "../dist/index.html",
           "./index.html"
         ];
-        for (const path12 of possiblePaths) {
-          if (fs9.existsSync(path12)) {
-            return path12;
+        for (const path14 of possiblePaths) {
+          if (fs14.existsSync(path14)) {
+            return path14;
           }
         }
         return null;
       }
       addToQueue(src, runtime) {
-        this.queue.push(src);
-        console.log(
-          ansiC3.green(
-            ansiC3.inverse(`Added ${src} (${runtime}) to the processing queue`)
-          )
-        );
-        this.checkQueue();
+        if (src.includes("testeranto/bundles")) {
+          const runnables = getRunnables(this.configs.tests, this.name);
+          const allEntryPoints = [
+            ...Object.entries(runnables.nodeEntryPoints),
+            ...Object.entries(runnables.webEntryPoints),
+            ...Object.entries(runnables.pureEntryPoints),
+            ...Object.entries(runnables.pythonEntryPoints),
+            ...Object.entries(runnables.golangEntryPoints)
+          ];
+          const normalizedSrc = path11.normalize(src);
+          for (const [testName2, bundlePath] of allEntryPoints) {
+            const normalizedBundlePath = path11.normalize(bundlePath);
+            if (normalizedSrc.endsWith(normalizedBundlePath)) {
+              src = testName2;
+              break;
+            }
+          }
+        }
+        this.cleanupTestProcesses(src);
+        if (!this.queue.includes(src)) {
+          this.queue.push(src);
+          console.log(
+            ansiC3.green(
+              ansiC3.inverse(`Added ${src} (${runtime}) to the processing queue`)
+            )
+          );
+          this.checkQueue();
+        } else {
+          console.log(
+            ansiC3.yellow(
+              ansiC3.inverse(`Test ${src} is already in the queue, skipping`)
+            )
+          );
+        }
       }
-      checkQueue() {
-        const x = this.queue.pop();
-        if (!x) {
-          ansiC3.inverse(`The following queue is empty`);
-          return;
+      cleanupTestProcesses(testName2) {
+        const processesToCleanup = [];
+        for (const [processId, processInfo] of this.allProcesses.entries()) {
+          if (processInfo.testName === testName2 && processInfo.status === "running") {
+            processesToCleanup.push(processId);
+          }
         }
-        const test = this.configs.tests.find((t) => t[0] === x);
-        if (!test)
-          throw `test is undefined ${x}`;
-        const runtime = test[1];
-        const runnables = getRunnables(this.configs.tests, this.name);
-        let dest;
-        switch (runtime) {
-          case "node":
-            dest = runnables.nodeEntryPoints[x];
-            if (dest) {
-              this.launchNode(x, dest);
-            } else {
-              console.error(`No destination found for node test: ${x}`);
+        processesToCleanup.forEach((processId) => {
+          const processInfo = this.allProcesses.get(processId);
+          if (processInfo) {
+            if (processInfo.child) {
+              try {
+                processInfo.child.kill();
+              } catch (error) {
+                console.error(`Error killing process ${processId}:`, error);
+              }
             }
-            break;
-          case "web":
-            dest = runnables.webEntryPoints[x];
-            if (dest) {
-              this.launchWeb(x, dest);
-            } else {
-              console.error(`No destination found for web test: ${x}`);
-            }
-            break;
-          case "pure":
-            dest = runnables.pureEntryPoints[x];
-            if (dest) {
-              this.launchPure(x, dest);
-            } else {
-              console.error(`No destination found for pure test: ${x}`);
-            }
-            break;
-          case "python":
-            dest = runnables.pythonEntryPoints[x];
-            if (dest) {
-              this.launchPython(x, dest);
-            } else {
-              console.error(`No destination found for python test: ${x}`);
-            }
-            break;
-          case "golang":
-            dest = runnables.golangEntryPoints[x];
-            if (dest) {
-              this.launchGolang(x, dest);
-            } else {
-              console.error(`No destination found for golang test: ${x}`);
+            this.allProcesses.set(processId, {
+              ...processInfo,
+              status: "exited",
+              exitCode: -1,
+              error: "Killed due to source file change"
+            });
+            this.runningProcesses.delete(processId);
+            this.broadcast({
+              type: "processExited",
+              processId,
+              exitCode: -1,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              logs: ["Process killed due to source file change"]
+            });
+          }
+        });
+      }
+      checkQueue() {
+        while (this.queue.length > 0) {
+          const x = this.queue.pop();
+          if (!x)
+            continue;
+          let isRunning = false;
+          for (const processInfo of this.allProcesses.values()) {
+            if (processInfo.testName === x && processInfo.status === "running") {
+              isRunning = true;
+              break;
             }
-            break;
-          default:
-            console.error(`Unknown runtime: ${runtime} for test ${x}`);
-            break;
+          }
+          if (isRunning) {
+            console.log(
+              ansiC3.yellow(
+                `Skipping ${x} - already running, will be re-queued when current run completes`
+              )
+            );
+            continue;
+          }
+          const test = this.configs.tests.find((t) => t[0] === x);
+          if (!test) {
+            console.error(`test is undefined ${x}`);
+            continue;
+          }
+          const runtime = test[1];
+          const runnables = getRunnables(this.configs.tests, this.name);
+          let dest;
+          switch (runtime) {
+            case "node":
+              dest = runnables.nodeEntryPoints[x];
+              if (dest) {
+                this.launchNode(x, dest);
+              } else {
+                console.error(`No destination found for node test: ${x}`);
+              }
+              break;
+            case "web":
+              dest = runnables.webEntryPoints[x];
+              if (dest) {
+                this.launchWeb(x, dest);
+              } else {
+                console.error(`No destination found for web test: ${x}`);
+              }
+              break;
+            case "pure":
+              dest = runnables.pureEntryPoints[x];
+              if (dest) {
+                this.launchPure(x, dest);
+              } else {
+                console.error(`No destination found for pure test: ${x}`);
+              }
+              break;
+            case "python":
+              dest = runnables.pythonEntryPoints[x];
+              if (dest) {
+                this.launchPython(x, dest);
+              } else {
+                console.error(`No destination found for python test: ${x}`);
+              }
+              break;
+            case "golang":
+              dest = runnables.golangEntryPoints[x];
+              if (dest) {
+                this.launchGolang(x, dest);
+              } else {
+                console.error(`No destination found for golang test: ${x}`);
+              }
+              break;
+            default:
+              console.error(`Unknown runtime: ${runtime} for test ${x}`);
+              break;
+          }
+        }
+        if (this.queue.length === 0) {
+          console.log(ansiC3.inverse(`The queue is empty`));
         }
       }
       onBuildDone() {
@@ -2972,16 +4225,173 @@ var init_PM_WithProcesses = __esm({
   }
 });
 
+// src/PM/PM_WithHelpo.ts
+import { spawnSync } from "node:child_process";
+import fs15 from "fs";
+import path12 from "path";
+var PM_WithHelpo;
+var init_PM_WithHelpo = __esm({
+  async "src/PM/PM_WithHelpo.ts"() {
+    "use strict";
+    await init_PM_WithProcesses();
+    PM_WithHelpo = class extends PM_WithProcesses {
+      constructor(configs, name, mode2) {
+        super(configs, name, mode2);
+        this.aiderProcess = null;
+        this.MAX_HISTORY_SIZE = 10 * 1024;
+        // 10KB
+        this.isAiderAtPrompt = false;
+        this.chatHistoryPath = path12.join(
+          process.cwd(),
+          "testeranto",
+          "helpo_chat_history.json"
+        );
+        this.initializeChatHistory();
+        this.startAiderProcess();
+      }
+      initializeChatHistory() {
+        fs15.writeFileSync(this.chatHistoryPath, JSON.stringify([]));
+        const messagePath = path12.join(
+          process.cwd(),
+          "testeranto",
+          "helpo_chat_message.txt"
+        );
+        const messageDir = path12.dirname(messagePath);
+        if (!fs15.existsSync(messageDir)) {
+          fs15.mkdirSync(messageDir, { recursive: true });
+        }
+        fs15.writeFileSync(messagePath, "");
+      }
+      startAiderProcess() {
+      }
+      async processAiderResponse(response) {
+        const cleanResponse = response.trim();
+        if (!cleanResponse) {
+          return;
+        }
+        const assistantMessage = {
+          type: "assistant",
+          content: cleanResponse,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await this.addToChatHistory(assistantMessage);
+        const history = await this.getChatHistory();
+        this.broadcast({
+          type: "chatHistory",
+          messages: history
+        });
+        await this.trimChatHistory();
+      }
+      restartAiderProcess() {
+        if (this.aiderProcess) {
+          this.aiderProcess.kill();
+        }
+        this.startAiderProcess();
+      }
+      isAiderAvailable() {
+        try {
+          const whichAider = spawnSync("which", ["aider"]);
+          return whichAider.status === 0;
+        } catch (error) {
+          return false;
+        }
+      }
+      async addToChatHistory(message) {
+        const history = await this.getChatHistory();
+        history.push(message);
+        fs15.writeFileSync(this.chatHistoryPath, JSON.stringify(history, null, 2));
+        console.log(
+          `Added message to chat history: ${message.content.substring(0, 50)}...`
+        );
+      }
+      async trimChatHistory() {
+        const history = await this.getChatHistory();
+        let currentSize = Buffer.from(JSON.stringify(history)).length;
+        while (currentSize > this.MAX_HISTORY_SIZE && history.length > 0) {
+          history.shift();
+          currentSize = Buffer.from(JSON.stringify(history)).length;
+        }
+        fs15.writeFileSync(this.chatHistoryPath, JSON.stringify(history, null, 2));
+      }
+      async getChatHistory() {
+        try {
+          const data = fs15.readFileSync(this.chatHistoryPath, "utf-8");
+          return JSON.parse(data);
+        } catch (error) {
+          return [];
+        }
+      }
+      async handleChatMessage(userMessage) {
+        const userChatMessage = {
+          type: "user",
+          content: userMessage,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await this.addToChatHistory(userChatMessage);
+        const history = await this.getChatHistory();
+        this.broadcast({
+          type: "chatHistory",
+          messages: history
+        });
+        console.log(`User message recorded: ${userMessage}`);
+        if (!this.aiderProcess) {
+          console.log(
+            "Aider process is not available - message recorded but not processed"
+          );
+          return;
+        }
+        setTimeout(() => {
+          try {
+            if (this.aiderProcess) {
+              const messagePath = path12.join(
+                process.cwd(),
+                "testeranto",
+                "helpo_chat_message.txt"
+              );
+              fs15.writeFileSync(messagePath, "");
+              const ptyProcess = this.aiderProcess;
+              ptyProcess.write(
+                "PROCESS_CHAT_HISTORY_AND_RESPOND: Read the chat history and write your response ONLY to testeranto/helpo_chat_message.txt. Do NOT print to stdout.\n"
+              );
+            } else {
+              console.log("Aider process is not available");
+            }
+          } catch (error) {
+            console.error("Error writing to aider process:", error);
+          }
+        }, 100);
+      }
+      // Override WebSocket message handling to include chat messages
+      setupWebSocketHandlers() {
+      }
+      // This method should be called when a WebSocket message is received
+      handleWebSocketMessage(ws, message) {
+        try {
+          const parsedMessage = JSON.parse(message.toString());
+          if (parsedMessage.type === "chatMessage") {
+            this.handleChatMessage(parsedMessage.content);
+          } else {
+            super.handleWebSocketMessage?.(ws, message);
+          }
+        } catch (error) {
+          console.error("Error handling WebSocket message:", error);
+        }
+      }
+    };
+  }
+});
+
 // src/PM/main.ts
 var main_exports = {};
 __export(main_exports, {
   PM_Main: () => PM_Main
 });
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import ansiColors from "ansi-colors";
 import net from "net";
-import fs10 from "fs";
+import fs16 from "fs";
 import ansiC4 from "ansi-colors";
+import path13 from "node:path";
 var files2, screenshots2, PM_Main;
 var init_main = __esm({
   async "src/PM/main.ts"() {
@@ -2989,20 +4399,21 @@ var init_main = __esm({
     init_utils();
     init_queue();
     init_utils2();
-    await init_PM_WithProcesses();
+    await init_PM_WithHelpo();
     files2 = {};
     screenshots2 = {};
-    PM_Main = class extends PM_WithProcesses {
+    PM_Main = class extends PM_WithHelpo {
       constructor() {
         super(...arguments);
         this.launchPure = async (src, dest) => {
+          console.log(ansiC4.green(ansiC4.inverse(`pure < ${src}`)));
           const processId = `pure-${src}-${Date.now()}`;
           const command = `pure test: ${src}`;
           const purePromise = (async () => {
             this.bddTestIsRunning(src);
             const reportDest = `testeranto/reports/${this.name}/${src.split(".").slice(0, -1).join(".")}/pure`;
-            if (!fs10.existsSync(reportDest)) {
-              fs10.mkdirSync(reportDest, { recursive: true });
+            if (!fs16.existsSync(reportDest)) {
+              fs16.mkdirSync(reportDest, { recursive: true });
             }
             const destFolder = dest.replace(".mjs", "");
             let argz = "";
@@ -3065,6 +4476,22 @@ var init_main = __esm({
                       `pure ! ${src} failed to execute. No "tests.json" file was generated. Check the logs for more info`
                     )
                   );
+                  const testsJsonPath = `${reportDest}/tests.json`;
+                  if (!fs16.existsSync(testsJsonPath)) {
+                    fs16.writeFileSync(
+                      testsJsonPath,
+                      JSON.stringify(
+                        {
+                          tests: [],
+                          features: [],
+                          givens: [],
+                          fullPath: src
+                        },
+                        null,
+                        2
+                      )
+                    );
+                  }
                   logs.exit.write(e2.stack);
                   logs.exit.write(-1);
                   this.bddTestIsNowDone(src, -1);
@@ -3073,6 +4500,22 @@ var init_main = __esm({
                 });
               });
             } catch (e3) {
+              const testsJsonPath = `${reportDest}/tests.json`;
+              if (!fs16.existsSync(testsJsonPath)) {
+                fs16.writeFileSync(
+                  testsJsonPath,
+                  JSON.stringify(
+                    {
+                      tests: [],
+                      features: [],
+                      givens: [],
+                      fullPath: src
+                    },
+                    null,
+                    2
+                  )
+                );
+              }
               logs.writeExitCode(-1, e3);
               console.log(
                 ansiC4.red(
@@ -3087,6 +4530,7 @@ var init_main = __esm({
               statusMessagePretty(-1, src, "pure");
               throw e3;
             } finally {
+              await this.generatePromptFiles(reportDest, src);
               for (let i = 0; i <= portsToUse.length; i++) {
                 if (portsToUse[i]) {
                   this.ports[portsToUse[i]] = "";
@@ -3104,83 +4548,25 @@ var init_main = __esm({
           );
         };
         this.launchNode = async (src, dest) => {
+          console.log(ansiC4.green(ansiC4.inverse(`node < ${src}`)));
           const processId = `node-${src}-${Date.now()}`;
           const command = `node test: ${src}`;
           const nodePromise = (async () => {
-            this.bddTestIsRunning(src);
-            const reportDest = `testeranto/reports/${this.name}/${src.split(".").slice(0, -1).join(".")}/node`;
-            if (!fs10.existsSync(reportDest)) {
-              fs10.mkdirSync(reportDest, { recursive: true });
-            }
-            let testResources = "";
-            const testConfig = this.configs.tests.find((t) => {
-              return t[0] === src;
-            });
-            if (!testConfig) {
-              console.log(
-                ansiC4.inverse(
-                  `missing test config! Exiting ungracefully for '${src}'`
-                )
-              );
-              process.exit(-1);
-            }
-            const testConfigResource = testConfig[2];
-            const portsToUse = [];
-            if (testConfigResource.ports === 0) {
-              const t = {
-                name: src,
-                ports: [],
-                fs: reportDest,
-                browserWSEndpoint: this.browser.wsEndpoint()
-              };
-              testResources = JSON.stringify(t);
-            } else if (testConfigResource.ports > 0) {
-              const openPorts = 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;
-                }
-                testResources = JSON.stringify({
-                  scheduled: true,
-                  name: src,
-                  ports: portsToUse,
-                  fs: reportDest,
-                  browserWSEndpoint: this.browser.wsEndpoint()
-                });
-              } else {
-                console.log(
-                  ansiC4.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 = spawn2("node", [builtfile, testResources, ipcfile], {
-              stdio: ["pipe", "pipe", "pipe", "ipc"]
-            });
-            let buffer = new Buffer("");
-            const server = net.createServer((socket) => {
+            try {
+              const { reportDest, testResources, portsToUse } = await this.setupTestEnvironment(src, "node");
+              const builtfile = dest;
+              const ipcfile = "/tmp/tpipe_" + Math.random();
+              const logs = createLogStreams(reportDest, "node");
+              let buffer = Buffer.from("");
               const queue = new Queue();
-              socket.on("data", (data) => {
+              const onData = (data) => {
                 buffer = Buffer.concat([buffer, data]);
                 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) {
                   }
@@ -3190,85 +4576,39 @@ var init_main = __esm({
                   if (message) {
                     this.mapping().forEach(async ([command2, func]) => {
                       if (message[0] === command2) {
-                        const x = message.slice(1, -1);
-                        const r = await this[command2](...x);
-                        if (!haltReturns) {
+                        const args = message.slice(1, -1);
+                        try {
+                          const result = await this[command2](...args);
                           child.send(
                             JSON.stringify({
-                              payload: r,
+                              payload: result,
                               key: message[message.length - 1]
                             })
                           );
+                        } catch (error) {
+                          console.error(`Error handling command ${command2}:`, error);
                         }
                       }
                     });
                   }
                 }
+              };
+              const server = await this.createIpcServer(onData, ipcfile);
+              const child = spawn3("node", [builtfile, testResources, ipcfile], {
+                stdio: ["pipe", "pipe", "pipe", "ipc"]
               });
-            });
-            const logs = createLogStreams(reportDest, "node");
-            return new Promise((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}`));
-                  }
-                  haltReturns = true;
-                });
-                child.on("error", (e) => {
-                  console.log("error");
-                  haltReturns = true;
-                  console.log(
-                    ansiC4.red(
-                      ansiC4.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]] = "";
-                }
+              try {
+                await this.handleChildProcess(child, logs, reportDest, src, "node");
+                await this.generatePromptFiles(reportDest, src);
+              } finally {
+                server.close();
+                this.cleanupPorts(portsToUse);
               }
-            });
+            } catch (error) {
+              if (error.message !== "No ports available") {
+                throw error;
+              }
+            }
           })();
           this.addPromiseProcess(
             processId,
@@ -3280,13 +4620,14 @@ var init_main = __esm({
           );
         };
         this.launchWeb = async (src, dest) => {
+          console.log(ansiC4.green(ansiC4.inverse(`web < ${src}`)));
           const processId = `web-${src}-${Date.now()}`;
           const command = `web test: ${src}`;
           const webPromise = (async () => {
             this.bddTestIsRunning(src);
             const reportDest = `testeranto/reports/${this.name}/${src.split(".").slice(0, -1).join(".")}/web`;
-            if (!fs10.existsSync(reportDest)) {
-              fs10.mkdirSync(reportDest, { recursive: true });
+            if (!fs16.existsSync(reportDest)) {
+              fs16.mkdirSync(reportDest, { recursive: true });
             }
             const destFolder = dest.replace(".mjs", "");
             const webArgz = JSON.stringify({
@@ -3373,9 +4714,26 @@ var init_main = __esm({
                       )
                     )
                   );
+                  const testsJsonPath = `${reportDest}/tests.json`;
+                  if (!fs16.existsSync(testsJsonPath)) {
+                    fs16.writeFileSync(
+                      testsJsonPath,
+                      JSON.stringify(
+                        {
+                          tests: [],
+                          features: [],
+                          givens: [],
+                          fullPath: src
+                        },
+                        null,
+                        2
+                      )
+                    );
+                  }
                   this.bddTestIsNowDone(src, -1);
                   reject(e);
-                }).finally(() => {
+                }).finally(async () => {
+                  await this.generatePromptFiles(reportDest, src);
                   close();
                 });
               }).catch((error) => {
@@ -3393,117 +4751,68 @@ var init_main = __esm({
           );
         };
         this.launchPython = async (src, dest) => {
+          console.log(ansiC4.green(ansiC4.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 (!fs10.existsSync(reportDest)) {
-              fs10.mkdirSync(reportDest, { recursive: true });
-            }
-            let testResources = "";
-            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 testConfigResource = testConfig[2];
-            const portsToUse = [];
-            if (testConfigResource.ports === 0) {
-              testResources = JSON.stringify({
-                scheduled: true,
-                name: src,
-                ports: portsToUse,
-                fs: reportDest,
-                browserWSEndpoint: this.browser.wsEndpoint()
+            try {
+              const { reportDest, testResources, portsToUse } = await this.setupTestEnvironment(src, "python");
+              const logs = createLogStreams(reportDest, "python");
+              const venvPython = `./venv/bin/python3`;
+              const pythonCommand = fs16.existsSync(venvPython) ? venvPython : "python3";
+              const ipcfile = "/tmp/tpipe_python_" + Math.random();
+              const child = spawn3(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;
+              let buffer = Buffer.from("");
+              const queue = new Queue();
+              const onData = (data) => {
+                buffer = Buffer.concat([buffer, data]);
+                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) {
+                  }
                 }
-                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);
-            }
-            const logs = createLogStreams(reportDest, "python");
-            const child = spawn2("python3", [src, testResources], {
-              stdio: ["pipe", "pipe", "pipe"]
-            });
-            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, "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}`));
+                while (queue.size() > 0) {
+                  const message = queue.dequeue();
+                  if (message) {
+                    this.mapping().forEach(async ([command2, func]) => {
+                      if (message[0] === command2) {
+                        const args = message.slice(1, -1);
+                        try {
+                          const result = await this[command2](...args);
+                          child.send(
+                            JSON.stringify({
+                              payload: result,
+                              key: message[message.length - 1]
+                            })
+                          );
+                        } catch (error) {
+                          console.error(`Error handling command ${command2}:`, error);
+                        }
+                      }
+                    });
+                  }
                 }
-              });
-              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] = "";
-              });
-            });
+              };
+              const server = await this.createIpcServer(onData, ipcfile);
+              try {
+                await this.handleChildProcess(child, logs, reportDest, src, "python");
+                await this.generatePromptFiles(reportDest, src);
+              } finally {
+                server.close();
+                this.cleanupPorts(portsToUse);
+              }
+            } catch (error) {
+              if (error.message !== "No ports available") {
+                throw error;
+              }
+            }
           })();
           this.addPromiseProcess(
             processId,
@@ -3515,152 +4824,88 @@ var init_main = __esm({
           );
         };
         this.launchGolang = async (src, dest) => {
+          console.log(ansiC4.green(ansiC4.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`;
-            if (!fs10.existsSync(reportDest)) {
-              fs10.mkdirSync(reportDest, { recursive: true });
-            }
-            let testResources = "";
-            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 = [];
-            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 === ""
-              );
-              if (openPorts.length >= testConfigResource.ports) {
-                for (let i = 0; i < testConfigResource.ports; i++) {
-                  portsToUse.push(openPorts[i][0]);
-                  this.ports[openPorts[i][0]] = src;
+            try {
+              const { reportDest, testResources, portsToUse } = await this.setupTestEnvironment(src, "golang");
+              const logs = createLogStreams(reportDest, "golang");
+              const ipcfile = "/tmp/tpipe_golang_" + Math.random().toString(36).substring(2);
+              let buffer = Buffer.from("");
+              const queue = new Queue();
+              const onData = (data) => {
+                buffer = Buffer.concat([buffer, data]);
+                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) {
+                  }
                 }
-                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;
+                while (queue.size() > 0) {
+                  const message = queue.dequeue();
+                  if (message) {
+                    this.mapping().forEach(async ([command2, func]) => {
+                      if (message[0] === command2) {
+                        const args = message.slice(1, -1);
+                        try {
+                          const result = await this[command2](...args);
+                        } catch (error) {
+                          console.error(`Error handling command ${command2}:`, error);
+                        }
+                      }
+                    });
+                  }
+                }
+              };
+              const server = await this.createIpcServer(onData, ipcfile);
+              let currentDir = path13.dirname(src);
+              let goModDir = null;
+              while (currentDir !== path13.parse(currentDir).root) {
+                if (fs16.existsSync(path13.join(currentDir, "go.mod"))) {
+                  goModDir = currentDir;
+                  break;
+                }
+                currentDir = path13.dirname(currentDir);
               }
-            } else {
-              console.error("negative port makes no sense", src);
-              process.exit(-1);
-            }
-            const buildDir = path.dirname(dest);
-            const binaryName = path.basename(dest, ".go");
-            const binaryPath = path.join(buildDir, binaryName);
-            const logs = createLogStreams(reportDest, "golang");
-            const compileProcess = spawn2("go", ["build", "-o", binaryPath, dest]);
-            return new Promise((resolve, reject) => {
-              compileProcess.stdout?.on("data", (data) => {
-                logs.stdout?.write(data);
-              });
-              compileProcess.stderr?.on("data", (data) => {
-                logs.stderr?.write(data);
-              });
-              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;
+              if (!goModDir) {
+                console.error(`Could not find go.mod file for test ${src}`);
+                goModDir = path13.dirname(src);
+                console.error(`Falling back to: ${goModDir}`);
+              }
+              const relativeTestPath = path13.relative(goModDir, src);
+              const child = spawn3(
+                "go",
+                ["test", "-v", "-json", "./" + path13.dirname(relativeTestPath)],
+                {
+                  stdio: ["pipe", "pipe", "pipe"],
+                  env: {
+                    ...process.env,
+                    TEST_RESOURCES: testResources,
+                    IPC_FILE: ipcfile,
+                    GO111MODULE: "on"
+                  },
+                  cwd: goModDir
                 }
-                const child = spawn2(binaryPath, [testResources], {
-                  stdio: ["pipe", "pipe", "pipe"]
-                });
-                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, "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}`));
-                  }
-                });
-                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);
-                });
-              });
-              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] = "";
-              });
-            });
+              );
+              await this.handleChildProcess(child, logs, reportDest, src, "golang");
+              await this.generatePromptFiles(reportDest, src);
+              await this.processGoTestOutput(reportDest, src);
+              server.close();
+              try {
+                fs16.unlinkSync(ipcfile);
+              } catch (e) {
+              }
+              this.cleanupPorts(portsToUse);
+            } catch (error) {
+              if (error.message !== "No ports available") {
+                throw error;
+              }
+            }
           })();
           this.addPromiseProcess(
             processId,
@@ -3672,184 +4917,241 @@ var init_main = __esm({
           );
         };
       }
-    };
-  }
-});
-
-// src/utils/golingvuMetafile.ts
-var golingvuMetafile_exports = {};
-__export(golingvuMetafile_exports, {
-  generateGolangMetafile: () => generateGolangMetafile,
-  writeGolangMetafile: () => writeGolangMetafile
-});
-import fs11 from "fs";
-import path9 from "path";
-async function generateGolangMetafile(testName2, entryPoints) {
-  const outputs = {};
-  for (const entryPoint of entryPoints) {
-    try {
-      const entryDir = path9.dirname(entryPoint);
-      const goFiles = fs11.readdirSync(entryDir).filter((file) => file.endsWith(".go")).map((file) => path9.join(entryDir, file));
-      const inputs = {};
-      let totalBytes = 0;
-      for (const file of goFiles) {
+      async setupTestEnvironment(src, runtime) {
+        this.bddTestIsRunning(src);
+        const reportDest = `testeranto/reports/${this.name}/${src.split(".").slice(0, -1).join(".")}/${runtime}`;
+        if (!fs16.existsSync(reportDest)) {
+          fs16.mkdirSync(reportDest, { recursive: true });
+        }
+        const testConfig = this.configs.tests.find((t) => t[0] === src);
+        if (!testConfig) {
+          console.log(
+            ansiC4.inverse(`missing test config! Exiting ungracefully for '${src}'`)
+          );
+          process.exit(-1);
+        }
+        const testConfigResource = testConfig[2];
+        const portsToUse = [];
+        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(
+              ansiC4.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
+        };
+      }
+      cleanupPorts(portsToUse) {
+        portsToUse.forEach((port) => {
+          this.ports[port] = "";
+        });
+      }
+      createIpcServer(onData, ipcfile) {
+        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);
+        });
+      }
+      handleChildProcess(child, logs, reportDest, src, runtime) {
+        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(
+              ansiC4.red(
+                ansiC4.inverse(
+                  `${src} errored with: ${e.name}. Check error logs for more info`
+                )
+              )
+            );
+            this.bddTestIsNowDone(src, -1);
+            statusMessagePretty(-1, src, runtime);
+            reject(e);
+          });
+        });
+      }
+      async processGoTestOutput(reportDest, src) {
+        const testsJsonPath = `${reportDest}/tests.json`;
+        const stdoutPath = `${reportDest}/stdout.log`;
+        if (fs16.existsSync(stdoutPath)) {
+          try {
+            const stdoutContent = fs16.readFileSync(stdoutPath, "utf-8");
+            const lines = stdoutContent.split("\n").filter((line) => line.trim());
+            const testResults = {
+              tests: [],
+              features: [],
+              givens: [],
+              fullPath: path13.resolve(process.cwd(), src)
+            };
+            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) {
+              }
+            }
+            fs16.writeFileSync(testsJsonPath, JSON.stringify(testResults, null, 2));
+            return;
+          } catch (error) {
+            console.error("Error processing go test output:", error);
+          }
+        }
+        const basicTestResult = {
+          tests: [],
+          features: [],
+          givens: [],
+          fullPath: path13.resolve(process.cwd(), src)
+        };
+        fs16.writeFileSync(testsJsonPath, JSON.stringify(basicTestResult, null, 2));
+      }
+      async generatePromptFiles(reportDest, src) {
         try {
-          const stats = fs11.statSync(file);
-          inputs[file] = { bytesInOutput: stats.size };
-          totalBytes += stats.size;
-        } catch {
-          inputs[file] = { bytesInOutput: 0 };
+          if (!fs16.existsSync(reportDest)) {
+            fs16.mkdirSync(reportDest, { recursive: true });
+          }
+          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.`;
+          fs16.writeFileSync(messagePath, messageContent);
+          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`;
+          fs16.writeFileSync(promptPath, promptContent);
+        } catch (error) {
+          console.error(`Failed to generate prompt files for ${src}:`, error);
         }
       }
-      if (!inputs[entryPoint]) {
+      getGolangSourceFiles(src) {
+        const testDir = path13.dirname(src);
+        const files3 = [];
         try {
-          const entryStats = fs11.statSync(entryPoint);
-          inputs[entryPoint] = { bytesInOutput: entryStats.size };
-          totalBytes += entryStats.size;
-        } catch {
-          inputs[entryPoint] = { bytesInOutput: 0 };
+          const dirContents = fs16.readdirSync(testDir);
+          dirContents.forEach((file) => {
+            if (file.endsWith(".go")) {
+              files3.push(path13.join(testDir, file));
+            }
+          });
+        } catch (error) {
+          console.error(`Error reading directory ${testDir}:`, error);
+        }
+        if (!files3.includes(src)) {
+          files3.push(src);
         }
+        return files3;
       }
-      const outputPath = `testeranto/bundles/golang/${testName2}/${entryPoint}`;
-      outputs[outputPath] = {
-        entryPoint,
-        // Use the source file path, not the bundle path
-        inputs,
-        bytes: totalBytes
-      };
-    } catch (error) {
-      console.error(`Error processing Go entry point ${entryPoint}:`, error);
-    }
-  }
-  const allInputs = {};
-  const allGoFiles = /* @__PURE__ */ new Set();
-  for (const entryPoint of entryPoints) {
-    try {
-      const entryDir = path9.dirname(entryPoint);
-      const goFiles = fs11.readdirSync(entryDir).filter((file) => file.endsWith(".go")).map((file) => path9.join(entryDir, file));
-      goFiles.forEach((file) => allGoFiles.add(file));
-      allGoFiles.add(entryPoint);
-    } catch (error) {
-      console.error(`Error processing Go entry point ${entryPoint} for source files:`, error);
-    }
-  }
-  for (const filePath of Array.from(allGoFiles)) {
-    try {
-      const stats = fs11.statSync(filePath);
-      allInputs[filePath] = {
-        bytes: stats.size,
-        imports: []
-        // Go files don't have imports like JS
-      };
-    } catch {
-      allInputs[filePath] = {
-        bytes: 0,
-        imports: []
-      };
-    }
-  }
-  const esbuildOutputs = {};
-  for (const [outputPath, output] of Object.entries(outputs)) {
-    esbuildOutputs[outputPath] = {
-      bytes: output.bytes,
-      inputs: output.inputs,
-      entryPoint: output.entryPoint
     };
   }
-  return {
-    errors: [],
-    warnings: [],
-    metafile: {
-      inputs: allInputs,
-      outputs: esbuildOutputs
-    }
-  };
-}
-function writeGolangMetafile(testName2, metafile) {
-  const metafileDir = path9.join(
-    process.cwd(),
-    "testeranto",
-    "metafiles",
-    "golang"
-  );
-  fs11.mkdirSync(metafileDir, { recursive: true });
-  const metafilePath = path9.join(metafileDir, `${testName2}.json`);
-  fs11.writeFileSync(metafilePath, JSON.stringify(metafile, null, 2));
-}
-var init_golingvuMetafile = __esm({
-  "src/utils/golingvuMetafile.ts"() {
-    "use strict";
-  }
-});
-
-// src/utils/pitonoMetafile.ts
-var pitonoMetafile_exports = {};
-__export(pitonoMetafile_exports, {
-  generatePitonoMetafile: () => generatePitonoMetafile,
-  writePitonoMetafile: () => writePitonoMetafile
-});
-import fs12 from "fs";
-import path10 from "path";
-import { execSync } from "child_process";
-async function generatePitonoMetafile(testName2, entryPoints) {
-  return {
-    testName: testName2,
-    entryPoints,
-    timestamp: Date.now()
-  };
-}
-function writePitonoMetafile(testName2, metafile) {
-  const metafilePath = path10.join(process.cwd(), "testeranto", "pitono", testName2, "metafile.json");
-  const metafileDir = path10.dirname(metafilePath);
-  if (!fs12.existsSync(metafileDir)) {
-    fs12.mkdirSync(metafileDir, { recursive: true });
-  }
-  fs12.writeFileSync(metafilePath, JSON.stringify(metafile, null, 2));
-  console.log(`Pitono metafile written to: ${metafilePath}`);
-  try {
-    const command = `pitono-core-generator ${testName2} ${metafile.entryPoints.join(" ")}`;
-    execSync(command, { stdio: "inherit" });
-    console.log(`Pitono core.json generated successfully for ${testName2}`);
-  } catch (error) {
-    console.error(`Failed to generate Pitono core.json with installed command: ${error}`);
-    try {
-      const pythonCommand = `python ${process.cwd()}/pitono/core_generator.py ${testName2} ${metafile.entryPoints.join(" ")}`;
-      execSync(pythonCommand, { stdio: "inherit" });
-      console.log(`Pitono core.json generated successfully using direct Python execution`);
-    } catch (fallbackError) {
-      console.error(`Direct Python execution also failed: ${fallbackError}`);
-      try {
-        const coreData = {
-          testName: testName2,
-          entryPoints: metafile.entryPoints,
-          outputs: {},
-          metafile: {
-            inputs: {},
-            outputs: {}
-          },
-          timestamp: Date.now(),
-          runtime: "pitono"
-        };
-        const coreFilePath = path10.join(process.cwd(), "testeranto", "pitono", testName2, "core.json");
-        fs12.writeFileSync(coreFilePath, JSON.stringify(coreData, null, 2));
-        console.log(`Pitono core.json created manually as fallback`);
-      } catch (manualError) {
-        console.error(`Even manual creation failed: ${manualError}`);
-      }
-    }
-  }
-}
-var init_pitonoMetafile = __esm({
-  "src/utils/pitonoMetafile.ts"() {
-    "use strict";
-  }
 });
 
 // src/testeranto.ts
 init_utils();
 import ansiC5 from "ansi-colors";
-import fs13 from "fs";
-import path11 from "path";
+import fs17 from "fs";
 import readline from "readline";
 
 // src/utils/buildTemplates.ts
@@ -3887,33 +5189,403 @@ var AppHtml = () => `
 </html>
 `;
 
-// src/web.html.ts
-var web_html_default = (jsfilePath, htmlFilePath, cssfilePath) => `
-<!DOCTYPE html>
-<html lang="en">
+// src/utils/pitonoMetafile.ts
+import fs from "fs";
+import path2 from "path";
+function resolvePythonImport(importPath, currentFile) {
+  if (importPath.startsWith(".")) {
+    const currentDir = path2.dirname(currentFile);
+    let dotCount = 0;
+    let remainingPath = importPath;
+    while (remainingPath.startsWith(".")) {
+      dotCount++;
+      remainingPath = remainingPath.substring(1);
+    }
+    if (remainingPath.startsWith("/")) {
+      remainingPath = remainingPath.substring(1);
+    }
+    let baseDir = currentDir;
+    for (let i = 1; i < dotCount; i++) {
+      baseDir = path2.dirname(baseDir);
+    }
+    if (remainingPath.length === 0) {
+      const initPath = path2.join(baseDir, "__init__.py");
+      if (fs.existsSync(initPath)) {
+        return initPath;
+      }
+      return null;
+    }
+    const resolvedPath = path2.join(baseDir, remainingPath);
+    const extensions = [".py", "/__init__.py"];
+    for (const ext of extensions) {
+      const potentialPath = resolvedPath + ext;
+      if (fs.existsSync(potentialPath)) {
+        return potentialPath;
+      }
+    }
+    if (fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isDirectory()) {
+      const initPath = path2.join(resolvedPath, "__init__.py");
+      if (fs.existsSync(initPath)) {
+        return initPath;
+      }
+    }
+    return null;
+  }
+  const dirs = [
+    path2.dirname(currentFile),
+    process.cwd(),
+    ...process.env.PYTHONPATH ? process.env.PYTHONPATH.split(path2.delimiter) : []
+  ];
+  for (const dir of dirs) {
+    const potentialPaths = [
+      path2.join(dir, importPath + ".py"),
+      path2.join(dir, importPath, "__init__.py"),
+      path2.join(dir, importPath.replace(/\./g, "/") + ".py"),
+      path2.join(dir, importPath.replace(/\./g, "/"), "__init__.py")
+    ];
+    for (const potentialPath of potentialPaths) {
+      if (fs.existsSync(potentialPath)) {
+        return potentialPath;
+      }
+    }
+  }
+  return null;
+}
+function parsePythonImports(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const imports = [];
+    const importRegex = /^import\s+([\w., ]+)/gm;
+    const fromImportRegex = /^from\s+([\w.]+)\s+import/gm;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      const importPaths = match[1].split(",").map((p) => p.trim());
+      for (const importPath of importPaths) {
+        const resolvedPath = resolvePythonImport(importPath, filePath);
+        imports.push({
+          path: importPath,
+          kind: "import-statement",
+          external: resolvedPath === null,
+          original: importPath
+        });
+      }
+    }
+    while ((match = fromImportRegex.exec(content)) !== null) {
+      const importPath = match[1];
+      const resolvedPath = resolvePythonImport(importPath, filePath);
+      imports.push({
+        path: importPath,
+        kind: "import-statement",
+        external: resolvedPath === null,
+        original: importPath
+      });
+    }
+    return imports;
+  } catch (error) {
+    console.warn(`Could not parse imports for ${filePath}:`, error);
+    return [];
+  }
+}
+function collectDependencies(filePath, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(filePath))
+    return [];
+  visited.add(filePath);
+  const dependencies = [filePath];
+  const imports = parsePythonImports(filePath);
+  for (const imp of imports) {
+    if (!imp.external && imp.path) {
+      const resolvedPath = resolvePythonImport(imp.path, filePath);
+      if (resolvedPath && fs.existsSync(resolvedPath)) {
+        dependencies.push(...collectDependencies(resolvedPath, visited));
+      }
+    }
+  }
+  return [...new Set(dependencies)];
+}
+async function generatePitonoMetafile(testName2, entryPoints) {
+  const inputs = {};
+  const outputs = {};
+  const signature = Date.now().toString(36);
+  for (const entryPoint of entryPoints) {
+    if (!fs.existsSync(entryPoint)) {
+      console.warn(`Entry point ${entryPoint} does not exist`);
+      continue;
+    }
+    const allDependencies = collectDependencies(entryPoint);
+    for (const dep of allDependencies) {
+      if (!inputs[dep]) {
+        const bytes = fs.statSync(dep).size;
+        const imports = parsePythonImports(dep);
+        inputs[dep] = {
+          bytes,
+          imports
+        };
+      }
+    }
+    const entryPointName = path2.basename(entryPoint, ".py");
+    const outputKey = `python/core/${entryPointName}.py`;
+    const inputBytes = {};
+    let totalBytes = 0;
+    for (const dep of allDependencies) {
+      const bytes = fs.statSync(dep).size;
+      inputBytes[dep] = { bytesInOutput: bytes };
+      totalBytes += bytes;
+    }
+    outputs[outputKey] = {
+      imports: [],
+      exports: [],
+      entryPoint,
+      inputs: inputBytes,
+      bytes: totalBytes,
+      signature
+    };
+  }
+  if (Object.keys(inputs).length === 0) {
+    inputs["placeholder.py"] = {
+      bytes: 0,
+      imports: []
+    };
+    outputs["testeranto/bundles/python/core/placeholder.py"] = {
+      imports: [],
+      exports: [],
+      entryPoint: "placeholder.py",
+      inputs: {
+        "placeholder.py": {
+          bytesInOutput: 0
+        }
+      },
+      bytes: 0,
+      signature: "placeholder"
+    };
+  }
+  return {
+    errors: [],
+    warnings: [],
+    metafile: {
+      inputs,
+      outputs
+    }
+  };
+}
+function writePitonoMetafile(testName2, metafile) {
+  const projectRoot = process.cwd();
+  const metafilePath = path2.join(
+    projectRoot,
+    "testeranto",
+    "metafiles",
+    "python",
+    "core.json"
+  );
+  const metafileDir = path2.dirname(metafilePath);
+  if (!fs.existsSync(metafileDir)) {
+    fs.mkdirSync(metafileDir, { recursive: true });
+  }
+  fs.writeFileSync(metafilePath, JSON.stringify(metafile, null, 2));
+  const outputDir = path2.join(
+    projectRoot,
+    "testeranto",
+    "bundles",
+    "python",
+    "core"
+  );
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+  for (const [outputPath, outputInfo] of Object.entries(
+    metafile.metafile.outputs
+  )) {
+    const fileName = path2.basename(outputPath);
+    const fullOutputPath = path2.join(outputDir, fileName);
+    const outputDirPath = path2.dirname(fullOutputPath);
+    if (!fs.existsSync(outputDirPath)) {
+      fs.mkdirSync(outputDirPath, { recursive: true });
+    }
+    const entryPoint = outputInfo.entryPoint;
+    const signature = outputInfo.signature;
+    const content = `# This file is auto-generated by testeranto
+# Signature: ${signature}
+# It runs tests from: ${entryPoint}
 
-<head>
-  <script type="module" src="${jsfilePath}"></script>
-  <link rel="stylesheet" href="${cssfilePath}">
-</head>
+import os
+import sys
 
-<body>
-  <div id="root">
-  </div>
-</body>
+# Add the original entry point to the path
+sys.path.insert(0, os.path.dirname(os.path.abspath("${entryPoint}")))
 
-</html>
+# Import and run the tests
+try:
+    # Import the module
+    module_name = os.path.basename("${entryPoint}").replace('.py', '')
+    module = __import__(module_name)
+    
+    # Run the tests if there's a main block
+    if hasattr(module, 'main'):
+        module.main()
+    else:
+        print(f"No main function found in {module_name}")
+except Exception as e:
+    print(f"Error running tests from ${entryPoint}: {e}")
+    sys.exit(1)
 `;
+    fs.writeFileSync(fullOutputPath, content);
+  }
+}
+
+// src/utils/pitonoWatcher.ts
+import chokidar from "chokidar";
+import path3 from "path";
+import fs2 from "fs";
+var PitonoWatcher = class {
+  constructor(testName2, entryPoints) {
+    this.watcher = null;
+    this.onChangeCallback = null;
+    this.testName = testName2;
+    this.entryPoints = entryPoints;
+  }
+  async start() {
+    const pythonFilesPattern = "**/*.py";
+    this.watcher = chokidar.watch(pythonFilesPattern, {
+      persistent: true,
+      ignoreInitial: true,
+      cwd: process.cwd(),
+      ignored: [
+        "**/node_modules/**",
+        "**/.git/**",
+        "**/testeranto/bundles/**",
+        "**/testeranto/reports/**"
+      ],
+      usePolling: true,
+      interval: 1e3,
+      binaryInterval: 1e3,
+      depth: 99,
+      followSymlinks: false,
+      atomic: false
+    });
+    this.watcher.on("add", (filePath) => {
+      this.handleFileChange("add", filePath);
+    }).on("change", (filePath) => {
+      this.handleFileChange("change", filePath);
+    }).on("unlink", (filePath) => {
+      this.handleFileChange("unlink", filePath);
+    }).on("error", (error) => {
+      console.error(`Source watcher error: ${error}`);
+    }).on("ready", () => {
+      console.log(
+        "Initial python source file scan complete. Ready for changes."
+      );
+    });
+    const outputDir = path3.join(
+      process.cwd(),
+      `testeranto/bundles/python/${this.testName}`
+    );
+    if (!fs2.existsSync(outputDir)) {
+      fs2.mkdirSync(outputDir, { recursive: true });
+    }
+    const lastSignatures = /* @__PURE__ */ new Map();
+    const bundleWatcher = chokidar.watch(path3.join(outputDir, "*.py"), {
+      persistent: true,
+      ignoreInitial: false,
+      awaitWriteFinish: {
+        stabilityThreshold: 100,
+        pollInterval: 50
+      }
+    });
+    bundleWatcher.on("add", (filePath) => {
+      this.readAndCheckSignature(filePath, lastSignatures);
+    }).on("change", (filePath) => {
+      this.readAndCheckSignature(filePath, lastSignatures);
+    }).on("error", (error) => console.error(`Bundle watcher error: ${error}`));
+    await this.regenerateMetafile();
+  }
+  async handleFileChange(event, filePath) {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    await this.regenerateMetafile();
+    if (this.onChangeCallback) {
+      this.onChangeCallback();
+    }
+  }
+  readAndCheckSignature(filePath, lastSignatures) {
+    try {
+      const content = fs2.readFileSync(filePath, "utf-8");
+      const signatureMatch = content.match(/# Signature: (\w+)/);
+      if (signatureMatch && signatureMatch[1]) {
+        const currentSignature = signatureMatch[1];
+        const lastSignature = lastSignatures.get(filePath);
+        if (lastSignature === void 0) {
+          lastSignatures.set(filePath, currentSignature);
+        } else if (lastSignature !== currentSignature) {
+          lastSignatures.set(filePath, currentSignature);
+          if (this.onChangeCallback) {
+            this.onChangeCallback();
+          }
+        }
+      }
+    } catch (error) {
+      console.error(`Error reading bundle file ${filePath}:`, error);
+    }
+  }
+  async regenerateMetafile() {
+    try {
+      const metafile = await generatePitonoMetafile(
+        this.testName,
+        this.entryPoints
+      );
+      writePitonoMetafile(this.testName, metafile);
+    } catch (error) {
+      console.error("Error regenerating pitono metafile:", error);
+    }
+  }
+  onMetafileChange(callback) {
+    this.onChangeCallback = callback;
+  }
+  stop() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+  }
+};
+
+// src/PM/pitonoBuild.ts
+var PitonoBuild = class {
+  constructor(config, testName2) {
+    this.watcher = null;
+    this.config = config;
+    this.testName = testName2;
+  }
+  async build() {
+    const pythonTests = this.config.tests.filter((test) => test[1] === "python");
+    const hasPythonTests = pythonTests.length > 0;
+    if (hasPythonTests) {
+      const pythonEntryPoints = pythonTests.map((test) => test[0]);
+      const metafile = await generatePitonoMetafile(this.testName, pythonEntryPoints);
+      writePitonoMetafile(this.testName, metafile);
+      this.watcher = new PitonoWatcher(this.testName, pythonEntryPoints);
+      await this.watcher.start();
+      return pythonEntryPoints;
+    }
+    return [];
+  }
+  async rebuild() {
+    if (this.watcher) {
+      await this.watcher.regenerateMetafile();
+    }
+  }
+  stop() {
+    if (this.watcher) {
+      this.watcher.stop();
+      this.watcher = null;
+    }
+  }
+  onBundleChange(callback) {
+    if (this.watcher) {
+      this.watcher.onMetafileChange(callback);
+    }
+  }
+};
 
 // src/testeranto.ts
-if (!process.env.GITHUB_CLIENT_ID) {
-  console.error(`env var "GITHUB_CLIENT_ID" needs to be set!`);
-  process.exit(-1);
-}
-if (!process.env.GITHUB_CLIENT_SECRET) {
-  console.error(`env var "GITHUB_CLIENT_SECRET" needs to be set!`);
-  process.exit(-1);
-}
+var { GolingvuBuild: GolingvuBuild2 } = await Promise.resolve().then(() => (init_golingvuBuild(), golingvuBuild_exports));
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
   process.stdin.setRawMode(true);
@@ -3923,9 +5595,8 @@ if (mode !== "once" && mode !== "dev") {
   console.error(`The 3rd argument should be 'dev' or 'once', not '${mode}'.`);
   process.exit(-1);
 }
-var f = process.cwd() + "/testeranto.config.ts";
-console.log("config file:", f);
-import(f).then(async (module) => {
+var configFilePath = process.cwd() + "/testeranto.config.ts";
+import(configFilePath).then(async (module) => {
   const pckge = (await import(`${process.cwd()}/package.json`)).default;
   const bigConfig = module.default;
   const project = bigConfig.projects[testName];
@@ -3934,7 +5605,7 @@ import(f).then(async (module) => {
     process.exit(-1);
   }
   try {
-    fs13.writeFileSync(
+    fs17.writeFileSync(
       `${process.cwd()}/testeranto/projects.json`,
       JSON.stringify(Object.keys(bigConfig.projects), null, 2)
     );
@@ -3949,7 +5620,7 @@ import(f).then(async (module) => {
     process.exit(-1);
   }
   if (!rawConfig.tests) {
-    console.error(testName, "appears to have no tests: ", f);
+    console.error(testName, "appears to have no tests: ", configFilePath);
     console.error(`here is the config:`);
     console.log(JSON.stringify(rawConfig));
     process.exit(-1);
@@ -3970,88 +5641,16 @@ import(f).then(async (module) => {
   const { PM_Main: PM_Main2 } = await init_main().then(() => main_exports);
   pm = new PM_Main2(config, testName, mode);
   await pm.start();
-  fs13.writeFileSync(`${process.cwd()}/testeranto/projects.html`, AppHtml());
+  fs17.writeFileSync(`${process.cwd()}/testeranto/projects.html`, AppHtml());
   Object.keys(bigConfig.projects).forEach((projectName) => {
-    console.log(`testeranto/reports/${projectName}`);
-    if (!fs13.existsSync(`testeranto/reports/${projectName}`)) {
-      fs13.mkdirSync(`testeranto/reports/${projectName}`);
+    if (!fs17.existsSync(`testeranto/reports/${projectName}`)) {
+      fs17.mkdirSync(`testeranto/reports/${projectName}`);
     }
-    fs13.writeFileSync(
+    fs17.writeFileSync(
       `testeranto/reports/${projectName}/config.json`,
       JSON.stringify(config, null, 2)
     );
   });
-  const getSecondaryEndpointsPoints = (runtime) => {
-    const meta = (ts2, st) => {
-      ts2.forEach((t) => {
-        if (t[1] === runtime) {
-          st.add(t[0]);
-        }
-        if (Array.isArray(t[3])) {
-          meta(t[3], st);
-        }
-      });
-      return st;
-    };
-    return Array.from(meta(config.tests, /* @__PURE__ */ new Set()));
-  };
-  [...getSecondaryEndpointsPoints("python")].forEach(async (sourceFilePath) => {
-    console.log(`Pitono test found: ${sourceFilePath}`);
-  });
-  const golangTests = config.tests.filter((test) => test[1] === "golang");
-  const hasGolangTests = golangTests.length > 0;
-  if (hasGolangTests) {
-    const { generateGolangMetafile: generateGolangMetafile2, writeGolangMetafile: writeGolangMetafile2 } = await Promise.resolve().then(() => (init_golingvuMetafile(), golingvuMetafile_exports));
-    const golangEntryPoints = golangTests.map((test) => test[0]);
-    const metafile = await generateGolangMetafile2(testName, golangEntryPoints);
-    writeGolangMetafile2(testName, metafile);
-  }
-  const pitonoTests = config.tests.filter((test) => test[1] === "python");
-  const hasPitonoTests = pitonoTests.length > 0;
-  if (hasPitonoTests) {
-    const { generatePitonoMetafile: generatePitonoMetafile2 } = await Promise.resolve().then(() => (init_pitonoMetafile(), pitonoMetafile_exports));
-    const pitonoEntryPoints = pitonoTests.map((test) => test[0]);
-    const metafile = await generatePitonoMetafile2(testName, pitonoEntryPoints);
-    const pitonoMetafilePath = `${process.cwd()}/testeranto/metafiles/python`;
-    await fs13.promises.mkdir(pitonoMetafilePath, { recursive: true });
-    fs13.writeFileSync(
-      `${pitonoMetafilePath}/core.json`,
-      JSON.stringify(metafile, null, 2)
-    );
-    console.log(
-      ansiC5.green(
-        ansiC5.inverse(`Python metafile written to: ${pitonoMetafilePath}/core.json`)
-      )
-    );
-    pitonoEntryPoints.forEach((entryPoint) => {
-      if (pm) {
-        pm.addToQueue(entryPoint, "python");
-      }
-    });
-  }
-  Promise.resolve(
-    Promise.all(
-      [...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
-        const sourceFileSplit = sourceFilePath.split("/");
-        const sourceDir = sourceFileSplit.slice(0, -1);
-        const sourceFileName = sourceFileSplit[sourceFileSplit.length - 1];
-        const sourceFileNameMinusJs = sourceFileName.split(".").slice(0, -1).join(".");
-        const htmlFilePath = path11.normalize(
-          `${process.cwd()}/testeranto/bundles/web/${testName}/${sourceDir.join(
-            "/"
-          )}/${sourceFileNameMinusJs}.html`
-        );
-        const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
-        const cssFilePath = `./${sourceFileNameMinusJs}.css`;
-        return fs13.promises.mkdir(path11.dirname(htmlFilePath), { recursive: true }).then(
-          (x2) => fs13.writeFileSync(
-            htmlFilePath,
-            web_html_default(jsfilePath, htmlFilePath, cssFilePath)
-          )
-        );
-      })
-    )
-  );
   const {
     nodeEntryPoints,
     nodeEntryPointSidecars,
@@ -4060,39 +5659,53 @@ import(f).then(async (module) => {
     pureEntryPoints,
     pureEntryPointSidecars,
     pythonEntryPoints,
-    pythonEntryPointSidecars
+    pythonEntryPointSidecars,
+    golangEntryPoints,
+    golangEntryPointSidecars
   } = getRunnables(config.tests, testName);
-  const x = [
+  console.log("Node entry points:", Object.keys(nodeEntryPoints));
+  console.log("Web entry points:", Object.keys(webEntryPoints));
+  console.log("Pure entry points:", Object.keys(pureEntryPoints));
+  const golangTests = config.tests.filter((test) => test[1] === "golang");
+  const hasGolangTests = golangTests.length > 0;
+  if (hasGolangTests) {
+    const golingvuBuild = new GolingvuBuild2(config, testName);
+    const golangEntryPoints2 = await golingvuBuild.build();
+    golingvuBuild.onBundleChange(() => {
+      Object.keys(golangEntryPoints2).forEach((entryPoint) => {
+        if (pm) {
+          pm.addToQueue(entryPoint, "golang");
+        }
+      });
+    });
+  }
+  const pitonoTests = config.tests.filter((test) => test[1] === "python");
+  const hasPitonoTests = pitonoTests.length > 0;
+  if (hasPitonoTests) {
+    const pitonoBuild = new PitonoBuild(config, testName);
+    const pitonoEntryPoints = await pitonoBuild.build();
+    pitonoBuild.onBundleChange(() => {
+      Object.keys(pitonoEntryPoints).forEach((entryPoint) => {
+        if (pm) {
+          pm.addToQueue(entryPoint, "python");
+        }
+      });
+    });
+  }
+  [
     ["pure", Object.keys(pureEntryPoints)],
     ["node", Object.keys(nodeEntryPoints)],
     ["web", Object.keys(webEntryPoints)],
-    ["python", Object.keys(pythonEntryPoints)]
-  ];
-  x.forEach(async ([runtime, keys]) => {
+    ["python", Object.keys(pythonEntryPoints)],
+    ["golang", Object.keys(golangEntryPoints)]
+  ].forEach(async ([runtime, keys]) => {
     keys.forEach(async (k) => {
-      const folder = `testeranto/reports/${testName}/${k.split(".").slice(0, -1).join(".")}/${runtime}`;
-      await fs13.mkdirSync(folder, { recursive: true });
+      fs17.mkdirSync(
+        `testeranto/reports/${testName}/${k.split(".").slice(0, -1).join(".")}/${runtime}`,
+        { recursive: true }
+      );
     });
   });
-  [
-    [pureEntryPoints, pureEntryPointSidecars, "pure"],
-    [webEntryPoints, webEntryPointSidecars, "web"],
-    [nodeEntryPoints, nodeEntryPointSidecars, "node"],
-    [pythonEntryPoints, pythonEntryPointSidecars, "python"]
-  ].forEach(
-    ([eps, eps2, runtime]) => {
-      [...Object.keys(eps), ...Object.keys(eps2)].forEach((ep) => {
-        const fp = path11.resolve(
-          `testeranto`,
-          `reports`,
-          testName,
-          ep.split(".").slice(0, -1).join("."),
-          runtime
-        );
-        fs13.mkdirSync(fp, { recursive: true });
-      });
-    }
-  );
   process.stdin.on("keypress", (str, key) => {
     if (key.name === "q") {
       console.log("Testeranto is shutting down gracefully...");