ortoni-report 4.0.1-beta.0 → 4.0.1-beta.3

package/dist/{cli/cli.js → cli.js}

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-"use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -23,76 +22,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/cli/cli.ts
+// src/cli.ts
 var import_commander = require("commander");
+var fs4 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
 
-// src/utils/expressServer.ts
-var import_express = __toESM(require("express"));
-var import_path = __toESM(require("path"));
-var import_child_process = require("child_process");
-function startReportServer(reportFolder, reportFilename, port = 2004, open2) {
-  const app = (0, import_express.default)();
-  app.use(import_express.default.static(reportFolder));
-  app.get("/", (_req, res) => {
-    try {
-      res.sendFile(import_path.default.resolve(reportFolder, reportFilename));
-    } catch (error) {
-      console.error("Ortoni Report: Error sending report file:", error);
-      res.status(500).send("Error loading report");
-    }
-  });
-  try {
-    const server = app.listen(port, () => {
-      console.log(
-        `Server is running at http://localhost:${port} 
-Press Ctrl+C to stop.`
-      );
-      if (open2 === "always" || open2 === "on-failure") {
-        try {
-          openBrowser(`http://localhost:${port}`);
-        } catch (error) {
-          console.error("Ortoni Report: Error opening browser:", error);
-        }
-      }
-    });
-    server.on("error", (error) => {
-      if (error.code === "EADDRINUSE") {
-        console.error(
-          `Ortoni Report: Port ${port} is already in use. Trying a different port...`
-        );
-      } else {
-        console.error("Ortoni Report: Server error:", error);
-      }
-    });
-  } catch (error) {
-    console.error("Ortoni Report: Error starting the server:", error);
-  }
-}
-function openBrowser(url) {
-  const platform = process.platform;
-  let command;
-  try {
-    if (platform === "win32") {
-      command = "cmd";
-      (0, import_child_process.spawn)(command, ["/c", "start", url]);
-    } else if (platform === "darwin") {
-      command = "open";
-      (0, import_child_process.spawn)(command, [url]);
-    } else {
-      command = "xdg-open";
-      (0, import_child_process.spawn)(command, [url]);
-    }
-  } catch (error) {
-    console.error("Ortoni Report: Error opening the browser:", error);
-  }
-}
-
-// src/cli/cli.ts
+// src/mergeData.ts
 var fs3 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
-
-// src/cli/mergeData.ts
-var fs2 = __toESM(require("fs"));
 var path3 = __toESM(require("path"));
 
 // src/helpers/databaseManager.ts
@@ -387,74 +323,6 @@ var DatabaseManager = class {
   }
 };
 
