claude-autopm 2.8.2 → 2.8.3

package/packages/plugin-pm/scripts/pm/context.js

@@ -0,0 +1,338 @@
+const fs = require('fs');
+const path = require('path');
+const { logError } = require('./lib/logger');
+
+/**
+ * PM Context Script
+ * Displays current project context, configuration, and progress
+ */
+
+// Constants
+const TASK_FILE_PATTERN = /^\d{3}\.md$/;
+
+async function context() {
+  console.log('');
+  console.log('🎯 Project Context');
+  console.log('='.repeat(60));
+  console.log('');
+
+  // Project Information
+  console.log('📦 Project Information:');
+
+  // Get project name from package.json or directory name
+  let projectName = path.basename(process.cwd());
+  try {
+    if (fs.existsSync('package.json')) {
+      const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+      if (pkg.name) {
+        projectName = pkg.name;
+      }
+    }
+  } catch (err) {
+    // Use directory name as fallback
+  }
+  console.log(`  Name:           ${projectName}`);
+  console.log(`  Directory:      ${process.cwd()}`);
+  console.log('');
+
+  // Configuration
+  console.log('⚙️  Configuration:');
+  let provider = 'Not configured';
+  let githubOwner = '-';
+  let githubRepo = '-';
+  let azureOrg = '-';
+  let azureProject = '-';
+
+  try {
+    if (fs.existsSync('.claude/config.json')) {
+      const config = JSON.parse(fs.readFileSync('.claude/config.json', 'utf8'));
+      if (config.provider) {
+        provider = config.provider.charAt(0).toUpperCase() + config.provider.slice(1);
+      }
+      if (config.github) {
+        githubOwner = config.github.owner || '-';
+        githubRepo = config.github.repo || '-';
+      }
+      if (config.azure) {
+        azureOrg = config.azure.organization || '-';
+        azureProject = config.azure.project || '-';
+      }
+    }
+  } catch (err) {
+    // Config not found
+  }
+
+  console.log(`  Provider:       ${provider}`);
+  if (provider.toLowerCase() === 'github') {
+    console.log(`  GitHub Owner:   ${githubOwner}`);
+    console.log(`  GitHub Repo:    ${githubRepo}`);
+  } else if (provider.toLowerCase() === 'azure') {
+    console.log(`  Azure Org:      ${azureOrg}`);
+    console.log(`  Azure Project:  ${azureProject}`);
+  }
+  console.log('');
+
+  // Active Team
+  console.log('👥 Active Team:');
+  let activeTeam = 'Default';
+  try {
+    if (fs.existsSync('.claude/active_team.txt')) {
+      activeTeam = fs.readFileSync('.claude/active_team.txt', 'utf8').trim();
+    }
+  } catch (err) {
+    // No active team
+  }
+  console.log(`  Team:           ${activeTeam}`);
+  console.log('');
+
+  // PRDs
+  console.log('📄 Product Requirements (PRDs):');
+  let prdCount = 0;
+  let prdNames = [];
+  try {
+    if (fs.existsSync('.claude/prds')) {
+      const files = fs.readdirSync('.claude/prds')
+        .filter(f => f.endsWith('.md') && !f.startsWith('.'));
+      prdCount = files.length;
+      prdNames = files.map(f => f.replace('.md', ''));
+    }
+  } catch (err) {
+    // No PRDs
+  }
+
+  console.log(`  Total:          ${prdCount}`);
+  if (prdCount > 0) {
+    prdNames.slice(0, 5).forEach(name => {
+      console.log(`    • ${name}`);
+    });
+    if (prdCount > 5) {
+      console.log(`    ... and ${prdCount - 5} more`);
+    }
+  }
+  console.log('');
+
+  // Epics with Progress
+  console.log('📚 Epics & Progress:');
+  let epicCount = 0;
+  let totalTasks = 0;
+  let completedTasks = 0;
+  let inProgressTasks = 0;
+  let pendingTasks = 0;
+  let epicDetails = [];
+
+  try {
+    if (fs.existsSync('.claude/epics')) {
+      const epicDirs = fs.readdirSync('.claude/epics', { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name);
+
+      epicCount = epicDirs.length;
+
+      // Helper to count tasks in a directory and update counters
+      function countTasksInDir(dir, counters) {
+        try {
+          const entries = fs.readdirSync(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+              countTasksInDir(fullPath, counters);
+            } else if (entry.isFile() && TASK_FILE_PATTERN.test(entry.name)) {
+              counters.epicTasks++;
+              totalTasks++;
+              try {
+                const content = fs.readFileSync(fullPath, 'utf8');
+                const statusMatch = content.match(/^status:\s*(.+)$/m);
+                if (statusMatch) {
+                  const status = statusMatch[1].trim().toLowerCase();
+                  if (status === 'completed' || status === 'done' || status === 'closed') {
+                    counters.epicCompleted++;
+                    completedTasks++;
+                  } else if (status === 'in-progress' || status === 'in_progress') {
+                    counters.epicInProgress++;
+                    inProgressTasks++;
+                  } else {
+                    counters.epicPending++;
+                    pendingTasks++;
+                  }
+                } else {
+                  counters.epicPending++;
+                  pendingTasks++;
+                }
+              } catch (err) {
+                counters.epicPending++;
+                pendingTasks++;
+              }
+            }
+          }
+        } catch (err) {
+          // Directory read error
+        }
+      }
+
+      for (const epicDir of epicDirs) {
+        const epicPath = path.join('.claude/epics', epicDir);
+        // Count tasks in this epic (including subdirectories)
+        let counters = {
+          epicTasks: 0,
+          epicCompleted: 0,
+          epicInProgress: 0,
+          epicPending: 0
+        };
+        countTasksInDir(epicPath, counters);
+        if (counters.epicTasks > 0) {
+          const progress = Math.round((counters.epicCompleted / counters.epicTasks) * 100);
+          epicDetails.push({
+            name: epicDir,
+            tasks: counters.epicTasks,
+            completed: counters.epicCompleted,
+            inProgress: counters.epicInProgress,
+            pending: counters.epicPending,
+            progress: progress
+          });
+        }
+      }
+    }
+  } catch (err) {
+    // No epics
+  }
+
+  console.log(`  Total Epics:    ${epicCount}`);
+  console.log(`  Total Tasks:    ${totalTasks}`);
+  console.log(`    Completed:    ${completedTasks}`);
+  console.log(`    In Progress:  ${inProgressTasks}`);
+  console.log(`    Pending:      ${pendingTasks}`);
+  console.log('');
+
+  if (epicDetails.length > 0) {
+    console.log('  Epic Breakdown:');
+    epicDetails.slice(0, 5).forEach(epic => {
+      const progressBar = createProgressBar(epic.progress, 20);
+      console.log(`    ${epic.name}`);
+      console.log(`      ${progressBar} ${epic.progress}% (${epic.completed}/${epic.tasks} tasks)`);
+    });
+    if (epicDetails.length > 5) {
+      console.log(`    ... and ${epicDetails.length - 5} more epics`);
+    }
+    console.log('');
+  }
+
+  // Overall Progress
+  if (totalTasks > 0) {
+    const overallProgress = Math.round((completedTasks / totalTasks) * 100);
+    console.log('📊 Overall Progress:');
+    const overallBar = createProgressBar(overallProgress, 40);
+    console.log(`  ${overallBar} ${overallProgress}%`);
+    console.log(`  ${completedTasks} / ${totalTasks} tasks completed`);
+    console.log('');
+  }
+
+  // Current/Recent Activity
+  console.log('🔄 Recent Activity:');
+  try {
+    // Find most recently modified task file
+    let recentTask = null;
+    let recentTime = 0;
+
+    if (fs.existsSync('.claude/epics')) {
+      function findRecentTask(dir) {
+        let bestTask = null;
+        let bestTime = 0;
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+        for (const entry of entries) {
+          const fullPath = path.join(dir, entry.name);
+
+          if (entry.isDirectory()) {
+            const subTask = findRecentTask(fullPath);
+            if (subTask && subTask.timeMs > bestTime) {
+              bestTask = subTask;
+              bestTime = subTask.timeMs;
+            }
+          } else if (entry.isFile() && TASK_FILE_PATTERN.test(entry.name)) {
+            const stats = fs.statSync(fullPath);
+            if (stats.mtimeMs > bestTime) {
+              const content = fs.readFileSync(fullPath, 'utf8');
+              const titleMatch = content.match(/^#\s+(.+)$/m);
+              const statusMatch = content.match(/^status:\s*(.+)$/m);
+              bestTask = {
+                path: fullPath,
+                title: titleMatch ? titleMatch[1] : entry.name,
+                status: statusMatch ? statusMatch[1].trim() : 'pending',
+                time: stats.mtime,
+                timeMs: stats.mtimeMs
+              };
+              bestTime = stats.mtimeMs;
+            }
+          }
+        }
+        return bestTask;
+      }
+
+      const foundTask = findRecentTask('.claude/epics');
+      if (foundTask) {
+        recentTask = foundTask;
+        recentTime = foundTask.timeMs;
+      }
+    }
+
+    if (recentTask) {
+      const timeAgo = getTimeAgo(recentTask.time);
+      console.log(`  Last Modified:  ${recentTask.title}`);
+      console.log(`  Status:         ${recentTask.status}`);
+      console.log(`  Modified:       ${timeAgo}`);
+      console.log(`  File:           ${recentTask.path}`);
+    } else {
+      console.log('  No recent activity');
+    }
+  } catch (err) {
+    console.log('  No recent activity');
+  }
+
+  console.log('');
+  console.log('💡 Quick Commands:');
+  console.log('  /pm:next                # Get next priority task');
+  console.log('  /pm:status              # Detailed project status');
+  console.log('  /pm:standup             # Generate standup report');
+  console.log('  /pm:search <keyword>    # Search PRDs and epics');
+  console.log('');
+}
+
+// Helper function to create progress bar
+function createProgressBar(percentage, length) {
+  const filled = Math.round((percentage / 100) * length);
+  const empty = length - filled;
+  return '[' + '='.repeat(filled) + '-'.repeat(empty) + ']';
+}
+
+// Helper function to get human-readable time ago
+function getTimeAgo(date) {
+  const seconds = Math.floor((new Date() - date) / 1000);
+
+  const intervals = {
+    year: 31536000,
+    month: 2592000,
+    week: 604800,
+    day: 86400,
+    hour: 3600,
+    minute: 60
+  };
+
+  for (const [name, secondsInInterval] of Object.entries(intervals)) {
+    const interval = Math.floor(seconds / secondsInInterval);
+    if (interval >= 1) {
+      return `${interval} ${name}${interval > 1 ? 's' : ''} ago`;
+    }
+  }
+
+  return 'just now';
+}
+
+// Run if called directly
+if (require.main === module) {
+  context().catch(err => {
+    logError('Error executing context command', err);
+    process.exit(1);
+  });
+}
+
+module.exports = context;

package/packages/plugin-pm/scripts/pm/epic-close.js

@@ -0,0 +1,347 @@
+#!/usr/bin/env node
+/**
+ * Epic Close - Close/complete an epic
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class EpicCloser {
+  constructor() {
+    this.epicsDir = path.join('.claude', 'epics');
+    this.prdsDir = path.join('.claude', 'prds');
+    this.activeWorkFile = path.join('.claude', 'active-work.json');
+    this.completedFile = path.join('.claude', 'completed-work.json');
+  }
+
+  findEpicFile(epicName) {
+    // Check epics directory
+    let epicPath = path.join(this.epicsDir, `${epicName}.md`);
+    if (fs.existsSync(epicPath)) {
+      return epicPath;
+    }
+
+    // Check PRDs directory
+    epicPath = path.join(this.prdsDir, `${epicName}.md`);
+    if (fs.existsSync(epicPath)) {
+      return epicPath;
+    }
+
+    return null;
+  }
+
+  loadActiveWork() {
+    if (!fs.existsSync(this.activeWorkFile)) {
+      return { issues: [], epics: [] };
+    }
+    try {
+      return JSON.parse(fs.readFileSync(this.activeWorkFile, 'utf8'));
+    } catch {
+      return { issues: [], epics: [] };
+    }
+  }
+
+  saveActiveWork(activeWork) {
+    const dir = path.dirname(this.activeWorkFile);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(this.activeWorkFile, JSON.stringify(activeWork, null, 2));
+  }
+
+  loadCompletedWork() {
+    if (!fs.existsSync(this.completedFile)) {
+      return { issues: [], epics: [] };
+    }
+    try {
+      return JSON.parse(fs.readFileSync(this.completedFile, 'utf8'));
+    } catch {
+      return { issues: [], epics: [] };
+    }
+  }
+
+  saveCompletedWork(completedWork) {
+    const dir = path.dirname(this.completedFile);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(this.completedFile, JSON.stringify(completedWork, null, 2));
+  }
+
+  extractTasksFromEpic(epicContent) {
+    const lines = epicContent.split('\n');
+    const tasks = {
+      total: 0,
+      completed: 0,
+      incomplete: 0,
+      completedTasks: [],
+      incompleteTasks: []
+    };
+
+    lines.forEach(line => {
+      if (line.match(/^- \[x\]/)) {
+        tasks.completed++;
+        tasks.completedTasks.push(line.replace(/^- \[x\] /, ''));
+      } else if (line.match(/^- \[ \]/)) {
+        tasks.incomplete++;
+        tasks.incompleteTasks.push(line.replace(/^- \[ \] /, ''));
+      }
+    });
+
+    tasks.total = tasks.completed + tasks.incomplete;
+    return tasks;
+  }
+
+  async closeEpic(epicName, options = {}) {
+    console.log(`\n🔒 Closing Epic: ${epicName}`);
+    console.log(`${'═'.repeat(50)}\n`);
+
+    // Find epic file
+    const epicFile = this.findEpicFile(epicName);
+    if (!epicFile) {
+      console.error(`❌ Epic not found: ${epicName}`);
+      this.listAvailableEpics();
+      return false;
+    }
+
+    // Read and analyze epic
+    let epicContent = fs.readFileSync(epicFile, 'utf8');
+    const tasks = this.extractTasksFromEpic(epicContent);
+
+    // Show current status
+    console.log('📊 Epic Status:');
+    console.log(`  • Total Tasks: ${tasks.total}`);
+    console.log(`  • Completed: ${tasks.completed} (${tasks.total > 0 ? Math.round(tasks.completed / tasks.total * 100) : 0}%)`);
+    console.log(`  • Remaining: ${tasks.incomplete}`);
+
+    // Check if all tasks are complete
+    if (tasks.incomplete > 0 && !options.force) {
+      console.log('\n⚠️  Warning: Epic has incomplete tasks!');
+      console.log('\nIncomplete tasks:');
+      tasks.incompleteTasks.slice(0, 5).forEach(task => {
+        console.log(`  ⬜ ${task}`);
+      });
+      if (tasks.incompleteTasks.length > 5) {
+        console.log(`  ... and ${tasks.incompleteTasks.length - 5} more`);
+      }
+
+      console.log('\n💡 Options:');
+      console.log('  • Complete remaining tasks first');
+      console.log('  • Use --force to close anyway');
+      console.log('  • Use --complete-all to mark all tasks as done');
+
+      if (!options.completeAll) {
+        return false;
+      }
+    }
+
+    // Mark all tasks as complete if requested
+    if (options.completeAll) {
+      console.log('\n✅ Marking all tasks as complete...');
+      epicContent = epicContent.replace(/- \[ \]/g, '- [x]');
+      fs.writeFileSync(epicFile, epicContent);
+    }
+
+    // Update epic metadata
+    const closedDate = new Date().toISOString();
+    const updatedContent = this.updateEpicMetadata(epicContent, {
+      status: 'completed',
+      closedDate: closedDate
+    });
+    fs.writeFileSync(epicFile, updatedContent);
+
+    // Update tracking
+    const activeWork = this.loadActiveWork();
+    const completedWork = this.loadCompletedWork();
+
+    // Find and move epic from active to completed
+    const activeEpic = activeWork.epics.find(e => e.name === epicName);
+    if (activeEpic) {
+      // Remove from active
+      activeWork.epics = activeWork.epics.filter(e => e.name !== epicName);
+      this.saveActiveWork(activeWork);
+
+      // Add to completed
+      const completedEntry = {
+        ...activeEpic,
+        completedAt: closedDate,
+        status: 'completed',
+        finalStats: {
+          totalTasks: tasks.total,
+          completedTasks: options.completeAll ? tasks.total : tasks.completed
+        }
+      };
+
+      completedWork.epics.unshift(completedEntry);
+
+      // Keep only last 50 completed epics
+      if (completedWork.epics.length > 50) {
+        completedWork.epics = completedWork.epics.slice(0, 50);
+      }
+
+      this.saveCompletedWork(completedWork);
+    } else {
+      // Add to completed even if not in active
+      const completedEntry = {
+        name: epicName,
+        completedAt: closedDate,
+        status: 'completed',
+        finalStats: {
+          totalTasks: tasks.total,
+          completedTasks: options.completeAll ? tasks.total : tasks.completed
+        }
+      };
+
+      completedWork.epics.unshift(completedEntry);
+      this.saveCompletedWork(completedWork);
+    }
+
+    // Success message
+    console.log(`\n✅ Epic "${epicName}" has been closed!`);
+    console.log('\n📋 Final Statistics:');
+    console.log(`  • Total Tasks: ${tasks.total}`);
+    console.log(`  • Completed: ${options.completeAll ? tasks.total : tasks.completed} (100%)`);
+    console.log(`  • Closed Date: ${new Date(closedDate).toLocaleString()}`);
+
+    // Archive epic if requested
+    if (options.archive) {
+      const archiveDir = path.join(path.dirname(epicFile), 'archive');
+      if (!fs.existsSync(archiveDir)) {
+        fs.mkdirSync(archiveDir, { recursive: true });
+      }
+
+      const archivePath = path.join(archiveDir, path.basename(epicFile));
+      fs.renameSync(epicFile, archivePath);
+      console.log(`\n📦 Epic archived to: ${archivePath}`);
+    }
+
+    // Show next steps
+    console.log('\n💡 Next Steps:');
+    console.log('  • View completed epics: /pm:status');
+    console.log('  • Start new epic: /pm:init <epic-name>');
+    console.log('  • List all epics: /pm:epic-list');
+
+    return true;
+  }
+
+  updateEpicMetadata(content, metadata) {
+    const lines = content.split('\n');
+    const updatedLines = [];
+    let inMetadata = false;
+    let metadataUpdated = false;
+
+    for (const line of lines) {
+      if (line.startsWith('---') && !inMetadata) {
+        inMetadata = true;
+        updatedLines.push(line);
+      } else if (line.startsWith('---') && inMetadata) {
+        // Add missing metadata before closing
+        if (!metadataUpdated) {
+          updatedLines.push(`status: ${metadata.status}`);
+          updatedLines.push(`closedDate: ${metadata.closedDate}`);
+        }
+        updatedLines.push(line);
+        inMetadata = false;
+        metadataUpdated = true;
+      } else if (inMetadata) {
+        // Update existing metadata
+        if (line.startsWith('status:')) {
+          updatedLines.push(`status: ${metadata.status}`);
+          metadataUpdated = true;
+        } else if (line.startsWith('closedDate:')) {
+          updatedLines.push(`closedDate: ${metadata.closedDate}`);
+        } else {
+          updatedLines.push(line);
+        }
+      } else {
+        updatedLines.push(line);
+      }
+    }
+
+    // If no metadata section exists, add it
+    if (!metadataUpdated) {
+      const titleIndex = updatedLines.findIndex(line => line.startsWith('# '));
+      if (titleIndex !== -1) {
+        updatedLines.splice(titleIndex + 1, 0,
+          '',
+          '---',
+          `status: ${metadata.status}`,
+          `closedDate: ${metadata.closedDate}`,
+          '---',
+          ''
+        );
+      }
+    }
+
+    return updatedLines.join('\n');
+  }
+
+  listAvailableEpics() {
+    console.log('\nAvailable epics:');
+
+    const epics = new Set();
+
+    // List from epics directory
+    if (fs.existsSync(this.epicsDir)) {
+      fs.readdirSync(this.epicsDir)
+        .filter(file => file.endsWith('.md'))
+        .forEach(file => epics.add(file.replace('.md', '')));
+    }
+
+    // List from PRDs directory
+    if (fs.existsSync(this.prdsDir)) {
+      fs.readdirSync(this.prdsDir)
+        .filter(file => file.endsWith('.md'))
+        .forEach(file => epics.add(file.replace('.md', '')));
+    }
+
+    if (epics.size > 0) {
+      Array.from(epics).forEach(epic => {
+        console.log(`  • ${epic}`);
+      });
+    } else {
+      console.log('  No epics found');
+    }
+  }
+
+  async run(args) {
+    const epicName = args[0];
+
+    if (!epicName) {
+      console.error('❌ Error: Epic name required');
+      console.error('Usage: /pm:epic-close <epic-name> [--force] [--complete-all] [--archive]');
+      console.error('\nOptions:');
+      console.error('  --force        Close even with incomplete tasks');
+      console.error('  --complete-all Mark all tasks as complete');
+      console.error('  --archive      Move epic to archive folder');
+
+      this.listAvailableEpics();
+      process.exit(1);
+    }
+
+    const options = {};
+    args.slice(1).forEach(arg => {
+      if (arg === '--force') {
+        options.force = true;
+      } else if (arg === '--complete-all') {
+        options.completeAll = true;
+      } else if (arg === '--archive') {
+        options.archive = true;
+      }
+    });
+
+    const success = await this.closeEpic(epicName, options);
+    process.exit(success ? 0 : 1);
+  }
+}
+
+// Main execution
+if (require.main === module) {
+  const closer = new EpicCloser();
+  closer.run(process.argv.slice(2)).catch(error => {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+  });
+}
+
+module.exports = EpicCloser;