testeranto 0.199.0 → 0.200.0

package/dist/module/src/components/stateful/TestPage.js

@@ -51,6 +51,7 @@ export const TestPage = () => {
                 const receivedLogs = await testResponse.logs;
                 console.log('Received logs:', Object.keys(receivedLogs));
                 let sourceFiles = {};
+                let buildLogs = {};
                 if (metafileRes.ok) {
                     const metafile = await metafileRes.json();
                     if ((_a = metafile === null || metafile === void 0 ? void 0 : metafile.metafile) === null || _a === void 0 ? void 0 : _a.outputs) {
@@ -63,28 +64,34 @@ export const TestPage = () => {
                             const normalizedTestPath = testPath.replace(/\./g, '_');
                             const testFileName = testPath.split('/').pop();
                             const testBaseName = testFileName === null || testFileName === void 0 ? void 0 : testFileName.split('.').slice(0, -1).join('.');
+                            // Also check outputPath normalized for slashes replaced by underscores
+                            const normalizedOutputPath = outputPath.replace(/\//g, '_');
                             return output.entryPoint === testEntryPoint ||
                                 outputPath.includes(normalizedTestPath) ||
+                                normalizedOutputPath.includes(normalizedTestPath) ||
                                 (testBaseName && outputPath.includes(testBaseName));
                         });
                         // Then collect all inputs from matching outputs
                         matchingOutputs.forEach(([_, output]) => {
                             Object.keys(output.inputs).forEach(inputPath => {
-                                // Check if this input is a TypeScript file and not in node_modules
-                                if ((inputPath.endsWith('.ts') || inputPath.endsWith('.tsx')) &&
+                                // Check if this input is a source file (TypeScript or Go) and not in node_modules
+                                if ((inputPath.endsWith('.ts') || inputPath.endsWith('.tsx') || inputPath.endsWith('.go')) &&
                                     !inputPath.includes('node_modules')) {
                                     // Get the full input details from metafile.inputs
                                     const inputDetails = metafile.metafile.inputs[inputPath];
                                     if (inputDetails) {
                                         tsSources.add(inputPath);
-                                        // Also include any imported TypeScript files
-                                        inputDetails.imports.forEach(imp => {
-                                            if ((imp.path.endsWith('.ts') || imp.path.endsWith('.tsx')) &&
-                                                !imp.path.includes('node_modules') &&
-                                                !imp.external) {
-                                                tsSources.add(imp.path);
-                                            }
-                                        });
+                                        // Also include any imported source files (for TypeScript)
+                                        // Go files don't have imports in the same way, so we'll only process for TypeScript
+                                        if (inputPath.endsWith('.ts') || inputPath.endsWith('.tsx')) {
+                                            inputDetails.imports.forEach(imp => {
+                                                if ((imp.path.endsWith('.ts') || imp.path.endsWith('.tsx')) &&
+                                                    !imp.path.includes('node_modules') &&
+                                                    !imp.external) {
+                                                    tsSources.add(imp.path);
+                                                }
+                                            });
+                                        }
                                     }
                                 }
                             });
@@ -131,11 +138,14 @@ export const TestPage = () => {
                             });
                         });
                         sourceFiles = fileTree;
+                        buildLogs = metafile;
                     }
                 }
-                // Add source files to logs
+                // Add source files and build logs to logs
                 receivedLogs['source_files'] = sourceFiles;
+                receivedLogs['build_logs'] = buildLogs;
                 console.log('Source files structure:', sourceFiles);
+                console.log('Build logs:', buildLogs);
                 // Ensure tests.json is properly formatted
                 if (receivedLogs['tests.json']) {
                     console.log('tests.json content type:', typeof receivedLogs['tests.json']);
@@ -174,6 +184,35 @@ export const TestPage = () => {
                 catch (err) {
                     console.error('Failed to load summary:', err);
                 }
+                // Fetch build.json to get build errors and warnings
+                try {
+                    // The build.json is in the runtime directory directly under the test path
+                    // testPath is "src/lib/pmProxy.test/index.ts"
+                    // We need to use the directory path without the filename
+                    const pathParts = testPath.split('/');
+                    const fileName = pathParts.pop();
+                    const directoryPath = pathParts.join('/');
+                    // Construct the path without the filename without extension
+                    const buildUrl = `/reports/${projectName}/${directoryPath}/${runtime}/build.json`;
+                    console.log(`Fetching build.json from: ${buildUrl}`);
+                    const buildResponse = await fetch(buildUrl);
+                    if (buildResponse.ok) {
+                        const buildData = await buildResponse.json();
+                        console.log('Build data received:', buildData);
+                        // Add build errors and warnings to logs
+                        receivedLogs['build.json'] = buildData;
+                    }
+                    else {
+                        console.log('Build.json not found or not accessible, status:', buildResponse.status);
+                        // Add an empty build.json to logs to prevent errors
+                        receivedLogs['build.json'] = { errors: [], warnings: [] };
+                    }
+                }
+                catch (err) {
+                    console.log('No build.json found or error fetching it:', err);
+                    // Add an empty build.json to logs to prevent errors
+                    receivedLogs['build.json'] = { errors: [], warnings: [] };
+                }
             }
             catch (err) {
                 setError(err instanceof Error ? err.message : 'Unknown error');

package/dist/module/src/lib/abstractBase.test/index.js

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-empty-object-type */
 import Testeranto from "../../Node";
 import { specification } from "./specification";
 import { implementation } from "./implementation";

package/dist/module/src/run.js

@@ -1,45 +1,49 @@
-import ansiC from "ansi-colors";
-import readline from "readline";
-import { PM_Main } from "./PM/main";
-readline.emitKeypressEvents(process.stdin);
-if (process.stdin.isTTY)
-    process.stdin.setRawMode(true);
-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 === "x") {
-        console.log(ansiC.inverse("Shutting down forcefully..."));
-        process.exit(-1);
-    }
-});
-const projectName = process.argv[2];
-const mode = process.argv[3];
-if (mode !== "once" && mode !== "dev") {
-    console.error("the 2nd argument should be 'dev' or 'once' ");
-    process.exit(-1);
-}
-const f = process.cwd() + "/" + "testeranto.config.ts";
-console.log("config file:", f);
-import(f).then(async (module) => {
-    const bigConfig = module.default || module;
-    const rawConfig = bigConfig.projects[projectName];
-    if (!rawConfig) {
-        console.error(`Project "${projectName}" does not exist in the configuration.`);
-        console.error("Available projects:", Object.keys(bigConfig.projects));
-        process.exit(-1);
-    }
-    if (!rawConfig.tests) {
-        console.error(projectName, "appears to have no tests: ", f);
-        console.error(`here is the config:`);
-        console.log(JSON.stringify(rawConfig));
-        process.exit(-1);
-    }
-    const config = Object.assign(Object.assign({}, rawConfig), { buildDir: process.cwd() + "/" + `testeranto/${projectName}.json` });
-    const pm = new PM_Main(config, projectName, mode);
-    pm.start();
-    process.stdin.on("keypress", (str, key) => {
-        if (key.name === "q") {
-            pm.stop();
-        }
-    });
-});
+"use strict";
+// import ansiC from "ansi-colors";
+// import readline from "readline";
+// import { PM_Main } from "./PM/main";
+// import { ITestconfig, IBuiltConfig, IProject } from "./Types";
+// readline.emitKeypressEvents(process.stdin);
+// if (process.stdin.isTTY) process.stdin.setRawMode(true);
+// 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 === "x") {
+//     console.log(ansiC.inverse("Shutting down forcefully..."));
+//     process.exit(-1);
+//   }
+// });
+// const projectName = process.argv[2];
+// const mode = process.argv[3] as "once" | "dev";
+// if (mode !== "once" && mode !== "dev") {
+//   console.error("the 2nd argument should be 'dev' or 'once' ");
+//   process.exit(-1);
+// }
+// const f = process.cwd() + "/" + "testeranto.config.ts";
+// console.log("config file:", f);
+// import(f).then(async (module) => {
+//   const bigConfig: IProject = module.default || module;
+//   const rawConfig: ITestconfig = bigConfig.projects[projectName];
+//   if (!rawConfig) {
+//     console.error(`Project "${projectName}" does not exist in the configuration.`);
+//     console.error("Available projects:", Object.keys(bigConfig.projects));
+//     process.exit(-1);
+//   }
+//   if (!rawConfig.tests) {
+//     console.error(projectName, "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/${projectName}.json`,
+//   };
+//   const pm = new PM_Main(config, projectName, mode);
+//   pm.start();
+//   process.stdin.on("keypress", (str, key) => {
+//     if (key.name === "q") {
+//       pm.stop();
+//     }
+//   });
+// });

