testeranto 0.202.0 → 0.205.0

package/dist/module/src/components/pure/SingleProcessView.js

@@ -1,130 +0,0 @@
-import React, { useEffect, useRef, useState } from 'react';
-import { Badge, Alert } from 'react-bootstrap';
-import { useWebSocket } from '../../App';
-export const SingleProcessView = ({ process, onBack, loading, onKillProcess, }) => {
-    var _a;
-    const terminalRef = useRef(null);
-    const [inputEnabled, setInputEnabled] = useState(false);
-    const ws = useWebSocket();
-    // Update input enabled status
-    useEffect(() => {
-        setInputEnabled((process === null || process === void 0 ? void 0 : process.status) === 'running');
-    }, [process === null || process === void 0 ? void 0 : process.status]);
-    // Handle user input
-    const handleInput = (data) => {
-        if (ws && ws.readyState === WebSocket.OPEN && (process === null || process === void 0 ? void 0 : process.status) === 'running') {
-            console.log('Sending stdin:', data);
-            ws.send(JSON.stringify({
-                type: 'stdin',
-                processId: process.processId,
-                data: data
-            }));
-        }
-        else {
-            console.log('Cannot send stdin - conditions not met:', {
-                wsExists: !!ws,
-                wsReady: ws === null || ws === void 0 ? void 0 : ws.readyState,
-                processStatus: process === null || process === void 0 ? void 0 : process.status
-            });
-        }
-    };
-    const getStatusBadge = (process) => {
-        switch (process.status) {
-            case 'running':
-                return React.createElement(Badge, { bg: "success" }, "Running");
-            case 'exited':
-                return React.createElement(Badge, { bg: "secondary" },
-                    "Exited (",
-                    process.exitCode,
-                    ")");
-            case 'error':
-                return React.createElement(Badge, { bg: "danger" }, "Error");
-            default:
-                return React.createElement(Badge, { bg: "warning" }, "Unknown");
-        }
-    };
-    if (loading) {
-        return React.createElement("div", null, "Initializing terminal...");
-    }
-    if (!process) {
-        return (React.createElement(Alert, { variant: "warning" }, "Process not found or not running. The process may have completed."));
-    }
-    return (React.createElement("div", { style: { height: '100%', display: 'flex', flexDirection: 'column' } },
-        React.createElement("div", { style: { flex: 1, display: 'flex', overflow: 'hidden' } },
-            React.createElement("div", { className: " border-end", style: {
-                    width: '300px',
-                    minWidth: '300px',
-                    flexShrink: 0,
-                    overflowY: 'auto'
-                } },
-                React.createElement("div", { className: "p-3" },
-                    React.createElement("div", { className: "mb-3" },
-                        React.createElement("strong", null, "Command:"),
-                        React.createElement("code", { className: "bg-white p-2 rounded d-block mt-1", style: { fontSize: '0.8rem' } }, process.command)),
-                    React.createElement("div", { className: "mb-2" },
-                        React.createElement("strong", null, "Status:"),
-                        React.createElement("div", { className: "mt-1" }, getStatusBadge(process))),
-                    React.createElement("div", { className: "mb-2" },
-                        React.createElement("strong", null, "PID:"),
-                        React.createElement("div", { className: "text-muted" }, process.pid || 'N/A')),
-                    React.createElement("div", { className: "mb-2" },
-                        React.createElement("strong", null, "Started:"),
-                        React.createElement("div", { className: "text-muted" }, new Date(process.timestamp).toLocaleString())),
-                    process.exitCode !== undefined && (React.createElement("div", { className: "mb-2" },
-                        React.createElement("strong", null, "Exit Code:"),
-                        React.createElement("div", { className: "text-muted" }, process.exitCode))),
-                    process.error && (React.createElement("div", { className: "mt-3" },
-                        React.createElement("strong", { className: "text-danger" }, "Error:"),
-                        React.createElement("div", { className: "text-danger small mt-1" }, process.error))))),
-            React.createElement("div", { style: { flex: 1, display: 'flex', flexDirection: 'column', minHeight: 0 } },
-                React.createElement("div", { className: "d-flex justify-content-between align-items-center p-3 border-bottom bg-white", style: { flexShrink: 0 } },
-                    React.createElement("small", { className: "text-muted" },
-                        ((_a = process.logs) === null || _a === void 0 ? void 0 : _a.length) || 0,
-                        " lines")),
-                React.createElement("div", { className: "bg-dark text-light flex-grow-1", style: {
-                        overflowY: 'auto',
-                        fontFamily: 'Monaco, Menlo, "Ubuntu Mono", monospace',
-                        fontSize: '14px',
-                        lineHeight: '1.4',
-                        padding: '1rem'
-                    }, ref: (el) => {
-                        // Auto-scroll to bottom when logs update
-                        if (el) {
-                            el.scrollTop = el.scrollHeight;
-                        }
-                    } }, process.logs && process.logs.length > 0 ? (React.createElement("pre", { className: "mb-0", style: {
-                        whiteSpace: 'pre-wrap',
-                        wordBreak: 'break-word',
-                        backgroundColor: 'transparent',
-                        border: 'none',
-                        color: 'inherit'
-                    } }, process.logs.join(''))) : (React.createElement("div", { className: "text-muted text-center py-4" },
-                    React.createElement("i", null, "No output yet")))))),
-        inputEnabled && (React.createElement("div", { className: "border-top bg-white p-3", style: { flexShrink: 0 } },
-            React.createElement("div", { className: "input-group" },
-                React.createElement("input", { type: "text", className: "form-control", placeholder: "Type input and press Enter...", onKeyPress: (e) => {
-                        if (e.key === 'Enter') {
-                            const target = e.target;
-                            const inputValue = target.value;
-                            if (inputValue.trim()) {
-                                handleInput(inputValue + '\n');
-                                target.value = '';
-                            }
-                        }
-                    }, autoFocus: true }),
-                React.createElement("button", { className: "btn btn-primary", type: "button", onClick: () => {
-                        const input = document.querySelector('input');
-                        const inputValue = input.value;
-                        if (inputValue.trim()) {
-                            handleInput(inputValue + '\n');
-                            input.value = '';
-                        }
-                    } }, "Send")),
-            React.createElement("small", { className: "text-muted" }, "\uD83D\uDCA1 Press Enter to send input to the process"))),
-        !inputEnabled && process.status === 'running' && (React.createElement(Alert, { variant: "info", className: "m-3", style: { flexShrink: 0 } },
-            React.createElement(Alert.Heading, { className: "h6" }, "Input Disabled"),
-            React.createElement("small", null, "Terminal input is temporarily unavailable. Try refreshing the page."))),
-        process.status !== 'running' && (React.createElement(Alert, { variant: "secondary", className: "m-3", style: { flexShrink: 0 } },
-            React.createElement(Alert.Heading, { className: "h6" }, "Read-only Mode"),
-            React.createElement("small", null, "This process is no longer running. You can view the output logs but cannot send input.")))));
-};

