ortoni-report 3.0.5 → 4.0.2-beta.0

package/dist/ortoni-report.mjs

@@ -1,388 +1,25 @@
 import {
+  DatabaseManager,
+  FileManager,
+  HTMLGenerator,
   __publicField,
-  __require,
+  ensureHtmlExtension,
+  escapeHtml,
+  extractSuites,
+  normalizeFilePath,
   startReportServer
-} from "./chunk-A6HCKATU.mjs";
-
-// src/helpers/fileManager.ts
-import fs from "fs";
-import path from "path";
-var FileManager = class {
-  constructor(folderPath) {
-    this.folderPath = folderPath;
-  }
-  ensureReportDirectory() {
-    const ortoniDataFolder = path.join(this.folderPath, "ortoni-data");
-    if (!fs.existsSync(this.folderPath)) {
-      fs.mkdirSync(this.folderPath, { recursive: true });
-    } else {
-      if (fs.existsSync(ortoniDataFolder)) {
-        fs.rmSync(ortoniDataFolder, { recursive: true, force: true });
-      }
-    }
-  }
-  writeReportFile(filename, content) {
-    const outputPath = path.join(process.cwd(), this.folderPath, filename);
-    fs.writeFileSync(outputPath, content);
-    return outputPath;
-  }
-  readCssContent() {
-    return fs.readFileSync(
-      path.resolve(__dirname, "style", "main.css"),
-      "utf-8"
-    );
-  }
-  copyTraceViewerAssets(skip) {
-    if (skip) return;
-    const traceViewerFolder = path.join(
-      __require.resolve("playwright-core"),
-      "..",
-      "lib",
-      "vite",
-      "traceViewer"
-    );
-    const traceViewerTargetFolder = path.join(this.folderPath, "trace");
-    const traceViewerAssetsTargetFolder = path.join(
-      traceViewerTargetFolder,
-      "assets"
-    );
-    fs.mkdirSync(traceViewerAssetsTargetFolder, { recursive: true });
-    for (const file of fs.readdirSync(traceViewerFolder)) {
-      if (file.endsWith(".map") || file.includes("watch") || file.includes("assets"))
-        continue;
-      fs.copyFileSync(
-        path.join(traceViewerFolder, file),
-        path.join(traceViewerTargetFolder, file)
-      );
-    }
-    const assetsFolder = path.join(traceViewerFolder, "assets");
-    for (const file of fs.readdirSync(assetsFolder)) {
-      if (file.endsWith(".map") || file.includes("xtermModule")) continue;
-      fs.copyFileSync(
-        path.join(assetsFolder, file),
-        path.join(traceViewerAssetsTargetFolder, file)
-      );
-    }
-  }
-};
-
-// src/helpers/HTMLGenerator.ts
-import path3 from "path";
-
-// src/utils/groupProjects.ts
-function groupResults(config, results) {
-  if (config.showProject) {
-    const groupedResults = results.reduce((acc, result, index) => {
-      const testId = `${result.filePath}:${result.projectName}:${result.title}`;
-      const { filePath, suite, projectName } = result;
-      acc[filePath] = acc[filePath] || {};
-      acc[filePath][suite] = acc[filePath][suite] || {};
-      acc[filePath][suite][projectName] = acc[filePath][suite][projectName] || [];
-      acc[filePath][suite][projectName].push({ ...result, index, testId });
-      return acc;
-    }, {});
-    return groupedResults;
-  } else {
-    const groupedResults = results.reduce((acc, result, index) => {
-      const testId = `${result.filePath}:${result.projectName}:${result.title}`;
-      const { filePath, suite } = result;
-      acc[filePath] = acc[filePath] || {};
-      acc[filePath][suite] = acc[filePath][suite] || [];
-      acc[filePath][suite].push({ ...result, index, testId });
-      return acc;
-    }, {});
-    return groupedResults;
-  }
-}
-
-// src/utils/utils.ts
-import path2 from "path";
-function msToTime(duration) {
-  const milliseconds = Math.floor(duration % 1e3);
-  const seconds = Math.floor(duration / 1e3 % 60);
-  const minutes = Math.floor(duration / (1e3 * 60) % 60);
-  const hours = Math.floor(duration / (1e3 * 60 * 60) % 24);
-  let result = "";
-  if (hours > 0) {
-    result += `${hours}h:`;
-  }
-  if (minutes > 0 || hours > 0) {
-    result += `${minutes < 10 ? "0" + minutes : minutes}m:`;
-  }
-  if (seconds > 0 || minutes > 0 || hours > 0) {
-    result += `${seconds < 10 ? "0" + seconds : seconds}s`;
-  }
-  if (milliseconds > 0 && !(seconds > 0 || minutes > 0 || hours > 0)) {
-    result += `${milliseconds}ms`;
-  } else if (milliseconds > 0) {
-    result += `:${milliseconds < 100 ? "0" + milliseconds : milliseconds}ms`;
-  }
-  return result;
-}
-function normalizeFilePath(filePath) {
-  const normalizedPath = path2.normalize(filePath);
-  return path2.basename(normalizedPath);
-}
-function formatDate(date) {
-  const day = String(date.getDate()).padStart(2, "0");
-  const month = date.toLocaleString("default", { month: "short" });
-  const year = date.getFullYear();
-  const time = date.toLocaleTimeString();
-  return `${day}-${month}-${year} ${time}`;
-}
-function safeStringify(obj, indent = 2) {
-  const cache = /* @__PURE__ */ new Set();
-  const json = JSON.stringify(
-    obj,
-    (key, value) => {
-      if (typeof value === "object" && value !== null) {
-        if (cache.has(value)) {
-          return;
-        }
-        cache.add(value);
-      }
-      return value;
-    },
-    indent
-  );
-  cache.clear();
-  return json;
-}
-function ensureHtmlExtension(filename) {
-  const ext = path2.extname(filename);
-  if (ext && ext.toLowerCase() === ".html") {
-    return filename;
-  }
-  return `${filename}.html`;
-}
-function escapeHtml(unsafe) {
-  if (typeof unsafe !== "string") {
-    return String(unsafe);
-  }
-  return unsafe.replace(/[&<"']/g, function(match) {
-    const escapeMap = {
-      "&": "&amp;",
-      "<": "&lt;",
-      ">": "&gt;",
-      '"': "&quot;",
-      "'": "&#039;"
-    };
-    return escapeMap[match] || match;
-  });
-}
-function formatDateUTC(date) {
-  return date.toISOString();
-}
-function formatDateLocal(isoString) {
-  const date = new Date(isoString);
-  const options = {
-    year: "numeric",
-    month: "short",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: true,
-    timeZoneName: "shortOffset"
-  };
-  return new Intl.DateTimeFormat(void 0, options).format(date);
-}
-function formatDateNoTimezone(isoString) {
-  const date = new Date(isoString);
-  return date.toLocaleString("en-US", {
-    dateStyle: "medium",
-    timeStyle: "short"
-  });
-}
-
-// src/helpers/HTMLGenerator.ts
-import fs2 from "fs";
-import Handlebars from "handlebars";
-var HTMLGenerator = class {
-  constructor(ortoniConfig, dbManager) {
-    this.ortoniConfig = ortoniConfig;
-    this.registerHandlebarsHelpers();
-    this.registerPartials();
-    this.dbManager = dbManager;
-  }
-  async generateHTML(filteredResults, totalDuration, cssContent, results, projectSet) {
-    const data = await this.prepareReportData(
-      filteredResults,
-      totalDuration,
-      results,
-      projectSet
-    );
-    const templateSource = fs2.readFileSync(
-      path3.resolve(__dirname, "views", "main.hbs"),
-      "utf-8"
-    );
-    const template = Handlebars.compile(templateSource);
-    return template({ ...data, inlineCss: cssContent });
-  }
-  async getReportData() {
-    return {
-      summary: await this.dbManager.getSummaryData(),
-      trends: await this.dbManager.getTrends(),
-      flakyTests: await this.dbManager.getFlakyTests(),
-      slowTests: await this.dbManager.getSlowTests()
-    };
-  }
-  async chartTrendData() {
-    return {
-      labels: (await this.getReportData()).trends.map(
-        (t) => formatDateNoTimezone(t.run_date)
-      ),
-      passed: (await this.getReportData()).trends.map((t) => t.passed),
-      failed: (await this.getReportData()).trends.map((t) => t.failed),
-      avgDuration: (await this.getReportData()).trends.map(
-        (t) => t.avg_duration
-      )
-    };
-  }
-  async prepareReportData(filteredResults, totalDuration, results, projectSet) {
-    const totalTests = filteredResults.length;
-    const passedTests = results.filter((r) => r.status === "passed").length;
-    const flakyTests = results.filter((r) => r.status === "flaky").length;
-    const failed = filteredResults.filter(
-      (r) => r.status === "failed" || r.status === "timedOut"
-    ).length;
-    const successRate = ((passedTests + flakyTests) / totalTests * 100).toFixed(2);
-    const allTags = /* @__PURE__ */ new Set();
-    results.forEach(
-      (result) => result.testTags.forEach((tag) => allTags.add(tag))
-    );
-    const projectResults = this.calculateProjectResults(
-      filteredResults,
-      results,
-      projectSet
-    );
-    const utcRunDate = formatDateUTC(/* @__PURE__ */ new Date());
-    const localRunDate = formatDateLocal(utcRunDate);
-    const testHistories = await Promise.all(
-      results.map(async (result) => {
-        const testId = `${result.filePath}:${result.projectName}:${result.title}`;
-        const history = await this.dbManager.getTestHistory(testId);
-        return {
-          testId,
-          history
-        };
-      })
-    );
-    return {
-      utcRunDate,
-      localRunDate,
-      testHistories,
-      logo: this.ortoniConfig.logo || void 0,
-      totalDuration,
-      results,
-      retryCount: results.filter((r) => r.isRetry).length,
-      passCount: passedTests,
-      failCount: failed,
-      skipCount: results.filter((r) => r.status === "skipped").length,
-      flakyCount: flakyTests,
-      totalCount: filteredResults.length,
-      groupedResults: groupResults(this.ortoniConfig, results),
-      projectName: this.ortoniConfig.projectName,
-      authorName: this.ortoniConfig.authorName,
-      meta: this.ortoniConfig.meta,
-      testType: this.ortoniConfig.testType,
-      preferredTheme: this.ortoniConfig.preferredTheme,
-      successRate,
-      lastRunDate: formatDate(/* @__PURE__ */ new Date()),
-      projects: projectSet,
-      allTags: Array.from(allTags),
-      showProject: this.ortoniConfig.showProject || false,
-      title: this.ortoniConfig.title || "Ortoni Playwright Test Report",
-      chartType: this.ortoniConfig.chartType || "pie",
-      reportAnalyticsData: await this.getReportData(),
-      chartData: await this.chartTrendData(),
-      ...this.extractProjectStats(projectResults)
-    };
-  }
-  calculateProjectResults(filteredResults, results, projectSet) {
-    return Array.from(projectSet).map((projectName) => {
-      const projectTests = filteredResults.filter(
-        (r) => r.projectName === projectName
-      );
-      const allProjectTests = results.filter(
-        (r) => r.projectName === projectName
-      );
-      return {
-        projectName,
-        passedTests: projectTests.filter((r) => r.status === "passed").length,
-        failedTests: projectTests.filter(
-          (r) => r.status === "failed" || r.status === "timedOut"
-        ).length,
-        skippedTests: allProjectTests.filter((r) => r.status === "skipped").length,
-        retryTests: allProjectTests.filter((r) => r.isRetry).length,
-        flakyTests: allProjectTests.filter((r) => r.status === "flaky").length,
-        totalTests: projectTests.length
-      };
-    });
-  }
-  extractProjectStats(projectResults) {
-    return {
-      projectNames: projectResults.map((result) => result.projectName),
-      totalTests: projectResults.map((result) => result.totalTests),
-      passedTests: projectResults.map((result) => result.passedTests),
-      failedTests: projectResults.map((result) => result.failedTests),
-      skippedTests: projectResults.map((result) => result.skippedTests),
-      retryTests: projectResults.map((result) => result.retryTests),
-      flakyTests: projectResults.map((result) => result.flakyTests)
-    };
-  }
-  registerHandlebarsHelpers() {
-    Handlebars.registerHelper("joinWithSpace", (array) => array.join(" "));
-    Handlebars.registerHelper("json", (context) => safeStringify(context));
-    Handlebars.registerHelper(
-      "eq",
-      (actualStatus, expectedStatus) => actualStatus === expectedStatus
-    );
-    Handlebars.registerHelper(
-      "includes",
-      (actualStatus, expectedStatus) => actualStatus.includes(expectedStatus)
-    );
-    Handlebars.registerHelper("gr", (count) => count > 0);
-    Handlebars.registerHelper("or", function(a3, b2) {
-      return a3 || b2;
-    });
-    Handlebars.registerHelper("concat", function(...args) {
-      args.pop();
-      return args.join("");
-    });
-  }
-  registerPartials() {
-    [
-      "head",
-      "sidebar",
-      "testPanel",
-      "summaryCard",
-      "userInfo",
-      "project",
-      "testStatus",
-      "testIcons",
-      "analytics"
-    ].forEach((partialName) => {
-      Handlebars.registerPartial(
-        partialName,
-        fs2.readFileSync(
-          path3.resolve(__dirname, "views", `${partialName}.hbs`),
-          "utf-8"
-        )
-      );
-    });
-  }
-};
+} from "./chunk-JEIWNUQY.mjs";
 
 // src/helpers/resultProcessor .ts
 import AnsiToHtml from "ansi-to-html";
