claude-autopm 3.1.2 → 3.2.1

package/autopm/scripts/optimize-context.js

@@ -0,0 +1,401 @@
+#!/usr/bin/env node
+/**
+ * AutoPM Context Optimization Wizard
+ * Helps users identify and archive unused rules to reduce memory usage
+ *
+ * Usage: node autopm/scripts/optimize-context.js
+ *
+ * Impact: 50-70% reduction in context memory usage (67k → 21k tokens typical)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+class ContextOptimizer {
+  constructor() {
+    this.rulesDir = path.join('.claude', 'rules');
+    this.archiveDir = path.join('.claude', 'rules-archive');
+
+    // Rule categories with descriptions
+    this.ruleCategories = {
+      'ai-ml': {
+        name: 'AI/ML Integration',
+        files: [
+          'ai-integration-patterns.md',
+          'ai-model-standards.md',
+          'prompt-engineering-standards.md'
+        ],
+        question: 'Are you using OpenAI, Gemini, LangChain, or other AI/ML APIs?'
+      },
+      'cloud': {
+        name: 'Cloud Platforms',
+        files: [
+          'ci-cd-kubernetes-strategy.md',
+          'cloud-security-compliance.md',
+          'infrastructure-pipeline.md'
+        ],
+        question: 'Are you deploying to AWS, Azure, GCP, or using Kubernetes/Terraform?'
+      },
+      'databases-advanced': {
+        name: 'Advanced Database Systems',
+        files: [
+          'database-management-strategy.md',
+          'database-pipeline.md'
+        ],
+        question: 'Are you using MongoDB, CosmosDB, BigQuery, or Redis?'
+      },
+      'ui-ux': {
+        name: 'UI/UX Development',
+        files: [
+          'ui-development-standards.md',
+          'ui-framework-rules.md',
+          'ux-design-rules.md',
+          'visual-testing.md'
+        ],
+        question: 'Are you building complex UI/UX with React, Vue, or Angular?'
+      },
+      'verbose-guidelines': {
+        name: 'General Guidelines',
+        files: [
+          'performance-guidelines.md',
+          'security-checklist.md',
+          'definition-of-done.md',
+          'golden-rules.md',
+          'code-quality-standards.md',
+          'context-hygiene.md'
+        ],
+        question: 'Do you want verbose general guidelines (performance, security, quality)?'
+      }
+    };
+
+    // Essential rules that should never be archived
+    this.essentialRules = [
+      'agent-coordination.md',
+      'agent-mandatory-optimized.md',
+      'command-pipelines.md',
+      'context-optimization.md',
+      'datetime.md',
+      'development-workflow.md',
+      'docker-first-development.md',
+      'frontmatter-operations.md',
+      'git-strategy.md',
+      'github-operations.md',
+      'naming-conventions.md',
+      'standard-patterns.md',
+      'strip-frontmatter.md',
+      'tdd.enforcement.md',
+      'test-execution.md',
+      'testing-standards.md'
+    ];
+  }
+
+  async detectProjectTech() {
+    // Auto-detect technologies used in project
+    const detected = {
+      hasAI: false,
+      hasCloud: false,
+      hasAdvancedDB: false,
+      hasUI: false
+    };
+
+    try {
+      // Check package.json for AI libraries
+      if (fs.existsSync('package.json')) {
+        const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+        detected.hasAI = Object.keys(deps).some(dep =>
+          dep.includes('openai') ||
+          dep.includes('langchain') ||
+          dep.includes('@google/generative-ai') ||
+          dep.includes('@anthropic-ai/sdk')
+        );
+
+        detected.hasUI = Object.keys(deps).some(dep =>
+          dep.includes('react') ||
+          dep.includes('vue') ||
+          dep.includes('angular') ||
+          dep.includes('@angular/core')
+        );
+      }
+
+      // Check for Python AI libraries
+      if (fs.existsSync('requirements.txt')) {
+        const reqs = fs.readFileSync('requirements.txt', 'utf8');
+        detected.hasAI = detected.hasAI || reqs.includes('openai') || reqs.includes('langchain');
+      }
+
+      // Check for cloud infrastructure files
+      detected.hasCloud =
+        fs.existsSync('terraform') ||
+        fs.existsSync('.github/workflows') ||
+        fs.existsSync('.gitlab-ci.yml') ||
+        fs.existsSync('kubernetes') ||
+        fs.existsSync('k8s') ||
+        fs.existsSync('Dockerfile') ||
+        fs.existsSync('docker-compose.yml');
+
+      // Check for advanced database configs
+      detected.hasAdvancedDB =
+        fs.existsSync('mongodb.conf') ||
+        fs.existsSync('redis.conf') ||
+        fs.existsSync('cosmosdb.json') ||
+        fs.existsSync('.redshift') ||
+        this.checkFileContent('docker-compose.yml', ['mongodb', 'redis']);
+
+    } catch (error) {
+      // Silently continue if detection fails
+    }
+
+    return detected;
+  }
+
+  checkFileContent(filename, keywords) {
+    try {
+      if (fs.existsSync(filename)) {
+        const content = fs.readFileSync(filename, 'utf8').toLowerCase();
+        return keywords.some(keyword => content.includes(keyword));
+      }
+    } catch (error) {
+      // Ignore errors
+    }
+    return false;
+  }
+
+  async runWizard() {
+    console.log('\n🔍 AutoPM Context Optimization Wizard');
+    console.log('═'.repeat(60));
+    console.log('This wizard helps reduce memory usage by archiving unused rules.\n');
+
+    const detected = await this.detectProjectTech();
+    console.log('📊 Detected technologies:');
+    console.log(`  AI/ML:       ${detected.hasAI ? '✅ Yes' : '❌ No'}`);
+    console.log(`  Cloud:       ${detected.hasCloud ? '✅ Yes' : '❌ No'}`);
+    console.log(`  Advanced DB: ${detected.hasAdvancedDB ? '✅ Yes' : '❌ No'}`);
+    console.log(`  UI Framework: ${detected.hasUI ? '✅ Yes' : '❌ No'}`);
+    console.log('');
+
+    // Check if rules directory exists
+    if (!fs.existsSync(this.rulesDir)) {
+      console.error('❌ Error: .claude/rules directory not found');
+      console.log('💡 This wizard must be run from a project with AutoPM installed');
+      process.exit(1);
+    }
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    const prompt = (question) => new Promise(resolve => {
+      rl.question(question + ' (yes/no): ', answer => {
+        resolve(answer.toLowerCase().startsWith('y'));
+      });
+    });
+
+    const toArchive = [];
+    let categoryCount = 0;
+
+    for (const [key, category] of Object.entries(this.ruleCategories)) {
+      categoryCount++;
+      const keep = await prompt(`\n[${categoryCount}/${Object.keys(this.ruleCategories).length}] ${category.name}: ${category.question}`);
+
+      if (!keep) {
+        // Filter out any essential rules
+        const safeToArchive = category.files.filter(f => !this.essentialRules.includes(f));
+        if (safeToArchive.length > 0) {
+          toArchive.push(...safeToArchive);
+          console.log(`  → Will archive ${safeToArchive.length} files`);
+        }
+        if (safeToArchive.length < category.files.length) {
+          console.log(`  → Keeping ${category.files.length - safeToArchive.length} essential files`);
+        }
+      } else {
+        console.log(`  → Keeping all ${category.files.length} files`);
+      }
+    }
+
+    rl.close();
+
+    if (toArchive.length === 0) {
+      console.log('\n✅ No files to archive. All rules will be kept.');
+      console.log('💡 You can run this wizard again at any time to optimize further.\n');
+      return;
+    }
+
+    console.log(`\n📦 Archiving ${toArchive.length} unused rules...`);
+    const archived = this.archiveFiles(toArchive);
+
+    console.log('\n✅ Context optimization complete!');
+    console.log(`📊 Results:`);
+    console.log(`   • Files archived: ${archived.length}`);
+    console.log(`   • Estimated memory savings: ~${this.estimateSavings(archived.length)} tokens`);
+    console.log(`   • Typical reduction: 50-70% of rules context\n`);
+
+    console.log('💡 Next steps:');
+    console.log('   • Test your workflow to ensure everything works');
+    console.log('   • Restore files if needed: mv .claude/rules-archive/<file> .claude/rules/');
+    console.log('   • Run wizard again anytime to further optimize\n');
+  }
+
+  archiveFiles(files) {
+    // Create archive directory
+    if (!fs.existsSync(this.archiveDir)) {
+      fs.mkdirSync(this.archiveDir, { recursive: true });
+    }
+
+    const archived = [];
+
+    // Move files to archive
+    for (const file of files) {
+      const source = path.join(this.rulesDir, file);
+      const dest = path.join(this.archiveDir, file);
+
+      if (fs.existsSync(source)) {
+        try {
+          fs.renameSync(source, dest);
+          console.log(`  ✓ Archived: ${file}`);
+          archived.push(file);
+        } catch (error) {
+          console.log(`  ⚠ Failed to archive: ${file} (${error.message})`);
+        }
+      } else {
+        console.log(`  ⊘ Skipped (not found): ${file}`);
+      }
+    }
+
+    return archived;
+  }
+
+  estimateSavings(fileCount) {
+    // Rough estimate: ~1500 tokens per rule file
+    return (fileCount * 1500).toLocaleString();
+  }
+
+  async restoreAll() {
+    console.log('\n📥 Restoring all archived rules...');
+
+    if (!fs.existsSync(this.archiveDir)) {
+      console.log('❌ No archive directory found');
+      return;
+    }
+
+    const archived = fs.readdirSync(this.archiveDir).filter(f => f.endsWith('.md'));
+
+    if (archived.length === 0) {
+      console.log('✅ No archived files to restore');
+      return;
+    }
+
+    let restored = 0;
+    for (const file of archived) {
+      const source = path.join(this.archiveDir, file);
+      const dest = path.join(this.rulesDir, file);
+
+      try {
+        fs.renameSync(source, dest);
+        console.log(`  ✓ Restored: ${file}`);
+        restored++;
+      } catch (error) {
+        console.log(`  ⚠ Failed to restore: ${file}`);
+      }
+    }
+
+    console.log(`\n✅ Restored ${restored} files`);
+  }
+
+  listArchived() {
+    console.log('\n📦 Archived Rules:');
+
+    if (!fs.existsSync(this.archiveDir)) {
+      console.log('  No archive directory found');
+      return;
+    }
+
+    const archived = fs.readdirSync(this.archiveDir).filter(f => f.endsWith('.md'));
+
+    if (archived.length === 0) {
+      console.log('  No files archived');
+      return;
+    }
+
+    archived.forEach(file => {
+      console.log(`  • ${file}`);
+    });
+
+    console.log(`\nTotal: ${archived.length} files`);
+    console.log(`Estimated memory saved: ~${this.estimateSavings(archived.length)} tokens\n`);
+  }
+}
+
+// Main execution
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const optimizer = new ContextOptimizer();
+
+  if (args.includes('--restore')) {
+    optimizer.restoreAll().catch(error => {
+      console.error('❌ Error:', error.message);
+      process.exit(1);
+    });
+  } else if (args.includes('--list')) {
+    optimizer.listArchived();
+  } else if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+AutoPM Context Optimization Wizard
+
+Usage:
+  node autopm/scripts/optimize-context.js          Run optimization wizard
+  node autopm/scripts/optimize-context.js --list   List archived files
+  node autopm/scripts/optimize-context.js --restore Restore all archived files
+  node autopm/scripts/optimize-context.js --help   Show this help
+
+Description:
+  Helps reduce Claude Code context memory usage by 50-70% by archiving
+  unused rules files based on your project's technology stack.
+
+Examples:
+  # Run the wizard (recommended)
+  node autopm/scripts/optimize-context.js
+
+  # Check what's currently archived
+  node autopm/scripts/optimize-context.js --list
+
+  # Restore all archived files
+  node autopm/scripts/optimize-context.js --restore
+
+Impact:
+  • Typical reduction: 50-70% of rules context
+  • Before: ~67,000 tokens (33.5% of 200k limit)
+  • After:  ~21,000 tokens (10.5% of 200k limit)
+  • Savings: ~46,000 tokens available for project code
+
+Essential Rules (Never Archived):
+  These 16 core rules are always kept:
+  • agent-coordination.md
+  • agent-mandatory-optimized.md
+  • command-pipelines.md
+  • context-optimization.md
+  • datetime.md
+  • development-workflow.md
+  • docker-first-development.md
+  • frontmatter-operations.md
+  • git-strategy.md
+  • github-operations.md
+  • naming-conventions.md
+  • standard-patterns.md
+  • strip-frontmatter.md
+  • tdd.enforcement.md
+  • test-execution.md
+  • testing-standards.md
+`);
+  } else {
+    optimizer.runWizard().catch(error => {
+      console.error('❌ Error:', error.message);
+      process.exit(1);
+    });
+  }
+}
+
+module.exports = ContextOptimizer;

package/package.json

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

package/packages/plugin-pm/commands/pm:epic-decompose.md

@@ -70,6 +70,111 @@ Example:
 **IMPORTANT:** Before executing this command, read and follow:
 - `.claude/rules/datetime.md` - For getting real current date/time
 
+## Agent Selection Strategy
+
+Based on the PRD content and technical requirements, automatically determine which specialized agents should be assigned to tasks.
+
+### Step 1: Analyze PRD for Technology Stack
+
+Read `.claude/prds/$ARGUMENTS.md` and identify:
+- **Programming languages** mentioned (Python, JavaScript/TypeScript, Go, Bash, etc.)
+- **Frameworks** required (React, FastAPI, Next.js, Express, etc.)
+- **Databases** needed (PostgreSQL, MongoDB, Redis, etc.)
+- **Cloud platforms** (AWS, Azure, GCP)
+- **Infrastructure** tools (Docker, Kubernetes, Terraform)
+- **Testing** requirements (unit, integration, E2E)
+- **CI/CD** platforms (GitHub Actions, Azure DevOps, GitLab CI)
+
+### Step 2: Map Technologies to Specialized Agents
+
+**Programming Languages**:
+- Python → `.claude/agents/languages/python-backend-engineer.md`
+- JavaScript/TypeScript/Node.js → `.claude/agents/languages/nodejs-backend-engineer.md`
+- React → `.claude/agents/frontend/react-frontend-engineer.md`
+- Bash/Shell scripting → `.claude/agents/languages/bash-scripting-expert.md`
+
+**Databases**:
+- PostgreSQL → `.claude/agents/databases/postgresql-expert.md`
+- MongoDB → `.claude/agents/databases/mongodb-expert.md`
+- Redis → `.claude/agents/databases/redis-expert.md`
+- Cosmos DB → `.claude/agents/databases/cosmosdb-expert.md`
+
+**Cloud Platforms**:
+- AWS → `.claude/agents/cloud/aws-cloud-architect.md`
+- Azure → `.claude/agents/cloud/azure-cloud-architect.md`
+- GCP → `.claude/agents/cloud/gcp-cloud-architect.md`
+
+**Infrastructure & Containers**:
+- Docker → `.claude/agents/containers/docker-containerization-expert.md`
+- Kubernetes → `.claude/agents/orchestration/kubernetes-orchestrator.md`
+- Terraform → `.claude/agents/infrastructure/terraform-infrastructure-expert.md`
+
+**Testing**:
+- Unit/Integration tests → `.claude/agents/core/test-runner.md`
+- Frontend E2E testing → `.claude/agents/testing/frontend-testing-engineer.md`
+- E2E automation → `.claude/agents/testing/e2e-test-engineer.md`
+
+**DevOps & CI/CD**:
+- GitHub operations → `.claude/agents/devops/github-operations-specialist.md`
+- Azure DevOps → `.claude/agents/devops/azure-devops-specialist.md`
+- Observability → `.claude/agents/devops/observability-engineer.md`
+
+### Step 3: Document Agent Assignments in Epic Frontmatter
+
+Add `required_agents` array to epic.md frontmatter:
+
+```yaml
+---
+name: user-authentication
+prd: user-authentication
+status: backlog
+created: 2025-12-17T10:00:00Z
+updated: 2025-12-17T10:00:00Z
+required_agents:
+  - path: .claude/agents/languages/python-backend-engineer.md
+    role: API implementation
+    tasks: [001, 002, 003]
+  - path: .claude/agents/databases/postgresql-expert.md
+    role: Database schema and migrations
+    tasks: [004, 005]
+  - path: .claude/agents/testing/frontend-testing-engineer.md
+    role: Test suite development
+    tasks: [006, 007]
+  - path: .claude/agents/devops/github-operations-specialist.md
+    role: CI/CD pipeline setup
+    tasks: [008]
+---
+```
+
+### Step 4: Assign Agents to Individual Tasks
+
+Each task file should include `assigned_agent` in frontmatter:
+
+```yaml
+---
+name: Implement JWT authentication endpoints
+status: open
+created: 2025-12-17T10:00:00Z
+updated: 2025-12-17T10:00:00Z
+assigned_agent: .claude/agents/languages/python-backend-engineer.md
+agent_context:
+  framework: fastapi
+  auth_method: jwt
+  libraries: [pyjwt, passlib]
+github: [Will be updated when synced to GitHub]
+depends_on: [004]  # Depends on user schema
+parallel: true
+conflicts_with: []
+---
+```
+
+**Benefits of Agent Assignment**:
+- ✅ Automatic selection of specialized agents based on technology
+- ✅ Clear agent responsibilities per task
+- ✅ Easier task assignment when starting work
+- ✅ Better parallel execution planning with appropriate agents
+- ✅ Consistent expertise application across similar tasks
+
 ## Preflight Checklist
 
 Before proceeding, complete these validation steps.
@@ -139,35 +244,81 @@ You are decomposing epic(s) into specific, actionable tasks for: **$ARGUMENTS**
 - Understand the technical approach and requirements
 - Review the task breakdown preview
 
-### 2. Analyze for Parallel Creation
+### 3. Analyze PRD and Select Agents
+
+**IMPORTANT**: Before creating tasks, determine which specialized agents should be used:
+
+1. **Read the PRD** from `.claude/prds/$ARGUMENTS.md` (or linked PRD in epic frontmatter)
+
+2. **Identify Technology Stack**:
+   - Scan for programming languages (Python, JavaScript, Go, etc.)
+   - Find frameworks (React, FastAPI, Django, Express, etc.)
+   - Note databases (PostgreSQL, MongoDB, Redis, etc.)
+   - Identify cloud platforms (AWS, Azure, GCP)
+   - Check for infrastructure tools (Docker, K8s, Terraform)
+
+3. **Map to Specialized Agents** using the Agent Selection Strategy section above:
+   - **Backend tasks** → `python-backend-engineer` or `nodejs-backend-engineer`
+   - **Frontend tasks** → `react-frontend-engineer` or `javascript-frontend-engineer`
+   - **Database tasks** → `postgresql-expert`, `mongodb-expert`, or `redis-expert`
+   - **Cloud tasks** → `aws-cloud-architect`, `azure-cloud-architect`, or `gcp-cloud-architect`
+   - **Container tasks** → `docker-containerization-expert`
+   - **Orchestration** → `kubernetes-orchestrator`
+   - **IaC tasks** → `terraform-infrastructure-expert`
+   - **Testing** → `test-runner`, `frontend-testing-engineer`, `e2e-test-engineer`
+   - **CI/CD** → `github-operations-specialist` or `azure-devops-specialist`
+
+4. **Update Epic Frontmatter** with `required_agents` array (see Agent Selection Strategy section)
+
+5. **Prepare Agent Assignments** for each task to be created
+
+**Example**:
+```markdown
+Technology Stack Detected:
+- Backend: Python + FastAPI
+- Database: PostgreSQL
+- Testing: pytest
+- Deployment: Docker
+
+Agent Mapping:
+- Tasks 001-003 (API): python-backend-engineer
+- Tasks 004-005 (Database): postgresql-expert
+- Tasks 006-007 (Tests): test-runner
+- Task 008 (Docker): docker-containerization-expert
+```
+
+### 4. Analyze for Parallel Creation
 
 Determine if tasks can be created in parallel:
 - If tasks are mostly independent: Create in parallel using Task agents
 - If tasks have complex dependencies: Create sequentially
 - For best results: Group independent tasks for parallel creation
 
-### 3. Parallel Task Creation (When Possible)
+### 5. Parallel Task Creation (When Possible)
 
-If tasks can be created in parallel, spawn sub-agents:
+If tasks can be created in parallel, spawn sub-agents.
 
-```yaml
-Task:
-  description: "Create task files batch {X}"
-  subagent_type: "general-purpose"
-  prompt: |
-    Create task files for epic: $ARGUMENTS
-
-    Tasks to create:
-    - {list of 3-4 tasks for this batch}
-
-    For each task:
-    1. Create file: .claude/epics/$ARGUMENTS/{number}.md
-    2. Use exact format with frontmatter and all sections
-    3. Follow task breakdown from epic
-    4. Set parallel/depends_on fields appropriately
-    5. Number sequentially (001.md, 002.md, etc.)
-
-    Return: List of files created
+**IMPORTANT**: Do NOT use generic "general-purpose" agents. Task creation should be done directly by Claude Code, not delegated to sub-agents, as it requires careful analysis of PRD, agent selection, and proper frontmatter generation.
+
+**Task Creation Process**:
+1. For each task, determine the appropriate `assigned_agent` based on PRD analysis
+2. Create task file with complete frontmatter including agent assignment
+3. Generate proper task content with all required sections
+4. Ensure sequential numbering (001.md, 002.md, etc.)
+
+**Example Task Creation**:
+```markdown
+Creating task 001 (API endpoint):
+- assigned_agent: .claude/agents/languages/python-backend-engineer.md
+- agent_context: {framework: "fastapi", auth: "jwt"}
+- File: .claude/epics/$ARGUMENTS/001.md
+✓ Created
+
+Creating task 002 (Database schema):
+- assigned_agent: .claude/agents/databases/postgresql-expert.md
+- agent_context: {orm: "sqlalchemy", migrations: "alembic"}
+- File: .claude/epics/$ARGUMENTS/002.md
+✓ Created
 ```
 
 ### 4. Task File Format with Frontmatter
@@ -179,6 +330,11 @@ name: [Task Title]
 status: open
 created: [Current ISO date/time]
 updated: [Current ISO date/time]
+assigned_agent: .claude/agents/{category}/{agent-name}.md  # Specialized agent for this task
+agent_context:  # Optional: Agent-specific configuration
+  framework: [framework_name]
+  language: [language_name]
+  approach: [implementation_approach]
 github: [Will be updated when synced to GitHub]
 depends_on: []  # List of task numbers this depends on, e.g., [001, 002]
 parallel: true  # Can this run in parallel with other tasks?
@@ -245,6 +401,15 @@ Example: `.claude/epics/ecommerce/01-infrastructure/001.md`
 - **status**: Always start with "open" for new tasks
 - **created**: Get REAL current datetime by running: `date -u +"%Y-%m-%dT%H:%M:%SZ"`
 - **updated**: Use the same real datetime as created for new tasks
+- **assigned_agent**: Path to specialized agent file (e.g., `.claude/agents/languages/python-backend-engineer.md`)
+  - Select based on technology stack from PRD
+  - Use most specific agent for the task type
+  - See Agent Selection Strategy section for mapping
+- **agent_context**: Optional object with agent-specific configuration
+  - **framework**: Specific framework being used (e.g., "fastapi", "react", "express")
+  - **language**: Programming language if multiple options (e.g., "python", "typescript")
+  - **approach**: Implementation approach or pattern to use
+  - Add any task-specific parameters the agent needs
 - **github**: Leave placeholder text - will be updated during sync
 - **depends_on**: List task numbers that must complete before this can start (e.g., [001, 002])
 - **parallel**: Set to true if this can run alongside other tasks without conflicts