rafcode 2.3.0 → 2.4.1-0

package/tests/unit/frontmatter.test.ts

@@ -0,0 +1,276 @@
+import { parsePlanFrontmatter } from '../../src/utils/frontmatter.js';
+
+describe('parsePlanFrontmatter', () => {
+  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
+---
+# 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 accept all effort levels', () => {
+      for (const level of ['low', 'medium', 'high']) {
+        const content = `effort: ${level}
+---
+# Task: Test`;
+        const result = parsePlanFrontmatter(content);
+        expect(result.hasFrontmatter).toBe(true);
+        expect(result.frontmatter.effort).toBe(level);
+      }
+    });
+
+    it('should accept full model IDs', () => {
+      const content = `model: claude-opus-4-6
+---
+# Task: Test`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.model).toBe('claude-opus-4-6');
+    });
+
+    it('should be case-insensitive for effort values', () => {
+      const content = `effort: MEDIUM
+---
+# Task: Test`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.effort).toBe('medium');
+    });
+
+    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');
+    });
+  });
+
+  describe('no frontmatter', () => {
+    it('should return empty for content without delimiter', () => {
+      const content = `# Task: Test Task
+
+## Objective
+Do something`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(false);
+      expect(result.frontmatter.effort).toBeUndefined();
+      expect(result.frontmatter.model).toBeUndefined();
+    });
+
+    it('should return empty for empty content', () => {
+      const result = parsePlanFrontmatter('');
+      expect(result.hasFrontmatter).toBe(false);
+    });
+
+    it('should return empty when markdown heading appears before delimiter', () => {
+      const content = `# Task: Test Task
+---
+More content`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(false);
+      expect(result.warnings).toContain('Frontmatter section contains markdown content before closing delimiter');
+    });
+  });
+
+  describe('warnings', () => {
+    it('should warn on unknown frontmatter keys', () => {
+      const content = `effort: medium
+unknownKey: value
+---
+# Task: Test`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.warnings).toContain('Unknown frontmatter key: "unknownkey"');
+    });
+
+    it('should warn on invalid effort value', () => {
+      const content = `effort: invalid
+---
+# Task: Test`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(false); // No valid frontmatter extracted
+      expect(result.warnings.some(w => w.includes('Invalid effort value'))).toBe(true);
+    });
+
+    it('should warn on invalid model value', () => {
+      const content = `model: gpt-4
+---
+# Task: Test`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(false);
+      expect(result.warnings.some(w => w.includes('Invalid model value'))).toBe(true);
+    });
+
+    it('should collect multiple warnings', () => {
+      const content = `effort: invalid
+model: gpt-4
+unknownKey: value
+---
+# Task: Test`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.warnings.length).toBeGreaterThanOrEqual(3);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle delimiter with content after it', () => {
+      const content = `effort: medium
+---
+# Task: Test
+
+## Objective
+Do something
+
+---
+
+More content with another delimiter`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.effort).toBe('medium');
+    });
+
+    it('should handle whitespace around values', () => {
+      const content = `effort:   high
+model:  sonnet
+---
+# Task: Test`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.effort).toBe('high');
+      expect(result.frontmatter.model).toBe('sonnet');
+    });
+
+    it('should handle tabs in whitespace', () => {
+      const content = `effort:\thigh
+---
+# Task: Test`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.effort).toBe('high');
+    });
+  });
+});

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

