rafcode 1.3.2 → 2.0.0

package/src/utils/terminal-symbols.ts

@@ -36,8 +36,8 @@ function truncate(str: string, maxLength: number): string {
  * @param status - Task status
  * @param name - Task name
  * @param elapsedMs - Optional elapsed time in milliseconds
- * @param taskId - Optional task ID for [NNN] prefix display
- * @returns Formatted string like "● [001] auth-login 1:23" or "✓ [001] auth-login 1/5"
+ * @param taskId - Optional task ID prefix display
+ * @returns Formatted string like "● 001-auth-login 1:23" or "✓ 001-auth-login 1/5"
  */
 export function formatTaskProgress(
   current: number,
@@ -49,7 +49,7 @@ export function formatTaskProgress(
 ): string {
   const symbol = SYMBOLS[status];
   const displayName = truncate(name || 'task', 40);
-  const idPrefix = taskId ? `[${taskId}] ` : '';
+  const idPrefix = taskId ? `${taskId}-` : '';
 
   // Show elapsed time for running tasks, completed tasks, and failed tasks
   if (elapsedMs !== undefined) {

package/src/utils/validation.ts

@@ -58,15 +58,8 @@ export function validateProjectExists(rafDir: string, projectName: string): stri
 
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      // Match numeric pattern like "001-project-name" (or legacy 01-project-name)
-      const numericMatch = entry.name.match(/^\d{2,3}-(.+)$/);
-      if (numericMatch && numericMatch[1] === projectName) {
-        return path.join(rafDir, entry.name);
-      }
-
-      // Match base36 pattern like "a00-project-name"
-      const base36Match = entry.name.match(/^[a-z][0-9a-z]{2}-(.+)$/i);
-      if (base36Match && base36Match[1] === projectName) {
+      const match = entry.name.match(/^[a-z]{6}-(.+)$/i);
+      if (match && match[1] === projectName) {
         return path.join(rafDir, entry.name);
       }
     }

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

@@ -0,0 +1,85 @@
+import { getAmendPrompt, AmendPromptParams } from '../../src/prompts/amend.js';
+
+describe('Amend Prompt', () => {
+  const baseParams: AmendPromptParams = {
+    projectPath: '/test/project',
+    existingTasks: [
+      {
+        id: '01',
+        status: 'completed',
+        planFile: 'plans/01-setup.md',
+        taskName: 'setup',
+      },
+      {
+        id: '02',
+        status: 'pending',
+        planFile: 'plans/02-feature.md',
+        taskName: 'feature',
+      },
+    ],
+    nextTaskNumber: 3,
+    newTaskDescription: 'Add a new feature',
+  };
+
+  describe('getAmendPrompt', () => {
+    it('should return systemPrompt and userMessage', () => {
+      const result = getAmendPrompt(baseParams);
+
+      expect(result).toHaveProperty('systemPrompt');
+      expect(result).toHaveProperty('userMessage');
+      expect(typeof result.systemPrompt).toBe('string');
+      expect(typeof result.userMessage).toBe('string');
+    });
+
+    it('should include project path in system prompt', () => {
+      const { systemPrompt } = getAmendPrompt(baseParams);
+
+      expect(systemPrompt).toContain('/test/project');
+    });
+
+    it('should include existing tasks in system prompt', () => {
+      const { systemPrompt } = getAmendPrompt(baseParams);
+
+      expect(systemPrompt).toContain('Task 01');
+      expect(systemPrompt).toContain('Task 02');
+      expect(systemPrompt).toContain('[COMPLETED]');
+      expect(systemPrompt).toContain('[PENDING]');
+    });
+
+    it('should show raf do without --worktree when worktreeMode is false', () => {
+      const params: AmendPromptParams = {
+        ...baseParams,
+        worktreeMode: false,
+      };
+
+      const { systemPrompt } = getAmendPrompt(params);
+
+      expect(systemPrompt).toContain('raf do <project>');
+      expect(systemPrompt).not.toContain('--worktree');
+    });
+
+    it('should show raf do without --worktree when worktreeMode is undefined', () => {
+      const { systemPrompt } = getAmendPrompt(baseParams);
+
+      expect(systemPrompt).toContain('raf do <project>');
+      expect(systemPrompt).not.toContain('--worktree');
+    });
+
+    it('should show raf do with --worktree when worktreeMode is true', () => {
+      const params: AmendPromptParams = {
+        ...baseParams,
+        worktreeMode: true,
+      };
+
+      const { systemPrompt } = getAmendPrompt(params);
+
+      expect(systemPrompt).toContain('raf do <project> --worktree');
+    });
+
+    it('should include new task description in user message', () => {
+      const { userMessage } = getAmendPrompt(baseParams);
+
+      expect(userMessage).toContain('Add a new feature');
+    });
+  });
+});

package/tests/unit/claude-runner.test.ts

@@ -854,7 +854,7 @@ describe('ClaudeRunner', () => {
       const mockProc = createMockProcess();
       mockSpawn.mockReturnValue(mockProc);
 
-      const outcomePath = '/test/project/outcomes/001-task.md';
+      const outcomePath = '/test/project/outcomes/01-task.md';
 
       // Outcome file doesn't exist initially
       mockExistsSync.mockReturnValue(false);
@@ -893,7 +893,7 @@ describe('ClaudeRunner', () => {
       mockProc.kill = jest.fn();
       mockSpawn.mockReturnValue(mockProc);
 
-      const outcomePath = '/test/project/outcomes/001-task.md';
+      const outcomePath = '/test/project/outcomes/01-task.md';
 
       // Outcome file already exists from previous failed run
       mockExistsSync.mockReturnValue(true);
@@ -981,8 +981,8 @@ describe('ClaudeRunner', () => {
 
     const commitContext = {
       preExecutionHead: 'aaa111',
-      expectedPrefix: 'RAF[005:001]',
-      outcomeFilePath: '/project/outcomes/001-task.md',
+      expectedPrefix: 'RAF[005:01]',
+      outcomeFilePath: '/project/outcomes/01-task.md',
     };
 
     beforeEach(() => {
@@ -998,7 +998,7 @@ describe('ClaudeRunner', () => {
 
       // Commit lands during grace period
       mockGetHeadCommitHash.mockReturnValue('bbb222');
-      mockGetHeadCommitMessage.mockReturnValue('RAF[005:001] Add feature');
+      mockGetHeadCommitMessage.mockReturnValue('RAF[005:01] Add feature');
       mockIsFileCommittedInHead.mockReturnValue(true);
 
       const runner = new ClaudeRunner();
@@ -1042,7 +1042,7 @@ describe('ClaudeRunner', () => {
 
       // Now simulate commit landing during extended polling
       mockGetHeadCommitHash.mockReturnValue('bbb222');
-      mockGetHeadCommitMessage.mockReturnValue('RAF[005:001] Add feature');
+      mockGetHeadCommitMessage.mockReturnValue('RAF[005:01] Add feature');
       mockIsFileCommittedInHead.mockReturnValue(true);
 
       // Advance to next commit poll interval
@@ -1131,7 +1131,7 @@ describe('ClaudeRunner', () => {
 
       // HEAD changed but message doesn't match expected prefix
       mockGetHeadCommitHash.mockReturnValue('bbb222');
-      mockGetHeadCommitMessage.mockReturnValue('RAF[005:002] Wrong task');
+      mockGetHeadCommitMessage.mockReturnValue('RAF[005:02] Wrong task');
       mockIsFileCommittedInHead.mockReturnValue(true);
 
       const runner = new ClaudeRunner();
@@ -1148,7 +1148,7 @@ describe('ClaudeRunner', () => {
       expect(mockProc.kill).not.toHaveBeenCalled();
 
       // Fix commit message
-      mockGetHeadCommitMessage.mockReturnValue('RAF[005:001] Correct task');
+      mockGetHeadCommitMessage.mockReturnValue('RAF[005:01] Correct task');
 
       // Next poll finds it
       jest.advanceTimersByTime(COMMIT_POLL_INTERVAL_MS);
@@ -1165,7 +1165,7 @@ describe('ClaudeRunner', () => {
 
       // HEAD changed and message matches, but file not committed
       mockGetHeadCommitHash.mockReturnValue('bbb222');
-      mockGetHeadCommitMessage.mockReturnValue('RAF[005:001] Add feature');
+      mockGetHeadCommitMessage.mockReturnValue('RAF[005:01] Add feature');
       mockIsFileCommittedInHead.mockReturnValue(false);
 
       const runner = new ClaudeRunner();

package/tests/unit/commit-planning-artifacts-worktree.test.ts

@@ -0,0 +1,327 @@
+import { execSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+/**
+ * Integration tests for commitPlanningArtifacts in worktree scenarios.
+ * Uses real git repos and worktrees to verify the commit behavior.
+ */
+
+// Import the actual module (no mocking)
+const { commitPlanningArtifacts } = await import('../../src/core/git.js');
+
+/**
+ * Helper: create a temp directory for testing.
+ * Uses realpathSync to resolve symlinks (e.g., /tmp -> /private/tmp on macOS).
+ */
+function makeTempDir(prefix: string): string {
+  return fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), prefix)));
+}
+
+/**
+ * Helper: initialise a bare-bones git repo with one commit.
+ */
+function initGitRepo(dir: string): void {
+  execSync('git init', { cwd: dir, stdio: 'pipe' });
+  execSync('git config user.email "test@test.com"', { cwd: dir, stdio: 'pipe' });
+  execSync('git config user.name "Test"', { cwd: dir, stdio: 'pipe' });
+  fs.writeFileSync(path.join(dir, 'README.md'), '# Test repo\n');
+  execSync('git add .', { cwd: dir, stdio: 'pipe' });
+  execSync('git commit -m "Initial commit"', { cwd: dir, stdio: 'pipe' });
+}
+
+/**
+ * Helper: get the last commit message.
+ */
+function getLastCommitMessage(cwd: string): string {
+  return execSync('git log -1 --format=%s', { cwd, encoding: 'utf-8', stdio: 'pipe' }).trim();
+}
+
+/**
+ * Helper: get list of files changed in the last commit.
+ */
+function getLastCommitFiles(cwd: string): string[] {
+  const output = execSync('git show --name-only --format=""', {
+    cwd,
+    encoding: 'utf-8',
+    stdio: 'pipe',
+  }).trim();
+  return output ? output.split('\n').filter(Boolean) : [];
+}
+
+describe('commitPlanningArtifacts - worktree integration', () => {
+  let repoDir: string;
+  let worktreePath: string;
+  const worktreePaths: string[] = [];
+
+  beforeEach(() => {
+    repoDir = makeTempDir('raf-commit-wt-');
+    initGitRepo(repoDir);
+  });
+
+  afterEach(() => {
+    // Clean up worktrees first (before removing repo)
+    for (const wt of worktreePaths) {
+      try {
+        execSync(`git worktree remove "${wt}" --force`, { cwd: repoDir, stdio: 'pipe' });
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+    worktreePaths.length = 0;
+
+    // Clean up repo
+    try {
+      fs.rmSync(repoDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  function createInitialProject(dir: string, projectFolder: string): string {
+    const projectPath = path.join(dir, 'RAF', projectFolder);
+    fs.mkdirSync(path.join(projectPath, 'plans'), { recursive: true });
+    fs.mkdirSync(path.join(projectPath, 'outcomes'), { recursive: true });
+    fs.writeFileSync(path.join(projectPath, 'input.md'), 'original input');
+    fs.writeFileSync(path.join(projectPath, 'decisions.md'), '# Decisions\n\n## Q1?\nA1');
+    fs.writeFileSync(path.join(projectPath, 'plans', '01-first-task.md'), '# Task: First');
+    return projectPath;
+  }
+
+  function createWorktreeForProject(repoDir: string, projectFolder: string): string {
+    const wtPath = path.join(makeTempDir('raf-wt-'), projectFolder);
+    execSync(`git worktree add "${wtPath}" -b "${projectFolder}"`, {
+      cwd: repoDir,
+      stdio: 'pipe',
+    });
+    worktreePaths.push(wtPath);
+    return wtPath;
+  }
+
+  it('should commit input.md and decisions.md changes in worktree', async () => {
+    const projectFolder = 'aatest-my-project';
+
+    // Create initial project and commit
+    createInitialProject(repoDir, projectFolder);
+    execSync('git add -A', { cwd: repoDir, stdio: 'pipe' });
+    execSync('git commit -m "Initial plan"', { cwd: repoDir, stdio: 'pipe' });
+
+    // Create worktree
+    worktreePath = createWorktreeForProject(repoDir, projectFolder);
+    const wtProjectPath = path.join(worktreePath, 'RAF', projectFolder);
+
+    // Simulate amend: update input.md and decisions.md
+    fs.writeFileSync(
+      path.join(wtProjectPath, 'input.md'),
+      'original input\n\n---\n\nnew task description'
+    );
+    fs.writeFileSync(
+      path.join(wtProjectPath, 'decisions.md'),
+      '# Decisions\n\n## Q1?\nA1\n\n## Q2?\nA2'
+    );
+
+    // Call commitPlanningArtifacts with worktree cwd
+    await commitPlanningArtifacts(wtProjectPath, {
+      cwd: worktreePath,
+    });
+
+    // Verify commit was made
+    const lastMsg = getLastCommitMessage(worktreePath);
+    expect(lastMsg).toMatch(/RAF\[aatest\] Plan: my-project/);
+
+    // Verify both files are in the commit
+    const committedFiles = getLastCommitFiles(worktreePath);
+    expect(committedFiles).toContain(`RAF/${projectFolder}/input.md`);
+    expect(committedFiles).toContain(`RAF/${projectFolder}/decisions.md`);
+  });
+
+  it('should commit amend artifacts with additional plan files in worktree', async () => {
+    const projectFolder = 'aatest-my-project';
+
+    // Create initial project and commit
+    createInitialProject(repoDir, projectFolder);
+    execSync('git add -A', { cwd: repoDir, stdio: 'pipe' });
+    execSync('git commit -m "Initial plan"', { cwd: repoDir, stdio: 'pipe' });
+
+    // Create worktree
+    worktreePath = createWorktreeForProject(repoDir, projectFolder);
+    const wtProjectPath = path.join(worktreePath, 'RAF', projectFolder);
+
+    // Simulate amend: update files and create new plan
+    fs.writeFileSync(
+      path.join(wtProjectPath, 'input.md'),
+      'original input\n\n---\n\nnew task description'
+    );
+    fs.writeFileSync(
+      path.join(wtProjectPath, 'decisions.md'),
+      '# Decisions\n\n## Q1?\nA1\n\n## Q2?\nA2'
+    );
+    fs.writeFileSync(
+      path.join(wtProjectPath, 'plans', '02-new-task.md'),
+      '# Task: New Task'
+    );
+
+    // Call commitPlanningArtifacts with additional files
+    const additionalFiles = [
+      path.join(wtProjectPath, 'plans', '02-new-task.md'),
+    ];
+    await commitPlanningArtifacts(wtProjectPath, {
+      cwd: worktreePath,
+      additionalFiles,
+      isAmend: true,
+    });
+
+    // Verify commit was made with Amend prefix
+    const lastMsg = getLastCommitMessage(worktreePath);
+    expect(lastMsg).toMatch(/RAF\[aatest\] Amend: my-project/);
+
+    // Verify all three files are in the commit
+    const committedFiles = getLastCommitFiles(worktreePath);
+    expect(committedFiles).toContain(`RAF/${projectFolder}/input.md`);
+    expect(committedFiles).toContain(`RAF/${projectFolder}/decisions.md`);
+    expect(committedFiles).toContain(`RAF/${projectFolder}/plans/02-new-task.md`);
+  });
+
+  it('should commit after worktree recreation from branch', async () => {
+    const projectFolder = 'aatest-my-project';
+
+    // Create initial project, commit, and create initial worktree
+    createInitialProject(repoDir, projectFolder);
+    execSync('git add -A', { cwd: repoDir, stdio: 'pipe' });
+    execSync('git commit -m "Initial plan"', { cwd: repoDir, stdio: 'pipe' });
+
+    // Create worktree
+    const initialWtPath = createWorktreeForProject(repoDir, projectFolder);
+    const initialWtProjectPath = path.join(initialWtPath, 'RAF', projectFolder);
+
+    // Commit something on the worktree branch (simulating initial plan commit)
+    fs.writeFileSync(
+      path.join(initialWtProjectPath, 'decisions.md'),
+      '# Decisions\n\n## Q1?\nA1\n\n## Q2?\nA2'
+    );
+    execSync('git add -A', { cwd: initialWtPath, stdio: 'pipe' });
+    execSync('git commit -m "Plan commit on branch"', { cwd: initialWtPath, stdio: 'pipe' });
+
+    // Remove the worktree (simulating cleanup after execution)
+    execSync(`git worktree remove "${initialWtPath}" --force`, {
+      cwd: repoDir,
+      stdio: 'pipe',
+    });
+    worktreePaths.splice(worktreePaths.indexOf(initialWtPath), 1);
+
+    // Recreate worktree from existing branch (simulating amend --worktree)
+    const recreatedWtPath = path.join(makeTempDir('raf-wt-recreated-'), projectFolder);
+    execSync(`git worktree add "${recreatedWtPath}" "${projectFolder}"`, {
+      cwd: repoDir,
+      stdio: 'pipe',
+    });
+    worktreePaths.push(recreatedWtPath);
+
+    const recreatedProjectPath = path.join(recreatedWtPath, 'RAF', projectFolder);
+
+    // Simulate amend: update input.md, update decisions.md, create new plan
+    fs.writeFileSync(
+      path.join(recreatedProjectPath, 'input.md'),
+      'original input\n\n---\n\namend task description'
+    );
+    fs.writeFileSync(
+      path.join(recreatedProjectPath, 'decisions.md'),
+      '# Decisions\n\n## Q1?\nA1\n\n## Q2?\nA2\n\n## Q3?\nA3'
+    );
+    fs.writeFileSync(
+      path.join(recreatedProjectPath, 'plans', '02-new-task.md'),
+      '# Task: New Task'
+    );
+
+    // Call commitPlanningArtifacts with worktree cwd
+    const additionalFiles = [
+      path.join(recreatedProjectPath, 'plans', '02-new-task.md'),
+    ];
+    await commitPlanningArtifacts(recreatedProjectPath, {
+      cwd: recreatedWtPath,
+      additionalFiles,
+      isAmend: true,
+    });
+
+    // Verify commit was made
+    const lastMsg = getLastCommitMessage(recreatedWtPath);
+    expect(lastMsg).toMatch(/RAF\[aatest\] Amend: my-project/);
+
+    // Verify all files are in the commit
+    const committedFiles = getLastCommitFiles(recreatedWtPath);
+    expect(committedFiles).toContain(`RAF/${projectFolder}/input.md`);
+    expect(committedFiles).toContain(`RAF/${projectFolder}/decisions.md`);
+    expect(committedFiles).toContain(`RAF/${projectFolder}/plans/02-new-task.md`);
+  });
+
+  it('should work when only some files have changed', async () => {
+    const projectFolder = 'aatest-my-project';
+
+    // Create initial project and commit
+    createInitialProject(repoDir, projectFolder);
+    execSync('git add -A', { cwd: repoDir, stdio: 'pipe' });
+    execSync('git commit -m "Initial plan"', { cwd: repoDir, stdio: 'pipe' });
+
+    // Create worktree
+    worktreePath = createWorktreeForProject(repoDir, projectFolder);
+    const wtProjectPath = path.join(worktreePath, 'RAF', projectFolder);
+
+    // Only modify input.md (decisions.md unchanged)
+    fs.writeFileSync(
+      path.join(wtProjectPath, 'input.md'),
+      'original input\n\n---\n\nnew task'
+    );
+
+    await commitPlanningArtifacts(wtProjectPath, {
+      cwd: worktreePath,
+    });
+
+    // Verify commit was made
+    const lastMsg = getLastCommitMessage(worktreePath);
+    expect(lastMsg).toMatch(/RAF\[aatest\] Plan: my-project/);
+
+    // Only input.md should be in the commit (decisions.md unchanged)
+    const committedFiles = getLastCommitFiles(worktreePath);
+    expect(committedFiles).toContain(`RAF/${projectFolder}/input.md`);
+    expect(committedFiles).not.toContain(`RAF/${projectFolder}/decisions.md`);
+  });
+
+  it('should handle non-worktree commit (standard mode) correctly', async () => {
+    const projectFolder = 'aatest-my-project';
+
+    // Create initial project and commit
+    createInitialProject(repoDir, projectFolder);
+    execSync('git add -A', { cwd: repoDir, stdio: 'pipe' });
+    execSync('git commit -m "Initial"', { cwd: repoDir, stdio: 'pipe' });
+
+    const projectPath = path.join(repoDir, 'RAF', projectFolder);
+
+    // Modify files in main repo
+    fs.writeFileSync(
+      path.join(projectPath, 'input.md'),
+      'original input\n\n---\n\nnew task'
+    );
+    fs.writeFileSync(
+      path.join(projectPath, 'decisions.md'),
+      '# Decisions\n\n## Q1?\nA1\n\n## Q2?\nA2'
+    );
+
+    // Save and restore cwd
+    const savedCwd = process.cwd();
+    try {
+      process.chdir(repoDir);
+      await commitPlanningArtifacts(projectPath);
+    } finally {
+      process.chdir(savedCwd);
+    }
+
+    // Verify commit
+    const lastMsg = getLastCommitMessage(repoDir);
+    expect(lastMsg).toMatch(/RAF\[aatest\] Plan: my-project/);
+
+    const committedFiles = getLastCommitFiles(repoDir);
+    expect(committedFiles).toContain(`RAF/${projectFolder}/input.md`);
+    expect(committedFiles).toContain(`RAF/${projectFolder}/decisions.md`);
+  });
+});