claude-autopm 1.31.0 → 2.1.1

package/lib/utils/ServiceFactory.js

@@ -0,0 +1,165 @@
+/**
+ * @fileoverview ServiceFactory - Creates services with ConfigManager integration
+ *
+ * Provides factory methods for creating AutoPM services with:
+ * - Automatic provider creation from ConfigManager
+ * - Centralized configuration management
+ * - Simplified service instantiation
+ *
+ * @example
+ * const factory = new ServiceFactory(configManager);
+ * const prdService = factory.createPRDService();
+ * const epicService = factory.createEpicService();
+ */
+
+const ConfigManager = require('../config/ConfigManager');
+
+/**
+ * ServiceFactory - Creates services with ConfigManager integration
+ */
+class ServiceFactory {
+  /**
+   * Create a ServiceFactory instance
+   *
+   * @param {ConfigManager} configManager - ConfigManager instance
+   * @throws {Error} If configManager is not provided or invalid
+   */
+  constructor(configManager) {
+    if (!configManager) {
+      throw new Error('ConfigManager instance is required');
+    }
+
+    if (!(configManager instanceof ConfigManager)) {
+      throw new Error('configManager must be an instance of ConfigManager');
+    }
+
+    this.configManager = configManager;
+  }
+
+  /**
+   * Create AI provider from ConfigManager
+   *
+   * @param {string} [providerName] - Provider name (defaults to defaultProvider)
+   * @returns {Object} Provider instance
+   * @throws {Error} If provider creation fails
+   *
+   * @example
+   * const provider = factory.createProvider(); // Uses default provider
+   * const provider = factory.createProvider('openai'); // Specific provider
+   */
+  createProvider(providerName = null) {
+    // Check master password
+    if (!this.configManager.hasMasterPassword()) {
+      throw new Error('Master password not set. Call configManager.setMasterPassword() first.');
+    }
+
+    // Get provider name (default if not specified)
+    const name = providerName || this.configManager.getDefaultProvider();
+
+    // Get provider config first to validate provider exists
+    const config = this.configManager.getProvider(name);
+    if (!config) {
+      throw new Error(`Provider configuration not found: ${name}`);
+    }
+
+    // Validate configuration before attempting to get API key
+    try {
+      this.configManager.validateProvider(config);
+    } catch (error) {
+      throw new Error(`Invalid configuration for provider '${name}': ${error.message}`);
+    }
+
+    // Get API key
+    const apiKey = this.configManager.getApiKey(name);
+    if (!apiKey) {
+      throw new Error(`API key not found for provider: ${name}`);
+    }
+
+    // Create provider based on name
+    if (name === 'claude') {
+      const ClaudeProvider = require('../ai-providers/ClaudeProvider');
+      return new ClaudeProvider({ apiKey, ...config });
+    }
+
+    throw new Error(`Unknown provider: ${name}`);
+  }
+
+  /**
+   * Create PRDService instance
+   *
+   * @param {Object} [options] - Service options
+   * @param {Object} [options.provider] - Custom provider (overrides ConfigManager)
+   * @param {number} [options.defaultEffortHours] - Default effort hours
+   * @param {number} [options.hoursPerDay] - Hours per day
+   * @param {number} [options.hoursPerWeek] - Hours per week
+   * @returns {PRDService} PRDService instance
+   *
+   * @example
+   * const service = factory.createPRDService();
+   * const service = factory.createPRDService({ defaultEffortHours: 10 });
+   */
+  createPRDService(options = {}) {
+    const PRDService = require('../services/PRDService');
+
+    // Create provider if not provided
+    const provider = options.provider || this.createProvider();
+
+    return new PRDService({
+      provider,
+      configManager: this.configManager,
+      ...options
+    });
+  }
+
+  /**
+   * Create EpicService instance
+   *
+   * @param {Object} [options] - Service options
+   * @param {PRDService} [options.prdService] - Custom PRDService (overrides auto-creation)
+   * @returns {EpicService} EpicService instance
+   *
+   * @example
+   * const service = factory.createEpicService();
+   * const service = factory.createEpicService({ prdService: customPrdService });
+   */
+  createEpicService(options = {}) {
+    const EpicService = require('../services/EpicService');
+
+    // Create PRDService if not provided
+    const prdService = options.prdService || this.createPRDService();
+
+    return new EpicService({
+      prdService,
+      configManager: this.configManager,
+      ...options
+    });
+  }
+
+  /**
+   * Create TaskService instance
+   *
+   * @param {Object} [options] - Service options
+   * @param {PRDService} [options.prdService] - Custom PRDService (overrides auto-creation)
+   * @param {string} [options.defaultTaskType] - Default task type
+   * @param {string} [options.defaultEffort] - Default effort
+   * @returns {TaskService} TaskService instance
+   *
+   * @example
+   * const service = factory.createTaskService();
+   * const service = factory.createTaskService({ defaultTaskType: 'testing' });
+   */
+  createTaskService(options = {}) {
+    const TaskService = require('../services/TaskService');
+
+    // Create PRDService if not provided
+    const prdService = options.prdService || this.createPRDService();
+
+    return new TaskService({
+      prdService,
+      configManager: this.configManager,
+      ...options
+    });
+  }
+}
+
+module.exports = ServiceFactory;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-autopm",
-  "version": "1.31.0",
+  "version": "2.1.1",
   "description": "Autonomous Project Management Framework for Claude Code - Advanced AI-powered development automation",
   "main": "bin/autopm.js",
   "bin": {
@@ -116,11 +116,11 @@
     "README.md"
   ],
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.32.1",
+    "@anthropic-ai/sdk": "^0.65.0",
     "@octokit/rest": "^22.0.0",
     "azure-devops-node-api": "^15.1.1",
