maiass 5.7.31

package/maiass-standalone.cjs

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+/**
+ * MAIASS: Modular AI-Augmented Semantic Scribe
+ * Standalone bundled version for distribution
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+// Embedded version and config (updated during build)
+const MAIASS_VERSION = "5.3.6";
+const MAIASS_CONFIG = {
+  name: "maiass",
+  description: "MAIASS: Modular AI-Augmented Semantic Scribe - CLI tool for AI-augmented development",
+  version: MAIASS_VERSION
+};
+
+// Simple argument parsing
+const args = process.argv.slice(2);
+const firstArg = args[0];
+
+// Handle version flag
+if (args.includes('--version') || args.includes('-v')) {
+  console.log(MAIASS_VERSION);
+  process.exit(0);
+}
+
+// Handle help flag
+if (args.includes('--help') || args.includes('-h') || firstArg === 'help') {
+  console.log(`\nMAIASS v${MAIASS_VERSION}`);
+  console.log('Modular AI-Augmented Semantic Scribe\n');
+  console.log('Usage: maiass [command] [options]\n');
+  console.log('Commands:');
+  console.log('  hello              Print hello world');
+  console.log('  version            Show version information');
+  console.log('  check-updates      Check for available updates');
+  console.log('\nOptions:');
+  console.log('  --help, -h         Show this help message');
+  console.log('  --version, -v      Show version');
+  console.log('\nThis is a bundled Node.js version with limited functionality.');
+  console.log('For full features, install from source or use the bash version.');
+  console.log('\nHomepage: https://github.com/vsmash/maiass');
+  process.exit(0);
+}
+
+// Simple color utilities
+const colors = {
+  green: (text) => `\x1b[32m${text}\x1b[0m`,
+  cyan: (text) => `\x1b[36m${text}\x1b[0m`,
+  yellow: (text) => `\x1b[33m${text}\x1b[0m`,
+  red: (text) => `\x1b[31m${text}\x1b[0m`,
+  bold: (text) => `\x1b[1m${text}\x1b[0m`
+};
+
+// Check for updates function
+async function checkForUpdates() {
+  try {
+    console.log(colors.cyan('🔍 Checking for MAIASS updates...'));
+    
+    const https = require('https');
+    const url = 'https://api.github.com/repos/vsmash/maiass/releases/latest';
+    
+    return new Promise((resolve, reject) => {
+      const req = https.get(url, {
+        headers: {
+          'User-Agent': 'MAIASS-CLI'
+        }
+      }, (res) => {
+        let data = '';
+        res.on('data', (chunk) => data += chunk);
+        res.on('end', () => {
+          try {
+            const release = JSON.parse(data);
+            const latestVersion = release.tag_name?.replace('v', '') || release.name;
+            
+            if (latestVersion && latestVersion !== MAIASS_VERSION) {
+              console.log(colors.yellow(`📦 Update available: ${MAIASS_VERSION} → ${latestVersion}`));
+              console.log(colors.cyan('🍺 Update with: brew upgrade maiass'));
+              console.log(colors.cyan('📖 Or visit: https://github.com/vsmash/maiass/releases'));
+            } else {
+              console.log(colors.green('✅ You have the latest version!'));
+            }
+            resolve(true);
+          } catch (e) {
+            console.log(colors.yellow('⚠️  Could not parse update information'));
+            resolve(false);
+          }
+        });
+      });
+      
+      req.on('error', (err) => {
+        console.log(colors.yellow('⚠️  Could not check for updates (offline?)'));
+        resolve(false);
+      });
+      
+      req.setTimeout(5000, () => {
+        req.destroy();
+        console.log(colors.yellow('⚠️  Update check timed out'));
+        resolve(false);
+      });
+    });
+  } catch (error) {
+    console.log(colors.yellow('⚠️  Could not check for updates'));
+    return false;
+  }
+}
+
+// Command routing
+async function main() {
+  const command = firstArg || 'hello';
+  
+  switch (command) {
+    case 'hello':
+      console.log(colors.cyan('\n🚀 Hello from MAIASS!'));
+      console.log(colors.bold(`Version: ${MAIASS_VERSION}`));
+      console.log('\nThis is the bundled Node.js version with basic functionality.');
+      console.log('For full features, see: https://github.com/vsmash/maiass');
+      
+      // Auto-check for updates
+      console.log('');
+      await checkForUpdates();
+      break;
+      
+    case 'version':
+      console.log(colors.bold(`MAIASS v${MAIASS_VERSION}`));
+      console.log(`Node.js ${process.version}`);
+      console.log(`Platform: ${process.platform} ${process.arch}`);
+      break;
+      
+    case 'check-updates':
+      await checkForUpdates();
+      break;
+      
+    default:
+      console.log(colors.red(`❌ Unknown command: ${command}`));
+      console.log(colors.cyan('Run `maiass --help` for available commands.'));
+      console.log('\nNote: This bundled version has limited functionality.');
+      console.log('For full MAIASS features, install from source:');
+      console.log('https://github.com/vsmash/maiass');
+      process.exit(1);
+  }
+}
+
+// Run main function
+main().catch(error => {
+  console.error(colors.red('❌ Error:'), error.message);
+  process.exit(1);
+});

package/maiass.cjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/**
+ * CommonJS wrapper for maiass.mjs to ensure pkg compatibility
+ * This file serves as an entry point that pkg can properly handle
+ */
+
+// Import the ES module using dynamic import with detailed error handling
+(async () => {
+  try {
+    // Check if we're running in pkg environment
+    const isPkg = typeof process.pkg !== 'undefined';
+    
+    if (isPkg) {
+      // In pkg environment, try different import approaches
+      console.log('Running in pkg environment, attempting ES module import...');
+    }
+    
+    const module = await import('./maiass.mjs');
+    // console.log('ES module imported successfully');
+  } catch (error) {
+    console.error('Error starting maiass:');
+    console.error('Error type:', error.constructor.name);
+    console.error('Error message:', error.message);
+    console.error('Error stack:', error.stack);
+    
+    // Check if it's a specific pkg-related error
+    if (error.message.includes('Invalid host defined options')) {
+      console.error('\nThis appears to be a pkg/yargs compatibility issue.');
+      console.error('Try running with Node.js directly: node maiass.cjs');
+    }
+    
+    process.exit(1);
+  }
+})();

