claude-autopm 1.30.1 → 1.31.0

package/autopm/.claude/scripts/pm/next.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const { logError } = require('./lib/logger');
+const { findAllEpicDirs } = require('./lib/epic-discovery');
 
 /**
  * PM Next Script (Node.js version)
@@ -106,69 +107,66 @@ function displayTddReminder(addMessage) {
 async function findAvailableTasks() {
   const availableTasks = [];
 
-  if (!fs.existsSync('.claude/epics')) {
-    return availableTasks;
-  }
+  // Use shared epic discovery utility
+  const epicDirs = findAllEpicDirs();
 
-  try {
-    const epicDirs = fs.readdirSync('.claude/epics', { withFileTypes: true })
-      .filter(dirent => dirent.isDirectory())
-      .map(dirent => dirent.name);
-
-    for (const epicName of epicDirs) {
-      const epicPath = path.join('.claude/epics', epicName);
-
-      try {
-        const taskFiles = fs.readdirSync(epicPath)
-          .filter(file => /^[0-9].*\.md$/.test(file))
-          .sort();
-
-        for (const taskFile of taskFiles) {
-          const taskPath = path.join(epicPath, taskFile);
-
-          try {
-            const content = fs.readFileSync(taskPath, 'utf8');
-
-            // Check if task is open
-            const statusMatch = content.match(/^status:\s*(.+)$/m);
-            const status = statusMatch ? statusMatch[1].trim() : '';
-
-            // Skip non-open tasks (only open tasks or tasks without status are available)
-            if (status !== 'open' && status !== '') {
-              continue;
-            }
-
-            // Check dependencies
-            const depsMatch = content.match(/^depends_on:\s*\[(.*?)\]/m);
-            const depsStr = depsMatch ? depsMatch[1].trim() : '';
-
-            // If no dependencies or empty dependencies, task is available
-            if (!depsStr || depsStr === '') {
-              const nameMatch = content.match(/^name:\s*(.+)$/m);
-              const name = nameMatch ? nameMatch[1].trim() : 'Unnamed Task';
-
-              const parallelMatch = content.match(/^parallel:\s*(.+)$/m);
-              const parallel = parallelMatch ? parallelMatch[1].trim() === 'true' : false;
-
-              const taskNum = path.basename(taskFile, '.md');
-
-              availableTasks.push({
-                taskNum,
-                name,
-                epicName,
-                parallel
-              });
-            }
-          } catch (err) {
-            // Skip files we can't read
+  for (const epicDir of epicDirs) {
+    const { name: epicName, path: epicPath } = epicDir;
+
+    try {
+      const taskFiles = fs.readdirSync(epicPath)
+        .filter(file => /^\d+.*\.md$/.test(file))
+        .sort();
+
+      for (const taskFile of taskFiles) {
+        const taskPath = path.join(epicPath, taskFile);
+
+        try {
+          const content = fs.readFileSync(taskPath, 'utf8');
+
+          // Check if task is open (case-insensitive)
+          const statusMatch = content.match(/^status:\s*(.+)$/m);
+          const status = statusMatch ? statusMatch[1].trim().toLowerCase() : '';
+
+          // Skip non-open tasks (only open tasks or tasks without status are available)
+          if (status !== 'open' && status !== '') {
+            continue;
+          }
+
+          // Check dependencies
+          const depsMatch = content.match(/^depends_on:\s*\[(.*?)\]/m);
+          const depsStr = depsMatch ? depsMatch[1].trim() : '';
+
+          // If no dependencies or empty dependencies, task is available
+          if (!depsStr || depsStr === '') {
+            const nameMatch = content.match(/^name:\s*(.+)$/m);
+            const name = nameMatch ? nameMatch[1].trim() : 'Unnamed Task';
+
+            const parallelMatch = content.match(/^parallel:\s*(.+)$/m);
+            const parallel = parallelMatch ? parallelMatch[1].trim() === 'true' : false;
+
+            const taskNum = path.basename(taskFile, '.md');
+
+            availableTasks.push({
+              taskNum,
+              name,
+              epicName,
+              parallel
+            });
+          }
+        } catch (err) {
+          // Log file read errors in DEBUG mode
+          if (process.env.DEBUG) {
+            console.error(`Error reading task file ${taskPath}:`, err.message);
           }
         }
-      } catch (err) {
-        // Skip directories we can't read
+      }
+    } catch (err) {
+      // Log directory read errors in DEBUG mode
+      if (process.env.DEBUG) {
+        console.error(`Error reading epic directory ${epicPath}:`, err.message);
       }
     }
-  } catch (err) {
-    // Silently handle errors
   }
 
   return availableTasks;

package/bin/autopm-poc.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+/**
+ * AutoPM POC - CLI for testing Claude API integration
+ *
+ * Usage:
+ *   autopm-poc parse <prd-file>       - Parse PRD with streaming output
+ *   autopm-poc parse <prd-file> --json - Parse PRD and output JSON
+ *   autopm-poc summarize <prd-file>   - Get one-paragraph summary
+ *   autopm-poc test                   - Test API connection
+ *
+ * Environment:
+ *   ANTHROPIC_API_KEY - Required for all operations
+ */
+
+const fs = require('fs');
+const path = require('path');
+const ClaudeProvider = require('../lib/ai-providers/ClaudeProvider');
+const PRDService = require('../lib/services/PRDService');
+
+/**
+ * Print usage information
+ */
+function printUsage() {
+  console.log(`
+AutoPM POC - Claude API Integration Demo
+=========================================
+
+Usage:
+  autopm-poc parse <prd-file>          Parse PRD with streaming output
+  autopm-poc parse <prd-file> --json   Parse PRD and extract epics as JSON
+  autopm-poc summarize <prd-file>      Get one-paragraph summary
+  autopm-poc test                      Test API connection
+  autopm-poc help                      Show this help message
+
+Environment Variables:
+  ANTHROPIC_API_KEY                    Required - Your Anthropic API key
+
+Examples:
+  export ANTHROPIC_API_KEY="sk-ant-..."
+  autopm-poc parse examples/sample-prd.md
+  autopm-poc summarize examples/sample-prd.md
+  autopm-poc parse examples/sample-prd.md --json
+`);
+}
+
+/**
+ * Test API connection
+ */
+async function testConnection(provider) {
+  console.log('🔍 Testing API connection...\n');
+
+  try {
+    const result = await provider.complete('Say "Connection successful!"', {
+      maxTokens: 50
+    });
+
+    console.log('✅ API Connection Test: SUCCESS');
+    console.log(`📝 Response: ${result}\n`);
+    return true;
+  } catch (error) {
+    console.error('❌ API Connection Test: FAILED');
+    console.error(`   Error: ${error.message}\n`);
+    return false;
+  }
+}
+
+/**
+ * Parse PRD with streaming output
+ */
+async function parsePRDStream(service, content) {
+  console.log('🔍 Analyzing PRD with Claude AI...\n');
+  console.log('📝 Streaming response:\n');
+  console.log('─'.repeat(60));
+
+  let fullResponse = '';
+  try {
+    for await (const chunk of service.parseStream(content)) {
+      process.stdout.write(chunk);
+      fullResponse += chunk;
+    }
+
+    console.log('\n' + '─'.repeat(60));
+    console.log('\n✅ Analysis complete!');
+    console.log(`📊 Total response length: ${fullResponse.length} characters\n`);
+  } catch (error) {
+    console.error('\n❌ Error during parsing:', error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Parse PRD and extract epics as JSON
+ */
+async function parsePRDJson(service, content) {
+  console.log('🔍 Extracting epics from PRD...\n');
+
+  try {
+    const epics = await service.extractEpics(content);
+
+    console.log('✅ Extraction complete!\n');
+    console.log('📋 Extracted Epics:\n');
+    console.log(JSON.stringify(epics, null, 2));
+    console.log(`\n📊 Found ${Array.isArray(epics) ? epics.length : 0} epic(s)\n`);
+  } catch (error) {
+    console.error('❌ Error during JSON extraction:', error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Summarize PRD
+ */
+async function summarizePRD(service, content) {
+  console.log('🔍 Summarizing PRD...\n');
+
+  try {
+    const summary = await service.summarize(content);
+
+    console.log('✅ Summary complete!\n');
+    console.log('📝 Summary:\n');
+    console.log(summary);
+    console.log();
+  } catch (error) {
+    console.error('❌ Error during summarization:', error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Main entry point
+ */
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  // Handle help
+  if (!command || command === 'help' || command === '--help' || command === '-h') {
+    printUsage();
+    process.exit(0);
+  }
+
+  // Check for API key
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    console.error('❌ Error: ANTHROPIC_API_KEY environment variable required\n');
+    console.error('Set it with:');
+    console.error('  export ANTHROPIC_API_KEY="sk-ant-..."\n');
+    process.exit(1);
+  }
+
+  // Initialize provider and service
+  const provider = new ClaudeProvider(apiKey);
+  const service = new PRDService(provider);
+
+  // Handle test command
+  if (command === 'test') {
+    const success = await testConnection(provider);
+    process.exit(success ? 0 : 1);
+  }
+
+  // Handle parse and summarize commands
+  if (command === 'parse' || command === 'summarize') {
+    const file = args[1];
+
+    if (!file) {
+      console.error(`❌ Error: PRD file required for '${command}' command\n`);
+      console.error(`Usage: autopm-poc ${command} <prd-file>\n`);
+      process.exit(1);
+    }
+
+    // Check if file exists
+    if (!fs.existsSync(file)) {
+      console.error(`❌ Error: File not found: ${file}\n`);
+      process.exit(1);
+    }
+
+    // Read file content
+    const content = fs.readFileSync(file, 'utf8');
+
+    if (!content.trim()) {
+      console.error('❌ Error: PRD file is empty\n');
+      process.exit(1);
+    }
+
+    console.log(`📄 Reading PRD from: ${file}`);
+    console.log(`📏 File size: ${content.length} characters\n`);
+
+    // Execute command
+    if (command === 'parse') {
+      const jsonFlag = args[2] === '--json';
+
+      if (jsonFlag) {
+        await parsePRDJson(service, content);
+      } else {
+        await parsePRDStream(service, content);
+      }
+    } else if (command === 'summarize') {
+      await summarizePRD(service, content);
+    }
+
+    process.exit(0);
+  }
+
+  // Unknown command
+  console.error(`❌ Error: Unknown command: ${command}\n`);
+  printUsage();
+  process.exit(1);
+}
+
+// Run main with error handling
+main().catch(err => {
+  console.error('❌ Fatal error:', err.message);
+  console.error('\nStack trace:');
+  console.error(err.stack);
+  process.exit(1);
+});

package/lib/ai-providers/ClaudeProvider.js

@@ -0,0 +1,112 @@
+/**
+ * ClaudeProvider - Anthropic Claude API integration
+ *
+ * Provides both synchronous completion and streaming capabilities
+ * for Claude AI interactions.
+ *
+ * Documentation Queries:
+ * - mcp://context7/anthropic/sdk - Anthropic SDK patterns
+ * - mcp://context7/anthropic/streaming - Streaming best practices
+ * - mcp://context7/nodejs/async-generators - Async generator patterns
+ */
+
+const Anthropic = require('@anthropic-ai/sdk');
+
+/**
+ * ClaudeProvider class for Anthropic Claude API integration
+ */
+class ClaudeProvider {
+  /**
+   * Create a new ClaudeProvider instance
+   * @param {string} apiKey - Anthropic API key
+   * @throws {Error} If API key is not provided
+   */
+  constructor(apiKey) {
+    if (!apiKey) {
+      throw new Error('API key is required for ClaudeProvider');
+    }
+
+    this.apiKey = apiKey;
+    this.client = new Anthropic({ apiKey });
+  }
+
+  /**
+   * Complete a prompt synchronously (wait for full response)
+   * @param {string} prompt - The prompt to complete
+   * @param {Object} options - Optional configuration
+   * @param {string} options.model - Model to use (default: claude-sonnet-4-20250514)
+   * @param {number} options.maxTokens - Maximum tokens to generate (default: 4096)
+   * @returns {Promise<string>} The completed text
+   */
+  async complete(prompt, options = {}) {
+    try {
+      const response = await this.client.messages.create({
+        model: options.model || 'claude-sonnet-4-20250514',
+        max_tokens: options.maxTokens || 4096,
+        messages: [{ role: 'user', content: prompt }]
+      });
+
+      // Extract text from response
+      if (response.content && response.content.length > 0) {
+        return response.content[0].text;
+      }
+
+      return '';
+    } catch (error) {
+      throw new Error(`Claude API error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Stream a prompt response (async generator for real-time feedback)
+   * @param {string} prompt - The prompt to complete
+   * @param {Object} options - Optional configuration
+   * @param {string} options.model - Model to use (default: claude-sonnet-4-20250514)
+   * @param {number} options.maxTokens - Maximum tokens to generate (default: 4096)
+   * @yields {string} Text chunks as they arrive
+   */
+  async *stream(prompt, options = {}) {
+    try {
+      const stream = await this.client.messages.create({
+        model: options.model || 'claude-sonnet-4-20250514',
+        max_tokens: options.maxTokens || 4096,
+        stream: true,
+        messages: [{ role: 'user', content: prompt }]
+      });
+
+      // Yield text deltas as they arrive
+      for await (const event of stream) {
+        if (event.type === 'content_block_delta' &&
+            event.delta &&
+            event.delta.type === 'text_delta') {
+          yield event.delta.text;
+        }
+      }
+    } catch (error) {
+      throw new Error(`Claude API streaming error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get the current model being used
+   * @returns {string} The default model name
+   */
+  getModel() {
+    return 'claude-sonnet-4-20250514';
+  }
+
+  /**
+   * Test the API connection
+   * @returns {Promise<boolean>} True if connection is successful
+   */
+  async testConnection() {
+    try {
+      await this.complete('Hello');
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+}
+
+module.exports = ClaudeProvider;

package/lib/services/PRDService.js

@@ -0,0 +1,178 @@
+/**
+ * PRDService - Product Requirements Document parsing with AI
+ *
+ * Analyzes PRD documents and extracts structured information
+ * including epics, features, dependencies, and estimates.
+ *
+ * Documentation Queries:
+ * - mcp://context7/agile/prd-analysis - PRD analysis best practices
+ * - mcp://context7/agile/epic-breakdown - Epic decomposition patterns
+ * - mcp://context7/project-management/estimation - Estimation techniques
+ */
+
+/**
+ * PRDService class for analyzing Product Requirements Documents
+ */
+class PRDService {
+  /**
+   * Create a new PRDService instance
+   * @param {Object} aiProvider - AI provider instance (e.g., ClaudeProvider)
+   */
+  constructor(aiProvider) {
+    if (!aiProvider) {
+      throw new Error('AI provider is required for PRDService');
+    }
+    this.ai = aiProvider;
+  }
+
+  /**
+   * Build a comprehensive prompt for PRD analysis
+   * @param {string} prdContent - The PRD content to analyze
+   * @returns {string} Structured prompt for AI
+   * @private
+   */
+  _buildPrompt(prdContent) {
+    return `You are an expert product manager and technical analyst. Analyze the following Product Requirements Document (PRD) and extract structured information.
+
+PRD Content:
+${prdContent}
+
+Please analyze and provide:
+
+1. **Project Overview**
+   - Project name
+   - Brief description
+   - Goals and objectives
+
+2. **Epics/Features** (Main features or user stories)
+   - Name of each epic
+   - Description
+   - Rough estimate (if mentioned)
+   - Priority (High/Medium/Low)
+
+3. **Technical Requirements**
+   - Technologies mentioned
+   - Infrastructure needs
+   - Integration points
+
+4. **Dependencies**
+   - Dependencies between features
+   - External dependencies
+   - Blockers or constraints
+
+5. **Timeline/Phases** (if mentioned)
+   - Phases or milestones
+   - Estimated durations
+
+Please structure your response clearly with headers and bullet points. Focus on actionable insights that would help with project planning and task breakdown.`;
+  }
+
+  /**
+   * Build a simpler prompt for streaming analysis
+   * @param {string} prdContent - The PRD content to analyze
+   * @returns {string} Prompt for streaming
+   * @private
+   */
+  _buildStreamPrompt(prdContent) {
+    return `Analyze this PRD and extract the key epics, features, and technical requirements:
+
+${prdContent}
+
+Provide a clear, structured breakdown of:
+1. Main features/epics
+2. Technical requirements
+3. Dependencies
+4. Estimated timeline (if mentioned)`;
+  }
+
+  /**
+   * Parse PRD synchronously (wait for complete analysis)
+   * @param {string} prdContent - The PRD content to analyze
+   * @param {Object} options - Optional configuration
+   * @returns {Promise<string>} Structured analysis of the PRD
+   */
+  async parse(prdContent, options = {}) {
+    if (!prdContent) {
+      return 'No PRD content provided. Please provide a PRD document to analyze.';
+    }
+
+    const prompt = this._buildPrompt(prdContent);
+
+    try {
+      return await this.ai.complete(prompt, options);
+    } catch (error) {
+      throw new Error(`PRD parsing error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Parse PRD with streaming (async generator for real-time feedback)
+   * @param {string} prdContent - The PRD content to analyze
+   * @param {Object} options - Optional configuration
+   * @yields {string} Analysis chunks as they arrive
+   */
+  async *parseStream(prdContent, options = {}) {
+    if (!prdContent) {
+      yield 'No PRD content provided. Please provide a PRD document to analyze.';
+      return;
+    }
+
+    const prompt = this._buildStreamPrompt(prdContent);
+
+    try {
+      for await (const chunk of this.ai.stream(prompt, options)) {
+        yield chunk;
+      }
+    } catch (error) {
+      throw new Error(`PRD streaming error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Extract epics from PRD (simplified extraction)
+   * @param {string} prdContent - The PRD content
+   * @returns {Promise<Array>} Array of epic objects
+   */
+  async extractEpics(prdContent) {
+    const prompt = `Extract all epics/features from this PRD and return them as a JSON array:
+
+${prdContent}
+
+Format: [{"name": "Epic Name", "description": "Brief description", "estimate": "time estimate if available"}]
+
+Return ONLY the JSON array, no other text.`;
+
+    try {
+      const response = await this.ai.complete(prompt, { maxTokens: 2048 });
+
+      // Try to parse as JSON
+      try {
+        return JSON.parse(response);
+      } catch (parseError) {
+        // If parsing fails, return raw response wrapped in array
+        return [{ raw: response }];
+      }
+    } catch (error) {
+      throw new Error(`Epic extraction error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Summarize PRD in one paragraph
+   * @param {string} prdContent - The PRD content
+   * @returns {Promise<string>} One-paragraph summary
+   */
+  async summarize(prdContent) {
+    const prompt = `Summarize this PRD in one concise paragraph (2-3 sentences):
+
+${prdContent}`;
+
+    try {
+      return await this.ai.complete(prompt, { maxTokens: 256 });
+    } catch (error) {
+      throw new Error(`PRD summarization error: ${error.message}`);
+    }
+  }
+}
+
+module.exports = PRDService;

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "claude-autopm",
-  "version": "1.30.1",
+  "version": "1.31.0",
   "description": "Autonomous Project Management Framework for Claude Code - Advanced AI-powered development automation",
   "main": "bin/autopm.js",
   "bin": {
-    "autopm": "./bin/autopm.js"
+    "autopm": "./bin/autopm.js",
+    "autopm-poc": "./bin/autopm-poc.js"
   },
   "scripts": {
     "postinstall": "echo '🎉 ClaudeAutoPM installed! Run: autopm --help'",
@@ -52,6 +53,7 @@
     "test:unit:coverage": "c8 node --test $(find test/unit -name '*.test.js' ! -name '*-jest.test.js')",
     "test:e2e": "jest test/e2e",
     "test:e2e:legacy": "node --test test/e2e/*.test.js",
+    "test:poc": "jest --config jest.config.poc.js",
     "setup:hooks": "bash scripts/setup-hooks.sh",
     "lint": "markdownlint *.md .claude/**/*.md install/*.md",
     "lint:fix": "markdownlint --fix *.md .claude/**/*.md install/*.md",
@@ -114,6 +116,7 @@
     "README.md"
   ],
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.32.1",
     "@octokit/rest": "^22.0.0",
     "azure-devops-node-api": "^15.1.1",
     "chalk": "^5.3.0",