claude-autopm 1.20.0 → 1.21.0

package/autopm/.claude/scripts/pm/epic-sync/create-epic-issue.sh

@@ -1,201 +1,77 @@
 #!/bin/bash
-# Create Epic Issue Script
-# Extracts content from epic.md, processes it, and creates GitHub issue
+# Create Epic Issue
+# Creates the main GitHub issue for an epic with proper labels and stats
 
 set -euo pipefail
 
-# Load libraries
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/../../lib/logging-utils.sh"
-source "${SCRIPT_DIR}/../../lib/github-utils.sh"
-source "${SCRIPT_DIR}/../../lib/frontmatter-utils.sh"
-source "${SCRIPT_DIR}/../../lib/validation-utils.sh"
-
-# Script configuration
-readonly EPIC_NAME="${1:-}"
-
-# Main function
-main() {
-    print_banner "Epic Issue Creator" "1.0.0"
-
-    # Validate inputs
-    log_info "Validating epic: $EPIC_NAME"
-    validate_epic_name "$EPIC_NAME" || exit 1
-    validate_epic_structure "$EPIC_NAME" || exit 1
-
-    # Check GitHub authentication and repo protection
-    validate_github_auth || exit 1
-    check_repo_protection || exit 1
-
-    local epic_file=".claude/epics/$EPIC_NAME/epic.md"
-    local temp_dir="/tmp/epic-sync-$$"
-
-    log_info "Creating temporary workspace: $temp_dir"
-    mkdir -p "$temp_dir"
-
-    # Ensure cleanup on exit
-    trap "rm -rf '$temp_dir'" EXIT
-
-    # Process epic content
-    with_error_handling "Strip frontmatter from epic" \
-        strip_frontmatter "$epic_file" "$temp_dir/epic-body-raw.md"
-
-    with_error_handling "Process epic content and stats" \
-        process_epic_content "$temp_dir/epic-body-raw.md" "$temp_dir/epic-body.md"
-
-    with_error_handling "Determine epic type" \
-        epic_type=$(determine_epic_type "$temp_dir/epic-body.md")
-
-    with_error_handling "Create GitHub epic issue" \
-        issue_number=$(create_epic_github_issue "$temp_dir/epic-body.md" "$epic_type")
-
-    # Output result
-    local repo_info
-    repo_info=$(get_repo_info)
-    local repo_name
-    repo_name=$(echo "$repo_info" | grep -o '"nameWithOwner":"[^"]*"' | cut -d'"' -f4)
-
-    log_success "Epic issue created successfully!"
-    echo "Epic Issue: #${issue_number}"
-    echo "URL: https://github.com/${repo_name}/issues/${issue_number}"
-    echo "$issue_number"  # For script consumption
-}
-
-# Process epic content and replace Tasks Created section with Stats
-process_epic_content() {
-    local input_file="$1"
-    local output_file="$2"
-
-    log_function_entry "process_epic_content" "$input_file" "$output_file"
-
-    # Count tasks in epic directory
-    local epic_dir=".claude/epics/$EPIC_NAME"
-    local total_tasks parallel_tasks sequential_tasks total_effort
-
-    total_tasks=$(find "$epic_dir" -name '[0-9][0-9][0-9].md' -type f | wc -l)
-    parallel_tasks=$(grep -l '^parallel: true' "$epic_dir"/[0-9][0-9][0-9].md 2>/dev/null | wc -l || echo 0)
-    sequential_tasks=$((total_tasks - parallel_tasks))
-
-    # Try to calculate total effort from task files
-    total_effort=$(calculate_total_effort "$epic_dir")
-
-    # Process content with awk to replace Tasks Created section
-    awk -v total_tasks="$total_tasks" \
-        -v parallel_tasks="$parallel_tasks" \
-        -v sequential_tasks="$sequential_tasks" \
-        -v total_effort="$total_effort" '
-        /^## Tasks Created/ {
-            in_tasks=1
-            next
-        }
-        /^## / && in_tasks {
-            in_tasks=0
-            # Add Stats section
-            print "## Stats"
-            print ""
-            print "Total tasks: " total_tasks
-            print "Parallel tasks: " parallel_tasks " (can be worked on simultaneously)"
-            print "Sequential tasks: " sequential_tasks " (have dependencies)"
-            if (total_effort) print "Estimated total effort: " total_effort " hours"
-            print ""
-        }
-        /^Total tasks:/ && in_tasks { next }
-        /^Parallel tasks:/ && in_tasks { next }
-        /^Sequential tasks:/ && in_tasks { next }
-        /^Estimated total effort:/ && in_tasks { next }
-        !in_tasks { print }
-        END {
-            # If we were still in tasks section at EOF, add stats
-            if (in_tasks) {
-                print "## Stats"
-                print ""
-                print "Total tasks: " total_tasks
-                print "Parallel tasks: " parallel_tasks " (can be worked on simultaneously)"
-                print "Sequential tasks: " sequential_tasks " (have dependencies)"
-                if (total_effort) print "Estimated total effort: " total_effort " hours"
-            }
-        }
-    ' "$input_file" > "$output_file"
-
-    log_debug "Processed epic content with stats: $total_tasks total, $parallel_tasks parallel"
-    log_function_exit "process_epic_content"
-}
-
-# Calculate total effort from task files
-calculate_total_effort() {
-    local epic_dir="$1"
-    local total_effort=0
-
-    for task_file in "$epic_dir"/[0-9][0-9][0-9].md; do
-        [[ -f "$task_file" ]] || continue
-
-        local effort
-        effort=$(get_frontmatter_field "$task_file" "effort" 2>/dev/null || echo "")
-
-        if [[ "$effort" =~ ^[0-9]+$ ]]; then
-            total_effort=$((total_effort + effort))
-        fi
-    done
-
-    if [[ "$total_effort" -gt 0 ]]; then
-        echo "$total_effort"
-    fi
-}
-
-# Determine epic type from content
-determine_epic_type() {
-    local content_file="$1"
-
-    log_function_entry "determine_epic_type" "$content_file"
-
-    if grep -qi "bug\|fix\|issue\|problem\|error\|hotfix\|patch" "$content_file"; then
-        echo "bug"
-    else
-        echo "feature"
-    fi
-
-    log_function_exit "determine_epic_type"
-}
-
-# Create GitHub epic issue with proper labels
-create_epic_github_issue() {
-    local body_file="$1"
-    local epic_type="$2"
-
-    log_function_entry "create_epic_github_issue" "$body_file" "$epic_type"
-
-    local title="Epic: $EPIC_NAME"
-    local labels="epic,epic:$EPIC_NAME,$epic_type"
-
-    local issue_number
-    issue_number=$(create_github_issue "$title" "$body_file" "$labels")
-
-    log_function_exit "create_epic_github_issue" 0
-    echo "$issue_number"
-}
-
-# Error handling
-handle_error() {
-    local exit_code=$?
-    log_error "Script failed with exit code: $exit_code"
-    log_error "Epic issue creation failed for: $EPIC_NAME"
-    exit "$exit_code"
-}
-
-# Set up error handling
-trap handle_error ERR
-
-# Validate arguments
-if [[ $# -ne 1 ]]; then
+EPIC_NAME="${1:-}"
+
+if [[ -z "$EPIC_NAME" ]]; then
+    echo "❌ Error: Epic name required"
     echo "Usage: $0 <epic_name>"
-    echo ""
-    echo "Creates a GitHub issue for the specified epic."
-    echo ""
-    echo "Example:"
-    echo "  $0 authentication"
-    echo ""
     exit 1
 fi
 
-# Run main function
-main "$@"
+# Source utilities if they exist
+if [[ -f "$SCRIPT_DIR/../../lib/github-utils.sh" ]]; then
+    source "$SCRIPT_DIR/../../lib/github-utils.sh"
+fi
+
+EPIC_FILE=".claude/epics/$EPIC_NAME/epic.md"
+
+if [[ ! -f "$EPIC_FILE" ]]; then
+    echo "❌ Error: Epic file not found: $EPIC_FILE"
+    exit 1
+fi
+
+# Check GitHub CLI
+if ! command -v gh &> /dev/null; then
+    echo "❌ Error: GitHub CLI (gh) not installed"
+    exit 1
+fi
+
+# Check authentication
+if ! gh auth status &> /dev/null; then
+    echo "❌ Error: GitHub CLI not authenticated. Run: gh auth login"
+    exit 1
+fi
+
+# Strip frontmatter and get content
+epic_content=$(awk 'BEGIN{p=0} /^---$/{p++; next} p==2{print}' "$EPIC_FILE")
+
+# Count tasks
+task_count=$(find ".claude/epics/$EPIC_NAME" -name "[0-9]*.md" -type f 2>/dev/null | wc -l)
+
+# Detect epic type (bug vs feature)
+if echo "$epic_content" | grep -qi "bug\|fix\|error\|issue"; then
+    labels="epic,bug"
+else
+    labels="epic,feature"
+fi
+
+# Create issue
+echo "📝 Creating epic issue for: $EPIC_NAME"
+echo "   Tasks: $task_count"
+echo "   Labels: $labels"
+
+# Create the issue
+epic_number=$(gh issue create \
+    --title "Epic: $EPIC_NAME" \
+    --body "$epic_content
+
+---
+**Epic Statistics:**
+- Tasks: $task_count
+- Status: Planning
+- Created: $(date -u +"%Y-%m-%dT%H:%M:%SZ")
+" \
+    --label "$labels" \
+    2>&1 | grep -oP '(?<=#)[0-9]+' | head -1)
+
+if [[ -z "$epic_number" ]]; then
+    echo "❌ Error: Failed to create epic issue"
+    exit 1
+fi
+
+echo "$epic_number"

package/autopm/.claude/scripts/pm/epic-sync/create-task-issues.sh

@@ -1,354 +1,86 @@
 #!/bin/bash
-# Create Task Issues Script
-# Creates GitHub issues for all tasks in an epic with parallel execution support
+# Create Task Issues
+# Creates GitHub issues for all tasks and generates mapping file
 
 set -euo pipefail
 
-# Load libraries
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/../../lib/logging-utils.sh"
-source "${SCRIPT_DIR}/../../lib/github-utils.sh"
-source "${SCRIPT_DIR}/../../lib/frontmatter-utils.sh"
-source "${SCRIPT_DIR}/../../lib/validation-utils.sh"
+EPIC_NAME="${1:-}"
+EPIC_NUMBER="${2:-}"
 
-# Script configuration
-readonly EPIC_NAME="${1:-}"
-readonly EPIC_NUMBER="${2:-}"
-readonly PARALLEL_THRESHOLD="${AUTOPM_PARALLEL_THRESHOLD:-5}"
-
-# Global variables
-declare -g use_subissues=false
-declare -g temp_dir=""
-declare -g mapping_file=""
-
-# Main function
-main() {
-    print_banner "Task Issues Creator" "1.0.0"
-
-    # Validate inputs
-    log_info "Validating inputs: epic=$EPIC_NAME, epic_number=$EPIC_NUMBER"
-    validate_inputs || exit 1
-
-    # Setup workspace
-    setup_workspace
-
-    # Check GitHub capabilities
-    check_github_capabilities
-
-    # Get task files and determine strategy
-    local task_files
-    readarray -t task_files < <(find ".claude/epics/$EPIC_NAME" -name '[0-9][0-9][0-9].md' -type f | sort)
-    local task_count=${#task_files[@]}
-
-    log_info "Found $task_count task files"
-
-    if [[ $task_count -eq 0 ]]; then
-        log_error "No task files found in epic directory"
-        echo "❌ No tasks to sync. Run: /pm:epic-decompose $EPIC_NAME"
-        exit 1
-    fi
-
-    # Create issues based on count
-    if [[ $task_count -lt $PARALLEL_THRESHOLD ]]; then
-        log_info "Using sequential creation for $task_count tasks"
-        create_tasks_sequential "${task_files[@]}"
-    else
-        log_info "Using parallel creation for $task_count tasks"
-        create_tasks_parallel "${task_files[@]}"
-    fi
-
-    # Output results
-    display_results "$task_count"
-
-    # Return mapping file path for further processing
-    echo "$mapping_file"
-}
-
-# Validate script inputs
-validate_inputs() {
-    log_function_entry "validate_inputs"
-
-    validate_epic_name "$EPIC_NAME" || return 1
-    validate_issue_number "$EPIC_NUMBER" || return 1
-    validate_epic_structure "$EPIC_NAME" || return 1
-    validate_github_auth || return 1
-
-    log_function_exit "validate_inputs"
-    return 0
-}
-
-# Setup temporary workspace
-setup_workspace() {
-    log_function_entry "setup_workspace"
-
-    temp_dir="/tmp/task-issues-$$"
-    mapping_file="$temp_dir/task-mapping.txt"
-
-    log_info "Creating workspace: $temp_dir"
-    mkdir -p "$temp_dir"
-
-    # Initialize mapping file
-    > "$mapping_file"
-
-    # Cleanup on exit
-    trap "cleanup_workspace" EXIT
-
-    log_function_exit "setup_workspace"
-}
-
-# Cleanup workspace
-cleanup_workspace() {
-    if [[ -n "$temp_dir" ]] && [[ -d "$temp_dir" ]]; then
-        log_debug "Cleaning up workspace: $temp_dir"
-        rm -rf "$temp_dir"
-    fi
-}
-
-# Check GitHub capabilities (sub-issues extension)
-check_github_capabilities() {
-    log_function_entry "check_github_capabilities"
-
-    if gh extension list | grep -q "yahsan2/gh-sub-issue"; then
-        use_subissues=true
-        log_info "gh-sub-issue extension detected - using sub-issues"
-    else
-        use_subissues=false
-        log_warning "gh-sub-issue extension not available - using regular issues"
-    fi
-
-    log_function_exit "check_github_capabilities"
-}
-
-# Create tasks sequentially (for small batches)
-create_tasks_sequential() {
-    local task_files=("$@")
-
-    log_function_entry "create_tasks_sequential" "${#task_files[@]} tasks"
-
-    local labels="task,epic:$EPIC_NAME"
-    local processed=0
-
-    for task_file in "${task_files[@]}"; do
-        [[ -f "$task_file" ]] || continue
-
-        log_info "Processing task file: $(basename "$task_file")"
-
-        # Extract task name from frontmatter
-        local task_name
-        task_name=$(get_frontmatter_field "$task_file" "name")
-
-        if [[ -z "$task_name" ]]; then
-            log_error "No task name found in $task_file"
-            continue
-        fi
-
-        # Strip frontmatter for issue body
-        local task_body_file="$temp_dir/task-body-$(basename "$task_file")"
-        strip_frontmatter "$task_file" "$task_body_file"
-
-        # Create issue
-        local task_number
-        if [[ "$use_subissues" == "true" ]]; then
-            task_number=$(create_github_subissue "$EPIC_NUMBER" "$task_name" "$task_body_file" "$labels")
-        else
-            task_number=$(create_github_issue "$task_name" "$task_body_file" "$labels")
-        fi
+if [[ -z "$EPIC_NAME" ]] || [[ -z "$EPIC_NUMBER" ]]; then
+    echo "❌ Error: Epic name and epic number required"
+    echo "Usage: $0 <epic_name> <epic_number>"
+    exit 1
+fi
 
-        if [[ -n "$task_number" ]]; then
-            # Record mapping
-            echo "$task_file:$task_number" >> "$mapping_file"
-            processed=$((processed + 1))
-            log_success "Created task issue #$task_number: $task_name"
-        else
-            log_error "Failed to create issue for $task_file"
-        fi
-    done
+EPIC_DIR=".claude/epics/$EPIC_NAME"
 
-    log_info "Sequential creation completed: $processed/$# tasks created"
-    log_function_exit "create_tasks_sequential"
-}
+if [[ ! -d "$EPIC_DIR" ]]; then
+    echo "❌ Error: Epic directory not found: $EPIC_DIR"
+    exit 1
+fi
 
-# Create tasks in parallel (for large batches)
-create_tasks_parallel() {
-    local task_files=("$@")
+# Mapping file - PERSISTENT location (not in /tmp)
+MAPPING_FILE="$EPIC_DIR/.task-mapping.txt"
+> "$MAPPING_FILE"  # Clear/create file
 
-    log_function_entry "create_tasks_parallel" "${#task_files[@]} tasks"
+echo "📋 Creating task issues for epic #$EPIC_NUMBER"
 
-    local batch_size=4
-    local batches=()
-    local batch_count=0
+# Find all task files (sequential numbered files)
+task_files=$(find "$EPIC_DIR" -name "[0-9]*.md" -type f | sort)
 
-    # Split tasks into batches
-    for ((i=0; i<${#task_files[@]}; i+=batch_size)); do
-        local batch=("${task_files[@]:$i:$batch_size}")
-        batches+=("$(printf '%s\n' "${batch[@]}")")
-        batch_count=$((batch_count + 1))
-    done
+if [[ -z "$task_files" ]]; then
+    echo "❌ Error: No task files found in $EPIC_DIR"
+    exit 1
+fi
 
-    log_info "Split into $batch_count batches of up to $batch_size tasks each"
+task_count=$(echo "$task_files" | wc -l)
+echo "   Found $task_count tasks to create"
 
-    # Process batches in parallel using background jobs
-    local pids=()
-    local batch_mapping_files=()
+current=0
 
-    for ((b=0; b<batch_count; b++)); do
-        local batch_mapping="$temp_dir/batch-$b-mapping.txt"
-        batch_mapping_files+=("$batch_mapping")
+# Create issues for each task
+for task_file in $task_files; do
+    ((current++))
 
-        # Create batch in background
-        (
-            log_info "Starting batch $((b+1))/$batch_count"
-            process_task_batch "$b" "$batch_mapping" <<< "${batches[$b]}"
-        ) &
+    task_basename=$(basename "$task_file" .md)
 
-        pids+=($!)
-    done
+    # Strip frontmatter and get content
+    task_content=$(awk 'BEGIN{p=0} /^---$/{p++; next} p==2{print}' "$task_file")
 
-    # Wait for all batches to complete
-    log_info "Waiting for $batch_count parallel batches to complete..."
-    local failed_batches=0
+    # Extract title from first heading or use basename
+    task_title=$(echo "$task_content" | grep -m1 "^#" | sed 's/^# *//' || echo "Task $task_basename")
 
-    for ((p=0; p<${#pids[@]}; p++)); do
-        if wait "${pids[$p]}"; then
-            log_success "Batch $((p+1)) completed successfully"
-        else
-            log_error "Batch $((p+1)) failed"
-            failed_batches=$((failed_batches + 1))
-        fi
-    done
+    echo -n "   [$current/$task_count] Creating issue for task $task_basename... "
 
-    # Consolidate results
-    log_info "Consolidating results from $batch_count batches"
-    for batch_mapping in "${batch_mapping_files[@]}"; do
-        if [[ -f "$batch_mapping" ]]; then
-            cat "$batch_mapping" >> "$mapping_file"
-        fi
-    done
+    # Create task issue
+    issue_number=$(gh issue create \
+        --title "$task_title" \
+        --body "$task_content
 
-    local total_created
-    total_created=$(wc -l < "$mapping_file" 2>/dev/null || echo 0)
+---
+**Task Information:**
+- Epic: #$EPIC_NUMBER
+- Original ID: $task_basename
+- Created: $(date -u +"%Y-%m-%dT%H:%M:%SZ")
+" \
+        --label "task,epic:$EPIC_NAME" \
+        2>&1 | grep -oP '(?<=#)[0-9]+' | head -1)
 
-    if [[ $failed_batches -gt 0 ]]; then
-        log_warning "Parallel creation completed with $failed_batches failed batches"
-        log_warning "Created $total_created/${#task_files[@]} task issues"
+    if [[ -n "$issue_number" ]]; then
+        echo "#$issue_number ✓"
+        # Save mapping: old_name -> new_number
+        echo "$task_basename $issue_number" >> "$MAPPING_FILE"
     else
-        log_success "Parallel creation completed successfully"
-        log_success "Created $total_created/${#task_files[@]} task issues"
-    fi
-
-    log_function_exit "create_tasks_parallel"
-}
-
-# Process a single batch of tasks
-process_task_batch() {
-    local batch_number="$1"
-    local batch_mapping_file="$2"
-    local labels="task,epic:$EPIC_NAME"
-
-    # Read task files from stdin
-    local task_files=()
-    while IFS= read -r task_file; do
-        [[ -n "$task_file" ]] && task_files+=("$task_file")
-    done
-
-    log_debug "Batch $batch_number processing ${#task_files[@]} tasks"
-
-    > "$batch_mapping_file"  # Initialize batch mapping file
-
-    for task_file in "${task_files[@]}"; do
-        [[ -f "$task_file" ]] || continue
-
-        # Extract task name
-        local task_name
-        task_name=$(get_frontmatter_field "$task_file" "name")
-
-        if [[ -z "$task_name" ]]; then
-            log_error "No task name in $task_file"
-            continue
-        fi
-
-        # Strip frontmatter
-        local task_body_file="$temp_dir/batch-$batch_number-$(basename "$task_file")"
-        strip_frontmatter "$task_file" "$task_body_file"
-
-        # Create issue
-        local task_number
-        if [[ "$use_subissues" == "true" ]]; then
-            task_number=$(create_github_subissue "$EPIC_NUMBER" "$task_name" "$task_body_file" "$labels")
-        else
-            task_number=$(create_github_issue "$task_name" "$task_body_file" "$labels")
-        fi
-
-        if [[ -n "$task_number" ]]; then
-            echo "$task_file:$task_number" >> "$batch_mapping_file"
-            log_debug "Batch $batch_number: Created #$task_number for $(basename "$task_file")"
-        else
-            log_error "Batch $batch_number: Failed to create issue for $(basename "$task_file")"
-        fi
-    done
-
-    log_debug "Batch $batch_number completed"
-}
-
-# Display creation results
-display_results() {
-    local task_count="$1"
-    local created_count
-    created_count=$(wc -l < "$mapping_file" 2>/dev/null || echo 0)
-
-    print_section "✅ Task Issues Creation Results"
-
-    echo "Epic: $EPIC_NAME (Issue #$EPIC_NUMBER)"
-    echo "Strategy: $([[ $task_count -lt $PARALLEL_THRESHOLD ]] && echo "Sequential" || echo "Parallel")"
-    echo "Sub-issues: $([[ "$use_subissues" == "true" ]] && echo "Enabled" || echo "Disabled")"
-    echo "Created: $created_count/$task_count task issues"
-
-    if [[ $created_count -gt 0 ]]; then
-        echo ""
-        echo "Task mappings:"
-        while IFS=: read -r task_file issue_number; do
-            local task_name
-            task_name=$(basename "$task_file" .md)
-            echo "  #$issue_number: $task_name"
-        done < "$mapping_file"
-    fi
-
-    if [[ $created_count -lt $task_count ]]; then
-        echo ""
-        echo "⚠️  Some issues failed to create. Check logs for details."
+        echo "FAILED"
+        echo "⚠️  Failed to create issue for $task_basename"
     fi
-}
+done
 
-# Error handling
-handle_error() {
-    local exit_code=$?
-    log_error "Script failed with exit code: $exit_code"
-    log_error "Task issues creation failed for epic: $EPIC_NAME"
-    exit "$exit_code"
-}
-
-# Set up error handling
-trap handle_error ERR
-
-# Validate arguments
-if [[ $# -lt 2 ]]; then
-    echo "Usage: $0 <epic_name> <epic_issue_number>"
-    echo ""
-    echo "Creates GitHub issues for all tasks in the specified epic."
-    echo ""
-    echo "Arguments:"
-    echo "  epic_name           Name of the epic directory"
-    echo "  epic_issue_number   GitHub issue number of the parent epic"
-    echo ""
-    echo "Environment Variables:"
-    echo "  AUTOPM_PARALLEL_THRESHOLD   Minimum tasks for parallel execution (default: 5)"
-    echo ""
-    echo "Examples:"
-    echo "  $0 authentication 123"
-    echo "  AUTOPM_PARALLEL_THRESHOLD=3 $0 user-dashboard 456"
-    echo ""
-    exit 1
-fi
+echo ""
+echo "✅ Created $current task issues"
+echo "   Mapping saved to: $MAPPING_FILE"
 
-# Run main function
-main "$@"
+# Output the mapping file path for next script
+echo "$MAPPING_FILE"