rafcode 1.2.0 → 2.0.0

package/tests/unit/status-command.test.ts

@@ -1,8 +1,13 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
-import { resolveProjectIdentifier, extractProjectName } from '../../src/utils/paths.js';
-import { discoverProjects } from '../../src/core/state-derivation.js';
+import { resolveProjectIdentifier, extractProjectName, encodeBase26 } from '../../src/utils/paths.js';
+import {
+  deriveProjectState,
+  getDerivedStats,
+  discoverProjects,
+  type DerivedProjectState,
+} from '../../src/core/state-derivation.js';
 
 describe('Status Command - Identifier Support', () => {
   let tempDir: string;
@@ -16,138 +21,117 @@ describe('Status Command - Identifier Support', () => {
   });
 
   describe('Identifier Resolution for Status', () => {
-    it('should resolve project by numeric ID', () => {
-      fs.mkdirSync(path.join(tempDir, '003-fix-bug'));
-      const result = resolveProjectIdentifier(tempDir, '3');
-      expect(result).toBe(path.join(tempDir, '003-fix-bug'));
-    });
-
-    it('should resolve project by zero-padded numeric ID', () => {
-      fs.mkdirSync(path.join(tempDir, '003-fix-bug'));
-      const result = resolveProjectIdentifier(tempDir, '003');
-      expect(result).toBe(path.join(tempDir, '003-fix-bug'));
-    });
-
-    it('should resolve project by base36 ID', () => {
-      fs.mkdirSync(path.join(tempDir, 'a00-large-project'));
-      const result = resolveProjectIdentifier(tempDir, 'a00');
-      expect(result).toBe(path.join(tempDir, 'a00-large-project'));
+    it('should resolve project by 6-char base26 ID', () => {
+      fs.mkdirSync(path.join(tempDir, 'aaaaad-fix-bug'));
+      const result = resolveProjectIdentifier(tempDir, 'aaaaad');
+      expect(result).toBe(path.join(tempDir, 'aaaaad-fix-bug'));
     });
 
     it('should resolve project by name', () => {
-      fs.mkdirSync(path.join(tempDir, '001-my-project'));
+      fs.mkdirSync(path.join(tempDir, 'aaaaab-my-project'));
       const result = resolveProjectIdentifier(tempDir, 'my-project');
-      expect(result).toBe(path.join(tempDir, '001-my-project'));
+      expect(result).toBe(path.join(tempDir, 'aaaaab-my-project'));
     });
 
-    it('should resolve project by full numeric folder name', () => {
-      fs.mkdirSync(path.join(tempDir, '001-fix-stuff'));
-      const result = resolveProjectIdentifier(tempDir, '001-fix-stuff');
-      expect(result).toBe(path.join(tempDir, '001-fix-stuff'));
+    it('should resolve project by full folder name', () => {
+      fs.mkdirSync(path.join(tempDir, 'aaaaab-fix-stuff'));
+      const result = resolveProjectIdentifier(tempDir, 'aaaaab-fix-stuff');
+      expect(result).toBe(path.join(tempDir, 'aaaaab-fix-stuff'));
     });
 
-    it('should resolve project by full base36 folder name', () => {
-      fs.mkdirSync(path.join(tempDir, 'a00-important'));
-      const result = resolveProjectIdentifier(tempDir, 'a00-important');
-      expect(result).toBe(path.join(tempDir, 'a00-important'));
+    it('should resolve project by full base26 folder name', () => {
+      fs.mkdirSync(path.join(tempDir, 'abcdef-important'));
+      const result = resolveProjectIdentifier(tempDir, 'abcdef-important');
+      expect(result).toBe(path.join(tempDir, 'abcdef-important'));
     });
 
     it('should return null for invalid identifier', () => {
-      fs.mkdirSync(path.join(tempDir, '001-my-project'));
+      fs.mkdirSync(path.join(tempDir, 'aaaaab-my-project'));
       const result = resolveProjectIdentifier(tempDir, 'non-existent');
       expect(result).toBeNull();
     });
 
     it('should handle case-insensitive folder matching for full folder names', () => {
-      fs.mkdirSync(path.join(tempDir, 'A01-My-Project'));
-      const result = resolveProjectIdentifier(tempDir, 'a01-my-project');
-      expect(result).toBe(path.join(tempDir, 'A01-My-Project'));
+      fs.mkdirSync(path.join(tempDir, 'ABCDEF-My-Project'));
+      const result = resolveProjectIdentifier(tempDir, 'abcdef-my-project');
+      expect(result).toBe(path.join(tempDir, 'ABCDEF-My-Project'));
     });
   });
 
   describe('Project Name Extraction', () => {
-    it('should extract project name from numeric folder', () => {
-      const projectPath = path.join(tempDir, '001-my-project');
+    it('should extract project name from 6-char prefix folder', () => {
+      const projectPath = path.join(tempDir, 'aaaaab-my-project');
       const name = extractProjectName(projectPath);
       expect(name).toBe('my-project');
     });
 
-    it('should extract project name from base36 folder', () => {
-      const projectPath = path.join(tempDir, 'a00-my-project');
+    it('should extract project name from base26 folder', () => {
+      const projectPath = path.join(tempDir, 'abcdef-my-project');
       const name = extractProjectName(projectPath);
       expect(name).toBe('my-project');
     });
+
+    it('should return null for old-format folder', () => {
+      const projectPath = path.join(tempDir, '001-my-project');
+      const name = extractProjectName(projectPath);
+      expect(name).toBeNull();
+    });
   });
 
   describe('All Identifier Formats Work', () => {
     beforeEach(() => {
-      // Create a numeric project
-      fs.mkdirSync(path.join(tempDir, '003-numeric-project'));
-      // Create a base36 project
-      fs.mkdirSync(path.join(tempDir, 'a01-base36-project'));
-    });
-
-    it('should work with number without leading zeros', () => {
-      expect(resolveProjectIdentifier(tempDir, '3')).toBe(path.join(tempDir, '003-numeric-project'));
+      // Create projects with 6-char base26 prefixes
+      fs.mkdirSync(path.join(tempDir, 'aaaaad-first-project'));
+      fs.mkdirSync(path.join(tempDir, 'abcdef-second-project'));
     });
 
-    it('should work with number with leading zeros', () => {
-      expect(resolveProjectIdentifier(tempDir, '003')).toBe(path.join(tempDir, '003-numeric-project'));
+    it('should work with 6-char base26 prefix', () => {
+      expect(resolveProjectIdentifier(tempDir, 'aaaaad')).toBe(path.join(tempDir, 'aaaaad-first-project'));
     });
 
-    it('should work with base36 prefix', () => {
-      expect(resolveProjectIdentifier(tempDir, 'a01')).toBe(path.join(tempDir, 'a01-base36-project'));
+    it('should work with 6-char base26 prefix for second project', () => {
+      expect(resolveProjectIdentifier(tempDir, 'abcdef')).toBe(path.join(tempDir, 'abcdef-second-project'));
     });
 
-    it('should work with project name for numeric project', () => {
-      expect(resolveProjectIdentifier(tempDir, 'numeric-project')).toBe(path.join(tempDir, '003-numeric-project'));
+    it('should work with project name for first project', () => {
+      expect(resolveProjectIdentifier(tempDir, 'first-project')).toBe(path.join(tempDir, 'aaaaad-first-project'));
     });
 
-    it('should work with project name for base36 project', () => {
-      expect(resolveProjectIdentifier(tempDir, 'base36-project')).toBe(path.join(tempDir, 'a01-base36-project'));
+    it('should work with project name for second project', () => {
+      expect(resolveProjectIdentifier(tempDir, 'second-project')).toBe(path.join(tempDir, 'abcdef-second-project'));
     });
 
-    it('should work with full numeric folder name', () => {
-      expect(resolveProjectIdentifier(tempDir, '003-numeric-project')).toBe(path.join(tempDir, '003-numeric-project'));
+    it('should work with full folder name (first project)', () => {
+      expect(resolveProjectIdentifier(tempDir, 'aaaaad-first-project')).toBe(path.join(tempDir, 'aaaaad-first-project'));
     });
 
-    it('should work with full base36 folder name', () => {
-      expect(resolveProjectIdentifier(tempDir, 'a01-base36-project')).toBe(path.join(tempDir, 'a01-base36-project'));
-    });
-
-    it('should work with numeric value of base36 project', () => {
-      // a01 = 1001 in base36 encoding
-      expect(resolveProjectIdentifier(tempDir, '1001')).toBe(path.join(tempDir, 'a01-base36-project'));
+    it('should work with full folder name (second project)', () => {
+      expect(resolveProjectIdentifier(tempDir, 'abcdef-second-project')).toBe(path.join(tempDir, 'abcdef-second-project'));
     });
   });
 
   describe('Error Cases', () => {
-    it('should return null for non-existent numeric ID', () => {
-      fs.mkdirSync(path.join(tempDir, '001-project'));
-      expect(resolveProjectIdentifier(tempDir, '999')).toBeNull();
-    });
-
-    it('should return null for non-existent base36 ID', () => {
-      fs.mkdirSync(path.join(tempDir, 'a00-project'));
-      expect(resolveProjectIdentifier(tempDir, 'b00')).toBeNull();
+    it('should return null for non-existent 6-char base26 ID', () => {
+      fs.mkdirSync(path.join(tempDir, 'aaaaab-project'));
+      expect(resolveProjectIdentifier(tempDir, 'aaabmm')).toBeNull();
     });
 
     it('should return null for non-existent project name', () => {
-      fs.mkdirSync(path.join(tempDir, '001-my-project'));
+      fs.mkdirSync(path.join(tempDir, 'aaaaab-my-project'));
       expect(resolveProjectIdentifier(tempDir, 'other-project')).toBeNull();
     });
 
     it('should return null for non-existent full folder name', () => {
-      fs.mkdirSync(path.join(tempDir, '001-my-project'));
-      expect(resolveProjectIdentifier(tempDir, '002-my-project')).toBeNull();
+      fs.mkdirSync(path.join(tempDir, 'aaaaab-my-project'));
+      expect(resolveProjectIdentifier(tempDir, 'aaaaac-my-project')).toBeNull();
     });
 
     it('should return null for empty RAF directory', () => {
-      expect(resolveProjectIdentifier(tempDir, '001')).toBeNull();
+      expect(resolveProjectIdentifier(tempDir, 'aaaaab')).toBeNull();
     });
 
     it('should return null for non-existent RAF directory', () => {
-      expect(resolveProjectIdentifier('/non/existent/path', '001')).toBeNull();
+      expect(resolveProjectIdentifier('/non/existent/path', 'aaaaab')).toBeNull();
     });
   });
 });
@@ -165,8 +149,8 @@ describe('Status Command - Truncation Behavior', () => {
   });
 
   function createProject(number: number, name: string): void {
-    const projectNumber = String(number).padStart(3, '0');
-    fs.mkdirSync(path.join(tempDir, `${projectNumber}-${name}`));
+    const projectPrefix = encodeBase26(number);
+    fs.mkdirSync(path.join(tempDir, `${projectPrefix}-${name}`));
   }
 
   describe('Project List Truncation Logic', () => {
@@ -269,3 +253,287 @@ describe('Status Command - Truncation Behavior', () => {
     });
   });
 });
+
+describe('Status Command - Worktree Discovery', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-wt-status-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  /**
+   * Helper to create a project with plans and optional outcomes.
+   */
+  function createProjectWithTasks(
+    baseDir: string,
+    projectFolder: string,
+    tasks: Array<{ id: string; name: string; status?: 'completed' | 'failed' | 'pending' }>
+  ): string {
+    const projectPath = path.join(baseDir, projectFolder);
+    fs.mkdirSync(path.join(projectPath, 'plans'), { recursive: true });
+    fs.mkdirSync(path.join(projectPath, 'outcomes'), { recursive: true });
+    fs.writeFileSync(path.join(projectPath, 'input.md'), '# Test Input\n');
+
+    for (const task of tasks) {
+      // Write plan file
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', `${task.id}-${task.name}.md`),
+        `# Task: ${task.name}\n\n## Objective\nTest task\n`
+      );
+
+      // Write outcome file if not pending
+      if (task.status === 'completed') {
+        fs.writeFileSync(
+          path.join(projectPath, 'outcomes', `${task.id}-${task.name}.md`),
+          `# Outcome\nCompleted.\n\n<promise>COMPLETE</promise>\n`
+        );
+      } else if (task.status === 'failed') {
+        fs.writeFileSync(
+          path.join(projectPath, 'outcomes', `${task.id}-${task.name}.md`),
+          `# Outcome\nFailed.\n\n<promise>FAILED</promise>\n`
+        );
+      }
+    }
+
+    return projectPath;
+  }
+
+  describe('Project State Comparison', () => {
+    it('should detect identical project states', () => {
+      // Create two identical project directories
+      const mainDir = path.join(tempDir, 'main');
+      const wtDir = path.join(tempDir, 'worktree');
+
+      createProjectWithTasks(mainDir, 'aaaaab-test', [
+        { id: '01', name: 'task-a', status: 'completed' },
+        { id: '02', name: 'task-b', status: 'completed' },
+      ]);
+      createProjectWithTasks(wtDir, 'aaaaab-test', [
+        { id: '01', name: 'task-a', status: 'completed' },
+        { id: '02', name: 'task-b', status: 'completed' },
+      ]);
+
+      const mainState = deriveProjectState(path.join(mainDir, 'aaaaab-test'));
+      const wtState = deriveProjectState(path.join(wtDir, 'aaaaab-test'));
+
+      // Same task count and same statuses
+      expect(mainState.tasks.length).toBe(wtState.tasks.length);
+      expect(mainState.tasks.length).toBe(2);
+      for (let i = 0; i < mainState.tasks.length; i++) {
+        expect(mainState.tasks[i].status).toBe(wtState.tasks[i].status);
+      }
+    });
+
+    it('should detect differing task counts (amendment scenario)', () => {
+      const mainDir = path.join(tempDir, 'main');
+      const wtDir = path.join(tempDir, 'worktree');
+
+      // Main: 2 tasks completed
+      createProjectWithTasks(mainDir, 'aaaaab-test', [
+        { id: '01', name: 'task-a', status: 'completed' },
+        { id: '02', name: 'task-b', status: 'completed' },
+      ]);
+      // Worktree: 4 tasks (2 completed + 2 pending from amend)
+      createProjectWithTasks(wtDir, 'aaaaab-test', [
+        { id: '01', name: 'task-a', status: 'completed' },
+        { id: '02', name: 'task-b', status: 'completed' },
+        { id: '03', name: 'task-c' },
+        { id: '04', name: 'task-d' },
+      ]);
+
+      const mainState = deriveProjectState(path.join(mainDir, 'aaaaab-test'));
+      const wtState = deriveProjectState(path.join(wtDir, 'aaaaab-test'));
+
+      expect(mainState.tasks.length).toBe(2);
+      expect(wtState.tasks.length).toBe(4);
+    });
+
+    it('should detect differing task statuses', () => {
+      const mainDir = path.join(tempDir, 'main');
+      const wtDir = path.join(tempDir, 'worktree');
+
+      // Main: all pending
+      createProjectWithTasks(mainDir, 'aaaaab-test', [
+        { id: '01', name: 'task-a' },
+        { id: '02', name: 'task-b' },
+      ]);
+      // Worktree: some completed
+      createProjectWithTasks(wtDir, 'aaaaab-test', [
+        { id: '01', name: 'task-a', status: 'completed' },
+        { id: '02', name: 'task-b' },
+      ]);
+
+      const mainState = deriveProjectState(path.join(mainDir, 'aaaaab-test'));
+      const wtState = deriveProjectState(path.join(wtDir, 'aaaaab-test'));
+
+      expect(mainState.tasks[0].status).toBe('pending');
+      expect(wtState.tasks[0].status).toBe('completed');
+    });
+  });
+
+  describe('Worktree Project Discovery', () => {
+    it('should discover worktree projects via listWorktreeProjects pattern', () => {
+      // Simulate the worktree base dir structure
+      const worktreeBaseDir = path.join(tempDir, 'worktree-base');
+      fs.mkdirSync(path.join(worktreeBaseDir, 'aaaabk-feature-a'), { recursive: true });
+      fs.mkdirSync(path.join(worktreeBaseDir, 'aaaabm-feature-b'), { recursive: true });
+
+      // Read directory to simulate what listWorktreeProjects does
+      const entries = fs.readdirSync(worktreeBaseDir, { withFileTypes: true });
+      const projects = entries
+        .filter(entry => entry.isDirectory())
+        .map(entry => entry.name)
+        .sort();
+
+      expect(projects).toEqual(['aaaabk-feature-a', 'aaaabm-feature-b']);
+    });
+
+    it('should derive state from worktree project path', () => {
+      // Simulate worktree project path: <wtPath>/<rafRelativePath>/<projectFolder>
+      const wtPath = path.join(tempDir, 'wt-root');
+      const rafRelativePath = 'RAF';
+      const projectFolder = 'aaaabk-feature';
+      const wtProjectPath = path.join(wtPath, rafRelativePath, projectFolder);
+
+      createProjectWithTasks(path.join(wtPath, rafRelativePath), projectFolder, [
+        { id: '01', name: 'setup', status: 'completed' },
+        { id: '02', name: 'implement' },
+        { id: '03', name: 'test' },
+      ]);
+
+      const state = deriveProjectState(wtProjectPath);
+      const stats = getDerivedStats(state);
+
+      expect(stats.total).toBe(3);
+      expect(stats.completed).toBe(1);
+      expect(stats.pending).toBe(2);
+    });
+
+    it('should filter out worktree-only projects correctly', () => {
+      // Create main repo projects
+      const mainRafDir = path.join(tempDir, 'main-raf');
+      createProjectWithTasks(mainRafDir, 'aaaaab-auth', [
+        { id: '01', name: 'login', status: 'completed' },
+      ]);
+
+      // Main repo folders
+      const mainFolderNames = new Set(
+        discoverProjects(mainRafDir).map(p => path.basename(p.path))
+      );
+
+      // Worktree folders include one that doesn't exist in main
+      const worktreeFolders = ['aaaaab-auth', 'aaaabk-new-feature'];
+
+      // Worktree-only projects
+      const worktreeOnly = worktreeFolders.filter(f => !mainFolderNames.has(f));
+      expect(worktreeOnly).toEqual(['aaaabk-new-feature']);
+
+      // Projects with main counterpart
+      const withCounterpart = worktreeFolders.filter(f => mainFolderNames.has(f));
+      expect(withCounterpart).toEqual(['aaaaab-auth']);
+    });
+
+    it('should identify differing worktree projects for display', () => {
+      const mainRafDir = path.join(tempDir, 'main');
+      const wtRafDir = path.join(tempDir, 'worktree');
+
+      // Main: 2 tasks all completed
+      createProjectWithTasks(mainRafDir, 'aaaaab-auth', [
+        { id: '01', name: 'login', status: 'completed' },
+        { id: '02', name: 'signup', status: 'completed' },
+      ]);
+
+      // Worktree: same 2 tasks completed + 2 new pending (amendment)
+      createProjectWithTasks(wtRafDir, 'aaaaab-auth', [
+        { id: '01', name: 'login', status: 'completed' },
+        { id: '02', name: 'signup', status: 'completed' },
+        { id: '03', name: 'oauth' },
+        { id: '04', name: 'sso' },
+      ]);
+
+      const mainState = deriveProjectState(path.join(mainRafDir, 'aaaaab-auth'));
+      const wtState = deriveProjectState(path.join(wtRafDir, 'aaaaab-auth'));
+
+      // Different task counts = states differ
+      expect(mainState.tasks.length).not.toBe(wtState.tasks.length);
+
+      // Main is completed, worktree is executing
+      expect(mainState.status).toBe('completed');
+      expect(wtState.status).toBe('executing');
+    });
+
+    it('should not show worktree project when identical to main', () => {
+      const mainRafDir = path.join(tempDir, 'main');
+      const wtRafDir = path.join(tempDir, 'worktree');
+
+      // Both have identical state
+      createProjectWithTasks(mainRafDir, 'aaaaab-auth', [
+        { id: '01', name: 'login', status: 'completed' },
+        { id: '02', name: 'signup', status: 'completed' },
+      ]);
+      createProjectWithTasks(wtRafDir, 'aaaaab-auth', [
+        { id: '01', name: 'login', status: 'completed' },
+        { id: '02', name: 'signup', status: 'completed' },
+      ]);
+
+      const mainState = deriveProjectState(path.join(mainRafDir, 'aaaaab-auth'));
+      const wtState = deriveProjectState(path.join(wtRafDir, 'aaaaab-auth'));
+
+      // Same task count
+      expect(mainState.tasks.length).toBe(wtState.tasks.length);
+
+      // Same statuses
+      for (let i = 0; i < mainState.tasks.length; i++) {
+        expect(mainState.tasks[i].status).toBe(wtState.tasks[i].status);
+      }
+
+      // The comparison function logic: these are identical so should NOT be shown
+      const differs = mainState.tasks.length !== wtState.tasks.length ||
+        mainState.tasks.some((t, i) => t.status !== wtState.tasks[i].status);
+      expect(differs).toBe(false);
+    });
+  });
+
+  describe('Worktree Stats Display', () => {
+    it('should compute correct stats for worktree project with mixed states', () => {
+      const wtRafDir = path.join(tempDir, 'worktree');
+
+      createProjectWithTasks(wtRafDir, 'aaaabk-feature', [
+        { id: '01', name: 'setup', status: 'completed' },
+        { id: '02', name: 'implement', status: 'completed' },
+        { id: '03', name: 'test', status: 'failed' },
+        { id: '04', name: 'deploy' },
+      ]);
+
+      const state = deriveProjectState(path.join(wtRafDir, 'aaaabk-feature'));
+      const stats = getDerivedStats(state);
+
+      expect(stats.completed).toBe(2);
+      expect(stats.failed).toBe(1);
+      expect(stats.pending).toBe(1);
+      expect(stats.total).toBe(4);
+    });
+
+    it('should show worktree-only project stats correctly', () => {
+      const wtRafDir = path.join(tempDir, 'worktree');
+
+      createProjectWithTasks(wtRafDir, 'aaaabp-new-only', [
+        { id: '01', name: 'step-a' },
+        { id: '02', name: 'step-b' },
+        { id: '03', name: 'step-c' },
+      ]);
+
+      const state = deriveProjectState(path.join(wtRafDir, 'aaaabp-new-only'));
+      const stats = getDerivedStats(state);
+
+      expect(stats.completed).toBe(0);
+      expect(stats.pending).toBe(3);
+      expect(stats.total).toBe(3);
+      expect(state.status).toBe('ready');
+    });
+  });
+});