@@ -45,6 +45,8 @@ jest.unstable_mockModule('../../src/core/pull-request.js', () => ({
 // Mock worktree module
 const mockMergeWorktreeBranch = jest.fn();
 const mockRemoveWorktree = jest.fn();
+const mockPullMainBranch = jest.fn();
+const mockPushMainBranch = jest.fn();
 jest.unstable_mockModule('../../src/core/worktree.js', () => ({
   getRepoRoot: jest.fn(),
   getRepoBasename: jest.fn(),
@@ -60,6 +62,10 @@ jest.unstable_mockModule('../../src/core/worktree.js', () => ({
   branchExists: jest.fn(),
   getWorktreeProjectPath: jest.fn(),
   resolveWorktreeProjectByIdentifier: jest.fn(),
+  pullMainBranch: mockPullMainBranch,
+  pushMainBranch: mockPushMainBranch,
+  detectMainBranch: jest.fn(),
+  rebaseOntoMain: jest.fn(),
 }));
 
 // Import after mocking

package/tests/unit/terminal-symbols.test.ts

@@ -8,6 +8,8 @@ import {
   formatCost,
   formatTaskTokenSummary,
   formatTokenTotalSummary,
+  formatRateLimitPercentage,
+  TokenSummaryOptions,
   TaskStatus,
 } from '../../src/utils/terminal-symbols.js';
 import type { UsageData } from '../../src/types/config.js';
@@ -475,5 +477,145 @@ describe('Terminal Symbols', () => {
       expect(lines[0]).toContain('──');
       expect(lines[lines.length - 1]).toContain('──');
     });
+
+    it('should include rate limit percentage when option enabled', () => {
+      const options: TokenSummaryOptions = {
+        showRateLimitEstimate: true,
+        rateLimitPercentage: 42.5,
+      };
+      const result = formatTokenTotalSummary(makeUsage(), makeCost(3.75), options);
+      expect(result).toContain('~43% of 5h window');
+    });
+
+    it('should not include rate limit when option disabled', () => {
+      const options: TokenSummaryOptions = {
+        showRateLimitEstimate: false,
+        rateLimitPercentage: 42.5,
+      };
+      const result = formatTokenTotalSummary(makeUsage(), makeCost(3.75), options);
+      expect(result).not.toContain('5h window');
+    });
+
+    it('should hide cache tokens when option disabled', () => {
+      const options: TokenSummaryOptions = {
+        showCacheTokens: false,
+      };
+      const result = formatTokenTotalSummary(
+        makeUsage({ cacheReadInputTokens: 125000 }),
+        makeCost(3.75),
+        options
+      );
+      expect(result).not.toContain('Cache:');
+    });
+  });
+
+  describe('formatRateLimitPercentage', () => {
+    it('should format zero percentage', () => {
+      expect(formatRateLimitPercentage(0)).toBe('~0% of 5h window');
+    });
+
+    it('should format very small percentages with 2 decimals', () => {
+      expect(formatRateLimitPercentage(0.05)).toBe('~0.05% of 5h window');
+    });
+
+    it('should format small percentages with 1 decimal', () => {
+      expect(formatRateLimitPercentage(0.5)).toBe('~0.5% of 5h window');
+    });
+
+    it('should round percentages >= 1', () => {
+      expect(formatRateLimitPercentage(1.5)).toBe('~2% of 5h window');
+      expect(formatRateLimitPercentage(42.3)).toBe('~42% of 5h window');
+      expect(formatRateLimitPercentage(100)).toBe('~100% of 5h window');
+    });
+
+    it('should handle percentages over 100%', () => {
+      expect(formatRateLimitPercentage(150.7)).toBe('~151% of 5h window');
+    });
+  });
+
+  describe('formatTaskTokenSummary with options', () => {
+    const makeUsage = (overrides: Partial<UsageData> = {}): UsageData => ({
+      inputTokens: 5234,
+      outputTokens: 1023,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0,
+      modelUsage: {},
+      ...overrides,
+    });
+
+    const makeCost = (total: number): CostBreakdown => ({
+      inputCost: 0,
+      outputCost: 0,
+      cacheReadCost: 0,
+      cacheCreateCost: 0,
+      totalCost: total,
+    });
+
+    const makeEntry = (usage: UsageData, cost: CostBreakdown, attempts?: UsageData[]): TaskUsageEntry => ({
+      taskId: '01',
+      usage,
+      cost,
+      attempts: attempts ?? [usage],
+    });
+
+    it('should include rate limit percentage in single-attempt summary', () => {
+      const usage = makeUsage({ cacheReadInputTokens: 18500 });
+      const entry = makeEntry(usage, makeCost(0.42));
+      const options: TokenSummaryOptions = {
+        showRateLimitEstimate: true,
+        rateLimitPercentage: 2.5,
+      };
+
+      const result = formatTaskTokenSummary(entry, undefined, options);
+      expect(result).toContain('~3% of 5h window');
+    });
+
+    it('should hide cache tokens in single-attempt summary when disabled', () => {
+      const usage = makeUsage({ cacheReadInputTokens: 18500 });
+      const entry = makeEntry(usage, makeCost(0.42));
+      const options: TokenSummaryOptions = {
+        showCacheTokens: false,
+      };
+
+      const result = formatTaskTokenSummary(entry, undefined, options);
+      expect(result).not.toContain('Cache:');
+    });
+
+    it('should only show rate limit on total line in multi-attempt summary', () => {
+      const attempt1 = makeUsage({ inputTokens: 1000, outputTokens: 200 });
+      const attempt2 = makeUsage({ inputTokens: 2000, outputTokens: 400 });
+      const totalUsage = makeUsage({ inputTokens: 3000, outputTokens: 600 });
+      const entry = makeEntry(totalUsage, makeCost(0.05), [attempt1, attempt2]);
+      const options: TokenSummaryOptions = {
+        showRateLimitEstimate: true,
+        rateLimitPercentage: 1.5,
+      };
+
+      const result = formatTaskTokenSummary(entry, undefined, options);
+      const lines = result.split('\n');
+
+      // Rate limit should only appear on the Total line
+      expect(lines[0]).not.toContain('5h window'); // Attempt 1
+      expect(lines[1]).not.toContain('5h window'); // Attempt 2
+      expect(lines[2]).toContain('~2% of 5h window'); // Total
+    });
+
+    it('should respect showCacheTokens in multi-attempt summary', () => {
+      const attempt1 = makeUsage({ inputTokens: 1000, outputTokens: 200, cacheReadInputTokens: 5000 });
+      const attempt2 = makeUsage({ inputTokens: 1500, outputTokens: 300, cacheCreationInputTokens: 2000 });
+      const totalUsage = makeUsage({
+        inputTokens: 2500,
+        outputTokens: 500,
+        cacheReadInputTokens: 5000,
+        cacheCreationInputTokens: 2000,
+      });
+      const entry = makeEntry(totalUsage, makeCost(0.08), [attempt1, attempt2]);
+      const options: TokenSummaryOptions = {
+        showCacheTokens: false,
+      };
+
+      const result = formatTaskTokenSummary(entry, undefined, options);
+      expect(result).not.toContain('Cache:');
+    });
   });
 });