claude-autopm 1.26.0 → 1.28.0

package/autopm/.claude/scripts/pm/template-new.js

@@ -0,0 +1,344 @@
+#!/usr/bin/env node
+/**
+ * Template New - Create custom template
+ *
+ * Usage:
+ *   autopm template:new prd my-custom-template
+ *   autopm template:new epic my-sprint-template
+ *   autopm template:new task my-task-template
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Dynamically resolve template engine path
+let TemplateEngine;
+try {
+  TemplateEngine = require(path.join(__dirname, '..', '..', '..', '..', 'lib', 'template-engine'));
+} catch (err) {
+  try {
+    TemplateEngine = require(path.join(process.cwd(), 'lib', 'template-engine'));
+  } catch (err2) {
+    TemplateEngine = require('../../../lib/template-engine');
+  }
+}
+
+class TemplateCreator {
+  constructor() {
+    this.templateEngine = new TemplateEngine();
+  }
+
+  /**
+   * Get base template for type
+   */
+  getBaseTemplate(type) {
+    const templates = {
+      prd: `---
+id: {{id}}
+title: {{title}}
+type: prd
+status: draft
+priority: {{priority}}
+created: {{timestamp}}
+author: {{author}}
+timeline: {{timeline}}
+---
+
+# PRD: {{title}}
+
+## Executive Summary
+
+{{executive_summary}}
+
+## Problem Statement
+
+### Background
+{{problem_background}}
+
+### Current State
+{{current_state}}
+
+### Desired State
+{{desired_state}}
+
+## Target Users
+
+{{target_users}}
+
+## Key Features
+
+### Must Have (P0)
+{{#if must_have_features}}
+{{#each must_have_features}}
+- [ ] {{this}}
+{{/each}}
+{{/if}}
+
+### Should Have (P1)
+{{#if should_have_features}}
+{{#each should_have_features}}
+- [ ] {{this}}
+{{/each}}
+{{/if}}
+
+## Success Metrics
+
+{{success_metrics}}
+
+## Technical Requirements
+
+{{technical_requirements}}
+
+## Implementation Plan
+
+### Phase 1: Design (Week 1)
+- [ ] Requirements finalized
+- [ ] Technical design review
+- [ ] Development environment setup
+
+### Phase 2: Development (Week 2-3)
+- [ ] Implement core features
+- [ ] Write tests (TDD)
+- [ ] Code review
+
+### Phase 3: Testing (Week 4)
+- [ ] Integration testing
+- [ ] User acceptance testing
+- [ ] Performance testing
+
+### Phase 4: Release (Week 5)
+- [ ] Documentation
+- [ ] Deployment
+- [ ] Monitoring setup
+
+## Risks and Mitigation
+
+{{risks_and_mitigation}}
+
+## Open Questions
+
+- [ ] {{open_question_1}}
+- [ ] {{open_question_2}}
+
+## Appendix
+
+### Changelog
+- {{timestamp}}: Initial PRD created by {{author}}
+
+---
+
+*Custom PRD Template*
+`,
+      epic: `---
+id: {{id}}
+title: {{title}}
+type: epic
+status: planning
+priority: {{priority}}
+created: {{timestamp}}
+author: {{author}}
+start_date: {{start_date}}
+end_date: {{end_date}}
+---
+
+# Epic: {{title}}
+
+## Overview
+
+{{overview}}
+
+## Goals
+
+{{#each goals}}
+- {{this}}
+{{/each}}
+
+## User Stories
+
+{{#each user_stories}}
+- As a {{role}}, I want to {{action}}, so that {{benefit}}
+{{/each}}
+
+## Tasks
+
+{{#each tasks}}
+- [ ] {{this}}
+{{/each}}
+
+## Success Criteria
+
+{{success_criteria}}
+
+## Dependencies
+
+{{dependencies}}
+
+---
+
+*Custom Epic Template*
+`,
+      task: `---
+id: {{id}}
+title: {{title}}
+type: task
+status: todo
+priority: {{priority}}
+created: {{timestamp}}
+author: {{author}}
+assigned_to: {{assigned_to}}
+estimated_hours: {{estimated_hours}}
+---
+
+# Task: {{title}}
+
+## Description
+
+{{description}}
+
+## Acceptance Criteria
+
+{{#each acceptance_criteria}}
+- [ ] {{this}}
+{{/each}}
+
+## Technical Details
+
+{{technical_details}}
+
+## Testing
+
+{{testing_notes}}
+
+## Notes
+
+{{notes}}
+
+---
+
+*Custom Task Template*
+`
+    };
+
+    return templates[type] || templates.prd;
+  }
+
+  /**
+   * Create new template
+   */
+  create(type, name) {
+    console.log(`\n📝 Creating Custom Template`);
+    console.log(`${'═'.repeat(50)}\n`);
+
+    // Validate type
+    const validTypes = ['prd', 'epic', 'task'];
+    if (!validTypes.includes(type)) {
+      console.error(`❌ Invalid type: ${type}`);
+      console.log(`Valid types: ${validTypes.join(', ')}`);
+      return false;
+    }
+
+    // Ensure template directory exists
+    const typeDir = type === 'prd' ? 'prds' : type === 'epic' ? 'epics' : 'tasks';
+    this.templateEngine.ensureTemplateDir(typeDir);
+
+    const templatePath = path.join('.claude', 'templates', typeDir, `${name}.md`);
+
+    // Check if template already exists
+    if (fs.existsSync(templatePath)) {
+      console.error(`❌ Template already exists: ${templatePath}`);
+      console.log(`💡 Edit file directly or choose a different name`);
+      return false;
+    }
+
+    // Get base template
+    const baseTemplate = this.getBaseTemplate(type);
+
+    // Write template file
+    fs.writeFileSync(templatePath, baseTemplate);
+
+    console.log(`✅ Template created: ${templatePath}`);
+    console.log(`\n📋 Template Structure:`);
+    console.log(`   - Frontmatter: Define metadata variables`);
+    console.log(`   - Variables: Use {{variable_name}} for substitution`);
+    console.log(`   - Conditionals: {{#if var}}...{{/if}}`);
+    console.log(`   - Loops: {{#each items}}...{{/each}}`);
+
+    console.log(`\n🛠️  Next Steps:`);
+    console.log(`   1. Edit template: nano ${templatePath}`);
+    console.log(`   2. Add custom variables and sections`);
+    console.log(`   3. Test template: autopm ${type}:new --template ${name} "Test"`);
+
+    // Try to open in editor
+    this.openInEditor(templatePath);
+
+    return true;
+  }
+
+  /**
+   * Open template in editor
+   */
+  openInEditor(templatePath) {
+    const editors = ['code', 'nano', 'vim', 'vi'];
+
+    for (const editor of editors) {
+      try {
+        // Check if editor exists
+        execSync(`which ${editor}`, { stdio: 'ignore' });
+
+        console.log(`\n📝 Opening in ${editor}...`);
+        console.log(`   Edit the template, save, and exit`);
+
+        // Open editor (blocking)
+        execSync(`${editor} ${templatePath}`, { stdio: 'inherit' });
+
+        // Validate template after editing
+        const content = fs.readFileSync(templatePath, 'utf8');
+        const validation = this.templateEngine.validate(content);
+
+        if (!validation.valid) {
+          console.log(`\n⚠️  Template validation warnings:`);
+          validation.errors.forEach(err => console.log(`   - ${err}`));
+          console.log(`\n💡 These are suggestions. Template will still work.`);
+        } else {
+          console.log(`\n✅ Template is valid!`);
+        }
+
+        return true;
+      } catch (err) {
+        // Editor not found, try next
+        continue;
+      }
+    }
+
+    // No editor found
+    console.log(`\n💡 Edit manually: ${templatePath}`);
+    return false;
+  }
+
+  run(args) {
+    if (args.length < 2) {
+      console.error('❌ Usage: autopm template:new <type> <name>');
+      console.log('\nExamples:');
+      console.log('  autopm template:new prd my-custom-prd');
+      console.log('  autopm template:new epic my-sprint');
+      console.log('  autopm template:new task my-development-task');
+      console.log('\nTypes: prd, epic, task');
+      process.exit(1);
+    }
+
+    const type = args[0];
+    const name = args[1];
+
+    const success = this.create(type, name);
+    process.exit(success ? 0 : 1);
+  }
+}
+
+// Main execution
+if (require.main === module) {
+  const creator = new TemplateCreator();
+  creator.run(process.argv.slice(2));
+}
+
+module.exports = TemplateCreator;

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

