rafcode 1.0.0

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

@@ -0,0 +1,270 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { resolveProjectIdentifier } from '../../src/utils/paths.js';
+
+describe('Multi-Project Execution', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-multiproject-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('Project Resolution', () => {
+    it('should resolve multiple projects by number', () => {
+      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', '002', '003'];
+      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 resolve multiple projects by name', () => {
+      fs.mkdirSync(path.join(tempDir, '001-project-a'));
+      fs.mkdirSync(path.join(tempDir, '002-project-b'));
+
+      const identifiers = ['project-a', 'project-b'];
+      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
+
+      expect(resolved).toHaveLength(2);
+      expect(resolved[0]).toBe(path.join(tempDir, '001-project-a'));
+      expect(resolved[1]).toBe(path.join(tempDir, '002-project-b'));
+    });
+
+    it('should resolve mixed number and name identifiers', () => {
+      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-b', '3'];
+      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 return null for non-existent projects in list', () => {
+      fs.mkdirSync(path.join(tempDir, '001-project-a'));
+      fs.mkdirSync(path.join(tempDir, '003-project-c'));
+
+      const identifiers = ['001', '002', '003'];
+      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
+
+      expect(resolved[0]).toBe(path.join(tempDir, '001-project-a'));
+      expect(resolved[1]).toBeNull(); // 002 doesn't exist
+      expect(resolved[2]).toBe(path.join(tempDir, '003-project-c'));
+    });
+  });
+
+  describe('Duplicate Detection', () => {
+    it('should detect duplicates when same project specified by number', () => {
+      fs.mkdirSync(path.join(tempDir, '001-project-a'));
+
+      const identifiers = ['001', '001'];
+      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
+      const uniquePaths = new Set(resolved.filter(Boolean));
+
+      expect(uniquePaths.size).toBe(1);
+    });
+
+    it('should detect duplicates when same project specified by number and name', () => {
+      fs.mkdirSync(path.join(tempDir, '001-project-a'));
+
+      const identifiers = ['001', 'project-a'];
+      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
+      const uniquePaths = new Set(resolved.filter(Boolean));
+
+      expect(uniquePaths.size).toBe(1);
+      expect(resolved[0]).toBe(resolved[1]); // Both resolve to same path
+    });
+
+    it('should detect duplicates with different number formats', () => {
+      fs.mkdirSync(path.join(tempDir, '005-project'));
+
+      const identifiers = ['5', '05', '005'];
+      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
+      const uniquePaths = new Set(resolved.filter(Boolean));
+
+      expect(uniquePaths.size).toBe(1);
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle empty project list', () => {
+      const identifiers: string[] = [];
+      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
+      expect(resolved).toHaveLength(0);
+    });
+
+    it('should handle all invalid identifiers', () => {
+      const identifiers = ['999', 'non-existent', 'fake'];
+      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
+      const valid = resolved.filter(Boolean);
+
+      expect(valid).toHaveLength(0);
+    });
+
+    it('should handle single project', () => {
+      fs.mkdirSync(path.join(tempDir, '001-project'));
+
+      const identifiers = ['001'];
+      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
+
+      expect(resolved).toHaveLength(1);
+      expect(resolved[0]).toBe(path.join(tempDir, '001-project'));
+    });
+
+    it('should handle projects with similar names', () => {
+      fs.mkdirSync(path.join(tempDir, '001-test'));
+      fs.mkdirSync(path.join(tempDir, '002-test-feature'));
+      fs.mkdirSync(path.join(tempDir, '003-testing'));
+
+      // Exact name match only
+      expect(resolveProjectIdentifier(tempDir, 'test')).toBe(path.join(tempDir, '001-test'));
+      expect(resolveProjectIdentifier(tempDir, 'test-feature')).toBe(path.join(tempDir, '002-test-feature'));
+      expect(resolveProjectIdentifier(tempDir, 'testing')).toBe(path.join(tempDir, '003-testing'));
+    });
+  });
+
+  describe('Order Preservation', () => {
+    it('should resolve projects in the order specified', () => {
+      fs.mkdirSync(path.join(tempDir, '001-project-a'));
+      fs.mkdirSync(path.join(tempDir, '002-project-b'));
+      fs.mkdirSync(path.join(tempDir, '003-project-c'));
+
+      // Specify out of order
+      const identifiers = ['003', '001', '002'];
+      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
+
+      expect(resolved[0]).toBe(path.join(tempDir, '003-project-c'));
+      expect(resolved[1]).toBe(path.join(tempDir, '001-project-a'));
+      expect(resolved[2]).toBe(path.join(tempDir, '002-project-b'));
+    });
+  });
+
+  describe('Full Folder Name Support', () => {
+    it('should resolve single project by full folder name with numeric prefix', () => {
+      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 single project by full folder name with base36 prefix', () => {
+      fs.mkdirSync(path.join(tempDir, 'a00-important-project'));
+
+      const result = resolveProjectIdentifier(tempDir, 'a00-important-project');
+      expect(result).toBe(path.join(tempDir, 'a00-important-project'));
+    });
+
+    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'));
+
+      const identifiers = ['001-project-a', '002-project-b'];
+      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
+
+      expect(resolved).toHaveLength(2);
+      expect(resolved[0]).toBe(path.join(tempDir, '001-project-a'));
+      expect(resolved[1]).toBe(path.join(tempDir, '002-project-b'));
+    });
+
+    it('should resolve mixed identifier formats including full folder names', () => {
+      fs.mkdirSync(path.join(tempDir, '003-numeric-id'));
+      fs.mkdirSync(path.join(tempDir, '001-full-folder-name'));
+      fs.mkdirSync(path.join(tempDir, '002-by-name'));
+
+      // Mix of number, full folder name, and project name
+      const identifiers = ['3', '001-full-folder-name', 'by-name'];
+      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
+
+      expect(resolved).toHaveLength(3);
+      expect(resolved[0]).toBe(path.join(tempDir, '003-numeric-id'));
+      expect(resolved[1]).toBe(path.join(tempDir, '001-full-folder-name'));
+      expect(resolved[2]).toBe(path.join(tempDir, '002-by-name'));
+    });
+
+    it('should return null for invalid full folder name (wrong prefix)', () => {
+      fs.mkdirSync(path.join(tempDir, '001-my-project'));
+
+      // Correct name but wrong prefix
+      const result = resolveProjectIdentifier(tempDir, '002-my-project');
+      expect(result).toBeNull();
+    });
+
+    it('should return null for invalid full folder name (wrong name)', () => {
+      fs.mkdirSync(path.join(tempDir, '001-my-project'));
+
+      // Correct prefix but wrong name
+      const result = resolveProjectIdentifier(tempDir, '001-other-project');
+      expect(result).toBeNull();
+    });
+
+    it('should detect duplicates when same project specified by number and full folder name', () => {
+      fs.mkdirSync(path.join(tempDir, '001-project-a'));
+
+      const identifiers = ['001', '001-project-a'];
+      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
+      const uniquePaths = new Set(resolved.filter(Boolean));
+
+      expect(uniquePaths.size).toBe(1);
+      expect(resolved[0]).toBe(resolved[1]); // Both resolve to same path
+    });
+
+    it('should detect duplicates when same project specified by name and full folder name', () => {
+      fs.mkdirSync(path.join(tempDir, '001-project-a'));
+
+      const identifiers = ['project-a', '001-project-a'];
+      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
+      const uniquePaths = new Set(resolved.filter(Boolean));
+
+      expect(uniquePaths.size).toBe(1);
+      expect(resolved[0]).toBe(resolved[1]); // Both resolve to same path
+    });
+
+    it('should handle case-insensitive full folder name matching', () => {
+      fs.mkdirSync(path.join(tempDir, '001-My-Project'));
+
+      const result = resolveProjectIdentifier(tempDir, '001-my-project');
+      expect(result).toBe(path.join(tempDir, '001-My-Project'));
+    });
+
+    it('should handle full folder names with multiple hyphens', () => {
+      fs.mkdirSync(path.join(tempDir, '001-my-cool-project-name'));
+
+      const result = resolveProjectIdentifier(tempDir, '001-my-cool-project-name');
+      expect(result).toBe(path.join(tempDir, '001-my-cool-project-name'));
+    });
+
+    it('should handle 2-digit prefix full folder names', () => {
+      fs.mkdirSync(path.join(tempDir, '01-short-prefix'));
+
+      const result = resolveProjectIdentifier(tempDir, '01-short-prefix');
+      expect(result).toBe(path.join(tempDir, '01-short-prefix'));
+    });
+
+    it('should resolve mixed base36 and numeric full folder names', () => {
+      fs.mkdirSync(path.join(tempDir, '001-numeric'));
+      fs.mkdirSync(path.join(tempDir, 'a01-base36'));
+
+      const identifiers = ['001-numeric', 'a01-base36'];
+      const resolved = identifiers.map((id) => resolveProjectIdentifier(tempDir, id));
+
+      expect(resolved).toHaveLength(2);
+      expect(resolved[0]).toBe(path.join(tempDir, '001-numeric'));
+      expect(resolved[1]).toBe(path.join(tempDir, 'a01-base36'));
+    });
+  });
+});

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

