claude-autopm 1.23.2 → 1.24.2

package/autopm/.claude/commands/pm/context-prime.md

@@ -0,0 +1,170 @@
+---
+allowed-tools: Read, Bash
+---
+
+# Context Prime
+
+Load project context into current AI session for better understanding and continuity.
+
+## Required Documentation Access
+
+**MANDATORY:** Before priming context, query Context7 for best practices:
+
+**Documentation Queries:**
+- `mcp://context7/knowledge-management/context-loading` - Context loading patterns
+- `mcp://context7/ai/prompt-engineering` - Effective context management for AI
+
+**Why This is Required:**
+- Ensures optimal context loading for AI comprehension
+- Provides strategies for maintaining session continuity
+
+## Instructions
+
+Load comprehensive project context into the current AI session.
+
+### 1. Verify context exists
+
+```bash
+if [ ! -d ".claude/context" ]; then
+  echo "❌ Context not found. Run /pm:context-create first."
+  exit 1
+fi
+```
+
+### 2. Read all context files
+
+Read in order:
+1. `.claude/context/project-brief.md` - Project overview and objectives
+2. `.claude/context/tech-context.md` - Technical stack and dependencies
+3. `.claude/context/project-structure.md` - Directory layout and organization
+4. `.claude/context/progress.md` - Current status and next steps
+
+### 3. Process and internalize context
+
+**Parse key information:**
+
+From **project-brief.md**:
+- Project name and description
+- Primary objectives and goals
+- Target users and stakeholders
+- Key constraints and limitations
+- Success criteria
+
+From **tech-context.md**:
+- Technology stack (frontend, backend, database, infrastructure)
+- Development environment (Node.js version, package manager, testing framework)
+- Key dependencies and their purposes
+- Architecture patterns in use
+- Development practices
+
+From **project-structure.md**:
+- Directory layout and organization
+- Key files and their purposes
+- Module structure
+- Configuration files
+
+From **progress.md**:
+- Current phase and progress percentage
+- Completed tasks
+- In-progress tasks
+- Next steps
+- Any blockers
+
+### 4. Display loaded context summary
+
+Present a comprehensive summary:
+
+```
+📋 Project Context Loaded
+
+══════════════════════════════════════════════════════════════════
+
+PROJECT: [Project Name]
+PHASE: [Current Phase] | PROGRESS: [X]%
+LAST UPDATED: [Date from progress.md]
+
+══════════════════════════════════════════════════════════════════
+
+🎯 OBJECTIVES
+  - [Primary goal]
+  - [Secondary goal]
+  - [Tertiary goal]
+
+🔧 TECH STACK
+  - Frontend: [Technologies]
+  - Backend: [Technologies]
+  - Database: [Database]
+  - Testing: [Framework]
+
+📁 STRUCTURE
+  [Brief structure overview]
+
+✅ COMPLETED
+  - [Recent completed task 1]
+  - [Recent completed task 2]
+
+🚧 IN PROGRESS
+  - [Current task 1]
+  - [Current task 2]
+
+⏭️  NEXT STEPS
+  1. [Next action 1]
+  2. [Next action 2]
+
+⚠️  BLOCKERS
+  - [Blocker 1, if any]
+
+══════════════════════════════════════════════════════════════════
+
+✅ Context loaded. AI agent now has project memory.
+
+💡 TIP: Run /pm:context-update after significant changes to keep context current.
+```
+
+### 5. Internal context retention
+
+**CRITICAL:** After displaying the summary, the AI agent should:
+
+1. **Retain project identity**: Remember project name, goals, and constraints
+2. **Understand technical environment**: Keep tech stack and dependencies in mind
+3. **Maintain progress awareness**: Know what's done, what's in progress, what's next
+4. **Respect project structure**: Work within established organization patterns
+5. **Align with practices**: Follow development practices outlined in context
+
+This context should guide all subsequent interactions in the session:
+- Suggestions should align with project objectives
+- Recommendations should fit the tech stack
+- Changes should consider current progress
+- Code should match project structure
+
+### 6. Confirmation
+
+Return structured confirmation:
+
+```json
+{
+  "status": "loaded",
+  "project": "[Project Name]",
+  "phase": "[Current Phase]",
+  "progress": "[X]%",
+  "filesRead": [
+    "project-brief.md",
+    "tech-context.md",
+    "project-structure.md",
+    "progress.md"
+  ],
+  "keyTakeaways": [
+    "[Important point 1]",
+    "[Important point 2]",
+    "[Important point 3]"
+  ]
+}
+```
+
+## Output Format
+
+Return:
+- Formatted context summary (as shown above)
+- Key information highlighted
+- Current focus areas
+- Recommendations based on loaded context

