rafcode 1.0.0

package/src/commands/plan.ts

@@ -0,0 +1,422 @@
+import * as fs from 'node:fs';
+import { Command } from 'commander';
+import { ProjectManager } from '../core/project-manager.js';
+import { ClaudeRunner } from '../core/claude-runner.js';
+import { openEditor, getInputTemplate } from '../core/editor.js';
+import { shutdownHandler } from '../core/shutdown-handler.js';
+import { getPlanningPrompt } from '../prompts/planning.js';
+import { getAmendPrompt } from '../prompts/amend.js';
+import {
+  validateEnvironment,
+  reportValidation,
+  validateProjectName,
+  resolveModelOption,
+} from '../utils/validation.js';
+import { logger } from '../utils/logger.js';
+import { generateProjectNames } from '../utils/name-generator.js';
+import { pickProjectName } from '../ui/name-picker.js';
+import {
+  getPlansDir,
+  getRafDir,
+  resolveProjectIdentifier,
+  resolveProjectIdentifierWithDetails,
+  getInputPath,
+  extractTaskNameFromPlanFile,
+} from '../utils/paths.js';
+import {
+  deriveProjectState,
+  isProjectComplete,
+  DerivedTask,
+} from '../core/state-derivation.js';
+
+interface PlanCommandOptions {
+  amend?: boolean;
+  model?: string;
+  sonnet?: boolean;
+  auto?: boolean;
+}
+
+export function createPlanCommand(): Command {
+  const command = new Command('plan')
+    .description('Create a new project and interactively plan tasks with Claude')
+    .argument('[projectName]', 'Optional project name (will be prompted if not provided)')
+    .option(
+      '-a, --amend',
+      'Add tasks to an existing project (requires project identifier as argument)'
+    )
+    .option('-m, --model <name>', 'Claude model to use (sonnet, haiku, opus)')
+    .option('--sonnet', 'Use Sonnet model (shorthand for --model sonnet)')
+    .option('-y, --auto', "Skip Claude's permission prompts for file operations")
+    .action(async (projectName: string | undefined, options: PlanCommandOptions) => {
+      // Validate and resolve model option
+      let model: string;
+      try {
+        model = resolveModelOption(options.model, options.sonnet);
+      } catch (error) {
+        logger.error((error as Error).message);
+        process.exit(1);
+      }
+
+      const autoMode = options.auto ?? false;
+
+      if (options.amend) {
+        if (!projectName) {
+          logger.error('--amend requires a project identifier');
+          logger.error('Usage: raf plan <project> --amend');
+          logger.error('   or: raf plan --amend <project>');
+          process.exit(1);
+        }
+        await runAmendCommand(projectName, model, autoMode);
+      } else {
+        await runPlanCommand(projectName, model, autoMode);
+      }
+    });
+
+  return command;
+}
+
+async function runPlanCommand(projectName?: string, model?: string, autoMode: boolean = false): Promise<void> {
+  // Validate environment
+  const validation = validateEnvironment();
+  reportValidation(validation);
+
+  if (!validation.valid) {
+    process.exit(1);
+  }
+
+  // Check if project name matches an existing project
+  if (projectName) {
+    const rafDir = getRafDir();
+    const existingProject = resolveProjectIdentifier(rafDir, projectName);
+    if (existingProject) {
+      logger.error(`Project already exists: ${existingProject}`);
+      logger.error(`To add tasks to an existing project, use: raf plan --amend ${projectName}`);
+      process.exit(1);
+    }
+  }
+
+  // Open editor for user input
+  logger.info('Opening editor for project description...');
+  logger.info('(Save and close the editor when done)');
+  logger.newline();
+
+  let userInput: string;
+  try {
+    userInput = await openEditor(getInputTemplate());
+  } catch (error) {
+    logger.error(`Failed to get input: ${error}`);
+    process.exit(1);
+  }
+
+  // Check if input is empty or just the template
+  const cleanInput = userInput
+    .replace(/<!--[\s\S]*?-->/g, '')
+    .replace(/^#.*$/gm, '')
+    .trim();
+
+  if (!cleanInput) {
+    logger.error('No project description provided. Aborting.');
+    process.exit(1);
+  }
+
+  // Get or generate project name
+  let finalProjectName = projectName;
+  if (!finalProjectName) {
+    logger.info('Generating project name suggestions...');
+    const suggestedNames = await generateProjectNames(cleanInput);
+    logger.newline();
+
+    if (autoMode) {
+      // Auto-select the first generated name
+      // generateProjectNames always returns at least one fallback name
+      finalProjectName = suggestedNames[0] ?? 'project';
+      logger.info(`Auto-selected project name: ${finalProjectName}`);
+    } else {
+      finalProjectName = await pickProjectName(suggestedNames);
+    }
+  }
+
+  if (!validateProjectName(finalProjectName)) {
+    logger.error('Invalid project name. Use only letters, numbers, hyphens, and underscores.');
+    process.exit(1);
+  }
+
+  // Create project
+  const projectManager = new ProjectManager();
+  const projectPath = projectManager.createProject(finalProjectName);
+
+  logger.success(`Created project: ${projectPath}`);
+  logger.newline();
+
+  // Save input
+  projectManager.saveInput(projectPath, userInput);
+
+  // Set up shutdown handler
+  const claudeRunner = new ClaudeRunner({ model });
+  shutdownHandler.init();
+  shutdownHandler.registerClaudeRunner(claudeRunner);
+
+  // Register cleanup callback for empty project folder
+  shutdownHandler.onShutdown(() => {
+    projectManager.cleanupEmptyProject(projectPath);
+  });
+
+  // Run planning session
+  logger.info('Starting planning session with Claude...');
+  logger.info('Claude will interview you about each task.');
+  if (model) {
+    logger.info(`Using model: ${model}`);
+  }
+  if (autoMode) {
+    logger.warn('Auto mode enabled: permission prompts will be skipped.');
+  }
+  logger.newline();
+
+  const { systemPrompt, userMessage } = getPlanningPrompt({
+    projectPath,
+    inputContent: userInput,
+  });
+
+  try {
+    const exitCode = await claudeRunner.runInteractive(systemPrompt, userMessage, {
+      dangerouslySkipPermissions: autoMode,
+    });
+
+    if (exitCode !== 0) {
+      logger.warn(`Claude exited with code ${exitCode}`);
+    }
+
+    // Check for created plan files
+    const plansDir = getPlansDir(projectPath);
+    const planFiles = fs.existsSync(plansDir)
+      ? fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).sort()
+      : [];
+
+    if (planFiles.length === 0) {
+      logger.warn('No plan files were created.');
+    } else {
+      logger.newline();
+      logger.success(`Planning complete! Created ${planFiles.length} task(s).`);
+      logger.newline();
+      logger.info('Plans created:');
+      for (const planFile of planFiles) {
+        logger.info(`  - plans/${planFile}`);
+      }
+
+      logger.newline();
+      logger.info(`Run 'raf do ${finalProjectName}' to execute the plans.`);
+    }
+  } catch (error) {
+    logger.error(`Planning failed: ${error}`);
+    throw error;
+  } finally {
+    // Cleanup empty project folder if no plans were created
+    projectManager.cleanupEmptyProject(projectPath);
+  }
+}
+
+async function runAmendCommand(identifier: string, model?: string, autoMode: boolean = false): Promise<void> {
+  // Validate environment
+  const validation = validateEnvironment();
+  reportValidation(validation);
+
+  if (!validation.valid) {
+    process.exit(1);
+  }
+
+  // Resolve the project
+  const rafDir = getRafDir();
+  const result = resolveProjectIdentifierWithDetails(rafDir, identifier);
+
+  if (!result.path) {
+    if (result.error === 'ambiguous' && result.matches) {
+      logger.error(`Ambiguous project name: ${identifier}`);
+      logger.error('Multiple projects match:');
+      for (const match of result.matches) {
+        logger.error(`  - ${match.folder}`);
+      }
+      logger.error('Please specify the project ID or full folder name.');
+    } else {
+      logger.error(`Project not found: ${identifier}`);
+    }
+    process.exit(1);
+  }
+
+  const projectPath = result.path;
+
+  // Load existing project state
+  const projectState = deriveProjectState(projectPath);
+
+  if (projectState.tasks.length === 0) {
+    logger.error(`Project has no tasks yet. Use 'raf plan' instead.`);
+    process.exit(1);
+  }
+
+  // Check if project is fully completed and show warning
+  if (isProjectComplete(projectState)) {
+    logger.warn('Project is fully completed. New tasks will extend the existing plan.');
+    logger.newline();
+  }
+
+  // Get existing tasks with their names
+  const plansDir = getPlansDir(projectPath);
+  const existingTasks: Array<DerivedTask & { taskName: string }> = projectState.tasks.map(
+    (task) => {
+      const planFile = task.planFile.replace('plans/', '');
+      const taskName = extractTaskNameFromPlanFile(planFile) ?? 'unknown';
+      return { ...task, taskName };
+    }
+  );
+
+  // Calculate next task number
+  const maxTaskNumber = Math.max(
+    ...projectState.tasks.map((t) => parseInt(t.id, 10))
+  );
+  const nextTaskNumber = maxTaskNumber + 1;
+
+  // Load original input
+  const inputPath = getInputPath(projectPath);
+  const originalInput = fs.existsSync(inputPath)
+    ? fs.readFileSync(inputPath, 'utf-8')
+    : '';
+
+  // Show existing tasks summary
+  logger.info('Amending existing project:');
+  logger.info(`  Path: ${projectPath}`);
+  logger.info(`  Existing tasks: ${existingTasks.length}`);
+  logger.newline();
+  logger.info('Current tasks:');
+  for (const task of existingTasks) {
+    const statusIcon =
+      task.status === 'completed' ? '[done]' : task.status === 'failed' ? '[fail]' : '[    ]';
+    logger.info(`  ${statusIcon} ${task.id}: ${task.taskName}`);
+  }
+  logger.newline();
+
+  // Open editor for new task description
+  const editorTemplate = getAmendTemplate(existingTasks, nextTaskNumber);
+  logger.info('Opening editor for new task description...');
+  logger.info('(Save and close the editor when done)');
+  logger.newline();
+
+  let userInput: string;
+  try {
+    userInput = await openEditor(editorTemplate);
+  } catch (error) {
+    logger.error(`Failed to get input: ${error}`);
+    process.exit(1);
+  }
+
+  // Extract new task description (remove the template comments)
+  const cleanInput = userInput
+    .replace(/<!--[\s\S]*?-->/g, '')
+    .replace(/^#.*$/gm, '')
+    .trim();
+
+  if (!cleanInput) {
+    logger.error('No new task description provided. Aborting.');
+    process.exit(1);
+  }
+
+  // Append new task description to input.md with separator
+  const separator = '\n\n---\n\n';
+  const updatedInput = originalInput.trim()
+    ? `${originalInput.trimEnd()}${separator}${cleanInput}`
+    : cleanInput;
+  fs.writeFileSync(inputPath, updatedInput);
+
+  // Set up shutdown handler
+  const claudeRunner = new ClaudeRunner({ model });
+  shutdownHandler.init();
+  shutdownHandler.registerClaudeRunner(claudeRunner);
+
+  // Run amend planning session
+  logger.info('Starting amendment session with Claude...');
+  logger.info('Claude will interview you about each new task.');
+  if (model) {
+    logger.info(`Using model: ${model}`);
+  }
+  if (autoMode) {
+    logger.warn('Auto mode enabled: permission prompts will be skipped.');
+  }
+  logger.newline();
+
+  const { systemPrompt, userMessage } = getAmendPrompt({
+    projectPath,
+    existingTasks,
+    nextTaskNumber,
+    newTaskDescription: cleanInput,
+  });
+
+  try {
+    const exitCode = await claudeRunner.runInteractive(systemPrompt, userMessage, {
+      dangerouslySkipPermissions: autoMode,
+    });
+
+    if (exitCode !== 0) {
+      logger.warn(`Claude exited with code ${exitCode}`);
+    }
+
+    // Check for new plan files
+    const allPlanFiles = fs.existsSync(plansDir)
+      ? fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).sort()
+      : [];
+
+    const newPlanFiles = allPlanFiles.filter((f) => {
+      const match = f.match(/^(\d{2,3})-/);
+      if (match && match[1]) {
+        return parseInt(match[1], 10) >= nextTaskNumber;
+      }
+      return false;
+    });
+
+    if (newPlanFiles.length === 0) {
+      logger.warn('No new plan files were created.');
+    } else {
+      logger.newline();
+      logger.success(`Amendment complete! Added ${newPlanFiles.length} new task(s).`);
+      logger.newline();
+      logger.info('New plans created:');
+      for (const planFile of newPlanFiles) {
+        logger.info(`  - plans/${planFile}`);
+      }
+
+      logger.newline();
+      logger.info(`Total tasks: ${allPlanFiles.length}`);
+      logger.info(`Run 'raf do ${identifier}' to execute the new tasks.`);
+    }
+  } catch (error) {
+    logger.error(`Amendment failed: ${error}`);
+    throw error;
+  }
+}
+
+/**
+ * Generate editor template for amend mode showing existing tasks.
+ */
+function getAmendTemplate(
+  existingTasks: Array<DerivedTask & { taskName: string }>,
+  nextTaskNumber: number
+): string {
+  const taskList = existingTasks
+    .map((task) => {
+      const status =
+        task.status === 'completed'
+          ? '[COMPLETED]'
+          : task.status === 'failed'
+            ? '[FAILED]'
+            : '[PENDING]';
+      return `#   ${task.id}: ${task.taskName} ${status}`;
+    })
+    .join('\n');
+
+  return `# Describe the new tasks you want to add
+#
+# Existing tasks (read-only reference):
+${taskList}
+#
+# New tasks will be numbered starting from ${nextTaskNumber.toString().padStart(3, '0')}
+#
+# Describe what you want to add below:
+`;
+}