package/maiass.mjs

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+// MAIASS: Modular AI-Augmented Semantic Scribe
+import path from 'path';
+import fs from 'fs';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { initLogger, logger } from './lib/logger.js';
+import { loadEnvironmentConfig, ensureConfigDirectories } from './lib/config.js';
+
+// Load environment variables from multiple sources with cross-platform support
+ensureConfigDirectories();
+const envConfig = loadEnvironmentConfig();
+
+// Initialize logger with environment variables
+initLogger(envConfig);
+
+// Add a visible debug message
+const debugLine = '─'.repeat(60);
+logger.debug(debugLine);
+logger.debug('DEBUG MODE ENABLED - VERBOSE LOGGING ACTIVE');
+logger.debug('MAIASS_DEBUG is set to: ' + (envConfig.MAIASS_DEBUG || 'false'));
+logger.debug(debugLine);
+
+// Example: print version and a colorful welcome
+import colors from './lib/colors.js';
+
+// get the version from package.json (ES module compatible, cross-platform)
+const __dirname = path.dirname(new URL(import.meta.url).pathname.replace(/^\/(\w):/, '$1:'));
+const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json')));
+const version = packageJson.version;
+
+// Import env display utility
+import { displayEnvironmentVariables } from './lib/env-display.js';
+import { getGitInfo, displayGitInfo, validateBranchForOperations } from './lib/git-info.js';
+import { commitThis } from './lib/commit.js';
+import { handleConfigCommand } from './lib/config-command.js';
+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';
+
+// Simple CLI setup for pkg compatibility
+const args = process.argv.slice(2);
+const firstArg = args[0];
+
+// Check if first argument is a version bump type
+const versionBumpTypes = ['major', 'minor', 'patch'];
+let command = 'maiass'; // Default to maiass workflow
+let versionBump = null;
+
+if (firstArg && versionBumpTypes.includes(firstArg)) {
+  // First arg is a version bump type, use it for maiass workflow
+  versionBump = firstArg;
+  command = 'maiass';
+} else if (firstArg && !firstArg.startsWith('-')) {
+  // First arg is a command
+  command = firstArg;
+} else {
+  // No command specified or starts with flag, default to maiass
+  command = 'maiass';
+}
+
+// Handle --auto flag (must be before other processing)
+if (args.includes('--auto') || args.includes('-a')) {
+  // Override all auto-yes variables for non-interactive mode
+  process.env.MAIASS_AUTO_STAGE_UNSTAGED = 'true';
+  process.env.MAIASS_AUTO_PUSH_COMMITS = 'true';
+  process.env.MAIASS_AUTO_MERGE_TO_DEVELOP = 'true';
+  process.env.MAIASS_AUTO_APPROVE_AI_SUGGESTIONS = 'true';
+  
+  if (process.env.MAIASS_DEBUG === 'true') {
+    logger.debug('[DEBUG] Auto-mode enabled - all prompts will be skipped');
+  }
+}
+
+// Handle version flag
+if (args.includes('--version') || args.includes('-v')) {
+  console.log(version);
+  process.exit(0);
+}
+
+// Handle help flag
+if (args.includes('--help') || args.includes('-h') || command === 'help') {
+  console.log(`\nMAIASS v${version}`);
+  console.log('Usage: maiass [version-bump] [options]\n');
+  console.log('Version Bump (runs full MAIASS workflow):');
+  console.log('  maiass             Run MAIASS workflow (default: patch bump)');
+  console.log('  maiass minor       Run MAIASS workflow with minor version bump');
+  console.log('  maiass major       Run MAIASS workflow with major version bump');
+  console.log('  maiass patch       Run MAIASS workflow with patch version bump');
+  console.log('\nOther Commands:');
+  console.log('  hello              Print hello world');
+  console.log('  env                Display environment variables');
+  console.log('  git-info           Display git repository information');
+  console.log('  config             Manage configuration');
+  console.log('  version            Manage version information');
+  console.log('  account-info       Show your account status (masked token)');
+  console.log('\nOptions:');
+  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('  --help, -h         Show this help message');
+  console.log('  --version, -v      Show version');
+  console.log('  --dry-run          Run without making changes');
+  console.log('  --force            Skip confirmation prompts');
+  console.log('  --silent           Suppress non-essential output');
+  process.exit(0);
+}
+
+// Command routing
+switch (command) {
+  case 'hello':
+    console.log(colors.BCyan('Hello from MAIASS!'));
+    break;
+    
+  case 'env':
+    displayEnvironmentVariables();
+    break;
+    
+  case 'git-info':
+    const gitInfo = getGitInfo();
+    displayGitInfo(gitInfo);
+    break;
+    
+  case 'config':
+    handleConfigCommand(process.argv.slice(3));
+    break;
+    
+  case 'version':
+    handleVersionCommand(process.argv.slice(3));
+    break;
+    
+  case 'account-info':
+    handleAccountInfoCommand({
+      json: args.includes('--json')
+    });
+    break;
+    
+  case 'maiass':
+    // Handle the main MAIASS workflow
+    handleMaiassCommand({
+      _: process.argv.slice(2).filter(arg => !arg.startsWith('--')),
+      'commits-only': args.includes('--commits-only') || args.includes('-c'),
+      'auto-stage': args.includes('--auto-stage'),
+      'auto': args.includes('--auto'),
+      'version-bump': versionBump,
+      'dry-run': args.includes('--dry-run') || args.includes('-d'),
+      force: args.includes('--force') || args.includes('-f'),
+      silent: args.includes('--silent') || args.includes('-s'),
+      tag: getArgValue(args, '--tag') || getArgValue(args, '-t')
+    });
+    break;
+    
+  default:
+    console.error(`Unknown command: ${command}`);
+    console.log('Run `maiass --help` for available commands.');
+    process.exit(1);
+}
+
+// Helper function to get argument values
+function getArgValue(args, flag) {
+  const index = args.indexOf(flag);
+  if (index !== -1 && index < args.length - 1) {
+    return args[index + 1];
+  }
+  return null;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "maiass",
+  "type": "module",
+  "version": "5.7.31",
+  "description": "MAIASS - Modular AI-Augmented Semantic Scribe - Intelligent Git workflow automation",
+  "main": "maiass.mjs",
+  "bin": {
+    "maiass": "./maiass.mjs",
+    "maiass-setup": "./setup-env.js"
+  },
+  "author": "Velvary Pty Ltd",
+  "license": "GPL-3.0-only",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "git",
+    "automation",
+    "workflow",
+    "ai",
+    "commit",
+    "version",
+    "cli"
+  ],
+  "scripts": {
+    "start": "node maiass.mjs",
+    "build": "./scripts/build-bundled.sh",
+    "build:all": "./scripts/advanced-build.sh all",
+    "build:pkg": "./scripts/advanced-build.sh pkg",
+    "build:bun": "./scripts/advanced-build.sh bun",
+    "build:nexe": "./scripts/advanced-build.sh nexe",
+    "build:source": "./scripts/advanced-build.sh source",
+    "build:legacy": "node build.js",
+    "test": "node test/test-runner.js"
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "dotenv": "^16.4.5",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "nexe": "^5.0.0-beta.4",
+    "pkg": "^5.8.1"
+  }
+}

