@getcodesentinel/codesentinel 1.11.0 → 1.12.1

package/dist/index.js

@@ -2463,7 +2463,7 @@ var resolveAutoBaselineRef = async (input) => {
 
 // src/index.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { dirname, resolve as resolve5 } from "path";
+import { dirname as dirname2, resolve as resolve5 } from "path";
 import { fileURLToPath } from "url";
 
 // src/application/format-analyze-output.ts
@@ -2857,6 +2857,337 @@ var parseLogLevel = (value) => {
   }
 };
 
+// src/application/check-for-updates.ts
+import { spawn } from "child_process";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join as join3 } from "path";
+import { stderr, stdin } from "process";
+import { clearScreenDown, cursorTo, emitKeypressEvents, moveCursor } from "readline";
+var UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var UPDATE_CACHE_PATH = join3(homedir(), ".cache", "codesentinel", "update-check.json");
+var SEMVER_PATTERN = /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?:-(?<prerelease>[0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m"
+};
+var parsePrereleaseIdentifier = (identifier) => {
+  if (/^\d+$/.test(identifier)) {
+    return Number.parseInt(identifier, 10);
+  }
+  return identifier;
+};
+var parseSemver2 = (value) => {
+  const match = SEMVER_PATTERN.exec(value.trim());
+  if (match === null) {
+    return null;
+  }
+  const groups = match.groups;
+  if (groups === void 0) {
+    return null;
+  }
+  const majorRaw = groups["major"];
+  const minorRaw = groups["minor"];
+  const patchRaw = groups["patch"];
+  const prereleaseRaw = groups["prerelease"];
+  if (majorRaw === void 0 || minorRaw === void 0 || patchRaw === void 0) {
+    return null;
+  }
+  const prerelease = prereleaseRaw === void 0 || prereleaseRaw.length === 0 ? [] : prereleaseRaw.split(".").map(parsePrereleaseIdentifier);
+  return {
+    major: Number.parseInt(majorRaw, 10),
+    minor: Number.parseInt(minorRaw, 10),
+    patch: Number.parseInt(patchRaw, 10),
+    prerelease
+  };
+};
+var comparePrerelease = (left, right) => {
+  if (left.length === 0 && right.length === 0) {
+    return 0;
+  }
+  if (left.length === 0) {
+    return 1;
+  }
+  if (right.length === 0) {
+    return -1;
+  }
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftValue = left[index];
+    const rightValue = right[index];
+    if (leftValue === void 0) {
+      return -1;
+    }
+    if (rightValue === void 0) {
+      return 1;
+    }
+    if (typeof leftValue === "number" && typeof rightValue === "number") {
+      if (leftValue !== rightValue) {
+        return leftValue > rightValue ? 1 : -1;
+      }
+      continue;
+    }
+    if (typeof leftValue === "number" && typeof rightValue === "string") {
+      return -1;
+    }
+    if (typeof leftValue === "string" && typeof rightValue === "number") {
+      return 1;
+    }
+    if (leftValue !== rightValue) {
+      return leftValue > rightValue ? 1 : -1;
+    }
+  }
+  return 0;
+};
+var compareVersions = (left, right) => {
+  const leftParsed = parseSemver2(left);
+  const rightParsed = parseSemver2(right);
+  if (leftParsed === null || rightParsed === null) {
+    return null;
+  }
+  if (leftParsed.major !== rightParsed.major) {
+    return leftParsed.major > rightParsed.major ? 1 : -1;
+  }
+  if (leftParsed.minor !== rightParsed.minor) {
+    return leftParsed.minor > rightParsed.minor ? 1 : -1;
+  }
+  if (leftParsed.patch !== rightParsed.patch) {
+    return leftParsed.patch > rightParsed.patch ? 1 : -1;
+  }
+  return comparePrerelease(leftParsed.prerelease, rightParsed.prerelease);
+};
+var isTruthy = (value) => {
+  if (value === void 0) {
+    return false;
+  }
+  return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+};
+var parseNpmViewVersionOutput = (output) => {
+  const trimmed = output.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed === "string" && parsed.trim().length > 0) {
+      return parsed.trim();
+    }
+    if (Array.isArray(parsed) && parsed.length > 0) {
+      const latest = parsed.at(-1);
+      if (typeof latest === "string" && latest.trim().length > 0) {
+        return latest.trim();
+      }
+    }
+  } catch {
+    return trimmed;
+  }
+  return null;
+};
+var readCache = async () => {
+  try {
+    const raw = await readFile(UPDATE_CACHE_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && typeof parsed.lastCheckedAt === "string") {
+      return { lastCheckedAt: parsed.lastCheckedAt };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+};
+var writeCache = async (cache) => {
+  await mkdir(dirname(UPDATE_CACHE_PATH), { recursive: true });
+  await writeFile(UPDATE_CACHE_PATH, JSON.stringify(cache), "utf8");
+};
+var shouldRunUpdateCheck = (input) => {
+  if (!input.isInteractive) {
+    return false;
+  }
+  if (isTruthy(input.env["CI"])) {
+    return false;
+  }
+  if (isTruthy(input.env["CODESENTINEL_NO_UPDATE_NOTIFIER"])) {
+    return false;
+  }
+  if (input.argv.some((argument) => argument === "--help" || argument === "-h")) {
+    return false;
+  }
+  if (input.argv.some((argument) => argument === "--version" || argument === "-V")) {
+    return false;
+  }
+  if (input.lastCheckedAt === null) {
+    return true;
+  }
+  const lastCheckedMs = Date.parse(input.lastCheckedAt);
+  if (!Number.isFinite(lastCheckedMs)) {
+    return true;
+  }
+  return input.nowMs - lastCheckedMs >= UPDATE_CHECK_INTERVAL_MS;
+};
+var runCommand = async (command, args, mode) => {
+  return await new Promise((resolvePromise, reject) => {
+    const child = spawn(command, [...args], {
+      stdio: mode === "inherit" ? "inherit" : ["ignore", "pipe", "pipe"]
+    });
+    let stdoutRaw = "";
+    if (mode === "capture" && child.stdout !== null) {
+      child.stdout.setEncoding("utf8");
+      child.stdout.on("data", (chunk) => {
+        stdoutRaw += chunk;
+      });
+    }
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("close", (code) => {
+      resolvePromise({ code: code ?? 1, stdout: stdoutRaw });
+    });
+  });
+};
+var fetchLatestVersion = async (packageName) => {
+  const result = await runCommand("npm", ["view", packageName, "version", "--json"], "capture");
+  if (result.code !== 0) {
+    return null;
+  }
+  return parseNpmViewVersionOutput(result.stdout);
+};
+var renderUpdatePrompt = (latestVersion, currentVersion, selectedIndex) => {
+  const options = ["Install update now", "Not now (continue current command)"];
+  const lines = [
+    `${ANSI.cyan}${ANSI.bold}CodeSentinel Update Available${ANSI.reset}`,
+    `${ANSI.dim}Current: ${currentVersion}  Latest: ${latestVersion}${ANSI.reset}`,
+    "",
+    ...options.map((option, index) => {
+      const selected = index === selectedIndex;
+      const prefix = selected ? `${ANSI.green}>${ANSI.reset}` : " ";
+      const text = selected ? `${ANSI.bold}${option}${ANSI.reset}` : option;
+      return `${prefix} ${text}`;
+    }),
+    "",
+    `${ANSI.dim}Use \u2191/\u2193 to choose, Enter to confirm.${ANSI.reset}`
+  ];
+  stderr.write(lines.join("\n"));
+  return lines.length;
+};
+var promptInstall = async (latestVersion, currentVersion) => {
+  if (!stdin.isTTY || !stderr.isTTY || typeof stdin.setRawMode !== "function") {
+    stderr.write(
+      `New version ${latestVersion} is available (current ${currentVersion}). Run: npm install -g @getcodesentinel/codesentinel@latest
+`
+    );
+    return "skip";
+  }
+  return await new Promise((resolve6) => {
+    emitKeypressEvents(stdin);
+    let selectedIndex = 0;
+    let renderedLines = 0;
+    const previousRawMode = stdin.isRaw;
+    const clearPromptArea = () => {
+      if (renderedLines > 0) {
+        moveCursor(stderr, 0, -(renderedLines - 1));
+      }
+      cursorTo(stderr, 0);
+      clearScreenDown(stderr);
+    };
+    const redraw = () => {
+      clearPromptArea();
+      renderedLines = renderUpdatePrompt(latestVersion, currentVersion, selectedIndex);
+    };
+    const cleanup = (choice) => {
+      stdin.off("keypress", onKeypress);
+      stdin.pause();
+      if (typeof stdin.setRawMode === "function") {
+        stdin.setRawMode(previousRawMode);
+      }
+      clearPromptArea();
+      if (choice === "install") {
+        stderr.write(`${ANSI.yellow}Installing latest CodeSentinel...${ANSI.reset}
+`);
+      } else if (renderedLines > 0) {
+        stderr.write("\n");
+      }
+      resolve6(choice);
+    };
+    const onKeypress = (_str, key) => {
+      if (key.ctrl === true && key.name === "c") {
+        cleanup("interrupt");
+        return;
+      }
+      if (key.name === "up") {
+        selectedIndex = selectedIndex > 0 ? selectedIndex - 1 : 1;
+        redraw();
+        return;
+      }
+      if (key.name === "down") {
+        selectedIndex = selectedIndex < 1 ? selectedIndex + 1 : 0;
+        redraw();
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        cleanup(selectedIndex === 0 ? "install" : "skip");
+      }
+    };
+    stdin.on("keypress", onKeypress);
+    if (typeof stdin.setRawMode === "function") {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    redraw();
+  });
+};
+var installLatestVersion = async (packageName) => {
+  const result = await runCommand("npm", ["install", "-g", `${packageName}@latest`], "inherit");
+  return result.code === 0;
+};
+var checkForCliUpdates = async (input) => {
+  try {
+    const nowMs = Date.now();
+    const cache = await readCache();
+    const shouldCheck = shouldRunUpdateCheck({
+      argv: input.argv,
+      env: input.env,
+      isInteractive: Boolean(process.stdout.isTTY) && Boolean(process.stdin.isTTY),
+      nowMs,
+      lastCheckedAt: cache?.lastCheckedAt ?? null
+    });
+    if (!shouldCheck) {
+      return;
+    }
+    await writeCache({ lastCheckedAt: new Date(nowMs).toISOString() });
+    const latestVersion = await fetchLatestVersion(input.packageName);
+    if (latestVersion === null) {
+      return;
+    }
+    const comparison = compareVersions(latestVersion, input.currentVersion);
+    if (comparison === null || comparison <= 0) {
+      return;
+    }
+    const choice = await promptInstall(latestVersion, input.currentVersion);
+    if (choice === "interrupt") {
+      process.exit(130);
+    }
+    if (choice !== "install") {
+      return;
+    }
+    const installed = await installLatestVersion(input.packageName);
+    if (installed) {
+      stderr.write(
+        "CodeSentinel updated to latest version. Rerun your command to use the new version.\n"
+      );
+      process.exit(0);
+    } else {
+      stderr.write(
+        "CodeSentinel update failed. You can retry with: npm install -g @getcodesentinel/codesentinel@latest\n"
+      );
+    }
+  } catch {
+  }
+};
+
 // src/application/run-analyze-command.ts
 import { resolve as resolve3 } from "path";
 
@@ -4098,6 +4429,29 @@ var computeDependencySignalScore = (ownSignals, inheritedSignals, inheritedSigna
   return toUnitInterval(weightedTotal / maxWeightedTotal);
 };
 var clampConfidence = (value) => round45(toUnitInterval(value));
+var computeExternalMetadataConfidence = (external) => {
+  if (!external.available) {
+    return 0;
+  }
+  return round45(toUnitInterval(0.35 + external.metrics.metadataCoverage * 0.65));
+};
+var computeEvolutionHistoryConfidence = (structural, evolution, evolutionByFile) => {
+  if (!evolution.available) {
+    return 0;
+  }
+  const totalFiles = structural.files.length;
+  if (totalFiles === 0) {
+    return 1;
+  }
+  let coveredFiles = 0;
+  for (const file of structural.files) {
+    if (evolutionByFile.has(normalizePath2(file.id))) {
+      coveredFiles += 1;
+    }
+  }
+  const coverage = coveredFiles / totalFiles;
+  return round45(toUnitInterval(0.3 + coverage * 0.7));
+};
 var buildFactorTraces = (totalScore, inputs) => {
   const positiveInputs = inputs.filter((input) => input.strength > 0);
   const strengthTotal = positiveInputs.reduce((sum, input) => sum + input.strength, 0);
@@ -4198,6 +4552,7 @@ var computeDependencyScores = (external, config) => {
     config.quantileClamp.upper
   );
   const dependencyContexts = /* @__PURE__ */ new Map();
+  const metadataConfidence = computeExternalMetadataConfidence(external);
   const dependencyScores = external.dependencies.map((dependency) => {
     const signalScore = computeDependencySignalScore(
       dependency.ownRiskSignals,
@@ -4232,7 +4587,7 @@ var computeDependencyScores = (external, config) => {
       dependency.busFactor,
       dependency.weeklyDownloads
     ].filter((value) => value !== null).length;
-    const confidence = toUnitInterval(0.5 + availableMetricCount * 0.125);
+    const confidence = toUnitInterval((0.5 + availableMetricCount * 0.125) * metadataConfidence);
     dependencyContexts.set(dependency.name, {
       signalScore: round45(signalScore),
       stalenessRisk: round45(stalenessRisk),
@@ -4431,7 +4786,13 @@ var buildFragileClusters = (structural, evolution, fileScoresByFile, config) =>
 var computeRiskSummary = (structural, evolution, external, config, traceCollector) => {
   const collector = traceCollector;
   const dependencyComputation = computeDependencyScores(external, config);
+  const externalMetadataConfidence = computeExternalMetadataConfidence(external);
   const evolutionByFile = mapEvolutionByFile(evolution);
+  const evolutionHistoryConfidence = computeEvolutionHistoryConfidence(
+    structural,
+    evolution,
+    evolutionByFile
+  );
   const evolutionScales = computeEvolutionScales(evolutionByFile, config);
   const cycleFileSet = new Set(
     structural.cycles.flatMap((cycle) => cycle.nodes.map((node) => normalizePath2(node)))
@@ -4615,7 +4976,7 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
           weight: dimensionWeights.evolution,
           amplification: null,
           evidence: [{ kind: "file_metric", target: context.file, metric: "commitCount" }],
-          confidence: evolution.available ? 1 : 0
+          confidence: evolution.available ? evolutionHistoryConfidence * (context.rawMetrics.commitCount === null ? 0.5 : 1) : 0
         },
         {
           factorId: "file.external",
@@ -4631,7 +4992,7 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
           weight: dimensionWeights.external,
           amplification: null,
           evidence: [{ kind: "repository_metric", metric: "repositoryExternalPressure" }],
-          confidence: external.available ? 0.7 : 0
+          confidence: external.available ? 0.7 * externalMetadataConfidence : 0
         },
         {
           factorId: "file.composite.interactions",
@@ -4759,7 +5120,7 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
           weight: config.dependencyFactorWeights.signals,
           amplification: config.dependencySignals.inheritedSignalMultiplier,
           evidence: [{ kind: "dependency_metric", target: dependency.name, metric: "riskSignals" }],
-          confidence: 0.95
+          confidence: 0.95 * externalMetadataConfidence
         },
         {
           factorId: "dependency.staleness",
@@ -4772,7 +5133,7 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
           evidence: [
             { kind: "dependency_metric", target: dependency.name, metric: "daysSinceLastRelease" }
           ],
-          confidence: hasMetadata ? 0.9 : 0.5
+          confidence: (hasMetadata ? 0.9 : 0.5) * externalMetadataConfidence
         },
         {
           factorId: "dependency.maintainer_concentration",
@@ -4787,7 +5148,7 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
           evidence: [
             { kind: "dependency_metric", target: dependency.name, metric: "maintainerCount" }
           ],
-          confidence: hasMetadata ? 0.9 : 0.5
+          confidence: (hasMetadata ? 0.9 : 0.5) * externalMetadataConfidence
         },
         {
           factorId: "dependency.topology",
@@ -4808,7 +5169,7 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
           evidence: [
             { kind: "dependency_metric", target: dependency.name, metric: "dependencyDepth" }
           ],
-          confidence: 1
+          confidence: 1 * externalMetadataConfidence
         },
         {
           factorId: "dependency.bus_factor",
@@ -4819,7 +5180,7 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
           weight: config.dependencyFactorWeights.busFactorRisk,
           amplification: null,
           evidence: [{ kind: "dependency_metric", target: dependency.name, metric: "busFactor" }],
-          confidence: context.rawMetrics.busFactor === null ? 0.5 : 0.85
+          confidence: (context.rawMetrics.busFactor === null ? 0.5 : 0.85) * externalMetadataConfidence
         },
         {
           factorId: "dependency.popularity_dampening",
@@ -4832,7 +5193,7 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
           evidence: [
             { kind: "dependency_metric", target: dependency.name, metric: "weeklyDownloads" }
           ],
-          confidence: context.rawMetrics.weeklyDownloads === null ? 0.4 : 0.9
+          confidence: (context.rawMetrics.weeklyDownloads === null ? 0.4 : 0.9) * externalMetadataConfidence
         }
       ]);
       collector.record(
@@ -4889,7 +5250,7 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
         weight: dimensionWeights.evolution,
         amplification: null,
         evidence: [{ kind: "repository_metric", metric: "evolutionDimension" }],
-        confidence: evolution.available ? 1 : 0
+        confidence: evolution.available ? evolutionHistoryConfidence : 0
       },
       {
         factorId: "repository.external",
@@ -4900,7 +5261,7 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
         weight: dimensionWeights.external,
         amplification: null,
         evidence: [{ kind: "repository_metric", metric: "externalDimension" }],
-        confidence: external.available ? 0.8 : 0
+        confidence: external.available ? 0.8 * externalMetadataConfidence : 0
       },
       {
         factorId: "repository.composite.interactions",
@@ -5236,7 +5597,7 @@ var runAnalyzeCommand = async (inputPath, authorIdentityMode, options = {}, logg
 };
 
 // src/application/run-check-command.ts
-import { readFile, writeFile } from "fs/promises";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 
 // src/application/build-analysis-snapshot.ts
 var buildAnalysisSnapshot = async (inputPath, authorIdentityMode, options, logger) => {
@@ -5301,7 +5662,7 @@ var runCheckCommand = async (inputPath, authorIdentityMode, options, logger = cr
   let diff;
   if (options.baselinePath !== void 0) {
     logger.info(`loading baseline snapshot: ${options.baselinePath}`);
-    const baselineRaw = await readFile(options.baselinePath, "utf8");
+    const baselineRaw = await readFile2(options.baselinePath, "utf8");
     try {
       baseline = parseSnapshot(baselineRaw);
     } catch (error) {
@@ -5327,7 +5688,7 @@ var runCheckCommand = async (inputPath, authorIdentityMode, options, logger = cr
     options.outputFormat
   );
   if (options.outputPath !== void 0) {
-    await writeFile(options.outputPath, rendered, "utf8");
+    await writeFile2(options.outputPath, rendered, "utf8");
     logger.info(`check output written: ${options.outputPath}`);
   }
   return {
@@ -5340,7 +5701,7 @@ var runCheckCommand = async (inputPath, authorIdentityMode, options, logger = cr
 };
 
 // src/application/run-ci-command.ts
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import { relative as relative2, resolve as resolve4 } from "path";
 var isPathOutsideBase = (value) => {
   return value === ".." || value.startsWith("../") || value.startsWith("..\\");
@@ -5366,7 +5727,7 @@ var runCiCommand = async (inputPath, authorIdentityMode, options, logger = creat
     logger
   );
   if (options.snapshotPath !== void 0) {
-    await writeFile2(options.snapshotPath, JSON.stringify(current, null, 2), "utf8");
+    await writeFile3(options.snapshotPath, JSON.stringify(current, null, 2), "utf8");
     logger.info(`snapshot written: ${options.snapshotPath}`);
   }
   let baseline;
@@ -5438,7 +5799,7 @@ var runCiCommand = async (inputPath, authorIdentityMode, options, logger = creat
     diff = compareSnapshots(current, baseline);
   } else if (options.baselinePath !== void 0) {
     logger.info(`loading baseline snapshot: ${options.baselinePath}`);
-    const baselineRaw = await readFile2(options.baselinePath, "utf8");
+    const baselineRaw = await readFile3(options.baselinePath, "utf8");
     try {
       baseline = parseSnapshot(baselineRaw);
     } catch (error) {
@@ -5460,7 +5821,7 @@ var runCiCommand = async (inputPath, authorIdentityMode, options, logger = creat
 
 ${ciMarkdown}`;
   if (options.reportPath !== void 0) {
-    await writeFile2(options.reportPath, markdownSummary, "utf8");
+    await writeFile3(options.reportPath, markdownSummary, "utf8");
     logger.info(`report written: ${options.reportPath}`);
   }
   const machineReadable = {
@@ -5472,7 +5833,7 @@ ${ciMarkdown}`;
     exitCode: gateResult.exitCode
   };
   if (options.jsonOutputPath !== void 0) {
-    await writeFile2(options.jsonOutputPath, JSON.stringify(machineReadable, null, 2), "utf8");
+    await writeFile3(options.jsonOutputPath, JSON.stringify(machineReadable, null, 2), "utf8");
     logger.info(`ci machine output written: ${options.jsonOutputPath}`);
   }
   return {
@@ -5486,7 +5847,7 @@ ${ciMarkdown}`;
 };
 
 // src/application/run-report-command.ts
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
 var runReportCommand = async (inputPath, authorIdentityMode, options, logger = createSilentLogger()) => {
   logger.info("building analysis snapshot");
   const current = await buildAnalysisSnapshot(
@@ -5499,7 +5860,7 @@ var runReportCommand = async (inputPath, authorIdentityMode, options, logger = c
     logger
   );
   if (options.snapshotPath !== void 0) {
-    await writeFile3(options.snapshotPath, JSON.stringify(current, null, 2), "utf8");
+    await writeFile4(options.snapshotPath, JSON.stringify(current, null, 2), "utf8");
     logger.info(`snapshot written: ${options.snapshotPath}`);
   }
   let report;
@@ -5507,14 +5868,14 @@ var runReportCommand = async (inputPath, authorIdentityMode, options, logger = c
     report = createReport(current);
   } else {
     logger.info(`loading baseline snapshot: ${options.comparePath}`);
-    const baselineRaw = await readFile3(options.comparePath, "utf8");
+    const baselineRaw = await readFile4(options.comparePath, "utf8");
     const baseline = parseSnapshot(baselineRaw);
     const diff = compareSnapshots(current, baseline);
     report = createReport(current, diff);
   }
   const rendered = formatReport(report, options.format);
   if (options.outputPath !== void 0) {
-    await writeFile3(options.outputPath, rendered, "utf8");
+    await writeFile4(options.outputPath, rendered, "utf8");
     logger.info(`report written: ${options.outputPath}`);
   }
   return { report, rendered };
@@ -5568,7 +5929,7 @@ var runExplainCommand = async (inputPath, authorIdentityMode, options, logger =
 
 // src/index.ts
 var program = new Command();
-var packageJsonPath = resolve5(dirname(fileURLToPath(import.meta.url)), "../package.json");
+var packageJsonPath = resolve5(dirname2(fileURLToPath(import.meta.url)), "../package.json");
 var { version } = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
 var parseRecentWindowDays = (value) => {
   const parsed = Number.parseInt(value, 10);
@@ -5886,5 +6247,11 @@ if (argv.length <= 2) {
   program.outputHelp();
   process.exit(0);
 }
+await checkForCliUpdates({
+  packageName: "@getcodesentinel/codesentinel",
+  currentVersion: version,
+  argv: process.argv,
+  env: process.env
+});
 await program.parseAsync(argv);
 //# sourceMappingURL=index.js.map