@getcodesentinel/codesentinel 1.11.0 → 1.12.0

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";
 
@@ -5236,7 +5567,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 +5632,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 +5658,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 +5671,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 +5697,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 +5769,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 +5791,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 +5803,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 +5817,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 +5830,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 +5838,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 +5899,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 +6217,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