claude-autopm 1.24.0 → 1.25.0

package/autopm/.claude/lib/commands/pm/epicSync.js

@@ -0,0 +1,498 @@
+#!/usr/bin/env node
+/**
+ * Epic Sync - Complete GitHub sync for epics
+ *
+ * Replaces all 4 Bash scripts with clean, testable JavaScript:
+ * - create-epic-issue.sh → createEpicIssue()
+ * - create-task-issues.sh → createTaskIssues()
+ * - update-epic-file.sh → updateEpicFile()
+ * - update-references.sh → updateTaskReferences()
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Parse frontmatter and body from markdown file
+ */
+function parseMarkdownFile(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const lines = content.split('\n');
+
+  let inFrontmatter = false;
+  let frontmatterLines = [];
+  let bodyLines = [];
+  let frontmatterCount = 0;
+
+  for (const line of lines) {
+    if (line === '---') {
+      frontmatterCount++;
+      if (frontmatterCount === 1) {
+        inFrontmatter = true;
+        continue;
+      } else if (frontmatterCount === 2) {
+        inFrontmatter = false;
+        continue;
+      }
+    }
+
+    if (inFrontmatter) {
+      frontmatterLines.push(line);
+    } else if (frontmatterCount === 2) {
+      bodyLines.push(line);
+    }
+  }
+
+  // Parse frontmatter
+  const frontmatter = {};
+  for (const line of frontmatterLines) {
+    const match = line.match(/^(\w+):\s*(.+)$/);
+    if (match) {
+      const [, key, value] = match;
+      frontmatter[key] = value;
+    }
+  }
+
+  return {
+    frontmatter,
+    frontmatterLines,
+    body: bodyLines.join('\n').trim(),
+    fullContent: content
+  };
+}
+
+/**
+ * Update frontmatter field in markdown content
+ */
+function updateFrontmatter(content, updates) {
+  const lines = content.split('\n');
+  const result = [];
+  let inFrontmatter = false;
+  let frontmatterCount = 0;
+
+  for (const line of lines) {
+    if (line === '---') {
+      frontmatterCount++;
+      result.push(line);
+      if (frontmatterCount === 1) {
+        inFrontmatter = true;
+      } else if (frontmatterCount === 2) {
+        inFrontmatter = false;
+      }
+      continue;
+    }
+
+    if (inFrontmatter) {
+      const match = line.match(/^(\w+):\s*(.+)$/);
+      if (match) {
+        const [, key] = match;
+        if (updates[key] !== undefined) {
+          result.push(`${key}: ${updates[key]}`);
+        } else {
+          result.push(line);
+        }
+      } else {
+        result.push(line);
+      }
+    } else {
+      result.push(line);
+    }
+  }
+
+  return result.join('\n');
+}
+
+/**
+ * Get current timestamp in ISO format
+ */
+function getTimestamp() {
+  return new Date().toISOString();
+}
+
+/**
+ * Get repository info from gh CLI
+ */
+function getRepoInfo() {
+  try {
+    const result = execSync('gh repo view --json nameWithOwner -q .nameWithOwner', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    return result.trim();
+  } catch (error) {
+    return 'unknown/repo';
+  }
+}
+
+/**
+ * Create epic GitHub issue
+ */
+function createEpicIssue(epicPath) {
+  const epicFile = path.join(process.cwd(), '.claude/epics', epicPath, 'epic.md');
+
+  if (!fs.existsSync(epicFile)) {
+    throw new Error(`Epic file not found: ${epicFile}`);
+  }
+
+  const { body } = parseMarkdownFile(epicFile);
+
+  // Count tasks
+  const epicDir = path.dirname(epicFile);
+  const taskFiles = fs.readdirSync(epicDir)
+    .filter(f => /^\d+\.md$/.test(f));
+  const taskCount = taskFiles.length;
+
+  // Detect epic type
+  const isFeature = body.toLowerCase().includes('feature') ||
+                    body.toLowerCase().includes('implement') ||
+                    !body.toLowerCase().includes('bug');
+  const labels = isFeature ? 'epic,feature' : 'epic,bug';
+
+  console.log(`📝 Creating epic issue: ${epicPath}`);
+  console.log(`   Tasks: ${taskCount}`);
+  console.log(`   Labels: ${labels}`);
+
+  // Create issue body
+  const issueBody = `
+${body}
+
+---
+
+**Epic Statistics:**
+- Tasks: ${taskCount}
+- Status: Planning
+- Created: ${getTimestamp()}
+`.trim();
+
+  // Escape for shell
+  const escapedTitle = `Epic: ${epicPath}`.replace(/"/g, '\\"');
+  const escapedBody = issueBody.replace(/"/g, '\\"').replace(/`/g, '\\`');
+
+  try {
+    const result = execSync(
+      `gh issue create --title "${escapedTitle}" --body "${escapedBody}" --label "${labels}"`,
+      { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+    );
+
+    const match = result.match(/https:\/\/github\.com\/[^\/]+\/[^\/]+\/issues\/(\d+)/);
+    if (match) {
+      const issueNumber = parseInt(match[1]);
+      console.log(`✅ Created epic issue #${issueNumber}`);
+      return issueNumber;
+    }
+
+    throw new Error('Could not extract issue number from gh output');
+  } catch (error) {
+    throw new Error(`Failed to create epic issue: ${error.message}`);
+  }
+}
+
+/**
+ * Create task issues for an epic
+ */
+function createTaskIssues(epicPath, epicIssueNumber) {
+  const epicDir = path.join(process.cwd(), '.claude/epics', epicPath);
+
+  if (!fs.existsSync(epicDir)) {
+    throw new Error(`Epic directory not found: ${epicDir}`);
+  }
+
+  // Find all task files
+  const taskFiles = fs.readdirSync(epicDir)
+    .filter(f => /^\d+\.md$/.test(f))
+    .sort();
+
+  if (taskFiles.length === 0) {
+    throw new Error(`No task files found in ${epicDir}`);
+  }
+
+  console.log(`\n📋 Creating ${taskFiles.length} task issues for epic #${epicIssueNumber}`);
+
+  const mapping = [];
+  let successCount = 0;
+
+  for (let i = 0; i < taskFiles.length; i++) {
+    const taskFile = taskFiles[i];
+    const taskNumber = taskFile.replace('.md', '');
+    const taskPath = path.join(epicDir, taskFile);
+
+    console.log(`[${i + 1}/${taskFiles.length}] Creating issue for task ${taskNumber}...`);
+
+    try {
+      const { frontmatter, body } = parseMarkdownFile(taskPath);
+      const title = frontmatter.name || 'Untitled Task';
+
+      // Create issue body
+      const issueBody = `
+Part of Epic #${epicIssueNumber}
+
+---
+
+${body}
+
+---
+
+**Epic Path:** \`${epicPath}\`
+**Task Number:** ${taskNumber}
+`.trim();
+
+      // Escape for shell
+      const escapedTitle = title.replace(/"/g, '\\"');
+      const escapedBody = issueBody.replace(/"/g, '\\"').replace(/`/g, '\\`');
+
+      const result = execSync(
+        `gh issue create --title "${escapedTitle}" --body "${escapedBody}" --label "task"`,
+        { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+      );
+
+      const match = result.match(/https:\/\/github\.com\/[^\/]+\/[^\/]+\/issues\/(\d+)/);
+      if (match) {
+        const issueNumber = parseInt(match[1]);
+        console.log(`   ✅ Created issue #${issueNumber}: ${title}`);
+        mapping.push({ oldName: taskNumber, newNumber: issueNumber });
+        successCount++;
+      }
+    } catch (error) {
+      console.error(`   ❌ Error: ${error.message}`);
+    }
+  }
+
+  // Save mapping file
+  const mappingFile = path.join(epicDir, '.task-mapping.txt');
+  const mappingContent = mapping.map(m => `${m.oldName} ${m.newNumber}`).join('\n');
+  fs.writeFileSync(mappingFile, mappingContent, 'utf8');
+
+  console.log(`\n📊 Summary:`);
+  console.log(`   ✅ Success: ${successCount}`);
+  console.log(`   ❌ Failed: ${taskFiles.length - successCount}`);
+  console.log(`   📝 Total: ${taskFiles.length}`);
+
+  return mapping;
+}
+
+/**
+ * Update epic file with GitHub URL and task references
+ */
+function updateEpicFile(epicPath, epicIssueNumber, taskMapping) {
+  const epicFile = path.join(process.cwd(), '.claude/epics', epicPath, 'epic.md');
+
+  if (!fs.existsSync(epicFile)) {
+    throw new Error(`Epic file not found: ${epicFile}`);
+  }
+
+  console.log(`\n📄 Updating epic file: ${epicFile}`);
+
+  const repo = getRepoInfo();
+  const epicUrl = `https://github.com/${repo}/issues/${epicIssueNumber}`;
+
+  // Read current content
+  let content = fs.readFileSync(epicFile, 'utf8');
+
+  // Update frontmatter
+  content = updateFrontmatter(content, {
+    github: epicUrl,
+    updated: getTimestamp()
+  });
+
+  // Update task references in body
+  if (taskMapping && taskMapping.length > 0) {
+    console.log('   Updating task references...');
+
+    for (const { oldName, newNumber } of taskMapping) {
+      // Update checkbox items
+      content = content.replace(
+        new RegExp(`- \\[ \\] ${oldName}\\b`, 'g'),
+        `- [ ] #${newNumber}`
+      );
+      content = content.replace(
+        new RegExp(`- \\[x\\] ${oldName}\\b`, 'g'),
+        `- [x] #${newNumber}`
+      );
+
+      // Update task links
+      content = content.replace(
+        new RegExp(`Task ${oldName}\\b`, 'g'),
+        `Task #${newNumber}`
+      );
+    }
+  }
+
+  // Write updated content
+  fs.writeFileSync(epicFile, content, 'utf8');
+
+  console.log('✅ Epic file updated');
+  console.log(`   GitHub: ${epicUrl}`);
+}
+
+/**
+ * Update task files with GitHub URLs and rename to issue numbers
+ */
+function updateTaskReferences(epicPath, taskMapping) {
+  const epicDir = path.join(process.cwd(), '.claude/epics', epicPath);
+
+  if (!fs.existsSync(epicDir)) {
+    throw new Error(`Epic directory not found: ${epicDir}`);
+  }
+
+  console.log(`\n🔗 Updating task references and renaming files`);
+
+  const repo = getRepoInfo();
+
+  for (const { oldName, newNumber } of taskMapping) {
+    const oldFile = path.join(epicDir, `${oldName}.md`);
+    const newFile = path.join(epicDir, `${newNumber}.md`);
+
+    if (!fs.existsSync(oldFile)) {
+      console.log(`   ⚠️  File not found: ${oldName}.md (skipping)`);
+      continue;
+    }
+
+    console.log(`   Renaming ${oldName}.md → ${newNumber}.md...`);
+
+    // Read and update content
+    let content = fs.readFileSync(oldFile, 'utf8');
+
+    const githubUrl = `https://github.com/${repo}/issues/${newNumber}`;
+    content = updateFrontmatter(content, {
+      github: githubUrl,
+      updated: getTimestamp()
+    });
+
+    // Write to new file
+    fs.writeFileSync(newFile, content, 'utf8');
+
+    // Remove old file
+    fs.unlinkSync(oldFile);
+
+    console.log(`      ✓`);
+  }
+
+  console.log('\n✅ Task files renamed and frontmatter updated');
+}
+
+/**
+ * Full epic sync workflow
+ */
+function syncEpic(epicPath) {
+  console.log(`🚀 Starting full epic sync: ${epicPath}\n`);
+
+  try {
+    // Step 1: Create epic issue
+    const epicIssueNumber = createEpicIssue(epicPath);
+
+    // Step 2: Create task issues
+    const taskMapping = createTaskIssues(epicPath, epicIssueNumber);
+
+    // Step 3: Update epic file
+    updateEpicFile(epicPath, epicIssueNumber, taskMapping);
+
+    // Step 4: Update task references
+    updateTaskReferences(epicPath, taskMapping);
+
+    console.log(`\n✅ Epic sync complete!`);
+    console.log(`   Epic: #${epicIssueNumber}`);
+    console.log(`   Tasks: ${taskMapping.length} created and synced`);
+
+    return { epicIssueNumber, taskMapping };
+  } catch (error) {
+    console.error(`\n❌ Epic sync failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * CLI interface
+ */
+function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  if (!command) {
+    console.log('Usage:');
+    console.log('  epicSync.js sync <epic-path>           - Full sync workflow');
+    console.log('  epicSync.js create-epic <epic-path>    - Create epic issue only');
+    console.log('  epicSync.js create-tasks <epic-path> <epic-number> - Create task issues only');
+    console.log('  epicSync.js update-epic <epic-path> <epic-number>  - Update epic file only');
+    console.log('');
+    console.log('Examples:');
+    console.log('  epicSync.js sync fullstack/01-infrastructure');
+    console.log('  epicSync.js create-epic fullstack/01-infrastructure');
+    process.exit(1);
+  }
+
+  switch (command) {
+    case 'sync': {
+      const epicPath = args[1];
+      if (!epicPath) {
+        console.error('Error: epic-path required');
+        process.exit(1);
+      }
+      syncEpic(epicPath);
+      break;
+    }
+
+    case 'create-epic': {
+      const epicPath = args[1];
+      if (!epicPath) {
+        console.error('Error: epic-path required');
+        process.exit(1);
+      }
+      const epicNumber = createEpicIssue(epicPath);
+      console.log(`\nEpic issue number: ${epicNumber}`);
+      break;
+    }
+
+    case 'create-tasks': {
+      const epicPath = args[1];
+      const epicNumber = parseInt(args[2]);
+      if (!epicPath || !epicNumber) {
+        console.error('Error: epic-path and epic-number required');
+        process.exit(1);
+      }
+      createTaskIssues(epicPath, epicNumber);
+      break;
+    }
+
+    case 'update-epic': {
+      const epicPath = args[1];
+      const epicNumber = parseInt(args[2]);
+      if (!epicPath || !epicNumber) {
+        console.error('Error: epic-path and epic-number required');
+        process.exit(1);
+      }
+      // Load mapping file
+      const mappingFile = path.join(process.cwd(), '.claude/epics', epicPath, '.task-mapping.txt');
+      let mapping = [];
+      if (fs.existsSync(mappingFile)) {
+        const content = fs.readFileSync(mappingFile, 'utf8');
+        mapping = content.split('\n')
+          .filter(line => line.trim())
+          .map(line => {
+            const [oldName, newNumber] = line.split(' ');
+            return { oldName, newNumber: parseInt(newNumber) };
+          });
+      }
+      updateEpicFile(epicPath, epicNumber, mapping);
+      break;
+    }
+
+    default:
+      console.error(`Unknown command: ${command}`);
+      process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  parseMarkdownFile,
+  updateFrontmatter,
+  createEpicIssue,
+  createTaskIssues,
+  updateEpicFile,
+  updateTaskReferences,
+  syncEpic
+};

package/autopm/.claude/lib/commands/pm/epicSyncTasks.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+/**
+ * Epic Sync Tasks - Create GitHub issues for all tasks in an epic
+ *
+ * Modern Node.js replacement for bash scripts that had parsing issues.
+ * Uses simple, testable code instead of complex shell heredocs.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Parse task file frontmatter and content
+ */
+function parseTaskFile(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const lines = content.split('\n');
+
+  let inFrontmatter = false;
+  let frontmatterLines = [];
+  let bodyLines = [];
+  let frontmatterCount = 0;
+
+  for (const line of lines) {
+    if (line === '---') {
+      frontmatterCount++;
+      if (frontmatterCount === 1) {
+        inFrontmatter = true;
+        continue;
+      } else if (frontmatterCount === 2) {
+        inFrontmatter = false;
+        continue;
+      }
+    }
+
+    if (inFrontmatter) {
+      frontmatterLines.push(line);
+    } else if (frontmatterCount === 2) {
+      bodyLines.push(line);
+    }
+  }
+
+  // Parse frontmatter
+  const frontmatter = {};
+  for (const line of frontmatterLines) {
+    const match = line.match(/^(\w+):\s*(.+)$/);
+    if (match) {
+      const [, key, value] = match;
+      frontmatter[key] = value;
+    }
+  }
+
+  return {
+    frontmatter,
+    body: bodyLines.join('\n').trim(),
+    title: frontmatter.name || 'Untitled Task'
+  };
+}
+
+/**
+ * Create GitHub issue for a task
+ */
+function createTaskIssue(taskData, epicIssueNumber, epicPath, taskNumber) {
+  const { title, body } = taskData;
+
+  // Create issue body with epic reference
+  const issueBody = `
+Part of Epic #${epicIssueNumber}
+
+---
+
+${body}
+
+---
+
+**Epic Path:** \`${epicPath}\`
+**Task Number:** ${taskNumber}
+`.trim();
+
+  // Escape quotes for shell
+  const escapedTitle = title.replace(/"/g, '\\"');
+  const escapedBody = issueBody.replace(/"/g, '\\"').replace(/`/g, '\\`');
+
+  // Create GitHub issue
+  try {
+    const result = execSync(
+      `gh issue create --title "${escapedTitle}" --body "${escapedBody}" --label "task"`,
+      { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+    );
+
+    const issueMatch = result.match(/https:\/\/github\.com\/[^\/]+\/[^\/]+\/issues\/(\d+)/);
+    if (issueMatch) {
+      return parseInt(issueMatch[1]);
+    }
+
+    return null;
+  } catch (error) {
+    console.error(`❌ Failed to create issue for task ${taskNumber}:`, error.message);
+    return null;
+  }
+}
+
+/**
+ * Update task file with GitHub issue number
+ */
+function updateTaskFrontmatter(filePath, issueNumber) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const updatedContent = content.replace(
+    /^github:.*$/m,
+    `github: "#${issueNumber}"`
+  );
+  fs.writeFileSync(filePath, updatedContent, 'utf8');
+}
+
+/**
+ * Main function
+ */
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length < 2) {
+    console.error('Usage: epicSyncTasks.js <epic-path> <epic-issue-number>');
+    console.error('Example: epicSyncTasks.js fullstack/01-infrastructure 2');
+    process.exit(1);
+  }
+
+  const [epicPath, epicIssueNumber] = args;
+  const epicDir = path.join(process.cwd(), '.claude/epics', epicPath);
+
+  if (!fs.existsSync(epicDir)) {
+    console.error(`❌ Epic directory not found: ${epicDir}`);
+    process.exit(1);
+  }
+
+  // Find all task files (numbered .md files)
+  const taskFiles = fs.readdirSync(epicDir)
+    .filter(f => /^\d+\.md$/.test(f))
+    .sort();
+
+  if (taskFiles.length === 0) {
+    console.error(`❌ No task files found in ${epicDir}`);
+    process.exit(1);
+  }
+
+  console.log(`📋 Creating ${taskFiles.length} task issues for epic #${epicIssueNumber}`);
+  console.log(`📂 Epic path: ${epicPath}\n`);
+
+  let successCount = 0;
+  let failCount = 0;
+
+  for (const taskFile of taskFiles) {
+    const taskNumber = taskFile.replace('.md', '');
+    const taskPath = path.join(epicDir, taskFile);
+
+    console.log(`[${successCount + failCount + 1}/${taskFiles.length}] Creating issue for task ${taskNumber}...`);
+
+    try {
+      const taskData = parseTaskFile(taskPath);
+      const issueNumber = createTaskIssue(taskData, epicIssueNumber, epicPath, taskNumber);
+
+      if (issueNumber) {
+        updateTaskFrontmatter(taskPath, issueNumber);
+        console.log(`   ✅ Created issue #${issueNumber}: ${taskData.title}`);
+        successCount++;
+      } else {
+        console.log(`   ⚠️  Issue created but number not found`);
+        failCount++;
+      }
+    } catch (error) {
+      console.error(`   ❌ Error: ${error.message}`);
+      failCount++;
+    }
+  }
+
+  console.log(`\n📊 Summary:`);
+  console.log(`   ✅ Success: ${successCount}`);
+  console.log(`   ❌ Failed: ${failCount}`);
+  console.log(`   📝 Total: ${taskFiles.length}`);
+
+  if (failCount > 0) {
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { parseTaskFile, createTaskIssue, updateTaskFrontmatter };

package/autopm/.claude/lib/commands/pm/issueSync.js

@@ -0,0 +1,593 @@
+#!/usr/bin/env node
+/**
+ * Issue Sync - Complete GitHub issue synchronization
+ *
+ * Replaces 5 Bash scripts with clean, testable JavaScript:
+ * - gather-updates.sh → gatherUpdates()
+ * - format-comment.sh → formatComment()
+ * - post-comment.sh → postComment()
+ * - update-frontmatter.sh → updateFrontmatter()
+ * - preflight-validation.sh → preflightValidation()
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Parse frontmatter from markdown file
+ */
+function parseFrontmatter(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const lines = content.split('\n');
+
+  let inFrontmatter = false;
+  let frontmatterCount = 0;
+  const frontmatter = {};
+
+  for (const line of lines) {
+    if (line === '---') {
+      frontmatterCount++;
+      if (frontmatterCount === 1) {
+        inFrontmatter = true;
+      } else if (frontmatterCount === 2) {
+        break;
+      }
+      continue;
+    }
+
+    if (inFrontmatter) {
+      const match = line.match(/^(\w+):\s*(.+)$/);
+      if (match) {
+        const [, key, value] = match;
+        frontmatter[key] = value;
+      }
+    }
+  }
+
+  return frontmatter;
+}
+
+/**
+ * Update frontmatter field
+ */
+function updateFrontmatterField(filePath, field, value) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const lines = content.split('\n');
+  const result = [];
+
+  let inFrontmatter = false;
+  let frontmatterCount = 0;
+  let fieldUpdated = false;
+
+  for (const line of lines) {
+    if (line === '---') {
+      frontmatterCount++;
+      result.push(line);
+      if (frontmatterCount === 1) {
+        inFrontmatter = true;
+      } else if (frontmatterCount === 2) {
+        inFrontmatter = false;
+        // Add field if not found
+        if (!fieldUpdated && inFrontmatter === false) {
+          result.splice(result.length - 1, 0, `${field}: ${value}`);
+        }
+      }
+      continue;
+    }
+
+    if (inFrontmatter) {
+      const match = line.match(/^(\w+):/);
+      if (match && match[1] === field) {
+        result.push(`${field}: ${value}`);
+        fieldUpdated = true;
+      } else {
+        result.push(line);
+      }
+    } else {
+      result.push(line);
+    }
+  }
+
+  fs.writeFileSync(filePath, result.join('\n'), 'utf8');
+  return true;
+}
+
+/**
+ * Get current ISO timestamp
+ */
+function getTimestamp() {
+  return new Date().toISOString();
+}
+
+/**
+ * Strip frontmatter and return body only
+ */
+function stripFrontmatter(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return '';
+  }
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const lines = content.split('\n');
+
+  let frontmatterCount = 0;
+  const bodyLines = [];
+
+  for (const line of lines) {
+    if (line === '---') {
+      frontmatterCount++;
+      continue;
+    }
+
+    if (frontmatterCount >= 2) {
+      bodyLines.push(line);
+    }
+  }
+
+  return bodyLines.join('\n').trim();
+}
+
+/**
+ * Gather updates from various sources
+ */
+function gatherUpdates(issueNumber, updatesDir, lastSync = null) {
+  console.log(`\n📋 Gathering updates for issue #${issueNumber}`);
+
+  if (!fs.existsSync(updatesDir)) {
+    throw new Error(`Updates directory not found: ${updatesDir}`);
+  }
+
+  const updates = {
+    progress: '',
+    notes: '',
+    commits: '',
+    acceptanceCriteria: '',
+    nextSteps: '',
+    blockers: ''
+  };
+
+  // Gather progress
+  const progressFile = path.join(updatesDir, 'progress.md');
+  if (fs.existsSync(progressFile)) {
+    updates.progress = stripFrontmatter(progressFile);
+    const frontmatter = parseFrontmatter(progressFile);
+    if (frontmatter && frontmatter.completion) {
+      updates.progress += `\n\n**Current Progress:** ${frontmatter.completion}`;
+    }
+  }
+
+  // Gather notes
+  const notesFile = path.join(updatesDir, 'notes.md');
+  if (fs.existsSync(notesFile)) {
+    updates.notes = stripFrontmatter(notesFile);
+  }
+
+  // Gather commits
+  const commitsFile = path.join(updatesDir, 'commits.md');
+  if (fs.existsSync(commitsFile)) {
+    updates.commits = stripFrontmatter(commitsFile);
+  } else {
+    // Auto-gather recent commits
+    updates.commits = gatherRecentCommits(lastSync);
+  }
+
+  // Gather acceptance criteria
+  const criteriaFile = path.join(updatesDir, 'acceptance-criteria.md');
+  if (fs.existsSync(criteriaFile)) {
+    updates.acceptanceCriteria = stripFrontmatter(criteriaFile);
+  }
+
+  // Gather next steps
+  const nextStepsFile = path.join(updatesDir, 'next-steps.md');
+  if (fs.existsSync(nextStepsFile)) {
+    updates.nextSteps = stripFrontmatter(nextStepsFile);
+  }
+
+  // Gather blockers
+  const blockersFile = path.join(updatesDir, 'blockers.md');
+  if (fs.existsSync(blockersFile)) {
+    updates.blockers = stripFrontmatter(blockersFile);
+  }
+
+  console.log('✅ Updates gathered');
+  return updates;
+}
+
+/**
+ * Auto-gather recent commits
+ */
+function gatherRecentCommits(since = null) {
+  try {
+    const sinceArg = since || '24 hours ago';
+    const result = execSync(
+      `git log --since="${sinceArg}" --oneline --no-merges`,
+      { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+    );
+
+    if (result.trim()) {
+      const commits = result.trim().split('\n').map(line => `- ${line}`);
+      return `**Recent Commits:**\n${commits.join('\n')}`;
+    }
+  } catch (error) {
+    // Git not available or no commits
+  }
+
+  return 'No recent commits found';
+}
+
+/**
+ * Format comment from gathered updates
+ */
+function formatComment(issueNumber, updates, isCompletion = false) {
+  console.log(`\n📝 Formatting comment for issue #${issueNumber}`);
+
+  const sections = [];
+
+  if (isCompletion) {
+    sections.push('# ✅ Task Completed\n');
+    sections.push(`*Completed at: ${getTimestamp()}*\n`);
+  } else {
+    sections.push('# 📊 Progress Update\n');
+    sections.push(`*Updated at: ${getTimestamp()}*\n`);
+  }
+
+  // Add sections with content
+  if (updates.progress && !updates.progress.includes('No progress')) {
+    sections.push('## Progress Updates\n');
+    sections.push(updates.progress + '\n');
+  }
+
+  if (updates.notes && !updates.notes.includes('No technical notes')) {
+    sections.push('## Technical Notes\n');
+    sections.push(updates.notes + '\n');
+  }
+
+  if (updates.commits && !updates.commits.includes('No recent commits')) {
+    sections.push('## Recent Commits\n');
+    sections.push(updates.commits + '\n');
+  }
+
+  if (updates.acceptanceCriteria && !updates.acceptanceCriteria.includes('No acceptance')) {
+    sections.push('## Acceptance Criteria\n');
+    sections.push(updates.acceptanceCriteria + '\n');
+  }
+
+  if (updates.nextSteps && !updates.nextSteps.includes('No specific next steps')) {
+    sections.push('## Next Steps\n');
+    sections.push(updates.nextSteps + '\n');
+  }
+
+  if (updates.blockers && !updates.blockers.includes('No current blockers')) {
+    sections.push('## Blockers\n');
+    sections.push(updates.blockers + '\n');
+  }
+
+  const comment = sections.join('\n');
+  console.log('✅ Comment formatted');
+
+  return comment;
+}
+
+/**
+ * Post comment to GitHub issue
+ */
+function postComment(issueNumber, comment, isDryRun = false) {
+  console.log(`\n💬 Posting comment to issue #${issueNumber}`);
+
+  if (isDryRun) {
+    console.log('🔸 DRY RUN - Comment preview:');
+    console.log(comment.split('\n').slice(0, 20).join('\n'));
+    console.log('...');
+    return 'https://github.com/DRYRUN/issues/' + issueNumber + '#issuecomment-DRYRUN';
+  }
+
+  // Write comment to temp file
+  const tempFile = `/tmp/issue-comment-${issueNumber}-${Date.now()}.md`;
+  fs.writeFileSync(tempFile, comment, 'utf8');
+
+  try {
+    // Post via gh CLI
+    const result = execSync(
+      `gh issue comment ${issueNumber} --body-file "${tempFile}"`,
+      { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+    );
+
+    // Extract URL from result
+    const match = result.match(/https:\/\/github\.com\/[^\/]+\/[^\/]+\/issues\/\d+#issuecomment-\d+/);
+    if (match) {
+      const url = match[0];
+      console.log(`✅ Comment posted: ${url}`);
+
+      // Cleanup temp file
+      fs.unlinkSync(tempFile);
+
+      return url;
+    }
+
+    console.log('⚠️  Comment posted but URL not found in response');
+    return null;
+  } catch (error) {
+    console.error(`❌ Failed to post comment: ${error.message}`);
+    console.log(`Temp comment file preserved: ${tempFile}`);
+    throw error;
+  }
+}
+
+/**
+ * Update frontmatter after successful sync
+ */
+function updateFrontmatterAfterSync(progressFile, commentUrl, isCompletion = false) {
+  console.log(`\n📄 Updating frontmatter: ${progressFile}`);
+
+  if (!fs.existsSync(progressFile)) {
+    throw new Error(`Progress file not found: ${progressFile}`);
+  }
+
+  // Create backup
+  const backupFile = `${progressFile}.backup.${Date.now()}`;
+  fs.copyFileSync(progressFile, backupFile);
+
+  try {
+    // Update last_sync
+    updateFrontmatterField(progressFile, 'last_sync', getTimestamp());
+
+    // Update comment URL if provided
+    if (commentUrl) {
+      updateFrontmatterField(progressFile, 'last_comment_url', commentUrl);
+    }
+
+    // Update completion if needed
+    if (isCompletion) {
+      updateFrontmatterField(progressFile, 'completion', '100');
+      updateFrontmatterField(progressFile, 'status', 'completed');
+      updateFrontmatterField(progressFile, 'completed_at', getTimestamp());
+    }
+
+    // Update issue state from GitHub
+    try {
+      const issueState = execSync('gh issue view --json state -q .state', {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe']
+      }).trim();
+
+      if (issueState) {
+        updateFrontmatterField(progressFile, 'issue_state', issueState);
+      }
+    } catch (error) {
+      // GitHub CLI not available or issue not found
+    }
+
+    console.log('✅ Frontmatter updated');
+
+    // Cleanup old backups (keep last 5)
+    cleanupOldBackups(progressFile, 5);
+
+  } catch (error) {
+    console.error('❌ Frontmatter update failed, restoring backup');
+    fs.copyFileSync(backupFile, progressFile);
+    throw error;
+  }
+}
+
+/**
+ * Cleanup old backup files
+ */
+function cleanupOldBackups(originalFile, keepCount = 5) {
+  const dir = path.dirname(originalFile);
+  const basename = path.basename(originalFile);
+
+  try {
+    const backups = fs.readdirSync(dir)
+      .filter(f => f.startsWith(basename + '.backup.'))
+      .map(f => ({
+        name: f,
+        path: path.join(dir, f),
+        time: fs.statSync(path.join(dir, f)).mtime.getTime()
+      }))
+      .sort((a, b) => b.time - a.time);
+
+    // Remove old backups
+    for (let i = keepCount; i < backups.length; i++) {
+      fs.unlinkSync(backups[i].path);
+    }
+  } catch (error) {
+    // Ignore cleanup errors
+  }
+}
+
+/**
+ * Preflight validation
+ */
+function preflightValidation(issueNumber, updatesDir) {
+  console.log(`\n🔍 Preflight validation for issue #${issueNumber}`);
+
+  const errors = [];
+
+  // Check GitHub auth
+  try {
+    execSync('gh auth status', { stdio: ['pipe', 'pipe', 'pipe'] });
+  } catch (error) {
+    errors.push('GitHub CLI not authenticated. Run: gh auth login');
+  }
+
+  // Check if issue exists
+  try {
+    const state = execSync(`gh issue view ${issueNumber} --json state -q .state`, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+
+    if (state === 'CLOSED') {
+      console.log(`⚠️  Issue #${issueNumber} is closed`);
+    }
+  } catch (error) {
+    errors.push(`Issue #${issueNumber} not found`);
+  }
+
+  // Check updates directory
+  if (!fs.existsSync(updatesDir)) {
+    errors.push(`Updates directory not found: ${updatesDir}`);
+  }
+
+  if (errors.length > 0) {
+    console.error('\n❌ Preflight validation failed:');
+    errors.forEach(err => console.error(`   - ${err}`));
+    return false;
+  }
+
+  console.log('✅ Preflight validation passed');
+  return true;
+}
+
+/**
+ * Full sync workflow
+ */
+function syncIssue(issueNumber, updatesDir, isCompletion = false, isDryRun = false) {
+  console.log(`\n🚀 Starting issue sync: #${issueNumber}`);
+
+  // Preflight validation
+  if (!preflightValidation(issueNumber, updatesDir)) {
+    throw new Error('Preflight validation failed');
+  }
+
+  // Gather updates
+  const progressFile = path.join(updatesDir, 'progress.md');
+  const frontmatter = parseFrontmatter(progressFile);
+  const lastSync = frontmatter ? frontmatter.last_sync : null;
+
+  const updates = gatherUpdates(issueNumber, updatesDir, lastSync);
+
+  // Format comment
+  const comment = formatComment(issueNumber, updates, isCompletion);
+
+  // Post comment
+  const commentUrl = postComment(issueNumber, comment, isDryRun);
+
+  // Update frontmatter
+  if (!isDryRun && fs.existsSync(progressFile)) {
+    updateFrontmatterAfterSync(progressFile, commentUrl, isCompletion);
+  }
+
+  console.log(`\n✅ Issue sync complete!`);
+  console.log(`   Issue: #${issueNumber}`);
+  if (commentUrl) {
+    console.log(`   Comment: ${commentUrl}`);
+  }
+
+  return { commentUrl, updates };
+}
+
+/**
+ * CLI interface
+ */
+function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  if (!command) {
+    console.log('Usage:');
+    console.log('  issueSync.js sync <issue-number> <updates-dir> [--complete] [--dry-run]');
+    console.log('  issueSync.js gather <issue-number> <updates-dir>');
+    console.log('  issueSync.js format <issue-number> <updates-dir> [--complete]');
+    console.log('  issueSync.js post <issue-number> <comment-file> [--dry-run]');
+    console.log('  issueSync.js update <progress-file> <comment-url> [--complete]');
+    console.log('');
+    console.log('Examples:');
+    console.log('  issueSync.js sync 123 .claude/epics/auth/updates/123');
+    console.log('  issueSync.js sync 456 ./updates --complete');
+    console.log('  issueSync.js sync 789 ./updates --dry-run');
+    process.exit(1);
+  }
+
+  const issueNumber = args[1];
+  const isComplete = args.includes('--complete');
+  const isDryRun = args.includes('--dry-run');
+
+  try {
+    switch (command) {
+      case 'sync': {
+        const updatesDir = args[2];
+        if (!issueNumber || !updatesDir) {
+          console.error('Error: issue-number and updates-dir required');
+          process.exit(1);
+        }
+        syncIssue(issueNumber, updatesDir, isComplete, isDryRun);
+        break;
+      }
+
+      case 'gather': {
+        const updatesDir = args[2];
+        if (!issueNumber || !updatesDir) {
+          console.error('Error: issue-number and updates-dir required');
+          process.exit(1);
+        }
+        const updates = gatherUpdates(issueNumber, updatesDir);
+        console.log(JSON.stringify(updates, null, 2));
+        break;
+      }
+
+      case 'format': {
+        const updatesDir = args[2];
+        if (!issueNumber || !updatesDir) {
+          console.error('Error: issue-number and updates-dir required');
+          process.exit(1);
+        }
+        const updates = gatherUpdates(issueNumber, updatesDir);
+        const comment = formatComment(issueNumber, updates, isComplete);
+        console.log(comment);
+        break;
+      }
+
+      case 'post': {
+        const commentFile = args[2];
+        if (!issueNumber || !commentFile) {
+          console.error('Error: issue-number and comment-file required');
+          process.exit(1);
+        }
+        const comment = fs.readFileSync(commentFile, 'utf8');
+        const url = postComment(issueNumber, comment, isDryRun);
+        console.log(url);
+        break;
+      }
+
+      case 'update': {
+        const progressFile = args[2];
+        const commentUrl = args[3];
+        if (!progressFile) {
+          console.error('Error: progress-file required');
+          process.exit(1);
+        }
+        updateFrontmatterAfterSync(progressFile, commentUrl, isComplete);
+        break;
+      }
+
+      default:
+        console.error(`Unknown command: ${command}`);
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(`\n❌ Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  parseFrontmatter,
+  updateFrontmatterField,
+  stripFrontmatter,
+  gatherUpdates,
+  formatComment,
+  postComment,
+  updateFrontmatterAfterSync,
+  preflightValidation,
+  syncIssue
+};

package/package.json

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