rafcode 2.1.0 → 2.2.0

package/src/commands/config.ts

@@ -0,0 +1,204 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as readline from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import { Command } from 'commander';
+import { ClaudeRunner } from '../core/claude-runner.js';
+import { shutdownHandler } from '../core/shutdown-handler.js';
+import { logger } from '../utils/logger.js';
+import {
+  getConfigPath,
+  getModel,
+  getEffort,
+  validateConfig,
+  ConfigValidationError,
+} from '../utils/config.js';
+
+interface ConfigCommandOptions {
+  reset?: boolean;
+}
+
+/**
+ * Load the config documentation markdown from src/prompts/config-docs.md.
+ * Resolved relative to this file's location in the dist/ tree.
+ */
+function loadConfigDocs(): string {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  // From dist/commands/config.js -> ../../src/prompts/config-docs.md
+  const docsPath = path.join(__dirname, '..', '..', 'src', 'prompts', 'config-docs.md');
+  return fs.readFileSync(docsPath, 'utf-8');
+}
+
+/**
+ * Read the current user config file contents, or a message indicating no file exists.
+ */
+function getCurrentConfigState(configPath: string): string {
+  if (!fs.existsSync(configPath)) {
+    return 'No config file exists yet. All settings use defaults. The file will be created at: ' + configPath;
+  }
+  try {
+    const content = fs.readFileSync(configPath, 'utf-8');
+    return `Current config file (${configPath}):\n\`\`\`json\n${content}\`\`\``;
+  } catch {
+    return 'Config file exists but could not be read: ' + configPath;
+  }
+}
+
+/**
+ * Build the system prompt for the config editing Claude session.
+ */
+function buildConfigSystemPrompt(configDocs: string, configState: string): string {
+  return [
+    'You are helping the user edit their RAF configuration.',
+    'You have full permission to read and write ~/.raf/raf.config.json.',
+    '',
+    '# Current Config State',
+    configState,
+    '',
+    '# Config Documentation',
+    configDocs,
+  ].join('\n');
+}
+
+/**
+ * Validate the config file after the Claude session ends and report results.
+ */
+function postSessionValidation(configPath: string): void {
+  if (!fs.existsSync(configPath)) {
+    logger.info('No config file exists — using all defaults.');
+    return;
+  }
+
+  try {
+    const content = fs.readFileSync(configPath, 'utf-8');
+    const parsed: unknown = JSON.parse(content);
+    validateConfig(parsed);
+    logger.success('Config updated successfully.');
+
+    // Show a summary of what's set
+    const userConfig = parsed as Record<string, unknown>;
+    const keys = Object.keys(userConfig);
+    if (keys.length > 0) {
+      logger.info(`Custom settings: ${keys.join(', ')}`);
+    }
+  } 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.');
+    } 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.');
+    } else {
+      logger.warn(`Could not validate config: ${error}`);
+    }
+  }
+}
+
+/**
+ * Prompt the user for Y/N confirmation via readline.
+ */
+async function confirm(message: string): Promise<boolean> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(message, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === 'y');
+    });
+  });
+}
+
+export function createConfigCommand(): Command {
+  const command = new Command('config')
+    .description('View and edit RAF configuration with Claude')
+    .argument('[prompt...]', 'Optional initial prompt for the config session')
+    .option('--reset', 'Delete config file and restore all defaults')
+    .action(async (promptParts: string[], options: ConfigCommandOptions) => {
+      if (options.reset) {
+        await handleReset();
+        return;
+      }
+
+      const initialPrompt = promptParts.length > 0 ? promptParts.join(' ') : undefined;
+      await runConfigSession(initialPrompt);
+    });
+
+  return command;
+}
+
+async function handleReset(): Promise<void> {
+  const configPath = getConfigPath();
+
+  if (!fs.existsSync(configPath)) {
+    logger.info('No config file exists — already using defaults.');
+    return;
+  }
+
+  const confirmed = await confirm(
+    'This will delete ~/.raf/raf.config.json and restore all defaults. Continue? [y/N] '
+  );
+
+  if (!confirmed) {
+    logger.info('Cancelled.');
+    return;
+  }
+
+  fs.unlinkSync(configPath);
+  logger.success('Config file deleted. All settings restored to defaults.');
+}
+
+async function runConfigSession(initialPrompt?: string): Promise<void> {
+  const configPath = getConfigPath();
+  const model = getModel('config');
+  const effort = getEffort('config');
+
+  // Set effort level env var for the Claude session
+  process.env['CLAUDE_CODE_EFFORT_LEVEL'] = effort;
+
+  // Load config docs
+  let configDocs: string;
+  try {
+    configDocs = loadConfigDocs();
+  } catch (error) {
+    logger.error(`Failed to load config documentation: ${error}`);
+    process.exit(1);
+  }
+
+  // Build system prompt
+  const configState = getCurrentConfigState(configPath);
+  const systemPrompt = buildConfigSystemPrompt(configDocs, configState);
+
+  // Build user message
+  const userMessage = initialPrompt
+    ?? 'Show me my current config and help me make changes.';
+
+  // Set up Claude runner
+  const claudeRunner = new ClaudeRunner({ model });
+  shutdownHandler.init();
+  shutdownHandler.registerClaudeRunner(claudeRunner);
+
+  logger.info('Starting config session with Claude...');
+  logger.info(`Using model: ${model}`);
+  logger.newline();
+
+  try {
+    const exitCode = await claudeRunner.runInteractive(systemPrompt, userMessage, {
+      dangerouslySkipPermissions: true,
+    });
+
+    if (exitCode !== 0) {
+      logger.warn(`Claude exited with code ${exitCode}`);
+    }
+
+    // Post-session validation
+    logger.newline();
+    postSessionValidation(configPath);
+  } catch (error) {
+    logger.error(`Config session failed: ${error}`);
+    throw error;
+  }
+}

