claude-autopm 2.5.0 → 2.6.0

package/bin/autopm.js

@@ -184,6 +184,8 @@ function main() {
     .command(require('../lib/cli/commands/epic'))
     // Issue management command (STANDALONE)
     .command(require('../lib/cli/commands/issue'))
+    // PM workflow commands (STANDALONE)
+    .command(require('../lib/cli/commands/pm'))
     // PRD management command (STANDALONE)
     .command(require('../lib/cli/commands/prd'))
     // Task management command (STANDALONE)

package/lib/cli/commands/pm.js

@@ -0,0 +1,528 @@
+/**
+ * CLI PM (Project Management) Commands
+ *
+ * Provides workflow and project management commands for ClaudeAutoPM.
+ * Implements subcommands for workflow analysis and task prioritization.
+ *
+ * Commands:
+ * - next: Get next priority task based on dependencies and priorities
+ * - what-next: AI-powered suggestions for next steps
+ * - standup: Generate daily standup report
+ * - status: Project status overview and health
+ * - in-progress: Show all active tasks
+ * - blocked: Show all blocked tasks
+ *
+ * @module cli/commands/pm
+ * @requires ../../services/WorkflowService
+ * @requires ../../services/IssueService
+ * @requires ../../services/EpicService
+ * @requires fs-extra
+ * @requires ora
+ * @requires chalk
+ * @requires path
+ */
+
+const WorkflowService = require('../../services/WorkflowService');
+const IssueService = require('../../services/IssueService');
+const EpicService = require('../../services/EpicService');
+const fs = require('fs-extra');
+const ora = require('ora');
+const chalk = require('chalk');
+const path = require('path');
+
+/**
+ * Get service instances
+ * @returns {Object} Service instances
+ */
+async function getServices() {
+  const issueService = new IssueService();
+  const epicService = new EpicService();
+  const workflowService = new WorkflowService({
+    issueService,
+    epicService
+  });
+  return { workflowService, issueService, epicService };
+}
+
+/**
+ * PM Next - Get next priority task
+ * @param {Object} argv - Command arguments
+ */
+async function pmNext(argv) {
+  const spinner = ora('Finding next priority task...').start();
+
+  try {
+    const { workflowService } = await getServices();
+    const nextTask = await workflowService.getNextTask();
+
+    if (!nextTask) {
+      spinner.info(chalk.yellow('No available tasks found'));
+
+      console.log(chalk.yellow('\n⚠️  No tasks available to start\n'));
+      console.log(chalk.bold('Possible reasons:'));
+      console.log('  • All tasks are completed or in-progress');
+      console.log('  • Remaining tasks are blocked by dependencies');
+      console.log('  • No tasks have been created yet\n');
+
+      console.log(chalk.bold('💡 Suggestions:'));
+      console.log(`  ${chalk.cyan('1.')} Check blocked tasks:  ${chalk.yellow('autopm pm blocked')}`);
+      console.log(`  ${chalk.cyan('2.')} Check active work:    ${chalk.yellow('autopm pm in-progress')}`);
+      console.log(`  ${chalk.cyan('3.')} View all tasks:       ${chalk.yellow('autopm issue list')}\n`);
+      return;
+    }
+
+    spinner.succeed(chalk.green('Found next task'));
+
+    // Display task with reasoning
+    console.log(chalk.cyan('\n📋 Next Task:\n'));
+    console.log(chalk.gray('─'.repeat(60)) + '\n');
+
+    console.log(chalk.bold(`#${nextTask.id}: ${nextTask.title}`));
+    if (nextTask.epic) {
+      console.log(chalk.gray(`Epic: ${nextTask.epic}`));
+    }
+    console.log(chalk.gray(`Priority: ${nextTask.priority || 'P2'}`));
+    if (nextTask.effort) {
+      console.log(chalk.gray(`Estimated effort: ${nextTask.effort}`));
+    }
+
+    console.log(chalk.yellow(`\n💡 Why this task?\n${nextTask.reasoning}`));
+
+    console.log('\n' + chalk.gray('─'.repeat(60)) + '\n');
+
+    // TDD Reminder
+    console.log(chalk.red('⚠️  TDD REMINDER - Before starting work:\n'));
+    console.log(chalk.dim('   🚨 ALWAYS follow Test-Driven Development:'));
+    console.log(chalk.dim('   1. RED: Write failing test first'));
+    console.log(chalk.dim('   2. GREEN: Write minimal code to pass'));
+    console.log(chalk.dim('   3. REFACTOR: Clean up while keeping tests green\n'));
+
+    console.log(chalk.green('✅ Ready to start?'));
+    console.log(`   ${chalk.yellow(`autopm issue start ${nextTask.id}`)}\n`);
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to find next task'));
+    console.error(chalk.red(`\nError: ${error.message}\n`));
+  }
+}
+
+/**
+ * PM What-Next - AI-powered next step suggestions
+ * @param {Object} argv - Command arguments
+ */
+async function pmWhatNext(argv) {
+  const spinner = ora('Analyzing project state...').start();
+
+  try {
+    const { workflowService } = await getServices();
+    const result = await workflowService.getWhatNext();
+
+    spinner.succeed(chalk.green('Analysis complete'));
+
+    console.log(chalk.cyan('\n🤔 What Should You Work On Next?\n'));
+    console.log(chalk.gray('='.repeat(60)) + '\n');
+
+    // Display project state
+    console.log(chalk.bold('📊 Current Project State:\n'));
+    console.log(`  PRDs:          ${result.projectState.prdCount}`);
+    console.log(`  Epics:         ${result.projectState.epicCount}`);
+    console.log(`  Total Issues:  ${result.projectState.issueCount}`);
+    console.log(`  Open:          ${result.projectState.openIssues}`);
+    console.log(`  In Progress:   ${result.projectState.inProgressIssues}`);
+    console.log(`  Blocked:       ${result.projectState.blockedIssues}\n`);
+
+    console.log(chalk.gray('─'.repeat(60)) + '\n');
+
+    // Display suggestions
+    console.log(chalk.bold('💡 Suggested Next Steps:\n'));
+
+    result.suggestions.forEach((suggestion, index) => {
+      const marker = suggestion.recommended ? '⭐' : '○';
+      const priorityColor = suggestion.priority === 'high' ? chalk.red : chalk.yellow;
+
+      console.log(`${index + 1}. ${marker} ${chalk.bold(suggestion.title)}`);
+      console.log(`   ${suggestion.description}`);
+      console.log(`   ${priorityColor(`Priority: ${suggestion.priority.toUpperCase()}`)}`);
+
+      if (Array.isArray(suggestion.commands)) {
+        suggestion.commands.forEach(cmd => {
+          console.log(`   ${chalk.yellow(cmd)}`);
+        });
+      }
+
+      console.log(`   ${chalk.dim(`💭 ${suggestion.why}`)}\n`);
+    });
+
+    if (result.suggestions.length === 0) {
+      console.log(chalk.yellow('  No specific suggestions at this time\n'));
+    }
+
+    console.log(chalk.gray('─'.repeat(60)) + '\n');
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to analyze project'));
+    console.error(chalk.red(`\nError: ${error.message}\n`));
+  }
+}
+
+/**
+ * PM Standup - Generate daily standup report
+ * @param {Object} argv - Command arguments
+ */
+async function pmStandup(argv) {
+  const spinner = ora('Generating standup report...').start();
+
+  try {
+    const { workflowService } = await getServices();
+    const report = await workflowService.generateStandup();
+
+    spinner.succeed(chalk.green('Standup report generated'));
+
+    console.log(chalk.cyan(`\n📅 Daily Standup - ${report.date}\n`));
+    console.log(chalk.gray('='.repeat(60)) + '\n');
+
+    // Yesterday
+    console.log(chalk.bold('✅ Yesterday (Completed):\n'));
+    if (report.yesterday.length > 0) {
+      report.yesterday.forEach(task => {
+        console.log(`   #${task.id} - ${task.title}`);
+        if (task.epic) {
+          console.log(`   ${chalk.gray(`Epic: ${task.epic}`)}`);
+        }
+        console.log('');
+      });
+    } else {
+      console.log(chalk.gray('   No tasks completed yesterday\n'));
+    }
+
+    console.log(chalk.gray('─'.repeat(60)) + '\n');
+
+    // Today
+    console.log(chalk.bold('🚀 Today (In Progress):\n'));
+    if (report.today.length > 0) {
+      report.today.forEach(task => {
+        console.log(`   #${task.id} - ${task.title || 'Unnamed task'}`);
+        if (task.stale) {
+          console.log(`   ${chalk.red('⚠️  STALE (>3 days in progress)')}`);
+        }
+        console.log('');
+      });
+    } else {
+      console.log(chalk.gray('   No tasks currently in progress\n'));
+    }
+
+    console.log(chalk.gray('─'.repeat(60)) + '\n');
+
+    // Blockers
+    console.log(chalk.bold('🚫 Blockers:\n'));
+    if (report.blockers.length > 0) {
+      report.blockers.forEach(task => {
+        console.log(`   #${task.id} - ${task.title || 'Unnamed task'}`);
+        console.log(`   ${chalk.red(`Blocked by: ${task.reason}`)}`);
+        if (task.daysBlocked) {
+          console.log(`   ${chalk.gray(`Blocked for: ${task.daysBlocked} days`)}`);
+        }
+        console.log('');
+      });
+    } else {
+      console.log(chalk.green('   No blockers! 🎉\n'));
+    }
+
+    console.log(chalk.gray('─'.repeat(60)) + '\n');
+
+    // Metrics
+    console.log(chalk.bold('📊 Metrics:\n'));
+    console.log(`  Velocity:        ${report.velocity} tasks/day (7-day avg)`);
+    console.log(`  Sprint Progress: ${report.sprintProgress.completed}/${report.sprintProgress.total} (${report.sprintProgress.percentage}%)\n`);
+
+    console.log(chalk.gray('='.repeat(60)) + '\n');
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to generate standup'));
+    console.error(chalk.red(`\nError: ${error.message}\n`));
+  }
+}
+
+/**
+ * PM Status - Project status overview
+ * @param {Object} argv - Command arguments
+ */
+async function pmStatus(argv) {
+  const spinner = ora('Analyzing project status...').start();
+
+  try {
+    const { workflowService } = await getServices();
+    const status = await workflowService.getProjectStatus();
+
+    spinner.succeed(chalk.green('Status analysis complete'));
+
+    console.log(chalk.cyan('\n📊 Project Status Overview\n'));
+    console.log(chalk.gray('='.repeat(60)) + '\n');
+
+    // Epics
+    console.log(chalk.bold('📚 Epics:\n'));
+    console.log(`   Backlog:       ${status.epics.backlog}`);
+    console.log(`   Planning:      ${status.epics.planning}`);
+    console.log(`   In Progress:   ${status.epics.inProgress}`);
+    console.log(`   Completed:     ${status.epics.completed}`);
+    console.log(`   ${chalk.bold('Total:')}         ${status.epics.total}\n`);
+
+    console.log(chalk.gray('─'.repeat(60)) + '\n');
+
+    // Issues
+    console.log(chalk.bold('📋 Issues:\n'));
+    console.log(`   Open:          ${status.issues.open}`);
+    console.log(`   In Progress:   ${status.issues.inProgress}`);
+    console.log(`   Blocked:       ${chalk.red(status.issues.blocked)}`);
+    console.log(`   Closed:        ${chalk.green(status.issues.closed)}`);
+    console.log(`   ${chalk.bold('Total:')}         ${status.issues.total}\n`);
+
+    console.log(chalk.gray('─'.repeat(60)) + '\n');
+
+    // Progress
+    console.log(chalk.bold('📈 Progress:\n'));
+    console.log(`   Overall:       ${status.progress.overall}% complete`);
+    console.log(`   Velocity:      ${status.progress.velocity} tasks/day\n`);
+
+    console.log(chalk.gray('─'.repeat(60)) + '\n');
+
+    // Health
+    const healthColor = status.health === 'ON_TRACK' ? chalk.green : chalk.red;
+    console.log(chalk.bold('🎯 Health: ') + healthColor(status.health) + '\n');
+
+    if (status.recommendations.length > 0) {
+      console.log(chalk.bold('💡 Recommendations:\n'));
+      status.recommendations.forEach((rec, index) => {
+        console.log(`   ${index + 1}. ${rec}`);
+      });
+      console.log('');
+    }
+
+    console.log(chalk.gray('='.repeat(60)) + '\n');
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to analyze status'));
+    console.error(chalk.red(`\nError: ${error.message}\n`));
+  }
+}
+
+/**
+ * PM In-Progress - Show all active tasks
+ * @param {Object} argv - Command arguments
+ */
+async function pmInProgress(argv) {
+  const spinner = ora('Finding active tasks...').start();
+
+  try {
+    const { workflowService } = await getServices();
+    const tasks = await workflowService.getInProgressTasks();
+
+    spinner.succeed(chalk.green('Active tasks found'));
+
+    console.log(chalk.cyan('\n🚀 In Progress Tasks\n'));
+    console.log(chalk.gray('='.repeat(60)) + '\n');
+
+    if (tasks.length === 0) {
+      console.log(chalk.yellow('No tasks currently in progress\n'));
+      console.log(chalk.bold('💡 Ready to start work?'));
+      console.log(`   ${chalk.yellow('autopm pm next')}\n`);
+      return;
+    }
+
+    // Group by epic if available
+    const byEpic = {};
+    tasks.forEach(task => {
+      const epic = task.epic || 'No Epic';
+      if (!byEpic[epic]) {
+        byEpic[epic] = [];
+      }
+      byEpic[epic].push(task);
+    });
+
+    Object.keys(byEpic).forEach(epicName => {
+      console.log(chalk.bold(`Epic: ${epicName}\n`));
+
+      byEpic[epicName].forEach(task => {
+        console.log(`   #${task.id} - ${task.title || 'Unnamed task'}`);
+        if (task.started) {
+          console.log(`   ${chalk.gray(`Started: ${new Date(task.started).toLocaleDateString()}`)}`);
+        }
+        if (task.assignee) {
+          console.log(`   ${chalk.gray(`Assignee: ${task.assignee}`)}`);
+        }
+        if (task.stale) {
+          console.log(`   ${chalk.red('⚠️  STALE (>3 days without update)')}`);
+          console.log(`   ${chalk.yellow('💡 Consider checking in or splitting task')}`);
+        }
+        console.log('');
+      });
+    });
+
+    // Summary
+    const staleCount = tasks.filter(t => t.stale).length;
+    console.log(chalk.gray('─'.repeat(60)) + '\n');
+    console.log(chalk.bold('📊 Summary:\n'));
+    console.log(`   Total active: ${tasks.length} tasks`);
+    if (staleCount > 0) {
+      console.log(`   ${chalk.red(`⚠️  Stale: ${staleCount} tasks (>3 days)`)}`);
+    }
+    console.log('');
+
+    console.log(chalk.gray('='.repeat(60)) + '\n');
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to find active tasks'));
+    console.error(chalk.red(`\nError: ${error.message}\n`));
+  }
+}
+
+/**
+ * PM Blocked - Show all blocked tasks
+ * @param {Object} argv - Command arguments
+ */
+async function pmBlocked(argv) {
+  const spinner = ora('Finding blocked tasks...').start();
+
+  try {
+    const { workflowService } = await getServices();
+    const tasks = await workflowService.getBlockedTasks();
+
+    spinner.succeed(chalk.green('Blocked tasks analyzed'));
+
+    console.log(chalk.cyan('\n🚫 Blocked Tasks\n'));
+    console.log(chalk.gray('='.repeat(60)) + '\n');
+
+    if (tasks.length === 0) {
+      console.log(chalk.green('✅ No blocked tasks! All tasks are unblocked.\n'));
+      console.log(chalk.bold('💡 Ready to work?'));
+      console.log(`   ${chalk.yellow('autopm pm next')}\n`);
+      return;
+    }
+
+    tasks.forEach((task, index) => {
+      console.log(`${index + 1}. ${chalk.bold(`#${task.id} - ${task.title || 'Unnamed task'}`)}`);
+      console.log(`   ${chalk.red(`Blocked by: ${task.reason}`)}`);
+      if (task.daysBlocked !== undefined) {
+        const daysLabel = task.daysBlocked === 1 ? 'day' : 'days';
+        const daysColor = task.daysBlocked > 3 ? chalk.red : chalk.yellow;
+        console.log(`   ${daysColor(`Blocked since: ${task.daysBlocked} ${daysLabel} ago`)}`);
+      }
+      if (task.suggestedAction) {
+        console.log(`   ${chalk.yellow(`💡 Action: ${task.suggestedAction}`)}`);
+      }
+      console.log('');
+    });
+
+    // Summary
+    const criticalCount = tasks.filter(t => t.daysBlocked > 3).length;
+    console.log(chalk.gray('─'.repeat(60)) + '\n');
+    console.log(chalk.bold('📊 Summary:\n'));
+    console.log(`   Total blocked: ${tasks.length} tasks`);
+    if (criticalCount > 0) {
+      console.log(`   ${chalk.red(`🔴 Critical: ${criticalCount} tasks (>3 days)`)}`);
+    }
+    console.log('');
+
+    console.log(chalk.bold('💡 Recommendations:\n'));
+    console.log('   1. Unblock critical tasks first (>3 days)');
+    console.log('   2. Review and resolve dependencies');
+    console.log('   3. Update stakeholders on delays\n');
+
+    console.log(chalk.gray('='.repeat(60)) + '\n');
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to find blocked tasks'));
+    console.error(chalk.red(`\nError: ${error.message}\n`));
+  }
+}
+
+/**
+ * Command builder - registers all subcommands
+ * @param {Object} yargs - Yargs instance
+ * @returns {Object} Configured yargs instance
+ */
+function builder(yargs) {
+  return yargs
+    .command(
+      'next',
+      'Get next priority task',
+      (yargs) => {
+        return yargs
+          .example('autopm pm next', 'Show next priority task to work on');
+      },
+      pmNext
+    )
+    .command(
+      'what-next',
+      'AI-powered next step suggestions',
+      (yargs) => {
+        return yargs
+          .example('autopm pm what-next', 'Get intelligent suggestions for next steps');
+      },
+      pmWhatNext
+    )
+    .command(
+      'standup',
+      'Generate daily standup report',
+      (yargs) => {
+        return yargs
+          .example('autopm pm standup', 'Generate daily standup summary');
+      },
+      pmStandup
+    )
+    .command(
+      'status',
+      'Project status overview',
+      (yargs) => {
+        return yargs
+          .example('autopm pm status', 'Show overall project health and metrics');
+      },
+      pmStatus
+    )
+    .command(
+      'in-progress',
+      'Show all active tasks',
+      (yargs) => {
+        return yargs
+          .example('autopm pm in-progress', 'List all tasks currently being worked on');
+      },
+      pmInProgress
+    )
+    .command(
+      'blocked',
+      'Show all blocked tasks',
+      (yargs) => {
+        return yargs
+          .example('autopm pm blocked', 'List all blocked tasks with reasons');
+      },
+      pmBlocked
+    )
+    .demandCommand(1, 'You must specify a pm command')
+    .strictCommands()
+    .help();
+}
+
+/**
+ * Command export
+ */
+module.exports = {
+  command: 'pm',
+  describe: 'Project management and workflow commands',
+  builder,
+  handler: (argv) => {
+    if (!argv._.includes('pm') || argv._.length === 1) {
+      console.log(chalk.yellow('\nPlease specify a pm command\n'));
+      console.log('Usage: autopm pm <command>\n');
+      console.log('Available commands:');
+      console.log('  next              Get next priority task');
+      console.log('  what-next         AI-powered next step suggestions');
+      console.log('  standup           Generate daily standup report');
+      console.log('  status            Project status overview');
+      console.log('  in-progress       Show all active tasks');
+      console.log('  blocked           Show all blocked tasks');
+      console.log('\nUse: autopm pm <command> --help for more info\n');
+    }
+  },
+  handlers: {
+    next: pmNext,
+    whatNext: pmWhatNext,
+    standup: pmStandup,
+    status: pmStatus,
+    inProgress: pmInProgress,
+    blocked: pmBlocked
+  }
+};

package/lib/services/WorkflowService.js

@@ -0,0 +1,677 @@
+/**
+ * WorkflowService - Project Management and Workflow Service
+ *
+ * Pure service layer for workflow operations following ClaudeAutoPM patterns.
+ * Follows 3-layer architecture: Service (logic) -> No direct I/O
+ *
+ * Provides comprehensive workflow management:
+ *
+ * 1. Task Prioritization & Selection (2 methods):
+ *    - getNextTask: Get next priority task based on dependencies, priorities, status
+ *    - getWhatNext: AI-powered suggestions for next steps
+ *
+ * 2. Project Reporting (3 methods):
+ *    - generateStandup: Generate daily standup report
+ *    - getProjectStatus: Overall project health and metrics
+ *    - getInProgressTasks: All currently active tasks
+ *
+ * 3. Bottleneck Analysis (2 methods):
+ *    - getBlockedTasks: All blocked tasks with reasons
+ *    - analyzeBottlenecks: Identify workflow bottlenecks
+ *
+ * 4. Metrics & Analysis (3 methods):
+ *    - calculateVelocity: Calculate team/project velocity
+ *    - prioritizeTasks: Task prioritization logic
+ *    - resolveDependencies: Check and resolve task dependencies
+ *
+ * Documentation Queries:
+ * - mcp://context7/agile/workflow-management - Agile workflow patterns
+ * - mcp://context7/agile/velocity-tracking - Velocity and metrics
+ * - mcp://context7/project-management/standup - Daily standup best practices
+ * - mcp://context7/project-management/bottlenecks - Bottleneck identification
+ */
+
+class WorkflowService {
+  /**
+   * Create a new WorkflowService instance
+   *
+   * @param {Object} options - Configuration options
+   * @param {Object} options.issueService - IssueService instance (required)
+   * @param {Object} options.epicService - EpicService instance (required)
+   * @param {Object} [options.prdService] - PRDService instance (optional)
+   */
+  constructor(options = {}) {
+    if (!options.issueService) {
+      throw new Error('IssueService is required');
+    }
+    if (!options.epicService) {
+      throw new Error('EpicService is required');
+    }
+
+    this.issueService = options.issueService;
+    this.epicService = options.epicService;
+    this.prdService = options.prdService;
+
+    // Priority order: P0 (highest) -> P1 -> P2 -> P3 (lowest)
+    this.priorityOrder = { 'P0': 0, 'P1': 1, 'P2': 2, 'P3': 3 };
+  }
+
+  // ==========================================
+  // 1. TASK PRIORITIZATION & SELECTION
+  // ==========================================
+
+  /**
+   * Get next priority task based on dependencies, priorities, status
+   *
+   * Algorithm:
+   * 1. Filter open tasks only
+   * 2. Check dependencies (skip if any are open)
+   * 3. Sort by priority (P0 > P1 > P2 > P3)
+   * 4. Within same priority, oldest first
+   * 5. Return top task with reasoning
+   *
+   * @returns {Promise<Object|null>} Next task with reasoning, or null if none available
+   */
+  async getNextTask() {
+    try {
+      // Get all issues
+      const allIssues = await this.issueService.listIssues();
+      if (!allIssues || allIssues.length === 0) {
+        return null;
+      }
+
+      // Filter open tasks
+      const openTasks = allIssues.filter(issue => {
+        const status = this.issueService.categorizeStatus(issue.status);
+        return status === 'open';
+      });
+
+      if (openTasks.length === 0) {
+        return null;
+      }
+
+      // Check dependencies for each task
+      const availableTasks = [];
+      for (const task of openTasks) {
+        const deps = await this.resolveDependencies(task.id);
+        if (deps.resolved) {
+          availableTasks.push(task);
+        }
+      }
+
+      if (availableTasks.length === 0) {
+        return null;
+      }
+
+      // Sort by priority
+      const prioritized = this.prioritizeTasks(availableTasks);
+
+      // Get first task
+      const nextTask = prioritized[0];
+
+      // Generate reasoning
+      const reasoning = this._generateTaskReasoning(nextTask, availableTasks);
+
+      return {
+        id: nextTask.id,
+        title: nextTask.title,
+        status: nextTask.status,
+        priority: nextTask.priority,
+        epic: nextTask.epic,
+        effort: nextTask.effort,
+        reasoning
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Generate reasoning for why a task is recommended
+   * @private
+   */
+  _generateTaskReasoning(task, allAvailable) {
+    const reasons = [];
+
+    // Priority reasoning
+    const priority = task.priority || 'P2';
+    if (priority === 'P0') {
+      reasons.push('Highest priority (P0) - critical task');
+    } else if (priority === 'P1') {
+      reasons.push('High priority (P1) - important task');
+    }
+
+    // Dependencies resolved
+    reasons.push('All dependencies completed');
+
+    // Unblocked
+    reasons.push('No blocking issues');
+
+    // Count of available alternatives
+    if (allAvailable.length > 1) {
+      reasons.push(`${allAvailable.length - 1} other tasks also available`);
+    }
+
+    return reasons.join('. ') + '.';
+  }
+
+  /**
+   * AI-powered suggestions for next steps (what to work on)
+   *
+   * Analyzes project state and suggests contextual next actions:
+   * - No PRDs: Create first PRD
+   * - No epics: Parse PRD into epic
+   * - No tasks: Decompose epic
+   * - Tasks available: Start working
+   * - Tasks in progress: Continue work
+   *
+   * @returns {Promise<Object>} Suggestions with project state
+   */
+  async getWhatNext() {
+    const projectState = await this._analyzeProjectState();
+    const suggestions = this._generateSuggestions(projectState);
+
+    return {
+      projectState,
+      suggestions
+    };
+  }
+
+  /**
+   * Analyze current project state
+   * @private
+   */
+  async _analyzeProjectState() {
+    const state = {
+      prdCount: 0,
+      epicCount: 0,
+      issueCount: 0,
+      openIssues: 0,
+      inProgressIssues: 0,
+      blockedIssues: 0
+    };
+
+    try {
+      // Count PRDs
+      if (this.prdService && this.prdService.listPRDs) {
+        const prds = await this.prdService.listPRDs();
+        state.prdCount = prds.length;
+      }
+
+      // Count epics
+      const epics = await this.epicService.listEpics();
+      state.epicCount = epics.length;
+
+      // Count issues
+      const issues = await this.issueService.listIssues();
+      state.issueCount = issues.length;
+      state.openIssues = issues.filter(i => this.issueService.categorizeStatus(i.status) === 'open').length;
+      state.inProgressIssues = issues.filter(i => this.issueService.categorizeStatus(i.status) === 'in_progress').length;
+      state.blockedIssues = issues.filter(i => (i.status || '').toLowerCase() === 'blocked').length;
+    } catch (error) {
+      // Errors handled gracefully
+    }
+
+    return state;
+  }
+
+  /**
+   * Generate contextual suggestions
+   * @private
+   */
+  _generateSuggestions(state) {
+    const suggestions = [];
+
+    // Scenario 1: No PRDs
+    if (state.prdCount === 0) {
+      suggestions.push({
+        priority: 'high',
+        recommended: true,
+        title: 'Create Your First PRD',
+        description: 'Start by defining what you want to build',
+        commands: ['autopm prd create my-feature'],
+        why: 'PRDs define requirements and guide development'
+      });
+      return suggestions;
+    }
+
+    // Scenario 2: No epics
+    if (state.epicCount === 0) {
+      suggestions.push({
+        priority: 'high',
+        recommended: true,
+        title: 'Parse PRD into Epic',
+        description: 'Convert requirements into executable epic',
+        commands: ['autopm prd parse <prd-name>'],
+        why: 'Creates epic structure needed for task breakdown'
+      });
+      return suggestions;
+    }
+
+    // Scenario 3: Open tasks available
+    if (state.openIssues > 0) {
+      suggestions.push({
+        priority: 'high',
+        recommended: true,
+        title: 'Start Working on Tasks',
+        description: `You have ${state.openIssues} tasks ready to work on`,
+        commands: ['autopm pm next', 'autopm issue start <number>'],
+        why: 'Begin implementation with TDD approach'
+      });
+    }
+
+    // Scenario 4: Tasks in progress
+    if (state.inProgressIssues > 0) {
+      suggestions.push({
+        priority: 'medium',
+        recommended: state.openIssues === 0,
+        title: 'Continue In-Progress Work',
+        description: `You have ${state.inProgressIssues} tasks currently in progress`,
+        commands: ['autopm pm in-progress'],
+        why: 'Finish what you started before starting new work'
+      });
+    }
+
+    // Scenario 5: Blocked tasks
+    if (state.blockedIssues > 0) {
+      suggestions.push({
+        priority: 'high',
+        recommended: true,
+        title: 'Unblock Tasks',
+        description: `${state.blockedIssues} tasks are blocked`,
+        commands: ['autopm pm blocked'],
+        why: 'Blocked tasks prevent progress'
+      });
+    }
+
+    return suggestions;
+  }
+
+  // ==========================================
+  // 2. PROJECT REPORTING
+  // ==========================================
+
+  /**
+   * Generate daily standup report
+   *
+   * Includes:
+   * - Yesterday: tasks closed in last 24h
+   * - Today: tasks currently in-progress
+   * - Blockers: tasks blocked and why
+   * - Velocity: recent completion rate
+   * - Sprint progress: overall completion
+   *
+   * @returns {Promise<Object>} Standup report data
+   */
+  async generateStandup() {
+    const now = new Date();
+    const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+
+    const report = {
+      date: now.toISOString().split('T')[0],
+      yesterday: [],
+      today: [],
+      blockers: [],
+      velocity: 0,
+      sprintProgress: {
+        completed: 0,
+        total: 0,
+        percentage: 0
+      }
+    };
+
+    try {
+      // Yesterday: completed tasks in last 24h
+      const allIssues = await this.issueService.listIssues();
+      const yesterdayTasks = allIssues.filter(issue => {
+        if (!issue.completed) return false;
+        const completedDate = new Date(issue.completed);
+        return completedDate >= yesterday;
+      });
+      report.yesterday = yesterdayTasks;
+
+      // Today: in-progress tasks
+      const inProgressTasks = await this.getInProgressTasks();
+      report.today = inProgressTasks;
+
+      // Blockers: blocked tasks
+      const blockedTasks = await this.getBlockedTasks();
+      report.blockers = blockedTasks;
+
+      // Velocity: 7-day average
+      report.velocity = await this.calculateVelocity(7);
+
+      // Sprint progress
+      const closedCount = allIssues.filter(i => this.issueService.categorizeStatus(i.status) === 'closed').length;
+      report.sprintProgress = {
+        completed: closedCount,
+        total: allIssues.length,
+        percentage: allIssues.length > 0 ? Math.round((closedCount * 100) / allIssues.length) : 0
+      };
+    } catch (error) {
+      // Errors handled gracefully
+    }
+
+    return report;
+  }
+
+  /**
+   * Overall project health and metrics
+   *
+   * @returns {Promise<Object>} Project status with health indicators
+   */
+  async getProjectStatus() {
+    const status = {
+      epics: {
+        backlog: 0,
+        planning: 0,
+        inProgress: 0,
+        completed: 0,
+        total: 0
+      },
+      issues: {
+        open: 0,
+        inProgress: 0,
+        blocked: 0,
+        closed: 0,
+        total: 0
+      },
+      progress: {
+        overall: 0,
+        velocity: 0
+      },
+      health: 'ON_TRACK',
+      recommendations: []
+    };
+
+    try {
+      // Epics
+      const epics = await this.epicService.listEpics();
+      status.epics.total = epics.length;
+      epics.forEach(epic => {
+        const category = this.epicService.categorizeStatus(epic.status);
+        if (category === 'backlog') status.epics.backlog++;
+        else if (category === 'planning') status.epics.planning++;
+        else if (category === 'in_progress') status.epics.inProgress++;
+        else if (category === 'done') status.epics.completed++;
+      });
+
+      // Issues
+      const issues = await this.issueService.listIssues();
+      status.issues.total = issues.length;
+      issues.forEach(issue => {
+        const category = this.issueService.categorizeStatus(issue.status);
+        if (category === 'open') status.issues.open++;
+        else if (category === 'in_progress') status.issues.inProgress++;
+        else if (category === 'closed') status.issues.closed++;
+
+        if ((issue.status || '').toLowerCase() === 'blocked') {
+          status.issues.blocked++;
+        }
+      });
+
+      // Progress
+      if (status.issues.total > 0) {
+        status.progress.overall = Math.round((status.issues.closed * 100) / status.issues.total);
+      }
+      status.progress.velocity = await this.calculateVelocity(7);
+
+      // Health check
+      const { health, recommendations } = this._assessProjectHealth(status);
+      status.health = health;
+      status.recommendations = recommendations;
+    } catch (error) {
+      // Errors handled gracefully
+    }
+
+    return status;
+  }
+
+  /**
+   * Assess project health based on metrics
+   * @private
+   */
+  _assessProjectHealth(status) {
+    let health = 'ON_TRACK';
+    const recommendations = [];
+
+    // Check for blocked tasks >2 days
+    if (status.issues.blocked >= 2) {
+      health = 'AT_RISK';
+      recommendations.push('Unblock multiple blocked tasks preventing progress');
+    }
+
+    // Check for no velocity (only if we have tasks)
+    if (status.progress.velocity === 0 && status.issues.closed === 0 && status.issues.total > 0) {
+      health = 'AT_RISK';
+      recommendations.push('No tasks completed recently - team may be blocked');
+    }
+
+    // Check for high WIP
+    if (status.issues.inProgress > status.issues.total * 0.5 && status.issues.total >= 5) {
+      recommendations.push('High work-in-progress ratio - consider finishing tasks before starting new ones');
+    }
+
+    return { health, recommendations };
+  }
+
+  /**
+   * Get all currently active tasks across epics
+   *
+   * @returns {Promise<Array>} Array of in-progress tasks with metadata
+   */
+  async getInProgressTasks() {
+    try {
+      const allIssues = await this.issueService.listIssues();
+      const inProgress = allIssues.filter(issue => {
+        const category = this.issueService.categorizeStatus(issue.status);
+        return category === 'in_progress';
+      });
+
+      // Mark stale tasks (>3 days)
+      const threeDaysAgo = Date.now() - 3 * 24 * 60 * 60 * 1000;
+      return inProgress.map(task => {
+        const started = task.started ? new Date(task.started).getTime() : Date.now();
+        const stale = started < threeDaysAgo;
+
+        return {
+          ...task,
+          stale
+        };
+      });
+    } catch (error) {
+      return [];
+    }
+  }
+
+  // ==========================================
+  // 3. BOTTLENECK ANALYSIS
+  // ==========================================
+
+  /**
+   * Get all blocked tasks with reasons
+   *
+   * @returns {Promise<Array>} Array of blocked tasks with analysis
+   */
+  async getBlockedTasks() {
+    try {
+      const allIssues = await this.issueService.listIssues();
+      const blocked = allIssues.filter(issue => {
+        return (issue.status || '').toLowerCase() === 'blocked';
+      });
+
+      return blocked.map(task => {
+        // Calculate days blocked
+        const blockedSince = task.blocked_since ? new Date(task.blocked_since) : new Date();
+        const daysBlocked = Math.floor((Date.now() - blockedSince.getTime()) / (24 * 60 * 60 * 1000));
+
+        // Suggest action
+        let suggestedAction = 'Review blocking dependencies';
+        if (task.dependencies && task.dependencies.length > 0) {
+          suggestedAction = `Complete dependencies: ${task.dependencies.join(', ')}`;
+        }
+
+        return {
+          id: task.id,
+          title: task.title,
+          reason: task.blocked_reason || 'Unknown',
+          daysBlocked,
+          suggestedAction
+        };
+      });
+    } catch (error) {
+      return [];
+    }
+  }
+
+  /**
+   * Identify workflow bottlenecks
+   *
+   * Analyzes:
+   * - Blocked tasks
+   * - Stale in-progress tasks
+   * - High WIP ratio
+   *
+   * @returns {Promise<Array>} Array of bottleneck objects
+   */
+  async analyzeBottlenecks() {
+    const bottlenecks = [];
+
+    try {
+      const allIssues = await this.issueService.listIssues();
+
+      // Check for blocked tasks
+      const blocked = allIssues.filter(i => (i.status || '').toLowerCase() === 'blocked');
+      if (blocked.length > 0) {
+        bottlenecks.push({
+          type: 'BLOCKED_TASKS',
+          count: blocked.length,
+          severity: blocked.length >= 3 ? 'HIGH' : 'MEDIUM',
+          description: `${blocked.length} tasks are blocked`
+        });
+      }
+
+      // Check for stale in-progress tasks
+      const threeDaysAgo = Date.now() - 3 * 24 * 60 * 60 * 1000;
+      const stale = allIssues.filter(issue => {
+        const category = this.issueService.categorizeStatus(issue.status);
+        if (category !== 'in_progress') return false;
+        const started = issue.started ? new Date(issue.started).getTime() : Date.now();
+        return started < threeDaysAgo;
+      });
+
+      if (stale.length > 0) {
+        bottlenecks.push({
+          type: 'STALE_TASKS',
+          count: stale.length,
+          severity: 'MEDIUM',
+          description: `${stale.length} tasks in progress for >3 days`
+        });
+      }
+    } catch (error) {
+      // Errors handled gracefully
+    }
+
+    return bottlenecks;
+  }
+
+  // ==========================================
+  // 4. METRICS & ANALYSIS
+  // ==========================================
+
+  /**
+   * Calculate team/project velocity
+   *
+   * Velocity = tasks completed / time period (days)
+   *
+   * @param {number} days - Number of days to calculate over (default: 7)
+   * @returns {Promise<number>} Tasks per day
+   */
+  async calculateVelocity(days = 7) {
+    try {
+      const allIssues = await this.issueService.listIssues();
+      const cutoffDate = Date.now() - days * 24 * 60 * 60 * 1000;
+
+      const recentCompletions = allIssues.filter(issue => {
+        if (!issue.completed) return false;
+        const completedDate = new Date(issue.completed).getTime();
+        return completedDate >= cutoffDate;
+      });
+
+      const velocity = recentCompletions.length / days;
+      return Math.round(velocity * 10) / 10; // Round to 1 decimal
+    } catch (error) {
+      return 0;
+    }
+  }
+
+  /**
+   * Task prioritization logic
+   *
+   * Sorts by:
+   * 1. Priority (P0 > P1 > P2 > P3)
+   * 2. Creation date (oldest first within same priority)
+   *
+   * @param {Array} tasks - Array of task objects
+   * @returns {Array} Sorted tasks
+   */
+  prioritizeTasks(tasks) {
+    if (!Array.isArray(tasks)) {
+      return [];
+    }
+
+    return [...tasks].sort((a, b) => {
+      // Priority first
+      const aPriority = this.priorityOrder[a.priority] ?? this.priorityOrder['P2'];
+      const bPriority = this.priorityOrder[b.priority] ?? this.priorityOrder['P2'];
+
+      if (aPriority !== bPriority) {
+        return aPriority - bPriority;
+      }
+
+      // Creation date second (older first)
+      const aCreated = a.created ? new Date(a.created).getTime() : 0;
+      const bCreated = b.created ? new Date(b.created).getTime() : 0;
+      return aCreated - bCreated;
+    });
+  }
+
+  /**
+   * Check and resolve task dependencies
+   *
+   * @param {string|number} issueNumber - Issue number to check
+   * @returns {Promise<Object>} { resolved: boolean, blocking: Array }
+   */
+  async resolveDependencies(issueNumber) {
+    try {
+      const dependencies = await this.issueService.getDependencies(issueNumber);
+
+      if (!dependencies || dependencies.length === 0) {
+        return { resolved: true, blocking: [] };
+      }
+
+      const blocking = [];
+      for (const depId of dependencies) {
+        try {
+          const dep = await this.issueService.getLocalIssue(depId);
+          const category = this.issueService.categorizeStatus(dep.status);
+          if (category !== 'closed') {
+            blocking.push(depId);
+          }
+        } catch (error) {
+          // If we can't read dependency, consider it blocking
+          blocking.push(depId);
+        }
+      }
+
+      return {
+        resolved: blocking.length === 0,
+        blocking
+      };
+    } catch (error) {
+      return { resolved: true, blocking: [] };
+    }
+  }
+}
+
+module.exports = WorkflowService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-autopm",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "Autonomous Project Management Framework for Claude Code - Advanced AI-powered development automation",
   "main": "bin/autopm.js",
   "bin": {