rafcode 3.2.1 → 3.8.0

package/src/commands/plan.ts

@@ -13,28 +13,23 @@ import {
   validateEnvironment,
   reportValidation,
   validateProjectName,
-  resolveModelOption,
 } from '../utils/validation.js';
 import { logger } from '../utils/logger.js';
-import { getWorktreeDefault, getModel, getModelShortName, getSyncMainBranch } from '../utils/config.js';
+import { formatModelDisplay, getModel } from '../utils/config.js';
+import type { ModelEntry } from '../types/config.js';
 import { generateProjectNames } from '../utils/name-generator.js';
 import { pickProjectName } from '../ui/name-picker.js';
 import {
   getPlansDir,
   getRafDir,
-  getNextProjectNumber,
-  formatProjectNumber,
   resolveProjectIdentifierWithDetails,
   getInputPath,
-  getDecisionsPath,
-  getOutcomesDir,
   extractTaskNameFromPlanFile,
   decodeTaskId,
   encodeTaskId,
   TASK_ID_PATTERN,
   numericFileSort,
 } from '../utils/paths.js';
-import { sanitizeProjectName } from '../utils/validation.js';
 import {
   deriveProjectState,
   isProjectComplete,
@@ -43,21 +38,14 @@ import {
 import {
   getRepoBasename,
   getRepoRoot,
-  createWorktree,
   validateWorktree,
-  removeWorktree,
-  pullMainBranch,
   resolveWorktreeProjectByIdentifier,
 } from '../core/worktree.js';
 
 interface PlanCommandOptions {
   amend?: boolean;
-  model?: string;
-  sonnet?: boolean;
   auto?: boolean;
-  worktree?: boolean;
   resume?: string;
-  provider?: string;
 }
 
 export function createPlanCommand(): Command {
@@ -68,30 +56,15 @@ export function createPlanCommand(): Command {
       '-a, --amend',
       'Add tasks to an existing project (requires project identifier as argument)'
     )
-    .option('-m, --model <name>', 'Model to use (sonnet, haiku, opus)')
-    .option('--sonnet', 'Use Sonnet model (shorthand for --model sonnet)')
     .option('-y, --auto', 'Skip permission prompts for file operations')
-    .option('-w, --worktree', 'Create a git worktree for isolated planning')
-    .option('--no-worktree', 'Disable worktree mode (overrides config)')
     .option('-r, --resume <identifier>', 'Resume a planning session for an existing project')
-    .option('-p, --provider <provider>', 'CLI provider to use (claude, codex)')
     .action(async (projectName: string | undefined, options: PlanCommandOptions) => {
-      // Validate and resolve model option
-      let model: string;
-      try {
-        model = resolveModelOption(options.model, options.sonnet, 'plan');
-      } catch (error) {
-        logger.error((error as Error).message);
-        process.exit(1);
-      }
+      const modelEntry = getModel('plan');
 
       const autoMode = options.auto ?? false;
-      const worktreeMode = options.worktree ?? getWorktreeDefault();
-
-      const provider = options.provider as import('../types/config.js').HarnessProvider | undefined;
 
       if (options.resume) {
-        await runResumeCommand(options.resume, model, provider);
+        await runResumeCommand(options.resume, modelEntry);
       } else if (options.amend) {
         if (!projectName) {
           logger.error('--amend requires a project identifier');
@@ -99,16 +72,16 @@ export function createPlanCommand(): Command {
           logger.error('   or: raf plan --amend <project>');
           process.exit(1);
         }
-        await runAmendCommand(projectName, model, autoMode, provider);
+        await runAmendCommand(projectName, modelEntry, autoMode);
       } else {
-        await runPlanCommand(projectName, model, autoMode, worktreeMode, provider);
+        await runPlanCommand(projectName, modelEntry, autoMode);
       }
     });
 
   return command;
 }
 
-async function runPlanCommand(projectName?: string, model?: string, autoMode: boolean = false, worktreeMode: boolean = false, provider?: import('../types/config.js').HarnessProvider): Promise<void> {
+async function runPlanCommand(projectName?: string, modelEntry?: ModelEntry, autoMode: boolean = false): Promise<void> {
   // Validate environment
   const validation = validateEnvironment();
   reportValidation(validation);
@@ -151,7 +124,7 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
       });
 
       if (answer === 'amend') {
-        await runAmendCommand(existingFolder, model, autoMode, provider);
+        await runAmendCommand(existingFolder, modelEntry, autoMode);
         return;
       } else if (answer === 'cancel') {
         logger.info('Aborted.');
@@ -161,15 +134,6 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
     }
   }
 
-  // Validate git repo for worktree mode
-  if (worktreeMode) {
-    const repoRoot = getRepoRoot();
-    if (!repoRoot) {
-      logger.error('--worktree requires a git repository');
-      process.exit(1);
-    }
-  }
-
   // Open editor for user input
   logger.info('Opening editor for project description...');
   logger.info('(Save and close the editor when done)');
@@ -197,7 +161,8 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
   // Get or generate project name
   let finalProjectName = projectName;
   if (!finalProjectName) {
-    const nameModel = getModelShortName(getModel('nameGeneration'));
+    const nameEntry = getModel('nameGeneration');
+    const nameModel = formatModelDisplay(nameEntry.model);
     logger.info(`Generating project name suggestions with ${nameModel}...`);
     const suggestedNames = await generateProjectNames(cleanInput);
     logger.newline();
@@ -217,103 +182,32 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
     process.exit(1);
   }
 
-  let projectPath: string;
-  let worktreePath: string | null = null;
-  let worktreeBranch: string | null = null;
-
-  if (worktreeMode) {
-    // Worktree mode: create worktree, then project folder inside it
-    const repoBasename = getRepoBasename()!;
-    const repoRoot = getRepoRoot()!;
-    const rafDir = getRafDir();
-
-    // Sync main branch before creating worktree (if enabled)
-    if (getSyncMainBranch()) {
-      const syncResult = pullMainBranch();
-      if (syncResult.success) {
-        if (syncResult.hadChanges) {
-          logger.info(`Synced ${syncResult.mainBranch} from remote`);
-        }
-      } else {
-        logger.warn(`Could not sync main branch: ${syncResult.error}`);
-      }
-    }
-
-    // Compute project number from main repo's RAF directory (scan worktrees too)
-    const projectNumber = getNextProjectNumber(rafDir, repoBasename);
-    const sanitizedName = sanitizeProjectName(finalProjectName);
-    const folderName = `${formatProjectNumber(projectNumber)}-${sanitizedName}`;
-
-    // Create worktree
-    const result = createWorktree(repoBasename, folderName);
-    if (!result.success) {
-      logger.error(`Failed to create worktree: ${result.error}`);
-      process.exit(1);
-    }
-
-    worktreePath = result.worktreePath;
-    worktreeBranch = result.branch;
-
-    // Compute project path inside worktree at the same relative path
-    const rafRelativePath = path.relative(repoRoot, rafDir);
-    projectPath = path.join(worktreePath, rafRelativePath, folderName);
-
-    // Create project folder structure inside the worktree
-    fs.mkdirSync(projectPath, { recursive: true });
-    fs.mkdirSync(getPlansDir(projectPath), { recursive: true });
-    fs.mkdirSync(getOutcomesDir(projectPath), { recursive: true });
-    fs.writeFileSync(getDecisionsPath(projectPath), '# Project Decisions\n');
+  // Standard mode: create project in main repo
+  const projectManager = new ProjectManager();
+  const projectPath = projectManager.createProject(finalProjectName);
 
-    // Save input inside worktree project folder
-    fs.writeFileSync(getInputPath(projectPath), userInput);
-
-    logger.success(`Created worktree: ${worktreePath}`);
-    logger.success(`Branch: ${worktreeBranch}`);
-    logger.success(`Project: ${projectPath}`);
-    logger.newline();
-  } else {
-    // Standard mode: create project in main repo
-    const projectManager = new ProjectManager();
-    projectPath = projectManager.createProject(finalProjectName);
-
-    logger.success(`Created project: ${projectPath}`);
-    logger.newline();
+  logger.success(`Created project: ${projectPath}`);
+  logger.newline();
 
-    // Save input
-    projectManager.saveInput(projectPath, userInput);
-  }
+  // Save input
+  projectManager.saveInput(projectPath, userInput);
 
   // Set up shutdown handler
-  const claudeRunner = createRunner({ model, provider });
+  const claudeRunner = createRunner({ model: modelEntry?.model, harness: modelEntry?.harness, reasoningEffort: modelEntry?.reasoningEffort, fast: modelEntry?.fast });
   shutdownHandler.init();
   shutdownHandler.registerClaudeRunner(claudeRunner);
 
   // Register cleanup callback
   shutdownHandler.onShutdown(() => {
-    if (worktreeMode && worktreePath) {
-      // Clean up worktree if no plans were created
-      const plansDir = getPlansDir(projectPath);
-      const hasPlanFiles = fs.existsSync(plansDir) &&
-        fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).length > 0;
-      if (!hasPlanFiles) {
-        const removal = removeWorktree(worktreePath);
-        if (removal.success) {
-          logger.debug(`Cleaned up worktree: ${worktreePath}`);
-        } else {
-          logger.warn(`Failed to clean up worktree: ${removal.error}`);
-        }
-      }
-    } else {
-      const projectManager = new ProjectManager();
-      projectManager.cleanupEmptyProject(projectPath);
-    }
+    const projectManager = new ProjectManager();
+    projectManager.cleanupEmptyProject(projectPath);
   });
 
   // Run planning session
   logger.info('Starting planning session...');
   logger.info('The planner will interview you about each task.');
-  if (model) {
-    logger.info(`Using model: ${model}`);
+  if (modelEntry) {
+    logger.info(`Using model: ${formatModelDisplay(modelEntry.model, modelEntry.harness, { includeHarness: true })}`);
   }
   if (autoMode) {
     logger.warn('Auto mode enabled: permission prompts will be skipped.');
@@ -323,14 +217,11 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
   const { systemPrompt, userMessage } = getPlanningPrompt({
     projectPath,
     inputContent: userInput,
-    worktreeMode,
   });
 
   try {
     const exitCode = await claudeRunner.runInteractive(systemPrompt, userMessage, {
       dangerouslySkipPermissions: autoMode,
-      // Run session in the worktree root if in worktree mode
-      cwd: worktreePath ?? undefined,
     });
 
     if (exitCode !== 0) {
@@ -357,45 +248,23 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
       // Commit planning artifacts (input.md, decisions.md, and plan files)
       const planAbsolutePaths = planFiles.map((f) => path.join(plansDir, f));
       await commitPlanningArtifacts(projectPath, {
-        cwd: worktreePath ?? undefined,
         additionalFiles: planAbsolutePaths,
       });
 
       logger.newline();
-      if (worktreeMode) {
-        logger.info(`Worktree: ${worktreePath}`);
-        logger.info(`Branch: ${worktreeBranch}`);
-        logger.info(`Run 'raf do ${finalProjectName}' to execute the plans.`);
-      } else {
-        logger.info(`Run 'raf do ${finalProjectName}' to execute the plans.`);
-      }
+      logger.info(`Run 'raf do ${finalProjectName}' to execute the plans.`);
     }
   } catch (error) {
     logger.error(`Planning failed: ${error}`);
     throw error;
   } finally {
-    if (worktreeMode && worktreePath) {
-      // Clean up worktree if no plans were created
-      const plansDir = getPlansDir(projectPath);
-      const hasPlanFiles = fs.existsSync(plansDir) &&
-        fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).length > 0;
-      if (!hasPlanFiles) {
-        const removal = removeWorktree(worktreePath);
-        if (removal.success) {
-          logger.debug(`Cleaned up worktree: ${worktreePath}`);
-        } else {
-          logger.warn(`Failed to clean up worktree: ${removal.error}`);
-        }
-      }
-    } else if (!worktreeMode) {
-      // Cleanup empty project folder if no plans were created (standard mode only)
-      const projectManager = new ProjectManager();
-      projectManager.cleanupEmptyProject(projectPath);
-    }
+    // Cleanup empty project folder if no plans were created
+    const projectManager = new ProjectManager();
+    projectManager.cleanupEmptyProject(projectPath);
   }
 }
 
-async function runAmendCommand(identifier: string, model?: string, autoMode: boolean = false, provider?: import('../types/config.js').HarnessProvider): Promise<void> {
+async function runAmendCommand(identifier: string, modelEntry?: ModelEntry, autoMode: boolean = false): Promise<void> {
   // Validate environment
   const validation = validateEnvironment();
   reportValidation(validation);
@@ -528,15 +397,15 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
   fs.writeFileSync(inputPath, updatedInput);
 
   // Set up shutdown handler
-  const claudeRunner = createRunner({ model, provider });
+  const claudeRunner = createRunner({ model: modelEntry?.model, harness: modelEntry?.harness, reasoningEffort: modelEntry?.reasoningEffort, fast: modelEntry?.fast });
   shutdownHandler.init();
   shutdownHandler.registerClaudeRunner(claudeRunner);
 
   // Run amend planning session
   logger.info('Starting amendment session...');
   logger.info('The planner will interview you about each new task.');
-  if (model) {
-    logger.info(`Using model: ${model}`);
+  if (modelEntry) {
+    logger.info(`Using model: ${formatModelDisplay(modelEntry.model, modelEntry.harness, { includeHarness: true })}`);
   }
   if (autoMode) {
     logger.warn('Auto mode enabled: permission prompts will be skipped.');
@@ -636,7 +505,7 @@ ${taskList}
 `;
 }
 
-async function runResumeCommand(identifier: string, model?: string, provider?: import('../types/config.js').HarnessProvider): Promise<void> {
+async function runResumeCommand(identifier: string, modelEntry?: ModelEntry): Promise<void> {
   // Validate environment
   const validation = validateEnvironment();
   reportValidation(validation);
@@ -700,13 +569,13 @@ async function runResumeCommand(identifier: string, model?: string, provider?: i
   }
 
   logger.info(`Project: ${folderName}`);
-  if (model) {
-    logger.info(`Model: ${model}`);
+  if (modelEntry) {
+    logger.info(`Model: ${formatModelDisplay(modelEntry.model, modelEntry.harness, { includeHarness: true })}`);
   }
   logger.newline();
 
   // Set up shutdown handler
-  const claudeRunner = createRunner({ model, provider });
+  const claudeRunner = createRunner({ model: modelEntry?.model, harness: modelEntry?.harness, reasoningEffort: modelEntry?.reasoningEffort, fast: modelEntry?.fast });
   shutdownHandler.init();
   shutdownHandler.registerClaudeRunner(claudeRunner);
 

package/src/commands/preset.ts

@@ -0,0 +1,186 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { Command } from 'commander';
+import { logger } from '../utils/logger.js';
+import {
+  getConfigPath,
+  validateConfig,
+  ConfigValidationError,
+} from '../utils/config.js';
+
+const PRESETS_DIR = path.join(os.homedir(), '.raf', 'presets');
+
+function ensurePresetsDir(): void {
+  if (!fs.existsSync(PRESETS_DIR)) {
+    fs.mkdirSync(PRESETS_DIR, { recursive: true });
+  }
+}
+
+function getPresetPath(name: string): string {
+  return path.join(PRESETS_DIR, `${name}.json`);
+}
+
+function validatePresetName(name: string): void {
+  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+    logger.error('Preset name must contain only letters, numbers, hyphens, and underscores.');
+    process.exit(1);
+  }
+}
+
+function savePreset(name: string): void {
+  validatePresetName(name);
+  ensurePresetsDir();
+
+  const configPath = getConfigPath();
+  if (!fs.existsSync(configPath)) {
+    logger.error('No config file found. Run `raf config wizard` or `raf config set <key> <value>` to create one first.');
+    process.exit(1);
+  }
+
+  const presetPath = getPresetPath(name);
+  const configContent = fs.readFileSync(configPath, 'utf-8');
+
+  // Validate the config before saving
+  try {
+    const parsed = JSON.parse(configContent);
+    validateConfig(parsed);
+  } catch (err) {
+    if (err instanceof ConfigValidationError) {
+      logger.error(`Current config is invalid: ${err.message}`);
+      process.exit(1);
+    }
+    throw err;
+  }
+
+  const existed = fs.existsSync(presetPath);
+  fs.writeFileSync(presetPath, configContent);
+  logger.info(`${existed ? 'Updated' : 'Saved'} preset "${name}" at ${presetPath}`);
+}
+
+function loadPreset(name: string): void {
+  validatePresetName(name);
+  const presetPath = getPresetPath(name);
+
+  if (!fs.existsSync(presetPath)) {
+    logger.error(`Preset "${name}" not found. Run \`raf config preset list\` to see available presets.`);
+    process.exit(1);
+  }
+
+  const content = fs.readFileSync(presetPath, 'utf-8');
+
+  // Validate preset before applying
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    logger.error(`Preset "${name}" contains invalid JSON.`);
+    process.exit(1);
+  }
+
+  try {
+    validateConfig(parsed);
+  } catch (err) {
+    if (err instanceof ConfigValidationError) {
+      logger.error(`Preset "${name}" is invalid: ${err.message}`);
+      process.exit(1);
+    }
+    throw err;
+  }
+
+  const configPath = getConfigPath();
+  const configDir = path.dirname(configPath);
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  fs.writeFileSync(configPath, content);
+  logger.info(`Loaded preset "${name}" into ${configPath}`);
+
+  // Show a brief summary of what was loaded
+  const config = parsed as Record<string, unknown>;
+  const keys = Object.keys(config);
+  if (keys.length > 0) {
+    logger.info(`  Keys: ${keys.join(', ')}`);
+  }
+}
+
+function listPresets(): void {
+  ensurePresetsDir();
+
+  const files = fs.readdirSync(PRESETS_DIR).filter(f => f.endsWith('.json'));
+  if (files.length === 0) {
+    logger.info('No presets saved. Use `raf config preset save <name>` to create one.');
+    return;
+  }
+
+  logger.info(`Found ${files.length} preset(s):\n`);
+  for (const file of files) {
+    const name = path.basename(file, '.json');
+    const filePath = path.join(PRESETS_DIR, file);
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const config = JSON.parse(content) as Record<string, unknown>;
+
+      // Build a brief summary from models
+      const summary: string[] = [];
+      if (config.models && typeof config.models === 'object') {
+        const models = config.models as Record<string, { model?: string; harness?: string }>;
+        const harnesses = new Set<string>();
+        for (const entry of Object.values(models)) {
+          if (entry?.harness) harnesses.add(entry.harness);
+        }
+        if (harnesses.size > 0) {
+          summary.push(`harnesses: ${[...harnesses].join(', ')}`);
+        }
+        if (models.execute?.model) {
+          summary.push(`execute: ${models.execute.model}`);
+        }
+      }
+
+      const info = summary.length > 0 ? ` (${summary.join('; ')})` : '';
+      logger.info(`  ${name}${info}`);
+    } catch {
+      logger.info(`  ${name} (invalid JSON)`);
+    }
+  }
+}
+
+function deletePreset(name: string): void {
+  validatePresetName(name);
+  const presetPath = getPresetPath(name);
+
+  if (!fs.existsSync(presetPath)) {
+    logger.error(`Preset "${name}" not found.`);
+    process.exit(1);
+  }
+
+  fs.unlinkSync(presetPath);
+  logger.info(`Deleted preset "${name}".`);
+}
+
+export function createPresetCommand(): Command {
+  const preset = new Command('preset')
+    .description('Manage named config presets under `raf config preset`');
+
+  preset
+    .command('save <name>')
+    .description('Save current config as a named preset')
+    .action((name: string) => savePreset(name));
+
+  preset
+    .command('load <name>')
+    .description('Load a preset into the active config (overwrites current config)')
+    .action((name: string) => loadPreset(name));
+
+  preset
+    .command('list')
+    .description('List all saved presets')
+    .action(() => listPresets());
+
+  preset
+    .command('delete <name>')
+    .description('Delete a saved preset')
+    .action((name: string) => deletePreset(name));
+
+  return preset;
+}

