claude-autopm 2.8.2 → 2.8.3

package/packages/plugin-pm/commands/clean.md

@@ -0,0 +1,119 @@
+---
+allowed-tools: Bash, Read, Write, LS
+---
+
+# Clean
+
+Clean up completed work and archive old epics.
+
+## Usage
+```
+/pm:clean [--dry-run]
+```
+
+Options:
+- `--dry-run` - Show what would be cleaned without doing it
+
+## Required Documentation Access
+
+**MANDATORY:** Before project management workflows, query Context7 for best practices:
+
+**Documentation Queries:**
+- `mcp://context7/agile/epic-management` - epic management best practices
+- `mcp://context7/project-management/issue-tracking` - issue tracking best practices
+- `mcp://context7/agile/task-breakdown` - task breakdown best practices
+- `mcp://context7/project-management/workflow` - workflow best practices
+
+**Why This is Required:**
+- Ensures adherence to current industry standards and best practices
+- Prevents outdated or incorrect implementation patterns
+- Provides access to latest framework/tool documentation
+- Reduces errors from stale knowledge or assumptions
+
+
+## Instructions
+
+### 1. Identify Completed Epics
+
+Find epics with:
+- `status: completed` in frontmatter
+- All tasks closed
+- Last update > 30 days ago
+
+### 2. Identify Stale Work
+
+Find:
+- Progress files for closed issues
+- Update directories for completed work
+- Orphaned task files (epic deleted)
+- Empty directories
+
+### 3. Show Cleanup Plan
+
+```
+🧹 Cleanup Plan
+
+Completed Epics to Archive:
+  {epic_name} - Completed {days} days ago
+  {epic_name} - Completed {days} days ago
+  
+Stale Progress to Remove:
+  {count} progress files for closed issues
+  
+Empty Directories:
+  {list_of_empty_dirs}
+  
+Space to Recover: ~{size}KB
+
+{If --dry-run}: This is a dry run. No changes made.
+{Otherwise}: Proceed with cleanup? (yes/no)
+```
+
+### 4. Execute Cleanup
+
+If user confirms:
+
+**Archive Epics:**
+```bash
+mkdir -p .claude/epics/.archived
+mv .claude/epics/{completed_epic} .claude/epics/.archived/
+```
+
+**Remove Stale Files:**
+- Delete progress files for closed issues > 30 days
+- Remove empty update directories
+- Clean up orphaned files
+
+**Create Archive Log:**
+Create `.claude/epics/.archived/archive-log.md`:
+```markdown
+# Archive Log
+
+## {current_date}
+- Archived: {epic_name} (completed {date})
+- Removed: {count} stale progress files
+- Cleaned: {count} empty directories
+```
+
+### 5. Output
+
+```
+✅ Cleanup Complete
+
+Archived:
+  {count} completed epics
+  
+Removed:
+  {count} stale files
+  {count} empty directories
+  
+Space recovered: {size}KB
+
+System is clean and organized.
+```
+
+## Important Notes
+
+Always offer --dry-run to preview changes.
+Never delete PRDs or incomplete work.
+Keep archive log for history.

package/packages/plugin-pm/commands/context-create.md

@@ -0,0 +1,136 @@
+---
+allowed-tools: Bash, Read, Write, Glob
+---
+
+# Context Create
+
+Initialize project context documentation for AI agent memory.
+
+## Required Documentation Access
+
+**MANDATORY:** Before creating context, query Context7 for best practices:
+
+**Documentation Queries:**
+- `mcp://context7/documentation/project-context` - Project documentation standards
+- `mcp://context7/agile/project-setup` - Project initialization best practices
+- `mcp://context7/knowledge-management/technical-documentation` - Documentation organization patterns
+
+**Why This is Required:**
+- Ensures context follows industry standards
+- Provides templates aligned with best practices
+- Establishes effective knowledge management patterns
+
+## Instructions
+
+Create comprehensive project context in `.claude/context/` directory.
+
+### 1. Check if context already exists
+
+```bash
+if [ -d ".claude/context" ]; then
+  echo "⚠️  Context already exists. Use /pm:context-update to modify."
+  exit 1
+fi
+```
+
+### 2. Create context directory structure
+
+```bash
+mkdir -p .claude/context
+```
+
+### 3. Copy and customize templates
+
+**Read templates from AutoPM installation:**
+- `.claude/templates/context-templates/project-brief.md.template`
+- `.claude/templates/context-templates/tech-context.md.template`
+- `.claude/templates/context-templates/progress.md.template`
+- `.claude/templates/context-templates/project-structure.md.template`
+
+### 4. Auto-populate with project information
+
+**Analyze project and pre-fill templates:**
+
+1. **Read package.json** for tech stack:
+   - Extract dependencies and devDependencies
+   - Determine Node.js version from engines
+   - Identify testing framework (Jest, Mocha, etc.)
+   - Detect package manager from lock files
+
+2. **Read README.md** for project description:
+   - Extract project name and description
+   - Identify key features and objectives
+   - Find usage examples
+
+3. **Detect directory structure:**
+   - Scan top-level directories
+   - Identify common patterns (src/, test/, docs/, etc.)
+   - Map key configuration files
+
+4. **Initialize progress:**
+   - Set initial phase as "Setup" or "Development"
+   - Mark context creation as first completed task
+   - Set progress to appropriate starting percentage
+
+### 5. Create context README
+
+Write `.claude/context/README.md`:
+
+```markdown
+# Project Context
+
+This directory maintains comprehensive project information for AI agents.
+
+## Files
+- **project-brief.md**: Project scope and objectives
+- **tech-context.md**: Technology stack and dependencies
+- **progress.md**: Current status and next steps
+- **project-structure.md**: Directory layout and key files
+
+## Usage
+- `/pm:context-prime`: Load context for new session
+- `/pm:context-update`: Update after changes
+- `/pm:context`: View current context
+
+## Maintenance
+Keep these files updated as the project evolves. Run `/pm:context-update` after:
+- Adding new dependencies
+- Completing major tasks
+- Changing project structure
+- Updating technical stack
+```
+
+### 6. Write populated templates
+
+Create the following files in `.claude/context/`:
+- `project-brief.md` (populated from README and package.json)
+- `tech-context.md` (populated from package.json and file detection)
+- `progress.md` (initialized with setup phase)
+- `project-structure.md` (populated from directory scan)
+
+### 7. Confirm creation
+
+Display success message:
+
+```
+✅ Context created in .claude/context/
+
+📝 Files created:
+   - project-brief.md (auto-populated from README)
+   - tech-context.md (auto-populated from package.json)
+   - progress.md (initialized)
+   - project-structure.md (auto-populated from directory scan)
+   - README.md (usage guide)
+
+💡 Next steps:
+   1. Review and customize the context files
+   2. Run /pm:context-prime to load context into session
+   3. Update regularly with /pm:context-update
+```
+
+## Output Format
+
+Return a structured summary of:
+- Files created with auto-populated content preview
+- Any information that couldn't be auto-detected
+- Recommendations for manual customization

package/packages/plugin-pm/commands/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/packages/plugin-pm/commands/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