@@ -0,0 +1,158 @@
+/**
+ * Epic Decomposition - Local Mode
+ *
+ * AI-powered decomposition of epics into right-sized tasks (4-8h each).
+ * Generates task files with frontmatter, dependencies, and acceptance criteria.
+ *
+ * Usage:
+ *   const { decomposeLocalEpic } = require('./pm-epic-decompose-local');
+ *
+ *   const result = await decomposeLocalEpic('epic-001', {
+ *     aiProvider: new OpenAIProvider(),
+ *     maxTasks: 10
+ *   });
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { showLocalEpic } = require('./pm-epic-show-local');
+const { updateLocalEpic } = require('./pm-epic-update-local');
+const { stringifyFrontmatter } = require('../lib/frontmatter');
+const { TaskGenerator } = require('../lib/ai-task-generator');
+const { analyzeDependencies } = require('../lib/dependency-analyzer');
+const { generateTaskId, generateTaskNumber, generateTaskFilename } = require('../lib/task-utils');
+
+/**
+ * Decompose epic into tasks using AI
+ *
+ * @param {string} epicId - Epic ID to decompose
+ * @param {Object} options - Decomposition options
+ * @param {Object} [options.aiProvider] - AI provider instance (for testing)
+ * @param {number} [options.maxTasks=15] - Maximum tasks to generate
+ * @param {boolean} [options.validateDependencies=false] - Validate dependency graph
+ * @returns {Promise<Object>} Decomposition result
+ */
+async function decomposeLocalEpic(epicId, options = {}) {
+  const {
+    aiProvider = null,
+    maxTasks = 15,
+    validateDependencies = false
+  } = options;
+
+  // 1. Load epic
+  const epic = await showLocalEpic(epicId);
+  const epicDir = path.dirname(epic.path);
+
+  // 2. Generate tasks using AI
+  const generator = new TaskGenerator(aiProvider);
+  const tasks = await generator.generate(epic.body, { maxTasks });
+
+  // Handle empty response
+  if (tasks.length === 0) {
+    return {
+      epicId,
+      tasksCreated: 0,
+      warning: 'No tasks generated by AI provider'
+    };
+  }
+
+  // 3. Validate dependencies if requested
+  if (validateDependencies) {
+    const analysis = analyzeDependencies(tasks);
+    if (analysis.hasCircularDependencies) {
+      throw new Error(
+        `Circular dependency detected: ${analysis.cycles.map(c => c.join(' -> ')).join(', ')}`
+      );
+    }
+  }
+
+  // 4. Create task files
+  const taskIds = [];
+  for (let i = 0; i < tasks.length; i++) {
+    const task = tasks[i];
+    const taskId = generateTaskId(epicId, i + 1);
+    const taskFilename = generateTaskFilename(i + 1);
+    const taskPath = path.join(epicDir, taskFilename);
+
+    // Build task frontmatter
+    const taskFrontmatter = {
+      id: taskId,
+      epic_id: epicId,
+      title: task.title,
+      status: 'pending',
+      priority: task.priority || 'medium',
+      estimated_hours: task.estimated_hours || 4,
+      dependencies: task.dependencies || [],
+      created: new Date().toISOString().split('T')[0]
+    };
+
+    // Build task body
+    const taskBody = buildTaskBody(task);
+
+    // Write task file
+    const taskContent = stringifyFrontmatter(taskFrontmatter, taskBody);
+    await fs.writeFile(taskPath, taskContent, 'utf8');
+
+    taskIds.push(taskId);
+  }
+
+  // 5. Update epic with task count
+  await updateLocalEpic(epicId, {
+    tasks_total: tasks.length,
+    tasks_completed: 0,
+    task_ids: taskIds
+  });
+
+  return {
+    epicId,
+    tasksCreated: tasks.length,
+    taskIds
+  };
+}
+
+/**
+ * Build task body content from AI-generated task
+ *
+ * @param {Object} task - Task object from AI
+ * @returns {string} Markdown body content
+ */
+function buildTaskBody(task) {
+  let body = `# ${task.title}\n\n`;
+
+  // Description
+  if (task.description) {
+    body += `## Description\n\n${task.description}\n\n`;
+  }
+
+  // Acceptance Criteria
+  body += `## Acceptance Criteria\n\n`;
+  if (task.acceptance_criteria && task.acceptance_criteria.length > 0) {
+    task.acceptance_criteria.forEach(criterion => {
+      body += `- [ ] ${criterion}\n`;
+    });
+  } else {
+    body += `- [ ] Implementation complete\n`;
+    body += `- [ ] Tests passing\n`;
+    body += `- [ ] Code reviewed\n`;
+  }
+
+  body += `\n`;
+
+  // Technical Notes (if provided)
+  if (task.technical_notes) {
+    body += `## Technical Notes\n\n${task.technical_notes}\n\n`;
+  }
+
+  // Dependencies
+  if (task.dependencies && task.dependencies.length > 0) {
+    body += `## Dependencies\n\n`;
+    task.dependencies.forEach(dep => {
+      body += `- ${dep}\n`;
+    });
+    body += `\n`;
+  }
+
+  return body.trim();
+}
+
+module.exports = { decomposeLocalEpic };

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

