rafcode 2.1.1 → 2.3.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', () => {