@@ -0,0 +1,270 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  deriveProjectState,
+  getNextExecutableTask,
+  isProjectComplete,
+  type DerivedProjectState,
+} from '../../src/core/state-derivation.js';
+
+/**
+ * Tests for the re-run functionality of the do command.
+ * These tests verify the task selection logic used by raf do when resuming projects.
+ */
+describe('do command rerun functionality', () => {
+  let tempDir: string;
+  let projectPath: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-do-rerun-test-'));
+    projectPath = path.join(tempDir, '001-test-project');
+    fs.mkdirSync(projectPath, { recursive: true });
+    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');
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  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');
+
+      // Mark first task as complete
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '001-task.md'),
+        '# Task 001 - Completed\n\n<promise>COMPLETE</promise>'
+      );
+
+      const state = deriveProjectState(projectPath);
+      const nextTask = getNextExecutableTask(state);
+
+      expect(nextTask?.id).toBe('002');
+      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');
+
+      // Mark first two tasks as complete
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '001-task.md'),
+        '# Task 001 - Completed\n\n<promise>COMPLETE</promise>'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '002-task.md'),
+        '# Task 002 - Completed\n\n<promise>COMPLETE</promise>'
+      );
+
+      const state = deriveProjectState(projectPath);
+      const nextTask = getNextExecutableTask(state);
+
+      expect(nextTask?.id).toBe('003');
+    });
+  });
+
+  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');
+
+      // Mark first task as failed
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '001-task.md'),
+        '# Task 001 - 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?.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');
+
+      // Mark first as complete, second as failed
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '001-task.md'),
+        '# Task 001 - Completed\n\n<promise>COMPLETE</promise>'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '002-task.md'),
+        '# Task 002 - Failed\n\n<promise>FAILED</promise>'
+      );
+
+      const state = deriveProjectState(projectPath);
+      const nextTask = getNextExecutableTask(state);
+
+      expect(nextTask?.id).toBe('002');
+      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');
+
+      const state = deriveProjectState(projectPath);
+      const nextTask = getNextExecutableTask(state);
+
+      expect(nextTask?.id).toBe('001');
+      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, 'outcomes', '001-task.md'),
+        '# Old format without status marker'
+      );
+
+      const state = deriveProjectState(projectPath);
+
+      expect(state.tasks[0]?.status).toBe('pending');
+    });
+
+    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'), '');
+
+      const state = deriveProjectState(projectPath);
+
+      expect(state.tasks[0]?.status).toBe('pending');
+    });
+  });
+
+  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, 'outcomes', '001-task.md'),
+        '# Task 001 - Completed\n\n<promise>COMPLETE</promise>'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '002-task.md'),
+        '# Task 002 - Completed\n\n<promise>COMPLETE</promise>'
+      );
+
+      const state = deriveProjectState(projectPath);
+
+      expect(isProjectComplete(state)).toBe(true);
+      expect(getNextExecutableTask(state)).toBeNull();
+    });
+
+    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, 'outcomes', '001-task.md'),
+        '# Task 001 - Failed\n\n<promise>FAILED</promise>'
+      );
+
+      const state = deriveProjectState(projectPath);
+
+      expect(isProjectComplete(state)).toBe(false);
+    });
+  });
+
+  describe('force mode task selection', () => {
+    /**
+     * Test that force mode logic would select all tasks regardless of status.
+     * The actual force mode implementation uses a Set to track tasks completed in the current session,
+     * 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');
+
+      // All tasks completed
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '001-task.md'),
+        '# Task 001 - Completed\n\n<promise>COMPLETE</promise>'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '002-task.md'),
+        '# Task 002 - Completed\n\n<promise>COMPLETE</promise>'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '003-task.md'),
+        '# Task 003 - Completed\n\n<promise>COMPLETE</promise>'
+      );
+
+      const state = deriveProjectState(projectPath);
+
+      // In force mode, all tasks should be available regardless of status
+      expect(state.tasks).toHaveLength(3);
+      expect(state.tasks.every((t) => t.status === 'completed')).toBe(true);
+
+      // Simulate force mode task selection
+      const completedInSession = new Set<string>();
+      function getNextForceTask(
+        s: DerivedProjectState,
+        completed: Set<string>
+      ) {
+        for (const t of s.tasks) {
+          if (!completed.has(t.id)) {
+            return t;
+          }
+        }
+        return null;
+      }
+
+      // First iteration - should get task 001
+      let task = getNextForceTask(state, completedInSession);
+      expect(task?.id).toBe('001');
+      completedInSession.add(task!.id);
+
+      // Second iteration - should get task 002
+      task = getNextForceTask(state, completedInSession);
+      expect(task?.id).toBe('002');
+      completedInSession.add(task!.id);
+
+      // Third iteration - should get task 003
+      task = getNextForceTask(state, completedInSession);
+      expect(task?.id).toBe('003');
+      completedInSession.add(task!.id);
+
+      // Fourth iteration - no more tasks
+      task = getNextForceTask(state, completedInSession);
+      expect(task).toBeNull();
+    });
+  });
+
+  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, 'outcomes', '001-task.md'),
+        '# Task 001 - Completed\n\n<promise>COMPLETE</promise>'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '002-task.md'),
+        '# Task 002 - 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?.status).toBe('failed');
+    });
+  });
+});