rafcode 1.2.0 → 2.0.0

package/tests/unit/post-execution-picker.test.ts

@@ -0,0 +1,251 @@
+import { jest } from '@jest/globals';
+
+// Mock @inquirer/prompts before importing the module
+const mockSelect = jest.fn();
+jest.unstable_mockModule('@inquirer/prompts', () => ({
+  select: mockSelect,
+}));
+
+// Mock logger
+const mockLoggerInfo = jest.fn();
+const mockLoggerWarn = jest.fn();
+const mockLoggerSuccess = jest.fn();
+const mockLoggerNewline = jest.fn();
+jest.unstable_mockModule('../../src/utils/logger.js', () => ({
+  logger: {
+    debug: jest.fn(),
+    info: mockLoggerInfo,
+    warn: mockLoggerWarn,
+    error: jest.fn(),
+    success: mockLoggerSuccess,
+    newline: mockLoggerNewline,
+    configure: jest.fn(),
+    setContext: jest.fn(),
+    clearContext: jest.fn(),
+  },
+}));
+
+// Mock pull-request module
+const mockPrPreflight = jest.fn();
+const mockCreatePullRequest = jest.fn();
+jest.unstable_mockModule('../../src/core/pull-request.js', () => ({
+  prPreflight: mockPrPreflight,
+  createPullRequest: mockCreatePullRequest,
+  generatePrBody: jest.fn(),
+  generatePrTitle: jest.fn(),
+  detectBaseBranch: jest.fn(),
+  readProjectContext: jest.fn(),
+  isGhInstalled: jest.fn(),
+  isGhAuthenticated: jest.fn(),
+  isGitHubRemote: jest.fn(),
+  isBranchPushed: jest.fn(),
+  pushBranch: jest.fn(),
+}));
+
+// Mock worktree module
+const mockMergeWorktreeBranch = jest.fn();
+const mockRemoveWorktree = jest.fn();
+jest.unstable_mockModule('../../src/core/worktree.js', () => ({
+  getRepoRoot: jest.fn(),
+  getRepoBasename: jest.fn(),
+  getCurrentBranch: jest.fn(),
+  computeWorktreePath: jest.fn(),
+  computeWorktreeBaseDir: jest.fn(),
+  validateWorktree: jest.fn(),
+  listWorktreeProjects: jest.fn(),
+  mergeWorktreeBranch: mockMergeWorktreeBranch,
+  removeWorktree: mockRemoveWorktree,
+  createWorktree: jest.fn(),
+  createWorktreeFromBranch: jest.fn(),
+  branchExists: jest.fn(),
+  getWorktreeProjectPath: jest.fn(),
+}));
+
+// Import after mocking
+const { pickPostExecutionAction } = await import('../../src/commands/do.js');
+import type { PostExecutionAction } from '../../src/commands/do.js';
+
+describe('pickPostExecutionAction', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should present three choices: merge, PR, leave', async () => {
+    mockSelect.mockResolvedValue('leave');
+
+    await pickPostExecutionAction('/path/to/worktree/acbfhg-my-project');
+
+    expect(mockSelect).toHaveBeenCalledWith({
+      message: expect.stringContaining('acbfhg-my-project'),
+      choices: [
+        { name: 'Merge into current branch', value: 'merge' },
+        { name: 'Create a GitHub PR', value: 'pr' },
+        { name: 'Leave branch as-is', value: 'leave' },
+      ],
+    });
+  });
+
+  it('should return "merge" when user selects merge', async () => {
+    mockSelect.mockResolvedValue('merge');
+
+    const result = await pickPostExecutionAction('/path/to/worktree/acbfhg-my-project');
+
+    expect(result).toBe('merge');
+  });
+
+  it('should return "leave" when user selects leave', async () => {
+    mockSelect.mockResolvedValue('leave');
+
+    const result = await pickPostExecutionAction('/path/to/worktree/acbfhg-my-project');
+
+    expect(result).toBe('leave');
+  });
+
+  it('should return "pr" when user selects PR and preflight passes', async () => {
+    mockSelect.mockResolvedValue('pr');
+    mockPrPreflight.mockReturnValue({ ready: true, ghInstalled: true, ghAuthenticated: true, isGitHubRemote: true, branchPushed: false });
+
+    const result = await pickPostExecutionAction('/path/to/worktree/acbfhg-my-project');
+
+    expect(result).toBe('pr');
+  });
+
+  it('should run PR preflight when PR is selected', async () => {
+    mockSelect.mockResolvedValue('pr');
+    mockPrPreflight.mockReturnValue({ ready: true, ghInstalled: true, ghAuthenticated: true, isGitHubRemote: true, branchPushed: false });
+
+    await pickPostExecutionAction('/path/to/worktree/acbfhg-my-project');
+
+    expect(mockPrPreflight).toHaveBeenCalledWith('acbfhg-my-project', '/path/to/worktree/acbfhg-my-project');
+  });
+
+  it('should fall back to "leave" when PR preflight fails', async () => {
+    mockSelect.mockResolvedValue('pr');
+    mockPrPreflight.mockReturnValue({
+      ready: false,
+      ghInstalled: false,
+      ghAuthenticated: false,
+      isGitHubRemote: false,
+      branchPushed: false,
+      error: 'GitHub CLI (gh) is not installed.',
+    });
+
+    const result = await pickPostExecutionAction('/path/to/worktree/acbfhg-my-project');
+
+    expect(result).toBe('leave');
+    expect(mockLoggerWarn).toHaveBeenCalledWith(expect.stringContaining('PR preflight failed'));
+    expect(mockLoggerWarn).toHaveBeenCalledWith(expect.stringContaining('Leave branch'));
+  });
+
+  it('should not run preflight for merge choice', async () => {
+    mockSelect.mockResolvedValue('merge');
+
+    await pickPostExecutionAction('/path/to/worktree/acbfhg-my-project');
+
+    expect(mockPrPreflight).not.toHaveBeenCalled();
+  });
+
+  it('should not run preflight for leave choice', async () => {
+    mockSelect.mockResolvedValue('leave');
+
+    await pickPostExecutionAction('/path/to/worktree/acbfhg-my-project');
+
+    expect(mockPrPreflight).not.toHaveBeenCalled();
+  });
+
+  it('should use branch name from worktree path in picker message', async () => {
+    mockSelect.mockResolvedValue('leave');
+
+    await pickPostExecutionAction('/home/user/.raf/worktrees/myapp/aaabcd-feature-x');
+
+    expect(mockSelect).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringContaining('aaabcd-feature-x'),
+      })
+    );
+  });
+});
+
+describe('PostExecutionAction type', () => {
+  it('should accept valid action values', () => {
+    const merge: PostExecutionAction = 'merge';
+    const pr: PostExecutionAction = 'pr';
+    const leave: PostExecutionAction = 'leave';
+
+    expect(merge).toBe('merge');
+    expect(pr).toBe('pr');
+    expect(leave).toBe('leave');
+  });
+});
+
+describe('post-execution action dispatch logic', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('merge action', () => {
+    it('should clean up worktree before merge', () => {
+      // The merge action calls removeWorktree first, then mergeWorktreeBranch
+      // We verify the expected call sequence
+      mockRemoveWorktree.mockReturnValue({ success: true });
+      mockMergeWorktreeBranch.mockReturnValue({ success: true, merged: true, fastForward: true });
+
+      // Simulate the merge action dispatch
+      const action: PostExecutionAction = 'merge';
+      expect(action).toBe('merge');
+
+      // Verify removeWorktree behavior
+      const cleanup = mockRemoveWorktree('/path/to/worktree');
+      expect(mockRemoveWorktree).toHaveBeenCalled();
+    });
+  });
+
+  describe('PR action', () => {
+    it('should NOT clean up worktree after PR creation', () => {
+      // PR action should preserve the worktree for follow-up changes
+      const action: PostExecutionAction = 'pr';
+      expect(action).toBe('pr');
+      // This is verified by the absence of removeWorktree call in executePostAction for PR
+    });
+  });
+
+  describe('leave action', () => {
+    it('should clean up worktree directory', () => {
+      mockRemoveWorktree.mockReturnValue({ success: true });
+
+      const action: PostExecutionAction = 'leave';
+      expect(action).toBe('leave');
+
+      // Verify removeWorktree behavior
+      mockRemoveWorktree('/path/to/worktree');
+      expect(mockRemoveWorktree).toHaveBeenCalled();
+    });
+  });
+
+  describe('action skipped on failure', () => {
+    it('should identify when action should be skipped', () => {
+      const resultSuccess = false;
+      const postAction: PostExecutionAction = 'merge';
+
+      // This mirrors the logic in runDoCommand
+      const shouldSkip = !resultSuccess && postAction !== 'leave';
+      expect(shouldSkip).toBe(true);
+    });
+
+    it('should not show skip message for leave action on failure', () => {
+      const resultSuccess = false;
+      const postAction: PostExecutionAction = 'leave';
+
+      const shouldSkip = !resultSuccess && postAction !== 'leave';
+      expect(shouldSkip).toBe(false);
+    });
+
+    it('should not skip when execution succeeds', () => {
+      const resultSuccess = true;
+      const postAction: PostExecutionAction = 'merge';
+
+      const shouldExecute = resultSuccess;
+      expect(shouldExecute).toBe(true);
+    });
+  });
+});

