@getcodesentinel/codesentinel 1.18.0 → 1.19.1

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);
@@ -3539,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;
@@ -3571,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 {
@@ -3580,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") {
@@ -3599,6 +3610,7 @@ var promptInstall = async (packageName, latestVersion, currentVersion) => {
     };
     stdin.on("keypress", onKeypress);
     if (typeof stdin.setRawMode === "function") {
+      hideCursor();
       stdin.setRawMode(true);
     }
     stdin.resume();
@@ -3625,9 +3637,6 @@ var runManualCliUpdate = async (input) => {
     return 0;
   }
   const choice = await promptInstall(input.packageName, latestVersion, input.currentVersion);
-  if (choice === "interrupt") {
-    return 130;
-  }
   if (choice !== "install") {
     return 0;
   }
@@ -3665,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;
     }
@@ -3684,6 +3690,312 @@ 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 PROMPT_PADDING = "  ";
+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 pipeWithPadding = (stream, target, padding) => {
+  if (stream === null) {
+    return;
+  }
+  stream.setEncoding("utf8");
+  let buffer = "";
+  let needsPrefix = true;
+  const writeChunk = (chunk) => {
+    let start = 0;
+    while (start < chunk.length) {
+      if (needsPrefix) {
+        target.write(padding);
+        needsPrefix = false;
+      }
+      const newlineIndex = chunk.indexOf("\n", start);
+      if (newlineIndex === -1) {
+        target.write(chunk.slice(start));
+        return;
+      }
+      target.write(chunk.slice(start, newlineIndex + 1));
+      needsPrefix = true;
+      start = newlineIndex + 1;
+    }
+  };
+  stream.on("data", (chunk) => {
+    buffer += chunk;
+    const lastNewlineIndex = buffer.lastIndexOf("\n");
+    if (lastNewlineIndex === -1) {
+      return;
+    }
+    writeChunk(buffer.slice(0, lastNewlineIndex + 1));
+    buffer = buffer.slice(lastNewlineIndex + 1);
+  });
+  stream.on("end", () => {
+    if (buffer.length > 0) {
+      writeChunk(buffer);
+      buffer = "";
+    }
+  });
+};
+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.length === 0 ? "" : ` [${defaultValue}]`;
+  let answer;
+  try {
+    answer = await prompt.question(
+      `${PROMPT_PADDING}${label}${suffix}: `
+    );
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ABORT_ERR") {
+      stderr2.write("\n");
+      return null;
+    }
+    throw error;
+  }
+  const trimmed = answer.trim();
+  return trimmed.length > 0 ? trimmed : defaultValue ?? "";
+};
+var renderDependencyRiskPrompt = (errorMessage) => {
+  clearTerminal();
+  stderr2.write(`${PROMPT_PADDING}${ANSI2.bold}Scan dependency risk${ANSI2.reset}
+`);
+  if (errorMessage !== void 0) {
+    stderr2.write(`
+${PROMPT_PADDING}${errorMessage}
+`);
+  }
+  stderr2.write("\n");
+};
+var buildDependencyRiskArgs = async () => {
+  const prompt = createPrompt();
+  try {
+    let errorMessage;
+    while (true) {
+      renderDependencyRiskPrompt(errorMessage);
+      const dependency = await promptText(prompt, "Package name");
+      if (dependency === null) {
+        return { kind: "cancel" };
+      }
+      if (dependency.length === 0) {
+        errorMessage = "A package name is required.";
+        continue;
+      }
+      return {
+        kind: "run",
+        args: ["dependency-risk", dependency]
+      };
+    }
+  } finally {
+    prompt.close();
+  }
+};
+var waitForReturnToMenu = async () => {
+  if (!stdin2.isTTY || !stderr2.isTTY || typeof stdin2.setRawMode !== "function") {
+    return;
+  }
+  stderr2.write(`
+${PROMPT_PADDING}Press enter to return to the menu...`);
+  await new Promise((resolve6) => {
+    emitKeypressEvents2(stdin2);
+    const previousRawMode = stdin2.isRaw;
+    const cleanup = () => {
+      stdin2.off("keypress", onKeypress);
+      stdin2.pause();
+      stdin2.setRawMode(previousRawMode);
+      showCursor2();
+      stderr2.write("\n");
+      resolve6();
+    };
+    const onKeypress = (_str, key) => {
+      if (key.ctrl === true && key.name === "c") {
+        cleanup();
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        cleanup();
+      }
+    };
+    hideCursor2();
+    stdin2.on("keypress", onKeypress);
+    stdin2.setRawMode(true);
+    stdin2.resume();
+  });
+};
+var runCliCommand = async (scriptPath2, args) => {
+  return await new Promise((resolve6, reject) => {
+    const child = spawn2(process.execPath, [...process.execArgv, scriptPath2, ...args], {
+      stdio: ["inherit", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        CODESENTINEL_NO_UPDATE_NOTIFIER: "1"
+      }
+    });
+    pipeWithPadding(child.stdout, stdout, PROMPT_PADDING);
+    pipeWithPadding(child.stderr, stderr2, PROMPT_PADDING);
+    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(`${PROMPT_PADDING}Interactive menu requires a TTY.
+`);
+    return 1;
+  }
+  const actions = [
+    {
+      label: "Run overview",
+      description: "combined analyze + explain + report",
+      commandBuilder: () => ({ kind: "run", args: ["run"] })
+    },
+    {
+      label: "Analyze repository",
+      description: "structural and health scoring summary",
+      commandBuilder: () => ({ kind: "run", args: ["analyze"] })
+    },
+    {
+      label: "Explain hotspots",
+      description: "top findings in markdown by default",
+      commandBuilder: () => ({ kind: "run", args: ["explain", "--format", "md"] })
+    },
+    {
+      label: "Generate report",
+      description: "create a full report for a repository",
+      commandBuilder: () => ({ kind: "run", args: ["report", "--format", "md"] })
+    },
+    {
+      label: "Run policy check",
+      description: "execute governance gates",
+      commandBuilder: () => ({ kind: "run", args: ["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(`
+${PROMPT_PADDING}`);
+      return 1;
+    }
+    const actionResult = await selectedAction.commandBuilder();
+    if (actionResult.kind === "cancel") {
+      continue;
+    }
+    const exitCode = await runCliCommand(input.scriptPath, actionResult.args);
+    if (exitCode !== 0) {
+      stderr2.write(`
+${PROMPT_PADDING}Command exited with code ${exitCode}.
+`);
+    } else {
+      stderr2.write("\n");
+    }
+    await waitForReturnToMenu();
+  }
+};
+
 // src/application/run-analyze-command.ts
 import { resolve as resolve3 } from "path";
 
@@ -8052,14 +8364,17 @@ 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);
 }