git-watchtower 1.6.1 → 1.7.0

package/src/utils/errors.js

@@ -0,0 +1,490 @@
+/**
+ * Standardized error classes for Git Watchtower
+ * Provides consistent error handling across the application
+ */
+
+/**
+ * Base error class for Git Watchtower
+ * @extends Error
+ */
+class AppError extends Error {
+  /**
+   * @param {string} message - Error message
+   * @param {string} [code] - Error code for programmatic handling
+   * @param {Object} [details] - Additional error details
+   */
+  constructor(message, code = 'APP_ERROR', details = {}) {
+    super(message);
+    this.name = 'AppError';
+    this.code = code;
+    this.details = details;
+    this.timestamp = new Date();
+
+    // Capture stack trace (V8 specific)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+
+  /**
+   * Create a user-friendly message for display
+   * @returns {string}
+   */
+  toUserMessage() {
+    return this.message;
+  }
+
+  /**
+   * Serialize error for logging
+   * @returns {Object}
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      details: this.details,
+      timestamp: this.timestamp.toISOString(),
+    };
+  }
+}
+
+/**
+ * Error class for Git-related operations
+ * @extends AppError
+ */
+class GitError extends AppError {
+  /**
+   * @param {string} message - Error message
+   * @param {string} [code] - Git error code
+   * @param {Object} [details] - Additional details including command, stderr
+   */
+  constructor(message, code = 'GIT_ERROR', details = {}) {
+    super(message, code, details);
+    this.name = 'GitError';
+    this.command = details.command || null;
+    this.stderr = details.stderr || null;
+  }
+
+  /**
+   * Check if error is due to network issues
+   * @returns {boolean}
+   */
+  isNetworkError() {
+    const networkPatterns = [
+      'Could not resolve host',
+      'Connection refused',
+      'Connection timed out',
+      'Network is unreachable',
+      'fatal: unable to access',
+      'SSL certificate problem',
+    ];
+    return networkPatterns.some(
+      (pattern) =>
+        this.message.includes(pattern) ||
+        (this.stderr && this.stderr.includes(pattern))
+    );
+  }
+
+  /**
+   * Check if error is due to authentication
+   * @returns {boolean}
+   */
+  isAuthError() {
+    const authPatterns = [
+      'Authentication failed',
+      'Permission denied',
+      'Invalid username or password',
+      'could not read Username',
+      'fatal: Authentication',
+    ];
+    return authPatterns.some(
+      (pattern) =>
+        this.message.includes(pattern) ||
+        (this.stderr && this.stderr.includes(pattern))
+    );
+  }
+
+  /**
+   * Check if error is due to merge conflicts
+   * @returns {boolean}
+   */
+  isMergeConflict() {
+    const conflictPatterns = [
+      'CONFLICT',
+      'Automatic merge failed',
+      'fix conflicts',
+      'Merge conflict',
+    ];
+    return conflictPatterns.some(
+      (pattern) =>
+        this.message.includes(pattern) ||
+        (this.stderr && this.stderr.includes(pattern))
+    );
+  }
+
+  /**
+   * Check if error is due to dirty working directory
+   * @returns {boolean}
+   */
+  isDirtyWorkingDir() {
+    const dirtyPatterns = [
+      'Your local changes',
+      'uncommitted changes',
+      'Please commit your changes',
+      'overwritten by checkout',
+    ];
+    return dirtyPatterns.some(
+      (pattern) =>
+        this.message.includes(pattern) ||
+        (this.stderr && this.stderr.includes(pattern))
+    );
+  }
+
+  toUserMessage() {
+    if (this.isNetworkError()) {
+      return 'Network error - check your connection';
+    }
+    if (this.isAuthError()) {
+      return 'Authentication failed - check credentials';
+    }
+    if (this.isMergeConflict()) {
+      return 'Merge conflict - resolve conflicts first';
+    }
+    if (this.isDirtyWorkingDir()) {
+      return 'Uncommitted changes - commit or stash first';
+    }
+    return this.message;
+  }
+
+  /**
+   * Create GitError from exec callback error
+   * @param {Error} error - Original error
+   * @param {string} command - Git command that was executed
+   * @param {string} [stderr] - Standard error output
+   * @returns {GitError}
+   */
+  static fromExecError(error, command, stderr = '') {
+    const message = stderr || error.message;
+    let code = 'GIT_ERROR';
+
+    // Determine specific error code
+    // @ts-ignore - Node.js ExecException has killed and code properties
+    if (error.killed) {
+      code = 'GIT_TIMEOUT';
+      // @ts-ignore - Node.js ExecException has code property
+    } else if (error.code === 'ENOENT') {
+      code = 'GIT_NOT_FOUND';
+    }
+
+    return new GitError(message, code, { command, stderr });
+  }
+}
+
+/**
+ * Error class for configuration-related issues
+ * @extends AppError
+ */
+class ConfigError extends AppError {
+  /**
+   * @param {string} message - Error message
+   * @param {string} [code] - Config error code
+   * @param {Object} [details] - Additional details
+   */
+  constructor(message, code = 'CONFIG_ERROR', details = {}) {
+    super(message, code, details);
+    this.name = 'ConfigError';
+  }
+
+  /**
+   * Create ConfigError for missing config
+   * @param {string} configPath - Path to missing config
+   * @returns {ConfigError}
+   */
+  static missing(configPath) {
+    return new ConfigError(
+      `Configuration file not found: ${configPath}`,
+      'CONFIG_NOT_FOUND',
+      { path: configPath }
+    );
+  }
+
+  /**
+   * Create ConfigError for invalid config
+   * @param {string} reason - Why config is invalid
+   * @param {Object} [details] - Validation details
+   * @returns {ConfigError}
+   */
+  static invalid(reason, details = {}) {
+    return new ConfigError(
+      `Invalid configuration: ${reason}`,
+      'CONFIG_INVALID',
+      details
+    );
+  }
+
+  /**
+   * Create ConfigError for parse error
+   * @param {Error} parseError - Original parse error
+   * @returns {ConfigError}
+   */
+  static parseError(parseError) {
+    return new ConfigError(
+      `Failed to parse configuration: ${parseError.message}`,
+      'CONFIG_PARSE_ERROR',
+      { originalError: parseError.message }
+    );
+  }
+}
+
+/**
+ * Error class for server-related issues
+ * @extends AppError
+ */
+class ServerError extends AppError {
+  /**
+   * @param {string} message - Error message
+   * @param {string} [code] - Server error code
+   * @param {Object} [details] - Additional details
+   */
+  constructor(message, code = 'SERVER_ERROR', details = {}) {
+    super(message, code, details);
+    this.name = 'ServerError';
+  }
+
+  /**
+   * Create ServerError for port in use
+   * @param {number} port - The port that's in use
+   * @returns {ServerError}
+   */
+  static portInUse(port) {
+    return new ServerError(
+      `Port ${port} is already in use`,
+      'PORT_IN_USE',
+      { port }
+    );
+  }
+
+  /**
+   * Create ServerError for process crash
+   * @param {string} command - The command that crashed
+   * @param {number} exitCode - Exit code
+   * @returns {ServerError}
+   */
+  static processCrashed(command, exitCode) {
+    return new ServerError(
+      `Server process crashed with exit code ${exitCode}`,
+      'PROCESS_CRASHED',
+      { command, exitCode }
+    );
+  }
+
+  /**
+   * Create ServerError for start failure
+   * @param {string} command - The command that failed to start
+   * @param {string} reason - Failure reason
+   * @returns {ServerError}
+   */
+  static startFailed(command, reason) {
+    return new ServerError(
+      `Failed to start server: ${reason}`,
+      'START_FAILED',
+      { command, reason }
+    );
+  }
+}
+
+/**
+ * Error class for validation errors
+ * @extends AppError
+ */
+class ValidationError extends AppError {
+  /**
+   * @param {string} message - Error message
+   * @param {string} field - Field that failed validation
+   * @param {*} value - Invalid value
+   */
+  constructor(message, field, value) {
+    super(message, 'VALIDATION_ERROR', { field, value });
+    this.name = 'ValidationError';
+    this.field = field;
+    this.value = value;
+  }
+
+  /**
+   * Create ValidationError for invalid branch name
+   * @param {string} name - Invalid branch name
+   * @returns {ValidationError}
+   */
+  static invalidBranchName(name) {
+    return new ValidationError(
+      `Invalid branch name: "${name}"`,
+      'branchName',
+      name
+    );
+  }
+
+  /**
+   * Create ValidationError for invalid port
+   * @param {*} port - Invalid port value
+   * @returns {ValidationError}
+   */
+  static invalidPort(port) {
+    return new ValidationError(
+      `Invalid port: ${port}. Must be a number between 1 and 65535`,
+      'port',
+      port
+    );
+  }
+}
+
+/**
+ * Standardized error handler
+ * Provides consistent error handling across the application
+ */
+class ErrorHandler {
+  /**
+   * @param {Object} [options]
+   * @param {boolean} [options.debug=false] - Enable debug logging
+   * @param {Function} [options.onError] - Callback for all errors
+   */
+  constructor(options = {}) {
+    this.debug = options.debug || process.env.DEBUG === 'true';
+    this.onError = options.onError || null;
+  }
+
+  /**
+   * Handle an error and return a user-friendly message
+   * @param {Error} error - The error to handle
+   * @param {string} context - Context where error occurred
+   * @returns {{ message: string, severity: 'error' | 'warning' | 'info' }}
+   */
+  handle(error, context = 'unknown') {
+    // Log in debug mode
+    if (this.debug) {
+      console.error(`[${context}]`, error);
+    }
+
+    // Call error callback if provided
+    if (this.onError) {
+      this.onError(error, context);
+    }
+
+    // Determine severity and message
+    if (error instanceof AppError) {
+      return {
+        message: error.toUserMessage(),
+        severity: this.getSeverity(error),
+      };
+    }
+
+    // Handle standard errors
+    return {
+      message: error.message || 'An unexpected error occurred',
+      severity: 'error',
+    };
+  }
+
+  /**
+   * Determine error severity
+   * @param {AppError} error
+   * @returns {'error' | 'warning' | 'info'}
+   */
+  getSeverity(error) {
+    // Network errors are warnings (transient)
+    if (error instanceof GitError && error.isNetworkError()) {
+      return 'warning';
+    }
+
+    // Config errors are usually user-fixable
+    if (error instanceof ConfigError) {
+      return 'warning';
+    }
+
+    return 'error';
+  }
+
+  /**
+   * Check if error is retryable
+   * @param {Error} error
+   * @returns {boolean}
+   */
+  isRetryable(error) {
+    if (error instanceof GitError) {
+      return error.isNetworkError();
+    }
+    return false;
+  }
+}
+
+// ============================================================================
+// Standalone error classifiers (work on raw error message strings)
+// ============================================================================
+
+/**
+ * Check if an error message indicates an authentication failure
+ * @param {string} errorMessage - Error message to check
+ * @returns {boolean}
+ */
+function isAuthError(errorMessage) {
+  const authErrors = [
+    'Authentication failed',
+    'could not read Username',
+    'could not read Password',
+    'Permission denied',
+    'invalid credentials',
+    'authorization failed',
+    'fatal: Authentication',
+    'HTTP 401',
+    'HTTP 403',
+  ];
+  const msg = (errorMessage || '').toLowerCase();
+  return authErrors.some(err => msg.includes(err.toLowerCase()));
+}
+
+/**
+ * Check if an error message indicates a merge conflict
+ * @param {string} errorMessage - Error message to check
+ * @returns {boolean}
+ */
+function isMergeConflict(errorMessage) {
+  const conflictIndicators = [
+    'CONFLICT',
+    'Automatic merge failed',
+    'fix conflicts',
+    'Merge conflict',
+  ];
+  return conflictIndicators.some(ind => (errorMessage || '').includes(ind));
+}
+
+/**
+ * Check if an error message indicates a network error
+ * @param {string} errorMessage - Error message to check
+ * @returns {boolean}
+ */
+function isNetworkError(errorMessage) {
+  const networkErrors = [
+    'Could not resolve host',
+    'unable to access',
+    'Connection refused',
+    'Network is unreachable',
+    'Connection timed out',
+    'Failed to connect',
+    'no route to host',
+    'Temporary failure in name resolution',
+  ];
+  const msg = (errorMessage || '').toLowerCase();
+  return networkErrors.some(err => msg.includes(err.toLowerCase()));
+}
+
+module.exports = {
+  AppError,
+  GitError,
+  ConfigError,
+  ServerError,
+  ValidationError,
+  ErrorHandler,
+  isAuthError,
+  isMergeConflict,
+  isNetworkError,
+};

package/src/utils/gitignore.js

@@ -0,0 +1,174 @@
+/**
+ * Gitignore pattern parsing and file filtering utilities
+ * Used by the file watcher to ignore .git directory and .gitignore patterns
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Convert a gitignore pattern to a RegExp
+ * Supports basic gitignore syntax: *, **, ?, negation (!), directory markers (/)
+ * @param {string} pattern - The gitignore pattern
+ * @returns {RegExp|null} - The compiled regex or null if pattern is invalid/negation
+ */
+function gitignorePatternToRegex(pattern) {
+  // Handle negation (we'll filter these out separately)
+  if (pattern.startsWith('!')) {
+    return null;
+  }
+
+  // Handle directory-only patterns (ending with /)
+  const dirOnly = pattern.endsWith('/');
+  if (dirOnly) {
+    pattern = pattern.slice(0, -1);
+  }
+
+  // Handle patterns starting with / (anchored to root)
+  const anchored = pattern.startsWith('/');
+  if (anchored) {
+    pattern = pattern.slice(1);
+  }
+
+  // Escape special regex characters except * and ?
+  let regexStr = pattern
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    // Convert **/ to a placeholder (matches any path prefix including empty)
+    .replace(/\*\*\//g, '{{GLOBSTAR_SLASH}}')
+    // Convert ** to a placeholder (matches any path)
+    .replace(/\*\*/g, '{{GLOBSTAR}}')
+    // Convert * to match anything except /
+    .replace(/\*/g, '[^/]*')
+    // Convert ? to match single character except /
+    .replace(/\?/g, '[^/]')
+    // Convert globstar placeholders back
+    // {{GLOBSTAR_SLASH}} matches "any/path/" or empty string
+    .replace(/\{\{GLOBSTAR_SLASH\}\}/g, '(.*\\/)?')
+    // {{GLOBSTAR}} matches any path including slashes
+    .replace(/\{\{GLOBSTAR\}\}/g, '.*');
+
+  // Build the final regex
+  if (anchored) {
+    regexStr = '^' + regexStr;
+  } else {
+    // Match anywhere in path
+    regexStr = '(^|/)' + regexStr;
+  }
+
+  if (dirOnly) {
+    regexStr = regexStr + '(/|$)';
+  } else {
+    regexStr = regexStr + '($|/)';
+  }
+
+  try {
+    return new RegExp(regexStr);
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Parse a .gitignore file and return an array of compiled regex patterns
+ * @param {string} gitignorePath - Path to the .gitignore file
+ * @returns {RegExp[]} - Array of compiled regex patterns
+ */
+function parseGitignoreFile(gitignorePath) {
+  const patterns = [];
+
+  if (!fs.existsSync(gitignorePath)) {
+    return patterns;
+  }
+
+  try {
+    const content = fs.readFileSync(gitignorePath, 'utf8');
+    const lines = content.split('\n');
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      // Skip empty lines and comments
+      if (!trimmed || trimmed.startsWith('#')) {
+        continue;
+      }
+
+      const regex = gitignorePatternToRegex(trimmed);
+      if (regex) {
+        patterns.push(regex);
+      }
+    }
+  } catch (err) {
+    // Silently continue if we can't read .gitignore
+  }
+
+  return patterns;
+}
+
+/**
+ * Load gitignore patterns from multiple possible locations
+ * @param {string[]} searchPaths - Array of directories to search for .gitignore
+ * @returns {RegExp[]} - Array of compiled regex patterns
+ */
+function loadGitignorePatterns(searchPaths) {
+  for (const searchPath of searchPaths) {
+    const gitignorePath = path.join(searchPath, '.gitignore');
+    const patterns = parseGitignoreFile(gitignorePath);
+    if (patterns.length > 0) {
+      return patterns;
+    }
+  }
+  return [];
+}
+
+/**
+ * Check if a filename matches the .git directory
+ * @param {string} filename - The filename to check
+ * @returns {boolean} - True if the file is in the .git directory
+ */
+function isGitDirectory(filename) {
+  if (filename === '.git' || filename.startsWith('.git/') || filename.startsWith('.git\\')) {
+    return true;
+  }
+
+  // Normalize path separators for cross-platform support
+  const normalizedPath = filename.replace(/\\/g, '/');
+
+  // Check if path contains .git directory anywhere
+  if (normalizedPath.includes('/.git/') || normalizedPath.includes('/.git')) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Check if a file path should be ignored by the file watcher
+ * @param {string} filename - The filename to check
+ * @param {RegExp[]} ignorePatterns - Array of compiled gitignore patterns
+ * @returns {boolean} - True if the file should be ignored
+ */
+function shouldIgnoreFile(filename, ignorePatterns = []) {
+  // Always ignore .git directory
+  if (isGitDirectory(filename)) {
+    return true;
+  }
+
+  // Normalize path separators for cross-platform support
+  const normalizedPath = filename.replace(/\\/g, '/');
+
+  // Check against gitignore patterns
+  for (const pattern of ignorePatterns) {
+    if (pattern.test(normalizedPath)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+module.exports = {
+  gitignorePatternToRegex,
+  parseGitignoreFile,
+  loadGitignorePatterns,
+  isGitDirectory,
+  shouldIgnoreFile,
+};

package/src/utils/sound.js

@@ -0,0 +1,33 @@
+/**
+ * Cross-platform system sound playback
+ * @module utils/sound
+ */
+
+const { exec } = require('child_process');
+
+/**
+ * Play a system notification sound (non-blocking).
+ * Cross-platform: macOS (afplay), Linux (paplay/aplay), Windows (terminal bell).
+ * @param {object} [options]
+ * @param {string} [options.cwd] - Working directory for exec
+ */
+function playSound(options = {}) {
+  const { platform } = process;
+  const cwd = options.cwd || process.cwd();
+
+  if (platform === 'darwin') {
+    exec('afplay /System/Library/Sounds/Pop.aiff 2>/dev/null', { cwd });
+  } else if (platform === 'linux') {
+    exec(
+      'paplay /usr/share/sounds/freedesktop/stereo/message-new-instant.oga 2>/dev/null || ' +
+      'paplay /usr/share/sounds/freedesktop/stereo/complete.oga 2>/dev/null || ' +
+      'aplay /usr/share/sounds/sound-icons/prompt.wav 2>/dev/null || ' +
+      'printf "\\a"',
+      { cwd }
+    );
+  } else {
+    process.stdout.write('\x07');
+  }
+}
+
+module.exports = { playSound };