claude-autopm 2.8.2 → 2.8.4

package/packages/plugin-pm/scripts/pm/standup.sh

@@ -0,0 +1,95 @@
+#!/bin/bash
+
+# PM Standup Script - Wrapper for Node.js implementation
+# This wrapper maintains backward compatibility while delegating to the Node.js version
+
+# Get the directory of this script
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Check if Node.js is available
+if command -v node >/dev/null 2>&1; then
+  # Use the Node.js implementation
+  node "$SCRIPT_DIR/standup.js"
+  exit $?
+else
+  # Fallback to the original bash implementation if Node.js is not available
+  echo "⚠️ Node.js not found, falling back to bash implementation"
+  echo ""
+
+  # Original bash implementation (preserved for fallback)
+  echo "📅 Daily Standup - $(date '+%Y-%m-%d')"
+  echo "================================"
+  echo ""
+
+  today=$(date '+%Y-%m-%d')
+
+  echo "Getting status..."
+  echo ""
+  echo ""
+
+  echo "📝 Today's Activity:"
+  echo "===================="
+  echo ""
+
+  # Find files modified today
+  recent_files=$(find .claude -name "*.md" -mtime -1 2>/dev/null)
+
+  if [ -n "$recent_files" ]; then
+    # Count by type
+    prd_count=$(echo "$recent_files" | grep -c "/prds/" || echo 0)
+    epic_count=$(echo "$recent_files" | grep -c "/epic.md" || echo 0)
+    task_count=$(echo "$recent_files" | grep -c "/[0-9]*.md" || echo 0)
+    update_count=$(echo "$recent_files" | grep -c "/updates/" || echo 0)
+
+    [ $prd_count -gt 0 ] && echo "  • Modified $prd_count PRD(s)"
+    [ $epic_count -gt 0 ] && echo "  • Updated $epic_count epic(s)"
+    [ $task_count -gt 0 ] && echo "  • Worked on $task_count task(s)"
+    [ $update_count -gt 0 ] && echo "  • Posted $update_count progress update(s)"
+  else
+    echo "  No activity recorded today"
+  fi
+
+  echo ""
+  echo "🔄 Currently In Progress:"
+  # Show active work items
+  for updates_dir in .claude/epics/*/updates/*/; do
+    [ -d "$updates_dir" ] || continue
+    if [ -f "$updates_dir/progress.md" ]; then
+      issue_num=$(basename "$updates_dir")
+      epic_name=$(basename $(dirname $(dirname "$updates_dir")))
+      completion=$(grep "^completion:" "$updates_dir/progress.md" | head -1 | sed 's/^completion: *//')
+      echo "  • Issue #$issue_num ($epic_name) - ${completion:-0%} complete"
+    fi
+  done
+
+  echo ""
+  echo "⏭️ Next Available Tasks:"
+  # Show top 3 available tasks
+  count=0
+  for epic_dir in .claude/epics/*/; do
+    [ -d "$epic_dir" ] || continue
+    for task_file in "$epic_dir"[0-9]*.md; do
+      [ -f "$task_file" ] || continue
+      status=$(grep "^status:" "$task_file" | head -1 | sed 's/^status: *//')
+      [ "$status" != "open" ] && [ -n "$status" ] && continue
+
+      deps=$(grep "^depends_on:" "$task_file" | head -1 | sed 's/^depends_on: *\[//' | sed 's/\]//')
+      if [ -z "$deps" ] || [ "$deps" = "depends_on:" ]; then
+        task_name=$(grep "^name:" "$task_file" | head -1 | sed 's/^name: *//')
+        task_num=$(basename "$task_file" .md)
+        echo "  • #$task_num - $task_name"
+        ((count++))
+        [ $count -ge 3 ] && break 2
+      fi
+    done
+  done
+
+  echo ""
+  echo "📊 Quick Stats:"
+  total_tasks=$(find .claude/epics -name "[0-9]*.md" 2>/dev/null | wc -l)
+  open_tasks=$(find .claude/epics -name "[0-9]*.md" -exec grep -l "^status: *open" {} \; 2>/dev/null | wc -l)
+  closed_tasks=$(find .claude/epics -name "[0-9]*.md" -exec grep -l "^status: *closed" {} \; 2>/dev/null | wc -l)
+  echo "  Tasks:        $open_tasks open,        $closed_tasks closed,        $total_tasks total"
+
+  exit 0
+fi

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

