testeranto 0.202.0 → 0.205.0

package/src/utils/golingvuMetafile.ts

@@ -1,165 +1,8 @@
-import { execSync } from "child_process";
-import fs from "fs";
-import path from "path";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 
-export interface GolingvuBuildResult {
-  errors: any[];
-  warnings: any[];
-  metafile?: {
-    inputs: Record<string, {
-      bytes: number;
-      imports: any[];
-    }>;
-    outputs: Record<
-      string,
-      {
-        bytes: number;
-        inputs: Record<string, { bytesInOutput: number }>;
-        entryPoint: string;
-      }
-    >;
-  };
-}
+import { generateGolingvuMetafile as gmf } from "./generateGolingvuMetafile";
+import { writeGolingvuMetafile as wgmf } from "./writeGolingvuMetafile";
 
-export async function generateGolangMetafile(testName: string, entryPoints: string[]): Promise<GolingvuBuildResult> {
-  const outputs: Record<
-    string,
-    {
-      entryPoint: string;
-      inputs: Record<string, { bytesInOutput: number }>;
-      bytes: number;
-    }
-  > = {};
-
-  // Process each Go entry point
-  for (const entryPoint of entryPoints) {
-    try {
-      // Get the package directory to find all Go files in the same package
-      const entryDir = path.dirname(entryPoint);
-      
-      // Find all .go files in the same directory
-      const goFiles = fs.readdirSync(entryDir)
-        .filter(file => file.endsWith('.go'))
-        .map(file => path.join(entryDir, file));
-      
-      // Create inputs record
-      const inputs: Record<string, { bytesInOutput: number }> = {};
-      let totalBytes = 0;
-      
-      for (const file of goFiles) {
-        try {
-          const stats = fs.statSync(file);
-          inputs[file] = { bytesInOutput: stats.size };
-          totalBytes += stats.size;
-        } catch {
-          inputs[file] = { bytesInOutput: 0 };
-        }
-      }
-      
-      // Add the entry point itself if not already included
-      if (!inputs[entryPoint]) {
-        try {
-          const entryStats = fs.statSync(entryPoint);
-          inputs[entryPoint] = { bytesInOutput: entryStats.size };
-          totalBytes += entryStats.size;
-        } catch {
-          inputs[entryPoint] = { bytesInOutput: 0 };
-        }
-      }
-
-      // The output path should match the Node.js structure - use a path in testeranto/bundles
-      // For Go, we don't have actual bundled outputs, so we'll use a placeholder
-      const outputPath = `testeranto/bundles/golang/${testName}/${entryPoint}`;
-      outputs[outputPath] = {
-        entryPoint: entryPoint, // Use the source file path, not the bundle path
-        inputs,
-        bytes: totalBytes
-      };
-    } catch (error) {
-      console.error(`Error processing Go entry point ${entryPoint}:`, error);
-    }
-  }
-
-  // Create inputs record for the metafile - include all Go files
-  const allInputs: Record<string, {
-    bytes: number;
-    imports: any[];
-  }> = {};
-  
-  // Collect all unique Go files from all entry points
-  const allGoFiles = new Set<string>();
-  
-  for (const entryPoint of entryPoints) {
-    try {
-      const entryDir = path.dirname(entryPoint);
-      
-      // Find all .go files in the same directory
-      const goFiles = fs.readdirSync(entryDir)
-        .filter(file => file.endsWith('.go'))
-        .map(file => path.join(entryDir, file));
-      
-      goFiles.forEach(file => allGoFiles.add(file));
-      
-      // Add the entry point itself
-      allGoFiles.add(entryPoint);
-    } catch (error) {
-      console.error(`Error processing Go entry point ${entryPoint} for source files:`, error);
-    }
-  }
-
-  // Add all Go files to inputs
-  for (const filePath of Array.from(allGoFiles)) {
-    try {
-      const stats = fs.statSync(filePath);
-      allInputs[filePath] = { 
-        bytes: stats.size,
-        imports: [] // Go files don't have imports like JS
-      };
-    } catch {
-      allInputs[filePath] = { 
-        bytes: 0,
-        imports: []
-      };
-    }
-  }
-  
-  // Reformat outputs to match esbuild structure
-  const esbuildOutputs: Record<string, {
-    bytes: number;
-    inputs: Record<string, { bytesInOutput: number }>;
-    entryPoint: string;
-  }> = {};
-  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
-    }
-  };
-}
-
-
-export function writeGolangMetafile(
-  testName: string,
-  metafile: GolingvuBuildResult
-): void {
-  const metafileDir = path.join(
-    process.cwd(),
-    "testeranto",
-    "metafiles",
-    "golang"
-  );
-  fs.mkdirSync(metafileDir, { recursive: true });
-
-  const metafilePath = path.join(metafileDir, `${testName}.json`);
-  fs.writeFileSync(metafilePath, JSON.stringify(metafile, null, 2));
-}
+export const generateGolingvuMetafile = gmf;
+export const writeGolingvuMetafile = wgmf;

