rafcode 2.5.1-0 → 3.0.0

package/src/types/config.ts

@@ -1,12 +1,25 @@
+/** CLI harness provider */
+export type HarnessProvider = 'claude' | 'codex';
+
 /** Short alias for a Claude model family */
 export type ClaudeModelAlias = 'sonnet' | 'haiku' | 'opus';
 
+/** Short alias for a Codex model family */
+export type CodexModelAlias = 'spark' | 'codex' | 'gpt54';
+
+/** Provider-agnostic model alias (union of all provider aliases) */
+export type ModelAlias = ClaudeModelAlias | CodexModelAlias;
+
 /**
  * Accepts short aliases (`sonnet`, `haiku`, `opus`) or full model IDs
  * matching the pattern `claude-{family}-{version}` (e.g., `claude-opus-4-5-20251101`).
+ * Also accepts harness-prefixed format: `claude/opus`, `codex/gpt-5.4`.
  */
 export type ClaudeModelName = ClaudeModelAlias | (string & { __brand?: 'FullModelId' });
 
+/** Provider-agnostic model name — accepts any alias, full ID, or harness-prefixed format */
+export type ModelName = string & { __brand?: 'ModelName' };
+
 /** Task complexity label for per-task effort frontmatter. Maps to models via effortMapping. */
 export type TaskEffortLevel = 'low' | 'medium' | 'high';
 