-import path5 from "path";
+import path2 from "path";
 
 // src/utils/attachFiles.ts
-import path4 from "path";
-import fs4 from "fs";
+import path from "path";
+import fs2 from "fs";
 
 // src/helpers/markdownConverter.ts
-import fs3 from "fs";
+import fs from "fs";
 
 // node_modules/marked/lib/marked.esm.js
 function M() {
@@ -1507,108 +1144,44 @@ var Ft = T.parse;
 var Qt = b.lex;
 
 // src/helpers/markdownConverter.ts
-function convertMarkdownToHtml(markdownPath, htmlOutputPath, stepsError, resultError) {
-  const hasMarkdown = fs3.existsSync(markdownPath);
-  const markdownContent = hasMarkdown ? fs3.readFileSync(markdownPath, "utf-8") : "";
+function convertMarkdownToHtml(markdownPath, htmlOutputPath) {
+  const hasMarkdown = fs.existsSync(markdownPath);
+  const markdownContent = hasMarkdown ? fs.readFileSync(markdownPath, "utf-8") : "";
   const markdownHtml = hasMarkdown ? k(markdownContent) : "";
-  const stepsHtml = stepsError.filter((step) => step.snippet?.trim()).map(
-    (step) => `
-      <div>
-        <pre><code>${step.snippet}</code></pre>
-        ${step.location ? `<p><em>Location: ${escapeHtml(step.location)}</em></p>` : ""}
-      </div>`
-  ).join("\n");
-  const errorHtml = resultError.map((error) => `<pre><code>${error}</code></pre>`).join("\n");
-  const fullHtml = `
-    <!DOCTYPE html>
-    <html lang="en">
-    <head>
-      <meta charset="UTF-8" />
-      <title>Ortoni Error Report</title>
-      <style>
-        body { font-family: sans-serif; padding: 2rem; line-height: 1.6; max-width: 900px; margin: auto; }
-        code, pre { background: #f4f4f4; padding: 0.5rem; border-radius: 5px; display: block; overflow-x: auto; }
-        h1, h2, h3 { color: #444; }
-        hr { margin: 2em 0; }
-        #copyBtn {
-          background-color: #007acc;
-          color: white;
-          border: none;
-          padding: 0.5rem 1rem;
-          margin-bottom: 1rem;
-          border-radius: 5px;
-          cursor: pointer;
-        }
-        #copyBtn:hover {
-          background-color: #005fa3;
-        }
-      </style>
-    </head>
-    <body>
-      <button id="copyBtn">\u{1F4CB} Copy All</button>
-      <script>
-        document.getElementById("copyBtn").addEventListener("click", () => {
-          const content = document.getElementById("markdownContent").innerText;
-          navigator.clipboard.writeText(content).then(() => {
-            // change button text to indicate success
-            const button = document.getElementById("copyBtn");
-            button.textContent = "\u2705 Copied!";
-            setTimeout(() => {
-              button.textContent = "\u{1F4CB} Copy All"
-              }, 2000);
-          }).catch(err => {
-            console.error("Failed to copy text: ", err);
-            alert("Failed to copy text. Please try manually.");   
-          });
-        });
-      </script>
-      <div id="markdownContent">
-      <h1>Instructions</h1>
-      <ul>
-        <li>Following Playwright test failed.</li>
-        <li>Explain why, be concise, respect Playwright best practices.</li>
-        <li>Provide a snippet of code with the fix, if possible.</li>
-      </ul>
-      <h1>Error Details</h1>
-      ${errorHtml || "<p>No errors found.</p>"}
-      ${stepsHtml || "<p>No step data available.</p>"}
-      ${markdownHtml || ""}
-      </div>
-    </body>
-    </html>
-  `;
-  fs3.writeFileSync(htmlOutputPath, fullHtml, "utf-8");
+  const drawerHtml = `${markdownHtml || ""}`;
+  fs.writeFileSync(htmlOutputPath, drawerHtml.trim(), "utf-8");
   if (hasMarkdown) {
-    fs3.unlinkSync(markdownPath);
+    fs.unlinkSync(markdownPath);
   }
 }
 
 // src/utils/attachFiles.ts
 function attachFiles(subFolder, result, testResult, config, steps, errors) {
   const folderPath = config.folderPath || "ortoni-report";
-  const attachmentsFolder = path4.join(
+  const attachmentsFolder = path.join(
     folderPath,
     "ortoni-data",
     "attachments",
     subFolder
   );
-  if (!fs4.existsSync(attachmentsFolder)) {
-    fs4.mkdirSync(attachmentsFolder, { recursive: true });
+  if (!fs2.existsSync(attachmentsFolder)) {
+    fs2.mkdirSync(attachmentsFolder, { recursive: true });
   }
   if (!result.attachments) return;
   const { base64Image } = config;
   testResult.screenshots = [];
+  testResult.videoPath = [];
   result.attachments.forEach((attachment) => {
     const { contentType, name, path: attachmentPath, body } = attachment;
     if (!attachmentPath && !body) return;
-    const fileName = attachmentPath ? path4.basename(attachmentPath) : `${name}.${getFileExtension(contentType)}`;
-    const relativePath = path4.join(
+    const fileName = attachmentPath ? path.basename(attachmentPath) : `${name}.${getFileExtension(contentType)}`;
+    const relativePath = path.join(
       "ortoni-data",
       "attachments",
       subFolder,
       fileName
     );
-    const fullPath = path4.join(attachmentsFolder, fileName);
+    const fullPath = path.join(attachmentsFolder, fileName);
     if (contentType === "image/png") {
       handleImage(
         attachmentPath,
@@ -1651,13 +1224,13 @@ function handleImage(attachmentPath, body, base64Image, fullPath, relativePath,
   let screenshotPath = "";
   if (attachmentPath) {
     try {
-      const screenshotContent = fs4.readFileSync(
+      const screenshotContent = fs2.readFileSync(
         attachmentPath,
         base64Image ? "base64" : void 0
       );
       screenshotPath = base64Image ? `data:image/png;base64,${screenshotContent}` : relativePath;
       if (!base64Image) {
-        fs4.copyFileSync(attachmentPath, fullPath);
+        fs2.copyFileSync(attachmentPath, fullPath);
       }
     } catch (error) {
       console.error(
@@ -1674,13 +1247,17 @@ function handleImage(attachmentPath, body, base64Image, fullPath, relativePath,
 }
 function handleAttachment(attachmentPath, fullPath, relativePath, resultKey, testResult, steps, errors) {
   if (attachmentPath) {
-    fs4.copyFileSync(attachmentPath, fullPath);
-    testResult[resultKey] = relativePath;
+    fs2.copyFileSync(attachmentPath, fullPath);
+    if (resultKey === "videoPath") {
+      testResult[resultKey]?.push(relativePath);
+    } else if (resultKey === "tracePath") {
+      testResult[resultKey] = relativePath;
+    }
   }
   if (resultKey === "markdownPath" && errors) {
     const htmlPath = fullPath.replace(/\.md$/, ".html");
     const htmlRelativePath = relativePath.replace(/\.md$/, ".html");
-    convertMarkdownToHtml(fullPath, htmlPath, steps || [], errors || []);
+    convertMarkdownToHtml(fullPath, htmlPath);
     testResult[resultKey] = htmlRelativePath;
     return;
   }
@@ -1710,19 +1287,21 @@ var TestResultProcessor = class {
     const tagPattern = /@[\w]+/g;
     const title = test.title.replace(tagPattern, "").trim();
     const suite = test.titlePath()[3].replace(tagPattern, "").trim();
+    const suiteAndTitle = extractSuites(test.titlePath());
+    const suiteHierarchy = suiteAndTitle.hierarchy;
     const testResult = {
-      port: ortoniConfig.port || 2004,
+      suiteHierarchy,
+      key: test.id,
       annotations: test.annotations,
       testTags: test.tags,
       location: `${filePath}:${location.line}:${location.column}`,
-      retry: result.retry > 0 ? "retry" : "",
-      isRetry: result.retry,
+      retryAttemptCount: result.retry,
       projectName,
       suite,
       title,
       status,
       flaky: test.outcome(),
-      duration: msToTime(result.duration),
+      duration: result.duration,
       errors: result.errors.map(
         (e) => this.ansiToHtml.toHtml(escapeHtml(e.stack || e.toString()))
       ),
@@ -1734,7 +1313,8 @@ var TestResultProcessor = class {
       ),
       filePath,
       filters: projectSet,
-      base64Image: ortoniConfig.base64Image
+      base64Image: ortoniConfig.base64Image,
+      testId: `${filePath}:${projectName}:${title}`
     };
     attachFiles(
       test.id,
@@ -1748,7 +1328,7 @@ var TestResultProcessor = class {
   }
   processSteps(steps) {
     return steps.map((step) => {
-      const stepLocation = step.location ? `${path5.relative(this.projectRoot, step.location.file)}:${step.location.line}:${step.location.column}` : "";
+      const stepLocation = step.location ? `${path2.relative(this.projectRoot, step.location.file)}:${step.location.line}:${step.location.column}` : "";
       return {
         snippet: this.ansiToHtml.toHtml(escapeHtml(step.error?.snippet || "")),
         title: step.title,
@@ -1777,277 +1357,8 @@ var ServerManager = class {
   }
 };
 
-// src/helpers/databaseManager.ts
-import { open } from "sqlite";
-import sqlite3 from "sqlite3";
-var DatabaseManager = class {
-  constructor() {
-    this.db = null;
-  }
-  async initialize(dbPath) {
-    try {
-      this.db = await open({
-        filename: dbPath,
-        driver: sqlite3.Database
-      });
-      await this.createTables();
-      await this.createIndexes();
-    } catch (error) {
-      console.error("OrtoniReport: Error initializing database:", error);
-    }
-  }
-  async createTables() {
-    if (!this.db) {
-      console.error("OrtoniReport: Database not initialized");
-      return;
-    }
-    try {
-      await this.db.exec(`
-        CREATE TABLE IF NOT EXISTS test_runs (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          run_date TEXT
-        );
-
-        CREATE TABLE IF NOT EXISTS test_results (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          run_id INTEGER,
-          test_id TEXT,
-          status TEXT,
-          duration TEXT,
-          error_message TEXT,
-          FOREIGN KEY (run_id) REFERENCES test_runs (id)
-        );
-      `);
-    } catch (error) {
-      console.error("OrtoniReport: Error creating tables:", error);
-    }
-  }
-  async createIndexes() {
-    if (!this.db) {
-      console.error("OrtoniReport: Database not initialized");
-      return;
-    }
-    try {
-      await this.db.exec(`
-        CREATE INDEX IF NOT EXISTS idx_test_id ON test_results (test_id);
-        CREATE INDEX IF NOT EXISTS idx_run_id ON test_results (run_id);
-      `);
-    } catch (error) {
-      console.error("OrtoniReport: Error creating indexes:", error);
-    }
-  }
-  async saveTestRun() {
-    if (!this.db) {
-      console.error("OrtoniReport: Database not initialized");
-      return null;
-    }
-    try {
-      const runDate = (/* @__PURE__ */ new Date()).toISOString();
-      const { lastID } = await this.db.run(
-        `
-        INSERT INTO test_runs (run_date)
-        VALUES (?)
-      `,
-        [runDate]
-      );
-      return lastID;
-    } catch (error) {
-      console.error("OrtoniReport: Error saving test run:", error);
-      return null;
-    }
-  }
-  async saveTestResults(runId, results) {
-    if (!this.db) {
-      console.error("OrtoniReport: Database not initialized");
-      return;
-    }
-    try {
-      await this.db.exec("BEGIN TRANSACTION;");
-      const stmt = await this.db.prepare(`
-        INSERT INTO test_results (run_id, test_id, status, duration, error_message)
-        VALUES (?, ?, ?, ?, ?)
-      `);
-      for (const result of results) {
-        await stmt.run([
-          runId,
-          `${result.filePath}:${result.projectName}:${result.title}`,
-          result.status,
-          result.duration,
-          result.errors.join("\n")
-        ]);
-      }
-      await stmt.finalize();
-      await this.db.exec("COMMIT;");
-    } catch (error) {
-      await this.db.exec("ROLLBACK;");
-      console.error("OrtoniReport: Error saving test results:", error);
-    }
-  }
-  async getTestHistory(testId, limit = 10) {
-    if (!this.db) {
-      console.error("OrtoniReport: Database not initialized");
-      return [];
-    }
-    try {
-      const results = await this.db.all(
-        `
-        SELECT tr.status, tr.duration, tr.error_message, trun.run_date
-        FROM test_results tr
-        JOIN test_runs trun ON tr.run_id = trun.id
-        WHERE tr.test_id = ?
-        ORDER BY trun.run_date DESC
-        LIMIT ?
-      `,
-        [testId, limit]
-      );
-      return results.map((result) => ({
-        ...result,
-        run_date: formatDateLocal(result.run_date)
-      }));
-    } catch (error) {
-      console.error("OrtoniReport: Error getting test history:", error);
-      return [];
-    }
-  }
-  async close() {
-    if (this.db) {
-      try {
-        await this.db.close();
-      } catch (error) {
-        console.error("OrtoniReport: Error closing database:", error);
-      } finally {
-        this.db = null;
-      }
-    }
-  }
-  async getSummaryData() {
-    if (!this.db) {
-      console.error("OrtoniReport: Database not initialized");
-      return {
-        totalRuns: 0,
-        totalTests: 0,
-        passed: 0,
-        failed: 0,
-        passRate: 0,
-        avgDuration: 0
-      };
-    }
-    try {
-      const summary = await this.db.get(`
-      SELECT
-        (SELECT COUNT(*) FROM test_runs) as totalRuns,
-        (SELECT COUNT(*) FROM test_results) as totalTests,
-        (SELECT COUNT(*) FROM test_results WHERE status = 'passed') as passed,
-        (SELECT COUNT(*) FROM test_results WHERE status = 'failed') as failed,
-        (SELECT AVG(CAST(duration AS FLOAT)) FROM test_results) as avgDuration
-    `);
-      const passRate = summary.totalTests ? (summary.passed / summary.totalTests * 100).toFixed(2) : 0;
-      return {
-        totalRuns: summary.totalRuns,
-        totalTests: summary.totalTests,
-        passed: summary.passed,
-        failed: summary.failed,
-        passRate: parseFloat(passRate.toString()),
-        avgDuration: Math.round(summary.avgDuration || 0)
-      };
-    } catch (error) {
-      console.error("OrtoniReport: Error getting summary data:", error);
-      return {
-        totalRuns: 0,
-        totalTests: 0,
-        passed: 0,
-        failed: 0,
-        passRate: 0,
-        avgDuration: 0
-      };
-    }
-  }
-  async getTrends(limit = 100) {
-    if (!this.db) {
-      console.error("OrtoniReport: Database not initialized");
-      return [];
-    }
-    try {
-      const rows = await this.db.all(
-        `
-      SELECT trun.run_date,
-        SUM(CASE WHEN tr.status = 'passed' THEN 1 ELSE 0 END) AS passed,
-        SUM(CASE WHEN tr.status = 'failed' THEN 1 ELSE 0 END) AS failed,
-        AVG(CAST(tr.duration AS FLOAT)) AS avg_duration
-      FROM test_results tr
-      JOIN test_runs trun ON tr.run_id = trun.id
-      GROUP BY trun.run_date
-      ORDER BY trun.run_date DESC
-      LIMIT ?
-    `,
-        [limit]
-      );
-      return rows.reverse().map((row) => ({
-        ...row,
-        run_date: formatDateLocal(row.run_date),
-        avg_duration: Math.round(row.avg_duration || 0)
-      }));
-    } catch (error) {
-      console.error("OrtoniReport: Error getting trends data:", error);
-      return [];
-    }
-  }
-  async getFlakyTests(limit = 10) {
-    if (!this.db) {
-      console.error("OrtoniReport: Database not initialized");
-      return [];
-    }
-    try {
-      return await this.db.all(
-        `
-      SELECT
-        test_id,
-        COUNT(*) AS total,
-        SUM(CASE WHEN status = 'flaky' THEN 1 ELSE 0 END) AS flaky
-      FROM test_results
-      GROUP BY test_id
-      HAVING flaky > 0
-      ORDER BY flaky DESC
-      LIMIT ?
-    `,
-        [limit]
-      );
-    } catch (error) {
-      console.error("OrtoniReport: Error getting flaky tests:", error);
-      return [];
-    }
-  }
-  async getSlowTests(limit = 10) {
-    if (!this.db) {
-      console.error("OrtoniReport: Database not initialized");
-      return [];
-    }
-    try {
-      const rows = await this.db.all(
-        `
-      SELECT
-        test_id,
-        AVG(CAST(duration AS FLOAT)) AS avg_duration
-      FROM test_results
-      GROUP BY test_id
-      ORDER BY avg_duration DESC
-      LIMIT ?
-    `,
-        [limit]
-      );
-      return rows.map((row) => ({
-        test_id: row.test_id,
-        avg_duration: Math.round(row.avg_duration || 0)
-      }));
-    } catch (error) {
-      console.error("OrtoniReport: Error getting slow tests:", error);
-      return [];
-    }
-  }
-};
-
 // src/ortoni-report.ts
-import path6 from "path";
+import path3 from "path";
 var OrtoniReport = class {
   constructor(ortoniConfig = {}) {
     this.ortoniConfig = ortoniConfig;
@@ -2078,8 +1389,9 @@ var OrtoniReport = class {
     this.testResultProcessor = new TestResultProcessor(config.rootDir);
     this.fileManager.ensureReportDirectory();
     await this.dbManager.initialize(
-      path6.join(this.folderPath, "ortoni-data-history.sqlite")
+      path3.join(this.folderPath, "ortoni-data-history.sqlite")
     );
+    this.config = config?.shard;
   }
   onStdOut(chunk, _test, _result) {
     if (this.reportsCount == 1 && this.showConsoleLogs) {
@@ -2112,23 +1424,35 @@ var OrtoniReport = class {
       this.overAllStatus = result.status;
       if (this.shouldGenerateReport) {
         const filteredResults = this.results.filter(
-          (r) => r.status !== "skipped" && !r.isRetry
+          (r) => r.status !== "skipped"
         );
-        const totalDuration = msToTime(result.duration);
-        const cssContent = this.fileManager.readCssContent();
+        const totalDuration = result.duration;
+        if (this.config && this.config.total > 1) {
+          const shard = this.config;
+          const shardFile = `ortoni-shard-${shard.current}-of-${shard.total}.json`;
+          const shardData = {
+            status: result.status,
+            duration: totalDuration,
+            results: this.results,
+            projectSet: Array.from(this.projectSet)
+          };
+          this.fileManager.writeRawFile(shardFile, shardData);
+          console.log(`\u{1F4E6} OrtoniReport wrote shard file: ${shardFile}`);
+          this.shouldGenerateReport = false;
+          return;
+        }
         const runId = await this.dbManager.saveTestRun();
         if (runId !== null) {
           await this.dbManager.saveTestResults(runId, this.results);
-          const html = await this.htmlGenerator.generateHTML(
+          const finalReportData = await this.htmlGenerator.generateFinalReport(
             filteredResults,
             totalDuration,
-            cssContent,
             this.results,
             this.projectSet
           );
           this.outputPath = this.fileManager.writeReportFile(
             this.outputFilename,
-            html
+            finalReportData
           );
         } else {
           console.error("OrtoniReport: Error saving test run to database");