package/dist/module/src/{build.js → testeranto.js}

@@ -15,12 +15,14 @@ readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
     process.stdin.setRawMode(true);
 const testName = process.argv[2];
-let mode = process.argv[3];
+const mode = process.argv[3];
 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 = module.default;
     const project = bigConfig.projects[testName];
@@ -30,56 +32,31 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
     }
     fs.writeFileSync(`${process.cwd()}/testeranto/projects.json`, JSON.stringify(Object.keys(bigConfig.projects), null, 2));
     const rawConfig = bigConfig.projects[testName];
-    const getSecondaryEndpointsPoints = (runtime) => {
-        const meta = (ts, st) => {
-            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()));
-    };
-    // 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) {
+        console.error(`Project "${testName}" does not exist in the configuration.`);
+        console.error("Available projects:", Object.keys(bigConfig.projects));
+        process.exit(-1);
+    }
+    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 = Object.assign(Object.assign({}, 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 = false;
     let webDone = false;
     let importDone = false;
+    let golangDone = false;
+    let pitonoDone = false;
     let status = "build";
     const { nodeEntryPoints, nodeEntryPointSidecars, webEntryPoints, webEntryPointSidecars, pureEntryPoints, pureEntryPointSidecars, } = getRunnables(config.tests, testName);
     const onNodeDone = () => {
@@ -94,13 +71,35 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
         importDone = true;
         onDone();
     };
+    const onGolangDone = () => {
+        golangDone = true;
+        onDone();
+    };
+    const onPitonoDone = () => {
+        pitonoDone = true;
+        onDone();
+    };
+    let pm = 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
         }
     };
     fs.writeFileSync(`${process.cwd()}/testeranto/projects.html`, AppHtml());