@@ -46,9 +59,15 @@ export interface DisplayConfig {
 }
 
 export interface RafConfig {
+  /** CLI harness provider. Default: 'claude' */
+  provider: HarnessProvider;
   models: ModelsConfig;
   /** Maps task complexity labels (low/medium/high) to models. Used for per-task effort frontmatter. */
   effortMapping: EffortMappingConfig;
+  /** Codex model assignments per scenario */
+  codexModels: ModelsConfig;
+  /** Maps task complexity labels to Codex models */
+  codexEffortMapping: EffortMappingConfig;
   timeout: number;
   maxRetries: number;
   autoCommit: boolean;
@@ -60,6 +79,7 @@ export interface RafConfig {
 }
 
 export const DEFAULT_CONFIG: RafConfig = {
+  provider: 'claude',
   models: {
     plan: 'opus',
     execute: 'opus',
@@ -73,6 +93,19 @@ export const DEFAULT_CONFIG: RafConfig = {
     medium: 'opus',
     high: 'opus',
   },
+  codexModels: {
+    plan: 'gpt-5.3-codex',
+    execute: 'gpt-5.4',
+    nameGeneration: 'gpt-5.3-codex-spark',
+    failureAnalysis: 'gpt-5.3-codex-spark',
+    prGeneration: 'gpt-5.3-codex',
+    config: 'gpt-5.3-codex',
+  },
+  codexEffortMapping: {
+    low: 'gpt-5.3-codex-spark',
+    medium: 'gpt-5.3-codex',
+    high: 'gpt-5.4',
+  },
   timeout: 60,
   maxRetries: 3,
   autoCommit: true,
@@ -98,6 +131,10 @@ export type UserConfig = DeepPartial<RafConfig>;
 
 export const VALID_MODEL_ALIASES: readonly ClaudeModelAlias[] = ['sonnet', 'haiku', 'opus'];
 
+export const VALID_CODEX_MODEL_ALIASES: readonly CodexModelAlias[] = ['spark', 'codex', 'gpt54'];
+
+export const VALID_HARNESS_PROVIDERS: readonly HarnessProvider[] = ['claude', 'codex'];
+
 /**
  * Regex for full Claude model IDs (e.g., `claude-sonnet-4-5-20250929`, `claude-opus-4-5-20251101`).
  * Pattern: claude-{family}-{major}(-{minor})?(-{date})?
@@ -122,6 +159,7 @@ export interface PlanCommandOptions {
   projectName?: string;
   model?: ClaudeModelName;
   sonnet?: boolean;
+  provider?: HarnessProvider;
 }
 
 export interface DoCommandOptions {
@@ -132,6 +170,7 @@ export interface DoCommandOptions {
   model?: ClaudeModelName;
   sonnet?: boolean;
   worktree?: boolean;
+  provider?: HarnessProvider;
 }
 
 export interface StatusCommandOptions {

package/src/ui/project-picker.ts

@@ -1,6 +1,7 @@
 import { select } from '@inquirer/prompts';
 import { discoverProjects, deriveProjectState, getDerivedStats } from '../core/state-derivation.js';
 import { extractProjectNumber, extractProjectName, parseProjectPrefix, formatProjectNumber } from '../utils/paths.js';
+
 import { listWorktreeProjects, computeWorktreePath } from '../core/worktree.js';
 import * as fs from 'node:fs';
 import * as path from 'node:path';

package/src/utils/config.ts

@@ -7,6 +7,8 @@ import {
   DEFAULT_RAF_CONFIG,
   UserConfig,
   VALID_MODEL_ALIASES,
+  VALID_CODEX_MODEL_ALIASES,
+  VALID_HARNESS_PROVIDERS,
   FULL_MODEL_ID_PATTERN,
   ClaudeModelName,
   TaskEffortLevel,
@@ -14,6 +16,7 @@ import {
   CommitFormatType,
   DisplayConfig,
   EffortMappingConfig,
+  HarnessProvider,
 } from '../types/config.js';
 
 const CONFIG_DIR = path.join(os.homedir(), '.raf');
@@ -33,7 +36,8 @@ export function getClaudeSettingsPath(): string {
 // ---- Validation ----
 
 const VALID_TOP_LEVEL_KEYS = new Set<string>([
-  'models', 'effortMapping', 'timeout', 'maxRetries', 'autoCommit',
+  'provider', 'models', 'effortMapping', 'codexModels', 'codexEffortMapping',
+  'timeout', 'maxRetries', 'autoCommit',
   'worktree', 'syncMainBranch', 'commitFormat', 'display',
 ]);
 
@@ -62,11 +66,64 @@ function checkUnknownKeys(obj: Record<string, unknown>, validKeys: Set<string>,
   }
 }
 
+/** Regex for raw Codex model IDs (e.g., `gpt-5.4`, `gpt-5.3-codex-spark`). Requires dot-separated version. */
+const CODEX_MODEL_ID_PATTERN = /^gpt-\d+\.\d+(-.+)*$/;
+
 /**
- * Check whether a string is a valid model name — either a short alias or a full model ID.
+ * Check whether a string is a valid model name.
+ * Accepts:
+ * - Claude short aliases: sonnet, haiku, opus
+ * - Claude full IDs: claude-opus-4-6
+ * - Codex short aliases: spark, codex, gpt54
+ * - Raw Codex model IDs: gpt-5.4, gpt-5.3-codex-spark
+ * - Harness-prefixed format: claude/opus, codex/gpt-5.4
  */
 export function isValidModelName(value: string): boolean {
-  return (VALID_MODEL_ALIASES as readonly string[]).includes(value) || FULL_MODEL_ID_PATTERN.test(value);
+  // Harness-prefixed format: provider/model
+  const prefixMatch = value.match(/^(claude|codex)\/(.+)$/);
+  if (prefixMatch) {
+    const [, provider, model] = prefixMatch;
+    if (provider === 'claude') {
+      return (VALID_MODEL_ALIASES as readonly string[]).includes(model!) || FULL_MODEL_ID_PATTERN.test(model!);
+    }
+    if (provider === 'codex') {
+      return (VALID_CODEX_MODEL_ALIASES as readonly string[]).includes(model!) || CODEX_MODEL_ID_PATTERN.test(model!);
+    }
+  }
+
+  // Unprefixed: Claude aliases and full IDs
+  if ((VALID_MODEL_ALIASES as readonly string[]).includes(value) || FULL_MODEL_ID_PATTERN.test(value)) {
+    return true;
+  }
+
+  // Unprefixed: Codex aliases and raw IDs
+  if ((VALID_CODEX_MODEL_ALIASES as readonly string[]).includes(value) || CODEX_MODEL_ID_PATTERN.test(value)) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Parse a model spec string into its provider and model components.
+ * - `codex/gpt-5.4` -> { provider: 'codex', model: 'gpt-5.4' }
+ * - `claude/opus` -> { provider: 'claude', model: 'opus' }
+ * - `opus` -> { provider: 'claude', model: 'opus' } (defaults to claude)
+ * - `gpt-5.4` -> { provider: 'codex', model: 'gpt-5.4' } (inferred from model format)
+ */
+export function parseModelSpec(modelSpec: string): { provider: HarnessProvider; model: string } {
+  const prefixMatch = modelSpec.match(/^(claude|codex)\/(.+)$/);
+  if (prefixMatch) {
+    return { provider: prefixMatch[1] as HarnessProvider, model: prefixMatch[2]! };
+  }
+
+  // Infer provider from model format
+  if ((VALID_CODEX_MODEL_ALIASES as readonly string[]).includes(modelSpec) || CODEX_MODEL_ID_PATTERN.test(modelSpec)) {
+    return { provider: 'codex', model: modelSpec };
+  }
+
+  // Default to claude
+  return { provider: 'claude', model: modelSpec };
 }
 
 export function validateConfig(config: unknown): UserConfig {
@@ -77,6 +134,13 @@ export function validateConfig(config: unknown): UserConfig {
   const obj = config as Record<string, unknown>;
   checkUnknownKeys(obj, VALID_TOP_LEVEL_KEYS, '');
 
+  // provider
+  if (obj.provider !== undefined) {
+    if (typeof obj.provider !== 'string' || !(VALID_HARNESS_PROVIDERS as readonly string[]).includes(obj.provider)) {
+      throw new ConfigValidationError(`provider must be one of: ${VALID_HARNESS_PROVIDERS.join(', ')}`);
+    }
+  }
+
   // models
   if (obj.models !== undefined) {
     if (typeof obj.models !== 'object' || obj.models === null || Array.isArray(obj.models)) {
@@ -109,6 +173,38 @@ export function validateConfig(config: unknown): UserConfig {
     }
   }
 
+  // codexModels
+  if (obj.codexModels !== undefined) {
+    if (typeof obj.codexModels !== 'object' || obj.codexModels === null || Array.isArray(obj.codexModels)) {
+      throw new ConfigValidationError('codexModels must be an object');
+    }
+    const codexModels = obj.codexModels as Record<string, unknown>;
+    checkUnknownKeys(codexModels, VALID_MODEL_KEYS, 'codexModels');
+    for (const [key, val] of Object.entries(codexModels)) {
+      if (typeof val !== 'string' || !isValidModelName(val)) {
+        throw new ConfigValidationError(
+          `codexModels.${key} must be a valid model name (e.g., gpt-5.4, gpt-5.3-codex-spark)`
+        );
+      }
+    }
+  }
+
+  // codexEffortMapping
+  if (obj.codexEffortMapping !== undefined) {
+    if (typeof obj.codexEffortMapping !== 'object' || obj.codexEffortMapping === null || Array.isArray(obj.codexEffortMapping)) {
+      throw new ConfigValidationError('codexEffortMapping must be an object');
+    }
+    const codexEffortMapping = obj.codexEffortMapping as Record<string, unknown>;
+    checkUnknownKeys(codexEffortMapping, VALID_EFFORT_MAPPING_KEYS, 'codexEffortMapping');
+    for (const [key, val] of Object.entries(codexEffortMapping)) {
+      if (typeof val !== 'string' || !isValidModelName(val)) {
+        throw new ConfigValidationError(
+          `codexEffortMapping.${key} must be a valid model name (e.g., gpt-5.4, gpt-5.3-codex-spark)`
+        );
+      }
+    }
+  }
+
   // timeout
   if (obj.timeout !== undefined) {
     if (typeof obj.timeout !== 'number' || obj.timeout <= 0 || !Number.isFinite(obj.timeout)) {
@@ -180,12 +276,19 @@ export function validateConfig(config: unknown): UserConfig {
 function deepMerge(defaults: RafConfig, overrides: UserConfig): RafConfig {
   const result = { ...defaults };
 
+  if (overrides.provider !== undefined) result.provider = overrides.provider;
   if (overrides.models) {
     result.models = { ...defaults.models, ...overrides.models };
   }
   if (overrides.effortMapping) {
     result.effortMapping = { ...defaults.effortMapping, ...overrides.effortMapping };
   }
+  if (overrides.codexModels) {
+    result.codexModels = { ...defaults.codexModels, ...overrides.codexModels };
+  }
+  if (overrides.codexEffortMapping) {
+    result.codexEffortMapping = { ...defaults.codexEffortMapping, ...overrides.codexEffortMapping };
+  }
   if (overrides.commitFormat) {
     result.commitFormat = { ...defaults.commitFormat, ...overrides.commitFormat };
   }
@@ -215,6 +318,8 @@ export function resolveConfig(configPath?: string): RafConfig {
       ...DEFAULT_CONFIG,
       models: { ...DEFAULT_CONFIG.models },
       effortMapping: { ...DEFAULT_CONFIG.effortMapping },
+      codexModels: { ...DEFAULT_CONFIG.codexModels },
+      codexEffortMapping: { ...DEFAULT_CONFIG.codexEffortMapping },
       commitFormat: { ...DEFAULT_CONFIG.commitFormat },
       display: { ...DEFAULT_CONFIG.display },
     };
@@ -260,22 +365,37 @@ export function resetConfigCache(): void {
   _cachedConfig = null;
 }
 
-export function getModel(scenario: ModelScenario): ClaudeModelName {
-  return getResolvedConfig().models[scenario];
+export function getModel(scenario: ModelScenario, provider?: HarnessProvider): ClaudeModelName {
+  const config = getResolvedConfig();
+  const effectiveProvider = provider ?? config.provider;
+  if (effectiveProvider === 'codex') {
+    return config.codexModels[scenario];
+  }
+  return config.models[scenario];
 }
 
 /**
  * Get the full effort mapping config.
  */
-export function getEffortMapping(): EffortMappingConfig {
-  return getResolvedConfig().effortMapping;
+export function getEffortMapping(provider?: HarnessProvider): EffortMappingConfig {
+  const config = getResolvedConfig();
+  const effectiveProvider = provider ?? config.provider;
+  if (effectiveProvider === 'codex') {
+    return config.codexEffortMapping;
+  }
+  return config.effortMapping;
 }
 
 /**
  * Resolve a task effort level to a model name using the effort mapping config.
  */
-export function resolveEffortToModel(effort: TaskEffortLevel): ClaudeModelName {
-  return getResolvedConfig().effortMapping[effort];
+export function resolveEffortToModel(effort: TaskEffortLevel, provider?: HarnessProvider): ClaudeModelName {
+  const config = getResolvedConfig();
+  const effectiveProvider = provider ?? config.provider;
+  if (effectiveProvider === 'codex') {
+    return config.codexEffortMapping[effort];
+  }
+  return config.effortMapping[effort];
 }
 
 /**
@@ -289,19 +409,35 @@ const MODEL_TIER_ORDER: Record<string, number> = {
   opus: 3,
 };
 
+/** Codex model tier ordering: spark (1) < codex (2) < gpt-5.4 (3) */
+const CODEX_MODEL_TIER_ORDER: Record<string, number> = {
+  spark: 1,
+  'gpt-5.3-codex-spark': 1,
+  codex: 2,
+  'gpt-5.3-codex': 2,
+  gpt54: 3,
+  'gpt-5.4': 3,
+};
+
 /**
  * Get the numeric tier of a model for comparison.
  * Extracts family from full model IDs (e.g., 'claude-opus-4-6' -> 3).
  * Unknown models default to highest tier (3) so they're never accidentally capped.
  */
 export function getModelTier(modelName: string): number {
-  // Check short aliases first
+  // Check Claude short aliases first
   const tier = MODEL_TIER_ORDER[modelName];
   if (tier !== undefined) {
     return tier;
   }
 
-  // Extract family from full model ID
+  // Check Codex model tiers
+  const codexTier = CODEX_MODEL_TIER_ORDER[modelName];
+  if (codexTier !== undefined) {
+    return codexTier;
+  }
+
+  // Extract family from full Claude model ID
   const match = modelName.match(/^claude-([a-z]+)-/);
   if (match && match[1]) {
     const familyTier = MODEL_TIER_ORDER[match[1]];
@@ -364,11 +500,19 @@ export function getSyncMainBranch(): boolean {
  * Returns the original string if no known alias can be extracted.
  */
 export function getModelShortName(modelId: string): string {
-  // Already a short alias
+  // Already a short Claude alias
   if (modelId === 'opus' || modelId === 'sonnet' || modelId === 'haiku') {
     return modelId;
   }
-  // Extract family from full model ID: claude-{family}-{version}
+  // Codex short aliases
+  if (modelId === 'spark' || modelId === 'codex' || modelId === 'gpt54') {
+    return modelId;
+  }
+  // Codex model IDs -> short names
+  if (modelId === 'gpt-5.3-codex-spark') return 'spark';
+  if (modelId === 'gpt-5.3-codex') return 'codex';
+  if (modelId === 'gpt-5.4') return 'gpt54';
+  // Extract family from full Claude model ID: claude-{family}-{version}
   const match = modelId.match(/^claude-([a-z]+)-/);
   if (match) {
     const family = match[1];
@@ -388,14 +532,26 @@ const MODEL_ALIAS_TO_FULL_ID: Record<string, string> = {
   opus: 'claude-opus-4-6',
   sonnet: 'claude-sonnet-4-5-20250929',
   haiku: 'claude-haiku-4-5-20251001',
+  spark: 'gpt-5.3-codex-spark',
+  codex: 'gpt-5.3-codex',
+  gpt54: 'gpt-5.4',
 };
 
 /**
  * Resolve a model name to its full model ID.
  * If already a full model ID, returns as-is.
- * If a short alias (opus, sonnet, haiku), returns the corresponding full ID.
+ * If a short alias, returns the corresponding full ID.
+ * Handles harness-prefixed format: strips prefix and resolves.
  */
 export function resolveFullModelId(modelName: string): string {
+  // Handle harness-prefixed format
+  const prefixMatch = modelName.match(/^(claude|codex)\/(.+)$/);
+  if (prefixMatch) {
+    const model = prefixMatch[2]!;
+    const fullId = MODEL_ALIAS_TO_FULL_ID[model];
+    return fullId ?? model;
+  }
+
   const fullId = MODEL_ALIAS_TO_FULL_ID[modelName];
   if (fullId) {
     return fullId;

package/src/utils/name-generator.ts

@@ -30,7 +30,7 @@ Rules:
 Project description:`;
 
 /**
- * Run Claude CLI with the given prompt and return stdout.
+ * Run the CLI with the given prompt and return stdout.
  * Uses spawn with --no-session-persistence to avoid cluttering session history.
  */
 function runClaudePrint(prompt: string): Promise<string | null> {
@@ -65,7 +65,7 @@ function runClaudePrint(prompt: string): Promise<string | null> {
       clearTimeout(timeoutHandle);
       if (exitCode !== 0) {
         if (stderr) {
-          logger.debug(`Claude CLI stderr: ${stderr}`);
+          logger.debug(`CLI stderr: ${stderr}`);
         }
         resolve(null);
       } else {
@@ -75,14 +75,14 @@ function runClaudePrint(prompt: string): Promise<string | null> {
 
     proc.on('error', (error) => {
       clearTimeout(timeoutHandle);
-      logger.debug(`Claude CLI spawn error: ${error}`);
+      logger.debug(`CLI spawn error: ${error}`);
       resolve(null);
     });
   });
 }
 
 /**
- * Generate a single project name using Claude.
+ * Generate a single project name using the LLM.
  * Falls back to extracting words from the description if the API call fails.
  */
 export async function generateProjectName(description: string): Promise<string> {
@@ -96,7 +96,7 @@ export async function generateProjectName(description: string): Promise<string>
       }
     }
   } catch (error) {
-    logger.debug(`Failed to generate name with Claude: ${error}`);
+    logger.debug(`Failed to generate name: ${error}`);
   }
 
   // Fallback to extracting words from description
@@ -104,7 +104,7 @@ export async function generateProjectName(description: string): Promise<string>
 }
 
 /**
- * Generate multiple project name suggestions using Claude.
+ * Generate multiple project name suggestions using the LLM.
  * Returns 3-5 unique names with varied styles.
  */
 export async function generateProjectNames(description: string): Promise<string[]> {
@@ -115,7 +115,7 @@ export async function generateProjectNames(description: string): Promise<string[
       return names;
     }
   } catch (error) {
-    logger.debug(`Failed to generate names with Claude: ${error}`);
+    logger.debug(`Failed to generate names: ${error}`);
   }
 
   // Fallback: generate a single fallback name
@@ -125,7 +125,7 @@ export async function generateProjectNames(description: string): Promise<string[
 }
 
 /**
- * Call Claude to generate a single project name.
+ * Call the LLM to generate a single project name.
  */
 async function callSonnetForName(description: string): Promise<string | null> {
   const fullPrompt = `${NAME_GENERATION_PROMPT}\n${description}`;
@@ -133,7 +133,7 @@ async function callSonnetForName(description: string): Promise<string | null> {
 }
 
 /**
- * Call Claude to generate multiple project names.
+ * Call the LLM to generate multiple project names.
  */
 async function callSonnetForMultipleNames(description: string): Promise<string[]> {
   const fullPrompt = `${MULTI_NAME_GENERATION_PROMPT}\n${description}`;