@girardmedia/bootspring 2.0.21 → 2.0.23

package/src/cli/task.ts

@@ -0,0 +1,780 @@
+/**
+ * Bootspring Task Command
+ * Manage development tasks with lifecycle tracking
+ *
+ * @package bootspring
+ * @module cli/task
+ */
+
+import * as path from 'path';
+import * as fs from 'fs';
+
+// Import JS modules with type interfaces
+interface Config {
+  _projectRoot: string;
+}
+
+interface ConfigModule {
+  load(): Config;
+}
+
+interface ParsedArgs {
+  _: string[];
+  title?: string | undefined;
+  description?: string | undefined;
+  priority?: string | undefined;
+  status?: string | undefined;
+  tag?: string | undefined;
+  tags?: string | undefined;
+  estimate?: string | undefined;
+  all?: boolean | undefined;
+  text?: string | undefined;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const config = require('../../core/config') as ConfigModule;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const utils = require('../../core/utils') as typeof import('../core/utils');
+
+/**
+ * Task status info
+ */
+interface StatusInfo {
+  emoji: string;
+  label: string;
+  color: string;
+}
+
+/**
+ * Priority info
+ */
+interface PriorityInfo {
+  label: string;
+  color: string;
+}
+
+/**
+ * Lifecycle phase
+ */
+interface LifecyclePhase {
+  id: string;
+  name: string;
+  description: string;
+}
+
+/**
+ * Task note
+ */
+interface TaskNote {
+  timestamp: string;
+  content: string;
+}
+
+/**
+ * Time tracking session
+ */
+interface TimeSession {
+  start: string;
+  end?: string | undefined;
+  duration?: number | undefined;
+}
+
+/**
+ * Task time tracking
+ */
+interface TimeTracking {
+  estimated: string | null;
+  actual: number;
+  sessions: TimeSession[];
+}
+
+/**
+ * Task definition
+ */
+interface Task {
+  id: number;
+  title: string;
+  description: string;
+  status: string;
+  priority: string;
+  phase: string;
+  tags: string[];
+  assignee: string | null;
+  created: string;
+  updated: string;
+  blockedBy: number[];
+  blocks: number[];
+  notes: TaskNote[];
+  timeTracking: TimeTracking;
+}
+
+/**
+ * Tasks data file
+ */
+interface TasksData {
+  tasks: Task[];
+  nextId: number;
+}
+
+/**
+ * Create task options
+ */
+interface CreateTaskOptions {
+  title?: string | undefined;
+  description?: string | undefined;
+  priority?: string | undefined;
+  tags?: string[] | undefined;
+  estimate?: string | undefined;
+  assignee?: string | undefined;
+}
+
+/**
+ * List task options
+ */
+interface ListTasksOptions {
+  status?: string | undefined;
+  priority?: string | undefined;
+  tag?: string | undefined;
+  all?: boolean | undefined;
+}
+
+/**
+ * Task statuses with emoji indicators
+ */
+export const TASK_STATUS: Record<string, StatusInfo> = {
+  draft: { emoji: '📝', label: 'Draft', color: 'dim' },
+  ready: { emoji: '📋', label: 'Ready', color: 'cyan' },
+  'in-progress': { emoji: '🔨', label: 'In Progress', color: 'yellow' },
+  review: { emoji: '👀', label: 'Review', color: 'magenta' },
+  testing: { emoji: '🧪', label: 'Testing', color: 'blue' },
+  done: { emoji: '✅', label: 'Done', color: 'green' },
+  blocked: { emoji: '🚫', label: 'Blocked', color: 'red' }
+};
+
+/**
+ * Task priorities
+ */
+export const TASK_PRIORITY: Record<string, PriorityInfo> = {
+  P0: { label: 'Critical', color: 'red' },
+  P1: { label: 'High', color: 'yellow' },
+  P2: { label: 'Medium', color: 'cyan' },
+  P3: { label: 'Low', color: 'dim' }
+};
+
+/**
+ * Task lifecycle phases (11-phase workflow)
+ */
+export const LIFECYCLE_PHASES: LifecyclePhase[] = [
+  { id: 'context', name: 'Context Gathering', description: 'Understand the task fully' },
+  { id: 'research', name: 'Research', description: 'Investigate options and approaches' },
+  { id: 'design', name: 'Design', description: 'Plan the implementation' },
+  { id: 'setup', name: 'Setup', description: 'Prepare environment and dependencies' },
+  { id: 'implement', name: 'Implementation', description: 'Write the code' },
+  { id: 'test', name: 'Testing', description: 'Write and run tests' },
+  { id: 'review', name: 'Review', description: 'Code review and feedback' },
+  { id: 'refine', name: 'Refinement', description: 'Address feedback and polish' },
+  { id: 'document', name: 'Documentation', description: 'Update docs and comments' },
+  { id: 'deploy', name: 'Deployment', description: 'Deploy to target environment' },
+  { id: 'verify', name: 'Verification', description: 'Verify in production' }
+];
+
+/**
+ * Get tasks file path
+ */
+function getTasksPath(projectRoot: string): string {
+  return path.join(projectRoot, '.bootspring', 'tasks.json');
+}
+
+/**
+ * Load tasks from file
+ */
+function loadTasks(projectRoot: string): TasksData {
+  const tasksPath = getTasksPath(projectRoot);
+
+  if (!fs.existsSync(tasksPath)) {
+    return { tasks: [], nextId: 1 };
+  }
+
+  try {
+    const content = fs.readFileSync(tasksPath, 'utf-8');
+    return JSON.parse(content) as TasksData;
+  } catch {
+    return { tasks: [], nextId: 1 };
+  }
+}
+
+/**
+ * Save tasks to file
+ */
+function saveTasks(projectRoot: string, data: TasksData): void {
+  const tasksPath = getTasksPath(projectRoot);
+  const dir = path.dirname(tasksPath);
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  fs.writeFileSync(tasksPath, JSON.stringify(data, null, 2));
+}
+
+/**
+ * Create a new task
+ */
+export function createTask(options: CreateTaskOptions = {}): Task {
+  const cfg = config.load();
+  const projectRoot = cfg._projectRoot;
+  const data = loadTasks(projectRoot);
+
+  const task: Task = {
+    id: data.nextId,
+    title: options.title || 'Untitled Task',
+    description: options.description || '',
+    status: 'draft',
+    priority: options.priority || 'P2',
+    phase: 'context',
+    tags: options.tags || [],
+    assignee: options.assignee || null,
+    created: new Date().toISOString(),
+    updated: new Date().toISOString(),
+    blockedBy: [],
+    blocks: [],
+    notes: [],
+    timeTracking: {
+      estimated: options.estimate || null,
+      actual: 0,
+      sessions: []
+    }
+  };
+
+  data.tasks.push(task);
+  data.nextId++;
+  saveTasks(projectRoot, data);
+
+  const statusInfo = TASK_STATUS[task.status];
+  const priorityInfo = TASK_PRIORITY[task.priority];
+
+  utils.print.success(`Created task #${task.id}: ${task.title}`);
+  if (statusInfo) {
+    console.log(`${utils.COLORS.dim}Status: ${statusInfo.label}${utils.COLORS.reset}`);
+  }
+  if (priorityInfo) {
+    console.log(`${utils.COLORS.dim}Priority: ${priorityInfo.label}${utils.COLORS.reset}`);
+  }
+
+  return task;
+}
+
+/**
+ * List tasks
+ */
+export function listTasks(options: ListTasksOptions = {}): void {
+  const cfg = config.load();
+  const projectRoot = cfg._projectRoot;
+  const data = loadTasks(projectRoot);
+
+  let tasks = data.tasks;
+
+  // Filter by status
+  if (options.status) {
+    tasks = tasks.filter(t => t.status === options.status);
+  }
+
+  // Filter by priority
+  if (options.priority) {
+    tasks = tasks.filter(t => t.priority === options.priority);
+  }
+
+  // Filter by tag
+  if (options.tag) {
+    tasks = tasks.filter(t => t.tags.includes(options.tag!));
+  }
+
+  // Exclude done unless requested
+  if (!options.all && !options.status) {
+    tasks = tasks.filter(t => t.status !== 'done');
+  }
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Tasks${utils.COLORS.reset}
+${utils.COLORS.dim}${tasks.length} task(s) found${utils.COLORS.reset}
+`);
+
+  if (tasks.length === 0) {
+    utils.print.dim('No tasks found. Use "bootspring task create" to add one.');
+    return;
+  }
+
+  // Group by status
+  const grouped: Record<string, Task[]> = {};
+  for (const task of tasks) {
+    if (!grouped[task.status]) {
+      grouped[task.status] = [];
+    }
+    grouped[task.status]!.push(task);
+  }
+
+  for (const [status, statusTasks] of Object.entries(grouped)) {
+    const statusInfo = TASK_STATUS[status];
+    if (!statusInfo) continue;
+    console.log(`${statusInfo.emoji} ${utils.COLORS.bold}${statusInfo.label}${utils.COLORS.reset}`);
+
+    for (const task of statusTasks) {
+      const priorityInfo = TASK_PRIORITY[task.priority];
+      const priorityColor = priorityInfo ? (utils.COLORS as Record<string, string>)[priorityInfo.color] || '' : '';
+
+      console.log(`  ${utils.COLORS.dim}#${task.id}${utils.COLORS.reset} ${task.title}`);
+      console.log(`     ${priorityColor}${task.priority}${utils.COLORS.reset} ${utils.COLORS.dim}| Phase: ${task.phase}${utils.COLORS.reset}`);
+
+      if (task.tags.length > 0) {
+        console.log(`     ${utils.COLORS.dim}Tags: ${task.tags.join(', ')}${utils.COLORS.reset}`);
+      }
+    }
+    console.log();
+  }
+}
+
+/**
+ * Show task details
+ */
+export function showTask(taskId: string): void {
+  const cfg = config.load();
+  const projectRoot = cfg._projectRoot;
+  const data = loadTasks(projectRoot);
+
+  const task = data.tasks.find(t => t.id === parseInt(taskId));
+
+  if (!task) {
+    utils.print.error(`Task #${taskId} not found`);
+    return;
+  }
+
+  const statusInfo = TASK_STATUS[task.status];
+  const priorityInfo = TASK_PRIORITY[task.priority];
+  const phaseInfo = LIFECYCLE_PHASES.find(p => p.id === task.phase);
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Task #${task.id}${utils.COLORS.reset}
+${utils.COLORS.bold}${task.title}${utils.COLORS.reset}
+
+${utils.COLORS.bold}Status${utils.COLORS.reset}
+  ${statusInfo?.emoji || '?'} ${statusInfo?.label || task.status}
+  Priority: ${priorityInfo ? (utils.COLORS as Record<string, string>)[priorityInfo.color] || '' : ''}${task.priority}${utils.COLORS.reset} (${priorityInfo?.label || 'Unknown'})
+  Phase: ${task.phase} - ${phaseInfo?.name || 'Unknown'}
+
+${utils.COLORS.bold}Description${utils.COLORS.reset}
+  ${task.description || utils.COLORS.dim + 'No description' + utils.COLORS.reset}
+
+${utils.COLORS.bold}Details${utils.COLORS.reset}
+  Created: ${utils.formatRelativeTime(new Date(task.created))}
+  Updated: ${utils.formatRelativeTime(new Date(task.updated))}
+  ${task.assignee ? `Assignee: ${task.assignee}` : ''}
+  ${task.tags.length > 0 ? `Tags: ${task.tags.join(', ')}` : ''}
+`);
+
+  // Show lifecycle progress
+  console.log(`${utils.COLORS.bold}Lifecycle Progress${utils.COLORS.reset}`);
+  const currentPhaseIndex = LIFECYCLE_PHASES.findIndex(p => p.id === task.phase);
+
+  for (let i = 0; i < LIFECYCLE_PHASES.length; i++) {
+    const phase = LIFECYCLE_PHASES[i];
+    if (!phase) continue;
+    let icon: string, color: string;
+
+    if (i < currentPhaseIndex) {
+      icon = '✓';
+      color = utils.COLORS.green;
+    } else if (i === currentPhaseIndex) {
+      icon = '●';
+      color = utils.COLORS.cyan;
+    } else {
+      icon = '○';
+      color = utils.COLORS.dim;
+    }
+
+    console.log(`  ${color}${icon} ${phase.name}${utils.COLORS.reset}`);
+  }
+
+  // Show notes
+  if (task.notes.length > 0) {
+    console.log(`\n${utils.COLORS.bold}Notes${utils.COLORS.reset}`);
+    for (const note of task.notes.slice(-5)) {
+      console.log(`  ${utils.COLORS.dim}${note.timestamp}${utils.COLORS.reset}`);
+      console.log(`  ${note.content}`);
+      console.log();
+    }
+  }
+
+  // Show blocking info
+  if (task.blockedBy.length > 0) {
+    console.log(`${utils.COLORS.red}Blocked by: ${task.blockedBy.map(id => `#${id}`).join(', ')}${utils.COLORS.reset}`);
+  }
+  if (task.blocks.length > 0) {
+    console.log(`${utils.COLORS.yellow}Blocks: ${task.blocks.map(id => `#${id}`).join(', ')}${utils.COLORS.reset}`);
+  }
+}
+
+/**
+ * Update task status
+ */
+export function updateTaskStatus(taskId: string, newStatus: string): void {
+  const cfg = config.load();
+  const projectRoot = cfg._projectRoot;
+  const data = loadTasks(projectRoot);
+
+  const task = data.tasks.find(t => t.id === parseInt(taskId));
+
+  if (!task) {
+    utils.print.error(`Task #${taskId} not found`);
+    return;
+  }
+
+  if (!TASK_STATUS[newStatus]) {
+    utils.print.error(`Invalid status: ${newStatus}`);
+    utils.print.dim(`Valid statuses: ${Object.keys(TASK_STATUS).join(', ')}`);
+    return;
+  }
+
+  const oldStatus = task.status;
+  task.status = newStatus;
+  task.updated = new Date().toISOString();
+
+  saveTasks(projectRoot, data);
+
+  const oldInfo = TASK_STATUS[oldStatus];
+  const newInfo = TASK_STATUS[newStatus];
+
+  if (oldInfo && newInfo) {
+    utils.print.success(`Task #${taskId}: ${oldInfo.emoji} ${oldInfo.label} → ${newInfo.emoji} ${newInfo.label}`);
+  }
+}
+
+/**
+ * Advance task to next phase
+ */
+export function advancePhase(taskId: string): void {
+  const cfg = config.load();
+  const projectRoot = cfg._projectRoot;
+  const data = loadTasks(projectRoot);
+
+  const task = data.tasks.find(t => t.id === parseInt(taskId));
+
+  if (!task) {
+    utils.print.error(`Task #${taskId} not found`);
+    return;
+  }
+
+  const currentIndex = LIFECYCLE_PHASES.findIndex(p => p.id === task.phase);
+
+  if (currentIndex === LIFECYCLE_PHASES.length - 1) {
+    utils.print.success(`Task #${taskId} is already at final phase`);
+    return;
+  }
+
+  const nextPhase = LIFECYCLE_PHASES[currentIndex + 1];
+  if (!nextPhase) {
+    utils.print.error(`Cannot advance phase`);
+    return;
+  }
+
+  const oldPhase = task.phase;
+  task.phase = nextPhase.id;
+  task.updated = new Date().toISOString();
+
+  // Auto-update status based on phase
+  if (nextPhase.id === 'implement' && task.status === 'ready') {
+    task.status = 'in-progress';
+  } else if (nextPhase.id === 'review') {
+    task.status = 'review';
+  } else if (nextPhase.id === 'test') {
+    task.status = 'testing';
+  } else if (nextPhase.id === 'verify') {
+    task.status = 'done';
+  }
+
+  saveTasks(projectRoot, data);
+
+  utils.print.success(`Task #${taskId}: ${oldPhase} → ${nextPhase.id}`);
+  console.log(`${utils.COLORS.dim}${nextPhase.name}: ${nextPhase.description}${utils.COLORS.reset}`);
+}
+
+/**
+ * Add note to task
+ */
+function addNote(taskId: string, noteContent: string): void {
+  const cfg = config.load();
+  const projectRoot = cfg._projectRoot;
+  const data = loadTasks(projectRoot);
+
+  const task = data.tasks.find(t => t.id === parseInt(taskId));
+
+  if (!task) {
+    utils.print.error(`Task #${taskId} not found`);
+    return;
+  }
+
+  task.notes.push({
+    timestamp: new Date().toISOString(),
+    content: noteContent
+  });
+  task.updated = new Date().toISOString();
+
+  saveTasks(projectRoot, data);
+
+  utils.print.success(`Added note to task #${taskId}`);
+}
+
+/**
+ * Set task priority
+ */
+function setPriority(taskId: string, priority: string): void {
+  const cfg = config.load();
+  const projectRoot = cfg._projectRoot;
+  const data = loadTasks(projectRoot);
+
+  const task = data.tasks.find(t => t.id === parseInt(taskId));
+
+  if (!task) {
+    utils.print.error(`Task #${taskId} not found`);
+    return;
+  }
+
+  if (!TASK_PRIORITY[priority]) {
+    utils.print.error(`Invalid priority: ${priority}`);
+    utils.print.dim(`Valid priorities: ${Object.keys(TASK_PRIORITY).join(', ')}`);
+    return;
+  }
+
+  task.priority = priority;
+  task.updated = new Date().toISOString();
+
+  saveTasks(projectRoot, data);
+
+  const priorityInfo = TASK_PRIORITY[priority];
+  if (priorityInfo) {
+    utils.print.success(`Task #${taskId} priority set to ${priority} (${priorityInfo.label})`);
+  }
+}
+
+/**
+ * Delete a task
+ */
+function deleteTask(taskId: string): void {
+  const cfg = config.load();
+  const projectRoot = cfg._projectRoot;
+  const data = loadTasks(projectRoot);
+
+  const taskIndex = data.tasks.findIndex(t => t.id === parseInt(taskId));
+
+  if (taskIndex === -1) {
+    utils.print.error(`Task #${taskId} not found`);
+    return;
+  }
+
+  const task = data.tasks[taskIndex];
+  if (!task) {
+    utils.print.error(`Task #${taskId} not found`);
+    return;
+  }
+
+  data.tasks.splice(taskIndex, 1);
+
+  saveTasks(projectRoot, data);
+
+  utils.print.success(`Deleted task #${taskId}: ${task.title}`);
+}
+
+/**
+ * Show lifecycle phases
+ */
+function showLifecycle(): void {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Task Lifecycle Phases${utils.COLORS.reset}
+${utils.COLORS.dim}11-phase development workflow${utils.COLORS.reset}
+`);
+
+  for (let i = 0; i < LIFECYCLE_PHASES.length; i++) {
+    const phase = LIFECYCLE_PHASES[i];
+    if (!phase) continue;
+    console.log(`  ${utils.COLORS.cyan}${i + 1}. ${phase.name}${utils.COLORS.reset}`);
+    console.log(`     ${utils.COLORS.dim}${phase.description}${utils.COLORS.reset}`);
+  }
+
+  console.log(`
+${utils.COLORS.bold}Usage${utils.COLORS.reset}
+  ${utils.COLORS.dim}bootspring task advance <id>${utils.COLORS.reset}  Move to next phase
+  ${utils.COLORS.dim}bootspring task show <id>${utils.COLORS.reset}     See current phase
+`);
+}
+
+/**
+ * Show task help
+ */
+function showHelp(): void {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Task${utils.COLORS.reset}
+${utils.COLORS.dim}Manage development tasks with lifecycle tracking${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring task <command> [args] [options]
+
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}list${utils.COLORS.reset}              List all tasks
+  ${utils.COLORS.cyan}create${utils.COLORS.reset}            Create a new task
+  ${utils.COLORS.cyan}show${utils.COLORS.reset} <id>         Show task details
+  ${utils.COLORS.cyan}status${utils.COLORS.reset} <id> <s>   Update task status
+  ${utils.COLORS.cyan}advance${utils.COLORS.reset} <id>      Advance to next phase
+  ${utils.COLORS.cyan}priority${utils.COLORS.reset} <id> <p> Set task priority
+  ${utils.COLORS.cyan}note${utils.COLORS.reset} <id> <text>  Add note to task
+  ${utils.COLORS.cyan}delete${utils.COLORS.reset} <id>       Delete a task
+  ${utils.COLORS.cyan}lifecycle${utils.COLORS.reset}         Show lifecycle phases
+
+${utils.COLORS.bold}Options:${utils.COLORS.reset}
+  --title <title>       Task title
+  --description <desc>  Task description
+  --priority <P0-P3>    Task priority
+  --status <status>     Filter by status
+  --tag <tag>           Filter by tag
+  --all                 Include completed tasks
+
+${utils.COLORS.bold}Statuses:${utils.COLORS.reset}
+  draft, ready, in-progress, review, testing, done, blocked
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring task create --title "Add auth" --priority P1
+  bootspring task list --status in-progress
+  bootspring task status 1 in-progress
+  bootspring task advance 1
+  bootspring task note 1 "Completed API integration"
+`);
+}
+
+/**
+ * Run task command
+ */
+export async function run(args: string[]): Promise<void> {
+  const parsedArgs = utils.parseArgs(args) as ParsedArgs;
+  const subcommand = parsedArgs._[0] || 'list';
+  const subargs = parsedArgs._.slice(1);
+
+  switch (subcommand) {
+    case 'list':
+    case 'ls':
+      listTasks({
+        status: parsedArgs.status,
+        priority: parsedArgs.priority,
+        tag: parsedArgs.tag,
+        all: parsedArgs.all
+      });
+      break;
+
+    case 'create':
+    case 'new':
+    case 'add':
+      createTask({
+        title: parsedArgs.title || subargs.join(' '),
+        description: parsedArgs.description,
+        priority: parsedArgs.priority,
+        tags: parsedArgs.tags ? parsedArgs.tags.split(',') : [],
+        estimate: parsedArgs.estimate
+      });
+      break;
+
+    case 'show':
+    case 'view': {
+      const showId = subargs[0];
+      if (!showId) {
+        utils.print.error('Please specify a task ID');
+        utils.print.dim('Usage: bootspring task show <id>');
+        return;
+      }
+      showTask(showId);
+      break;
+    }
+
+    case 'status': {
+      const statusId = subargs[0];
+      const statusValue = subargs[1];
+      if (!statusId || !statusValue) {
+        utils.print.error('Please specify task ID and new status');
+        utils.print.dim('Usage: bootspring task status <id> <status>');
+        return;
+      }
+      updateTaskStatus(statusId, statusValue);
+      break;
+    }
+
+    case 'advance':
+    case 'next': {
+      const advanceId = subargs[0];
+      if (!advanceId) {
+        utils.print.error('Please specify a task ID');
+        utils.print.dim('Usage: bootspring task advance <id>');
+        return;
+      }
+      advancePhase(advanceId);
+      break;
+    }
+
+    case 'priority':
+    case 'prio': {
+      const prioId = subargs[0];
+      const prioValue = subargs[1];
+      if (!prioId || !prioValue) {
+        utils.print.error('Please specify task ID and priority');
+        utils.print.dim('Usage: bootspring task priority <id> <P0-P3>');
+        return;
+      }
+      setPriority(prioId, prioValue.toUpperCase());
+      break;
+    }
+
+    case 'note': {
+      const noteId = subargs[0];
+      if (!noteId) {
+        utils.print.error('Please specify a task ID');
+        utils.print.dim('Usage: bootspring task note <id> <text>');
+        return;
+      }
+      const noteContent = subargs.slice(1).join(' ') || parsedArgs.text;
+      if (!noteContent) {
+        utils.print.error('Please provide note content');
+        return;
+      }
+      addNote(noteId, noteContent);
+      break;
+    }
+
+    case 'delete':
+    case 'rm':
+    case 'remove': {
+      const deleteId = subargs[0];
+      if (!deleteId) {
+        utils.print.error('Please specify a task ID');
+        utils.print.dim('Usage: bootspring task delete <id>');
+        return;
+      }
+      deleteTask(deleteId);
+      break;
+    }
+
+    case 'lifecycle':
+    case 'phases':
+      showLifecycle();
+      break;
+
+    case 'help':
+    case '-h':
+    case '--help':
+      showHelp();
+      break;
+
+    default:
+      // Check if it's a task ID (number)
+      if (/^\d+$/.test(subcommand)) {
+        showTask(subcommand);
+      } else {
+        utils.print.error(`Unknown subcommand: ${subcommand}`);
+        showHelp();
+      }
+  }
+}