rafcode 1.2.0 → 2.0.0

package/tests/unit/do-blocked-tasks.test.ts

@@ -21,7 +21,7 @@ describe('do command blocked tasks', () => {
 
   beforeEach(() => {
     tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-do-blocked-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 });
@@ -36,18 +36,18 @@ describe('do command blocked tasks', () => {
     it('should mark task as blocked when dependency fails', () => {
       // Task 001 - no dependencies
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '001-setup.md'),
+        path.join(projectPath, 'plans', '01-setup.md'),
         '# Task: Setup\n\n## Objective\nSetup the project'
       );
       // Task 002 - depends on 001
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '002-build.md'),
-        '# Task: Build\n\n## Objective\nBuild the project\n\n## Dependencies\n001'
+        path.join(projectPath, 'plans', '02-build.md'),
+        '# Task: Build\n\n## Objective\nBuild the project\n\n## Dependencies\n01'
       );
 
       // Mark task 001 as failed
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-setup.md'),
+        path.join(projectPath, 'outcomes', '01-setup.md'),
         '# Task 001 - Failed\n\n<promise>FAILED</promise>'
       );
 
@@ -60,23 +60,23 @@ describe('do command blocked tasks', () => {
     it('should cascade blocking through multiple tasks', () => {
       // Task 001 - no dependencies
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '001-first.md'),
+        path.join(projectPath, 'plans', '01-first.md'),
         '# Task: First'
       );
       // Task 002 - depends on 001
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '002-second.md'),
-        '# Task: Second\n\n## Dependencies\n001'
+        path.join(projectPath, 'plans', '02-second.md'),
+        '# Task: Second\n\n## Dependencies\n01'
       );
       // Task 003 - depends on 002
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '003-third.md'),
-        '# Task: Third\n\n## Dependencies\n002'
+        path.join(projectPath, 'plans', '03-third.md'),
+        '# Task: Third\n\n## Dependencies\n02'
       );
 
       // Mark task 001 as failed
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-first.md'),
+        path.join(projectPath, 'outcomes', '01-first.md'),
         '# Task 001 - Failed\n\n<promise>FAILED</promise>'
       );
 
@@ -89,17 +89,17 @@ describe('do command blocked tasks', () => {
 
     it('should not block task if dependency succeeds', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '001-setup.md'),
+        path.join(projectPath, 'plans', '01-setup.md'),
         '# Task: Setup'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '002-build.md'),
-        '# Task: Build\n\n## Dependencies\n001'
+        path.join(projectPath, 'plans', '02-build.md'),
+        '# Task: Build\n\n## Dependencies\n01'
       );
 
       // Mark task 001 as complete
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-setup.md'),
+        path.join(projectPath, 'outcomes', '01-setup.md'),
         '# Task 001 - Complete\n\n<promise>COMPLETE</promise>'
       );
 
@@ -111,25 +111,25 @@ describe('do command blocked tasks', () => {
 
     it('should block task when one of multiple dependencies fails', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '001-first.md'),
+        path.join(projectPath, 'plans', '01-first.md'),
         '# Task: First'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '002-second.md'),
+        path.join(projectPath, 'plans', '02-second.md'),
         '# Task: Second'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '003-third.md'),
-        '# Task: Third\n\n## Dependencies\n001, 002'
+        path.join(projectPath, 'plans', '03-third.md'),
+        '# Task: Third\n\n## Dependencies\n01, 02'
       );
 
       // Mark 001 as complete, 002 as failed
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-first.md'),
+        path.join(projectPath, 'outcomes', '01-first.md'),
         '# Task 001 - Complete\n\n<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '002-second.md'),
+        path.join(projectPath, 'outcomes', '02-second.md'),
         '# Task 002 - Failed\n\n<promise>FAILED</promise>'
       );
 
