testeranto 0.203.0 → 0.205.0

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

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePrompt = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+const logFiles_1 = require("../../utils/logFiles");
+const logFiles_2 = require("../../utils/logFiles");
+const makePrompt = async (summary, name, entryPoint, addableFiles, runTime) => {
+    summary[entryPoint].prompt = "?";
+    const promptPath = (0, utils_1.promptPather)(entryPoint, runTime, name);
+    // Correct directory structure: testeranto/reports/<name>/<testname>/<runtime>/
+    const testDir = path_1.default.join("testeranto", "reports", name, entryPoint.split(".").slice(0, -1).join("."), runTime);
+    const testPaths = path_1.default.join(testDir, logFiles_2.LOG_FILES.TESTS);
+    const lintPath = path_1.default.join(testDir, logFiles_2.LOG_FILES.LINT_ERRORS);
+    const typePath = path_1.default.join(testDir, logFiles_2.LOG_FILES.TYPE_ERRORS);
+    const messagePath = path_1.default.join(testDir, logFiles_2.LOG_FILES.MESSAGE);
+    try {
+        await Promise.all([
+            fs_1.default.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 ${(0, logFiles_1.getLogFilesForRuntime)(runTime)
+                .map((p) => `${testDir}/${p}`)
+                .join("\n/read ")}
+`),
+            fs_1.default.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`;
+};
+exports.makePrompt = makePrompt;

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

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRunnables = exports.promptPather = exports.bddPather = exports.lintPather = exports.tscPather = exports.destinationOfRuntime = exports.webEvaluator = void 0;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const path_1 = __importDefault(require("path"));
+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())
+  }
+})
+`;
+};
+exports.webEvaluator = webEvaluator;
+const destinationOfRuntime = (f, r, configs) => {
+    return path_1.default
+        .normalize(`${configs.buildDir}/${r}/${f}`)
+        .split(".")
+        .slice(0, -1)
+        .join(".");
+};
+exports.destinationOfRuntime = destinationOfRuntime;
+const tscPather = (entryPoint, platform, projectName) => {
+    return path_1.default.join("testeranto", "reports", projectName, entryPoint.split(".").slice(0, -1).join("."), platform, `type_errors.txt`);
+};
+exports.tscPather = tscPather;
+const lintPather = (entryPoint, platform, projectName) => {
+    return path_1.default.join("testeranto", "reports", projectName, entryPoint.split(".").slice(0, -1).join("."), platform, `lint_errors.txt`);
+};
+exports.lintPather = lintPather;
+const bddPather = (entryPoint, platform, projectName) => {
+    return path_1.default.join("testeranto", "reports", projectName, entryPoint.split(".").slice(0, -1).join("."), platform, `tests.json`);
+};
+exports.bddPather = bddPather;
+const promptPather = (entryPoint, platform, projectName) => {
+    const e = entryPoint.split(".").slice(0, -1).join(".");
+    return path_1.default.join("testeranto", "reports", projectName, e, platform, `prompt.txt`);
+};
+exports.promptPather = promptPather;
+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_1.default.resolve(`./testeranto/bundles/node/${projectName}/${cv[0]
+                .split(".")
+                .slice(0, -1)
+                .concat("mjs")
+                .join(".")}`);
+        }
+        else if (cv[1] === "web") {
+            pt.webEntryPoints[cv[0]] = path_1.default.resolve(`./testeranto/bundles/web/${projectName}/${cv[0]
+                .split(".")
+                .slice(0, -1)
+                .concat("mjs")
+                .join(".")}`);
+        }
+        else if (cv[1] === "pure") {
+            pt.pureEntryPoints[cv[0]] = path_1.default.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_1.default.resolve(cv[0]);
+        }
+        else if (cv[1] === "python") {
+            // For python files, use the original Python file path
+            pt.pythonEntryPoints[cv[0]] = path_1.default.resolve(cv[0]);
+        }
+        //////////////////////////////////////////////////////////
+        cv[3]
+            .filter((t) => t[1] === "node")
+            .forEach((t) => {
+            pt.nodeEntryPointSidecars[`${t[0]}`] = path_1.default.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_1.default.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_1.default.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_1.default.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_1.default.resolve(t[0]);
+        });
+        return pt;
+    }, initializedPayload);
+};
+exports.getRunnables = getRunnables;

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

@@ -0,0 +1,206 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.App = exports.useAuth = exports.useTutorialMode = void 0;
+const react_1 = __importStar(require("react"));
+const react_router_dom_1 = require("react-router-dom");
+const client_1 = __importDefault(require("react-dom/client"));
+const Helpo_1 = require("../../Helpo");
+const AppFrame_1 = require("./components/pure/AppFrame");
+const SignIn_1 = require("./components/pure/SignIn");
+const GitHubAuthService_1 = require("./GitHubAuthService");
+const AuthCallbackPage_1 = require("./components/stateful/AuthCallbackPage");
+const ProjectPage_1 = require("./components/stateful/ProjectPage");
+const ProjectsPage_1 = require("./components/stateful/ProjectsPage");
+const FluaPage_1 = require("./flua/FluaPage");
+const TestPage_1 = require("./testPage/TestPage");
+const DesignEditorPage_1 = require("./components/DesignEditorPage");
+const TextEditorPage_1 = require("./components/stateful/TextEditorPage");
+const ProcessManagerPage_1 = require("./components/stateful/ProcessManagerPage");
+const Settings_1 = require("./components/pure/Settings");
+const GitIntegrationPage_1 = require("./components/stateful/GitIntegrationPage");
+// import { FileServiceContext } from "./useFileService";
+const useFs_1 = require("./useFs");
+const TutorialModeContext = (0, react_1.createContext)({
+    tutorialMode: false,
+    setTutorialMode: () => { },
+});
+const useTutorialMode = () => {
+    return (0, react_1.useContext)(TutorialModeContext);
+};
+exports.useTutorialMode = useTutorialMode;
+const AuthContext = (0, react_1.createContext)({
+    isAuthenticated: false,
+    user: null,
+    login: () => { },
+    logout: () => { },
+});
+const useAuth = () => {
+    return (0, react_1.useContext)(AuthContext);
+};
+exports.useAuth = useAuth;
+const App = () => {
+    const [fs, setFs] = (0, useFs_1.useFs)();
+    const [ws, setWs] = (0, react_1.useState)(null);
+    const [isConnected, setIsConnected] = (0, react_1.useState)(false);
+    const [tutorialMode, setTutorialMode] = (0, react_1.useState)(false);
+    const [isAuthenticated, setIsAuthenticated] = (0, react_1.useState)(GitHubAuthService_1.githubAuthService.isAuthenticated);
+    const [user, setUser] = (0, react_1.useState)(GitHubAuthService_1.githubAuthService.userInfo);
+    (0, react_1.useEffect)(() => {
+        const savedTutorialMode = localStorage.getItem("tutorialMode");
+        if (savedTutorialMode) {
+            setTutorialMode(savedTutorialMode === "true");
+        }
+        const handleAuthChange = (authenticated) => {
+            setIsAuthenticated(authenticated);
+            setUser(GitHubAuthService_1.githubAuthService.userInfo);
+        };
+        GitHubAuthService_1.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_1.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_1.githubAuthService.off("authChange", handleAuthChange);
+            window.removeEventListener("message", handleMessage);
+            websocket.close();
+        };
+    }, []);
+    const authContextValue = {
+        isAuthenticated,
+        user,
+        login: () => GitHubAuthService_1.githubAuthService.initiateLogin(),
+        logout: () => GitHubAuthService_1.githubAuthService.logout(),
+    };
+    // let fs: FileService;
+    // if (ws) {
+    //   fs = useFs(ws);
+    // } else {
+    //   return <p>loading</p>
+    // }
+    return (react_1.default.createElement(FileServiceContext.Provider, { value: fs },
+        react_1.default.createElement(TutorialModeContext.Provider, { value: { tutorialMode, setTutorialMode } },
+            react_1.default.createElement(AuthContext.Provider, { value: authContextValue },
+                react_1.default.createElement(react_router_dom_1.HashRouter, null,
+                    react_1.default.createElement(AppFrame_1.AppFrame, null,
+                        react_1.default.createElement(react_router_dom_1.Routes, null,
+                            react_1.default.createElement(react_router_dom_1.Route, { path: "/", element: react_1.default.createElement(Helpo_1.Helpo, null) }),
+                            react_1.default.createElement(react_router_dom_1.Route, { path: "/flua", element: react_1.default.createElement(FluaPage_1.FluaPage, null) }),
+                            react_1.default.createElement(react_router_dom_1.Route, { path: "/projects", element: react_1.default.createElement(ProjectsPage_1.ProjectsPage, null) }),
+                            react_1.default.createElement(react_router_dom_1.Route, { path: "/projects/:projectName", element: react_1.default.createElement(ProjectPage_1.ProjectPage, null) }),
+                            react_1.default.createElement(react_router_dom_1.Route, { path: "/projects/:projectName/tests/*", element: react_1.default.createElement(TestPage_1.TestPage, null) }),
+                            react_1.default.createElement(react_router_dom_1.Route, { path: "/projects/:projectName#:tab", element: react_1.default.createElement(ProjectPage_1.ProjectPage, null) }),
+                            react_1.default.createElement(react_router_dom_1.Route, { path: "/signin", element: react_1.default.createElement(SignIn_1.SignIn, null) }),
+                            react_1.default.createElement(react_router_dom_1.Route, { path: "/auth/github/callback", element: react_1.default.createElement(AuthCallbackPage_1.AuthCallbackPage, null) }),
+                            react_1.default.createElement(react_router_dom_1.Route, { path: "/design-editor", element: isAuthenticated ? react_1.default.createElement(DesignEditorPage_1.DesignEditorPage, null) : react_1.default.createElement(SignIn_1.SignIn, null) }),
+                            react_1.default.createElement(react_router_dom_1.Route, { path: "/text-editor", element: isAuthenticated ? react_1.default.createElement(TextEditorPage_1.TextEditorPage, null) : react_1.default.createElement(SignIn_1.SignIn, null) }),
+                            isConnected ? (react_1.default.createElement(react_1.default.Fragment, null,
+                                react_1.default.createElement(react_router_dom_1.Route, { path: "/processes", element: isAuthenticated ? react_1.default.createElement(ProcessManagerPage_1.ProcessManagerPage, null) : react_1.default.createElement(SignIn_1.SignIn, null) }),
+                                react_1.default.createElement(react_router_dom_1.Route, { path: "/processes/:processId", element: react_1.default.createElement("p", null, "IDK") }))) : null,
+                            react_1.default.createElement(react_router_dom_1.Route, { path: "/settings", element: react_1.default.createElement(Settings_1.Settings, null) }),
+                            react_1.default.createElement(react_router_dom_1.Route, { path: "/git", element: isAuthenticated ? react_1.default.createElement(GitIntegrationPage_1.GitIntegrationPage, null) : react_1.default.createElement(SignIn_1.SignIn, null) }),
+                            react_1.default.createElement(react_router_dom_1.Route, { path: "*", element: react_1.default.createElement(Helpo_1.Helpo, null) }))))))));
+};
+exports.App = App;
+// Export App to global scope
+function initApp() {
+    const rootElement = document.getElementById("root");
+    if (rootElement) {
+        try {
+            // Use React 18's createRoot
+            const root = client_1.default.createRoot(rootElement);
+            root.render(react_1.default.createElement(exports.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/common/src/app/frontend/DevelopmentFileService.js

@@ -0,0 +1,98 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable no-async-promise-executor */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevelopmentFileService = void 0;
+const lightning_fs_1 = __importDefault(require("@isomorphic-git/lightning-fs"));
+const FileService_1 = require("../FileService");
+class DevelopmentFileService extends FileService_1.FileService {
+    constructor() {
+        super();
+        this.fs = new lightning_fs_1.default("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.");
+    }
+}
+exports.DevelopmentFileService = DevelopmentFileService;