-    "chalk": "^5.3.0",
-    "dotenv": "^16.6.1",
+    "chalk": "4.1.2",
+    "dotenv": "^17.2.3",
     "execa": "^9.6.0",
     "fast-glob": "^3.3.2",
     "fs-extra": "^11.3.2",
@@ -128,6 +128,7 @@
     "inquirer": "^12.9.6",
     "js-yaml": "^4.1.0",
     "markdown-it": "^14.1.0",
+    "marked": "^16.4.0",
     "moment": "^2.29.4",
     "ora": "^5.4.1",
     "simple-git": "^3.20.0",
@@ -155,7 +156,7 @@
     "sinon": "^21.0.0"
   },
   "optionalDependencies": {
-    "@playwright/mcp": "^0.0.41",
+    "@playwright/mcp": "^0.0.42",
     "@upstash/context7-mcp": "^1.0.0"
   },
   "publishConfig": {

package/scripts/config/get.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+/**
+ * @fileoverview Config command: get
+ * Get configuration value with dot notation support
+ *
+ * Usage: autopm config:get <key>
+ * Example: autopm config:get providers.claude.model
+ */
+
+const path = require('path');
+const os = require('os');
+const ConfigManager = require('../../lib/config/ConfigManager');
+
+// Default config path
+const DEFAULT_CONFIG_PATH = path.join(os.homedir(), '.autopm', 'config.json');
+
+/**
+ * Mask sensitive API key data
+ * @param {*} value - Value to potentially mask
+ * @returns {*} Masked value or original value
+ */
+function maskSensitiveData(value) {
+  if (value && typeof value === 'object') {
+    if ('iv' in value && 'encryptedData' in value) {
+      // This is an encrypted API key
+      return '***encrypted***';
+    }
+
+    // Recursively mask object properties
+    const masked = {};
+    for (const [key, val] of Object.entries(value)) {
+      masked[key] = maskSensitiveData(val);
+    }
+    return masked;
+  }
+
+  return value;
+}
+
+/**
+ * Format output value
+ * @param {*} value - Value to format
+ * @returns {string} Formatted output
+ */
+function formatOutput(value) {
+  if (value === null || value === undefined) {
+    return 'null';
+  }
+
+  if (typeof value === 'object') {
+    // Mask sensitive data before printing
+    const masked = maskSensitiveData(value);
+    return JSON.stringify(masked, null, 2);
+  }
+
+  return String(value);
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  try {
+    const configPath = process.env.AUTOPM_CONFIG_PATH || DEFAULT_CONFIG_PATH;
+
+    // Get key from command line arguments
+    const key = process.argv[2];
+
+    if (!key) {
+      console.error('Error: Key is required');
+      console.error('Usage: autopm config:get <key>');
+      console.error('Example: autopm config:get providers.claude.model');
+      process.exit(1);
+    }
+
+    // Check if config exists
+    const fs = require('fs');
+    if (!fs.existsSync(configPath)) {
+      console.error('Error: Configuration not found');
+      console.error('Run: autopm config:init');
+      process.exit(1);
+    }
+
+    // Load configuration
+    const manager = new ConfigManager(configPath);
+
+    // Get value
+    const value = manager.getConfig(key);
+
+    // Output formatted value
+    console.log(formatOutput(value));
+
+  } catch (error) {
+    if (error.message.includes('Unexpected token') || error.message.includes('JSON')) {
+      console.error('Error reading config: Invalid JSON format');
+    } else {
+      console.error('Error:', error.message);
+    }
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = main;

package/scripts/config/init.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+/**
+ * @fileoverview Config command: init
+ * Initialize configuration with interactive prompts for master password
+ *
+ * Usage: autopm config:init
+ */
+
+const path = require('path');
+const os = require('os');
+const { password } = require('@inquirer/prompts');
+const ConfigManager = require('../../lib/config/ConfigManager');
+
+// Default config path
+const DEFAULT_CONFIG_PATH = path.join(os.homedir(), '.autopm', 'config.json');
+
+/**
+ * Validate password meets minimum requirements
+ * @param {string} pwd - Password to validate
+ * @returns {boolean|string} True if valid, error message otherwise
+ */
+function validatePassword(pwd) {
+  if (!pwd || pwd.length < 8) {
+    return 'Password must be at least 8 characters long';
+  }
+  return true;
+}
+
+/**
+ * Main initialization function
+ */
+async function main() {
+  try {
+    const configPath = process.env.AUTOPM_CONFIG_PATH || DEFAULT_CONFIG_PATH;
+
+    console.log('\n🔧 AutoPM Configuration Setup');
+    console.log('=============================\n');
+
+    // Check if config already exists
+    const fs = require('fs');
+    if (fs.existsSync(configPath)) {
+      console.log('⚠️  Configuration already exists at:', configPath);
+      console.log('To reconfigure, delete the existing file first.\n');
+      return;
+    }
+
+    // Prompt for master password
+    const masterPassword = await password({
+      message: 'Enter master password (for API key encryption):',
+      mask: '*'
+    });
+
+    // Validate password
+    const validationResult = validatePassword(masterPassword);
+    if (validationResult !== true) {
+      console.error(`\nError: ${validationResult}`);
+      process.exit(1);
+    }
+
+    // Confirm password
+    const confirmPassword = await password({
+      message: 'Confirm master password:',
+      mask: '*'
+    });
+
+    // Check passwords match
+    if (masterPassword !== confirmPassword) {
+      console.error('\nError: Passwords do not match');
+      process.exit(1);
+    }
+
+    // Create ConfigManager instance
+    const manager = new ConfigManager(configPath);
+    manager.setMasterPassword(masterPassword);
+
+    // Save configuration
+    manager.save();
+
+    console.log('\n✓ Configuration initialized at:', configPath);
+    console.log('✓ Master password set (not stored, remember it!)');
+    console.log('\nNext steps:');
+    console.log('  - Set API key: autopm config:set-api-key');
+    console.log('  - Configure provider: autopm config:set-provider\n');
+
+  } catch (error) {
+    if (error.message.includes('cancelled') || error.message.includes('User force closed')) {
+      console.error('\nError: Setup cancelled by user');
+    } else {
+      console.error('\nError:', error.message);
+    }
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = main;

package/scripts/config/list-providers.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/**
+ * @fileoverview Config command: list-providers
+ * List all configured providers with API key status
+ *
+ * Usage: autopm config:list-providers
+ */
+
+const path = require('path');
+const os = require('os');
+const ConfigManager = require('../../lib/config/ConfigManager');
+
+// Default config path
+const DEFAULT_CONFIG_PATH = path.join(os.homedir(), '.autopm', 'config.json');
+
+/**
+ * Main function
+ */
+async function main() {
+  try {
+    const configPath = process.env.AUTOPM_CONFIG_PATH || DEFAULT_CONFIG_PATH;
+
+    // Check if config exists
+    const fs = require('fs');
+    if (!fs.existsSync(configPath)) {
+      console.error('\nError: Configuration not found');
+      console.error('Run: autopm config:init\n');
+      process.exit(1);
+    }
+
+    // Load configuration
+    const manager = new ConfigManager(configPath);
+
+    // Get providers
+    const providers = manager.listProviders();
+    const defaultProvider = manager.getDefaultProvider();
+
+    if (providers.length === 0) {
+      console.log('\nNo providers configured');
+      console.log('Run: autopm config:set-provider <name>\n');
+      return;
+    }
+
+    // Display header
+    console.log('\nConfigured Providers:');
+    console.log('=====================\n');
+
+    // Sort providers alphabetically
+    const sortedProviders = providers.sort();
+
+    // Count providers with API keys
+    let apiKeyCount = 0;
+
+    // Display each provider
+    for (const providerName of sortedProviders) {
+      const provider = manager.getProvider(providerName);
+      const hasApiKey = manager.hasApiKey(providerName);
+      const isDefault = providerName === defaultProvider;
+
+      if (hasApiKey) {
+        apiKeyCount++;
+      }
+
+      // Format line
+      const defaultMarker = isDefault ? '* ' : '  ';
+      const apiKeyStatus = hasApiKey ? '✓ API key set' : '✗ No API key';
+      const modelInfo = provider.model || 'not configured';
+
+      console.log(`${defaultMarker}${providerName.padEnd(18)} ${apiKeyStatus.padEnd(15)} ${modelInfo}`);
+    }
+
+    console.log('\n(* = default provider)\n');
+
+    // Summary
+    console.log(`Total: ${providers.length} provider${providers.length !== 1 ? 's' : ''} configured`);
+    console.log(`API keys: ${apiKeyCount} with API keys configured\n`);
+
+  } catch (error) {
+    if (error.message.includes('Unexpected token') || error.message.includes('JSON')) {
+      console.error('\nError reading config: Invalid JSON format\n');
+    } else {
+      console.error('\nError:', error.message, '\n');
+    }
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = main;

package/scripts/config/set-api-key.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+/**
+ * @fileoverview Config command: set-api-key
+ * Set encrypted API key for a provider
+ *
+ * Usage: autopm config:set-api-key
+ */
+
+const path = require('path');
+const os = require('os');
+const { select, password } = require('@inquirer/prompts');
+const ConfigManager = require('../../lib/config/ConfigManager');
+
+// Default config path
+const DEFAULT_CONFIG_PATH = path.join(os.homedir(), '.autopm', 'config.json');
+
+/**
+ * Main function
+ */
+async function main() {
+  try {
+    const configPath = process.env.AUTOPM_CONFIG_PATH || DEFAULT_CONFIG_PATH;
+
+    // Check if config exists
+    const fs = require('fs');
+    if (!fs.existsSync(configPath)) {
+      console.error('\nError: Configuration not initialized');
+      console.error('Run: autopm config:init\n');
+      process.exit(1);
+    }
+
+    // Load configuration
+    const manager = new ConfigManager(configPath);
+
+    // Get list of providers
+    const providers = manager.listProviders();
+
+    if (providers.length === 0) {
+      console.error('\nError: No providers configured');
+      console.error('Run: autopm config:set-provider <name>\n');
+      process.exit(1);
+    }
+
+    // Build choices with current API key status
+    const choices = providers.map(provider => {
+      const hasKey = manager.hasApiKey(provider);
+      const status = hasKey ? '✓ API key set' : '✗ No API key';
+      return {
+        name: `${provider.padEnd(20)} ${status}`,
+        value: provider
+      };
+    });
+
+    // Prompt for provider selection
+    const selectedProvider = await select({
+      message: 'Select provider:',
+      choices
+    });
+
+    // Get master password (from env or prompt)
+    let masterPassword = process.env.AUTOPM_MASTER_PASSWORD;
+
+    if (!masterPassword) {
+      masterPassword = await password({
+        message: 'Enter master password:',
+        mask: '*'
+      });
+    }
+
+    manager.setMasterPassword(masterPassword);
+
+    // Prompt for API key
+    const apiKey = await password({
+      message: `Enter API key for ${selectedProvider}:`,
+      mask: '*'
+    });
+
+    // Validate API key not empty
+    if (!apiKey || apiKey.trim().length === 0) {
+      console.error('\nError: API key cannot be empty');
+      process.exit(1);
+    }
+
+    // Set and save API key
+    manager.setApiKey(selectedProvider, apiKey);
+    manager.save();
+
+    console.log(`\n✓ API key encrypted and stored for '${selectedProvider}'\n`);
+
+  } catch (error) {
+    if (error.message.includes('cancelled') || error.message.includes('User force closed')) {
+      console.error('\nError: Operation cancelled by user');
+    } else if (error.message.includes('incorrect')) {
+      console.error('\nError: Incorrect master password');
+    } else {
+      console.error('\nError:', error.message);
+    }
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = main;