package/autopm/.claude/commands/pm/context-update.md

@@ -0,0 +1,292 @@
+---
+allowed-tools: Read, Write, Edit, Bash, Glob
+---
+
+# Context Update
+
+Update project context after significant changes to maintain AI agent memory accuracy.
+
+## Required Documentation Access
+
+**MANDATORY:** Before updating context, query Context7 for best practices:
+
+**Documentation Queries:**
+- `mcp://context7/knowledge-management/documentation-maintenance` - Documentation update strategies
+- `mcp://context7/agile/progress-tracking` - Progress tracking best practices
+- `mcp://context7/project-management/status-reporting` - Status update patterns
+
+**Why This is Required:**
+- Ensures context updates follow documentation best practices
+- Maintains consistency with agile progress tracking
+- Provides effective status reporting patterns
+
+## Instructions
+
+Intelligently update project context files based on detected changes.
+
+### 1. Verify context exists
+
+```bash
+if [ ! -d ".claude/context" ]; then
+  echo "❌ Context not found. Run /pm:context-create first."
+  exit 1
+fi
+```
+
+### 2. Detect changes since last update
+
+**Check multiple sources for changes:**
+
+1. **package.json changes:**
+   - Compare current dependencies with tech-context.md
+   - Detect new dependencies added
+   - Identify version updates
+   - Note removed dependencies
+
+2. **Directory structure changes:**
+   - Scan current directory structure
+   - Compare with project-structure.md
+   - Detect new directories
+   - Note removed directories
+
+3. **Git history (if available):**
+   - Check recent commits since last context update
+   - Extract meaningful changes from commit messages
+   - Identify completed features/tasks
+
+4. **README.md changes:**
+   - Compare current README with project-brief.md
+   - Detect updated project description
+   - Note new features or objectives
+
+### 3. Update relevant files
+
+**Update tech-context.md if tech stack changed:**
+
+If new dependencies detected:
+```markdown
+## Dependencies
+[Existing dependencies]
+
+**Recently Added:**
+- [new-package-name]: [Purpose/description]
+  Added: [Date]
+```
+
+If versions changed:
+```markdown
+## Development Environment
+- Node.js: [new version] (updated from [old version])
+```
+
+**Update progress.md for project progress:**
+
+Always update:
+1. **Last Updated timestamp** to current date
+2. Move completed items from "In Progress" to "Completed"
+3. Update progress percentage based on completed tasks
+4. Add new tasks to "In Progress" or "Next Steps"
+5. Update or remove blockers
+
+Example update:
+```markdown
+## Current Status
+- Phase: [Current phase]
+- Progress: [Updated]%
+- Last Updated: [Current date]
+
+## Completed
+- [x] [Previously in-progress task now completed]
+- [x] [Another completed task]
+
+## In Progress
+- [ ] [New current task]
+- [ ] [Another current task]
+
+## Next Steps
+1. [Updated next action]
+2. [New next action]
+
+## Blockers
+- [Updated or new blocker, or note "None" if resolved]
+
+## Recent Updates
+- [Date]: [Description of recent change]
+- [Date]: [Description of recent change]
+```
+
+**Update project-structure.md if structure changed:**
+
+If new directories detected:
+```markdown
+## Directory Layout
+```
+project/
+├── src/           # Source code
+├── test/          # Tests
+├── .claude/       # AutoPM configuration
+├── [new-dir]/     # [Purpose of new directory]
+└── docs/          # Documentation
+```
+```
+
+If new key files added:
+```markdown
+## Key Files
+- **[new-file]**: [Purpose and description]
+```
+
+**Update project-brief.md if scope changed:**
+
+Only if README.md or objectives significantly changed:
+- Update project description
+- Add new objectives
+- Update success criteria
+- Note scope expansions or reductions
+
+### 4. Generate change summary
+
+Track what was updated:
+```json
+{
+  "updatedFiles": [],
+  "changes": {
+    "techContext": {
+      "addedDependencies": [],
+      "updatedVersions": [],
+      "removedDependencies": []
+    },
+    "progress": {
+      "completedTasks": [],
+      "newTasks": [],
+      "progressIncrease": "X%",
+      "resolvedBlockers": []
+    },
+    "structure": {
+      "newDirectories": [],
+      "newFiles": []
+    },
+    "brief": {
+      "updated": false,
+      "changes": []
+    }
+  }
+}
+```
+
+### 5. Smart update logic
+
+**Only update files with actual changes:**
+
+```javascript
+// Pseudocode for update logic
+if (techStackChanged) {
+  updateTechContext();
+  updatedFiles.push("tech-context.md");
+}
+
+if (progressChanged || tasksCompleted) {
+  updateProgress();
+  updatedFiles.push("progress.md");
+}
+
+if (structureChanged) {
+  updateProjectStructure();
+  updatedFiles.push("project-structure.md");
+}
+
+if (scopeChanged) {
+  updateProjectBrief();
+  updatedFiles.push("project-brief.md");
+}
+
+// Always update progress.md with "Last Updated" timestamp
+if (!updatedFiles.includes("progress.md")) {
+  updateProgressTimestamp();
+  updatedFiles.push("progress.md");
+}
+```
+
+### 6. Confirm updates
+
+Display comprehensive update summary:
+
+```
+✅ Context updated
+
+══════════════════════════════════════════════════════════════════
+
+📝 UPDATED FILES
+  - tech-context.md
+  - progress.md
+  - project-structure.md
+
+══════════════════════════════════════════════════════════════════
+
+🔧 TECH CONTEXT CHANGES
+  Added Dependencies:
+  - [new-package]: [Purpose]
+
+  Updated Versions:
+  - Node.js: [old] → [new]
+
+══════════════════════════════════════════════════════════════════
+
+📊 PROGRESS UPDATES
+  Completed Tasks:
+  ✅ [Task 1]
+  ✅ [Task 2]
+
+  Progress: [Old]% → [New]%
+  Phase: [Phase name]
+
+  Next Steps:
+  1. [Next action]
+  2. [Next action]
+
+══════════════════════════════════════════════════════════════════
+
+📁 STRUCTURE CHANGES
+  New Directories:
+  + [new-dir]/  # [Purpose]
+
+  New Key Files:
+  + [new-file]  # [Purpose]
+
+══════════════════════════════════════════════════════════════════
+
+💡 RECOMMENDATIONS
+  - Run /pm:context-prime to reload updated context
+  - Consider updating project-brief.md if objectives changed
+  - [Other relevant recommendations]
+
+══════════════════════════════════════════════════════════════════
+```
+
+### 7. Handle no-change scenario
+
+If no changes detected:
+
+```
+ℹ️  No significant changes detected since last update
+
+Context is up-to-date:
+- Tech stack: No changes
+- Progress: No new completions
+- Structure: No changes
+- Last updated: [Date from progress.md]
+
+💡 Context will be updated when changes are detected:
+  - New dependencies in package.json
+  - New directories or files
+  - Changes to README.md
+  - Git commits (if available)
+```
+
+## Output Format
+
+Return:
+- List of updated files
+- Detailed change summary for each file
+- Recommendations based on changes
+- Prompt to reload context if significant updates made