@@ -144,17 +144,17 @@ describe('do command blocked tasks', () => {
   describe('getNextExecutableTask with blocked tasks', () => {
     it('should skip blocked tasks and return null if only blocked remain', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '001-setup.md'),
+        path.join(projectPath, 'plans', '01-setup.md'),
         '# Task: Setup'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '002-build.md'),
-        '# Task: Build\n\n## Dependencies\n001'
+        path.join(projectPath, 'plans', '02-build.md'),
+        '# Task: Build\n\n## Dependencies\n01'
       );
 
       // Mark task 001 as failed
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-setup.md'),
+        path.join(projectPath, 'outcomes', '01-setup.md'),
         '# Task 001 - Failed\n\n<promise>FAILED</promise>'
       );
 
@@ -162,27 +162,27 @@ describe('do command blocked tasks', () => {
       const nextTask = getNextExecutableTask(state);
 
       // Should return the failed task for retry, not the blocked one
-      expect(nextTask?.id).toBe('001');
+      expect(nextTask?.id).toBe('01');
       expect(nextTask?.status).toBe('failed');
     });
 
     it('should return pending tasks before failed tasks', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '001-first.md'),
+        path.join(projectPath, 'plans', '01-first.md'),
         '# Task: First'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '002-second.md'),
+        path.join(projectPath, 'plans', '02-second.md'),
         '# Task: Second'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '003-third.md'),
-        '# Task: Third\n\n## Dependencies\n001'
+        path.join(projectPath, 'plans', '03-third.md'),
+        '# Task: Third\n\n## Dependencies\n01'
       );
 
       // Mark 001 as failed, 002 remains pending
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-first.md'),
+        path.join(projectPath, 'outcomes', '01-first.md'),
         '# Task 001 - Failed\n\n<promise>FAILED</promise>'
       );
 
@@ -190,7 +190,7 @@ describe('do command blocked tasks', () => {
       const nextTask = getNextExecutableTask(state);
 
       // Should return pending task 002, not failed 001
-      expect(nextTask?.id).toBe('002');
+      expect(nextTask?.id).toBe('02');
       expect(nextTask?.status).toBe('pending');
     });
   });
@@ -198,25 +198,25 @@ describe('do command blocked tasks', () => {
   describe('getDerivedStats with blocked tasks', () => {
     it('should count blocked tasks separately', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '001-first.md'),
+        path.join(projectPath, 'plans', '01-first.md'),
         '# Task: First'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '002-second.md'),
-        '# Task: Second\n\n## Dependencies\n001'
+        path.join(projectPath, 'plans', '02-second.md'),
+        '# Task: Second\n\n## Dependencies\n01'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '003-third.md'),
-        '# Task: Third\n\n## Dependencies\n002'
+        path.join(projectPath, 'plans', '03-third.md'),
+        '# Task: Third\n\n## Dependencies\n02'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '004-fourth.md'),
+        path.join(projectPath, 'plans', '04-fourth.md'),
         '# Task: Fourth'
       );
 
       // Mark task 001 as failed
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-first.md'),
+        path.join(projectPath, 'outcomes', '01-first.md'),
         '# Task 001 - Failed\n\n<promise>FAILED</promise>'
       );
 
