ralphctl 0.1.0 → 0.1.2

package/src/commands/sprint/index.ts

@@ -1,226 +0,0 @@
-import type { Command } from 'commander';
-import { sprintCreateCommand } from '@src/commands/sprint/create.ts';
-import { sprintListCommand } from '@src/commands/sprint/list.ts';
-import { sprintShowCommand } from '@src/commands/sprint/show.ts';
-import { sprintContextCommand } from '@src/commands/sprint/context.ts';
-import { sprintCloseCommand } from '@src/commands/sprint/close.ts';
-import { sprintStartCommand } from '@src/commands/sprint/start.ts';
-import { sprintPlanCommand } from '@src/commands/sprint/plan.ts';
-import { sprintCurrentCommand } from '@src/commands/sprint/current.ts';
-import { sprintSwitchCommand } from '@src/commands/sprint/switch.ts';
-import { sprintRefineCommand } from '@src/commands/sprint/refine.ts';
-import { sprintIdeateCommand } from '@src/commands/sprint/ideate.ts';
-import { sprintRequirementsCommand } from '@src/commands/sprint/requirements.ts';
-import { sprintHealthCommand } from '@src/commands/sprint/health.ts';
-import { sprintDeleteCommand } from '@src/commands/sprint/delete.ts';
-
-export function registerSprintCommands(program: Command): void {
-  const sprint = program.command('sprint').description('Manage sprints');
-
-  sprint.addHelpText(
-    'after',
-    `
-Examples:
-  $ ralphctl sprint create --name "Sprint 1"
-  $ ralphctl sprint refine              # Refine ticket requirements with AI
-  $ ralphctl sprint plan --auto         # Generate tasks automatically
-  $ ralphctl sprint start -s            # Start with interactive session
-`
-  );
-
-  sprint
-    .command('create')
-    .description('Create a new sprint')
-    .option('--name <name>', 'Sprint name')
-    .option('-n, --no-interactive', 'Non-interactive mode (error on missing params)')
-    .action(async (opts: { name?: string; interactive?: boolean }) => {
-      await sprintCreateCommand({
-        name: opts.name,
-        // --no-interactive sets interactive=false, otherwise true (prompt for missing)
-        interactive: opts.interactive !== false,
-      });
-    });
-
-  sprint
-    .command('list')
-    .description('List all sprints')
-    .option('--status <status>', 'Filter by status (draft, active, closed)')
-    .action(async (opts: { status?: string }) => {
-      const args: string[] = [];
-      if (opts.status) args.push('--status', opts.status);
-      await sprintListCommand(args);
-    });
-
-  sprint
-    .command('show [id]')
-    .description('Show sprint details')
-    .action(async (id?: string) => {
-      await sprintShowCommand(id ? [id] : []);
-    });
-
-  sprint
-    .command('context [id]')
-    .description('Output full context for planning')
-    .action(async (id?: string) => {
-      await sprintContextCommand(id ? [id] : []);
-    });
-
-  sprint
-    .command('current [id]')
-    .description('Show/set current sprint (use "-" to open selector)')
-    .action(async (id?: string) => {
-      await sprintCurrentCommand(id ? [id] : []);
-    });
-
-  sprint
-    .command('switch')
-    .description('Quick sprint switcher (opens selector)')
-    .action(async () => {
-      await sprintSwitchCommand();
-    });
-
-  sprint
-    .command('refine [id]')
-    .description('Refine ticket specifications')
-    .option('--project <name>', 'Only refine tickets for specific project')
-    .action(async (id?: string, opts?: { project?: string }) => {
-      const args: string[] = [];
-      if (id) args.push(id);
-      if (opts?.project) args.push('--project', opts.project);
-      await sprintRefineCommand(args);
-    });
-
-  sprint
-    .command('ideate [id]')
-    .description('Quick idea to tasks (refine + plan in one session)')
-    .option('--auto', 'Run without user interaction (AI decides autonomously)')
-    .option('--all-paths', 'Explore all project repositories instead of prompting for selection')
-    .option('--project <name>', 'Pre-select project (skip interactive selection)')
-    .action(async (id?: string, opts?: { auto?: boolean; allPaths?: boolean; project?: string }) => {
-      const args: string[] = [];
-      if (id) args.push(id);
-      if (opts?.auto) args.push('--auto');
-      if (opts?.allPaths) args.push('--all-paths');
-      if (opts?.project) args.push('--project', opts.project);
-      await sprintIdeateCommand(args);
-    });
-
-  sprint
-    .command('plan [id]')
-    .description('Generate tasks using AI CLI')
-    .option('--auto', 'Run without user interaction (AI decides autonomously)')
-    .option('--all-paths', 'Explore all project repositories instead of prompting for selection')
-    .action(async (id?: string, opts?: { auto?: boolean; allPaths?: boolean }) => {
-      const args: string[] = [];
-      if (id) args.push(id);
-      if (opts?.auto) args.push('--auto');
-      if (opts?.allPaths) args.push('--all-paths');
-      await sprintPlanCommand(args);
-    });
-
-  sprint
-    .command('close [id]')
-    .description('Close an active sprint')
-    .option('--create-pr', 'Create pull requests for sprint branches')
-    .action(async (id?: string, opts?: { createPr?: boolean }) => {
-      const args: string[] = [];
-      if (id) args.push(id);
-      if (opts?.createPr) args.push('--create-pr');
-      await sprintCloseCommand(args);
-    });
-
-  sprint
-    .command('delete [id]')
-    .description('Delete a sprint permanently')
-    .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 sprintDeleteCommand(args);
-    });
-
-  sprint
-    .command('requirements [id]')
-    .description('Export refined requirements to file')
-    .action(async (id?: string) => {
-      await sprintRequirementsCommand(id ? [id] : []);
-    });
-
-  sprint
-    .command('health')
-    .description('Check sprint health')
-    .action(async () => {
-      await sprintHealthCommand();
-    });
-
-  sprint
-    .command('start [id]')
-    .description('Run automated implementation loop')
-    .option('-s, --session', 'Interactive AI session (collaborate with your AI provider)')
-    .option('-t, --step', 'Step through tasks with approval between each')
-    .option('-c, --count <n>', 'Limit to N tasks')
-    .option('--no-commit', 'Skip automatic git commit after each task completes')
-    .option('--concurrency <n>', 'Max parallel tasks (default: auto based on unique repos)')
-    .option('--max-retries <n>', 'Max rate-limit retries per task (default: 5)')
-    .option('--fail-fast', 'Stop launching new tasks on first failure')
-    .option('-f, --force', 'Skip precondition checks (e.g., unplanned tickets)')
-    .option('--refresh-check', 'Force re-run check scripts even if they already ran this sprint')
-    .option('-b, --branch', 'Create sprint branch (ralphctl/<sprint-id>) in all repos')
-    .option('--branch-name <name>', 'Use a custom branch name for sprint execution')
-    .addHelpText(
-      'after',
-      `
-Exit Codes:
-  0 - Success (all requested operations completed)
-  1 - Error (validation, missing params, execution failed)
-  2 - No tasks available
-  3 - All remaining tasks blocked by dependencies
-
-Parallel Execution:
-  Tasks targeting different repos run concurrently by default.
-  At most one task per repository runs at a time to avoid git conflicts.
-  Use --concurrency 1 to force sequential execution.
-  Session (--session) and step (--step) modes always run sequentially.
-
-Branch Management:
-  Use -b/--branch to auto-create a sprint branch in all repos.
-  Use --branch-name <name> to specify a custom branch name.
-  On first run, an interactive prompt offers branch strategy selection.
-  The chosen branch is persisted and reused on subsequent runs.
-`
-    )
-    .action(
-      async (
-        id?: string,
-        opts?: {
-          session?: boolean;
-          step?: boolean;
-          count?: string;
-          commit?: boolean;
-          concurrency?: string;
-          maxRetries?: string;
-          failFast?: boolean;
-          force?: boolean;
-          refreshCheck?: boolean;
-          branch?: boolean;
-          branchName?: string;
-        }
-      ) => {
-        const args: string[] = [];
-        if (id) args.push(id);
-        if (opts?.session) args.push('--session');
-        if (opts?.step) args.push('--step');
-        if (opts?.count) args.push('--count', opts.count);
-        if (opts?.commit === false) args.push('--no-commit');
-        if (opts?.concurrency) args.push('--concurrency', opts.concurrency);
-        if (opts?.maxRetries) args.push('--max-retries', opts.maxRetries);
-        if (opts?.failFast) args.push('--fail-fast');
-        if (opts?.force) args.push('--force');
-        if (opts?.refreshCheck) args.push('--refresh-check');
-        if (opts?.branch) args.push('--branch');
-        if (opts?.branchName) args.push('--branch-name', opts.branchName);
-        await sprintStartCommand(args);
-      }
-    );
-}

