testeranto 0.200.0 → 0.202.0

package/dist/module/src/PM/PM_WithEslintAndTsc.js

@@ -8,81 +8,94 @@ import ansiC from "ansi-colors";
 import { ESLint } from "eslint";
 import tsc from "tsc-prog";
 import { lintPather, tscPather } from "../utils";
-import { PM_Base } from "./base.js";
+import { PM_WithBuild } from "./PM_WithBuild.js";
 import { makePromptInternal } from "../utils/makePrompt";
 const eslint = new ESLint();
 const formatter = await eslint.loadFormatter("./node_modules/testeranto/dist/prebuild/esbuildConfigs/eslint-formatter-testeranto.mjs");
-export class PM_WithEslintAndTsc extends PM_Base {
+export class PM_WithEslintAndTsc extends PM_WithBuild {
     constructor(configs, name, mode) {
-        super(configs);
+        super(configs, name, mode);
         this.summary = {};
         this.tscCheck = async ({ entrypoint, addableFiles, platform, }) => {
-            console.log(ansiC.green(ansiC.inverse(`tsc < ${entrypoint}`)));
-            try {
-                this.typeCheckIsRunning(entrypoint);
-            }
-            catch (e) {
-                console.error("error in tscCheck");
-                console.error(e);
-                console.error(entrypoint);
-                console.error(JSON.stringify(this.summary, null, 2));
-                process.exit(-1);
-            }
-            const program = tsc.createProgramFromConfig({
-                basePath: process.cwd(), // always required, used for relative paths
-                configFilePath: "tsconfig.json", // config to inherit from (optional)
-                compilerOptions: {
-                    outDir: tscPather(entrypoint, platform, this.name),
-                    // declaration: true,
-                    // skipLibCheck: true,
-                    noEmit: true,
-                },
-                include: addableFiles, //["src/**/*"],
-                // exclude: ["node_modules", "../testeranto"],
-                // exclude: ["**/*.test.ts", "**/*.spec.ts"],
-            });
-            const tscPath = tscPather(entrypoint, platform, this.name);
-            const allDiagnostics = program.getSemanticDiagnostics();
-            const results = [];
-            allDiagnostics.forEach((diagnostic) => {
-                if (diagnostic.file) {
-                    const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
-                    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-                    results.push(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+            const processId = `tsc-${entrypoint}-${Date.now()}`;
+            const command = `tsc check for ${entrypoint}`;
+            const tscPromise = (async () => {
+                try {
+                    this.typeCheckIsRunning(entrypoint);
                 }
-                else {
-                    results.push(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+                catch (e) {
+                    // Log error through process manager
+                    throw new Error(`Error in tscCheck: ${e.message}`);
                 }
-            });
-            fs.writeFileSync(tscPath, results.join("\n"));
-            this.typeCheckIsNowDone(entrypoint, results.length);
+                const program = tsc.createProgramFromConfig({
+                    basePath: process.cwd(),
+                    configFilePath: "tsconfig.json",
+                    compilerOptions: {
+                        outDir: tscPather(entrypoint, platform, this.name),
+                        noEmit: true,
+                    },
+                    include: addableFiles,
+                });
+                const tscPath = tscPather(entrypoint, platform, this.name);
+                const allDiagnostics = program.getSemanticDiagnostics();
+                const results = [];
+                allDiagnostics.forEach((diagnostic) => {
+                    if (diagnostic.file) {
+                        const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+                        const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+                        results.push(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+                    }
+                    else {
+                        results.push(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+                    }
+                });
+                fs.writeFileSync(tscPath, results.join("\n"));
+                this.typeCheckIsNowDone(entrypoint, results.length);
+                return results.length;
+            })();
+            // Add to process manager if available
+            if (this.addPromiseProcess) {
+                this.addPromiseProcess(processId, tscPromise, command, "build-time", entrypoint);
+            }
+            else {
+                // Fallback to just running the promise
+                await tscPromise;
+            }
         };
         this.eslintCheck = async (entrypoint, platform, addableFiles) => {
-            console.log(ansiC.green(ansiC.inverse(`eslint < ${entrypoint}`)));
-            try {
-                this.lintIsRunning(entrypoint);
+            const processId = `eslint-${entrypoint}-${Date.now()}`;
+            const command = `eslint check for ${entrypoint}`;
+            const eslintPromise = (async () => {
+                try {
+                    this.lintIsRunning(entrypoint);
+                }
+                catch (e) {
+                    throw new Error(`Error in eslintCheck: ${e.message}`);
+                }
+                const filepath = lintPather(entrypoint, platform, this.name);
+                if (fs.existsSync(filepath))
+                    fs.rmSync(filepath);
+                const results = (await eslint.lintFiles(addableFiles))
+                    .filter((r) => r.messages.length)
+                    .filter((r) => {
+                    return r.messages[0].ruleId !== null;
+                })
+                    .map((r) => {
+                    delete r.source;
+                    return r;
+                });
+                fs.writeFileSync(filepath, await formatter.format(results));
+                this.lintIsNowDone(entrypoint, results.length);
+                return results.length;
+            })();
+            // Add to process manager if available
+            if (this.addPromiseProcess) {
+                this.addPromiseProcess(processId, eslintPromise, command, "build-time", entrypoint);
             }
-            catch (e) {
-                console.error("error in eslintCheck");
-                console.error(e);
-                console.error(entrypoint);
-                console.error(JSON.stringify(this.summary, null, 2));
-                process.exit(-1);
+            else {
+                // Fallback to just running the promise
+                await eslintPromise;
             }
-            const filepath = lintPather(entrypoint, platform, this.name);
-            if (fs.existsSync(filepath))
-                fs.rmSync(filepath);
-            const results = (await eslint.lintFiles(addableFiles))
-                .filter((r) => r.messages.length)
-                .filter((r) => {
-                return r.messages[0].ruleId !== null;
-            })
-                .map((r) => {
-                delete r.source;
-                return r;
-            });
-            fs.writeFileSync(filepath, await formatter.format(results));
-            this.lintIsNowDone(entrypoint, results.length);
         };
         this.makePrompt = async (entryPoint, addableFiles, platform) => {
             await makePromptInternal(this.summary, this.name, entryPoint, addableFiles, platform);
@@ -145,17 +158,16 @@ export class PM_WithEslintAndTsc extends PM_Base {
             this.checkForShutdown();
         };
         this.writeBigBoard = () => {
+            // note: this path is different from the one used by front end
             const summaryPath = `./testeranto/reports/${this.name}/summary.json`;
             const summaryData = JSON.stringify(this.summary, null, 2);
             fs.writeFileSync(summaryPath, summaryData);
             // Broadcast the update
             this.broadcast({
-                type: 'summaryUpdate',
-                data: this.summary
+                type: "summaryUpdate",
+                data: this.summary,
             });
         };
-        this.name = name;
-        this.mode = mode;
         this.summary = {};
         // Initialize all test entries first
         this.configs.tests.forEach(([t, rt, tr, sidecars]) => {

package/dist/module/src/PM/PM_WithGit.js

@@ -0,0 +1,477 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable no-async-promise-executor */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import url from "url";
+import { PM_WithEslintAndTsc } from "./PM_WithEslintAndTsc.js";
+export class PM_WithGit extends PM_WithEslintAndTsc {
+    constructor(configs, name, mode) {
+        super(configs, name, mode);
+        this.gitWatchTimeout = null;
+        this.gitWatcher = null;
+    }
+    // Override requestHandler to add Git-specific endpoints
+    requestHandler(req, res) {
+        const parsedUrl = url.parse(req.url || "/");
+        const pathname = parsedUrl.pathname || "/";
+        // Handle Git API endpoints
+        if (pathname === null || pathname === void 0 ? void 0 : pathname.startsWith("/api/git/")) {
+            this.handleGitApi(req, res);
+            return;
+        }
+        if (pathname === "/api/auth/github/token" && req.method === "POST") {
+            this.handleGitHubTokenExchange(req, res);
+            return;
+        }
+        // Handle GitHub OAuth callback
+        if (pathname === "/auth/github/callback") {
+            // Serve the callback HTML page
+            const callbackHtml = `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>GitHub Authentication - Testeranto</title>
+    <script>
+        // Extract the code from the URL and send it to the parent window
+        const urlParams = new URLSearchParams(window.location.search);
+        const code = urlParams.get('code');
+        const error = urlParams.get('error');
+        
+        if (code) {
+            window.opener.postMessage({ type: 'github-auth-callback', code }, '*');
+        } else if (error) {
+            window.opener.postMessage({ type: 'github-auth-error', error }, '*');
+        }
+        window.close();
+    </script>
+</head>
+<body>
+    <p>Completing authentication...</p>
+</body>
+</html>`;
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(callbackHtml);
+            return;
+        }
+        // Call the parent class's requestHandler for all other requests
+        super.requestHandler(req, res);
+    }
+    // this method is also horrible
+    handleGitApi(req, res) {
+        const parsedUrl = url.parse(req.url || "/");
+        const pathname = parsedUrl.pathname || "/";
+        // Set CORS headers
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        if (req.method === "OPTIONS") {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        try {
+            if (pathname === "/api/git/changes" && req.method === "GET") {
+                this.handleGitChanges(req, res);
+            }
+            else if (pathname === "/api/git/status" && req.method === "GET") {
+                this.handleGitFileStatus(req, res);
+            }
+            else if (pathname === "/api/git/commit" && req.method === "POST") {
+                this.handleGitCommit(req, res);
+            }
+            else if (pathname === "/api/git/push" && req.method === "POST") {
+                this.handleGitPush(req, res);
+            }
+            else if (pathname === "/api/git/pull" && req.method === "POST") {
+                this.handleGitPull(req, res);
+            }
+            else if (pathname === "/api/git/branch" && req.method === "GET") {
+                this.handleGitBranch(req, res);
+            }
+            else if (pathname === "/api/git/remote-status" &&
+                req.method === "GET") {
+                this.handleGitRemoteStatus(req, res);
+            }
+            else {
+                res.writeHead(404, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Not found" }));
+            }
+        }
+        catch (error) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Internal server error" }));
+        }
+    }
+    async handleGitChanges(req, res) {
+        try {
+            const changes = await this.getGitChanges();
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(changes));
+        }
+        catch (error) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Failed to get changes" }));
+        }
+    }
+    async handleGitFileStatus(req, res) {
+        const parsedUrl = url.parse(req.url || "/");
+        const query = parsedUrl.query || "";
+        const params = new URLSearchParams(query);
+        const path = params.get("path");
+        if (!path) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Path parameter required" }));
+            return;
+        }
+        try {
+            const status = await this.getGitFileStatus(path);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(status));
+        }
+        catch (error) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Failed to get file status" }));
+        }
+    }
+    async handleGitCommit(req, res) {
+        let body = "";
+        req.on("data", (chunk) => {
+            body += chunk.toString();
+        });
+        req.on("end", async () => {
+            try {
+                const { message, description } = JSON.parse(body);
+                await this.executeGitCommit(message, description);
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ success: true }));
+            }
+            catch (error) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Failed to commit" }));
+            }
+        });
+    }
+    async handleGitPush(req, res) {
+        try {
+            await this.executeGitPush();
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ success: true }));
+        }
+        catch (error) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Failed to push" }));
+        }
+    }
+    async handleGitPull(req, res) {
+        try {
+            await this.executeGitPull();
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ success: true }));
+        }
+        catch (error) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Failed to pull" }));
+        }
+    }
+    async handleGitBranch(req, res) {
+        try {
+            const branch = await this.getCurrentGitBranch();
+            res.writeHead(200, { "Content-Type": "text/plain" });
+            res.end(branch);
+        }
+        catch (error) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Failed to get branch" }));
+        }
+    }
+    async handleGitHubTokenExchange(req, res) {
+        let body = "";
+        req.on("data", (chunk) => {
+            body += chunk.toString();
+        });
+        req.on("end", async () => {
+            try {
+                const { code } = JSON.parse(body);
+                // Exchange code for access token
+                const tokenResponse = await fetch("https://github.com/login/oauth/access_token", {
+                    method: "POST",
+                    headers: {
+                        Accept: "application/json",
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify({
+                        client_id: process.env.GITHUB_CLIENT_ID,
+                        client_secret: process.env.GITHUB_CLIENT_SECRET,
+                        code,
+                    }),
+                });
+                const tokenData = await tokenResponse.json();
+                if (tokenData.error) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: tokenData.error_description }));
+                    return;
+                }
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ access_token: tokenData.access_token }));
+            }
+            catch (error) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Failed to exchange token" }));
+            }
+        });
+    }
+    async handleGitRemoteStatus(req, res) {
+        try {
+            const status = await this.getGitRemoteStatus();
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(status));
+        }
+        catch (error) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Failed to get remote status" }));
+        }
+    }
+    async getGitFileStatus(path) {
+        try {
+            const changes = await this.getGitChanges();
+            const fileChange = changes.find((change) => change.path === path);
+            if (fileChange) {
+                return { status: fileChange.status };
+            }
+            return { status: "unchanged" };
+        }
+        catch (error) {
+            console.error("Failed to get file status:", error);
+            return { status: "unchanged" };
+        }
+    }
+    async executeGitCommit(message, description) {
+        try {
+            const { exec } = await import("child_process");
+            const fullMessage = description
+                ? `${message}\n\n${description}`
+                : message;
+            return new Promise((resolve, reject) => {
+                // Stage all changes first
+                exec("git add -A", { cwd: process.cwd() }, (error) => {
+                    if (error) {
+                        reject(new Error(`Failed to stage changes: ${error.message}`));
+                        return;
+                    }
+                    // Commit with message
+                    const commitCommand = `git commit -m "${fullMessage.replace(/"/g, '\\"')}"`;
+                    exec(commitCommand, { cwd: process.cwd() }, (commitError) => {
+                        if (commitError) {
+                            reject(new Error(`Failed to commit: ${commitError.message}`));
+                            return;
+                        }
+                        resolve();
+                    });
+                });
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to execute commit: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    async executeGitPush() {
+        try {
+            const { exec } = await import("child_process");
+            return new Promise((resolve, reject) => {
+                exec("git push", { cwd: process.cwd() }, (error) => {
+                    if (error) {
+                        reject(new Error(`Failed to push: ${error.message}`));
+                        return;
+                    }
+                    resolve();
+                });
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to execute push: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    async executeGitPull() {
+        try {
+            const { exec } = await import("child_process");
+            return new Promise((resolve, reject) => {
+                exec("git pull", { cwd: process.cwd() }, (error) => {
+                    if (error) {
+                        reject(new Error(`Failed to pull: ${error.message}`));
+                        return;
+                    }
+                    resolve();
+                });
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to execute pull: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    // private async sendInitialState(ws: WebSocket) {
+    //   try {
+    //     const changes = await this.getGitChanges();
+    //     const status = await this.getGitRemoteStatus();
+    //     const branch = await this.getCurrentGitBranch();
+    //     ws.send(JSON.stringify({ type: "changes", changes }));
+    //     ws.send(JSON.stringify({ type: "status", status }));
+    //     ws.send(JSON.stringify({ type: "branch", branch }));
+    //   } catch (error) {
+    //     console.error("Error sending initial state:", error);
+    //     ws.send(
+    //       JSON.stringify({
+    //         type: "error",
+    //         message: "Failed to get Git status",
+    //       })
+    //     );
+    //   }
+    // }
+    // private async refreshGitStatus() {
+    //   try {
+    //     const changes = await this.getGitChanges();
+    //     const status = await this.getGitRemoteStatus();
+    //     const branch = await this.getCurrentGitBranch();
+    //     this.broadcast({ type: "changes", changes });
+    //     this.broadcast({ type: "status", status });
+    //     this.broadcast({ type: "branch", branch });
+    //   } catch (error) {
+    //     console.error("Error refreshing Git status:", error);
+    //   }
+    // }
+    onBuildDone() {
+        console.log("Build processes completed");
+        // The builds are done, which means the files are ready to be watched
+        // This matches the original behavior where builds completed before PM_Main started
+        // Start Git watcher for development mode
+        this.startGitWatcher();
+    }
+    async startGitWatcher() {
+        console.log("Starting Git watcher for real-time updates");
+        // Watch for file system changes in the current directory
+        const watcher = (await import("fs")).watch(process.cwd(), { recursive: true }, async (eventType, filename) => {
+            if (filename && !filename.includes(".git")) {
+                try {
+                    // Debounce the Git status check
+                    clearTimeout(this.gitWatchTimeout);
+                    this.gitWatchTimeout = setTimeout(async () => {
+                        const changes = await this.getGitChanges();
+                        const status = await this.getGitRemoteStatus();
+                        const branch = await this.getCurrentGitBranch();
+                        this.broadcast({ type: "changes", changes });
+                        this.broadcast({ type: "status", status });
+                        this.broadcast({ type: "branch", branch });
+                    }, 500); // Wait 500ms after last change
+                }
+                catch (error) {
+                    console.error("Error checking Git status:", error);
+                }
+            }
+        });
+        // Also set up a periodic check in case file watching misses something
+        setInterval(async () => {
+            try {
+                const changes = await this.getGitChanges();
+                const status = await this.getGitRemoteStatus();
+                const branch = await this.getCurrentGitBranch();
+                this.broadcast({ type: "changes", changes });
+                this.broadcast({ type: "status", status });
+                this.broadcast({ type: "branch", branch });
+            }
+            catch (error) {
+                console.error("Error checking Git status:", error);
+            }
+        }, 10000); // Check every 10 seconds as a fallback
+        this.gitWatcher = watcher;
+    }
+    async getGitChanges() {
+        try {
+            // Use git status --porcelain to get machine-readable output
+            const { exec } = await import("child_process");
+            return new Promise((resolve, reject) => {
+                exec("git status --porcelain", { cwd: process.cwd() }, (error, stdout, stderr) => {
+                    if (error) {
+                        console.error("Error getting git changes:", error);
+                        resolve([]);
+                        return;
+                    }
+                    const changes = [];
+                    const lines = stdout.trim().split("\n");
+                    for (const line of lines) {
+                        if (!line.trim())
+                            continue;
+                        // Parse git status output (XY PATH)
+                        const status = line.substring(0, 2).trim();
+                        const path = line.substring(3).trim();
+                        let fileStatus = "unchanged";
+                        if (status.startsWith("M")) {
+                            fileStatus = "modified";
+                        }
+                        else if (status.startsWith("A")) {
+                            fileStatus = "added";
+                        }
+                        else if (status.startsWith("D")) {
+                            fileStatus = "deleted";
+                        }
+                        else if (status.startsWith("U") || status.includes("U")) {
+                            fileStatus = "conflicted";
+                        }
+                        else if (status.startsWith("??")) {
+                            fileStatus = "added";
+                        }
+                        if (fileStatus !== "unchanged") {
+                            changes.push({
+                                path,
+                                status: fileStatus,
+                            });
+                        }
+                    }
+                    resolve(changes);
+                });
+            });
+        }
+        catch (error) {
+            console.error("Failed to get git changes:", error);
+            return [];
+        }
+    }
+    async getGitRemoteStatus() {
+        try {
+            const { exec } = await import("child_process");
+            return new Promise((resolve) => {
+                // Get ahead/behind status for current branch
+                exec("git rev-list --left-right --count HEAD...@{u}", { cwd: process.cwd() }, (error, stdout, stderr) => {
+                    if (error) {
+                        // If there's no upstream branch, return 0 for both
+                        resolve({ ahead: 0, behind: 0 });
+                        return;
+                    }
+                    const [behind, ahead] = stdout.trim().split("\t").map(Number);
+                    resolve({ ahead, behind });
+                });
+            });
+        }
+        catch (error) {
+            console.error("Failed to get remote status:", error);
+            return { ahead: 0, behind: 0 };
+        }
+    }
+    async getCurrentGitBranch() {
+        try {
+            const { exec } = await import("child_process");
+            return new Promise((resolve) => {
+                exec("git branch --show-current", { cwd: process.cwd() }, (error, stdout, stderr) => {
+                    if (error) {
+                        console.error("Error getting current branch:", error);
+                        resolve("main");
+                        return;
+                    }
+                    resolve(stdout.trim() || "main");
+                });
+            });
+        }
+        catch (error) {
+            console.error("Failed to get current branch:", error);
+            return "main";
+        }
+    }
+}