maiass 5.7.31

package/lib/config.js

@@ -0,0 +1,150 @@
+// Cross-platform configuration and environment variable loading
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import dotenv from 'dotenv';
+import { loadSecureVariables } from './secure-storage.js';
+
+/**
+ * Get OS-specific config directory paths
+ * @returns {Object} Object with config paths for different purposes
+ */
+export function getConfigPaths() {
+  const platform = os.platform();
+  const homedir = os.homedir();
+  
+  let configDir, dataDir;
+  
+  switch (platform) {
+    case 'win32':
+      configDir = process.env.APPDATA || path.join(homedir, 'AppData', 'Roaming');
+      dataDir = process.env.LOCALAPPDATA || path.join(homedir, 'AppData', 'Local');
+      break;
+    case 'darwin': // macOS
+      configDir = path.join(homedir, 'Library', 'Application Support');
+      dataDir = path.join(homedir, 'Library', 'Application Support');
+      break;
+    default: // Linux and others
+      configDir = process.env.XDG_CONFIG_HOME || path.join(homedir, '.config');
+      dataDir = process.env.XDG_DATA_HOME || path.join(homedir, '.local', 'share');
+      break;
+  }
+  
+  return {
+    config: path.join(configDir, 'maiass'),
+    data: path.join(dataDir, 'maiass'),
+    home: homedir
+  };
+}
+
+/**
+ * Load environment variables from multiple sources with fallback priority:
+ * 1. Current working directory (.env.maiass.local) - highest priority, for sensitive local overrides
+ * 2. Current working directory (.env.maiass) - project-specific config
+ * 3. Home directory (.maiass.env) - user global config
+ * 4. OS-specific config directory (maiass/config.env)
+ * 5. OS secure storage (keychain/secret-tool) - lowest priority, for sensitive vars
+ */
+export function loadEnvironmentConfig() {
+  const paths = getConfigPaths();
+  
+  const loadedFiles = [];
+  
+  // Load files in priority order (lowest to highest priority)
+  const orderedFiles = [
+    path.join(paths.config, 'config.env'),                 
+    path.join(paths.home, '.maiass.env'),                  
+    path.resolve(process.cwd(), '.env.maiass'),             // Project config
+    path.resolve(process.cwd(), '.env.maiass.local')        // Highest priority - local overrides
+  ];
+  
+  // Load all files except the last two without override
+  orderedFiles.slice(0, -2).forEach((envFile) => {
+    if (fs.existsSync(envFile)) {
+      try {
+        dotenv.config({ path: envFile });
+        loadedFiles.push(envFile);
+      } catch (error) {
+        console.warn(`Warning: Could not load ${envFile}:`, error.message);
+      }
+    }
+  });
+  
+  // Load project .env.maiass with override
+  const projectEnv = orderedFiles[orderedFiles.length - 2];
+  if (fs.existsSync(projectEnv)) {
+    try {
+      dotenv.config({ path: projectEnv, override: true });
+      loadedFiles.push(projectEnv);
+    } catch (error) {
+      console.warn(`Warning: Could not load ${projectEnv}:`, error.message);
+    }
+  }
+  
+  // Finally, load .env.maiass.local with override to ensure it takes highest precedence
+  const localEnv = orderedFiles[orderedFiles.length - 1];
+  if (fs.existsSync(localEnv)) {
+    try {
+      dotenv.config({ path: localEnv, override: true });
+      loadedFiles.push(localEnv);
+    } catch (error) {
+      console.warn(`Warning: Could not load ${localEnv}:`, error.message);
+    }
+  }
+  
+  // NOW load secure variables after .env files are loaded
+  // This ensures MAIASS_AI_HOST is set before determining which keychain to use
+  loadSecureVariables();
+  
+  // Return the environment variables along with metadata
+  return {
+    ...process.env,
+    _metadata: {
+      loadedFiles,
+      configPaths: paths
+    }
+  };
+}
+
+/**
+ * Ensure config directories exist
+ */
+export function ensureConfigDirectories() {
+  const paths = getConfigPaths();
+  
+  [paths.config, paths.data].forEach(dir => {
+    if (!fs.existsSync(dir)) {
+      try {
+        fs.mkdirSync(dir, { recursive: true });
+      } catch (error) {
+        console.warn(`Warning: Could not create config directory ${dir}:`, error.message);
+      }
+    }
+  });
+  
+  return paths;
+}
+
+/**
+ * Get the recommended path for storing sensitive environment variables
+ */
+export function getSecureEnvPath() {
+  const paths = getConfigPaths();
+  return path.join(paths.data, 'secure.env');
+}
+
+/**
+ * Get the recommended path for storing general config
+ */
+export function getConfigEnvPath() {
+  const paths = getConfigPaths();
+  return path.join(paths.config, 'config.env');
+}
+
+export default {
+  loadEnvironmentConfig,
+  ensureConfigDirectories,
+  getSecureEnvPath,
+  getConfigEnvPath,
+  getConfigPaths
+};

