maiass 5.9.6 → 5.9.9

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/version-manager.js

@@ -516,21 +516,96 @@ function updateWordPressVersions(newVersion, projectPath = process.cwd()) {
 }
 
 /**
- * Detect version files in the current directory
+ * Extract version from a file using type and line-start pattern (matches bashmaiass behavior)
+ * @param {string} content - File content
+ * @param {string} type - File type: 'json', 'txt', 'text', 'php', 'pattern'
+ * @param {string} lineStart - Line start pattern for txt type
+ * @returns {string|null} Extracted version or null
+ */
+function extractVersionByType(content, type, lineStart) {
+  if (type === 'json') {
+    return VERSION_FILE_TYPES.json.extract(content);
+  }
+  
+  if (type === 'txt' || type === 'text') {
+    if (lineStart) {
+      for (const line of content.split('\n')) {
+        if (line.trim().startsWith(lineStart)) {
+          const match = line.match(/(\d+\.\d+\.\d+)/);
+          if (match) return match[1];
+        }
+      }
+      return null;
+    }
+    return VERSION_FILE_TYPES.text.extract(content);
+  }
+  
+  if (type === 'php' || type === 'pattern') {
+    return VERSION_FILE_TYPES.php.extract(content);
+  }
+  
+  // Unknown type - try generic version extraction
+  const match = content.match(/(\d+\.\d+\.\d+)/);
+  return match ? match[1] : null;
+}
+
+/**
+ * Detect version files in the current directory.
+ * Checks MAIASS_VERSION_PRIMARY_FILE env var first (from .env.maiass),
+ * then falls back to scanning common version file patterns.
  * @param {string} projectPath - Path to project directory
  * @returns {Array} Array of detected version files
  */
 export function detectVersionFiles(projectPath = process.cwd()) {
   const versionFiles = [];
   
-  // Common version file patterns to check
+  // Check for custom primary version file from .env.maiass first
+  const primaryFile = process.env.MAIASS_VERSION_PRIMARY_FILE;
+  const primaryType = process.env.MAIASS_VERSION_PRIMARY_TYPE || 'txt';
+  const primaryLineStart = process.env.MAIASS_VERSION_PRIMARY_LINE_START || '';
+  
+  if (primaryFile) {
+    logger.debug(`Custom primary version file configured: ${primaryFile} (type: ${primaryType})`);
+    const filePath = path.isAbsolute(primaryFile)
+      ? primaryFile
+      : path.join(projectPath, primaryFile);
+    
+    if (fs.existsSync(filePath)) {
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const version = extractVersionByType(content, primaryType, primaryLineStart);
+        
+        if (version) {
+          logger.debug(`Found version ${version} in custom primary file: ${primaryFile}`);
+          versionFiles.push({
+            path: filePath,
+            filename: path.basename(filePath),
+            type: primaryType,
+            currentVersion: version,
+            content,
+            isPrimary: true,
+            lineStart: primaryLineStart
+          });
+          return versionFiles;
+        } else {
+          logger.warning(SYMBOLS.WARNING, `Could not extract version from custom primary file: ${primaryFile}`);
+        }
+      } catch (error) {
+        logger.error(SYMBOLS.CROSS, `Error reading custom primary version file ${primaryFile}: ${error.message}`);
+      }
+    } else {
+      logger.warning(SYMBOLS.WARNING, `Custom primary version file not found: ${filePath}`);
+    }
+  }
+  
+  // Fallback: scan common version file patterns in project root
   const filesToCheck = [
     'package.json',
     'composer.json', 
     'VERSION',
     'version.txt',
-    'style.css', // WordPress themes
-    'plugin.php', // WordPress plugins
+    'style.css',
+    'plugin.php',
     'functions.php'
   ];
   
@@ -542,7 +617,6 @@ export function detectVersionFiles(projectPath = process.cwd()) {
         const content = fs.readFileSync(filePath, 'utf8');
         const ext = path.extname(filename);
         
-        // Determine file type and check if it contains version info
         for (const [typeName, typeConfig] of Object.entries(VERSION_FILE_TYPES)) {
           if (typeConfig.extensions.includes(ext) || typeConfig.extensions.includes('')) {
             if (typeConfig.detect(content, filename)) {
@@ -555,13 +629,12 @@ export function detectVersionFiles(projectPath = process.cwd()) {
                   currentVersion: version,
                   content
                 });
-                break; // Found matching type, move to next file
+                break;
               }
             }
           }
         }
       } catch (error) {
-        // Skip files that can't be read
         continue;
       }
     }
@@ -603,18 +676,24 @@ export async function getCurrentVersion(projectPath = process.cwd()) {
   let primaryVersion = null;
   let primarySource = null;
   
-  // Prioritize package.json if it exists
-  const packageJson = versionFiles.find(f => f.filename === 'package.json');
-  if (packageJson) {
-    primaryVersion = packageJson.currentVersion;
-    primarySource = 'package.json';
-  } else if (versionFiles.length > 0) {
-    // Use first detected version file
-    primaryVersion = versionFiles[0].currentVersion;
-    primarySource = versionFiles[0].filename;
-  } else if (tagVersion) {
-    primaryVersion = tagVersion;
-    primarySource = 'git tags';
+  // Prioritize custom primary file from .env.maiass if present
+  const customPrimary = versionFiles.find(f => f.isPrimary);
+  if (customPrimary) {
+    primaryVersion = customPrimary.currentVersion;
+    primarySource = process.env.MAIASS_VERSION_PRIMARY_FILE || customPrimary.filename;
+  } else {
+    // Fallback: prioritize package.json
+    const packageJson = versionFiles.find(f => f.filename === 'package.json');
+    if (packageJson) {
+      primaryVersion = packageJson.currentVersion;
+      primarySource = 'package.json';
+    } else if (versionFiles.length > 0) {
+      primaryVersion = versionFiles[0].currentVersion;
+      primarySource = versionFiles[0].filename;
+    } else if (tagVersion) {
+      primaryVersion = tagVersion;
+      primarySource = 'git tags';
+    }
   }
   
   return {
@@ -765,8 +844,27 @@ export async function updateVersionFiles(newVersion, versionFiles, dryRun = fals
   // Update primary version files
   for (const file of versionFiles) {
     try {
-      const typeConfig = VERSION_FILE_TYPES[file.type];
-      const updatedContent = typeConfig.update(file.content, newVersion);
+      let updatedContent = null;
+      
+      // Custom primary file with lineStart pattern needs special handling
+      if (file.isPrimary && file.lineStart && (file.type === 'txt' || file.type === 'text')) {
+        const lines = file.content.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+          if (lines[i].trim().startsWith(file.lineStart)) {
+            lines[i] = lines[i].replace(/\d+\.\d+\.\d+/, newVersion);
+          }
+        }
+        updatedContent = lines.join('\n');
+      } else {
+        // Map env types to VERSION_FILE_TYPES keys
+        const typeKey = (file.type === 'txt' || file.type === 'text') ? 'text'
+          : (file.type === 'pattern') ? 'php'
+          : file.type;
+        const typeConfig = VERSION_FILE_TYPES[typeKey];
+        if (typeConfig) {
+          updatedContent = typeConfig.update(file.content, newVersion);
+        }
+      }
       
       if (!updatedContent) {
         results.failed.push({

package/package.json

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