testeranto 0.203.0 → 0.206.0

package/dist/module/src/app/backend/makePrompt.js

@@ -0,0 +1,66 @@
+import fs from "fs";
+import path from "path";
+import { promptPather } from "./utils";
+import { getLogFilesForRuntime } from "../../utils/logFiles";
+import { LOG_FILES } from "../../utils/logFiles";
+export 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);
+    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("\n/read ")}
+`),
+            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`;
+};

package/dist/module/src/app/backend/utils.js

@@ -0,0 +1,131 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import path from "path";
+export const webEvaluator = (d, webArgz) => {
+    return `
+import('${d}').then(async (x) => {
+  try {
+    return await (await x.default).receiveTestResourceConfig(${webArgz})
+  } catch (e) {
+    console.log("web run failure", e.toString())
+  }
+})
+`;
+};
+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) => {
+    const e = entryPoint.split(".").slice(0, -1).join(".");
+    return path.join("testeranto", "reports", projectName, e, platform, `prompt.txt`);
+};
+export const getRunnables = (tests, projectName, payload = {
+    nodeEntryPoints: {},
+    nodeEntryPointSidecars: {},
+    webEntryPoints: {},
+    webEntryPointSidecars: {},
+    pureEntryPoints: {},
+    pureEntryPointSidecars: {},
+    golangEntryPoints: {},
+    golangEntryPointSidecars: {},
+    pythonEntryPoints: {},
+    pythonEntryPointSidecars: {},
+}) => {
+    // Ensure all properties are properly initialized
+    const initializedPayload = {
+        nodeEntryPoints: payload.nodeEntryPoints || {},
+        nodeEntryPointSidecars: payload.nodeEntryPointSidecars || {},
+        webEntryPoints: payload.webEntryPoints || {},
+        webEntryPointSidecars: payload.webEntryPointSidecars || {},
+        pureEntryPoints: payload.pureEntryPoints || {},
+        pureEntryPointSidecars: payload.pureEntryPointSidecars || {},
+        golangEntryPoints: payload.golangEntryPoints || {},
+        golangEntryPointSidecars: payload.golangEntryPointSidecars || {},
+        pythonEntryPoints: payload.pythonEntryPoints || {},
+        pythonEntryPointSidecars: payload.pythonEntryPointSidecars || {},
+    };
+    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] === "python") {
+            // For python files, use the original Python file path
+            pt.pythonEntryPoints[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] === "python")
+            .forEach((t) => {
+            // For python sidecars, use the original Python file path
+            pt.pythonEntryPointSidecars[`${t[0]}`] = path.resolve(t[0]);
+        });
+        return pt;
+    }, initializedPayload);
+};

package/dist/module/src/app/frontend/App.js

