scene-capability-engine 3.0.0

package/lib/repo/handlers/status-handler.js

@@ -0,0 +1,176 @@
+const RepoManager = require('../repo-manager');
+const ConfigManager = require('../config-manager');
+const OutputFormatter = require('../output-formatter');
+
+/**
+ * StatusHandler - Handles repository status command
+ * 
+ * Displays the Git status of all configured repositories in a
+ * tabular format with optional verbose output.
+ */
+class StatusHandler {
+  /**
+   * Create a new StatusHandler
+   * @param {string} projectRoot - The project root directory
+   */
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.repoManager = new RepoManager(projectRoot);
+    this.configManager = new ConfigManager(projectRoot);
+    this.formatter = new OutputFormatter();
+  }
+
+  /**
+   * Execute status command
+   * @param {Object} options - Status options
+   * @param {boolean} options.verbose - Show detailed file-level changes
+   * @returns {Promise<void>}
+   */
+  async execute(options = {}) {
+    const { verbose = false } = options;
+
+    // Load configuration
+    let config;
+    try {
+      config = await this.configManager.loadConfig();
+    } catch (error) {
+      console.log(this.formatter.error(error.message));
+      throw error;
+    }
+
+    if (config.repositories.length === 0) {
+      console.log(this.formatter.warning('No repositories configured'));
+      return;
+    }
+
+    // Get status for all repositories
+    const progress = this.formatter.createProgress('Checking repository status...');
+    progress.start();
+
+    let statuses;
+    try {
+      statuses = await this.repoManager.getAllRepoStatuses(config.repositories);
+      progress.stop();
+    } catch (error) {
+      progress.fail('Failed to get repository status');
+      throw error;
+    }
+
+    // Display status
+    if (verbose) {
+      this.formatVerboseStatus(statuses);
+    } else {
+      this.formatStatusTable(statuses);
+    }
+
+    // Display summary
+    const cleanRepos = statuses.filter(s => s.isClean && !s.error).length;
+    const dirtyRepos = statuses.filter(s => !s.isClean && !s.error).length;
+    const errorRepos = statuses.filter(s => s.error).length;
+
+    console.log('\nSummary:');
+    console.log(`  Clean: ${cleanRepos}`);
+    console.log(`  Modified: ${dirtyRepos}`);
+    if (errorRepos > 0) {
+      console.log(this.formatter.error(`  Errors: ${errorRepos}`));
+    }
+  }
+
+  /**
+   * Format status output as table
+   * @param {Array<Object>} statuses - Array of repository statuses
+   */
+  formatStatusTable(statuses) {
+    const tableData = statuses.map(status => {
+      if (status.error) {
+        return [
+          status.name,
+          status.path,
+          this.formatter.error('ERROR'),
+          status.error
+        ];
+      }
+
+      const statusStr = status.isClean 
+        ? this.formatter.success('Clean')
+        : this.formatter.warning('Modified');
+
+      let changes = '';
+      if (!status.isClean) {
+        const parts = [];
+        if (status.modified > 0) parts.push(`M:${status.modified}`);
+        if (status.added > 0) parts.push(`A:${status.added}`);
+        if (status.deleted > 0) parts.push(`D:${status.deleted}`);
+        if (status.ahead > 0) parts.push(`↑${status.ahead}`);
+        if (status.behind > 0) parts.push(`↓${status.behind}`);
+        changes = parts.join(' ');
+      }
+
+      return [
+        status.name,
+        status.path,
+        status.branch || 'N/A',
+        statusStr,
+        changes
+      ];
+    });
+
+    const table = this.formatter.formatTable([], {
+      head: ['Name', 'Path', 'Branch', 'Status', 'Changes'],
+      rows: tableData
+    });
+
+    console.log('\n' + table);
+  }
+
+  /**
+   * Format verbose status output
+   * @param {Array<Object>} statuses - Array of repository statuses
+   */
+  formatVerboseStatus(statuses) {
+    console.log('\n' + this.formatter.info('Repository Status (Verbose)'));
+    console.log('='.repeat(80));
+
+    statuses.forEach((status, index) => {
+      if (index > 0) {
+        console.log('\n' + '-'.repeat(80));
+      }
+
+      console.log(`\n${this.formatter.info('Repository:')} ${status.name}`);
+      console.log(`${this.formatter.info('Path:')} ${status.path}`);
+
+      if (status.error) {
+        console.log(`${this.formatter.error('Error:')} ${status.error}`);
+        return;
+      }
+
+      console.log(`${this.formatter.info('Branch:')} ${status.branch}`);
+
+      if (status.isClean) {
+        console.log(this.formatter.success('Status: Clean - no changes'));
+      } else {
+        console.log(this.formatter.warning('Status: Modified'));
+        
+        if (status.modified > 0) {
+          console.log(`  Modified files: ${status.modified}`);
+        }
+        if (status.added > 0) {
+          console.log(`  Added files: ${status.added}`);
+        }
+        if (status.deleted > 0) {
+          console.log(`  Deleted files: ${status.deleted}`);
+        }
+        if (status.ahead > 0) {
+          console.log(`  Commits ahead: ${status.ahead}`);
+        }
+        if (status.behind > 0) {
+          console.log(`  Commits behind: ${status.behind}`);
+        }
+      }
+    });
+
+    console.log('\n' + '='.repeat(80));
+  }
+}
+
+module.exports = StatusHandler;

