maiass 5.9.7 → 5.9.10

package/lib/commit.js

@@ -1002,6 +1002,7 @@ export async function commitThis(options = {}) {
 
 // Export individual functions for testing and reuse
 export {
+  createAnonymousSubscriptionIfNeeded,
   getCommitMessage,
   handleStagedCommit,
   getAICommitSuggestion,

package/lib/maiass-command.js

@@ -1,6 +1,7 @@
 import { log, logger } from './logger.js';
 import { SYMBOLS } from './symbols.js';
 import { runMaiassPipeline } from './maiass-pipeline.js';
+import { createAnonymousSubscriptionIfNeeded } from './commit.js';
 import colors from './colors.js';
 
 /**
@@ -33,6 +34,13 @@ export async function handleMaiassCommand(args) {
   logger.header('', 'MAIASS - Modular AI-Assisted Semantic Scribe');
   
   try {
+    // Create anonymous subscription if needed (matches bashmaiass behavior)
+    // This ensures free credits are allocated on first run
+    const aiMode = process.env.MAIASS_AI_MODE || 'ask';
+    if (aiMode !== 'off') {
+      await createAnonymousSubscriptionIfNeeded();
+    }
+    
     // Run the complete MAIASS pipeline
     const result = await runMaiassPipeline({
       commitsOnly,

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.7",
+  "version": "5.9.10",
   "description": "MAIASS - Modular AI-Augmented Semantic Scribe - Intelligent Git workflow automation",
   "main": "maiass.mjs",
   "bin": {