@@ -0,0 +1,164 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import React, { useContext, useState, useEffect, createContext } from "react";
+import { Routes, Route, HashRouter } from "react-router-dom";
+import ReactDOM from "react-dom/client";
+import { Helpo } from "../../Helpo";
+import { AppFrame } from "./components/pure/AppFrame";
+import { SignIn } from "./components/pure/SignIn";
+import { githubAuthService } from "./GitHubAuthService";
+import { AuthCallbackPage } from "./components/stateful/AuthCallbackPage";
+import { ProjectPage } from "./components/stateful/ProjectPage";
+import { ProjectsPage } from "./components/stateful/ProjectsPage";
+import { FluaPage } from "./flua/FluaPage";
+import { TestPage } from "./testPage/TestPage";
+import { DesignEditorPage } from "./components/DesignEditorPage";
+import { TextEditorPage } from "./components/stateful/TextEditorPage";
+import { ProcessManagerPage } from "./components/stateful/ProcessManagerPage";
+import { Settings } from "./components/pure/Settings";
+import { GitIntegrationPage } from "./components/stateful/GitIntegrationPage";
+// import { FileServiceContext } from "./useFileService";
+import { useFs } from "./useFs";
+const TutorialModeContext = createContext({
+    tutorialMode: false,
+    setTutorialMode: () => { },
+});
+export const useTutorialMode = () => {
+    return useContext(TutorialModeContext);
+};
+const AuthContext = createContext({
+    isAuthenticated: false,
+    user: null,
+    login: () => { },
+    logout: () => { },
+});
+export const useAuth = () => {
+    return useContext(AuthContext);
+};
+export const App = () => {
+    const [fs, setFs] = useFs();
+    const [ws, setWs] = useState(null);
+    const [isConnected, setIsConnected] = useState(false);
+    const [tutorialMode, setTutorialMode] = useState(false);
+    const [isAuthenticated, setIsAuthenticated] = useState(githubAuthService.isAuthenticated);
+    const [user, setUser] = useState(githubAuthService.userInfo);
+    useEffect(() => {
+        const savedTutorialMode = localStorage.getItem("tutorialMode");
+        if (savedTutorialMode) {
+            setTutorialMode(savedTutorialMode === "true");
+        }
+        const handleAuthChange = (authenticated) => {
+            setIsAuthenticated(authenticated);
+            setUser(githubAuthService.userInfo);
+        };
+        githubAuthService.on("authChange", handleAuthChange);
+        // Handle GitHub OAuth callback from popup
+        const handleMessage = async (event) => {
+            if (event.data.type === "github-auth-callback") {
+                const { code } = event.data;
+                try {
+                    const success = await githubAuthService.handleCallback(code);
+                    if (success) {
+                        console.log("GitHub authentication successful");
+                    }
+                    else {
+                        console.error("GitHub authentication failed");
+                    }
+                }
+                catch (error) {
+                    console.error("Error handling GitHub callback:", error);
+                }
+            }
+            else if (event.data.type === "github-auth-error") {
+                console.error("GitHub authentication error:", event.data.error);
+            }
+        };
+        window.addEventListener("message", handleMessage);
+        const wsProtocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+        const wsUrl = `${wsProtocol}//${window.location.host}`;
+        const websocket = new WebSocket(wsUrl);
+        websocket.onopen = () => {
+            console.log("WebSocket connected");
+            setIsConnected(true);
+            setWs(websocket);
+            fs.setSocket(websocket);
+        };
+        websocket.onclose = () => {
+            console.log("WebSocket disconnected");
+            setWs(null);
+            setIsConnected(false);
+        };
+        websocket.onerror = (error) => {
+            console.error("WebSocket error:", error);
+            setIsConnected(false);
+        };
+        return () => {
+            githubAuthService.off("authChange", handleAuthChange);
+            window.removeEventListener("message", handleMessage);
+            websocket.close();
+        };
+    }, []);
+    const authContextValue = {
+        isAuthenticated,
+        user,
+        login: () => githubAuthService.initiateLogin(),
+        logout: () => githubAuthService.logout(),
+    };
+    // let fs: FileService;
+    // if (ws) {
+    //   fs = useFs(ws);
+    // } else {
+    //   return <p>loading</p>
+    // }
+    return (React.createElement(FileServiceContext.Provider, { value: fs },
+        React.createElement(TutorialModeContext.Provider, { value: { tutorialMode, setTutorialMode } },
+            React.createElement(AuthContext.Provider, { value: authContextValue },
+                React.createElement(HashRouter, null,
+                    React.createElement(AppFrame, null,
+                        React.createElement(Routes, null,
+                            React.createElement(Route, { path: "/", element: React.createElement(Helpo, null) }),
+                            React.createElement(Route, { path: "/flua", element: React.createElement(FluaPage, null) }),
+                            React.createElement(Route, { path: "/projects", element: React.createElement(ProjectsPage, null) }),
+                            React.createElement(Route, { path: "/projects/:projectName", element: React.createElement(ProjectPage, null) }),
+                            React.createElement(Route, { path: "/projects/:projectName/tests/*", element: React.createElement(TestPage, null) }),
+                            React.createElement(Route, { path: "/projects/:projectName#:tab", element: React.createElement(ProjectPage, null) }),
+                            React.createElement(Route, { path: "/signin", element: React.createElement(SignIn, null) }),
+                            React.createElement(Route, { path: "/auth/github/callback", element: React.createElement(AuthCallbackPage, null) }),
+                            React.createElement(Route, { path: "/design-editor", element: isAuthenticated ? React.createElement(DesignEditorPage, null) : React.createElement(SignIn, null) }),
+                            React.createElement(Route, { path: "/text-editor", element: isAuthenticated ? React.createElement(TextEditorPage, null) : React.createElement(SignIn, null) }),
+                            isConnected ? (React.createElement(React.Fragment, null,
+                                React.createElement(Route, { path: "/processes", element: isAuthenticated ? React.createElement(ProcessManagerPage, null) : React.createElement(SignIn, null) }),
+                                React.createElement(Route, { path: "/processes/:processId", element: React.createElement("p", null, "IDK") }))) : null,
+                            React.createElement(Route, { path: "/settings", element: React.createElement(Settings, null) }),
+                            React.createElement(Route, { path: "/git", element: isAuthenticated ? React.createElement(GitIntegrationPage, null) : React.createElement(SignIn, null) }),
+                            React.createElement(Route, { path: "*", element: React.createElement(Helpo, null) }))))))));
+};
+// Export App to global scope
+function initApp() {
+    const rootElement = document.getElementById("root");
+    if (rootElement) {
+        try {
+            // Use React 18's createRoot
+            const root = ReactDOM.createRoot(rootElement);
+            root.render(React.createElement(App));
+        }
+        catch (err) {
+            console.error("Error rendering app:", err);
+            // Retry if React isn't loaded yet
+            setTimeout(initApp, 100);
+        }
+    }
+    else {
+        // Retry if root element isn't available yet
+        setTimeout(initApp, 100);
+    }
+}
+// Initialize the app when the window is ready
+if (typeof window !== "undefined" && typeof document !== "undefined") {
+    if (document.readyState === "loading") {
+        document.addEventListener("DOMContentLoaded", initApp);
+    }
+    else {
+        initApp();
+    }
+}

