ralphctl 0.1.0

package/src/commands/task/add.ts

@@ -0,0 +1,316 @@
+import { resolve } from 'node:path';
+import { confirm, input } from '@inquirer/prompts';
+import { error, muted } from '@src/theme/index.ts';
+import { emoji, field, icons, log, showError, showNextSteps, showSuccess } from '@src/theme/ui.ts';
+import { editorInput } from '@src/utils/editor-input.ts';
+import { validateProjectPath } from '@src/utils/paths.ts';
+import { addTask } from '@src/store/task.ts';
+import { formatTicketDisplay, getTicket, listTickets } from '@src/store/ticket.ts';
+import { getProject, listProjects } from '@src/store/project.ts';
+import {
+  assertSprintStatus,
+  getSprint,
+  NoCurrentSprintError,
+  resolveSprintId,
+  SprintStatusError,
+} from '@src/store/sprint.ts';
+import { EXIT_ERROR, exitWithCode } from '@src/utils/exit-codes.ts';
+import { selectProjectRepository } from '@src/interactive/selectors.ts';
+
+export interface TaskAddOptions {
+  name?: string;
+  description?: string;
+  steps?: string[];
+  ticket?: string;
+  project?: string;
+  interactive?: boolean; // Set by REPL or CLI (default true unless --no-interactive)
+}
+
+export async function taskAddCommand(options: TaskAddOptions = {}): Promise<void> {
+  const isInteractive = options.interactive !== false;
+
+  // FAIL FAST: Check sprint status before collecting any input
+  try {
+    const sprintId = await resolveSprintId();
+    const sprint = await getSprint(sprintId);
+    assertSprintStatus(sprint, ['draft'], 'add tasks');
+  } catch (err) {
+    if (err instanceof SprintStatusError) {
+      // Show only the main error, not the built-in hint
+      const mainError = err.message.split('\n')[0] ?? err.message;
+      showError(mainError);
+      showNextSteps([
+        ['ralphctl sprint close', 'close current sprint'],
+        ['ralphctl sprint create', 'start a new draft sprint'],
+      ]);
+      log.newline();
+      if (!isInteractive) exitWithCode(EXIT_ERROR);
+      return;
+    }
+    if (err instanceof NoCurrentSprintError) {
+      showError('No current sprint set.');
+      showNextSteps([['ralphctl sprint create', 'create a new sprint']]);
+      log.newline();
+      if (!isInteractive) exitWithCode(EXIT_ERROR);
+      return;
+    }
+    throw err;
+  }
+
+  let name: string;
+  let description: string | undefined;
+  let steps: string[];
+  let ticketId: string | undefined;
+  let projectPath: string | undefined;
+
+  if (options.interactive === false) {
+    // Non-interactive mode: validate required params
+    const errors: string[] = [];
+    const trimmedName = options.name?.trim();
+    const trimmedProject = options.project?.trim();
+
+    if (!trimmedName) {
+      errors.push('--name is required');
+    }
+
+    // Project is required unless we can get it from a ticket
+    if (!trimmedProject && !options.ticket) {
+      errors.push('--project is required (or --ticket to inherit from ticket)');
+    }
+
+    if (errors.length > 0 || !trimmedName) {
+      showError('Validation failed');
+      for (const e of errors) {
+        log.item(error(e));
+      }
+      log.newline();
+      exitWithCode(EXIT_ERROR);
+    }
+
+    name = trimmedName;
+    const trimmedDesc = options.description?.trim();
+    description = trimmedDesc === '' ? undefined : trimmedDesc;
+    steps = options.steps ?? [];
+    const trimmedTicket = options.ticket?.trim();
+    ticketId = trimmedTicket === '' ? undefined : trimmedTicket;
+
+    // Get project path from ticket or option
+    if (ticketId) {
+      try {
+        const ticket = await getTicket(ticketId);
+        // Get first repository path from project
+        const project = await getProject(ticket.projectName);
+        projectPath = project.repositories[0]?.path;
+      } catch {
+        if (!trimmedProject) {
+          showError(`Ticket not found: ${ticketId}`);
+          console.log(muted('  Provide --project or a valid --ticket\n'));
+          exitWithCode(EXIT_ERROR);
+        }
+        const validation = await validateProjectPath(trimmedProject);
+        if (validation !== true) {
+          showError(`Invalid project path: ${validation}`);
+          exitWithCode(EXIT_ERROR);
+        }
+        projectPath = resolve(trimmedProject);
+      }
+    } else if (trimmedProject) {
+      const validation = await validateProjectPath(trimmedProject);
+      if (validation !== true) {
+        showError(`Invalid project path: ${validation}`);
+        exitWithCode(EXIT_ERROR);
+      }
+      projectPath = resolve(trimmedProject);
+    } else {
+      // This shouldn't happen due to earlier validation
+      showError('--project is required');
+      exitWithCode(EXIT_ERROR);
+    }
+  } else {
+    // Interactive mode (default): prompt for missing params, use provided values as defaults
+    name = await input({
+      message: `${icons.task} Task name:`,
+      default: options.name?.trim(),
+      validate: (v) => (v.trim().length > 0 ? true : 'Name is required'),
+    });
+
+    description = await editorInput({
+      message: 'Description (optional):',
+      default: options.description?.trim(),
+    });
+
+    // Add steps one by one
+    steps = options.steps ? [...options.steps] : [];
+    const addSteps = await confirm({
+      message: `${emoji.donut} ${steps.length > 0 ? `Add more steps? (${String(steps.length)} pre-filled)` : 'Add implementation steps?'}`,
+      default: steps.length === 0,
+    });
+
+    if (addSteps) {
+      let stepNum = steps.length + 1;
+      let adding = true;
+      while (adding) {
+        const step = await input({
+          message: `  Step ${String(stepNum)} (empty to finish):`,
+        });
+        if (step.trim()) {
+          steps.push(step.trim());
+          stepNum++;
+        } else {
+          adding = false;
+        }
+      }
+    }
+
+    // Optionally link to a ticket
+    const tickets = await listTickets();
+
+    if (tickets.length > 0) {
+      const { select } = await import('@inquirer/prompts');
+      const defaultTicketValue = options.ticket ? (tickets.find((t) => t.id === options.ticket)?.id ?? '') : '';
+      const ticketChoice = await select({
+        message: `${icons.ticket} Link to ticket:`,
+        default: defaultTicketValue,
+        choices: [
+          { name: `${emoji.donut} None (select project/repo manually)`, value: '' },
+          ...tickets.map((t) => ({
+            name: `${icons.ticket} ${formatTicketDisplay(t)} ${muted(`(${t.projectName})`)}`,
+            value: t.id,
+          })),
+        ],
+      });
+      if (ticketChoice) {
+        ticketId = ticketChoice;
+        const ticket = tickets.find((t) => t.id === ticketChoice);
+        if (ticket) {
+          try {
+            const project = await getProject(ticket.projectName);
+            // Auto-select first repo for ticket, or prompt if multiple
+            if (project.repositories.length === 1) {
+              projectPath = project.repositories[0]?.path;
+            } else {
+              // Multiple repos - let user pick
+              const { select: selectRepo } = await import('@inquirer/prompts');
+              projectPath = await selectRepo({
+                message: `${emoji.donut} Select repository for this task:`,
+                choices: project.repositories.map((r) => ({
+                  name: `${r.name} (${r.path})`,
+                  value: r.path,
+                })),
+              });
+            }
+          } catch {
+            log.warn(`Project '${ticket.projectName}' not found, will prompt for path.`);
+          }
+        }
+      }
+    } else if (options.ticket) {
+      ticketId = options.ticket;
+      try {
+        const ticket = await getTicket(ticketId);
+        const project = await getProject(ticket.projectName);
+        projectPath = project.repositories[0]?.path;
+      } catch {
+        // Will prompt for project below
+      }
+    }
+
+    // If no project from ticket, use two-step selector
+    if (projectPath === undefined) {
+      const projects = await listProjects();
+
+      if (projects.length > 0) {
+        const { select } = await import('@inquirer/prompts');
+        const choice = await select({
+          message: `${icons.project} Select project:`,
+          choices: [
+            { name: `${icons.edit} Enter path manually`, value: '__manual__' },
+            { name: `${emoji.donut} Select project/repository`, value: '__select__' },
+          ],
+        });
+
+        if (choice === '__manual__') {
+          projectPath = await input({
+            message: `${icons.project} Project path:`,
+            default: options.project?.trim() ?? process.cwd(),
+            validate: async (v) => {
+              const result = await validateProjectPath(v.trim());
+              return result;
+            },
+          });
+          projectPath = resolve(projectPath.trim());
+        } else {
+          // Two-step selector: project → repository
+          const selectedPath = await selectProjectRepository('Select repository:');
+          if (!selectedPath) {
+            showError('No repository selected');
+            exitWithCode(EXIT_ERROR);
+          }
+          projectPath = selectedPath;
+        }
+      } else {
+        projectPath = await input({
+          message: `${icons.project} Project path:`,
+          default: options.project?.trim() ?? process.cwd(),
+          validate: async (v) => {
+            const result = await validateProjectPath(v.trim());
+            return result;
+          },
+        });
+        projectPath = resolve(projectPath.trim());
+      }
+    }
+
+    name = name.trim();
+    const trimmedDescription = description.trim();
+    description = trimmedDescription === '' ? undefined : trimmedDescription;
+  }
+
+  // projectPath must be set by this point
+  if (!projectPath) {
+    showError('Project path is required');
+    exitWithCode(EXIT_ERROR);
+  }
+
+  try {
+    const task = await addTask({
+      name,
+      description,
+      steps,
+      ticketId,
+      projectPath,
+    });
+
+    showSuccess('Task added!', [
+      ['ID', task.id],
+      ['Name', task.name],
+      ['Project', task.projectPath],
+      ['Order', String(task.order)],
+    ]);
+
+    if (task.ticketId) {
+      console.log(field('Ticket', task.ticketId));
+    }
+    if (task.steps.length > 0) {
+      console.log(field('Steps', ''));
+      task.steps.forEach((step, i) => {
+        console.log(muted(`    ${String(i + 1)}. ${step}`));
+      });
+    }
+    console.log('');
+  } catch (err) {
+    if (err instanceof SprintStatusError) {
+      // Fallback handler (shouldn't reach here due to early check)
+      const mainError = err.message.split('\n')[0] ?? err.message;
+      showError(mainError);
+      showNextSteps([
+        ['ralphctl sprint close', 'close current sprint'],
+        ['ralphctl sprint create', 'start a new draft sprint'],
+      ]);
+      log.newline();
+      if (!isInteractive) exitWithCode(EXIT_ERROR);
+      return;
+    }
+    throw err;
+  }
+}