package/dist/module/src/components/pure/TestPageView.js

@@ -1,336 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import React, { useState, useEffect } from "react";
-import { useNavigate } from "react-router-dom";
-import { useWebSocket } from "../../App";
-import { STANDARD_LOGS, RUNTIME_SPECIFIC_LOGS, } from "../../utils/logFiles";
-import { Container, Row, Col, Button, Modal } from "react-bootstrap";
-import { Editor } from "@monaco-editor/react";
-import { NavBar } from "./NavBar";
-import { FileTreeItem } from "./FileTreeItem";
-import { FileTree } from "./FileTree";
-import { ToastNotification } from "./ToastNotification";
-import { getLanguage, renderTestResults } from "./TestPageView_utils";
-export const TestPageView = ({ projectName, testName, decodedTestPath, runtime, testsExist, errorCounts, logs, isWebSocketConnected, }) => {
-    const navigate = useNavigate();
-    const [showAiderModal, setShowAiderModal] = useState(false);
-    const [messageOption, setMessageOption] = useState("default");
-    const [customMessage, setCustomMessage] = useState(typeof logs["message.txt"] === "string"
-        ? logs["message.txt"]
-        : "make a script that prints hello");
-    const [showToast, setShowToast] = useState(false);
-    const [toastMessage, setToastMessage] = useState("");
-    const [toastVariant, setToastVariant] = useState("success");
-    const [expandedSections, setExpandedSections] = useState({
-        standardLogs: true,
-        runtimeLogs: true,
-        sourceFiles: true,
-        buildErrors: true,
-    });
-    const [isNavbarCollapsed, setIsNavbarCollapsed] = useState(false);
-    // Extract build errors and warnings relevant to this test
-    const [buildErrors, setBuildErrors] = useState({ errors: [], warnings: [] });
-    useEffect(() => {
-        var _a, _b, _c;
-        const metafile = (_a = logs.build_logs) === null || _a === void 0 ? void 0 : _a.metafile;
-        if (!metafile) {
-            setBuildErrors({ errors: [], warnings: [] });
-            return;
-        }
-        const sourceFilesSet = new Set();
-        // Collect all input files from metafile outputs related to this test
-        Object.entries(metafile.outputs || {}).forEach(([outputPath, output]) => {
-            // Normalize paths for comparison
-            const normalizedTestName = testName.replace(/\\/g, "/");
-            const normalizedEntryPoint = output.entryPoint
-                ? output.entryPoint.replace(/\\/g, "/")
-                : "";
-            if (normalizedEntryPoint.includes(normalizedTestName)) {
-                Object.keys(output.inputs || {}).forEach((inputPath) => {
-                    sourceFilesSet.add(inputPath.replace(/\\/g, "/"));
-                });
-            }
-        });
-        // Filter errors and warnings to those originating from source files of this test
-        const filteredErrors = (((_b = logs.build_logs) === null || _b === void 0 ? void 0 : _b.errors) || []).filter((err) => {
-            if (!err.location || !err.location.file)
-                return false;
-            return sourceFilesSet.has(err.location.file.replace(/\\/g, "/"));
-        });
-        const filteredWarnings = (((_c = logs.build_logs) === null || _c === void 0 ? void 0 : _c.warnings) || []).filter((warn) => {
-            if (!warn.location || !warn.location.file)
-                return false;
-            return sourceFilesSet.has(warn.location.file.replace(/\\/g, "/"));
-        });
-        setBuildErrors({ errors: filteredErrors, warnings: filteredWarnings });
-    }, [logs, testName]);
-    // Update customMessage when logs change
-    useEffect(() => {
-        if (typeof logs["message.txt"] === "string" && logs["message.txt"].trim()) {
-            setCustomMessage(logs["message.txt"]);
-        }
-    }, [logs]);
-    // Use the centralized WebSocket from App context
-    const wsContext = useWebSocket();
-    const ws = wsContext === null || wsContext === void 0 ? void 0 : wsContext.ws;
-    const [activeTab, setActiveTab] = React.useState("tests.json");
-    const [selectedFile, setSelectedFile] = useState(null);
-    const [selectedSourcePath, setSelectedSourcePath] = useState(null);
-    const [editorTheme, setEditorTheme] = useState("vs-dark");
-    return (React.createElement(Container, { fluid: true, className: "px-0" },
-        React.createElement(NavBar, { title: decodedTestPath, backLink: `/projects/${projectName}`, navItems: [
-                {
-                    label: "",
-                    badge: {
-                        variant: runtime === "node"
-                            ? "primary"
-                            : runtime === "web"
-                                ? "success"
-                                : "info",
-                        text: runtime,
-                    },
-                    className: "pe-none d-flex align-items-center gap-2",
-                },
-            ], rightContent: React.createElement(Button, { variant: "info", onClick: () => setShowAiderModal(true), className: "ms-2 position-relative", title: isWebSocketConnected
-                    ? "AI Assistant"
-                    : "AI Assistant (WebSocket not connected)", disabled: !isWebSocketConnected },
-                "\uD83E\uDD16",
-                !isWebSocketConnected && (React.createElement("span", { className: "position-absolute top-0 start-100 translate-middle p-1 bg-danger border border-light rounded-circle", title: "WebSocket disconnected" },
-                    React.createElement("span", { className: "visually-hidden" }, "WebSocket disconnected")))) }),
-        React.createElement(Modal, { show: showAiderModal, onHide: () => setShowAiderModal(false), size: "lg", onShow: () => setMessageOption("default") },
-            React.createElement(Modal.Header, { closeButton: true },
-                React.createElement(Modal.Title, null, "Aider")),
-            React.createElement(Modal.Body, null,
-                React.createElement("div", { className: "mb-3" },
-                    React.createElement("div", { className: "form-check" },
-                        React.createElement("input", { className: "form-check-input", type: "radio", name: "messageOption", id: "defaultMessage", value: "default", checked: messageOption === "default", onChange: () => setMessageOption("default") }),
-                        React.createElement("label", { className: "form-check-label", htmlFor: "defaultMessage" }, "Use default message.txt")),
-                    React.createElement("div", { className: "form-check" },
-                        React.createElement("input", { className: "form-check-input", type: "radio", name: "messageOption", id: "customMessage", value: "custom", checked: messageOption === "custom", onChange: () => setMessageOption("custom") }),
-                        React.createElement("label", { className: "form-check-label", htmlFor: "customMessage" }, "Use custom message")),
-                    messageOption === "custom" && (React.createElement("div", { className: "mt-2" },
-                        React.createElement("textarea", { className: "form-control", rows: 8, placeholder: "Enter your custom message", value: customMessage, onChange: (e) => setCustomMessage(e.target.value), style: { minHeight: "500px" } }))))),
-            React.createElement(Modal.Footer, null,
-                React.createElement(Button, { variant: "primary", onClick: async () => {
-                        try {
-                            const promptPath = `testeranto/reports/${projectName}/${testName
-                                .split(".")
-                                .slice(0, -1)
-                                .join(".")}/${runtime}/prompt.txt`;
-                            let command = `aider --load ${promptPath}`;
-                            if (messageOption === "default") {
-                                const messagePath = `testeranto/reports/${projectName}/${testName
-                                    .split(".")
-                                    .slice(0, -1)
-                                    .join(".")}/${runtime}/message.txt`;
-                                command += ` --message-file ${messagePath}`;
-                            }
-                            else {
-                                command += ` --message "${customMessage}"`;
-                            }
-                            // Send command to server via the centralized WebSocket
-                            if (isWebSocketConnected && ws) {
-                                ws.send(JSON.stringify({
-                                    type: "executeCommand",
-                                    command: command,
-                                }));
-                                setToastMessage("Command sent to server");
-                                setToastVariant("success");
-                                setShowToast(true);
-                                setShowAiderModal(false);
-                                // Navigate to process manager page
-                                setTimeout(() => {
-                                    navigate("/processes");
-                                }, 1000);
-                            }
-                            else {
-                                setToastMessage("WebSocket connection not ready");
-                                setToastVariant("danger");
-                                setShowToast(true);
-                            }
-                        }
-                        catch (err) {
-                            console.error("WebSocket error:", err);
-                            setToastMessage("Error preparing command");
-                            setToastVariant("danger");
-                            setShowToast(true);
-                        }
-                    } }, "Run Aider Command"))),
-        React.createElement(Row, { className: "g-0" },
-            React.createElement(Col, { sm: 3, className: "border-end", style: {
-                    height: "calc(100vh - 56px)",
-                    overflow: "auto",
-                    backgroundColor: "#f8f9fa",
-                } },
-                React.createElement("div", { className: "p-2 border-bottom" },
-                    React.createElement("small", { className: "fw-bold text-muted" }, "EXPLORER")),
-                React.createElement("div", { className: "p-2" },
-                    React.createElement("div", { className: "d-flex align-items-center text-muted mb-1", style: { cursor: "pointer", fontSize: "0.875rem" }, onClick: () => setExpandedSections((prev) => (Object.assign(Object.assign({}, prev), { standardLogs: !prev.standardLogs }))) },
-                        React.createElement("i", { className: `bi bi-chevron-${expandedSections.standardLogs ? "down" : "right"} me-1` }),
-                        React.createElement("span", null, "Standard Logs")),
-                    expandedSections.standardLogs && (React.createElement("div", null, Object.values(STANDARD_LOGS).map((logName) => {
-                        const logContent = logs ? logs[logName] : undefined;
-                        const exists = logContent !== undefined &&
-                            ((typeof logContent === "string" &&
-                                logContent.trim() !== "") ||
-                                (typeof logContent === "object" &&
-                                    logContent !== null &&
-                                    Object.keys(logContent).length > 0));
-                        return (React.createElement(FileTreeItem, { key: logName, name: logName, isFile: true, level: 1, isSelected: activeTab === logName, exists: exists, onClick: () => {
-                                if (exists) {
-                                    setActiveTab(logName);
-                                    setSelectedFile({
-                                        path: logName,
-                                        content: typeof logContent === "string"
-                                            ? logContent
-                                            : JSON.stringify(logContent, null, 2),
-                                        language: logName.endsWith(".json")
-                                            ? "json"
-                                            : "plaintext",
-                                    });
-                                }
-                                else {
-                                    setActiveTab(logName);
-                                    setSelectedFile({
-                                        path: logName,
-                                        content: `// ${logName} not found or empty\nThis file was not generated during the test run.`,
-                                        language: "plaintext",
-                                    });
-                                }
-                            } }));
-                    })))),
-                runtime &&
-                    RUNTIME_SPECIFIC_LOGS[runtime] &&
-                    Object.values(RUNTIME_SPECIFIC_LOGS[runtime])
-                        .length > 0 && (React.createElement("div", { className: "p-2" },
-                    React.createElement("div", { className: "d-flex align-items-center text-muted mb-1", style: { cursor: "pointer", fontSize: "0.875rem" }, onClick: () => setExpandedSections((prev) => (Object.assign(Object.assign({}, prev), { runtimeLogs: !prev.runtimeLogs }))) },
-                        React.createElement("i", { className: `bi bi-chevron-${expandedSections.runtimeLogs ? "down" : "right"} me-1` }),
-                        React.createElement("span", null, "Runtime Logs")),
-                    expandedSections.runtimeLogs && (React.createElement("div", null, Object.values(RUNTIME_SPECIFIC_LOGS[runtime]).map((logName) => {
-                        const logContent = logs ? logs[logName] : undefined;
-                        const exists = logContent !== undefined &&
-                            ((typeof logContent === "string" &&
-                                logContent.trim() !== "") ||
-                                (typeof logContent === "object" &&
-                                    logContent !== null &&
-                                    Object.keys(logContent).length > 0));
-                        return (React.createElement(FileTreeItem, { key: logName, name: logName, isFile: true, level: 1, isSelected: activeTab === logName, exists: exists, onClick: () => {
-                                if (exists) {
-                                    setActiveTab(logName);
-                                    setSelectedFile({
-                                        path: logName,
-                                        content: typeof logContent === "string"
-                                            ? logContent
-                                            : JSON.stringify(logContent, null, 2),
-                                        language: logName.endsWith(".json")
-                                            ? "json"
-                                            : "plaintext",
-                                    });
-                                }
-                                else {
-                                    setActiveTab(logName);
-                                    setSelectedFile({
-                                        path: logName,
-                                        content: `// ${logName} not found or empty\nThis file was not generated during the test run.`,
-                                        language: "plaintext",
-                                    });
-                                }
-                            } }));
-                    }))))),
-                logs && logs.source_files && (React.createElement("div", { className: "p-2" },
-                    React.createElement("div", { className: "d-flex align-items-center text-muted mb-1", style: { cursor: "pointer", fontSize: "0.875rem" }, onClick: () => setExpandedSections((prev) => (Object.assign(Object.assign({}, prev), { sourceFiles: !prev.sourceFiles }))) },
-                        React.createElement("i", { className: `bi bi-chevron-${expandedSections.sourceFiles ? "down" : "right"} me-1` }),
-                        React.createElement("span", null, "Source Files")),
-                    expandedSections.sourceFiles && (React.createElement("div", null,
-                        React.createElement(FileTree, { data: logs.source_files, onSelect: (path, content) => {
-                                setActiveTab("source_file");
-                                setSelectedSourcePath(path);
-                                setSelectedFile({
-                                    path,
-                                    content,
-                                    language: getLanguage(path),
-                                });
-                            }, level: 1, selectedSourcePath: selectedSourcePath })))))),
-            React.createElement(Col, { sm: 6, className: "border-end p-0", style: { height: "calc(100vh - 56px)", overflow: "hidden" } },
-                React.createElement(Editor, { height: "100%", path: (selectedFile === null || selectedFile === void 0 ? void 0 : selectedFile.path) || "empty", defaultLanguage: (selectedFile === null || selectedFile === void 0 ? void 0 : selectedFile.language) || "plaintext", value: (selectedFile === null || selectedFile === void 0 ? void 0 : selectedFile.content) || "// Select a file to view its contents", theme: editorTheme, options: {
-                        minimap: { enabled: false },
-                        fontSize: 14,
-                        wordWrap: "on",
-                        automaticLayout: true,
-                        readOnly: !(selectedFile === null || selectedFile === void 0 ? void 0 : selectedFile.path.includes("source_files")),
-                    } })),
-            React.createElement(Col, { sm: 3, className: "p-0 border-start", style: { height: "calc(100vh - 56px)", overflow: "auto" } },
-                React.createElement("div", { className: "p-3" },
-                    (selectedFile === null || selectedFile === void 0 ? void 0 : selectedFile.path.endsWith("tests.json")) && (React.createElement("div", { className: "test-results-preview" }, typeof selectedFile.content === "string"
-                        ? renderTestResults(JSON.parse(selectedFile.content), buildErrors, projectName, testName, runtime)
-                        : renderTestResults(selectedFile.content, buildErrors, projectName, testName, runtime))),
-                    (selectedFile === null || selectedFile === void 0 ? void 0 : selectedFile.path.match(/\.(png|jpg|jpeg|gif|svg)$/i)) && (React.createElement("div", { className: "text-center" },
-                        React.createElement("img", { src: selectedFile.content, alt: selectedFile.path, className: "img-fluid", style: { maxHeight: "300px" } }),
-                        React.createElement("div", { className: "mt-2" },
-                            React.createElement("a", { href: selectedFile.content, target: "_blank", rel: "noopener noreferrer", className: "btn btn-sm btn-outline-primary" }, "Open Full Size")))),
-                    (selectedFile === null || selectedFile === void 0 ? void 0 : selectedFile.path.endsWith("build.json")) && (React.createElement("div", null,
-                        React.createElement("h5", null, "Build Information"),
-                        (() => {
-                            var _a, _b;
-                            try {
-                                const buildData = JSON.parse(selectedFile.content);
-                                return (React.createElement(React.Fragment, null,
-                                    ((_a = buildData.errors) === null || _a === void 0 ? void 0 : _a.length) > 0 && (React.createElement("div", { className: "mb-3" },
-                                        React.createElement("h6", { className: "text-danger" },
-                                            "Errors (",
-                                            buildData.errors.length,
-                                            ")"),
-                                        React.createElement("ul", { className: "list-unstyled" }, buildData.errors.map((error, index) => (React.createElement("li", { key: index, className: "mb-2 p-2  rounded" },
-                                            React.createElement("div", { className: "text-danger fw-bold" }, error.text),
-                                            error.location && (React.createElement("div", { className: "small text-muted" },
-                                                "File: ",
-                                                error.location.file,
-                                                "Line: ",
-                                                error.location.line,
-                                                "Column: ",
-                                                error.location.column)),
-                                            error.notes && error.notes.length > 0 && (React.createElement("div", { className: "small" },
-                                                "Notes:",
-                                                React.createElement("ul", null, error.notes.map((note, noteIndex) => (React.createElement("li", { key: noteIndex }, note.text)))))))))))),
-                                    ((_b = buildData.warnings) === null || _b === void 0 ? void 0 : _b.length) > 0 && (React.createElement("div", { className: "mb-3" },
-                                        React.createElement("h6", { className: "text-warning" },
-                                            "Warnings (",
-                                            buildData.warnings.length,
-                                            ")"),
-                                        React.createElement("ul", { className: "list-unstyled" }, buildData.warnings.map((warning, index) => (React.createElement("li", { key: index, className: "mb-2 p-2  rounded" },
-                                            React.createElement("div", { className: "text-warning fw-bold" }, warning.text),
-                                            warning.location && (React.createElement("div", { className: "small text-muted" },
-                                                "File: ",
-                                                warning.location.file,
-                                                "Line: ",
-                                                warning.location.line,
-                                                "Column: ",
-                                                warning.location.column)),
-                                            warning.notes &&
-                                                warning.notes.length > 0 && (React.createElement("div", { className: "small" },
-                                                "Notes:",
-                                                React.createElement("ul", null, warning.notes.map((note, noteIndex) => (React.createElement("li", { key: noteIndex }, note.text)))))))))))),
-                                    (!buildData.errors || buildData.errors.length === 0) &&
-                                        (!buildData.warnings ||
-                                            buildData.warnings.length === 0) && (React.createElement("div", { className: "alert alert-success" }, "No build errors or warnings"))));
-                            }
-                            catch (e) {
-                                return (React.createElement("div", { className: "alert alert-danger" },
-                                    "Error parsing build.json: ",
-                                    e.message));
-                            }
-                        })())),
-                    (selectedFile === null || selectedFile === void 0 ? void 0 : selectedFile.path.endsWith(".json")) &&
-                        !selectedFile.path.endsWith("tests.json") &&
-                        !selectedFile.path.endsWith("build.json") && (React.createElement("pre", { className: " p-2 small" },
-                        React.createElement("code", null, selectedFile.content))),
-                    (selectedFile === null || selectedFile === void 0 ? void 0 : selectedFile.path.includes("source_files")) && (React.createElement("div", null,
-                        React.createElement("div", { className: "mb-2 small text-muted" },
-                            React.createElement("i", { className: "bi bi-file-earmark-text me-1" }),
-                            selectedFile.path.split("/").pop()),
-                        React.createElement(Button, { variant: "outline-primary", size: "sm", className: "mb-2", onClick: () => {
-                                // TODO: Add save functionality
-                                alert("Save functionality will be implemented here");
-                            } }, "Save Changes")))))),
-        React.createElement(ToastNotification, { showToast: showToast, setShowToast: setShowToast, toastVariant: toastVariant, toastMessage: toastMessage })));
-};

