claude-autopm 1.26.0 → 1.27.0

package/autopm/.claude/scripts/pm-epic-show-local.js

@@ -0,0 +1,70 @@
+/**
+ * Show Local Epic
+ *
+ * Displays details of a specific epic including frontmatter,
+ * body content, and directory information.
+ *
+ * Usage:
+ *   const { showLocalEpic } = require('./pm-epic-show-local');
+ *
+ *   const epic = await showLocalEpic('epic-001');
+ *   console.log(epic.frontmatter.title);
+ *   console.log(epic.body);
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { parseFrontmatter } = require('../lib/frontmatter');
+
+/**
+ * Get epic details by ID
+ *
+ * @param {string} epicId - Epic ID to retrieve
+ * @returns {Promise<Object>} Epic object with frontmatter, body, and directory
+ * @throws {Error} If epic not found
+ */
+async function showLocalEpic(epicId) {
+  const basePath = process.cwd();
+  const epicsDir = path.join(basePath, '.claude', 'epics');
+
+  // Check if epics directory exists
+  try {
+    await fs.access(epicsDir);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw new Error(`Epic not found: ${epicId} (epics directory does not exist)`);
+    }
+    throw err;
+  }
+
+  // Find epic directory by ID
+  const dirs = await fs.readdir(epicsDir);
+  const epicDir = dirs.find(dir => dir.startsWith(`${epicId}-`));
+
+  if (!epicDir) {
+    throw new Error(`Epic not found: ${epicId}`);
+  }
+
+  const epicDirPath = path.join(epicsDir, epicDir);
+  const epicPath = path.join(epicDirPath, 'epic.md');
+
+  // Read and parse epic file
+  try {
+    const content = await fs.readFile(epicPath, 'utf8');
+    const { frontmatter, body } = parseFrontmatter(content);
+
+    return {
+      frontmatter,
+      body,
+      directory: epicDir,
+      path: epicPath
+    };
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw new Error(`Epic not found: ${epicId} (epic.md missing in ${epicDir})`);
+    }
+    throw err;
+  }
+}
+
+module.exports = { showLocalEpic };

package/autopm/.claude/scripts/pm-epic-update-local.js

@@ -0,0 +1,56 @@
+/**
+ * Update Local Epic
+ *
+ * Updates epic frontmatter fields while preserving body content.
+ * Supports updating single or multiple fields at once.
+ *
+ * Usage:
+ *   const { updateLocalEpic } = require('./pm-epic-update-local');
+ *
+ *   // Update status
+ *   await updateLocalEpic('epic-001', { status: 'in_progress' });
+ *
+ *   // Update multiple fields
+ *   await updateLocalEpic('epic-001', {
+ *     status: 'completed',
+ *     tasks_completed: 5
+ *   });
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { parseFrontmatter, stringifyFrontmatter } = require('../lib/frontmatter');
+const { showLocalEpic } = require('./pm-epic-show-local');
+
+/**
+ * Update epic frontmatter fields
+ *
+ * @param {string} epicId - Epic ID to update
+ * @param {Object} updates - Fields to update in frontmatter
+ * @returns {Promise<Object>} Updated epic object
+ * @throws {Error} If epic not found
+ */
+async function updateLocalEpic(epicId, updates) {
+  // Get current epic
+  const epic = await showLocalEpic(epicId);
+
+  // Merge updates into frontmatter
+  const updatedFrontmatter = {
+    ...epic.frontmatter,
+    ...updates
+  };
+
+  // Preserve body content
+  const updatedContent = stringifyFrontmatter(updatedFrontmatter, epic.body);
+
+  // Write updated content back to file
+  await fs.writeFile(epic.path, updatedContent, 'utf8');
+
+  return {
+    epicId,
+    frontmatter: updatedFrontmatter,
+    body: epic.body
+  };
+}
+
+module.exports = { updateLocalEpic };

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
+};