testeranto 0.200.1 → 0.203.0

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");
-    }
-};

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

@@ -1,60 +0,0 @@
-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}`);
-            }
-        }
-    }
-}

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

@@ -1,32 +0,0 @@
-export class Queue {
-    constructor() {
-        this.items = [];
-    }
-    enqueue(element) {
-        this.items.push(element);
-    }
-    dequeue() {
-        if (this.isEmpty()) {
-            return "Queue is empty";
-        }
-        return this.items.shift();
-    }
-    peek() {
-        if (this.isEmpty()) {
-            return "Queue is empty";
-        }
-        return this.items[0];
-    }
-    isEmpty() {
-        return this.items.length === 0;
-    }
-    size() {
-        return this.items.length;
-    }
-    clear() {
-        this.items = [];
-    }
-    print() {
-        console.log(this.items.join(" -> "));
-    }
-}

package/dist/module/src/utils.js

@@ -1,121 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import path from "path";
-export const destinationOfRuntime = (f, r, configs) => {
-    return path
-        .normalize(`${configs.buildDir}/${r}/${f}`)
-        .split(".")
-        .slice(0, -1)
-        .join(".");
-};
-export const tscPather = (entryPoint, platform, projectName) => {
-    return path.join("testeranto", "reports", projectName, entryPoint.split(".").slice(0, -1).join("."), platform, `type_errors.txt`);
-};
-export const lintPather = (entryPoint, platform, projectName) => {
-    return path.join("testeranto", "reports", projectName, entryPoint.split(".").slice(0, -1).join("."), platform, `lint_errors.txt`);
-};
-export const bddPather = (entryPoint, platform, projectName) => {
-    return path.join("testeranto", "reports", projectName, entryPoint.split(".").slice(0, -1).join("."), platform, `tests.json`);
-};
-export const promptPather = (entryPoint, platform, projectName) => {
-    return path.join("testeranto", "reports", projectName, entryPoint.split(".").slice(0, -1).join("."), platform, `prompt.txt`);
-};
-export const getRunnables = (tests, projectName, payload = {
-    pythonEntryPoints: {},
-    nodeEntryPoints: {},
-    nodeEntryPointSidecars: {},
-    webEntryPoints: {},
-    webEntryPointSidecars: {},
-    pureEntryPoints: {},
-    pureEntryPointSidecars: {},
-    golangEntryPoints: {},
-    golangEntryPointSidecars: {},
-    pitonoEntryPoints: {},
-    pitonoEntryPointSidecars: {},
-}) => {
-    // 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(`./testeranto/bundles/node/${projectName}/${cv[0]
-                .split(".")
-                .slice(0, -1)
-                .concat("mjs")
-                .join(".")}`);
-        }
-        else if (cv[1] === "web") {
-            pt.webEntryPoints[cv[0]] = path.resolve(`./testeranto/bundles/web/${projectName}/${cv[0]
-                .split(".")
-                .slice(0, -1)
-                .concat("mjs")
-                .join(".")}`);
-        }
-        else if (cv[1] === "pure") {
-            pt.pureEntryPoints[cv[0]] = path.resolve(`./testeranto/bundles/pure/${projectName}/${cv[0]
-                .split(".")
-                .slice(0, -1)
-                .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]);
-        }
-        //////////////////////////////////////////////////////////
-        cv[3]
-            .filter((t) => t[1] === "node")
-            .forEach((t) => {
-            pt.nodeEntryPointSidecars[`${t[0]}`] = path.resolve(`./testeranto/bundles/node/${projectName}/${cv[0]
-                .split(".")
-                .slice(0, -1)
-                .concat("mjs")
-                .join(".")}`);
-        });
-        cv[3]
-            .filter((t) => t[1] === "web")
-            .forEach((t) => {
-            pt.webEntryPointSidecars[`${t[0]}`] = path.resolve(`./testeranto/bundles/web/${projectName}/${cv[0]
-                .split(".")
-                .slice(0, -1)
-                .concat("mjs")
-                .join(".")}`);
-        });
-        cv[3]
-            .filter((t) => t[1] === "pure")
-            .forEach((t) => {
-            pt.pureEntryPointSidecars[`${t[0]}`] = path.resolve(`./testeranto/bundles/pure/${projectName}/${cv[0]
-                .split(".")
-                .slice(0, -1)
-                .concat("mjs")
-                .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;
-    }, initializedPayload);
-};

package/dist/module/src/web.html.js

@@ -1,16 +0,0 @@
-export default (jsfilePath, htmlFilePath, cssfilePath) => `
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-  <script type="module" src="${jsfilePath}"></script>
-  <link rel="stylesheet" href="${cssfilePath}">
-</head>
-
-<body>
-  <div id="root">
-  </div>
-</body>
-
-</html>
-`;

package/dist/module/testeranto.config.js

@@ -1,96 +0,0 @@
-import { sassPlugin } from "esbuild-sass-plugin";
-// TODO- this config file is horrible. I need to redo how config files are handled.
-const config = {
-    projects: {
-        // staticSite: {
-        //   tests: [["src/ReportServer.test.ts/index.ts", "node", { ports: 1 }, []]],
-        //   clearScreen: false,
-        //   debugger: false,
-        //   externals: [],
-        //   featureIngestor: function (s: string): Promise<string> {
-        //     throw new Error("Function not implemented.");
-        //   },
-        //   importPlugins: [],
-        //   minify: false,
-        //   nodePlugins: [],
-        //   ports: ["3334"],
-        //   src: "",
-        //   webPlugins: [],
-        // },
-        core: {
-            tests: [
-                ["example/test_example.py", "python", { ports: 0 }, []],
-                ["src/golingvu/base_suite_test.go", "golang", { ports: 0 }, []],
-                ["src/lib/BaseSuite.test/node.test.ts", "node", { ports: 0 }, []],
-                ["src/lib/BaseSuite.test/pure.test.ts", "pure", { ports: 0 }, []],
-                ["src/lib/BaseSuite.test/web.test.ts", "web", { ports: 0 }, []],
-                // [
-                //   "src/components/pure/TestPageView.test/index.tsx",
-                //   "web",
-                //   { ports: 0 },
-                //   [],
-                // ],
-                // [
-                //   "src/components/pure/ProjectPageView.test/index.tsx",
-                //   "web",
-                //   { ports: 0 },
-                //   [],
-                // ],
-                // ["src/Pure.test.ts", "pure", { ports: 0 }, []],
-                // ["src/lib/pmProxy.test/index.ts", "node", { ports: 0 }, []],
-                // ["src/lib/TipoSkripto.test/TipoSkripto.ts", "node", { ports: 0 }, []],
-                // [
-                //   "src/components/pure/FeaturesReporterView.test/index.tsx",
-                //   "web",
-                //   { ports: 0 },
-                //   [],
-                // ],
-                //////////////////////////////////////////////////////////////////////////////////////////////////////////
-                // broken
-                // [
-                //   "src/components/pure/ModalContent.test/index.tsx",
-                //   "web",
-                //   { ports: 0 },
-                //   [],
-                // ],
-                // [
-                //   "src/components/pure/AppFrame.test/index.tsx",
-                //   "web",
-                //   { ports: 0 },
-                //   [],
-                // ],
-                // ["src/mothership/test.ts", "node", { ports: 0 }, []],
-                // ["./src/lib/abstractBase.test/index.ts", "node", { ports: 0 }, []],
-                // [
-                //   "src/PM/__tests__/nodeSidecar.testeranto.ts",
-                //   "node",
-                //   { ports: 1 },
-                //   [],
-                // ],
-                // [
-                //   "src/PM/__tests__/pureSidecar.testeranto.ts",
-                //   "node",
-                //   { ports: 1 },
-                //   [],
-                // ],
-                // ["src/PM/__tests__/webSidecar.testeranto.ts", "node", { ports: 1 }, []],
-            ],
-            clearScreen: false,
-            debugger: false,
-            externals: [],
-            featureIngestor: function (s) {
-                throw new Error("Function not implemented.");
-            },
-            importPlugins: [],
-            minify: false,
-            nodePlugins: [],
-            ports: ["3333"],
-            src: "",
-            webPlugins: [() => sassPlugin()],
-            webLoaders: {
-                ".ttf": "file",
-            },
-        },
-    },
-};
-export default config;