claude-autopm 2.8.9 → 2.11.1

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/bin/commands/plugin.js

@@ -24,7 +24,7 @@ module.exports = {
       .positional('action', {
         describe: 'Plugin action to perform',
         type: 'string',
-        choices: ['list', 'search', 'install', 'uninstall', 'info', 'enable', 'disable']
+        choices: ['list', 'search', 'install', 'uninstall', 'update', 'info', 'enable', 'disable']
       })
       .positional('name', {
         describe: 'Plugin name (without @claudeautopm/plugin- prefix)',
@@ -40,6 +40,8 @@ module.exports = {
       .example('autopm plugin search cloud', 'Search for cloud-related plugins')
       .example('autopm plugin install cloud', 'Install cloud plugin')
       .example('autopm plugin uninstall cloud', 'Remove cloud plugin')
+      .example('autopm plugin update', 'Update all installed plugins')
+      .example('autopm plugin update cloud devops', 'Update specific plugins')
       .example('autopm plugin info cloud', 'Show cloud plugin details')
       .epilogue(`
 📦 Plugin Management
@@ -121,6 +123,12 @@ Usage:
           }
           await handleDisable(manager, argv.name, argv);
           break;
+        case 'update':
+          // argv.name is optional - if not provided, update all
+          // argv._ contains additional arguments after the command
+          const pluginsToUpdate = argv.name ? [argv.name, ...(argv._.slice(3) || [])] : null;
+          await handleUpdate(manager, pluginsToUpdate, argv);
+          break;
         default:
           console.error(chalk.red(`Unknown action: ${argv.action}`));
           process.exit(1);
@@ -393,3 +401,120 @@ async function handleDisable(manager, pluginName, argv) {
   console.log(chalk.gray('Note: Agents remain in .claude/agents/ but plugin is marked as disabled'));
   console.log('');
 }
+
+/**
+ * Handle 'update' command
+ */
+async function handleUpdate(manager, pluginNames, argv) {
+  console.log(chalk.bold('\n🔄 Updating Plugins\n'));
+
+  // Get list of installed plugins
+  const installed = manager.getInstalledPlugins();
+
+  if (installed.length === 0) {
+    console.log(chalk.yellow('No plugins installed to update.'));
+    console.log('');
+    return;
+  }
+
+  // Determine which plugins to update
+  let toUpdate = [];
+  if (pluginNames && pluginNames.length > 0) {
+    // Update specific plugins
+    for (const name of pluginNames) {
+      const fullName = name.startsWith('plugin-') ? name : `plugin-${name}`;
+      if (!installed.includes(fullName)) {
+        console.log(chalk.yellow(`⚠ Plugin ${name} is not installed, skipping`));
+      } else {
+        toUpdate.push(fullName);
+      }
+    }
+  } else {
+    // Update all installed plugins
+    toUpdate = installed;
+    console.log(chalk.gray(`Updating all ${installed.length} installed plugin(s)...\n`));
+  }
+
+  if (toUpdate.length === 0) {
+    console.log(chalk.yellow('No plugins to update.'));
+    console.log('');
+    return;
+  }
+
+  const results = {
+    updated: [],
+    failed: [],
+    skipped: [],
+    upToDate: []
+  };
+
+  // Update each plugin
+  for (const pluginName of toUpdate) {
+    const shortName = pluginName.replace('plugin-', '');
+
+    try {
+      console.log(chalk.bold(`\n📦 Updating ${shortName}...`));
+
+      const result = await manager.updatePlugin(pluginName, {
+        verbose: argv.verbose,
+        force: argv.force
+      });
+
+      if (result.updated) {
+        results.updated.push({
+          name: shortName,
+          oldVersion: result.oldVersion,
+          newVersion: result.newVersion,
+          stats: result.stats
+        });
+        console.log(chalk.green(`✅ Updated ${shortName} (${result.oldVersion} → ${result.newVersion})`));
+
+        if (argv.verbose && result.stats) {
+          console.log(chalk.gray(`   Agents: ${result.stats.agents || 0}, Commands: ${result.stats.commands || 0}, Rules: ${result.stats.rules || 0}`));
+        }
+      } else if (result.upToDate) {
+        results.upToDate.push(shortName);
+        console.log(chalk.gray(`✓ ${shortName} is already up to date (${result.currentVersion})`));
+      } else {
+        results.skipped.push(shortName);
+        console.log(chalk.yellow(`⚠ Skipped ${shortName}: ${result.reason || 'Unknown reason'}`));
+      }
+    } catch (error) {
+      results.failed.push({ name: shortName, error: error.message });
+      console.log(chalk.red(`✗ Failed to update ${shortName}: ${error.message}`));
+
+      if (argv.verbose) {
+        console.error(chalk.red(error.stack));
+      }
+    }
+  }
+
+  // Summary
+  console.log(chalk.bold('\n📊 Update Summary\n'));
+  console.log(`${chalk.green('✅ Updated:')} ${results.updated.length}`);
+  console.log(`${chalk.gray('✓ Up to date:')} ${results.upToDate.length}`);
+  console.log(`${chalk.yellow('⚠ Skipped:')} ${results.skipped.length}`);
+  console.log(`${chalk.red('✗ Failed:')} ${results.failed.length}`);
+  console.log('');
+
+  if (results.updated.length > 0) {
+    console.log(chalk.bold('Updated Plugins:'));
+    for (const plugin of results.updated) {
+      console.log(`  • ${plugin.name} (${plugin.oldVersion} → ${plugin.newVersion})`);
+    }
+    console.log('');
+  }
+
+  if (results.failed.length > 0) {
+    console.log(chalk.bold(chalk.red('Failed Updates:')));
+    for (const plugin of results.failed) {
+      console.log(chalk.red(`  • ${plugin.name}: ${plugin.error}`));
+    }
+    console.log('');
+  }
+
+  // Exit with error if any updates failed
+  if (results.failed.length > 0) {
+    process.exit(1);
+  }
+}

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',