claude-autopm 1.18.0 → 1.20.1

package/lib/utils/config.js

@@ -1,317 +0,0 @@
-/**
- * Configuration management utility
- * Handles loading and saving configuration files
- */
-
-const fs = require('fs-extra');
-const path = require('path');
-const yaml = require('js-yaml');
-const dotenv = require('dotenv');
-
-class Config {
-  constructor(logger) {
-    this.logger = logger;
-    this.configDir = '.claude';
-    this.configFile = 'config.json';
-  }
-
-  /**
-   * Get config file path
-   */
-  getConfigPath(projectPath = process.cwd()) {
-    return path.join(projectPath, this.configDir, this.configFile);
-  }
-
-  /**
-   * Load configuration
-   */
-  async load(projectPath = process.cwd()) {
-    const configPath = this.getConfigPath(projectPath);
-
-    try {
-      if (await fs.pathExists(configPath)) {
-        const config = await fs.readJson(configPath);
-        this.logger.debug(`Loaded configuration from: ${configPath}`);
-        return config;
-      }
-
-      this.logger.debug('No configuration file found, using defaults');
-      return this.getDefaultConfig();
-    } catch (error) {
-      this.logger.error('Failed to load configuration', error);
-      return this.getDefaultConfig();
-    }
-  }
-
-  /**
-   * Save configuration
-   */
-  async save(config, projectPath = process.cwd()) {
-    const configPath = this.getConfigPath(projectPath);
-
-    try {
-      await fs.ensureDir(path.dirname(configPath));
-      await fs.writeJson(configPath, config, { spaces: 2 });
-      this.logger.success(`Configuration saved to: ${configPath}`);
-      return true;
-    } catch (error) {
-      this.logger.error('Failed to save configuration', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Get default configuration
-   */
-  getDefaultConfig() {
-    return {
-      version: '1.0.0',
-      provider: 'github',
-      executionStrategy: 'adaptive',
-      features: {
-        docker_first_development: false,
-        kubernetes_devops_testing: false,
-        github_actions_k8s: false,
-        enforce_docker_tests: false,
-        integration_tests: true
-      },
-      paths: {
-        epics: '.claude/epics',
-        prds: '.claude/prds',
-        context: '.claude/context'
-      },
-      settings: {
-        verbose: false,
-        autoSync: false,
-        parallelExecution: true
-      }
-    };
-  }
-
-  /**
-   * Merge configurations
-   */
-  mergeConfig(base, updates) {
-    return {
-      ...base,
-      ...updates,
-      features: {
-        ...base.features,
-        ...(updates.features || {})
-      },
-      paths: {
-        ...base.paths,
-        ...(updates.paths || {})
-      },
-      settings: {
-        ...base.settings,
-        ...(updates.settings || {})
-      }
-    };
-  }
-
-  /**
-   * Load environment variables
-   */
-  async loadEnv(projectPath = process.cwd()) {
-    const envPath = path.join(projectPath, this.configDir, '.env');
-
-    try {
-      if (await fs.pathExists(envPath)) {
-        dotenv.config({ path: envPath });
-        this.logger.debug(`Loaded environment variables from: ${envPath}`);
-        return true;
-      }
-
-      this.logger.debug('No .env file found');
-      return false;
-    } catch (error) {
-      this.logger.error('Failed to load .env file', error);
-      return false;
-    }
-  }
-
-  /**
-   * Save environment variables
-   */
-  async saveEnv(variables, projectPath = process.cwd()) {
-    const envPath = path.join(projectPath, this.configDir, '.env');
-
-    try {
-      await fs.ensureDir(path.dirname(envPath));
-
-      const envContent = Object.entries(variables)
-        .map(([key, value]) => `${key}="${value}"`)
-        .join('\n');
-
-      await fs.writeFile(envPath, envContent);
-      await fs.chmod(envPath, 0o600); // Secure permissions
-
-      this.logger.success(`Environment variables saved to: ${envPath}`);
-      return true;
-    } catch (error) {
-      this.logger.error('Failed to save .env file', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Get configuration presets
-   */
-  getPresets() {
-    return {
-      minimal: {
-        executionStrategy: 'sequential',
-        features: {
-          docker_first_development: false,
-          kubernetes_devops_testing: false,
-          github_actions_k8s: false,
-          enforce_docker_tests: false,
-          integration_tests: true
-        }
-      },
-      docker: {
-        executionStrategy: 'adaptive',
-        features: {
-          docker_first_development: true,
-          kubernetes_devops_testing: false,
-          github_actions_k8s: false,
-          enforce_docker_tests: true,
-          integration_tests: true
-        }
-      },
-      devops: {
-        executionStrategy: 'adaptive',
-        features: {
-          docker_first_development: true,
-          kubernetes_devops_testing: true,
-          github_actions_k8s: true,
-          enforce_docker_tests: true,
-          integration_tests: true
-        }
-      },
-      performance: {
-        executionStrategy: 'hybrid-parallel',
-        features: {
-          docker_first_development: false,
-          kubernetes_devops_testing: false,
-          github_actions_k8s: false,
-          enforce_docker_tests: false,
-          integration_tests: true
-        },
-        settings: {
-          parallelExecution: true
-        }
-      }
-    };
-  }
-
-  /**
-   * Apply preset configuration
-   */
-  applyPreset(presetName) {
-    const presets = this.getPresets();
-    const preset = presets[presetName];
-
-    if (!preset) {
-      throw new Error(`Unknown preset: ${presetName}`);
-    }
-
-    const defaultConfig = this.getDefaultConfig();
-    return this.mergeConfig(defaultConfig, preset);
-  }
-
-  /**
-   * Validate configuration
-   */
-  validateConfig(config) {
-    const errors = [];
-
-    // Check required fields
-    if (!config.version) {
-      errors.push('Missing version field');
-    }
-
-    if (!config.provider) {
-      errors.push('Missing provider field');
-    }
-
-    if (!['github', 'azure'].includes(config.provider)) {
-      errors.push(`Invalid provider: ${config.provider}`);
-    }
-
-    if (!config.executionStrategy) {
-      errors.push('Missing executionStrategy field');
-    }
-
-    const validStrategies = ['sequential', 'adaptive', 'hybrid-parallel'];
-    if (!validStrategies.includes(config.executionStrategy)) {
-      errors.push(`Invalid executionStrategy: ${config.executionStrategy}`);
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-
-  /**
-   * Load YAML configuration
-   */
-  async loadYaml(filepath) {
-    try {
-      const content = await fs.readFile(filepath, 'utf8');
-      return yaml.load(content);
-    } catch (error) {
-      this.logger.error(`Failed to load YAML file: ${filepath}`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Save YAML configuration
-   */
-  async saveYaml(filepath, data) {
-    try {
-      const content = yaml.dump(data, { indent: 2 });
-      await fs.writeFile(filepath, content);
-      this.logger.debug(`Saved YAML file: ${filepath}`);
-      return true;
-    } catch (error) {
-      this.logger.error(`Failed to save YAML file: ${filepath}`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Check if project is configured
-   */
-  async isConfigured(projectPath = process.cwd()) {
-    const configPath = this.getConfigPath(projectPath);
-    return fs.pathExists(configPath);
-  }
-
-  /**
-   * Get provider-specific settings
-   */
-  getProviderSettings(config) {
-    switch (config.provider) {
-      case 'github':
-        return {
-          useSubIssues: true,
-          labelsPrefix: 'pm:',
-          ...config.github
-        };
-      case 'azure':
-        return {
-          organization: process.env.AZURE_DEVOPS_ORG,
-          project: process.env.AZURE_DEVOPS_PROJECT,
-          ...config.azure
-        };
-      default:
-        return {};
-    }
-  }
-}
-
-module.exports = Config;

package/lib/utils/filesystem.js

@@ -1,316 +0,0 @@
-/**
- * Filesystem utility for cross-platform file operations
- * Wraps fs-extra with additional safety and logging
- */
-
-const fs = require('fs-extra');
-const path = require('path');
-const { glob } = require('glob');
-
-class FileSystem {
-  constructor(logger) {
-    this.logger = logger;
-  }
-
-  /**
-   * Check if a path exists
-   */
-  async exists(filepath) {
-    try {
-      await fs.access(filepath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Create directory with parents if needed
-   */
-  async ensureDir(dirPath) {
-    try {
-      await fs.ensureDir(dirPath);
-      this.logger.debug(`Created directory: ${dirPath}`);
-      return true;
-    } catch (error) {
-      this.logger.error(`Failed to create directory: ${dirPath}`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Copy file or directory
-   */
-  async copy(src, dest, options = {}) {
-    try {
-      await fs.copy(src, dest, options);
-      this.logger.debug(`Copied: ${src} → ${dest}`);
-      return true;
-    } catch (error) {
-      this.logger.error(`Failed to copy: ${src} → ${dest}`, error);
-      const newError = new Error(`Failed to copy: ${error.message}`);
-      newError.code = error.code;
-      newError.src = src;
-      newError.dest = dest;
-      throw newError;
-    }
-  }
-
-  /**
-   * Move file or directory
-   */
-  async move(src, dest, options = {}) {
-    try {
-      await fs.move(src, dest, options);
-      this.logger.debug(`Moved: ${src} → ${dest}`);
-      return true;
-    } catch (error) {
-      this.logger.error(`Failed to move: ${src} → ${dest}`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Remove file or directory
-   */
-  async remove(filepath) {
-    try {
-      await fs.remove(filepath);
-      this.logger.debug(`Removed: ${filepath}`);
-      return true;
-    } catch (error) {
-      this.logger.error(`Failed to remove: ${filepath}`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Read file content
-   */
-  async readFile(filepath, encoding = 'utf8') {
-    try {
-      const content = await fs.readFile(filepath, encoding);
-      this.logger.debug(`Read file: ${filepath}`);
-      return content;
-    } catch (error) {
-      this.logger.error(`Failed to read file: ${filepath}`, error);
-      const newError = new Error(`Failed to read file: ${error.message}`);
-      newError.code = error.code;
-      newError.path = error.path;
-      throw newError;
-    }
-  }
-
-  /**
-   * Write file content
-   */
-  async writeFile(filepath, content, options = {}) {
-    try {
-      await fs.writeFile(filepath, content, options);
-      this.logger.debug(`Wrote file: ${filepath}`);
-      return true;
-    } catch (error) {
-      this.logger.error(`Failed to write file: ${filepath}`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Read JSON file
-   */
-  async readJson(filepath) {
-    try {
-      const data = await fs.readJson(filepath);
-      this.logger.debug(`Read JSON: ${filepath}`);
-      return data;
-    } catch (error) {
-      this.logger.error(`Failed to read JSON: ${filepath}`, error);
-      const newError = new Error(`Failed to read JSON: ${error.message}`);
-      newError.code = error.code;
-      newError.path = filepath;
-      throw newError;
-    }
-  }
-
-  /**
-   * Write JSON file
-   */
-  async writeJson(filepath, data, options = { spaces: 2 }) {
-    try {
-      await fs.writeJson(filepath, data, options);
-      this.logger.debug(`Wrote JSON: ${filepath}`);
-      return true;
-    } catch (error) {
-      this.logger.error(`Failed to write JSON: ${filepath}`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * List directory contents
-   */
-  async listDir(dirPath, options = {}) {
-    try {
-      const items = await fs.readdir(dirPath, options);
-      this.logger.debug(`Listed directory: ${dirPath}`);
-      return items;
-    } catch (error) {
-      this.logger.error(`Failed to list directory: ${dirPath}`, error);
-      const newError = new Error(`Failed to list directory: ${error.message}`);
-      newError.code = error.code;
-      newError.path = error.path;
-      throw newError;
-    }
-  }
-
-  /**
-   * Find files using glob pattern
-   */
-  async findFiles(pattern, options = {}) {
-    try {
-      const files = await glob(pattern, options);
-      this.logger.debug(`Found ${files.length} files matching: ${pattern}`);
-      return files;
-    } catch (error) {
-      this.logger.error(`Failed to find files: ${pattern}`, error);
-      const newError = new Error(`Failed to find files: ${error.message}`);
-      newError.code = error.code;
-      newError.pattern = pattern;
-      throw newError;
-    }
-  }
-
-  /**
-   * Get file stats
-   */
-  async stat(filepath) {
-    try {
-      const stats = await fs.stat(filepath);
-      this.logger.debug(`Got stats for: ${filepath}`);
-      return stats;
-    } catch (error) {
-      this.logger.error(`Failed to get stats: ${filepath}`, error);
-      const newError = new Error(`Failed to get stats: ${error.message}`);
-      newError.code = error.code;
-      newError.path = error.path;
-      throw newError;
-    }
-  }
-
-  /**
-   * Check if path is a directory
-   */
-  async isDirectory(filepath) {
-    try {
-      const stats = await this.stat(filepath);
-      return stats.isDirectory();
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Check if path is a file
-   */
-  async isFile(filepath) {
-    try {
-      const stats = await this.stat(filepath);
-      return stats.isFile();
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Create backup with timestamp
-   */
-  async backup(filepath) {
-    if (!await this.exists(filepath)) {
-      return null;
-    }
-
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-    const backupPath = `${filepath}.backup-${timestamp}`;
-
-    try {
-      await this.copy(filepath, backupPath);
-      this.logger.info(`Created backup: ${backupPath}`);
-      return backupPath;
-    } catch (error) {
-      this.logger.error(`Failed to create backup: ${filepath}`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Set file permissions
-   */
-  async chmod(filepath, mode) {
-    try {
-      await fs.chmod(filepath, mode);
-      this.logger.debug(`Changed permissions: ${filepath} to ${mode.toString(8)}`);
-      return true;
-    } catch (error) {
-      this.logger.error(`Failed to change permissions: ${filepath}`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Create symbolic link
-   */
-  async symlink(target, linkPath) {
-    try {
-      await fs.ensureSymlink(target, linkPath);
-      this.logger.debug(`Created symlink: ${linkPath} → ${target}`);
-      return true;
-    } catch (error) {
-      this.logger.error(`Failed to create symlink: ${linkPath}`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Get absolute path
-   */
-  resolvePath(...paths) {
-    return path.resolve(...paths);
-  }
-
-  /**
-   * Get relative path
-   */
-  relativePath(from, to) {
-    return path.relative(from, to);
-  }
-
-  /**
-   * Join paths
-   */
-  joinPath(...paths) {
-    return path.join(...paths);
-  }
-
-  /**
-   * Get directory name
-   */
-  dirname(filepath) {
-    return path.dirname(filepath);
-  }
-
-  /**
-   * Get base name
-   */
-  basename(filepath, ext) {
-    return path.basename(filepath, ext);
-  }
-
-  /**
-   * Get extension
-   */
-  extname(filepath) {
-    return path.extname(filepath);
-  }
-}
-
-module.exports = FileSystem;