package/src/commands/task/import.ts

@@ -0,0 +1,150 @@
+import { readFile } from 'node:fs/promises';
+import { error, muted } from '@src/theme/index.ts';
+import { createSpinner, log, showError, showNextStep } from '@src/theme/ui.ts';
+import { addTask, getTasks, saveTasks, validateImportTasks } from '@src/store/task.ts';
+import { getSprint, resolveSprintId, SprintStatusError } from '@src/store/sprint.ts';
+import { ImportTasksSchema } from '@src/schemas/index.ts';
+import { withFileLock } from '@src/utils/file-lock.ts';
+import { getTasksFilePath } from '@src/utils/paths.ts';
+
+export async function taskImportCommand(args: string[]): Promise<void> {
+  const filePath = args[0];
+
+  if (!filePath) {
+    showError('File path required.');
+    showNextStep('ralphctl task import <file.json>', 'provide a task file');
+    log.dim('Expected JSON format:');
+    console.log(
+      muted(`[
+  {
+    "id": "1",
+    "name": "Task name",
+    "projectPath": "/path/to/repo",
+    "description": "Optional description",
+    "steps": ["Step 1", "Step 2"],
+    "ticketId": "abc12345",
+    "blockedBy": ["task-001"]
+  }
+]`)
+    );
+    log.dim('Note: projectPath is required for each task.');
+    log.newline();
+    return;
+  }
+
+  let content: string;
+  try {
+    content = await readFile(filePath, 'utf-8');
+  } catch {
+    showError(`Failed to read file: ${filePath}`);
+    log.newline();
+    return;
+  }
+
+  let data: unknown;
+  try {
+    data = JSON.parse(content);
+  } catch {
+    showError('Invalid JSON format.');
+    log.newline();
+    return;
+  }
+
+  const result = ImportTasksSchema.safeParse(data);
+  if (!result.success) {
+    showError('Invalid task format');
+    for (const issue of result.error.issues) {
+      log.item(error(`${issue.path.join('.')}: ${issue.message}`));
+    }
+    log.newline();
+    return;
+  }
+
+  const tasks = result.data;
+  if (tasks.length === 0) {
+    showError('No tasks to import.');
+    log.newline();
+    return;
+  }
+
+  // Validate dependencies and ticketId references before importing
+  const existingTasks = await getTasks();
+  const sprintId = await resolveSprintId();
+  const sprint = await getSprint(sprintId);
+  const ticketIds = new Set(sprint.tickets.map((t) => t.id));
+  const validationErrors = validateImportTasks(tasks, existingTasks, ticketIds);
+  if (validationErrors.length > 0) {
+    showError('Dependency validation failed');
+    for (const err of validationErrors) {
+      log.item(error(err));
+    }
+    log.newline();
+    return;
+  }
+
+  // Build local ID to real ID mapping
+  const localToRealId = new Map<string, string>();
+  const createdTasks: { task: (typeof tasks)[0]; realId: string }[] = [];
+
+  // First pass: create tasks without blockedBy
+  const spinner = createSpinner(`Importing ${String(tasks.length)} task(s)...`).start();
+  let imported = 0;
+  for (const taskInput of tasks) {
+    try {
+      // projectPath is required from the schema
+      const task = await addTask({
+        name: taskInput.name,
+        description: taskInput.description,
+        steps: taskInput.steps ?? [],
+        ticketId: taskInput.ticketId,
+        blockedBy: [], // Set later
+        projectPath: taskInput.projectPath,
+      });
+
+      // Map local ID to real ID
+      if (taskInput.id) {
+        localToRealId.set(taskInput.id, task.id);
+      }
+
+      createdTasks.push({ task: taskInput, realId: task.id });
+      imported++;
+      spinner.text = `Importing tasks... (${String(imported)}/${String(tasks.length)})`;
+    } catch (err) {
+      if (err instanceof SprintStatusError) {
+        spinner.fail('Import failed');
+        showError(err.message);
+        log.newline();
+        return;
+      }
+      log.itemError(`Failed to add: ${taskInput.name}`);
+      if (err instanceof Error) {
+        console.log(muted(`    ${err.message}`));
+      }
+    }
+  }
+
+  // Second pass: update blockedBy with resolved real IDs (under file lock)
+  spinner.text = 'Resolving task dependencies...';
+  const tasksFilePath = getTasksFilePath(sprintId);
+  await withFileLock(tasksFilePath, async () => {
+    const allTasks = await getTasks();
+    for (const { task: taskInput, realId } of createdTasks) {
+      const blockedBy = (taskInput.blockedBy ?? [])
+        .map((localId) => localToRealId.get(localId) ?? '')
+        .filter((id) => id !== '');
+
+      if (blockedBy.length > 0) {
+        const taskToUpdate = allTasks.find((t) => t.id === realId);
+        if (taskToUpdate) {
+          taskToUpdate.blockedBy = blockedBy;
+        }
+      }
+    }
+    await saveTasks(allTasks);
+  });
+
+  spinner.succeed(`Imported ${String(imported)}/${String(tasks.length)} tasks`);
+  for (const { task: taskInput, realId } of createdTasks) {
+    log.itemSuccess(`${realId}: ${taskInput.name}`);
+  }
+}

