@getcodesentinel/codesentinel 1.17.5 → 1.19.0

package/README.md

@@ -149,6 +149,7 @@ codesentinel report [path]
 codesentinel check [path]
 codesentinel ci [path]
 codesentinel dependency-risk <dependency[@version]>
+codesentinel update
 ```
 
 Examples:
@@ -173,8 +174,11 @@ codesentinel ci --baseline-ref origin/main --max-risk-delta 0.03 --no-new-cycles
 codesentinel ci --baseline-ref auto --fail-on error
 codesentinel dependency-risk react
 codesentinel dependency-risk react@19.0.0
+codesentinel update
 ```
 
+Use `codesentinel update` to manually check for a newer CLI release and install it without waiting for the startup notifier.
+
 Author identity mode:
 
 ```bash

package/dist/index.js

@@ -2809,10 +2809,10 @@ var runGit = async (repositoryPath, args) => {
 };
 var tryRunGit = async (repositoryPath, args) => {
   try {
-    const { stdout } = await execFileAsync("git", ["-C", repositoryPath, ...args], {
+    const { stdout: stdout2 } = await execFileAsync("git", ["-C", repositoryPath, ...args], {
       encoding: "utf8"
     });
-    return { ok: true, stdout: stdout.trim() };
+    return { ok: true, stdout: stdout2.trim() };
   } catch (error) {
     const message = error instanceof Error ? error.message : "unknown git error";
     return { ok: false, message };
@@ -3336,6 +3336,12 @@ var ANSI = {
   green: "\x1B[32m",
   yellow: "\x1B[33m"
 };
+var hideCursor = () => {
+  stderr.write("\x1B[?25l");
+};
+var showCursor = () => {
+  stderr.write("\x1B[?25h");
+};
 var parsePrereleaseIdentifier = (identifier) => {
   if (/^\d+$/.test(identifier)) {
     return Number.parseInt(identifier, 10);
@@ -3451,6 +3457,9 @@ var parseNpmViewVersionOutput = (output) => {
 var renderUpdateInProgressMessage = (packageName) => `Updating CodeSentinel via \`npm install -g ${packageName}\`...
 `;
 var renderUpdateSuccessMessage = () => "\u{1F389} Update ran successfully! Please restart CodeSentinel.\n";
+var renderAlreadyUpToDateMessage = (currentVersion) => `CodeSentinel is already up to date (${currentVersion}).
+`;
+var renderUpdateCheckFailedMessage = () => "CodeSentinel could not check for updates right now. Please try again later.\n";
 var readCache = async () => {
   try {
     const raw = await readFile2(UPDATE_CACHE_PATH, "utf8");
@@ -3536,7 +3545,7 @@ var renderUpdatePrompt = (packageName, latestVersion, currentVersion, selectedIn
       return `${prefix} ${text}`;
     }),
     "",
-    `  ${ANSI.dim}Use \u2191/\u2193 to choose. Press enter to continue${ANSI.reset}`
+    `  ${ANSI.dim}Use \u2191/\u2193 to choose. Press enter to continue. Press q or Ctrl+C to exit.${ANSI.reset}`
   ];
   stderr.write(lines.join("\n"));
   return lines.length;
@@ -3568,6 +3577,7 @@ var promptInstall = async (packageName, latestVersion, currentVersion) => {
         stdin.setRawMode(previousRawMode);
       }
       clearPromptArea();
