testeranto 0.203.0 → 0.206.0

package/src/app/frontend/fetchDataUtil.ts

@@ -0,0 +1,206 @@
+// /* eslint-disable @typescript-eslint/no-unused-vars */
+// import { summaryDotJson } from "./api";
+
+// export const fetchDataUtil = async (
+//   testResponse,
+//   metafileRes,
+//   testPath,
+//   setLogs,
+//   projectName,
+//   setSummary,
+//   setErrorCounts,
+//   setTestsExist,
+//   runtime
+// ) => {
+//   const receivedLogs = await testResponse.logs;
+//   let sourceFiles = {};
+//   let buildLogs = {};
+
+//   if (metafileRes.ok) {
+//     const metafile = await metafileRes.json();
+//     if (metafile?.metafile?.outputs) {
+//       // Find input files only for this test's entry point
+//       const tsSources = new Set<string>();
+//       const testEntryPoint = `src/${testPath}`;
+
+//       // First find all outputs that match this test
+//       const matchingOutputs = Object.entries(metafile.metafile.outputs).filter(
+//         ([outputPath, output]) => {
+//           const normalizedTestPath = testPath.replace(/\./g, "_");
+//           const testFileName = testPath.split("/").pop();
+//           const testBaseName = testFileName?.split(".").slice(0, -1).join(".");
+
+//           // Also check outputPath normalized for slashes replaced by underscores
+//           const normalizedOutputPath = outputPath.replace(/\//g, "_");
+
+//           return (
+//             output.entryPoint === testEntryPoint ||
+//             outputPath.includes(normalizedTestPath) ||
+//             normalizedOutputPath.includes(normalizedTestPath) ||
+//             (testBaseName && outputPath.includes(testBaseName))
+//           );
+//         }
+//       );
+
+//       // Then collect all inputs from matching outputs
+//       matchingOutputs.forEach(([_, output]) => {
+//         Object.keys(output.inputs).forEach((inputPath) => {
+//           // Check if this input is a source file (TypeScript or Go) and not in node_modules
+//           if (
+//             (inputPath.endsWith(".ts") ||
+//               inputPath.endsWith(".tsx") ||
+//               inputPath.endsWith(".go") ||
+//               inputPath.endsWith(".py")) &&
+//             !inputPath.includes("node_modules")
+//           ) {
+//             // Get the full input details from metafile.inputs
+//             const inputDetails = metafile.metafile.inputs[inputPath];
+//             if (inputDetails) {
+//               tsSources.add(inputPath);
+//               // Also include any imported source files (for TypeScript)
+//               // Go files don't have imports in the same way, so we'll only process for TypeScript
+//               if (inputPath.endsWith(".ts") || inputPath.endsWith(".tsx")) {
+//                 inputDetails.imports.forEach((imp) => {
+//                   if (
+//                     (imp.path.endsWith(".ts") || imp.path.endsWith(".tsx")) &&
+//                     !imp.path.includes("node_modules") &&
+//                     !imp.external
+//                   ) {
+//                     tsSources.add(imp.path);
+//                   }
+//                 });
+//               }
+//             }
+//           }
+//         });
+//       });
+
+//       // Organize source files into directory tree structure
+//       const fileTree = {};
+//       const filesList = await Promise.all(
+//         Array.from(tsSources).map(async (filePath) => {
+//           try {
+//             const fetchPath = filePath.startsWith("/")
+//               ? filePath
+//               : `/${filePath.replace(/^\.\//, "")}`;
+//             const res = await fetch(fetchPath);
+//             if (res.ok) {
+//               return {
+//                 path: filePath,
+//                 content: await res.text(),
+//               };
+//             }
+//             return null;
+//           } catch (err) {
+//             console.warn(`Failed to fetch source file ${filePath}:`, err);
+//             return null;
+//           }
+//         })
+//       );
+
+//       filesList.forEach((file) => {
+//         if (!file) return;
+
+//         const parts = file.path.split("/");
+//         let currentLevel = fileTree;
+
+//         parts.forEach((part, index) => {
+//           if (!currentLevel[part]) {
+//             if (index === parts.length - 1) {
+//               currentLevel[part] = {
+//                 __isFile: true,
+//                 content: file.content,
+//               };
+//             } else {
+//               currentLevel[part] = {};
+//             }
+//           }
+//           currentLevel = currentLevel[part];
+//         });
+//       });
+
+//       sourceFiles = fileTree;
+//       buildLogs = metafile;
+//     }
+//   }
+
+//   // Add source files and build logs to logs
+//   receivedLogs["source_files"] = sourceFiles;
+//   receivedLogs["build_logs"] = buildLogs;
+//   // console.log("Source files structure:", sourceFiles);
+//   // console.log("Build logs:", buildLogs);
+
+//   // Ensure tests.json is properly formatted
+//   if (receivedLogs["tests.json"]) {
+//     console.log("tests.json content type:", typeof receivedLogs["tests.json"]);
+//     try {
+//       // Handle both string and already-parsed JSON
+//       if (typeof receivedLogs["tests.json"] === "string") {
+//         receivedLogs["tests.json"] = JSON.parse(receivedLogs["tests.json"]);
+//       }
+//       // If it's already an object, leave it as is
+//     } catch (e) {
+//       console.error("Failed to parse tests.json:", e);
+//       // Keep the original content but don't replace it with an error object
+//     }
+//   }
+//   setLogs(receivedLogs);
+//   // setTypeErrors(testResponse.typeErrors);
+//   // setLintErrors(testResponse.lintErrors);
+
+//   try {
+//     const summaryResponse = await fetch(summaryDotJson(projectName));
+//     if (!summaryResponse.ok) throw new Error("Failed to fetch summary");
+//     const allSummaries = await summaryResponse.json();
+//     const testSummary = allSummaries[testPath];
+
+//     if (testSummary) {
+//       const counts = {
+//         typeErrors: Number(testSummary.typeErrors) || 0,
+//         staticErrors: Number(testSummary.staticErrors) || 0,
+//         runTimeErrors: Number(testSummary.runTimeErrors) || 0,
+//       };
+
+//       setSummary(testSummary);
+//       setErrorCounts(counts);
+//       setTestsExist(testSummary.testsExist !== false);
+//     }
+//   } catch (err) {
+//     console.error("Failed to load summary:", err);
+//   }
+
+//   // Fetch build.json to get build errors and warnings
+//   try {
+//     // The build.json is in the runtime directory directly under the test path
+//     // testPath is "src/lib/pmProxy.test/index.ts"
+//     // We need to use the directory path without the filename
+//     const pathParts = testPath.split("/");
+//     // const fileName = pathParts.pop();
+//     const directoryPath = pathParts.join("/");
+
+//     // Construct the path without the filename without extension
+//     const buildUrl = `/reports/${projectName}/${directoryPath}/${runtime}/build.json`;
+//     // console.log(`Fetching build.json from: ${buildUrl}`);
+
+//     const buildResponse = await fetch(buildUrl);
+//     if (buildResponse.ok) {
+//       const buildData = await buildResponse.json();
+//       console.log("Build data received:", buildData);
+//       // Add build errors and warnings to logs
+//       receivedLogs["build.json"] = buildData;
+//     } else {
+//       // console.log(
+//       //   "Build.json not found or not accessible, status:",
+//       //   buildResponse.status
+//       // );
+//       // Add an empty build.json to logs to prevent errors
+//       receivedLogs["build.json"] = { errors: [], warnings: [] };
+//     }
+//   } catch (err) {
+//     console.log("No build.json found or error fetching it:", err);
+//     // Add an empty build.json to logs to prevent errors
+//     receivedLogs["build.json"] = { errors: [], warnings: [] };
+//   }
+
+//   return receivedLogs;
+// };

