rafcode 2.4.0 → 2.4.1-0

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/worktree.test.ts

@@ -46,6 +46,7 @@ const {
   detectMainBranch,
   pullMainBranch,
   pushMainBranch,
+  rebaseOntoMain,
 } = await import('../../src/core/worktree.js');
 
 const HOME = os.homedir();
@@ -729,7 +730,7 @@ describe('worktree utilities', () => {
 
       const result = pullMainBranch();
 
-      expect(result.success).toBe(true);
+      expect(result.success).toBe(false);
       expect(result.mainBranch).toBe('main');
       expect(result.hadChanges).toBe(false);
       expect(result.error).toContain('diverged');
@@ -806,6 +807,72 @@ describe('worktree utilities', () => {
     });
   });
 
+  describe('rebaseOntoMain', () => {
+    it('should successfully rebase onto main branch', () => {
+      mockExecSync.mockImplementation((cmd: unknown) => {
+        const cmdStr = cmd as string;
+        if (cmdStr.includes('git rebase main')) return '';
+        return '';
+      });
+
+      const result = rebaseOntoMain('main', '/path/to/worktree');
+
+      expect(result.success).toBe(true);
+      expect(result.error).toBeUndefined();
+      expect(mockExecSync).toHaveBeenCalledWith(
+        'git rebase main',
+        expect.objectContaining({
+          cwd: '/path/to/worktree',
+        })
+      );
+    });
+
+    it('should abort rebase and return failure on conflict', () => {
+      const commands: string[] = [];
+      mockExecSync.mockImplementation((cmd: unknown) => {
+        const cmdStr = cmd as string;
+        commands.push(cmdStr);
+        if (cmdStr.includes('git rebase main')) {
+          throw new Error('CONFLICT: Merge conflict in file.ts');
+        }
+        if (cmdStr.includes('git rebase --abort')) return '';
+        return '';
+      });
+
+      const result = rebaseOntoMain('main', '/path/to/worktree');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('CONFLICT');
+      expect(commands).toContain('git rebase main');
+      expect(commands).toContain('git rebase --abort');
+      expect(mockExecSync).toHaveBeenCalledWith(
+        'git rebase --abort',
+        expect.objectContaining({
+          cwd: '/path/to/worktree',
+        })
+      );
+    });
+
+    it('should handle rebase abort failure gracefully', () => {
+      mockExecSync.mockImplementation((cmd: unknown) => {
+        const cmdStr = cmd as string;
+        if (cmdStr.includes('git rebase main')) {
+          throw new Error('CONFLICT: Merge conflict');
+        }
+        if (cmdStr.includes('git rebase --abort')) {
+          throw new Error('abort failed');
+        }
+        return '';
+      });
+
+      const result = rebaseOntoMain('main', '/path/to/worktree');
+
+      // Should still return failure even if abort fails
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('CONFLICT');
+    });
+  });
+
   describe('pushMainBranch', () => {
     it('should return error when main branch cannot be detected', () => {
       mockExecSync.mockImplementation(() => {

package/src/utils/session-parser.ts

@@ -1,161 +0,0 @@
-/**
- * Utilities for parsing Claude CLI session files to extract token usage data.
- * Claude CLI saves session data to ~/.claude/projects/<escaped-path>/<session-id>.jsonl
- */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import type { UsageData } from '../types/config.js';
-
-/** Raw usage structure from Claude session JSONL assistant message entries. */
-interface SessionMessageUsage {
-  input_tokens?: number;
-  output_tokens?: number;
-  cache_read_input_tokens?: number;
-  cache_creation_input_tokens?: number;
-}
-
-/** Structure of an assistant message entry in the session JSONL. */
-interface SessionMessageEntry {
-  type: 'assistant';
-  message?: {
-    usage?: SessionMessageUsage;
-    model?: string;
-  };
-  costUSD?: number;
-}
-
-/** Result of parsing a session file. */
-export interface SessionParseResult {
-  /** Accumulated usage data from all assistant messages. */
-  usage: UsageData;
-  /** Whether parsing was successful. */
-  success: boolean;
-  /** Error message if parsing failed. */
-  error?: string;
-}
-
-/**
- * Escape a path for use in Claude's project directory naming scheme.
- * Claude escapes `/` to `-` in project paths.
- */
-export function escapeProjectPath(projectPath: string): string {
-  // Remove leading slash and replace remaining slashes with dashes
-  return projectPath.replace(/^\//, '').replace(/\//g, '-');
-}
-
-/**
- * Compute the expected session file path for a given session ID and working directory.
- *
- * @param sessionId - The UUID session ID passed to --session-id
- * @param cwd - The working directory where Claude was run (project path)
- * @returns The expected path to the session JSONL file
- */
-export function getSessionFilePath(sessionId: string, cwd: string): string {
-  const claudeDir = path.join(os.homedir(), '.claude', 'projects');
-  const escapedPath = escapeProjectPath(cwd);
-  return path.join(claudeDir, escapedPath, `${sessionId}.jsonl`);
-}
-
-/**
- * Parse a Claude session JSONL file and extract accumulated token usage data.
- *
- * @param sessionFilePath - Path to the session JSONL file
- * @returns Parsed usage data or error information
- */
-export function parseSessionFile(sessionFilePath: string): SessionParseResult {
-  const emptyUsage: UsageData = {
-    inputTokens: 0,
-    outputTokens: 0,
-    cacheReadInputTokens: 0,
-    cacheCreationInputTokens: 0,
-    modelUsage: {},
-  };
-
-  if (!fs.existsSync(sessionFilePath)) {
-    return {
-      usage: emptyUsage,
-      success: false,
-      error: `Session file not found: ${sessionFilePath}`,
-    };
-  }
-
-  try {
-    const content = fs.readFileSync(sessionFilePath, 'utf-8');
-    const lines = content.trim().split('\n').filter(line => line.trim());
-
-    const accumulated: UsageData = { ...emptyUsage, modelUsage: {} };
-
-    for (const line of lines) {
-      try {
-        const entry = JSON.parse(line) as Record<string, unknown>;
-
-        // Only process assistant message entries
-        if (entry.type !== 'assistant') continue;
-
-        const assistantEntry = entry as unknown as SessionMessageEntry;
-        const usage = assistantEntry.message?.usage;
-        const model = assistantEntry.message?.model;
-
-        if (!usage) continue;
-
-        const inputTokens = usage.input_tokens ?? 0;
-        const outputTokens = usage.output_tokens ?? 0;
-        const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
-        const cacheCreateTokens = usage.cache_creation_input_tokens ?? 0;
-
-        // Accumulate aggregate totals
-        accumulated.inputTokens += inputTokens;
-        accumulated.outputTokens += outputTokens;
-        accumulated.cacheReadInputTokens += cacheReadTokens;
-        accumulated.cacheCreationInputTokens += cacheCreateTokens;
-
-        // Accumulate per-model usage
-        if (model) {
-          const existing = accumulated.modelUsage[model];
-          if (existing) {
-            existing.inputTokens += inputTokens;
-            existing.outputTokens += outputTokens;
-            existing.cacheReadInputTokens += cacheReadTokens;
-            existing.cacheCreationInputTokens += cacheCreateTokens;
-          } else {
-            accumulated.modelUsage[model] = {
-              inputTokens,
-              outputTokens,
-              cacheReadInputTokens: cacheReadTokens,
-              cacheCreationInputTokens: cacheCreateTokens,
-            };
-          }
-        }
-      } catch {
-        // Skip malformed lines
-        continue;
-      }
-    }
-
-    return {
-      usage: accumulated,
-      success: true,
-    };
-  } catch (error) {
-    return {
-      usage: emptyUsage,
-      success: false,
-      error: `Failed to parse session file: ${error}`,
-    };
-  }
-}
-
-/**
- * Parse a Claude session by session ID and working directory.
- * Convenience wrapper around getSessionFilePath + parseSessionFile.
- *
- * @param sessionId - The UUID session ID passed to --session-id
- * @param cwd - The working directory where Claude was run
- * @returns Parsed usage data or error information
- */
-export function parseSessionById(sessionId: string, cwd: string): SessionParseResult {
-  const filePath = getSessionFilePath(sessionId, cwd);
-  return parseSessionFile(filePath);
-}

package/tests/unit/session-parser.test.ts

@@ -1,301 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import {
-  escapeProjectPath,
-  getSessionFilePath,
-  parseSessionFile,
-  parseSessionById,
-} from '../../src/utils/session-parser.js';
-
-describe('Session Parser', () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-session-parser-test-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  describe('escapeProjectPath', () => {
-    it('should replace slashes with dashes', () => {
-      expect(escapeProjectPath('/Users/test/project')).toBe('Users-test-project');
-    });
-
-    it('should handle single leading slash', () => {
-      expect(escapeProjectPath('/project')).toBe('project');
-    });
-
-    it('should handle no leading slash', () => {
-      expect(escapeProjectPath('Users/test/project')).toBe('Users-test-project');
-    });
-
-    it('should handle multiple slashes', () => {
-      expect(escapeProjectPath('/a/b/c/d')).toBe('a-b-c-d');
-    });
-  });
-
-  describe('getSessionFilePath', () => {
-    it('should construct correct session file path', () => {
-      const sessionId = '550e8400-e29b-41d4-a716-446655440000';
-      const cwd = '/Users/test/myproject';
-
-      const result = getSessionFilePath(sessionId, cwd);
-
-      expect(result).toBe(
-        path.join(os.homedir(), '.claude', 'projects', 'Users-test-myproject', '550e8400-e29b-41d4-a716-446655440000.jsonl')
-      );
-    });
-  });
-
-  describe('parseSessionFile', () => {
-    it('should return error when file does not exist', () => {
-      const result = parseSessionFile(path.join(tempDir, 'nonexistent.jsonl'));
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('not found');
-      expect(result.usage.inputTokens).toBe(0);
-      expect(result.usage.outputTokens).toBe(0);
-    });
-
-    it('should parse empty session file', () => {
-      const filePath = path.join(tempDir, 'empty.jsonl');
-      fs.writeFileSync(filePath, '');
-
-      const result = parseSessionFile(filePath);
-
-      expect(result.success).toBe(true);
-      expect(result.usage.inputTokens).toBe(0);
-      expect(result.usage.outputTokens).toBe(0);
-    });
-
-    it('should parse single assistant message entry', () => {
-      const filePath = path.join(tempDir, 'single.jsonl');
-      const entry = {
-        type: 'assistant',
-        message: {
-          model: 'claude-sonnet-4-5',
-          usage: {
-            input_tokens: 1000,
-            output_tokens: 500,
-            cache_read_input_tokens: 100,
-            cache_creation_input_tokens: 50,
-          },
-        },
-      };
-      fs.writeFileSync(filePath, JSON.stringify(entry) + '\n');
-
-      const result = parseSessionFile(filePath);
-
-      expect(result.success).toBe(true);
-      expect(result.usage.inputTokens).toBe(1000);
-      expect(result.usage.outputTokens).toBe(500);
-      expect(result.usage.cacheReadInputTokens).toBe(100);
-      expect(result.usage.cacheCreationInputTokens).toBe(50);
-      expect(result.usage.modelUsage['claude-sonnet-4-5']?.inputTokens).toBe(1000);
-    });
-
-    it('should accumulate multiple assistant messages', () => {
-      const filePath = path.join(tempDir, 'multiple.jsonl');
-      const entry1 = {
-        type: 'assistant',
-        message: {
-          model: 'claude-sonnet-4-5',
-          usage: {
-            input_tokens: 1000,
-            output_tokens: 500,
-          },
-        },
-      };
-      const entry2 = {
-        type: 'assistant',
-        message: {
-          model: 'claude-sonnet-4-5',
-          usage: {
-            input_tokens: 2000,
-            output_tokens: 1000,
-          },
-        },
-      };
-      fs.writeFileSync(filePath, JSON.stringify(entry1) + '\n' + JSON.stringify(entry2) + '\n');
-
-      const result = parseSessionFile(filePath);
-
-      expect(result.success).toBe(true);
-      expect(result.usage.inputTokens).toBe(3000);
-      expect(result.usage.outputTokens).toBe(1500);
-      expect(result.usage.modelUsage['claude-sonnet-4-5']?.inputTokens).toBe(3000);
-    });
-
-    it('should handle different models in same session', () => {
-      const filePath = path.join(tempDir, 'multi-model.jsonl');
-      const entry1 = {
-        type: 'assistant',
-        message: {
-          model: 'claude-sonnet-4-5',
-          usage: {
-            input_tokens: 1000,
-            output_tokens: 500,
-          },
-        },
-      };
-      const entry2 = {
-        type: 'assistant',
-        message: {
-          model: 'claude-haiku-4-5',
-          usage: {
-            input_tokens: 500,
-            output_tokens: 200,
-          },
-        },
-      };
-      fs.writeFileSync(filePath, JSON.stringify(entry1) + '\n' + JSON.stringify(entry2) + '\n');
-
-      const result = parseSessionFile(filePath);
-
-      expect(result.success).toBe(true);
-      expect(result.usage.inputTokens).toBe(1500);
-      expect(result.usage.outputTokens).toBe(700);
-      expect(result.usage.modelUsage['claude-sonnet-4-5']?.inputTokens).toBe(1000);
-      expect(result.usage.modelUsage['claude-haiku-4-5']?.inputTokens).toBe(500);
-    });
-
-    it('should skip non-assistant entries', () => {
-      const filePath = path.join(tempDir, 'mixed.jsonl');
-      const userEntry = { type: 'user', message: { content: 'hello' } };
-      const assistantEntry = {
-        type: 'assistant',
-        message: {
-          model: 'claude-sonnet-4-5',
-          usage: {
-            input_tokens: 1000,
-            output_tokens: 500,
-          },
-        },
-      };
-      const systemEntry = { type: 'system', data: {} };
-      fs.writeFileSync(
-        filePath,
-        JSON.stringify(userEntry) + '\n' + JSON.stringify(assistantEntry) + '\n' + JSON.stringify(systemEntry) + '\n'
-      );
-
-      const result = parseSessionFile(filePath);
-
-      expect(result.success).toBe(true);
-      expect(result.usage.inputTokens).toBe(1000);
-      expect(result.usage.outputTokens).toBe(500);
-    });
-
-    it('should skip malformed JSON lines', () => {
-      const filePath = path.join(tempDir, 'malformed.jsonl');
-      const goodEntry = {
-        type: 'assistant',
-        message: {
-          model: 'claude-sonnet-4-5',
-          usage: {
-            input_tokens: 1000,
-            output_tokens: 500,
-          },
-        },
-      };
-      fs.writeFileSync(
-        filePath,
-        'not valid json\n' + JSON.stringify(goodEntry) + '\n' + '{ broken }\n'
-      );
-
-      const result = parseSessionFile(filePath);
-
-      expect(result.success).toBe(true);
-      expect(result.usage.inputTokens).toBe(1000);
-      expect(result.usage.outputTokens).toBe(500);
-    });
-
-    it('should handle entries without usage data', () => {
-      const filePath = path.join(tempDir, 'no-usage.jsonl');
-      const entryWithUsage = {
-        type: 'assistant',
-        message: {
-          model: 'claude-sonnet-4-5',
-          usage: {
-            input_tokens: 1000,
-            output_tokens: 500,
-          },
-        },
-      };
-      const entryWithoutUsage = {
-        type: 'assistant',
-        message: {
-          model: 'claude-sonnet-4-5',
-        },
-      };
-      fs.writeFileSync(
-        filePath,
-        JSON.stringify(entryWithUsage) + '\n' + JSON.stringify(entryWithoutUsage) + '\n'
-      );
-
-      const result = parseSessionFile(filePath);
-
-      expect(result.success).toBe(true);
-      expect(result.usage.inputTokens).toBe(1000);
-    });
-
-    it('should handle entries without model', () => {
-      const filePath = path.join(tempDir, 'no-model.jsonl');
-      const entry = {
-        type: 'assistant',
-        message: {
-          usage: {
-            input_tokens: 1000,
-            output_tokens: 500,
-          },
-        },
-      };
-      fs.writeFileSync(filePath, JSON.stringify(entry) + '\n');
-
-      const result = parseSessionFile(filePath);
-
-      expect(result.success).toBe(true);
-      expect(result.usage.inputTokens).toBe(1000);
-      expect(result.usage.outputTokens).toBe(500);
-      // modelUsage should be empty since no model specified
-      expect(Object.keys(result.usage.modelUsage)).toHaveLength(0);
-    });
-  });
-
-  describe('parseSessionById', () => {
-    it('should combine getSessionFilePath and parseSessionFile', () => {
-      // Create the expected directory structure
-      const sessionId = 'test-session-id';
-      const cwd = tempDir;
-      const escapedPath = cwd.replace(/^\//, '').replace(/\//g, '-');
-      const projectsDir = path.join(tempDir, '.claude', 'projects', escapedPath);
-      fs.mkdirSync(projectsDir, { recursive: true });
-
-      // Create a session file
-      const entry = {
-        type: 'assistant',
-        message: {
-          model: 'claude-opus-4-6',
-          usage: {
-            input_tokens: 5000,
-            output_tokens: 2000,
-          },
-        },
-      };
-      fs.writeFileSync(path.join(projectsDir, `${sessionId}.jsonl`), JSON.stringify(entry) + '\n');
-
-      // Mock os.homedir to return tempDir
-      // Since we can't easily mock, we'll test parseSessionFile directly
-      // and just verify parseSessionById calls it correctly by testing with the expected path
-      const expectedPath = getSessionFilePath(sessionId, cwd);
-
-      // This will fail because the path is relative to actual homedir, but demonstrates the logic
-      const result = parseSessionById(sessionId, cwd);
-
-      // Will return error since file doesn't exist at real homedir path
-      expect(result.success).toBe(false);
-    });
-  });
-});