maiass 5.9.5 → 5.9.7

package/lib/commit.js

@@ -13,6 +13,51 @@ import { logCommit } from './devlog.js';
 import colors from './colors.js';
 import chalk from 'chalk';
 
+/**
+ * Simple spinner for AI API calls
+ */
+class Spinner {
+  constructor(message = 'Working') {
+    this.message = message;
+    this.frames = ['\u280b', '\u2819', '\u2839', '\u2838', '\u283c', '\u2834', '\u2826', '\u2827', '\u2807', '\u280f'];
+    this.frameIndex = 0;
+    this.intervalId = null;
+    this.isSpinning = false;
+  }
+
+  start() {
+    if (this.isSpinning) return;
+    this.isSpinning = true;
+    
+    // Hide cursor
+    process.stderr.write('\x1B[?25l');
+    
+    this.intervalId = setInterval(() => {
+      const frame = this.frames[this.frameIndex];
+      process.stderr.write(`\r${colors.BYellow(frame)} ${this.message}...`);
+      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+    }, 100);
+  }
+
+  stop(success = true) {
+    if (!this.isSpinning) return;
+    this.isSpinning = false;
+    
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    
+    // Clear line and show cursor
+    process.stderr.write('\r' + ' '.repeat(100) + '\r');
+    process.stderr.write('\x1B[?25h');
+    
+    if (success) {
+      process.stderr.write(`${colors.BGreen('\u2713')} Done\n`);
+    }
+  }
+}
+
 /**
  * Get color for credit display based on remaining credits (matches bashmaiass)
  * @param {number} credits - Remaining credits
@@ -373,111 +418,150 @@ ${gitDiff}`;
       log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Request body: ${JSON.stringify(requestBody, null, 2)}`);
     }
 
-    const response = await fetch(aiEndpoint, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${maiassToken}`,
-        'X-Machine-Fingerprint': generateMachineFingerprint(),
-        'X-Client-Name': getClientName(),
-        'X-Client-Version': getClientVersion(),
-        'X-Subscription-ID': process.env.MAIASS_SUBSCRIPTION_ID || ''
-      },
-      body: JSON.stringify(requestBody)
-    });
+    // Set timeout for API call (default 30 seconds)
+    const timeout = parseInt(process.env.MAIASS_AI_TIMEOUT || '30') * 1000;
     
     if (debugMode) {
-      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Response status: ${response.status} ${response.statusText}`);
-      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Response headers: ${JSON.stringify(Object.fromEntries(response.headers), null, 2)}`);
+      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] API timeout set to ${timeout/1000} seconds`);
     }
-    
-    if (!response.ok) {
-      const errorText = await response.text();
-      if (debugMode) {
-        log.debug(SYMBOLS.WARNING, `[MAIASS DEBUG] Response error body: ${errorText}`);
-      }
-      log.error(SYMBOLS.WARNING, `AI API request failed: ${response.status} ${response.statusText}`);
-      return null;
-    }
-    
-    const data = await response.json();
-    
-    if (debugMode) {
-      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Response data: ${JSON.stringify(data, null, 2)}`);
-    }
-    
-    if (data.choices && data.choices.length > 0) {
-      let suggestion = data.choices[0].message.content.trim();
 
-      // Enhanced debug logging: output the suggestion returned by AI
+    // Start spinner (unless in debug mode)
+    const spinner = !debugMode ? new Spinner('Waiting for AI response') : null;
+    if (spinner) spinner.start();
+
+    try {
+      // Fetch with timeout using AbortController
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+      const response = await fetch(aiEndpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${maiassToken}`,
+          'X-Machine-Fingerprint': generateMachineFingerprint(),
+          'X-Client-Name': getClientName(),
+          'X-Client-Version': getClientVersion(),
+          'X-Subscription-ID': process.env.MAIASS_SUBSCRIPTION_ID || ''
+        },
+        body: JSON.stringify(requestBody),
+        signal: controller.signal
+      });
+      
+      clearTimeout(timeoutId);
+      
+      // Stop spinner on success
+      if (spinner) spinner.stop(true);
+      
       if (debugMode) {
-        log.debug(SYMBOLS.INFO, '[MAIASS DEBUG] --- AI SUGGESTION RETURNED ---');
-        log.debug(SYMBOLS.INFO, suggestion);
+        log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Response status: ${response.status} ${response.statusText}`);
+        log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Response headers: ${JSON.stringify(Object.fromEntries(response.headers), null, 2)}`);
+      }
+      
+      if (!response.ok) {
+        const errorText = await response.text();
+        if (debugMode) {
+          log.debug(SYMBOLS.WARNING, `[MAIASS DEBUG] Response error body: ${errorText}`);
+        }
+        log.error(SYMBOLS.WARNING, `AI API request failed: ${response.status} ${response.statusText}`);
+        return null;
       }
       
-      // Clean up any quotes that might wrap the entire response
-      if ((suggestion.startsWith("'") && suggestion.endsWith("'")) || 
-          (suggestion.startsWith('"') && suggestion.endsWith('"'))) {
-        suggestion = suggestion.slice(1, -1).trim();
+      // Parse JSON response inside the same try block
+      const data = await response.json();
+      
+      if (debugMode) {
+        log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Response data: ${JSON.stringify(data, null, 2)}`);
       }
       
-      // Extract credit information from billing data
-      let creditsUsed, creditsRemaining;
-      if (data.billing) {
-        creditsUsed = data.billing.credits_used;
-        creditsRemaining = data.billing.credits_remaining;
+      if (data.choices && data.choices.length > 0) {
+        let suggestion = data.choices[0].message.content.trim();
+
+        // Enhanced debug logging: output the suggestion returned by AI
+        if (debugMode) {
+          log.debug(SYMBOLS.INFO, '[MAIASS DEBUG] --- AI SUGGESTION RETURNED ---');
+          log.debug(SYMBOLS.INFO, suggestion);
+        }
         
-        // Show warnings if available
-        if (data.billing.warning) {
-          log.warning(SYMBOLS.WARNING, data.billing.warning);
+        // Clean up any quotes that might wrap the entire response
+        if ((suggestion.startsWith("'") && suggestion.endsWith("'")) || 
+            (suggestion.startsWith('"') && suggestion.endsWith('"'))) {
+          suggestion = suggestion.slice(1, -1).trim();
         }
         
-        // Display proxy messages if available
-        if (data.messages && Array.isArray(data.messages)) {
-          data.messages.forEach(message => {
-            const icon = message.icon || '';
-            const text = message.text || '';
-            
-            switch (message.type) {
-              case 'error':
-                log.error(icon, text);
-                break;
-              case 'warning':
-                log.warning(icon, text);
-                break;
-              case 'info':
-                log.info(icon, text);
-                break;
-              case 'notice':
-                log.blue(icon, text);
-                break;
-              case 'success':
-                log.success(icon, text);
-                break;
-              default:
-                log.plain(`${icon} ${text}`);
-            }
-          });
+        // Extract credit information from billing data
+        let creditsUsed, creditsRemaining;
+        if (data.billing) {
+          creditsUsed = data.billing.credits_used;
+          creditsRemaining = data.billing.credits_remaining;
+          
+          // Show warnings if available
+          if (data.billing.warning) {
+            log.warning(SYMBOLS.WARNING, data.billing.warning);
+          }
+          
+          // Display proxy messages if available
+          if (data.messages && Array.isArray(data.messages)) {
+            data.messages.forEach(message => {
+              const icon = message.icon || '';
+              const text = message.text || '';
+              
+              switch (message.type) {
+                case 'error':
+                  log.error(icon, text);
+                  break;
+                case 'warning':
+                  log.warning(icon, text);
+                  break;
+                case 'info':
+                  log.info(icon, text);
+                  break;
+                case 'notice':
+                  log.blue(icon, text);
+                  break;
+                case 'success':
+                  log.success(icon, text);
+                  break;
+                default:
+                  log.plain(`${icon} ${text}`);
+              }
+            });
+          }
+        } else if (data.usage) {
+          // Fallback to legacy token display
+          const totalTokens = data.usage.total_tokens || 0;
+          const promptTokens = data.usage.prompt_tokens || 0;
+          const completionTokens = data.usage.completion_tokens || 0;
+          log.info(SYMBOLS.INFO, `Total Tokens: ${totalTokens} (${promptTokens} + ${completionTokens})`);
         }
-      } else if (data.usage) {
-        // Fallback to legacy token display
-        const totalTokens = data.usage.total_tokens || 0;
-        const promptTokens = data.usage.prompt_tokens || 0;
-        const completionTokens = data.usage.completion_tokens || 0;
-        log.info(SYMBOLS.INFO, `Total Tokens: ${totalTokens} (${promptTokens} + ${completionTokens})`);
+        
+        return {
+          suggestion,
+          creditsUsed,
+          creditsRemaining
+        };
       }
       
-      return {
-        suggestion,
-        creditsUsed,
-        creditsRemaining
-      };
-    }
-    
-    if (debugMode) {
-      log.debug(SYMBOLS.WARNING, '[MAIASS DEBUG] No valid AI response received - no choices in response data');
+      if (debugMode) {
+        log.debug(SYMBOLS.WARNING, '[MAIASS DEBUG] No valid AI response received - no choices in response data');
+      }
+      return null;
+    } catch (error) {
+      // Stop spinner on error
+      if (spinner) spinner.stop(false);
+      
+      if (error.name === 'AbortError') {
+        log.error(SYMBOLS.WARNING, `AI request timed out after ${timeout/1000} seconds`);
+        log.info(SYMBOLS.INFO, 'The AI service might be slow or unresponsive. Try again or increase MAIASS_AI_TIMEOUT.');
+        return null;
+      }
+      
+      if (debugMode) {
+        log.debug(SYMBOLS.WARNING, `[MAIASS DEBUG] AI suggestion error details: ${error.stack || error.message}`);
+      }
+      log.error(SYMBOLS.WARNING, `AI suggestion failed: ${error.message}`);
+      return null;
     }
-    return null;
   } catch (error) {
     if (debugMode) {
       log.debug(SYMBOLS.WARNING, `[MAIASS DEBUG] AI suggestion error details: ${error.stack || error.message}`);

package/lib/maiass-variables.js

@@ -18,6 +18,7 @@ export const MAIASS_VARIABLES = {
   '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_TIMEOUT': { default: '30', description: 'AI request timeout in seconds' },
   'MAIASS_AI_COMMIT_MESSAGE_STYLE': { default: 'bullet', description: 'Commit message style' },
 
   // Version file system

package/lib/secure-storage.js

@@ -1,11 +1,67 @@
 // Secure storage functionality for nodemaiass
 // Uses OS keychain (macOS) or secret-tool (Linux) for sensitive data storage
+// Windows uses encrypted file storage in AppData
 // Compatible with bashmaiass approach but uses NODEMAIASS service names
 
 import { execSync } from 'child_process';
 import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
 import { log, logger } from './logger.js';
 
+/**
+ * Encryption key derivation for Windows storage
+ * Uses machine-specific data to create a unique encryption key
+ * @returns {Buffer} Encryption key
+ */
+function getEncryptionKey() {
+  // Use machine-specific data to derive a key
+  // This provides basic protection while being deterministic per machine
+  const machineId = os.hostname() + os.userInfo().username;
+  return crypto.createHash('sha256').update(machineId).digest();
+}
+
+/**
+ * Encrypt data for Windows storage
+ * @param {string} data - Data to encrypt
+ * @returns {string} Encrypted data (base64)
+ */
+function encryptData(data) {
+  const key = getEncryptionKey();
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
+  
+  let encrypted = cipher.update(data, 'utf8', 'base64');
+  encrypted += cipher.final('base64');
+  
+  // Prepend IV to encrypted data
+  return iv.toString('base64') + ':' + encrypted;
+}
+
+/**
+ * Decrypt data from Windows storage
+ * @param {string} encryptedData - Encrypted data (base64 with IV)
+ * @returns {string} Decrypted data
+ */
+function decryptData(encryptedData) {
+  const key = getEncryptionKey();
+  const parts = encryptedData.split(':');
+  
+  if (parts.length !== 2) {
+    throw new Error('Invalid encrypted data format');
+  }
+  
+  const iv = Buffer.from(parts[0], 'base64');
+  const encrypted = parts[1];
+  
+  const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
+  let decrypted = decipher.update(encrypted, 'base64', 'utf8');
+  decrypted += decipher.final('utf8');
+  
+  return decrypted;
+}
+
 /**
  * Get environment-specific service name for secure storage
  * Uses NODEMAIASS prefix to differentiate from bashmaiass
@@ -46,6 +102,42 @@ export function storeSecureVariable(varName, varValue) {
       execSync(`security add-generic-password -U -s "${serviceName}" -a "${varName}" -w "${varValue}"`, {
         stdio: 'pipe'
       });
+    } else if (os.platform() === 'win32') {
+      // Windows: Use encrypted file storage in AppData
+      // cmdkey doesn't support password retrieval, so we use a file-based approach
+      const storageDir = path.join(os.homedir(), 'AppData', 'Local', 'maiass');
+      const storageFile = path.join(storageDir, `${serviceName}.dat`);
+      
+      // Create directory if it doesn't exist
+      if (!fs.existsSync(storageDir)) {
+        fs.mkdirSync(storageDir, { recursive: true, mode: 0o700 });
+      }
+      
+      // Read existing data or create new
+      let data = {};
+      if (fs.existsSync(storageFile)) {
+        try {
+          const encrypted = fs.readFileSync(storageFile, 'utf8');
+          const decrypted = decryptData(encrypted);
+          data = JSON.parse(decrypted);
+        } catch (error) {
+          // If decryption fails, start fresh
+          if (debugMode) {
+            logger.debug(`Could not read existing storage file: ${error.message}`);
+          }
+        }
+      }
+      
+      // Update the value
+      data[varName] = varValue;
+      
+      // Encrypt and save
+      const encrypted = encryptData(JSON.stringify(data));
+      fs.writeFileSync(storageFile, encrypted, { mode: 0o600 });
+      
+      if (debugMode) {
+        logger.debug(`Stored ${varName} in Windows secure storage (encrypted file)`);
+      }
     } else {
       // Linux: Use secret-tool if available
       try {
@@ -96,6 +188,33 @@ export function retrieveSecureVariable(varName) {
         stdio: 'pipe',
         encoding: 'utf8'
       }).trim();
+    } else if (os.platform() === 'win32') {
+      // Windows: Read from encrypted file storage
+      const storageDir = path.join(os.homedir(), 'AppData', 'Local', 'maiass');
+      const storageFile = path.join(storageDir, `${serviceName}.dat`);
+      
+      if (!fs.existsSync(storageFile)) {
+        if (debugMode) {
+          logger.debug(`Storage file does not exist: ${storageFile}`);
+        }
+        return null;
+      }
+      
+      try {
+        const encrypted = fs.readFileSync(storageFile, 'utf8');
+        const decrypted = decryptData(encrypted);
+        const data = JSON.parse(decrypted);
+        value = data[varName] || null;
+        
+        if (debugMode && value) {
+          logger.debug(`Retrieved ${varName} from Windows secure storage (encrypted file)`);
+        }
+      } catch (error) {
+        if (debugMode) {
+          logger.debug(`Could not retrieve ${varName}: ${error.message}`);
+        }
+        return null;
+      }
     } else {
       // Linux: Use secret-tool if available
       try {
@@ -144,6 +263,44 @@ export function removeSecureVariable(varName) {
       execSync(`security delete-generic-password -s "${serviceName}" -a "${varName}"`, {
         stdio: 'pipe'
       });
+    } else if (os.platform() === 'win32') {
+      // Windows: Remove from encrypted file storage
+      const storageDir = path.join(os.homedir(), 'AppData', 'Local', 'maiass');
+      const storageFile = path.join(storageDir, `${serviceName}.dat`);
+      
+      if (!fs.existsSync(storageFile)) {
+        // File doesn't exist, nothing to remove
+        if (debugMode) {
+          logger.debug(`Storage file does not exist, nothing to remove`);
+        }
+        return true;
+      }
+      
+      try {
+        const encrypted = fs.readFileSync(storageFile, 'utf8');
+        const decrypted = decryptData(encrypted);
+        const data = JSON.parse(decrypted);
+        
+        // Remove the variable
+        delete data[varName];
+        
+        // If no more data, delete the file
+        if (Object.keys(data).length === 0) {
+          fs.unlinkSync(storageFile);
+          if (debugMode) {
+            logger.debug(`Removed storage file (no more credentials)`);
+          }
+        } else {
+          // Save updated data
+          const newEncrypted = encryptData(JSON.stringify(data));
+          fs.writeFileSync(storageFile, newEncrypted, { mode: 0o600 });
+        }
+      } catch (error) {
+        if (debugMode) {
+          logger.debug(`Error removing ${varName}: ${error.message}`);
+        }
+        return false;
+      }
     } else {
       // Linux: secret-tool doesn't have direct delete, but we can try to clear it
       try {
@@ -236,7 +393,11 @@ export function isSecureStorageAvailable() {
     if (os.platform() === 'darwin') {
       execSync('which security', { stdio: 'pipe' });
       return true;
+    } else if (os.platform() === 'win32') {
+      // Windows: Always available (uses encrypted file storage)
+      return true;
     } else {
+      // Linux: Check for secret-tool
       execSync('which secret-tool', { stdio: 'pipe' });
       return true;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "maiass",
   "type": "module",
-  "version": "5.9.5",
+  "version": "5.9.7",
   "description": "MAIASS - Modular AI-Augmented Semantic Scribe - Intelligent Git workflow automation",
   "main": "maiass.mjs",
   "bin": {