rafcode 1.2.0 → 2.0.0

package/tests/unit/dependency-integration.test.ts

@@ -26,7 +26,7 @@ describe('Dependency Integration Flow', () => {
 
   beforeEach(() => {
     tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-dep-integration-'));
-    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 });
@@ -51,28 +51,28 @@ describe('Dependency Integration Flow', () => {
     beforeEach(() => {
       // Create plan files with dependency structure
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '001-setup.md'),
+        path.join(projectPath, 'plans', '01-setup.md'),
         '# Task: Setup\n\n## Objective\nSetup the project infrastructure.\n\n## Requirements\n- Initialize project'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '002-core.md'),
-        '# Task: Core\n\n## Objective\nBuild core functionality.\n\n## Dependencies\n001\n\n## Requirements\n- Build core'
+        path.join(projectPath, 'plans', '02-core.md'),
+        '# Task: Core\n\n## Objective\nBuild core functionality.\n\n## Dependencies\n01\n\n## Requirements\n- Build core'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '003-api.md'),
-        '# Task: API\n\n## Objective\nImplement API layer.\n\n## Dependencies\n001, 002\n\n## Requirements\n- Create API'
+        path.join(projectPath, 'plans', '03-api.md'),
+        '# Task: API\n\n## Objective\nImplement API layer.\n\n## Dependencies\n01, 02\n\n## Requirements\n- Create API'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '004-tests.md'),
-        '# Task: Tests\n\n## Objective\nWrite tests.\n\n## Dependencies\n003\n\n## Requirements\n- Write tests'
+        path.join(projectPath, 'plans', '04-tests.md'),
+        '# Task: Tests\n\n## Objective\nWrite tests.\n\n## Dependencies\n03\n\n## Requirements\n- Write tests'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '005-docs.md'),
-        '# Task: Docs\n\n## Objective\nWrite documentation.\n\n## Dependencies\n003\n\n## Requirements\n- Write docs'
+        path.join(projectPath, 'plans', '05-docs.md'),
+        '# Task: Docs\n\n## Objective\nWrite documentation.\n\n## Dependencies\n03\n\n## Requirements\n- Write docs'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '006-deploy.md'),
-        '# Task: Deploy\n\n## Objective\nDeploy the project.\n\n## Dependencies\n004, 005\n\n## Requirements\n- Deploy'
+        path.join(projectPath, 'plans', '06-deploy.md'),
+        '# Task: Deploy\n\n## Objective\nDeploy the project.\n\n## Dependencies\n04, 05\n\n## Requirements\n- Deploy'
       );
     });
 
