claude-autopm 2.8.2 → 2.8.3

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

@@ -0,0 +1,94 @@
+#!/bin/bash
+# Epic Start - Launch parallel agent execution for an epic
+
+set -e
+
+# Get the directory where this script is located
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SCRIPTS_DIR="$(dirname "$SCRIPT_DIR")"
+BASE_DIR="$(dirname "$(dirname "$SCRIPTS_DIR")")"
+
+# Source common functions
+source "$SCRIPTS_DIR/lib/common-functions.sh" 2>/dev/null || true
+
+# Epic name from argument
+EPIC_NAME="${1:-}"
+
+if [ -z "$EPIC_NAME" ]; then
+    echo "❌ Error: Epic name required"
+    echo "Usage: /pm:epic-start <epic-name>"
+    exit 1
+fi
+
+# Find epic file
+EPIC_FILE=".claude/epics/${EPIC_NAME}.md"
+if [ ! -f "$EPIC_FILE" ]; then
+    EPIC_FILE=".claude/prds/${EPIC_NAME}.md"
+    if [ ! -f "$EPIC_FILE" ]; then
+        echo "❌ Error: Epic not found: ${EPIC_NAME}"
+        echo "Available epics:"
+        ls .claude/epics/*.md .claude/prds/*.md 2>/dev/null | xargs -n1 basename | sed 's/\.md$//' | sed 's/^/  - /'
+        exit 1
+    fi
+fi
+
+echo "🚀 Starting parallel execution for epic: ${EPIC_NAME}"
+echo "📄 Epic file: ${EPIC_FILE}"
+echo ""
+
+# Extract tasks from epic file
+echo "📋 Extracting tasks from epic..."
+TASKS=$(grep -E "^- \[ \]|^- \[x\]" "$EPIC_FILE" 2>/dev/null || true)
+
+if [ -z "$TASKS" ]; then
+    echo "⚠️  No tasks found in epic file"
+    echo "Tip: Add tasks in format: - [ ] Task description"
+    exit 1
+fi
+
+# Count tasks
+TOTAL_TASKS=$(echo "$TASKS" | wc -l | tr -d ' ')
+INCOMPLETE_TASKS=$(echo "$TASKS" | grep "^- \[ \]" | wc -l | tr -d ' ')
+COMPLETE_TASKS=$(echo "$TASKS" | grep "^- \[x\]" | wc -l | tr -d ' ')
+
+echo "📊 Task Status:"
+echo "  • Total: $TOTAL_TASKS"
+echo "  • Complete: $COMPLETE_TASKS"
+echo "  • Remaining: $INCOMPLETE_TASKS"
+echo ""
+
+if [ "$INCOMPLETE_TASKS" -eq 0 ]; then
+    echo "✅ All tasks are already complete!"
+    exit 0
+fi
+
+# Start parallel execution
+echo "🔄 Starting parallel execution for $INCOMPLETE_TASKS tasks..."
+echo ""
+
+# Check if parallel streams script exists
+PARALLEL_SCRIPT="$SCRIPTS_DIR/start-parallel-streams.js"
+if [ -f "$PARALLEL_SCRIPT" ]; then
+    echo "Using Node.js parallel executor..."
+    node "$PARALLEL_SCRIPT" --epic "$EPIC_NAME"
+else
+    # Fallback to basic parallel execution
+    echo "Starting tasks in parallel..."
+
+    # Process each incomplete task
+    echo "$TASKS" | grep "^- \[ \]" | while IFS= read -r task; do
+        # Extract task description
+        TASK_DESC=$(echo "$task" | sed 's/^- \[ \] //')
+        echo "  ▶ Starting: $TASK_DESC"
+
+        # You can add actual task execution logic here
+        # For example, launching agents or running specific scripts
+    done
+
+    echo ""
+    echo "✅ Parallel execution initiated"
+fi
+
+echo ""
+echo "💡 Monitor progress with: /pm:epic-status $EPIC_NAME"
+echo "📝 View details with: /pm:epic-show $EPIC_NAME"

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

@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+
+/**
+ * PM Epic Status Script - Node.js Implementation
+ *
+ * Migrated from epic-status.sh to provide epic status with progress visualization
+ * Maintains full compatibility with the original bash implementation
+ *
+ * Features:
+ * - Shows epic status with progress bar visualization
+ * - Calculates task breakdown (total, open, closed, blocked)
+ * - Identifies blocked tasks based on dependencies
+ * - Provides visual progress indication
+ * - Handles various dependency formats
+ * - Includes GitHub link if available
+ */
+
+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 hasValidDependencies(depsString) {
+  if (!depsString || depsString.trim() === '') {
+    return false;
+  }
+
+  // Handle malformed dependency strings
+  if (depsString === 'depends_on:') {
+    return false;
+  }
+
+  // Clean up the dependency string
+  let cleanDeps = depsString.trim();
+
+  // Remove array brackets if present
+  cleanDeps = cleanDeps.replace(/^\[|\]$/g, '');
+
+  // Check if there's actual content after cleaning
+  cleanDeps = cleanDeps.trim();
+
+  return cleanDeps.length > 0;
+}
+
+function generateProgressBar(percent) {
+  const totalChars = 20;
+  const filled = Math.round((percent * totalChars) / 100);
+  const empty = totalChars - filled;
+
+  let bar = '[';
+  bar += '█'.repeat(filled);
+  bar += '░'.repeat(empty);
+  bar += ']';
+
+  return {
+    bar,
+    percent,
+    filled,
+    empty
+  };
+}
+
+function epicStatus(epicName) {
+  if (!epicName || epicName.trim() === '') {
+    throw new Error('❌ Please specify an epic name\nUsage: /pm:epic-status <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 || ''
+  };
+
+  // Analyze tasks
+  let totalTasks = 0;
+  let openTasks = 0;
+  let closedTasks = 0;
+  let blockedTasks = 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);
+
+      let taskMetadata;
+      try {
+        const taskContent = fs.readFileSync(taskFilePath, 'utf8');
+        taskMetadata = parseMetadata(taskContent);
+      } catch (error) {
+        // Use defaults if file can't be read
+        taskMetadata = {
+          status: 'open',
+          depends_on: ''
+        };
+      }
+
+      const status = taskMetadata.status || 'open';
+      const depsString = taskMetadata.depends_on || '';
+
+      totalTasks++;
+
+      if (isTaskClosed(status)) {
+        closedTasks++;
+      } else if (hasValidDependencies(depsString)) {
+        // Task is open but has dependencies - consider it blocked
+        blockedTasks++;
+      } else {
+        // Task is open and has no dependencies
+        openTasks++;
+      }
+    }
+  } catch (error) {
+    // Directory can't be read, continue with zero tasks
+  }
+
+  // Calculate progress
+  let progressData;
+  if (totalTasks > 0) {
+    const percent = Math.round((closedTasks * 100) / totalTasks);
+    progressData = generateProgressBar(percent);
+    progressData.message = `Progress: ${progressData.bar} ${percent}%`;
+  } else {
+    progressData = {
+      bar: '',
+      percent: 0,
+      filled: 0,
+      empty: 0,
+      message: 'Progress: No tasks created'
+    };
+  }
+
+  return {
+    epic,
+    taskBreakdown: {
+      totalTasks,
+      openTasks,
+      closedTasks,
+      blockedTasks
+    },
+    progressBar: progressData
+  };
+}
+
+function formatEpicStatus(epicName, data) {
+  let output = 'Getting status...\n\n\n';
+
+  output += `📚 Epic Status: ${epicName}\n`;
+  output += '================================\n\n';
+
+  // Progress bar
+  output += `${data.progressBar.message}\n\n`;
+
+  // Task breakdown
+  output += '📊 Breakdown:\n';
+  output += `  Total tasks: ${data.taskBreakdown.totalTasks}\n`;
+  output += `  ✅ Completed: ${data.taskBreakdown.closedTasks}\n`;
+  output += `  🔄 Available: ${data.taskBreakdown.openTasks}\n`;
+  output += `  ⏸️ Blocked: ${data.taskBreakdown.blockedTasks}\n`;
+
+  // GitHub link if available
+  if (data.epic.github) {
+    output += `\n🔗 GitHub: ${data.epic.github}\n`;
+  }
+
+  return output;
+}
+
+// CommonJS export for testing
+module.exports = epicStatus;
+
+// CLI execution
+if (require.main === module) {
+  const epicName = process.argv[2];
+
+  try {
+    const data = epicStatus(epicName);
+    console.log(formatEpicStatus(epicName, data));
+    process.exit(0);
+  } catch (error) {
+    console.error(error.message);
+    process.exit(1);
+  }
+}

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

