rafcode 2.1.1 → 2.2.0

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

@@ -1,13 +1,35 @@
 import { jest } from '@jest/globals';
-
-// Mock execSync before importing the module
-const mockExecSync = jest.fn();
+import { EventEmitter } from 'node:events';
+
+// Helper to create a mock spawn that returns a fake ChildProcess
+function createMockSpawn(stdoutData: string | null, exitCode: number = 0) {
+  const stdout = new EventEmitter();
+  const stderr = new EventEmitter();
+  const proc = new EventEmitter() as any;
+  proc.stdout = stdout;
+  proc.stderr = stderr;
+  proc.kill = jest.fn();
+
+  // Schedule data emission and close after spawn is called
+  setTimeout(() => {
+    if (stdoutData !== null) {
+      stdout.emit('data', Buffer.from(stdoutData));
+    }
+    proc.emit('close', exitCode);
+  }, 0);
+
+  return proc;
+}
+
+// Mock spawn before importing the module
+const mockSpawn = jest.fn();
 jest.unstable_mockModule('node:child_process', () => ({
-  execSync: mockExecSync,
+  spawn: mockSpawn,
+  execSync: jest.fn(), // keep available for transitive imports
 }));
 
 // Import after mocking
-const { generateProjectName, generateProjectNames, sanitizeGeneratedName, escapeShellArg } =
+const { generateProjectName, generateProjectNames, sanitizeGeneratedName } =
   await import('../../src/utils/name-generator.js');
 
 describe('Name Generator', () => {
@@ -16,55 +38,63 @@ describe('Name Generator', () => {
   });
 
   describe('generateProjectName', () => {
-    it('should return sanitized name from Sonnet response', async () => {
-      mockExecSync.mockReturnValue('user-auth-system\n');
+    it('should return sanitized name from Claude response', async () => {
+      mockSpawn.mockReturnValue(createMockSpawn('user-auth-system\n'));
 
       const result = await generateProjectName('Build a user authentication system');
 
       expect(result).toBe('user-auth-system');
-      expect(mockExecSync).toHaveBeenCalledTimes(1);
-      expect(mockExecSync).toHaveBeenCalledWith(
-        expect.stringContaining('claude --model sonnet --print'),
+      expect(mockSpawn).toHaveBeenCalledTimes(1);
+      expect(mockSpawn).toHaveBeenCalledWith(
+        'claude',
+        expect.arrayContaining(['--model', 'haiku', '--no-session-persistence', '-p']),
         expect.any(Object)
       );
     });
 
-    it('should sanitize Sonnet response with quotes', async () => {
-      mockExecSync.mockReturnValue('"api-rate-limiter"');
+    it('should pass --no-session-persistence flag', async () => {
+      mockSpawn.mockReturnValue(createMockSpawn('test-name\n'));
+
+      await generateProjectName('Test project');
+
+      const args = mockSpawn.mock.calls[0][1] as string[];
+      expect(args).toContain('--no-session-persistence');
+    });
+
+    it('should sanitize response with quotes', async () => {
+      mockSpawn.mockReturnValue(createMockSpawn('"api-rate-limiter"'));
 
       const result = await generateProjectName('Create an API rate limiting service');
 
       expect(result).toBe('api-rate-limiter');
     });
 
-    it('should sanitize Sonnet response with special characters', async () => {
-      mockExecSync.mockReturnValue('Some Project! Name');
+    it('should sanitize response with special characters', async () => {
+      mockSpawn.mockReturnValue(createMockSpawn('Some Project! Name'));
 
       const result = await generateProjectName('Some project description');
 
       expect(result).toBe('some-project-name');
     });
 
-    it('should fall back to word extraction when Sonnet fails', async () => {
-      mockExecSync.mockImplementation(() => {
-        throw new Error('Command failed');
-      });
+    it('should fall back to word extraction when Claude fails', async () => {
+      mockSpawn.mockReturnValue(createMockSpawn(null, 1));
 
       const result = await generateProjectName('Build a user authentication system with OAuth');
 
       expect(result).toBe('build-user-authentication');
     });
 
-    it('should fall back to word extraction when Sonnet returns empty', async () => {
-      mockExecSync.mockReturnValue('');
+    it('should fall back to word extraction when Claude returns empty', async () => {
+      mockSpawn.mockReturnValue(createMockSpawn(''));
 
       const result = await generateProjectName('Implement caching layer for database');
 
       expect(result).toBe('implement-caching-layer');
     });
 
-    it('should fall back to word extraction when Sonnet returns single char', async () => {
-      mockExecSync.mockReturnValue('a');
+    it('should fall back to word extraction when Claude returns single char', async () => {
+      mockSpawn.mockReturnValue(createMockSpawn('a'));
 
       const result = await generateProjectName('Add new logging functionality');
 
@@ -72,47 +102,60 @@ describe('Name Generator', () => {
     });
 
     it('should return "project" when description has no meaningful words', async () => {
-      mockExecSync.mockImplementation(() => {
-        throw new Error('Command failed');
-      });
+      mockSpawn.mockReturnValue(createMockSpawn(null, 1));
 
       const result = await generateProjectName('a b c');
 
       expect(result).toBe('project');
     });
 
-    it('should truncate long names from Sonnet', async () => {
+    it('should truncate long names from Claude', async () => {
       const longName =
         'this-is-a-very-long-project-name-that-exceeds-the-maximum-allowed-length-for-folder-names';
-      mockExecSync.mockReturnValue(longName);
+      mockSpawn.mockReturnValue(createMockSpawn(longName));
 
       const result = await generateProjectName('Some project');
 
       expect(result.length).toBeLessThanOrEqual(50);
     });
 
-    it('should handle multiline Sonnet response', async () => {
-      mockExecSync.mockReturnValue('project-name\nSome extra explanation\n');
+    it('should handle multiline response', async () => {
+      mockSpawn.mockReturnValue(createMockSpawn('project-name\nSome extra explanation\n'));
 
       const result = await generateProjectName('Some project');
 
-      // Should take first line after trim
+      // Should take full trimmed output
       expect(result).toBe('project-name-some-extra-explanation');
     });
 
     it('should convert uppercase to lowercase', async () => {
-      mockExecSync.mockReturnValue('API-Gateway-Service');
+      mockSpawn.mockReturnValue(createMockSpawn('API-Gateway-Service'));
 
       const result = await generateProjectName('Build an API gateway');
 
       expect(result).toBe('api-gateway-service');
     });
+
+    it('should handle spawn error gracefully', async () => {
+      const proc = new EventEmitter() as any;
+      proc.stdout = new EventEmitter();
+      proc.stderr = new EventEmitter();
+      proc.kill = jest.fn();
+      setTimeout(() => {
+        proc.emit('error', new Error('ENOENT'));
+      }, 0);
+      mockSpawn.mockReturnValue(proc);
+
+      const result = await generateProjectName('Build something');
+
+      expect(result).toBe('build-something');
+    });
   });
 
   describe('generateProjectNames', () => {
-    it('should return multiple sanitized names from Sonnet response', async () => {
-      mockExecSync.mockReturnValue(
-        'phoenix-rise\nturbo-boost\nbug-squasher\ncatalyst\nmerlin\n'
+    it('should return multiple sanitized names from Claude response', async () => {
+      mockSpawn.mockReturnValue(
+        createMockSpawn('phoenix-rise\nturbo-boost\nbug-squasher\ncatalyst\nmerlin\n')
       );
 
       const result = await generateProjectNames('Build a user authentication system');
@@ -124,16 +167,15 @@ describe('Name Generator', () => {
         'catalyst',
         'merlin',
       ]);
-      expect(mockExecSync).toHaveBeenCalledTimes(1);
-      expect(mockExecSync).toHaveBeenCalledWith(
-        expect.stringContaining('Generate 5 creative project names'),
-        expect.any(Object)
-      );
+      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');
     });
 
     it('should handle names with numbering prefixes', async () => {
-      mockExecSync.mockReturnValue(
-        '1. phoenix-rise\n2. turbo-boost\n3. bug-squasher\n4. catalyst\n5. merlin\n'
+      mockSpawn.mockReturnValue(
+        createMockSpawn('1. phoenix-rise\n2. turbo-boost\n3. bug-squasher\n4. catalyst\n5. merlin\n')
       );
 
       const result = await generateProjectNames('Some project');
@@ -148,8 +190,8 @@ describe('Name Generator', () => {
     });
 
     it('should handle names with colon prefixes', async () => {
-      mockExecSync.mockReturnValue(
-        '1: phoenix-rise\n2: turbo-boost\n3: bug-squasher\n'
+      mockSpawn.mockReturnValue(
+        createMockSpawn('1: phoenix-rise\n2: turbo-boost\n3: bug-squasher\n')
       );
 
       const result = await generateProjectNames('Some project');
@@ -158,8 +200,8 @@ describe('Name Generator', () => {
     });
 
     it('should remove duplicate names', async () => {
-      mockExecSync.mockReturnValue(
-        'phoenix\nturbo-boost\nphoenix\ncatalyst\nturbo-boost\n'
+      mockSpawn.mockReturnValue(
+        createMockSpawn('phoenix\nturbo-boost\nphoenix\ncatalyst\nturbo-boost\n')
       );
 
       const result = await generateProjectNames('Some project');
@@ -168,8 +210,8 @@ describe('Name Generator', () => {
     });
 
     it('should limit to 5 names maximum', async () => {
-      mockExecSync.mockReturnValue(
-        'name-one\nname-two\nname-three\nname-four\nname-five\nname-six\nname-seven\n'
+      mockSpawn.mockReturnValue(
+        createMockSpawn('name-one\nname-two\nname-three\nname-four\nname-five\nname-six\nname-seven\n')
       );
 
       const result = await generateProjectNames('Some project');
@@ -178,17 +220,15 @@ describe('Name Generator', () => {
     });
 
     it('should return 3+ names when available', async () => {
-      mockExecSync.mockReturnValue('phoenix\nturbo-boost\ncatalyst\n');
+      mockSpawn.mockReturnValue(createMockSpawn('phoenix\nturbo-boost\ncatalyst\n'));
 
       const result = await generateProjectNames('Some project');
 
       expect(result.length).toBe(3);
     });
 
-    it('should fall back to single name when Sonnet fails', async () => {
-      mockExecSync.mockImplementation(() => {
-        throw new Error('Command failed');
-      });
+    it('should fall back to single name when Claude fails', async () => {
+      mockSpawn.mockReturnValue(createMockSpawn(null, 1));
 
       const result = await generateProjectNames('Build a user authentication system with OAuth');
 
@@ -196,7 +236,7 @@ describe('Name Generator', () => {
     });
 
     it('should fall back to single name when too few names returned', async () => {
-      mockExecSync.mockReturnValue('phoenix\nturbo\n');
+      mockSpawn.mockReturnValue(createMockSpawn('phoenix\nturbo\n'));
 
       const result = await generateProjectNames('Build something awesome');
 
@@ -205,7 +245,9 @@ describe('Name Generator', () => {
     });
 
     it('should filter out invalid/short names', async () => {
-      mockExecSync.mockReturnValue('phoenix\na\nturbo-boost\nb\ncatalyst\n');
+      mockSpawn.mockReturnValue(
+        createMockSpawn('phoenix\na\nturbo-boost\nb\ncatalyst\n')
+      );
 
       const result = await generateProjectNames('Some project');
 
@@ -213,8 +255,8 @@ describe('Name Generator', () => {
     });
 
     it('should sanitize names with special characters', async () => {
-      mockExecSync.mockReturnValue(
-        'Phoenix Rise!\nTurbo-Boost!!!\nBug Squasher\n'
+      mockSpawn.mockReturnValue(
+        createMockSpawn('Phoenix Rise!\nTurbo-Boost!!!\nBug Squasher\n')
       );
 
       const result = await generateProjectNames('Some project');
@@ -223,7 +265,7 @@ describe('Name Generator', () => {
     });
 
     it('should handle empty response', async () => {
-      mockExecSync.mockReturnValue('');
+      mockSpawn.mockReturnValue(createMockSpawn(''));
 
       const result = await generateProjectNames('Some project');
 
@@ -262,22 +304,4 @@ describe('Name Generator', () => {
       expect(result?.length).toBeLessThanOrEqual(50);
     });
   });
-
-  describe('escapeShellArg', () => {
-    it('should escape double quotes', () => {
-      expect(escapeShellArg('hello "world"')).toBe('hello \\"world\\"');
-    });
-
-    it('should escape backslashes', () => {
-      expect(escapeShellArg('hello\\world')).toBe('hello\\\\world');
-    });
-
-    it('should escape dollar signs', () => {
-      expect(escapeShellArg('$HOME')).toBe('\\$HOME');
-    });
-
-    it('should escape backticks', () => {
-      expect(escapeShellArg('`whoami`')).toBe('\\`whoami\\`');
-    });
-  });
 });

package/tests/unit/pull-request.test.ts

@@ -25,8 +25,10 @@ jest.unstable_mockModule('node:fs', () => ({
 
 // Mock os
 const mockTmpdir = jest.fn().mockReturnValue('/tmp');
+const mockHomedir = jest.fn().mockReturnValue('/home/testuser');
 jest.unstable_mockModule('node:os', () => ({
   tmpdir: mockTmpdir,
+  homedir: mockHomedir,
 }));
 
 // Mock logger to prevent console output

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

@@ -235,6 +235,89 @@ describe('renderStreamEvent', () => {
       expect(result.display).toBe('');
       expect(result.textContent).toBe('');
     });
+
+    it('should extract usage data from result event', () => {
+      const line = JSON.stringify({
+        type: 'result',
+        subtype: 'success',
+        result: 'Done',
+        usage: {
+          input_tokens: 1000,
+          output_tokens: 500,
+          cache_read_input_tokens: 200,
+          cache_creation_input_tokens: 100,
+        },
+        modelUsage: {
+          'claude-opus-4-6': {
+            inputTokens: 1000,
+            outputTokens: 500,
+            cacheReadInputTokens: 200,
+            cacheCreationInputTokens: 100,
+          },
+        },
+      });
+      const result = renderStreamEvent(line);
+      expect(result.usageData).toBeDefined();
+      expect(result.usageData!.inputTokens).toBe(1000);
+      expect(result.usageData!.outputTokens).toBe(500);
+      expect(result.usageData!.cacheReadInputTokens).toBe(200);
+      expect(result.usageData!.cacheCreationInputTokens).toBe(100);
+      expect(result.usageData!.modelUsage['claude-opus-4-6']).toEqual({
+        inputTokens: 1000,
+        outputTokens: 500,
+        cacheReadInputTokens: 200,
+        cacheCreationInputTokens: 100,
+      });
+    });
+
+    it('should return undefined usageData when no usage in result', () => {
+      const line = JSON.stringify({
+        type: 'result',
+        subtype: 'success',
+        result: 'Done',
+      });
+      const result = renderStreamEvent(line);
+      expect(result.usageData).toBeUndefined();
+    });
+
+    it('should handle partial usage data gracefully', () => {
+      const line = JSON.stringify({
+        type: 'result',
+        usage: { input_tokens: 500 },
+      });
+      const result = renderStreamEvent(line);
+      expect(result.usageData).toBeDefined();
+      expect(result.usageData!.inputTokens).toBe(500);
+      expect(result.usageData!.outputTokens).toBe(0);
+      expect(result.usageData!.cacheReadInputTokens).toBe(0);
+      expect(result.usageData!.cacheCreationInputTokens).toBe(0);
+      expect(result.usageData!.modelUsage).toEqual({});
+    });
+
+    it('should handle multi-model usage data', () => {
+      const line = JSON.stringify({
+        type: 'result',
+        usage: {
+          input_tokens: 2000,
+          output_tokens: 800,
+        },
+        modelUsage: {
+          'claude-opus-4-6': {
+            inputTokens: 1500,
+            outputTokens: 600,
+          },
+          'claude-haiku-4-5-20251001': {
+            inputTokens: 500,
+            outputTokens: 200,
+          },
+        },
+      });
+      const result = renderStreamEvent(line);
+      expect(result.usageData).toBeDefined();
+      expect(Object.keys(result.usageData!.modelUsage)).toHaveLength(2);
+      expect(result.usageData!.modelUsage['claude-opus-4-6'].inputTokens).toBe(1500);
+      expect(result.usageData!.modelUsage['claude-haiku-4-5-20251001'].inputTokens).toBe(500);
+    });
   });
 
   describe('edge cases', () => {

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

@@ -4,8 +4,14 @@ import {
   formatProjectHeader,
   formatSummary,
   formatProgressBar,
+  formatNumber,
+  formatCost,
+  formatTaskTokenSummary,
+  formatTokenTotalSummary,
   TaskStatus,
 } from '../../src/utils/terminal-symbols.js';
+import type { UsageData } from '../../src/types/config.js';
+import type { CostBreakdown } from '../../src/utils/token-tracker.js';
 
 describe('Terminal Symbols', () => {
   describe('SYMBOLS', () => {
@@ -231,4 +237,155 @@ describe('Terminal Symbols', () => {
       expect(result).toBe('✓✗⊘○');
     });
   });
+
+  describe('formatNumber', () => {
+    it('should format small numbers without separators', () => {
+      expect(formatNumber(42)).toBe('42');
+    });
+
+    it('should format numbers with thousands separators', () => {
+      expect(formatNumber(12345)).toBe('12,345');
+    });
+
+    it('should format large numbers', () => {
+      expect(formatNumber(1234567)).toBe('1,234,567');
+    });
+
+    it('should format zero', () => {
+      expect(formatNumber(0)).toBe('0');
+    });
+  });
+
+  describe('formatCost', () => {
+    it('should format zero cost', () => {
+      expect(formatCost(0)).toBe('$0.00');
+    });
+
+    it('should format normal costs with 2 decimals', () => {
+      expect(formatCost(1.23)).toBe('$1.23');
+    });
+
+    it('should format small costs with 4 decimals', () => {
+      expect(formatCost(0.0042)).toBe('$0.0042');
+    });
+
+    it('should format costs just at the threshold', () => {
+      expect(formatCost(0.01)).toBe('$0.01');
+    });
+
+    it('should format costs below threshold', () => {
+      expect(formatCost(0.009)).toBe('$0.0090');
+    });
+  });
+
+  describe('formatTaskTokenSummary', () => {
+    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,
+    });
+
+    it('should format basic token summary without cache', () => {
+      const result = formatTaskTokenSummary(makeUsage(), makeCost(0.42));
+      expect(result).toBe('  Tokens: 5,234 in / 1,023 out | Est. cost: $0.42');
+    });
+
+    it('should include cache read tokens', () => {
+      const result = formatTaskTokenSummary(
+        makeUsage({ cacheReadInputTokens: 18500 }),
+        makeCost(0.42)
+      );
+      expect(result).toBe('  Tokens: 5,234 in / 1,023 out | Cache: 18,500 read | Est. cost: $0.42');
+    });
+
+    it('should include cache creation tokens', () => {
+      const result = formatTaskTokenSummary(
+        makeUsage({ cacheCreationInputTokens: 5000 }),
+        makeCost(0.55)
+      );
+      expect(result).toBe('  Tokens: 5,234 in / 1,023 out | Cache: 5,000 created | Est. cost: $0.55');
+    });
+
+    it('should include both cache read and creation tokens', () => {
+      const result = formatTaskTokenSummary(
+        makeUsage({ cacheReadInputTokens: 18500, cacheCreationInputTokens: 5000 }),
+        makeCost(0.75)
+      );
+      expect(result).toBe('  Tokens: 5,234 in / 1,023 out | Cache: 18,500 read / 5,000 created | Est. cost: $0.75');
+    });
+
+    it('should format small costs with 4 decimal places', () => {
+      const result = formatTaskTokenSummary(makeUsage(), makeCost(0.0042));
+      expect(result).toBe('  Tokens: 5,234 in / 1,023 out | Est. cost: $0.0042');
+    });
+  });
+
+  describe('formatTokenTotalSummary', () => {
+    const makeUsage = (overrides: Partial<UsageData> = {}): UsageData => ({
+      inputTokens: 45678,
+      outputTokens: 12345,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0,
+      modelUsage: {},
+      ...overrides,
+    });
+
+    const makeCost = (total: number): CostBreakdown => ({
+      inputCost: 0,
+      outputCost: 0,
+      cacheReadCost: 0,
+      cacheCreateCost: 0,
+      totalCost: total,
+    });
+
+    it('should format total summary without cache', () => {
+      const result = formatTokenTotalSummary(makeUsage(), makeCost(3.75));
+      expect(result).toContain('Token Usage Summary');
+      expect(result).toContain('Total tokens: 45,678 in / 12,345 out');
+      expect(result).toContain('Estimated cost: $3.75');
+      expect(result).not.toContain('Cache:');
+    });
+
+    it('should include cache read in total summary', () => {
+      const result = formatTokenTotalSummary(
+        makeUsage({ cacheReadInputTokens: 125000 }),
+        makeCost(3.75)
+      );
+      expect(result).toContain('Cache: 125,000 read');
+    });
+
+    it('should include cache creation in total summary', () => {
+      const result = formatTokenTotalSummary(
+        makeUsage({ cacheCreationInputTokens: 8000 }),
+        makeCost(3.75)
+      );
+      expect(result).toContain('Cache: 8,000 created');
+    });
+
+    it('should include both cache types in total summary', () => {
+      const result = formatTokenTotalSummary(
+        makeUsage({ cacheReadInputTokens: 125000, cacheCreationInputTokens: 8000 }),
+        makeCost(3.75)
+      );
+      expect(result).toContain('Cache: 125,000 read / 8,000 created');
+    });
+
+    it('should have divider lines', () => {
+      const result = formatTokenTotalSummary(makeUsage(), makeCost(3.75));
+      const lines = result.split('\n');
+      expect(lines[0]).toContain('──');
+      expect(lines[lines.length - 1]).toContain('──');
+    });
+  });
 });