package/lib/repo/output-formatter.js

@@ -0,0 +1,184 @@
+const chalk = require('chalk');
+const Table = require('cli-table3');
+
+/**
+ * OutputFormatter provides consistent formatting for command output
+ * with color-coding and table support.
+ */
+class OutputFormatter {
+  constructor() {
+    this.chalk = chalk;
+  }
+
+  /**
+   * Format data as table
+   * @param {Object[]} data - Array of data objects
+   * @param {Object} options - Table options
+   * @param {string[]} options.head - Table header columns
+   * @param {string[][]} options.rows - Table rows (optional, will be extracted from data if not provided)
+   * @param {Object} options.style - Table style options (optional)
+   * @returns {string} Formatted table string
+   */
+  formatTable(data, options = {}) {
+    const tableConfig = {
+      head: options.head || [],
+      style: {
+        head: ['cyan'],
+        border: ['gray'],
+        ...options.style
+      }
+    };
+
+    const table = new Table(tableConfig);
+
+    // If rows are provided directly, use them
+    if (options.rows) {
+      options.rows.forEach(row => table.push(row));
+    } else if (Array.isArray(data) && data.length > 0) {
+      // Otherwise, extract rows from data objects
+      data.forEach(item => {
+        const row = options.head.map(header => {
+          const key = header.toLowerCase().replace(/\s+/g, '');
+          return item[key] !== undefined ? String(item[key]) : '';
+        });
+        table.push(row);
+      });
+    }
+
+    return table.toString();
+  }
+
+  /**
+   * Format success message
+   * @param {string} message - Success message
+   * @returns {string} Formatted success message
+   */
+  success(message) {
+    return chalk.green(`✅ ${message}`);
+  }
+
+  /**
+   * Format error message
+   * @param {string} message - Error message
+   * @returns {string} Formatted error message
+   */
+  error(message) {
+    return chalk.red(`❌ ${message}`);
+  }
+
+  /**
+   * Format warning message
+   * @param {string} message - Warning message
+   * @returns {string} Formatted warning message
+   */
+  warning(message) {
+    return chalk.yellow(`⚠️  ${message}`);
+  }
+
+  /**
+   * Format info message
+   * @param {string} message - Info message
+   * @returns {string} Formatted info message
+   */
+  info(message) {
+    return chalk.blue(`ℹ️  ${message}`);
+  }
+
+  /**
+   * Create progress indicator
+   * @param {string} message - Progress message
+   * @returns {ProgressIndicator} Progress indicator object
+   */
+  createProgress(message) {
+    return new ProgressIndicator(message);
+  }
+}
+
+/**
+ * ProgressIndicator provides a simple progress indicator for long-running operations
+ */
+class ProgressIndicator {
+  constructor(message) {
+    this.message = message;
+    this.started = false;
+    this.frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    this.currentFrame = 0;
+    this.interval = null;
+  }
+
+  /**
+   * Start the progress indicator
+   */
+  start() {
+    if (this.started) return;
+    
+    this.started = true;
+    process.stdout.write(`${this.frames[0]} ${this.message}`);
+    
+    this.interval = setInterval(() => {
+      this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+      process.stdout.write(`\r${this.frames[this.currentFrame]} ${this.message}`);
+    }, 80);
+    if (this.interval && typeof this.interval.unref === 'function') {
+      this.interval.unref();
+    }
+  }
+
+  /**
+   * Update the progress message
+   * @param {string} message - New progress message
+   */
+  update(message) {
+    this.message = message;
+    if (this.started) {
+      process.stdout.write(`\r${this.frames[this.currentFrame]} ${this.message}`);
+    }
+  }
+
+  /**
+   * Stop the progress indicator with a success message
+   * @param {string} message - Success message (optional)
+   */
+  succeed(message) {
+    this.stop();
+    const finalMessage = message || this.message;
+    console.log(chalk.green(`✅ ${finalMessage}`));
+  }
+
+  /**
+   * Stop the progress indicator with an error message
+   * @param {string} message - Error message (optional)
+   */
+  fail(message) {
+    this.stop();
+    const finalMessage = message || this.message;
+    console.log(chalk.red(`❌ ${finalMessage}`));
+  }
+
+  /**
+   * Stop the progress indicator with a warning message
+   * @param {string} message - Warning message (optional)
+   */
+  warn(message) {
+    this.stop();
+    const finalMessage = message || this.message;
+    console.log(chalk.yellow(`⚠️  ${finalMessage}`));
+  }
+
+  /**
+   * Stop the progress indicator
+   */
+  stop() {
+    if (!this.started) return;
+    
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    
+    process.stdout.write('\r\x1b[K'); // Clear the line
+    this.started = false;
+  }
+}
+
+module.exports = OutputFormatter;

