claude-autopm 2.8.1 → 2.8.2

package/lib/plugins/PluginManager.old.js

@@ -0,0 +1,400 @@
+/**
+ * PluginManager - Manages ClaudeAutoPM plugins
+ *
+ * Responsibilities:
+ * - Discover installed plugins in node_modules
+ * - Load and validate plugin metadata
+ * - Install/uninstall plugin agents
+ * - Maintain plugin registry
+ *
+ * @module lib/plugins/PluginManager
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+
+class PluginManager {
+  constructor(options = {}) {
+    this.projectRoot = options.projectRoot || process.cwd();
+    this.pluginsDir = options.pluginsDir || path.join(os.homedir(), '.claudeautopm', 'plugins');
+    this.registryPath = path.join(this.pluginsDir, 'registry.json');
+
+    // Ensure plugins directory exists
+    fs.ensureDirSync(this.pluginsDir);
+
+    // Load or initialize registry
+    this.registry = this.loadRegistry();
+  }
+
+  /**
+   * Load plugin registry from disk
+   * @returns {Object} Plugin registry
+   */
+  loadRegistry() {
+    if (fs.existsSync(this.registryPath)) {
+      try {
+        return JSON.parse(fs.readFileSync(this.registryPath, 'utf-8'));
+      } catch (error) {
+        console.warn('Warning: Failed to load plugin registry, creating new one');
+      }
+    }
+
+    // Default registry structure
+    return {
+      version: '1.0.0',
+      installed: [],
+      enabled: [],
+      lastUpdate: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Save plugin registry to disk
+   */
+  saveRegistry() {
+    this.registry.lastUpdate = new Date().toISOString();
+    fs.writeFileSync(
+      this.registryPath,
+      JSON.stringify(this.registry, null, 2),
+      'utf-8'
+    );
+  }
+
+  /**
+   * Get plugin installation path in node_modules
+   * @param {string} pluginName - Plugin name (e.g., 'plugin-cloud')
+   * @returns {string} Full path to plugin directory
+   */
+  getPluginPath(pluginName) {
+    // Check local node_modules first
+    const localPath = path.join(this.projectRoot, 'node_modules', '@claudeautopm', pluginName);
+    if (fs.existsSync(localPath)) {
+      return localPath;
+    }
+
+    // Check global node_modules
+    const { execSync } = require('child_process');
+    try {
+      const globalModules = execSync('npm root -g', { encoding: 'utf-8' }).trim();
+      const globalPath = path.join(globalModules, '@claudeautopm', pluginName);
+      if (fs.existsSync(globalPath)) {
+        return globalPath;
+      }
+    } catch (error) {
+      // Fall through
+    }
+
+    throw new Error(`Plugin not found: ${pluginName}`);
+  }
+
+  /**
+   * Discover all installed plugins
+   * Scans both local and global node_modules/@claudeautopm/plugin-*
+   * @returns {Array<Object>} Array of plugin metadata
+   */
+  async discoverPlugins() {
+    const plugins = [];
+    const scannedPaths = new Set();
+
+    // Scan local node_modules
+    const localModules = path.join(this.projectRoot, 'node_modules', '@claudeautopm');
+    if (fs.existsSync(localModules)) {
+      const dirs = fs.readdirSync(localModules);
+      for (const dir of dirs) {
+        if (dir.startsWith('plugin-')) {
+          const pluginPath = path.join(localModules, dir);
+          scannedPaths.add(pluginPath);
+        }
+      }
+    }
+
+    // Scan global node_modules
+    try {
+      const { execSync } = require('child_process');
+      const globalModules = execSync('npm root -g', { encoding: 'utf-8' }).trim();
+      const globalClaudeAutopm = path.join(globalModules, '@claudeautopm');
+
+      if (fs.existsSync(globalClaudeAutopm)) {
+        const dirs = fs.readdirSync(globalClaudeAutopm);
+        for (const dir of dirs) {
+          if (dir.startsWith('plugin-')) {
+            const pluginPath = path.join(globalClaudeAutopm, dir);
+            scannedPaths.add(pluginPath);
+          }
+        }
+      }
+    } catch (error) {
+      // Global modules not accessible, skip
+    }
+
+    // Load metadata for each discovered plugin
+    for (const pluginPath of scannedPaths) {
+      try {
+        const pluginName = path.basename(pluginPath);
+        const metadata = await this.loadPluginMetadata(pluginName);
+        if (metadata) {
+          plugins.push(metadata);
+        }
+      } catch (error) {
+        console.warn(`Warning: Failed to load plugin metadata from ${pluginPath}: ${error.message}`);
+      }
+    }
+
+    return plugins;
+  }
+
+  /**
+   * Load plugin metadata from plugin.json
+   * @param {string} pluginName - Plugin name (e.g., 'plugin-cloud')
+   * @returns {Object} Plugin metadata
+   */
+  async loadPluginMetadata(pluginName) {
+    const pluginPath = this.getPluginPath(pluginName);
+    const metadataPath = path.join(pluginPath, 'plugin.json');
+
+    if (!fs.existsSync(metadataPath)) {
+      throw new Error(`Plugin metadata not found: ${metadataPath}`);
+    }
+
+    const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
+
+    // Validate metadata
+    this.validateMetadata(metadata);
+
+    // Add computed properties
+    metadata.path = pluginPath;
+    metadata.pluginName = pluginName;
+
+    return metadata;
+  }
+
+  /**
+   * Validate plugin metadata schema
+   * @param {Object} metadata - Plugin metadata to validate
+   * @throws {Error} If metadata is invalid
+   */
+  validateMetadata(metadata) {
+    const required = ['name', 'version', 'displayName', 'description', 'category', 'agents'];
+
+    for (const field of required) {
+      if (!metadata[field]) {
+        throw new Error(`Plugin metadata missing required field: ${field}`);
+      }
+    }
+
+    if (!Array.isArray(metadata.agents)) {
+      throw new Error('Plugin metadata "agents" must be an array');
+    }
+
+    // Validate each agent
+    for (const agent of metadata.agents) {
+      if (!agent.name || !agent.file || !agent.description) {
+        throw new Error('Agent metadata must have name, file, and description');
+      }
+    }
+  }
+
+  /**
+   * Install plugin agents to .claude/agents/
+   * @param {string} pluginName - Plugin name (e.g., 'plugin-cloud')
+   * @returns {Object} Installation result
+   */
+  async installPlugin(pluginName) {
+    const metadata = await this.loadPluginMetadata(pluginName);
+    const pluginPath = this.getPluginPath(pluginName);
+    const targetDir = path.join(this.projectRoot, '.claude', 'agents', metadata.category);
+
+    // Create category directory
+    fs.ensureDirSync(targetDir);
+
+    const installedAgents = [];
+
+    // Copy agents
+    for (const agent of metadata.agents) {
+      const sourcePath = path.join(pluginPath, agent.file);
+      const targetPath = path.join(targetDir, path.basename(agent.file));
+
+      if (!fs.existsSync(sourcePath)) {
+        console.warn(`Warning: Agent file not found: ${sourcePath}`);
+        continue;
+      }
+
+      fs.copyFileSync(sourcePath, targetPath);
+      installedAgents.push({
+        name: agent.name,
+        file: targetPath,
+        description: agent.description
+      });
+    }
+
+    // Update registry
+    if (!this.registry.installed.includes(pluginName)) {
+      this.registry.installed.push(pluginName);
+    }
+    if (!this.registry.enabled.includes(pluginName)) {
+      this.registry.enabled.push(pluginName);
+    }
+    this.saveRegistry();
+
+    return {
+      success: true,
+      pluginName,
+      displayName: metadata.displayName,
+      category: metadata.category,
+      agentsInstalled: installedAgents.length,
+      agents: installedAgents
+    };
+  }
+
+  /**
+   * Uninstall plugin - remove agents and update registry
+   * @param {string} pluginName - Plugin name (e.g., 'plugin-cloud')
+   * @returns {Object} Uninstallation result
+   */
+  async uninstallPlugin(pluginName) {
+    const metadata = await this.loadPluginMetadata(pluginName);
+    const targetDir = path.join(this.projectRoot, '.claude', 'agents', metadata.category);
+
+    const removedAgents = [];
+
+    // Remove agents
+    for (const agent of metadata.agents) {
+      const targetPath = path.join(targetDir, path.basename(agent.file));
+      if (fs.existsSync(targetPath)) {
+        fs.unlinkSync(targetPath);
+        removedAgents.push(agent.name);
+      }
+    }
+
+    // Remove empty category directory
+    if (fs.existsSync(targetDir) && fs.readdirSync(targetDir).length === 0) {
+      fs.rmdirSync(targetDir);
+    }
+
+    // Update registry
+    this.registry.installed = this.registry.installed.filter(p => p !== pluginName);
+    this.registry.enabled = this.registry.enabled.filter(p => p !== pluginName);
+    this.saveRegistry();
+
+    return {
+      success: true,
+      pluginName,
+      agentsRemoved: removedAgents.length,
+      agents: removedAgents
+    };
+  }
+
+  /**
+   * Get list of installed plugins
+   * @returns {Array<string>} Array of plugin names
+   */
+  getInstalledPlugins() {
+    return this.registry.installed;
+  }
+
+  /**
+   * Get list of enabled plugins
+   * @returns {Array<string>} Array of plugin names
+   */
+  getEnabledPlugins() {
+    return this.registry.enabled;
+  }
+
+  /**
+   * Enable plugin
+   * @param {string} pluginName - Plugin name
+   */
+  enablePlugin(pluginName) {
+    if (!this.registry.installed.includes(pluginName)) {
+      throw new Error(`Plugin not installed: ${pluginName}`);
+    }
+    if (!this.registry.enabled.includes(pluginName)) {
+      this.registry.enabled.push(pluginName);
+      this.saveRegistry();
+    }
+  }
+
+  /**
+   * Disable plugin
+   * @param {string} pluginName - Plugin name
+   */
+  disablePlugin(pluginName) {
+    this.registry.enabled = this.registry.enabled.filter(p => p !== pluginName);
+    this.saveRegistry();
+  }
+
+  /**
+   * Check if plugin is installed
+   * @param {string} pluginName - Plugin name
+   * @returns {boolean} True if installed
+   */
+  isInstalled(pluginName) {
+    return this.registry.installed.includes(pluginName);
+  }
+
+  /**
+   * Check if plugin is enabled
+   * @param {string} pluginName - Plugin name
+   * @returns {boolean} True if enabled
+   */
+  isEnabled(pluginName) {
+    return this.registry.enabled.includes(pluginName);
+  }
+
+  /**
+   * Search plugins by keyword
+   * @param {string} keyword - Search keyword
+   * @returns {Array<Object>} Matching plugins
+   */
+  async searchPlugins(keyword) {
+    const allPlugins = await this.discoverPlugins();
+    const lowerKeyword = keyword.toLowerCase();
+
+    return allPlugins.filter(plugin => {
+      // Search in name
+      if (plugin.name.toLowerCase().includes(lowerKeyword)) {
+        return true;
+      }
+
+      // Search in display name
+      if (plugin.displayName.toLowerCase().includes(lowerKeyword)) {
+        return true;
+      }
+
+      // Search in description
+      if (plugin.description.toLowerCase().includes(lowerKeyword)) {
+        return true;
+      }
+
+      // Search in keywords
+      if (plugin.keywords && plugin.keywords.some(k => k.toLowerCase().includes(lowerKeyword))) {
+        return true;
+      }
+
+      // Search in agent names
+      if (plugin.agents.some(a => a.name.toLowerCase().includes(lowerKeyword))) {
+        return true;
+      }
+
+      return false;
+    });
+  }
+
+  /**
+   * Get plugin info
+   * @param {string} pluginName - Plugin name
+   * @returns {Object} Plugin metadata with status
+   */
+  async getPluginInfo(pluginName) {
+    const metadata = await this.loadPluginMetadata(pluginName);
+
+    return {
+      ...metadata,
+      installed: this.isInstalled(pluginName),
+      enabled: this.isEnabled(pluginName)
+    };
+  }
+}
+
+module.exports = PluginManager;

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "claude-autopm",
-  "version": "2.8.1",
+  "version": "2.8.2",
   "description": "Autonomous Project Management Framework for Claude Code - Advanced AI-powered development automation",
   "main": "bin/autopm.js",
+  "workspaces": [
+    "packages/*"
+  ],
   "bin": {
     "autopm": "./bin/autopm.js",
     "autopm-poc": "./bin/autopm-poc.js"

package/scripts/publish-plugins.sh

@@ -0,0 +1,166 @@
+#!/bin/bash
+# Publish all ClaudeAutoPM plugins to npm
+# Usage: ./scripts/publish-plugins.sh [--dry-run]
+
+set -e  # Exit on error
+
+DRY_RUN=false
+if [ "$1" = "--dry-run" ]; then
+  DRY_RUN=true
+  echo "🧪 DRY RUN MODE - No actual publishing"
+  echo ""
+fi
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Check npm login
+echo -e "${BLUE}📋 Pre-flight Checks${NC}"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""
+
+echo -n "Checking npm authentication... "
+if ! npm whoami &>/dev/null; then
+  echo -e "${RED}✗ Not logged in${NC}"
+  echo ""
+  echo "Please run: npm login"
+  exit 1
+fi
+echo -e "${GREEN}✓ Logged in as $(npm whoami)${NC}"
+
+# Check if we're in the right directory
+if [ ! -d "packages" ]; then
+  echo -e "${RED}✗ packages/ directory not found${NC}"
+  echo "Please run this script from the AUTOPM root directory"
+  exit 1
+fi
+
+# Count plugins
+PLUGIN_COUNT=$(find packages -name "plugin-*" -type d | wc -l | tr -d ' ')
+echo -e "Found ${GREEN}$PLUGIN_COUNT${NC} plugins to publish"
+echo ""
+
+# List plugins
+echo -e "${BLUE}📦 Plugins to Publish${NC}"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""
+
+for plugin_dir in packages/plugin-*; do
+  plugin_name=$(basename "$plugin_dir")
+  package_name=$(grep '"name"' "$plugin_dir/package.json" | head -1 | sed 's/.*: *"\([^"]*\)".*/\1/')
+  version=$(grep '"version"' "$plugin_dir/package.json" | head -1 | sed 's/.*: *"\([^"]*\)".*/\1/')
+  agent_count=$(find "$plugin_dir/agents" -name "*.md" -not -name "README.md" | wc -l | tr -d ' ')
+
+  echo "  • $package_name@$version ($agent_count agents)"
+done
+echo ""
+
+# Confirm before proceeding
+if [ "$DRY_RUN" = false ]; then
+  echo -e "${YELLOW}⚠️  This will publish $PLUGIN_COUNT packages to npm${NC}"
+  read -p "Continue? (yes/no) " -r
+  echo ""
+  if [[ ! $REPLY =~ ^[Yy](es)?$ ]]; then
+    echo "Cancelled."
+    exit 0
+  fi
+fi
+
+# Publish each plugin
+echo -e "${BLUE}🚀 Publishing Plugins${NC}"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""
+
+SUCCESS_COUNT=0
+FAIL_COUNT=0
+FAILED_PLUGINS=()
+
+for plugin_dir in packages/plugin-*; do
+  plugin_name=$(basename "$plugin_dir")
+  package_name=$(grep '"name"' "$plugin_dir/package.json" | head -1 | sed 's/.*: *"\([^"]*\)".*/\1/')
+  version=$(grep '"version"' "$plugin_dir/package.json" | head -1 | sed 's/.*: *"\([^"]*\)".*/\1/')
+
+  echo -e "${BLUE}Publishing:${NC} $package_name@$version"
+
+  # Change to plugin directory
+  cd "$plugin_dir"
+
+  # Publish
+  if [ "$DRY_RUN" = true ]; then
+    # Dry run
+    if npm publish --dry-run --access public > /tmp/npm-publish.log 2>&1; then
+      echo -e "  ${GREEN}✓ Dry run successful${NC}"
+      ((SUCCESS_COUNT++))
+    else
+      echo -e "  ${RED}✗ Dry run failed${NC}"
+      cat /tmp/npm-publish.log
+      ((FAIL_COUNT++))
+      FAILED_PLUGINS+=("$package_name")
+    fi
+  else
+    # Actual publish
+    if npm publish --access public 2>&1 | tee /tmp/npm-publish.log; then
+      echo -e "  ${GREEN}✓ Published successfully${NC}"
+      ((SUCCESS_COUNT++))
+
+      # Verify
+      sleep 2
+      if npm view "$package_name@$version" > /dev/null 2>&1; then
+        echo -e "  ${GREEN}✓ Verified on npm registry${NC}"
+      else
+        echo -e "  ${YELLOW}⚠ Published but not yet visible on registry (may take a moment)${NC}"
+      fi
+    else
+      echo -e "  ${RED}✗ Publish failed${NC}"
+      cat /tmp/npm-publish.log
+      ((FAIL_COUNT++))
+      FAILED_PLUGINS+=("$package_name")
+    fi
+  fi
+
+  echo ""
+
+  # Return to root
+  cd - > /dev/null
+done
+
+# Summary
+echo ""
+echo -e "${BLUE}📊 Summary${NC}"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""
+echo -e "Total plugins:    $PLUGIN_COUNT"
+echo -e "${GREEN}Successful:       $SUCCESS_COUNT${NC}"
+
+if [ $FAIL_COUNT -gt 0 ]; then
+  echo -e "${RED}Failed:           $FAIL_COUNT${NC}"
+  echo ""
+  echo -e "${RED}Failed plugins:${NC}"
+  for failed in "${FAILED_PLUGINS[@]}"; do
+    echo "  • $failed"
+  done
+  echo ""
+  exit 1
+else
+  echo -e "${RED}Failed:           0${NC}"
+  echo ""
+
+  if [ "$DRY_RUN" = false ]; then
+    echo -e "${GREEN}🎉 All plugins published successfully!${NC}"
+    echo ""
+    echo "Next steps:"
+    echo "  1. Verify on npm: https://www.npmjs.com/org/claudeautopm"
+    echo "  2. Test installation: npm install -g @claudeautopm/plugin-cloud"
+    echo "  3. Update CHANGELOG.md"
+    echo "  4. Tag release: git tag v2.8.1 && git push origin v2.8.1"
+  else
+    echo -e "${GREEN}🎉 All dry runs successful!${NC}"
+    echo ""
+    echo "Ready to publish for real:"
+    echo "  ./scripts/publish-plugins.sh"
+  fi
+fi

package/autopm/.claude/agents/cloud/README.md

@@ -1,55 +0,0 @@
-# Cloud & Infrastructure Agents
-
-Specialized agents for cloud platforms and infrastructure management. These agents understand cloud services, IaC patterns, and cost optimization.
-
-## Available Agents
-
-### ☁️ aws-cloud-architect
-- **Services**: EC2, Lambda, EKS, RDS, S3
-- **IaC**: CloudFormation, CDK, Terraform
-- **Features**: Cost optimization, security best practices
-
-### 🔷 azure-cloud-architect
-- **Services**: AKS, App Service, Functions, CosmosDB
-- **IaC**: ARM Templates, Bicep, Terraform
-- **Features**: Azure AD integration, hybrid cloud
-
-### 🔵 gcp-cloud-architect
-- **Services**: GKE, Cloud Run, Functions, BigQuery
-- **IaC**: Deployment Manager, Terraform
-- **Features**: AI/ML services, data analytics
-
-### ☸️ kubernetes-orchestrator
-- **Expertise**: K8s manifests, Helm charts, operators
-- **GitOps**: ArgoCD, Flux, Kustomize
-- **Features**: Service mesh, monitoring, scaling
-
-### ☁️ gcp-cloud-functions-engineer
-- **Expertise**: Serverless functions on GCP, event-driven architecture
-- **Runtimes**: Python, Node.js, Go for Cloud Functions
-- **Features**: Pub/Sub triggers, Firestore events, HTTP functions
-- **Integration**: GCP services, Secret Manager, Cloud Build
-
-## Planned Agents
-
-### 🔧 terraform-infrastructure-engineer
-- **Expertise**: Terraform, Terragrunt, modules
-- **Providers**: Multi-cloud support
-- **Features**: State management, drift detection
-
-### 📦 docker-container-engineer
-- **Expertise**: Docker, Compose, multi-stage builds
-- **Registries**: DockerHub, ECR, ACR, GCR
-- **Security**: Image scanning, best practices
-
-### 🌐 cdn-edge-engineer
-- **Expertise**: CloudFlare, Fastly, Akamai
-- **Features**: Edge functions, caching, WAF
-
-## Cloud Best Practices
-
-All cloud agents follow:
-1. **Security First**: IAM, encryption, network isolation
-2. **Cost Optimization**: Right-sizing, spot instances, reserved capacity
-3. **High Availability**: Multi-AZ, load balancing, auto-scaling
-4. **IaC**: Everything as code, version controlled