package/src/utils/golingvuWatcher.ts

@@ -0,0 +1,280 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import path from "path";
+import fs from "fs";
+import chokidar from "chokidar";
+import type { FSWatcher } from "chokidar";
+
+import {
+  generateGolingvuMetafile,
+  writeGolingvuMetafile,
+} from "./golingvuMetafile";
+
+export class GolingvuWatcher {
+  private watcher: FSWatcher | null = null;
+  private testName: string;
+  private entryPoints: string[];
+  private onChangeCallback: (() => void) | null = null;
+  private debounceTimer: NodeJS.Timeout | null = null;
+
+  constructor(testName: string, entryPoints: string[]) {
+    this.testName = testName;
+    this.entryPoints = entryPoints;
+  }
+
+  async start() {
+    // Watch source Go files to trigger metafile regeneration
+    const goFilesPattern = "**/*.go";
+
+    this.watcher = chokidar.watch(goFilesPattern, {
+      persistent: true,
+      ignoreInitial: true,
+      cwd: process.cwd(),
+      ignored: [
+        "**/node_modules/**",
+        "**/.git/**",
+        "**/testeranto/bundles/**",
+        "**/testeranto/reports/**",
+      ],
+      usePolling: true,
+      interval: 1000,
+      binaryInterval: 1000,
+      depth: 99,
+      followSymlinks: false,
+      atomic: false,
+    });
+
+    // Add event listeners for source file changes with more detailed logging
+    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();
+
+        // If no directories are being watched, let's try a different approach
+        if (Object.keys(watched || {}).length === 0) {
+          console.error("WARNING: No directories are being watched!");
+          console.error("Trying to manually find and watch .go files...");
+
+          // Manually find all .go files and add them to the watcher
+          const findAllGoFiles = (dir: string): string[] => {
+            let results: string[] = [];
+            const list = fs.readdirSync(dir);
+
+            list.forEach((file) => {
+              const filePath = path.join(dir, "example", file);
+              const stat = fs.statSync(filePath);
+
+              if (stat.isDirectory()) {
+                // Skip ignored directories
+                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}`));
+
+          //   // Add these files to the watcher
+          //   allGoFiles.forEach((file) => {
+          //     this.watcher?.add(file);
+          //   });
+          // } catch (error) {
+          //   console.error("Error manually finding Go files:", error);
+          // }
+        } else {
+          // // Log each directory and its files
+          // for (const [dir, files] of Object.entries(watched || {})) {
+          //   console.log(`Directory: ${dir}`);
+          //   console.log(`Files: ${(files as string[]).join(", ")}`);
+          // }
+        }
+      })
+      .on("raw", (event, path, details) => {
+        // This can help debug what events are being emitted
+        // console.log(`Raw event: ${event} on path: ${path}`);
+      });
+
+    // Second watcher: watches bundle files in the core directory
+    const outputDir = path.join(
+      process.cwd(),
+      "testeranto",
+      "bundles",
+      "golang",
+      "core"
+    );
+    // Ensure the output directory exists
+    // if (!fs.existsSync(outputDir)) {
+    //   fs.mkdirSync(outputDir, { recursive: true });
+    // }
+
+    // console.log(`Watching bundle directory: ${outputDir}`);
+
+    // Track the last seen signatures to detect changes
+    const lastSignatures = new Map<string, string>();
+
+    // Create a separate watcher for bundle files, including .golingvu.go files
+    const bundleWatcher = chokidar.watch(
+      [path.join(outputDir, "*.go"), path.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}`));
+
+    // Initial metafile generation
+    await this.regenerateMetafile();
+  }
+
+  private async handleFileChange(event: string, filePath: string) {
+    // Debounce file changes to prevent multiple rapid triggers
+    // Use a simple timeout-based debounce
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+
+    this.debounceTimer = setTimeout(async () => {
+      const fullPath = path.join(process.cwd(), filePath);
+
+      // Add a small delay to ensure the file is fully written
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      // Check if the file exists and log its stats
+      // if (fs.existsSync(fullPath)) {
+      //   try {
+      //     const stats = fs.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); // 300ms debounce
+  }
+
+  private readAndCheckSignature(
+    filePath: string,
+    lastSignatures: Map<string, string>
+  ) {
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      // Extract the signature from the comment
+      const signatureMatch = content.match(/\/\/ Signature: (\w+)/);
+      if (signatureMatch && signatureMatch[1]) {
+        const currentSignature = signatureMatch[1];
+        const lastSignature = lastSignatures.get(filePath);
+
+        if (lastSignature === undefined) {
+          // First time seeing this file, just record the signature
+          lastSignatures.set(filePath, currentSignature);
+        } else if (lastSignature !== currentSignature) {
+          // Signature changed, trigger test scheduling
+          lastSignatures.set(filePath, currentSignature);
+
+          // Find which entry point this corresponds to
+          // Handle .golingvu.go files by mapping back to the original .go file
+          const fileName = path.basename(filePath);
+          // Remove .golingvu from the filename to find the original entry point
+          const originalFileName = fileName.replace(".golingvu.go", ".go");
+
+          const originalEntryPoint = this.entryPoints.find(
+            (ep) => path.basename(ep) === originalFileName
+          );
+          if (originalEntryPoint) {
+            // Add to processing queue
+            if (this.onChangeCallback) {
+              this.onChangeCallback();
+            }
+          }
+        }
+      }
+    } catch (error) {
+      console.error(`Error reading bundle file ${filePath}:`, error);
+    }
+  }
+
+  async regenerateMetafile() {
+    console.log("regenerateMetafile!");
+
+    try {
+      // console.log("Regenerating golingvu metafile...");
+      // Always regenerate using the original entry points
+      const metafile = await generateGolingvuMetafile(
+        this.testName,
+        this.entryPoints
+      );
+      writeGolingvuMetafile(this.testName, metafile);
+      // console.log("Golingvu metafile regenerated due to Go file changes");
+    } catch (error) {
+      console.error("Error regenerating golingvu metafile:", error);
+    }
+  }
+
+  onMetafileChange(callback: () => void) {
+    this.onChangeCallback = callback;
+  }
+
+  stop() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+  }
+}

package/src/utils/logFiles.ts

@@ -1,4 +1,4 @@
-export type RuntimeName = 'node' | 'web' | 'pure';
+export type RuntimeName = 'node' | 'web' | 'pure' | 'python' | 'golang';
 
 export const LOG_FILES = {
   TESTS: 'tests.json',
@@ -36,7 +36,15 @@ export const RUNTIME_SPECIFIC_LOGS = {
     WARN: 'warn.log',
     DEBUG: 'debug.log'
   },
-  pure: {} // No runtime-specific logs for pure
+  pure: {}, // No runtime-specific logs for pure
+  python: {
+    STDOUT: 'stdout.log',
+    STDERR: 'stderr.log'
+  },
+  golang: {
+    STDOUT: 'stdout.log',
+    STDERR: 'stderr.log'
+  }
 } as const;
 
 export const ALL_LOGS = {