ralphctl 0.1.0 → 0.1.2

package/src/store/sprint.ts

@@ -1,229 +0,0 @@
-import {
-  getProgressFilePath,
-  getSprintDir,
-  getSprintFilePath,
-  getSprintsDir,
-  getTasksFilePath,
-} from '@src/utils/paths.ts';
-import {
-  appendToFile,
-  ensureDir,
-  fileExists,
-  listDirs,
-  readValidatedJson,
-  removeDir,
-  ValidationError,
-  writeValidatedJson,
-} from '@src/utils/storage.ts';
-import { type Sprint, SprintSchema, type SprintStatus, type Tasks, TasksSchema } from '@src/schemas/index.ts';
-import { getCurrentSprint } from '@src/store/config.ts';
-import { generateSprintId } from '@src/utils/ids.ts';
-import { logBaselines } from '@src/store/progress.ts';
-
-export class SprintNotFoundError extends Error {
-  public readonly sprintId: string;
-
-  constructor(sprintId: string) {
-    super(`Sprint not found: ${sprintId}`);
-    this.name = 'SprintNotFoundError';
-    this.sprintId = sprintId;
-  }
-}
-
-export class SprintStatusError extends Error {
-  public readonly currentStatus: SprintStatus;
-  public readonly operation: string;
-
-  constructor(message: string, currentStatus: SprintStatus, operation: string) {
-    super(message);
-    this.name = 'SprintStatusError';
-    this.currentStatus = currentStatus;
-    this.operation = operation;
-  }
-}
-
-export class NoCurrentSprintError extends Error {
-  constructor() {
-    super('No sprint specified and no current sprint set.');
-    this.name = 'NoCurrentSprintError';
-  }
-}
-
-/**
- * Assert that a sprint is in one of the allowed statuses for an operation.
- * @throws SprintStatusError if status is not allowed
- */
-export function assertSprintStatus(
-  sprint: Sprint,
-  allowedStatuses: SprintStatus[],
-  operation: string
-): asserts sprint is Sprint {
-  if (!allowedStatuses.includes(sprint.status)) {
-    const statusText = allowedStatuses.join(' or ');
-    const hints: Record<string, string> = {
-      'add tickets': 'Close the current sprint and create a new one for additional work.',
-      'remove tickets': 'Sprint must be in draft status to remove tickets.',
-      'add tasks': 'Close the current sprint and create a new one for additional work.',
-      'remove tasks': 'Sprint must be in draft status to remove tasks.',
-      'reorder tasks': 'Sprint must be in draft status to reorder tasks.',
-      refine: 'Refinement can only be done on draft sprints.',
-      plan: 'Planning can only be done on draft sprints.',
-      activate: 'Sprint must be in draft status to activate.',
-      start: 'Sprint must be draft or active to start.',
-      'update task status': 'Task status can only be updated during active execution.',
-      'log progress': 'Progress can only be logged during active execution.',
-      close: 'Sprint must be active to close.',
-    };
-
-    const hint = hints[operation] ?? '';
-    const hintText = hint ? `\nHint: ${hint}` : '';
-
-    throw new SprintStatusError(
-      `Cannot ${operation}: sprint status is '${sprint.status}' (must be ${statusText}).${hintText}`,
-      sprint.status,
-      operation
-    );
-  }
-}
-
-export async function createSprint(name?: string): Promise<Sprint> {
-  const id = generateSprintId(name);
-  const now = new Date().toISOString();
-
-  // Use the slug portion of the ID as display name if no name provided
-  const displayName = name ?? id.slice(16); // Skip "YYYYMMDD-HHmmss-" prefix
-
-  const sprint: Sprint = {
-    id,
-    name: displayName,
-    status: 'draft',
-    createdAt: now,
-    activatedAt: null,
-    closedAt: null,
-    tickets: [],
-    checkRanAt: {},
-    branch: null,
-  };
-
-  const sprintDir = getSprintDir(id);
-  await ensureDir(sprintDir);
-
-  await writeValidatedJson(getSprintFilePath(id), sprint, SprintSchema);
-  await writeValidatedJson(getTasksFilePath(id), [], TasksSchema);
-  await appendToFile(getProgressFilePath(id), `# Sprint: ${displayName}\n\nCreated: ${now}\n\n---\n\n`);
-
-  return sprint;
-}
-
-/**
- * Find the sprint with status='active' (if any).
- * Returns null if no sprint is currently active.
- */
-export async function findActiveSprint(): Promise<Sprint | null> {
-  const sprints = await listSprints();
-  return sprints.find((s) => s.status === 'active') ?? null;
-}
-
-export async function getSprint(sprintId: string): Promise<Sprint> {
-  const sprintPath = getSprintFilePath(sprintId);
-  if (!(await fileExists(sprintPath))) {
-    throw new SprintNotFoundError(sprintId);
-  }
-  return readValidatedJson(sprintPath, SprintSchema);
-}
-
-export async function saveSprint(sprint: Sprint): Promise<void> {
-  await writeValidatedJson(getSprintFilePath(sprint.id), sprint, SprintSchema);
-}
-
-export async function listSprints(): Promise<Sprint[]> {
-  const sprintsDir = getSprintsDir();
-  const dirs = await listDirs(sprintsDir);
-
-  const sprints: Sprint[] = [];
-  for (const dir of dirs) {
-    try {
-      const sprint = await getSprint(dir);
-      sprints.push(sprint);
-    } catch (err) {
-      if (err instanceof ValidationError || err instanceof SprintNotFoundError) {
-        continue; // Skip invalid/corrupt sprint directories
-      }
-      throw err;
-    }
-  }
-
-  // Sort by creation date (newest first)
-  return sprints.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-}
-
-export async function activateSprint(sprintId: string): Promise<Sprint> {
-  const sprint = await getSprint(sprintId);
-
-  assertSprintStatus(sprint, ['draft'], 'activate');
-
-  sprint.status = 'active';
-  sprint.activatedAt = new Date().toISOString();
-  await saveSprint(sprint);
-
-  // Log baseline git state for each unique project path
-  const tasks: Tasks = await readValidatedJson(getTasksFilePath(sprintId), TasksSchema);
-  const projectPaths = tasks.map((t) => t.projectPath).filter((p): p is string => !!p);
-
-  if (projectPaths.length > 0) {
-    await logBaselines({
-      sprintId,
-      sprintName: sprint.name,
-      projectPaths,
-    });
-  }
-
-  return sprint;
-}
-
-export async function closeSprint(sprintId: string): Promise<Sprint> {
-  const sprint = await getSprint(sprintId);
-
-  assertSprintStatus(sprint, ['active'], 'close');
-
-  sprint.status = 'closed';
-  sprint.closedAt = new Date().toISOString();
-  sprint.checkRanAt = {};
-  await saveSprint(sprint);
-
-  return sprint;
-}
-
-export async function deleteSprint(sprintId: string): Promise<Sprint> {
-  const sprint = await getSprint(sprintId);
-  const sprintDir = getSprintDir(sprintId);
-  await removeDir(sprintDir);
-  return sprint;
-}
-
-export async function getCurrentSprintOrThrow(): Promise<Sprint> {
-  const currentSprintId = await getCurrentSprint();
-  if (!currentSprintId) {
-    throw new Error('No current sprint. Use "ralphctl sprint create" to create one.');
-  }
-  return getSprint(currentSprintId);
-}
-
-export async function getActiveSprintOrThrow(): Promise<Sprint> {
-  const activeSprint = await findActiveSprint();
-  if (!activeSprint) {
-    throw new Error('No active sprint. Use "ralphctl sprint start" to start a draft sprint.');
-  }
-  return activeSprint;
-}
-
-export async function resolveSprintId(sprintId?: string): Promise<string> {
-  if (sprintId) {
-    return sprintId;
-  }
-  const currentSprintId = await getCurrentSprint();
-  if (!currentSprintId) {
-    throw new NoCurrentSprintError();
-  }
-  return currentSprintId;
-}

