claude-autopm 1.25.0 → 1.27.0

package/autopm/.claude/scripts/pm-prd-list-local.js

@@ -0,0 +1,111 @@
+/**
+ * Local PRD Listing Command
+ *
+ * Lists all Product Requirements Documents (PRDs) in local mode.
+ * Supports filtering and sorting.
+ *
+ * Usage:
+ *   /pm:prd-list --local
+ *   /pm:prd-list --local --status approved
+ *
+ * @module pm-prd-list-local
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { parseFrontmatter } = require('../lib/frontmatter');
+
+/**
+ * Lists all local PRDs with optional filtering
+ *
+ * @param {Object} options - Listing options
+ * @param {string} options.status - Filter by status (draft, approved, etc.)
+ * @returns {Promise<Array>} Array of PRD metadata objects
+ */
+async function listLocalPRDs(options = {}) {
+  const prdsDir = path.join(process.cwd(), '.claude', 'prds');
+
+  // Ensure directory exists
+  try {
+    await fs.access(prdsDir);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return []; // No PRDs directory = no PRDs
+    }
+    throw err;
+  }
+
+  // Read directory
+  const files = await fs.readdir(prdsDir);
+  const mdFiles = files.filter(f => f.endsWith('.md'));
+
+  // Parallelize file reading/parsing with Promise.allSettled
+  const prdPromises = mdFiles.map(async (file) => {
+    try {
+      const filepath = path.join(prdsDir, file);
+      const content = await fs.readFile(filepath, 'utf8');
+      const { frontmatter } = parseFrontmatter(content);
+      // Only include files with valid frontmatter containing required fields
+      // A valid PRD must have at least an 'id' field
+      if (frontmatter && typeof frontmatter === 'object' && frontmatter.id) {
+        return {
+          filename: file,
+          ...frontmatter
+        };
+      }
+    } catch (err) {
+      // Skip files that can't be parsed
+      console.warn(`Warning: Could not parse ${file}:`, err.message);
+    }
+    return null;
+  });
+
+  const settled = await Promise.allSettled(prdPromises);
+  const prds = settled
+    .filter(r => r.status === 'fulfilled' && r.value)
+    .map(r => r.value);
+  // Filter by status if specified
+  let filtered = prds;
+  if (options.status) {
+    filtered = filtered.filter(p => p.status === options.status);
+  }
+
+  // Sort by creation timestamp (newest first)
+  filtered.sort((a, b) => {
+    // Use createdAt if available (full timestamp), fallback to created (date only)
+    const dateA = new Date(a.createdAt || a.created || 0);
+    const dateB = new Date(b.createdAt || b.created || 0);
+    return dateB - dateA;
+  });
+
+  return filtered;
+}
+
+/**
+ * Formats PRD list for display
+ *
+ * @param {Array} prds - Array of PRD objects
+ * @returns {string} Formatted string for display
+ */
+function formatPRDList(prds) {
+  if (prds.length === 0) {
+    return 'No PRDs found.';
+  }
+
+  const lines = ['', 'Local PRDs:', ''];
+
+  prds.forEach((prd, index) => {
+    lines.push(
+      `${index + 1}. [${prd.id}] ${prd.title}`,
+      `   Status: ${prd.status} | Priority: ${prd.priority} | Created: ${prd.created}`,
+      ''
+    );
+  });
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  listLocalPRDs,
+  formatPRDList
+};

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