package/src/commands/task/index.ts

@@ -0,0 +1,123 @@
+import type { Command } from 'commander';
+import { taskAddCommand } from '@src/commands/task/add.ts';
+import { taskListCommand } from '@src/commands/task/list.ts';
+import { taskShowCommand } from '@src/commands/task/show.ts';
+import { taskRemoveCommand } from '@src/commands/task/remove.ts';
+import { taskStatusCommand } from '@src/commands/task/status.ts';
+import { taskNextCommand } from '@src/commands/task/next.ts';
+import { taskReorderCommand } from '@src/commands/task/reorder.ts';
+import { taskImportCommand } from '@src/commands/task/import.ts';
+
+export function registerTaskCommands(program: Command): void {
+  const task = program.command('task').description('Manage tasks');
+
+  task.addHelpText(
+    'after',
+    `
+Examples:
+  $ ralphctl task add --name "Implement login" --ticket abc123
+  $ ralphctl task list
+  $ ralphctl task status abc123 done
+  $ ralphctl task next
+`
+  );
+
+  task
+    .command('add')
+    .description('Add task to current sprint')
+    .option('--name <name>', 'Task name')
+    .option('-d, --description <desc>', 'Description')
+    .option('--step <step...>', 'Implementation step (repeatable)')
+    .option('--ticket <id>', 'Link to ticket ID')
+    .option('-p, --project <path>', 'Project path')
+    .option('-n, --no-interactive', 'Non-interactive mode (error on missing params)')
+    .action(
+      async (opts: {
+        name?: string;
+        description?: string;
+        step?: string[];
+        ticket?: string;
+        project?: string;
+        interactive?: boolean;
+      }) => {
+        await taskAddCommand({
+          name: opts.name,
+          description: opts.description,
+          steps: opts.step,
+          ticket: opts.ticket,
+          project: opts.project,
+          // --no-interactive sets interactive=false, otherwise true (prompt for missing)
+          interactive: opts.interactive !== false,
+        });
+      }
+    );
+
+  task
+    .command('import <file>')
+    .description('Import tasks from JSON file')
+    .action(async (file: string) => {
+      await taskImportCommand([file]);
+    });
+
+  task
+    .command('list')
+    .description('List tasks')
+    .option('-b, --brief', 'Brief format')
+    .option('--status <status>', 'Filter by status (todo, in_progress, done)')
+    .option('--project <name>', 'Filter by project path')
+    .option('--ticket <id>', 'Filter by ticket ID')
+    .option('--blocked', 'Show only blocked tasks')
+    .action(
+      async (opts: { brief?: boolean; status?: string; project?: string; ticket?: string; blocked?: boolean }) => {
+        const args: string[] = [];
+        if (opts.brief) args.push('-b');
+        if (opts.status) args.push('--status', opts.status);
+        if (opts.project) args.push('--project', opts.project);
+        if (opts.ticket) args.push('--ticket', opts.ticket);
+        if (opts.blocked) args.push('--blocked');
+        await taskListCommand(args);
+      }
+    );
+
+  task
+    .command('show [id]')
+    .description('Show task details')
+    .action(async (id?: string) => {
+      await taskShowCommand(id ? [id] : []);
+    });
+
+  task
+    .command('remove [id]')
+    .description('Remove a task')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (id?: string, opts?: { yes?: boolean }) => {
+      const args: string[] = [];
+      if (id) args.push(id);
+      if (opts?.yes) args.push('-y');
+      await taskRemoveCommand(args);
+    });
+
+  task
+    .command('status [id] [status]')
+    .description('Update task status (todo/in_progress/done)')
+    .option('-n, --no-interactive', 'Non-interactive mode (exit with error codes)')
+    .action(async (id?: string, status?: string, opts?: { interactive?: boolean }) => {
+      await taskStatusCommand([], {
+        taskId: id,
+        status,
+        noInteractive: opts?.interactive === false,
+      });
+    });
+
+  task.command('next').description('Get next task').action(taskNextCommand);
+
+  task
+    .command('reorder [id] [position]')
+    .description('Change task priority')
+    .action(async (id?: string, position?: string) => {
+      const args: string[] = [];
+      if (id) args.push(id);
+      if (position) args.push(position);
+      await taskReorderCommand(args);
+    });
+}