rafcode 1.0.0

package/tests/unit/planning-prompt.test.ts

@@ -0,0 +1,137 @@
+import { getPlanningPrompt, PlanningPromptParams } from '../../src/prompts/planning.js';
+
+describe('Planning Prompt', () => {
+  describe('getPlanningPrompt', () => {
+    it('should return systemPrompt and userMessage', () => {
+      const params: PlanningPromptParams = {
+        projectPath: '/test/project',
+        inputContent: 'Build a todo app with user authentication',
+      };
+
+      const result = getPlanningPrompt(params);
+
+      expect(result).toHaveProperty('systemPrompt');
+      expect(result).toHaveProperty('userMessage');
+      expect(typeof result.systemPrompt).toBe('string');
+      expect(typeof result.userMessage).toBe('string');
+      expect(result.systemPrompt.length).toBeGreaterThan(0);
+      expect(result.userMessage.length).toBeGreaterThan(0);
+    });
+
+    it('should include project path in system prompt', () => {
+      const params: PlanningPromptParams = {
+        projectPath: '/my/custom/project/path',
+        inputContent: 'Some description',
+      };
+
+      const { systemPrompt } = getPlanningPrompt(params);
+
+      expect(systemPrompt).toContain('/my/custom/project/path');
+    });
+
+    it('should include inputContent in user message', () => {
+      const params: PlanningPromptParams = {
+        projectPath: '/test/project',
+        inputContent: 'Build a REST API with Express and MongoDB',
+      };
+
+      const { userMessage } = getPlanningPrompt(params);
+
+      expect(userMessage).toContain('Build a REST API with Express and MongoDB');
+      expect(userMessage).toContain('planning interview');
+    });
+
+    it('should include planning instructions in system prompt', () => {
+      const params: PlanningPromptParams = {
+        projectPath: '/test/project',
+        inputContent: 'Some project',
+      };
+
+      const { systemPrompt } = getPlanningPrompt(params);
+
+      expect(systemPrompt).toContain('project planning assistant');
+      expect(systemPrompt).toContain('RAF');
+      expect(systemPrompt).toContain('Identify and Order Tasks');
+      expect(systemPrompt).toContain('Interview the User');
+      expect(systemPrompt).toContain('Create Plan Files');
+      expect(systemPrompt).toContain('AskUserQuestion');
+    });
+
+    it('should include decisions file path in system prompt', () => {
+      const params: PlanningPromptParams = {
+        projectPath: '/test/project',
+        inputContent: 'Some project',
+      };
+
+      const { systemPrompt } = getPlanningPrompt(params);
+
+      expect(systemPrompt).toContain('/test/project/decisions.md');
+    });
+
+    it('should include plans directory path in system prompt', () => {
+      const params: PlanningPromptParams = {
+        projectPath: '/test/project',
+        inputContent: 'Some project',
+      };
+
+      const { systemPrompt } = getPlanningPrompt(params);
+
+      expect(systemPrompt).toContain('/test/project/plans/001-task-name.md');
+      expect(systemPrompt).toContain('/test/project/plans/002-task-name.md');
+    });
+
+    it('should include task guidelines in system prompt', () => {
+      const params: PlanningPromptParams = {
+        projectPath: '/test/project',
+        inputContent: 'Some project',
+      };
+
+      const { systemPrompt } = getPlanningPrompt(params);
+
+      expect(systemPrompt).toContain('3-8 distinct');
+      expect(systemPrompt).toContain('independently completable');
+      expect(systemPrompt).toContain('10-30 minutes');
+    });
+
+    it('should include plan file structure template in system prompt', () => {
+      const params: PlanningPromptParams = {
+        projectPath: '/test/project',
+        inputContent: 'Some project',
+      };
+
+      const { systemPrompt } = getPlanningPrompt(params);
+
+      expect(systemPrompt).toContain('## Objective');
+      expect(systemPrompt).toContain('## Context');
+      expect(systemPrompt).toContain('## Requirements');
+      expect(systemPrompt).toContain('## Implementation Steps');
+      expect(systemPrompt).toContain('## Acceptance Criteria');
+    });
+
+    it('should include important rules in system prompt', () => {
+      const params: PlanningPromptParams = {
+        projectPath: '/test/project',
+        inputContent: 'Some project',
+      };
+
+      const { systemPrompt } = getPlanningPrompt(params);
+
+      expect(systemPrompt).toContain('ALWAYS interview the user before creating plans');
+      expect(systemPrompt).toContain('numbered order (001, 002, 003');
+      expect(systemPrompt).toContain('kebab-case names');
+    });
+
+    it('should include project description in user message', () => {
+      const params: PlanningPromptParams = {
+        projectPath: '/test/project',
+        inputContent: 'Build a dashboard with charts and graphs',
+      };
+
+      const { userMessage } = getPlanningPrompt(params);
+
+      // User message should contain the actual project description
+      expect(userMessage).toContain('Build a dashboard with charts and graphs');
+      expect(userMessage).toContain('project description');
+    });
+  });
+});