@@ -0,0 +1,196 @@
+/**
+ * Local PRD Creation Command
+ *
+ * Creates a new Product Requirements Document (PRD) in local mode.
+ * PRDs are stored in .claude/prds/ directory.
+ *
+ * Usage:
+ *   /pm:prd-new --local "Feature Name"
+ *
+ * @module pm-prd-new-local
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { stringifyFrontmatter } = require('../lib/frontmatter');
+
+/**
+ * Creates a new PRD in the local .claude/prds/ directory
+ *
+ * @param {string} name - PRD title/name
+ * @param {Object} options - Optional configuration
+ * @param {string} options.id - Custom PRD ID (auto-generated if not provided)
+ * @param {string} options.author - Author name (default: 'ClaudeAutoPM')
+ * @param {string} options.priority - Priority level (default: 'medium')
+ * @returns {Promise<Object>} Created PRD metadata
+ * @throws {Error} If name is invalid or PRD already exists
+ */
+async function createLocalPRD(name, options = {}) {
+  // Validate name
+  if (!name || typeof name !== 'string' || name.trim().length === 0) {
+    throw new Error('PRD name is required and must be a non-empty string');
+  }
+
+  const sanitizedName = name.trim();
+
+  // Generate unique ID
+  const id = options.id || generatePRDId();
+
+  // Create frontmatter
+  const now = new Date();
+  const frontmatter = {
+    id,
+    title: sanitizedName,
+    created: now.toISOString().split('T')[0],
+    createdAt: now.toISOString(), // Include full timestamp for sorting
+    author: options.author || 'ClaudeAutoPM',
+    status: 'draft',
+    priority: options.priority || 'medium',
+    version: '1.0'
+  };
+
+  // Create PRD body template
+  const body = createPRDTemplate(sanitizedName);
+
+  // Generate full markdown content
+  const content = stringifyFrontmatter(frontmatter, body);
+
+  // Generate filename (sanitize name + add ID for uniqueness)
+  const filename = `${id}-${sanitizeFilename(sanitizedName)}`;
+  const filepath = path.join(process.cwd(), '.claude', 'prds', filename);
+
+  // Check if file already exists
+  try {
+    await fs.access(filepath);
+    throw new Error(`PRD already exists: ${filename}`);
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      throw err;
+    }
+  }
+
+  // Ensure directory exists
+  await fs.mkdir(path.dirname(filepath), { recursive: true });
+
+  // Write to file
+  await fs.writeFile(filepath, content, 'utf8');
+
+  return {
+    id,
+    filepath,
+    frontmatter
+  };
+}
+
+/**
+ * Creates a PRD template with standard sections
+ *
+ * @param {string} name - PRD title
+ * @returns {string} PRD template content
+ */
+function createPRDTemplate(name) {
+  return `# Product Requirements Document: ${name}
+
+## 1. Executive Summary
+
+### Overview
+[Describe the feature/product in 2-3 sentences]
+
+### Business Value
+[Why is this important?]
+
+### Success Metrics
+[How will we measure success?]
+
+## 2. Background
+
+### Problem Statement
+[What problem are we solving?]
+
+### Current State
+[What exists today?]
+
+### Goals and Objectives
+[What are we trying to achieve?]
+
+## 3. User Stories
+
+[Epic-level user stories]
+
+## 4. Functional Requirements
+
+[Detailed requirements]
+
+## 5. Non-Functional Requirements
+
+[Performance, security, etc.]
+
+## 6. Out of Scope
+
+[What we're NOT doing]
+
+## 7. Timeline
+
+[Key milestones]
+`;
+}
+
+// Counter for ensuring unique IDs even when created at the same millisecond
+let idCounter = 0;
+
+/**
+ * Generates a unique PRD ID
+ *
+ * Format: prd-XXX (3 digits from timestamp + counter)
+ *
+ * @returns {string} Generated PRD ID
+ */
+function generatePRDId() {
+  const timestamp = Date.now();
+  const random = Math.floor(Math.random() * 900) + 100; // 100-999
+  const counter = (idCounter++) % 10; // 0-9 cycling counter
+
+  // Use last digit of timestamp + last 2 digits of random = 3 digits total
+  const suffix = (timestamp % 10).toString() +
+                 (Math.floor(random / 10) % 10).toString() +
+                 counter.toString();
+
+  return `prd-${suffix}`;
+}
+
+/**
+ * Sanitizes a PRD name for use as a filename
+ *
+ * - Converts to lowercase
+ * - Replaces spaces with hyphens
+ * - Removes special characters except hyphens
+ * - Truncates to safe length (max 100 chars before .md)
+ * - Adds .md extension
+ *
+ * @param {string} name - PRD name to sanitize
+ * @returns {string} Sanitized filename
+ */
+function sanitizeFilename(name) {
+  const sanitized = name
+    .toLowerCase()
+    .replace(/\s+/g, '-')           // Replace spaces with hyphens
+    .replace(/[^a-z0-9-]/g, '')     // Remove special characters
+    .replace(/-+/g, '-')            // Collapse multiple hyphens
+    .replace(/^-|-$/g, '');         // Remove leading/trailing hyphens
+
+  // Truncate to safe length (100 chars + .md = 103 total)
+  // With prd-XXX- prefix (8 chars), max base name is ~92 chars
+  const maxLength = 92;
+  const truncated = sanitized.length > maxLength
+    ? sanitized.substring(0, maxLength)
+    : sanitized;
+
+  return truncated + '.md';
+}
+
+module.exports = {
+  createLocalPRD,
+  createPRDTemplate,
+  generatePRDId,
+  sanitizeFilename
+};

