maiass 5.7.31

package/lib/maiass-variables.js

@@ -0,0 +1,152 @@
+// Complete list of MAIASS environment variables with their defaults
+// Extracted from setup_bumpscript_variables() in maiass.sh
+import fs from 'fs';
+import path from 'path';
+
+export const MAIASS_VARIABLES = {
+  // Core system variables
+  'MAIASS_DEBUG': { default: 'false', description: 'Enable debug mode' },
+  'MAIASS_AUTOPUSH_COMMITS': { default: 'false', description: 'Automatically push commits' },
+  'MAIASS_BRAND': { default: 'MAIASS', description: 'Brand name for display' },
+  'MAIASS_VERBOSITY': { default: 'brief', description: 'Verbosity level (brief/normal/verbose)' },
+  'MAIASS_LOGGING': { default: 'false', description: 'Enable logging to file' },
+  'MAIASS_LOG_FILE': { default: 'maiass.log', description: 'Log file name' },
+
+  // AI configuration
+  'MAIASS_AI_MODE': { default: 'ask', description: 'AI interaction mode' },
+  'MAIASS_AI_TOKEN': { default: '', description: 'AI API token', sensitive: true },
+  'MAIASS_AI_MODEL': { default: 'gpt-3.5-turbo', description: 'AI model to use' },
+  'MAIASS_AI_TEMPERATURE': { default: '0.7', description: 'AI temperature setting' },
+  'MAIASS_AI_MAX_CHARACTERS': { default: '8000', description: 'Max characters for AI requests' },
+  'MAIASS_AI_COMMIT_MESSAGE_STYLE': { default: 'bullet', description: 'Commit message style' },
+
+  // Version file system
+  'MAIASS_VERSION_PRIMARY_FILE': { default: '', description: 'Primary version file path' },
+  'MAIASS_VERSION_PRIMARY_TYPE': { default: '', description: 'Primary version file type' },
+  'MAIASS_VERSION_PRIMARY_LINE_START': { default: '', description: 'Line start pattern for version' },
+  'MAIASS_VERSION_SECONDARY_FILES': { default: '', description: 'Secondary version files (comma-separated)' },
+
+  // Branch configuration
+  'MAIASS_DEVELOPBRANCH': { default: 'develop', description: 'Development branch name' },
+  'MAIASS_STAGINGBRANCH': { default: 'staging', description: 'Staging branch name' },
+  'MAIASS_MAINBRANCH': { default: 'main', description: 'Main/Master branch name' },
+
+  // Changelog configuration
+  'MAIASS_CHANGELOG_PATH': { default: '.', description: 'Path to changelog directory' },
+  'MAIASS_CHANGELOG_NAME': { default: 'CHANGELOG.md', description: 'Main changelog filename' },
+  'MAIASS_CHANGELOG_INTERNAL_NAME': { default: '.CHANGELOG_internal.md', description: 'Internal changelog filename' },
+
+  // Repository configuration
+  'MAIASS_REPO_TYPE': { default: 'bespoke', description: 'Repository type (wordpress-theme/plugin/site, craft, bespoke)' },
+  'MAIASS_VERSION_PATH': { default: '.', description: 'Path to version files' },
+  'MAIASS_PACKAGE_PATH': { default: '.', description: 'Path to package.json' },
+  'MAIASS_WP_FILES_PATH': { default: '', description: 'Path to WordPress files' },
+
+  // Release configuration
+  'MAIASS_AUTO_TAG_RELEASES': { default: 'true', description: 'Automatically tag releases without prompting' },
+
+  // Pull request configuration
+  'MAIASS_STAGING_PULLREQUESTS': { default: 'on', description: 'Enable staging pull requests' },
+  'MAIASS_MAIN_PULLREQUESTS': { default: 'on', description: 'Enable main branch pull requests' },
+
+  // Repository provider configuration
+  'MAIASS_BITBUCKET_WORKSPACE': { default: '', description: 'Bitbucket workspace name' },
+  'MAIASS_BITBUCKET_REPO_SLUG': { default: '', description: 'Bitbucket repository slug' },
+  'MAIASS_GITHUB_OWNER': { default: '', description: 'GitHub repository owner' },
+  'MAIASS_GITHUB_REPO': { default: '', description: 'GitHub repository name' }
+};
+
+/**
+ * Get the source of an environment variable value
+ * @param {string} key - Environment variable key
+ * @param {string} value - Current value
+ * @param {Array} loadedFiles - Array of loaded config files
+ * @returns {string} Source description
+ */
+export function getVariableSource(key, value, loadedFiles) {
+  const varDef = MAIASS_VARIABLES[key];
+  
+  if (!value) {
+    return 'not set';
+  }
+  
+  if (varDef && value === varDef.default) {
+    return 'default';
+  }
+  
+  // Check which file contains this variable by reading file contents
+  // Priority order: .env.maiass.local (highest) -> .env.maiass -> user .maiass.env -> OS config -> OS secure (lowest)
+  
+  // Check project .env.maiass.local first (highest priority)
+  const projectLocalEnv = path.resolve(process.cwd(), '.env.maiass.local');
+  if (fs.existsSync(projectLocalEnv)) {
+    try {
+      const content = fs.readFileSync(projectLocalEnv, 'utf8');
+      // Use more precise regex to match the exact variable
+      const regex = new RegExp(`^\\s*${key}\\s*=`, 'm');
+      if (regex.test(content)) {
+        return 'project local';
+      }
+    } catch (error) {
+      // File read error, continue checking other files
+    }
+  }
+  
+  // Check project .env.maiass (second priority)
+  const projectEnv = path.resolve(process.cwd(), '.env.maiass');
+  if (fs.existsSync(projectEnv)) {
+    try {
+      const content = fs.readFileSync(projectEnv, 'utf8');
+      const regex = new RegExp(`^\\s*${key}\\s*=`, 'm');
+      if (regex.test(content)) {
+        return 'project';
+      }
+    } catch (error) {
+      // File read error, continue checking other files
+    }
+  }
+  
+  // Check user .maiass.env (global user config)
+  const userEnv = loadedFiles.find(f => f.includes('.maiass.env'));
+  if (userEnv) {
+    try {
+      const content = fs.readFileSync(userEnv, 'utf8');
+      const regex = new RegExp(`^\\s*${key}\\s*=`, 'm');
+      if (regex.test(content)) {
+        return 'global';
+      }
+    } catch (error) {
+      // File read error, continue checking other files
+    }
+  }
+  
+  // Check OS config
+  const osConfig = loadedFiles.find(f => f.includes('config.env'));
+  if (osConfig) {
+    try {
+      const content = fs.readFileSync(osConfig, 'utf8');
+      if (content.includes(`${key}=`)) {
+        return 'OS config';
+      }
+    } catch (error) {
+      // File read error, continue checking other files
+    }
+  }
+  
+  // Check OS secure
+  const osSecure = loadedFiles.find(f => f.includes('secure.env'));
+  if (osSecure) {
+    try {
+      const content = fs.readFileSync(osSecure, 'utf8');
+      if (content.includes(`${key}=`)) {
+        return 'OS secure';
+      }
+    } catch (error) {
+      // File read error, continue checking other files
+    }
+  }
+  
+  return 'environment';
+}
+
+export default MAIASS_VARIABLES;

