ralphctl 0.1.0 → 0.1.2

package/src/commands/task/add.ts

@@ -1,316 +0,0 @@
-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

@@ -1,150 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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);
-    });
-}