rafcode 1.3.2 → 2.0.0

package/tests/unit/do-rerun.test.ts

@@ -18,7 +18,7 @@ describe('do command rerun functionality', () => {
 
   beforeEach(() => {
     tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-do-rerun-test-'));
-    projectPath = path.join(tempDir, '001-test-project');
+    projectPath = path.join(tempDir, 'aaaaab-test-project');
     fs.mkdirSync(projectPath, { recursive: true });
     fs.mkdirSync(path.join(projectPath, 'plans'), { recursive: true });
     fs.mkdirSync(path.join(projectPath, 'outcomes'), { recursive: true });
@@ -32,102 +32,102 @@ describe('do command rerun functionality', () => {
   describe('skip completed tasks', () => {
     it('should skip tasks with SUCCESS outcome', () => {
       // Set up plans
-      fs.writeFileSync(path.join(projectPath, 'plans', '001-task.md'), '# Task 1');
-      fs.writeFileSync(path.join(projectPath, 'plans', '002-task.md'), '# Task 2');
-      fs.writeFileSync(path.join(projectPath, 'plans', '003-task.md'), '# Task 3');
+      fs.writeFileSync(path.join(projectPath, 'plans', '01-task.md'), '# Task 1');
+      fs.writeFileSync(path.join(projectPath, 'plans', '02-task.md'), '# Task 2');
+      fs.writeFileSync(path.join(projectPath, 'plans', '03-task.md'), '# Task 3');
 
       // Mark first task as complete
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-task.md'),
-        '# Task 001 - Completed\n\n<promise>COMPLETE</promise>'
+        path.join(projectPath, 'outcomes', '01-task.md'),
+        '# Task 01 - Completed\n\n<promise>COMPLETE</promise>'
       );
 
       const state = deriveProjectState(projectPath);
       const nextTask = getNextExecutableTask(state);
 
-      expect(nextTask?.id).toBe('002');
+      expect(nextTask?.id).toBe('02');
       expect(nextTask?.status).toBe('pending');
     });
 
     it('should skip multiple completed tasks', () => {
-      fs.writeFileSync(path.join(projectPath, 'plans', '001-task.md'), '# Task 1');
-      fs.writeFileSync(path.join(projectPath, 'plans', '002-task.md'), '# Task 2');
-      fs.writeFileSync(path.join(projectPath, 'plans', '003-task.md'), '# Task 3');
+      fs.writeFileSync(path.join(projectPath, 'plans', '01-task.md'), '# Task 1');
+      fs.writeFileSync(path.join(projectPath, 'plans', '02-task.md'), '# Task 2');
+      fs.writeFileSync(path.join(projectPath, 'plans', '03-task.md'), '# Task 3');
 
       // Mark first two tasks as complete
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-task.md'),
-        '# Task 001 - Completed\n\n<promise>COMPLETE</promise>'
+        path.join(projectPath, 'outcomes', '01-task.md'),
+        '# Task 01 - Completed\n\n<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '002-task.md'),
-        '# Task 002 - Completed\n\n<promise>COMPLETE</promise>'
+        path.join(projectPath, 'outcomes', '02-task.md'),
+        '# Task 02 - Completed\n\n<promise>COMPLETE</promise>'
       );
 
       const state = deriveProjectState(projectPath);
       const nextTask = getNextExecutableTask(state);
 
-      expect(nextTask?.id).toBe('003');
+      expect(nextTask?.id).toBe('03');
     });
   });
 
   describe('retry failed tasks', () => {
     it('should retry tasks with FAILED outcome', () => {
-      fs.writeFileSync(path.join(projectPath, 'plans', '001-task.md'), '# Task 1');
-      fs.writeFileSync(path.join(projectPath, 'plans', '002-task.md'), '# Task 2');
+      fs.writeFileSync(path.join(projectPath, 'plans', '01-task.md'), '# Task 1');
+      fs.writeFileSync(path.join(projectPath, 'plans', '02-task.md'), '# Task 2');
 
       // Mark first task as failed
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-task.md'),
-        '# Task 001 - Failed\n\n<promise>FAILED</promise>'
+        path.join(projectPath, 'outcomes', '01-task.md'),
+        '# Task 01 - Failed\n\n<promise>FAILED</promise>'
       );
 
       const state = deriveProjectState(projectPath);
       const nextTask = getNextExecutableTask(state);
 
       // Should return the pending task first, then failed
-      expect(nextTask?.id).toBe('002');
+      expect(nextTask?.id).toBe('02');
       expect(nextTask?.status).toBe('pending');
     });
 
     it('should retry failed task when no pending tasks remain', () => {
-      fs.writeFileSync(path.join(projectPath, 'plans', '001-task.md'), '# Task 1');
-      fs.writeFileSync(path.join(projectPath, 'plans', '002-task.md'), '# Task 2');
+      fs.writeFileSync(path.join(projectPath, 'plans', '01-task.md'), '# Task 1');
+      fs.writeFileSync(path.join(projectPath, 'plans', '02-task.md'), '# Task 2');
 
       // Mark first as complete, second as failed
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-task.md'),
-        '# Task 001 - Completed\n\n<promise>COMPLETE</promise>'
+        path.join(projectPath, 'outcomes', '01-task.md'),
+        '# Task 01 - Completed\n\n<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '002-task.md'),
-        '# Task 002 - Failed\n\n<promise>FAILED</promise>'
+        path.join(projectPath, 'outcomes', '02-task.md'),
+        '# Task 02 - Failed\n\n<promise>FAILED</promise>'
       );
 
       const state = deriveProjectState(projectPath);
       const nextTask = getNextExecutableTask(state);
 
-      expect(nextTask?.id).toBe('002');
+      expect(nextTask?.id).toBe('02');
       expect(nextTask?.status).toBe('failed');
     });
   });
 
   describe('run pending tasks', () => {
     it('should run tasks without outcome files', () => {
-      fs.writeFileSync(path.join(projectPath, 'plans', '001-task.md'), '# Task 1');
-      fs.writeFileSync(path.join(projectPath, 'plans', '002-task.md'), '# Task 2');
+      fs.writeFileSync(path.join(projectPath, 'plans', '01-task.md'), '# Task 1');
+      fs.writeFileSync(path.join(projectPath, 'plans', '02-task.md'), '# Task 2');
 
       const state = deriveProjectState(projectPath);
       const nextTask = getNextExecutableTask(state);
 
-      expect(nextTask?.id).toBe('001');
+      expect(nextTask?.id).toBe('01');
       expect(nextTask?.status).toBe('pending');
     });
 
     it('should handle outcome file without status marker as pending', () => {
-      fs.writeFileSync(path.join(projectPath, 'plans', '001-task.md'), '# Task 1');
+      fs.writeFileSync(path.join(projectPath, 'plans', '01-task.md'), '# Task 1');
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-task.md'),
+        path.join(projectPath, 'outcomes', '01-task.md'),
         '# Old format without status marker'
       );
 
@@ -137,8 +137,8 @@ describe('do command rerun functionality', () => {
     });
 
     it('should handle empty outcome file as pending', () => {
-      fs.writeFileSync(path.join(projectPath, 'plans', '001-task.md'), '# Task 1');
-      fs.writeFileSync(path.join(projectPath, 'outcomes', '001-task.md'), '');
+      fs.writeFileSync(path.join(projectPath, 'plans', '01-task.md'), '# Task 1');
+      fs.writeFileSync(path.join(projectPath, 'outcomes', '01-task.md'), '');
 
       const state = deriveProjectState(projectPath);
 
@@ -148,16 +148,16 @@ describe('do command rerun functionality', () => {
 
   describe('all complete detection', () => {
     it('should detect all tasks completed', () => {
-      fs.writeFileSync(path.join(projectPath, 'plans', '001-task.md'), '# Task 1');
-      fs.writeFileSync(path.join(projectPath, 'plans', '002-task.md'), '# Task 2');
+      fs.writeFileSync(path.join(projectPath, 'plans', '01-task.md'), '# Task 1');
+      fs.writeFileSync(path.join(projectPath, 'plans', '02-task.md'), '# Task 2');
 
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-task.md'),
-        '# Task 001 - Completed\n\n<promise>COMPLETE</promise>'
+        path.join(projectPath, 'outcomes', '01-task.md'),
+        '# Task 01 - Completed\n\n<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '002-task.md'),
-        '# Task 002 - Completed\n\n<promise>COMPLETE</promise>'
+        path.join(projectPath, 'outcomes', '02-task.md'),
+        '# Task 02 - Completed\n\n<promise>COMPLETE</promise>'
       );
 
       const state = deriveProjectState(projectPath);
@@ -167,10 +167,10 @@ describe('do command rerun functionality', () => {
     });
 
     it('should not report complete when failed tasks exist', () => {
-      fs.writeFileSync(path.join(projectPath, 'plans', '001-task.md'), '# Task 1');
+      fs.writeFileSync(path.join(projectPath, 'plans', '01-task.md'), '# Task 1');
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-task.md'),
-        '# Task 001 - Failed\n\n<promise>FAILED</promise>'
+        path.join(projectPath, 'outcomes', '01-task.md'),
+        '# Task 01 - Failed\n\n<promise>FAILED</promise>'
       );
 
       const state = deriveProjectState(projectPath);
@@ -186,22 +186,22 @@ describe('do command rerun functionality', () => {
      * and returns tasks that haven't been completed in this session.
      */
     it('should identify all tasks for force mode execution', () => {
-      fs.writeFileSync(path.join(projectPath, 'plans', '001-task.md'), '# Task 1');
-      fs.writeFileSync(path.join(projectPath, 'plans', '002-task.md'), '# Task 2');
-      fs.writeFileSync(path.join(projectPath, 'plans', '003-task.md'), '# Task 3');
+      fs.writeFileSync(path.join(projectPath, 'plans', '01-task.md'), '# Task 1');
+      fs.writeFileSync(path.join(projectPath, 'plans', '02-task.md'), '# Task 2');
+      fs.writeFileSync(path.join(projectPath, 'plans', '03-task.md'), '# Task 3');
 
       // All tasks completed
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-task.md'),
-        '# Task 001 - Completed\n\n<promise>COMPLETE</promise>'
+        path.join(projectPath, 'outcomes', '01-task.md'),
+        '# Task 01 - Completed\n\n<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '002-task.md'),
-        '# Task 002 - Completed\n\n<promise>COMPLETE</promise>'
+        path.join(projectPath, 'outcomes', '02-task.md'),
+        '# Task 02 - Completed\n\n<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '003-task.md'),
-        '# Task 003 - Completed\n\n<promise>COMPLETE</promise>'
+        path.join(projectPath, 'outcomes', '03-task.md'),
+        '# Task 03 - Completed\n\n<promise>COMPLETE</promise>'
       );
 
       const state = deriveProjectState(projectPath);
@@ -224,19 +224,19 @@ describe('do command rerun functionality', () => {
         return null;
       }
 
-      // First iteration - should get task 001
+      // First iteration - should get task 01
       let task = getNextForceTask(state, completedInSession);
-      expect(task?.id).toBe('001');
+      expect(task?.id).toBe('01');
       completedInSession.add(task!.id);
 
-      // Second iteration - should get task 002
+      // Second iteration - should get task 02
       task = getNextForceTask(state, completedInSession);
-      expect(task?.id).toBe('002');
+      expect(task?.id).toBe('02');
       completedInSession.add(task!.id);
 
-      // Third iteration - should get task 003
+      // Third iteration - should get task 03
       task = getNextForceTask(state, completedInSession);
-      expect(task?.id).toBe('003');
+      expect(task?.id).toBe('03');
       completedInSession.add(task!.id);
 
       // Fourth iteration - no more tasks
@@ -247,23 +247,23 @@ describe('do command rerun functionality', () => {
 
   describe('task status logging', () => {
     it('should identify failed tasks for retry logging', () => {
-      fs.writeFileSync(path.join(projectPath, 'plans', '001-task.md'), '# Task 1');
-      fs.writeFileSync(path.join(projectPath, 'plans', '002-task.md'), '# Task 2');
+      fs.writeFileSync(path.join(projectPath, 'plans', '01-task.md'), '# Task 1');
+      fs.writeFileSync(path.join(projectPath, 'plans', '02-task.md'), '# Task 2');
 
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-task.md'),
-        '# Task 001 - Completed\n\n<promise>COMPLETE</promise>'
+        path.join(projectPath, 'outcomes', '01-task.md'),
+        '# Task 01 - Completed\n\n<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '002-task.md'),
-        '# Task 002 - Failed\n\n<promise>FAILED</promise>'
+        path.join(projectPath, 'outcomes', '02-task.md'),
+        '# Task 02 - Failed\n\n<promise>FAILED</promise>'
       );
 
       const state = deriveProjectState(projectPath);
       const nextTask = getNextExecutableTask(state);
 
       // The task being retried should have failed status
-      expect(nextTask?.id).toBe('002');
+      expect(nextTask?.id).toBe('02');
       expect(nextTask?.status).toBe('failed');
     });
   });

package/tests/unit/do-worktree-cleanup.test.ts

@@ -0,0 +1,151 @@
+import { jest } from '@jest/globals';
+
+/**
+ * Tests for worktree cleanup logic in the do command.
+ *
+ * The cleanup flow in runDoCommand:
+ * 1. After executeSingleProject() returns
+ * 2. Post-execution action (merge/pr/leave) is executed via executePostAction()
+ * 3. Cleanup happens as part of the post-action: merge and leave clean up, PR does not
+ * 4. If cleanup fails, warn but don't error
+ *
+ * Since runDoCommand is not exported, we test the logic indirectly by
+ * verifying removeWorktree behavior and the conditions under which
+ * cleanup should/should not occur.
+ */
+
+// Mock execSync before importing the module
+const mockExecSync = jest.fn();
+jest.unstable_mockModule('node:child_process', () => ({
+  execSync: mockExecSync,
+}));
+
+// Mock fs
+const mockExistsSync = jest.fn();
+const mockMkdirSync = jest.fn();
+const mockReaddirSync = jest.fn();
+jest.unstable_mockModule('node:fs', () => ({
+  existsSync: mockExistsSync,
+  mkdirSync: mockMkdirSync,
+  readdirSync: mockReaddirSync,
+}));
+
+// Mock logger
+const mockLoggerInfo = jest.fn();
+const mockLoggerWarn = jest.fn();
+jest.unstable_mockModule('../../src/utils/logger.js', () => ({
+  logger: {
+    debug: jest.fn(),
+    info: mockLoggerInfo,
+    warn: mockLoggerWarn,
+    error: jest.fn(),
+  },
+}));
+
+const { removeWorktree, mergeWorktreeBranch } = await import('../../src/core/worktree.js');
+
+describe('worktree cleanup after successful execution', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('removeWorktree preserves branch', () => {
+    it('should only call git worktree remove, not git branch delete', () => {
+      mockExecSync.mockReturnValue('');
+
+      removeWorktree('/path/to/worktree');
+
+      // Should call git worktree remove
+      expect(mockExecSync).toHaveBeenCalledTimes(1);
+      expect(mockExecSync).toHaveBeenCalledWith(
+        'git worktree remove "/path/to/worktree"',
+        expect.any(Object)
+      );
+      // Should NOT call git branch -d or -D
+      const calls = mockExecSync.mock.calls.map((c: unknown[]) => c[0] as string);
+      expect(calls.every((cmd: string) => !cmd.includes('branch -d') && !cmd.includes('branch -D'))).toBe(true);
+    });
+  });
+
+  describe('cleanup decision logic', () => {
+    /**
+     * Simulate the cleanup decision from runDoCommand:
+     *   if (worktreeMode && worktreeRoot && result.success) { removeWorktree(...) }
+     */
+    function shouldCleanup(worktreeMode: boolean, worktreeRoot: string | undefined, resultSuccess: boolean): boolean {
+      return worktreeMode && !!worktreeRoot && resultSuccess;
+    }
+
+    it('should clean up when worktree mode is active and execution succeeds', () => {
+      expect(shouldCleanup(true, '/path/to/worktree', true)).toBe(true);
+    });
+
+    it('should NOT clean up when execution fails', () => {
+      expect(shouldCleanup(true, '/path/to/worktree', false)).toBe(false);
+    });
+
+    it('should NOT clean up when not in worktree mode', () => {
+      expect(shouldCleanup(false, '/path/to/worktree', true)).toBe(false);
+    });
+
+    it('should NOT clean up when worktreeRoot is undefined', () => {
+      expect(shouldCleanup(true, undefined, true)).toBe(false);
+    });
+  });
+
+  describe('cleanup failure handling', () => {
+    it('should return success:false with error message when removal fails', () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('worktree is dirty');
+      });
+
+      const result = removeWorktree('/path/to/dirty/worktree');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Failed to remove worktree');
+      expect(result.error).toContain('worktree is dirty');
+    });
+
+    it('should return success:true when removal succeeds', () => {
+      mockExecSync.mockReturnValue('');
+
+      const result = removeWorktree('/path/to/clean/worktree');
+
+      expect(result.success).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+  });
+
+  describe('merge after cleanup', () => {
+    /**
+     * The merge step uses the branch name (path.basename(worktreeRoot)),
+     * not the worktree directory itself. This verifies that merge can
+     * work independently of the worktree directory existing.
+     */
+    it('should use branch name for merge, not worktree directory', () => {
+      // Simulate: worktreeRoot = '/home/user/.raf/worktrees/myapp/abcabc-prune-cycle'
+      // mergeWorktreeBranch uses: path.basename(worktreeRoot) = 'abcabc-prune-cycle'
+
+      // Mock successful checkout and ff merge
+      mockExecSync.mockImplementation((cmd: unknown) => {
+        const cmdStr = cmd as string;
+        if (cmdStr.includes('checkout')) return '';
+        if (cmdStr.includes('--ff-only')) return '';
+        return '';
+      });
+
+      const result = mergeWorktreeBranch('abcabc-prune-cycle', 'main');
+
+      expect(result.success).toBe(true);
+      // Verify git checkout was called with the branch name, not a path
+      expect(mockExecSync).toHaveBeenCalledWith(
+        'git checkout "main"',
+        expect.any(Object)
+      );
+      expect(mockExecSync).toHaveBeenCalledWith(
+        'git merge --ff-only "abcabc-prune-cycle"',
+        expect.any(Object)
+      );
+    });
+  });
+});