codesummary 1.0.0

package/src/configManager.js

@@ -0,0 +1,427 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ErrorHandler from './errorHandler.js';
+
+/**
+ * Configuration Manager for CodeSummary
+ * Handles global configuration storage, first-run setup, and user preferences
+ * Cross-platform compatible with POSIX and Windows systems
+ */
+export class ConfigManager {
+  constructor() {
+    this.configDir = this.getConfigDirectory();
+    this.configPath = path.join(this.configDir, 'config.json');
+    this.defaultConfig = this.getDefaultConfig();
+  }
+
+  /**
+   * Get the appropriate configuration directory based on platform
+   * @returns {string} Configuration directory path
+   */
+  getConfigDirectory() {
+    const platform = os.platform();
+    const homeDir = os.homedir();
+
+    if (platform === 'win32') {
+      // Windows: %APPDATA%\CodeSummary\
+      return path.join(process.env.APPDATA || homeDir, 'CodeSummary');
+    } else {
+      // POSIX (Linux/macOS): ~/.codesummary/
+      return path.join(homeDir, '.codesummary');
+    }
+  }
+
+  /**
+   * Get default configuration object
+   * @returns {object} Default configuration
+   */
+  getDefaultConfig() {
+    return {
+      output: {
+        mode: 'fixed',
+        fixedPath: path.join(os.homedir(), 'Desktop', 'CodeSummaries')
+      },
+      allowedExtensions: [
+        '.json', '.ts', '.js', '.jsx', '.tsx', '.xml', '.html',
+        '.css', '.scss', '.md', '.txt', '.py', '.java', '.cs',
+        '.cpp', '.c', '.h', '.yaml', '.yml', '.sh', '.bat'
+      ],
+      excludeDirs: [
+        'node_modules', '.git', '.vscode', 'dist', 'build',
+        'coverage', 'out', '__pycache__', '.next', '.nuxt'
+      ],
+      styles: {
+        colors: {
+          title: '#333353',
+          section: '#00FFB9',
+          text: '#333333',
+          error: '#FF4D4D',
+          footer: '#666666'
+        },
+        layout: {
+          marginLeft: 40,
+          marginTop: 40,
+          marginRight: 40,
+          footerHeight: 20
+        },
+        fonts: {
+          base: 'Source Code Pro'
+        }
+      },
+      settings: {
+        documentTitle: 'Project Code Summary',
+        maxFilesBeforePrompt: 500
+      }
+    };
+  }
+
+  /**
+   * Check if configuration file exists
+   * @returns {boolean} True if config exists
+   */
+  configExists() {
+    return fs.existsSync(this.configPath);
+  }
+
+  /**
+   * Load configuration from file or return null if not found/corrupted
+   * @returns {object|null} Configuration object or null
+   */
+  async loadConfig() {
+    try {
+      if (!this.configExists()) {
+        return null;
+      }
+
+      const configData = await fs.readJSON(this.configPath);
+      
+      // Validate configuration structure
+      ErrorHandler.validateConfig(configData);
+
+      return configData;
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return null;
+      }
+
+      if (error.message.includes('JSON')) {
+        console.log(chalk.red('ERROR: Configuration file contains invalid JSON.'));
+      } else if (error.message.includes('Configuration')) {
+        console.log(chalk.red('ERROR: Configuration file structure is invalid.'));
+        console.log(chalk.gray('Details:'), error.message);
+      } else {
+        ErrorHandler.handleFileSystemError(error, 'read configuration', this.configPath);
+        return null;
+      }
+      
+      const { shouldReset } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'shouldReset',
+        message: 'Do you want to reset the configuration?',
+        default: true
+      }]);
+
+      if (shouldReset) {
+        await this.resetConfig();
+        return await this.runFirstTimeSetup();
+      } else {
+        process.exit(1);
+      }
+    }
+  }
+
+  /**
+   * Save configuration to file
+   * @param {object} config Configuration object to save
+   */
+  async saveConfig(config) {
+    try {
+      // Validate configuration before saving
+      ErrorHandler.validateConfig(config);
+      
+      // Ensure config directory exists
+      await fs.ensureDir(this.configDir);
+      
+      // Save configuration with pretty formatting
+      await fs.writeJSON(this.configPath, config, { spaces: 2 });
+      
+      console.log(chalk.green(`Configuration saved to ${this.configPath}`));
+    } catch (error) {
+      if (error.message.includes('Configuration')) {
+        console.error(chalk.red('ERROR: Invalid configuration:'), error.message);
+      } else {
+        ErrorHandler.handleFileSystemError(error, 'save configuration', this.configPath);
+      }
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Delete existing configuration file
+   */
+  async resetConfig() {
+    try {
+      if (this.configExists()) {
+        await fs.remove(this.configPath);
+        console.log(chalk.yellow('Configuration reset successfully.'));
+      }
+    } catch (error) {
+      console.error(chalk.red('ERROR: Failed to reset configuration:'), error.message);
+    }
+  }
+
+  /**
+   * Run the first-time setup wizard
+   * @returns {object} New configuration object
+   */
+  async runFirstTimeSetup() {
+    console.log(chalk.cyan('Welcome to CodeSummary!'));
+    console.log(chalk.gray('No configuration found. Starting setup...\n'));
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'outputMode',
+        message: 'Where should the PDF be generated by default?',
+        choices: [
+          {
+            name: 'Current working directory (relative mode)',
+            value: 'relative'
+          },
+          {
+            name: 'Fixed folder (absolute mode)',
+            value: 'fixed'
+          }
+        ],
+        default: 'fixed'
+      },
+      {
+        type: 'input',
+        name: 'fixedPath',
+        message: 'Enter absolute path for fixed folder:',
+        default: path.join(os.homedir(), 'Desktop', 'CodeSummaries'),
+        when: (answers) => answers.outputMode === 'fixed',
+        validate: (input) => {
+          if (!path.isAbsolute(input)) {
+            return 'Please enter an absolute path';
+          }
+          return true;
+        }
+      }
+    ]);
+
+    // Create the config object
+    const config = { ...this.defaultConfig };
+    config.output.mode = answers.outputMode;
+    
+    if (answers.outputMode === 'fixed') {
+      config.output.fixedPath = path.resolve(answers.fixedPath);
+      
+      // Offer to create the directory if it doesn't exist
+      if (!fs.existsSync(config.output.fixedPath)) {
+        const { createDir } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'createDir',
+          message: `Directory ${config.output.fixedPath} does not exist. Create it?`,
+          default: true
+        }]);
+
+        if (createDir) {
+          try {
+            await fs.ensureDir(config.output.fixedPath);
+            console.log(chalk.green(`SUCCESS: Created directory: ${config.output.fixedPath}`));
+          } catch (error) {
+            console.error(chalk.red('ERROR: Failed to create directory:'), error.message);
+            process.exit(1);
+          }
+        }
+      }
+    }
+
+    // Save the configuration
+    await this.saveConfig(config);
+    
+    console.log(chalk.green('\nSUCCESS: Setup completed successfully!\n'));
+    
+    return config;
+  }
+
+  /**
+   * Launch interactive configuration editor
+   * @param {object} currentConfig Current configuration to edit
+   * @returns {object} Updated configuration
+   */
+  async editConfig(currentConfig) {
+    console.log(chalk.cyan('Configuration Editor\n'));
+
+    const choices = [
+      'Output Settings',
+      'File Extensions',
+      'Excluded Directories',
+      'PDF Styling',
+      'General Settings',
+      'Save and Exit'
+    ];
+
+    let config = { ...currentConfig };
+    let editing = true;
+
+    while (editing) {
+      const { section } = await inquirer.prompt([{
+        type: 'list',
+        name: 'section',
+        message: 'Select section to edit:',
+        choices
+      }]);
+
+      switch (section) {
+        case 'Output Settings':
+          config = await this.editOutputSettings(config);
+          break;
+        case 'File Extensions':
+          config = await this.editAllowedExtensions(config);
+          break;
+        case 'Excluded Directories':
+          config = await this.editExcludedDirs(config);
+          break;
+        case 'PDF Styling':
+          console.log(chalk.yellow('PDF styling editor coming in future version'));
+          break;
+        case 'General Settings':
+          config = await this.editGeneralSettings(config);
+          break;
+        case 'Save and Exit':
+          editing = false;
+          break;
+      }
+    }
+
+    await this.saveConfig(config);
+    return config;
+  }
+
+  /**
+   * Edit output settings
+   * @param {object} config Current configuration
+   * @returns {object} Updated configuration
+   */
+  async editOutputSettings(config) {
+    const answers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'mode',
+        message: 'Output mode:',
+        choices: [
+          { name: 'Relative (current directory)', value: 'relative' },
+          { name: 'Fixed path', value: 'fixed' }
+        ],
+        default: config.output.mode
+      },
+      {
+        type: 'input',
+        name: 'fixedPath',
+        message: 'Fixed path:',
+        default: config.output.fixedPath,
+        when: (answers) => answers.mode === 'fixed'
+      }
+    ]);
+
+    config.output.mode = answers.mode;
+    if (answers.fixedPath) {
+      config.output.fixedPath = path.resolve(answers.fixedPath);
+    }
+
+    return config;
+  }
+
+  /**
+   * Edit allowed extensions
+   * @param {object} config Current configuration
+   * @returns {object} Updated configuration
+   */
+  async editAllowedExtensions(config) {
+    const { extensions } = await inquirer.prompt([{
+      type: 'input',
+      name: 'extensions',
+      message: 'Allowed extensions (comma-separated):',
+      default: config.allowedExtensions.join(', '),
+      validate: (input) => {
+        if (!input.trim()) {
+          return 'Please enter at least one extension';
+        }
+        return true;
+      }
+    }]);
+
+    config.allowedExtensions = extensions
+      .split(',')
+      .map(ext => ext.trim())
+      .filter(ext => ext.length > 0)
+      .map(ext => ext.startsWith('.') ? ext : '.' + ext);
+
+    return config;
+  }
+
+  /**
+   * Edit excluded directories
+   * @param {object} config Current configuration
+   * @returns {object} Updated configuration
+   */
+  async editExcludedDirs(config) {
+    const { dirs } = await inquirer.prompt([{
+      type: 'input',
+      name: 'dirs',
+      message: 'Excluded directories (comma-separated):',
+      default: config.excludeDirs.join(', ')
+    }]);
+
+    config.excludeDirs = dirs
+      .split(',')
+      .map(dir => dir.trim())
+      .filter(dir => dir.length > 0);
+
+    return config;
+  }
+
+  /**
+   * Edit general settings
+   * @param {object} config Current configuration
+   * @returns {object} Updated configuration
+   */
+  async editGeneralSettings(config) {
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'documentTitle',
+        message: 'Document title:',
+        default: config.settings.documentTitle
+      },
+      {
+        type: 'number',
+        name: 'maxFilesBeforePrompt',
+        message: 'Max files before warning prompt:',
+        default: config.settings.maxFilesBeforePrompt,
+        validate: (input) => input > 0 || 'Must be a positive number'
+      }
+    ]);
+
+    config.settings.documentTitle = answers.documentTitle;
+    config.settings.maxFilesBeforePrompt = answers.maxFilesBeforePrompt;
+
+    return config;
+  }
+
+  /**
+   * Display current configuration
+   * @param {object} config Configuration to display
+   */
+  displayConfig(config) {
+    console.log(chalk.cyan('\nCurrent Configuration:\n'));
+    console.log(JSON.stringify(config, null, 2));
+  }
+}
+
+export default ConfigManager;