testeranto 0.203.0 → 0.205.0

package/src/utils/golingvuWatcher.ts

@@ -1,12 +1,13 @@
 /* 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";
-import path from "path";
-import fs from "fs";
 
 export class GolingvuWatcher {
   private watcher: FSWatcher | null = null;
@@ -69,12 +70,8 @@ export class GolingvuWatcher {
         console.log(
           "Initial golang source file scan complete. Ready for changes."
         );
-        // Log the watched paths for debugging
+
         const watched = this.watcher?.getWatched();
-        console.log(
-          "Number of watched directories:",
-          Object.keys(watched || {}).length
-        );
 
         // If no directories are being watched, let's try a different approach
         if (Object.keys(watched || {}).length === 0) {
@@ -87,7 +84,7 @@ export class GolingvuWatcher {
             const list = fs.readdirSync(dir);
 
             list.forEach((file) => {
-              const filePath = path.join(dir, file);
+              const filePath = path.join(dir, "example", file);
               const stat = fs.statSync(filePath);
 
               if (stat.isDirectory()) {
@@ -108,29 +105,29 @@ export class GolingvuWatcher {
             return results;
           };
 
-          try {
-            const allGoFiles = findAllGoFiles(process.cwd());
-            console.log(`Found ${allGoFiles.length} Go files manually:`);
-            allGoFiles.forEach((file) => console.log(`  ${file}`));
+          // 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);
-          }
+          //   // 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(", ")}`);
-          }
+          // // 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}`);
+        // console.log(`Raw event: ${event} on path: ${path}`);
       });
 
     // Second watcher: watches bundle files in the core directory
@@ -142,11 +139,11 @@ export class GolingvuWatcher {
       "core"
     );
     // Ensure the output directory exists
-    if (!fs.existsSync(outputDir)) {
-      fs.mkdirSync(outputDir, { recursive: true });
-    }
+    // if (!fs.existsSync(outputDir)) {
+    //   fs.mkdirSync(outputDir, { recursive: true });
+    // }
 
-    console.log(`Watching bundle directory: ${outputDir}`);
+    // console.log(`Watching bundle directory: ${outputDir}`);
 
     // Track the last seen signatures to detect changes
     const lastSignatures = new Map<string, string>();
@@ -166,11 +163,9 @@ export class GolingvuWatcher {
 
     bundleWatcher
       .on("add", (filePath) => {
-        // Read the signature when the file is added
         this.readAndCheckSignature(filePath, lastSignatures);
       })
       .on("change", (filePath) => {
-        // Check if the signature has changed when the file is modified
         this.readAndCheckSignature(filePath, lastSignatures);
       })
       .on("error", (error) => console.error(`Bundle watcher error: ${error}`));
@@ -193,14 +188,14 @@ export class GolingvuWatcher {
       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}`);
-        }
-      }
+      // 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();
@@ -251,7 +246,7 @@ export class GolingvuWatcher {
     }
   }
 
-  private async regenerateMetafile() {
+  async regenerateMetafile() {
     console.log("regenerateMetafile!");
 
     try {

package/src/utils/pitonoMetafile.ts

@@ -32,232 +32,230 @@ export interface PitonoMetafile {
   };
 }
 
-function resolvePythonImport(importPath: string, currentFile: string): string | null {
-    // Handle relative imports
-    if (importPath.startsWith('.')) {
-        const currentDir = path.dirname(currentFile);
-        // For relative imports, we need to handle the dots properly
-        // Count the number of dots to determine how many levels to go up
-        let dotCount = 0;
-        let remainingPath = importPath;
-        while (remainingPath.startsWith('.')) {
-            dotCount++;
-            remainingPath = remainingPath.substring(1);
-        }
-        
-        // Remove any leading slash
-        if (remainingPath.startsWith('/')) {
-            remainingPath = remainingPath.substring(1);
-        }
-        
-        // Build the base path by going up the appropriate number of directories
-        let baseDir = currentDir;
-        for (let i = 1; i < dotCount; i++) {
-            baseDir = path.dirname(baseDir);
-        }
-        
-        // Handle the case where there's no remaining path (just dots)
-        if (remainingPath.length === 0) {
-            const initPath = path.join(baseDir, '__init__.py');
-            if (fs.existsSync(initPath)) {
-                return initPath;
-            }
-            return null;
-        }
-        
-        // Resolve the full path
-        const resolvedPath = path.join(baseDir, remainingPath);
-        
-        // Try different extensions
-        const extensions = ['.py', '/__init__.py'];
-        for (const ext of extensions) {
-            const potentialPath = resolvedPath + ext;
-            if (fs.existsSync(potentialPath)) {
-                return potentialPath;
-            }
-        }
-        
-        // Check if it's a directory with __init__.py
-        if (fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isDirectory()) {
-            const initPath = path.join(resolvedPath, '__init__.py');
-            if (fs.existsSync(initPath)) {
-                return initPath;
-            }
-        }
-        return null;
+function resolvePythonImport(
+  importPath: string,
+  currentFile: string
+): string | null {
+  // Handle relative imports
+  if (importPath.startsWith(".")) {
+    const currentDir = path.dirname(currentFile);
+    // For relative imports, we need to handle the dots properly
+    // Count the number of dots to determine how many levels to go up
+    let dotCount = 0;
+    let remainingPath = importPath;
+    while (remainingPath.startsWith(".")) {
+      dotCount++;
+      remainingPath = remainingPath.substring(1);
     }
-    
-    // Handle absolute imports by looking in the same directory and parent directories
-    // This is a simplification - Python's import system is more complex
-    const dirs = [
-        path.dirname(currentFile),
-        process.cwd(),
-        ...(process.env.PYTHONPATH ? process.env.PYTHONPATH.split(path.delimiter) : [])
-    ];
-    
-    for (const dir of dirs) {
-        const potentialPaths = [
-            path.join(dir, importPath + '.py'),
-            path.join(dir, importPath, '__init__.py'),
-            path.join(dir, importPath.replace(/\./g, '/') + '.py'),
-            path.join(dir, importPath.replace(/\./g, '/'), '__init__.py')
-        ];
-        
-        for (const potentialPath of potentialPaths) {
-            if (fs.existsSync(potentialPath)) {
-                return potentialPath;
-            }
-        }
+
+    // Remove any leading slash
+    if (remainingPath.startsWith("/")) {
+      remainingPath = remainingPath.substring(1);
+    }
+
+    // Build the base path by going up the appropriate number of directories
+    let baseDir = currentDir;
+    for (let i = 1; i < dotCount; i++) {
+      baseDir = path.dirname(baseDir);
+    }
+
+    // Handle the case where there's no remaining path (just dots)
+    if (remainingPath.length === 0) {
+      const initPath = path.join(baseDir, "__init__.py");
+      if (fs.existsSync(initPath)) {
+        return initPath;
+      }
+      return null;
+    }
+
+    // Resolve the full path
+    const resolvedPath = path.join(baseDir, remainingPath);
+
+    // Try different extensions
+    const extensions = [".py", "/__init__.py"];
+    for (const ext of extensions) {
+      const potentialPath = resolvedPath + ext;
+      if (fs.existsSync(potentialPath)) {
+        return potentialPath;
+      }
+    }
+
+    // Check if it's a directory with __init__.py
+    if (
+      fs.existsSync(resolvedPath) &&
+      fs.statSync(resolvedPath).isDirectory()
+    ) {
+      const initPath = path.join(resolvedPath, "__init__.py");
+      if (fs.existsSync(initPath)) {
+        return initPath;
+      }
     }
-    
     return null;
+  }
+
+  // Handle absolute imports by looking in the same directory and parent directories
+  // This is a simplification - Python's import system is more complex
+  const dirs = [
+    path.dirname(currentFile),
+    process.cwd(),
+    ...(process.env.PYTHONPATH
+      ? process.env.PYTHONPATH.split(path.delimiter)
+      : []),
+  ];
+
+  for (const dir of dirs) {
+    const potentialPaths = [
+      path.join(dir, importPath + ".py"),
+      path.join(dir, importPath, "__init__.py"),
+      path.join(dir, importPath.replace(/\./g, "/") + ".py"),
+      path.join(dir, importPath.replace(/\./g, "/"), "__init__.py"),
+    ];
+
+    for (const potentialPath of potentialPaths) {
+      if (fs.existsSync(potentialPath)) {
+        return potentialPath;
+      }
+    }
+  }
+
+  return null;
 }
 
-function parsePythonImports(filePath: string): {path: string, kind: string, external?: boolean, original?: string}[] {
-    try {
-        const content = fs.readFileSync(filePath, 'utf-8');
-        const imports: {path: string, kind: string, external?: boolean, original?: string}[] = [];
-        
-        // Match import statements (including multiple imports)
-        const importRegex = /^import\s+([\w., ]+)/gm;
-        // Match from ... import statements
-        const fromImportRegex = /^from\s+([\w.]+)\s+import/gm;
-        
-        let match;
-        while ((match = importRegex.exec(content)) !== null) {
-            // Handle multiple imports in one line
-            const importPaths = match[1].split(',').map(p => p.trim());
-            for (const importPath of importPaths) {
-                // Try to resolve the import to see if it's external
-                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];
-            // Try to resolve the import to see if it's external
-            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 parsePythonImports(
+  filePath: string
+): { path: string; kind: string; external?: boolean; original?: string }[] {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const imports: {
+      path: string;
+      kind: string;
+      external?: boolean;
+      original?: string;
+    }[] = [];
+
+    // Match import statements (including multiple imports)
+    const importRegex = /^import\s+([\w., ]+)/gm;
+    // Match from ... import statements
+    const fromImportRegex = /^from\s+([\w.]+)\s+import/gm;
+
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      // Handle multiple imports in one line
+      const importPaths = match[1].split(",").map((p) => p.trim());
+      for (const importPath of importPaths) {
+        // Try to resolve the import to see if it's external
+        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];
+      // Try to resolve the import to see if it's external
+      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: string, visited: Set<string> = new Set()): string[] {
-    if (visited.has(filePath)) return [];
-    visited.add(filePath);
-    
-    const dependencies: string[] = [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));
-            }
-        }
+function collectDependencies(
+  filePath: string,
+  visited: Set<string> = new Set()
+): string[] {
+  if (visited.has(filePath)) return [];
+  visited.add(filePath);
+
+  const dependencies: string[] = [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)];
+  }
+
+  return [...new Set(dependencies)];
 }
 
 export async function generatePitonoMetafile(
-    testName: string,
-    entryPoints: string[]
+  testName: string,
+  entryPoints: string[]
 ): Promise<PitonoMetafile> {
-    const inputs: Record<string, any> = {};
-    const outputs: Record<string, any> = {};
-    const signature = Date.now().toString(36);
-
-    // Process each entry point
-    for (const entryPoint of entryPoints) {
-        if (!fs.existsSync(entryPoint)) {
-            console.warn(`Entry point ${entryPoint} does not exist`);
-            continue;
-        }
-
-        // Collect all dependencies recursively
-        const allDependencies = collectDependencies(entryPoint);
-        
-        // Process each dependency to add to inputs
-        for (const dep of allDependencies) {
-            if (!inputs[dep]) {
-                const bytes = fs.statSync(dep).size;
-                const imports = parsePythonImports(dep);
-                inputs[dep] = {
-                    bytes,
-                    imports,
-                };
-            }
-        }
-
-        // Generate output path
-        const entryPointName = path.basename(entryPoint, ".py");
-        const outputKey = `python/core/${entryPointName}.py`;
-        
-        // Calculate total bytes from all inputs
-        const inputBytes: Record<string, { bytesInOutput: number }> = {};
-        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,
-        };
+  const inputs: Record<string, any> = {};
+  const outputs: Record<string, any> = {};
+  const signature = Date.now().toString(36);
+
+  // Process each entry point
+  for (const entryPoint of entryPoints) {
+    if (!fs.existsSync(entryPoint)) {
+      console.warn(`Entry point ${entryPoint} does not exist`);
+      continue;
     }
 
-    // If no valid entry points were found, add a placeholder
-    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",
+    // Collect all dependencies recursively
+    const allDependencies = collectDependencies(entryPoint);
+
+    // Process each dependency to add to inputs
+    for (const dep of allDependencies) {
+      if (!inputs[dep]) {
+        const bytes = fs.statSync(dep).size;
+        const imports = parsePythonImports(dep);
+        inputs[dep] = {
+          bytes,
+          imports,
         };
+      }
     }
 
-    return {
-        errors: [],
-        warnings: [],
-        metafile: {
-            inputs,
-            outputs,
-        },
+    // Generate output path
+    const entryPointName = path.basename(entryPoint, ".py");
+    const outputKey = `python/core/${entryPointName}.py`;
+
+    // Calculate total bytes from all inputs
+    const inputBytes: Record<string, { bytesInOutput: number }> = {};
+    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,
     };
+  }
+
+  return {
+    errors: [],
+    warnings: [],
+    metafile: {
+      inputs,
+      outputs,
+    },
+  };
 }
 
 export function writePitonoMetafile(

package/src/utils/pitonoWatcher.ts

@@ -1,10 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import chokidar from "chokidar";
 import type { FSWatcher } from "chokidar";
-import {
-  generatePitonoMetafile,
-  writePitonoMetafile,
-} from "./pitonoMetafile";
+import { generatePitonoMetafile, writePitonoMetafile } from "./pitonoMetafile";
 import path from "path";
 import fs from "fs";
 
@@ -66,10 +63,6 @@ export class PitonoWatcher {
       process.cwd(),
       `testeranto/bundles/python/${this.testName}`
     );
-    // Ensure the output directory exists
-    if (!fs.existsSync(outputDir)) {
-      fs.mkdirSync(outputDir, { recursive: true });
-    }
 
     // Track the last seen signatures to detect changes
     const lastSignatures = new Map<string, string>();
@@ -132,7 +125,7 @@ export class PitonoWatcher {
     }
   }
 
-  private async regenerateMetafile() {
+  async regenerateMetafile() {
     try {
       const metafile = await generatePitonoMetafile(
         this.testName,