package/src/commands/do.ts

@@ -13,14 +13,18 @@ import { getRafDir, extractProjectNumber, extractProjectName, extractTaskNameFro
 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 } from '../utils/config.js';
+import { getConfig, getEffort, getWorktreeDefault } from '../utils/config.js';
 import { createTaskTimer, formatElapsedTime } from '../utils/timer.js';
 import { createStatusLine } from '../utils/status-line.js';
 import {
   formatProjectHeader,
   formatSummary,
   formatTaskProgress,
+  formatTaskTokenSummary,
+  formatTokenTotalSummary,
 } from '../utils/terminal-symbols.js';
+import { TokenTracker } from '../utils/token-tracker.js';
+import { VerboseToggle } from '../utils/verbose-toggle.js';
 import {
   deriveProjectState,
   discoverProjects,
@@ -124,7 +128,6 @@ export function createDoCommand(): Command {
     .option('-m, --model <name>', 'Claude model to use (sonnet, haiku, opus)')
     .option('--sonnet', 'Use Sonnet model (shorthand for --model sonnet)')
     .option('-w, --worktree', 'Execute tasks in a git worktree')
-    .option('-r, --resume <session-id>', 'Resume an interrupted Claude session')
     .action(async (project: string | undefined, options: DoCommandOptions) => {
       await runDoCommand(project, options);
     });
@@ -135,12 +138,12 @@ export function createDoCommand(): Command {
 async function runDoCommand(projectIdentifierArg: string | undefined, options: DoCommandOptions): Promise<void> {
   const rafDir = getRafDir();
   let projectIdentifier = projectIdentifierArg;
-  let worktreeMode = options.worktree ?? false;
+  let worktreeMode = options.worktree ?? getWorktreeDefault();
 
   // Validate and resolve model option
   let model: string;
   try {
-    model = resolveModelOption(options.model as string | undefined, options.sonnet);
+    model = resolveModelOption(options.model as string | undefined, options.sonnet, 'execute');
   } catch (error) {
     logger.error((error as Error).message);
     process.exit(1);
@@ -357,7 +360,6 @@ async function runDoCommand(projectIdentifierArg: string | undefined, options: D
   const verbose = options.verbose ?? false;
   const debug = options.debug ?? false;
   const force = options.force ?? false;
-  const resumeSessionId = options.resume;
   const maxRetries = config.maxRetries;
   const autoCommit = config.autoCommit;
 
@@ -395,7 +397,6 @@ async function runDoCommand(projectIdentifierArg: string | undefined, options: D
         showModel: true,
         model,
         worktreeCwd: worktreeRoot,
-        resumeSessionId,
       }
     );
   } catch (error) {
@@ -661,8 +662,6 @@ interface SingleProjectOptions {
   model: string;
   /** Worktree root directory. When set, Claude runs with cwd in the worktree. */
   worktreeCwd?: string;
-  /** Session ID to resume an interrupted Claude session. Only applies to the first pending task. */
-  resumeSessionId?: string;
 }
 
 async function executeSingleProject(
@@ -670,8 +669,7 @@ async function executeSingleProject(
   projectName: string,
   options: SingleProjectOptions
 ): Promise<ProjectExecutionResult> {
-  const { timeout, verbose, debug, force, maxRetries, autoCommit, showModel, model, worktreeCwd, resumeSessionId } = options;
-  let activeResumeSessionId = resumeSessionId;
+  const { timeout, verbose, debug, force, maxRetries, autoCommit, showModel, model, worktreeCwd } = options;
 
   if (!validatePlansExist(projectPath)) {
     return {
@@ -717,6 +715,13 @@ async function executeSingleProject(
   shutdownHandler.init();
   shutdownHandler.registerClaudeRunner(claudeRunner);
 
+  // Initialize token tracker for usage reporting
+  const tokenTracker = new TokenTracker();
+
+  // Set up runtime verbose toggle (Tab key to toggle during execution)
+  const verboseToggle = new VerboseToggle(verbose);
+  shutdownHandler.onShutdown(() => verboseToggle.stop());
+
   // Start project timer
   const projectStartTime = Date.now();
 
@@ -822,6 +827,9 @@ async function executeSingleProject(
     return lines.join('\n');
   }
 
+  // Start verbose toggle listener (Tab key)
+  verboseToggle.start();
+
   let task = getNextTaskToProcess(state);
 
   while (task) {
@@ -868,17 +876,13 @@ async function executeSingleProject(
       logger.setContext(taskContext);
 
       // Log task execution status
-      if (activeResumeSessionId) {
-        logger.info(`Resuming task ${taskLabel} with session ${activeResumeSessionId}`);
-      } else if (task.status === 'failed') {
+      if (task.status === 'failed') {
         logger.info(`Retrying task ${taskLabel} (previously failed)...`);
       } else if (task.status === 'completed' && force) {
         logger.info(`Re-running task ${taskLabel} (force mode)...`);
       } else {
         logger.info(`Executing task ${taskLabel}...`);
       }
-    } else if (activeResumeSessionId) {
-      logger.info(`Resuming task ${task.id} with session ${activeResumeSessionId}`);
     }
 
     // Get previous outcomes for context
@@ -901,6 +905,7 @@ async function executeSingleProject(
     let attempts = 0;
     let lastOutput = '';
     let failureReason = '';
+    let lastUsageData: import('../types/config.js').UsageData | undefined;
     // Track failure history for each attempt (attempt number -> reason)
     const failureHistory: Array<{ attempt: number; reason: string }> = [];
 
@@ -950,17 +955,23 @@ async function executeSingleProject(
       } : undefined;
 
       // Run Claude (use worktree root as cwd if in worktree mode)
-      let result;
-      if (activeResumeSessionId && attempts === 1) {
-        // Resume mode: use --resume flag instead of normal prompt execution
-        result = await claudeRunner.runResume(activeResumeSessionId, { timeout, outcomeFilePath, commitContext, cwd: worktreeCwd, effortLevel: 'medium' });
-      } else {
-        result = verbose
-          ? await claudeRunner.runVerbose(prompt, { timeout, outcomeFilePath, commitContext, cwd: worktreeCwd, effortLevel: 'medium' })
-          : await claudeRunner.run(prompt, { timeout, outcomeFilePath, commitContext, cwd: worktreeCwd, effortLevel: 'medium' });
-      }
+      const executeEffort = getEffort('execute');
+      const runnerOptions = {
+        timeout,
+        outcomeFilePath,
+        commitContext,
+        cwd: worktreeCwd,
+        effortLevel: executeEffort,
+        verboseCheck: () => verboseToggle.isVerbose,
+      };
+      const result = verbose
+        ? await claudeRunner.runVerbose(prompt, runnerOptions)
+        : await claudeRunner.run(prompt, runnerOptions);
 
       lastOutput = result.output;
+      if (result.usageData) {
+        lastUsageData = result.usageData;
+      }
 
       // Parse result
       const parsed = parseOutput(result.output);
@@ -1075,6 +1086,13 @@ Task completed. No detailed report provided.
         // Minimal mode: show completed task line
         logger.info(formatTaskProgress(taskNumber, totalTasks, 'completed', displayName, elapsedMs, task.id));
       }
+
+      // Track and display token usage for this task
+      if (lastUsageData) {
+        const entry = tokenTracker.addTask(task.id, lastUsageData);
+        logger.dim(formatTaskTokenSummary(entry.usage, entry.cost));
+      }
+
       completedInSession.add(task.id);
     } else {
       // Stash any uncommitted changes on complete failure
@@ -1096,6 +1114,12 @@ Task completed. No detailed report provided.
         logger.info(formatTaskProgress(taskNumber, totalTasks, 'failed', displayName, elapsedMs, task.id));
       }
 
+      // Track token usage even for failed tasks (partial data still useful for totals)
+      if (lastUsageData) {
+        const entry = tokenTracker.addTask(task.id, lastUsageData);
+        logger.dim(formatTaskTokenSummary(entry.usage, entry.cost));
+      }
+
       // Analyze failure and generate structured report
       const analysisReport = await analyzeFailure(lastOutput, failureReason, task.id);
 
@@ -1120,9 +1144,6 @@ ${stashName ? `- Stash: ${stashName}` : ''}
       logger.newline();
     }
 
-    // Clear resume flag after first task — subsequent tasks use normal execution
-    activeResumeSessionId = undefined;
-
     // Clear context before next task
     logger.clearContext();
 
@@ -1133,6 +1154,9 @@ ${stashName ? `- Stash: ${stashName}` : ''}
     task = getNextTaskToProcess(state);
   }
 
+  // Stop verbose toggle listener before summary output
+  verboseToggle.stop();
+
   // Ensure context is cleared for summary
   logger.clearContext();
 
@@ -1201,6 +1225,14 @@ ${stashName ? `- Stash: ${stashName}` : ''}
     }
   }
 
+  // Show token usage summary if any tasks reported usage data
+  const trackerEntries = tokenTracker.getEntries();
+  if (trackerEntries.length > 0) {
+    logger.newline();
+    const totals = tokenTracker.getTotals();
+    logger.dim(formatTokenTotalSummary(totals.usage, totals.cost));
+  }
+
   // Show retry history for tasks that had failures (even if eventually successful)
   if (projectRetryHistory.length > 0) {
     logger.newline();

package/src/commands/plan.ts

@@ -15,6 +15,7 @@ import {
   resolveModelOption,
 } from '../utils/validation.js';
 import { logger } from '../utils/logger.js';
+import { getWorktreeDefault } from '../utils/config.js';
 import { generateProjectNames } from '../utils/name-generator.js';
 import { pickProjectName } from '../ui/name-picker.js';
 import {
@@ -73,14 +74,14 @@ export function createPlanCommand(): Command {
       // Validate and resolve model option
       let model: string;
       try {
-        model = resolveModelOption(options.model, options.sonnet);
+        model = resolveModelOption(options.model, options.sonnet, 'plan');
       } catch (error) {
         logger.error((error as Error).message);
         process.exit(1);
       }
 
       const autoMode = options.auto ?? false;
-      const worktreeMode = options.worktree ?? false;
+      const worktreeMode = options.worktree ?? getWorktreeDefault();
 
       if (options.amend) {
         if (!projectName) {