package/src/core/claude-runner.ts

@@ -4,6 +4,7 @@ import { execSync, spawn } from 'node:child_process';
 import { logger } from '../utils/logger.js';
 import { renderStreamEvent } from '../parsers/stream-renderer.js';
 import { getModel } from '../utils/config.js';
+import { mergeUsageData } from '../utils/token-tracker.js';
 import type { ICliRunner } from './runner-interface.js';
 import type { RunnerOptions, RunnerConfig, RunResult } from './runner-types.js';
 import { createCompletionDetector } from './completion-detector.js';
@@ -32,9 +33,13 @@ export class ClaudeRunner implements ICliRunner {
   private activeProcess: pty.IPty | null = null;
   private killed = false;
   private model: string;
+  private reasoningEffort?: string;
+  private fast?: boolean;
 
   constructor(config: RunnerConfig = {}) {
-    this.model = config.model ?? getModel('execute');
+    this.model = config.model ?? getModel('execute').model;
+    this.reasoningEffort = config.reasoningEffort;
+    this.fast = config.fast;
   }
 
   /**
@@ -55,6 +60,16 @@ export class ClaudeRunner implements ICliRunner {
     return new Promise((resolve) => {
       const args = ['--model', this.model];
 
+      // Add reasoning effort flag when configured
+      if (this.reasoningEffort) {
+        args.push('--effort', this.reasoningEffort);
+      }
+
+      // Add fast mode when configured
+      if (this.fast) {
+        args.push('--settings', '{"fastMode": true}');
+      }
+
       // Add --dangerously-skip-permissions if requested (for --auto mode)
       if (dangerouslySkipPermissions) {
         args.push('--dangerously-skip-permissions');
@@ -147,6 +162,16 @@ export class ClaudeRunner implements ICliRunner {
     return new Promise((resolve) => {
       const args = ['--resume', '--model', this.model];
 
+      // Add reasoning effort flag when configured
+      if (this.reasoningEffort) {
+        args.push('--effort', this.reasoningEffort);
+      }
+
+      // Add fast mode when configured
+      if (this.fast) {
+        args.push('--settings', '{"fastMode": true}');
+      }
+
       logger.debug(`Starting session resume picker with model: ${this.model}`);
 
       this.activeProcess = pty.spawn(getClaudePath(), args, {
@@ -272,10 +297,23 @@ export class ClaudeRunner implements ICliRunner {
       // including tool calls, file operations, and token usage in the result event.
       // --dangerously-skip-permissions bypasses interactive prompts
       // -p enables print mode (non-interactive)
-      const proc = spawn(claudePath, [
+      const execArgs = [
         '--dangerously-skip-permissions',
         '--model',
         this.model,
+      ];
+
+      // Add reasoning effort flag when configured
+      if (this.reasoningEffort) {
+        execArgs.push('--effort', this.reasoningEffort);
+      }
+
+      // Add fast mode when configured
+      if (this.fast) {
+        execArgs.push('--settings', '{"fastMode": true}');
+      }
+
+      execArgs.push(
         '--append-system-prompt',
         prompt,
         '--output-format',
@@ -283,7 +321,9 @@ export class ClaudeRunner implements ICliRunner {
         '--verbose',
         '-p',
         'Execute the task as described in the system prompt.',
-      ], {
+      );
+
+      const proc = spawn(claudePath, execArgs, {
         cwd,
         env: process.env,
         stdio: ['ignore', 'pipe', 'pipe'], // no stdin needed
@@ -346,7 +386,7 @@ export class ClaudeRunner implements ICliRunner {
 
           // Capture usage data from result events
           if (rendered.usageData) {
-            usageData = rendered.usageData;
+            usageData = mergeUsageData(usageData, rendered.usageData);
           }
 
           if (shouldDisplay() && rendered.display) {
@@ -368,7 +408,7 @@ export class ClaudeRunner implements ICliRunner {
             output += rendered.textContent;
           }
           if (rendered.usageData) {
-            usageData = rendered.usageData;
+            usageData = mergeUsageData(usageData, rendered.usageData);
           }
           if (shouldDisplay() && rendered.display) {
             process.stdout.write(rendered.display);