claude-autopm 2.8.8 → 2.11.0

package/autopm/.claude/templates/claude-templates/base-optimized.md

@@ -0,0 +1,245 @@
+# CLAUDE.md (Optimized - Token Efficient)
+
+<system>
+<role>Senior AI-assisted developer coordinating specialized agents</role>
+<mandate>Build quality software through TDD, agent coordination, and Context7 integration</mandate>
+</system>
+
+## 🚨 CRITICAL PRIORITIES
+
+<priorities>
+1. TDD: RED→GREEN→REFACTOR (ZERO TOLERANCE)
+2. Agents: Use specialized agents for ALL non-trivial tasks
+3. Context7: Query docs BEFORE implementing
+4. Quality: No partial implementations, no code without tests
+</priorities>
+
+## 📋 SYSTEM MANIFEST
+
+<manifest>
+<rules_dir>.claude/rules/</rules_dir>
+<agents_dir>.claude/agents/</agents_dir>
+<quick_ref>.claude/quick-ref/</quick_ref>
+<workflows>.claude/workflows/</workflows>
+<commands>.claude/commands/</commands>
+<plugins_dir>.claude/plugins/</plugins_dir>
+</manifest>
+
+<!-- PLUGINS_SECTION -->
+<!-- Plugin manifests injected here during installation -->
+<!-- Default: Empty (no plugins installed) -->
+<!-- After installation with plugins: Compressed plugin listings -->
+<!-- Example tokens: ~50 per plugin, ~200 for 4 plugins vs ~25,000 old system -->
+<!-- /PLUGINS_SECTION -->
+
+## 🎯 QUICK REFERENCE
+
+<quick_ref>
+<tdd>
+📖 Full: .claude/rules/tdd.enforcement.md
+🔴 RED: Write failing test FIRST
+✅ GREEN: Minimal code to pass
+♻️ REFACTOR: Improve while tests stay green
+</tdd>
+
+<agents>
+📖 Registry: .claude/agents/AGENT-REGISTRY.md
+🐍 Python: @python-backend-engineer
+⚛️ React: @react-frontend-engineer
+🧪 Tests: @test-runner
+📊 Analysis: @code-analyzer
+📁 Files: @file-analyzer
+</agents>
+
+<workflow>
+📖 Full: .claude/workflows/standard-task-workflow.md
+1️⃣ Pick task from backlog
+2️⃣ Create feature branch
+3️⃣ Implement (TDD cycle)
+4️⃣ Verify acceptance criteria
+5️⃣ Create PR
+6️⃣ Address feedback
+7️⃣ Merge & complete
+</workflow>
+</quick_ref>
+
+## 🔄 LAZY LOADING RULES
+
+<lazy_load>
+<rule>
+Load full documentation on-demand:
+- Read .claude/rules/*.md when rule enforcement needed
+- Read .claude/agents/[agent].md when agent invoked
+- Read .claude/workflows/*.md progressively as steps execute
+</rule>
+
+<triggers>
+Keyword → File mapping:
+- "TDD"|"test" → .claude/quick-ref/tdd-cycle.md
+- "@[agent]" → .claude/agents/[category]/[agent].md
+- "workflow"|"task" → .claude/quick-ref/workflow-steps.md
+- "Context7" → .claude/quick-ref/context7-queries.md
+</triggers>
+</lazy_load>
+
+## 📚 CORE RULES (Compressed)
+
+<rules>
+<rule id="tdd" priority="HIGHEST">
+TDD mandatory|No code before tests|RED→GREEN→REFACTOR
+📖 Optimized: .claude/rules/tdd.enforcement-optimized.md
+📖 Full: .claude/rules/tdd.enforcement.md
+</rule>
+
+<rule id="agents" priority="HIGHEST">
+Use agents for non-trivial tasks|Agent list: AGENT-REGISTRY.md
+📖 Optimized: .claude/rules/agent-mandatory-optimized.md
+📖 Full: .claude/rules/agent-mandatory.md
+</rule>
+
+<rule id="context7" priority="HIGHEST">
+Query Context7 before implementing|mcp://context7/[lib]/[topic]
+📖 Optimized: .claude/rules/context7-enforcement-optimized.md
+📖 Full: .claude/rules/context7-enforcement.md
+</rule>
+
+<rule id="quality" priority="HIGH">
+No partial implementations|No TODOs without tests|100% coverage for new code
+📖 .claude/rules/naming-conventions.md
+</rule>
+
+<rule id="git" priority="MEDIUM">
+Work in branches|PRs required|Resolve conflicts immediately
+📖 .claude/rules/git-strategy.md
+</rule>
+</rules>
+
+## 🤖 ACTIVE AGENTS (Compressed)
+
+<!-- AGENTS_START -->
+<agents_list>
+Core: agent-manager|code-analyzer|file-analyzer|test-runner
+Languages: bash-scripting-expert|javascript-frontend-engineer|nodejs-backend-engineer|python-backend-engineer
+Frameworks: react-frontend-engineer|react-ui-expert
+Testing: e2e-test-engineer|frontend-testing-engineer
+Cloud: aws-cloud-architect|azure-cloud-architect|gcp-cloud-architect
+DevOps: docker-containerization-expert|github-operations-specialist|kubernetes-orchestrator
+Database: bigquery-expert|cosmosdb-expert|mongodb-expert|postgresql-expert|redis-expert
+Data: airflow-orchestration-expert|kedro-pipeline-expert
+Messaging: nats-messaging-expert|message-queue-engineer
+Integration: azure-devops-specialist|gemini-api-expert|openai-python-expert
+Infrastructure: gcp-cloud-functions-engineer|terraform-infrastructure-expert|traefik-proxy-expert
+Monitoring: observability-engineer
+Security: ssh-operations-expert
+Design: ux-design-expert|tailwindcss-expert
+CSS: tailwindcss-expert
+Workflow: langgraph-workflow-expert|parallel-worker
+Management: agent-manager|mcp-manager
+Context: mcp-context-manager
+
+📖 Full registry: .claude/agents/AGENT-REGISTRY.md
+</agents_list>
+<!-- AGENTS_END -->
+
+<!-- WORKFLOW_SECTION -->
+
+<!-- CICD_SECTION -->
+
+## ⚡ PERFORMANCE OPTIMIZATIONS
+
+<performance>
+<token_efficiency>
+- Load files on-demand, not upfront
+- Use compressed formats (pipe-separated lists)
+- Reference external files instead of embedding
+- Progressive workflow loading
+</token_efficiency>
+
+<context_preservation>
+- Agent responses: <20% of input data
+- File analysis: Summary only, not full content
+- Test output: Failures only, not all results
+- Log analysis: Errors + patterns, not raw logs
+</context_preservation>
+</performance>
+
+## 🎯 WHEN TO LOAD FULL DOCUMENTATION
+
+<load_conditions>
+<condition trigger="Starting new task">
+Load: .claude/workflows/standard-task-workflow.md
+</condition>
+
+<condition trigger="Agent invocation @[agent]">
+Load: .claude/agents/[category]/[agent].md
+</condition>
+
+<condition trigger="Rule violation OR uncertainty">
+Load: .claude/rules/[specific-rule].md
+</condition>
+
+<condition trigger="Complex multi-step task">
+Load: .claude/quick-ref/common-patterns.md
+</condition>
+</load_conditions>
+
+## 📖 EXAMPLE: LAZY LOADING IN ACTION
+
+<example>
+<scenario>User: "Implement user authentication"</scenario>
+
+<step1>Check QUICK REFERENCE for workflow</step1>
+<step2>Trigger: "@python-backend-engineer" → Load agent file</step2>
+<step3>Trigger: "TDD" → Load .claude/quick-ref/tdd-cycle.md</step3>
+<step4>Trigger: "Context7" → Query mcp://context7/fastapi/authentication</step4>
+<step5>Execute: TDD cycle with agent assistance</step5>
+
+<result>
+Tokens loaded: ~3,000 (vs ~20,000 in old system)
+Savings: 85%
+</result>
+</example>
+
+## 🔧 COMMIT CHECKLIST (Compressed)
+
+<before_commit>
+✓ Tests: RED→GREEN→REFACTOR sequence
+✓ Lint: black|prettier|eslint passed
+✓ Format: Applied + verified
+✓ Type: mypy|tsc passed
+✓ Coverage: 100% for new code
+✓ Commits: test→feat→refactor sequence
+</before_commit>
+
+## 📝 TONE & BEHAVIOR (Compressed)
+
+<behavior>
+Concise|Skeptical|Factual|No flattery|Ask when uncertain
+Welcome criticism|Suggest better approaches|Reference standards
+</behavior>
+
+## 🚫 ABSOLUTE PROHIBITIONS
+
+<prohibited>
+❌ Code without tests
+❌ Partial implementations
+❌ "TODO: add tests later"
+❌ WIP commits
+❌ Direct commits to main
+❌ Mock services (use real)
+❌ Skipping refactor phase
+</prohibited>
+
+## 📚 ADDITIONAL RESOURCES
+
+<resources>
+Checklists: .claude/checklists/
+Examples: .claude/examples/
+Templates: .claude/templates/
+Strategies: .claude/strategies/
+</resources>
+
+---
+
+**Token Count: ~2,100 tokens (vs ~20,000 old system)**
+**Savings: 89.5%**

package/autopm/.claude/templates/claude-templates/base.md

@@ -118,26 +118,78 @@ Use for coordinating multiple work streams in parallel.
 
 <!-- CICD_SECTION -->
 
-## TDD PIPELINE FOR ALL IMPLEMENTATIONS
+## 🚨 TDD PIPELINE FOR ALL IMPLEMENTATIONS (HIGHEST PRIORITY)
+
+```
+╔═══════════════════════════════════════════════════════════════════╗
+║  🔴 RED → ✅ GREEN → ♻️ REFACTOR                                   ║
+║                                                                   ║
+║  ZERO TOLERANCE: No code without tests. No exceptions.           ║
+║  See: .claude/rules/tdd.enforcement.md                           ║
+╚═══════════════════════════════════════════════════════════════════╝
+```
 
 ### Mandatory Test-Driven Development Cycle
 
-Every implementation MUST follow:
+**CRITICAL**: Every implementation MUST follow TDD cycle. This rule has **HIGHEST PRIORITY**.
+
+#### 1. 🔴 RED Phase: Write FAILING Test First
+
+- Write test that describes desired behavior
+- Test **MUST FAIL** initially (run `@test-runner` to confirm)
+- Test must be meaningful (no trivial assertions)
+- **NEVER proceed to code without failing test**
+
+```bash
+# Example workflow:
+touch tests/test_feature.py
+# Write test
+@test-runner run tests/test_feature.py  # MUST SEE RED ❌
+git commit -m "test: add failing test for feature"
+```
+
+#### 2. ✅ GREEN Phase: Write MINIMUM Code to Pass
+
+- Write **MINIMUM** code to pass test
+- Don't add features not required by test
+- Focus on making test green, not perfection
+- Run `@test-runner` to confirm tests pass
 
-1. **RED Phase**: Write failing test first
-   - Test must describe desired behavior
-   - Test MUST fail initially
-   - Test must be meaningful (no trivial assertions)
+```bash
+# Implement feature
+@test-runner run tests/test_feature.py  # MUST SEE GREEN ✅
+git commit -m "feat: implement feature"
+```
+
+#### 3. ♻️ REFACTOR Phase: Improve While Tests Stay Green
+
+- Improve code structure
+- Remove duplication
+- Enhance readability
+- **All tests MUST remain green**
+- Run `@test-runner` after each change
+
+```bash
+# Refactor code
+@test-runner run all tests  # ALL MUST BE GREEN ✅
+git commit -m "refactor: improve feature structure"
+```
+
+### TDD Commit Pattern (MANDATORY)
 
-2. **GREEN Phase**: Make test pass
-   - Write MINIMUM code to pass test
-   - Don't add features not required by test
-   - Focus on making test green, not perfection
+For EVERY feature, you MUST see this commit sequence:
+```bash
+git log --oneline
+# c3d4e5f refactor: improve feature structure  ♻️
+# b2c3d4e feat: implement feature              ✅
+# a1b2c3d test: add failing test for feature  🔴
+```
 
-3. **REFACTOR Phase**: Improve code
-   - Improve structure while tests stay green
-   - Remove duplication
-   - Enhance readability
+**❌ VIOLATIONS (Auto-Reject):**
+- Commits with code but no tests
+- Commits with "WIP" or "TODO: add tests later"
+- Skipping any phase of TDD cycle
+- Tests written after implementation
 
 ## CONTEXT OPTIMIZATION RULES
 

package/autopm/.claude/templates/plugin-manifest-template.xml

@@ -0,0 +1,36 @@
+<!-- Plugin Manifest Template for Token-Optimized CLAUDE.md -->
+<!-- This template generates compressed plugin listings for base-optimized.md -->
+
+<plugins>
+<installed>{{INSTALLED_PLUGINS}}</installed>
+
+<manifest>
+{{PLUGIN_MANIFESTS}}
+</manifest>
+
+<lazy_loading>
+<enabled>true</enabled>
+<triggers>
+  commands: "/[plugin-id]:[command-name]"
+  agents: "@[agent-name]" (from plugin)
+  rules: on-violation or explicit reference
+</triggers>
+</lazy_loading>
+
+<usage>
+Commands: Type /[plugin-id]:[command] to invoke
+Agents: Type @[agent-name] to invoke
+Rules: Automatically loaded when needed
+Files: All available in .claude/plugins/[plugin-id]/
+</usage>
+</plugins>
+
+<!-- Example compressed manifest per plugin -->
+<!--
+<plugin id="core">
+  agents: agent-manager|code-analyzer|test-runner|file-analyzer
+  commands: code-rabbit|prompt|re-init
+  rules: 23 files (on-demand)
+  📖 .claude/plugins/core/
+</plugin>
+-->

package/install/install.js

@@ -765,6 +765,9 @@ See: https://github.com/rafeekpro/ClaudeAutoPM
   getRequiredAddons() {
     const addons = [];
 
+    // ALWAYS include task-workflow (standard workflow for all projects)
+    addons.push('task-workflow');
+
     // Based on scenario/configuration, determine required addons
     if (this.currentConfig) {
       if (this.currentConfig.tools?.docker?.enabled) {
@@ -804,6 +807,7 @@ See: https://github.com/rafeekpro/ClaudeAutoPM
       'docker-agents': 'AGENT_SELECTION_SECTION',
       'devops-agents': 'AGENT_SELECTION_SECTION',
       'minimal-agents': 'AGENT_SELECTION_SECTION',
+      'task-workflow': 'WORKFLOW_SECTION',
       'docker-workflow': 'WORKFLOW_SECTION',
       'devops-workflow': 'WORKFLOW_SECTION',
       'minimal-workflow': 'WORKFLOW_SECTION',
@@ -840,9 +844,86 @@ See: https://github.com/rafeekpro/ClaudeAutoPM
       processedContent = processedContent.replace(regex, value);
     }
 
+    // Generate agent @include directives from installed plugins
+    const agentIncludes = this.generateAgentIncludes();
+    processedContent = processedContent.replace(
+      /<!-- AGENTS_START -->\s*<!-- AGENTS_END -->/,
+      `<!-- AGENTS_START -->\n${agentIncludes}\n<!-- AGENTS_END -->`
+    );
+
     return processedContent;
   }
 
+  generateAgentIncludes() {
+    if (!this.currentConfig?.installedPlugins) {
+      return '';
+    }
+
+    const packagesDir = path.join(this.baseDir, 'packages');
+    const agentsByCategory = {};
+
+    // Collect all agents from installed plugins
+    for (const plugin of this.currentConfig.installedPlugins) {
+      const pluginPath = path.join(packagesDir, plugin.name);
+      const pluginJsonPath = path.join(pluginPath, 'plugin.json');
+
+      if (!fs.existsSync(pluginJsonPath)) {
+        continue;
+      }
+
+      try {
+        const metadata = JSON.parse(fs.readFileSync(pluginJsonPath, 'utf-8'));
+
+        if (metadata.agents && metadata.agents.length > 0) {
+          for (const agent of metadata.agents) {
+            const category = agent.category || 'other';
+
+            if (!agentsByCategory[category]) {
+              agentsByCategory[category] = [];
+            }
+
+            // Build installed path: .claude/agents/{category}/{filename}
+            // agent.file contains the full path like "agents/core/agent-manager.md"
+            // We extract just the filename and use category for the directory
+            const filename = path.basename(agent.file);
+            const installedPath = `.claude/agents/${category}/${filename}`;
+
+            agentsByCategory[category].push({
+              name: agent.name,
+              path: installedPath,
+              description: agent.description
+            });
+          }
+        }
+      } catch (error) {
+        this.printWarning(`Failed to read plugin metadata for ${plugin.name}: ${error.message}`);
+      }
+    }
+
+    // Generate @include directives organized by category
+    const lines = [];
+    const categoryOrder = ['core', 'languages', 'frameworks', 'testing', 'devops', 'cloud', 'databases', 'data', 'ai', 'ml'];
+
+    for (const category of categoryOrder) {
+      if (agentsByCategory[category]) {
+        for (const agent of agentsByCategory[category]) {
+          lines.push(`- @include ${agent.path}`);
+        }
+      }
+    }
+
+    // Add any remaining categories not in the order list
+    for (const category of Object.keys(agentsByCategory)) {
+      if (!categoryOrder.includes(category)) {
+        for (const agent of agentsByCategory[category]) {
+          lines.push(`- @include ${agent.path}`);
+        }
+      }
+    }
+
+    return lines.join('\n');
+  }
+
   async installPlugins() {
     if (!this.currentConfig || !this.currentConfig.plugins) {
       this.printStep('No plugins configured for this scenario');

package/install/plugin-manifest-generator.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+
+/**
+ * Plugin Manifest Generator
+ *
+ * Generates compressed plugin manifests for token-optimized CLAUDE.md
+ * Reduces plugin metadata from thousands of tokens to ~50 tokens per plugin
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const CHARS_PER_TOKEN = 4;
+
+function estimateTokens(text) {
+  const normalized = text.replace(/\s+/g, ' ').trim();
+  return Math.ceil(normalized.length / CHARS_PER_TOKEN);
+}
+
+/**
+ * Generate compressed manifest for a single plugin
+ */
+function generatePluginManifest(pluginData, pluginId) {
+  const agentNames = (pluginData.agents || []).map(a => a.name).join('|');
+  const commandNames = (pluginData.commands || []).map(c => c.name).join('|');
+  const ruleCount = (pluginData.rules || []).length;
+
+  const manifest = `<plugin id="${pluginId}">
+  agents: ${agentNames || 'None'}
+  commands: ${commandNames || 'None'}
+  rules: ${ruleCount} files (on-demand)
+  📖 .claude/plugins/${pluginId}/
+</plugin>`;
+
+  return {
+    manifest,
+    tokens: estimateTokens(manifest),
+    stats: {
+      agents: pluginData.agents?.length || 0,
+      commands: pluginData.commands?.length || 0,
+      rules: ruleCount
+    }
+  };
+}
+
+/**
+ * Generate complete plugins section for CLAUDE.md
+ */
+function generatePluginsSection(installedPlugins, packagesDir) {
+  const manifests = [];
+  const pluginList = [];
+  let totalTokens = 0;
+  let totalFiles = 0;
+
+  installedPlugins.forEach(pluginId => {
+    const pluginPath = path.join(packagesDir, `plugin-${pluginId}`, 'plugin.json');
+
+    if (!fs.existsSync(pluginPath)) {
+      console.warn(`⚠️  Plugin ${pluginId} not found at ${pluginPath}`);
+      return;
+    }
+
+    try {
+      const pluginData = JSON.parse(fs.readFileSync(pluginPath, 'utf-8'));
+      const result = generatePluginManifest(pluginData, pluginId);
+
+      manifests.push(result.manifest);
+      pluginList.push(pluginId);
+      totalTokens += result.tokens;
+      totalFiles += result.stats.agents + result.stats.commands + result.stats.rules;
+
+      console.log(`✅ ${pluginId}: ${result.tokens} tokens (${result.stats.agents} agents, ${result.stats.commands} commands, ${result.stats.rules} rules)`);
+    } catch (error) {
+      console.error(`❌ Error processing ${pluginId}:`, error.message);
+    }
+  });
+
+  const pluginsSection = `<plugins>
+<installed>${pluginList.join('|')}</installed>
+
+<manifest>
+${manifests.join('\n\n')}
+</manifest>
+
+<lazy_loading>
+<enabled>true</enabled>
+<triggers>
+  commands: "/[plugin-id]:[command-name]"
+  agents: "@[agent-name]" (from plugin)
+  rules: on-violation or explicit reference
+</triggers>
+</lazy_loading>
+
+<usage>
+Commands: Type /[plugin-id]:[command] to invoke
+Agents: Type @[agent-name] to invoke
+Rules: Automatically loaded when needed
+Files: All available in .claude/plugins/[plugin-id]/
+</usage>
+</plugins>`;
+
+  return {
+    section: pluginsSection,
+    tokens: estimateTokens(pluginsSection),
+    totalFiles,
+    pluginCount: pluginList.length
+  };
+}
+
+/**
+ * Calculate token savings
+ */
+function calculateSavings(optimizedTokens, totalFiles) {
+  // Estimate: average 600 tokens per agent, 300 per command, 1500 per rule
+  const estimatedOldTokens = totalFiles * 800; // Conservative average
+  const savings = estimatedOldTokens - optimizedTokens;
+  const percent = ((savings / estimatedOldTokens) * 100).toFixed(1);
+
+  return {
+    old: estimatedOldTokens,
+    new: optimizedTokens,
+    saved: savings,
+    percent
+  };
+}
+
+/**
+ * Main function
+ */
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length < 2) {
+    console.log('Usage: node plugin-manifest-generator.js <packages-dir> <plugin1,plugin2,...>');
+    console.log('Example: node plugin-manifest-generator.js ./packages core,pm,cloud');
+    process.exit(1);
+  }
+
+  const packagesDir = path.resolve(args[0]);
+  const pluginIds = args[1].split(',').map(p => p.trim());
+
+  console.log('\n🔧 Plugin Manifest Generator');
+  console.log('='.repeat(70));
+  console.log(`Packages directory: ${packagesDir}`);
+  console.log(`Plugins to process: ${pluginIds.join(', ')}`);
+  console.log('');
+
+  const result = generatePluginsSection(pluginIds, packagesDir);
+
+  console.log('\n' + '='.repeat(70));
+  console.log('📊 Generation Complete');
+  console.log('='.repeat(70));
+  console.log(`Plugins processed: ${result.pluginCount}`);
+  console.log(`Total files: ${result.totalFiles}`);
+  console.log(`Manifest tokens: ${result.tokens}`);
+
+  const savings = calculateSavings(result.tokens, result.totalFiles);
+  console.log(`\n💰 Token Savings:`);
+  console.log(`  Old system (est): ${savings.old.toLocaleString()} tokens`);
+  console.log(`  New manifest: ${savings.new.toLocaleString()} tokens`);
+  console.log(`  Savings: ${savings.saved.toLocaleString()} tokens (${savings.percent}%)`);
+
+  console.log('\n📄 Generated Manifest:');
+  console.log('='.repeat(70));
+  console.log(result.section);
+  console.log('='.repeat(70));
+
+  return result;
+}
+
+// Export for use in other scripts
+module.exports = {
+  generatePluginManifest,
+  generatePluginsSection,
+  calculateSavings,
+  estimateTokens
+};
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}

package/package.json

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