@@ -111,6 +110,55 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
         }
         fs.writeFileSync(`testeranto/reports/${projectName}/config.json`, JSON.stringify(config, null, 2));
     });
+    const getSecondaryEndpointsPoints = (runtime) => {
+        const meta = (ts, st) => {
+            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) => {
         const sourceFileSplit = sourceFilePath.split("/");
         const sourceDir = sourceFileSplit.slice(0, -1);
@@ -126,13 +174,6 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
             .mkdir(path.dirname(htmlFilePath), { recursive: true })
             .then((x) => fs.writeFileSync(htmlFilePath, webHtmlFrame(jsfilePath, htmlFilePath, cssFilePath)));
     })));
-    // glob(`${process.cwd()}/testeranto/bundles/${testName}/chunk-*.mjs`, {
-    //   ignore: "node_modules/**",
-    // }).then((chunks) => {
-    //   chunks.forEach((chunk) => {
-    //     fs.unlinkSync(chunk);
-    //   });
-    // });
     const x = [
         ["pure", Object.keys(pureEntryPoints)],
         ["node", Object.keys(nodeEntryPoints)],
@@ -190,4 +231,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/dist/module/src/utils/golingvuMetafile.js

@@ -0,0 +1,109 @@
+import fs from "fs";
+import path from "path";
+export async function generateGolangMetafile(testName, entryPoints) {
+    const outputs = {};
+    // 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 = {};
+            let totalBytes = 0;
+            for (const file of goFiles) {
+                try {
+                    const stats = fs.statSync(file);
+                    inputs[file] = { bytesInOutput: stats.size };
+                    totalBytes += stats.size;
+                }
+                catch (_a) {
+                    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 (_b) {
+                    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 = {};
+    // Collect all unique Go files from all entry points
+    const allGoFiles = new Set();
+    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 (_c) {
+            allInputs[filePath] = {
+                bytes: 0,
+                imports: []
+            };
+        }
+    }
+    // Reformat outputs to match esbuild structure
+    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
+        }
+    };
+}
+export function writeGolangMetafile(testName, metafile) {
+    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/dist/module/src/utils/logFiles.js

@@ -18,7 +18,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'
 };
 export const RUNTIME_SPECIFIC_LOGS = {
     node: {

package/dist/module/src/utils/pitonoMetafile.js

@@ -0,0 +1,60 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+export async function generatePitonoMetafile(testName, entryPoints) {
+    return {
+        testName,
+        entryPoints,
+        timestamp: Date.now()
+    };
+}
+export function writePitonoMetafile(testName, metafile) {
+    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}`);
+            }
+        }
+    }
+}