package/lib/devlog.js

@@ -0,0 +1,182 @@
+// Development logging utility for MAIASS
+// Node.js equivalent of the devlog.sh integration from maiass.sh
+import { exec } from 'child_process';
+import { existsSync } from 'fs';
+import path from 'path';
+import colors from './colors.js';
+import { getGitInfo } from './git-info.js';
+import { logger } from './logger.js';
+
+/**
+ * Check if devlog.sh script exists and is executable
+ * @returns {boolean} True if devlog.sh is available
+ */
+function isDevlogAvailable() {
+  // On Windows, devlog.sh is never available
+  if (process.platform === 'win32') {
+    return false;
+  }
+  // Check if devlog.sh exists in common locations (sync check for immediate availability)
+  const commonPaths = [
+    '/usr/local/bin/devlog.sh',
+    '/usr/bin/devlog.sh',
+    path.join(process.env.HOME || '', 'bin/devlog.sh'),
+    path.join(process.env.HOME || '', '.local/bin/devlog.sh')
+  ];
+  // Quick sync check for file existence
+  if (commonPaths.some(path => existsSync(path))) {
+    return true;
+  }
+  // For PATH check, we'll assume it's available and let the async call handle errors
+  return true;
+}
+
+/**
+ * Extract devlog context from gitInfo object
+ * @param {Object} gitInfo - Git information object
+ * @returns {Object} Context with project, client, and jiraTicket
+ */
+function extractDevlogContext(gitInfo) {
+  const remote = gitInfo?.remote || {};
+  const project = remote.repo || process.env.MAIASS_DEVLOG_PROJECT || 'unknown-project';
+  const client = remote.owner || process.env.MAIASS_DEVLOG_CLIENT || 'unknown-client';
+  const jiraTicket = gitInfo?.jiraTicket || process.env.MAIASS_DEVLOG_JIRA_TICKET || 'no-ticket';
+  
+  return { project, client, jiraTicket };
+}
+
+/**
+ * Log a message using devlog.sh (equivalent to logthis function in maiass.sh)
+ * @param {string} message - The message to log
+ * @param {Object} options - Logging options
+ * @param {string} options.project - Project name (from repo name)
+ * @param {string} options.client - Client name (from repo owner/workspace)
+ * @param {string} options.jiraTicket - JIRA ticket number (from branch or fallback)
+ * @param {string} options.type - Log type (default: c for commit)
+ * @returns {string|null} Debug message from devlog.sh or null if not available
+ */
+export function logThis(message, options = {}) {
+  const {
+    project = process.env.MAIASS_DEVLOG_PROJECT || 'unknown-project',
+    client = process.env.MAIASS_DEVLOG_CLIENT || 'unknown-client',
+    jiraTicket = process.env.MAIASS_DEVLOG_JIRA_TICKET || 'no-ticket',
+    type = 'c'
+  } = options;
+
+  // If devlog.sh is not available, return null (equivalent to empty function in bash)
+  if (!isDevlogAvailable()) {
+      logger.debug(`devlog.sh not available, skipping log: ${message}`);
+    return null;
+  }
+
+  // If explicitly disabled, return null
+  if (process.env.MAIASS_DEVLOG_ENABLED === 'false') {
+    return null;
+  }
+
+  // Escape the message for shell execution
+  const escapedMessage = message.replace(/"/g, '\\"').replace(/\n/g, '; ');
+  
+  // Execute devlog.sh with the same parameters as the bash version (async, non-blocking)
+  const command = `devlog.sh "${escapedMessage}" "?" "${project}" "${client}" "${jiraTicket}"`;
+  
+    logger.debug(`Executing devlog.sh command: ${command}`);
+  
+  // Execute asynchronously - don't block the main workflow (fire-and-forget)
+  exec(command, { encoding: 'utf8' }, (error, stdout, stderr) => {
+    if (error) {
+      
+      if (process.env.MAIASS_DEBUG === 'true') {
+        logger.error(`devlog.sh error: ${error.message}`);
+      }
+      return;
+    }
+    
+    // Only log success confirmation, not the verbose stdout output
+
+      logger.debug(`Logged to devlog.sh: ${escapedMessage}`)  ;
+  });
+  
+  // Return immediately (don't wait for devlog.sh to complete)
+  return null;
+}
+
+/**
+ * Log a commit message (specific use case from maiass.sh)
+ * @param {string} commitMessage - The commit message to log
+ * @param {Object} gitInfo - Git information object (already extracted)
+ * @returns {string|null} Debug message from devlog.sh
+ */
+export function logCommit(commitMessage, gitInfo) {
+  // Clean up commit message (remove newlines, replace with semicolons)
+  const cleanMessage = commitMessage.replace(/\n/g, '; ');
+  
+  // Extract context from already-available gitInfo
+  const context = extractDevlogContext(gitInfo);
+  
+  const options = {
+    type: 'c', // 'c' for commit
+    project: context.project,
+    client: context.client,
+    jiraTicket: context.jiraTicket
+  };
+  
+  return logThis(cleanMessage, options);
+}
+
+/**
+ * Log a merge operation (specific use case from maiass.sh)
+ * @param {string} sourceBranch - Source branch name
+ * @param {string} targetBranch - Target branch name
+ * @param {Object} gitInfo - Git information object (already extracted)
+ * @param {string} operation - Operation type (e.g., "Merged", "Created pull request")
+ * @returns {string|null} Debug message from devlog.sh
+ */
+export function logMerge(sourceBranch, targetBranch, gitInfo, operation = 'Merged') {
+  const message = `${operation} ${sourceBranch} into ${targetBranch}`;
+  
+  // Extract context from already-available gitInfo
+  const context = extractDevlogContext(gitInfo);
+  
+  const options = {
+    type: 'c', // 'c' for commit/merge
+    project: context.project,
+    client: context.client,
+    jiraTicket: context.jiraTicket
+  };
+  
+  return logThis(message, options);
+}
+
+/**
+ * Log a pull request creation
+ * @param {string} version - Version or branch name
+ * @returns {string|null} Debug message from devlog.sh
+ */
+export function logPullRequest(version) {
+  const message = `Created pull request for ${version}`;
+  return logThis(message, { type: 'c' });
+}
+
+/**
+ * Check if devlog functionality is enabled
+ * @returns {boolean} True if devlog should be used
+ */
+export function isDevlogEnabled() {
+  // Check if explicitly disabled
+  if (process.env.MAIASS_DEVLOG_ENABLED === 'false') {
+    return false;
+  }
+  
+  // Check if devlog.sh is available
+  return isDevlogAvailable();
+}
+
+export default {
+  logThis,
+  logCommit,
+  logMerge,
+  logPullRequest,
+  isDevlogEnabled,
+  isDevlogAvailable
+};

package/lib/env-display.js

@@ -0,0 +1,162 @@
+// Environment variable display utility for development and debugging
+import colors from './colors.js';
+import { getConfigPaths, loadEnvironmentConfig } from './config.js';
+import { MAIASS_VARIABLES, getVariableSource } from './maiass-variables.js';
+import { log, logger } from './logger.js';
+import { SYMBOLS } from './symbols.js';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Display all environment variables with source information
+ * @param {Object} options - Display options
+ * @param {boolean} options.showSensitive - Whether to show sensitive variables (masked by default)
+ * @param {boolean} options.showSources - Whether to show which file each variable came from
+ * @param {boolean} options.showAll - Whether to show all process.env variables
+ */
+export function displayEnvironmentVariables(options = {}) {
+  const {
+    showSensitive = false,
+    showSources = true,
+    showAll = false
+  } = options;
+
+  log.info(SYMBOLS.GLOBE, 'Environment Variables Status');
+  console.log();
+  console.log('═'.repeat(50));
+  console.log();
+
+  // Show configuration sources if requested
+  if (showSources) {
+    displayLoadedConfigFiles();
+  }
+
+  // Get loaded files info for source tracking
+  const envConfig = loadEnvironmentConfig();
+  
+  // Display MAIASS-specific variables
+  if (showAll) {
+    displayAllEnvironmentVariables(showSensitive);
+  } else {
+    displayMaiassVariables(showSensitive, envConfig.loadedFiles);
+  }
+
+  console.log('═'.repeat(50));
+  log.success(SYMBOLS.CHECKMARK, 'Environment display complete');
+  log.space();
+}
+
+/**
+ * Display which config files were loaded
+ */
+function displayLoadedConfigFiles() {
+  log.warning(SYMBOLS.FOLDER, 'Configuration Sources:');
+  console.log();
+  
+  const paths = getConfigPaths();
+  const configFiles = [
+    { path: path.resolve(process.cwd(), '.env'), label: 'Project .env', priority: 1 },
+    { path: path.join(paths.home, '.maiass.env'), label: 'User .maiass.env', priority: 2 },
+    { path: path.join(paths.config, 'config.env'), label: 'OS Config', priority: 3 },
+    { path: path.join(paths.data, 'secure.env'), label: 'OS Secure', priority: 4 }
+  ];
+
+  configFiles.forEach(({ path: filePath, label, priority }) => {
+    const exists = fs.existsSync(filePath);
+    const status = exists ? colors.Green(SYMBOLS.CHECK + ' LOADED') : colors.Red(SYMBOLS.X + ' Not found');
+    console.log(`  ${priority}. ${colors.BBlue(label.padEnd(20))} ${status}`);
+    if (exists) {
+      console.log(`     ${colors.Cyan(filePath)}`);
+    }
+  });
+}
+
+/**
+ * Display MAIASS-specific environment variables with sources and defaults
+ */
+function displayMaiassVariables(showSensitive, loadedFiles = []) {
+  log.warning(SYMBOLS.GEAR, 'MAIASS Variables:');
+  console.log();
+
+  // Get all defined MAIASS variables
+  const allVarKeys = Object.keys(MAIASS_VARIABLES).sort();
+  
+  if (allVarKeys.length === 0) {
+    console.log(colors.Yellow('  No MAIASS variables defined'));
+    return;
+  }
+
+  allVarKeys.forEach(key => {
+    const varDef = MAIASS_VARIABLES[key];
+    const currentValue = process.env[key];
+    const isSensitive = varDef.sensitive || false;
+    
+    let displayValue;
+    let source;
+    
+    if (!currentValue) {
+      if (varDef.default) {
+        displayValue = colors.Cyan(`${varDef.default} (default)`);
+        source = colors.Yellow('default');
+      } else {
+        displayValue = colors.Red('(not set)');
+        source = colors.Red('not set');
+      }
+    } else {
+      if (isSensitive && !showSensitive) {
+        displayValue = colors.Yellow(`***${currentValue.slice(-4)} (masked)`);
+      } else {
+        displayValue = colors.Green(currentValue);
+      }
+      source = getVariableSource(key, currentValue, loadedFiles);
+      source = currentValue === varDef.default ? colors.Yellow('default') : colors.Green(source);
+    }
+
+    const keyColor = isSensitive ? colors.BRed : colors.BBlue;
+    console.log(`  ${keyColor(key.padEnd(35))} = ${displayValue}`);
+    console.log(`  ${' '.repeat(37)}   ${colors.Cyan(SYMBOLS.ARROW)} ${source} ${colors.White('(' + varDef.description + ')')}`);
+  });
+}
+
+/**
+ * Display all MAIASS-related environment variables (filtered)
+ */
+function displayAllEnvironmentVariables(showSensitive) {
+  log.warning(SYMBOLS.WRENCH, 'All MAIASS Environment Variables:');
+  console.log();
+
+  // Filter to only MAIASS_ prefixed variables
+  const allVars = Object.entries(process.env)
+    .filter(([key]) => key.startsWith('MAIASS_'))
+    .sort();
+
+  const sensitivePatterns = ['KEY', 'TOKEN', 'SECRET', 'PASSWORD', 'AUTH'];
+
+  if (allVars.length === 0) {
+    console.log(colors.Yellow('  No MAIASS-related environment variables found'));
+    return;
+  }
+
+  allVars.forEach(([key, value]) => {
+    const isSensitive = sensitivePatterns.some(pattern => 
+      key.toUpperCase().includes(pattern)
+    );
+
+    let displayValue;
+    if (isSensitive && !showSensitive) {
+      displayValue = colors.Yellow('*** (masked - use --show-sensitive)');
+    } else {
+      // Truncate very long values
+      displayValue = value.length > 100 
+        ? colors.Cyan(value.slice(0, 100) + '...')
+        : colors.Cyan(value);
+    }
+
+    const keyColor = isSensitive ? colors.BRed : colors.Blue;
+    console.log(`  ${keyColor(key.padEnd(30))} = ${displayValue}`);
+  });
+}
+
+export default {
+  displayEnvironmentVariables
+};