testeranto 0.199.0 → 0.200.0

package/src/templates/frontpage.html

@@ -54,17 +54,18 @@
   <section class="snap-section min-vh-100 d-flex align-items-center" style="
       background: linear-gradient(
           135deg,
-          rgba(66, 85, 197, 0.9) 0%,
-          rgba(105, 4, 106, 0.9) 100%
+          #220022 0%,
+          #440044 50%,
+          #220022 100%
         ),
         radial-gradient(
           circle at 30% 30%,
-          rgba(66, 85, 197, 0.2) 0%,
+          rgba(68, 0, 68, 0.3) 0%,
           transparent 50%
         ),
         radial-gradient(
           circle at 70% 70%,
-          rgba(105, 4, 106, 0.2) 0%,
+          rgba(34, 0, 34, 0.3) 0%,
           transparent 50%
         );
       color: var(--dark-vibrant-text);
@@ -302,30 +303,38 @@
 
   <!-- Demo Section -->
   <section class="snap-section d-flex align-items-center justify-content-center min-vh-100" style="
-      background: linear-gradient(0deg, #000 0%, #222 50%, #000 100%);
-      animation: vibrantPulse 8s ease infinite;
+      background: linear-gradient(135deg, #000022 0%, #220033 50%, #000022 100%),
+                  radial-gradient(circle at 20% 30%, rgba(34, 0, 51, 0.3) 0%, transparent 50%),
+                  radial-gradient(circle at 80% 70%, rgba(0, 0, 34, 0.3) 0%, transparent 50%);
+      background-size: 200% 200%, cover, cover;
       color: #fff;
       text-shadow: 0 2px 4px rgba(0, 0, 0, 0.5);
+      animation: vibrantPulse 8s ease infinite;
     ">
     <div class="container text-center">
       <h2 class="display-4 mb-4">A demo is worth a thousand tokens.</h2>
       <h2 class="mb-5">
         <a href="/testeranto/projects.html#/projects/core/tests/src%2Fcomponents%2Fpure%2FProjectPageView.test%2Findex.tsx/web"
-          style="">See it for yourself</a>
+          style="color: #fff;">See it for yourself</a>
       </h2>
     </div>
   </section>
 
   <!-- Beta Program Section -->
-  <!-- <section class="snap-section d-flex align-items-center justify-content-center min-vh-100" style="background: white;
-
-      color: #fff; 
-      text-shadow: 0 2px 4px rgba(0,0,0,0.5);">
+  <section class="snap-section d-flex align-items-center justify-content-center min-vh-100" style="
+      background: linear-gradient(135deg, #001100 0%, #003322 50%, #001100 100%),
+                  radial-gradient(circle at 30% 30%, rgba(0, 51, 34, 0.3) 0%, transparent 50%),
+                  radial-gradient(circle at 70% 70%, rgba(0, 17, 0, 0.3) 0%, transparent 50%);
+      background-size: 200% 200%, cover, cover;
+      color: #fff;
+      text-shadow: 0 2px 4px rgba(0, 0, 0, 0.5);
+      animation: gradientFlow 15s ease infinite;
+    ">
     <div class="container text-center">
-      <h2 class="display-4 mb-4">A demo is worth a thousand tokens.</h2>
-      <p class="lead mb-5">See testeranto in action <a
-          href="/testeranto/projects.html#/projects/core/tests/src%2Fcomponents%2Fpure%2FProjectPageView.test%2Findex.tsx/web"
-          style="color: #fff;">here</a></p>
+      <h2 class="display-4 mb-4">Join the Beta Program</h2>
+      <p class="lead mb-5">Be among the first to experience Testeranto's full potential. <a
+          href="#beta-signup"
+          style="color: #fff;">Sign up now</a></p>
     </div>
-  </section> -->
-</div>
+  </section>
+</div>

package/src/{build.ts → testeranto.ts}

@@ -15,19 +15,24 @@ import esbuildNodeConfiger from "./esbuildConfigs/node";
 import esbuildWebConfiger from "./esbuildConfigs/web";
 import esbuildImportConfiger from "./esbuildConfigs/pure";
 import webHtmlFrame from "./web.html";
+import { PM_Main } from "./PM/main";
 
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY) process.stdin.setRawMode(true);
 
 const testName = process.argv[2];
 
-let mode = process.argv[3] as "once" | "dev";
+const mode = process.argv[3] as "once" | "dev";
 if (mode !== "once" && mode !== "dev") {
-  console.error(`The 4th argument should be 'dev' or 'once', not '${mode}'.`);
+  console.error(`The 3rd argument should be 'dev' or 'once', not '${mode}'.`);
   process.exit(-1);
 }
 
-import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
+const f = process.cwd() + "/" + "testeranto.config.ts";
+
+console.log("config file:", f);
+
+import(f).then(async (module) => {
   const pckge = (await import(`${process.cwd()}/package.json`)).default;
   const bigConfig: IProject = module.default;
 
@@ -44,64 +49,39 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
 
   const rawConfig: ITestconfig = bigConfig.projects[testName];
 
-  const getSecondaryEndpointsPoints = (runtime?: IRunTime): string[] => {
-    const meta = (ts: ITestTypes[], st: Set<string>): Set<string> => {
-      ts.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, new Set()));
-  };
+  if (!rawConfig) {
+    console.error(`Project "${testName}" does not exist in the configuration.`);
+    console.error("Available projects:", Object.keys(bigConfig.projects));
+    process.exit(-1);
+  }
 
-  // const getSideCars = (runtime?: IRunTime): string[] => {
-  //   return Array.from(
-  //     new Set(
-  //       config.tests
-  //         .reduce((mm, t) => {
-  //           mm = mm.concat(t[3]);
-  //           return mm;
-  //         }, [] as ITestTypes[])
-  //         .filter((t) => {
-  //           return t[1] === runtime;
-  //         })
-  //         .map((t) => {
-  //           return t[0];
-  //         })
-  //     )
-  //   );
-  // };
+  if (!rawConfig.tests) {
+    console.error(testName, "appears to have no tests: ", f);
+    console.error(`here is the config:`);
+    console.log(JSON.stringify(rawConfig));
+    process.exit(-1);
+  }
 
   const config: IBuiltConfig = {
     ...rawConfig,
     buildDir: process.cwd() + "/testeranto/bundles/" + testName,
   };
 
-  console.log(
-    `Press 'q' to shutdown gracefully. Press 'x' to shutdown forcefully.`
-  );
+  console.log(ansiC.inverse("Press 'q' to initiate a graceful shutdown."));
+  console.log(ansiC.inverse("Press 'x' to quit forcefully."));
+
   process.stdin.on("keypress", (str, key) => {
-    if (key.name === "q") {
-      console.log("Testeranto-Build is shutting down...");
-      mode = "once";
-      onDone();
-    } else if (key.name === "x") {
-      console.log("Testeranto-Build is shutting down forcefully...");
+    if (key.name === "x") {
+      console.log(ansiC.inverse("Shutting down forcefully..."));
       process.exit(-1);
-    } else {
-      console.log(
-        `Press 'q' to shutdown gracefully. Press 'x' to shutdown forcefully.`
-      );
     }
   });
+
   let nodeDone: boolean = false;
   let webDone: boolean = false;
   let importDone: boolean = false;
+  let golangDone: boolean = false;
+  let pitonoDone: boolean = false;
 
   let status: "build" | "built" = "build";
 
@@ -129,17 +109,45 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
     onDone();
   };
 
+  const onGolangDone = () => {
+    golangDone = true;
+    onDone();
+  };
+
+  const onPitonoDone = () => {
+    pitonoDone = true;
+    onDone();
+  };
+
+  let pm: PM_Main | null = null;
   const onDone = async () => {
-    if (nodeDone && webDone && importDone) {
+    // Check which test types are present
+    const hasGolangTests = config.tests.some(test => test[1] === 'golang');
+    const hasPitonoTests = config.tests.some(test => test[1] === 'pitono');
+    
+    // Wait for all relevant runtimes to be done
+    const allDone = 
+      nodeDone && webDone && importDone && 
+      (!hasGolangTests || golangDone) && 
+      (!hasPitonoTests || pitonoDone);
+      
+    if (allDone) {
       status = "built";
+
+      // Start the PM_Main to run the tests after build
+      if (!pm) {
+        const { PM_Main } = await import("./PM/main");
+        pm = new PM_Main(config, testName, mode);
+        await pm.start();
+      }
     }
-    if (nodeDone && webDone && importDone && mode === "once") {
+    if (allDone && mode === "once") {
       console.log(
         ansiC.inverse(
           `${testName} was built and the builder exited successfully.`
         )
       );
-      process.exit();
+      // Let PM_Main handle the exit after tests are complete
     }
   };
 
@@ -157,6 +165,65 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
     );
   });
 
+  const getSecondaryEndpointsPoints = (runtime?: IRunTime): string[] => {
+    const meta = (ts: ITestTypes[], st: Set<string>): Set<string> => {
+      ts.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, new Set()));
+  };
+
+  // Also handle pitono endpoints for HTML generation if needed
+  [...getSecondaryEndpointsPoints("pitono")].forEach(async (sourceFilePath) => {
+    // You might want to generate specific files for pitono tests here
+    console.log(`Pitono test found: ${sourceFilePath}`);
+  });
+
+  // Handle golang tests by generating their metafiles
+  const golangTests = config.tests.filter(test => test[1] === 'golang');
+  const hasGolangTests = golangTests.length > 0;
+  if (hasGolangTests) {
+    // Import and use the golang metafile utilities
+    const { generateGolangMetafile, writeGolangMetafile } = await import('./utils/golingvuMetafile');
+    // Get the entry points (first element of each test tuple)
+    const golangEntryPoints = golangTests.map(test => test[0]);
+    const metafile = await generateGolangMetafile(testName, golangEntryPoints);
+    writeGolangMetafile(testName, metafile);
+    // Mark golang as done after writing the metafile
+    onGolangDone();
+  }
+
+  // Handle pitono (Python) tests by generating their metafiles
+  const pitonoTests = config.tests.filter(test => test[1] === 'pitono');
+  const hasPitonoTests = pitonoTests.length > 0;
+  if (hasPitonoTests) {
+    // Import and use the pitono metafile utilities
+    const { generatePitonoMetafile } = await import('./utils/pitonoMetafile');
+    // Get the entry points (first element of each test tuple)
+    const pitonoEntryPoints = pitonoTests.map(test => test[0]);
+    const metafile = await generatePitonoMetafile(testName, pitonoEntryPoints);
+    
+    // Ensure the directory exists
+    const pitonoMetafilePath = `${process.cwd()}/testeranto/metafiles/python`;
+    await fs.promises.mkdir(pitonoMetafilePath, { recursive: true });
+    
+    // Write the metafile to the specified path
+    fs.writeFileSync(
+      `${pitonoMetafilePath}/core.json`,
+      JSON.stringify(metafile, null, 2)
+    );
+    
+    // Mark pitono as done after writing the metafile
+    onPitonoDone();
+  }
+
   Promise.resolve(
     Promise.all(
       [...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
@@ -188,14 +255,6 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
     )
   );
 
-  // glob(`${process.cwd()}/testeranto/bundles/${testName}/chunk-*.mjs`, {
-  //   ignore: "node_modules/**",
-  // }).then((chunks) => {
-  //   chunks.forEach((chunk) => {
-  //     fs.unlinkSync(chunk);
-  //   });
-  // });
-
   const x: [IRunTime, string[]][] = [
     ["pure", Object.keys(pureEntryPoints)],
     ["node", Object.keys(nodeEntryPoints)],
@@ -282,4 +341,15 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
         });
     }),
   ]);
