maiass 5.7.31 → 5.7.33

package/lib/changelog.js

@@ -0,0 +1,215 @@
+// Changelog management for MAIASS - matches bashmaiass implementation
+import { execSync } from 'child_process';
+import fs from 'fs/promises';
+import { log } from './logger.js';
+import { SYMBOLS } from './symbols.js';
+
+/**
+ * Execute git command and return output
+ * @param {string} command - Git command to execute
+ * @returns {string|null} Command output or null if failed
+ */
+function executeGitCommand(command) {
+  try {
+    return execSync(command, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get the last changelog commit hash
+ * @param {string} changelogPath - Path to changelog file
+ * @returns {string|null} Commit hash or null
+ */
+function getLastChangelogCommit(changelogPath) {
+  try {
+    const content = execSync(`cat "${changelogPath}"`, { encoding: 'utf8' });
+    const match = content.match(/^## (.+)$/m);
+    if (match) {
+      const lastVersion = match[1].trim();
+      const hash = executeGitCommand(`git log -1 --format="%H" -S"## ${lastVersion}" -- "${changelogPath}"`);
+      if (hash) return hash;
+    }
+  } catch {}
+  
+  // Fallback to first commit
+  return executeGitCommand('git rev-list --max-parents=0 HEAD');
+}
+
+/**
+ * Update changelog files with new version and commits
+ * @param {string} changelogPath - Directory containing changelog
+ * @param {string} version - New version number
+ * @returns {Promise<void>}
+ */
+export async function updateChangelog(changelogPath = '.', version) {
+  const changelogName = process.env.MAIASS_CHANGELOG_NAME || 'CHANGELOG.md';
+  const changelogInternalName = process.env.MAIASS_CHANGELOG_INTERNAL_NAME || '.CHANGELOG_internal.md';
+  const changelogInternalPath = process.env.MAIASS_CHANGELOG_INTERNAL_PATH || changelogPath;
+  
+  const changelogFile = `${changelogPath}/${changelogName}`;
+  const changelogInternalFile = `${changelogInternalPath}/${changelogInternalName}`;
+  
+  // Get last changelog commit
+  let lastChangelogCommit = null;
+  try {
+    await fs.access(changelogFile);
+    lastChangelogCommit = getLastChangelogCommit(changelogFile);
+  } catch {}
+  
+  if (!lastChangelogCommit) {
+    lastChangelogCommit = executeGitCommand('git rev-list --max-parents=0 HEAD');
+  }
+  
+  if (!lastChangelogCommit) {
+    log.info(SYMBOLS.INFO, 'No commits found, skipping changelog');
+    return;
+  }
+  
+  const logRange = `${lastChangelogCommit}..HEAD`;
+  
+  // Get commits for main changelog (remove JIRA tickets, filter out merges/bumps)
+  const rawCommits = executeGitCommand(`git log ${logRange} --pretty=format:"%B"`);
+  
+  let changelog = '';
+  if (rawCommits) {
+    // Process commits: filter and format
+    const commits = rawCommits.split('\n\n').filter(commit => {
+      const firstLine = commit.split('\n')[0].toLowerCase();
+      return !firstLine.match(/^(ncl|merge|bump|fixing merge conflicts)/i);
+    });
+    
+    const formattedCommits = commits.map(commit => {
+      // Remove JIRA ticket from start
+      const cleaned = commit.replace(/^\[?[A-Z]+-[0-9]+\]?[\s:—-]+/gm, '');
+      const lines = cleaned.split('\n').filter(l => l.trim());
+      
+      if (lines.length === 0) return '';
+      
+      // First line as bullet, rest as indented sub-bullets
+      let result = `- ${lines[0]}`;
+      for (let i = 1; i < lines.length; i++) {
+        if (lines[i].trim()) {
+          result += `\n\t${lines[i]}`;
+        }
+      }
+      return result;
+    }).filter(c => c);
+    
+    changelog = formattedCommits.join('\n');
+  }
+  
+  // Get commits for internal changelog (with author names)
+  const rawInternalCommits = executeGitCommand(`git log ${logRange} --pretty=format:"%an%n%B"`);
+  
+  let changelogInternal = '';
+  if (rawInternalCommits) {
+    // Process internal commits with author
+    const commitBlocks = rawInternalCommits.split('\n\n').filter(block => {
+      const lines = block.split('\n');
+      if (lines.length < 2) return false;
+      const subject = lines[1].toLowerCase();
+      return !subject.match(/^(ncl|merge|bump|fixing merge conflicts)/i);
+    });
+    
+    const formattedInternal = commitBlocks.map(block => {
+      const lines = block.split('\n').filter(l => l.trim());
+      if (lines.length < 2) return '';
+      
+      const author = lines[0];
+      const subject = lines[1]; // Keep JIRA ticket in internal changelog
+      
+      let result = `- ${author}: ${subject}`;
+      for (let i = 2; i < lines.length; i++) {
+        if (lines[i].trim()) {
+          result += `\n\t${lines[i]}`;
+        }
+      }
+      return result;
+    }).filter(c => c);
+    
+    changelogInternal = formattedInternal.join('\n');
+  }
+  
+  // Get current date
+  const now = new Date();
+  const humanDate = now.toLocaleDateString('en-GB', { day: 'numeric', month: 'long', year: 'numeric' });
+  const weekday = now.toLocaleDateString('en-GB', { weekday: 'long' });
+  const longHumanDate = `${humanDate} (${weekday})`;
+  
+  // Update main changelog
+  if (!changelog) {
+    log.info(SYMBOLS.INFO, 'No changelog to add');
+  } else {
+    try {
+      let existingContent = '';
+      try {
+        existingContent = await fs.readFile(changelogFile, 'utf8');
+      } catch {}
+      
+      if (existingContent) {
+        const lines = existingContent.split('\n');
+        const firstVersion = lines[0]?.match(/^## (.+)$/)?.[1];
+        const secondLine = lines[1];
+        
+        // Check if we're updating the same minor version on the same date
+        const currentMinor = version.split('.').slice(0, 2).join('.');
+        const existingMinor = firstVersion?.split('.').slice(0, 2).join('.');
+        
+        if (currentMinor === existingMinor && secondLine === humanDate) {
+          // Replace existing entry
+          const newContent = `## ${version}\n${humanDate}\n\n${changelog}\n${lines.slice(3).join('\n')}`;
+          await fs.writeFile(changelogFile, newContent, 'utf8');
+        } else {
+          // Add new entry
+          const newContent = `## ${version}\n${humanDate}\n\n${changelog}\n\n${existingContent}`;
+          await fs.writeFile(changelogFile, newContent, 'utf8');
+        }
+      } else {
+        // Create new file
+        await fs.writeFile(changelogFile, `## ${version}\n${humanDate}\n\n${changelog}\n`, 'utf8');
+      }
+      
+      log.success(SYMBOLS.CHECKMARK, `Updated ${changelogName}`);
+    } catch (error) {
+      log.error(SYMBOLS.CROSS, `Failed to update ${changelogName}: ${error.message}`);
+    }
+  }
+  
+  // Update internal changelog
+  if (!changelogInternal) {
+    log.info(SYMBOLS.INFO, 'No commits for internal changelog - updating version header only');
+  }
+  
+  try {
+    await fs.access(changelogInternalFile);
+    
+    let existingContent = await fs.readFile(changelogInternalFile, 'utf8');
+    const lines = existingContent.split('\n');
+    const firstVersion = lines[0]?.match(/^## (.+)$/)?.[1];
+    const secondLine = lines[1];
+    
+    // Check if we're updating the same minor version on the same date
+    const currentMinor = version.split('.').slice(0, 2).join('.');
+    const existingMinor = firstVersion?.split('.').slice(0, 2).join('.');
+    
+    const contentToAdd = changelogInternal || '';
+    
+    if (currentMinor === existingMinor && secondLine === longHumanDate) {
+      // Replace existing entry
+      const newContent = `## ${version}\n${longHumanDate}\n\n${contentToAdd}\n${lines.slice(3).join('\n')}`;
+      await fs.writeFile(changelogInternalFile, newContent, 'utf8');
+    } else {
+      // Add new entry
+      const newContent = `## ${version}\n${longHumanDate}\n\n${contentToAdd}\n\n${existingContent}`;
+      await fs.writeFile(changelogInternalFile, newContent, 'utf8');
+    }
+    
+    log.success(SYMBOLS.CHECKMARK, `Updated ${changelogInternalName}`);
+  } catch (error) {
+    log.info(SYMBOLS.INFO, `Internal changelog ${changelogInternalFile} does not exist, skipping`);
+  }
+}
+
+export default { updateChangelog };

package/maiass.mjs

@@ -107,55 +107,66 @@ if (args.includes('--help') || args.includes('-h') || command === 'help') {
   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);
-}
+// Command routing (wrapped in async IIFE to handle async commands)
+(async () => {
+  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':
+      await handleConfigCommand(process.argv.slice(3));
+      break;
+      
+    case 'version':
+      await handleVersionCommand(process.argv.slice(3));
+      break;
+      
+    case 'account-info':
+      await handleAccountInfoCommand({
+        json: args.includes('--json')
+      });
+      break;
+      
+    case 'maiass':
+      // Handle the main MAIASS workflow
+      await 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);
+  }
+  
+  // Exit cleanly after successful command execution
+  process.exit(0);
+})().catch(error => {
+  console.error(colors.Red(`${SYMBOLS.CROSS} Fatal error: ${error.message}`));
+  if (process.env.MAIASS_DEBUG === 'true') {
+    console.error(colors.Gray(error.stack));
+  }
+  process.exit(1);
+});
 
 // Helper function to get argument values
 function getArgValue(args, flag) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "maiass",
   "type": "module",
-  "version": "5.7.31",
+  "version": "5.7.33",
   "description": "MAIASS - Modular AI-Augmented Semantic Scribe - Intelligent Git workflow automation",
   "main": "maiass.mjs",
   "bin": {
@@ -10,6 +10,15 @@
   },
   "author": "Velvary Pty Ltd",
   "license": "GPL-3.0-only",
+  "files": [
+    "lib/",
+    "maiass.mjs",
+    "maiass.cjs",
+    "maiass-standalone.cjs",
+    "setup-env.js",
+    "README.md",
+    "LICENSE"
+  ],
   "engines": {
     "node": ">=18.0.0"
   },

package/build.js

@@ -1,127 +0,0 @@
-#!/usr/bin/env node
-/**
- * Cross-platform build script for maiass
- * Builds binaries for all supported platforms and architectures
- */
-
-import { execSync } from 'child_process';
-import fs from 'fs';
-import path from 'path';
-import colors from './lib/colors.js';
-
-const targets = [
-  'node18-macos-x64',
-  'node18-macos-arm64', 
-  'node18-linux-x64',
-  'node18-linux-arm64',
-  'node18-win-x64',
-  'node18-win-arm64'
-];
-
-const platformNames = {
-  'node18-macos-x64': 'macOS Intel',
-  'node18-macos-arm64': 'macOS Apple Silicon',
-  'node18-linux-x64': 'Linux x64',
-  'node18-linux-arm64': 'Linux ARM64',
-  'node18-win-x64': 'Windows x64',
-  'node18-win-arm64': 'Windows ARM64'
-};
-
-function buildForTarget(target) {
-  console.log(colors.BBlue(`Building for ${platformNames[target]}...`));
-  
-  // Map target to output filename
-  const outputNames = {
-    'node18-macos-x64': 'maiass-macos-x64',
-    'node18-macos-arm64': 'maiass-macos-arm64',
-    'node18-linux-x64': 'maiass-linux-x64',
-    'node18-linux-arm64': 'maiass-linux-arm64',
-    'node18-win-x64': 'maiass-win-x64.exe',
-    'node18-win-arm64': 'maiass-win-arm64.exe'
-  };
-  
-  const outputName = outputNames[target];
-  const outputPath = `build/${outputName}`;
-  
-  try {
-    execSync(`npx pkg . --target ${target} --output ${outputPath}`, {
-      stdio: 'inherit',
-      encoding: 'utf8'
-    });
-    console.log(colors.Green(`✓ Successfully built for ${platformNames[target]} -> ${outputName}`));
-    
-    // Code sign macOS binaries
-    if (target.includes('macos') && process.platform === 'darwin') {
-      try {
-        console.log(colors.BBlue(`  🔐 Code signing ${outputName}...`));
-        execSync(`./scripts/codesign.sh "${outputPath}"`, { stdio: 'pipe' });
-        console.log(colors.Green(`  ✓ Code signed ${outputName}`));
-      } catch (error) {
-        console.log(colors.Yellow(`  ⚠️ Code signing failed for ${outputName} (continuing without signing)`));
-        console.log(colors.Gray(`    ${error.message.split('\n')[0]}`));
-      }
-    }
-    
-    // Code sign Windows binaries
-    if (target.includes('win')) {
-      try {
-        console.log(colors.BBlue(`  🔐 Code signing ${outputName}...`));
-        execSync(`./scripts/codesign-windows.sh "${outputPath}"`, { stdio: 'pipe' });
-        console.log(colors.Green(`  ✓ Code signed ${outputName}`));
-      } catch (error) {
-        console.log(colors.Yellow(`  ⚠️ Windows code signing failed for ${outputName} (continuing without signing)`));
-        console.log(colors.Gray(`    ${error.message.split('\n')[0]}`));
-      }
-    }
-    
-    return true;
-  } catch (error) {
-    console.log(colors.Red(`✗ Failed to build for ${platformNames[target]}: ${error.message}`));
-    return false;
-  }
-}
-
-function main() {
-  console.log(colors.Aqua('MAIASS Cross-Platform Build'));
-  console.log(colors.White('Building binaries for all supported platforms...\n'));
-
-  // Ensure build directory exists and is clean
-  if (fs.existsSync('build')) {
-    // Clean the build directory
-    const files = fs.readdirSync('build');
-    for (const file of files) {
-      if (file !== '.DS_Store') {
-        fs.unlinkSync(path.join('build', file));
-      }
-    }
-  } else {
-    fs.mkdirSync('build');
-  }
-
-  let successful = 0;
-  let failed = 0;
-
-  for (const target of targets) {
-    if (buildForTarget(target)) {
-      successful++;
-    } else {
-      failed++;
-    }
-    console.log(''); // Add spacing between builds
-  }
-
-  console.log(colors.White('\n=== Build Summary ==='));
-  console.log(colors.Green(`Successful builds: ${successful}`));
-  if (failed > 0) {
-    console.log(colors.Red(`Failed builds: ${failed}`));
-  }
-  
-  if (successful === targets.length) {
-    console.log(colors.Green('\n🎉 All builds completed successfully!'));
-    console.log(colors.White('Binaries are available in the build/ directory'));
-  } else {
-    console.log(colors.Yellow('\n⚠️  Some builds failed. Check the output above for details.'));
-  }
-}
-
-main();