package/lib/repo/path-resolver.js

@@ -0,0 +1,178 @@
+const path = require('path');
+
+/**
+ * PathResolver handles cross-platform path resolution and validation
+ * for repository paths. It ensures consistent path handling across
+ * Windows, Linux, and Mac platforms.
+ */
+class PathResolver {
+  /**
+   * Resolve repository path relative to project root
+   * @param {string} repoPath - The repository path (relative or absolute)
+   * @param {string} projectRoot - The project root directory
+   * @returns {string} Resolved absolute path
+   */
+  resolvePath(repoPath, projectRoot) {
+    if (!repoPath) {
+      throw new Error('Repository path cannot be empty');
+    }
+    if (!projectRoot) {
+      throw new Error('Project root cannot be empty');
+    }
+
+    // If path is absolute, return normalized version
+    if (this.isAbsolute(repoPath)) {
+      return this.normalizePath(path.resolve(repoPath));
+    }
+
+    // Resolve relative path against project root
+    return this.normalizePath(path.resolve(projectRoot, repoPath));
+  }
+
+  /**
+   * Normalize path to use forward slashes consistently
+   * @param {string} pathStr - The path to normalize
+   * @returns {string} Normalized path with forward slashes
+   */
+  normalizePath(pathStr) {
+    if (!pathStr) {
+      return pathStr;
+    }
+
+    // Normalize the path first (resolves . and ..)
+    let normalized = path.normalize(pathStr);
+
+    // Convert backslashes to forward slashes
+    normalized = normalized.replace(/\\/g, '/');
+
+    // Handle Windows drive letters - keep them uppercase
+    if (this._isWindowsPath(normalized)) {
+      normalized = normalized.charAt(0).toUpperCase() + normalized.slice(1);
+    }
+
+    // Remove trailing slashes (except for root paths)
+    if (normalized.length > 1 && normalized.endsWith('/')) {
+      // Don't remove trailing slash from root paths like '/' or 'C:/'
+      if (!(normalized.length === 3 && this._isWindowsPath(normalized))) {
+        normalized = normalized.slice(0, -1);
+      }
+    }
+
+    return normalized;
+  }
+
+  /**
+   * Check if path is absolute (cross-platform)
+   * @param {string} pathStr - The path to check
+   * @returns {boolean} True if path is absolute
+   */
+  isAbsolute(pathStr) {
+    if (!pathStr) {
+      return false;
+    }
+    
+    // Check for Windows absolute paths (C:/ or C:\) - must check first
+    // because path.isAbsolute() is platform-dependent
+    if (this._isWindowsPath(pathStr)) {
+      return true;
+    }
+    
+    // Check for Unix absolute paths (starts with /)
+    // On Unix systems, this will correctly identify /home/user
+    // On Windows systems, this will correctly identify C:/... (already handled above)
+    return pathStr.startsWith('/');
+  }
+
+  /**
+   * Convert absolute path to relative path
+   * @param {string} absolutePath - The absolute path
+   * @param {string} basePath - The base path to make it relative to
+   * @returns {string} Relative path
+   */
+  toRelative(absolutePath, basePath) {
+    if (!absolutePath || !basePath) {
+      throw new Error('Both absolutePath and basePath are required');
+    }
+
+    const relativePath = path.relative(basePath, absolutePath);
+    return this.normalizePath(relativePath);
+  }
+
+  /**
+   * Validate that paths don't overlap or nest within each other
+   * @param {string[]} paths - Array of absolute paths to validate
+   * @returns {{valid: boolean, errors: string[]}} Validation result
+   */
+  validateNoOverlap(paths) {
+    const errors = [];
+
+    if (!Array.isArray(paths)) {
+      return { valid: false, errors: ['Paths must be an array'] };
+    }
+
+    if (paths.length === 0) {
+      return { valid: true, errors: [] };
+    }
+
+    // Normalize all paths for comparison
+    const normalizedPaths = paths.map(p => this.normalizePath(p));
+
+    // Check for duplicates
+    const seen = new Set();
+    for (let i = 0; i < normalizedPaths.length; i++) {
+      const p = normalizedPaths[i];
+      if (seen.has(p)) {
+        errors.push(`Duplicate path found: ${paths[i]}`);
+      }
+      seen.add(p);
+    }
+
+    // Check for overlapping/nested paths
+    for (let i = 0; i < normalizedPaths.length; i++) {
+      for (let j = i + 1; j < normalizedPaths.length; j++) {
+        const path1 = normalizedPaths[i];
+        const path2 = normalizedPaths[j];
+
+        // Check if path2 is nested within path1
+        if (this._isNestedPath(path2, path1)) {
+          errors.push(`Path "${paths[j]}" is nested within "${paths[i]}"`);
+        }
+        // Check if path1 is nested within path2
+        else if (this._isNestedPath(path1, path2)) {
+          errors.push(`Path "${paths[i]}" is nested within "${paths[j]}"`);
+        }
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Check if a path is nested within another path
+   * @private
+   * @param {string} childPath - The potential child path
+   * @param {string} parentPath - The potential parent path
+   * @returns {boolean} True if childPath is nested within parentPath
+   */
+  _isNestedPath(childPath, parentPath) {
+    // Ensure paths end with separator for accurate comparison
+    const normalizedParent = parentPath.endsWith('/') ? parentPath : parentPath + '/';
+    return childPath.startsWith(normalizedParent);
+  }
+
+  /**
+   * Check if path is a Windows path (has drive letter)
+   * @private
+   * @param {string} pathStr - The path to check
+   * @returns {boolean} True if path is a Windows path
+   */
+  _isWindowsPath(pathStr) {
+    // Check for drive letter pattern: C:/ or C:\
+    return /^[a-zA-Z]:/.test(pathStr);
+  }
+}
+
+module.exports = PathResolver;