package/src/commands/sprint/list.ts

@@ -1,86 +0,0 @@
-import { listSprints } from '@src/store/sprint.ts';
-import { getCurrentSprint } from '@src/store/config.ts';
-import { SprintStatusSchema } from '@src/schemas/index.ts';
-import {
-  badge,
-  formatSprintStatus,
-  icons,
-  log,
-  printHeader,
-  renderTable,
-  showEmpty,
-  showError,
-  showNextStep,
-} from '@src/theme/ui.ts';
-
-export async function sprintListCommand(args: string[] = []): Promise<void> {
-  // Parse status filter
-  let statusFilter: string | undefined;
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--status' && args[i + 1]) {
-      statusFilter = args[i + 1];
-      i++;
-    }
-  }
-
-  // Validate status filter
-  if (statusFilter) {
-    const result = SprintStatusSchema.safeParse(statusFilter);
-    if (!result.success) {
-      showError(`Invalid status: "${statusFilter}". Valid values: draft, active, closed`);
-      return;
-    }
-  }
-
-  const sprints = await listSprints();
-
-  if (sprints.length === 0) {
-    showEmpty('sprints', 'Create one with: ralphctl sprint create');
-    return;
-  }
-
-  const filtered = statusFilter ? sprints.filter((s) => s.status === statusFilter) : sprints;
-  const isFiltered = filtered.length !== sprints.length;
-  const filterStr = statusFilter ? ` (filtered: status=${statusFilter})` : '';
-
-  if (filtered.length === 0) {
-    showEmpty('matching sprints', 'Try adjusting your filters');
-    return;
-  }
-
-  printHeader('Sprints', icons.sprint);
-
-  const currentSprintId = await getCurrentSprint();
-
-  const rows: string[][] = filtered.map((sprint) => {
-    const isCurrent = sprint.id === currentSprintId;
-    const marker = isCurrent ? badge('current', 'success') : '';
-    return [marker, sprint.id, formatSprintStatus(sprint.status), sprint.name, String(sprint.tickets.length)];
-  });
-
-  console.log(
-    renderTable(
-      [
-        { header: '', minWidth: 0 },
-        { header: 'ID' },
-        { header: 'Status' },
-        { header: 'Name' },
-        { header: 'Tickets', align: 'right' },
-      ],
-      rows
-    )
-  );
-
-  log.newline();
-  const showingLabel = isFiltered
-    ? `Showing ${String(filtered.length)} of ${String(sprints.length)} sprint(s)${filterStr}`
-    : `Showing ${String(sprints.length)} sprint(s)`;
-  log.dim(showingLabel);
-
-  const hasActive = sprints.some((s) => s.status === 'active');
-  if (!hasActive) {
-    log.newline();
-    showNextStep('ralphctl sprint start', 'start a sprint');
-  }
-  log.newline();
-}