package/tests/unit/project-manager.test.ts

@@ -2,6 +2,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
 import { ProjectManager } from '../../src/core/project-manager.js';
+import { encodeBase26, RAF_EPOCH } from '../../src/utils/paths.js';
 
 describe('ProjectManager', () => {
   let tempDir: string;
@@ -29,21 +30,31 @@ describe('ProjectManager', () => {
       expect(fs.existsSync(path.join(projectPath, 'decisions.md'))).toBe(true);
     });
 
-    it('should auto-increment project numbers', () => {
+    it('should create projects with epoch-based IDs', () => {
       const manager = new ProjectManager();
 
       const path1 = manager.createProject('first');
       const path2 = manager.createProject('second');
 
-      expect(path.basename(path1)).toBe('001-first');
-      expect(path.basename(path2)).toBe('002-second');
+      const folder1 = path.basename(path1);
+      const folder2 = path.basename(path2);
+
+      // Both should have 6-char base26 prefix followed by hyphen and name
+      expect(folder1).toMatch(/^[a-z]{6}-first$/);
+      expect(folder2).toMatch(/^[a-z]{6}-second$/);
+
+      // Second should have equal or greater prefix than first (timestamp-based)
+      const prefix1 = folder1.split('-')[0]!;
+      const prefix2 = folder2.split('-')[0]!;
+      expect(prefix2 >= prefix1).toBe(true);
     });
 
     it('should sanitize project names', () => {
       const manager = new ProjectManager();
       const projectPath = manager.createProject('My Project Name!');
 
-      expect(path.basename(projectPath)).toBe('001-my-project-name');
+      const folder = path.basename(projectPath);
+      expect(folder).toMatch(/^[a-z]{6}-my-project-name$/);
     });
   });
 
@@ -54,7 +65,8 @@ describe('ProjectManager', () => {
 
       const found = manager.findProject('findme');
       expect(found).not.toBeNull();
-      expect(found).toContain('001-findme');
+      expect(found).toContain('-findme');
+      expect(path.basename(found!)).toMatch(/^[a-z]{6}-findme$/);
     });
 
     it('should return null for non-existent project', () => {
@@ -87,12 +99,12 @@ describe('ProjectManager', () => {
       const projectPath = manager.createProject('test');
 
       // Create plan 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');
 
       // Create outcome with COMPLETE promise marker
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-task.md'),
+        path.join(projectPath, 'outcomes', '01-task.md'),
         '# Task 001 - Completed\n\n<promise>COMPLETE</promise>'
       );