maiass 5.7.31

package/lib/config-command.js

@@ -0,0 +1,310 @@
+// Configuration command handler for MAIASS CLI
+// Implements: nma config [options] [key[=value]]
+
+import { log, logger } from './logger.js';
+import colors from './colors.js';
+import { SYMBOLS } from './symbols.js';
+import { MAIASS_VARIABLES } from './maiass-variables.js';
+import {
+  getConfigPaths,
+  configExists,
+  readConfig,
+  writeConfig,
+  setConfigValue,
+  getConfigValue,
+  listConfig,
+  editConfig,
+  validateConfig
+} from './config-manager.js';
+
+/**
+ * Display configuration values in a formatted table
+ * @param {Object} config - Configuration data from listConfig()
+ * @param {Object} options - Display options
+ */
+function displayConfig(config, options = {}) {
+  const { scope = 'all', showSensitive = false, showPaths = true } = options;
+  
+  logger.header(SYMBOLS.GEAR, 'Configuration Status');
+  
+  if (showPaths) {
+    logger.section('Configuration Files:', colors.BBlue);
+    
+    const globalStatus = config.files.global.exists ? 
+      colors.BGreen(`${SYMBOLS.CHECKMARK} EXISTS`) : 
+      colors.BYellow(`${SYMBOLS.WARNING} Not found`);
+    
+    const projectStatus = config.files.project.exists ? 
+      colors.BGreen(`${SYMBOLS.CHECKMARK} EXISTS`) : 
+      colors.BYellow(`${SYMBOLS.WARNING} Not found`);
+    
+    console.log(`  1. Global Config      ${globalStatus}`);
+    console.log(`     ${colors.Gray(config.files.global.path)}`);
+    console.log(`  2. Project Config     ${projectStatus}`);
+    console.log(`     ${colors.Gray(config.files.project.path)}`);
+    console.log();
+  }
+  
+  // Filter variables based on scope
+  let varsToShow = Object.entries(config.merged);
+  
+  if (scope === 'global') {
+    varsToShow = varsToShow.filter(([key, info]) => info.source === 'global');
+  } else if (scope === 'project') {
+    varsToShow = varsToShow.filter(([key, info]) => info.source === 'project');
+  } else if (scope === 'set') {
+    varsToShow = varsToShow.filter(([key, info]) => info.source !== 'default' && info.source !== 'not_set');
+  }
+  
+  if (varsToShow.length === 0) {
+    console.log(colors.BYellow(`${SYMBOLS.INFO} No configuration values found for scope: ${scope}`));
+    return;
+  }
+  
+  logger.section('Configuration Values:', colors.BBlue);
+  
+  // Group by category for better display
+  const categories = {
+    'Core System': ['MAIASS_DEBUG', 'MAIASS_VERBOSITY', 'MAIASS_LOGGING', 'MAIASS_BRAND'],
+    'AI Integration': ['MAIASS_AI_MODE', 'MAIASS_AI_TOKEN', 'MAIASS_AI_MODEL', 'MAIASS_AI_TEMPERATURE', 'MAIASS_AI_HOST', 'MAIASS_AI_MAX_CHARACTERS', 'MAIASS_AI_COMMIT_MESSAGE_STYLE'],
+    'Git Branches': ['MAIASS_DEVELOPBRANCH', 'MAIASS_STAGINGBRANCH', 'MAIASS_MAINBRANCH'],
+    'Repository Settings': ['MAIASS_REPO_TYPE', 'MAIASS_GITHUB_OWNER', 'MAIASS_GITHUB_REPO', 'MAIASS_BITBUCKET_WORKSPACE', 'MAIASS_BITBUCKET_REPO_SLUG'],
+    'Pull Requests': ['MAIASS_STAGING_PULLREQUESTS', 'MAIASS_MAIN_PULLREQUESTS'],
+    'Version Management': ['MAIASS_VERSION_PATH', 'MAIASS_VERSION_PRIMARY_FILE', 'MAIASS_VERSION_PRIMARY_TYPE', 'MAIASS_VERSION_PRIMARY_LINE_START', 'MAIASS_VERSION_SECONDARY_FILES'],
+    'Changelog': ['MAIASS_CHANGELOG_PATH', 'MAIASS_CHANGELOG_NAME', 'MAIASS_CHANGELOG_INTERNAL_NAME']
+  };
+  
+  Object.entries(categories).forEach(([categoryName, categoryVars]) => {
+    const categoryEntries = varsToShow.filter(([key]) => categoryVars.includes(key));
+    
+    if (categoryEntries.length > 0) {
+      console.log(colors.BWhite(`  ${categoryName}:`));
+      console.log();
+      
+      categoryEntries.forEach(([key, info]) => {
+        const displayKey = key.replace('MAIASS_', '').toLowerCase();
+        const sourceColor = {
+          'project local': colors.BCyan,
+          'project': colors.BGreen,
+          'global': colors.BBlue,
+          'default': colors.Gray,
+          'not_set': colors.BYellow
+        }[info.source] || colors.White;
+        
+        const sourceText = {
+          'project local': 'project local',
+          'project': 'project',
+          'global': 'global',
+          'default': 'default',
+          'not_set': 'not set'
+        }[info.source];
+        
+        let displayValue = info.value || '(not set)';
+        if (info.sensitive && !showSensitive && info.value) {
+          displayValue = '***' + info.value.slice(-4);
+        }
+        
+        console.log(`    ${colors.BWhite(displayKey.padEnd(25))} = ${colors.White(displayValue)}`);
+        console.log(`    ${' '.repeat(25)}   ${sourceColor(`→ ${sourceText}`)} ${colors.Gray(`(${info.description})`)}`);
+        console.log();
+      });
+    }
+  });
+  
+  // Show other variables not in categories
+  const otherEntries = varsToShow.filter(([key]) => 
+    !Object.values(categories).flat().includes(key)
+  );
+  
+  if (otherEntries.length > 0) {
+    console.log(colors.BWhite('  Other Settings:'));
+    console.log();
+    
+    otherEntries.forEach(([key, info]) => {
+      const displayKey = key.replace('MAIASS_', '').toLowerCase();
+      const sourceColor = {
+        'project local': colors.BCyan,
+        'project': colors.BGreen,
+        'global': colors.BBlue,
+        'default': colors.Gray,
+        'not_set': colors.BYellow
+      }[info.source] || colors.White;
+      
+      const sourceText = {
+        'project local': 'project local',
+        'project': 'project',
+        'global': 'global',
+        'default': 'default',
+        'not_set': 'not set'
+      }[info.source];
+      
+      let displayValue = info.value || '(not set)';
+      if (info.sensitive && !showSensitive && info.value) {
+        displayValue = '***' + info.value.slice(-4);
+      }
+      
+      console.log(`    ${colors.BWhite(displayKey.padEnd(25))} = ${colors.White(displayValue)}`);
+      console.log(`    ${' '.repeat(25)}   ${sourceColor(`→ ${sourceText}`)} ${colors.Gray(`(${info.description})`)}`);
+      console.log();
+    });
+  }
+}
+
+/**
+ * Handle config command
+ * @param {Object} args - Command arguments from yargs
+ */
+export async function handleConfigCommand(args) {
+  const {
+    global: isGlobal,
+    project: isProject,
+    edit,
+    list,
+    'show-sensitive': showSensitive,
+    'list-vars': listVars,
+    key
+  } = args;
+  
+  const paths = getConfigPaths();
+  
+  try {
+    // Handle --list-vars flag
+    if (listVars) {
+      log.info(SYMBOLS.INFO, 'Available Configuration Variables:');
+      log.space();
+      
+      Object.entries(MAIASS_VARIABLES).forEach(([key, def]) => {
+        const displayKey = key.replace('MAIASS_', '').toLowerCase();
+        const sensitive = def.sensitive ? colors.BYellow(' (sensitive)') : '';
+        console.log(`  ${colors.BWhite(displayKey.padEnd(30))} - ${colors.Gray(def.description)}${sensitive}`);
+      });
+      
+      log.space();
+      log.blue(SYMBOLS.INFO, 'Usage examples:');
+      console.log(`  nma config --global maiass_token=your_token_here`);
+      console.log(`  nma config --project debug=true`);
+      console.log(`  nma config verbosity`);
+      return;
+    }
+    
+    // Handle --edit flag
+    if (edit) {
+      const configPath = isGlobal ? paths.global : 
+                        isProject ? paths.project : 
+                        paths.project; // Default to project
+      
+      log.blue(SYMBOLS.INFO, `Editing ${isGlobal ? 'global' : 'project'} configuration...`);
+      editConfig(configPath);
+      return;
+    }
+    
+    // Handle key=value assignment
+    if (key) {
+      const arg = key;
+      
+      if (arg.includes('=')) {
+        // Set configuration value
+        const [rawKey, ...valueParts] = arg.split('=');
+        const key = `MAIASS_${rawKey.toUpperCase()}`;
+        const value = valueParts.join('=');
+        
+        // Validate key exists
+        if (!MAIASS_VARIABLES[key]) {
+          console.error(colors.Red(`${SYMBOLS.CROSS} Unknown configuration variable: ${rawKey}`));
+          console.log(colors.BYellow(`${SYMBOLS.INFO} Use --list-vars to see available variables`));
+          return;
+        }
+        
+        // Determine target config file
+        const configPath = isGlobal ? paths.global : paths.project;
+        const scope = isGlobal ? 'global' : 'project';
+        
+        // Validate value
+        const tempConfig = { [key]: value };
+        const errors = validateConfig(tempConfig);
+        
+        if (errors.length > 0) {
+          console.error(colors.Red(`${SYMBOLS.CROSS} Configuration validation failed:`));
+          errors.forEach(error => {
+            console.error(colors.Red(`  ${error.key}: ${error.error}`));
+            if (error.current) {
+              console.error(colors.Gray(`    Current value: ${error.current}`));
+            }
+          });
+          return;
+        }
+        
+        // Set the value
+        setConfigValue(key, value, { global: isGlobal });
+        
+        const varDef = MAIASS_VARIABLES[key];
+        const displayKey = rawKey.toLowerCase();
+        let displayValue = value;
+        
+        if (varDef.sensitive) {
+          displayValue = '***' + value.slice(-4);
+        }
+        
+        log.success(SYMBOLS.CHECKMARK, 'Configuration updated');
+        console.log(`  ${colors.BWhite(displayKey)} = ${colors.White(displayValue)} ${colors.Gray(`(${scope})`)}`);
+        console.log(`  ${colors.Gray(`File: ${configPath}`)}`);
+        
+      } else {
+        // Get specific configuration value
+        const rawKey = arg;
+        const key = `MAIASS_${rawKey.toUpperCase()}`;
+        
+        if (!MAIASS_VARIABLES[key]) {
+          console.error(colors.Red(`${SYMBOLS.CROSS} Unknown configuration variable: ${rawKey}`));
+          console.log(colors.BYellow(`${SYMBOLS.INFO} Use --list-vars to see available variables`));
+          return;
+        }
+        
+        const valueInfo = getConfigValue(key);
+        const varDef = MAIASS_VARIABLES[key];
+        
+        let displayValue = valueInfo.value || '(not set)';
+        if (varDef.sensitive && !showSensitive && valueInfo.value) {
+          displayValue = '***' + valueInfo.value.slice(-4);
+        }
+        
+        const sourceColor = {
+          'project local': colors.BCyan,
+          'project': colors.BGreen,
+          'global': colors.BBlue,
+          'default': colors.Gray,
+          'not_set': colors.BYellow
+        }[valueInfo.source] || colors.White;
+        
+        log.info(SYMBOLS.INFO, 'Configuration Value:');
+        log.space();
+        console.log(`  ${colors.BWhite(rawKey.toLowerCase())} = ${colors.White(displayValue)}`);
+        console.log(`  ${sourceColor(`→ ${valueInfo.source}`)} ${colors.Gray(`(${varDef.description})`)}`);
+        
+        if (valueInfo.path) {
+          console.log(`  ${colors.Gray(`File: ${valueInfo.path}`)}`);
+        }
+      }
+      
+      return;
+    }
+    
+    // Default: show configuration
+    const config = listConfig({ showSensitive });
+    
+    let scope = 'all';
+    if (isGlobal && !isProject) scope = 'global';
+    else if (isProject && !isGlobal) scope = 'project';
+    else if (list) scope = 'set';
+    
+    displayConfig(config, { 
+      scope, 
+      showSensitive, 
+      showPaths: scope === 'all' 
+    });
+    
+  } catch (error) {
+    console.error(colors.Red(`${SYMBOLS.CROSS} Configuration error: ${error.message}`));
+    process.exit(1);
+  }
+}