+      showCursor();
       if (choice === "install") {
         stderr.write(`${ANSI.yellow}${renderUpdateInProgressMessage(packageName)}${ANSI.reset}`);
       } else {
@@ -3577,7 +3587,11 @@ var promptInstall = async (packageName, latestVersion, currentVersion) => {
     };
     const onKeypress = (_str, key) => {
       if (key.ctrl === true && key.name === "c") {
-        cleanup("interrupt");
+        cleanup("skip");
+        return;
+      }
+      if (key.name === "q") {
+        cleanup("skip");
         return;
       }
       if (key.name === "up") {
@@ -3596,6 +3610,7 @@ var promptInstall = async (packageName, latestVersion, currentVersion) => {
     };
     stdin.on("keypress", onKeypress);
     if (typeof stdin.setRawMode === "function") {
+      hideCursor();
       stdin.setRawMode(true);
     }
     stdin.resume();
@@ -3606,6 +3621,35 @@ var installLatestVersion = async (packageName) => {
   const result = await runCommand("npm", ["install", "-g", `${packageName}@latest`], "inherit");
   return result.code === 0;
 };
+var runManualCliUpdate = async (input) => {
+  const latestVersion = await fetchLatestVersion(input.packageName);
+  if (latestVersion === null) {
+    stderr.write(renderUpdateCheckFailedMessage());
+    return 1;
+  }
+  const comparison = compareVersions(latestVersion, input.currentVersion);
+  if (comparison === null) {
+    stderr.write(renderUpdateCheckFailedMessage());
+    return 1;
+  }
+  if (comparison <= 0) {
+    stderr.write(renderAlreadyUpToDateMessage(input.currentVersion));
+    return 0;
+  }
+  const choice = await promptInstall(input.packageName, latestVersion, input.currentVersion);
+  if (choice !== "install") {
+    return 0;
+  }
+  const installed = await installLatestVersion(input.packageName);
+  if (installed) {
+    stderr.write(renderUpdateSuccessMessage());
+    return 0;
+  }
+  stderr.write(
+    "CodeSentinel update failed. You can retry with: npm install -g @getcodesentinel/codesentinel@latest\n"
+  );
+  return 1;
+};
 var checkForCliUpdates = async (input) => {
   try {
     const nowMs = Date.now();
@@ -3630,9 +3674,6 @@ var checkForCliUpdates = async (input) => {
       return;
     }
     const choice = await promptInstall(input.packageName, latestVersion, input.currentVersion);
-    if (choice === "interrupt") {
-      process.exit(130);
-    }
     if (choice !== "install") {
       return;
     }
@@ -3649,6 +3690,217 @@ var checkForCliUpdates = async (input) => {
   }
 };
 
+// src/application/interactive-menu.ts
+import { spawn as spawn2 } from "child_process";
+import { stderr as stderr2, stdin as stdin2, stdout } from "process";
+import { clearScreenDown as clearScreenDown2, cursorTo as cursorTo2, emitKeypressEvents as emitKeypressEvents2, moveCursor } from "readline";
+import { createInterface as createPromisesInterface } from "readline/promises";
+var ANSI2 = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m"
+};
+var renderMenu = (currentVersion, actions, selectedIndex) => {
+  const optionLabels = actions.map((action, index) => `${index + 1}. ${action.label}`);
+  const labelWidth = optionLabels.reduce((max, label) => Math.max(max, label.length), 0);
+  const lines = [
+    `  ${ANSI2.bold}${ANSI2.cyan}CodeSentinel${ANSI2.reset} ${ANSI2.dim}v${currentVersion}${ANSI2.reset}`,
+    "",
+    "  Choose an action:",
+    "",
+    ...actions.map((action, index) => {
+      const selected = index === selectedIndex;
+      const prefix = selected ? `${ANSI2.green}>${ANSI2.reset}` : " ";
+      const label = optionLabels[index]?.padEnd(labelWidth, " ") ?? "";
+      const renderedLabel = selected ? `${ANSI2.bold}${label}${ANSI2.reset}` : label;
+      return `${prefix} ${renderedLabel}  ${ANSI2.dim}${action.description}${ANSI2.reset}`;
+    }),
+    "",
+    `  ${ANSI2.dim}Use \u2191/\u2193 to choose. Press enter to continue. Press q or Ctrl+C to exit.${ANSI2.reset}`
+  ];
+  stderr2.write(lines.join("\n"));
+};
+var clearTerminal = () => {
+  cursorTo2(stderr2, 0, 0);
+  clearScreenDown2(stderr2);
+};
+var hideCursor2 = () => {
+  stderr2.write("\x1B[?25l");
+};
+var showCursor2 = () => {
+  stderr2.write("\x1B[?25h");
+};
+var promptSelection = async (currentVersion, actions) => {
+  if (!stdin2.isTTY || !stderr2.isTTY || typeof stdin2.setRawMode !== "function") {
+    return "exit";
+  }
+  return await new Promise((resolve6) => {
+    emitKeypressEvents2(stdin2);
+    let selectedIndex = 0;
+    const previousRawMode = stdin2.isRaw;
+    const redraw = () => {
+      clearTerminal();
+      renderMenu(currentVersion, actions, selectedIndex);
+      moveCursor(stderr2, -1, 0);
+    };
+    const cleanup = (selection) => {
+      stdin2.off("keypress", onKeypress);
+      stdin2.pause();
+      stdin2.setRawMode(previousRawMode);
+      clearTerminal();
+      showCursor2();
+      resolve6(selection);
+    };
+    const onKeypress = (_str, key) => {
+      if (key.ctrl === true && key.name === "c") {
+        cleanup("exit");
+        return;
+      }
+      if (key.name === "q") {
+        cleanup("exit");
+        return;
+      }
+      if (key.name === "up") {
+        selectedIndex = selectedIndex > 0 ? selectedIndex - 1 : actions.length - 1;
+        redraw();
+        return;
+      }
+      if (key.name === "down") {
+        selectedIndex = selectedIndex < actions.length - 1 ? selectedIndex + 1 : 0;
+        redraw();
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        cleanup(selectedIndex);
+      }
+    };
+    stdin2.on("keypress", onKeypress);
+    hideCursor2();
+    stdin2.setRawMode(true);
+    stdin2.resume();
+    redraw();
+  });
+};
+var createPrompt = () => createPromisesInterface({
+  input: stdin2,
+  output: stderr2
+});
+var promptText = async (prompt, label, defaultValue) => {
+  const suffix = defaultValue === void 0 ? "" : ` [${defaultValue}]`;
+  const answer = await prompt.question(
+    `${label}${suffix}: `
+  );
+  const trimmed = answer.trim();
+  return trimmed.length > 0 ? trimmed : defaultValue ?? "";
+};
+var buildDependencyRiskArgs = async () => {
+  const prompt = createPrompt();
+  try {
+    const dependency = await promptText(prompt, "Dependency spec", "");
+    if (dependency.length === 0) {
+      stderr2.write("A dependency spec is required.\n");
+      return null;
+    }
+    return ["dependency-risk", dependency];
+  } finally {
+    prompt.close();
+  }
+};
+var waitForReturnToMenu = async () => {
+  const prompt = createPromisesInterface({
+    input: stdin2,
+    output: stderr2
+  });
+  try {
+    await prompt.question("Press enter to return to the menu...");
+  } finally {
+    prompt.close();
+  }
+};
+var runCliCommand = async (scriptPath2, args) => {
+  return await new Promise((resolve6, reject) => {
+    const child = spawn2(process.execPath, [...process.execArgv, scriptPath2, ...args], {
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        CODESENTINEL_NO_UPDATE_NOTIFIER: "1"
+      }
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("close", (code) => {
+      resolve6(code ?? 1);
+    });
+  });
+};
+var runInteractiveCliMenu = async (input) => {
+  if (!stdin2.isTTY || !stderr2.isTTY || !stdout.isTTY) {
+    stderr2.write("Interactive menu requires a TTY.\n");
+    return 1;
+  }
+  const actions = [
+    {
+      label: "Run overview",
+      description: "combined analyze + explain + report",
+      commandBuilder: () => ["run"]
+    },
+    {
+      label: "Analyze repository",
+      description: "structural and health scoring summary",
+      commandBuilder: () => ["analyze"]
+    },
+    {
+      label: "Explain hotspots",
+      description: "top findings in markdown by default",
+      commandBuilder: () => ["explain", "--format", "md"]
+    },
+    {
+      label: "Generate report",
+      description: "create a full report for a repository",
+      commandBuilder: () => ["report", "--format", "md"]
+    },
+    {
+      label: "Run policy check",
+      description: "execute governance gates",
+      commandBuilder: () => ["check"]
+    },
+    {
+      label: "Scan dependency risk",
+      description: "inspect a package from the registry",
+      commandBuilder: buildDependencyRiskArgs
+    }
+  ];
+  while (true) {
+    const selectedIndex = await promptSelection(input.currentVersion, actions);
+    if (selectedIndex === "exit") {
+      stderr2.write("\n");
+      return 0;
+    }
+    const selectedAction = actions[selectedIndex];
+    if (selectedAction === void 0) {
+      stderr2.write("\n");
+      return 1;
+    }
+    const args = await selectedAction.commandBuilder();
+    if (args === null) {
+      await waitForReturnToMenu();
+      continue;
+    }
+    const exitCode = await runCliCommand(input.scriptPath, args);
+    if (exitCode !== 0) {
+      stderr2.write(`
+Command exited with code ${exitCode}.
+`);
+    } else {
+      stderr2.write("\n");
+    }
+    await waitForReturnToMenu();
+  }
+};
+
 // src/application/run-analyze-command.ts
 import { resolve as resolve3 } from "path";
 
@@ -7486,6 +7738,12 @@ var scoringProfileOption = () => new Option(
   "scoring profile: default (balanced) or personal (down-weights single-maintainer ownership penalties for risk and health ownership)"
 ).choices(["default", "personal"]).default("default");
 program.name("codesentinel").description("Structural and evolutionary risk analysis for TypeScript/JavaScript codebases").version(version);
+program.command("update").description("check for a newer CodeSentinel version and install it").action(async () => {
+  process.exitCode = await runManualCliUpdate({
+    packageName: "@getcodesentinel/codesentinel",
+    currentVersion: version
+  });
+});
 program.command("analyze").argument("[path]", "path to the project to analyze").addOption(scoringProfileOption()).addOption(
   new Option(
     "--author-identity <mode>",
@@ -8011,22 +8269,27 @@ program.command("ci").argument("[path]", "path to the project to analyze").addOp
     }
   }
 );
-if (process.argv.length <= 2) {
-  program.outputHelp();
-  process.exit(0);
-}
 var executablePath = process.argv[0] ?? "";
 var scriptPath = process.argv[1] ?? "";
 var argv = process.argv[2] === "--" ? [executablePath, scriptPath, ...process.argv.slice(3)] : process.argv;
 if (argv.length <= 2) {
+  if (process.stdin.isTTY && process.stdout.isTTY && process.stderr.isTTY) {
+    process.exitCode = await runInteractiveCliMenu({
+      currentVersion: version,
+      scriptPath
+    });
+    process.exit(process.exitCode ?? 0);
+  }
   program.outputHelp();
   process.exit(0);
 }
-await checkForCliUpdates({
-  packageName: "@getcodesentinel/codesentinel",
-  currentVersion: version,
-  argv: process.argv,
-  env: process.env
-});
+if (argv[2] !== "update") {
+  await checkForCliUpdates({
+    packageName: "@getcodesentinel/codesentinel",
+    currentVersion: version,
+    argv: process.argv,
+    env: process.env
+  });
+}
 await program.parseAsync(argv);
 //# sourceMappingURL=index.js.map