package/dist/module/src/components/pure/TestPageView.test/implementation.js

@@ -1,121 +0,0 @@
-import { assert } from "chai";
-import * as React from "react";
-import * as ReactDom from "react-dom/client";
-export const implementation = {
-    suites: {
-        Default: "TestPageView basic rendering",
-        Navigation: "TestPageView navigation behavior",
-        ErrorStates: "TestPageView error handling",
-    },
-    givens: {
-        Default: () => (props) => {
-            // Create a container and render the component
-            const container = document.createElement('div');
-            document.body.appendChild(container);
-            const reactElement = React.createElement(props);
-            const domRoot = ReactDom.createRoot(container);
-            domRoot.render(reactElement);
-            return Object.assign({ container,
-                reactElement,
-                domRoot }, props);
-        },
-        WithErrors: () => (props) => {
-            const container = document.createElement('div');
-            document.body.appendChild(container);
-            const reactElement = React.createElement(props);
-            const domRoot = ReactDom.createRoot(container);
-            domRoot.render(reactElement);
-            return Object.assign(Object.assign({ container,
-                reactElement,
-                domRoot }, props), { errorCounts: {
-                    runTimeErrors: 1,
-                    typeErrors: 1,
-                    staticErrors: 1
-                } });
-        },
-        WithLogs: () => (props) => {
-            const container = document.createElement('div');
-            document.body.appendChild(container);
-            const reactElement = React.createElement(props);
-            const domRoot = ReactDom.createRoot(container);
-            domRoot.render(reactElement);
-            return Object.assign(Object.assign({ container,
-                reactElement,
-                domRoot }, props), { logs: {
-                    'tests.json': '{}',
-                    'stdout.log': 'test log content'
-                } });
-        },
-    },
-    whens: {
-        SwitchToTab: (tabName) => async (selection, tr, utils) => {
-            // Update the props to switch tabs
-            const newProps = Object.assign(Object.assign({}, selection), { activeTab: tabName });
-            const newReactElement = React.createElement(selection.reactElement.type, newProps);
-            selection.domRoot.render(newReactElement);
-            return (sel) => (Object.assign(Object.assign({}, sel), { reactElement: newReactElement, activeTab: tabName }));
-        },
-        ClickAiderButton: () => async (selection, tr, utils) => {
-            // Find and click the Aider button
-            const button = selection.container.querySelector('button');
-            if (button) {
-                button.click();
-            }
-            return (sel) => sel;
-        },
-    },
-    thens: {
-        takeScreenshot: (name) => async (ssel, utils) => (sel) => {
-            // Screenshot functionality would be implemented here
-            return Promise.resolve(sel);
-        },
-        RendersNavBar: () => async (ssel, utils) => (sel) => {
-            const navBar = sel.container.querySelector(".navbar");
-            assert.isNotNull(navBar, "Navbar should be rendered");
-            return Promise.resolve(sel);
-        },
-        ShowsActiveTab: (tabName) => async (ssel, utils) => (sel) => {
-            // Check if the active tab matches
-            assert.equal(sel.activeTab, tabName, `Active tab should be ${tabName}`);
-            return Promise.resolve(sel);
-        },
-        ShowsErrorCounts: () => async (ssel, utils) => (sel) => {
-            // Check for error badges
-            const badges = sel.container.querySelectorAll(".badge");
-            assert.isAtLeast(badges.length, 0, "Should show at least one badge");
-            return Promise.resolve(sel);
-        },
-        ShowsTestResults: () => async (ssel, utils) => (sel) => {
-            // Check if test results are shown
-            if (sel.testsExist) {
-                const testResults = sel.container.querySelector(".test-results");
-                assert.isNotNull(testResults, "Test results should be shown when tests exist");
-            }
-            return Promise.resolve(sel);
-        },
-        ShowsLogs: () => async (ssel, utils) => (sel) => {
-            // Check if logs are shown
-            const logs = sel.container.querySelector("pre");
-            assert.isNotNull(logs, "Logs should be shown");
-            return Promise.resolve(sel);
-        },
-        ShowsTypeErrors: () => async (ssel, utils) => (sel) => {
-            // Check if type errors are shown
-            const typeErrors = sel.container.querySelector('[data-testid="type-errors"]');
-            assert.isNotNull(typeErrors, "Type errors should be shown");
-            return Promise.resolve(sel);
-        },
-        ShowsLintErrors: () => async (ssel, utils) => (sel) => {
-            // Check if lint errors are shown
-            const lintErrors = sel.container.querySelector('[data-testid="lint-errors"]');
-            assert.isNotNull(lintErrors, "Lint errors should be shown");
-            return Promise.resolve(sel);
-        },
-        AiderButtonCopiesCommand: () => async (ssel, utils) => (sel) => {
-            // Check if Aider button exists
-            const aiderButton = sel.container.querySelector('button[title*="AI Assistant"]');
-            assert.isNotNull(aiderButton, "Aider button should be present");
-            return Promise.resolve(sel);
-        },
-    },
-};