package/tests/unit/project-manager.test.ts

@@ -0,0 +1,265 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { ProjectManager } from '../../src/core/project-manager.js';
+
+describe('ProjectManager', () => {
+  let tempDir: string;
+  let originalCwd: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-test-'));
+    originalCwd = process.cwd();
+    process.chdir(tempDir);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('createProject', () => {
+    it('should create project with correct structure', () => {
+      const manager = new ProjectManager();
+      const projectPath = manager.createProject('test-project');
+
+      expect(fs.existsSync(projectPath)).toBe(true);
+      expect(fs.existsSync(path.join(projectPath, 'plans'))).toBe(true);
+      expect(fs.existsSync(path.join(projectPath, 'outcomes'))).toBe(true);
+      expect(fs.existsSync(path.join(projectPath, 'decisions.md'))).toBe(true);
+    });
+
+    it('should auto-increment project numbers', () => {
+      const manager = new ProjectManager();
+
+      const path1 = manager.createProject('first');
+      const path2 = manager.createProject('second');
+
+      expect(path.basename(path1)).toBe('001-first');
+      expect(path.basename(path2)).toBe('002-second');
+    });
+
+    it('should sanitize project names', () => {
+      const manager = new ProjectManager();
+      const projectPath = manager.createProject('My Project Name!');
+
+      expect(path.basename(projectPath)).toBe('001-my-project-name');
+    });
+  });
+
+  describe('findProject', () => {
+    it('should find existing project by name', () => {
+      const manager = new ProjectManager();
+      manager.createProject('findme');
+
+      const found = manager.findProject('findme');
+      expect(found).not.toBeNull();
+      expect(found).toContain('001-findme');
+    });
+
+    it('should return null for non-existent project', () => {
+      const manager = new ProjectManager();
+      const found = manager.findProject('nonexistent');
+      expect(found).toBeNull();
+    });
+  });
+
+  describe('listProjects', () => {
+    it('should list all projects', () => {
+      const manager = new ProjectManager();
+      manager.createProject('alpha');
+      manager.createProject('beta');
+
+      const projects = manager.listProjects();
+      expect(projects).toHaveLength(2);
+      expect(projects[0]?.name).toBe('alpha');
+      expect(projects[1]?.name).toBe('beta');
+    });
+
+    it('should return empty array when no projects', () => {
+      const manager = new ProjectManager();
+      const projects = manager.listProjects();
+      expect(projects).toEqual([]);
+    });
+
+    it('should include task counts from derived state', () => {
+      const manager = new ProjectManager();
+      const projectPath = manager.createProject('test');
+
+      // Create plan files
+      fs.writeFileSync(path.join(projectPath, 'plans', '001-task.md'), '# Task 1');
+      fs.writeFileSync(path.join(projectPath, 'plans', '002-task.md'), '# Task 2');
+
+      // Create outcome with COMPLETE promise marker
+      fs.writeFileSync(
+        path.join(projectPath, 'outcomes', '001-task.md'),
+        '# Task 001 - Completed\n\n<promise>COMPLETE</promise>'
+      );
+
+      const projects = manager.listProjects();
+      expect(projects[0]?.taskCount).toBe(2);
+      expect(projects[0]?.completedCount).toBe(1);
+      expect(projects[0]?.failedCount).toBe(0);
+    });
+  });
+
+  describe('saveInput and readInput', () => {
+    it('should save and read input', () => {
+      const manager = new ProjectManager();
+      const projectPath = manager.createProject('test');
+
+      const content = '# My Project\n\nDescription here.';
+      manager.saveInput(projectPath, content);
+
+      const read = manager.readInput(projectPath);
+      expect(read).toBe(content);
+    });
+  });
+
+  describe('saveOutcome and readOutcomes', () => {
+    it('should save and read outcomes', () => {
+      const manager = new ProjectManager();
+      const projectPath = manager.createProject('test');
+
+      // Create a plan file to match naming
+      fs.writeFileSync(
+        path.join(projectPath, 'plans', '01-task.md'),
+        '# Task'
+      );
+
+      manager.saveOutcome(projectPath, '01', 'Outcome content');
+
+      const outcomes = manager.readOutcomes(projectPath);
+      expect(outcomes).toHaveLength(1);
+      expect(outcomes[0]?.taskId).toBe('01');
+      expect(outcomes[0]?.content).toBe('Outcome content');
+    });
+  });
+
+  describe('saveLog', () => {
+    it('should create logs directory in project and save log', () => {
+      const manager = new ProjectManager();
+      const projectPath = manager.createProject('test');
+
+      manager.saveLog(projectPath, '01', 'Log content');
+
+      const logPath = path.join(projectPath, 'logs', '01-task.log');
+      expect(fs.existsSync(logPath)).toBe(true);
+      expect(fs.readFileSync(logPath, 'utf-8')).toBe('Log content');
+    });
+  });
+
+  describe('isProjectFolderEmpty', () => {
+    it('should return true for non-existent folder', () => {
+      const manager = new ProjectManager();
+      const nonExistentPath = path.join(tempDir, 'nonexistent');
+
+      expect(manager.isProjectFolderEmpty(nonExistentPath)).toBe(true);
+    });
+
+    it('should return true when plans directory does not exist', () => {
+      const manager = new ProjectManager();
+      const projectPath = manager.createProject('test');
+
+      // Remove plans directory
+      const plansDir = path.join(projectPath, 'plans');
+      fs.rmSync(plansDir, { recursive: true, force: true });
+
+      expect(manager.isProjectFolderEmpty(projectPath)).toBe(true);
+    });
+
+    it('should return true when plans directory is empty', () => {
+      const manager = new ProjectManager();
+      const projectPath = manager.createProject('test');
+
+      // Plans directory exists but has no files
+      expect(manager.isProjectFolderEmpty(projectPath)).toBe(true);
+    });
+
+    it('should return false when at least one plan file exists', () => {
+      const manager = new ProjectManager();
+      const projectPath = manager.createProject('test');
+
+      // Create a plan file
+      const plansDir = path.join(projectPath, 'plans');
+      fs.writeFileSync(path.join(plansDir, '01-task.md'), '# Task 1');
+
+      expect(manager.isProjectFolderEmpty(projectPath)).toBe(false);
+    });
+
+    it('should ignore non-.md files in plans directory', () => {
+      const manager = new ProjectManager();
+      const projectPath = manager.createProject('test');
+
+      // Create a non-.md file
+      const plansDir = path.join(projectPath, 'plans');
+      fs.writeFileSync(path.join(plansDir, 'notes.txt'), 'Notes');
+
+      expect(manager.isProjectFolderEmpty(projectPath)).toBe(true);
+    });
+  });
+
+  describe('cleanupEmptyProject', () => {
+    it('should delete folder when no plans exist', () => {
+      const manager = new ProjectManager();
+      const projectPath = manager.createProject('test');
+
+      // Verify folder exists
+      expect(fs.existsSync(projectPath)).toBe(true);
+
+      // Cleanup should remove the folder
+      manager.cleanupEmptyProject(projectPath);
+
+      expect(fs.existsSync(projectPath)).toBe(false);
+    });
+
+    it('should not delete folder when plans exist', () => {
+      const manager = new ProjectManager();
+      const projectPath = manager.createProject('test');
+
+      // Create a plan file
+      const plansDir = path.join(projectPath, 'plans');
+      fs.writeFileSync(path.join(plansDir, '01-task.md'), '# Task 1');
+
+      // Cleanup should NOT remove the folder
+      manager.cleanupEmptyProject(projectPath);
+
+      expect(fs.existsSync(projectPath)).toBe(true);
+      expect(fs.existsSync(path.join(plansDir, '01-task.md'))).toBe(true);
+    });
+
+    it('should handle non-existent folder gracefully', () => {
+      const manager = new ProjectManager();
+      const nonExistentPath = path.join(tempDir, 'nonexistent');
+
+      // Should not throw
+      expect(() => {
+        manager.cleanupEmptyProject(nonExistentPath);
+      }).not.toThrow();
+    });
+
+    it('should be idempotent - safe to call multiple times', () => {
+      const manager = new ProjectManager();
+      const projectPath = manager.createProject('test');
+
+      // Call cleanup multiple times
+      manager.cleanupEmptyProject(projectPath);
+      manager.cleanupEmptyProject(projectPath);
+      manager.cleanupEmptyProject(projectPath);
+
+      expect(fs.existsSync(projectPath)).toBe(false);
+    });
+
+    it('should delete folder even if only subdirectories exist (no plans)', () => {
+      const manager = new ProjectManager();
+      const projectPath = manager.createProject('test');
+
+      // Create additional subdirectories but no plan files
+      fs.mkdirSync(path.join(projectPath, 'extra'), { recursive: true });
+
+      manager.cleanupEmptyProject(projectPath);
+
+      expect(fs.existsSync(projectPath)).toBe(false);
+    });
+  });
+});