@@ -234,17 +234,17 @@ describe('do command blocked tasks', () => {
   describe('isProjectComplete with blocked tasks', () => {
     it('should not consider project complete if blocked tasks exist', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '001-first.md'),
+        path.join(projectPath, 'plans', '01-first.md'),
         '# Task: First'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '002-second.md'),
-        '# Task: Second\n\n## Dependencies\n001'
+        path.join(projectPath, 'plans', '02-second.md'),
+        '# Task: Second\n\n## Dependencies\n01'
       );
 
       // Mark 001 as failed (002 becomes blocked)
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-first.md'),
+        path.join(projectPath, 'outcomes', '01-first.md'),
         '# Task 001 - Failed\n\n<promise>FAILED</promise>'
       );
 
@@ -257,16 +257,16 @@ describe('do command blocked tasks', () => {
   describe('hasProjectFailed with blocked tasks', () => {
     it('should report project as failed when there are failed tasks', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '001-first.md'),
+        path.join(projectPath, 'plans', '01-first.md'),
         '# Task: First'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '002-second.md'),
-        '# Task: Second\n\n## Dependencies\n001'
+        path.join(projectPath, 'plans', '02-second.md'),
+        '# Task: Second\n\n## Dependencies\n01'
       );
 
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-first.md'),
+        path.join(projectPath, 'outcomes', '01-first.md'),
         '# Task 001 - Failed\n\n<promise>FAILED</promise>'
       );
 
@@ -279,13 +279,13 @@ describe('do command blocked tasks', () => {
       // This is a theoretical edge case - blocked tasks always have a failed root cause
       // But if only blocked outcome files exist (without failed), hasProjectFailed should be false
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '001-first.md'),
+        path.join(projectPath, 'plans', '01-first.md'),
         '# Task: First'
       );
 
       // Mark as blocked (artificial - in practice there would be a failed dep)
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-first.md'),
+        path.join(projectPath, 'outcomes', '01-first.md'),
         '# Task 001 - Blocked\n\n<promise>BLOCKED</promise>'
       );
 
@@ -299,11 +299,11 @@ describe('do command blocked tasks', () => {
   describe('blocked outcome file format', () => {
     it('should recognize BLOCKED marker in outcome files', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '001-task.md'),
+        path.join(projectPath, 'plans', '01-task.md'),
         '# Task: Task'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-task.md'),
+        path.join(projectPath, 'outcomes', '01-task.md'),
         '# Outcome: Task 001 Blocked\n\n## Summary\n\nBlocked by dependency.\n\n<promise>BLOCKED</promise>'
       );
 
@@ -315,9 +315,9 @@ describe('do command blocked tasks', () => {
 
   describe('getOutcomeFilePath', () => {
     it('should generate correct outcome file path', () => {
-      const outcomePath = getOutcomeFilePath(projectPath, '002', 'build-project');
+      const outcomePath = getOutcomeFilePath(projectPath, '02', 'build-project');
 
-      expect(outcomePath).toBe(path.join(projectPath, 'outcomes', '002-build-project.md'));
+      expect(outcomePath).toBe(path.join(projectPath, 'outcomes', '02-build-project.md'));
     });
   });
 });

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

@@ -15,182 +15,89 @@ describe('Do Command - Identifier Support', () => {
   });
 
   describe('Single Project Full Folder Name Resolution', () => {
-    it('should resolve project by full numeric folder name: raf do 001-fix-stuff', () => {
-      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 6-char prefix folder name: raf do aaaaab-fix-stuff', () => {
+      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: raf do a00-project', () => {
-      fs.mkdirSync(path.join(tempDir, 'a00-project'));
-      const result = resolveProjectIdentifier(tempDir, 'a00-project');
-      expect(result).toBe(path.join(tempDir, 'a00-project'));
+    it('should resolve project by full base26 folder name: raf do abcdef-project', () => {
+      fs.mkdirSync(path.join(tempDir, 'abcdef-project'));
+      const result = resolveProjectIdentifier(tempDir, 'abcdef-project');
+      expect(result).toBe(path.join(tempDir, 'abcdef-project'));
     });
 
-    it('should resolve 2-digit prefix full folder name', () => {
-      fs.mkdirSync(path.join(tempDir, '01-short'));
-      const result = resolveProjectIdentifier(tempDir, '01-short');
-      expect(result).toBe(path.join(tempDir, '01-short'));
-    });
-
-    it('should resolve 3-digit prefix full folder name', () => {
-      fs.mkdirSync(path.join(tempDir, '123-three-digits'));
-      const result = resolveProjectIdentifier(tempDir, '123-three-digits');
-      expect(result).toBe(path.join(tempDir, '123-three-digits'));
-    });
-  });
-
-  describe('Multiple Projects with Full Folder Names: raf do 001-a 002-b', () => {
-    it('should resolve multiple projects by full folder names', () => {
-      fs.mkdirSync(path.join(tempDir, '001-project-a'));
-      fs.mkdirSync(path.join(tempDir, '002-project-b'));
-      fs.mkdirSync(path.join(tempDir, '003-project-c'));
-
-      const identifiers = ['001-project-a', '002-project-b', '003-project-c'];
-      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
-
-      expect(resolved).toHaveLength(3);
-      expect(resolved[0]).toBe(path.join(tempDir, '001-project-a'));
-      expect(resolved[1]).toBe(path.join(tempDir, '002-project-b'));
-      expect(resolved[2]).toBe(path.join(tempDir, '003-project-c'));
-    });
-
-    it('should handle gaps in project numbers with full folder names', () => {
-      fs.mkdirSync(path.join(tempDir, '001-first'));
-      fs.mkdirSync(path.join(tempDir, '005-fifth'));
-
-      const identifiers = ['001-first', '005-fifth'];
-      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
-
-      expect(resolved).toHaveLength(2);
-      expect(resolved[0]).toBe(path.join(tempDir, '001-first'));
-      expect(resolved[1]).toBe(path.join(tempDir, '005-fifth'));
-    });
-  });
-
-  describe('Mixed Formats: raf do 3 001-fix-stuff my-project', () => {
-    it('should resolve mixed number, full folder name, and project name', () => {
-      fs.mkdirSync(path.join(tempDir, '003-by-number'));
-      fs.mkdirSync(path.join(tempDir, '001-fix-stuff'));
-      fs.mkdirSync(path.join(tempDir, '002-my-project'));
-
-      const identifiers = ['3', '001-fix-stuff', 'my-project'];
-      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
-
-      expect(resolved).toHaveLength(3);
-      expect(resolved[0]).toBe(path.join(tempDir, '003-by-number'));
-      expect(resolved[1]).toBe(path.join(tempDir, '001-fix-stuff'));
-      expect(resolved[2]).toBe(path.join(tempDir, '002-my-project'));
-    });
-
-    it('should resolve mixed base36 prefix and full folder names', () => {
-      fs.mkdirSync(path.join(tempDir, 'a00-by-prefix'));
-      fs.mkdirSync(path.join(tempDir, '001-full-name'));
-      fs.mkdirSync(path.join(tempDir, 'b00-another-prefix'));
-
-      const identifiers = ['a00', '001-full-name', 'b00-another-prefix'];
-      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
-
-      expect(resolved).toHaveLength(3);
-      expect(resolved[0]).toBe(path.join(tempDir, 'a00-by-prefix'));
-      expect(resolved[1]).toBe(path.join(tempDir, '001-full-name'));
-      expect(resolved[2]).toBe(path.join(tempDir, 'b00-another-prefix'));
-    });
-
-    it('should resolve all five identifier formats', () => {
-      fs.mkdirSync(path.join(tempDir, '001-project-one'));
-      fs.mkdirSync(path.join(tempDir, '002-project-two'));
-      fs.mkdirSync(path.join(tempDir, '003-project-three'));
-      fs.mkdirSync(path.join(tempDir, 'a00-project-four'));
-      fs.mkdirSync(path.join(tempDir, '005-project-five'));
-
-      const identifiers = [
-        '1',                    // Short number
-        '002',                  // Padded number
-        '003-project-three',    // Full numeric folder name
-        'project-four',         // Project name
-        'a00',                  // Base36 prefix
-      ];
-      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
-
-      expect(resolved).toHaveLength(5);
-      expect(resolved[0]).toBe(path.join(tempDir, '001-project-one'));
-      expect(resolved[1]).toBe(path.join(tempDir, '002-project-two'));
-      expect(resolved[2]).toBe(path.join(tempDir, '003-project-three'));
-      expect(resolved[3]).toBe(path.join(tempDir, 'a00-project-four'));
-      expect(resolved[4]).toBe(path.join(tempDir, 'a00-project-four'));
+    it('should resolve full folder name with all-numeric prefix', () => {
+      fs.mkdirSync(path.join(tempDir, 'aaaadt-all-letters'));
+      const result = resolveProjectIdentifier(tempDir, 'aaaadt-all-letters');
+      expect(result).toBe(path.join(tempDir, 'aaaadt-all-letters'));
     });
   });
 
   describe('Error Messages for Non-Matching Full Folder Names', () => {
     it('should return null for non-existent full folder name', () => {
-      fs.mkdirSync(path.join(tempDir, '001-existing'));
-      const result = resolveProjectIdentifier(tempDir, '002-non-existent');
+      fs.mkdirSync(path.join(tempDir, 'aaaaab-existing'));
+      const result = resolveProjectIdentifier(tempDir, 'aaaaac-non-existent');
       expect(result).toBeNull();
     });
 
     it('should return null when prefix exists but name differs', () => {
-      fs.mkdirSync(path.join(tempDir, '001-actual-name'));
-      const result = resolveProjectIdentifier(tempDir, '001-different-name');
+      fs.mkdirSync(path.join(tempDir, 'aaaaab-actual-name'));
+      const result = resolveProjectIdentifier(tempDir, 'aaaaab-different-name');
       expect(result).toBeNull();
     });
 
     it('should return null when name exists but prefix differs', () => {
-      fs.mkdirSync(path.join(tempDir, '001-my-project'));
-      const result = resolveProjectIdentifier(tempDir, '999-my-project');
+      fs.mkdirSync(path.join(tempDir, 'aaaaab-my-project'));
+      const result = resolveProjectIdentifier(tempDir, 'aaabmm-my-project');
       expect(result).toBeNull();
     });
 
-    it('should return null for base36 full folder name when only numeric exists', () => {
-      fs.mkdirSync(path.join(tempDir, '001-my-project'));
-      const result = resolveProjectIdentifier(tempDir, 'a01-my-project');
+    it('should return null for non-matching full folder name', () => {
+      fs.mkdirSync(path.join(tempDir, 'aaaaab-my-project'));
+      const result = resolveProjectIdentifier(tempDir, 'abcdef-my-project');
       expect(result).toBeNull();
     });
   });
 
-  describe('Backward Compatibility', () => {
+  describe('Identifier Formats', () => {
     beforeEach(() => {
-      fs.mkdirSync(path.join(tempDir, '001-my-project'));
-      fs.mkdirSync(path.join(tempDir, '002-another-project'));
-      fs.mkdirSync(path.join(tempDir, 'a00-base36-project'));
-    });
-
-    it('should still resolve by number (short)', () => {
-      expect(resolveProjectIdentifier(tempDir, '1')).toBe(path.join(tempDir, '001-my-project'));
-      expect(resolveProjectIdentifier(tempDir, '2')).toBe(path.join(tempDir, '002-another-project'));
+      fs.mkdirSync(path.join(tempDir, 'aaaaab-my-project'));
+      fs.mkdirSync(path.join(tempDir, 'aaaaac-another-project'));
+      fs.mkdirSync(path.join(tempDir, 'ghijkl-alpha-project'));
     });
 
-    it('should still resolve by number (padded)', () => {
-      expect(resolveProjectIdentifier(tempDir, '001')).toBe(path.join(tempDir, '001-my-project'));
-      expect(resolveProjectIdentifier(tempDir, '002')).toBe(path.join(tempDir, '002-another-project'));
+    it('should resolve by 6-char base26 prefix', () => {
+      expect(resolveProjectIdentifier(tempDir, 'aaaaab')).toBe(path.join(tempDir, 'aaaaab-my-project'));
+      expect(resolveProjectIdentifier(tempDir, 'aaaaac')).toBe(path.join(tempDir, 'aaaaac-another-project'));
     });
 
-    it('should still resolve by base36 prefix', () => {
-      expect(resolveProjectIdentifier(tempDir, 'a00')).toBe(path.join(tempDir, 'a00-base36-project'));
+    it('should resolve by base26 prefix', () => {
+      expect(resolveProjectIdentifier(tempDir, 'ghijkl')).toBe(path.join(tempDir, 'ghijkl-alpha-project'));
     });
 
-    it('should still resolve by project name', () => {
-      expect(resolveProjectIdentifier(tempDir, 'my-project')).toBe(path.join(tempDir, '001-my-project'));
-      expect(resolveProjectIdentifier(tempDir, 'another-project')).toBe(path.join(tempDir, '002-another-project'));
-      expect(resolveProjectIdentifier(tempDir, 'base36-project')).toBe(path.join(tempDir, 'a00-base36-project'));
+    it('should resolve by project name', () => {
+      expect(resolveProjectIdentifier(tempDir, 'my-project')).toBe(path.join(tempDir, 'aaaaab-my-project'));
+      expect(resolveProjectIdentifier(tempDir, 'another-project')).toBe(path.join(tempDir, 'aaaaac-another-project'));
+      expect(resolveProjectIdentifier(tempDir, 'alpha-project')).toBe(path.join(tempDir, 'ghijkl-alpha-project'));
     });
   });
 
   describe('Project Name Extraction with Full Folder Names', () => {
-    it('should extract name from numeric full folder path', () => {
-      const projectPath = path.join(tempDir, '001-my-project');
+    it('should extract name from 6-char prefix folder path', () => {
+      const projectPath = path.join(tempDir, 'aaaaab-my-project');
       const name = extractProjectName(projectPath);
       expect(name).toBe('my-project');
     });
 
-    it('should extract name from base36 full folder path', () => {
-      const projectPath = path.join(tempDir, 'a00-my-project');
+    it('should extract name from base26 full folder path', () => {
+      const projectPath = path.join(tempDir, 'abcdef-my-project');
       const name = extractProjectName(projectPath);
       expect(name).toBe('my-project');
     });
 
     it('should handle multi-hyphen names', () => {
-      const projectPath = path.join(tempDir, '001-my-cool-project-name');
+      const projectPath = path.join(tempDir, 'aaaaab-my-cool-project-name');
       const name = extractProjectName(projectPath);
       expect(name).toBe('my-cool-project-name');
     });