package/lib/config-manager.js

@@ -0,0 +1,344 @@
+// Configuration management for MAIASS
+// Handles global and project-level configuration settings
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+import { log, logger } from './logger.js';
+import colors from './colors.js';
+import { SYMBOLS } from './symbols.js';
+import { MAIASS_VARIABLES } from './maiass-variables.js';
+import { loadEnvironmentConfig } from './config.js';
+
+/**
+ * Get configuration file paths
+ * @returns {Object} Configuration file paths
+ */
+export function getConfigPaths() {
+  return {
+    global: path.join(os.homedir(), '.env.maiass'),
+    project: path.resolve(process.cwd(), '.env.maiass'),
+    projectDir: process.cwd(),
+    homeDir: os.homedir()
+  };
+}
+
+/**
+ * Check if a configuration file exists
+ * @param {string} configPath - Path to config file
+ * @returns {boolean} True if file exists
+ */
+export function configExists(configPath) {
+  return fs.existsSync(configPath);
+}
+
+/**
+ * Read configuration file contents
+ * @param {string} configPath - Path to config file
+ * @returns {Object} Parsed configuration object
+ */
+export function readConfig(configPath) {
+  if (!configExists(configPath)) {
+    return {};
+  }
+  
+  try {
+    const content = fs.readFileSync(configPath, 'utf8');
+    const config = {};
+    
+    // Parse .env format (KEY=value)
+    content.split('\n').forEach(line => {
+      line = line.trim();
+      if (line && !line.startsWith('#')) {
+        const [key, ...valueParts] = line.split('=');
+        if (key && valueParts.length > 0) {
+          let value = valueParts.join('=').trim();
+          
+          // Remove surrounding quotes if present
+          if ((value.startsWith('"') && value.endsWith('"')) ||
+              (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+          }
+          
+          config[key.trim()] = value;
+        }
+      }
+    });
+    
+    return config;
+  } catch (error) {
+    console.error(colors.Red(`${SYMBOLS.CROSS} Error reading config file ${configPath}: ${error.message}`));
+    return {};
+  }
+}
+
+/**
+ * Write configuration to file
+ * @param {string} configPath - Path to config file
+ * @param {Object} config - Configuration object to write
+ * @param {Object} options - Write options
+ */
+export function writeConfig(configPath, config, options = {}) {
+  const { backup = true, createDir = true } = options;
+  
+  try {
+    // Create directory if it doesn't exist
+    if (createDir) {
+      const dir = path.dirname(configPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    }
+    
+    // Create backup if file exists
+    if (backup && configExists(configPath)) {
+      const backupPath = `${configPath}.backup.${Date.now()}`;
+      fs.copyFileSync(configPath, backupPath);
+    }
+    
+    // Generate .env format content
+    const lines = [];
+    lines.push('# MAIASS Configuration');
+    lines.push(`# Generated on ${new Date().toISOString()}`);
+    lines.push('');
+    
+    // Group variables by category for better organization
+    const categories = {
+      'Core': ['MAIASS_DEBUG', 'MAIASS_VERBOSITY', 'MAIASS_LOGGING', 'MAIASS_BRAND'],
+      'AI': ['MAIASS_AI_MODE', 'MAIASS_AI_TOKEN', 'MAIASS_AI_MODEL', 'MAIASS_AI_TEMPERATURE', 'MAIASS_AI_ENDPOINT', 'MAIASS_AI_MAX_CHARACTERS', 'MAIASS_AI_COMMIT_MESSAGE_STYLE'],
+      'Branches': ['MAIASS_DEVELOPBRANCH', 'MAIASS_STAGINGBRANCH', 'MAIASS_MAINBRANCH'],
+      'Repository': ['MAIASS_REPO_TYPE', 'MAIASS_GITHUB_OWNER', 'MAIASS_GITHUB_REPO', 'MAIASS_BITBUCKET_WORKSPACE', 'MAIASS_BITBUCKET_REPO_SLUG'],
+      'Pull Requests': ['MAIASS_STAGING_PULLREQUESTS', 'MAIASS_MAIN_PULLREQUESTS'],
+      'Versioning': ['MAIASS_VERSION_PATH', 'MAIASS_VERSION_PRIMARY_FILE', 'MAIASS_VERSION_PRIMARY_TYPE', 'MAIASS_VERSION_PRIMARY_LINE_START', 'MAIASS_VERSION_SECONDARY_FILES'],
+      'Changelog': ['MAIASS_CHANGELOG_PATH', 'MAIASS_CHANGELOG_NAME', 'MAIASS_CHANGELOG_INTERNAL_NAME'],
+      'Other': []
+    };
+    
+    // Write variables by category
+    Object.entries(categories).forEach(([categoryName, categoryVars]) => {
+      const varsInCategory = Object.keys(config).filter(key => 
+        categoryVars.includes(key) || (categoryName === 'Other' && !Object.values(categories).flat().includes(key))
+      );
+      
+      if (varsInCategory.length > 0) {
+        lines.push(`# ${categoryName} Settings`);
+        varsInCategory.forEach(key => {
+          const value = config[key];
+          const varDef = MAIASS_VARIABLES[key];
+          
+          if (varDef && varDef.description) {
+            lines.push(`# ${varDef.description}`);
+          }
+          
+          // Quote values that contain spaces or special characters
+          const needsQuotes = /[\s#"'\\]/.test(value);
+          const quotedValue = needsQuotes ? `"${value.replace(/"/g, '\\"')}"` : value;
+          
+          lines.push(`${key}=${quotedValue}`);
+        });
+        lines.push('');
+      }
+    });
+    
+    fs.writeFileSync(configPath, lines.join('\n'), 'utf8');
+    
+  } catch (error) {
+    console.error(colors.Red(`${SYMBOLS.CROSS} Error writing config file ${configPath}: ${error.message}`));
+    throw error;
+  }
+}
+
+/**
+ * Set a configuration value
+ * @param {string} key - Configuration key
+ * @param {string} value - Configuration value
+ * @param {Object} options - Options like { global: true }
+ */
+export function setConfigValue(key, value, options = {}) {
+  const paths = getConfigPaths();
+  const configPath = options.global ? paths.global : paths.project;
+  
+  const config = readConfig(configPath);
+  config[key] = value;
+  writeConfig(configPath, config);
+}
+
+/**
+ * Get a configuration value with fallback hierarchy
+ * @param {string} key - Configuration key
+ * @returns {Object} Value info with source
+ */
+export function getConfigValue(key) {
+  const paths = getConfigPaths();
+  
+  // Check project local config first (highest priority)
+  const projectLocalPath = path.resolve(process.cwd(), '.env.maiass.local');
+  const projectLocalConfig = readConfig(projectLocalPath);
+  if (projectLocalConfig[key] !== undefined) {
+    return {
+      value: projectLocalConfig[key],
+      source: 'project local',
+      path: projectLocalPath
+    };
+  }
+  
+  // Check project config (second priority)
+  const projectConfig = readConfig(paths.project);
+  if (projectConfig[key] !== undefined) {
+    return {
+      value: projectConfig[key],
+      source: 'project',
+      path: paths.project
+    };
+  }
+  
+  // Check global config
+  const globalConfig = readConfig(paths.global);
+  if (globalConfig[key] !== undefined) {
+    return {
+      value: globalConfig[key],
+      source: 'global',
+      path: paths.global
+    };
+  }
+  
+  // Check default value
+  const varDef = MAIASS_VARIABLES[key];
+  if (varDef && varDef.default !== undefined) {
+    return {
+      value: varDef.default,
+      source: 'default',
+      path: null
+    };
+  }
+  
+  return {
+    value: undefined,
+    source: 'not_set',
+    path: null
+  };
+}
+
+/**
+ * List all configuration values with their sources
+ * @param {Object} options - Listing options
+ * @returns {Object} Configuration listing
+ */
+export function listConfig(options = {}) {
+  const { scope = 'all', showSensitive = false } = options;
+  const paths = getConfigPaths();
+  
+  const result = {
+    global: {},
+    project: {},
+    merged: {},
+    files: {
+      global: { exists: configExists(paths.global), path: paths.global },
+      project: { exists: configExists(paths.project), path: paths.project }
+    }
+  };
+  
+  // Read config files
+  if (result.files.global.exists) {
+    result.global = readConfig(paths.global);
+  }
+  
+  if (result.files.project.exists) {
+    result.project = readConfig(paths.project);
+  }
+  
+  // Create merged config with source tracking
+  Object.keys(MAIASS_VARIABLES).forEach(key => {
+    const valueInfo = getConfigValue(key);
+    const varDef = MAIASS_VARIABLES[key];
+    
+    // Skip sensitive variables unless explicitly requested
+    if (varDef.sensitive && !showSensitive) {
+      if (valueInfo.value) {
+        valueInfo.value = '***' + valueInfo.value.slice(-4);
+      }
+    }
+    
+    result.merged[key] = {
+      ...valueInfo,
+      description: varDef.description,
+      sensitive: varDef.sensitive || false
+    };
+  });
+  
+  return result;
+}
+
+/**
+ * Open configuration file in default editor
+ * @param {string} configPath - Path to config file
+ */
+export function editConfig(configPath) {
+  try {
+    // Create file if it doesn't exist
+    if (!configExists(configPath)) {
+      writeConfig(configPath, {});
+    }
+    
+    // Try to detect and use appropriate editor
+    const editor = process.env.EDITOR || process.env.VISUAL || 'nano';
+    
+    log.blue(SYMBOLS.INFO, `Opening ${configPath} in ${editor}...`);
+    
+    execSync(`${editor} "${configPath}"`, { 
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
+    
+    log.success(SYMBOLS.CHECKMARK, 'Configuration file updated');
+    
+  } catch (error) {
+    console.error(colors.Red(`${SYMBOLS.CROSS} Error opening editor: ${error.message}`));
+    log.warning(SYMBOLS.INFO, `You can manually edit: ${configPath}`);
+  }
+}
+
+/**
+ * Validate configuration values
+ * @param {Object} config - Configuration object to validate
+ * @returns {Array} Array of validation errors
+ */
+export function validateConfig(config) {
+  const errors = [];
+  
+  Object.entries(config).forEach(([key, value]) => {
+    const varDef = MAIASS_VARIABLES[key];
+    
+    if (!varDef) {
+      errors.push({
+        key,
+        error: 'Unknown configuration variable',
+        suggestion: 'Check available variables with: nma config --list-vars'
+      });
+      return;
+    }
+    
+    // Add specific validation rules here as needed
+    if (key === 'MAIASS_AI_TEMPERATURE') {
+      const temp = parseFloat(value);
+      if (isNaN(temp) || temp < 0 || temp > 2) {
+        errors.push({
+          key,
+          error: 'Temperature must be a number between 0 and 2',
+          current: value
+        });
+      }
+    }
+    
+    if (key.includes('PULLREQUESTS') && !['on', 'off'].includes(value)) {
+      errors.push({
+        key,
+        error: 'Pull request setting must be "on" or "off"',
+        current: value
+      });
+    }
+  });
+  
+  return errors;
+}