-// src/helpers/fileManager.ts
-var import_fs = __toESM(require("fs"));
-var import_path2 = __toESM(require("path"));
-var FileManager = class {
-  constructor(folderPath) {
-    this.folderPath = folderPath;
-  }
-  ensureReportDirectory() {
-    const ortoniDataFolder = import_path2.default.join(this.folderPath, "ortoni-data");
-    if (!import_fs.default.existsSync(this.folderPath)) {
-      import_fs.default.mkdirSync(this.folderPath, { recursive: true });
-    } else {
-      if (import_fs.default.existsSync(ortoniDataFolder)) {
-        import_fs.default.rmSync(ortoniDataFolder, { recursive: true, force: true });
-      }
-    }
-  }
-  writeReportFile(filename, data) {
-    const templatePath = import_path2.default.join(__dirname, "..", "index.html");
-    let html = import_fs.default.readFileSync(templatePath, "utf-8");
-    const reportJSON = JSON.stringify({
-      data
-    });
-    html = html.replace("__ORTONI_TEST_REPORTDATA__", reportJSON);
-    import_fs.default.writeFileSync(filename, html);
-    return filename;
-  }
-  writeRawFile(filename, data) {
-    const outputPath = import_path2.default.join(process.cwd(), this.folderPath, filename);
-    import_fs.default.mkdirSync(import_path2.default.dirname(outputPath), { recursive: true });
-    const content = typeof data === "string" ? data : JSON.stringify(data, null, 2);
-    import_fs.default.writeFileSync(outputPath, content, "utf-8");
-    return outputPath;
-  }
-  copyTraceViewerAssets(skip) {
-    if (skip) return;
-    const traceViewerFolder = import_path2.default.join(
-      require.resolve("playwright-core"),
-      "..",
-      "lib",
-      "vite",
-      "traceViewer"
-    );
-    const traceViewerTargetFolder = import_path2.default.join(this.folderPath, "trace");
-    const traceViewerAssetsTargetFolder = import_path2.default.join(
-      traceViewerTargetFolder,
-      "assets"
-    );
-    import_fs.default.mkdirSync(traceViewerAssetsTargetFolder, { recursive: true });
-    for (const file of import_fs.default.readdirSync(traceViewerFolder)) {
-      if (file.endsWith(".map") || file.includes("watch") || file.includes("assets"))
-        continue;
-      import_fs.default.copyFileSync(
-        import_path2.default.join(traceViewerFolder, file),
-        import_path2.default.join(traceViewerTargetFolder, file)
-      );
-    }
-    const assetsFolder = import_path2.default.join(traceViewerFolder, "assets");
-    for (const file of import_fs.default.readdirSync(assetsFolder)) {
-      if (file.endsWith(".map") || file.includes("xtermModule")) continue;
-      import_fs.default.copyFileSync(
-        import_path2.default.join(assetsFolder, file),
-        import_path2.default.join(traceViewerAssetsTargetFolder, file)
-      );
-    }
-  }
-};
-
 // src/utils/groupProjects.ts
 function groupResults(config, results) {
   if (config.showProject) {
@@ -498,13 +366,46 @@ var HTMLGenerator = class {
     );
     return data;
   }
+  /**
+   * Return safe analytics/report data.
+   * If no dbManager is provided, return empty defaults and a note explaining why.
+   */
   async getReportData() {
-    return {
-      summary: await this.dbManager.getSummaryData(),
-      trends: await this.dbManager.getTrends(),
-      flakyTests: await this.dbManager.getFlakyTests(),
-      slowTests: await this.dbManager.getSlowTests()
-    };
+    if (!this.dbManager) {
+      return {
+        summary: {},
+        trends: {},
+        flakyTests: [],
+        slowTests: [],
+        note: "Test history/trends are unavailable (saveHistory disabled or DB not initialized)."
+      };
+    }
+    try {
+      const [summary, trends, flakyTests, slowTests] = await Promise.all([
+        this.dbManager.getSummaryData ? this.dbManager.getSummaryData() : Promise.resolve({}),
+        this.dbManager.getTrends ? this.dbManager.getTrends() : Promise.resolve({}),
+        this.dbManager.getFlakyTests ? this.dbManager.getFlakyTests() : Promise.resolve([]),
+        this.dbManager.getSlowTests ? this.dbManager.getSlowTests() : Promise.resolve([])
+      ]);
+      return {
+        summary: summary ?? {},
+        trends: trends ?? {},
+        flakyTests: flakyTests ?? [],
+        slowTests: slowTests ?? []
+      };
+    } catch (err) {
+      console.warn(
+        "HTMLGenerator: failed to read analytics from DB, continuing without history.",
+        err
+      );
+      return {
+        summary: {},
+        trends: {},
+        flakyTests: [],
+        slowTests: [],
+        note: "Test history/trends could not be loaded due to a DB error."
+      };
+    }
   }
   async prepareReportData(filteredResults, totalDuration, results, projectSet) {
     const totalTests = filteredResults.length;
@@ -513,10 +414,10 @@ var HTMLGenerator = class {
     const failed = filteredResults.filter(
       (r) => r.status === "failed" || r.status === "timedOut"
     ).length;
-    const successRate = ((passedTests + flakyTests) / totalTests * 100).toFixed(2);
+    const successRate = totalTests === 0 ? "0.00" : ((passedTests + flakyTests) / totalTests * 100).toFixed(2);
     const allTags = /* @__PURE__ */ new Set();
     results.forEach(
-      (result) => result.testTags.forEach((tag) => allTags.add(tag))
+      (result) => (result.testTags || []).forEach((tag) => allTags.add(tag))
     );
     const projectResults = this.calculateProjectResults(
       filteredResults,
@@ -527,13 +428,31 @@ var HTMLGenerator = class {
     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
-        };
+        if (!this.dbManager || !this.dbManager.getTestHistory) {
+          return {
+            testId,
+            history: []
+          };
+        }
+        try {
+          const history = await this.dbManager.getTestHistory(testId);
+          return {
+            testId,
+            history: history ?? []
+          };
+        } catch (err) {
+          console.warn(
+            `HTMLGenerator: failed to read history for ${testId}`,
+            err
+          );
+          return {
+            testId,
+            history: []
+          };
+        }
       })
     );
+    const reportData = await this.getReportData();
     return {
       summary: {
         overAllResult: {
@@ -569,7 +488,7 @@ var HTMLGenerator = class {
         showProject: this.ortoniConfig.showProject || false
       },
       analytics: {
-        reportData: await this.getReportData()
+        reportData
       }
     };
   }
@@ -607,45 +526,275 @@ var HTMLGenerator = class {
   }
 };
 
-// src/cli/mergeData.ts
-async function mergeAllData(options) {
-  const projectRoot = process.cwd();
-  const folderPath = path3.resolve(projectRoot, options.dir || "ortoni-report");
+// src/helpers/fileManager.ts
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+
+// src/helpers/templateLoader.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_meta = {};
+async function readBundledTemplate(pkgName = "ortoni-report") {
+  const packagedRel = "dist/index.html";
+  try {
+    if (typeof require === "function") {
+      const resolved = require.resolve(`${pkgName}/${packagedRel}`);
+      if (import_fs.default.existsSync(resolved)) {
+        return import_fs.default.readFileSync(resolved, "utf-8");
+      }
+    }
+  } catch {
+  }
+  try {
+    const moduleNS = await import("module");
+    if (moduleNS && typeof moduleNS.createRequire === "function") {
+      const createRequire = moduleNS.createRequire;
+      const req = createRequire(
+        // @ts-ignore
+        typeof __filename !== "undefined" ? __filename : import_meta.url
+      );
+      const resolved = req.resolve(`${pkgName}/${packagedRel}`);
+      if (import_fs.default.existsSync(resolved)) {
+        return import_fs.default.readFileSync(resolved, "utf-8");
+      }
+    }
+  } catch {
+  }
+  try {
+    const here = import_path.default.resolve(__dirname, "../dist/index.html");
+    if (import_fs.default.existsSync(here)) return import_fs.default.readFileSync(here, "utf-8");
+  } catch {
+  }
+  try {
+    const nm = import_path.default.join(process.cwd(), "node_modules", pkgName, packagedRel);
+    if (import_fs.default.existsSync(nm)) return import_fs.default.readFileSync(nm, "utf-8");
+  } catch {
+  }
+  try {
+    const alt = import_path.default.join(process.cwd(), "dist", "index.html");
+    if (import_fs.default.existsSync(alt)) return import_fs.default.readFileSync(alt, "utf-8");
+  } catch {
+  }
+  throw new Error(
+    `ortoni-report template not found (tried:
+  - require.resolve('${pkgName}/${packagedRel}')
+  - import('module').createRequire(...).resolve('${pkgName}/${packagedRel}')
+  - relative ../dist/index.html
+  - ${import_path.default.join(
+      process.cwd(),
+      "node_modules",
+      pkgName,
+      packagedRel
+    )}
+  - ${import_path.default.join(process.cwd(), "dist", "index.html")}
+Ensure 'dist/index.html' is present in the published package and package.json 'files' includes 'dist/'.`
+  );
+}
+
+// src/helpers/fileManager.ts
+var FileManager = class {
+  constructor(folderPath) {
+    this.folderPath = folderPath;
+  }
+  ensureReportDirectory() {
+    const ortoniDataFolder = import_path2.default.join(this.folderPath, "ortoni-data");
+    if (!import_fs2.default.existsSync(this.folderPath)) {
+      import_fs2.default.mkdirSync(this.folderPath, { recursive: true });
+    } else {
+      if (import_fs2.default.existsSync(ortoniDataFolder)) {
+        import_fs2.default.rmSync(ortoniDataFolder, { recursive: true, force: true });
+      }
+    }
+  }
+  async writeReportFile(filename, data) {
+    let html = await readBundledTemplate();
+    const reportJSON = JSON.stringify({
+      data
+    });
+    html = html.replace("__ORTONI_TEST_REPORTDATA__", reportJSON);
+    const outputPath = import_path2.default.join(process.cwd(), this.folderPath, filename);
+    import_fs2.default.writeFileSync(outputPath, html);
+    return outputPath;
+  }
+  writeRawFile(filename, data) {
+    const outputPath = import_path2.default.join(process.cwd(), this.folderPath, filename);
+    import_fs2.default.mkdirSync(import_path2.default.dirname(outputPath), { recursive: true });
+    const content = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+    import_fs2.default.writeFileSync(outputPath, content, "utf-8");
+    return outputPath;
+  }
+  copyTraceViewerAssets(skip) {
+    if (skip) return;
+    const traceViewerFolder = import_path2.default.join(
+      require.resolve("playwright-core"),
+      "..",
+      "lib",
+      "vite",
+      "traceViewer"
+    );
+    const traceViewerTargetFolder = import_path2.default.join(this.folderPath, "trace");
+    const traceViewerAssetsTargetFolder = import_path2.default.join(
+      traceViewerTargetFolder,
+      "assets"
+    );
+    import_fs2.default.mkdirSync(traceViewerAssetsTargetFolder, { recursive: true });
+    for (const file of import_fs2.default.readdirSync(traceViewerFolder)) {
+      if (file.endsWith(".map") || file.includes("watch") || file.includes("assets"))
+        continue;
+      import_fs2.default.copyFileSync(
+        import_path2.default.join(traceViewerFolder, file),
+        import_path2.default.join(traceViewerTargetFolder, file)
+      );
+    }
+    const assetsFolder = import_path2.default.join(traceViewerFolder, "assets");
+    for (const file of import_fs2.default.readdirSync(assetsFolder)) {
+      if (file.endsWith(".map") || file.includes("xtermModule")) continue;
+      import_fs2.default.copyFileSync(
+        import_path2.default.join(assetsFolder, file),
+        import_path2.default.join(traceViewerAssetsTargetFolder, file)
+      );
+    }
+  }
+};
+
+// src/mergeData.ts
+async function mergeAllData(options = {}) {
+  const folderPath = options.dir || "ortoni-report";
   console.info(`Ortoni Report: Merging shard files in folder: ${folderPath}`);
-  const shardFiles = fs2.readdirSync(folderPath).filter((f) => f.startsWith("ortoni-shard-") && f.endsWith(".json"));
-  if (shardFiles.length === 0) {
+  if (!fs3.existsSync(folderPath)) {
+    console.error(`Ortoni Report: folder "${folderPath}" does not exist.`);
+    process.exitCode = 1;
+    return;
+  }
+  const filenames = fs3.readdirSync(folderPath).filter((f) => f.startsWith("ortoni-shard-") && f.endsWith(".json"));
+  if (filenames.length === 0) {
     console.error("Ortoni Report: \u274C No shard files found to merge.");
-    process.exit(1);
+    process.exitCode = 1;
+    return;
   }
-  let allResults = [];
-  let projectSet = /* @__PURE__ */ new Set();
-  let totalDuration = 0;
+  const shardFileIndex = (name) => {
+    const m = name.match(/ortoni-shard-(\d+)-of-(\d+)\.json$/);
+    return m ? parseInt(m[1], 10) : null;
+  };
+  const sortedFiles = filenames.map((f) => ({ f, idx: shardFileIndex(f) })).sort((a, b) => {
+    if (a.idx === null && b.idx === null) return a.f.localeCompare(b.f);
+    if (a.idx === null) return 1;
+    if (b.idx === null) return -1;
+    return a.idx - b.idx;
+  }).map((x) => x.f);
+  const dedupeByTestId = true;
+  const resultsById = /* @__PURE__ */ new Map();
+  const projectSet = /* @__PURE__ */ new Set();
+  let totalDurationSum = 0;
+  let totalDurationMax = 0;
   let mergedUserConfig = null;
   let mergedUserMeta = null;
-  for (const file of shardFiles) {
-    const shardData = JSON.parse(
-      fs2.readFileSync(path3.join(folderPath, file), "utf-8")
+  const badShards = [];
+  for (const file of sortedFiles) {
+    const fullPath = path3.join(folderPath, file);
+    try {
+      const shardRaw = fs3.readFileSync(fullPath, "utf-8");
+      const shardData = JSON.parse(shardRaw);
+      if (!Array.isArray(shardData.results)) {
+        console.warn(
+          `Ortoni Report: Shard ${file} missing results array \u2014 skipping.`
+        );
+        badShards.push(file);
+        continue;
+      }
+      for (const r of shardData.results) {
+        const id = r.key;
+        if (dedupeByTestId) {
+          if (!resultsById.has(id)) {
+            resultsById.set(id, r);
+          } else {
+            console.info(
+              `Ortoni Report: Duplicate test ${id} found in ${file} \u2014 keeping first occurrence.`
+            );
+          }
+        } else {
+          resultsById.set(`${id}::${Math.random().toString(36).slice(2)}`, r);
+        }
+      }
+      if (Array.isArray(shardData.projectSet)) {
+        for (const p of shardData.projectSet) projectSet.add(p);
+      }
+      const dur = Number(shardData.duration) || 0;
+      totalDurationSum += dur;
+      if (dur > totalDurationMax) totalDurationMax = dur;
+      if (shardData.userConfig) {
+        if (!mergedUserConfig) mergedUserConfig = { ...shardData.userConfig };
+        else {
+          Object.keys(shardData.userConfig).forEach((k) => {
+            if (mergedUserConfig[k] === void 0 || mergedUserConfig[k] === null || mergedUserConfig[k] === "") {
+              mergedUserConfig[k] = shardData.userConfig[k];
+            } else if (shardData.userConfig[k] !== mergedUserConfig[k]) {
+              console.warn(
+                `Ortoni Report: userConfig mismatch for key "${k}" between shards. Using first value "${mergedUserConfig[k]}".`
+              );
+            }
+          });
+        }
+      }
+      if (shardData.userMeta) {
+        if (!mergedUserMeta) mergedUserMeta = { ...shardData.userMeta };
+        else {
+          mergedUserMeta.meta = {
+            ...mergedUserMeta.meta || {},
+            ...shardData.userMeta.meta || {}
+          };
+        }
+      }
+    } catch (err) {
+      console.error(`Ortoni Report: Failed to parse shard ${file}:`, err);
+      badShards.push(file);
+      continue;
+    }
+  }
+  if (badShards.length > 0) {
+    console.warn(
+      `Ortoni Report: Completed merge with ${badShards.length} bad shard(s) skipped:`,
+      badShards
     );
-    allResults.push(...shardData.results);
-    shardData.projectSet.forEach((p) => projectSet.add(p));
-    totalDuration += shardData.duration;
-    if (!mergedUserConfig && shardData.userConfig)
-      mergedUserConfig = shardData.userConfig;
-    if (!mergedUserMeta && shardData.userMeta)
-      mergedUserMeta = shardData.userMeta;
-  }
-  const dbManager = new DatabaseManager();
-  await dbManager.initialize(
-    path3.join(folderPath, "ortoni-data-history.sqlite")
-  );
-  const runId = await dbManager.saveTestRun();
-  if (typeof runId === "number") {
-    await dbManager.saveTestResults(runId, allResults);
+  }
+  const allResults = Array.from(resultsById.values());
+  const totalDuration = totalDurationSum;
+  const saveHistoryFromOptions = typeof options.saveHistory === "boolean" ? options.saveHistory : void 0;
+  const saveHistoryFromShard = mergedUserConfig && typeof mergedUserConfig.saveHistory === "boolean" ? mergedUserConfig.saveHistory : void 0;
+  const saveHistory = saveHistoryFromOptions ?? saveHistoryFromShard ?? true;
+  let dbManager;
+  let runId;
+  if (saveHistory) {
+    try {
+      dbManager = new DatabaseManager();
+      const dbPath = path3.join(folderPath, "ortoni-data-history.sqlite");
+      await dbManager.initialize(dbPath);
+      runId = await dbManager.saveTestRun();
+      if (typeof runId === "number") {
+        await dbManager.saveTestResults(runId, allResults);
+        console.info(
+          `Ortoni Report: Saved ${allResults.length} results to DB (runId=${runId}).`
+        );
+      } else {
+        console.warn(
+          "Ortoni Report: Failed to create test run in DB; proceeding without saving results."
+        );
+      }
+    } catch (err) {
+      console.error(
+        "Ortoni Report: Error while saving history to DB. Proceeding without DB:",
+        err
+      );
+      dbManager = void 0;
+      runId = void 0;
+    }
   } else {
-    console.error("Ortoni Report: \u274C Failed to save test run to database.");
+    console.info(
+      "Ortoni Report: Skipping history save (saveHistory=false). (Typical for CI runs)"
+    );
   }
   const htmlGenerator = new HTMLGenerator(
-    { ...mergedUserConfig, meta: mergedUserMeta?.meta },
+    { ...mergedUserConfig || {}, meta: mergedUserMeta?.meta },
     dbManager
   );
   const finalReportData = await htmlGenerator.generateFinalReport(
@@ -656,15 +805,76 @@ async function mergeAllData(options) {
   );
   const fileManager = new FileManager(folderPath);
   const outputFileName = options.file || "ortoni-report.html";
-  const outputFilenamePath = path3.join(folderPath, outputFileName);
-  const outputPath = fileManager.writeReportFile(
-    outputFilenamePath,
+  const outputPath = await fileManager.writeReportFile(
+    outputFileName,
     finalReportData
   );
   console.log(`\u2705 Final merged report generated at ${outputPath}`);
+  if (runId) console.log(`\u2705 DB runId: ${runId}`);
+}
+
+// src/utils/expressServer.ts
+var import_express = __toESM(require("express"));
+var import_path3 = __toESM(require("path"));
+var import_child_process = require("child_process");
+function startReportServer(reportFolder, reportFilename, port = 2004, open2) {
+  const app = (0, import_express.default)();
+  app.use(import_express.default.static(reportFolder, { index: false }));
+  app.get("/", (_req, res) => {
+    try {
+      res.sendFile(import_path3.default.resolve(reportFolder, reportFilename));
+    } catch (error) {
+      console.error("Ortoni Report: Error sending report file:", error);
+      res.status(500).send("Error loading report");
+    }
+  });
+  try {
+    const server = app.listen(port, () => {
+      console.log(
+        `Server is running at http://localhost:${port} 
+Press Ctrl+C to stop.`
+      );
+      if (open2 === "always" || open2 === "on-failure") {
+        try {
+          openBrowser(`http://localhost:${port}`);
+        } catch (error) {
+          console.error("Ortoni Report: Error opening browser:", error);
+        }
+      }
+    });
+    server.on("error", (error) => {
+      if (error.code === "EADDRINUSE") {
+        console.error(
+          `Ortoni Report: Port ${port} is already in use. Trying a different port...`
+        );
+      } else {
+        console.error("Ortoni Report: Server error:", error);
+      }
+    });
+  } catch (error) {
+    console.error("Ortoni Report: Error starting the server:", error);
+  }
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  let command;
+  try {
+    if (platform === "win32") {
+      command = "cmd";
+      (0, import_child_process.spawn)(command, ["/c", "start", url]);
+    } else if (platform === "darwin") {
+      command = "open";
+      (0, import_child_process.spawn)(command, [url]);
+    } else {
+      command = "xdg-open";
+      (0, import_child_process.spawn)(command, [url]);
+    }
+  } catch (error) {
+    console.error("Ortoni Report: Error opening the browser:", error);
+  }
 }
 
-// src/cli/cli.ts
+// src/cli.ts
 import_commander.program.version("4.0.1").description("Ortoni Report - CLI");
 import_commander.program.command("show-report").description("Open Ortoni Report").option(
   "-d, --dir <path>",
@@ -676,22 +886,26 @@ import_commander.program.command("show-report").description("Open Ortoni Report"
   "ortoni-report.html"
 ).option("-p, --port <port>", "Port to run the server", "2004").action((options) => {
   const projectRoot = process.cwd();
-  const folderPath = path4.resolve(projectRoot, options.dir);
-  const filePath = path4.resolve(folderPath, options.file);
+  const folderPath = path5.resolve(projectRoot, options.dir);
+  const filePath = path5.resolve(folderPath, options.file);
   const port = parseInt(options.port) || 2004;
-  if (!fs3.existsSync(filePath)) {
+  if (!fs4.existsSync(filePath)) {
     console.error(
       `\u274C Error: The file "${filePath}" does not exist in "${folderPath}".`
     );
     process.exit(1);
   }
-  startReportServer(folderPath, path4.basename(filePath), port, "always");
+  startReportServer(folderPath, path5.basename(filePath), port, "always");
 });
 import_commander.program.command("merge-report").description("Merge sharded reports into one final report").option(
   "-d, --dir <path>",
   "Path to the folder containing shard files",
   "ortoni-report"
 ).option("-f, --file <filename>", "Output report file", "ortoni-report.html").action(async (options) => {
-  await mergeAllData(options);
+  await mergeAllData({
+    dir: options.dir,
+    file: options.file,
+    saveHistory: false
+  });
 });
 import_commander.program.parse(process.argv);