package/autopm/.claude/commands/pm/epic-decompose.md

@@ -7,8 +7,27 @@ allowed-tools: Bash, Read, Write, LS, Task
 Break epic into concrete, actionable tasks.
 
 ## Usage
+
+**Single Epic:**
+```bash
+/pm:epic-decompose <feature_name>
 ```
+
+**Multi-Epic (decomposes ALL epics at once):**
+```bash
 /pm:epic-decompose <feature_name>
+# Example: /pm:epic-decompose ecommerce-platform
+# This will automatically decompose ALL epics:
+#   - 01-infrastructure
+#   - 02-auth-backend
+#   - 03-product-api
+#   - etc.
+```
+
+**Single Epic from Multi-Epic structure:**
+```bash
+/pm:epic-decompose <feature_name>/<epic_folder>
+# Example: /pm:epic-decompose ecommerce-platform/01-infrastructure
 ```
 
 ## Required Documentation Access

package/autopm/.claude/commands/pm/epic-merge.md

@@ -37,7 +37,7 @@ Merge completed epic branch back to main branch.
 
 2. **Check for active agents:**
    Read `.claude/epics/$ARGUMENTS/execution-status.md`
-   If active agents exist: "⚠️ Active agents detected. Stop them first with: /pm:epic-stop $ARGUMENTS"
+   If active agents exist: "⚠️ Active agents detected. Stop them first with: /pm:epic-close $ARGUMENTS"
 
 ## Instructions
 
@@ -123,7 +123,7 @@ Options:
    git merge --abort
    
 3. Get help:
-   /pm:epic-resolve $ARGUMENTS
+   /pm:epic-close $ARGUMENTS
 
 Branch preserved at: epic/$ARGUMENTS
 "

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