@@ -0,0 +1,103 @@
+/**
+ * List Local Epics
+ *
+ * Lists all epics in the local `.claude/epics/` directory
+ * with optional filtering by status or PRD ID.
+ *
+ * Usage:
+ *   const { listLocalEpics } = require('./pm-epic-list-local');
+ *
+ *   // List all epics
+ *   const epics = await listLocalEpics();
+ *
+ *   // Filter by status
+ *   const inProgress = await listLocalEpics({ status: 'in_progress' });
+ *
+ *   // Filter by PRD
+ *   const prdEpics = await listLocalEpics({ prd_id: 'prd-001' });
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { parseFrontmatter } = require('../lib/frontmatter');
+
+/**
+ * List all local epics with optional filtering
+ *
+ * @param {Object} options - Filter options
+ * @param {string} [options.status] - Filter by epic status (planning, in_progress, completed, etc.)
+ * @param {string} [options.prd_id] - Filter by PRD ID
+ * @returns {Promise<Array>} Array of epic objects with frontmatter
+ */
+async function listLocalEpics(options = {}) {
+  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') {
+      return []; // No epics directory = no epics
+    }
+    throw err;
+  }
+
+  // Read all epic directories
+  const dirs = await fs.readdir(epicsDir);
+  const epics = [];
+
+  // Process each epic directory
+  for (const dir of dirs) {
+    // Skip hidden directories and files
+    if (dir.startsWith('.')) continue;
+
+    const epicDir = path.join(epicsDir, dir);
+    const epicPath = path.join(epicDir, 'epic.md');
+
+    try {
+      // Check if it's a directory with epic.md
+      const stat = await fs.stat(epicDir);
+      if (!stat.isDirectory()) continue;
+
+      // Read and parse epic.md
+      const content = await fs.readFile(epicPath, 'utf8');
+      const { frontmatter } = parseFrontmatter(content);
+
+      // Only include valid epics with required fields
+      if (frontmatter && frontmatter.id) {
+        epics.push({
+          ...frontmatter,
+          directory: dir
+        });
+      }
+    } catch (err) {
+      // Skip invalid epic directories (missing epic.md, parse errors, etc.)
+      if (err.code !== 'ENOENT') {
+        console.warn(`Warning: Could not process epic in ${dir}:`, err.message);
+      }
+    }
+  }
+
+  // Apply filters
+  let filtered = epics;
+
+  if (options.status) {
+    filtered = filtered.filter(epic => epic.status === options.status);
+  }
+
+  if (options.prd_id) {
+    filtered = filtered.filter(epic => epic.prd_id === options.prd_id);
+  }
+
+  // Sort by creation date (newest first)
+  filtered.sort((a, b) => {
+    const dateA = new Date(a.created || 0);
+    const dateB = new Date(b.created || 0);
+    return dateB - dateA; // Descending order (newest first)
+  });
+
+  return filtered;
+}
+
+module.exports = { listLocalEpics };

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