ralph-review 0.2.2 → 0.2.4

package/src/commands/fix.ts

@@ -12,7 +12,10 @@ import {
 } from "@/lib/priority-list";
 import { loadFindingsArtifactBySessionId } from "@/lib/review-workflow/findings/artifact";
 import type { FindingId, FindingsArtifact } from "@/lib/review-workflow/findings/types";
-import { runFixSession } from "@/lib/review-workflow/remediation/run-fix-session";
+import {
+  promptForFixSelection,
+  runFixSession,
+} from "@/lib/review-workflow/remediation/run-fix-session";
 import {
   createSessionState,
   HEARTBEAT_INTERVAL_MS,
@@ -67,30 +70,19 @@ export interface FixCommandDeps {
   exit: (code: number) => void;
 }
 
-function defaultPromptForSelection(artifact: FindingsArtifact): Promise<FindingId[] | null> {
-  return p
-    .multiselect({
-      message: "Choose findings to fix",
-      options: artifact.findings.map((finding) => ({
-        value: finding.id,
-        label: `${finding.id} [${finding.priority}] ${finding.title}`,
-        hint: `${finding.filePath}:${finding.startLine}-${finding.endLine}`,
-      })),
-      required: false,
-    })
-    .then((selection) => {
-      if (p.isCancel(selection)) {
-        return null;
-      }
+interface LoadedFixArtifact {
+  parsed: ParsedFixCommandOptions;
+  artifact: FindingsArtifact;
+}
 
-      return (selection as FindingId[]) ?? [];
-    });
+interface PreparedFixCommand extends LoadedFixArtifact {
+  commandDeps: FixCommandDeps;
 }
 
 const DEFAULT_FIX_COMMAND_DEPS: FixCommandDeps = {
   loadConfig: loadEffectiveConfig,
   loadFindingsArtifactBySessionId,
-  promptForSelection: defaultPromptForSelection,
+  promptForSelection: promptForFixSelection,
   runFixSession,
   isTTY: () => process.stdout.isTTY === true,
   isTmuxInstalled,
@@ -332,31 +324,69 @@ export function parseFixCommandOptions(args: string[]): ParsedFixCommandOptions
   };
 }
 
-export async function runFix(
-  args: string[] = [],
-  deps: Partial<FixCommandDeps> = {}
-): Promise<void> {
-  const commandDeps = { ...DEFAULT_FIX_COMMAND_DEPS, ...deps };
-
+async function loadFixCommandArtifact(
+  args: string[],
+  commandDeps: FixCommandDeps
+): Promise<LoadedFixArtifact | null> {
   let parsed: ParsedFixCommandOptions;
   try {
     parsed = parseFixCommandOptions(args);
   } catch (error) {
     commandDeps.logError(`${error}`);
     commandDeps.exit(1);
-    return;
+    return null;
   }
 
   const artifact = await commandDeps.loadFindingsArtifactBySessionId(CONFIG_DIR, parsed.sessionId);
   if (!artifact) {
     commandDeps.logError(`Findings artifact not found for session ${parsed.sessionId}`);
     commandDeps.exit(1);
+    return null;
+  }
+
+  return { parsed, artifact };
+}
+
+async function prepareFixCommand(
+  args: string[],
+  deps: Partial<FixCommandDeps>
+): Promise<PreparedFixCommand | null> {
+  const commandDeps = { ...DEFAULT_FIX_COMMAND_DEPS, ...deps };
+  const loaded = await loadFixCommandArtifact(args, commandDeps);
+  return loaded ? { commandDeps, ...loaded } : null;
+}
+
+async function withPreparedFixCommand(
+  args: string[],
+  deps: Partial<FixCommandDeps>,
+  run: (prepared: PreparedFixCommand) => Promise<void>
+): Promise<void> {
+  const prepared = await prepareFixCommand(args, deps);
+  if (!prepared) {
     return;
   }
 
-  if (!(await commandDeps.loadConfig(artifact.projectPath))) {
+  await run(prepared);
+}
+
+async function loadRequiredFixConfig(
+  commandDeps: FixCommandDeps,
+  projectPath: string
+): ReturnType<FixCommandDeps["loadConfig"]> {
+  const config = await commandDeps.loadConfig(projectPath);
+  if (!config) {
     commandDeps.logError("Failed to load configuration");
     commandDeps.exit(1);
+  }
+  return config;
+}
+
+async function runPreparedFix({
+  commandDeps,
+  parsed,
+  artifact,
+}: PreparedFixCommand): Promise<void> {
+  if (!(await loadRequiredFixConfig(commandDeps, artifact.projectPath))) {
     return;
   }
 
@@ -423,33 +453,18 @@ export async function runFix(
   }
 }
 
-export async function runFixForeground(
-  args: string[] = [],
-  deps: Partial<FixCommandDeps> = {}
-): Promise<void> {
-  const commandDeps = { ...DEFAULT_FIX_COMMAND_DEPS, ...deps };
-
-  let parsed: ParsedFixCommandOptions;
-  try {
-    parsed = parseFixCommandOptions(args);
-  } catch (error) {
-    commandDeps.logError(`${error}`);
-    commandDeps.exit(1);
-    return;
-  }
-
-  const artifact = await commandDeps.loadFindingsArtifactBySessionId(CONFIG_DIR, parsed.sessionId);
-  if (!artifact) {
-    commandDeps.logError(`Findings artifact not found for session ${parsed.sessionId}`);
-    commandDeps.exit(1);
-    return;
-  }
+export function runFix(args: string[] = [], deps: Partial<FixCommandDeps> = {}): Promise<void> {
+  return withPreparedFixCommand(args, deps, runPreparedFix);
+}
 
+async function runPreparedFixForeground({
+  commandDeps,
+  parsed,
+  artifact,
+}: PreparedFixCommand): Promise<void> {
   const projectPath = commandDeps.env.RR_PROJECT_PATH || artifact.projectPath || commandDeps.cwd();
-  const config = await commandDeps.loadConfig(projectPath);
+  const config = await loadRequiredFixConfig(commandDeps, projectPath);
   if (!config) {
-    commandDeps.logError("Failed to load configuration");
-    commandDeps.exit(1);
     return;
   }
 
@@ -593,3 +608,10 @@ export async function runFixForeground(
     });
   }
 }
+
+export function runFixForeground(
+  args: string[] = [],
+  deps: Partial<FixCommandDeps> = {}
+): Promise<void> {
+  return withPreparedFixCommand(args, deps, runPreparedFixForeground);
+}

package/src/commands/handoff-selection.ts

@@ -2,6 +2,10 @@ import * as p from "@clack/prompts";
 import type { PendingHandoffArtifact } from "@/lib/handoff";
 
 type HandoffAction = "apply" | "discard";
+type HandoffSelect = (input: {
+  message: string;
+  options: Array<{ value: string; label: string; hint: string }>;
+}) => Promise<unknown>;
 
 interface SelectableHandoff {
   handoffId: string;
@@ -14,10 +18,7 @@ interface ResolvePendingHandoffSelectionOptions {
   selector?: string;
   action: HandoffAction;
   isTTY: boolean;
-  select?: (input: {
-    message: string;
-    options: Array<{ value: string; label: string; hint: string }>;
-  }) => Promise<unknown>;
+  select?: HandoffSelect;
   isCancel?: (value: unknown) => boolean;
 }
 
@@ -105,10 +106,7 @@ async function resolveHandoffSelection<T extends SelectableHandoff>(options: {
   action: HandoffAction;
   isTTY: boolean;
   multipleHandoffsMessage: string;
-  select?: (input: {
-    message: string;
-    options: Array<{ value: string; label: string; hint: string }>;
-  }) => Promise<unknown>;
+  select?: HandoffSelect;
   isCancel?: (value: unknown) => boolean;
 }): Promise<HandoffSelectionResult<T>> {
   if (options.selector) {

package/src/commands/interactive-deps.ts

@@ -0,0 +1,43 @@
+import * as p from "@clack/prompts";
+import { getCommandDef } from "@/cli";
+
+export interface InteractiveCommandDeps {
+  getCommandDef: typeof getCommandDef;
+  logError: (message: string) => void;
+  exit: (code: number) => void;
+  isTTY: () => boolean;
+}
+
+export type PromptSelect = (input: {
+  message: string;
+  options: Array<{ value: string; label: string; hint: string }>;
+}) => Promise<unknown>;
+
+export interface PromptDeps {
+  logInfo: (message: string) => void;
+  logMessage: (message: string) => void;
+  logStep: (message: string) => void;
+  logSuccess: (message: string) => void;
+  select: PromptSelect;
+  isCancel: (value: unknown) => boolean;
+}
+
+export function createInteractiveCommandDeps(): InteractiveCommandDeps {
+  return {
+    getCommandDef,
+    logError: (message) => p.log.error(message),
+    exit: (code) => process.exit(code),
+    isTTY: () => process.stdout.isTTY === true,
+  };
+}
+
+export function createPromptDeps(): PromptDeps {
+  return {
+    logInfo: p.log.info,
+    logMessage: p.log.message,
+    logStep: p.log.step,
+    logSuccess: p.log.success,
+    select: p.select,
+    isCancel: p.isCancel,
+  };
+}

package/src/commands/list.ts

@@ -2,6 +2,20 @@ import * as p from "@clack/prompts";
 import { listAllActiveSessions } from "@/lib/session-state";
 import { listRalphSessions } from "@/lib/tmux";
 
+interface ListDeps {
+  listAllActiveSessions: typeof listAllActiveSessions;
+  listRalphSessions: typeof listRalphSessions;
+  logInfo: (message: string) => void;
+  print: (...args: unknown[]) => void;
+}
+
+const DEFAULT_LIST_DEPS: ListDeps = {
+  listAllActiveSessions,
+  listRalphSessions,
+  logInfo: p.log.info,
+  print: (...args) => console.log(...args),
+};
+
 function formatRelativeStart(startTime: number): string {
   const elapsedSeconds = Math.max(0, Math.floor((Date.now() - startTime) / 1000));
 
@@ -18,10 +32,11 @@ function formatRelativeStart(startTime: number): string {
   return `${elapsedHours}h ago`;
 }
 
-export async function runList(): Promise<void> {
+export async function runList(deps: Partial<ListDeps> = {}): Promise<void> {
+  const listDeps = { ...DEFAULT_LIST_DEPS, ...deps };
   const [activeSessions, tmuxSessions] = await Promise.all([
-    listAllActiveSessions(),
-    listRalphSessions(),
+    listDeps.listAllActiveSessions(),
+    listDeps.listRalphSessions(),
   ]);
   const trackedTmuxSessions = new Set(activeSessions.map((session) => session.sessionName));
   const untrackedTmuxSessions = tmuxSessions.filter(
@@ -29,17 +44,19 @@ export async function runList(): Promise<void> {
   );
 
   if (activeSessions.length === 0 && untrackedTmuxSessions.length === 0) {
-    p.log.info("No active review sessions.");
+    listDeps.logInfo("No active review sessions.");
   } else {
-    p.log.info("Active review sessions:");
+    listDeps.logInfo("Active review sessions:");
     for (const session of activeSessions) {
       const worktree = session.worktreeBranch ? ` ${session.worktreeBranch}` : "";
-      console.log(
+      listDeps.print(
         `${session.sessionId.slice(0, 8)} ${session.sessionName} ${session.projectPath}${worktree} ${formatRelativeStart(session.startTime)}`
       );
     }
     for (const sessionName of untrackedTmuxSessions) {
-      console.log(`${sessionName} (tmux only)`);
+      listDeps.print(`${sessionName} (tmux only)`);
     }
   }
 }
+
+export type { ListDeps };

package/src/commands/log.ts

@@ -82,6 +82,16 @@ function isUnknownEmptySession(session: SessionStats): boolean {
   return session.status === "unknown" && session.iterations === 0;
 }
 
+function printNoProjectSessions(projectName: string, json: boolean): void {
+  if (json) {
+    console.log(JSON.stringify({ project: projectName, sessions: [] }, null, 2));
+    return;
+  }
+
+  p.log.info("No review sessions found for current working directory.");
+  p.log.message('Start a review with "rr run" first.');
+}
+
 function formatDate(timestamp: number): string {
   return new Date(timestamp).toLocaleString();
 }
@@ -412,12 +422,7 @@ export async function runLog(args: string[]): Promise<void> {
   const projectSessions = await listProjectLogSessions(CONFIG_DIR, currentProjectPath);
 
   if (projectSessions.length === 0) {
-    if (options.json) {
-      console.log(JSON.stringify({ project: projectName, sessions: [] }, null, 2));
-    } else {
-      p.log.info("No review sessions found for current working directory.");
-      p.log.message('Start a review with "rr run" first.');
-    }
+    printNoProjectSessions(projectName, options.json);
     return;
   }
 
@@ -451,12 +456,7 @@ export async function runLog(args: string[]): Promise<void> {
   }
 
   if (sessionStats.length === 0) {
-    if (options.json) {
-      console.log(JSON.stringify({ project: projectName, sessions: [] }, null, 2));
-    } else {
-      p.log.info("No review sessions found for current working directory.");
-      p.log.message('Start a review with "rr run" first.');
-    }
+    printNoProjectSessions(projectName, options.json);
     return;
   }
 

package/src/commands/run.ts

@@ -5,7 +5,7 @@ import { parseCommand } from "@/lib/cli-parser";
 import { loadEffectiveConfig } from "@/lib/config";
 import { collectIssueItems, runDiagnostics } from "@/lib/diagnostics";
 import { getTmuxInstallHint } from "@/lib/diagnostics/tmux-install";
-import type { DiagnosticsReport } from "@/lib/diagnostics/types";
+import type { DiagnosticItem, DiagnosticsReport } from "@/lib/diagnostics/types";
 import { type CycleResult, runReviewCycle } from "@/lib/engine";
 import { formatReviewType } from "@/lib/format";
 import { formatHandoffNote } from "@/lib/handoff-note";
@@ -19,6 +19,7 @@ import {
 } from "@/lib/priority-list";
 import { runFixSession } from "@/lib/review-workflow/remediation/run-fix-session";
 import type { FixSessionResult } from "@/lib/review-workflow/remediation/types";
+import { mapSessionStatusToFinalStatus } from "@/lib/review-workflow/session-status";
 import {
   createSessionId,
   createSessionState,
@@ -108,20 +109,6 @@ export function formatRunAgentsNote(config: Config, reviewOptions: ReviewOptions
   return lines.join("\n");
 }
 
-function mapSessionStatusToFinalStatus(
-  status: FixSessionResult["sessionStatus"]
-): CycleResult["finalStatus"] {
-  if (status === "failed") {
-    return "failed";
-  }
-
-  if (status === "interrupted") {
-    return "interrupted";
-  }
-
-  return "completed";
-}
-
 function hasAutoFixPriorityMatches(result: CycleResult, priorities: Priority[]): boolean {
   return (
     result.artifact?.findings.some((finding) => priorities.includes(finding.priority)) ?? false
@@ -257,6 +244,32 @@ export interface RunRuntimeOverrides
   timer?: Partial<RunRuntime["timer"]>;
 }
 
+function createRunCommandContext(overrides: RunRuntimeOverrides): {
+  runtime: RunRuntime;
+  projectPath: string;
+} {
+  const runtime = createRunRuntime(overrides);
+  return {
+    runtime,
+    projectPath: runtime.process.env.RR_PROJECT_PATH || runtime.process.cwd(),
+  };
+}
+
+function logPreflightItems(
+  runtime: RunRuntime,
+  items: DiagnosticItem[],
+  heading: string,
+  severity: "error" | "warn"
+): void {
+  runtime.prompt.log[severity](heading);
+  for (const item of items) {
+    runtime.prompt.log.message(`  ${item.summary}`);
+    item.remediation.forEach((remediation) => {
+      runtime.prompt.log.message(`    -> ${remediation}`);
+    });
+  }
+}
+
 export function createRunRuntime(overrides: RunRuntimeOverrides = {}): RunRuntime {
   const defaults: RunRuntime = {
     prompt: {
@@ -449,8 +462,7 @@ export async function runForeground(
   args: string[] = [],
   overrides: RunRuntimeOverrides = {}
 ): Promise<void> {
-  const runtime = createRunRuntime(overrides);
-  const projectPath = runtime.process.env.RR_PROJECT_PATH || runtime.process.cwd();
+  const { runtime, projectPath } = createRunCommandContext(overrides);
   const config = await runtime.loadConfig(projectPath);
   if (!config) {
     runtime.prompt.log.error("Failed to load config");
@@ -714,8 +726,7 @@ export async function startReview(
   args: string[],
   overrides: RunRuntimeOverrides = {}
 ): Promise<void> {
-  const runtime = createRunRuntime(overrides);
-  const projectPath = runtime.process.env.RR_PROJECT_PATH || runtime.process.cwd();
+  const { runtime, projectPath } = createRunCommandContext(overrides);
   // Parse options using command definition
   const runDef = runtime.getCommandDef("run");
   if (!runDef) {
@@ -856,25 +867,13 @@ export async function startReview(
   const warnings = issues.filter((item) => item.severity === "warning");
 
   if (errors.length > 0) {
-    runtime.prompt.log.error("Cannot run review:");
-    for (const item of errors) {
-      runtime.prompt.log.message(`  ${item.summary}`);
-      item.remediation.forEach((remediation) => {
-        runtime.prompt.log.message(`    -> ${remediation}`);
-      });
-    }
+    logPreflightItems(runtime, errors, "Cannot run review:", "error");
     runtime.process.exit(1);
     return;
   }
 
   if (warnings.length > 0) {
-    runtime.prompt.log.warn("Preflight warnings:");
-    for (const item of warnings) {
-      runtime.prompt.log.message(`  ${item.summary}`);
-      item.remediation.forEach((remediation) => {
-        runtime.prompt.log.message(`    -> ${remediation}`);
-      });
-    }
+    logPreflightItems(runtime, warnings, "Preflight warnings:", "warn");
   }
 
   const config = diagnostics.config ?? (await runtime.loadConfig(projectPath));

package/src/commands/status.ts

@@ -1,13 +1,34 @@
 import { getGitBranch } from "@/lib/logger";
 
-export async function runStatus(): Promise<void> {
-  const projectPath = process.cwd();
-  const branch = await getGitBranch(projectPath);
+interface StatusDeps {
+  cwd: () => string;
+  getGitBranch: typeof getGitBranch;
+  renderDashboard: (payload: { projectPath: string; branch: string | undefined }) => Promise<void>;
+}
 
+async function renderDashboardWithDynamicImport(payload: {
+  projectPath: string;
+  branch: string | undefined;
+}): Promise<void> {
   const { renderDashboard } = await import("@/lib/tui/index");
+  await renderDashboard(payload);
+}
+
+const DEFAULT_STATUS_DEPS: StatusDeps = {
+  cwd: () => process.cwd(),
+  getGitBranch,
+  renderDashboard: renderDashboardWithDynamicImport,
+};
 
-  await renderDashboard({
+export async function runStatus(deps: Partial<StatusDeps> = {}): Promise<void> {
+  const statusDeps = { ...DEFAULT_STATUS_DEPS, ...deps };
+  const projectPath = statusDeps.cwd();
+  const branch = await statusDeps.getGitBranch(projectPath);
+
+  await statusDeps.renderDashboard({
     projectPath,
     branch,
   });
 }
+
+export type { StatusDeps };