claude-autopm 1.27.0 → 1.29.0

package/autopm/.claude/scripts/pm/prd-new.js

@@ -1,16 +1,282 @@
 #!/usr/bin/env node
 /**
  * PRD New - Launch brainstorming for new product requirement
+ *
+ * Supports:
+ * - Template-based creation (--template flag)
+ * - Interactive template selection
+ * - Traditional brainstorming mode (backwards compatible)
  */
 
 const fs = require('fs');
 const path = require('path');
 const readline = require('readline');
 
+// Dynamically resolve template engine path
+// This works both in installed projects and during testing
+let TemplateEngine;
+try {
+  // Try relative path from .claude/scripts/pm/
+  TemplateEngine = require(path.join(__dirname, '..', '..', '..', '..', 'lib', 'template-engine'));
+} catch (err) {
+  try {
+    // Try from project root
+    TemplateEngine = require(path.join(process.cwd(), 'lib', 'template-engine'));
+  } catch (err2) {
+    // Fallback to relative
+    TemplateEngine = require('../../../../lib/template-engine');
+  }
+}
+
 class PrdCreator {
   constructor() {
     this.prdsDir = path.join('.claude', 'prds');
     this.templatesDir = path.join(__dirname, '..', '..', 'templates');
+    this.templateEngine = new TemplateEngine();
+  }
+
+  /**
+   * Create PRD from template
+   */
+  async createPrdFromTemplate(prdName, templateName) {
+    console.log(`\n🚀 Creating PRD from Template: ${templateName}`);
+    console.log(`${'═'.repeat(50)}\n`);
+
+    // Ensure PRDs directory exists
+    if (!fs.existsSync(this.prdsDir)) {
+      fs.mkdirSync(this.prdsDir, { recursive: true });
+    }
+
+    // Check if PRD already exists
+    const prdFile = path.join(this.prdsDir, `${prdName}.md`);
+    if (fs.existsSync(prdFile)) {
+      console.error(`❌ PRD already exists: ${prdName}`);
+      console.log(`💡 Edit file: .claude/prds/${prdName}.md`);
+      return false;
+    }
+
+    // Find template
+    const templatePath = this.templateEngine.findTemplate('prds', templateName);
+    if (!templatePath) {
+      console.error(`❌ Template not found: ${templateName}`);
+      console.log(`💡 List available templates: autopm template:list`);
+      return false;
+    }
+
+    // Read template to find required variables
+    const templateContent = fs.readFileSync(templatePath, 'utf8');
+    const requiredVars = this.extractTemplateVariables(templateContent);
+
+    // Prompt for variables
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    const prompt = (question) => new Promise((resolve) => {
+      rl.question(question, resolve);
+    });
+
+    try {
+      console.log(`📋 Template: ${templateName}`);
+      console.log(`Fill in the following details:\n`);
+
+      const variables = {
+        title: prdName.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' '),
+        type: 'prd'
+      };
+
+      // Prompt for common variables
+      const title = await prompt(`Title [${variables.title}]: `);
+      if (title) variables.title = title;
+
+      const priority = await prompt('Priority (P0/P1/P2/P3) [P2]: ');
+      variables.priority = priority || 'P2';
+
+      const timeline = await prompt('Timeline [TBD]: ');
+      variables.timeline = timeline || 'TBD';
+
+      // Prompt for template-specific variables
+      const templateSpecific = this.getTemplateSpecificPrompts(templateName);
+      for (const varName of templateSpecific) {
+        if (!variables[varName]) {
+          const value = await prompt(`${varName.replace(/_/g, ' ')}: `);
+          variables[varName] = value || '';
+        }
+      }
+
+      // Render template
+      const rendered = this.templateEngine.renderFile(templatePath, variables);
+
+      // Write PRD file
+      fs.writeFileSync(prdFile, rendered);
+
+      console.log('\n✅ PRD created successfully!');
+      console.log(`📄 File: ${prdFile}`);
+
+      // Show next steps
+      this.showNextSteps(prdName);
+
+      return true;
+    } finally {
+      rl.close();
+    }
+  }
+
+  /**
+   * Extract variables from template
+   */
+  extractTemplateVariables(template) {
+    const varRegex = /\{\{(\w+)\}\}/g;
+    const vars = new Set();
+    let match;
+
+    while ((match = varRegex.exec(template)) !== null) {
+      vars.add(match[1]);
+    }
+
+    // Remove auto-generated variables
+    vars.delete('id');
+    vars.delete('timestamp');
+    vars.delete('date');
+    vars.delete('author');
+
+    return Array.from(vars);
+  }
+
+  /**
+   * Get template-specific prompts
+   */
+  getTemplateSpecificPrompts(templateName) {
+    const prompts = {
+      'api-feature': [
+        'api_purpose',
+        'problem',
+        'business_value',
+        'http_method',
+        'api_endpoint',
+        'auth_method',
+        'rate_limit',
+        'user_role',
+        'api_action',
+        'user_benefit'
+      ],
+      'ui-feature': [
+        'component_type',
+        'feature_purpose',
+        'problem',
+        'user_need',
+        'user_goal',
+        'user_role',
+        'user_action',
+        'user_benefit'
+      ],
+      'bug-fix': [
+        'bug_summary',
+        'severity',
+        'user_impact',
+        'step_1',
+        'step_2',
+        'step_3',
+        'expected_behavior',
+        'actual_behavior',
+        'root_cause',
+        'solution_approach'
+      ],
+      'data-migration': [
+        'migration_purpose',
+        'current_state',
+        'desired_state',
+        'affected_tables',
+        'data_volume',
+        'migration_strategy'
+      ],
+      'documentation': [
+        'doc_type',
+        'target_audience',
+        'documentation_scope',
+        'current_gaps'
+      ]
+    };
+
+    return prompts[templateName] || [];
+  }
+
+  /**
+   * Show interactive template selection
+   */
+  async selectTemplate() {
+    const templates = this.templateEngine.listTemplates('prds');
+
+    if (templates.length === 0) {
+      console.log('No templates available');
+      return null;
+    }
+
+    console.log('\n📋 Available Templates:');
+
+    const builtIn = templates.filter(t => !t.custom);
+    const custom = templates.filter(t => t.custom);
+
+    let index = 1;
+    const options = [];
+
+    builtIn.forEach(t => {
+      const description = this.getTemplateDescription(t.name);
+      console.log(`${index}. ${t.name.padEnd(20)} - ${description}`);
+      options.push(t.name);
+      index++;
+    });
+
+    if (custom.length > 0) {
+      console.log('\nCustom Templates:');
+      custom.forEach(t => {
+        console.log(`${index}. ${t.name.padEnd(20)} - [Custom]`);
+        options.push(t.name);
+        index++;
+      });
+    }
+
+    console.log(`${index}. none${' '.repeat(20)} - Create empty PRD\n`);
+    options.push('none');
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    const prompt = (question) => new Promise((resolve) => {
+      rl.question(question, resolve);
+    });
+
+    try {
+      const selection = await prompt(`Select template (1-${options.length}): `);
+      const selectionNum = parseInt(selection, 10);
+
+      if (selectionNum < 1 || selectionNum > options.length) {
+        console.error('Invalid selection');
+        return null;
+      }
+
+      return options[selectionNum - 1];
+    } finally {
+      rl.close();
+    }
+  }
+
+  /**
+   * Get template description
+   */
+  getTemplateDescription(templateName) {
+    const descriptions = {
+      'api-feature': 'REST/GraphQL API development',
+      'ui-feature': 'Frontend component/page',
+      'bug-fix': 'Bug resolution workflow',
+      'data-migration': 'Database schema changes',
+      'documentation': 'Documentation updates'
+    };
+
+    return descriptions[templateName] || 'Template';
   }
 
   async createPrd(prdName) {
@@ -319,7 +585,19 @@ ${data.technical || 'Technical requirements to be specified...'}
   }
 
   async run(args) {
-    let prdName = args[0];
+    // Parse arguments
+    let prdName = null;
+    let templateName = null;
+
+    // Check for --template or -t flag
+    for (let i = 0; i < args.length; i++) {
+      if (args[i] === '--template' || args[i] === '-t') {
+        templateName = args[i + 1];
+        i++; // Skip next arg
+      } else if (!prdName) {
+        prdName = args[i];
+      }
+    }
 
     if (!prdName) {
       // Interactive mode
@@ -345,12 +623,24 @@ ${data.technical || 'Technical requirements to be specified...'}
         console.error('❌ Error: PRD name required');
         process.exit(1);
       }
+
+      // Ask for template if not provided
+      if (!templateName) {
+        templateName = await this.selectTemplate();
+      }
     }
 
     // Sanitize PRD name
     prdName = prdName.toLowerCase().replace(/[^a-z0-9-]/g, '-');
 
-    const success = await this.createPrd(prdName);
+    // Create PRD from template or traditional mode
+    let success;
+    if (templateName && templateName !== 'none') {
+      success = await this.createPrdFromTemplate(prdName, templateName);
+    } else {
+      success = await this.createPrd(prdName);
+    }
+
     process.exit(success ? 0 : 1);
   }
 }

package/autopm/.claude/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;