rafcode 1.0.0

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

@@ -0,0 +1,323 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  deriveProjectState,
+  getNextExecutableTask,
+  getDerivedStats,
+  isProjectComplete,
+  hasProjectFailed,
+} from '../../src/core/state-derivation.js';
+import { getOutcomeFilePath } from '../../src/utils/paths.js';
+
+/**
+ * Tests for blocked task handling in the do command.
+ * These tests verify that tasks with failed dependencies are correctly blocked
+ * and that blocked outcome files are generated properly.
+ */
+describe('do command blocked tasks', () => {
+  let tempDir: string;
+  let projectPath: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-do-blocked-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('blocked task detection', () => {
+    it('should mark task as blocked when dependency fails', () => {
+      // Task 001 - no dependencies
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '001-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'
+      );
+
+      // Mark task 001 as failed
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '001-setup.md'),
+        '# Task 001 - Failed\n\n<promise>FAILED</promise>'
+      );
+
+      const state = deriveProjectState(projectPath);
+
+      expect(state.tasks[0]?.status).toBe('failed');
+      expect(state.tasks[1]?.status).toBe('blocked');
+    });
+
+    it('should cascade blocking through multiple tasks', () => {
+      // Task 001 - no dependencies
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '001-first.md'),
+        '# Task: First'
+      );
+      // Task 002 - depends on 001
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '002-second.md'),
+        '# Task: Second\n\n## Dependencies\n001'
+      );
+      // Task 003 - depends on 002
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '003-third.md'),
+        '# Task: Third\n\n## Dependencies\n002'
+      );
+
+      // Mark task 001 as failed
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '001-first.md'),
+        '# Task 001 - Failed\n\n<promise>FAILED</promise>'
+      );
+
+      const state = deriveProjectState(projectPath);
+
+      expect(state.tasks[0]?.status).toBe('failed');
+      expect(state.tasks[1]?.status).toBe('blocked'); // Blocked by 001
+      expect(state.tasks[2]?.status).toBe('blocked'); // Blocked by 002 (transitively)
+    });
+
+    it('should not block task if dependency succeeds', () => {
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '001-setup.md'),
+        '# Task: Setup'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '002-build.md'),
+        '# Task: Build\n\n## Dependencies\n001'
+      );
+
+      // Mark task 001 as complete
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '001-setup.md'),
+        '# Task 001 - Complete\n\n<promise>COMPLETE</promise>'
+      );
+
+      const state = deriveProjectState(projectPath);
+
+      expect(state.tasks[0]?.status).toBe('completed');
+      expect(state.tasks[1]?.status).toBe('pending');
+    });
+
+    it('should block task when one of multiple dependencies fails', () => {
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '001-first.md'),
+        '# Task: First'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '002-second.md'),
+        '# Task: Second'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '003-third.md'),
+        '# Task: Third\n\n## Dependencies\n001, 002'
+      );
+
+      // Mark 001 as complete, 002 as failed
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '001-first.md'),
+        '# Task 001 - Complete\n\n<promise>COMPLETE</promise>'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '002-second.md'),
+        '# Task 002 - Failed\n\n<promise>FAILED</promise>'
+      );
+
+      const state = deriveProjectState(projectPath);
+
+      expect(state.tasks[0]?.status).toBe('completed');
+      expect(state.tasks[1]?.status).toBe('failed');
+      expect(state.tasks[2]?.status).toBe('blocked');
+    });
+  });
+
+  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'),
+        '# Task: Setup'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '002-build.md'),
+        '# Task: Build\n\n## Dependencies\n001'
+      );
+
+      // Mark task 001 as failed
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '001-setup.md'),
+        '# Task 001 - Failed\n\n<promise>FAILED</promise>'
+      );
+
+      const state = deriveProjectState(projectPath);
+      const nextTask = getNextExecutableTask(state);
+
+      // Should return the failed task for retry, not the blocked one
+      expect(nextTask?.id).toBe('001');
+      expect(nextTask?.status).toBe('failed');
+    });
+
+    it('should return pending tasks before failed tasks', () => {
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '001-first.md'),
+        '# Task: First'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '002-second.md'),
+        '# Task: Second'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '003-third.md'),
+        '# Task: Third\n\n## Dependencies\n001'
+      );
+
+      // Mark 001 as failed, 002 remains pending
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '001-first.md'),
+        '# Task 001 - Failed\n\n<promise>FAILED</promise>'
+      );
+
+      const state = deriveProjectState(projectPath);
+      const nextTask = getNextExecutableTask(state);
+
+      // Should return pending task 002, not failed 001
+      expect(nextTask?.id).toBe('002');
+      expect(nextTask?.status).toBe('pending');
+    });
+  });
+
+  describe('getDerivedStats with blocked tasks', () => {
+    it('should count blocked tasks separately', () => {
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '001-first.md'),
+        '# Task: First'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '002-second.md'),
+        '# Task: Second\n\n## Dependencies\n001'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '003-third.md'),
+        '# Task: Third\n\n## Dependencies\n002'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '004-fourth.md'),
+        '# Task: Fourth'
+      );
+
+      // Mark task 001 as failed
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '001-first.md'),
+        '# Task 001 - Failed\n\n<promise>FAILED</promise>'
+      );
+
+      const state = deriveProjectState(projectPath);
+      const stats = getDerivedStats(state);
+
+      expect(stats.failed).toBe(1);
+      expect(stats.blocked).toBe(2);
+      expect(stats.pending).toBe(1);
+      expect(stats.completed).toBe(0);
+      expect(stats.total).toBe(4);
+    });
+  });
+
+  describe('isProjectComplete with blocked tasks', () => {
+    it('should not consider project complete if blocked tasks exist', () => {
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '001-first.md'),
+        '# Task: First'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '002-second.md'),
+        '# Task: Second\n\n## Dependencies\n001'
+      );
+
+      // Mark 001 as failed (002 becomes blocked)
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '001-first.md'),
+        '# Task 001 - Failed\n\n<promise>FAILED</promise>'
+      );
+
+      const state = deriveProjectState(projectPath);
+
+      expect(isProjectComplete(state)).toBe(false);
+    });
+  });
+
+  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'),
+        '# Task: First'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '002-second.md'),
+        '# Task: Second\n\n## Dependencies\n001'
+      );
+
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '001-first.md'),
+        '# Task 001 - Failed\n\n<promise>FAILED</promise>'
+      );
+
+      const state = deriveProjectState(projectPath);
+
+      expect(hasProjectFailed(state)).toBe(true);
+    });
+
+    it('should not report project as failed with only 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'),
+        '# Task: First'
+      );
+
+      // Mark as blocked (artificial - in practice there would be a failed dep)
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '001-first.md'),
+        '# Task 001 - Blocked\n\n<promise>BLOCKED</promise>'
+      );
+
+      const state = deriveProjectState(projectPath);
+
+      // hasProjectFailed only checks for 'failed' status, not 'blocked'
+      expect(hasProjectFailed(state)).toBe(false);
+    });
+  });
+
+  describe('blocked outcome file format', () => {
+    it('should recognize BLOCKED marker in outcome files', () => {
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '001-task.md'),
+        '# Task: Task'
+      );
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '001-task.md'),
+        '# Outcome: Task 001 Blocked\n\n## Summary\n\nBlocked by dependency.\n\n<promise>BLOCKED</promise>'
+      );
+
+      const state = deriveProjectState(projectPath);
+
+      expect(state.tasks[0]?.status).toBe('blocked');
+    });
+  });
+
+  describe('getOutcomeFilePath', () => {
+    it('should generate correct outcome file path', () => {
+      const outcomePath = getOutcomeFilePath(projectPath, '002', 'build-project');
+
+      expect(outcomePath).toBe(path.join(projectPath, 'outcomes', '002-build-project.md'));
+    });
+  });
+});

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

@@ -0,0 +1,198 @@
+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';
+
+describe('Do Command - Identifier Support', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-do-cmd-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  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 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 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'));
+    });
+  });
+
+  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');
+      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');
+      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');
+      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');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('Backward Compatibility', () => {
+    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'));
+    });
+
+    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 still resolve by base36 prefix', () => {
+      expect(resolveProjectIdentifier(tempDir, 'a00')).toBe(path.join(tempDir, 'a00-base36-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'));
+    });
+  });
+
+  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');
+      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');
+      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 name = extractProjectName(projectPath);
+      expect(name).toBe('my-cool-project-name');
+    });
+  });
+});