package/autopm/.claude/scripts/pm-prd-parse-local.js

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+/**
+ * TASK-005: PRD-to-Epic Parser (Local Mode)
+ *
+ * Parse PRD markdown to Epic structure with proper section extraction
+ * Uses markdown-it for robust markdown parsing (Context7 verified)
+ *
+ * @module pm-prd-parse-local
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const MarkdownIt = require('markdown-it');
+const { parseFrontmatter, stringifyFrontmatter } = require('../lib/frontmatter');
+const { showLocalPRD } = require('./pm-prd-show-local');
+
+/**
+ * Parse PRD to Epic structure
+ *
+ * @param {string} prdId - PRD identifier (e.g., 'prd-347')
+ * @returns {Promise<object>} Epic data with structure:
+ *   - epicId: Generated epic ID
+ *   - epicDir: Path to epic directory
+ *   - epicPath: Path to epic.md file
+ *   - frontmatter: Epic frontmatter object
+ *   - sections: Extracted PRD sections
+ */
+async function parseLocalPRD(prdId) {
+  // 1. Load PRD
+  const prd = await showLocalPRD(prdId);
+  const prdMeta = prd.frontmatter;
+  const prdBody = prd.body;
+
+  // 2. Parse markdown sections
+  const sections = extractSections(prdBody);
+
+  // 3. Generate Epic frontmatter
+  const epicId = generateEpicId(prdId);
+  const epicFrontmatter = {
+    id: epicId,
+    prd_id: prdId,
+    title: `${prdMeta.title} - Implementation Epic`,
+    created: new Date().toISOString().split('T')[0],
+    status: 'planning',
+    github_issue: null,
+    tasks_total: 0,
+    tasks_completed: 0
+  };
+
+  // 4. Build Epic body
+  const epicBody = buildEpicBody(sections, prdMeta);
+
+  // 5. Create epic directory
+  const epicDir = path.join(process.cwd(), '.claude', 'epics',
+    `${epicId}-${slugify(prdMeta.title)}`);
+  await fs.mkdir(epicDir, { recursive: true });
+
+  // 6. Write epic.md
+  const epicContent = stringifyFrontmatter(epicFrontmatter, epicBody);
+  const epicPath = path.join(epicDir, 'epic.md');
+  await fs.writeFile(epicPath, epicContent);
+
+  return {
+    epicId,
+    epicDir,
+    epicPath,
+    frontmatter: epicFrontmatter,
+    sections
+  };
+}
+
+/**
+ * Extract sections from PRD markdown
+ * Uses markdown-it to parse headings and content
+ *
+ * @param {string} markdown - PRD markdown content
+ * @returns {object} Extracted sections:
+ *   - overview: Project overview/summary
+ *   - goals: Project goals/objectives
+ *   - userStories: Array of user story objects
+ *   - requirements: Technical requirements
+ *   - timeline: Timeline/milestones
+ */
+function extractSections(markdown) {
+  const md = new MarkdownIt();
+  const tokens = md.parse(markdown, {});
+
+  const sections = {
+    overview: '',
+    goals: '',
+    userStories: [],
+    requirements: '',
+    timeline: ''
+  };
+
+  let currentSection = null;
+  let currentContent = [];
+  let currentHeading = '';
+  let inList = false;
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+
+    if (token.type === 'heading_open') {
+      // Only process ## headings (level 2), not ### (level 3)
+      if (token.tag === 'h2') {
+        // Save previous section
+        if (currentSection) {
+          const content = currentContent.join('\n').trim();
+          if (currentSection === 'userStories') {
+            sections[currentSection] = parseUserStories(content);
+          } else {
+            sections[currentSection] = content;
+          }
+        }
+
+        // Get heading content from next token
+        const nextToken = tokens[i + 1];
+        if (nextToken && nextToken.type === 'inline') {
+          currentHeading = nextToken.content.toLowerCase();
+        }
+
+        // Start new section
+        currentContent = [];
+        inList = false;
+
+        // Determine section type from heading
+        if (currentHeading.includes('overview') || currentHeading.includes('summary')) {
+          currentSection = 'overview';
+        } else if (currentHeading.includes('goal') || currentHeading.includes('objective')) {
+          currentSection = 'goals';
+        } else if (currentHeading.includes('user stor')) {
+          currentSection = 'userStories';
+        } else if (currentHeading.includes('requirement')) {
+          currentSection = 'requirements';
+        } else if (currentHeading.includes('timeline') || currentHeading.includes('milestone')) {
+          currentSection = 'timeline';
+        } else {
+          currentSection = null;
+        }
+
+        // Skip the inline token (heading content) and closing tag
+        i += 2;
+      } else if (token.tag === 'h3' && currentSection) {
+        // Preserve ### headings within sections
+        const nextToken = tokens[i + 1];
+        if (nextToken && nextToken.type === 'inline') {
+          currentContent.push('');
+          currentContent.push('### ' + nextToken.content);
+          currentContent.push('');
+        }
+        i += 2; // Skip inline and closing tag
+      }
+    } else if (currentSection && token.type === 'inline' && token.content) {
+      currentContent.push(token.content);
+    } else if (currentSection && token.type === 'fence' && token.content) {
+      // Preserve code blocks
+      currentContent.push('');
+      currentContent.push('```' + (token.info || ''));
+      currentContent.push(token.content.trim());
+      currentContent.push('```');
+      currentContent.push('');
+    } else if (currentSection && token.type === 'bullet_list_open') {
+      // Handle bullet lists
+      if (currentContent.length > 0 && currentContent[currentContent.length - 1] !== '') {
+        currentContent.push('');
+      }
+      inList = true;
+    } else if (currentSection && token.type === 'bullet_list_close') {
+      inList = false;
+      if (currentContent.length > 0 && currentContent[currentContent.length - 1] !== '') {
+        currentContent.push('');
+      }
+    } else if (currentSection && token.type === 'list_item_open') {
+      // Add list item marker - look ahead for paragraph
+      let contentFound = false;
+      for (let j = i + 1; j < tokens.length && !contentFound; j++) {
+        if (tokens[j].type === 'inline' && tokens[j].content) {
+          currentContent.push('- ' + tokens[j].content);
+          contentFound = true;
+        } else if (tokens[j].type === 'list_item_close') {
+          break;
+        }
+      }
+    } else if (currentSection && token.type === 'paragraph_open' && !inList) {
+      // Add blank line before paragraph (except first one or in lists)
+      if (currentContent.length > 0 && currentContent[currentContent.length - 1] !== '') {
+        currentContent.push('');
+      }
+    }
+  }
+
+  // Save last section
+  if (currentSection) {
+    const content = currentContent.join('\n').trim();
+    if (currentSection === 'userStories') {
+      sections[currentSection] = parseUserStories(content);
+    } else {
+      sections[currentSection] = content;
+    }
+  }
+
+  return sections;
+}
+
+/**
+ * Parse user stories from text
+ * Looks for "As a...", "I want...", "So that..." patterns
+ *
+ * @param {string} text - Text containing user stories
+ * @returns {Array<object>} Array of user story objects with raw text
+ */
+function parseUserStories(text) {
+  const stories = [];
+  const lines = text.split('\n');
+
+  let currentStory = null;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Check if line starts a new user story (matches "As a" or "As an", with optional bold)
+    if (/^\*\*As an?\b/i.test(trimmed) || /^As an?\b/i.test(trimmed)) {
+      // Save previous story
+      if (currentStory) {
+        stories.push(currentStory);
+      }
+      // Start new story
+      currentStory = { raw: trimmed };
+    } else if (currentStory && trimmed) {
+      // Continue current story
+      currentStory.raw += '\n' + trimmed;
+    }
+  }
+
+  // Save last story
+  if (currentStory) {
+    stories.push(currentStory);
+  }
+
+  return stories;
+}
+
+/**
+ * Build Epic body from PRD sections
+ *
+ * @param {object} sections - Extracted PRD sections
+ * @param {object} prdMeta - PRD frontmatter metadata
+ * @returns {string} Epic markdown body
+ */
+function buildEpicBody(sections, prdMeta) {
+  // Build user stories section
+  let userStoriesSection = '';
+  if (sections.userStories && sections.userStories.length > 0) {
+    userStoriesSection = sections.userStories
+      .map((s, i) => `${i + 1}. ${s.raw}`)
+      .join('\n\n');
+  } else {
+    userStoriesSection = 'To be defined from PRD user stories.';
+  }
+
+  return `# Epic: ${prdMeta.title}
+
+## Overview
+
+${sections.overview || 'To be defined based on PRD.'}
+
+## Technical Architecture
+
+### Goals
+${sections.goals || 'Extract from PRD goals and objectives.'}
+
+### User Stories
+${userStoriesSection}
+
+## Implementation Tasks
+
+Tasks will be created via epic decomposition.
+
+## Dependencies
+
+### Between Tasks
+To be determined during task breakdown.
+
+### External Dependencies
+${sections.requirements ? 'See PRD requirements section.' : 'To be identified.'}
+
+## Timeline
+
+${sections.timeline || 'See PRD for timeline and milestones.'}
+
+## Related Documents
+
+- PRD: \`.claude/prds/${slugify(prdMeta.title)}.md\`
+`;
+}
+
+/**
+ * Generate unique epic ID from PRD ID
+ *
+ * @param {string} prdId - PRD identifier (e.g., 'prd-347')
+ * @returns {string} Epic identifier (e.g., 'epic-347')
+ */
+function generateEpicId(prdId) {
+  // prd-347 → epic-347
+  const num = prdId.replace('prd-', '');
+  return `epic-${num}`;
+}
+
+/**
+ * Slugify title for directory/file names
+ * Converts to lowercase, removes special chars, replaces spaces with hyphens
+ *
+ * @param {string} text - Text to slugify
+ * @returns {string} Slugified text
+ */
+function slugify(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^\w\s-]/g, '')
+    .replace(/\s+/g, '-')
+    .replace(/-+/g, '-');
+}
+
+module.exports = {
+  parseLocalPRD,
+  extractSections,
+  parseUserStories,
+  buildEpicBody,
+  generateEpicId,
+  slugify
+};
+
+// CLI execution
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const prdId = args[0];
+
+  if (!prdId) {
+    console.error('Usage: pm-prd-parse-local.js <prd-id>');
+    process.exit(1);
+  }
+
+  parseLocalPRD(prdId)
+    .then(epic => {
+      console.log('✅ Epic created successfully!');
+      console.log(`Epic ID: ${epic.epicId}`);
+      console.log(`Epic Path: ${epic.epicPath}`);
+      console.log(`\nSections extracted:`);
+      console.log(`- Overview: ${epic.sections.overview ? '✓' : '✗'}`);
+      console.log(`- Goals: ${epic.sections.goals ? '✓' : '✗'}`);
+      console.log(`- User Stories: ${epic.sections.userStories.length} found`);
+      console.log(`- Requirements: ${epic.sections.requirements ? '✓' : '✗'}`);
+      console.log(`- Timeline: ${epic.sections.timeline ? '✓' : '✗'}`);
+    })
+    .catch(err => {
+      console.error('❌ Error parsing PRD:', err.message);
+      process.exit(1);
+    });
+}