maiass 5.7.31

package/lib/input-utils.js

@@ -0,0 +1,116 @@
+import { createInterface } from 'readline';
+import colors from './colors.js';
+
+/**
+ * Format a user input prompt with distinct visual styling
+ * @param {string} message - The prompt message
+ * @returns {string} Formatted prompt
+ */
+function formatPrompt(message) {
+  // Format: |))  ?  message (bold yellow for calls to action)
+  return `\n${colors.BSoftPink('|))')}  ${colors.BBlueOnWhite(' ? ')}  ${colors.BYellow(message)}`;
+}
+
+/**
+ * Get single character input from user
+ * @param {string} prompt - Prompt message to display
+ * @returns {Promise<string>} Single character input
+ */
+export function getSingleCharInput(prompt) {
+  return new Promise((resolve) => {
+    // Use formatted prompt for better visibility
+    process.stdout.write(formatPrompt(prompt));
+    
+    // Store original state
+    const wasRawMode = process.stdin.isRaw;
+    
+    // Set raw mode to capture single characters
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    
+    const onData = (key) => {
+      // Handle Ctrl+C
+      if (key[0] === 3) {
+        console.log('\n');
+        process.exit(0);
+      }
+      
+      // Get only the first character and convert to lowercase
+      const char = key.toString().charAt(0).toLowerCase();
+      
+      // Echo the character and newline
+      process.stdout.write(char + '\n');
+      
+      // Clean up
+      process.stdin.removeListener('data', onData);
+      process.stdin.setRawMode(wasRawMode);
+      process.stdin.pause();
+      
+      resolve(char);
+    };
+    
+    process.stdin.on('data', onData);
+  });
+}
+
+/**
+ * Get multi-line input from user
+ * @param {string} prompt - Prompt message to display
+ * @returns {Promise<string>} Multi-line input
+ */
+export function getMultiLineInput(prompt) {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    console.log(formatPrompt(prompt));
+    
+    const lines = [];
+    let emptyLineCount = 0;
+    
+    rl.on('line', (line) => {
+      if (line.trim() === '') {
+        emptyLineCount++;
+        if (emptyLineCount >= 3) {
+          rl.close();
+          resolve(lines.join('\n').trim());
+          return;
+        }
+      } else {
+        emptyLineCount = 0;
+        lines.push(line);
+      }
+    });
+    
+    rl.on('SIGINT', () => {
+      console.log('\n');
+      process.exit(0);
+    });
+  });
+}
+
+/**
+ * Get simple line input from user
+ * @param {string} prompt - Prompt message to display
+ * @returns {Promise<string>} Single line input
+ */
+export function getLineInput(prompt) {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    rl.question(formatPrompt(prompt), (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+    
+    rl.on('SIGINT', () => {
+      console.log('\n');
+      process.exit(0);
+    });
+  });
+}

package/lib/logger.js