@@ -85,25 +85,25 @@ describe('Dependency Integration Flow', () => {
 
       // Verify dependencies are parsed correctly
       expect(state.tasks[0]?.dependencies).toEqual([]);
-      expect(state.tasks[1]?.dependencies).toEqual(['001']);
-      expect(state.tasks[2]?.dependencies).toEqual(['001', '002']);
-      expect(state.tasks[3]?.dependencies).toEqual(['003']);
-      expect(state.tasks[4]?.dependencies).toEqual(['003']);
-      expect(state.tasks[5]?.dependencies).toEqual(['004', '005']);
+      expect(state.tasks[1]?.dependencies).toEqual(['01']);
+      expect(state.tasks[2]?.dependencies).toEqual(['01', '02']);
+      expect(state.tasks[3]?.dependencies).toEqual(['03']);
+      expect(state.tasks[4]?.dependencies).toEqual(['03']);
+      expect(state.tasks[5]?.dependencies).toEqual(['04', '05']);
     });
 
     it('should return first pending task when all are pending', () => {
       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 cascade blocks when task 001 fails', () => {
       // Task 001 fails
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-setup.md'),
+        path.join(projectPath, 'outcomes', '01-setup.md'),
         '# Outcome\n\nSetup failed.\n\n<promise>FAILED</promise>'
       );
 
@@ -128,12 +128,12 @@ describe('Dependency Integration Flow', () => {
     it('should cascade blocks when task 002 fails (001 completed)', () => {
       // Task 001 completed
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-setup.md'),
+        path.join(projectPath, 'outcomes', '01-setup.md'),
         '# Outcome\n\nSetup complete.\n\n<promise>COMPLETE</promise>'
       );
       // Task 002 fails
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '002-core.md'),
+        path.join(projectPath, 'outcomes', '02-core.md'),
         '# Outcome\n\nCore failed.\n\n<promise>FAILED</promise>'
       );
 
@@ -157,16 +157,16 @@ describe('Dependency Integration Flow', () => {
     it('should cascade blocks when task 003 fails (001, 002 completed)', () => {
       // Tasks 001 and 002 completed
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-setup.md'),
+        path.join(projectPath, 'outcomes', '01-setup.md'),
         '<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '002-core.md'),
+        path.join(projectPath, 'outcomes', '02-core.md'),
         '<promise>COMPLETE</promise>'
       );
       // Task 003 fails
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '003-api.md'),
+        path.join(projectPath, 'outcomes', '03-api.md'),
         '<promise>FAILED</promise>'
       );
 
@@ -188,24 +188,24 @@ describe('Dependency Integration Flow', () => {
     it('should handle partial failure in parallel branches', () => {
       // Complete chain up to 003
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-setup.md'),
+        path.join(projectPath, 'outcomes', '01-setup.md'),
         '<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '002-core.md'),
+        path.join(projectPath, 'outcomes', '02-core.md'),
         '<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '003-api.md'),
+        path.join(projectPath, 'outcomes', '03-api.md'),
         '<promise>COMPLETE</promise>'
       );
       // 004 succeeds but 005 fails
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '004-tests.md'),
+        path.join(projectPath, 'outcomes', '04-tests.md'),
         '<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '005-docs.md'),
+        path.join(projectPath, 'outcomes', '05-docs.md'),
         '<promise>FAILED</promise>'
       );
 
@@ -226,7 +226,7 @@ describe('Dependency Integration Flow', () => {
 
     it('should mark project complete when all tasks succeed', () => {
       // All tasks complete
-      for (const taskNum of ['001', '002', '003', '004', '005', '006']) {
+      for (const taskNum of ['01', '02', '03', '04', '05', '06']) {
         const taskFile = fs.readdirSync(path.join(projectPath, 'plans'))
           .find((f) => f.startsWith(taskNum));
         const taskName = taskFile ? extractTaskNameFromPlanFile(`plans/${taskFile}`) : taskNum;
@@ -248,21 +248,21 @@ describe('Dependency Integration Flow', () => {
     it('should skip blocked tasks and find next available pending task', () => {
       // Setup: 001 fails, 002 depends on 001 (blocked), 003 has no deps (pending)
       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'),
+        path.join(projectPath, 'plans', '03-third.md'),
         '# Task: Third'
       );
 
       // 001 fails
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-first.md'),
+        path.join(projectPath, 'outcomes', '01-first.md'),
         '<promise>FAILED</promise>'
       );
 
@@ -270,23 +270,23 @@ describe('Dependency Integration Flow', () => {
       const nextTask = getNextExecutableTask(state);
 
       // Should return 003 (pending) not 002 (blocked)
-      expect(nextTask?.id).toBe('003');
+      expect(nextTask?.id).toBe('03');
       expect(nextTask?.status).toBe('pending');
     });
 
     it('should return failed task for retry when no pending 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'
       );
 
       // 001 fails
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-first.md'),
+        path.join(projectPath, 'outcomes', '01-first.md'),
         '<promise>FAILED</promise>'
       );
 
@@ -294,27 +294,27 @@ describe('Dependency Integration Flow', () => {
       const nextTask = getNextExecutableTask(state);
 
       // Should return 001 for retry (002 is blocked)
-      expect(nextTask?.id).toBe('001');
+      expect(nextTask?.id).toBe('01');
       expect(nextTask?.status).toBe('failed');
     });
 
     it('should return null when all tasks are blocked with no failed tasks to retry', () => {
       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'
       );
 
       // 001 completed, but 002 is marked as blocked explicitly (edge case)
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-first.md'),
+        path.join(projectPath, 'outcomes', '01-first.md'),
         '<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '002-second.md'),
+        path.join(projectPath, 'outcomes', '02-second.md'),
         '<promise>BLOCKED</promise>'
       );
 
@@ -329,92 +329,92 @@ describe('Dependency Integration Flow', () => {
   describe('Execution prompt with dependency context', () => {
     it('should include dependency outcomes in execution prompt', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '001-setup.md'),
+        path.join(projectPath, 'plans', '01-setup.md'),
         '# Task: Setup\n\n## Objective\nSetup the project.'
       );
       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'
       );
 
       // 001 completed with outcome
       const outcome001 = '# Outcome: Task 001\n\n## Summary\n\nInitialized project with configuration files.\n\n<promise>COMPLETE</promise>';
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-setup.md'),
+        path.join(projectPath, 'outcomes', '01-setup.md'),
         outcome001
       );
 
       const state = deriveProjectState(projectPath);
-      const task002 = state.tasks.find((t) => t.id === '002');
+      const task002 = state.tasks.find((t) => t.id === '02');
 
       expect(task002).toBeDefined();
-      expect(task002?.dependencies).toEqual(['001']);
+      expect(task002?.dependencies).toEqual(['01']);
 
       // Build execution prompt for task 002
       const prompt = getExecutionPrompt({
         projectPath,
-        planPath: path.join(projectPath, 'plans', '002-build.md'),
-        taskId: '002',
+        planPath: path.join(projectPath, 'plans', '02-build.md'),
+        taskId: '02',
         taskNumber: 2,
         totalTasks: 2,
-        previousOutcomes: [{ taskId: '001', content: outcome001 }],
+        previousOutcomes: [{ taskId: '01', content: outcome001 }],
         autoCommit: true,
         projectNumber: '001',
-        outcomeFilePath: path.join(projectPath, 'outcomes', '002-build.md'),
-        dependencyIds: ['001'],
-        dependencyOutcomes: [{ taskId: '001', content: outcome001 }],
+        outcomeFilePath: path.join(projectPath, 'outcomes', '02-build.md'),
+        dependencyIds: ['01'],
+        dependencyOutcomes: [{ taskId: '01', content: outcome001 }],
       });
 
       expect(prompt).toContain('## Dependency Context');
-      expect(prompt).toContain('**Dependencies**: 001');
-      expect(prompt).toContain('### Task 001');
+      expect(prompt).toContain('**Dependencies**: 01');
+      expect(prompt).toContain('### Task 01');
       expect(prompt).toContain('Initialized project with configuration files');
     });
 
     it('should include multiple dependency outcomes', () => {
       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-core.md'),
-        '# Task: Core\n\n## Dependencies\n001'
+        path.join(projectPath, 'plans', '02-core.md'),
+        '# Task: Core\n\n## Dependencies\n01'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '003-api.md'),
-        '# Task: API\n\n## Dependencies\n001, 002'
+        path.join(projectPath, 'plans', '03-api.md'),
+        '# Task: API\n\n## Dependencies\n01, 02'
       );
 
       const outcome001 = '## Summary\n\nSetup complete.\n\n<promise>COMPLETE</promise>';
       const outcome002 = '## Summary\n\nCore complete.\n\n<promise>COMPLETE</promise>';
 
-      fs.writeFileSync(path.join(projectPath, 'outcomes', '001-setup.md'), outcome001);
-      fs.writeFileSync(path.join(projectPath, 'outcomes', '002-core.md'), outcome002);
+      fs.writeFileSync(path.join(projectPath, 'outcomes', '01-setup.md'), outcome001);
+      fs.writeFileSync(path.join(projectPath, 'outcomes', '02-core.md'), outcome002);
 
       const prompt = getExecutionPrompt({
         projectPath,
-        planPath: path.join(projectPath, 'plans', '003-api.md'),
-        taskId: '003',
+        planPath: path.join(projectPath, 'plans', '03-api.md'),
+        taskId: '03',
         taskNumber: 3,
         totalTasks: 3,
         previousOutcomes: [
-          { taskId: '001', content: outcome001 },
-          { taskId: '002', content: outcome002 },
+          { taskId: '01', content: outcome001 },
+          { taskId: '02', content: outcome002 },
         ],
         autoCommit: true,
         projectNumber: '001',
-        outcomeFilePath: path.join(projectPath, 'outcomes', '003-api.md'),
-        dependencyIds: ['001', '002'],
+        outcomeFilePath: path.join(projectPath, 'outcomes', '03-api.md'),
+        dependencyIds: ['01', '02'],
         dependencyOutcomes: [
-          { taskId: '001', content: outcome001 },
-          { taskId: '002', content: outcome002 },
+          { taskId: '01', content: outcome001 },
+          { taskId: '02', content: outcome002 },
         ],
       });
 
-      expect(prompt).toContain('**Dependencies**: 001, 002');
-      expect(prompt).toContain('### Task 001');
+      expect(prompt).toContain('**Dependencies**: 01, 02');
+      expect(prompt).toContain('### Task 01');
       expect(prompt).toContain('Setup complete');
-      expect(prompt).toContain('### Task 002');
+      expect(prompt).toContain('### Task 02');
       expect(prompt).toContain('Core complete');
     });
   });
@@ -422,7 +422,7 @@ describe('Dependency Integration Flow', () => {
   describe('BLOCKED outcome file recognition', () => {
     it('should recognize BLOCKED marker and set status to blocked', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '001-task.md'),
+        path.join(projectPath, 'plans', '01-task.md'),
         '# Task: Task'
       );
 
@@ -448,7 +448,7 @@ To unblock this task:
 <promise>BLOCKED</promise>`;
 
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-task.md'),
+        path.join(projectPath, 'outcomes', '01-task.md'),
         blockedContent
       );
 
@@ -473,17 +473,17 @@ To unblock this task:
       // In practice, circular deps are prevented by only allowing deps on lower-numbered tasks
       // But if somehow created, should not infinite loop
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '001-first.md'),
-        '# Task: First\n\n## Dependencies\n002' // Invalid: depends on higher-numbered task
+        path.join(projectPath, 'plans', '01-first.md'),
+        '# Task: First\n\n## Dependencies\n02' // Invalid: depends on higher-numbered task
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '002-second.md'),
+        path.join(projectPath, 'plans', '02-second.md'),
         '# Task: Second'
       );
 
       // 002 succeeds
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '002-second.md'),
+        path.join(projectPath, 'outcomes', '02-second.md'),
         '<promise>COMPLETE</promise>'
       );
 
@@ -497,21 +497,21 @@ To unblock this task:
 
     it('should handle dependency on non-existent task gracefully', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '001-task.md'),
-        '# Task: Task\n\n## Dependencies\n999' // 999 doesn't exist
+        path.join(projectPath, 'plans', '01-task.md'),
+        '# Task: Task\n\n## Dependencies\nzz' // 999 doesn't exist
       );
 
       const state = deriveProjectState(projectPath);
       // Task should be pending since the non-existent dep doesn't block it
       // (The dependency 999 just won't be found, treated as if satisfied)
       expect(state.tasks[0]?.status).toBe('pending');
-      expect(state.tasks[0]?.dependencies).toEqual(['999']);
+      expect(state.tasks[0]?.dependencies).toEqual(['zz']);
     });
 
     it('should handle self-dependency gracefully', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '001-task.md'),
-        '# Task: Task\n\n## Dependencies\n001' // Self-dependency
+        path.join(projectPath, 'plans', '01-task.md'),
+        '# Task: Task\n\n## Dependencies\n01' // Self-dependency
       );
 
       const state = deriveProjectState(projectPath);
@@ -530,25 +530,25 @@ To unblock this task:
 
     it('should handle task with all dependencies completed', () => {
       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'
       );
 
       // Both deps complete
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '001-first.md'),
+        path.join(projectPath, 'outcomes', '01-first.md'),
         '<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '002-second.md'),
+        path.join(projectPath, 'outcomes', '02-second.md'),
         '<promise>COMPLETE</promise>'
       );