ralph-review 0.2.2 → 0.2.4

package/src/commands/config-handlers.ts

@@ -39,6 +39,11 @@ interface ParsedShowArgs extends ParsedScopedArgs {
   verbose: boolean;
 }
 
+type LoadedEffectiveConfig = Awaited<
+  ReturnType<ConfigCommandDeps["loadEffectiveConfigWithDiagnostics"]>
+>;
+type ValidEffectiveConfig = LoadedEffectiveConfig & { config: Config };
+
 const SHOW_USAGE = "Usage: rr config show [--local|--global] [--json] [--verbose]";
 
 function shellQuote(value: string): string {
@@ -61,61 +66,72 @@ function printValue(value: unknown, print: (value: string) => void): void {
   print(String(value));
 }
 
+async function warnIfEffectiveConfigInvalid(
+  deps: ConfigCommandDeps,
+  remediation: string
+): Promise<ValidEffectiveConfig | null> {
+  const effective = await deps.loadEffectiveConfigWithDiagnostics(deps.cwd());
+  const errors = collectEffectiveConfigValidationErrors(effective);
+  if (!effective.config || errors.length > 0) {
+    deps.log.warn(
+      formatConfigValidationMessage(
+        getEffectiveConfigErrorHeader(effective),
+        errors.length > 0 ? errors : ["Configuration format is invalid."],
+        remediation
+      )
+    );
+    return null;
+  }
+
+  return { ...effective, config: effective.config };
+}
+
 function parseScopedArgs(args: string[], defaultScope: ResolvedReadScope): ParsedScopedArgs {
   const positional: string[] = [];
-  let scope = defaultScope;
-  let sawLocal = false;
-  let sawGlobal = false;
+  const state = { scope: defaultScope, sawLocal: false, sawGlobal: false };
 
   for (const arg of args) {
-    if (arg === "--local") {
-      if (sawGlobal) {
-        throw new Error("Cannot use --local and --global together.");
-      }
-      sawLocal = true;
-      scope = "local";
-      continue;
+    if (!parseScopeFlag(arg, state)) {
+      positional.push(arg);
     }
+  }
 
-    if (arg === "--global") {
-      if (sawLocal) {
-        throw new Error("Cannot use --local and --global together.");
-      }
-      sawGlobal = true;
-      scope = "global";
-      continue;
+  return { scope: state.scope, positional };
+}
+
+function parseScopeFlag(
+  arg: string,
+  state: { scope: ResolvedReadScope; sawLocal: boolean; sawGlobal: boolean }
+): boolean {
+  if (arg === "--local") {
+    if (state.sawGlobal) {
+      throw new Error("Cannot use --local and --global together.");
     }
+    state.sawLocal = true;
+    state.scope = "local";
+    return true;
+  }
 
-    positional.push(arg);
+  if (arg === "--global") {
+    if (state.sawLocal) {
+      throw new Error("Cannot use --local and --global together.");
+    }
+    state.sawGlobal = true;
+    state.scope = "global";
+    return true;
   }
 
-  return { scope, positional };
+  return false;
 }
 
 function parseShowArgs(args: string[]): ParsedShowArgs {
   const positional: string[] = [];
-  let scope: ResolvedReadScope = "effective";
-  let sawLocal = false;
-  let sawGlobal = false;
+  const scopeState = { scope: "effective" as ResolvedReadScope, sawLocal: false, sawGlobal: false };
   let json = false;
   let verbose = false;
 
   for (const arg of args) {
-    if (arg === "--local") {
-      if (sawGlobal) {
-        throw new Error("Cannot use --local and --global together.");
-      }
-      sawLocal = true;
-      scope = "local";
-      continue;
-    }
-
-    if (arg === "--global") {
-      if (sawLocal) {
-        throw new Error("Cannot use --local and --global together.");
-      }
-      sawGlobal = true;
-      scope = "global";
+    if (parseScopeFlag(arg, scopeState)) {
       continue;
     }
 
@@ -132,7 +148,7 @@ function parseShowArgs(args: string[]): ParsedShowArgs {
     positional.push(arg);
   }
 
-  return { scope, positional, json, verbose };
+  return { scope: scopeState.scope, positional, json, verbose };
 }
 
 export async function runShow(args: string[], deps: ConfigCommandDeps): Promise<void> {
@@ -296,17 +312,10 @@ export async function runSet(args: string[], deps: ConfigCommandDeps): Promise<v
   await deps.saveConfig(normalized.config);
   deps.log.success(`Updated "${key}" to ${formatValue(parsedValue)}.`);
 
-  const effective = await deps.loadEffectiveConfigWithDiagnostics(deps.cwd());
-  const effectiveErrors = collectEffectiveConfigValidationErrors(effective);
-  if (!effective.config || effectiveErrors.length > 0) {
-    deps.log.warn(
-      formatConfigValidationMessage(
-        getEffectiveConfigErrorHeader(effective),
-        effectiveErrors.length > 0 ? effectiveErrors : ["Configuration format is invalid."],
-        "Fix the repo-local override or restore compatible global values, then try again."
-      )
-    );
-  }
+  await warnIfEffectiveConfigInvalid(
+    deps,
+    "Fix the repo-local override or restore compatible global values, then try again."
+  );
 }
 
 export async function runEdit(args: string[], deps: ConfigCommandDeps): Promise<void> {
@@ -347,16 +356,11 @@ export async function runEdit(args: string[], deps: ConfigCommandDeps): Promise<
   }
 
   if (parsed.scope === "local") {
-    const effective = await deps.loadEffectiveConfigWithDiagnostics(deps.cwd());
-    const errors = collectEffectiveConfigValidationErrors(effective);
-    if (!effective.config || errors.length > 0) {
-      deps.log.warn(
-        formatConfigValidationMessage(
-          getEffectiveConfigErrorHeader(effective),
-          errors.length > 0 ? errors : ["Configuration format is invalid."],
-          'Run "rr init" and choose Repo-local config to regenerate the file, or fix it manually.'
-        )
-      );
+    const effective = await warnIfEffectiveConfigInvalid(
+      deps,
+      'Run "rr init" and choose Repo-local config to regenerate the file, or fix it manually.'
+    );
+    if (!effective) {
       return;
     }
 
@@ -378,16 +382,11 @@ export async function runEdit(args: string[], deps: ConfigCommandDeps): Promise<
     return;
   }
 
-  const effective = await deps.loadEffectiveConfigWithDiagnostics(deps.cwd());
-  const effectiveErrors = collectEffectiveConfigValidationErrors(effective);
-  if (!effective.config || effectiveErrors.length > 0) {
-    deps.log.warn(
-      formatConfigValidationMessage(
-        getEffectiveConfigErrorHeader(effective),
-        effectiveErrors.length > 0 ? effectiveErrors : ["Configuration format is invalid."],
-        "Fix the repo-local override or restore compatible global values, then try again."
-      )
-    );
+  const effective = await warnIfEffectiveConfigInvalid(
+    deps,
+    "Fix the repo-local override or restore compatible global values, then try again."
+  );
+  if (!effective) {
     return;
   }
 

package/src/commands/config-model.ts

@@ -8,6 +8,7 @@ import {
   isAgentType,
   isReasoningLevel,
   type ReasoningLevel,
+  type RetryOverrideConfig,
 } from "@/lib/types";
 
 type ConfigRole = "reviewer" | "fixer";
@@ -116,6 +117,40 @@ function parseInteger(value: string, key: ConfigKey): number {
   return parsed;
 }
 
+function parseBoundedIntegerUpdate(
+  key: ParsedScalarConfigUpdate["key"],
+  rawValue: string,
+  minimum: number
+): ParsedScalarConfigUpdate {
+  const parsed = parseInteger(requireNonNullRawValue(key, rawValue), key);
+  if (parsed < minimum) {
+    throw new Error(`Value for "${key}" must be greater than or equal to ${minimum}.`);
+  }
+  return { key, value: parsed } as ParsedScalarConfigUpdate;
+}
+
+function requireNumberConfigValue(key: ConfigKey, value: ConfigValue, requirement: string): number {
+  if (typeof value === "number") {
+    return value;
+  }
+
+  throw new Error(`Value for "${key}" must be an integer ${requirement}.`);
+}
+
+function requirePiRoleSettings<T extends AgentSettings | AgentOverrideSettings>(
+  current: T | undefined,
+  role: ConfigRole,
+  command: string
+): T {
+  if (!current || current.agent !== "pi") {
+    throw new Error(
+      `Cannot set "${role}.agent" to "pi" in a single-key update. Run "${command}" for pi setup.`
+    );
+  }
+
+  return current;
+}
+
 function requireNonNullRawValue(key: ConfigKey, rawValue: string): string {
   if (rawValue === "null") {
     throw new Error(`Value "null" is not allowed for "${key}".`);
@@ -205,36 +240,20 @@ export function parseConfigUpdate(key: ConfigKey, rawValue: string): ParsedConfi
       return createRoleReasoningUpdate(key, rawValue);
 
     case "maxIterations": {
-      const parsed = parseInteger(requireNonNullRawValue(key, rawValue), key);
-      if (parsed <= 0) {
-        throw new Error(`Value for "${key}" must be greater than 0.`);
-      }
-      return { key, value: parsed };
+      return parseBoundedIntegerUpdate(key, rawValue, 1);
     }
 
     case "iterationTimeout": {
-      const parsed = parseInteger(requireNonNullRawValue(key, rawValue), key);
-      if (parsed <= 0) {
-        throw new Error(`Value for "${key}" must be greater than 0.`);
-      }
-      return { key, value: parsed };
+      return parseBoundedIntegerUpdate(key, rawValue, 1);
     }
 
     case "retry.maxRetries": {
-      const parsed = parseInteger(requireNonNullRawValue(key, rawValue), key);
-      if (parsed < 0) {
-        throw new Error(`Value for "${key}" must be greater than or equal to 0.`);
-      }
-      return { key, value: parsed };
+      return parseBoundedIntegerUpdate(key, rawValue, 0);
     }
 
     case "retry.baseDelayMs":
     case "retry.maxDelayMs": {
-      const parsed = parseInteger(requireNonNullRawValue(key, rawValue), key);
-      if (parsed <= 0) {
-        throw new Error(`Value for "${key}" must be greater than 0.`);
-      }
-      return { key, value: parsed };
+      return parseBoundedIntegerUpdate(key, rawValue, 1);
     }
 
     case "defaultReview.type":
@@ -329,18 +348,9 @@ function ensureRoleForMutation(
 function applyRoleAgentUpdate(config: Config, role: ConfigRole, nextAgent: AgentType): Config {
   const current = readRoleSettings(role, config);
   if (nextAgent === "pi") {
-    if (!current || current.agent !== "pi") {
-      throw new Error(
-        `Cannot set "${role}.agent" to "pi" in a single-key update. Run "rr init" for pi setup.`
-      );
-    }
+    const piSettings = requirePiRoleSettings(current, role, "rr init");
 
-    writeRoleSettings(role, config, {
-      agent: "pi",
-      provider: current.provider,
-      model: current.model,
-      reasoning: current.reasoning,
-    });
+    writeRoleSettings(role, config, piSettings);
     return config;
   }
 
@@ -362,6 +372,86 @@ function applyRoleAgentUpdate(config: Config, role: ConfigRole, nextAgent: Agent
   return config;
 }
 
+function setRequiredRetryValue(
+  config: Config,
+  field: keyof typeof DEFAULT_RETRY_CONFIG,
+  value: number
+): void {
+  config.retry = config.retry ? { ...config.retry } : { ...DEFAULT_RETRY_CONFIG };
+  config.retry[field] = value;
+}
+
+function setOverrideRetryValue(
+  config: ConfigOverride,
+  field: keyof RetryOverrideConfig,
+  value: number
+): void {
+  config.retry = {
+    ...(config.retry && config.retry !== null ? config.retry : {}),
+    [field]: value,
+  };
+}
+
+function applyRoleProviderUpdate(
+  settings: AgentSettings | AgentOverrideSettings,
+  role: ConfigRole,
+  key: RoleConfigKey,
+  value: ConfigValue,
+  clearNonPiProvider: boolean
+): void {
+  if (value === null) {
+    if (settings.agent !== "pi") {
+      if (clearNonPiProvider) {
+        delete settings.provider;
+      }
+      return;
+    }
+    throw new Error(`Cannot unset "${role}.provider" while "${role}.agent" is "pi".`);
+  }
+
+  if (typeof value !== "string") {
+    throw new Error(`Value for "${key}" must be a string or null.`);
+  }
+
+  if (settings.agent !== "pi") {
+    throw new Error(`"${role}.provider" is only valid when "${role}.agent" is "pi".`);
+  }
+
+  settings.provider = value;
+}
+
+function applyRoleModelUpdate(
+  settings: AgentSettings | AgentOverrideSettings,
+  role: ConfigRole,
+  key: RoleConfigKey,
+  value: ConfigValue,
+  assignNullForNonPi: boolean
+): void {
+  if (settings.agent === "pi") {
+    if (value === null || typeof value !== "string") {
+      throw new Error(`Cannot unset "${role}.model" while "${role}.agent" is "pi".`);
+    }
+    settings.model = value;
+    return;
+  }
+
+  if (value === null) {
+    if (assignNullForNonPi) {
+      settings.model = value;
+      return;
+    }
+    delete settings.model;
+    return;
+  }
+
+  if (typeof value === "string") {
+    settings.model = value;
+    return;
+  }
+
+  throw new Error(`Value for "${key}" must be a string or null.`);
+}
+
 export function setConfigValue(config: Config, key: ConfigKey, value: ConfigValue): Config {
   const next = structuredClone(config) as Config;
 
@@ -385,49 +475,12 @@ export function setConfigValue(config: Config, key: ConfigKey, value: ConfigValu
     const settings = ensureRoleForMutation(next, role, field);
 
     if (field === "provider") {
-      if (value === null) {
-        if (settings.agent !== "pi") {
-          return next;
-        }
-        throw new Error(`Cannot unset "${role}.provider" while "${role}.agent" is "pi".`);
-      }
-      if (typeof value !== "string") {
-        throw new Error(`Value for "${key}" must be a string or null.`);
-      }
-      if (settings.agent !== "pi") {
-        throw new Error(`"${role}.provider" is only valid when "${role}.agent" is "pi".`);
-      }
-      settings.provider = value;
+      applyRoleProviderUpdate(settings, role, key as RoleConfigKey, value, false);
       return next;
     }
 
     if (field === "model") {
-      if (settings.agent === "pi") {
-        if (value === null || typeof value !== "string") {
-          throw new Error(`Cannot unset "${role}.model" while "${role}.agent" is "pi".`);
-        }
-        settings.model = value;
-        return next;
-      }
-
-      if (value === null) {
-        delete settings.model;
-      } else if (typeof value === "string") {
-        settings.model = value;
-      } else {
-        throw new Error(`Value for "${key}" must be a string or null.`);
-      }
-      return next;
-    }
-
-    if (settings.agent === "pi") {
-      if (value === null) {
-        delete settings.reasoning;
-      } else if (typeof value === "string" && isReasoningLevel(value)) {
-        settings.reasoning = value;
-      } else {
-        throw new Error(`Value for "${key}" must be one of: low, medium, high, xhigh, max.`);
-      }
+      applyRoleModelUpdate(settings, role, key as RoleConfigKey, value, false);
       return next;
     }
 
@@ -479,25 +532,25 @@ export function setConfigValue(config: Config, key: ConfigKey, value: ConfigValu
       next.defaultReview = { type: "base", branch: value };
       return next;
     case "retry.maxRetries":
-      next.retry = next.retry ? { ...next.retry } : { ...DEFAULT_RETRY_CONFIG };
-      if (typeof value !== "number") {
-        throw new Error(`Value for "${key}" must be an integer greater than or equal to 0.`);
-      }
-      next.retry.maxRetries = value;
+      setRequiredRetryValue(
+        next,
+        "maxRetries",
+        requireNumberConfigValue(key, value, "greater than or equal to 0")
+      );
       return next;
     case "retry.baseDelayMs":
-      next.retry = next.retry ? { ...next.retry } : { ...DEFAULT_RETRY_CONFIG };
-      if (typeof value !== "number") {
-        throw new Error(`Value for "${key}" must be an integer greater than 0.`);
-      }
-      next.retry.baseDelayMs = value;
+      setRequiredRetryValue(
+        next,
+        "baseDelayMs",
+        requireNumberConfigValue(key, value, "greater than 0")
+      );
       return next;
     case "retry.maxDelayMs":
-      next.retry = next.retry ? { ...next.retry } : { ...DEFAULT_RETRY_CONFIG };
-      if (typeof value !== "number") {
-        throw new Error(`Value for "${key}" must be an integer greater than 0.`);
-      }
-      next.retry.maxDelayMs = value;
+      setRequiredRetryValue(
+        next,
+        "maxDelayMs",
+        requireNumberConfigValue(key, value, "greater than 0")
+      );
       return next;
     case "notifications.sound.enabled":
       if (typeof value !== "boolean") {
@@ -552,17 +605,13 @@ function applyOverrideRoleAgentUpdate(
 ): ConfigOverride {
   const current = readOverrideRoleSettings(role, config);
   if (nextAgent === "pi") {
-    if (!current || current.agent !== "pi") {
-      throw new Error(
-        `Cannot set "${role}.agent" to "pi" in a single-key update. Run "rr init --local" for pi setup.`
-      );
-    }
+    const piSettings = requirePiRoleSettings(current, role, "rr init --local");
 
     writeOverrideRoleSettings(role, config, {
       agent: "pi",
-      provider: current.provider,
-      model: current.model,
-      reasoning: current.reasoning,
+      provider: piSettings.provider,
+      model: piSettings.model,
+      reasoning: piSettings.reasoning,
     });
     return config;
   }
@@ -600,30 +649,12 @@ export function setConfigOverrideValue(
     const settings = ensureOverrideRoleForMutation(next, role);
 
     if (field === "provider") {
-      if (value === null) {
-        if (settings.agent !== "pi") {
-          delete settings.provider;
-          return next;
-        }
-        throw new Error(`Cannot unset "${role}.provider" while "${role}.agent" is "pi".`);
-      }
-      if (settings.agent !== "pi") {
-        throw new Error(`"${role}.provider" is only valid when "${role}.agent" is "pi".`);
-      }
-      settings.provider = value;
+      applyRoleProviderUpdate(settings, role, update.key, value, true);
       return next;
     }
 
     if (field === "model") {
-      if (settings.agent === "pi") {
-        if (value === null) {
-          throw new Error(`Cannot unset "${role}.model" while "${role}.agent" is "pi".`);
-        }
-        settings.model = value;
-        return next;
-      }
-
-      settings.model = value;
+      applyRoleModelUpdate(settings, role, update.key, value, true);
       return next;
     }
 
@@ -657,22 +688,13 @@ export function setConfigOverrideValue(
       next.defaultReview = { type: "base", branch: update.value };
       return next;
     case "retry.maxRetries":
-      next.retry = {
-        ...(next.retry && next.retry !== null ? next.retry : {}),
-        maxRetries: update.value,
-      };
+      setOverrideRetryValue(next, "maxRetries", update.value);
       return next;
     case "retry.baseDelayMs":
-      next.retry = {
-        ...(next.retry && next.retry !== null ? next.retry : {}),
-        baseDelayMs: update.value,
-      };
+      setOverrideRetryValue(next, "baseDelayMs", update.value);
       return next;
     case "retry.maxDelayMs":
-      next.retry = {
-        ...(next.retry && next.retry !== null ? next.retry : {}),
-        maxDelayMs: update.value,
-      };
+      setOverrideRetryValue(next, "maxDelayMs", update.value);
       return next;
     case "notifications.sound.enabled":
       next.notifications = {

package/src/commands/doctor.ts

@@ -1,4 +1,5 @@
 import * as p from "@clack/prompts";
+import type { SpinnerFactory } from "@/cli-io";
 import { runDiagnostics } from "@/lib/diagnostics";
 import type { FixResult, RemediationDependencies } from "@/lib/diagnostics/remediation";
 import { applyFixes as defaultApplyFixes, isFixable } from "@/lib/diagnostics/remediation";
@@ -17,10 +18,7 @@ interface DoctorRuntime {
   ) => Promise<FixResult[]>;
   intro: (message: string) => void;
   note: (message: string, title: string) => void;
-  spinner: () => {
-    start: (message: string) => void;
-    stop: (message: string) => void;
-  };
+  spinner: SpinnerFactory;
   log: {
     error: (message: string) => void;
     warn: (message: string) => void;