maiass 5.7.31

package/lib/git-info.js

@@ -0,0 +1,509 @@
+// Git branch detection and information extraction utility
+import { execSync } from 'child_process';
+import { log, logger } from './logger.js';
+import colors from './colors.js';
+import { SYMBOLS } from './symbols.js';
+
+/**
+ * Git information object structure
+ * @typedef {Object} GitInfo
+ * @property {string} branch - Current branch name
+ * @property {string} author - Git author name
+ * @property {string} email - Git author email
+ * @property {string|null} jiraTicket - JIRA ticket number if found in branch name
+ * @property {boolean} isFeatureBranch - True if this is a feature branch
+ * @property {boolean} isReleaseBranch - True if this is a release branch
+ * @property {boolean} isMainBranch - True if this is main/main branch
+ * @property {boolean} isDevelopBranch - True if this is develop branch
+ * @property {boolean} isStagingBranch - True if this is staging branch
+ * @property {string} branchType - Branch type classification
+ * @property {Object} remote - Remote repository information
+ * @property {Object} status - Git status information (staged, unstaged, untracked files)
+ * @property {boolean} hasChanges - True if there are any changes (staged or unstaged)
+ * @property {boolean} isClean - True if working directory is clean
+ */
+
+/**
+ * Execute git command safely
+ * @param {string} command - Git command to execute
+ * @param {boolean} silent - Whether to suppress errors
+ * @returns {string|null} Command output or null if failed
+ */
+function executeGitCommand(command, silent = false) {
+  try {
+    const result = execSync(command, { 
+      encoding: 'utf8', 
+      stdio: silent ? 'pipe' : ['pipe', 'pipe', 'ignore']
+    });
+    
+    // For git status --porcelain, preserve leading spaces but remove trailing newline
+    if (command.includes('git status --porcelain')) {
+      return result.replace(/\n$/, ''); // Only remove trailing newline
+    }
+    
+    return result.trim(); // Normal trim for other commands
+  } catch (error) {
+    if (!silent) {
+      console.error(`Git command failed: ${command}`);
+      console.error(error.message);
+    }
+    return null;
+  }
+}
+
+/**
+ * Check if we're in a git repository
+ * @returns {boolean} True if in a git repository
+ */
+export function isGitRepository() {
+  return executeGitCommand('git rev-parse --is-inside-work-tree', true) === 'true';
+}
+
+/**
+ * Get current git branch name
+ * @returns {string|null} Current branch name or null if not in git repo
+ */
+export function getCurrentBranch() {
+  return executeGitCommand('git rev-parse --abbrev-ref HEAD', true);
+}
+
+/**
+ * Get git author information
+ * @returns {Object} Author information with name and email
+ */
+export function getGitAuthor() {
+  const name = executeGitCommand('git config user.name', true) || 'Unknown';
+  const email = executeGitCommand('git config user.email', true) || 'unknown@example.com';
+  
+  return { name, email };
+}
+
+/**
+ * Extract JIRA ticket number from branch name
+ * Pattern matches: feature/ABC-123, bugfix/XYZ-456, etc.
+ * Looks for pattern after last slash: [A-Z]+-[0-9]+
+ * @param {string} branchName - Branch name to analyze
+ * @returns {string|null} JIRA ticket number or null if not found
+ */
+export function extractJiraTicket(branchName) {
+  if (!branchName) return null;
+
+  // Match after the last slash
+  const afterSlash = branchName.match(/.*\/([A-Z]+-[0-9]+)/);
+  if (afterSlash) return afterSlash[1];
+
+  // Match at the beginning of the branch name
+  const atStart = branchName.match(/^([A-Z]+-[0-9]+)/);
+  if (atStart) return atStart[1];
+
+  return null;
+}
+
+/**
+ * Classify branch type based on name and patterns
+ * @param {string} branchName - Branch name to classify
+ * @param {Object} branchConfig - Branch configuration from environment
+ * @returns {Object} Branch classification information
+ */
+export function classifyBranch(branchName, branchConfig = {}) {
+  if (!branchName) return { type: 'unknown', isSpecial: false };
+  
+  const {
+    developBranch = 'develop',
+    stagingBranch = 'staging', 
+    mainBranch = 'main'
+  } = branchConfig;
+  
+  const lowerBranch = branchName.toLowerCase();
+  
+  // Check for exact matches first
+  if (branchName === mainBranch || branchName === 'main') {
+    return { type: 'main', isSpecial: true, isMain: true };
+  }
+  
+  if (branchName === developBranch) {
+    return { type: 'develop', isSpecial: true, isDevelop: true };
+  }
+  
+  if (branchName === stagingBranch) {
+    return { type: 'staging', isSpecial: true, isStaging: true };
+  }
+  
+  // Check for pattern-based matches
+  if (lowerBranch.startsWith('feature/') || lowerBranch.startsWith('feat/')) {
+    return { type: 'feature', isSpecial: false, isFeature: true };
+  }
+  
+  if (lowerBranch.startsWith('bugfix/') || lowerBranch.startsWith('bug/') || lowerBranch.startsWith('fix/')) {
+    return { type: 'bugfix', isSpecial: false, isBugfix: true };
+  }
+  
+  if (lowerBranch.startsWith('hotfix/')) {
+    return { type: 'hotfix', isSpecial: true, isHotfix: true };
+  }
+  
+  if (lowerBranch.startsWith('release/') || lowerBranch.startsWith('releases/')) {
+    return { type: 'release', isSpecial: true, isRelease: true };
+  }
+  
+  if (lowerBranch.startsWith('chore/')) {
+    return { type: 'chore', isSpecial: false, isChore: true };
+  }
+  
+  if (lowerBranch.startsWith('docs/') || lowerBranch.startsWith('doc/')) {
+    return { type: 'documentation', isSpecial: false, isDocs: true };
+  }
+  
+  return { type: 'other', isSpecial: false, isOther: true };
+}
+
+/**
+ * Get git status information (staged, unstaged, untracked files)
+ * @returns {Object} Git status with file counts and lists
+ */
+export function getGitStatus() {
+  if (!isGitRepository()) {
+    return null;
+  }
+  
+  try {
+    // Get git status in porcelain format for easy parsing
+    const statusOutput = executeGitCommand('git status --porcelain', true);
+    
+    if (!statusOutput) {
+      return {
+        staged: [],
+        unstaged: [],
+        untracked: [],
+        stagedCount: 0,
+        unstagedCount: 0,
+        untrackedCount: 0,
+        hasChanges: false,
+        isClean: true
+      };
+    }
+    
+    const staged = [];
+    const unstaged = [];
+    const untracked = [];
+    
+    const lines = statusOutput.split('\n').filter(line => line.trim());
+    
+    lines.forEach(line => {
+      if (line.length < 3) return;
+      
+      const indexStatus = line[0]; // Staged changes
+      const workingStatus = line[1]; // Unstaged changes
+      const filename = line.substring(3);
+      
+      // Check for staged changes
+      if (indexStatus !== ' ' && indexStatus !== '?') {
+        staged.push({
+          file: filename,
+          status: indexStatus,
+          statusText: getStatusText(indexStatus)
+        });
+      }
+      
+      // Check for unstaged changes
+      if (workingStatus !== ' ' && workingStatus !== '?') {
+        unstaged.push({
+          file: filename,
+          status: workingStatus,
+          statusText: getStatusText(workingStatus)
+        });
+      }
+      
+      // Check for untracked files
+      if (indexStatus === '?' && workingStatus === '?') {
+        untracked.push({
+          file: filename,
+          status: '?',
+          statusText: 'untracked'
+        });
+      }
+    });
+    
+    const stagedCount = staged.length;
+    const unstagedCount = unstaged.length;
+    const untrackedCount = untracked.length;
+    const hasChanges = stagedCount > 0 || unstagedCount > 0 || untrackedCount > 0;
+    
+    return {
+      staged,
+      unstaged,
+      untracked,
+      stagedCount,
+      unstagedCount,
+      untrackedCount,
+      hasChanges,
+      isClean: !hasChanges
+    };
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Convert git status code to human-readable text
+ * @param {string} statusCode - Git status code
+ * @returns {string} Human-readable status
+ */
+function getStatusText(statusCode) {
+  switch (statusCode) {
+    case 'M': return 'modified';
+    case 'A': return 'added';
+    case 'D': return 'deleted';
+    case 'R': return 'renamed';
+    case 'C': return 'copied';
+    case 'U': return 'unmerged';
+    case '?': return 'untracked';
+    case '!': return 'ignored';
+    default: return 'unknown';
+  }
+}
+
+/**
+ * Get remote repository information
+ * @returns {Object} Remote repository information
+ */
+export function getRemoteInfo() {
+  const remoteUrl = executeGitCommand('git remote get-url origin', true);
+  
+  if (!remoteUrl) {
+    return { url: null, provider: null, owner: null, repo: null };
+  }
+  
+  // Parse GitHub URLs
+  const githubMatch = remoteUrl.match(/github\.com[:/]([^/]+)\/([^/\.]+)/);
+  if (githubMatch) {
+    return {
+      url: remoteUrl,
+      provider: 'github',
+      owner: githubMatch[1],
+      repo: githubMatch[2]
+    };
+  }
+  
+  // Parse Bitbucket URLs  
+  const bitbucketMatch = remoteUrl.match(/bitbucket\.org[:/]([^/]+)\/([^/\.]+)/);
+  if (bitbucketMatch) {
+    return {
+      url: remoteUrl,
+      provider: 'bitbucket',
+      owner: bitbucketMatch[1],
+      repo: bitbucketMatch[2]
+    };
+  }
+  
+  // Parse GitLab URLs
+  const gitlabMatch = remoteUrl.match(/gitlab\.com[:/]([^/]+)\/([^/\.]+)/);
+  if (gitlabMatch) {
+    return {
+      url: remoteUrl,
+      provider: 'gitlab',
+      owner: gitlabMatch[1],
+      repo: gitlabMatch[2]
+    };
+  }
+  
+  return {
+    url: remoteUrl,
+    provider: 'unknown',
+    owner: null,
+    repo: null
+  };
+}
+
+/**
+ * Get comprehensive git information
+ * @param {Object} options - Configuration options
+ * @returns {GitInfo} Complete git information with isRepository flag
+ */
+export function getGitInfo(options = {}) {
+  if (!isGitRepository()) {
+    return {
+      isRepository: false,
+      currentBranch: null,
+      hasChanges: false,
+      stagedChanges: [],
+      unstagedChanges: [],
+      gitAuthor: null,
+      jiraTicket: null
+    };
+  }
+  
+  const branch = getCurrentBranch();
+  if (!branch) {
+    return {
+      isRepository: true,
+      currentBranch: null,
+      hasChanges: false,
+      stagedChanges: [],
+      unstagedChanges: [],
+      gitAuthor: null,
+      jiraTicket: null
+    };
+  }
+  
+  const author = getGitAuthor();
+  const jiraTicket = extractJiraTicket(branch);
+  const remote = getRemoteInfo();
+  const status = getGitStatus();
+  
+  // Get branch configuration from environment or options
+  const branchConfig = {
+    developBranch: process.env.MAIASS_DEVELOPBRANCH || options.developBranch || 'develop',
+    stagingBranch: process.env.MAIASS_STAGINGBRANCH || options.stagingBranch || 'staging',
+    mainBranch: process.env.MAIASS_MAINBRANCH || options.mainBranch || 'main'
+  };
+  
+  const classification = classifyBranch(branch, branchConfig);
+  
+  return {
+    isRepository: true,
+    currentBranch: branch,
+    branch,
+    author: author.name,
+    email: author.email,
+    gitAuthor: `${author.name} <${author.email}>`,
+    jiraTicket,
+    branchType: classification.type,
+    isFeatureBranch: classification.isFeature || false,
+    isReleaseBranch: classification.isRelease || false,
+    isMainBranch: classification.isMain || false,
+    isDevelopBranch: classification.isDevelop || false,
+    isStagingBranch: classification.isStaging || false,
+    isBugfixBranch: classification.isBugfix || false,
+    isHotfixBranch: classification.isHotfix || false,
+    isSpecialBranch: classification.isSpecial || false,
+    remote,
+    status,
+    hasChanges: status ? status.hasChanges : false,
+    isClean: status ? status.isClean : true,
+    stagedChanges: status ? status.stagedChanges : [],
+    unstagedChanges: status ? status.unstagedChanges : [],
+    branchConfig
+  };
+}
+
+/**
+ * Display git information in a formatted way
+ * @param {GitInfo} gitInfo - Git information to display
+ * @param {Object} options - Display options
+ */
+export function displayGitInfo(gitInfo, options = {}) {
+  const { showRemote = true, showAuthor = true, showStatus = true } = options;
+  
+  if (!gitInfo) {
+    log.error(SYMBOLS.CROSS, 'Not in a git repository');
+    return;
+  }
+  
+  log.info(SYMBOLS.GEAR, 'Git Information');
+  console.log();
+  
+  // Branch information
+  const branchColor = gitInfo.isSpecialBranch ? colors.BYellow : colors.BGreen;
+  console.log(`  ${colors.BBlue('Current Branch:')} ${branchColor(gitInfo.branch)}`);
+  console.log(`  ${colors.BBlue('Branch Type:')}   ${colors.White(gitInfo.branchType)}`);
+  
+  // JIRA ticket if found
+  if (gitInfo.jiraTicket) {
+    console.log(`  ${colors.BBlue('JIRA Ticket:')}   ${colors.BPurple(gitInfo.jiraTicket)}`);
+  }
+  
+  // Author information
+  if (showAuthor) {
+    console.log(`  ${colors.BBlue('Author:')}       ${colors.White(gitInfo.author)}`);
+    console.log(`  ${colors.BBlue('Email:')}        ${colors.Gray(gitInfo.email)}`);
+  }
+  
+  // Git status information
+  if (showStatus && gitInfo.status) {
+    const status = gitInfo.status;
+    const statusColor = status.isClean ? colors.Green : colors.Yellow;
+    const statusText = status.isClean ? 'Clean' : 'Has changes';
+    console.log(`  ${colors.BBlue('Status:')}       ${statusColor(statusText)}`);
+    
+    if (!status.isClean) {
+      if (status.stagedCount > 0) {
+        console.log(`  ${colors.BBlue('Staged:')}       ${colors.Green(status.stagedCount + ' file' + (status.stagedCount === 1 ? '' : 's'))}`);
+      }
+      if (status.unstagedCount > 0) {
+        console.log(`  ${colors.BBlue('Unstaged:')}     ${colors.Yellow(status.unstagedCount + ' file' + (status.unstagedCount === 1 ? '' : 's'))}`);
+      }
+      if (status.untrackedCount > 0) {
+        console.log(`  ${colors.BBlue('Untracked:')}    ${colors.Red(status.untrackedCount + ' file' + (status.untrackedCount === 1 ? '' : 's'))}`);
+      }
+    }
+  }
+  
+  // Remote information
+  if (showRemote && gitInfo.remote.url) {
+    console.log(`  ${colors.BBlue('Remote:')}       ${colors.Cyan(gitInfo.remote.provider || 'unknown')} ${colors.Gray('(' + gitInfo.remote.url + ')')}`);
+    if (gitInfo.remote.owner && gitInfo.remote.repo) {
+      console.log(`  ${colors.BBlue('Repository:')}   ${colors.White(gitInfo.remote.owner + '/' + gitInfo.remote.repo)}`);
+    }
+  }
+  
+  console.log();
+}
+
+/**
+ * Validate branch for operations (similar to branchDetection in maiass.sh)
+ * @param {GitInfo} gitInfo - Git information
+ * @returns {Object} Validation result with warnings and recommendations
+ */
+export function validateBranchForOperations(gitInfo) {
+  if (!gitInfo) {
+    return {
+      valid: false,
+      error: 'Not in a git repository',
+      warnings: [],
+      recommendations: []
+    };
+  }
+  
+  const warnings = [];
+  const recommendations = [];
+  let valid = true;
+  
+  // Check if on main/main branch
+  if (gitInfo.isMainBranch) {
+    warnings.push(`You are on the ${gitInfo.branch} branch`);
+    recommendations.push(`Consider switching to ${gitInfo.branchConfig.developBranch} for development work`);
+  }
+  
+  // Check if on release branch
+  if (gitInfo.isReleaseBranch) {
+    warnings.push(`You are on a release branch: ${gitInfo.branch}`);
+    recommendations.push('Release branches should only be used for release preparation');
+  }
+  
+  // Check if on staging branch
+  if (gitInfo.isStagingBranch) {
+    warnings.push(`You are on the ${gitInfo.branch} branch`);
+    recommendations.push(`Consider switching to ${gitInfo.branchConfig.developBranch} for development work`);
+  }
+  
+  return {
+    valid,
+    warnings,
+    recommendations,
+    gitInfo
+  };
+}
+
+// Export all functions as default object
+export default {
+  isGitRepository,
+  getCurrentBranch,
+  getGitAuthor,
+  extractJiraTicket,
+  classifyBranch,
+  getRemoteInfo,
+  getGitInfo,
+  displayGitInfo,
+  validateBranchForOperations
+};

package/lib/header.js

@@ -0,0 +1,152 @@
+// Header display for MAIASS - matches bashmaiass branding
+import colors from './colors.js';
+import chalk from 'chalk';
+
+/**
+ * Check if terminal supports Unicode
+ * @returns {boolean}
+ */
+function supportsUnicode() {
+  // Check environment variables
+  const lang = process.env.LANG || process.env.LC_ALL || '';
+  if (lang.toLowerCase().includes('utf')) return true;
+  
+  // Windows typically doesn't support Unicode well in older terminals
+  if (process.platform === 'win32') {
+    // Windows Terminal and newer PowerShell support Unicode
+    return process.env.WT_SESSION || process.env.TERM_PROGRAM === 'vscode';
+  }
+  
+  // macOS and Linux typically support Unicode
+  return true;
+}
+
+/**
+ * Check if terminal supports 256 colors
+ * @returns {boolean}
+ */
+function supports256Color() {
+  const term = process.env.TERM || '';
+  return term.includes('256') || term.includes('xterm');
+}
+
+/**
+ * Check if terminal supports truecolor (24-bit)
+ * @returns {boolean}
+ */
+function supportsTruecolor() {
+  const colorterm = process.env.COLORTERM || '';
+  return colorterm === 'truecolor' || colorterm === '24bit';
+}
+
+/**
+ * Create a gradient line using the best available color support
+ * @param {number} length - Length of the line
+ * @param {string} startHex - Starting color (hex format)
+ * @param {string} endHex - Ending color (hex format)
+ * @returns {string} Colored gradient line
+ */
+function printGradientLine(length = 60, startHex = '#f7b2c4', endHex = '#6b0022') {
+  const useUnicode = supportsUnicode();
+  const char = useUnicode ? '═' : '=';
+  
+  // Truecolor support (best quality)
+  if (supportsTruecolor()) {
+    const r1 = parseInt(startHex.slice(1, 3), 16);
+    const g1 = parseInt(startHex.slice(3, 5), 16);
+    const b1 = parseInt(startHex.slice(5, 7), 16);
+    
+    const r2 = parseInt(endHex.slice(1, 3), 16);
+    const g2 = parseInt(endHex.slice(3, 5), 16);
+    const b2 = parseInt(endHex.slice(5, 7), 16);
+    
+    let line = '';
+    for (let i = 0; i < length; i++) {
+      const t = length > 1 ? i / (length - 1) : 0;
+      const r = Math.round(r1 + (r2 - r1) * t);
+      const g = Math.round(g1 + (g2 - g1) * t);
+      const b = Math.round(b1 + (b2 - b1) * t);
+      line += chalk.rgb(r, g, b)(char);
+    }
+    return line;
+  }
+  
+  // 256-color fallback
+  if (supports256Color()) {
+    // Pink -> burgundy palette (matching bashmaiass)
+    const palette = [224, 217, 218, 212, 211, 210, 205, 204, 198, 197, 161, 125, 89, 88, 52];
+    const total = palette.length;
+    const per = Math.ceil(length / total);
+    
+    let line = '';
+    let printed = 0;
+    
+    for (const code of palette) {
+      if (printed >= length) break;
+      const count = Math.min(per, length - printed);
+      line += chalk.ansi256(code)(char.repeat(count));
+      printed += count;
+    }
+    
+    return line;
+  }
+  
+  // Plain fallback (no colors)
+  return char.repeat(length);
+}
+
+/**
+ * Create colored MAIASS text with gradient
+ * @returns {string} Colored MAIASS text
+ */
+function colourMaiass() {
+  // Soft pink -> burgundy across M A I A S S
+  const cols = [218, 211, 205, 198, 161, 88];
+  const word = 'MAIASS';
+  
+  if (supports256Color()) {
+    let colored = '';
+    for (let i = 0; i < word.length; i++) {
+      colored += chalk.ansi256(cols[i])(word[i]);
+    }
+    return colored;
+  }
+  
+  // Fallback to simple bold
+  return chalk.bold(word);
+}
+
+/**
+ * Display the MAIASS header (matches bashmaiass style)
+ * @param {string} version - Current version number
+ */
+export function displayHeader(version) {
+  const maiass = colourMaiass();
+  const prefix = colors.BSoftPink('|))');
+  const welcomeText = colors.BBlue('             Welcome to ');
+  const versionText = colors.Blue(` (node) v${version} `);
+  
+  console.log(printGradientLine(60, '#0000FF', '#29CCC1'));
+  console.log(`${prefix}${welcomeText}${maiass}${versionText}`);
+  console.log(printGradientLine(60, '#0000FF', '#29CCC1'));
+}
+
+/**
+ * Display a simple separator line
+ * @param {number} length - Length of the line
+ * @param {string} char - Character to use
+ * @param {Function} colorFn - Color function to apply
+ */
+export function displaySeparator(length = 50, char = '─', colorFn = colors.BCyan) {
+  const useUnicode = supportsUnicode();
+  const actualChar = useUnicode ? char : '-';
+  console.log(colorFn(actualChar.repeat(length)));
+}
+
+export default {
+  displayHeader,
+  displaySeparator,
+  supportsUnicode,
+  supports256Color,
+  supportsTruecolor
+};