package/dist/module/src/app/frontend/DevelopmentFileService.js

@@ -0,0 +1,91 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable no-async-promise-executor */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import lfs from "@isomorphic-git/lightning-fs";
+import { FileService } from "../FileService";
+export class DevelopmentFileService extends FileService {
+    constructor() {
+        super();
+        this.fs = new lfs("testfs");
+        this.connected = false;
+    }
+    setSocket(ws) {
+        this.ws = ws;
+        this.ws.onmessage = (ev) => {
+            const m = JSON.parse(ev.data);
+            if (m.data[0] === `createDirectory`) {
+                this.createDirectory_receive(ev.data[1]);
+            }
+            if (m.data[0] === `deleteFile`) {
+                this.deleteFile_receive(ev.data[1]);
+            }
+            if (m.data[0] === `writeFile`) {
+                this.writeFile_receive(ev.data[1][0], ev.data[1][1]);
+            }
+            if (m.data[0] === `readFile`) {
+                this.readFile_receive(ev.data[1][0], ev.data[1][1]);
+            }
+            if (m.data[0] === `files`) {
+                this.files_receive(ev.data[1][0]);
+            }
+            if (m.data[0] === `projects`) {
+                this.projects_receive(ev.data[1][0]);
+            }
+            if (m.data[0] === `tests`) {
+                this.tests_receive(ev.data[1][0]);
+            }
+            if (m.data[0] === `report`) {
+                this.report_receive(ev.data[1][0]);
+            }
+        };
+        this.files_send();
+    }
+    createDirectory_send(s) {
+        this.ws.send([`createDirectory`, s].toString());
+    }
+    createDirectory_receive(x) {
+        this.fs.mkdir(x[1], { mode: 1 }, () => { });
+    }
+    deleteFile_send(s) {
+        this.ws.send([`deleteFile`, s].toString());
+    }
+    deleteFile_receive(s) {
+        this.fs.unlink(s, undefined, () => { });
+    }
+    writeFile_send(f, c) {
+        this.ws.send([`writeFile`, f, c].toString());
+    }
+    writeFile_receive(s, c) {
+        this.fs.writeFile(s, c, undefined, () => { });
+    }
+    readFile_send(f) {
+        this.ws.send([`readFile`, f].toString());
+    }
+    readFile_receive(f, c) {
+        this.fs.writeFile(f, c, undefined, () => { });
+    }
+    files_send() {
+        this.ws.send([`files`].toString());
+    }
+    files_receive(files) {
+        throw new Error("Method not implemented.");
+    }
+    projects_send() {
+        this.ws.send([`projects`].toString());
+    }
+    projects_receive(tests) {
+        throw new Error("Method not implemented.");
+    }
+    tests_send(project) {
+        this.ws.send([`tests`].toString());
+    }
+    tests_receive(tests) {
+        throw new Error("Method not implemented.");
+    }
+    report_send(project, test) {
+        this.ws.send([`report`, [project, test]].toString());
+    }
+    report_receive(tests) {
+        throw new Error("Method not implemented.");
+    }
+}