@@ -0,0 +1,285 @@
+// Centralized logger for MAIASS CLI with consistent branding
+import colors from './colors.js';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+// Store environment variables
+let env = {};
+
+// Debug collection system
+let debugBuffer = [];
+let sessionId = null;
+
+/**
+ * Initialize debug collection session
+ */
+function initDebugSession() {
+  sessionId = `maiass-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  debugBuffer = [];
+}
+
+/**
+ * Add entry to debug buffer
+ * @param {string} level - Log level
+ * @param {string} message - Log message
+ * @param {Object} metadata - Additional metadata
+ */
+function addToDebugBuffer(level, message, metadata = {}) {
+  if (!sessionId) initDebugSession();
+  
+  debugBuffer.push({
+    timestamp: new Date().toISOString(),
+    level,
+    message,
+    ...metadata
+  });
+}
+
+/**
+ * Write debug buffer to temporary file
+ * @returns {string} Path to debug file
+ */
+export function writeDebugFile() {
+  if (!sessionId || debugBuffer.length === 0) return null;
+  
+  try {
+    const tempDir = os.tmpdir();
+    const debugFile = path.join(tempDir, `${sessionId}.debug.log`);
+    
+    const debugContent = debugBuffer
+      .map(entry => `[${entry.timestamp}] ${entry.level.toUpperCase()}: ${entry.message}`)
+      .join('\n');
+    
+    fs.writeFileSync(debugFile, debugContent, 'utf8');
+    return debugFile;
+  } catch (error) {
+    console.error('Failed to write debug file:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Get current debug session info
+ * @returns {Object} Session info
+ */
+export function getDebugSession() {
+  return {
+    sessionId,
+    entryCount: debugBuffer.length,
+    hasErrors: debugBuffer.some(entry => entry.level === 'error')
+  };
+}
+
+/**
+ * Initialize logger with environment variables
+ * @param {Object} environment - Environment variables
+ */
+export function initLogger(environment) {
+  env = { ...environment };
+}
+
+/**
+ * Check if message should be shown based on verbosity level
+ * @param {string} level - Message level: 'error', 'warning', 'info', 'debug', 'critical', 'prompt'
+ * @returns {boolean} - Whether to show the message
+ */
+function shouldLog(level) {
+  const verbosity = env.MAIASS_VERBOSITY || process.env.MAIASS_VERBOSITY || 'brief';
+  
+  // Always show errors, prompts, and critical messages
+  if (['error', 'critical', 'prompt'].includes(level)) return true;
+  
+  // For brief: only errors, critical messages, prompts, final results, and important warnings
+  if (verbosity === 'brief') {
+    return ['error', 'critical', 'prompt', 'success', 'warning'].includes(level);
+  }
+  
+  // For normal: errors, warnings, success, and important info
+  if (verbosity === 'normal') {
+    return ['error', 'warning', 'success', 'info', 'critical', 'prompt'].includes(level);
+  }
+  
+  // For verbose/debug: show everything
+  if (verbosity === 'verbose' || verbosity === 'debug') {
+    return true;
+  }
+  
+  return false;
+}
+
+// Bold soft pink prefix for MAIASS branding
+const MAIASS_PREFIX = colors.BSoftPink('|))');
+
+export const log = {
+  logThis: (prefix, icon, message) => {
+    // Format: |))  icon  message (prefix always first)
+    const prefixPart = prefix ? `${prefix}  ` : '';
+    const iconPart = icon ? `${icon}  ` : '';
+    console.log(`${prefixPart}${iconPart}${message}`);
+    addToDebugBuffer('info', `${icon} ${message}`);
+  },
+
+  // Main branded message types with icons
+  info: (icon, message, bold=false) => {
+    if (!shouldLog('info')) return;
+    log.logThis(MAIASS_PREFIX, colors.BCyan(icon), bold?colors.BCyan(message):colors.Cyan(message));
+  },
+
+  success: (icon, message, bold=false) => {
+    if (!shouldLog('success')) return;
+    log.logThis(MAIASS_PREFIX, colors.BGreen(icon), bold?colors.BGreen(message):colors.Green(message));
+  },
+
+  aisuggestion: (icon, message, bold=true) => {
+    if (!shouldLog('prompt')) return;
+    log.logThis('', colors.BYellowBright(icon), bold?colors.BYellowBright(message):colors.BYellowBright(message));
+  },
+
+  warning: (icon, message, bold=false) => {
+    if (!shouldLog('warning')) return;
+    log.logThis(MAIASS_PREFIX, colors.BOrange(icon), bold?colors.BOrange(message):colors.Orange(message));
+  },
+
+  error: (icon, message, bold=false) => {
+    const msg = bold ? colors.BRed(message) : colors.Red(message);
+    const fullMessage = `${MAIASS_PREFIX}  ${colors.BRed(icon)}  ${msg}`;
+    console.error(fullMessage);
+    addToDebugBuffer('error', `${icon} ${message}`);
+  },
+
+  blue: (icon, message, bold=false) => {
+    if (!shouldLog('info')) return;
+    log.logThis(MAIASS_PREFIX, colors.BBlue(icon), bold?colors.BBlue(message):colors.Blue(message));
+  },
+
+  purple: (icon, message, bold=false) => {
+    if (!shouldLog('info')) return;
+    log.logThis(MAIASS_PREFIX, colors.BPurple(icon), bold?colors.BPurple(message):colors.Purple(message));
+  },
+
+  BWhite: (icon, message, bold=false) => {
+    if (!shouldLog('info')) return;
+    log.logThis(MAIASS_PREFIX, colors.BWhite(icon), bold?colors.BWhite(message):colors.White(message));
+  },
+
+  blueOnWhite: (icon, message, bold=false) => {
+    if (!shouldLog('info')) return;
+    log.logThis(MAIASS_PREFIX, colors.BBlueOnWhite(icon), bold?colors.BBlueOnWhite(message):colors.BlueOnWhite(message));
+  },
+
+  // Custom color variants
+  custom: (icon, message, colorFn) => {
+    if (!shouldLog('info')) return;
+    log.logThis(MAIASS_PREFIX, colorFn(icon), colorFn(message));
+  },
+
+  // Plain messages without icons (for indented content, spacing, etc.)
+  plain: (message) => {
+    if (!shouldLog('info')) return;
+    console.log(message);
+  },
+
+  // Branded plain message (no icon, but with | )) prefix)
+  branded: (message, colorFn = colors.White) => {
+    if (!shouldLog('info')) return;
+    console.log(`${MAIASS_PREFIX} ${colorFn(message)}`);
+  },
+
+  // Empty line
+  space: () => {
+    if (!shouldLog('info')) return;
+    console.log();
+  },
+
+  // Indented content (for sub-items under main messages)
+  indent: (message, colorFn = colors.Gray) => {
+    if (!shouldLog('info')) return;
+    console.log(`    ${colorFn(message)}`);
+  },
+
+  // Critical messages that should always show regardless of verbosity
+  critical: (icon, message, bold=false) => {
+    log.logThis(MAIASS_PREFIX, colors.BCyan(icon), bold?colors.BCyan(message):colors.Cyan(message));
+  },
+
+  // User prompts that should always show
+  prompt: (message, colorFn = colors.White) => {
+    console.log(colorFn(message));
+  },
+
+  // debug message (with MAIASS branding)
+  debug: (label, data) => {
+    const debugEnabled = env.MAIASS_DEBUG === 'true' || env.MAIASS_DEBUG === true || 
+                        process.env.MAIASS_DEBUG === 'true' || process.env.MAIASS_DEBUG === true;
+    if (!debugEnabled) return;
+    
+    const timestamp = new Date().toISOString();
+    const debugPrefix = colors.Blue('🐛  |))  ');
+    const timestampStr = colors.Gray(`[${timestamp}]`);
+    
+    // Ensure we're writing to stderr to avoid mixing with other output
+    const output = process.stderr;
+    
+    // Write the debug message header
+    output.write(`${debugPrefix} ${timestampStr} ${colors.Blue(label)}\n`);
+    
+    // If we have data, pretty-print it with 2-space indentation
+    if (data !== undefined) {
+      const jsonStr = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+      // Split into lines and indent each line
+      const lines = jsonStr.split('\n');
+      for (const line of lines) {
+        output.write(`  ${colors.Gray(line)}\n`);
+      }
+    }
+    
+    // Ensure everything is flushed
+    output.write('');
+  },
+
+  // Indented with arrow (for config values, etc.)
+  indentArrow: (message, colorFn = colors.Gray) => {
+    if (!shouldLog('info')) return;
+    console.log(`    ${colorFn('→')} ${colorFn(message)}`);
+  }
+  
+};
+
+// Convenience methods for common patterns
+export const logger = {
+  ...log,
+  
+  // Common CLI patterns
+  header: (icon, title) => {
+    log.info(icon, title);
+    log.space();
+  },
+
+  section: (title, colorFn = colors.BBlue) => {
+    log.custom('📁', title, colorFn);
+    log.space();
+  },
+
+  configItem: (key, value, source = '', description = '') => {
+    const keyColor = colors.BWhite;
+    const valueColor = colors.White;
+    const sourceColor = colors.Gray;
+    
+    log.plain(`    ${keyColor(key.padEnd(25))} = ${valueColor(value)}`);
+    if (source) {
+      log.plain(`    ${' '.repeat(25)}   ${sourceColor(`→ ${source}`)} ${colors.Gray(`(${description})`)}`);
+    }
+    log.space();
+  },
+
+  usage: (examples) => {
+    log.blue('ℹ️', 'Usage examples:');
+    examples.forEach(example => {
+      log.plain(`  ${example}`);
+    });
+  }
+};
+
+export default logger;

package/lib/machine-fingerprint.js

@@ -0,0 +1,229 @@
+// Machine fingerprinting for abuse prevention
+// Generates stable device identifiers using hardware characteristics
+// Matches bashmaiass implementation: MAC|CPU|Disk|Kernel → SHA-256 hex
+
+import os from 'os';
+import crypto from 'crypto';
+import { execSync } from 'child_process';
+import { logger } from './logger.js';
+
+/**
+ * Get MAC address for fingerprinting
+ * @returns {string} MAC address of primary network interface
+ */
+function getMacAddress() {
+  try {
+    const platform = os.platform();
+    
+    if (platform === 'linux') {
+      // Use ip command on Linux
+      const result = execSync('ip link | awk \'/ether/ {print $2; exit}\'', 
+        { encoding: 'utf8', timeout: 3000 }).trim();
+      if (result && result !== '') {
+        return result;
+      }
+    } else if (platform === 'darwin') {
+      // macOS - match bashmaiass exactly
+      const result = execSync('networksetup -listallhardwareports | awk \'/Wi-Fi|Ethernet/{getline; print $2; exit}\'', 
+        { encoding: 'utf8', timeout: 3000 }).trim();
+      if (result && result !== '') {
+        return result;
+      }
+    }
+    
+    // Fallback: try to get from network interfaces
+    const interfaces = os.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+      const iface = interfaces[name];
+      if (iface) {
+        for (const alias of iface) {
+          if (!alias.internal && alias.mac && alias.mac !== '00:00:00:00:00:00') {
+            return alias.mac;
+          }
+        }
+      }
+    }
+  } catch (error) {
+    logger.debug('Could not get MAC address:', error.message);
+  }
+  return 'unknown-mac';
+}
+
+/**
+ * Get CPU information for fingerprinting
+ * @returns {string} CPU brand string
+ */
+function getCpuInfo() {
+  try {
+    const platform = os.platform();
+    
+    if (platform === 'darwin') {
+      // Use sysctl on macOS to match bashmaiass
+      const result = execSync('sysctl -n machdep.cpu.brand_string', 
+        { encoding: 'utf8', timeout: 3000 }).trim();
+      if (result && result !== '') {
+        return result;
+      }
+    } else if (platform === 'linux') {
+      // Use /proc/cpuinfo on Linux
+      const result = execSync('grep -m1 "model name" /proc/cpuinfo | cut -d ":" -f 2 | xargs', 
+        { encoding: 'utf8', timeout: 3000 }).trim();
+      if (result && result !== '') {
+        return result;
+      }
+    }
+    
+    // Fallback to Node.js os.cpus()
+    const cpus = os.cpus();
+    if (cpus && cpus.length > 0) {
+      return cpus[0].model;
+    }
+  } catch (error) {
+    logger.debug('Could not get CPU info:', error.message);
+  }
+  return 'unknown-cpu';
+}
+
+/**
+ * Get disk identifier for fingerprinting
+ * @returns {string} Disk/volume identifier
+ */
+function getDiskIdentifier() {
+  try {
+    const platform = os.platform();
+    
+    if (platform === 'darwin') {
+      // Get volume UUID on macOS - match bashmaiass exactly
+      const result = execSync('diskutil info / | grep "Volume UUID" | awk \'{print $3}\'', 
+        { encoding: 'utf8', timeout: 3000 }).trim();
+      if (result && result !== '') {
+        return result;
+      }
+    } else if (platform === 'linux') {
+      // Get disk serial on Linux
+      const rootDisk = execSync('df / | tail -1 | awk \'{print $1}\' | sed \'s/[0-9]*$//\'', 
+        { encoding: 'utf8', timeout: 3000 }).trim();
+      if (rootDisk) {
+        const serial = execSync(`lsblk -no SERIAL "${rootDisk}" 2>/dev/null || echo "unknown-serial"`, 
+          { encoding: 'utf8', timeout: 3000 }).trim();
+        if (serial && serial !== '') {
+          return serial;
+        }
+      }
+    }
+  } catch (error) {
+    logger.debug('Could not get disk identifier:', error.message);
+  }
+  return 'unknown-disk';
+}
+
+/**
+ * Get kernel information for fingerprinting
+ * @returns {string} Kernel info (system, release, machine)
+ */
+function getKernelInfo() {
+  try {
+    // Use uname -srm to match bashmaiass
+    const result = execSync('uname -srm', 
+      { encoding: 'utf8', timeout: 3000 }).trim();
+    if (result && result !== '') {
+      return result;
+    }
+  } catch (error) {
+    logger.debug('Could not get kernel info:', error.message);
+  }
+  
+  // Fallback using Node.js os module
+  return `${os.type()} ${os.release()} ${os.arch()}`;
+}
+
+/**
+ * Generate a stable machine fingerprint for abuse prevention - V1 (LEGACY)
+ * Algorithm: MAC|CPU|Disk|Kernel → SHA-256 hex
+ * WARNING: Includes kernel version which changes on OS updates
+ * @returns {string} SHA-256 hex fingerprint hash
+ * @deprecated Use generateMachineFingerprint() (V2) instead
+ */
+export function generateMachineFingerprintV1() {
+  try {
+    const mac = getMacAddress();
+    const cpu = getCpuInfo();
+    const disk = getDiskIdentifier();
+    const kernel = getKernelInfo();
+    
+    // V1: Includes kernel (causes issues on OS updates)
+    const fingerprintInput = `${mac}|${cpu}|${disk}|${kernel}`;
+    
+    const hash = crypto.createHash('sha256').update(fingerprintInput).digest('hex');
+    
+    logger.debug('Machine fingerprint V1 components:', {
+      mac: mac,
+      cpu: cpu,
+      disk: disk,
+      kernel: kernel,
+      input: fingerprintInput
+    });
+    
+    return hash;
+  } catch (error) {
+    logger.error('Failed to generate machine fingerprint V1:', error.message);
+    const fallback = `${os.platform()}-${os.arch()}-${os.userInfo().username}-FALLBACK`;
+    return crypto.createHash('sha256').update(fallback).digest('hex');
+  }
+}
+
+/**
+ * Generate a stable machine fingerprint for abuse prevention - V2 (CURRENT)
+ * Algorithm: MAC|CPU|Disk → SHA-256 hex (hardware-only, no kernel)
+ * This version excludes kernel to prevent fingerprint changes on OS updates
+ * Matches bashmaiass V2 implementation
+ * @returns {string} SHA-256 hex fingerprint hash
+ */
+export function generateMachineFingerprint() {
+  try {
+    // Get hardware components only (no kernel)
+    const mac = getMacAddress();
+    const cpu = getCpuInfo();
+    const disk = getDiskIdentifier();
+    
+    // V2: Hardware-only (no kernel version)
+    // This prevents fingerprint changes on OS updates
+    const fingerprintInput = `${mac}|${cpu}|${disk}`;
+    
+    // Generate SHA-256 hash in hex format to match bashmaiass
+    const hash = crypto.createHash('sha256').update(fingerprintInput).digest('hex');
+    
+    logger.debug('Machine fingerprint V2 components:', {
+      mac: mac,
+      cpu: cpu,
+      disk: disk,
+      input: fingerprintInput,
+      version: 'V2 (hardware-only)'
+    });
+    
+    return hash;
+  } catch (error) {
+    logger.error('Failed to generate machine fingerprint V2:', error.message);
+    logger.warn('SECURITY WARNING: Using minimal fallback fingerprint');
+    const fallback = `${os.platform()}-${os.arch()}-${os.userInfo().username}-FALLBACK`;
+    return crypto.createHash('sha256').update(fallback).digest('hex');
+  }
+}
+
+/**
+ * Get a shortened machine fingerprint for display/logging
+ * @returns {string} First 12 characters of the fingerprint
+ */
+export function getShortFingerprint() {
+  return generateMachineFingerprint().substring(0, 12);
+}
+
+/**
+ * Validate that the current machine fingerprint matches a stored one
+ * @param {string} storedFingerprint - Previously stored fingerprint
+ * @returns {boolean} True if fingerprints match
+ */
+export function validateMachineFingerprint(storedFingerprint) {
+  const currentFingerprint = generateMachineFingerprint();
+  return currentFingerprint === storedFingerprint;
+}

package/lib/maiass-command.js

@@ -0,0 +1,79 @@
+import { log, logger } from './logger.js';
+import { SYMBOLS } from './symbols.js';
+import { runMaiassPipeline } from './maiass-pipeline.js';
+import colors from './colors.js';
+
+/**
+ * Handle the main MAIASS command
+ * @param {Object} args - Command arguments from yargs
+ */
+export async function handleMaiassCommand(args) {
+  const {
+    _: positionalArgs,
+    'commits-only': commitsOnly,
+    'auto-stage': autoStage,
+    'version-bump': versionBump,
+    'dry-run': dryRun,
+    tag,
+    force,
+    silent
+  } = args;
+  
+  // Extract version bump from positional arguments if provided
+  let bumpType = versionBump;
+  if (positionalArgs.length > 0 && !bumpType) {
+    bumpType = positionalArgs[0];
+  }
+  
+  // Default to 'patch' if no version bump specified and not commits-only
+  if (!bumpType && !commitsOnly) {
+    bumpType = 'patch';
+  }
+  
+  logger.header('', 'MAIASS - Modular AI-Assisted Semantic Scribe');
+  
+  try {
+    // Run the complete MAIASS pipeline
+    const result = await runMaiassPipeline({
+      commitsOnly,
+      autoStage,
+      versionBump: bumpType,
+      dryRun,
+      tag,
+      force,
+      silent
+    });
+    
+    if (result.success) {
+      // Success message already shown in pipeline
+      
+      // Display summary if not commits-only
+      if (!commitsOnly && result.versionResult && !result.versionResult.skipped) {
+        log.space();
+        log.info(SYMBOLS.INFO, 'Workflow Summary:');
+        log.indent(`${colors.Gray('Phase:')} ${colors.White('Complete Pipeline')}`);
+        if (result.versionResult.bumpType) {
+          log.indent(`${colors.Gray('Version Bump:')} ${colors.White(result.versionResult.bumpType)}`);
+        }
+        if (result.mergeResult && result.mergeResult.merged) {
+          log.indent(`${colors.Gray('Merge:')} ${colors.White('Completed')}`);
+        }
+      }
+      
+      log.space();
+      log.blue(SYMBOLS.INFO, 'Thank you for using MAIASS!');
+    } else if (result.cancelled) {
+      log.warning(SYMBOLS.INFO, 'Workflow cancelled by user');
+    } else {
+      console.error(colors.Red(`${SYMBOLS.CROSS} Workflow failed: ${result.error || 'Unknown error'}`));
+      process.exit(1);
+    }
+    
+  } catch (error) {
+    console.error(colors.Red(`${SYMBOLS.CROSS} MAIASS command failed: ${error.message}`));
+    if (process.env.MAIASS_DEBUG === 'true') {
+      console.error(colors.Gray(error.stack));
+    }
+    process.exit(1);
+  }
+}