package/lib/secure-storage.js

@@ -0,0 +1,256 @@
+// Secure storage functionality for nodemaiass
+// Uses OS keychain (macOS) or secret-tool (Linux) for sensitive data storage
+// Compatible with bashmaiass approach but uses NODEMAIASS service names
+
+import { execSync } from 'child_process';
+import os from 'os';
+import { log } from './logger.js';
+import { SYMBOLS } from './symbols.js';
+
+/**
+ * Get environment-specific service name for secure storage
+ * Uses NODEMAIASS prefix to differentiate from bashmaiass
+ * @returns {string} Service name for secure storage
+ */
+export function getSecureServiceName() {
+  const env = process.env.MAIASS_AI_HOST || '';
+  let envSuffix = '';
+  
+  if (env.includes('localhost') || env.includes('127.0.0.1')) {
+    envSuffix = '_localhost';
+  } else if (env.includes('preview') || env.includes('staging')) {
+    envSuffix = '_preview';
+  }
+  // Production uses no suffix
+  
+  // Use 'maiass' (not 'nodemaiass') to share keychain with bashmaiass
+  return `maiass${envSuffix}`;
+}
+
+/**
+ * Store a sensitive variable in OS secure storage
+ * @param {string} varName - Variable name (e.g., 'MAIASS_AI_TOKEN')
+ * @param {string} varValue - Variable value
+ * @returns {boolean} Success status
+ */
+export function storeSecureVariable(varName, varValue) {
+  const serviceName = getSecureServiceName();
+  const debugMode = process.env.MAIASS_DEBUG === 'true';
+  
+  if (debugMode) {
+    log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Storing ${varName} in secure storage service: ${serviceName}`);
+  }
+  
+  try {
+    if (os.platform() === 'darwin') {
+      // macOS: Use keychain via security command
+      execSync(`security add-generic-password -U -s "${serviceName}" -a "${varName}" -w "${varValue}"`, {
+        stdio: 'pipe'
+      });
+    } else {
+      // Linux: Use secret-tool if available
+      try {
+        execSync('which secret-tool', { stdio: 'pipe' });
+        execSync(`echo -n "${varValue}" | secret-tool store --label="NODEMAIASS ${varName} (${serviceName})" service "${serviceName}" key "${varName}"`, {
+          stdio: 'pipe',
+          shell: true
+        });
+      } catch (error) {
+        if (debugMode) {
+          log.debug(SYMBOLS.WARNING, '[MAIASS DEBUG] secret-tool not available, secure storage not supported on this system');
+        }
+        return false;
+      }
+    }
+    
+    if (debugMode) {
+      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Successfully stored ${varName} in secure storage`);
+    }
+    return true;
+  } catch (error) {
+    if (debugMode) {
+      log.debug(SYMBOLS.WARNING, `[MAIASS DEBUG] Failed to store ${varName} in secure storage: ${error.message}`);
+    }
+    return false;
+  }
+}
+
+/**
+ * Retrieve a sensitive variable from OS secure storage
+ * @param {string} varName - Variable name (e.g., 'MAIASS_AI_TOKEN')
+ * @returns {string|null} Variable value or null if not found
+ */
+export function retrieveSecureVariable(varName) {
+  const serviceName = getSecureServiceName();
+  const debugMode = process.env.MAIASS_DEBUG === 'true';
+  
+  if (debugMode) {
+    log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Retrieving ${varName} from secure storage service: ${serviceName}`);
+  }
+  
+  try {
+    let value = null;
+    
+    if (os.platform() === 'darwin') {
+      // macOS: Use keychain via security command
+      value = execSync(`security find-generic-password -s "${serviceName}" -a "${varName}" -w`, {
+        stdio: 'pipe',
+        encoding: 'utf8'
+      }).trim();
+    } else {
+      // Linux: Use secret-tool if available
+      try {
+        execSync('which secret-tool', { stdio: 'pipe' });
+        value = execSync(`secret-tool lookup service "${serviceName}" key "${varName}"`, {
+          stdio: 'pipe',
+          encoding: 'utf8'
+        }).trim();
+      } catch (error) {
+        if (debugMode) {
+          log.debug(SYMBOLS.WARNING, '[MAIASS DEBUG] secret-tool not available, secure storage not supported on this system');
+        }
+        return null;
+      }
+    }
+    
+    if (debugMode && value) {
+      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Successfully retrieved ${varName} from secure storage`);
+    }
+    
+    return value || null;
+  } catch (error) {
+    if (debugMode) {
+      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] ${varName} not found in secure storage (this is normal for first run)`);
+    }
+    return null;
+  }
+}
+
+/**
+ * Remove a sensitive variable from OS secure storage
+ * @param {string} varName - Variable name (e.g., 'MAIASS_AI_TOKEN')
+ * @returns {boolean} Success status
+ */
+export function removeSecureVariable(varName) {
+  const serviceName = getSecureServiceName();
+  const debugMode = process.env.MAIASS_DEBUG === 'true';
+  
+  if (debugMode) {
+    log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Removing ${varName} from secure storage service: ${serviceName}`);
+  }
+  
+  try {
+    if (os.platform() === 'darwin') {
+      // macOS: Use keychain via security command
+      execSync(`security delete-generic-password -s "${serviceName}" -a "${varName}"`, {
+        stdio: 'pipe'
+      });
+    } else {
+      // Linux: secret-tool doesn't have direct delete, but we can try to clear it
+      try {
+        execSync('which secret-tool', { stdio: 'pipe' });
+        // secret-tool doesn't have a delete command, so we store an empty value
+        execSync(`echo -n "" | secret-tool store --label="NODEMAIASS ${varName} (${serviceName})" service "${serviceName}" key "${varName}"`, {
+          stdio: 'pipe',
+          shell: true
+        });
+      } catch (error) {
+        if (debugMode) {
+          log.debug(SYMBOLS.WARNING, '[MAIASS DEBUG] secret-tool not available, secure storage not supported on this system');
+        }
+        return false;
+      }
+    }
+    
+    if (debugMode) {
+      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Successfully removed ${varName} from secure storage`);
+    }
+    return true;
+  } catch (error) {
+    if (debugMode) {
+      log.debug(SYMBOLS.WARNING, `[MAIASS DEBUG] Failed to remove ${varName} from secure storage: ${error.message}`);
+    }
+    return false;
+  }
+}
+
+/**
+ * Load secure variables into environment
+ * Loads MAIASS_AI_TOKEN and MAIASS_SUBSCRIPTION_ID from secure storage
+ */
+export function loadSecureVariables() {
+  const secureVars = ['MAIASS_AI_TOKEN', 'MAIASS_SUBSCRIPTION_ID'];
+  const debugMode = process.env.MAIASS_DEBUG === 'true';
+  const serviceName = getSecureServiceName();
+  
+  if (debugMode) {
+    const host = process.env.MAIASS_AI_HOST || 'https://pound.maiass.net';
+    log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Using secure storage service name: ${serviceName} (host: ${host})`);
+  }
+  
+  secureVars.forEach(varName => {
+    const envValue = process.env[varName];
+    
+    if (debugMode) {
+      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Checking ${varName}: value="${envValue}", type=${typeof envValue}, empty=${!envValue || envValue.trim() === ''}`);
+    }
+    
+    // Check if we should prefer secure storage over environment variable
+    let preferSecure = false;
+    if (varName === 'MAIASS_AI_TOKEN' && envValue) {
+      // Check if the existing token looks invalid
+      if (/^invalid_|^test_|_test$/.test(envValue) || envValue === 'DISABLED' || envValue.trim() === '') {
+        preferSecure = true;
+        if (debugMode) {
+          log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Environment token appears invalid, checking secure storage`);
+        }
+      }
+    }
+    
+    // Only load if not already set with valid token (unless we want to prefer secure storage)
+    if (!envValue || envValue.trim() === '' || preferSecure) {
+      const value = retrieveSecureVariable(varName);
+      if (value) {
+        process.env[varName] = value;
+        if (preferSecure) {
+          if (debugMode) {
+            log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Replaced invalid environment token with secure storage token`);
+          }
+        } else {
+          if (debugMode) {
+            log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Loaded ${varName} from secure storage`);
+          }
+        }
+      }
+    } else if (debugMode) {
+      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] ${varName} already set in environment, skipping secure storage`);
+    }
+  });
+}
+
+/**
+ * Check if secure storage is available on this system
+ * @returns {boolean} True if secure storage is supported
+ */
+export function isSecureStorageAvailable() {
+  try {
+    if (os.platform() === 'darwin') {
+      execSync('which security', { stdio: 'pipe' });
+      return true;
+    } else {
+      execSync('which secret-tool', { stdio: 'pipe' });
+      return true;
+    }
+  } catch (error) {
+    return false;
+  }
+}
+
+export default {
+  getSecureServiceName,
+  storeSecureVariable,
+  retrieveSecureVariable,
+  removeSecureVariable,
+  loadSecureVariables,
+  isSecureStorageAvailable
+};

package/lib/symbols.js

@@ -0,0 +1,200 @@
+// Cross-platform symbol system with Unicode/ASCII fallbacks
+import os from 'os';
+
+/**
+ * Detect if the current terminal supports Unicode
+ * @returns {boolean} True if Unicode is supported
+ */
+function supportsUnicode() {
+  // Check environment variable override
+  if (process.env.MAIASS_NO_UNICODE === 'true') {
+    return false;
+  }
+  
+  // Force Unicode if explicitly enabled
+  if (process.env.MAIASS_FORCE_UNICODE === 'true') {
+    return true;
+  }
+  
+  // Check platform and terminal capabilities
+  const platform = os.platform();
+  
+  // Windows-specific checks
+  if (platform === 'win32') {
+    // Modern Windows Terminal supports Unicode
+    if (process.env.WT_SESSION) {
+      return true;
+    }
+    
+    // PowerShell 7+ generally supports Unicode
+    if (process.env.PSModulePath && process.env.POWERSHELL_DISTRIBUTION_CHANNEL) {
+      return true;
+    }
+    
+    // VS Code integrated terminal
+    if (process.env.VSCODE_INJECTION || process.env.TERM_PROGRAM === 'vscode') {
+      return true;
+    }
+    
+    // Default to ASCII for Windows cmd and older terminals
+    return false;
+  }
+  
+  // macOS and Linux generally support Unicode
+  if (platform === 'darwin' || platform === 'linux') {
+    // Check if we're in a known Unicode-capable terminal
+    const term = process.env.TERM || '';
+    const termProgram = process.env.TERM_PROGRAM || '';
+    
+    if (term.includes('xterm') || 
+        term.includes('screen') || 
+        termProgram === 'vscode' ||
+        termProgram === 'iTerm.app' ||
+        process.env.COLORTERM === 'truecolor') {
+      return true;
+    }
+  }
+  
+  // Default to Unicode for non-Windows platforms
+  return platform !== 'win32';
+}
+
+/**
+ * Symbol definitions with Unicode and ASCII fallbacks
+ */
+const SYMBOL_SETS = {
+  unicode: {
+    globe: '🌍',
+    folder: '📁',
+    gear: '⚙️',
+    wrench: '🔧',
+    checkmark: '✅',
+    cross: '❌',
+    warning: '⚠️',
+    info: 'ℹ️',
+    smile: '😊',
+    sunglasses: '😎',
+    poo: '💩',
+    rocket: '🚀',
+    arrow: '→',
+    check: '✓',
+    x: '✗',
+    bullet: '•',
+    diamond: '◆',
+    star: '★',
+    heart: '♥',
+    spade: '♠',
+    club: '♣',
+    maiassdot: '(.)',
+    maiassass: '|))',
+    pushing: '↑↑↑',
+    merging: '<=>',
+    pulling: '↓↓↓',  
+    brain: '🧠',
+  },
+  ascii: {
+    globe: '[GLOBE]',
+    folder: '[FOLDER]',
+    gear: '[GEAR]',
+    wrench: '[TOOL]',
+    checkmark: '[OK]',
+    cross: '[ERROR]',
+    warning: '[WARN]',
+    info: '[INFO]',
+    smile: ':)',
+    sunglasses: ':D',
+    poo: ':(',
+    rocket: '[ROCKET]',
+    arrow: '->',
+    check: '+',
+    x: '-',
+    bullet: '*',
+    diamond: '<>',
+    star: '*',
+    heart: '<3',
+    spade: 'S',
+    club: 'C',
+    maiassdot: '(.)',
+    maiassass: '|))',
+    pushing: '↑↑↑',
+    merging: '<=>',
+    pulling: '↓↓↓',  
+    brain: '[AI]',}
+};
+
+/**
+ * Get the appropriate symbol set based on terminal capabilities
+ */
+const useUnicode = supportsUnicode();
+const symbols = useUnicode ? SYMBOL_SETS.unicode : SYMBOL_SETS.ascii;
+
+/**
+ * Get a symbol with automatic Unicode/ASCII fallback
+ * @param {string} name - Symbol name
+ * @returns {string} The appropriate symbol for the current terminal
+ */
+export function getSymbol(name) {
+  return symbols[name] || name;
+}
+
+/**
+ * Check if Unicode is being used
+ * @returns {boolean} True if Unicode symbols are active
+ */
+export function isUnicodeEnabled() {
+  return useUnicode;
+}
+
+/**
+ * Get terminal info for debugging
+ * @returns {Object} Terminal capability information
+ */
+export function getTerminalInfo() {
+  return {
+    platform: os.platform(),
+    supportsUnicode: useUnicode,
+    env: {
+      TERM: process.env.TERM,
+      TERM_PROGRAM: process.env.TERM_PROGRAM,
+      COLORTERM: process.env.COLORTERM,
+      WT_SESSION: process.env.WT_SESSION,
+      VSCODE_INJECTION: process.env.VSCODE_INJECTION,
+      MAIASS_NO_UNICODE: process.env.MAIASS_NO_UNICODE,
+      MAIASS_FORCE_UNICODE: process.env.MAIASS_FORCE_UNICODE
+    }
+  };
+}
+
+// Export individual symbols for convenience
+export const SYMBOLS = {
+  GLOBE: getSymbol('globe'),
+  FOLDER: getSymbol('folder'),
+  GEAR: getSymbol('gear'),
+  WRENCH: getSymbol('wrench'),
+  CHECKMARK: getSymbol('checkmark'),
+  CROSS: getSymbol('cross'),
+  WARNING: getSymbol('warning'),
+  INFO: getSymbol('info'),
+  ARROW: getSymbol('arrow'),
+  CHECK: getSymbol('check'),
+  X: getSymbol('x'),
+  BULLET: getSymbol('bullet'),
+  DIAMOND: getSymbol('diamond'),
+  STAR: getSymbol('star'),
+  HEART: getSymbol('heart'),
+  SPADE: getSymbol('spade'),
+  CLUB: getSymbol('club'),
+  MAIASSDOT: getSymbol('maiassdot'),
+  MAIASSASS: getSymbol('maiassass'),
+  PUSHING: getSymbol('pushing'),
+  MERGING: getSymbol('merging'),
+  PULLING: getSymbol('pulling'),
+  BRAIN: getSymbol('brain')
+};
+
+export default {
+  getSymbol,
+  isUnicodeEnabled,
+  getTerminalInfo,
+  SYMBOLS
+};