rafcode 1.3.2 → 2.0.0

package/src/commands/status.ts

@@ -1,5 +1,7 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { Command } from 'commander';
-import { getRafDir, resolveProjectIdentifier, extractProjectName } from '../utils/paths.js';
+import { getRafDir, resolveProjectIdentifier, extractProjectName, extractProjectNumber, resolveProjectIdentifierWithDetails, formatProjectNumber } from '../utils/paths.js';
 import { logger } from '../utils/logger.js';
 import type { StatusCommandOptions } from '../types/config.js';
 import {
@@ -7,8 +9,16 @@ import {
   getDerivedStats,
   discoverProjects,
   type DerivedTaskStatus,
+  type DerivedProjectState,
+  type DerivedStats,
 } from '../core/state-derivation.js';
 import { SYMBOLS, formatProgressBar, type TaskStatus } from '../utils/terminal-symbols.js';
+import {
+  getRepoRoot,
+  getRepoBasename,
+  listWorktreeProjects,
+  computeWorktreePath,
+} from '../core/worktree.js';
 
 /** Maximum number of projects to display in status list */
 const MAX_DISPLAYED_PROJECTS = 10;
@@ -16,7 +26,7 @@ const MAX_DISPLAYED_PROJECTS = 10;
 export function createStatusCommand(): Command {
   const command = new Command('status')
     .description('Show status of a project or list all projects')
-    .argument('[identifier]', 'Project identifier: number (3), name (my-project), or folder (001-my-project)')
+    .argument('[identifier]', 'Project identifier: ID (00j3k1), name (my-project), or folder (00j3k1-my-project)')
     .option('--json', 'Output as JSON')
     .action(async (identifier?: string, options?: StatusCommandOptions) => {
       await runStatusCommand(identifier, options);
@@ -25,53 +35,220 @@ export function createStatusCommand(): Command {
   return command;
 }
 
+/** Resolved worktree context for status display */
+interface WorktreeContext {
+  repoBasename: string;
+  rafRelativePath: string;
+}
+
+/** A worktree project with its derived state */
+interface WorktreeProjectInfo {
+  folder: string;
+  projectPath: string;
+  state: DerivedProjectState;
+  stats: DerivedStats;
+}
+
+/**
+ * Attempt to discover the worktree context (repo basename and RAF relative path).
+ * Returns null if not in a git repo.
+ */
+function getWorktreeContext(rafDir: string): WorktreeContext | null {
+  const repoRoot = getRepoRoot();
+  if (!repoRoot) return null;
+
+  const repoBasename = getRepoBasename();
+  if (!repoBasename) return null;
+
+  const rafRelativePath = path.relative(repoRoot, rafDir);
+  return { repoBasename, rafRelativePath };
+}
+
+/**
+ * Discover all worktree projects with their state.
+ * Returns only projects that have valid project directories.
+ */
+function discoverWorktreeProjectStates(ctx: WorktreeContext): WorktreeProjectInfo[] {
+  const wtProjects = listWorktreeProjects(ctx.repoBasename);
+  const results: WorktreeProjectInfo[] = [];
+
+  for (const folder of wtProjects) {
+    const wtPath = computeWorktreePath(ctx.repoBasename, folder);
+    const wtProjectPath = path.join(wtPath, ctx.rafRelativePath, folder);
+
+    if (!fs.existsSync(wtProjectPath)) continue;
+
+    try {
+      const state = deriveProjectState(wtProjectPath);
+      const stats = getDerivedStats(state);
+      results.push({ folder, projectPath: wtProjectPath, state, stats });
+    } catch {
+      // Skip projects that fail to derive state
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Check if two project states differ (different task counts or different statuses).
+ */
+function projectStatesDiffer(mainState: DerivedProjectState, wtState: DerivedProjectState): boolean {
+  if (mainState.tasks.length !== wtState.tasks.length) return true;
+
+  for (let i = 0; i < mainState.tasks.length; i++) {
+    const mainTask = mainState.tasks[i];
+    const wtTask = wtState.tasks[i];
+    if (mainTask && wtTask && mainTask.status !== wtTask.status) return true;
+  }
+
+  return false;
+}
+
 async function runStatusCommand(
   identifier?: string,
   options?: StatusCommandOptions
 ): Promise<void> {
   const rafDir = getRafDir();
+  const wtCtx = getWorktreeContext(rafDir);
 
   if (!identifier) {
-    // List all projects
-    await listAllProjects(rafDir, options);
+    await listAllProjects(rafDir, options, wtCtx);
     return;
   }
 
-  // Show specific project - resolve identifier (number, name, or full folder name)
-  const projectPath = resolveProjectIdentifier(rafDir, identifier);
+  // Show specific project - resolve in main repo
+  const mainProjectPath = resolveProjectIdentifier(rafDir, identifier);
 
-  if (!projectPath) {
+  // Resolve in worktree
+  let wtProject: WorktreeProjectInfo | null = null;
+  if (wtCtx) {
+    const wtProjects = discoverWorktreeProjectStates(wtCtx);
+    for (const wp of wtProjects) {
+      // Match by folder name against main project, or resolve identifier in worktree
+      if (mainProjectPath && path.basename(mainProjectPath) === wp.folder) {
+        wtProject = wp;
+        break;
+      }
+      // Try matching by identifier if not found via main project
+      if (!mainProjectPath) {
+        const wtRafDir = path.join(computeWorktreePath(wtCtx.repoBasename, wp.folder), wtCtx.rafRelativePath);
+        const resolved = resolveProjectIdentifierWithDetails(wtRafDir, identifier);
+        if (resolved.path) {
+          wtProject = wp;
+          break;
+        }
+      }
+    }
+  }
+
+  if (!mainProjectPath && !wtProject) {
     logger.error(`Project not found: ${identifier}`);
     process.exit(1);
   }
 
-  // Derive state from folder structure
-  const state = deriveProjectState(projectPath);
-  const stats = getDerivedStats(state);
-  const projectName = extractProjectName(projectPath) ?? identifier;
-  const projectStatus = state.status;
+  // Derive main repo state (if exists)
+  let mainState: DerivedProjectState | null = null;
+  let mainStats: DerivedStats | null = null;
+  let projectName: string;
+
+  if (mainProjectPath) {
+    mainState = deriveProjectState(mainProjectPath);
+    mainStats = getDerivedStats(mainState);
+    projectName = extractProjectName(mainProjectPath) ?? identifier;
+  } else {
+    projectName = extractProjectName(wtProject!.folder) ?? identifier;
+  }
+
+  // Determine if we need to show both views
+  const showBoth = mainState && wtProject && projectStatesDiffer(mainState, wtProject.state);
+  const worktreeOnly = !mainState && wtProject;
 
   if (options?.json) {
-    console.log(JSON.stringify({ projectName, status: projectStatus, state, stats }, null, 2));
+    const jsonData: Record<string, unknown> = {
+      projectName,
+      status: mainState?.status ?? wtProject!.state.status,
+      state: mainState ?? wtProject!.state,
+      stats: mainStats ?? wtProject!.stats,
+    };
+    if (wtProject) {
+      jsonData.worktree = {
+        folder: wtProject.folder,
+        projectPath: wtProject.projectPath,
+        status: wtProject.state.status,
+        state: wtProject.state,
+        stats: wtProject.stats,
+      };
+    }
+    console.log(JSON.stringify(jsonData, null, 2));
     return;
   }
 
-  // Convert derived task statuses to TaskStatus for progress bar
-  const taskStatuses: TaskStatus[] = state.tasks.map((t) => derivedStatusToTaskStatus(t.status));
-  const progressBar = formatProgressBar(taskStatuses);
+  if (showBoth) {
+    // Show both main and worktree states
+    logger.info(`${SYMBOLS.project} ${projectName}`);
 
-  // Display compact project status
-  logger.info(`${SYMBOLS.project} ${projectName}`);
-  logger.info(`${progressBar} (${stats.completed}/${stats.total})`);
+    const mainTaskStatuses: TaskStatus[] = mainState!.tasks.map((t) => derivedStatusToTaskStatus(t.status));
+    const mainProgressBar = formatProgressBar(mainTaskStatuses);
+    logger.info(`  Main:     ${mainProgressBar} (${mainStats!.completed}/${mainStats!.total})`);
+
+    const wtTaskStatuses: TaskStatus[] = wtProject!.state.tasks.map((t) => derivedStatusToTaskStatus(t.status));
+    const wtProgressBar = formatProgressBar(wtTaskStatuses);
+    logger.info(`  Worktree: ${wtProgressBar} (${wtProject!.stats.completed}/${wtProject!.stats.total})`);
+  } else if (worktreeOnly) {
+    // Show worktree only
+    const taskStatuses: TaskStatus[] = wtProject!.state.tasks.map((t) => derivedStatusToTaskStatus(t.status));
+    const progressBar = formatProgressBar(taskStatuses);
+    logger.info(`${SYMBOLS.project} ${projectName}`);
+    logger.info(`${progressBar} (${wtProject!.stats.completed}/${wtProject!.stats.total})`);
+  } else {
+    // Show main only (no worktree, or worktree is identical)
+    const taskStatuses: TaskStatus[] = mainState!.tasks.map((t) => derivedStatusToTaskStatus(t.status));
+    const progressBar = formatProgressBar(taskStatuses);
+    logger.info(`${SYMBOLS.project} ${projectName}`);
+    logger.info(`${progressBar} (${mainStats!.completed}/${mainStats!.total})`);
+  }
 }
 
 async function listAllProjects(
   rafDir: string,
-  options?: StatusCommandOptions
+  options?: StatusCommandOptions,
+  wtCtx?: WorktreeContext | null
 ): Promise<void> {
   const allProjects = discoverProjects(rafDir);
 
-  if (allProjects.length === 0) {
+  // Discover worktree projects
+  const wtProjectInfos = wtCtx ? discoverWorktreeProjectStates(wtCtx) : [];
+
+  // Build a set of main repo folder names for fast lookup
+  const mainFolderNames = new Set(allProjects.map((p) => path.basename(p.path)));
+
+  // Determine which worktree projects to show:
+  // - Worktree-only projects (no main repo counterpart) are always shown
+  // - Worktree projects that differ from main repo counterpart are shown
+  const worktreeToShow: WorktreeProjectInfo[] = [];
+  for (const wp of wtProjectInfos) {
+    if (!mainFolderNames.has(wp.folder)) {
+      // Worktree-only project
+      worktreeToShow.push(wp);
+    } else {
+      // Has main repo counterpart - check if they differ
+      const mainProject = allProjects.find((p) => path.basename(p.path) === wp.folder);
+      if (mainProject) {
+        try {
+          const mainState = deriveProjectState(mainProject.path);
+          if (projectStatesDiffer(mainState, wp.state)) {
+            worktreeToShow.push(wp);
+          }
+        } catch {
+          // If we can't derive main state, show the worktree project
+          worktreeToShow.push(wp);
+        }
+      }
+    }
+  }
+
+  if (allProjects.length === 0 && worktreeToShow.length === 0) {
     logger.info('No projects found.');
     return;
   }
@@ -91,39 +268,69 @@ async function listAllProjects(
         return { ...p, status: null, state: null, stats: null };
       }
     });
-    console.log(JSON.stringify(projectsWithState, null, 2));
+
+    const jsonData: Record<string, unknown> = { projects: projectsWithState };
+    if (worktreeToShow.length > 0) {
+      jsonData.worktrees = worktreeToShow.map((wp) => ({
+        folder: wp.folder,
+        projectPath: wp.projectPath,
+        status: wp.state.status,
+        state: wp.state,
+        stats: wp.stats,
+      }));
+    }
+    console.log(JSON.stringify(jsonData, null, 2));
     return;
   }
 
-  // Truncate to last N projects if needed (projects are sorted by number ascending)
-  const totalProjects = allProjects.length;
-  const hiddenCount = Math.max(0, totalProjects - MAX_DISPLAYED_PROJECTS);
-  const displayedProjects = hiddenCount > 0
-    ? allProjects.slice(-MAX_DISPLAYED_PROJECTS)
-    : allProjects;
+  // Display main repo projects
+  if (allProjects.length > 0) {
+    // Truncate to last N projects if needed (projects are sorted by number ascending)
+    const totalProjects = allProjects.length;
+    const hiddenCount = Math.max(0, totalProjects - MAX_DISPLAYED_PROJECTS);
+    const displayedProjects = hiddenCount > 0
+      ? allProjects.slice(-MAX_DISPLAYED_PROJECTS)
+      : allProjects;
+
+    // Show truncation indicator at top if there are hidden projects
+    if (hiddenCount > 0) {
+      logger.dim(`... and ${hiddenCount} more project${hiddenCount === 1 ? '' : 's'}`);
+    }
+
+    for (const project of displayedProjects) {
+      try {
+        const state = deriveProjectState(project.path);
+        const stats = getDerivedStats(state);
 
-  // Show truncation indicator at top if there are hidden projects
-  if (hiddenCount > 0) {
-    logger.dim(`... and ${hiddenCount} more project${hiddenCount === 1 ? '' : 's'}`);
+        // Convert derived task statuses to TaskStatus for progress bar
+        const taskStatuses: TaskStatus[] = state.tasks.map((t) => derivedStatusToTaskStatus(t.status));
+        const progressBar = formatProgressBar(taskStatuses);
+
+        // Format: "00j3k1 my-project ✓✓●○○ (2/5)"
+        const projectNumber = formatProjectNumber(project.number);
+        const counts = `(${stats.completed}/${stats.total})`;
+        logger.info(`${projectNumber} ${project.name} ${progressBar} ${counts}`);
+      } catch {
+        // Failed to derive state - show minimal info
+        const projectNumber = formatProjectNumber(project.number);
+        logger.info(`${projectNumber} ${project.name}`);
+      }
+    }
   }
 
-  for (const project of displayedProjects) {
-    try {
-      const state = deriveProjectState(project.path);
-      const stats = getDerivedStats(state);
+  // Display worktree projects section
+  if (worktreeToShow.length > 0) {
+    logger.newline();
+    logger.info('Worktrees:');
+    for (const wp of worktreeToShow) {
+      const projectNumber = extractProjectNumber(wp.folder) ?? '???';
+      const projectName = extractProjectName(wp.folder) ?? wp.folder;
 
-      // Convert derived task statuses to TaskStatus for progress bar
-      const taskStatuses: TaskStatus[] = state.tasks.map((t) => derivedStatusToTaskStatus(t.status));
+      const taskStatuses: TaskStatus[] = wp.state.tasks.map((t) => derivedStatusToTaskStatus(t.status));
       const progressBar = formatProgressBar(taskStatuses);
+      const counts = `(${wp.stats.completed}/${wp.stats.total})`;
 
-      // Format: "001 my-project ✓✓●○○ (2/5)"
-      const projectNumber = String(project.number).padStart(3, '0');
-      const counts = `(${stats.completed}/${stats.total})`;
-      logger.info(`${projectNumber} ${project.name} ${progressBar} ${counts}`);
-    } catch {
-      // Failed to derive state - show minimal info
-      const projectNumber = String(project.number).padStart(3, '0');
-      logger.info(`${projectNumber} ${project.name}`);
+      logger.info(`  ${projectNumber} ${projectName} ${progressBar} ${counts}`);
     }
   }
 }

package/src/core/claude-runner.ts

@@ -45,7 +45,7 @@ export interface ClaudeRunnerOptions {
   commitContext?: {
     /** HEAD commit hash recorded before task execution began. */
     preExecutionHead: string;
-    /** Expected commit message prefix (e.g., "RAF[005:001]"). */
+    /** Expected commit message prefix (e.g., "RAF[005:01]"). */
     expectedPrefix: string;
     /** Path to the outcome file that should be committed. */
     outcomeFilePath: string;
@@ -104,7 +104,7 @@ export const OUTCOME_POLL_INTERVAL_MS = 5_000;
 export interface CommitContext {
   /** HEAD commit hash recorded before task execution began. */
   preExecutionHead: string;
-  /** Expected commit message prefix (e.g., "RAF[005:001]"). */
+  /** Expected commit message prefix (e.g., "RAF[005:01]"). */
   expectedPrefix: string;
   /** Path to the outcome file that should be committed. */
   outcomeFilePath: string;

package/src/core/git.ts

@@ -12,9 +12,9 @@ export interface GitStatus {
 /**
  * Check if we're in a git repository.
  */
-export function isGitRepo(): boolean {
+export function isGitRepo(cwd?: string): boolean {
   try {
-    execSync('git rev-parse --is-inside-work-tree', { encoding: 'utf-8', stdio: 'pipe' });
+    execSync('git rev-parse --is-inside-work-tree', { encoding: 'utf-8', stdio: 'pipe', ...(cwd ? { cwd } : {}) });
     return true;
   } catch {
     return false;
@@ -58,9 +58,9 @@ export function getGitStatus(): GitStatus {
 /**
  * Check if there are uncommitted changes.
  */
-export function hasUncommittedChanges(): boolean {
+export function hasUncommittedChanges(cwd?: string): boolean {
   try {
-    const status = execSync('git status --porcelain', { encoding: 'utf-8', stdio: 'pipe' });
+    const status = execSync('git status --porcelain', { encoding: 'utf-8', stdio: 'pipe', ...(cwd ? { cwd } : {}) });
     return status.trim().length > 0;
   } catch {
     return false;
@@ -141,16 +141,16 @@ export function getChangedFiles(): string[] {
 
 /**
  * Stash uncommitted changes with a descriptive name.
- * @param name - Name for the stash (e.g., "raf-001-task-3-failed")
+ * @param name - Name for the stash (e.g., "raf-001-task-03-failed")
  * @returns true if stash was created, false otherwise
  */
-export function stashChanges(name: string): boolean {
-  if (!isGitRepo()) {
+export function stashChanges(name: string, cwd?: string): boolean {
+  if (!isGitRepo(cwd)) {
     logger.warn('Not in a git repository, skipping stash');
     return false;
   }
 
-  if (!hasUncommittedChanges()) {
+  if (!hasUncommittedChanges(cwd)) {
     logger.debug('No uncommitted changes to stash');
     return false;
   }
@@ -159,6 +159,7 @@ export function stashChanges(name: string): boolean {
     execSync(`git stash push -m "${name.replace(/"/g, '\\"')}"`, {
       encoding: 'utf-8',
       stdio: 'pipe',
+      ...(cwd ? { cwd } : {}),
     });
     return true;
   } catch (error) {
@@ -171,9 +172,9 @@ export function stashChanges(name: string): boolean {
  * Get the current HEAD commit hash.
  * Returns null if not in a git repo or HEAD doesn't exist.
  */
-export function getHeadCommitHash(): string | null {
+export function getHeadCommitHash(cwd?: string): string | null {
   try {
-    return execSync('git rev-parse HEAD', { encoding: 'utf-8', stdio: 'pipe' }).trim() || null;
+    return execSync('git rev-parse HEAD', { encoding: 'utf-8', stdio: 'pipe', ...(cwd ? { cwd } : {}) }).trim() || null;
   } catch {
     return null;
   }
@@ -214,13 +215,20 @@ export function isFileCommittedInHead(filePath: string): boolean {
 /**
  * Commit planning artifacts (input.md and decisions.md) for a project.
  * Uses commit message format: RAF[NNN] Plan: project-name
+ * For amendments: RAF[NNN] Amend: project-name
  *
  * @param projectPath - Full path to the project folder (e.g., /path/to/RAF/017-decision-vault)
+ * @param options - Optional settings
+ * @param options.cwd - Working directory for git commands (worktree support)
+ * @param options.additionalFiles - Extra file paths to stage (e.g., plan files for amend)
+ * @param options.isAmend - Use "Amend:" prefix instead of "Plan:" in commit message
  * @returns Promise that resolves when commit is complete (or fails silently)
  */
-export async function commitPlanningArtifacts(projectPath: string): Promise<void> {
+export async function commitPlanningArtifacts(projectPath: string, options?: { cwd?: string; additionalFiles?: string[]; isAmend?: boolean }): Promise<void> {
+  const execCwd = options?.cwd;
+
   // Check if we're in a git repository
-  if (!isGitRepo()) {
+  if (!isGitRepo(execCwd)) {
     logger.warn('Not in a git repository, skipping planning artifacts commit');
     return;
   }
@@ -234,25 +242,52 @@ export async function commitPlanningArtifacts(projectPath: string): Promise<void
     return;
   }
 
-  // Build file paths relative to the project folder
+  // Build absolute file paths
   const inputFile = path.join(projectPath, 'input.md');
   const decisionsFile = path.join(projectPath, 'decisions.md');
 
   // Build commit message
-  const commitMessage = `RAF[${projectNumber}] Plan: ${projectName}`;
+  const prefix = options?.isAmend ? 'Amend' : 'Plan';
+  const commitMessage = `RAF[${projectNumber}] ${prefix}: ${projectName}`;
+
+  // Build list of files to stage (absolute paths)
+  const absoluteFiles = [inputFile, decisionsFile, ...(options?.additionalFiles ?? [])];
+
+  // Convert to relative paths when cwd is provided (worktree mode).
+  // Git resolves paths relative to the working directory. Using relative paths
+  // avoids issues with symlink resolution (e.g., /tmp → /private/tmp on macOS)
+  // that can cause absolute paths to not match git's internal worktree paths.
+  const filesToStage = execCwd
+    ? absoluteFiles.map(f => path.relative(execCwd, f))
+    : absoluteFiles;
+
+  // Stage each file individually so one missing file doesn't block the others
+  let stagedCount = 0;
+  for (const file of filesToStage) {
+    try {
+      execSync(`git add -- "${file}"`, {
+        encoding: 'utf-8',
+        stdio: 'pipe',
+        ...(execCwd ? { cwd: execCwd } : {}),
+      });
+      stagedCount++;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.warn(`Failed to stage ${file}: ${msg}`);
+    }
+  }
 
-  try {
-    // Stage only the specific files (input.md and decisions.md)
-    // Use --force to add even if in .gitignore, and -- to handle paths with special chars
-    execSync(`git add -- "${inputFile}" "${decisionsFile}"`, {
-      encoding: 'utf-8',
-      stdio: 'pipe',
-    });
+  if (stagedCount === 0) {
+    logger.debug('No files were staged for planning artifacts commit');
+    return;
+  }
 
+  try {
     // Check if there's anything staged to commit
     const stagedStatus = execSync('git diff --cached --name-only', {
       encoding: 'utf-8',
       stdio: 'pipe',
+      ...(execCwd ? { cwd: execCwd } : {}),
     }).trim();
 
     if (!stagedStatus) {
@@ -264,6 +299,7 @@ export async function commitPlanningArtifacts(projectPath: string): Promise<void
     execSync(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, {
       encoding: 'utf-8',
       stdio: 'pipe',
+      ...(execCwd ? { cwd: execCwd } : {}),
     });
 
     logger.debug(`Committed planning artifacts: ${commitMessage}`);

package/src/core/project-manager.ts

@@ -11,6 +11,7 @@ import {
   getDecisionsPath,
   getInputPath,
   listProjects,
+  TASK_ID_PATTERN,
 } from '../utils/paths.js';
 import { sanitizeProjectName } from '../utils/validation.js';
 import { logger } from '../utils/logger.js';
@@ -145,7 +146,7 @@ export class ProjectManager {
     const files = fs.readdirSync(outcomesDir).filter((f) => f.endsWith('.md')).sort();
 
     for (const file of files) {
-      const match = file.match(/^(\d{2,3})-/);
+      const match = file.match(new RegExp(`^(${TASK_ID_PATTERN})-`));
       if (match && match[1]) {
         const content = fs.readFileSync(path.join(outcomesDir, file), 'utf-8');
         outcomes.push({ taskId: match[1], content });