+
+  process.stdin.on("keypress", (str, key) => {
+    if (key.name === "q") {
+      console.log("Testeranto is shutting down gracefully...");
+      if (pm) {
+        pm.stop();
+      } else {
+        process.exit();
+      }
+    }
+  });
 });

package/src/utils/golingvuMetafile.ts

@@ -0,0 +1,165 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+
+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;
+      }
+    >;
+  };
+}
+
+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));
+}

package/src/utils/logFiles.ts

@@ -21,7 +21,8 @@ export const STANDARD_LOGS = {
   LINT_ERRORS: 'lint_errors.txt',
   EXIT: 'exit.log',
   MESSAGE: 'message.txt',
-  PROMPT: 'prompt.txt'
+  PROMPT: 'prompt.txt',
+  BUILD: 'build.json'
 } as const;
 
 export const RUNTIME_SPECIFIC_LOGS = {

package/src/utils/pitonoMetafile.ts

@@ -0,0 +1,68 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+
+export interface PitonoMetafile {
+    testName: string;
+    entryPoints: string[];
+    timestamp: number;
+}
+
+export async function generatePitonoMetafile(testName: string, entryPoints: string[]): Promise<PitonoMetafile> {
+    return {
+        testName,
+        entryPoints,
+        timestamp: Date.now()
+    };
+}
+
+export function writePitonoMetafile(testName: string, metafile: PitonoMetafile): void {
+    const metafilePath = path.join(process.cwd(), 'testeranto', 'pitono', testName, 'metafile.json');
+    const metafileDir = path.dirname(metafilePath);
+    
+    // Ensure directory exists
+    if (!fs.existsSync(metafileDir)) {
+        fs.mkdirSync(metafileDir, { recursive: true });
+    }
+    
+    // Write the metafile
+    fs.writeFileSync(metafilePath, JSON.stringify(metafile, null, 2));
+    console.log(`Pitono metafile written to: ${metafilePath}`);
+    
+    // Generate core.json using the Python script
+    try {
+        // First try using the installed command
+        const command = `pitono-core-generator ${testName} ${metafile.entryPoints.join(' ')}`;
+        execSync(command, { stdio: 'inherit' });
+        console.log(`Pitono core.json generated successfully for ${testName}`);
+    } catch (error) {
+        console.error(`Failed to generate Pitono core.json with installed command: ${error}`);
+        // Fallback to direct Python execution
+        try {
+            const pythonCommand = `python ${process.cwd()}/pitono/core_generator.py ${testName} ${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}`);
+            // Last resort: create the core.json manually
+            try {
+                const coreData = {
+                    testName: testName,
+                    entryPoints: metafile.entryPoints,
+                    outputs: {},
+                    metafile: {
+                        inputs: {},
+                        outputs: {}
+                    },
+                    timestamp: Date.now(),
+                    runtime: "pitono"
+                };
+                const coreFilePath = path.join(process.cwd(), 'testeranto', 'pitono', testName, 'core.json');
+                fs.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}`);
+            }
+        }
+    }
+}

package/src/utils.ts

@@ -80,14 +80,33 @@ export const getRunnables = (
   tests: ITestTypes[],
   projectName: string,
   payload = {
+    pythonEntryPoints: {},
     nodeEntryPoints: {},
     nodeEntryPointSidecars: {},
     webEntryPoints: {},
     webEntryPointSidecars: {},
     pureEntryPoints: {},
     pureEntryPointSidecars: {},
+    golangEntryPoints: {},
+    golangEntryPointSidecars: {},
+    pitonoEntryPoints: {},
+    pitonoEntryPointSidecars: {},
   }
 ): IRunnables => {
+  // Ensure all properties are properly initialized
+  const initializedPayload = {
+    pythonEntryPoints: payload.pythonEntryPoints || {},
+    nodeEntryPoints: payload.nodeEntryPoints || {},
+    nodeEntryPointSidecars: payload.nodeEntryPointSidecars || {},
+    webEntryPoints: payload.webEntryPoints || {},
+    webEntryPointSidecars: payload.webEntryPointSidecars || {},
+    pureEntryPoints: payload.pureEntryPoints || {},
+    pureEntryPointSidecars: payload.pureEntryPointSidecars || {},
+    golangEntryPoints: payload.golangEntryPoints || {},
+    golangEntryPointSidecars: payload.golangEntryPointSidecars || {},
+    pitonoEntryPoints: payload.pitonoEntryPoints || {},
+    pitonoEntryPointSidecars: payload.pitonoEntryPointSidecars || {},
+  };
   return tests.reduce((pt, cv, cndx, cry) => {
     if (cv[1] === "node") {
       pt.nodeEntryPoints[cv[0]] = path.resolve(
@@ -113,6 +132,12 @@ export const getRunnables = (
           .concat("mjs")
           .join(".")}`
       );
+    } else if (cv[1] === "golang") {
+      // For Go files, we'll use the original path since they're not compiled to JS
+      pt.golangEntryPoints[cv[0]] = path.resolve(cv[0]);
+    } else if (cv[1] === "pitono") {
+      // For pitono files, use the original Python file path
+      pt.pitonoEntryPoints[cv[0]] = path.resolve(cv[0]);
     }
 
     //////////////////////////////////////////////////////////
@@ -150,7 +175,19 @@ export const getRunnables = (
             .join(".")}`
         );
       });
+    cv[3]
+      .filter((t) => t[1] === "golang")
+      .forEach((t) => {
+        // For Go sidecars, use the original path
+        pt.golangEntryPointSidecars[`${t[0]}`] = path.resolve(t[0]);
+      });
+    cv[3]
+      .filter((t) => t[1] === "pitono")
+      .forEach((t) => {
+        // For pitono sidecars, use the original Python file path
+        pt.pitonoEntryPointSidecars[`${t[0]}`] = path.resolve(t[0]);
+      });
 
     return pt;
-  }, payload as IRunnables);
+  }, initializedPayload as IRunnables);
 };