testeranto 0.173.0 → 0.189.0

package/src/types/features.ts

@@ -0,0 +1,38 @@
+export type TreeNode = {
+  name: string;
+  type: 'project' | 'file';
+  path?: string;
+  children?: TreeNode[];
+};
+
+export function buildTree(projects: string[]): TreeNode[] {
+  return projects.map(projectName => ({
+    name: projectName,
+    type: 'project',
+    children: [{
+      name: 'src',
+      type: 'file',
+      children: [{
+        name: 'components',
+        type: 'file',
+        children: [{
+          name: 'pure',
+          type: 'file',
+          children: [
+            { name: 'AppFrame.test', type: 'file', path: 'src/components/pure/AppFrame.test' },
+            { name: 'FeaturesReporterView.test', type: 'file', path: 'src/components/pure/FeaturesReporterView.test' },
+            { name: 'ProjectPageView.test', type: 'file', path: 'src/components/pure/ProjectPageView.test' }
+          ]
+        }]
+      }, {
+        name: 'lib',
+        type: 'file',
+        children: [{
+          name: 'baseBuilder.test',
+          type: 'file',
+          path: 'src/lib/baseBuilder.test'
+        }]
+      }]
+    }]
+  }));
+}

package/src/utils/api.ts

@@ -1,4 +1,6 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { ISummary, IBuiltConfig } from "../Types";
+import { getLogFilesForRuntime } from "./logFiles";
 
 export const fetchProjectData = async (projectName: string) => {
   const [summaryRes, configRes] = await Promise.all([
@@ -17,10 +19,10 @@ export const fetchTestData = async (
   filepath: string,
   runTime: string
 ): Promise<{
-  testData: any | null;
-  logs: string;
-  typeErrors: string;
-  lintErrors: string;
+  // testData: any | null;
+  logs: Record<string, string>;
+  // typeErrors: string;
+  // lintErrors: string;
   error: string | null;
 }> => {
   const basePath = `reports/${projectName}/${filepath
@@ -29,45 +31,73 @@ export const fetchTestData = async (
     .join(".")}/${runTime}`;
 
   try {
-    const [testRes, logsRes, typeRes, lintRes] = await Promise.all([
+    const logFiles = getLogFilesForRuntime(runTime);
+
+    console.log("mark2", logFiles);
+
+    const [testRes, ...logRes] = await Promise.all([
       fetch(`${basePath}/tests.json`),
-      fetch(`${basePath}/logs.txt`),
+      ...logFiles.map((f) => fetch(`${basePath}/${f}`)),
       fetch(`${basePath}/type_errors.txt`),
       fetch(`${basePath}/lint_errors.txt`),
     ]);
 
+    const logs = {
+      "tests.json": await (await fetch(`${basePath}/tests.json`)).json(),
+      "type_errors.txt": await (
+        await fetch(`${basePath}/type_errors.txt`)
+      ).text(),
+      "lint_errors.txt": await (
+        await fetch(`${basePath}/lint_errors.txt`)
+      ).text(),
+      "exit.log": await (await fetch(`${basePath}/exit.log`)).text(),
+    };
+
+    if (runTime === "node") {
+      logs["stdout.log"] = await (await fetch(`${basePath}/stdout.log`)).text();
+      logs["stderr.log"] = await (await fetch(`${basePath}/stderr.log`)).text();
+    }
+
+    if (runTime === "web") {
+      logs["info.log"] = await (await fetch(`${basePath}/info.log`)).text();
+      logs["error.log"] = await (await fetch(`${basePath}/error.log`)).text();
+      logs["debug.log"] = await (await fetch(`${basePath}/debug.log`)).text();
+      logs["warn.log"] = await (await fetch(`${basePath}/warn.log`)).text();
+    }
+
+    // const logs = await logFiles.reduce(async (acc, file, i) => {
+    //   acc[file.split(".")[0]] = await logRes[i].text();
+    //   return acc;
+    // }, {});
+
     if (!testRes.ok) {
       return {
-        testData: null,
-        logs: await logsRes.text(),
-        typeErrors: await typeRes.text(),
-        lintErrors: await lintRes.text(),
-        error: "Tests did not complete successfully. Please check the build and runtime logs for errors."
+        // testData: null,
+        logs,
+        // typeErrors: await logRes[logFiles.length].text(),
+        // lintErrors: await logRes[logFiles.length + 1].text(),
+        error:
+          "Tests did not complete successfully. Please check the build and runtime logs for errors.",
       };
     }
 
+    console.log("mark1", logs);
     return {
-      testData: await testRes.json(),
-      logs: await logsRes.text(),
-      typeErrors: await typeRes.text(),
-      lintErrors: await lintRes.text(),
-      error: null
+      // testData: await testRes.json(),
+      logs,
+      // typeErrors: await logRes[logFiles.length].text(),
+      // lintErrors: await logRes[logFiles.length + 1].text(),
+      error: null,
     };
   } catch (err) {
     return {
-      testData: null,
-      logs: "",
-      typeErrors: "",
-      lintErrors: "",
-      error: `Failed to load test data: ${err instanceof Error ? err.message : String(err)}`
+      // testData: null,
+      logs: {},
+      // typeErrors: "",
+      // lintErrors: "",
+      error: `Failed to load test data: ${
+        err instanceof Error ? err.message : String(err)
+      }`,
     };
   }
 };
-
-export const fetchBuildLogs = async (projectName: string, runtime: string) => {
-  const res = await fetch(
-    `reports/${projectName}/src/lib/${projectName}.${testName}/${runtime}/metafile.json`
-  );
-  return await res.json();
-};
-

package/src/utils/featureUtils.tsx

@@ -0,0 +1,42 @@
+export interface Feature {
+  name: string;
+  status: string;
+}
+
+export const buildTree = (features: Feature[]) => {
+  const tree: any = {};
+  features.forEach(({ name, status }) => {
+    const parts = name.split(" - ");
+    const projectAndTest = parts.slice(0, 2).join(" - ");
+    const givenAndThen = parts.slice(2).join(" - ");
+    const pathParts = projectAndTest.split("/");
+    let current = tree;
+    pathParts.forEach((part) => {
+      if (!current[part]) {
+        current[part] = {};
+      }
+      current = current[part];
+    });
+    current[givenAndThen] = status;
+  });
+  return tree;
+};
+
+export const renderTree = (nodes: any) => (
+  <ul>
+    {Object.entries(nodes).map(([key, value]) => (
+      <li key={key}>
+        {typeof value === "string" ? (
+          <span>
+            {key} - {value}
+          </span>
+        ) : (
+          <>
+            <span>{key}</span>
+            {renderTree(value)}
+          </>
+        )}
+      </li>
+    ))}
+  </ul>
+);

package/src/utils/logFiles.ts

@@ -0,0 +1,26 @@
+export const NODE_LOG_FILES = ["stdout.log", "stderr.log", "exit.log"] as const;
+export const WEB_LOG_FILES = [
+  "info.log",
+  "debug.log",
+  "error.log",
+  "warn.log",
+  "exit.log",
+] as const;
+export const PURE_LOG_FILES = ["exit.log"] as const;
+
+export type NodeLogFile = (typeof NODE_LOG_FILES)[number];
+export type WebLogFile = (typeof WEB_LOG_FILES)[number];
+export type PureLogFile = (typeof PURE_LOG_FILES)[number];
+
+export const getLogFilesForRuntime = (runtime: string) => {
+  switch (runtime) {
+    case "node":
+      return NODE_LOG_FILES;
+    case "web":
+      return WEB_LOG_FILES;
+    case "pure":
+      return PURE_LOG_FILES;
+    default:
+      throw new Error(`Unknown runtime: ${runtime}`);
+  }
+};

package/src/utils/makePrompt.ts

@@ -0,0 +1,148 @@
+import fs from "fs";
+import path from "path";
+
+import { promptPather } from "../utils";
+
+import { IRunTime, ISummary } from "../Types";
+import { getLogFilesForRuntime } from "./logFiles";
+
+const makePrompt = async (
+  summary: ISummary,
+  name: string,
+  entryPoint: string,
+  addableFiles: string[],
+  runtime: IRunTime
+) => {
+  summary[entryPoint].prompt = "?";
+  const promptPath = promptPather(entryPoint, runtime, name);
+
+  // Correct directory structure: testeranto/reports/<name>/<testname>/<runtime>/
+  const testDir = path.join(
+    "testeranto",
+    "reports",
+    name,
+    entryPoint.split(".").slice(0, -1).join("."),
+    runtime
+  );
+
+  // Ensure directory exists
+  if (!fs.existsSync(testDir)) {
+    fs.mkdirSync(testDir, { recursive: true });
+  }
+
+  // Test result files
+  const testPaths = path.join(testDir, "tests.json");
+  const lintPath = path.join(testDir, "lint_errors.txt");
+  const typePath = path.join(testDir, "type_errors.txt");
+  const messagePath = path.join(testDir, "message.txt");
+
+  try {
+    await Promise.all([
+      fs.promises.writeFile(
+        promptPath,
+        `
+${addableFiles
+  .map((x) => {
+    return `/add ${x}`;
+  })
+  .join("\n")}
+
+/read node_modules/testeranto/docs/index.md
+/read node_modules/testeranto/docs/style.md
+/read node_modules/testeranto/docs/testing.ai.txt
+/read node_modules/testeranto/src/CoreTypes.ts
+
+/read ${testPaths}
+/read ${typePath}
+/read ${lintPath}
+
+/read ${getLogFilesForRuntime(runtime)
+          .map((p) => `${testDir}/${p}`)
+          .join(" ")}
+`
+      ),
+      fs.promises.writeFile(
+        messagePath,
+        `
+There are 3 types of test reports.
+1) bdd (highest priority)
+2) type checker
+3) static analysis (lowest priority)
+
+"tests.json" is the detailed result of the bdd tests.
+if these files do not exist, then something has gone badly wrong and needs to be addressed.
+
+"type_errors.txt" is the result of the type checker.
+if this file does not exist, then type check passed without errors;
+
+"lint_errors.txt" is the result of the static analysis.
+if this file does not exist, then static analysis passed without errors;
+
+BDD failures are the highest priority. Focus on passing BDD tests before addressing other concerns.
+Do not add error throwing/catching to the tests themselves.
+`
+      ),
+    ]);
+  } catch (e) {
+    console.error(`Failed to write prompt files at ${testDir}`);
+    console.error(e);
+    throw e;
+  }
+
+  summary[
+    entryPoint
+  ].prompt = `aider --model deepseek/deepseek-chat --load testeranto/${name}/reports/${runtime}/${entryPoint
+    .split(".")
+    .slice(0, -1)
+    .join(".")}/prompt.txt`;
+};
+
+// function logs(r: IRunTime) {
+//   return getLogFilesForRuntime(r);
+// }
+
+// async function logsOfRuntime(
+//   runTime: IRunTime,
+//   testDir: string
+// ): Promise<string> {
+//   try {
+//     const fileChecks = await Promise.all(
+//       getLogFilesForRuntime(runTime).map(async (f) => {
+//         const filePath = path.join(testDir, f);
+//         try {
+//           await fs.promises.access(filePath);
+//           const content = await fs.promises.readFile(filePath, "utf-8");
+//           return content;
+//         } catch {
+//           return null;
+//         }
+//       })
+//     );
+
+//     return fileChecks.filter(Boolean).join("\n");
+//   } catch (e) {
+//     console.error(`Error checking log files in ${testDir}`);
+//     console.error(e);
+//     return "";
+//   }
+// }
+
+export const makePromptInternal = (
+  summary: ISummary,
+  name: string,
+  entryPoint: string,
+  addableFiles: string[],
+  runTime: IRunTime
+) => {
+  if (runTime === "node") {
+    return makePrompt(summary, name, entryPoint, addableFiles, "node");
+  }
+
+  if (runTime === "web") {
+    return makePrompt(summary, name, entryPoint, addableFiles, "web");
+  }
+
+  if (runTime === "pure") {
+    return makePrompt(summary, name, entryPoint, addableFiles, "pure");
+  }
+};

package/src/web.html.ts

@@ -1,20 +1,20 @@
-export default (jsfilePath: string, htmlFilePath: string) => `
+export default (
+  jsfilePath: string,
+  htmlFilePath: string,
+  cssfilePath: string
+) => `
 <!DOCTYPE html>
 <html lang="en">
 
 <head>
   <script type="module" src="${jsfilePath}"></script>
-
+  <link rel="stylesheet" href="${cssfilePath}">
 </head>
 
 <body>
-  <h1>${htmlFilePath}</h1>
   <div id="root">
-
   </div>
 </body>
 
-<footer></footer>
-
 </html>
 `;

package/style.css

@@ -1,6 +1,6 @@
 @charset "UTF-8";
 /*!
- * Bootstrap  v5.3.5 (https://getbootstrap.com/)
+ * Bootstrap  v5.3.7 (https://getbootstrap.com/)
  * Copyright 2011-2025 The Bootstrap Authors
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
  */
@@ -4454,24 +4454,24 @@ textarea.form-control-lg {
     border-top-right-radius: 0;
     border-bottom-right-radius: 0;
   }
-  .card-group > .card:not(:last-child) .card-img-top,
-  .card-group > .card:not(:last-child) .card-header {
+  .card-group > .card:not(:last-child) > .card-img-top,
+  .card-group > .card:not(:last-child) > .card-header {
     border-top-right-radius: 0;
   }
-  .card-group > .card:not(:last-child) .card-img-bottom,
-  .card-group > .card:not(:last-child) .card-footer {
+  .card-group > .card:not(:last-child) > .card-img-bottom,
+  .card-group > .card:not(:last-child) > .card-footer {
     border-bottom-right-radius: 0;
   }
   .card-group > .card:not(:first-child) {
     border-top-left-radius: 0;
     border-bottom-left-radius: 0;
   }
-  .card-group > .card:not(:first-child) .card-img-top,
-  .card-group > .card:not(:first-child) .card-header {
+  .card-group > .card:not(:first-child) > .card-img-top,
+  .card-group > .card:not(:first-child) > .card-header {
     border-top-left-radius: 0;
   }
-  .card-group > .card:not(:first-child) .card-img-bottom,
-  .card-group > .card:not(:first-child) .card-footer {
+  .card-group > .card:not(:first-child) > .card-img-bottom,
+  .card-group > .card:not(:first-child) > .card-footer {
     border-bottom-left-radius: 0;
   }
 }
@@ -7053,6 +7053,10 @@ textarea.form-control-lg {
 .visually-hidden-focusable:not(:focus):not(:focus-within):not(caption) {
   position: absolute !important;
 }
+.visually-hidden *,
+.visually-hidden-focusable:not(:focus):not(:focus-within) * {
+  overflow: hidden !important;
+}
 
 .stretched-link::after {
   position: absolute;
@@ -11892,6 +11896,21 @@ textarea.form-control-lg {
   font-weight: 900;
   font-style: normal;
 }
+.video-container {
+  position: relative;
+  width: 100%;
+  height: 315px;
+  margin: 1rem 0;
+  background: #1a1a1a;
+  border-radius: 8px;
+  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+  overflow: hidden;
+}
+.video-container canvas {
+  width: 100%;
+  height: 100%;
+}
+
 body {
   font-family: "M PLUS Rounded 1c", sans-serif;
   color: var(--dark);