testeranto 0.202.0 → 0.203.0

package/dist/module/src/testeranto.js

@@ -1,186 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import ansiC from "ansi-colors";
-import fs from "fs";
-import path from "path";
-import readline from "readline";
-import { getRunnables } from "./utils";
-import { AppHtml } from "./utils/buildTemplates";
-import webHtmlFrame from "./web.html";
-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);
-}
-readline.emitKeypressEvents(process.stdin);
-if (process.stdin.isTTY)
-    process.stdin.setRawMode(true);
-const testName = process.argv[2];
-const mode = process.argv[3];
-if (mode !== "once" && mode !== "dev") {
-    console.error(`The 3rd argument should be 'dev' or 'once', not '${mode}'.`);
-    process.exit(-1);
-}
-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];
-    if (!project) {
-        console.error("no project found for", testName, "in testeranto.config.ts");
-        process.exit(-1);
-    }
-    try {
-        fs.writeFileSync(`${process.cwd()}/testeranto/projects.json`, JSON.stringify(Object.keys(bigConfig.projects), null, 2));
-    }
-    catch (e) {
-        console.error("there was a problem");
-        console.error(e);
-    }
-    const rawConfig = bigConfig.projects[testName];
-    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(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);
-        }
-    });
-    let pm = null;
-    // Start PM_Main immediately - it will handle the build processes internally
-    const { PM_Main } = await import("./PM/main");
-    pm = new PM_Main(config, testName, mode);
-    await pm.start();
-    fs.writeFileSync(`${process.cwd()}/testeranto/projects.html`, AppHtml());
-    Object.keys(bigConfig.projects).forEach((projectName) => {
-        console.log(`testeranto/reports/${projectName}`);
-        if (!fs.existsSync(`testeranto/reports/${projectName}`)) {
-            fs.mkdirSync(`testeranto/reports/${projectName}`);
-        }
-        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("python")].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] === "python");
-    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));
-        console.log(ansiC.green(ansiC.inverse(`Python metafile written to: ${pitonoMetafilePath}/core.json`)));
-        // Add Python tests to the processing queue
-        pitonoEntryPoints.forEach((entryPoint) => {
-            if (pm) {
-                // For Python tests, the source file is the entry point itself
-                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 = path.normalize(`${process.cwd()}/testeranto/bundles/web/${testName}/${sourceDir.join("/")}/${sourceFileNameMinusJs}.html`);
-        const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
-        const cssFilePath = `./${sourceFileNameMinusJs}.css`;
-        return fs.promises
-            .mkdir(path.dirname(htmlFilePath), { recursive: true })
-            .then((x) => fs.writeFileSync(htmlFilePath, webHtmlFrame(jsfilePath, htmlFilePath, cssFilePath)));
-    })));
-    const { nodeEntryPoints, nodeEntryPointSidecars, webEntryPoints, webEntryPointSidecars, pureEntryPoints, pureEntryPointSidecars, pythonEntryPoints, pythonEntryPointSidecars, } = getRunnables(config.tests, testName);
-    const x = [
-        ["pure", Object.keys(pureEntryPoints)],
-        ["node", Object.keys(nodeEntryPoints)],
-        ["web", Object.keys(webEntryPoints)],
-        ["python", Object.keys(pythonEntryPoints)],
-    ];
-    x.forEach(async ([runtime, keys]) => {
-        keys.forEach(async (k) => {
-            const folder = `testeranto/reports/${testName}/${k
-                .split(".")
-                .slice(0, -1)
-                .join(".")}/${runtime}`;
-            await fs.mkdirSync(folder, { 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 = path.resolve(`testeranto`, `reports`, testName, ep.split(".").slice(0, -1).join("."), runtime);
-            fs.mkdirSync(fp, { recursive: true });
-        });
-    });
-    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/types/features.js

@@ -1,31 +0,0 @@
-export function buildTree(projects) {
-    return projects.map(projectName => ({
-        name: projectName,
-        type: 'project',
-        children: [{
-                name: 'src',
-                type: 'file',
-                children: [{
-                        name: 'components',
-                        type: 'file',
-                        children: [{
-                                name: 'pure',
-                                type: 'file',
-                                children: [
-                                    { name: 'AppFrame.test', type: 'file', path: 'src/components/pure/AppFrame.test' },
-                                    { name: 'FeaturesReporterView.test', type: 'file', path: 'src/components/pure/FeaturesReporterView.test' },
-                                    { name: 'ProjectPageView.test', type: 'file', path: 'src/components/pure/ProjectPageView.test' }
-                                ]
-                            }]
-                    }, {
-                        name: 'lib',
-                        type: 'file',
-                        children: [{
-                                name: 'baseBuilder.test',
-                                type: 'file',
-                                path: 'src/lib/baseBuilder.test'
-                            }]
-                    }]
-            }]
-    }));
-}

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

@@ -1,87 +0,0 @@
-import { getLogFilesForRuntime, STANDARD_LOGS } from "./logFiles";
-export const fetchProjectData = async (projectName) => {
-    const [summaryRes, configRes] = await Promise.all([
-        fetch(summaryDotJson(projectName)),
-        fetch("/reports/config.json"),
-    ]);
-    return {
-        summary: (await summaryRes.json()),
-        config: (await configRes.json()),
-    };
-};
-export const fetchTestData = async (projectName, filepath, runTime) => {
-    const basePath = `reports/${projectName}/${filepath
-        .split(".")
-        .slice(0, -1)
-        .join(".")}/${runTime}`;
-    try {
-        const logFiles = getLogFilesForRuntime(runTime);
-        const logs = {};
-        // Fetch all log files in parallel
-        const logRequests = logFiles.map(async (file) => {
-            try {
-                const response = await fetch(`${basePath}/${file}`);
-                if (!response.ok)
-                    return null;
-                const content = file.endsWith(".json")
-                    ? await response.json()
-                    : await response.text();
-                return { file, content };
-            }
-            catch (err) {
-                console.error(`Failed to fetch ${file}:`, err);
-                return null;
-            }
-        });
-        // Wait for all requests and populate logs
-        const logResults = await Promise.all(logRequests);
-        logResults.forEach((result) => {
-            if (result) {
-                logs[result.file] = result.content;
-            }
-        });
-        // Ensure we fetch all standard logs
-        for (const file of Object.values(STANDARD_LOGS)) {
-            if (!logs[file]) {
-                try {
-                    const response = await fetch(`${basePath}/${file}`);
-                    if (response.ok) {
-                        logs[file] = file.endsWith(".json")
-                            ? await response.json()
-                            : await response.text();
-                    }
-                }
-                catch (err) {
-                    console.error(`Failed to fetch ${file}:`, err);
-                }
-            }
-        }
-        // const logs = await logFiles.reduce(async (acc, file, i) => {
-        //   acc[file.split(".")[0]] = await logRes[i].text();
-        //   return acc;
-        // }, {});
-        // Check if we got any logs at all
-        if (Object.keys(logs).length === 0) {
-            return {
-                logs: {},
-                error: "No test logs found. The test may not have run or the report files are missing.",
-            };
-        }
-        return {
-            logs,
-            error: null,
-        };
-    }
-    catch (err) {
-        return {
-            // testData: null,
-            logs: {},
-            // typeErrors: "",
-            // lintErrors: "",
-            error: `Failed to load test data: ${err instanceof Error ? err.message : String(err)}`,
-        };
-    }
-};
-export const summaryDotJson = (name) => {
-    return `reports/${name}/summary.json`;
-};

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

@@ -1,33 +0,0 @@
-const getBaseHtml = (title) => `
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta name="description" content="Webpage description goes here" />
-  <meta charset="utf-8" />
-  <title>${title} - testeranto</title>
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <meta name="author" content="" />
-
-  <script>
-    function initApp() {
-      if (window.React && window.ReactDOM && window.App) {
-        const root = ReactDOM.createRoot(document.getElementById('root'));
-        root.render(React.createElement(App));
-      } else {
-        setTimeout(initApp, 100);
-      }
-    }
-    window.addEventListener('DOMContentLoaded', initApp);
-  </script>
-`;
-export const AppHtml = () => `
-  ${getBaseHtml("Testeranto")}
-  
-  <link rel="stylesheet" href="App.css" />
-  <script src="App.js"></script>
-</head>
-<body>
-  <div id="root"></div>
-</body>
-</html>
-`;

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

@@ -1,24 +0,0 @@
-export const buildTree = (features) => {
-    const tree = {};
-    features.forEach(({ name, status }) => {
-        const parts = name.split(" - ");
-        const projectAndTest = parts.slice(0, 2).join(" - ");
-        const givenAndThen = parts.slice(2).join(" - ");
-        const pathParts = projectAndTest.split("/");
-        let current = tree;
-        pathParts.forEach((part) => {
-            if (!current[part]) {
-                current[part] = {};
-            }
-            current = current[part];
-        });
-        current[givenAndThen] = status;
-    });
-    return tree;
-};
-export const renderTree = (nodes) => (React.createElement("ul", null, Object.entries(nodes).map(([key, value]) => (React.createElement("li", { key: key }, typeof value === "string" ? (React.createElement("span", null,
-    key,
-    " - ",
-    value)) : (React.createElement(React.Fragment, null,
-    React.createElement("span", null, key),
-    renderTree(value))))))));

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

@@ -1,23 +0,0 @@
-import { getFileService } from '../services/FileService';
-export const testGitIntegration = async () => {
-    try {
-        const fileService = getFileService('dev');
-        // Test basic file operations
-        const testContent = '// Test file content\nconsole.log("Hello Git!");';
-        await fileService.writeFile('test-file.ts', testContent);
-        const content = await fileService.readFile('test-file.ts');
-        console.log('File content:', content);
-        const exists = await fileService.exists('test-file.ts');
-        console.log('File exists:', exists);
-        // Test Git operations
-        const changes = await fileService.getChanges();
-        console.log('Changes:', changes);
-        const branch = await fileService.getCurrentBranch();
-        console.log('Current branch:', branch);
-        return { success: true, changes, branch };
-    }
-    catch (error) {
-        console.error('Git integration test failed:', error);
-        return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
-    }
-};

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

@@ -1,109 +0,0 @@
-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

@@ -1,47 +0,0 @@
-export const LOG_FILES = {
-    TESTS: 'tests.json',
-    TYPE_ERRORS: 'type_errors.txt',
-    LINT_ERRORS: 'lint_errors.txt',
-    EXIT: 'exit.log',
-    MESSAGE: 'message.txt',
-    PROMPT: 'prompt.txt',
-    STDOUT: 'stdout.log',
-    STDERR: 'stderr.log',
-    INFO: 'info.log',
-    ERROR: 'error.log',
-    WARN: 'warn.log',
-    DEBUG: 'debug.log'
-};
-export const STANDARD_LOGS = {
-    TESTS: 'tests.json',
-    TYPE_ERRORS: 'type_errors.txt',
-    LINT_ERRORS: 'lint_errors.txt',
-    EXIT: 'exit.log',
-    MESSAGE: 'message.txt',
-    PROMPT: 'prompt.txt',
-    BUILD: 'build.json'
-};
-export const RUNTIME_SPECIFIC_LOGS = {
-    node: {
-        STDOUT: 'stdout.log',
-        STDERR: 'stderr.log'
-    },
-    web: {
-        INFO: 'info.log',
-        ERROR: 'error.log',
-        WARN: 'warn.log',
-        DEBUG: 'debug.log'
-    },
-    pure: {} // No runtime-specific logs for pure
-};
-export const ALL_LOGS = Object.assign(Object.assign({}, STANDARD_LOGS), Object.values(RUNTIME_SPECIFIC_LOGS).reduce((acc, logs) => (Object.assign(Object.assign({}, acc), logs)), {}));
-export const getRuntimeLogs = (runtime) => {
-    return {
-        standard: Object.values(STANDARD_LOGS),
-        runtimeSpecific: Object.values(RUNTIME_SPECIFIC_LOGS[runtime])
-    };
-};
-export function getLogFilesForRuntime(runtime) {
-    const { standard, runtimeSpecific } = getRuntimeLogs(runtime);
-    return [...standard, ...runtimeSpecific];
-}

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

@@ -1,109 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { promptPather } from "../utils";
-import { getLogFilesForRuntime } from "./logFiles";
-import { LOG_FILES } from "./logFiles";
-const makePrompt = async (summary, name, entryPoint, addableFiles, runtime) => {
-    summary[entryPoint].prompt = "?";
-    const promptPath = promptPather(entryPoint, runtime, name);
-    // Correct directory structure: testeranto/reports/<name>/<testname>/<runtime>/
-    const testDir = path.join("testeranto", "reports", name, entryPoint.split(".").slice(0, -1).join("."), runtime);
-    // Ensure directory exists
-    if (!fs.existsSync(testDir)) {
-        fs.mkdirSync(testDir, { recursive: true });
-    }
-    // Test result files
-    const testPaths = path.join(testDir, LOG_FILES.TESTS);
-    const lintPath = path.join(testDir, LOG_FILES.LINT_ERRORS);
-    const typePath = path.join(testDir, LOG_FILES.TYPE_ERRORS);
-    const messagePath = path.join(testDir, LOG_FILES.MESSAGE);
-    try {
-        await Promise.all([
-            fs.promises.writeFile(promptPath, `
-${addableFiles
-                .map((x) => {
-                return `/add ${x}`;
-            })
-                .join("\n")}
-
-/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 ${testPaths}
-/read ${typePath}
-/read ${lintPath}
-
-/read ${getLogFilesForRuntime(runtime)
-                .map((p) => `${testDir}/${p}`)
-                .join(" ")}
-`),
-            fs.promises.writeFile(messagePath, `
-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.
-`),
-        ]);
-    }
-    catch (e) {
-        console.error(`Failed to write prompt files at ${testDir}`);
-        console.error(e);
-        throw e;
-    }
-    summary[entryPoint].prompt = `aider --model deepseek/deepseek-chat --load testeranto/${name}/reports/${runtime}/${entryPoint
-        .split(".")
-        .slice(0, -1)
-        .join(".")}/prompt.txt`;
-};
-// function logs(r: IRunTime) {
-//   return getLogFilesForRuntime(r);
-// }
-// async function logsOfRuntime(
-//   runTime: IRunTime,
-//   testDir: string
-// ): Promise<string> {
-//   try {
-//     const fileChecks = await Promise.all(
-//       getLogFilesForRuntime(runTime).map(async (f) => {
-//         const filePath = path.join(testDir, f);
-//         try {
-//           await fs.promises.access(filePath);
-//           const content = await fs.promises.readFile(filePath, "utf-8");
-//           return content;
-//         } catch {
-//           return null;
-//         }
-//       })
-//     );
-//     return fileChecks.filter(Boolean).join("\n");
-//   } catch (e) {
-//     console.error(`Error checking log files in ${testDir}`);
-//     console.error(e);
-//     return "";
-//   }
-// }
-export const makePromptInternal = (summary, name, entryPoint, addableFiles, runTime) => {
-    if (runTime === "node") {
-        return makePrompt(summary, name, entryPoint, addableFiles, "node");
-    }
-    if (runTime === "web") {
-        return makePrompt(summary, name, entryPoint, addableFiles, "web");
-    }
-    if (runTime === "pure") {
-        return makePrompt(summary, name, entryPoint, addableFiles, "pure");
-    }
-};