@@ -0,0 +1,148 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * PM Status Script (Node.js version)
+ * Migrated from bash script with 100% backward compatibility
+ */
+
+async function status() {
+  const result = {
+    prds: { total: 0, found: false },
+    epics: { total: 0, found: false },
+    tasks: { total: 0, open: 0, closed: 0, found: false },
+    messages: []
+  };
+
+  // Helper function to add messages
+  function addMessage(message) {
+    result.messages.push(message);
+    // Only log if running as CLI
+    if (require.main === module) {
+      console.log(message);
+    }
+  }
+
+  // Header messages to match bash output exactly
+  addMessage('Getting status...');
+  addMessage('');
+  addMessage('');
+  addMessage('📊 Project Status');
+  addMessage('================');
+  addMessage('');
+
+  // Check PRDs
+  addMessage('📄 PRDs:');
+  try {
+    if (fs.existsSync('.claude/prds') && fs.statSync('.claude/prds').isDirectory()) {
+      const prdFiles = fs.readdirSync('.claude/prds')
+        .filter(file => file.endsWith('.md'));
+
+      result.prds.total = prdFiles.length;
+      result.prds.found = true;
+      addMessage(`  Total:        ${result.prds.total}`);
+    } else {
+      addMessage('  No PRDs found');
+    }
+  } catch (err) {
+    addMessage('  No PRDs found');
+  }
+
+  addMessage('');
+
+  // Check Epics
+  addMessage('📚 Epics:');
+  try {
+    if (fs.existsSync('.claude/epics') && fs.statSync('.claude/epics').isDirectory()) {
+      const epicDirs = fs.readdirSync('.claude/epics', { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .length;
+
+      result.epics.total = epicDirs;
+      result.epics.found = true;
+      addMessage(`  Total:        ${result.epics.total}`);
+    } else {
+      addMessage('  No epics found');
+    }
+  } catch (err) {
+    addMessage('  No epics found');
+  }
+
+  addMessage('');
+
+  // Check Tasks
+  addMessage('📝 Tasks:');
+  try {
+    if (fs.existsSync('.claude/epics') && fs.statSync('.claude/epics').isDirectory()) {
+      const epicDirs = fs.readdirSync('.claude/epics', { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name);
+
+      let totalTasks = 0;
+      let openTasks = 0;
+      let closedTasks = 0;
+
+      for (const epicDir of epicDirs) {
+        const epicPath = path.join('.claude/epics', epicDir);
+
+        try {
+          const taskFiles = fs.readdirSync(epicPath)
+            .filter(file => /^[0-9].*\.md$/.test(file));
+
+          for (const taskFile of taskFiles) {
+            totalTasks++;
+
+            try {
+              const taskPath = path.join(epicPath, taskFile);
+              const content = fs.readFileSync(taskPath, 'utf8');
+
+              // Check status line
+              const statusMatch = content.match(/^status:\s*(.+)$/m);
+              const status = statusMatch ? statusMatch[1].trim() : '';
+
+              if (status === 'closed') {
+                closedTasks++;
+              } else {
+                // Anything that's not explicitly closed is considered open
+                openTasks++;
+              }
+            } catch (err) {
+              // If we can't read the file, count as open
+              openTasks++;
+            }
+          }
+        } catch (err) {
+          // Skip directories we can't read
+        }
+      }
+
+      result.tasks.total = totalTasks;
+      result.tasks.open = openTasks;
+      result.tasks.closed = closedTasks;
+      result.tasks.found = totalTasks > 0;
+
+      addMessage(`  Open:        ${result.tasks.open}`);
+      addMessage(`  Closed:        ${result.tasks.closed}`);
+      addMessage(`  Total:        ${result.tasks.total}`);
+    } else {
+      addMessage('  No tasks found');
+    }
+  } catch (err) {
+    addMessage('  No tasks found');
+  }
+
+  return result;
+}
+
+// Export for use as module
+module.exports = status;
+
+// CLI execution
+if (require.main === module) {
+  status().then(result => {
+    process.exit(0);
+  }).catch(err => {
+    console.error('Status failed:', err.message);
+    process.exit(1);
+  });
+}

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

@@ -0,0 +1,59 @@
+#!/bin/bash
+
+# PM Status Script - Wrapper for Node.js implementation
+# This wrapper maintains backward compatibility while delegating to the Node.js version
+
+# Get the directory of this script
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Check if Node.js is available
+if command -v node >/dev/null 2>&1; then
+  # Use the Node.js implementation
+  node "$SCRIPT_DIR/status.js"
+  exit $?
+else
+  # Fallback to the original bash implementation if Node.js is not available
+  echo "⚠️ Node.js not found, falling back to bash implementation"
+  echo ""
+
+  # Original bash implementation (preserved for fallback)
+  echo "Getting status..."
+  echo ""
+  echo ""
+
+  echo "📊 Project Status"
+  echo "================"
+  echo ""
+
+  echo "📄 PRDs:"
+  if [ -d ".claude/prds" ]; then
+    total=$(ls .claude/prds/*.md 2>/dev/null | wc -l)
+    echo "  Total:        $total"
+  else
+    echo "  No PRDs found"
+  fi
+
+  echo ""
+  echo "📚 Epics:"
+  if [ -d ".claude/epics" ]; then
+    total=$(ls -d .claude/epics/*/ 2>/dev/null | wc -l)
+    echo "  Total:        $total"
+  else
+    echo "  No epics found"
+  fi
+
+  echo ""
+  echo "📝 Tasks:"
+  if [ -d ".claude/epics" ]; then
+    total=$(find .claude/epics -name "[0-9]*.md" 2>/dev/null | wc -l)
+    open=$(find .claude/epics -name "[0-9]*.md" -exec grep -l "^status: *open" {} \; 2>/dev/null | wc -l)
+    closed=$(find .claude/epics -name "[0-9]*.md" -exec grep -l "^status: *closed" {} \; 2>/dev/null | wc -l)
+    echo "  Open:        $open"
+    echo "  Closed:        $closed"
+    echo "  Total:        $total"
+  else
+    echo "  No tasks found"
+  fi
+
+  exit 0
+fi

package/packages/plugin-pm/scripts/pm/sync-batch.js

@@ -0,0 +1,337 @@
+#!/usr/bin/env node
+/**
+ * Batch Sync Command
+ *
+ * Synchronize multiple PRDs/Epics/Tasks to GitHub in batch operations
+ * with parallel processing, rate limiting, and progress tracking.
+ *
+ * Usage:
+ *   autopm sync:batch                    # Sync all items
+ *   autopm sync:batch --type prd         # Sync only PRDs
+ *   autopm sync:batch --type epic        # Sync only Epics
+ *   autopm sync:batch --type task        # Sync only Tasks
+ *   autopm sync:batch --dry-run          # Preview without syncing
+ *   autopm sync:batch --concurrent 5     # Limit concurrency
+ *
+ * Features:
+ *   - Parallel processing (default: 10 concurrent)
+ *   - GitHub API rate limiting with backoff
+ *   - Real-time progress tracking
+ *   - Error recovery (continues on failures)
+ *   - Dry run mode
+ *
+ * Performance:
+ *   - 1000 items: < 30 seconds
+ *   - Respects GitHub API limits (5000 req/hour)
+ *   - Memory efficient: < 100MB for 1000 items
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { Octokit } = require('@octokit/rest');
+const { batchSyncAll, batchSyncPRDs, batchSyncEpics, batchSyncTasks } = require('../../../../lib/batch-processor-integration');
+
+class SyncBatchCommand {
+  constructor() {
+    this.basePath = '.claude';
+  }
+
+  /**
+   * Get GitHub repository info from git remote
+   */
+  async getRepoInfo() {
+    const { execSync } = require('child_process');
+
+    try {
+      const remoteUrl = execSync('git remote get-url origin', { encoding: 'utf8' }).trim();
+
+      // Parse GitHub URL: https://github.com/owner/repo.git or git@github.com:owner/repo.git
+      const match = remoteUrl.match(/github\.com[:/]([^/]+)\/(.+?)(\.git)?$/);
+
+      if (!match) {
+        throw new Error('Could not parse GitHub repository URL');
+      }
+
+      return {
+        owner: match[1],
+        repo: match[2]
+      };
+    } catch (error) {
+      throw new Error('Failed to get repository info. Are you in a Git repository with GitHub remote?');
+    }
+  }
+
+  /**
+   * Show help message
+   */
+  showHelp() {
+    console.log(`
+📦 Batch Sync Command
+
+Synchronize multiple PRDs/Epics/Tasks to GitHub in parallel.
+
+Usage:
+  autopm sync:batch [options]
+
+Options:
+  --type <type>       Type to sync: prd|epic|task|all (default: all)
+  --dry-run           Preview without syncing
+  --concurrent <n>    Max concurrent uploads (default: 10)
+  --help              Show this help
+
+Examples:
+  autopm sync:batch                    # Sync all items
+  autopm sync:batch --type prd         # Sync only PRDs
+  autopm sync:batch --dry-run          # Preview changes
+  autopm sync:batch --concurrent 5     # Limit to 5 parallel
+
+Performance:
+  - 1000 items: ~30 seconds
+  - Rate limiting: Automatic backoff
+  - Memory: < 100MB for 1000 items
+
+Environment:
+  GITHUB_TOKEN        GitHub personal access token (required)
+`);
+  }
+
+  /**
+   * Parse command line arguments
+   */
+  parseArgs(args) {
+    const options = {
+      type: 'all',
+      dryRun: false,
+      maxConcurrent: 10
+    };
+
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+
+      if (arg === '--help' || arg === '-h') {
+        this.showHelp();
+        process.exit(0);
+      } else if (arg === '--type' || arg === '-t') {
+        options.type = args[++i];
+        if (!['prd', 'epic', 'task', 'all'].includes(options.type)) {
+          throw new Error(`Invalid type: ${options.type}. Must be: prd|epic|task|all`);
+        }
+      } else if (arg === '--dry-run' || arg === '-d') {
+        options.dryRun = true;
+      } else if (arg === '--concurrent' || arg === '-c') {
+        options.maxConcurrent = parseInt(args[++i], 10);
+        if (isNaN(options.maxConcurrent) || options.maxConcurrent < 1) {
+          throw new Error('--concurrent must be a positive number');
+        }
+      } else {
+        throw new Error(`Unknown option: ${arg}. Use --help for usage.`);
+      }
+    }
+
+    return options;
+  }
+
+  /**
+   * Format duration in human-readable form
+   */
+  formatDuration(ms) {
+    if (ms < 1000) {
+      return `${ms}ms`;
+    }
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+
+    if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
+    }
+    return `${seconds}s`;
+  }
+
+  /**
+   * Print progress bar
+   */
+  printProgress(type, current, total) {
+    const percentage = Math.floor((current / total) * 100);
+    const barLength = 30;
+    const filledLength = Math.floor((current / total) * barLength);
+    const bar = '█'.repeat(filledLength) + '░'.repeat(barLength - filledLength);
+
+    process.stdout.write(`\r  [${type.toUpperCase().padEnd(5)}] ${bar} ${percentage}% (${current}/${total})`);
+
+    if (current === total) {
+      console.log(); // New line when complete
+    }
+  }
+
+  /**
+   * Run batch sync
+   */
+  async run(args) {
+    try {
+      // Parse arguments
+      const options = this.parseArgs(args);
+
+      // Check for GitHub token
+      const githubToken = process.env.GITHUB_TOKEN;
+      if (!githubToken) {
+        console.error('❌ Error: GITHUB_TOKEN environment variable not set');
+        console.error('\nSet your GitHub token:');
+        console.error('  export GITHUB_TOKEN=your_token_here');
+        console.error('\nOr create a .env file with:');
+        console.error('  GITHUB_TOKEN=your_token_here');
+        process.exit(1);
+      }
+
+      // Get repository info
+      console.log('🔍 Detecting repository...');
+      const repo = await this.getRepoInfo();
+      console.log(`   Repository: ${repo.owner}/${repo.repo}`);
+
+      // Initialize Octokit
+      const octokit = new Octokit({ auth: githubToken });
+
+      // Verify API access
+      try {
+        await octokit.rest.users.getAuthenticated();
+      } catch (error) {
+        console.error('❌ GitHub authentication failed. Check your GITHUB_TOKEN.');
+        process.exit(1);
+      }
+
+      // Show configuration
+      console.log('\n⚙️  Configuration:');
+      console.log(`   Type: ${options.type}`);
+      console.log(`   Dry run: ${options.dryRun ? 'Yes' : 'No'}`);
+      console.log(`   Max concurrent: ${options.maxConcurrent}`);
+
+      // Start sync
+      const startTime = Date.now();
+      console.log(`\n🚀 Starting batch sync...${options.dryRun ? ' (DRY RUN)' : ''}\n`);
+
+      let results;
+
+      // Sync based on type
+      if (options.type === 'all') {
+        results = await batchSyncAll({
+          basePath: this.basePath,
+          owner: repo.owner,
+          repo: repo.repo,
+          octokit,
+          dryRun: options.dryRun,
+          maxConcurrent: options.maxConcurrent,
+          onProgress: (type, current, total) => {
+            this.printProgress(type, current, total);
+          }
+        });
+      } else if (options.type === 'prd') {
+        results = await batchSyncPRDs({
+          basePath: this.basePath,
+          owner: repo.owner,
+          repo: repo.repo,
+          octokit,
+          dryRun: options.dryRun,
+          maxConcurrent: options.maxConcurrent,
+          onProgress: (current, total) => {
+            this.printProgress('prd', current, total);
+          }
+        });
+      } else if (options.type === 'epic') {
+        results = await batchSyncEpics({
+          basePath: this.basePath,
+          owner: repo.owner,
+          repo: repo.repo,
+          octokit,
+          dryRun: options.dryRun,
+          maxConcurrent: options.maxConcurrent,
+          onProgress: (current, total) => {
+            this.printProgress('epic', current, total);
+          }
+        });
+      } else if (options.type === 'task') {
+        results = await batchSyncTasks({
+          basePath: this.basePath,
+          owner: repo.owner,
+          repo: repo.repo,
+          octokit,
+          dryRun: options.dryRun,
+          maxConcurrent: options.maxConcurrent,
+          onProgress: (current, total) => {
+            this.printProgress('task', current, total);
+          }
+        });
+      }
+
+      const duration = Date.now() - startTime;
+
+      // Print summary
+      console.log('\n' + '═'.repeat(50));
+      console.log('📊 Batch Sync Summary');
+      console.log('═'.repeat(50));
+
+      if (options.type === 'all') {
+        console.log(`\n📋 PRDs:     ${results.prds.succeeded}/${results.prds.total} synced`);
+        console.log(`📚 Epics:    ${results.epics.succeeded}/${results.epics.total} synced`);
+        console.log(`✅ Tasks:    ${results.tasks.succeeded}/${results.tasks.total} synced`);
+        console.log(`\n📦 Total:    ${results.succeeded}/${results.total} items`);
+
+        if (results.failed > 0) {
+          console.log(`❌ Failed:   ${results.failed}`);
+        }
+      } else {
+        console.log(`\n✅ Succeeded: ${results.succeeded}`);
+        console.log(`❌ Failed:    ${results.failed}`);
+        console.log(`📦 Total:     ${results.total}`);
+      }
+
+      console.log(`\n⏱️  Duration:  ${this.formatDuration(duration)}`);
+
+      if (results.rateLimit) {
+        console.log(`🔄 Rate limit: ${results.rateLimit.remaining} requests remaining`);
+      }
+
+      // Show errors if any
+      if (results.errors && results.errors.length > 0) {
+        console.log(`\n⚠️  Errors (${results.errors.length}):`);
+        results.errors.slice(0, 5).forEach(err => {
+          console.log(`   • ${err.item}: ${err.error}`);
+        });
+
+        if (results.errors.length > 5) {
+          console.log(`   ... and ${results.errors.length - 5} more`);
+        }
+      }
+
+      console.log('\n' + '═'.repeat(50));
+
+      // Exit code based on results
+      if (results.failed === 0) {
+        console.log('✅ All items synced successfully!');
+        process.exit(0);
+      } else if (results.succeeded > 0) {
+        console.log('⚠️  Partial sync completed (some errors)');
+        process.exit(0);
+      } else {
+        console.log('❌ Sync failed');
+        process.exit(1);
+      }
+
+    } catch (error) {
+      console.error('\n❌ Error:', error.message);
+
+      if (error.stack && process.env.DEBUG) {
+        console.error('\nStack trace:');
+        console.error(error.stack);
+      }
+
+      process.exit(1);
+    }
+  }
+}
+
+// Main execution
+if (require.main === module) {
+  const command = new SyncBatchCommand();
+  command.run(process.argv.slice(2));
+}
+
+module.exports = SyncBatchCommand;