package/setup-env.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+// Helper script to set up environment variables in secure locations
+import { getSecureEnvPath, getConfigEnvPath, ensureConfigDirectories } from './lib/config.js';
+import fs from 'fs';
+import readline from 'readline';
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+function prompt(question) {
+  return new Promise((resolve) => {
+    rl.question(question, resolve);
+  });
+}
+
+async function setupEnvironment() {
+  console.log('🔧 MAIASS Environment Setup');
+  console.log('===============================\n');
+  
+  ensureConfigDirectories();
+  
+  const secureEnvPath = getSecureEnvPath();
+  const configEnvPath = getConfigEnvPath();
+  
+  console.log(`Secure variables will be stored in: ${secureEnvPath}`);
+  console.log(`General config will be stored in: ${configEnvPath}\n`);
+  
+  // Check if files already exist
+  const secureExists = fs.existsSync(secureEnvPath);
+  const configExists = fs.existsSync(configEnvPath);
+  
+  if (secureExists || configExists) {
+    console.log('⚠️  Configuration files already exist:');
+    if (secureExists) console.log(`   - ${secureEnvPath}`);
+    if (configExists) console.log(`   - ${configEnvPath}`);
+    
+    const overwrite = await prompt('\nDo you want to update them? (y/N): ');
+    if (overwrite.toLowerCase() !== 'y') {
+      console.log('Setup cancelled.');
+      rl.close();
+      return;
+    }
+  }
+  
+  // Collect sensitive variables
+  console.log('\n📝 Setting up sensitive variables (stored securely):');
+  const maiassKey = await prompt('MAIASS API Key (optional): ');
+  
+  // Collect general config
+  console.log('\n⚙️  Setting up general configuration:');
+  const defaultBranch = await prompt('Default branch name (default: main): ') || 'main';
+  const developBranch = await prompt('Development branch name (default: develop): ') || 'develop';
+  
+  // Write secure env file
+  if (maiassKey.trim()) {
+    const secureContent = `# Sensitive environment variables for MAIASS
+# This file is stored in a secure OS-specific location
+MAIASS_API_KEY=${maiassKey.trim()}
+`;
+    fs.writeFileSync(secureEnvPath, secureContent, { mode: 0o600 }); // Secure permissions
+    console.log(`✅ Secure variables saved to: ${secureEnvPath}`);
+  }
+  
+  // Write general config file
+  const configContent = `# General configuration for MAIASS
+# This file contains non-sensitive settings
+DEFAULT_BRANCH=${defaultBranch}
+DEVELOP_BRANCH=${developBranch}
+MAIASS_VERSION=0.2.0
+`;
+  fs.writeFileSync(configEnvPath, configContent);
+  console.log(`✅ General config saved to: ${configEnvPath}`);
+  
+  console.log('\n🎉 Environment setup complete!');
+  console.log('\nYou can also create project-specific .env files in your working directories.');
+  console.log('Priority order: .env (cwd) > ~/.maiass.env > config.env > secure.env');
+  
+  rl.close();
+}
+
+setupEnvironment().catch(console.error);