package/src/commands/status.ts

@@ -0,0 +1,146 @@
+import { Command } from 'commander';
+import { getRafDir, resolveProjectIdentifier, extractProjectName } from '../utils/paths.js';
+import { logger } from '../utils/logger.js';
+import type { StatusCommandOptions } from '../types/config.js';
+import {
+  deriveProjectState,
+  getDerivedStats,
+  discoverProjects,
+  type DerivedTaskStatus,
+} from '../core/state-derivation.js';
+import { SYMBOLS, formatProgressBar, type TaskStatus } from '../utils/terminal-symbols.js';
+
+/** Maximum number of projects to display in status list */
+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)')
+    .option('--json', 'Output as JSON')
+    .action(async (identifier?: string, options?: StatusCommandOptions) => {
+      await runStatusCommand(identifier, options);
+    });
+
+  return command;
+}
+
+async function runStatusCommand(
+  identifier?: string,
+  options?: StatusCommandOptions
+): Promise<void> {
+  const rafDir = getRafDir();
+
+  if (!identifier) {
+    // List all projects
+    await listAllProjects(rafDir, options);
+    return;
+  }
+
+  // Show specific project - resolve identifier (number, name, or full folder name)
+  const projectPath = resolveProjectIdentifier(rafDir, identifier);
+
+  if (!projectPath) {
+    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;
+
+  if (options?.json) {
+    console.log(JSON.stringify({ projectName, status: projectStatus, state, stats }, 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);
+
+  // Display compact project status
+  logger.info(`${SYMBOLS.project} ${projectName}`);
+  logger.info(`${progressBar} (${stats.completed}/${stats.total})`);
+}
+
+async function listAllProjects(
+  rafDir: string,
+  options?: StatusCommandOptions
+): Promise<void> {
+  const allProjects = discoverProjects(rafDir);
+
+  if (allProjects.length === 0) {
+    logger.info('No projects found.');
+    return;
+  }
+
+  if (options?.json) {
+    const projectsWithState = allProjects.map((p) => {
+      try {
+        const state = deriveProjectState(p.path);
+        const stats = getDerivedStats(state);
+        return {
+          ...p,
+          status: state.status,
+          state,
+          stats,
+        };
+      } catch {
+        return { ...p, status: null, state: null, stats: null };
+      }
+    });
+    console.log(JSON.stringify(projectsWithState, 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;
+
+  // 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);
+
+      // Convert derived task statuses to TaskStatus for progress bar
+      const taskStatuses: TaskStatus[] = state.tasks.map((t) => derivedStatusToTaskStatus(t.status));
+      const progressBar = formatProgressBar(taskStatuses);
+
+      // 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}`);
+    }
+  }
+}
+
+/**
+ * Convert DerivedTaskStatus to TaskStatus for terminal symbols.
+ * Note: DerivedTaskStatus doesn't have 'running' - tasks are either pending, completed, or failed.
+ */
+function derivedStatusToTaskStatus(status: DerivedTaskStatus): TaskStatus {
+  switch (status) {
+    case 'pending':
+      return 'pending';
+    case 'completed':
+      return 'completed';
+    case 'failed':
+      return 'failed';
+    default:
+      return 'pending';
+  }
+}