maiass 5.8.0 → 5.8.8

package/lib/account-info.js

@@ -6,6 +6,7 @@ import { SYMBOLS } from './symbols.js';
 import { loadEnvironmentConfig } from './config.js';
 import { generateMachineFingerprint } from './machine-fingerprint.js';
 import { retrieveSecureVariable, storeSecureVariable, removeSecureVariable } from './secure-storage.js';
+import { getClientName, getClientVersion } from './client-info.js';
 import { getSingleCharInput } from './input-utils.js';
 import fs from 'fs';
 import path from 'path';
@@ -25,23 +26,6 @@ function maskToken(token) {
   }
 }
 
-/**
- * Get client version from package.json
- * @returns {string} Version string
- */
-function getClientVersion() {
-  try {
-    const packagePath = path.resolve(process.cwd(), 'package.json');
-    if (fs.existsSync(packagePath)) {
-      const packageData = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-      return packageData.version || '0.0.0';
-    }
-  } catch (error) {
-    // Ignore errors, fallback to default
-  }
-  return '0.0.0';
-}
-
 /**
  * Create anonymous subscription if needed
  * @returns {Promise<string|null>} API token or null
@@ -50,21 +34,23 @@ async function createAnonymousSubscriptionIfNeeded() {
   const debugMode = process.env.MAIASS_DEBUG === 'true';
   
   try {
-    log.info(SYMBOLS.INFO, 'No AI API key found. Creating anonymous subscription...');
-    
+    log.info(SYMBOLS.INFO, 'Generating machine fingerprint...');
     const machineFingerprint = generateMachineFingerprint();
+    
     const endpoint = process.env.MAIASS_AI_HOST || 'https://pound.maiass.net';
     
     if (debugMode) {
       log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Creating anonymous subscription at: ${endpoint}/v1/token`);
     }
     
+    log.info(SYMBOLS.INFO, 'Requesting anonymous subscription...');
+    
     const response = await fetch(`${endpoint}/v1/token`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
-        'X-Client-Name': 'nodemaiass',
-        'X-Client-Version': '5.7.5'
+        'X-Client-Name': getClientName(),
+        'X-Client-Version': getClientVersion()
       },
       body: JSON.stringify({
         machine_fingerprint: machineFingerprint

package/lib/bootstrap.js

@@ -0,0 +1,564 @@
+// MAIASS Bootstrap Module
+// Interactive project setup and configuration
+// Mirrors bashmaiass lib/core/bootstrap.sh
+
+import fs from 'fs';
+import path from 'path';
+import { getSingleCharInput, getLineInput } from './input-utils.js';
+import { log, logger } from './logger.js';
+import { SYMBOLS } from './symbols.js';
+import colors from './colors.js';
+
+/**
+ * Check if bootstrap is needed
+ * @returns {boolean} True if .env.maiass doesn't exist or force bootstrap is set
+ */
+export function needsBootstrap() {
+  const forceBootstrap = process.env.MAIASS_FORCE_BOOTSTRAP === 'true';
+  const envFileExists = fs.existsSync('.env.maiass');
+  
+  return !envFileExists || forceBootstrap;
+}
+
+/**
+ * Load existing .env.maiass values to use as defaults
+ * @returns {Object} Existing configuration values
+ */
+function loadExistingValues() {
+  const existing = {};
+  
+  if (!fs.existsSync('.env.maiass')) {
+    return existing;
+  }
+  
+  try {
+    const content = fs.readFileSync('.env.maiass', 'utf8');
+    const lines = content.split('\n');
+    
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+      
+      const match = trimmed.match(/^([A-Z_]+)=(.*)$/);
+      if (match) {
+        const [, key, value] = match;
+        // Remove quotes if present
+        existing[key] = value.replace(/^["']|["']$/g, '');
+      }
+    }
+  } catch (error) {
+    logger.debug('Could not load existing .env.maiass:', error.message);
+  }
+  
+  return existing;
+}
+
+/**
+ * Detect project type based on files present
+ * @returns {string} Detected project type
+ */
+function detectProjectType() {
+  // Check for WordPress
+  if (fs.existsSync('wp-config.php') || fs.existsSync('wp-content')) {
+    if (fs.existsSync('style.css')) {
+      const styleContent = fs.readFileSync('style.css', 'utf8');
+      if (styleContent.includes('Theme Name:')) {
+        return 'wordpress-theme';
+      }
+    }
+    // Check for plugin
+    const files = fs.readdirSync('.');
+    for (const file of files) {
+      if (file.endsWith('.php')) {
+        const content = fs.readFileSync(file, 'utf8');
+        if (content.includes('Plugin Name:')) {
+          return 'wordpress-plugin';
+        }
+      }
+    }
+    return 'wordpress-site';
+  }
+  
+  // Check for Craft CMS
+  if (fs.existsSync('craft') || fs.existsSync('config/general.php')) {
+    return 'craft';
+  }
+  
+  // Default to bespoke
+  return 'bespoke';
+}
+
+/**
+ * Detect version source file
+ * @returns {string} Detected version file
+ */
+function detectVersionSource() {
+  if (fs.existsSync('package.json')) {
+    return 'package.json';
+  }
+  if (fs.existsSync('composer.json')) {
+    return 'composer.json';
+  }
+  if (fs.existsSync('VERSION')) {
+    return 'VERSION';
+  }
+  return 'package.json'; // Default
+}
+
+/**
+ * Main bootstrap function
+ * @returns {Promise<boolean>} True if bootstrap completed, false if skipped
+ */
+export async function bootstrapProject() {
+  const forceBootstrap = process.env.MAIASS_FORCE_BOOTSTRAP === 'true';
+  const envFileExists = fs.existsSync('.env.maiass');
+  
+  if (envFileExists && !forceBootstrap) {
+    logger.debug('Project already configured (.env.maiass exists)');
+    return false;
+  }
+  
+  const existing = loadExistingValues();
+  const isReconfigure = envFileExists && forceBootstrap;
+  
+  console.log('');
+  console.log(colors.BCyan('════════════════════════════════════════════════════════════'));
+  if (isReconfigure) {
+    console.log(colors.BCyan('🔧 Reconfiguring MAIASS for this project'));
+    console.log(colors.Gray('Current values will be shown as defaults.'));
+  } else {
+    console.log(colors.BCyan('🚀 Setting up MAIASS for this project'));
+    console.log(colors.Gray('This is a one-time setup that will make future runs smoother.'));
+  }
+  console.log(colors.BCyan('════════════════════════════════════════════════════════════'));
+  console.log('');
+  
+  const config = {};
+  
+  // Step 1: Configuration file setup
+  await setupEnvFile(existing);
+  
+  // Step 2: Project type detection
+  config.projectType = await configureProjectType(existing);
+  
+  // Step 3: Version source
+  config.versionSource = await configureVersionSource(existing);
+  
+  // Step 4: Features selection
+  config.features = await chooseFeatures(existing);
+  
+  // Step 5: Changelog configuration (if full features)
+  if (config.features === 'full') {
+    config.changelog = await configureChangelog(existing);
+  }
+  
+  // Step 6: Branch strategy
+  config.branches = await configureBranches(existing);
+  
+  // Step 7: Save configuration
+  await saveConfiguration(config);
+  
+  console.log('');
+  log.success(SYMBOLS.CHECKMARK, 'Project setup complete!');
+  log.info(SYMBOLS.INFO, 'You can modify these settings anytime by editing .env.maiass');
+  log.info(SYMBOLS.INFO, "Run 'maiass' again to start using your configured workflow.");
+  console.log('');
+  
+  return true;
+}
+
+/**
+ * Step 1: Setup environment file
+ */
+async function setupEnvFile(existing) {
+  console.log(colors.BCyan('📄 Configuration File Setup'));
+  console.log('');
+  
+  if (process.env.MAIASS_FORCE_BOOTSTRAP === 'true') {
+    console.log(`${SYMBOLS.INFO} Updating existing .env.maiass file with new configuration.`);
+    return;
+  }
+  
+  console.log(`${SYMBOLS.INFO} MAIASS uses configuration files to store project settings:`);
+  console.log('  • .env.maiass - Team/repo config (tracked in git)');
+  console.log('  • .env.maiass.local - Personal settings (gitignored)');
+  console.log('');
+  
+  const create = await getSingleCharInput('Create configuration files? [Y/n]: ');
+  if (create === 'n') {
+    console.log(`${SYMBOLS.WARNING} Setup cancelled. Run with --setup to try again.`);
+    process.exit(0);
+  }
+}
+
+/**
+ * Step 2: Configure project type
+ */
+async function configureProjectType(existing) {
+  console.log('');
+  console.log(colors.BCyan('🔍 Project Type Detection'));
+  console.log('');
+  
+  const detected = detectProjectType();
+  const current = existing.MAIASS_REPO_TYPE || detected;
+  
+  console.log('MAIASS can optimize its workflow based on your project type.');
+  console.log('This helps determine version file locations and update strategies.');
+  console.log('');
+  
+  console.log(`${SYMBOLS.INFO} Detected project type: ${colors.BGreen(detected)}`);
+  if (existing.MAIASS_REPO_TYPE) {
+    console.log(`${SYMBOLS.INFO} Current setting: ${colors.BGreen(existing.MAIASS_REPO_TYPE)}`);
+  }
+  console.log('');
+  
+  console.log(colors.BWhite('Available project types:'));
+  console.log(`  ${colors.BCyan('1)')} bespoke          - Standard Node.js/web project (default)`);
+  console.log(`  ${colors.BCyan('2)')} wordpress-theme  - WordPress theme with style.css versioning`);
+  console.log(`  ${colors.BCyan('3)')} wordpress-plugin - WordPress plugin with main PHP file versioning`);
+  console.log(`  ${colors.BCyan('4)')} wordpress-site   - Full WordPress installation`);
+  console.log(`  ${colors.BCyan('5)')} craft            - Craft CMS project`);
+  console.log('');
+  
+  const defaultChoice = ['bespoke', 'wordpress-theme', 'wordpress-plugin', 'wordpress-site', 'craft'].indexOf(current) + 1;
+  const choice = await getLineInput(`Select project type [1-5, Enter for ${defaultChoice}=${current}]: `);
+  
+  if (!choice) return current;
+  
+  const types = ['bespoke', 'wordpress-theme', 'wordpress-plugin', 'wordpress-site', 'craft'];
+  const index = parseInt(choice) - 1;
+  
+  if (index >= 0 && index < types.length) {
+    log.success(SYMBOLS.CHECKMARK, `Project type set to: ${colors.BGreen(types[index])}`);
+    return types[index];
+  }
+  
+  log.warning(SYMBOLS.WARNING, `Invalid choice, using: ${current}`);
+  return current;
+}
+
+/**
+ * Step 3: Configure version source
+ */
+async function configureVersionSource(existing) {
+  console.log('');
+  console.log(colors.BCyan('📦 Version Source Configuration'));
+  console.log('');
+  
+  const detected = detectVersionSource();
+  const current = existing.MAIASS_VERSION_PRIMARY_FILE || detected;
+  
+  console.log('MAIASS needs to know where your project version is stored.');
+  console.log('This file will be updated automatically when you bump versions.');
+  console.log('');
+  
+  console.log(`${SYMBOLS.INFO} Detected version file: ${colors.BGreen(detected)}`);
+  if (existing.MAIASS_VERSION_PRIMARY_FILE) {
+    console.log(`${SYMBOLS.INFO} Current setting: ${colors.BGreen(existing.MAIASS_VERSION_PRIMARY_FILE)}`);
+  }
+  console.log('');
+  
+  console.log(colors.Gray('Common options: package.json, composer.json, VERSION, style.css'));
+  const file = await getLineInput(`Version source file [Enter for ${current}]: `);
+  
+  const result = file || current;
+  if (file) {
+    console.log(`${SYMBOLS.CHECKMARK} Version source set to: ${colors.BGreen(result)}`);
+  }
+  return result;
+}
+
+/**
+ * Step 4: Choose MAIASS features
+ */
+async function chooseFeatures(existing) {
+  console.log('');
+  console.log(colors.BCyan('⚙️  Feature Selection'));
+  console.log('');
+  
+  const currentMode = existing.MAIASS_MODE || 'full';
+  const current = currentMode === 'ai_only' ? 'ai_only' : 'full';
+  
+  console.log('Choose which MAIASS features you want to use:');
+  console.log('');
+  console.log(colors.BWhite('Available modes:'));
+  console.log(`  ${colors.BCyan('1)')} full    - Complete workflow ${colors.Gray('(recommended)')}`);
+  console.log(`               • AI-powered commit messages`);
+  console.log(`               • Automatic version bumping`);
+  console.log(`               • Changelog generation`);
+  console.log(`               • Branch management`);
+  console.log('');
+  console.log(`  ${colors.BCyan('2)')} ai_only - AI commit messages only`);
+  console.log(`               • AI-powered commit messages`);
+  console.log(`               • No version management`);
+  console.log(`               • No changelog updates`);
+  console.log('');
+  
+  if (existing.MAIASS_MODE) {
+    console.log(`${SYMBOLS.INFO} Current mode: ${colors.BGreen(current)}`);
+  }
+  
+  const defaultChoice = current === 'full' ? '1' : '2';
+  const choice = await getLineInput(`Select mode [1-2, Enter for ${defaultChoice}]: `);
+  
+  let result;
+  if (choice === '2') result = 'ai_only';
+  else if (choice === '1' || !choice) result = 'full';
+  else result = current;
+  
+  console.log(`${SYMBOLS.CHECKMARK} Mode set to: ${colors.BGreen(result)}`);
+  return result;
+}
+
+/**
+ * Step 5: Configure changelog
+ */
+async function configureChangelog(existing) {
+  console.log('');
+  console.log(colors.BCyan('🧾 Changelog Configuration'));
+  console.log('');
+  
+  const config = {
+    path: existing.MAIASS_CHANGELOG_PATH || '.',
+    name: existing.MAIASS_CHANGELOG_NAME || 'CHANGELOG.md',
+    internalEnabled: existing.MAIASS_CHANGELOG_INTERNAL_ENABLED !== 'false',
+    internalPath: existing.MAIASS_CHANGELOG_INTERNAL_PATH || '.',
+    internalName: existing.MAIASS_CHANGELOG_INTERNAL_NAME || '.CHANGELOG_internal.md'
+  };
+  
+  console.log('MAIASS can maintain two changelogs:');
+  console.log(`  • ${colors.BWhite('Public changelog')}  - CHANGELOG.md (for users/clients)`);
+  console.log(`  • ${colors.BWhite('Internal changelog')} - .CHANGELOG_internal.md (for team)`);
+  console.log('');
+  console.log(colors.Gray('Internal changelog includes JIRA tickets, commit authors, and detailed notes.'));
+  console.log(colors.Gray('It should be excluded from production deployments.'));
+  console.log('');
+  
+  if (existing.MAIASS_CHANGELOG_INTERNAL_ENABLED) {
+    console.log(`${SYMBOLS.INFO} Current setting: ${config.internalEnabled ? colors.BGreen('enabled') : colors.BRed('disabled')}`);
+  }
+  
+  // Ask about internal changelog
+  const enableInternal = await getSingleCharInput(
+    `Enable internal changelog? [${config.internalEnabled ? 'Y/n' : 'y/N'}]: `
+  );
+  
+  if (enableInternal === 'y' || (enableInternal === '' && config.internalEnabled)) {
+    config.internalEnabled = true;
+    console.log(`${SYMBOLS.CHECKMARK} Internal changelog enabled`);
+  } else if (enableInternal === 'n' || (enableInternal === '' && !config.internalEnabled)) {
+    config.internalEnabled = false;
+    console.log(`${SYMBOLS.INFO} Internal changelog disabled`);
+  }
+  
+  return config;
+}
+
+/**
+ * Step 6: Configure branch strategy
+ */
+async function configureBranches(existing) {
+  console.log('');
+  console.log(colors.BCyan('🌿 Branch Strategy Configuration'));
+  console.log('');
+  
+  const config = {
+    main: existing.MAIASS_MAINBRANCH || 'main',
+    develop: existing.MAIASS_DEVELOPBRANCH || 'develop',
+    staging: existing.MAIASS_STAGINGBRANCH || 'staging'
+  };
+  
+  console.log('MAIASS uses a Git Flow-inspired branching strategy:');
+  console.log('');
+  console.log(`  ${colors.BWhite('Development Branch')} (${colors.BCyan('develop')}) - ${colors.BYellow('★ TRUNK BRANCH')}`);
+  console.log(`    • This is where MAIASS performs version bumps and changelog updates`);
+  console.log(`    • Must allow direct commits (no PR requirement)`);
+  console.log(`    • All feature work merges here first`);
+  console.log('');
+  console.log(`  ${colors.BWhite('Main/Production Branch')} (${colors.BCyan('main/master')})`);
+  console.log(`    • Stable releases only`);
+  console.log(`    • Updated via merge from develop after testing`);
+  console.log(`    • Can require PRs for merges`);
+  console.log('');
+  console.log(`  ${colors.BWhite('Staging Branch')} (${colors.BCyan('staging')}) - ${colors.Gray('optional')}`);
+  console.log(`    • Pre-production testing environment`);
+  console.log(`    • Sits between develop and main`);
+  console.log('');
+  console.log(colors.BYellow('IMPORTANT:') + ' MAIASS must run on the development branch to automatically');
+  console.log('version and commit changes. PRs should not be required for this branch.');
+  console.log('');
+  
+  if (existing.MAIASS_MAINBRANCH) {
+    console.log(`${SYMBOLS.INFO} Current branches: ${colors.BGreen(config.main)} / ${colors.BGreen(config.develop)} / ${colors.BGreen(config.staging)}`);
+  }
+  console.log('');
+  
+  const main = await getLineInput(`Main/production branch [Enter for ${config.main}]: `);
+  config.main = main || config.main;
+  
+  const develop = await getLineInput(`Development branch [Enter for ${config.develop}]: `);
+  config.develop = develop || config.develop;
+  
+  const staging = await getLineInput(`Staging branch (optional) [Enter for ${config.staging}]: `);
+  config.staging = staging || config.staging;
+  
+  console.log(`${SYMBOLS.CHECKMARK} Branches configured: ${colors.BGreen(config.main)} / ${colors.BGreen(config.develop)} / ${colors.BGreen(config.staging)}`);
+  
+  return config;
+}
+
+/**
+ * Step 7: Save configuration to .env.maiass
+ */
+async function saveConfiguration(config) {
+  const timestamp = new Date().toISOString();
+  
+  let content = `# MAIASS Configuration
+# Generated on ${timestamp}
+
+# Core Settings
+# Verbosity level (brief/normal/verbose)
+#MAIASS_VERBOSITY=normal
+# Enable debug mode
+#MAIASS_DEBUG=false
+
+# Project Configuration
+MAIASS_REPO_TYPE=${config.projectType}
+
+# Version Management Settings
+MAIASS_VERSION_PRIMARY_FILE=${config.versionSource}
+# Secondary files that should have their versions updated (comma-separated)
+#MAIASS_VERSION_SECONDARY_FILES=
+
+`;
+
+  // Add mode if AI-only
+  if (config.features === 'ai_only') {
+    content += `# MAIASS Mode (full or ai_only)
+MAIASS_MODE=ai_only
+
+`;
+  }
+
+  // Add changelog config if full mode
+  if (config.features === 'full' && config.changelog) {
+    content += `# Changelog Configuration
+MAIASS_CHANGELOG_PATH=${config.changelog.path}
+MAIASS_CHANGELOG_NAME=${config.changelog.name}
+MAIASS_CHANGELOG_INTERNAL_ENABLED=${config.changelog.internalEnabled}
+`;
+    if (config.changelog.internalEnabled) {
+      content += `MAIASS_CHANGELOG_INTERNAL_PATH=${config.changelog.internalPath}
+MAIASS_CHANGELOG_INTERNAL_NAME=${config.changelog.internalName}
+`;
+    }
+    content += '\n';
+  }
+
+  // Add branch configuration
+  content += `# Branch Configuration
+MAIASS_MAINBRANCH=${config.branches.main}
+MAIASS_DEVELOPBRANCH=${config.branches.develop}
+MAIASS_STAGINGBRANCH=${config.branches.staging}
+
+`;
+
+  // Add standard options
+  content += `# Auto-Yes Functionality (for CI/CD and non-interactive mode)
+#MAIASS_AUTO_STAGE_UNSTAGED=false
+#MAIASS_AUTO_PUSH_COMMITS=false
+#MAIASS_AUTO_MERGE_TO_DEVELOP=false
+#MAIASS_AUTO_APPROVE_AI_SUGGESTIONS=false
+
+# Push Control
+# Options: blank/ask (prompt user - default), 'always' (auto-push), 'never' (skip push)
+#MAIASS_PUSH_ABSTRACTS_TO_REMOTE=
+
+# Patch Release Control
+#MAIASS_PATCH_RELEASES=
+
+# Version Checking
+#MAIASS_AUTO_UPDATE_CHECK=true
+
+# Invalid Token Behavior
+#MAIASS_AI_INVALID_TOKEN_CHOICES=false
+
+# AI Configuration
+#MAIASS_AI_MODEL=gpt-4
+#MAIASS_AI_TEMPERATURE=0.8
+#MAIASS_AI_MAX_CHARACTERS=8000
+#MAIASS_AI_MODE=ask
+
+# Repository Configuration
+#MAIASS_REPO_PROVIDER=
+#MAIASS_GITHUB_OWNER=
+#MAIASS_GITHUB_REPO=
+#MAIASS_BITBUCKET_WORKSPACE=
+#MAIASS_BITBUCKET_REPO_SLUG=
+
+# Pull Request Configuration
+#MAIASS_STAGING_PULLREQUESTS=on
+#MAIASS_MAIN_PULLREQUESTS=on
+
+# Logging Configuration
+#MAIASS_LOGGING=true
+#MAIASS_LOG_FILE=maiass.log
+#MAIASS_HIDEGIT=true
+
+# Client Identity (for proxy version enforcement)
+#MAIASS_CLIENT_NAME=nodemaiass
+#MAIASS_CLIENT_VERSION=5.8.1
+`;
+
+  // Write .env.maiass
+  fs.writeFileSync('.env.maiass', content, 'utf8');
+  log.success(SYMBOLS.CHECKMARK, 'Configuration saved to .env.maiass');
+  
+  // Create .env.maiass.local if it doesn't exist
+  if (!fs.existsSync('.env.maiass.local')) {
+    const localContent = `# .env.maiass.local - Personal/Local Settings
+# This file is automatically gitignored and never committed.
+# Use this for personal overrides and sensitive data.
+
+# Example: Override AI host for local development
+#MAIASS_AI_HOST=http://localhost:8787
+
+# Example: Personal debug settings
+#MAIASS_DEBUG=true
+`;
+    fs.writeFileSync('.env.maiass.local', localContent, 'utf8');
+    log.success(SYMBOLS.CHECKMARK, 'Created .env.maiass.local for personal settings');
+  }
+  
+  // Ensure .gitignore includes .env.maiass.local
+  await ensureGitignore();
+}
+
+/**
+ * Ensure .gitignore includes necessary patterns
+ */
+async function ensureGitignore() {
+  let gitignoreContent = '';
+  let needsUpdate = false;
+  
+  if (fs.existsSync('.gitignore')) {
+    gitignoreContent = fs.readFileSync('.gitignore', 'utf8');
+  }
+  
+  const patterns = ['.env.maiass.local', '.env.maiass.bak'];
+  const missing = patterns.filter(pattern => !gitignoreContent.includes(pattern));
+  
+  if (missing.length > 0) {
+    needsUpdate = true;
+    if (gitignoreContent && !gitignoreContent.endsWith('\n')) {
+      gitignoreContent += '\n';
+    }
+    gitignoreContent += '\n# MAIASS environment files\n';
+    for (const pattern of missing) {
+      gitignoreContent += `${pattern}\n`;
+    }
+    
+    fs.writeFileSync('.gitignore', gitignoreContent, 'utf8');
+    log.success(SYMBOLS.CHECKMARK, `Added ${missing.join(', ')} to .gitignore`);
+  }
+}

package/lib/client-info.js

@@ -0,0 +1,60 @@
+// Client information utilities
+// Provides client name and version for API headers
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+let cachedVersion = null;
+
+/**
+ * Get the current version from package.json
+ * @returns {string} Version string
+ */
+function getVersionFromPackageJson() {
+  if (cachedVersion) {
+    return cachedVersion;
+  }
+  
+  try {
+    const packageJsonPath = path.join(__dirname, '..', 'package.json');
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    cachedVersion = packageJson.version || '0.0.0';
+    return cachedVersion;
+  } catch (error) {
+    console.error('Warning: Could not read version from package.json:', error.message);
+    return '0.0.0';
+  }
+}
+
+/**
+ * Get client name for API headers
+ * Uses MAIASS_CLIENT_NAME environment variable or defaults to 'nodemaiass'
+ * @returns {string} Client name
+ */
+export function getClientName() {
+  return process.env.MAIASS_CLIENT_NAME || 'nodemaiass';
+}
+
+/**
+ * Get client version for API headers
+ * Priority: MAIASS_CLIENT_VERSION env var > package.json version
+ * @returns {string} Client version
+ */
+export function getClientVersion() {
+  return process.env.MAIASS_CLIENT_VERSION || getVersionFromPackageJson();
+}
+
+/**
+ * Get both client name and version
+ * @returns {Object} Object with name and version properties
+ */
+export function getClientInfo() {
+  return {
+    name: getClientName(),
+    version: getClientVersion()
+  };
+}

package/lib/commit.js

@@ -7,6 +7,7 @@ import readline from 'readline';
 import { loadEnvironmentConfig } from './config.js';
 import { generateMachineFingerprint } from './machine-fingerprint.js';
 import { storeSecureVariable, retrieveSecureVariable } from './secure-storage.js';
+import { getClientName, getClientVersion } from './client-info.js';
 import { getSingleCharInput, getMultiLineInput } from './input-utils.js';
 import { logCommit } from './devlog.js';
 import colors from './colors.js';
@@ -118,9 +119,9 @@ async function createAnonymousSubscriptionIfNeeded() {
       return existingToken;
     }
 
-    log.info(SYMBOLS.INFO, 'No AI API key found. Creating anonymous subscription...');
-    
+    log.info(SYMBOLS.INFO, 'Generating machine fingerprint...');
     const machineFingerprint = generateMachineFingerprint();
+    
     const endpoint = process.env.MAIASS_AI_HOST || 'https://pound.maiass.net';
     
     if (debugMode) {
@@ -128,12 +129,14 @@ async function createAnonymousSubscriptionIfNeeded() {
       log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Machine fingerprint: ${JSON.stringify(machineFingerprint, null, 2)}`);
     }
     
+    log.info(SYMBOLS.INFO, 'Requesting anonymous subscription...');
+    
     const response = await fetch(`${endpoint}/v1/token`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
-        'X-Client-Name': 'nodemaiass',
-        'X-Client-Version': '5.7.5'
+        'X-Client-Name': getClientName(),
+        'X-Client-Version': getClientVersion()
       },
       body: JSON.stringify({
         machine_fingerprint: machineFingerprint
@@ -376,8 +379,8 @@ ${gitDiff}`;
         'Content-Type': 'application/json',
         'Authorization': `Bearer ${maiassToken}`,
         'X-Machine-Fingerprint': generateMachineFingerprint(),
-        'X-Client-Name': 'nodemaiass',
-        'X-Client-Version': '5.7.5',
+        'X-Client-Name': getClientName(),
+        'X-Client-Version': getClientVersion(),
         'X-Subscription-ID': process.env.MAIASS_SUBSCRIPTION_ID || ''
       },
       body: JSON.stringify(requestBody)
@@ -548,8 +551,12 @@ async function getCommitMessage(gitInfo, options = {}) {
     case 'ask':
       if (maiassToken) {
         let reply;
-        if (silent) {
+        const autoApprove = process.env.MAIASS_AUTO_APPROVE_AI_SUGGESTIONS === 'true';
+        if (silent || autoApprove) {
           log.info('', 'Would you like to use AI to suggest a commit message? [y/N] y');
+          if (autoApprove) {
+            log.info(SYMBOLS.INFO, 'MAIASS_AUTO_APPROVE_AI_SUGGESTIONS=true: Automatically using AI');
+          }
           reply = 'y';
         } else {
           reply = await getSingleCharInput('Would you like to use AI to suggest a commit message? [y/N] ');
@@ -565,8 +572,12 @@ async function getCommitMessage(gitInfo, options = {}) {
         if (anonToken) {
           // Token created successfully, now ask if they want to use AI
           let reply;
-          if (silent) {
+          const autoApprove = process.env.MAIASS_AUTO_APPROVE_AI_SUGGESTIONS === 'true';
+          if (silent || autoApprove) {
             log.info('', 'Would you like to use AI to suggest a commit message? [y/N] y');
+            if (autoApprove) {
+              log.info(SYMBOLS.INFO, 'MAIASS_AUTO_APPROVE_AI_SUGGESTIONS=true: Automatically using AI');
+            }
             reply = 'y';
           } else {
             reply = await getSingleCharInput('Would you like to use AI to suggest a commit message? [y/N] ');
@@ -611,14 +622,18 @@ async function getCommitMessage(gitInfo, options = {}) {
       printGradientLine(60);
       
       let reply;
-      if (silent) {
+      const autoApprove = process.env.MAIASS_AUTO_APPROVE_AI_SUGGESTIONS === 'true';
+      if (silent || autoApprove) {
         log.info('', 'Use this AI suggestion? [Y/n/e=edit] Y');
+        if (autoApprove) {
+          log.info(SYMBOLS.INFO, 'MAIASS_AUTO_APPROVE_AI_SUGGESTIONS=true: Automatically accepting AI suggestion');
+        }
         reply = 'Y';
       } else {
         reply = await getSingleCharInput('Use this AI suggestion? [Y/n/e=edit] ');
       }
       
-      switch (reply) {
+      switch (reply.toLowerCase()) {
         case 'n':
           log.info(SYMBOLS.INFO, 'AI suggestion declined, entering manual mode');
           useAI = false;
@@ -750,8 +765,24 @@ async function handleStagedCommit(gitInfo, options = {}) {
     // Ask about pushing to remote
     if (remoteExists('origin')) {
       let reply;
-      if (silent) {
-        // In silent mode, automatically push
+      const autoPush = process.env.MAIASS_AUTO_PUSH_COMMITS === 'true';
+      const pushAbstracts = process.env.MAIASS_PUSH_ABSTRACTS_TO_REMOTE || '';
+      
+      // Handle MAIASS_PUSH_ABSTRACTS_TO_REMOTE: 'always', 'never', or blank/'ask'
+      if (pushAbstracts === 'always' || autoPush) {
+        log.info('', 'Do you want to push this commit to remote? [y/N] y');
+        reply = 'y';
+        if (pushAbstracts === 'always') {
+          console.log('🔄 |)) Automatically pushing to remote (MAIASS_PUSH_ABSTRACTS_TO_REMOTE=always)');
+        } else if (autoPush) {
+          console.log('🔄 |)) Automatically pushing to remote (MAIASS_AUTO_PUSH_COMMITS=true)');
+        }
+      } else if (pushAbstracts === 'never') {
+        log.info('', 'Do you want to push this commit to remote? [y/N] n');
+        console.log('⏭️  |)) Skipping push to remote (MAIASS_PUSH_ABSTRACTS_TO_REMOTE=never)');
+        reply = 'n';
+      } else if (silent) {
+        log.info('', 'Do you want to push this commit to remote? [y/N] y');
         reply = 'y';
         console.log('🔄 |)) Automatically pushing to remote (silent mode)');
       } else {
@@ -816,10 +847,14 @@ export async function commitThis(options = {}) {
   if (status.unstagedCount > 0 || status.untrackedCount > 0) {
     if (!autoStage) {
       let reply;
-      if (silent) {
-        // In silent mode, automatically stage
+      const autoStage = process.env.MAIASS_AUTO_STAGE_UNSTAGED === 'true';
+      if (silent || autoStage) {
         reply = 'y';
-        console.log('🔄 |)) Automatically staging changes (silent mode)');
+        if (autoStage) {
+          console.log('🔄 |)) Automatically staging changes (MAIASS_AUTO_STAGE_UNSTAGED=true)');
+        } else {
+          console.log('🔄 |)) Automatically staging changes (silent mode)');
+        }
       } else {
         reply = await getSingleCharInput('Do you want to stage and commit them? [y/N] ');
       }

package/lib/logger.js

@@ -216,7 +216,7 @@ export const log = {
     if (!debugEnabled) return;
     
     const timestamp = new Date().toISOString();
-    const debugPrefix = colors.Blue('🐛  |))  ');
+    const debugPrefix = colors.BSoftPink('|))  ') + colors.Blue('🐛  ');
     const timestampStr = colors.Gray(`[${timestamp}]`);
     
     // Ensure we're writing to stderr to avoid mixing with other output

package/lib/maiass-pipeline.js

@@ -587,8 +587,12 @@ async function handleMergeToDevelop(branchInfo, commitResult, options = {}) {
     let reply;
     let tagReply = 'n'; // Default to no tagging for patches
     
-    if (silent) {
+    const autoMerge = process.env.MAIASS_AUTO_MERGE_TO_DEVELOP === 'true';
+    if (silent || autoMerge) {
       console.log(colors.BCyan(mergePrompt) + colors.BGreen('Y'));
+      if (autoMerge) {
+        log.info(SYMBOLS.INFO, 'MAIASS_AUTO_MERGE_TO_DEVELOP=true: Automatically merging to develop');
+      }
       reply = 'Y';
       if (tagPrompt) {
         console.log(colors.BCyan(tagPrompt) + colors.BGreen('N'));
@@ -663,7 +667,7 @@ async function handleMergeToDevelop(branchInfo, commitResult, options = {}) {
  * @returns {Object} Tagging decision and reason
  */
 function shouldTagRelease(versionBump, forceTag = false) {
-  const tagReleases = process.env.MAIASS_TAG_RELEASES || 'ask';
+  const patchReleases = process.env.MAIASS_PATCH_RELEASES || '';
   
   // CLI flag overrides everything
   if (forceTag) {
@@ -675,15 +679,17 @@ function shouldTagRelease(versionBump, forceTag = false) {
     return { shouldTag: true, reason: 'major/minor release', needsPrompt: false };
   }
   
-  // Handle patch releases based on configuration
-  switch (tagReleases.toLowerCase()) {
-    case 'all':
-      return { shouldTag: true, reason: 'MAIASS_TAG_RELEASES=all', needsPrompt: false };
-    case 'none':
-      return { shouldTag: false, reason: 'MAIASS_TAG_RELEASES=none', needsPrompt: false };
+  // Handle patch releases based on MAIASS_PATCH_RELEASES configuration
+  // Options: blank/no (skip release branch - default), 'ask' (prompt user), 'always' (create release)
+  switch (patchReleases.toLowerCase()) {
+    case 'always':
+      return { shouldTag: true, reason: 'MAIASS_PATCH_RELEASES=always', needsPrompt: false };
     case 'ask':
-    default:
       return { shouldTag: false, reason: 'patch release', needsPrompt: true };
+    case 'no':
+    case '':
+    default:
+      return { shouldTag: false, reason: 'MAIASS_PATCH_RELEASES=no (skip release branch)', needsPrompt: false };
   }
 }
 

package/lib/secure-storage.js

@@ -4,8 +4,7 @@
 
 import { execSync } from 'child_process';
 import os from 'os';
-import { log } from './logger.js';
-import { SYMBOLS } from './symbols.js';
+import { log, logger } from './logger.js';
 
 /**
  * Get environment-specific service name for secure storage
@@ -38,7 +37,7 @@ export function storeSecureVariable(varName, varValue) {
   const debugMode = process.env.MAIASS_DEBUG === 'true';
   
   if (debugMode) {
-    log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Storing ${varName} in secure storage service: ${serviceName}`);
+    logger.debug(`Storing ${varName} in secure storage service: ${serviceName}`);
   }
   
   try {
@@ -57,19 +56,19 @@ export function storeSecureVariable(varName, varValue) {
         });
       } catch (error) {
         if (debugMode) {
-          log.debug(SYMBOLS.WARNING, '[MAIASS DEBUG] secret-tool not available, secure storage not supported on this system');
+          logger.debug('secret-tool not available, secure storage not supported on this system');
         }
         return false;
       }
     }
     
     if (debugMode) {
-      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Successfully stored ${varName} in secure storage`);
+      logger.debug(`Successfully stored ${varName} in secure storage`);
     }
     return true;
   } catch (error) {
     if (debugMode) {
-      log.debug(SYMBOLS.WARNING, `[MAIASS DEBUG] Failed to store ${varName} in secure storage: ${error.message}`);
+      logger.debug(`Failed to store ${varName} in secure storage: ${error.message}`);
     }
     return false;
   }
@@ -85,7 +84,7 @@ export function retrieveSecureVariable(varName) {
   const debugMode = process.env.MAIASS_DEBUG === 'true';
   
   if (debugMode) {
-    log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Retrieving ${varName} from secure storage service: ${serviceName}`);
+    logger.debug(`Retrieving ${varName} from secure storage service: ${serviceName}`);
   }
   
   try {
@@ -107,20 +106,20 @@ export function retrieveSecureVariable(varName) {
         }).trim();
       } catch (error) {
         if (debugMode) {
-          log.debug(SYMBOLS.WARNING, '[MAIASS DEBUG] secret-tool not available, secure storage not supported on this system');
+          logger.debug('secret-tool not available, secure storage not supported on this system');
         }
         return null;
       }
     }
     
     if (debugMode && value) {
-      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Successfully retrieved ${varName} from secure storage`);
+      logger.debug(`Successfully retrieved ${varName} from secure storage`);
     }
     
     return value || null;
   } catch (error) {
     if (debugMode) {
-      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] ${varName} not found in secure storage (this is normal for first run)`);
+      logger.debug(`${varName} not found in secure storage (this is normal for first run)`);
     }
     return null;
   }
@@ -136,7 +135,7 @@ export function removeSecureVariable(varName) {
   const debugMode = process.env.MAIASS_DEBUG === 'true';
   
   if (debugMode) {
-    log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Removing ${varName} from secure storage service: ${serviceName}`);
+    logger.debug(`Removing ${varName} from secure storage service: ${serviceName}`);
   }
   
   try {
@@ -156,19 +155,19 @@ export function removeSecureVariable(varName) {
         });
       } catch (error) {
         if (debugMode) {
-          log.debug(SYMBOLS.WARNING, '[MAIASS DEBUG] secret-tool not available, secure storage not supported on this system');
+          logger.debug('secret-tool not available, secure storage not supported on this system');
         }
         return false;
       }
     }
     
     if (debugMode) {
-      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Successfully removed ${varName} from secure storage`);
+      logger.debug(`Successfully removed ${varName} from secure storage`);
     }
     return true;
   } catch (error) {
     if (debugMode) {
-      log.debug(SYMBOLS.WARNING, `[MAIASS DEBUG] Failed to remove ${varName} from secure storage: ${error.message}`);
+      logger.debug(`Failed to remove ${varName} from secure storage: ${error.message}`);
     }
     return false;
   }
@@ -185,14 +184,14 @@ export function loadSecureVariables() {
   
   if (debugMode) {
     const host = process.env.MAIASS_AI_HOST || 'https://pound.maiass.net';
-    log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Using secure storage service name: ${serviceName} (host: ${host})`);
+    logger.debug(`Using secure storage service name: ${serviceName} (host: ${host})`);
   }
   
   secureVars.forEach(varName => {
     const envValue = process.env[varName];
     
     if (debugMode) {
-      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Checking ${varName}: value="${envValue}", type=${typeof envValue}, empty=${!envValue || envValue.trim() === ''}`);
+      logger.debug(`Checking ${varName}: value="${envValue}", type=${typeof envValue}, empty=${!envValue || envValue.trim() === ''}`);
     }
     
     // Check if we should prefer secure storage over environment variable
@@ -202,7 +201,7 @@ export function loadSecureVariables() {
       if (/^invalid_|^test_|_test$/.test(envValue) || envValue === 'DISABLED' || envValue.trim() === '') {
         preferSecure = true;
         if (debugMode) {
-          log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Environment token appears invalid, checking secure storage`);
+          logger.debug('Environment token appears invalid, checking secure storage');
         }
       }
     }
@@ -214,16 +213,16 @@ export function loadSecureVariables() {
         process.env[varName] = value;
         if (preferSecure) {
           if (debugMode) {
-            log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Replaced invalid environment token with secure storage token`);
+            logger.debug('Replaced invalid environment token with secure storage token');
           }
         } else {
           if (debugMode) {
-            log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Loaded ${varName} from secure storage`);
+            logger.debug(`Loaded ${varName} from secure storage`);
           }
         }
       }
     } else if (debugMode) {
-      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] ${varName} already set in environment, skipping secure storage`);
+      logger.debug(`${varName} already set in environment, skipping secure storage`);
     }
   });
 }

package/maiass.mjs

@@ -38,11 +38,17 @@ import { handleVersionCommand } from './lib/version-command.js';
 import { handleMaiassCommand } from './lib/maiass-command.js';
 import { handleAccountInfoCommand } from './lib/account-info.js';
 import { SYMBOLS } from './lib/symbols.js';
+import { bootstrapProject, needsBootstrap } from './lib/bootstrap.js';
 
 // Simple CLI setup for pkg compatibility
 const args = process.argv.slice(2);
 const firstArg = args[0];
 
+// Handle --setup/--bootstrap flag early
+if (args.includes('--setup') || args.includes('--bootstrap')) {
+  process.env.MAIASS_FORCE_BOOTSTRAP = 'true';
+}
+
 // Check if first argument is a version bump type
 const versionBumpTypes = ['major', 'minor', 'patch'];
 let command = 'maiass'; // Default to maiass workflow
@@ -99,6 +105,7 @@ if (args.includes('--help') || args.includes('-h') || command === 'help') {
   console.log('  --auto             Enable all auto-yes functionality (non-interactive mode)');
   console.log('  --commits-only, -c Generate AI commits without version management');
   console.log('  --auto-stage       Automatically stage all changes');
+  console.log('  --setup, --bootstrap Run interactive project setup');
   console.log('  --help, -h         Show this help message');
   console.log('  --version, -v      Show version');
   console.log('  --dry-run          Run without making changes');
@@ -109,6 +116,15 @@ if (args.includes('--help') || args.includes('-h') || command === 'help') {
 
 // Command routing (wrapped in async IIFE to handle async commands)
 (async () => {
+  // Run bootstrap if needed (first-time setup)
+  if (needsBootstrap()) {
+    const completed = await bootstrapProject();
+    if (completed) {
+      // Bootstrap completed, exit so user can run maiass again
+      process.exit(0);
+    }
+  }
+  
   switch (command) {
     case 'hello':
       console.log(colors.BCyan('Hello from MAIASS!'));

package/package.json

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