package/src/commands/sprint/plan-utils.ts

@@ -1,207 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { muted } from '@src/theme/index.ts';
-import { log, renderTable } from '@src/theme/ui.ts';
-import { addTask, getTasks, saveTasks } from '@src/store/task.ts';
-import { getSchemaPath, getTasksFilePath } from '@src/utils/paths.ts';
-import { withFileLock } from '@src/utils/file-lock.ts';
-import { type ImportTask, ImportTasksSchema, type Task } from '@src/schemas/index.ts';
-import { extractJsonArray } from '@src/utils/json-extract.ts';
-import { generateUuid8 } from '@src/utils/ids.ts';
-
-/**
- * Load the task import JSON schema from file.
- */
-export async function getTaskImportSchema(): Promise<string> {
-  const schemaPath = getSchemaPath('task-import.schema.json');
-  return readFile(schemaPath, 'utf-8');
-}
-
-/**
- * Check if AI output contains a planning-blocked signal.
- * Returns the reason if blocked, null otherwise.
- */
-export function parsePlanningBlocked(output: string): string | null {
-  const match = /<planning-blocked>([\s\S]*?)<\/planning-blocked>/.exec(output);
-  return match?.[1]?.trim() ?? null;
-}
-
-/**
- * Parse AI output to extract and validate task JSON array.
- */
-export function parseTasksJson(output: string): ImportTask[] {
-  // Try to extract a balanced JSON array from the output (handles nested arrays like steps)
-  const jsonStr = extractJsonArray(output);
-
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(jsonStr);
-  } catch (err) {
-    throw new Error(`Invalid JSON: ${err instanceof Error ? err.message : 'parse error'}`, { cause: err });
-  }
-
-  if (!Array.isArray(parsed)) {
-    throw new Error('Expected JSON array');
-  }
-
-  // Validate against schema
-  const result = ImportTasksSchema.safeParse(parsed);
-  if (!result.success) {
-    const issues = result.error.issues
-      .map((issue) => {
-        const path = issue.path.length > 0 ? `[${issue.path.join('.')}]` : '';
-        return `  ${path}: ${issue.message}`;
-      })
-      .join('\n');
-    throw new Error(`Invalid task format:\n${issues}`);
-  }
-
-  return result.data;
-}
-
-/**
- * Render parsed tasks as a formatted table.
- */
-export function renderParsedTasksTable(parsedTasks: ImportTask[]): string {
-  const rows = parsedTasks.map((task, i) => {
-    const deps = task.blockedBy?.length ? task.blockedBy.join(', ') : '';
-    return [String(i + 1), task.name, task.projectPath, deps];
-  });
-  return renderTable(
-    [{ header: '#', align: 'right' as const }, { header: 'Name' }, { header: 'Path' }, { header: 'Blocked By' }],
-    rows
-  );
-}
-
-/**
- * Import tasks with two-pass ID resolution.
- * When `replace: true`, builds the complete task list in memory and writes atomically
- * (interruption-safe: original tasks.json untouched until final write).
- * When `replace: false` (default), appends via addTask() one-by-one.
- * Returns the number of successfully imported tasks.
- */
-export async function importTasks(
-  tasks: ImportTask[],
-  sprintId: string,
-  options?: { replace?: boolean }
-): Promise<number> {
-  if (options?.replace) {
-    return importTasksReplace(tasks, sprintId);
-  }
-
-  return importTasksAppend(tasks, sprintId);
-}
-
-/**
- * Append tasks one-by-one via addTask() (first plan — no existing tasks).
- */
-async function importTasksAppend(tasks: ImportTask[], sprintId: string): Promise<number> {
-  // Build mapping from local IDs to real IDs
-  const localToRealId = new Map<string, string>();
-
-  // First pass: create all tasks and build ID mapping
-  const createdTasks: { task: ImportTask; realId: string }[] = [];
-
-  for (const taskInput of tasks) {
-    try {
-      const projectPath = taskInput.projectPath;
-
-      // Create task without blockedBy first
-      const task = await addTask(
-        {
-          name: taskInput.name,
-          description: taskInput.description,
-          steps: taskInput.steps ?? [],
-          ticketId: taskInput.ticketId,
-          blockedBy: [], // Set later
-          projectPath,
-        },
-        sprintId
-      );
-
-      // Map local ID to real ID
-      if (taskInput.id) {
-        localToRealId.set(taskInput.id, task.id);
-      }
-
-      createdTasks.push({ task: taskInput, realId: task.id });
-      log.itemSuccess(`${task.id}: ${task.name}`);
-    } catch (err) {
-      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)
-  const tasksFilePath = getTasksFilePath(sprintId);
-  await withFileLock(tasksFilePath, async () => {
-    const allTasks = await getTasks(sprintId);
-    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, sprintId);
-  });
-
-  return createdTasks.length;
-}
-
-/**
- * Build the complete task list in memory and write atomically via saveTasks().
- * Original tasks.json is untouched until the final write — interruption-safe.
- */
-async function importTasksReplace(tasks: ImportTask[], sprintId: string): Promise<number> {
-  // Build mapping from local IDs to real IDs
-  const localToRealId = new Map<string, string>();
-  const newTasks: Task[] = [];
-
-  // First pass: generate real IDs and build mapping
-  for (const taskInput of tasks) {
-    const realId = generateUuid8();
-    if (taskInput.id) {
-      localToRealId.set(taskInput.id, realId);
-    }
-
-    newTasks.push({
-      id: realId,
-      name: taskInput.name,
-      description: taskInput.description,
-      steps: taskInput.steps ?? [],
-      status: 'todo',
-      order: newTasks.length + 1,
-      ticketId: taskInput.ticketId,
-      blockedBy: [], // Set in second pass
-      projectPath: taskInput.projectPath,
-      verified: false,
-    });
-
-    log.itemSuccess(`${realId}: ${taskInput.name}`);
-  }
-
-  // Second pass: resolve blockedBy references
-  for (let i = 0; i < tasks.length; i++) {
-    const taskInput = tasks[i];
-    const newTask = newTasks[i];
-    if (!taskInput || !newTask) continue;
-
-    const blockedBy = (taskInput.blockedBy ?? [])
-      .map((localId) => localToRealId.get(localId) ?? '')
-      .filter((id) => id !== '');
-
-    newTask.blockedBy = blockedBy;
-  }
-
-  // Atomic write — replaces all existing tasks in one operation
-  await saveTasks(newTasks, sprintId);
-
-  return newTasks.length;
-}