claude-autopm 2.2.2 → 2.3.0

package/lib/ai-providers/ClaudeProvider.js

@@ -396,6 +396,21 @@ class ClaudeProvider extends AbstractAIProvider {
   // BACKWARD COMPATIBILITY METHODS
   // ============================================================
 
+  /**
+   * Generate text completion (alias for complete)
+   *
+   * Provides a more generic interface name for consistency with other services.
+   * This is an alias for complete() with identical functionality.
+   *
+   * @param {string} prompt - The prompt to complete
+   * @param {Object} [options={}] - Optional configuration
+   * @returns {Promise<string>} The completed text
+   * @throws {AIProviderError} On API errors
+   */
+  async generate(prompt, options = {}) {
+    return await this.complete(prompt, options);
+  }
+
   /**
    * Get the current model being used (legacy method for backward compatibility)
    *

package/lib/cli/commands/prd.js

@@ -13,11 +13,13 @@
  */
 
 const PRDService = require('../../services/PRDService');
+const ClaudeProvider = require('../../ai-providers/ClaudeProvider');
 const fs = require('fs-extra');
 const ora = require('ora');
 const chalk = require('chalk');
 const path = require('path');
 const { spawn } = require('child_process');
+const readline = require('readline');
 
 /**
  * Get PRD file path
@@ -304,6 +306,12 @@ async function prdStatus(argv) {
  * @param {Object} argv - Command arguments
  */
 async function prdNew(argv) {
+  // Check if AI mode is enabled
+  if (argv.ai) {
+    return await prdNewWithAI(argv);
+  }
+
+  // Standard mode: spawn prd-new.js
   const spinner = ora(`Creating PRD: ${argv.name}`).start();
 
   try {
@@ -397,6 +405,171 @@ async function prdNew(argv) {
   }
 }
 
+/**
+ * Create new PRD with AI assistance
+ * @param {Object} argv - Command arguments
+ */
+async function prdNewWithAI(argv) {
+  console.log(chalk.cyan(`\n🤖 AI-Powered PRD Creation: ${argv.name}`));
+  console.log(chalk.cyan('══════════════════════════════════════\n'));
+
+  const spinner = ora('Initializing...').start();
+
+  try {
+    // Check if PRD already exists
+    const prdPath = getPrdPath(argv.name);
+    const exists = await fs.pathExists(prdPath);
+    if (exists) {
+      spinner.fail(chalk.red('PRD already exists'));
+      console.error(chalk.red(`\nError: PRD file already exists: ${prdPath}`));
+      console.error(chalk.yellow('Use: autopm prd edit ' + argv.name + ' to modify it'));
+      process.exit(1);
+    }
+
+    // Create PRDs directory if needed
+    const prdsDir = path.join(process.cwd(), '.claude', 'prds');
+    await fs.ensureDir(prdsDir);
+
+    spinner.stop();
+
+    // Gather information from user
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    const prompt = (question) => new Promise((resolve) => {
+      rl.question(question, resolve);
+    });
+
+    console.log(chalk.cyan('🧠 Let\'s gather some information for AI...\n'));
+
+    const context = {};
+
+    // Product Vision
+    console.log(chalk.bold('📌 Product Vision'));
+    console.log(chalk.gray('What problem are you solving? What\'s the vision?'));
+    context.vision = await prompt(chalk.cyan('Vision: '));
+
+    // Target Users
+    console.log(chalk.bold('\n👥 Target Users'));
+    console.log(chalk.gray('Who will use this? What are their needs?'));
+    context.users = await prompt(chalk.cyan('Target users: '));
+
+    // Key Features (simplified - just high level)
+    console.log(chalk.bold('\n✨ Key Features'));
+    console.log(chalk.gray('What are the main capabilities? (brief description)'));
+    context.features = await prompt(chalk.cyan('Features: '));
+
+    // Success Metrics
+    console.log(chalk.bold('\n📊 Success Metrics'));
+    console.log(chalk.gray('How will you measure success?'));
+    context.metrics = await prompt(chalk.cyan('Metrics: '));
+
+    // Priority
+    console.log(chalk.bold('\n🎯 Priority'));
+    const priority = await prompt(chalk.cyan('Priority (P0/P1/P2/P3) [P2]: '));
+    context.priority = priority || 'P2';
+
+    // Timeline
+    console.log(chalk.bold('\n⏰ Timeline'));
+    const timeline = await prompt(chalk.cyan('Timeline [Q1 2025]: '));
+    context.timeline = timeline || 'Q1 2025';
+
+    rl.close();
+
+    // Build AI prompt
+    const aiPrompt = `Generate a comprehensive Product Requirements Document (PRD) based on the following information:
+
+**PRD Name**: ${argv.name}
+**Priority**: ${context.priority}
+**Timeline**: ${context.timeline}
+
+**Product Vision**:
+${context.vision}
+
+**Target Users**:
+${context.users}
+
+**Key Features**:
+${context.features}
+
+**Success Metrics**:
+${context.metrics}
+
+Please generate a complete, professional PRD with the following sections:
+1. Executive Summary
+2. Problem Statement (with Background, Current State, Desired State)
+3. Target Users (with User Personas and User Stories)
+4. Key Features (organized by priority: Must Have, Should Have, Nice to Have)
+5. Success Metrics (with KPIs and Measurement Plan)
+6. Technical Requirements (Architecture, Non-Functional Requirements, Dependencies)
+7. Implementation Plan (broken into phases)
+8. Risks and Mitigation
+9. Open Questions
+10. Appendix (References, Glossary, Changelog)
+
+Format the output as a proper markdown document with frontmatter (status, priority, created, author, timeline).
+
+Make it comprehensive, actionable, and professional. Expand on the provided information with industry best practices.`;
+
+    // Initialize AI provider and PRD service
+    const provider = new ClaudeProvider();
+    const prdService = new PRDService({ provider });
+    let prdContent = '';
+
+    if (argv.stream) {
+      // Streaming mode
+      const genSpinner = ora('Generating PRD with AI...').start();
+      genSpinner.stop();
+
+      console.log(chalk.cyan('\n\n🤖 AI is generating your PRD...\n'));
+      console.log(chalk.gray('─'.repeat(80)) + '\n');
+
+      for await (const chunk of prdService.generatePRDStream(aiPrompt)) {
+        process.stdout.write(chunk);
+        prdContent += chunk;
+      }
+
+      console.log('\n\n' + chalk.gray('─'.repeat(80)));
+    } else {
+      // Non-streaming mode
+      const genSpinner = ora('Generating PRD with AI...').start();
+      prdContent = await prdService.generatePRD(aiPrompt);
+      genSpinner.succeed(chalk.green('PRD generated'));
+    }
+
+    // Save to file
+    const saveSpinner = ora('Saving PRD...').start();
+    await fs.writeFile(prdPath, prdContent);
+    saveSpinner.succeed(chalk.green('PRD saved'));
+
+    console.log(chalk.green('\n✅ AI-powered PRD created successfully!'));
+    console.log(chalk.cyan(`📄 File: ${prdPath}\n`));
+
+    // Show next steps
+    console.log(chalk.bold('📋 What You Can Do Next:\n'));
+    console.log(`  ${chalk.cyan('1.')} Review and edit: ${chalk.yellow('autopm prd edit ' + argv.name)}`);
+    console.log(`  ${chalk.cyan('2.')} Check status:    ${chalk.yellow('autopm prd status ' + argv.name)}`);
+    console.log(`  ${chalk.cyan('3.')} Parse to epic:   ${chalk.yellow('autopm prd parse ' + argv.name + ' --ai')}`);
+    console.log(`  ${chalk.cyan('4.')} Extract epics:   ${chalk.yellow('autopm prd extract-epics ' + argv.name)}\n`);
+
+  } catch (error) {
+    console.error(chalk.red(`\n✗ Error: ${error.message}`));
+
+    if (error.message.includes('ANTHROPIC_API_KEY') || error.message.includes('API key')) {
+      console.error(chalk.red('\n✗ Error: API key not configured'));
+      console.error(chalk.yellow('\n💡 Set your API key in .env file:'));
+      console.error(chalk.cyan('  ANTHROPIC_API_KEY=sk-ant-api03-...'));
+    } else if (process.env.DEBUG) {
+      console.error(chalk.gray('\nStack trace:'));
+      console.error(chalk.gray(error.stack));
+    }
+
+    process.exit(1);
+  }
+}
+
 /**
  * Parse PRD with AI
  * @param {Object} argv - Command arguments
@@ -642,8 +815,20 @@ function builder(yargs) {
             type: 'string',
             alias: 't'
           })
+          .option('ai', {
+            describe: 'Use AI to generate PRD content (requires ANTHROPIC_API_KEY)',
+            type: 'boolean',
+            default: false
+          })
+          .option('stream', {
+            describe: 'Stream AI output in real-time (only with --ai)',
+            type: 'boolean',
+            default: false
+          })
           .example('autopm prd new my-feature', 'Create PRD with wizard')
-          .example('autopm prd new payment-api --template api-feature', 'Create PRD from template');
+          .example('autopm prd new payment-api --template api-feature', 'Create PRD from template')
+          .example('autopm prd new my-feature --ai', 'AI-powered PRD generation')
+          .example('autopm prd new my-feature --ai --stream', 'AI generation with streaming');
       },
       prdNew  // Handler
     )

package/lib/services/PRDService.js

@@ -880,6 +880,55 @@ ${content}`;
   // TIER 4: AI STREAMING METHODS
   // ==========================================
 
+  /**
+   * Generate PRD from prompt (non-streaming)
+   *
+   * Uses AI to generate a complete PRD from a high-level description or prompt.
+   * Returns the generated PRD as markdown text.
+   *
+   * @param {string} prompt - Prompt describing what PRD to generate
+   * @param {Object} [options] - Generation options
+   * @returns {Promise<string>} Generated PRD markdown
+   * @throws {Error} If provider is not available
+   *
+   * @example
+   * const prd = await service.generatePRD('Create a PRD for user authentication');
+   * console.log(prd); // Full PRD markdown
+   */
+  async generatePRD(prompt, options = {}) {
+    if (!this.provider || !this.provider.generate) {
+      throw new Error('PRD generation requires an AI provider with generate() support');
+    }
+
+    return await this.provider.generate(prompt, options);
+  }
+
+  /**
+   * Generate PRD from prompt with streaming output
+   *
+   * Uses AI to generate a complete PRD from a high-level description,
+   * streaming the output in real-time as it's generated.
+   *
+   * @param {string} prompt - Prompt describing what PRD to generate
+   * @param {Object} [options] - Streaming options
+   * @returns {AsyncGenerator<string>} Stream of PRD markdown chunks
+   * @throws {Error} If provider is not available or lacks stream() support
+   *
+   * @example
+   * for await (const chunk of service.generatePRDStream('Create a PRD for...')) {
+   *   process.stdout.write(chunk); // Display PRD as it's generated
+   * }
+   */
+  async *generatePRDStream(prompt, options = {}) {
+    if (!this.provider || !this.provider.stream) {
+      throw new Error('Streaming PRD generation requires an AI provider with stream() support');
+    }
+
+    for await (const chunk of this.provider.stream(prompt, options)) {
+      yield chunk;
+    }
+  }
+
   /**
    * Parse PRD with streaming AI analysis
    *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-autopm",
-  "version": "2.2.2",
+  "version": "2.3.0",
   "description": "Autonomous Project Management Framework for Claude Code - Advanced AI-powered development automation",
   "main": "bin/autopm.js",
   "bin": {