Merge pull request #10134 from continuedev/nate/fixes-4858

Rename `cn check` to `cn review` with UX improvements

Author: sestinj

extensions/cli/src/commands/commands.ts

@@ -2,7 +2,7 @@ import { type AssistantConfig } from "@continuedev/sdk";
 
 // Export command functions
 export { chat } from "./chat.js";
-export { check } from "./check.js";
+export { review } from "./review.js";
 export { login } from "./login.js";
 export { logout } from "./logout.js";
 export { listSessionsCommand } from "./ls.js";

extensions/cli/src/commands/check.ts extensions/cli/src/commands/review.tsextensions/cli/src/commands/check.ts renamed to extensions/cli/src/commands/review.ts

@@ -7,38 +7,38 @@ import { configureConsoleForHeadless } from "../init.js";
 import { logger } from "../util/logger.js";
 
 import { ExtendedCommandOptions } from "./BaseCommandOptions.js";
-import type { CheckState } from "./check/CheckProgress.js";
-import { CheckProgress } from "./check/CheckProgress.js";
-import type { WorkerConfig, WorkerResult } from "./check/checkWorker.js";
-import type { DiffContext } from "./check/diffContext.js";
-import { computeDiffContext } from "./check/diffContext.js";
-import type { CheckResult } from "./check/renderReport.js";
-import { renderReport } from "./check/renderReport.js";
-import { resolveChecks } from "./check/resolveChecks.js";
-import { createWorktree, cleanupWorktree } from "./check/worktree.js";
-
-export interface CheckOptions extends ExtendedCommandOptions {
+import type { ReviewState } from "./review/ReviewProgress.js";
+import { ReviewProgress } from "./review/ReviewProgress.js";
+import type { WorkerConfig, WorkerResult } from "./review/reviewWorker.js";
+import type { DiffContext } from "./review/diffContext.js";
+import { computeDiffContext } from "./review/diffContext.js";
+import type { ReviewResult } from "./review/renderReport.js";
+import { renderReport } from "./review/renderReport.js";
+import { resolveReviews } from "./review/resolveReviews.js";
+import { createWorktree, cleanupWorktree } from "./review/worktree.js";
+
+export interface ReviewOptions extends ExtendedCommandOptions {
   base?: string;
   format?: string;
   fix?: boolean;
   patch?: boolean;
   failFast?: boolean;
-  checkAgents?: string[];
+  reviewAgents?: string[];
 }
 
 /**
- * Run a single check in a forked worker process.
+ * Run a single review in a forked worker process.
  */
-async function runCheckInWorker(
+async function runReviewInWorker(
   agentSource: string,
   worktreePath: string,
   diffContext: DiffContext,
-  options: CheckOptions,
+  options: ReviewOptions,
 ): Promise<WorkerResult> {
   return new Promise<WorkerResult>((resolve, _reject) => {
     // Fork the current CLI entry point with the internal worker flag
     const workerPath = process.argv[1];
-    const child = fork(workerPath, ["--internal-check-worker"], {
+    const child = fork(workerPath, ["--internal-review-worker"], {
       stdio: ["pipe", "pipe", "pipe", "ipc"],
       env: {
         ...process.env,
@@ -58,7 +58,7 @@ async function runCheckInWorker(
             patch: "",
             agentOutput: "",
             duration: 0,
-            error: "Check timed out after 5 minutes",
+            error: "Review timed out after 5 minutes",
           });
         }
       },
@@ -79,7 +79,7 @@ async function runCheckInWorker(
             verbose: options.verbose,
           },
         };
-        child.send({ type: "run-check", config });
+        child.send({ type: "run-review", config });
       } else if (msg.type === "result" && msg.result) {
         if (!settled) {
           settled = true;
@@ -135,7 +135,7 @@ async function runCheckInWorker(
 /**
  * Apply patches to the real working tree (--fix mode).
  */
-function applyPatches(results: CheckResult[]): void {
+function applyPatches(results: ReviewResult[]): void {
   const patchResults = results.filter(
     (r) => r.status === "fail" && r.patch.trim(),
   );
@@ -179,35 +179,37 @@ function applyPatches(results: CheckResult[]): void {
 }
 
 /**
- * Mount the Ink live progress UI or fall back to static logs.
+ * Mutable props bag for the live Ink UI so we can update it progressively.
+ */
+interface LiveUIProps {
+  checks: ReviewState[];
+  baseBranch?: string;
+  changedFileCount?: number;
+  loading?: boolean;
+}
+
+/**
+ * Mount the Ink live progress UI or return a no-op for non-TTY / special modes.
  */
 async function mountProgressUI(
-  checkStates: CheckState[],
-  diffContext: DiffContext,
-  options: CheckOptions,
-): Promise<{ rerender?: () => void; unmount?: () => void }> {
+  props: LiveUIProps,
+  options: ReviewOptions,
+): Promise<{ rerender: () => void; unmount: () => void }> {
   const useLiveUI =
     process.stdout.isTTY && !options.patch && options.format !== "json";
 
   if (!useLiveUI) {
-    console.log(
-      chalk.dim(
-        `Running ${checkStates.length} check${checkStates.length > 1 ? "s" : ""}: ${checkStates.map((c) => c.name).join(", ")}`,
-      ),
-    );
-    return {};
+    return {
+      rerender: () => {},
+      unmount: () => {},
+    };
   }
 
   const { render } = await import("ink");
-  const props = {
-    checks: checkStates,
-    baseBranch: diffContext.baseBranch,
-    changedFileCount: diffContext.changedFiles.length,
-  };
-  const instance = render(React.createElement(CheckProgress, props));
+  const instance = render(React.createElement(ReviewProgress, props));
   return {
     rerender: () =>
-      instance.rerender(React.createElement(CheckProgress, props)),
+      instance.rerender(React.createElement(ReviewProgress, props)),
     unmount: () => instance.unmount(),
   };
 }
@@ -216,9 +218,9 @@ async function mountProgressUI(
  * Output results and exit with appropriate code.
  */
 function outputResultsAndExit(
-  results: CheckResult[],
+  results: ReviewResult[],
   diffContext: DiffContext,
-  options: CheckOptions,
+  options: ReviewOptions,
   checksFromHub: boolean,
 ): void {
   const format = options.format === "json" ? "json" : "text";
@@ -254,20 +256,30 @@ function outputResultsAndExit(
 }
 
 /**
- * Main check command handler.
+ * Main review command handler.
  */
-export async function check(options: CheckOptions = {}): Promise<void> {
+export async function review(options: ReviewOptions = {}): Promise<void> {
   configureConsoleForHeadless(false);
 
   if (options.verbose) {
     logger.setLevel("debug");
   }
 
-  // Step 1: Check for changes
-  console.log(chalk.dim("Computing diff..."));
+  // Mount the live UI immediately with a loading state
+  const uiProps: LiveUIProps = {
+    checks: [],
+    loading: true,
+  };
+  const { rerender, unmount: unmountUI } = await mountProgressUI(
+    uiProps,
+    options,
+  );
+
+  // Step 1: Compute diff
   const diffContext = computeDiffContext(options.base);
 
   if (!diffContext.diff.trim() && diffContext.changedFiles.length === 0) {
+    unmountUI();
     console.log(
       chalk.yellow(
         "No changes detected. Make some changes or specify a different base branch with --base.",
@@ -276,64 +288,60 @@ export async function check(options: CheckOptions = {}): Promise<void> {
     process.exit(0);
   }
 
-  console.log(
-    chalk.dim(
-      `Found ${diffContext.changedFiles.length} changed files against ${diffContext.baseBranch}`,
-    ),
-  );
+  // Update UI with diff info (still loading reviews)
+  uiProps.baseBranch = diffContext.baseBranch;
+  uiProps.changedFileCount = diffContext.changedFiles.length;
+  rerender();
 
-  // Step 2: Resolve checks
-  console.log(chalk.dim("Resolving checks..."));
-  const checks = await resolveChecks(options.checkAgents);
+  // Step 2: Resolve reviews
+  const reviews = await resolveReviews(options.reviewAgents);
 
-  if (checks.length === 0) {
+  if (reviews.length === 0) {
+    unmountUI();
     console.log(
-      chalk.yellow("\nNo checks found. To add checks:\n") +
+      chalk.yellow("\nNo reviews found. To add reviews:\n") +
         chalk.dim(
-          "  1. Create .continue/agents/my-check.md with agent instructions\n",
+          "  1. Create .continue/agents/my-review.md with agent instructions\n",
         ) +
         chalk.dim(
-          "  2. Or specify an agent: cn check --agent org/agent-name\n",
+          "  2. Or specify an agent: cn review --review-agents org/agent-name\n",
         ) +
-        chalk.dim("  3. Or configure checks on https://continue.dev\n"),
+        chalk.dim("  3. Or configure reviews on https://continue.dev\n"),
     );
     process.exit(0);
   }
 
-  const checksFromHub = checks.some((c) => c.sourceType === "hub");
+  const checksFromHub = reviews.some((c) => c.sourceType === "hub");
 
-  // Build mutable state for the live UI
-  const checkStates: CheckState[] = checks.map((c) => ({
+  // Build mutable state for the live UI and stop loading
+  const reviewStates: ReviewState[] = reviews.map((c) => ({
     name: c.name,
     status: "pending" as const,
   }));
+  uiProps.checks = reviewStates;
+  uiProps.loading = false;
+  rerender();
 
-  const { rerender, unmount: unmountUI } = await mountProgressUI(
-    checkStates,
-    diffContext,
-    options,
-  );
-
-  // Step 3: Create worktrees and run checks
-  const results: CheckResult[] = [];
+  // Step 3: Create worktrees and run reviews
+  const results: ReviewResult[] = [];
 
-  const runSingleCheck = async (
-    resolvedCheck: (typeof checks)[number],
+  const runSingleReview = async (
+    resolvedReview: (typeof reviews)[number],
     i: number,
-  ): Promise<CheckResult> => {
+  ): Promise<ReviewResult> => {
     const startTime = Date.now();
     let worktreePath: string | null = null;
 
     try {
       // Mark as running
-      checkStates[i].status = "running";
-      checkStates[i].startTime = Date.now();
-      rerender?.();
+      reviewStates[i].status = "running";
+      reviewStates[i].startTime = Date.now();
+      rerender();
 
       worktreePath = await createWorktree(i);
 
-      const workerResult = await runCheckInWorker(
-        resolvedCheck.source,
+      const workerResult = await runReviewInWorker(
+        resolvedReview.source,
         worktreePath,
         diffContext,
         options,
@@ -345,31 +353,33 @@ export async function check(options: CheckOptions = {}): Promise<void> {
           ? ("fail" as const)
           : ("pass" as const);
 
+      const duration = (Date.now() - startTime) / 1000;
+
       // Mark as complete
-      checkStates[i].status = status;
-      checkStates[i].duration = workerResult.duration;
-      rerender?.();
+      reviewStates[i].status = status;
+      reviewStates[i].duration = duration;
+      rerender();
 
       return {
-        agent: resolvedCheck.source,
-        name: resolvedCheck.name,
+        agent: resolvedReview.source,
+        name: resolvedReview.name,
         status,
         patch: workerResult.patch,
         output: workerResult.agentOutput,
-        duration: workerResult.duration,
+        duration,
         error: workerResult.error,
       };
     } catch (e: any) {
       const duration = (Date.now() - startTime) / 1000;
 
       // Mark as error
-      checkStates[i].status = "error";
-      checkStates[i].duration = duration;
-      rerender?.();
+      reviewStates[i].status = "error";
+      reviewStates[i].duration = duration;
+      rerender();
 
       return {
-        agent: resolvedCheck.source,
-        name: resolvedCheck.name,
+        agent: resolvedReview.source,
+        name: resolvedReview.name,
         status: "error" as const,
         patch: "",
         output: "",
@@ -384,16 +394,16 @@ export async function check(options: CheckOptions = {}): Promise<void> {
   };
 
   if (options.failFast) {
-    for (let i = 0; i < checks.length; i++) {
-      const result = await runSingleCheck(checks[i], i);
+    for (let i = 0; i < reviews.length; i++) {
+      const result = await runSingleReview(reviews[i], i);
       results.push(result);
       if (result.status === "fail" || result.status === "error") {
         break;
       }
     }
   } else {
     const settled = await Promise.allSettled(
-      checks.map((resolvedCheck, i) => runSingleCheck(resolvedCheck, i)),
+      reviews.map((resolvedReview, i) => runSingleReview(resolvedReview, i)),
     );
     for (const result of settled) {
       if (result.status === "fulfilled") {
@@ -402,6 +412,6 @@ export async function check(options: CheckOptions = {}): Promise<void> {
     }
   }
 
-  unmountUI?.();
+  unmountUI();
   outputResultsAndExit(results, diffContext, options, checksFromHub);
 }