package/src/store/task.ts

@@ -1,443 +0,0 @@
-import { getTasksFilePath } from '@src/utils/paths.ts';
-import { readValidatedJson, writeValidatedJson } from '@src/utils/storage.ts';
-import { type Task, type Tasks, TasksSchema, type TaskStatus } from '@src/schemas/index.ts';
-import { assertSprintStatus, getSprint, resolveSprintId } from '@src/store/sprint.ts';
-import { generateUuid8 } from '@src/utils/ids.ts';
-import { withFileLock } from '@src/utils/file-lock.ts';
-
-export class TaskNotFoundError extends Error {
-  public readonly taskId: string;
-
-  constructor(taskId: string) {
-    super(`Task not found: ${taskId}`);
-    this.name = 'TaskNotFoundError';
-    this.taskId = taskId;
-  }
-}
-
-export class TaskStatusError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'TaskStatusError';
-  }
-}
-
-export class DependencyCycleError extends Error {
-  public readonly cycle: string[];
-
-  constructor(cycle: string[]) {
-    super(`Dependency cycle detected: ${cycle.join(' → ')}`);
-    this.name = 'DependencyCycleError';
-    this.cycle = cycle;
-  }
-}
-
-export async function getTasks(sprintId?: string): Promise<Tasks> {
-  const id = await resolveSprintId(sprintId);
-  return readValidatedJson(getTasksFilePath(id), TasksSchema);
-}
-
-export async function saveTasks(tasks: Tasks, sprintId?: string): Promise<void> {
-  const id = await resolveSprintId(sprintId);
-  await writeValidatedJson(getTasksFilePath(id), tasks, TasksSchema);
-}
-
-export async function getTask(taskId: string, sprintId?: string): Promise<Task> {
-  const tasks = await getTasks(sprintId);
-  const task = tasks.find((t) => t.id === taskId);
-  if (!task) {
-    throw new TaskNotFoundError(taskId);
-  }
-  return task;
-}
-
-export interface AddTaskInput {
-  name: string;
-  description?: string;
-  steps?: string[];
-  ticketId?: string;
-  blockedBy?: string[];
-  projectPath: string;
-}
-
-export async function addTask(input: AddTaskInput, sprintId?: string): Promise<Task> {
-  const id = await resolveSprintId(sprintId);
-  const sprint = await getSprint(id);
-
-  // Check sprint status - must be draft to add tasks
-  assertSprintStatus(sprint, ['draft'], 'add tasks');
-
-  const tasksFilePath = getTasksFilePath(id);
-
-  // Use file lock for atomic read-modify-write
-  return withFileLock(tasksFilePath, async () => {
-    const tasks = await getTasks(id);
-    const maxOrder = tasks.reduce((max, t) => Math.max(max, t.order), 0);
-
-    const task: Task = {
-      id: generateUuid8(),
-      name: input.name,
-      description: input.description,
-      steps: input.steps ?? [],
-      status: 'todo',
-      order: maxOrder + 1,
-      ticketId: input.ticketId,
-      blockedBy: input.blockedBy ?? [],
-      projectPath: input.projectPath,
-      verified: false,
-    };
-
-    tasks.push(task);
-    await saveTasks(tasks, id);
-    return task;
-  });
-}
-
-export async function removeTask(taskId: string, sprintId?: string): Promise<void> {
-  const id = await resolveSprintId(sprintId);
-  const sprint = await getSprint(id);
-
-  // Check sprint status - must be draft to remove tasks
-  assertSprintStatus(sprint, ['draft'], 'remove tasks');
-
-  const tasksFilePath = getTasksFilePath(id);
-
-  // Use file lock for atomic read-modify-write
-  await withFileLock(tasksFilePath, async () => {
-    const tasks = await getTasks(id);
-    const index = tasks.findIndex((t) => t.id === taskId);
-    if (index === -1) {
-      throw new TaskNotFoundError(taskId);
-    }
-    tasks.splice(index, 1);
-    await saveTasks(tasks, id);
-  });
-}
-
-export async function updateTaskStatus(taskId: string, status: TaskStatus, sprintId?: string): Promise<Task> {
-  const id = await resolveSprintId(sprintId);
-  const sprint = await getSprint(id);
-
-  // Check sprint status - must be active to update task status
-  assertSprintStatus(sprint, ['active'], 'update task status');
-
-  const tasksFilePath = getTasksFilePath(id);
-
-  // Use file lock for atomic read-modify-write
-  return withFileLock(tasksFilePath, async () => {
-    const tasks = await getTasks(id);
-    const task = tasks.find((t) => t.id === taskId);
-    if (!task) {
-      throw new TaskNotFoundError(taskId);
-    }
-
-    task.status = status;
-    await saveTasks(tasks, id);
-    return task;
-  });
-}
-
-export interface UpdateTaskInput {
-  verified?: boolean;
-  verificationOutput?: string;
-}
-
-export async function updateTask(taskId: string, updates: UpdateTaskInput, sprintId?: string): Promise<Task> {
-  const id = await resolveSprintId(sprintId);
-  const sprint = await getSprint(id);
-
-  // Check sprint status - must be active to update task
-  assertSprintStatus(sprint, ['active'], 'update task');
-
-  const tasksFilePath = getTasksFilePath(id);
-
-  // Use file lock for atomic read-modify-write
-  return withFileLock(tasksFilePath, async () => {
-    const tasks = await getTasks(id);
-    const task = tasks.find((t) => t.id === taskId);
-    if (!task) {
-      throw new TaskNotFoundError(taskId);
-    }
-
-    if (updates.verified !== undefined) {
-      task.verified = updates.verified;
-    }
-    if (updates.verificationOutput !== undefined) {
-      task.verificationOutput = updates.verificationOutput;
-    }
-
-    await saveTasks(tasks, id);
-    return task;
-  });
-}
-
-/**
- * Check if a task is blocked by dependencies.
- * A task is blocked if any of its blockedBy tasks are not done.
- */
-export async function isTaskBlocked(taskId: string, sprintId?: string): Promise<boolean> {
-  const tasks = await getTasks(sprintId);
-  const task = tasks.find((t) => t.id === taskId);
-  if (!task) return false;
-
-  if (task.blockedBy.length === 0) return false;
-
-  const doneIds = new Set(tasks.filter((t) => t.status === 'done').map((t) => t.id));
-  return !task.blockedBy.every((id) => doneIds.has(id));
-}
-
-export async function getNextTask(sprintId?: string): Promise<Task | null> {
-  const tasks = await getTasks(sprintId);
-
-  // Priority 1: Resume in_progress task
-  const inProgress = tasks.find((t) => t.status === 'in_progress');
-  if (inProgress) {
-    return inProgress;
-  }
-
-  // Priority 2: First todo task whose dependencies are all done
-  const ready = getReadyTasksFromList(tasks);
-  return ready[0] ?? null;
-}
-
-/**
- * Get all tasks from a task list that are ready to execute (unblocked todo tasks).
- * Pure function operating on an in-memory list.
- */
-export function getReadyTasksFromList(tasks: Tasks): Tasks {
-  const doneIds = new Set(tasks.filter((t) => t.status === 'done').map((t) => t.id));
-  return tasks
-    .filter((t) => t.status === 'todo')
-    .filter((t) => t.blockedBy.every((id) => doneIds.has(id)))
-    .sort((a, b) => a.order - b.order);
-}
-
-/**
- * Get all tasks that are ready to execute (unblocked todo tasks).
- * Returns multiple tasks for parallel execution.
- */
-export async function getReadyTasks(sprintId?: string): Promise<Tasks> {
-  const tasks = await getTasks(sprintId);
-  return getReadyTasksFromList(tasks);
-}
-
-export async function reorderTask(taskId: string, newOrder: number, sprintId?: string): Promise<Task> {
-  const id = await resolveSprintId(sprintId);
-  const sprint = await getSprint(id);
-
-  // Check sprint status - must be draft to reorder tasks
-  assertSprintStatus(sprint, ['draft'], 'reorder tasks');
-
-  const tasksFilePath = getTasksFilePath(id);
-
-  // Use file lock for atomic read-modify-write
-  return withFileLock(tasksFilePath, async () => {
-    const tasks = await getTasks(id);
-    const task = tasks.find((t) => t.id === taskId);
-    if (!task) {
-      throw new TaskNotFoundError(taskId);
-    }
-
-    const oldOrder = task.order;
-    task.order = newOrder;
-
-    // Adjust other task orders
-    for (const t of tasks) {
-      if (t.id === taskId) continue;
-
-      if (oldOrder < newOrder) {
-        // Moving down: decrement tasks between old and new positions
-        if (t.order > oldOrder && t.order <= newOrder) {
-          t.order--;
-        }
-      } else {
-        // Moving up: increment tasks between new and old positions
-        if (t.order >= newOrder && t.order < oldOrder) {
-          t.order++;
-        }
-      }
-    }
-
-    await saveTasks(tasks, id);
-    return task;
-  });
-}
-
-export async function listTasks(sprintId?: string): Promise<Tasks> {
-  const tasks = await getTasks(sprintId);
-  return tasks.sort((a, b) => a.order - b.order);
-}
-
-export async function getRemainingTasks(sprintId?: string): Promise<Tasks> {
-  const tasks = await getTasks(sprintId);
-  return tasks.filter((t) => t.status !== 'done').sort((a, b) => a.order - b.order);
-}
-
-export async function areAllTasksDone(sprintId?: string): Promise<boolean> {
-  const tasks = await getTasks(sprintId);
-  return tasks.length > 0 && tasks.every((t) => t.status === 'done');
-}
-
-/**
- * Performs topological sort on tasks based on blockedBy dependencies.
- * Returns tasks in dependency order (tasks that block others come first).
- * Throws DependencyCycleError if a cycle is detected.
- */
-export function topologicalSort(tasks: Tasks): Tasks {
-  const taskMap = new Map(tasks.map((t) => [t.id, t]));
-  const visited = new Set<string>();
-  const visiting = new Set<string>();
-  const result: Task[] = [];
-
-  function visit(taskId: string, path: string[]): void {
-    if (visited.has(taskId)) return;
-    if (visiting.has(taskId)) {
-      // Found a cycle - find where in path it starts
-      const cycleStart = path.indexOf(taskId);
-      throw new DependencyCycleError([...path.slice(cycleStart), taskId]);
-    }
-
-    const task = taskMap.get(taskId);
-    if (!task) return;
-
-    visiting.add(taskId);
-
-    // Visit all tasks this one depends on first
-    for (const blockedById of task.blockedBy) {
-      visit(blockedById, [...path, taskId]);
-    }
-
-    visiting.delete(taskId);
-    visited.add(taskId);
-    result.push(task);
-  }
-
-  for (const task of tasks) {
-    visit(task.id, []);
-  }
-
-  return result;
-}
-
-/**
- * Reorders tasks by dependencies and updates their order field.
- * Called at sprint start to ensure task order respects dependencies.
- */
-export async function reorderByDependencies(sprintId?: string): Promise<void> {
-  const id = await resolveSprintId(sprintId);
-  const tasksFilePath = getTasksFilePath(id);
-
-  // Use file lock for atomic read-modify-write
-  await withFileLock(tasksFilePath, async () => {
-    const tasks = await getTasks(id);
-    if (tasks.length === 0) return;
-
-    const sorted = topologicalSort(tasks);
-
-    // Update order field based on sorted position
-    sorted.forEach((task, index) => {
-      task.order = index + 1;
-    });
-
-    await saveTasks(sorted, id);
-  });
-}
-
-/**
- * Validates import tasks for dependency issues and ticketId references.
- * Tasks can have a local 'id' field that blockedBy references.
- * If ticketIds is provided, validates that ticketId references exist.
- * Returns an array of error messages (empty if valid).
- */
-export function validateImportTasks(
-  importTasks: { id?: string; name: string; blockedBy?: string[]; ticketId?: string }[],
-  existingTasks: Tasks,
-  ticketIds?: Set<string>
-): string[] {
-  const errors: string[] = [];
-
-  // Validate ticketId references if ticket IDs are provided
-  if (ticketIds) {
-    for (const task of importTasks) {
-      if (task.ticketId && !ticketIds.has(task.ticketId)) {
-        errors.push(`Task "${task.name}": ticketId "${task.ticketId}" does not match any ticket in the sprint`);
-      }
-    }
-  }
-
-  // Build set of all known IDs (local IDs from import + existing task IDs)
-  const localIds = new Set(importTasks.map((t) => t.id).filter((id): id is string => !!id));
-  const existingIds = new Set(existingTasks.map((t) => t.id));
-  const allKnownIds = new Set([...localIds, ...existingIds]);
-
-  // Build map of local ID to array index for ordering check
-  const localIdToIndex = new Map<string, number>();
-  importTasks.forEach((task, i) => {
-    if (task.id) {
-      localIdToIndex.set(task.id, i);
-    }
-  });
-
-  // Validate blockedBy references
-  importTasks.forEach((task, taskIndex) => {
-    for (const depId of task.blockedBy ?? []) {
-      if (!allKnownIds.has(depId)) {
-        errors.push(`Task "${task.name}": blockedBy "${depId}" does not exist`);
-      } else if (localIds.has(depId)) {
-        // If referencing a local ID, it must appear earlier in the import array
-        const depIndex = localIdToIndex.get(depId);
-        if (depIndex !== undefined && depIndex >= taskIndex) {
-          errors.push(`Task "${task.name}": blockedBy "${depId}" must reference an earlier task in the import`);
-        }
-      }
-    }
-  });
-
-  if (errors.length > 0) {
-    return errors;
-  }
-
-  // Generate temporary real IDs for cycle detection
-  const tempRealIds = importTasks.map(() => generateUuid8());
-
-  // Map local IDs to temp real IDs
-  const localToTempReal = new Map<string, string>();
-  importTasks.forEach((task, i) => {
-    if (task.id) {
-      localToTempReal.set(task.id, tempRealIds[i] ?? '');
-    }
-  });
-
-  // Build combined task list for cycle detection
-  const combinedTasks: Tasks = [
-    ...existingTasks,
-    ...importTasks.map((t, i) => ({
-      id: tempRealIds[i] ?? generateUuid8(),
-      name: t.name,
-      description: undefined,
-      steps: [],
-      status: 'todo' as const,
-      order: existingTasks.length + i + 1,
-      ticketId: undefined,
-      blockedBy: (t.blockedBy ?? []).map((depId) => {
-        // Convert local ID to temp real ID, or keep existing ID
-        return localToTempReal.get(depId) ?? depId;
-      }),
-      projectPath: '/tmp', // Placeholder for validation only
-      verified: false,
-    })),
-  ];
-
-  // Check for cycles
-  try {
-    topologicalSort(combinedTasks);
-  } catch (err) {
-    if (err instanceof DependencyCycleError) {
-      errors.push(err.message);
-    } else {
-      throw err;
-    }
-  }
-
-  return errors;
-}