claude-autopm 2.8.2 → 2.8.3

package/packages/plugin-pm/scripts/pm/epic-list.sh

@@ -0,0 +1,109 @@
+#!/bin/bash
+
+# Backward compatibility wrapper for epic-list.js
+# This script maintains compatibility while delegating to the Node.js implementation
+
+# Get script directory to locate the Node.js implementation
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+NODE_SCRIPT="$SCRIPT_DIR/epic-list.js"
+
+# Check if Node.js version exists and node is available
+if [ -f "$NODE_SCRIPT" ] && command -v node >/dev/null 2>&1; then
+  # Use Node.js implementation
+  node "$NODE_SCRIPT" "$@"
+else
+  # Fallback to original bash implementation
+  echo "Getting epics..."
+  echo ""
+  echo ""
+
+  [ ! -d ".claude/epics" ] && echo "📁 No epics directory found. Create your first epic with: /pm:prd-parse <feature-name>" && exit 0
+  [ -z "$(ls -d .claude/epics/*/ 2>/dev/null)" ] && echo "📁 No epics found. Create your first epic with: /pm:prd-parse <feature-name>" && exit 0
+
+  echo "📚 Project Epics"
+  echo "================"
+  echo ""
+
+  # Initialize arrays to store epics by status
+  planning_epics=""
+  in_progress_epics=""
+  completed_epics=""
+
+  # Process all epics
+  for dir in .claude/epics/*/; do
+    [ -d "$dir" ] || continue
+    [ -f "$dir/epic.md" ] || continue
+
+    # Extract metadata
+    n=$(grep "^name:" "$dir/epic.md" | head -1 | sed 's/^name: *//')
+    s=$(grep "^status:" "$dir/epic.md" | head -1 | sed 's/^status: *//' | tr '[:upper:]' '[:lower:]')
+    p=$(grep "^progress:" "$dir/epic.md" | head -1 | sed 's/^progress: *//')
+    g=$(grep "^github:" "$dir/epic.md" | head -1 | sed 's/^github: *//')
+
+    # Defaults
+    [ -z "$n" ] && n=$(basename "$dir")
+    [ -z "$p" ] && p="0%"
+
+    # Count tasks
+    t=$(ls "$dir"[0-9]*.md 2>/dev/null | wc -l)
+
+    # Format output with GitHub issue number if available
+    if [ -n "$g" ]; then
+      i=$(echo "$g" | grep -o '/[0-9]*$' | tr -d '/')
+      entry="   📋 ${dir}epic.md (#$i) - $p complete ($t tasks)"
+    else
+      entry="   📋 ${dir}epic.md - $p complete ($t tasks)"
+    fi
+
+    # Categorize by status (handle various status values)
+    case "$s" in
+      planning|draft|"")
+        planning_epics="${planning_epics}${entry}\n"
+        ;;
+      in-progress|in_progress|active|started)
+        in_progress_epics="${in_progress_epics}${entry}\n"
+        ;;
+      completed|complete|done|closed|finished)
+        completed_epics="${completed_epics}${entry}\n"
+        ;;
+      *)
+        # Default to planning for unknown statuses
+        planning_epics="${planning_epics}${entry}\n"
+        ;;
+    esac
+  done
+
+  # Display categorized epics
+  echo "📝 Planning:"
+  if [ -n "$planning_epics" ]; then
+    echo -e "$planning_epics" | sed '/^$/d'
+  else
+    echo "   (none)"
+  fi
+
+  echo ""
+  echo "🚀 In Progress:"
+  if [ -n "$in_progress_epics" ]; then
+    echo -e "$in_progress_epics" | sed '/^$/d'
+  else
+    echo "   (none)"
+  fi
+
+  echo ""
+  echo "✅ Completed:"
+  if [ -n "$completed_epics" ]; then
+    echo -e "$completed_epics" | sed '/^$/d'
+  else
+    echo "   (none)"
+  fi
+
+  # Summary
+  echo ""
+  echo "📊 Summary"
+  total=$(ls -d .claude/epics/*/ 2>/dev/null | wc -l)
+  tasks=$(find .claude/epics -name "[0-9]*.md" 2>/dev/null | wc -l)
+  echo "   Total epics: $total"
+  echo "   Total tasks: $tasks"
+
+  exit 0
+fi

package/packages/plugin-pm/scripts/pm/epic-show.js

@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+
+/**
+ * PM Epic Show Script - Node.js Implementation
+ *
+ * Migrated from epic-show.sh to provide detailed epic information
+ * Maintains full compatibility with the original bash implementation
+ *
+ * Features:
+ * - Shows detailed epic information including metadata
+ * - Lists all tasks with their status and properties
+ * - Provides statistics (total, open, closed, completion percentage)
+ * - Suggests next actions based on epic state
+ * - Handles various task status formats
+ * - Extracts metadata from frontmatter
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function parseMetadata(content) {
+  const metadata = {
+    name: '',
+    status: '',
+    progress: '',
+    github: '',
+    created: '',
+    parallel: '',
+    depends_on: ''
+  };
+
+  // Handle YAML frontmatter (between --- lines)
+  const yamlMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (yamlMatch) {
+    const yamlContent = yamlMatch[1];
+    const lines = yamlContent.split('\n');
+
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (trimmedLine.includes(':')) {
+        const [key, ...valueParts] = trimmedLine.split(':');
+        const value = valueParts.join(':').trim();
+        const cleanKey = key.trim().toLowerCase();
+
+        if (Object.prototype.hasOwnProperty.call(metadata, cleanKey)) {
+          metadata[cleanKey] = value;
+        }
+      }
+    }
+  } else {
+    // Handle simple key-value format (key: value lines at start of file)
+    const lines = content.split('\n');
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (trimmedLine.includes(':') && !trimmedLine.startsWith('#')) {
+        const [key, ...valueParts] = trimmedLine.split(':');
+        const value = valueParts.join(':').trim();
+        const cleanKey = key.trim().toLowerCase();
+
+        if (Object.prototype.hasOwnProperty.call(metadata, cleanKey)) {
+          metadata[cleanKey] = value;
+        }
+      } else if (trimmedLine.startsWith('#') || trimmedLine === '') {
+        // Stop parsing when we hit content
+        break;
+      }
+    }
+  }
+
+  return metadata;
+}
+
+function getAvailableEpics() {
+  if (!fs.existsSync('.claude/epics')) {
+    return [];
+  }
+
+  try {
+    return fs.readdirSync('.claude/epics', { withFileTypes: true })
+      .filter(dirent => dirent.isDirectory())
+      .map(dirent => dirent.name);
+  } catch (error) {
+    return [];
+  }
+}
+
+function isTaskClosed(status) {
+  const lowerStatus = (status || '').toLowerCase();
+  return ['closed', 'completed'].includes(lowerStatus);
+}
+
+function showEpic(epicName) {
+  if (!epicName || epicName.trim() === '') {
+    throw new Error('❌ Please provide an epic name\nUsage: /pm:epic-show <epic-name>');
+  }
+
+  const epicDir = `.claude/epics/${epicName}`;
+  const epicFilePath = `${epicDir}/epic.md`;
+
+  // Check if epic exists
+  if (!fs.existsSync(epicFilePath)) {
+    const availableEpics = getAvailableEpics();
+    let errorMessage = `❌ Epic not found: ${epicName}\n\nAvailable epics:`;
+
+    if (availableEpics.length > 0) {
+      for (const epic of availableEpics) {
+        errorMessage += `\n  • ${epic}`;
+      }
+    } else {
+      errorMessage += '\n  (none)';
+    }
+
+    throw new Error(errorMessage);
+  }
+
+  // Parse epic metadata
+  let epicMetadata;
+  try {
+    const epicContent = fs.readFileSync(epicFilePath, 'utf8');
+    epicMetadata = parseMetadata(epicContent);
+  } catch (error) {
+    // Use defaults if file can't be read
+    epicMetadata = {
+      name: epicName,
+      status: 'planning',
+      progress: '0%',
+      github: '',
+      created: 'unknown'
+    };
+  }
+
+  // Apply defaults
+  const epic = {
+    name: epicMetadata.name || epicName,
+    status: epicMetadata.status || 'planning',
+    progress: epicMetadata.progress || '0%',
+    github: epicMetadata.github || '',
+    created: epicMetadata.created || 'unknown'
+  };
+
+  // Parse tasks
+  const tasks = [];
+  let taskCount = 0;
+  let openCount = 0;
+  let closedCount = 0;
+
+  try {
+    const files = fs.readdirSync(epicDir);
+    const taskFiles = files.filter(file => /^\d+\.md$/.test(file));
+
+    for (const file of taskFiles) {
+      const taskFilePath = path.join(epicDir, file);
+      const taskNum = path.basename(file, '.md');
+
+      let taskMetadata;
+      try {
+        const taskContent = fs.readFileSync(taskFilePath, 'utf8');
+        taskMetadata = parseMetadata(taskContent);
+      } catch (error) {
+        // Use defaults if file can't be read
+        taskMetadata = {
+          name: taskNum,
+          status: 'open',
+          parallel: 'false',
+          depends_on: ''
+        };
+      }
+
+      const task = {
+        taskNum,
+        name: taskMetadata.name || taskNum,
+        status: taskMetadata.status || 'open',
+        parallel: taskMetadata.parallel || 'false',
+        depends_on: taskMetadata.depends_on || ''
+      };
+
+      tasks.push(task);
+      taskCount++;
+
+      if (isTaskClosed(task.status)) {
+        closedCount++;
+      } else {
+        openCount++;
+      }
+    }
+  } catch (error) {
+    // Directory can't be read, continue with empty tasks
+  }
+
+  // Calculate completion percentage
+  const completion = taskCount > 0 ? Math.round((closedCount * 100) / taskCount) : 0;
+
+  // Generate action suggestions
+  const actions = [];
+
+  if (taskCount === 0) {
+    actions.push('• Decompose into tasks: /pm:epic-decompose ' + epicName);
+  }
+
+  if (!epic.github && taskCount > 0) {
+    actions.push('• Sync to GitHub: /pm:epic-sync ' + epicName);
+  }
+
+  if (epic.github && epic.status !== 'completed') {
+    actions.push('• Start work: /pm:epic-start ' + epicName);
+  }
+
+  return {
+    epic,
+    tasks,
+    statistics: {
+      totalTasks: taskCount,
+      openTasks: openCount,
+      closedTasks: closedCount,
+      completion
+    },
+    actions
+  };
+}
+
+function formatEpicShow(epicName, data) {
+  let output = 'Getting epic...\n\n\n';
+
+  output += `📚 Epic: ${epicName}\n`;
+  output += '================================\n\n';
+
+  // Metadata section
+  output += '📊 Metadata:\n';
+  output += `  Status: ${data.epic.status}\n`;
+  output += `  Progress: ${data.epic.progress}\n`;
+  if (data.epic.github) {
+    output += `  GitHub: ${data.epic.github}\n`;
+  }
+  output += `  Created: ${data.epic.created}\n\n`;
+
+  // Tasks section
+  output += '📝 Tasks:\n';
+  if (data.tasks.length > 0) {
+    for (const task of data.tasks) {
+      const icon = isTaskClosed(task.status) ? '✅' : '⬜';
+      let taskLine = `  ${icon} #${task.taskNum} - ${task.name}`;
+
+      if (!isTaskClosed(task.status) && task.parallel === 'true') {
+        taskLine += ' (parallel)';
+      }
+
+      output += taskLine + '\n';
+    }
+  } else {
+    output += '  No tasks created yet\n';
+    output += `  Run: /pm:epic-decompose ${epicName}\n`;
+  }
+
+  // Statistics section
+  output += '\n📈 Statistics:\n';
+  output += `  Total tasks: ${data.statistics.totalTasks}\n`;
+  output += `  Open: ${data.statistics.openTasks}\n`;
+  output += `  Closed: ${data.statistics.closedTasks}\n`;
+  if (data.statistics.totalTasks > 0) {
+    output += `  Completion: ${data.statistics.completion}%\n`;
+  }
+
+  // Actions section
+  output += '\n💡 Actions:\n';
+  if (data.actions.length > 0) {
+    for (const action of data.actions) {
+      output += `  ${action}\n`;
+    }
+  } else {
+    output += '  No specific actions suggested\n';
+  }
+
+  return output;
+}
+
+// CommonJS export for testing
+module.exports = showEpic;
+
+// CLI execution
+if (require.main === module) {
+  const epicName = process.argv[2];
+
+  try {
+    const data = showEpic(epicName);
+    console.log(formatEpicShow(epicName, data));
+    process.exit(0);
+  } catch (error) {
+    console.error(error.message);
+    process.exit(1);
+  }
+}

package/packages/plugin-pm/scripts/pm/epic-show.sh

@@ -0,0 +1,105 @@
+#!/bin/bash
+
+# Backward compatibility wrapper for epic-show.js
+# This script maintains compatibility while delegating to the Node.js implementation
+
+# Get script directory to locate the Node.js implementation
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+NODE_SCRIPT="$SCRIPT_DIR/epic-show.js"
+
+# Check if Node.js version exists and node is available
+if [ -f "$NODE_SCRIPT" ] && command -v node >/dev/null 2>&1; then
+  # Use Node.js implementation
+  node "$NODE_SCRIPT" "$@"
+else
+  # Fallback to original bash implementation
+  epic_name="$1"
+
+  if [ -z "$epic_name" ]; then
+    echo "❌ Please provide an epic name"
+    echo "Usage: /pm:epic-show <epic-name>"
+    exit 1
+  fi
+
+  echo "Getting epic..."
+  echo ""
+  echo ""
+
+  epic_dir=".claude/epics/$epic_name"
+  epic_file="$epic_dir/epic.md"
+
+  if [ ! -f "$epic_file" ]; then
+    echo "❌ Epic not found: $epic_name"
+    echo ""
+    echo "Available epics:"
+    for dir in .claude/epics/*/; do
+      [ -d "$dir" ] && echo "  • $(basename "$dir")"
+    done
+    exit 1
+  fi
+
+  # Display epic details
+  echo "📚 Epic: $epic_name"
+  echo "================================"
+  echo ""
+
+  # Extract metadata
+  status=$(grep "^status:" "$epic_file" | head -1 | sed 's/^status: *//')
+  progress=$(grep "^progress:" "$epic_file" | head -1 | sed 's/^progress: *//')
+  github=$(grep "^github:" "$epic_file" | head -1 | sed 's/^github: *//')
+  created=$(grep "^created:" "$epic_file" | head -1 | sed 's/^created: *//')
+
+  echo "📊 Metadata:"
+  echo "  Status: ${status:-planning}"
+  echo "  Progress: ${progress:-0%}"
+  [ -n "$github" ] && echo "  GitHub: $github"
+  echo "  Created: ${created:-unknown}"
+  echo ""
+
+  # Show tasks
+  echo "📝 Tasks:"
+  task_count=0
+  open_count=0
+  closed_count=0
+
+  for task_file in "$epic_dir"/[0-9]*.md; do
+    [ -f "$task_file" ] || continue
+
+    task_num=$(basename "$task_file" .md)
+    task_name=$(grep "^name:" "$task_file" | head -1 | sed 's/^name: *//')
+    task_status=$(grep "^status:" "$task_file" | head -1 | sed 's/^status: *//')
+    parallel=$(grep "^parallel:" "$task_file" | head -1 | sed 's/^parallel: *//')
+
+    if [ "$task_status" = "closed" ] || [ "$task_status" = "completed" ]; then
+      echo "  ✅ #$task_num - $task_name"
+      ((closed_count++))
+    else
+      echo "  ⬜ #$task_num - $task_name"
+      [ "$parallel" = "true" ] && echo -n " (parallel)"
+      ((open_count++))
+    fi
+
+    ((task_count++))
+  done
+
+  if [ $task_count -eq 0 ]; then
+    echo "  No tasks created yet"
+    echo "  Run: /pm:epic-decompose $epic_name"
+  fi
+
+  echo ""
+  echo "📈 Statistics:"
+  echo "  Total tasks: $task_count"
+  echo "  Open: $open_count"
+  echo "  Closed: $closed_count"
+  [ $task_count -gt 0 ] && echo "  Completion: $((closed_count * 100 / task_count))%"
+
+  # Next actions
+  echo ""
+  echo "💡 Actions:"
+  [ $task_count -eq 0 ] && echo "  • Decompose into tasks: /pm:epic-decompose $epic_name"
+  [ -z "$github" ] && [ $task_count -gt 0 ] && echo "  • Sync to GitHub: /pm:epic-sync $epic_name"
+  [ -n "$github" ] && [ "$status" != "completed" ] && echo "  • Start work: /pm:epic-start $epic_name"
+
+  exit 0
+fi