package/src/app/frontend/flua/FluaPage.tsx

@@ -0,0 +1,458 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import React, { useState, useEffect } from "react";
+import { DndProvider, useDrag, useDrop } from "react-dnd";
+import { HTML5Backend } from "react-dnd-html5-backend";
+import { GenericXMLEditorPage } from "../components/stateful/GenericXMLEditorPage";
+import { XMLNode } from "../components/stateful/GenericXMLEditorPage";
+import { AttributeEditor } from "../components/stateful/GenericXMLEditor/AttributeEditor";
+
+// Function to parse XML string to XMLNode structure
+const parseXmlToNode = (xmlString: string): XMLNode => {
+  const parser = new DOMParser();
+  const xmlDoc = parser.parseFromString(xmlString, "text/xml");
+
+  const parseElement = (element: Element): XMLNode => {
+    // Get attributes
+    const attributes: Record<string, string> = {};
+    for (let i = 0; i < element.attributes.length; i++) {
+      const attr = element.attributes[i];
+      attributes[attr.name] = attr.value;
+    }
+
+    // Process children
+    const children: XMLNode[] = [];
+    let textContent: string | undefined;
+
+    for (let i = 0; i < element.childNodes.length; i++) {
+      const node = element.childNodes[i];
+      if (node.nodeType === Node.ELEMENT_NODE) {
+        children.push(parseElement(node as Element));
+      } else if (node.nodeType === Node.TEXT_NODE && node.textContent?.trim()) {
+        textContent = (textContent || "") + node.textContent;
+      }
+    }
+
+    // Trim text content if it exists
+    if (textContent) {
+      textContent = textContent.trim();
+    }
+
+    return {
+      id: `${element.nodeName}-${Date.now()}-${Math.random()}`,
+      type: element.nodeName,
+      attributes,
+      children,
+      textContent: textContent || undefined,
+    };
+  };
+
+  // Get the root element
+  const rootElement = xmlDoc.documentElement;
+  return parseElement(rootElement);
+};
+
+// Function to load XML file
+const loadXmlFile = async (filePath: string): Promise<XMLNode> => {
+  try {
+    const response = await fetch(
+      `/api/files/read?path=${encodeURIComponent(filePath)}`
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to load XML file: ${response.statusText}`);
+    }
+    const xmlContent = await response.text();
+    return parseXmlToNode(xmlContent);
+  } catch (error) {
+    console.error("Error loading XML file:", error);
+    throw error;
+  }
+};
+
+// Define node types based on the XSD
+const nodeTypes = [
+  { label: "Kanban Process", type: "kanban:KanbanProcess" },
+  { label: "Metadata", type: "core:Metadata" },
+  { label: "Version", type: "core:Version" },
+  { label: "Date Created", type: "core:DateCreated" },
+  { label: "Description", type: "core:Description" },
+  { label: "GraphML", type: "graphml:graphml" },
+  { label: "Key", type: "graphml:key" },
+  { label: "Graph", type: "graphml:graph" },
+  { label: "Node", type: "graphml:node" },
+  { label: "Data", type: "graphml:data" },
+  { label: "Edge", type: "graphml:edge" },
+];
+
+// Function to create a new node
+const createKanbanNode = (parentId: string, nodeType: string): XMLNode => {
+  const id = `${nodeType}-${Date.now()}`;
+  const baseNode: XMLNode = {
+    id,
+    type: nodeType,
+    attributes: {},
+    children: [],
+  };
+
+  // Add type-specific attributes
+  switch (nodeType) {
+    case "graphml:key":
+      baseNode.attributes = {
+        id: "new-key",
+        for: "node",
+        "attr.name": "",
+        "attr.type": "string",
+      };
+      break;
+    case "graphml:node":
+      baseNode.attributes = { id: `node-${Date.now()}` };
+      break;
+    case "graphml:data":
+      baseNode.attributes = { key: "name" };
+      break;
+    case "graphml:edge":
+      baseNode.attributes = { source: "", target: "" };
+      break;
+    // Add more cases as needed
+  }
+
+  return baseNode;
+};
+
+// Draggable Kanban Card Component
+const KanbanCard: React.FC<{
+  task: any;
+  status: string;
+  onMoveTask: (taskId: string, newStatus: string) => void;
+}> = ({ task, status, onMoveTask }) => {
+  const [{ isDragging }, drag] = useDrag(() => ({
+    type: "task",
+    item: { id: task.id, status },
+    collect: (monitor) => ({
+      isDragging: !!monitor.isDragging(),
+    }),
+  }));
+
+  return (
+    <div
+      ref={drag}
+      className="kanban-card"
+      style={{
+        background: "#fff",
+        borderRadius: "4px",
+        padding: "12px",
+        boxShadow: "0 1px 3px rgba(0,0,0,0.12), 0 1px 2px rgba(0,0,0,0.24)",
+        opacity: isDragging ? 0.5 : 1,
+        cursor: "move",
+      }}
+    >
+      <div style={{ fontWeight: "bold", marginBottom: "8px" }}>{task.name}</div>
+      <div style={{ fontSize: "0.875rem", color: "#666" }}>{task.role}</div>
+    </div>
+  );
+};
+
+// Kanban Column Component
+const KanbanColumn: React.FC<{
+  status: string;
+  tasks: any[];
+  onMoveTask: (taskId: string, newStatus: string) => void;
+}> = ({ status, tasks, onMoveTask }) => {
+  const [{ isOver }, drop] = useDrop(() => ({
+    accept: "task",
+    drop: (item: { id: string; status: string }) => {
+      if (item.status !== status) {
+        onMoveTask(item.id, status);
+      }
+    },
+    collect: (monitor) => ({
+      isOver: !!monitor.isOver(),
+    }),
+  }));
+
+  return (
+    <div
+      ref={drop}
+      className="kanban-column"
+      style={{
+        minWidth: "250px",
+        background: isOver ? "#e6f7ff" : "#f4f5f7",
+        borderRadius: "8px",
+        padding: "12px",
+        display: "flex",
+        flexDirection: "column",
+        gap: "8px",
+        transition: "background 0.2s ease",
+      }}
+    >
+      <h6
+        style={{
+          margin: "0 0 12px 0",
+          padding: "8px",
+          background: "#fff",
+          borderRadius: "4px",
+        }}
+      >
+        {status} ({tasks.length})
+      </h6>
+      <div
+        style={{
+          flex: 1,
+          display: "flex",
+          flexDirection: "column",
+          gap: "8px",
+        }}
+      >
+        {tasks.map((task) => (
+          <KanbanCard
+            key={task.id}
+            task={task}
+            status={status}
+            onMoveTask={onMoveTask}
+          />
+        ))}
+      </div>
+    </div>
+  );
+};
+
+// Kanban board preview component
+const KanbanBoardPreview: React.FC<{
+  xmlTree: XMLNode;
+  onTreeUpdate: (newTree: XMLNode) => void;
+}> = ({ xmlTree, onTreeUpdate }) => {
+  const [tasks, setTasks] = useState<any[]>([]);
+
+  const findGraphmlNode = React.useCallback((node: XMLNode): XMLNode | null => {
+    if (node.type === "graphml:graphml") return node;
+    for (const child of node.children) {
+      const result = findGraphmlNode(child);
+      if (result) return result;
+    }
+    return null;
+  }, []);
+
+  // Extract tasks from the graphml structure
+  const extractTasks = React.useCallback((graphmlNode: XMLNode | null) => {
+    if (!graphmlNode) return [];
+
+    // Find the graph node
+    const graphNode = graphmlNode.children.find(
+      (child) => child.type === "graphml:graph"
+    );
+    if (!graphNode) return [];
+
+    // Process each node to extract task information
+    const tasks = graphNode.children
+      .filter((child) => child.type === "graphml:node")
+      .map((node) => {
+        let task = {
+          id: node.attributes.id || "",
+          name: "",
+          status: "",
+          role: "",
+        };
+
+        // Extract data from child data nodes
+        node.children.forEach((dataNode) => {
+          if (dataNode.type === "graphml:data") {
+            const key = dataNode.attributes.key;
+            const value = dataNode.textContent || "";
+            switch (key) {
+              case "name":
+                task.name = value;
+                break;
+              case "status":
+                task.status = value;
+                break;
+              case "role":
+                task.role = value;
+                break;
+            }
+          }
+        });
+        return task;
+      });
+
+    return tasks;
+  }, []);
+
+  // Update tasks whenever xmlTree changes
+  React.useEffect(() => {
+    const graphmlNode = findGraphmlNode(xmlTree);
+    const extractedTasks = extractTasks(graphmlNode);
+    setTasks(extractedTasks);
+  }, [xmlTree, findGraphmlNode, extractTasks]);
+
+  // Handle moving tasks between statuses
+  const handleMoveTask = (taskId: string, newStatus: string) => {
+    // Deep clone the xmlTree
+    const newTree = JSON.parse(JSON.stringify(xmlTree));
+
+    // Find the task node and update its status data
+    const updateStatusInTree = (node: XMLNode): boolean => {
+      if (node.type === "graphml:node" && node.attributes.id === taskId) {
+        // Find the status data child and update its textContent
+        for (const child of node.children) {
+          if (
+            child.type === "graphml:data" &&
+            child.attributes.key === "status"
+          ) {
+            child.textContent = newStatus;
+            return true;
+          }
+        }
+        // If status data doesn't exist, create it
+        const statusDataNode: XMLNode = {
+          id: `status-${Date.now()}`,
+          type: "graphml:data",
+          attributes: { key: "status" },
+          children: [],
+          textContent: newStatus,
+        };
+        node.children.push(statusDataNode);
+        return true;
+      }
+      for (const child of node.children) {
+        if (updateStatusInTree(child)) {
+          return true;
+        }
+      }
+      return false;
+    };
+
+    if (updateStatusInTree(newTree)) {
+      // Update the tree using the provided callback
+      onTreeUpdate(newTree);
+      // Update the local state to show the drag and drop working
+      setTasks((prevTasks) =>
+        prevTasks.map((task) =>
+          task.id === taskId ? { ...task, status: newStatus } : task
+        )
+      );
+    }
+  };
+
+  // Group tasks by status - use a more reliable approach
+  const statusGroups = React.useMemo(() => {
+    const groups: Record<string, any[]> = {};
+    tasks.forEach((task) => {
+      if (!groups[task.status]) {
+        groups[task.status] = [];
+      }
+      groups[task.status].push(task);
+    });
+    return groups;
+  }, [tasks]);
+
+  // Define column order
+  const statusOrder = ["To Do", "In Progress", "Done"];
+
+  return (
+    <DndProvider backend={HTML5Backend}>
+      <div
+        className="kanban-board"
+        style={{
+          display: "flex",
+          gap: "16px",
+          padding: "16px",
+          height: "100%",
+          overflowX: "auto",
+        }}
+      >
+        {statusOrder.map((status) => {
+          const columnTasks = statusGroups[status] || [];
+          return (
+            <KanbanColumn
+              key={status}
+              status={status}
+              tasks={columnTasks}
+              onMoveTask={handleMoveTask}
+            />
+          );
+        })}
+      </div>
+    </DndProvider>
+  );
+};
+
+// Custom preview renderer for the Kanban board
+const renderKanbanPreview = (
+  node: XMLNode,
+  isSelected: boolean,
+  eventHandlers: any,
+  onTreeUpdate: (newTree: XMLNode) => void
+) => {
+  // Always render the Kanban board - the node parameter is always the root xmlTree
+  return (
+    <div
+      style={{
+        height: "100%",
+        width: "100%",
+      }}
+      {...eventHandlers}
+    >
+      <KanbanBoardPreview xmlTree={node} onTreeUpdate={onTreeUpdate} />
+    </div>
+  );
+};
+
+export const FluaPage: React.FC = () => {
+  const [initialTree, setInitialTree] = useState<XMLNode | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    const loadKanbanProcess = async () => {
+      try {
+        setLoading(true);
+        const tree = await loadXmlFile("example/single-kanban-process.xml");
+        setInitialTree(tree);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Failed to load XML");
+        console.error("Error loading kanban process:", err);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    loadKanbanProcess();
+  }, []);
+
+  if (loading) {
+    return <div>Loading kanban process...</div>;
+  }
+
+  if (error) {
+    throw error;
+  }
+
+  if (!initialTree) {
+    return <div>No XML data available</div>;
+  }
+
+  return (
+    <DndProvider backend={HTML5Backend}>
+      <GenericXMLEditorPage
+        initialTree={initialTree}
+        renderPreview={renderKanbanPreview}
+        attributeEditor={(node, onUpdateAttributes, onUpdateTextContent) => {
+          console.log("attributeEditor called with:", {
+            node,
+            onUpdateAttributes,
+            onUpdateTextContent,
+          });
+          return (
+            <AttributeEditor
+              node={node}
+              onUpdateAttributes={onUpdateAttributes}
+              onUpdateTextContent={onUpdateTextContent}
+            />
+          );
+        }}
+        nodeTypes={nodeTypes}
+        onAddNode={createKanbanNode}
+      />
+    </DndProvider>
+  );
+};

package/src/app/frontend/flua/agile.xsd

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+  targetNamespace="http://example.com/businessprocess/agile"
+  xmlns:agile="http://example.com/businessprocess/agile"
+  xmlns:core="http://example.com/businessprocess/core"
+  xmlns:graphml="http://graphml.graphdrawing.org/xmlns"
+  elementFormDefault="qualified">
+
+  <xs:import namespace="http://example.com/businessprocess/core" schemaLocation="core.xsd" />
+  <!-- The schemaLocation for GraphML can be a local file path -->
+  <xs:import namespace="http://graphml.graphdrawing.org/xmlns"
+    schemaLocation="../../src/graphml.xsd" />
+
+  <!-- Abstract base type for any agile process -->
+  <xs:complexType name="AgileProcessBaseType" abstract="true">
+    <xs:complexContent>
+      <xs:extension base="core:ProcessType">
+        <xs:sequence>
+          <!-- Correctly reference the global 'graphml' element -->
+          <xs:element ref="graphml:graphml" />
+        </xs:sequence>
+      </xs:extension>
+    </xs:complexContent>
+  </xs:complexType>
+
+  <!-- Common agile concepts like user stories could be defined here -->
+  <xs:complexType name="UserStoryType">
+    <xs:attribute name="name" type="xs:string" use="required" />
+    <xs:attribute name="points" type="xs:integer" />
+  </xs:complexType>
+
+</xs:schema>