claude-autopm 2.11.1 → 2.12.1

package/autopm/.claude/hooks/pre-action-agent-reminder.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+/**
+ * Pre-Action Agent Reminder Hook
+ *
+ * Reminds Claude to use specialized agents BEFORE performing tasks.
+ * This hook analyzes the user's request and suggests appropriate agents.
+ *
+ * IMPORTANT: This is a REMINDER, not a blocker. Claude can proceed,
+ * but should consider using agents for non-trivial tasks.
+ */
+
+const patterns = {
+  // Code writing patterns
+  code: {
+    patterns: [
+      /writ(e|ing) code/i,
+      /creat(e|ing) (a |an )?(function|class|component|module|api|endpoint)/i,
+      /implement(ing)?/i,
+      /add (a |an )?(feature|functionality)/i,
+      /build (a |an )?/i,
+      /develop(ing)?/i
+    ],
+    agents: [
+      'python-backend-engineer (Python)',
+      'nodejs-backend-engineer (Node.js/JavaScript)',
+      'react-frontend-engineer (React/Frontend)',
+      'bash-scripting-expert (Bash scripts)'
+    ],
+    context7: [
+      'Query Context7 for framework-specific best practices',
+      'Check API patterns and conventions',
+      'Verify current library versions and syntax'
+    ]
+  },
+
+  // Testing patterns
+  testing: {
+    patterns: [
+      /test(s|ing)?/i,
+      /unit test/i,
+      /integration test/i,
+      /e2e test/i,
+      /run.*(test|spec)/i,
+      /write.*test/i
+    ],
+    agents: [
+      'test-runner (Run and analyze tests)',
+      'frontend-testing-engineer (Frontend tests)',
+      'e2e-test-engineer (E2E tests)'
+    ],
+    context7: [
+      'mcp://context7/jest/best-practices',
+      'mcp://context7/testing/tdd-patterns',
+      'mcp://context7/<framework>/testing'
+    ]
+  },
+
+  // Database patterns
+  database: {
+    patterns: [
+      /database/i,
+      /schema/i,
+      /migration/i,
+      /query/i,
+      /sql/i,
+      /(postgres|mysql|mongodb|redis)/i
+    ],
+    agents: [
+      'postgresql-expert (PostgreSQL)',
+      'mongodb-expert (MongoDB)',
+      'redis-expert (Redis)'
+    ],
+    context7: [
+      'mcp://context7/<database>/schema-design',
+      'mcp://context7/<database>/query-optimization',
+      'mcp://context7/<database>/best-practices'
+    ]
+  },
+
+  // DevOps patterns
+  devops: {
+    patterns: [
+      /deploy(ing|ment)?/i,
+      /docker/i,
+      /kubernetes/i,
+      /k8s/i,
+      /container/i,
+      /ci\/cd/i,
+      /pipeline/i
+    ],
+    agents: [
+      'kubernetes-orchestrator (Kubernetes)',
+      'docker-containerization-expert (Docker)',
+      'terraform-infrastructure-expert (Terraform)',
+      'github-operations-specialist (GitHub Actions)'
+    ],
+    context7: [
+      'mcp://context7/kubernetes/deployment-patterns',
+      'mcp://context7/docker/best-practices',
+      'mcp://context7/terraform/infrastructure-patterns'
+    ]
+  },
+
+  // Code analysis patterns
+  analysis: {
+    patterns: [
+      /review/i,
+      /analyze/i,
+      /check.*bug/i,
+      /find.*issue/i,
+      /security/i,
+      /optimize/i
+    ],
+    agents: [
+      'code-analyzer (Bug detection, logic tracing)',
+      'security-scanning-expert (Security analysis)'
+    ],
+    context7: [
+      'mcp://context7/<language>/code-quality',
+      'mcp://context7/security/best-practices'
+    ]
+  },
+
+  // Large file patterns
+  files: {
+    patterns: [
+      /log file/i,
+      /analyze.*file/i,
+      /summarize.*file/i,
+      /parse.*(log|output)/i
+    ],
+    agents: [
+      'file-analyzer (File and log analysis)'
+    ],
+    context7: [
+      'mcp://context7/logging/analysis-patterns'
+    ]
+  }
+};
+
+function analyzeRequest(userMessage) {
+  const matches = [];
+
+  for (const [category, config] of Object.entries(patterns)) {
+    for (const pattern of config.patterns) {
+      if (pattern.test(userMessage)) {
+        matches.push({
+          category,
+          agents: config.agents,
+          context7: config.context7
+        });
+        break;
+      }
+    }
+  }
+
+  return matches;
+}
+
+function generateReminder(matches) {
+  if (matches.length === 0) {
+    return null;
+  }
+
+  let reminder = '\n🤖 AGENT USAGE REMINDER\n';
+  reminder += '━'.repeat(80) + '\n\n';
+
+  reminder += '⚠️  This task may benefit from using specialized agents:\n\n';
+
+  for (const match of matches) {
+    reminder += `📋 ${match.category.toUpperCase()} TASK DETECTED\n\n`;
+
+    reminder += '**Recommended Agents:**\n';
+    for (const agent of match.agents) {
+      reminder += `   • ${agent}\n`;
+    }
+
+    reminder += '\n**Context7 Queries:**\n';
+    for (const query of match.context7) {
+      reminder += `   • ${query}\n`;
+    }
+
+    reminder += '\n';
+  }
+
+  reminder += '📖 See: .claude/rules/agent-mandatory.md for complete guidance\n';
+  reminder += '━'.repeat(80) + '\n\n';
+
+  reminder += '💡 You can proceed directly if this is simple, but consider:\n';
+  reminder += '   1. Using agents for better quality and consistency\n';
+  reminder += '   2. Querying Context7 for up-to-date best practices\n';
+  reminder += '   3. Following TDD cycle (RED-GREEN-REFACTOR)\n\n';
+
+  return reminder;
+}
+
+function main() {
+  // Get user message from command line args or stdin
+  const args = process.argv.slice(2);
+  const userMessage = args.join(' ') || '';
+
+  if (!userMessage) {
+    // No message to analyze
+    process.exit(0);
+  }
+
+  const matches = analyzeRequest(userMessage);
+  const reminder = generateReminder(matches);
+
+  if (reminder) {
+    console.log(reminder);
+  }
+
+  process.exit(0);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { analyzeRequest, generateReminder };

package/autopm/.claude/hooks/pre-commit-clear-reminder.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+# Pre-Commit Clear Reminder Hook
+#
+# Detects when an issue is being closed and reminds to run /clear
+# before starting the next issue.
+
+# Get the commit message
+COMMIT_MSG_FILE="$1"
+COMMIT_MSG=$(cat "$COMMIT_MSG_FILE" 2>/dev/null || git log --format=%B -n 1 HEAD 2>/dev/null)
+
+# Patterns that indicate issue closure
+CLOSING_PATTERNS=(
+    "close #"
+    "closes #"
+    "closed #"
+    "fix #"
+    "fixes #"
+    "fixed #"
+    "resolve #"
+    "resolves #"
+    "resolved #"
+    "complete #"
+    "completes #"
+    "completed #"
+)
+
+# Check if commit message contains issue closing keywords
+issue_closed=false
+for pattern in "${CLOSING_PATTERNS[@]}"; do
+    if echo "$COMMIT_MSG" | grep -qi "$pattern"; then
+        issue_closed=true
+        break
+    fi
+done
+
+# If issue is being closed, show reminder
+if [ "$issue_closed" = true ]; then
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "🧹 CONTEXT HYGIENE REMINDER"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+    echo "⚠️  This commit closes an issue!"
+    echo ""
+    echo "📋 IMPORTANT: After this commit, run /clear before starting"
+    echo "   the next issue to prevent context bleed."
+    echo ""
+    echo "Why this matters:"
+    echo "  • Prevents mixing context from different issues"
+    echo "  • Ensures Claude starts fresh for each task"
+    echo "  • Reduces token usage"
+    echo "  • Improves response quality"
+    echo ""
+    echo "Next steps:"
+    echo "  1. ✅ Complete this commit"
+    echo "  2. 🧹 Type: /clear"
+    echo "  3. 📝 Start next issue with clean context"
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+
+    # Optional: Create a reminder file
+    echo "REMINDER: Run /clear before next issue" > .claude/.clear-reminder
+fi
+
+# Always allow commit to proceed
+exit 0

package/autopm/.claude/rules/agent-mandatory.md

@@ -2,12 +2,43 @@
 
 **🚨 CRITICAL: This rule has HIGHEST PRIORITY and MUST be followed for ALL tasks.**
 
+## ⚠️ BEFORE YOU START ANY TASK - READ THIS
+
+**MANDATORY SELF-CHECK:**
+
+Before doing ANYTHING complex, ask yourself:
+1. ❓ Is this writing code? → **USE AGENT**
+2. ❓ Is this testing code? → **USE test-runner**
+3. ❓ Is this analyzing code/files? → **USE code-analyzer or file-analyzer**
+4. ❓ Is this database work? → **USE database expert agent**
+5. ❓ Is this DevOps/infrastructure? → **USE DevOps agent**
+
+**If YES to ANY → STOP and USE the appropriate agent!**
+
 ## Core Requirement
 
 **YOU MUST USE SPECIALIZED AGENTS FOR ALL NON-TRIVIAL TASKS.**
 
 Do NOT perform complex tasks yourself. Use the Task tool to delegate to appropriate agents.
 
+### Why This Rule Exists
+
+1. **Quality**: Specialized agents have deeper expertise
+2. **Consistency**: Agents follow established patterns
+3. **Context7**: Agents query live documentation (you should too!)
+4. **TDD**: Agents enforce RED-GREEN-REFACTOR cycle
+5. **Best Practices**: Agents apply industry standards
+
+### What Happens When You Don't Use Agents
+
+❌ **Common failures:**
+- Code without tests (violates TDD)
+- Missing Context7 queries (outdated patterns)
+- Inconsistent code style
+- Security vulnerabilities
+- Performance issues
+- Missing error handling
+
 ## When to Use Agents
 
 ### ✅ ALWAYS Use Agents For:
@@ -160,11 +191,59 @@ If you're unsure whether to use an agent:
 - When in doubt, delegate to specialist
 - Better to over-use agents than under-use them
 
+## Context7 Integration - ALSO MANDATORY
+
+**In addition to using agents, you MUST query Context7 for up-to-date documentation.**
+
+### When to Query Context7
+
+**BEFORE implementing ANY code:**
+```bash
+# Query relevant documentation
+mcp://context7/<framework>/<topic>
+mcp://context7/<language>/best-practices
+mcp://context7/<library>/api-reference
+```
+
+### Why Context7 is Required
+
+1. **Up-to-date info**: Your training data may be outdated
+2. **API changes**: Libraries evolve, APIs change
+3. **Best practices**: Current industry standards
+4. **Bug fixes**: Known issues and workarounds
+
+### Examples
+
+**Writing Python FastAPI code:**
+```bash
+# Query BEFORE implementation
+mcp://context7/fastapi/routing
+mcp://context7/fastapi/validation
+mcp://context7/pydantic/models
+```
+
+**Writing React components:**
+```bash
+# Query BEFORE implementation
+mcp://context7/react/hooks
+mcp://context7/react/18.0/best-practices
+mcp://context7/typescript/react-patterns
+```
+
+**Database schema design:**
+```bash
+# Query BEFORE implementation
+mcp://context7/postgresql/schema-design
+mcp://context7/postgresql/indexing
+mcp://context7/postgresql/performance
+```
+
 ## Summary
 
 **Before doing ANY complex task, ask yourself:**
 1. Is there a specialized agent for this?
 2. Would an agent do this better/faster/more thoroughly?
 3. Am I trying to do something I should delegate?
+4. Should I query Context7 for current best practices?
 
-**If answer is YES to any → USE THE AGENT!**
+**If answer is YES to any → USE THE AGENT! AND QUERY CONTEXT7!**

package/autopm/.claude/rules/context-hygiene.md

@@ -0,0 +1,270 @@
+# Context Hygiene - MANDATORY
+
+**🧹 CRITICAL: Run `/clear` between issues to prevent context bleed.**
+
+## Core Requirement
+
+**YOU MUST CLEAR CONTEXT AFTER COMPLETING EACH ISSUE.**
+
+Context from previous issues can:
+- ❌ Cause incorrect assumptions
+- ❌ Mix concerns from different tasks
+- ❌ Waste tokens on irrelevant history
+- ❌ Reduce response quality
+
+## When to Run /clear
+
+### ✅ ALWAYS Clear After:
+
+1. **Issue/Task Completion**
+   - After merging PR that closes an issue
+   - After marking task as complete
+   - Before starting new issue
+
+2. **Context Switches**
+   - Switching between different features
+   - Moving to different part of codebase
+   - Changing from bug fix to feature development
+
+3. **Long Conversations**
+   - After 20+ messages in one issue
+   - When context window getting full
+   - When conversation becomes unfocused
+
+4. **Daily Boundaries**
+   - At end of work day
+   - At start of new work session
+   - After long breaks
+
+### 🔴 NEVER Skip /clear When:
+
+- Closing an issue (MOST IMPORTANT)
+- Starting a new issue
+- Switching work contexts
+- After merge conflicts resolved
+- After completing refactoring
+
+## How to Use /clear
+
+### Manual Trigger:
+
+```bash
+# Type this in Claude Code CLI:
+/clear
+```
+
+### Expected Behavior:
+
+```
+Claude Code: "Context cleared. Ready for next task."
+```
+
+## Enforcement
+
+### Git Hook Reminder
+
+Pre-commit hook detects issue closure and reminds:
+
+```
+🧹 CONTEXT HYGIENE REMINDER
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+⚠️  This commit closes an issue!
+
+📋 IMPORTANT: After this commit, run /clear before starting
+   the next issue to prevent context bleed.
+
+Next steps:
+  1. ✅ Complete this commit
+  2. 🧹 Type: /clear
+  3. 📝 Start next issue with clean context
+```
+
+### PM Command Integration
+
+PM commands include `/clear` reminders:
+
+```bash
+# After completing issue
+/pm:issue-complete 123
+
+# Output includes:
+# ✅ Issue #123 marked as complete
+# 🧹 REMINDER: Run /clear before starting next issue
+```
+
+## Workflow Integration
+
+### Standard Issue Workflow:
+
+```bash
+# 1. Start issue
+/pm:issue-start 123
+
+# 2. Work on issue...
+# ... implement, test, commit ...
+
+# 3. Complete issue
+git commit -m "fix: resolve issue #123"
+git push
+
+# 4. CLEAR CONTEXT (MANDATORY)
+/clear
+
+# 5. Start next issue with clean slate
+/pm:issue-start 124
+```
+
+### Example Violation:
+
+❌ **WRONG - No /clear:**
+```bash
+# Complete issue 123
+git commit -m "fix: issue #123"
+
+# Immediately start issue 124 (BAD!)
+/pm:issue-start 124
+# Context from #123 still present!
+```
+
+✅ **CORRECT - With /clear:**
+```bash
+# Complete issue 123
+git commit -m "fix: issue #123"
+
+# Clear context (REQUIRED)
+/clear
+
+# Now start issue 124
+/pm:issue-start 124
+# Fresh context, no bleed from #123
+```
+
+## Why This Matters
+
+### Context Bleed Examples:
+
+**Without /clear:**
+```
+Issue #123: Add user authentication
+Claude remembers: "We're working on auth..."
+
+Issue #124: Fix database query bug
+Claude thinks: "This must be related to auth system from #123"
+# WRONG ASSUMPTION - wastes time debugging wrong area
+```
+
+**With /clear:**
+```
+Issue #123: Add user authentication
+/clear
+
+Issue #124: Fix database query bug
+Claude thinks: "Fresh start, what's the actual issue?"
+# CORRECT - focuses on actual problem
+```
+
+### Token Efficiency:
+
+**Without /clear:**
+- Context window: 50k+ tokens from previous issues
+- Available for work: 150k tokens
+- Efficiency: 75%
+
+**With /clear:**
+- Context window: 5k tokens (fresh start)
+- Available for work: 195k tokens
+- Efficiency: 97.5%
+
+## Best Practices
+
+### 1. Clear After Every PR Merge
+
+```bash
+# Merge PR
+gh pr merge 123 --squash
+
+# Immediate clear
+/clear
+
+# Ready for next task
+```
+
+### 2. Clear Before Starting New Feature
+
+```bash
+# Check what's next
+/pm:backlog
+
+# Pick issue
+/pm:issue-start 125
+
+# But first...
+/clear
+
+# Now start fresh
+/pm:issue-start 125
+```
+
+### 3. Clear After Context Gets Large
+
+Check context size with:
+```bash
+# If conversation has 20+ messages
+# Or if responses become slow
+# Or if Claude seems confused
+
+# CLEAR IT
+/clear
+```
+
+## Automation Ideas
+
+### Option 1: Auto-Clear on Issue Close
+
+**PM command auto-clears:**
+```bash
+/pm:issue-complete 123
+# Automatically runs /clear internally
+```
+
+### Option 2: Clear Reminder File
+
+**Hook creates reminder:**
+```bash
+# After commit that closes issue
+# Creates: .claude/.clear-reminder
+
+# Next Claude interaction checks:
+if [ -f .claude/.clear-reminder ]; then
+  echo "⚠️  REMINDER: Run /clear before continuing"
+fi
+```
+
+### Option 3: Session Start Check
+
+**Check on session start:**
+```bash
+# In CLAUDE.md:
+## Session Start Protocol
+1. Check for .clear-reminder file
+2. If exists, warn user
+3. Remove file after /clear
+```
+
+## Summary
+
+**Context hygiene is as important as code hygiene.**
+
+### Remember:
+- 🧹 **ALWAYS** `/clear` after issue completion
+- 🧹 **ALWAYS** `/clear` before new issue
+- 🧹 **ALWAYS** `/clear` on context switch
+
+### Benefits:
+- ✅ No context bleed between issues
+- ✅ Better response quality
+- ✅ More efficient token usage
+- ✅ Clearer thinking for each task
+
+**Make `/clear` a habit, not an afterthought.**

package/autopm/.claude/scripts/check-clear-reminder.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+
+# Check for /clear reminder
+#
+# This script checks if there's a pending /clear reminder
+# and displays it to the user.
+#
+# Should be run at session start or before new commands.
+
+REMINDER_FILE=".claude/.clear-reminder"
+
+if [ -f "$REMINDER_FILE" ]; then
+    echo ""
+    echo "╔════════════════════════════════════════════════════════════════╗"
+    echo "║                   🧹 PENDING /clear REMINDER                   ║"
+    echo "╚════════════════════════════════════════════════════════════════╝"
+    echo ""
+    echo "⚠️  You have a pending context clear reminder from:"
+    echo ""
+    cat "$REMINDER_FILE"
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+    echo "Why this is important:"
+    echo "  • Prevents context bleed from previous issue"
+    echo "  • Ensures fresh start for new task"
+    echo "  • Improves response quality"
+    echo "  • Reduces token waste"
+    echo ""
+    echo "Action required:"
+    echo "  1. Type: /clear"
+    echo "  2. This reminder will be automatically removed"
+    echo "  3. Then proceed with your new task"
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+
+    # Optional: Block until /clear is run
+    # Uncomment to enforce /clear before proceeding:
+    # read -p "Press Enter after running /clear to continue..."
+    # rm "$REMINDER_FILE"
+fi