claude-autopm 2.2.2 → 2.4.0

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/EpicService.js

@@ -40,26 +40,28 @@ class EpicService {
    * Create a new EpicService instance
    *
    * @param {Object} options - Configuration options
-   * @param {PRDService} options.prdService - PRDService instance for parsing
+   * @param {PRDService} options.prdService - PRDService instance for parsing (optional for CLI operations)
    * @param {ConfigManager} [options.configManager] - Optional ConfigManager instance
    * @param {Object} [options.provider] - Optional AI provider instance for streaming
+   * @param {string} [options.epicsDir] - Path to epics directory (default: .claude/epics)
+   * @param {string} [options.defaultStatus] - Default epic status (default: backlog)
    */
   constructor(options = {}) {
-    if (!options.prdService) {
-      throw new Error('PRDService instance is required');
-    }
-
-    if (!(options.prdService instanceof PRDService)) {
-      throw new Error('prdService must be an instance of PRDService');
-    }
-
-    this.prdService = options.prdService;
+    // PRDService is optional now - only required for PRD parsing operations
+    this.prdService = options.prdService || null;
 
     // Store ConfigManager if provided (for future use)
     this.configManager = options.configManager || undefined;
 
     // Store provider if provided (for streaming operations)
     this.provider = options.provider || undefined;
+
+    // CLI operation options
+    this.options = {
+      epicsDir: options.epicsDir || '.claude/epics',
+      defaultStatus: options.defaultStatus || 'backlog',
+      ...options
+    };
   }
 
   // ==========================================
@@ -312,6 +314,10 @@ class EpicService {
    * // }
    */
   analyzePRD(prdContent) {
+    if (!this.prdService) {
+      throw new Error('PRDService instance is required for PRD analysis operations');
+    }
+
     const frontmatter = this.prdService.parseFrontmatter(prdContent);
     const sections = this.prdService.extractPrdContent(prdContent);
 
@@ -321,6 +327,59 @@ class EpicService {
     };
   }
 
+  /**
+   * Parse YAML frontmatter from markdown content
+   *
+   * Extracts key-value pairs from YAML frontmatter block.
+   * Returns null if frontmatter is missing or malformed.
+   *
+   * @param {string} content - Markdown content with frontmatter
+   * @returns {Object|null} Parsed frontmatter object or null
+   */
+  parseFrontmatter(content) {
+    if (!content || typeof content !== 'string') {
+      return null;
+    }
+
+    // Match frontmatter block: ---\n...\n--- or ---\n---
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/) ||
+                             content.match(/^---\n---/);
+
+    if (!frontmatterMatch) {
+      return null;
+    }
+
+    // Empty frontmatter (---\n---)
+    if (!frontmatterMatch[1] && content.startsWith('---\n---')) {
+      return {};
+    }
+
+    const frontmatter = {};
+    const lines = (frontmatterMatch[1] || '').split('\n');
+
+    for (const line of lines) {
+      // Skip empty lines
+      if (!line.trim()) {
+        continue;
+      }
+
+      // Find first colon to split key and value
+      const colonIndex = line.indexOf(':');
+      if (colonIndex === -1) {
+        continue; // Skip lines without colons
+      }
+
+      const key = line.substring(0, colonIndex).trim();
+      const value = line.substring(colonIndex + 1).trim();
+
+      if (key) {
+        frontmatter[key] = value;
+      }
+    }
+
+    return frontmatter;
+  }
+
   /**
    * Determine dependencies between features
    *
@@ -604,6 +663,221 @@ ${prdContent}`;
       yield chunk;
     }
   }
+
+  // ==========================================
+  // 6. CLI OPERATIONS (I/O Methods)
+  // ==========================================
+
+  /**
+   * List all epics with metadata
+   *
+   * @returns {Promise<Array<Object>>} Array of epic objects
+   */
+  async listEpics() {
+    const fs = require('fs-extra');
+    const path = require('path');
+
+    const epicsDir = path.join(process.cwd(), this.options.epicsDir);
+
+    // Check if epics directory exists
+    const dirExists = await fs.pathExists(epicsDir);
+    if (!dirExists) {
+      return [];
+    }
+
+    // Read all epic directories
+    let epicDirs;
+    try {
+      const items = await fs.readdir(epicsDir, { withFileTypes: true });
+      epicDirs = items
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name);
+    } catch (error) {
+      return [];
+    }
+
+    const epics = [];
+
+    for (const epicDir of epicDirs) {
+      const epicPath = path.join(epicsDir, epicDir);
+      const epicFilePath = path.join(epicPath, 'epic.md');
+
+      // Skip directories without epic.md file
+      const fileExists = await fs.pathExists(epicFilePath);
+      if (!fileExists) {
+        continue;
+      }
+
+      let metadata;
+      try {
+        const content = await fs.readFile(epicFilePath, 'utf8');
+        metadata = this.parseFrontmatter(content);
+      } catch (error) {
+        // Skip files that can't be read
+        continue;
+      }
+
+      // Apply defaults
+      const name = (metadata && metadata.name) || epicDir;
+      const status = (metadata && metadata.status) || this.options.defaultStatus;
+      const progress = (metadata && metadata.progress) || '0%';
+      const github = (metadata && metadata.github) || '';
+      const created = (metadata && metadata.created) || '';
+
+      // Count tasks
+      const taskCount = await this.countTasks(epicPath);
+
+      // Extract GitHub issue number
+      const githubIssue = this.extractGitHubIssue(github);
+
+      epics.push({
+        name,
+        status,
+        progress,
+        github,
+        githubIssue,
+        created,
+        taskCount,
+        epicDir,
+        epicPath: path.join(epicPath, 'epic.md')
+      });
+    }
+
+    return epics;
+  }
+
+  /**
+   * Get detailed epic information
+   *
+   * @param {string} epicName - Epic directory name
+   * @returns {Promise<Object>} Epic data with metadata and task count
+   * @throws {Error} If epic not found
+   */
+  async getEpic(epicName) {
+    const fs = require('fs-extra');
+
+    const epicPath = this.getEpicPath(epicName);
+    const epicFilePath = this.getEpicFilePath(epicName);
+
+    // Check if epic exists
+    const exists = await fs.pathExists(epicFilePath);
+    if (!exists) {
+      throw new Error(`Epic not found: ${epicName}`);
+    }
+
+    // Read epic content
+    const content = await fs.readFile(epicFilePath, 'utf8');
+    const metadata = this.parseFrontmatter(content);
+
+    // Apply defaults
+    const name = (metadata && metadata.name) || epicName;
+    const status = (metadata && metadata.status) || this.options.defaultStatus;
+    const progress = (metadata && metadata.progress) || '0%';
+    const github = (metadata && metadata.github) || '';
+    const created = (metadata && metadata.created) || '';
+
+    // Count tasks
+    const taskCount = await this.countTasks(epicPath);
+
+    // Extract GitHub issue
+    const githubIssue = this.extractGitHubIssue(github);
+
+    return {
+      name,
+      status,
+      progress,
+      github,
+      githubIssue,
+      created,
+      taskCount,
+      epicDir: epicName,
+      epicPath: epicFilePath,
+      content
+    };
+  }
+
+  /**
+   * Validate epic structure and completeness
+   *
+   * @param {string} epicName - Epic directory name
+   * @returns {Promise<Object>} Validation result: { valid: boolean, issues: string[] }
+   * @throws {Error} If epic not found
+   */
+  async validateEpicStructure(epicName) {
+    const fs = require('fs-extra');
+
+    const epicFilePath = this.getEpicFilePath(epicName);
+
+    // Check if epic exists
+    const exists = await fs.pathExists(epicFilePath);
+    if (!exists) {
+      throw new Error(`Epic not found: ${epicName}`);
+    }
+
+    const issues = [];
+
+    // Read epic content
+    const content = await fs.readFile(epicFilePath, 'utf8');
+
+    // Check for frontmatter
+    const frontmatter = this.parseFrontmatter(content);
+    if (!frontmatter) {
+      issues.push('Missing frontmatter');
+    } else {
+      // Check for required fields
+      if (!frontmatter.name) {
+        issues.push('Missing name in frontmatter');
+      }
+      if (!frontmatter.status) {
+        issues.push('Missing status in frontmatter');
+      }
+    }
+
+    return {
+      valid: issues.length === 0,
+      issues
+    };
+  }
+
+  /**
+   * Count task files in epic directory
+   *
+   * @param {string} epicPath - Path to epic directory
+   * @returns {Promise<number>} Number of task files
+   */
+  async countTasks(epicPath) {
+    const fs = require('fs-extra');
+
+    try {
+      const files = await fs.readdir(epicPath);
+      // Count files that match pattern [0-9]*.md
+      return files.filter(file => /^\d+\.md$/.test(file)).length;
+    } catch (error) {
+      return 0;
+    }
+  }
+
+  /**
+   * Get full path to epic directory
+   *
+   * @param {string} epicName - Epic directory name
+   * @returns {string} Full path to epic directory
+   */
+  getEpicPath(epicName) {
+    const path = require('path');
+    return path.join(process.cwd(), this.options.epicsDir, epicName);
+  }
+
+  /**
+   * Get full path to epic.md file
+   *
+   * @param {string} epicName - Epic directory name
+   * @returns {string} Full path to epic.md file
+   */
+  getEpicFilePath(epicName) {
+    const path = require('path');
+    return path.join(this.getEpicPath(epicName), 'epic.md');
+  }
 }
 
 module.exports = EpicService;

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.4.0",
   "description": "Autonomous Project Management Framework for Claude Code - Advanced AI-powered development automation",
   "main": "bin/autopm.js",
   "bin": {