rafcode 3.0.0 → 3.8.0

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);

package/src/core/codex-runner.ts

@@ -4,6 +4,7 @@ import { execSync, spawn } from 'node:child_process';
 import { logger } from '../utils/logger.js';
 import { renderCodexStreamEvent } from '../parsers/codex-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';
@@ -36,9 +37,11 @@ export class CodexRunner implements ICliRunner {
   private activeProcess: pty.IPty | null = null;
   private killed = false;
   private model: string;
+  private reasoningEffort?: string;
 
   constructor(config: RunnerConfig = {}) {
-    this.model = config.model ?? getModel('execute', 'codex');
+    this.model = config.model ?? getModel('execute').model;
+    this.reasoningEffort = config.reasoningEffort;
   }
 
   /**
@@ -54,7 +57,14 @@ export class CodexRunner implements ICliRunner {
 
     return new Promise((resolve) => {
       const combinedPrompt = buildCombinedPrompt(systemPrompt, userMessage);
-      const args = ['-m', this.model, combinedPrompt];
+      const args = ['-m', this.model];
+
+      // Add reasoning effort via config override when configured
+      if (this.reasoningEffort) {
+        args.push('-c', `model_reasoning_effort="${this.reasoningEffort}"`);
+      }
+
+      args.push(combinedPrompt);
 
       logger.debug(`Starting interactive Codex session with model: ${this.model}`);
 
@@ -167,6 +177,7 @@ export class CodexRunner implements ICliRunner {
       let stderr = '';
       let timedOut = false;
       let contextOverflow = false;
+      let usageData: import('../types/config.js').UsageData | undefined;
 
       const codexPath = getCodexPath();
 
@@ -175,15 +186,23 @@ export class CodexRunner implements ICliRunner {
       logger.debug(`Codex path: ${codexPath}`);
 
       logger.debug('Spawning process...');
-      const proc = spawn(codexPath, [
+      const execArgs = [
         'exec',
         '--full-auto',
         '--json',
         '--ephemeral',
         '-m',
         this.model,
-        prompt,
-      ], {
+      ];
+
+      // Add reasoning effort via config override when configured
+      if (this.reasoningEffort) {
+        execArgs.push('-c', `model_reasoning_effort="${this.reasoningEffort}"`);
+      }
+
+      execArgs.push(prompt);
+
+      const proc = spawn(codexPath, execArgs, {
         cwd,
         env: process.env,
         stdio: ['ignore', 'pipe', 'pipe'],
@@ -244,6 +263,10 @@ export class CodexRunner implements ICliRunner {
             }
           }
 
+          if (rendered.usageData) {
+            usageData = mergeUsageData(usageData, rendered.usageData);
+          }
+
           if (shouldDisplay() && rendered.display) {
             process.stdout.write(rendered.display);
           }
@@ -262,6 +285,9 @@ export class CodexRunner implements ICliRunner {
           if (rendered.textContent) {
             output += rendered.textContent;
           }
+          if (rendered.usageData) {
+            usageData = mergeUsageData(usageData, rendered.usageData);
+          }
           if (shouldDisplay() && rendered.display) {
             process.stdout.write(rendered.display);
           }
@@ -281,8 +307,7 @@ export class CodexRunner implements ICliRunner {
           exitCode: exitCode ?? (this.killed ? 130 : 1),
           timedOut,
           contextOverflow,
-          // Codex does not provide usage data in the same format — omit gracefully
-          usageData: undefined,
+          usageData,
         });
       });
     });

package/src/core/failure-analyzer.ts

@@ -308,7 +308,8 @@ Respond with ONLY a markdown report in this exact format:
     const claudePath = getClaudePath();
 
     // Use configured model for failure analysis
-    const failureModel = getModel('failureAnalysis');
+    const failureEntry = getModel('failureAnalysis');
+    const failureModel = failureEntry.model;
     const proc = spawn(claudePath, [
       '--model', failureModel,
       '--no-session-persistence',

package/src/core/git.ts

@@ -1,4 +1,5 @@
 import { execSync } from 'node:child_process';
+import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { logger } from '../utils/logger.js';
 import { extractProjectNumber, extractProjectName } from '../utils/paths.js';
@@ -213,10 +214,56 @@ export function isFileCommittedInHead(filePath: string): boolean {
   }
 }
 
+/**
+ * Extract a concise description from input.md for use in plan commit messages.
+ * Reads the first non-empty line and truncates to ~70 chars.
+ * Falls back to the project name if input.md can't be read.
+ */
+function extractPlanDescription(projectPath: string, fallback: string): string {
+  const inputPath = path.join(projectPath, 'input.md');
+  try {
+    const content = fs.readFileSync(inputPath, 'utf-8');
+    const firstLine = content.split('\n').find(line => line.trim().length > 0);
+    if (firstLine) {
+      // Strip leading markdown markers (-, *, [ ], [x], #, etc.)
+      let cleaned = firstLine.trim().replace(/^[-*#>\s]*(\[.\]\s*)?/, '').trim();
+      if (cleaned.length > 70) {
+        cleaned = cleaned.substring(0, 67) + '...';
+      }
+      if (cleaned.length > 0) {
+        return cleaned;
+      }
+    }
+  } catch {
+    // Can't read input.md, use fallback
+  }
+  return fallback;
+}
+
+/**
+ * Generate a description for amend commit messages.
+ * Uses the count and names of additional plan files if provided.
+ */
+function extractAmendDescription(additionalFiles?: string[]): string {
+  if (!additionalFiles || additionalFiles.length === 0) {
+    return 'updated plans';
+  }
+  // Extract task names from plan file paths (e.g., "plans/3-fix-bug.md" → "fix-bug")
+  const taskNames = additionalFiles
+    .map(f => path.basename(f, '.md'))
+    .map(name => name.replace(/^\d+-/, ''))
+    .filter(name => name.length > 0);
+
+  if (taskNames.length <= 3) {
+    return taskNames.join(', ');
+  }
+  return `${taskNames.length} tasks`;
+}
+
 /**
  * Commit planning artifacts (input.md and decisions.md) for a project.
- * Uses commit message format: RAF[NNN] Plan: project-name
- * For amendments: RAF[NNN] Amend: project-name
+ * Uses commit message format: RAF[project-name] Plan: description
+ * For amendments: RAF[project-name] Amend: description
  *
  * @param projectPath - Full path to the project folder (e.g., /path/to/RAF/017-decision-vault)
  * @param options - Optional settings
@@ -254,10 +301,17 @@ export async function commitPlanningArtifacts(projectPath: string, options?: { c
   const formatType = options?.isAmend ? 'amend' as const : 'plan' as const;
   const template = getCommitFormat(formatType);
   const commitPrefix = getCommitPrefix();
+
+  // Auto-generate description based on commit type
+  const description = options?.isAmend
+    ? extractAmendDescription(options?.additionalFiles)
+    : extractPlanDescription(projectPath, projectName);
+
   const commitMessage = renderCommitMessage(template, {
     prefix: commitPrefix,
-    projectId: projectNumber,
+    projectId: projectName,  // backwards compat: {projectId} resolves to projectName
     projectName,
+    description,
   });
 
   // Build list of files to stage (absolute paths)

package/src/core/project-manager.ts

@@ -12,6 +12,7 @@ import {
   getInputPath,
   listProjects,
   TASK_ID_PATTERN,
+  numericFileSort,
 } from '../utils/paths.js';
 import { sanitizeProjectName } from '../utils/validation.js';
 import { logger } from '../utils/logger.js';
@@ -143,7 +144,7 @@ export class ProjectManager {
     }
 
     const outcomes: Array<{ taskId: string; content: string }> = [];
-    const files = fs.readdirSync(outcomesDir).filter((f) => f.endsWith('.md')).sort();
+    const files = fs.readdirSync(outcomesDir).filter((f) => f.endsWith('.md')).sort(numericFileSort);
 
     for (const file of files) {
       const match = file.match(new RegExp(`^(${TASK_ID_PATTERN})-`));

package/src/core/pull-request.ts

@@ -3,8 +3,8 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { logger } from '../utils/logger.js';
-import { getModel, getModelShortName } from '../utils/config.js';
-import { extractProjectName, getInputPath, getDecisionsPath, getOutcomesDir, TASK_ID_PATTERN } from '../utils/paths.js';
+import { formatModelDisplay, getModel } from '../utils/config.js';
+import { extractProjectName, getInputPath, getDecisionsPath, getOutcomesDir, TASK_ID_PATTERN, numericFileSort } from '../utils/paths.js';
 
 export interface PrCreateResult {
   success: boolean;
@@ -208,7 +208,7 @@ export function readProjectContext(projectPath: string): {
 
   const outcomesDir = getOutcomesDir(projectPath);
   if (fs.existsSync(outcomesDir)) {
-    const files = fs.readdirSync(outcomesDir).filter(f => f.endsWith('.md')).sort();
+    const files = fs.readdirSync(outcomesDir).filter(f => f.endsWith('.md')).sort(numericFileSort);
     const taskIdPattern = new RegExp(`^(${TASK_ID_PATTERN})-`);
     for (const file of files) {
       const match = file.match(taskIdPattern);
@@ -279,7 +279,7 @@ Respond with ONLY the PR body in this exact format (no extra text, no code fence
 [1-3 bullet points describing how to verify these changes work correctly]`;
 
   try {
-    const prModel = getModelShortName(getModel('prGeneration'));
+    const prModel = formatModelDisplay(getModel('prGeneration').model);
     logger.info(`Generating PR with ${prModel}...`);
     const body = await callClaudeForPrBody(prompt, timeoutMs);
     return body;
@@ -365,7 +365,7 @@ async function callClaudeForPrBody(prompt: string, timeoutMs: number): Promise<s
     let output = '';
     let stderr = '';
 
-    const prModel = getModel('prGeneration');
+    const prModel = getModel('prGeneration').model;
     const proc = spawn(claudePath, [
       '--model', prModel,
       '--no-session-persistence',

package/src/core/runner-factory.ts

@@ -1,35 +1,35 @@
-import type { HarnessProvider } from '../types/config.js';
+import type { HarnessName } from '../types/config.js';
 import type { ICliRunner } from './runner-interface.js';
 import type { RunnerConfig } from './runner-types.js';
 import { ClaudeRunner } from './claude-runner.js';
 import { CodexRunner } from './codex-runner.js';
 
 /**
- * Create a CLI runner for the given provider configuration.
+ * Create a CLI runner for the given harness configuration.
  */
 export function createRunner(config: RunnerConfig = {}): ICliRunner {
-  const provider = config.provider ?? 'claude';
+  const harness = config.harness ?? 'claude';
 
-  switch (provider) {
+  switch (harness) {
     case 'claude':
       return new ClaudeRunner(config);
     case 'codex':
       return new CodexRunner(config);
     default:
-      throw new Error(`Unknown provider: ${provider}`);
+      throw new Error(`Unknown harness: ${harness}`);
   }
 }
 
 /**
- * Get the binary name for a given provider.
+ * Get the binary name for a given harness.
  */
-export function getProviderBinaryName(provider: HarnessProvider): string {
-  switch (provider) {
+export function getHarnessBinaryName(harness: HarnessName): string {
+  switch (harness) {
     case 'claude':
       return 'claude';
     case 'codex':
       return 'codex';
     default:
-      throw new Error(`Unknown provider: ${provider}`);
+      throw new Error(`Unknown harness: ${harness}`);
   }
 }

package/src/core/runner-interface.ts

@@ -1,7 +1,7 @@
 import type { RunnerOptions, RunResult } from './runner-types.js';
 
 /**
- * Provider-agnostic CLI runner interface.
+ * Harness-agnostic CLI runner interface.
  * Both ClaudeRunner and CodexRunner implement this interface.
  */
 export interface ICliRunner {

package/src/core/runner-types.ts

@@ -1,4 +1,4 @@
-import type { UsageData, HarnessProvider } from '../types/config.js';
+import type { UsageData, HarnessName } from '../types/config.js';
 
 /**
  * Options for a single runner execution (run, runVerbose, runInteractive, etc.).
@@ -52,14 +52,27 @@ export interface RunnerOptions {
 export interface RunnerConfig {
   /**
    * Model to use (e.g., opus, sonnet, haiku, gpt-5.4).
-   * Default: provider-specific default.
+   * Default: harness-specific default.
    */
   model?: string;
   /**
-   * CLI provider to use.
+   * CLI harness to use.
    * Default: 'claude'.
    */
-  provider?: HarnessProvider;
+  harness?: HarnessName;
+  /**
+   * Reasoning effort level to pass to the CLI.
+   * Claude CLI: --effort <level>
+   * Codex CLI: -c model_reasoning_effort="<level>"
+   * Only included when explicitly set.
+   */
+  reasoningEffort?: string;
+  /**
+   * Enable fast mode for faster output.
+   * Claude CLI: --settings '{"fastMode": true}'
+   * Only included when explicitly set to true.
+   */
+  fast?: boolean;
 }
 
 /**

package/src/core/state-derivation.ts

@@ -1,6 +1,6 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { getPlansDir, getOutcomesDir, getInputPath, TASK_ID_PATTERN } from '../utils/paths.js';
+import { getPlansDir, getOutcomesDir, getInputPath, TASK_ID_PATTERN, numericFileSort } from '../utils/paths.js';
 import { parsePlanFrontmatter, type PlanFrontmatter } from '../utils/frontmatter.js';
 
 export type DerivedTaskStatus = 'pending' | 'completed' | 'failed' | 'blocked';
@@ -198,14 +198,14 @@ export function deriveProjectState(projectPath: string): DerivedProjectState {
 
   const planFiles = fs.readdirSync(plansDir)
     .filter((f) => f.endsWith('.md'))
-    .sort();
+    .sort(numericFileSort);
 
   // Build a map of outcome statuses
   const outcomeStatuses = new Map<string, DerivedTaskStatus>();
   if (fs.existsSync(outcomesDir)) {
     const outcomeFiles = fs.readdirSync(outcomesDir)
       .filter((f) => f.endsWith('.md'))
-      .sort();
+      .sort(numericFileSort);
 
     for (const outcomeFile of outcomeFiles) {
       const match = outcomeFile.match(new RegExp(`^(${TASK_ID_PATTERN})-`));