rafcode 2.4.0 → 2.5.0-0

package/tests/unit/config.test.ts

@@ -25,9 +25,6 @@ import {
   saveConfig,
   renderCommitMessage,
   isValidModelName,
-  resolveModelPricingCategory,
-  getPricing,
-  getPricingConfig,
 } from '../../src/utils/config.js';
 import { DEFAULT_CONFIG } from '../../src/types/config.js';
 
@@ -538,97 +535,6 @@ describe('Config', () => {
     });
   });
 
-  describe('validateConfig - pricing', () => {
-    it('should accept valid pricing config', () => {
-      expect(() => validateConfig({
-        pricing: {
-          opus: { inputPerMTok: 15, outputPerMTok: 75 },
-        },
-      })).not.toThrow();
-    });
-
-    it('should accept partial pricing override', () => {
-      expect(() => validateConfig({
-        pricing: {
-          haiku: { outputPerMTok: 4 },
-        },
-      })).not.toThrow();
-    });
-
-    it('should reject non-object pricing', () => {
-      expect(() => validateConfig({ pricing: 'expensive' })).toThrow('pricing must be an object');
-    });
-
-    it('should reject unknown pricing categories', () => {
-      expect(() => validateConfig({ pricing: { gpt4: { inputPerMTok: 10 } } })).toThrow('Unknown config key: pricing.gpt4');
-    });
-
-    it('should reject non-object category value', () => {
-      expect(() => validateConfig({ pricing: { opus: 'expensive' } })).toThrow('pricing.opus must be an object');
-    });
-
-    it('should reject unknown pricing fields', () => {
-      expect(() => validateConfig({ pricing: { opus: { unknownField: 5 } } })).toThrow('Unknown config key: pricing.opus.unknownField');
-    });
-
-    it('should reject negative pricing values', () => {
-      expect(() => validateConfig({ pricing: { opus: { inputPerMTok: -1 } } })).toThrow('pricing.opus.inputPerMTok must be a non-negative number');
-    });
-
-    it('should reject non-number pricing values', () => {
-      expect(() => validateConfig({ pricing: { opus: { inputPerMTok: 'fifteen' } } })).toThrow('pricing.opus.inputPerMTok must be a non-negative number');
-    });
-
-    it('should accept zero pricing values', () => {
-      expect(() => validateConfig({ pricing: { haiku: { inputPerMTok: 0 } } })).not.toThrow();
-    });
-
-    it('should reject Infinity pricing values', () => {
-      expect(() => validateConfig({ pricing: { opus: { inputPerMTok: Infinity } } })).toThrow('must be a non-negative number');
-    });
-  });
-
-  describe('resolveModelPricingCategory', () => {
-    it('should map short aliases directly', () => {
-      expect(resolveModelPricingCategory('opus')).toBe('opus');
-      expect(resolveModelPricingCategory('sonnet')).toBe('sonnet');
-      expect(resolveModelPricingCategory('haiku')).toBe('haiku');
-    });
-
-    it('should extract family from full model IDs', () => {
-      expect(resolveModelPricingCategory('claude-opus-4-6')).toBe('opus');
-      expect(resolveModelPricingCategory('claude-sonnet-4-5-20250929')).toBe('sonnet');
-      expect(resolveModelPricingCategory('claude-haiku-4-5-20251001')).toBe('haiku');
-    });
-
-    it('should return null for unknown model families', () => {
-      expect(resolveModelPricingCategory('claude-unknown-3-0')).toBeNull();
-      expect(resolveModelPricingCategory('gpt-4')).toBeNull();
-      expect(resolveModelPricingCategory('')).toBeNull();
-    });
-  });
-
-  describe('resolveConfig - pricing', () => {
-    it('should include default pricing when no config file', () => {
-      const config = resolveConfig(path.join(tempDir, 'nonexistent.json'));
-      expect(config.pricing.opus.inputPerMTok).toBe(15);
-      expect(config.pricing.sonnet.inputPerMTok).toBe(3);
-      expect(config.pricing.haiku.inputPerMTok).toBe(1);
-    });
-
-    it('should deep-merge partial pricing override', () => {
-      const configPath = path.join(tempDir, 'pricing.json');
-      fs.writeFileSync(configPath, JSON.stringify({
-        pricing: { opus: { inputPerMTok: 10 } },
-      }));
-
-      const config = resolveConfig(configPath);
-      expect(config.pricing.opus.inputPerMTok).toBe(10);
-      expect(config.pricing.opus.outputPerMTok).toBe(75); // default preserved
-      expect(config.pricing.sonnet.inputPerMTok).toBe(3); // default preserved
-    });
-  });
-
   describe('getModelShortName', () => {
     it('should return short aliases as-is', () => {
       expect(getModelShortName('opus')).toBe('opus');
@@ -709,7 +615,6 @@ describe('Config', () => {
     it('should accept valid display config', () => {
       expect(() => validateConfig({
         display: {
-          showRateLimitEstimate: true,
           showCacheTokens: false,
         },
       })).not.toThrow();
@@ -717,7 +622,7 @@ describe('Config', () => {
 
     it('should accept partial display override', () => {
       expect(() => validateConfig({
-        display: { showRateLimitEstimate: false },
+        display: { showCacheTokens: false },
       })).not.toThrow();
     });
 
@@ -730,78 +635,31 @@ describe('Config', () => {
     });
 
     it('should reject non-boolean display values', () => {
-      expect(() => validateConfig({ display: { showRateLimitEstimate: 'yes' } })).toThrow('display.showRateLimitEstimate must be a boolean');
-    });
-  });
-
-  describe('validateConfig - rateLimitWindow', () => {
-    it('should accept valid rateLimitWindow config', () => {
-      expect(() => validateConfig({
-        rateLimitWindow: { sonnetTokenCap: 100000 },
-      })).not.toThrow();
-    });
-
-    it('should reject non-object rateLimitWindow', () => {
-      expect(() => validateConfig({ rateLimitWindow: 88000 })).toThrow('rateLimitWindow must be an object');
-    });
-
-    it('should reject unknown rateLimitWindow keys', () => {
-      expect(() => validateConfig({ rateLimitWindow: { unknownKey: 50000 } })).toThrow('Unknown config key: rateLimitWindow.unknownKey');
-    });
-
-    it('should reject non-positive sonnetTokenCap', () => {
-      expect(() => validateConfig({ rateLimitWindow: { sonnetTokenCap: 0 } })).toThrow('rateLimitWindow.sonnetTokenCap must be a positive number');
-      expect(() => validateConfig({ rateLimitWindow: { sonnetTokenCap: -100 } })).toThrow('rateLimitWindow.sonnetTokenCap must be a positive number');
-    });
-
-    it('should reject non-number sonnetTokenCap', () => {
-      expect(() => validateConfig({ rateLimitWindow: { sonnetTokenCap: '88000' } })).toThrow('rateLimitWindow.sonnetTokenCap must be a positive number');
+      expect(() => validateConfig({ display: { showCacheTokens: 'yes' } })).toThrow('display.showCacheTokens must be a boolean');
     });
   });
 
-  describe('resolveConfig - display and rateLimitWindow', () => {
+  describe('resolveConfig - display', () => {
     it('should include default display when no config file', () => {
       const config = resolveConfig(path.join(tempDir, 'nonexistent.json'));
-      expect(config.display.showRateLimitEstimate).toBe(true);
       expect(config.display.showCacheTokens).toBe(true);
     });
 
-    it('should include default rateLimitWindow when no config file', () => {
-      const config = resolveConfig(path.join(tempDir, 'nonexistent.json'));
-      expect(config.rateLimitWindow.sonnetTokenCap).toBe(88000);
-    });
-
     it('should deep-merge partial display override', () => {
       const configPath = path.join(tempDir, 'display.json');
       fs.writeFileSync(configPath, JSON.stringify({
-        display: { showRateLimitEstimate: false },
+        display: { showCacheTokens: false },
       }));
 
       const config = resolveConfig(configPath);
-      expect(config.display.showRateLimitEstimate).toBe(false);
-      expect(config.display.showCacheTokens).toBe(true); // default preserved
-    });
-
-    it('should deep-merge partial rateLimitWindow override', () => {
-      const configPath = path.join(tempDir, 'rateLimit.json');
-      fs.writeFileSync(configPath, JSON.stringify({
-        rateLimitWindow: { sonnetTokenCap: 100000 },
-      }));
-
-      const config = resolveConfig(configPath);
-      expect(config.rateLimitWindow.sonnetTokenCap).toBe(100000);
+      expect(config.display.showCacheTokens).toBe(false);
     });
   });
 
-  describe('DEFAULT_CONFIG - display and rateLimitWindow', () => {
+  describe('DEFAULT_CONFIG - display', () => {
     it('should have default display settings', () => {
-      expect(DEFAULT_CONFIG.display.showRateLimitEstimate).toBe(true);
       expect(DEFAULT_CONFIG.display.showCacheTokens).toBe(true);
     });
-
-    it('should have default rateLimitWindow settings', () => {
-      expect(DEFAULT_CONFIG.rateLimitWindow.sonnetTokenCap).toBe(88000);
-    });
   });
 
   describe('getModelTier', () => {

package/tests/unit/frontmatter.test.ts

@@ -1,7 +1,101 @@
 import { parsePlanFrontmatter } from '../../src/utils/frontmatter.js';
 
 describe('parsePlanFrontmatter', () => {
-  describe('valid frontmatter', () => {
+  describe('standard format (---/---)', () => {
+    it('should parse effort field', () => {
+      const content = `---
+effort: medium
+---
+# Task: Test Task`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.effort).toBe('medium');
+      expect(result.warnings).toHaveLength(0);
+    });
+
+    it('should parse model field', () => {
+      const content = `---
+model: sonnet
+---
+# Task: Test Task`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.model).toBe('sonnet');
+      expect(result.warnings).toHaveLength(0);
+    });
+
+    it('should parse both effort and model', () => {
+      const content = `---
+effort: high
+model: opus
+---
+# Task: Test Task`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.effort).toBe('high');
+      expect(result.frontmatter.model).toBe('opus');
+    });
+
+    it('should handle empty frontmatter block', () => {
+      const content = `---
+---
+# Task: Test Task`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(false);
+    });
+
+    it('should handle whitespace before opening delimiter', () => {
+      const content = `
+---
+effort: low
+---
+# Task: Test Task`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.effort).toBe('low');
+    });
+
+    it('should handle empty lines in frontmatter', () => {
+      const content = `---
+effort: low
+
+model: haiku
+---
+# Task: Test`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.effort).toBe('low');
+      expect(result.frontmatter.model).toBe('haiku');
+    });
+
+    it('should handle opening delimiter with trailing spaces', () => {
+      const content = `---
+effort: medium
+---
+# Task: Test Task`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.effort).toBe('medium');
+    });
+
+    it('should return empty for missing closing delimiter', () => {
+      const content = `---
+effort: medium
+# Task: Test Task`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(false);
+    });
+
+    it('should return empty for opening delimiter without newline', () => {
+      const content = `---effort: medium
+---
+# Task: Test Task`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(false);
+    });
+  });
+
+  describe('legacy format (closing --- only)', () => {
     it('should parse effort field', () => {
       const content = `effort: medium
 ---

package/tests/unit/name-generator.test.ts

@@ -170,7 +170,7 @@ describe('Name Generator', () => {
       expect(mockSpawn).toHaveBeenCalledTimes(1);
       // Verify the prompt contains the multi-name generation prompt
       const promptArg = (mockSpawn.mock.calls[0][1] as string[]).at(-1);
-      expect(promptArg).toContain('Generate 5 creative project names');
+      expect(promptArg).toContain('Output EXACTLY 5 project names');
     });
 
     it('should handle names with numbering prefixes', async () => {

package/tests/unit/post-execution-picker.test.ts

@@ -65,6 +65,7 @@ jest.unstable_mockModule('../../src/core/worktree.js', () => ({
   pullMainBranch: mockPullMainBranch,
   pushMainBranch: mockPushMainBranch,
   detectMainBranch: jest.fn(),
+  rebaseOntoMain: jest.fn(),
 }));
 
 // Import after mocking

package/tests/unit/stream-renderer.test.ts

@@ -267,6 +267,7 @@ describe('renderStreamEvent', () => {
         outputTokens: 500,
         cacheReadInputTokens: 200,
         cacheCreationInputTokens: 100,
+        costUsd: 0, // costUSD is extracted from modelUsage data
       });
     });
 
@@ -318,6 +319,87 @@ describe('renderStreamEvent', () => {
       expect(result.usageData!.modelUsage['claude-opus-4-6'].inputTokens).toBe(1500);
       expect(result.usageData!.modelUsage['claude-haiku-4-5-20251001'].inputTokens).toBe(500);
     });
+
+    it('should extract total_cost_usd from result event', () => {
+      const line = JSON.stringify({
+        type: 'result',
+        subtype: 'success',
+        result: 'Done',
+        usage: {
+          input_tokens: 1000,
+          output_tokens: 500,
+        },
+        total_cost_usd: 18.5,
+      });
+      const result = renderStreamEvent(line);
+      expect(result.usageData).toBeDefined();
+      expect(result.usageData!.totalCostUsd).toBe(18.5);
+    });
+
+    it('should default totalCostUsd to 0 when no cost provided', () => {
+      const line = JSON.stringify({
+        type: 'result',
+        subtype: 'success',
+        result: 'Done',
+        usage: {
+          input_tokens: 1000,
+          output_tokens: 500,
+        },
+        // No cost field - costUSD is in modelUsage, not at top level
+      });
+      const result = renderStreamEvent(line);
+      expect(result.usageData).toBeDefined();
+      expect(result.usageData!.totalCostUsd).toBe(0);
+    });
+
+    it('should prioritize total_cost_usd over costUSD', () => {
+      const line = JSON.stringify({
+        type: 'result',
+        subtype: 'success',
+        result: 'Done',
+        usage: {
+          input_tokens: 1000,
+          output_tokens: 500,
+        },
+        total_cost_usd: 18.5,
+        costUSD: 20.0,
+      });
+      const result = renderStreamEvent(line);
+      expect(result.usageData).toBeDefined();
+      expect(result.usageData!.totalCostUsd).toBe(18.5);
+    });
+
+    it('should handle missing cost fields gracefully', () => {
+      const line = JSON.stringify({
+        type: 'result',
+        subtype: 'success',
+        result: 'Done',
+        usage: {
+          input_tokens: 1000,
+          output_tokens: 500,
+        },
+      });
+      const result = renderStreamEvent(line);
+      expect(result.usageData).toBeDefined();
+      // When no cost is provided, defaults to 0
+      expect(result.usageData!.totalCostUsd).toBe(0);
+    });
+
+    it('should extract zero cost correctly', () => {
+      const line = JSON.stringify({
+        type: 'result',
+        subtype: 'success',
+        result: 'Done',
+        usage: {
+          input_tokens: 0,
+          output_tokens: 0,
+        },
+        total_cost_usd: 0,
+      });
+      const result = renderStreamEvent(line);
+      expect(result.usageData).toBeDefined();
+      expect(result.usageData!.totalCostUsd).toBe(0);
+    });
   });
 
   describe('edge cases', () => {