rafcode 3.2.1 → 3.8.0

package/src/commands/config.ts

@@ -8,9 +8,10 @@ import { shutdownHandler } from '../core/shutdown-handler.js';
 import { logger } from '../utils/logger.js';
 import {
   getConfigPath,
+  formatModelDisplay,
   getModel,
-  getModelShortName,
   validateConfig,
+  collectConfigValidationWarnings,
   ConfigValidationError,
   resetConfigCache,
   resolveConfig,
@@ -18,12 +19,7 @@ import {
 } from '../utils/config.js';
 import { DEFAULT_CONFIG } from '../types/config.js';
 import type { UserConfig } from '../types/config.js';
-
-interface ConfigCommandOptions {
-  reset?: boolean;
-  get?: true | string;  // true when --get with no key, string when --get <key>
-  set?: string[];       // [key, value]
-}
+import { createPresetCommand } from './preset.js';
 
 /**
  * Load the config documentation markdown from src/prompts/config-docs.md.
@@ -92,10 +88,10 @@ function postSessionValidation(configPath: string): void {
   } catch (error) {
     if (error instanceof ConfigValidationError) {
       logger.warn(`Config validation warning: ${error.message}`);
-      logger.warn('The file was not deleted — you can fix it manually or run `raf config` again.');
+      logger.warn('The file was not deleted — you can fix it manually or run `raf config wizard` again.');
     } else if (error instanceof SyntaxError) {
       logger.warn('Config file contains invalid JSON.');
-      logger.warn('The file was not deleted — you can fix it manually or run `raf config` again.');
+      logger.warn('The file was not deleted — you can fix it manually or run `raf config wizard` again.');
     } else {
       logger.warn(`Could not validate config: ${error}`);
     }
@@ -242,18 +238,16 @@ function formatValue(value: unknown): string {
 // ---- Config get/set handlers ----
 
 /**
- * Handle --get flag: print config value(s).
+ * Print config value(s).
  */
-function handleGet(key: true | string): void {
+function handleGet(key?: string): void {
   const config = resolveConfig();
 
-  if (key === true) {
-    // No key specified: print full config
+  if (key === undefined) {
     console.log(JSON.stringify(config, null, 2));
     return;
   }
 
-  // Specific key requested
   const value = getNestedValue(config, key);
 
   if (value === undefined) {
@@ -265,15 +259,9 @@ function handleGet(key: true | string): void {
 }
 
 /**
- * Handle --set flag: update config file with a new value.
+ * Update config file with a new value.
  */
-function handleSet(args: string[]): void {
-  if (args.length !== 2) {
-    logger.error('--set requires exactly 2 arguments: key and value');
-    process.exit(1);
-  }
-
-  const [key, rawValue] = args as [string, string];
+function handleSet(key: string, rawValue: string): void {
   const value = parseValue(rawValue);
   const configPath = getConfigPath();
 
@@ -312,7 +300,10 @@ function handleSet(args: string[]): void {
 
   // Validate the resulting config
   try {
-    validateConfig(userConfig);
+    const validated = validateConfig(userConfig);
+    for (const warning of collectConfigValidationWarnings(validated)) {
+      logger.warn(`Config validation warning: ${warning}`);
+    }
   } catch (error) {
     if (error instanceof ConfigValidationError) {
       logger.error(`Validation error: ${error.message}`);
@@ -336,41 +327,47 @@ function handleSet(args: string[]): void {
 
 export function createConfigCommand(): Command {
   const command = new Command('config')
-    .description('View and edit RAF configuration interactively')
-    .argument('[prompt...]', 'Optional initial prompt for the config session')
-    .option('--reset', 'Delete config file and restore all defaults')
-    .option('--get [key]', 'Show config value (all config if no key, or specific dot-notation key)')
-    .option('--set <items...>', 'Set a config value using dot-notation key and value')
-    .action(async (promptParts: string[], options: ConfigCommandOptions) => {
-      // --reset takes precedence
-      if (options.reset) {
-        await handleReset();
-        return;
-      }
-
-      // --get and --set are mutually exclusive
-      if (options.get !== undefined && options.set !== undefined) {
-        logger.error('Cannot use --get and --set together');
-        process.exit(1);
-      }
-
-      // Handle --get
-      if (options.get !== undefined) {
-        handleGet(options.get);
-        return;
-      }
-
-      // Handle --set
-      if (options.set !== undefined) {
-        handleSet(options.set);
-        return;
-      }
-
-      // Default: run interactive session
-      const initialPrompt = promptParts.length > 0 ? promptParts.join(' ') : undefined;
-      await runConfigSession(initialPrompt);
+    .description('Manage RAF configuration with get, set, reset, wizard, and preset subcommands')
+    .action(function(this: Command) {
+      this.outputHelp();
     });
 
+  command
+    .addCommand(
+      new Command('get')
+        .description('Print the resolved config or one resolved dot-notation value')
+        .argument('[key]', 'Optional dot-notation key to read')
+        .action((key?: string) => {
+          handleGet(key);
+        })
+    )
+    .addCommand(
+      new Command('set')
+        .description('Write a config value using a dot-notation key')
+        .argument('<key>', 'Dot-notation key to write')
+        .argument('<value>', 'Value to write; parsed as JSON when possible')
+        .action((key: string, value: string) => {
+          handleSet(key, value);
+        })
+    )
+    .addCommand(
+      new Command('reset')
+        .description('Delete the config file and restore all defaults')
+        .action(async () => {
+          await handleReset();
+        })
+    )
+    .addCommand(
+      new Command('wizard')
+        .description('Launch the interactive config editor session')
+        .argument('[prompt...]', 'Optional initial prompt for the config session')
+        .action(async (promptParts: string[]) => {
+          const initialPrompt = promptParts.length > 0 ? promptParts.join(' ') : undefined;
+          await runConfigSession(initialPrompt);
+        })
+    )
+    .addCommand(createPresetCommand());
+
   return command;
 }
 
@@ -399,16 +396,16 @@ async function runConfigSession(initialPrompt?: string): Promise<void> {
   const configPath = getConfigPath();
 
   // Try to load config, but fall back to defaults if it's broken
-  // This allows raf config to be used to fix a broken config file
-  let model: string;
+  // This allows raf config wizard to be used to fix a broken config file
+  let modelEntry: import('../types/config.js').ModelEntry;
   let configError: Error | null = null;
 
   try {
-    model = getModel('config');
+    modelEntry = getModel('config');
   } catch (error) {
     // Config file has errors - fall back to defaults so the session can launch
     configError = error instanceof Error ? error : new Error(String(error));
-    model = DEFAULT_CONFIG.models.config;
+    modelEntry = DEFAULT_CONFIG.models.config;
     // Clear the cached config so subsequent calls don't use the broken cache
     resetConfigCache();
   }
@@ -416,7 +413,7 @@ async function runConfigSession(initialPrompt?: string): Promise<void> {
   // Warn user if config has errors, before starting the session
   if (configError) {
     logger.warn(`Config file has errors, using defaults: ${configError.message}`);
-    logger.warn('Fix the config in this session or run `raf config --reset` to start fresh.');
+    logger.warn('Fix the config in this session or run `raf config reset` to start fresh.');
     logger.newline();
   }
 
@@ -438,11 +435,11 @@ async function runConfigSession(initialPrompt?: string): Promise<void> {
     ?? 'Show me my current config and help me make changes.';
 
   // Set up runner
-  const claudeRunner = createRunner({ model });
+  const claudeRunner = createRunner({ model: modelEntry.model, harness: modelEntry.harness, reasoningEffort: modelEntry.reasoningEffort, fast: modelEntry.fast });
   shutdownHandler.init();
   shutdownHandler.registerClaudeRunner(claudeRunner);
 
-  const configModel = getModelShortName(model);
+  const configModel = formatModelDisplay(modelEntry.model);
   logger.info(`Starting config session with ${configModel}...`);
   logger.newline();
 

package/src/commands/do.ts

@@ -8,18 +8,19 @@ import { shutdownHandler } from '../core/shutdown-handler.js';
 import { stashChanges, hasUncommittedChanges, isGitRepo, getHeadCommitHash } from '../core/git.js';
 import { getExecutionPrompt } from '../prompts/execution.js';
 import { parseOutput, isRetryableFailure } from '../parsers/output-parser.js';
-import { validatePlansExist, resolveModelOption } from '../utils/validation.js';
+import { validatePlansExist } from '../utils/validation.js';
 import { getRafDir, extractProjectNumber, extractProjectName, extractTaskNameFromPlanFile, resolveProjectIdentifierWithDetails, getOutcomeFilePath } from '../utils/paths.js';
 import { pickPendingProject, getPendingProjects, getPendingWorktreeProjects } from '../ui/project-picker.js';
 import type { PendingProjectInfo } from '../ui/project-picker.js';
 import { logger } from '../utils/logger.js';
-import { getConfig, getModel, getModelShortName, resolveFullModelId, getSyncMainBranch, resolveEffortToModel, applyModelCeiling, getShowCacheTokens } from '../utils/config.js';
+import { formatModelDisplay, getConfig, getModel, getSyncMainBranch, resolveEffortToModel, applyModelCeiling, getShowCacheTokens, parseModelSpec, resolveFullModelId } from '../utils/config.js';
 import type { PlanFrontmatter } from '../utils/frontmatter.js';
 import { getVersion } from '../utils/version.js';
 import { createTaskTimer, formatElapsedTime } from '../utils/timer.js';
 import { createStatusLine } from '../utils/status-line.js';
 import {
   formatProjectHeader,
+  formatModelMetadata,
   formatSummary,
   formatTaskProgress,
   formatTaskTokenSummary,
@@ -52,7 +53,7 @@ import {
   rebaseOntoMain,
 } from '../core/worktree.js';
 import { createPullRequest, prPreflight } from '../core/pull-request.js';
-import type { DoCommandOptions } from '../types/config.js';
+import type { DoCommandOptions, ModelEntry } from '../types/config.js';
 
 /**
  * Post-execution action chosen by the user before task execution begins.
@@ -66,8 +67,8 @@ export type PostExecutionAction = 'merge' | 'pr' | 'leave';
  * Result of resolving a task's model from frontmatter.
  */
 interface TaskModelResolution {
-  /** The resolved model (after ceiling is applied). */
-  model: string;
+  /** The resolved model entry (after ceiling is applied). */
+  entry: ModelEntry;
   /** Whether a warning should be logged about missing frontmatter. */
   missingFrontmatter: boolean;
   /** Frontmatter parsing warnings to log. */
@@ -84,27 +85,26 @@ interface TaskModelResolution {
  *
  * @param frontmatter - Parsed frontmatter from the plan file
  * @param frontmatterWarnings - Warnings from frontmatter parsing
- * @param ceilingModel - The ceiling model (usually models.execute from config)
+ * @param ceilingEntry - The ceiling model entry (usually models.execute from config)
  * @param isRetry - Whether this is a retry attempt (escalates to ceiling)
  */
 function resolveTaskModel(
   frontmatter: PlanFrontmatter | undefined,
   frontmatterWarnings: string[] | undefined,
-  ceilingModel: string,
+  ceilingEntry: ModelEntry,
   isRetry: boolean,
-  provider?: import('../types/config.js').HarnessProvider,
 ): TaskModelResolution {
   const warnings = frontmatterWarnings ? [...frontmatterWarnings] : [];
 
   // Retry escalation: always use the ceiling model on retry
   if (isRetry) {
-    return { model: ceilingModel, missingFrontmatter: false, warnings };
+    return { entry: ceilingEntry, missingFrontmatter: false, warnings };
   }
 
   // No frontmatter - fallback to ceiling with warning
   if (!frontmatter) {
     return {
-      model: ceilingModel,
+      entry: ceilingEntry,
       missingFrontmatter: true,
       warnings,
     };
@@ -112,20 +112,25 @@ function resolveTaskModel(
 
   // Explicit model in frontmatter - apply ceiling
   if (frontmatter.model) {
-    const model = applyModelCeiling(frontmatter.model, ceilingModel);
-    return { model, missingFrontmatter: false, warnings };
+    const parsed = parseModelSpec(frontmatter.model);
+    const fmEntry: ModelEntry = {
+      model: parsed.model,
+      harness: parsed.harness,
+    };
+    const result = applyModelCeiling(fmEntry, ceilingEntry);
+    return { entry: result, missingFrontmatter: false, warnings };
   }
 
   // Effort-based resolution - apply ceiling
   if (frontmatter.effort) {
-    const mappedModel = resolveEffortToModel(frontmatter.effort, provider);
-    const model = applyModelCeiling(mappedModel, ceilingModel);
-    return { model, missingFrontmatter: false, warnings };
+    const mappedEntry = resolveEffortToModel(frontmatter.effort);
+    const result = applyModelCeiling(mappedEntry, ceilingEntry);
+    return { entry: result, missingFrontmatter: false, warnings };
   }
 
   // Frontmatter present but no effort or model - fallback to ceiling with warning
   return {
-    model: ceilingModel,
+    entry: ceilingEntry,
     missingFrontmatter: true,
     warnings,
   };
@@ -186,6 +191,13 @@ interface ProjectExecutionResult {
   retryHistory?: TaskRetryHistory[];
 }
 
+export function formatResolvedTaskModel(entry: ModelEntry): string {
+  return formatModelMetadata(resolveFullModelId(entry.model), {
+    effort: entry.reasoningEffort,
+    fast: entry.fast === true,
+  });
+}
+
 export function createDoCommand(): Command {
   const command = new Command('do')
     .description('Execute planned tasks for a project')
@@ -195,9 +207,6 @@ export function createDoCommand(): Command {
     .option('-v, --verbose', 'Show full LLM output')
     .option('-d, --debug', 'Save all logs and show debug output')
     .option('-f, --force', 'Re-run all tasks regardless of status')
-    .option('-m, --model <name>', 'Model to use (sonnet, haiku, opus)')
-    .option('--sonnet', 'Use Sonnet model (shorthand for --model sonnet)')
-    .option('-p, --provider <provider>', 'CLI provider to use (claude, codex)')
     .action(async (project: string | undefined, options: DoCommandOptions) => {
       await runDoCommand(project, options);
     });
@@ -208,14 +217,7 @@ export function createDoCommand(): Command {
 async function runDoCommand(projectIdentifierArg: string | undefined, options: DoCommandOptions): Promise<void> {
   const rafDir = getRafDir();
   let projectIdentifier = projectIdentifierArg;
-  // Validate and resolve model option
-  let model: string;
-  try {
-    model = resolveModelOption(options.model as string | undefined, options.sonnet, 'execute');
-  } catch (error) {
-    logger.error((error as Error).message);
-    process.exit(1);
-  }
+  const executeEntry = getModel('execute');
 
   // Variables for worktree context (derived from where the project is found)
   let worktreeRoot: string | undefined;
@@ -398,8 +400,7 @@ async function runDoCommand(projectIdentifierArg: string | undefined, options: D
         force,
         maxRetries,
         autoCommit,
-        model,
-        provider: options.provider,
+        executeEntry,
         worktreeCwd: worktreeRoot,
       }
     );
@@ -558,9 +559,8 @@ interface SingleProjectOptions {
   force: boolean;
   maxRetries: number;
   autoCommit: boolean;
-  model: string;
-  /** CLI provider to use (claude, codex). */
-  provider?: import('../types/config.js').HarnessProvider;
+  /** The resolved execute model entry (acts as ceiling for per-task resolution). */
+  executeEntry: ModelEntry;
   /** Worktree root directory. When set, the runner uses cwd in the worktree. */
   worktreeCwd?: string;
 }
@@ -570,7 +570,7 @@ async function executeSingleProject(
   projectName: string,
   options: SingleProjectOptions
 ): Promise<ProjectExecutionResult> {
-  const { timeout, verbose, debug, force, maxRetries, autoCommit, model, provider, worktreeCwd } = options;
+  const { timeout, verbose, debug, force, maxRetries, autoCommit, executeEntry, worktreeCwd } = options;
 
   if (!validatePlansExist(projectPath)) {
     return {
@@ -614,8 +614,8 @@ async function executeSingleProject(
   const projectManager = new ProjectManager();
   shutdownHandler.init();
 
-  // The ceiling model for all tasks (can be overridden per-task, subject to this ceiling)
-  const ceilingModel = model;
+  // The ceiling model entry for all tasks (can be overridden per-task, subject to this ceiling)
+  const ceilingEntry = executeEntry;
 
   // Initialize token tracker for usage reporting
   const tokenTracker = new TokenTracker();
@@ -628,8 +628,8 @@ async function executeSingleProject(
   const projectStartTime = Date.now();
 
   // Resolve and display version + ceiling model info (before any tasks run)
-  const fullCeilingModelId = resolveFullModelId(ceilingModel);
-  logger.dim(`RAF v${getVersion()} | Ceiling: ${fullCeilingModelId}`);
+  const fullCeilingModelId = resolveFullModelId(ceilingEntry.model);
+  logger.dim(`RAF v${getVersion()} | Ceiling: ${fullCeilingModelId} (${ceilingEntry.harness})`);
 
   if (verbose) {
     logger.info(`Executing project: ${projectName}`);
@@ -811,6 +811,8 @@ async function executeSingleProject(
     const failureHistory: Array<{ attempt: number; reason: string }> = [];
     // Track current model for display in status line (updated in retry loop)
     let currentModel: string | undefined;
+    let currentEffort: string | undefined;
+    let currentModelFast = false;
 
     // Set up timer for elapsed time tracking
     const statusLine = createStatusLine();
@@ -821,8 +823,11 @@ async function executeSingleProject(
         return;
       }
       // Show running status with task name and timer (updates in place)
-      const modelShortName = currentModel ? getModelShortName(currentModel) : undefined;
-      statusLine.update(formatTaskProgress(taskNumber, totalTasks, 'running', displayName, elapsed, taskId, modelShortName));
+      const modelShortName = currentModel ? formatModelDisplay(currentModel) : undefined;
+      statusLine.update(formatTaskProgress(taskNumber, totalTasks, 'running', displayName, elapsed, taskId, modelShortName, {
+        effort: currentEffort,
+        fast: currentModelFast,
+      }));
     });
     timer.start();
 
@@ -841,13 +846,14 @@ async function executeSingleProject(
       const modelResolution = resolveTaskModel(
         task.frontmatter,
         undefined, // warnings already logged above
-        ceilingModel,
+        ceilingEntry,
         isRetry,
-        provider,
       );
 
       // Update current model for timer callback display
-      currentModel = modelResolution.model;
+      currentModel = modelResolution.entry.model;
+      currentEffort = task.frontmatter?.effort;
+      currentModelFast = modelResolution.entry.fast === true;
 
       // Log missing frontmatter warning on first attempt only
       if (!isRetry && modelResolution.missingFrontmatter) {
@@ -855,14 +861,14 @@ async function executeSingleProject(
       }
 
       // Create a runner for this attempt's model
-      const taskRunner = createRunner({ model: modelResolution.model, provider });
+      const taskRunner = createRunner({ model: modelResolution.entry.model, harness: modelResolution.entry.harness, reasoningEffort: modelResolution.entry.reasoningEffort, fast: modelResolution.entry.fast });
       shutdownHandler.registerClaudeRunner(taskRunner);
 
       if (verbose && isRetry) {
-        const retryModel = resolveFullModelId(modelResolution.model);
+        const retryModel = formatResolvedTaskModel(modelResolution.entry);
         logger.info(`  Retry ${attempts}/${maxRetries} for task ${taskLabel} (model: ${retryModel})...`);
       } else if (verbose && !isRetry) {
-        const taskModel = resolveFullModelId(modelResolution.model);
+        const taskModel = formatResolvedTaskModel(modelResolution.entry);
         logger.info(`  Model: ${taskModel}`);
       }
 
@@ -1024,8 +1030,11 @@ Task completed. No detailed report provided.
         logger.success(`  Task ${taskLabel} completed (${elapsedFormatted})`);
       } else {
         // Minimal mode: show completed task line
-        const modelShortName = currentModel ? getModelShortName(currentModel) : undefined;
-        logger.info(formatTaskProgress(taskNumber, totalTasks, 'completed', displayName, elapsedMs, task.id, modelShortName));
+        const modelShortName = currentModel ? formatModelDisplay(currentModel) : undefined;
+        logger.info(formatTaskProgress(taskNumber, totalTasks, 'completed', displayName, elapsedMs, task.id, modelShortName, {
+          effort: currentEffort,
+          fast: currentModelFast,
+        }));
       }
 
       // Track and display token usage for this task
@@ -1051,12 +1060,16 @@ Task completed. No detailed report provided.
 
       if (verbose) {
         logger.error(`  Task ${taskLabel} failed: ${failureReason} (${elapsedFormatted})`);
-        const analysisModel = getModelShortName(getModel('failureAnalysis'));
+        const analysisEntry = getModel('failureAnalysis');
+        const analysisModel = formatModelDisplay(analysisEntry.model);
         logger.info(`  Analyzing failure with ${analysisModel}...`);
       } else {
         // Minimal mode: show failed task line
-        const modelShortName = currentModel ? getModelShortName(currentModel) : undefined;
-        logger.info(formatTaskProgress(taskNumber, totalTasks, 'failed', displayName, elapsedMs, task.id, modelShortName));
+        const modelShortName = currentModel ? formatModelDisplay(currentModel) : undefined;
+        logger.info(formatTaskProgress(taskNumber, totalTasks, 'failed', displayName, elapsedMs, task.id, modelShortName, {
+          effort: currentEffort,
+          fast: currentModelFast,
+        }));
       }
 
       // Track token usage even for failed tasks (partial data still useful for totals)
@@ -1209,4 +1222,3 @@ ${stashName ? `- Stash: ${stashName}` : ''}
     retryHistory: projectRetryHistory,
   };
 }
-