package/dist/module/src/components/pure/TestPageView.test/index.js

@@ -1,10 +0,0 @@
-import Testeranto from "testeranto-react/src/react-dom/jsx/web";
-import { MemoryRouter } from "react-router-dom";
-import { implementation } from "./implementation";
-import { specification } from "./specification";
-import { TestPageView } from "../TestPageView";
-import React from "react";
-import "./../../../App.scss";
-const WrappedTestPageView = (props) => (React.createElement(MemoryRouter, null,
-    React.createElement(TestPageView, Object.assign({}, props))));
-export default Testeranto(implementation, specification, WrappedTestPageView);

package/dist/module/src/components/pure/TestPageView.test/specification.js

@@ -1,22 +0,0 @@
-export const specification = (Suite, Given, When, Then) => {
-    return [
-        Suite.Default("TestPageView basic rendering", {
-            "renders navigation bar": Given.Default([], [], [Then.RendersNavBar()]),
-            "shows error counts": Given.Default([], [], [Then.ShowsErrorCounts()]),
-            "shows test results when data exists": Given.Default([], [], [Then.takeScreenshot("shot.png"), Then.ShowsTestResults()]),
-        }),
-        Suite.Navigation("TestPageView navigation behavior", {
-            "shows results tab by default": Given.Default([], [], [Then.ShowsActiveTab("results")]),
-            "switches to logs tab": Given.Default([], [When.SwitchToTab("logs")], [Then.ShowsActiveTab("logs"), Then.ShowsLogs()]),
-            "copies aider command when button clicked": Given.Default([], [When.ClickAiderButton()], [Then.AiderButtonCopiesCommand()]),
-        }),
-        Suite.ErrorStates("TestPageView error handling", {
-            "shows error state when tests fail": Given.WithErrors([], [], [
-                Then.ShowsErrorCounts(),
-                Then.ShowsTypeErrors(),
-                Then.ShowsLintErrors(),
-            ]),
-            "shows logs when available": Given.WithLogs([], [], [Then.ShowsLogs()]),
-        }),
-    ];
-};