@@ -0,0 +1,104 @@
+#!/bin/bash
+
+# Backward compatibility wrapper for epic-status.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-status.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 status..."
+  echo ""
+  echo ""
+
+  epic_name="$1"
+
+  if [ -z "$epic_name" ]; then
+    echo "❌ Please specify an epic name"
+    echo "Usage: /pm:epic-status <epic-name>"
+    echo ""
+    echo "Available epics:"
+    for dir in .claude/epics/*/; do
+      [ -d "$dir" ] && echo "  • $(basename "$dir")"
+    done
+    exit 1
+  else
+    # Show status for specific epic
+    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
+
+    echo "📚 Epic Status: $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: *//')
+
+    # Count tasks
+    total=0
+    open=0
+    closed=0
+    blocked=0
+
+    # Use find to safely iterate over task files
+    for task_file in "$epic_dir"/[0-9]*.md; do
+      [ -f "$task_file" ] || continue
+      ((total++))
+
+      task_status=$(grep "^status:" "$task_file" | head -1 | sed 's/^status: *//')
+      deps=$(grep "^depends_on:" "$task_file" | head -1 | sed 's/^depends_on: *\[//' | sed 's/\]//')
+
+      if [ "$task_status" = "closed" ] || [ "$task_status" = "completed" ]; then
+        ((closed++))
+      elif [ -n "$deps" ] && [ "$deps" != "depends_on:" ]; then
+        ((blocked++))
+      else
+        ((open++))
+      fi
+    done
+
+    # Display progress bar
+    if [ $total -gt 0 ]; then
+      percent=$((closed * 100 / total))
+      filled=$((percent * 20 / 100))
+      empty=$((20 - filled))
+
+      echo -n "Progress: ["
+      [ $filled -gt 0 ] && printf '%0.s█' $(seq 1 $filled)
+      [ $empty -gt 0 ] && printf '%0.s░' $(seq 1 $empty)
+      echo "] $percent%"
+    else
+      echo "Progress: No tasks created"
+    fi
+
+    echo ""
+    echo "📊 Breakdown:"
+    echo "  Total tasks: $total"
+    echo "  ✅ Completed: $closed"
+    echo "  🔄 Available: $open"
+    echo "  ⏸️ Blocked: $blocked"
+
+    [ -n "$github" ] && echo ""
+    [ -n "$github" ] && echo "🔗 GitHub: $github"
+  fi
+
+  exit 0
+fi

