claude-autopm 2.1.0 → 2.2.0

package/README.md

@@ -15,7 +15,7 @@ Transform your development workflow with intelligent automation, parallel AI age
 
 ClaudeAutoPM is a comprehensive project management and development automation framework designed specifically for [Claude Code](https://claude.ai/code). It combines:
 
-- **109+ CLI commands** for deterministic operations (scaffolding, templates, automation)
+- **112+ CLI commands** for deterministic operations (scaffolding, templates, automation)
 - **39 specialized AI agents** for intelligent tasks (analysis, design, development)
 - **Dynamic team management** with automatic agent switching
 - **Hybrid execution modes** - choose between templates or AI assistance
@@ -44,7 +44,58 @@ PRD → Epic Decomposition → Parallel Development → Testing → Production
 
 ## ✨ Key Features
 
-### 🆕 **NEW in v1.30.0: Advanced Conflict Resolution - Complete Sync Safety!**
+### 🆕 **NEW in v2.1.0: STANDALONE CLI Commands - Direct Service Access!**
+
+**Three New CLI Commands** - Direct access to service layer without AI overhead
+- 🎯 **Deterministic Operations** - Fast, predictable, no AI required
+- 🎨 **Modern UX** - Progress spinners, color-coded output, streaming support
+- ⚡ **High Performance** - Direct service layer access for instant results
+- 🧪 **100% Test Coverage** - 65 CLI tests passing, full TDD methodology
+
+**New Commands:**
+
+```bash
+# PRD Management
+autopm prd parse my-prd --ai          # AI-powered PRD parsing
+autopm prd parse my-prd --stream      # Real-time streaming output
+autopm prd extract-epics my-prd       # Extract epics from PRD
+autopm prd summarize my-prd           # Generate comprehensive summary
+autopm prd validate my-prd            # Validate structure & quality
+
+# Task Management
+autopm task list epic-001             # Display all tasks from epic
+autopm task prioritize epic-001       # AI-powered prioritization
+
+# Agent Invocation
+autopm agent list                     # Display available agents
+autopm agent search "kubernetes"      # Search agents by keyword
+autopm agent invoke aws-architect "Design VPC"  # Invoke agent with task
+autopm agent invoke --stream agent-name "task"  # Streaming invocation
+```
+
+**User Experience Features:**
+- 🔄 Progress indicators with ora spinners
+- 🎨 Color-coded output (green=success, red=error, yellow=warning)
+- 📡 Streaming support for real-time AI responses
+- ❌ Comprehensive error handling with user-friendly messages
+- 📋 Consistent patterns across all commands
+
+**Technical Implementation:**
+- Extended PRDService with 4 non-streaming methods
+- All services support both streaming and non-streaming modes
+- Proper separation of concerns (CLI → Service → Provider)
+- Zero breaking changes to existing functionality
+- CommonJS compatibility maintained
+
+**Test Coverage:**
+- 28 new tests across 3 CLI command suites
+- 65 total CLI tests passing (100% pass rate)
+- Full TDD methodology with Jest
+- Comprehensive coverage of success, error, and streaming scenarios
+
+---
+
+### 🎉 **v1.30.0: Advanced Conflict Resolution - Complete Sync Safety!**
 
 **Three-Way Merge Conflict Resolution** - Safe GitHub synchronization
 - 🔒 **Intelligent Merge** - Three-way diff (local/remote/base) with conflict detection
@@ -341,7 +392,7 @@ claude --dangerously-skip-permissions .
 │                                                               │
 │  ┌─────────────┐  ┌──────────────┐  ┌──────────────┐       │
 │  │ CLI Layer   │  │ Agent Teams  │  │ MCP Servers  │       │
-│  │ (109 cmds)  │  │ (39 agents)  │  │ (Context7)   │       │
+│  │ (112 cmds)  │  │ (39 agents)  │  │ (Context7)   │       │
 │  └──────┬──────┘  └──────┬───────┘  └──────┬───────┘       │
 │         │                 │                  │                │
 │         └─────────────────┼──────────────────┘                │
@@ -351,6 +402,7 @@ claude --dangerously-skip-permissions .
 │  │  - Sequential / Adaptive / Hybrid                │        │
 │  │  - Parallel agent coordination                   │        │
 │  │  - Context optimization                          │        │
+│  │  - STANDALONE mode (direct service access)       │        │
 │  └────────────────────────┬─────────────────────────┘        │
 │                           │                                   │
 │  ┌────────────────────────┴─────────────────────────┐        │
@@ -405,8 +457,8 @@ claude --dangerously-skip-permissions .
 
 ## 📦 What's Included
 
-### CLI Commands (109 total)
-- **Project Management**: PRD, Epic, Issue, Task management
+### CLI Commands (112 total)
+- **Project Management**: PRD, Epic, Issue, Task management (3 new STANDALONE commands in v2.1.0)
 - **Development**: Scaffolding, testing, deployment
 - **Configuration**: Provider setup, team management, MCP servers
 - **DevOps**: Docker, Kubernetes, CI/CD automation

package/bin/autopm.js

@@ -232,12 +232,35 @@ function main() {
     .wrap(cli.terminalWidth())
     // Enhanced help epilogue
     .epilogue(`
-📖 Quick Start:
-   autopm install                    # Install ClaudeAutoPM in current directory
-   autopm validate                   # Check configuration status
-   autopm update                     # Update to latest framework version
-   autopm team load frontend         # Load React/UI development agents
-   claude --dangerously-skip-permissions .     # Open Claude Code
+╔════════════════════════════════════════════════════════════════════════════╗
+║                    ClaudeAutoPM v${VERSION} - Quick Reference                    ║
+║         AI-Powered Project Management for Claude Code                      ║
+╚════════════════════════════════════════════════════════════════════════════╝
+
+🚀 Quick Start (3 Steps):
+   1. autopm install                    # Install framework in project
+   2. autopm config set provider github # Configure your provider
+   3. claude --dangerously-skip-permissions .  # Open Claude Code
+
+🆕 NEW in v2.1.0 - STANDALONE Commands:
+   autopm prd parse <name>              # Parse PRD without AI overhead
+   autopm prd extract-epics <name>      # Extract epics from PRD
+   autopm prd summarize <name>          # Generate PRD summary
+   autopm prd validate <name>           # Validate PRD structure
+
+   autopm task list <epic>              # List tasks from epic
+   autopm task prioritize <epic>        # AI-powered prioritization
+
+   autopm agent list                    # List available agents
+   autopm agent search <keyword>        # Search agents
+   autopm agent invoke <name> <task>    # Invoke agent directly
+
+📋 Common Commands:
+   autopm validate                      # Check configuration status
+   autopm update                        # Update to latest version
+   autopm team load fullstack           # Load development agents
+   autopm mcp enable context7           # Enable documentation access
+   autopm config show                   # View current configuration
 
 🔧 Configuration Setup:
    # View current configuration
@@ -289,187 +312,76 @@ function main() {
 
 🤖 Team Management:
    autopm team list                 # See all available agent teams
-   autopm team load frontend        # Load React/UI agents
-   autopm team load backend         # Load Python/Node.js agents
-   autopm team load fullstack       # Load complete development stack
-   autopm team load devops          # Load Docker/K8s/CI-CD agents
+   autopm team load <name>          # Load specific team (frontend/backend/fullstack/devops)
    autopm team current              # Check currently active team
-   autopm team reset                # Reset to default team
 
-💡 Claude Code PM Commands:
-   /pm:what-next                    # ⭐ Smart suggestions for what to do next
+💡 Claude Code Workflows (In-Editor Commands):
+   /pm:what-next                    # ⭐ Smart suggestions for next steps
    /pm:status                       # Project overview and health
-   /pm:context                      # Show current project context and progress
-   /pm:validate                     # Validate configuration
-   /pm:prd-new feature-name         # Create new Product Requirements Document
-   /pm:prd-parse feature-name       # Parse PRD into epic structure
-   /pm:epic-decompose feature-name  # Break PRD into actionable tasks
-   /pm:epic-sync feature-name       # Sync epic with provider (GitHub/Azure)
-   /pm:next                         # Get next priority task to work on
-   /pm:issue-start TASK-123         # Start working on specific task
-   /pm:issue-show TASK-123          # View task details
-   /pm:issue-close TASK-123         # Close completed task
-   /pm:standup                      # Generate daily standup summary
-   /pm:search keyword               # Search across PRDs and epics
-   /pm:help                         # Show all PM commands
-
-📋 PM Workflow Decision Guide:
-
-   WHEN TO USE ONE EPIC (/pm:epic-decompose):
-   ✅ Simple feature (1-2 weeks)
-   ✅ Single component (frontend OR backend)
-   ✅ One developer
-   Examples: "User profile page", "REST API endpoint"
-
-   WHEN TO USE MULTIPLE EPICS (/pm:epic-split):
-   ✅ Complex project (2+ months)
-   ✅ Multiple components (frontend + backend + infra)
-   ✅ Multiple teams working in parallel
-   Examples: "E-commerce platform", "Social dashboard"
-
-   SIMPLE FEATURE FLOW:
-   /pm:prd-new feature → /pm:prd-parse feature → /pm:epic-decompose feature
-
-   COMPLEX PROJECT FLOW:
-   /pm:prd-new project → /pm:prd-parse project → /pm:epic-split project
-   → /pm:epic-decompose project/01-epic1 → /pm:epic-decompose project/02-epic2 ...
-
-   📖 Full Guide: See PM-WORKFLOW-GUIDE.md
-
-🚀 Complete Workflows:
-
-   === GITHUB WORKFLOW (PRD → Epic → Issues) ===
-   1. autopm install               # Setup project framework
-   2. autopm config set provider github  # Set provider
-      autopm config set github.owner <username>
-      autopm config set github.repo <repository>
-      export GITHUB_TOKEN=<your-token>
-   3. autopm team load fullstack   # Load appropriate agents
-   4. claude --dangerously-skip-permissions . # Open Claude Code
-   5. /pm:validate                 # Verify GitHub integration
-
-   6. /pm:prd-new user-auth        # Create Product Requirements Document
-   7. /pm:prd-parse user-auth      # Parse PRD into structured format
-   8. /pm:epic-split user-auth     # [OPTIONAL] Split complex PRD into multiple epics
-   9. /pm:epic-decompose user-auth # Break PRD/Epic into Issues
-   10. /pm:epic-sync user-auth     # Create GitHub Epic + Issues
-   11. /pm:next                    # Get next priority issue
-   12. /pm:issue-start ISSUE-123   # Start working on specific issue
-   13. # ... development work ...
-   14. /pm:issue-close ISSUE-123   # Close completed issue
-   15. /pm:standup                 # Generate progress summary
-
-   === AZURE DEVOPS WORKFLOW (PRD → User Stories → Tasks) ===
-   1. autopm install               # Setup project framework
-   2. autopm config set provider azure  # Set provider
-      autopm config set azure.organization <org>
-      autopm config set azure.project <project>
-      export AZURE_DEVOPS_PAT=<your-pat>
-   3. autopm team load fullstack   # Load appropriate agents
-   4. claude --dangerously-skip-permissions . # Open Claude Code
-   5. /pm:validate                 # Verify Azure DevOps integration
-
-   6. /pm:prd-new user-auth        # Create Product Requirements Document
-   7. /pm:prd-parse user-auth      # Parse PRD into structured format
-   8. /pm:epic-split user-auth     # [OPTIONAL] Split complex PRD into multiple epics
-   9. /pm:epic-decompose user-auth # Break PRD/Epic into User Stories + Tasks
-   10. /pm:epic-sync user-auth     # Create Azure Epic + User Stories + Tasks
-   11. /pm:next                    # Get next priority task
-   12. /pm:issue-start TASK-123    # Start working on specific task
-   13. # ... development work ...
-   14. /pm:issue-close TASK-123    # Close completed task
-   15. /pm:standup                 # Generate sprint summary
-
-   === COMPLEX PROJECT WORKFLOW (Multi-Epic Split) ===
-   Example: Full-stack e-commerce platform
-
-   6. /pm:prd-new ecommerce-platform
-   7. /pm:prd-parse ecommerce-platform
-   8. /pm:epic-split ecommerce-platform # → Creates 6 epics automatically
-      → Epic 1: Infrastructure Foundation (Docker, DB, monitoring)
-      → Epic 2: Authentication Backend (JWT, users, RBAC)
-      → Epic 3: Product API Services (catalog, inventory, orders)
-      → Epic 4: Frontend Foundation (React setup, state management)
-      → Epic 5: E-commerce UI (product pages, cart, checkout)
-      → Epic 6: Testing & Deployment (CI/CD, quality gates)
-   9. /pm:epic-decompose ecommerce-platform/01-infrastructure # Decompose each epic
-   10. /pm:epic-decompose ecommerce-platform/02-auth-backend
-   11. ... (repeat for each epic)
-   12. /pm:epic-sync ecommerce-platform # Sync all epics to provider
-   13. /pm:next                         # Start with P0 infrastructure epic
-
-📋 Detailed Step-by-Step Examples:
-
-   STEP 6 - Creating PRD:
-   /pm:prd-new user-authentication
-   → Creates: .claude/prds/user-authentication.md
-   → Contains: Problem statement, user stories, acceptance criteria
-
-   STEP 7 - Parsing PRD:
-   /pm:prd-parse user-authentication
-   → Analyzes PRD content and structure
-   → Prepares for epic decomposition
-
-   STEP 8 - Epic Split (Optional for Complex Projects):
-   /pm:epic-split user-authentication
-   → Analyzes PRD complexity and identifies logical divisions
-   → Splits into multiple epics: Infrastructure, Backend, Frontend, UI, etc.
-   → Creates structured epic hierarchy with dependencies
-   → Example: 6 epics identified (Infrastructure, Auth Backend, Frontend, etc.)
-   → Use when: Multi-component projects, large teams, parallel work needed
-
-   STEP 9 - Epic Decomposition:
-   /pm:epic-decompose user-authentication
-   → GitHub: Creates Epic with linked Issues
-   → Azure: Creates Epic with User Stories and child Tasks
-   → File: .claude/epics/user-authentication.md (or multiple epic folders if split)
-
-   STEP 10 - Sync with Provider:
-   /pm:epic-sync user-authentication
-   → GitHub: Creates Epic + Issues in repository
-   → Azure: Creates Epic + User Stories + Tasks in project
-   → Links local files with remote work items
-
-   STEP 11 - Get Next Work:
-   /pm:next
-   → Returns highest priority unassigned item
-   → GitHub: Next issue to work on
-   → Azure: Next task to work on
-
-   STEP 12 - Start Development:
-   /pm:issue-start USER-AUTH-001
-   → Assigns work item to you
-   → Updates status to "In Progress"
-   → Creates development branch (if configured)
-
-   STEP 13 - Complete Work:
-   /pm:issue-close USER-AUTH-001
-   → Updates status to "Done/Closed"
-   → Links commits and PR (if available)
-   → Updates epic progress tracking
+   /pm:prd-new <name>               # Create new PRD
+   /pm:epic-decompose <name>        # Break PRD into tasks
+   /pm:epic-sync <name>             # Sync to GitHub/Azure
+   /pm:next                         # Get next priority task
+   /pm:issue-start <id>             # Start working on task
+   /pm:issue-close <id>             # Complete task
+   /pm:standup                      # Generate daily summary
 
-🛠️  Troubleshooting:
-   # Check installation and configuration
-   autopm validate                  # Comprehensive status check
-   ls -la .claude/                  # Should show: agents/, commands/, config.json
+📋 Quick Workflow Examples:
 
-   # Verify configuration
-   /pm:validate                     # In Claude Code
-   autopm team current              # Check active team
+   SIMPLE FEATURE (Use this for most tasks):
+   1. /pm:prd-new user-login        # Create PRD
+   2. /pm:epic-decompose user-login # Break into tasks
+   3. /pm:epic-sync user-login      # Push to GitHub/Azure
+   4. /pm:next                      # Start working
 
-   # Reset if needed
-   autopm install --force           # Reinstall framework
-   autopm team reset                # Reset to default agents
+   COMPLEX PROJECT (Multiple epics):
+   1. /pm:prd-new ecommerce         # Create PRD
+   2. /pm:epic-split ecommerce      # Split into multiple epics
+   3. /pm:epic-decompose ecommerce/01-backend  # Decompose each epic
+   4. /pm:epic-sync ecommerce       # Sync all epics
+
+🔍 Using STANDALONE Commands:
+
+   # Parse PRD without AI (fast, deterministic)
+   autopm prd parse my-feature
+
+   # AI-powered parsing with streaming output
+   autopm prd parse my-feature --ai --stream
 
-📋 Documentation Generation:
-   autopm guide config              # Generate configuration docs
-   autopm guide tutorial            # Create tutorials
-   autopm guide examples            # Generate code examples
+   # Extract and validate
+   autopm prd extract-epics my-feature
+   autopm prd validate my-feature --fix
+
+   # Task management
+   autopm task list epic-001
+   autopm task prioritize epic-001
+
+   # Agent invocation
+   autopm agent search kubernetes
+   autopm agent invoke aws-architect "Design VPC" --stream
+
+🛠️  Troubleshooting:
+   autopm validate                  # Check installation & config
+   autopm validate --fix            # Auto-fix common issues
+   autopm mcp diagnose              # Check MCP server health
+   autopm install --force           # Reinstall framework
 
-📚 Resources:
-   Documentation: https://github.com/rafeekpro/ClaudeAutoPM
-   Report Issues: https://github.com/rafeekpro/ClaudeAutoPM/issues
-   Agent Registry: autopm/.claude/agents/AGENT-REGISTRY.md
+📚 Resources & Help:
+   📖 Documentation:  https://github.com/rafeekpro/ClaudeAutoPM
+   🐛 Report Issues:  https://github.com/rafeekpro/ClaudeAutoPM/issues
+   💬 Discussions:    https://github.com/rafeekpro/ClaudeAutoPM/discussions
+   📦 npm Package:    https://www.npmjs.com/package/claude-autopm
+
+💡 Pro Tips:
+   • Use \`autopm --help\` to see this guide anytime
+   • Run \`autopm validate\` after configuration changes
+   • Use \`--stream\` flag for real-time AI responses
+   • Check \`autopm mcp status\` to verify documentation access
+   • Load appropriate team before starting work (frontend/backend/fullstack)
+
+╔════════════════════════════════════════════════════════════════════════════╗
+║  Need more help? Run: autopm <command> --help for detailed command docs   ║
+╚════════════════════════════════════════════════════════════════════════════╝
 `)
     .fail((msg, err, yargs) => {
       if (err) {

package/lib/cli/commands/prd.js

@@ -17,6 +17,7 @@ const fs = require('fs-extra');
 const ora = require('ora');
 const chalk = require('chalk');
 const path = require('path');
+const { spawn } = require('child_process');
 
 /**
  * Get PRD file path
@@ -46,6 +47,310 @@ async function readPrdFile(name) {
   return await fs.readFile(prdPath, 'utf8');
 }
 
+/**
+ * List all PRDs
+ */
+async function prdList(argv) {
+  const spinner = ora('Loading PRDs...').start();
+
+  try {
+    const prdsDir = path.join(process.cwd(), '.claude', 'prds');
+
+    // Check if directory exists
+    const dirExists = await fs.pathExists(prdsDir);
+    if (!dirExists) {
+      spinner.info(chalk.yellow('No PRDs directory found'));
+      console.log(chalk.yellow('\nCreate your first PRD with: autopm prd new <name>'));
+      return;
+    }
+
+    // Read all PRD files
+    const files = await fs.readdir(prdsDir);
+    const prdFiles = files.filter(f => f.endsWith('.md'));
+
+    if (prdFiles.length === 0) {
+      spinner.info(chalk.yellow('No PRDs found'));
+      console.log(chalk.yellow('\nCreate your first PRD with: autopm prd new <name>'));
+      return;
+    }
+
+    spinner.succeed(chalk.green(`Found ${prdFiles.length} PRD(s)`));
+
+    // Read and parse each PRD
+    const prds = [];
+    for (const file of prdFiles) {
+      const filePath = path.join(prdsDir, file);
+      const content = await fs.readFile(filePath, 'utf8');
+
+      // Extract frontmatter
+      const titleMatch = content.match(/^title:\s*(.+)$/m);
+      const statusMatch = content.match(/^status:\s*(\w+)$/m);
+      const priorityMatch = content.match(/^priority:\s*(P\d|Critical|High|Medium|Low)$/m);
+      const createdMatch = content.match(/^created:\s*(.+)$/m);
+
+      prds.push({
+        name: file.replace('.md', ''),
+        title: titleMatch ? titleMatch[1] : file.replace('.md', ''),
+        status: statusMatch ? statusMatch[1] : 'unknown',
+        priority: priorityMatch ? priorityMatch[1] : 'P2',
+        created: createdMatch ? createdMatch[1] : 'unknown'
+      });
+    }
+
+    // Sort by priority (P0 > P1 > P2 > P3)
+    prds.sort((a, b) => {
+      const priorities = { 'P0': 0, 'Critical': 0, 'P1': 1, 'High': 1, 'P2': 2, 'Medium': 2, 'P3': 3, 'Low': 3 };
+      return (priorities[a.priority] || 2) - (priorities[b.priority] || 2);
+    });
+
+    // Display PRDs
+    console.log(chalk.green('\n📋 PRDs:\n'));
+
+    prds.forEach((prd, index) => {
+      const priorityColor = prd.priority.startsWith('P0') || prd.priority === 'Critical' ? chalk.red :
+                           prd.priority.startsWith('P1') || prd.priority === 'High' ? chalk.yellow :
+                           chalk.blue;
+
+      const statusColor = prd.status === 'completed' ? chalk.green :
+                         prd.status === 'in-progress' ? chalk.yellow :
+                         prd.status === 'draft' ? chalk.gray :
+                         chalk.white;
+
+      console.log(`${index + 1}. ${chalk.bold(prd.name)}`);
+      console.log(`   ${priorityColor(prd.priority.padEnd(10))} ${statusColor(prd.status.padEnd(12))} ${chalk.gray(prd.created)}`);
+      if (prd.title !== prd.name) {
+        console.log(`   ${chalk.dim(prd.title)}`);
+      }
+      console.log('');
+    });
+
+    console.log(chalk.dim(`\nTotal: ${prds.length} PRD(s)`));
+    console.log(chalk.dim('Use: autopm prd show <name> to view details\n'));
+
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to list PRDs'));
+    console.error(chalk.red(`\nError: ${error.message}`));
+  }
+}
+
+/**
+ * Show PRD content
+ * @param {Object} argv - Command arguments
+ */
+async function prdShow(argv) {
+  const spinner = ora(`Loading PRD: ${argv.name}`).start();
+
+  try {
+    const content = await readPrdFile(argv.name);
+    spinner.succeed(chalk.green('PRD loaded'));
+
+    console.log('\n' + chalk.gray('─'.repeat(80)) + '\n');
+    console.log(content);
+    console.log('\n' + chalk.gray('─'.repeat(80)) + '\n');
+
+    const prdPath = getPrdPath(argv.name);
+    console.log(chalk.dim(`File: ${prdPath}\n`));
+
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to show PRD'));
+
+    if (error.message.includes('not found')) {
+      console.error(chalk.red(`\nError: ${error.message}`));
+      console.error(chalk.yellow('Use: autopm prd list to see available PRDs'));
+    } else {
+      console.error(chalk.red(`\nError: ${error.message}`));
+    }
+  }
+}
+
+/**
+ * Edit PRD in editor
+ * @param {Object} argv - Command arguments
+ */
+async function prdEdit(argv) {
+  const spinner = ora(`Opening PRD: ${argv.name}`).start();
+
+  try {
+    const prdPath = getPrdPath(argv.name);
+
+    // Check if file exists
+    const exists = await fs.pathExists(prdPath);
+    if (!exists) {
+      spinner.fail(chalk.red('PRD not found'));
+      console.error(chalk.red(`\nError: PRD file not found: ${prdPath}`));
+      console.error(chalk.yellow('Use: autopm prd list to see available PRDs'));
+      return;
+    }
+
+    spinner.succeed(chalk.green('Opening editor...'));
+
+    // Determine editor
+    const editor = process.env.EDITOR || process.env.VISUAL || 'nano';
+
+    // Spawn editor
+    const { spawn } = require('child_process');
+    const child = spawn(editor, [prdPath], {
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
+
+    // Wait for editor to close
+    await new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          console.log(chalk.green('\n✓ PRD saved'));
+          resolve();
+        } else {
+          reject(new Error(`Editor exited with code ${code}`));
+        }
+      });
+      child.on('error', reject);
+    });
+
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to edit PRD'));
+    console.error(chalk.red(`\nError: ${error.message}`));
+  }
+}
+
+/**
+ * Show PRD status
+ * @param {Object} argv - Command arguments
+ */
+async function prdStatus(argv) {
+  const spinner = ora(`Analyzing PRD: ${argv.name}`).start();
+
+  try {
+    const content = await readPrdFile(argv.name);
+
+    // Extract metadata
+    const titleMatch = content.match(/^title:\s*(.+)$/m);
+    const statusMatch = content.match(/^status:\s*(\w+)$/m);
+    const priorityMatch = content.match(/^priority:\s*(P\d|Critical|High|Medium|Low)$/m);
+    const createdMatch = content.match(/^created:\s*(.+)$/m);
+    const authorMatch = content.match(/^author:\s*(.+)$/m);
+    const timelineMatch = content.match(/^timeline:\s*(.+)$/m);
+
+    // Count sections
+    const sections = {
+      'Problem Statement': content.includes('## Problem Statement'),
+      'User Stories': content.includes('## User Stories'),
+      'Technical Requirements': content.includes('## Technical Requirements'),
+      'Success Metrics': content.includes('## Success Metrics'),
+      'Implementation Plan': content.includes('## Implementation Plan'),
+      'Risks': content.includes('## Risks')
+    };
+
+    const completedSections = Object.values(sections).filter(Boolean).length;
+    const totalSections = Object.keys(sections).length;
+    const completeness = Math.round((completedSections / totalSections) * 100);
+
+    spinner.succeed(chalk.green('Status analyzed'));
+
+    // Display status
+    console.log('\n' + chalk.bold('📊 PRD Status Report') + '\n');
+    console.log(chalk.gray('─'.repeat(50)) + '\n');
+
+    console.log(chalk.bold('Metadata:'));
+    console.log(`  Title:     ${titleMatch ? titleMatch[1] : 'N/A'}`);
+    console.log(`  Status:    ${statusMatch ? chalk.yellow(statusMatch[1]) : 'N/A'}`);
+    console.log(`  Priority:  ${priorityMatch ? chalk.red(priorityMatch[1]) : 'N/A'}`);
+    console.log(`  Created:   ${createdMatch ? createdMatch[1] : 'N/A'}`);
+    console.log(`  Author:    ${authorMatch ? authorMatch[1] : 'N/A'}`);
+    console.log(`  Timeline:  ${timelineMatch ? timelineMatch[1] : 'N/A'}`);
+
+    console.log('\n' + chalk.bold('Completeness:') + ` ${completeness}%`);
+
+    const progressBar = '█'.repeat(Math.floor(completeness / 5)) +
+                       '░'.repeat(20 - Math.floor(completeness / 5));
+    console.log(`  [${completeness >= 80 ? chalk.green(progressBar) :
+                      completeness >= 50 ? chalk.yellow(progressBar) :
+                      chalk.red(progressBar)}]`);
+
+    console.log('\n' + chalk.bold('Sections:'));
+    Object.entries(sections).forEach(([name, exists]) => {
+      const icon = exists ? chalk.green('✓') : chalk.red('✗');
+      console.log(`  ${icon} ${name}`);
+    });
+
+    // Statistics
+    const lines = content.split('\n').length;
+    const words = content.split(/\s+/).length;
+    const chars = content.length;
+
+    console.log('\n' + chalk.bold('Statistics:'));
+    console.log(`  Lines:     ${lines}`);
+    console.log(`  Words:     ${words}`);
+    console.log(`  Chars:     ${chars}`);
+
+    console.log('\n' + chalk.gray('─'.repeat(50)) + '\n');
+
+    const prdPath = getPrdPath(argv.name);
+    console.log(chalk.dim(`File: ${prdPath}\n`));
+
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to analyze status'));
+
+    if (error.message.includes('not found')) {
+      console.error(chalk.red(`\nError: ${error.message}`));
+    } else {
+      console.error(chalk.red(`\nError: ${error.message}`));
+    }
+  }
+}
+
+/**
+ * Create new PRD
+ * @param {Object} argv - Command arguments
+ */
+async function prdNew(argv) {
+  const spinner = ora(`Creating PRD: ${argv.name}`).start();
+
+  try {
+    // Build script path
+    const scriptPath = path.join(process.cwd(), '.claude', 'scripts', 'pm', 'prd-new.js');
+
+    // Check if script exists
+    const scriptExists = await fs.pathExists(scriptPath);
+    if (!scriptExists) {
+      spinner.fail(chalk.red('PRD creation script not found'));
+      console.error(chalk.red('\nError: .claude/scripts/pm/prd-new.js not found'));
+      console.error(chalk.yellow('Run: autopm install'));
+      return;
+    }
+
+    // Build arguments
+    const args = [scriptPath, argv.name];
+    if (argv.template) {
+      args.push('--template', argv.template);
+    }
+
+    spinner.stop();
+
+    // Spawn interactive process
+    const child = spawn('node', args, {
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
+
+    // Wait for completion
+    await new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`PRD creation failed with code ${code}`));
+        }
+      });
+      child.on('error', reject);
+    });
+
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to create PRD'));
+    console.error(chalk.red(`\nError: ${error.message}`));
+  }
+}
+
 /**
  * Parse PRD with AI
  * @param {Object} argv - Command arguments
@@ -222,7 +527,7 @@ async function prdValidate(argv) {
  */
 async function handler(argv) {
   // Validate action
-  const validActions = ['parse', 'extract-epics', 'summarize', 'validate'];
+  const validActions = ['list', 'new', 'show', 'edit', 'status', 'parse', 'extract-epics', 'summarize', 'validate'];
 
   if (!validActions.includes(argv.action)) {
     console.error(chalk.red(`\nError: Unknown action: ${argv.action}`));
@@ -233,6 +538,21 @@ async function handler(argv) {
   // Route to appropriate handler
   try {
     switch (argv.action) {
+      case 'list':
+        await prdList(argv);
+        break;
+      case 'new':
+        await prdNew(argv);
+        break;
+      case 'show':
+        await prdShow(argv);
+        break;
+      case 'edit':
+        await prdEdit(argv);
+        break;
+      case 'status':
+        await prdStatus(argv);
+        break;
       case 'parse':
         await prdParse(argv);
         break;
@@ -259,6 +579,69 @@ async function handler(argv) {
  */
 function builder(yargs) {
   return yargs
+    .command(
+      'list',
+      'List all PRDs',
+      (yargs) => {
+        return yargs
+          .example('autopm prd list', 'Show all PRDs');
+      }
+    )
+    .command(
+      'new <name>',
+      'Create new PRD interactively',
+      (yargs) => {
+        return yargs
+          .positional('name', {
+            describe: 'PRD name (use-kebab-case)',
+            type: 'string'
+          })
+          .option('template', {
+            describe: 'Template to use (api-feature, ui-feature, bug-fix, data-migration, documentation)',
+            type: 'string',
+            alias: 't'
+          })
+          .example('autopm prd new my-feature', 'Create PRD with wizard')
+          .example('autopm prd new payment-api --template api-feature', 'Create PRD from template');
+      }
+    )
+    .command(
+      'show <name>',
+      'Display PRD content',
+      (yargs) => {
+        return yargs
+          .positional('name', {
+            describe: 'PRD name (without .md extension)',
+            type: 'string'
+          })
+          .example('autopm prd show my-feature', 'Display PRD content');
+      }
+    )
+    .command(
+      'edit <name>',
+      'Edit PRD in your editor',
+      (yargs) => {
+        return yargs
+          .positional('name', {
+            describe: 'PRD name (without .md extension)',
+            type: 'string'
+          })
+          .example('autopm prd edit my-feature', 'Open PRD in editor')
+          .example('EDITOR=code autopm prd edit my-feature', 'Open PRD in VS Code');
+      }
+    )
+    .command(
+      'status <name>',
+      'Show PRD status and completeness',
+      (yargs) => {
+        return yargs
+          .positional('name', {
+            describe: 'PRD name (without .md extension)',
+            type: 'string'
+          })
+          .example('autopm prd status my-feature', 'Show PRD status report');
+      }
+    )
     .command(
       'parse <name>',
       'Parse PRD with AI analysis',
@@ -337,6 +720,11 @@ module.exports = {
   builder,
   handler,
   handlers: {
+    list: prdList,
+    new: prdNew,
+    show: prdShow,
+    edit: prdEdit,
+    status: prdStatus,
     parse: prdParse,
     extractEpics: prdExtractEpics,
     summarize: prdSummarize,

package/package.json

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