testeranto 0.202.0 → 0.203.0

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

@@ -1,197 +0,0 @@
-/* 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 ts from "typescript";
-import fs from "fs";
-import ansiC from "ansi-colors";
-import { ESLint } from "eslint";
-import tsc from "tsc-prog";
-import { lintPather, tscPather } from "../utils";
-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_WithBuild {
-    constructor(configs, name, mode) {
-        super(configs, name, mode);
-        this.summary = {};
-        this.tscCheck = async ({ entrypoint, addableFiles, platform, }) => {
-            const processId = `tsc-${entrypoint}-${Date.now()}`;
-            const command = `tsc check for ${entrypoint}`;
-            const tscPromise = (async () => {
-                try {
-                    this.typeCheckIsRunning(entrypoint);
-                }
-                catch (e) {
-                    // Log error through process manager
-                    throw new Error(`Error in tscCheck: ${e.message}`);
-                }
-                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) => {
-            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);
-            }
-            else {
-                // Fallback to just running the promise
-                await eslintPromise;
-            }
-        };
-        this.makePrompt = async (entryPoint, addableFiles, platform) => {
-            await makePromptInternal(this.summary, this.name, entryPoint, addableFiles, platform);
-            this.checkForShutdown();
-        };
-        this.typeCheckIsRunning = (src) => {
-            if (!this.summary[src]) {
-                throw `this.summary[${src}] is undefined`;
-            }
-            this.summary[src].typeErrors = "?";
-        };
-        this.typeCheckIsNowDone = (src, failures) => {
-            if (!this.summary[src]) {
-                throw `this.summary[${src}] is undefined`;
-            }
-            if (failures === 0) {
-                console.log(ansiC.green(ansiC.inverse(`tsc > ${src}`)));
-            }
-            else {
-                console.log(ansiC.red(ansiC.inverse(`tsc > ${src} failed ${failures} times`)));
-            }
-            this.summary[src].typeErrors = failures;
-            this.writeBigBoard();
-            this.checkForShutdown();
-        };
-        this.lintIsRunning = (src) => {
-            if (!this.summary[src]) {
-                throw `this.summary[${src}] is undefined`;
-            }
-            this.summary[src].staticErrors = "?";
-            this.writeBigBoard();
-        };
-        this.lintIsNowDone = (src, failures) => {
-            if (!this.summary[src]) {
-                throw `this.summary[${src}] is undefined`;
-            }
-            if (failures === 0) {
-                console.log(ansiC.green(ansiC.inverse(`eslint > ${src}`)));
-            }
-            else {
-                console.log(ansiC.red(ansiC.inverse(`eslint > ${src} failed ${failures} times`)));
-            }
-            this.summary[src].staticErrors = failures;
-            this.writeBigBoard();
-            this.checkForShutdown();
-        };
-        this.bddTestIsRunning = (src) => {
-            if (!this.summary[src]) {
-                throw `this.summary[${src}] is undefined`;
-            }
-            this.summary[src].runTimeErrors = "?";
-            this.writeBigBoard();
-        };
-        this.bddTestIsNowDone = (src, failures) => {
-            if (!this.summary[src]) {
-                throw `this.summary[${src}] is undefined`;
-            }
-            this.summary[src].runTimeErrors = failures;
-            this.writeBigBoard();
-            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,
-            });
-        };
-        this.summary = {};
-        // Initialize all test entries first
-        this.configs.tests.forEach(([t, rt, tr, sidecars]) => {
-            this.ensureSummaryEntry(t);
-            sidecars.forEach(([sidecarName]) => {
-                this.ensureSummaryEntry(sidecarName, true);
-            });
-        });
-    }
-    ensureSummaryEntry(src, isSidecar = false) {
-        if (!this.summary[src]) {
-            this.summary[src] = {
-                typeErrors: undefined,
-                staticErrors: undefined,
-                runTimeErrors: undefined,
-                prompt: undefined,
-                failingFeatures: {},
-            };
-            if (isSidecar) {
-                // Sidecars don't need all fields
-                // delete this.summary[src].runTimeError;
-                // delete this.summary[src].prompt;
-            }
-        }
-        return this.summary[src];
-    }
-}

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

@@ -1,477 +0,0 @@
-/* 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";
-        }
-    }
-}