package/packages/plugin-pm/scripts/pm/epic-sync/README.md

@@ -0,0 +1,208 @@
+# Epic Sync Modular Scripts
+
+This directory contains the modular implementation of the epic-sync workflow that pushes epics and tasks to GitHub as issues.
+
+## Architecture
+
+The epic-sync process is split into 4 specialized scripts:
+
+1. **create-epic-issue.sh** - Creates the main epic GitHub issue
+2. **create-task-issues.sh** - Creates GitHub issues for all tasks
+3. **update-references.sh** - Renames task files to match GitHub issue numbers
+4. **update-epic-file.sh** - Updates epic.md with real issue numbers
+
+## Orchestration
+
+The **recommended way** to use these scripts is via the orchestration script:
+
+```bash
+# From project root
+bash .claude/scripts/pm/epic-sync.sh <epic_name>
+```
+
+This automatically runs all 4 steps in the correct order.
+
+## Individual Scripts
+
+### 1. create-epic-issue.sh
+
+**Purpose:** Creates the main GitHub issue for the epic
+
+**Input:**
+- Epic name (e.g., `postgresql-connection-module`)
+
+**Output:**
+- GitHub issue number (stdout)
+
+**What it does:**
+- Strips frontmatter from epic.md
+- Counts tasks in epic directory
+- Detects epic type (bug vs feature)
+- Creates GitHub issue with proper labels
+- Returns epic issue number
+
+**Usage:**
+```bash
+epic_number=$(bash .claude/scripts/pm/epic-sync/create-epic-issue.sh "my-feature")
+echo "Epic created: #$epic_number"
+```
+
+### 2. create-task-issues.sh
+
+**Purpose:** Creates GitHub issues for all task files
+
+**Input:**
+- Epic name
+- Epic issue number (from step 1)
+
+**Output:**
+- Path to task mapping file (stdout)
+
+**What it does:**
+- Finds all `[0-9]*.md` files in epic directory
+- Strips frontmatter from each task
+- Creates GitHub issue for each task
+- Labels with `task,epic:<epic_name>`
+- Saves mapping of old_name -> issue_number to `.task-mapping.txt`
+- **Mapping file is saved in epic directory** (persistent, not in /tmp)
+
+**Usage:**
+```bash
+mapping=$(bash .claude/scripts/pm/epic-sync/create-task-issues.sh "my-feature" "42")
+echo "Mapping saved: $mapping"
+```
+
+**Important:** The mapping file is saved as `.claude/epics/<epic>/.task-mapping.txt` for use in subsequent steps.
+
+### 3. update-references.sh
+
+**Purpose:** Renames task files to GitHub issue numbers and updates frontmatter
+
+**Input:**
+- Epic name
+- Path to task mapping file (from step 2)
+
+**Output:**
+- None (modifies files in place)
+
+**What it does:**
+- Reads `.task-mapping.txt` file
+- For each mapping (e.g., `001 -> 2`):
+  - Renames `001.md` to `2.md`
+  - Updates frontmatter with GitHub URL
+  - Updates frontmatter timestamp
+- Creates backups during rename (removed on success)
+
+**Usage:**
+```bash
+bash .claude/scripts/pm/epic-sync/update-references.sh "my-feature" ".claude/epics/my-feature/.task-mapping.txt"
+```
+
+**Before:**
+```
+.claude/epics/my-feature/
+├── 001.md (github: [Will be updated...])
+├── 002.md (github: [Will be updated...])
+```
+
+**After:**
+```
+.claude/epics/my-feature/
+├── 2.md (github: https://github.com/user/repo/issues/2)
+├── 3.md (github: https://github.com/user/repo/issues/3)
+```
+
+### 4. update-epic-file.sh
+
+**Purpose:** Updates epic.md with GitHub URL and real task references
+
+**Input:**
+- Epic name
+- Epic issue number
+
+**Output:**
+- None (modifies epic.md in place)
+
+**What it does:**
+- Updates epic.md frontmatter with GitHub URL
+- Updates timestamp
+- Reads `.task-mapping.txt`
+- Replaces task references (e.g., `- [ ] 001` → `- [ ] #2`)
+- Creates backup during update (removed on success)
+
+**Usage:**
+```bash
+bash .claude/scripts/pm/epic-sync/update-epic-file.sh "my-feature" "42"
+```
+
+## File Persistence Fix
+
+**IMPORTANT:** The task mapping file is saved to a **persistent location**:
+
+```
+.claude/epics/<epic_name>/.task-mapping.txt
+```
+
+This fixes the bug where the mapping file was being saved to `/tmp` and deleted before subsequent scripts could use it.
+
+## Error Handling
+
+All scripts use `set -euo pipefail` for robust error handling:
+- `-e`: Exit on error
+- `-u`: Error on undefined variables
+- `-o pipefail`: Fail if any command in pipeline fails
+
+## Testing
+
+Test individual scripts:
+
+```bash
+# Create a test epic first
+mkdir -p .claude/epics/test-epic
+echo "---\ntitle: Test\n---\n# Test Epic" > .claude/epics/test-epic/epic.md
+echo "---\ntitle: Task 1\n---\n# Task 1" > .claude/epics/test-epic/001.md
+echo "---\ntitle: Task 2\n---\n# Task 2" > .claude/epics/test-epic/002.md
+
+# Run orchestration script
+bash .claude/scripts/pm/epic-sync.sh test-epic
+
+# Verify files were renamed
+ls .claude/epics/test-epic/
+# Should show: epic.md, <issue_number>.md files
+```
+
+## Dependencies
+
+- **bash** >= 4.0
+- **gh** (GitHub CLI) - authenticated
+- **awk** - for frontmatter processing
+- **find** - for file discovery
+- **grep** - for pattern matching
+
+## Common Issues
+
+### "Template repository detected"
+```bash
+# Fix: Set correct remote
+git remote set-url origin https://github.com/YOUR_USERNAME/YOUR_REPO.git
+```
+
+### "GitHub CLI not authenticated"
+```bash
+gh auth login
+```
+
+### "Mapping file not found"
+- Ensure step 2 completed successfully
+- Check `.claude/epics/<epic>/.task-mapping.txt` exists
+
+### "Task files still numbered 001, 002..."
+- Step 3 (update-references.sh) may not have run
+- Check for errors in step 2 output
+- Run orchestration script instead of individual scripts
+
+## Related Files
+
+- **/.claude/commands/pm/epic-sync.md** - Command documentation
+- **/.claude/commands/pm/issue-start.md** - Works with renamed files
+- **/.claude/commands/pm/issue-analyze.md** - Expects GitHub issue numbers