git-watchtower 1.6.1 → 1.7.1

package/src/index.js

@@ -0,0 +1,179 @@
+/**
+ * Git Watchtower - Modular Architecture
+ *
+ * This is the main entry point for the refactored modules.
+ * Import what you need from this file.
+ *
+ * @example
+ * const { Store, createStore } = require('./src');
+ * const { GitError, ConfigError } = require('./src');
+ * const { ansi, box } = require('./src');
+ */
+
+// Utilities
+const asyncUtils = require('./utils/async');
+const errors = require('./utils/errors');
+
+// State management
+const state = require('./state/store');
+
+// UI components
+const ui = require('./ui/ansi');
+const rendererModule = require('./ui/renderer');
+const actionsModule = require('./ui/actions');
+const keybindingsModule = require('./ui/keybindings');
+
+// Git operations
+const gitCommands = require('./git/commands');
+const gitBranch = require('./git/branch');
+
+// Configuration
+const configSchema = require('./config/schema');
+const configLoader = require('./config/loader');
+
+// Server management
+const serverProcess = require('./server/process');
+
+// Telemetry
+const telemetryModule = require('./telemetry');
+
+// CLI and utilities
+const cliArgs = require('./cli/args');
+const timeUtils = require('./utils/time');
+const browserUtils = require('./utils/browser');
+const soundUtils = require('./utils/sound');
+const gitRemote = require('./git/remote');
+
+module.exports = {
+  // Async utilities
+  Mutex: asyncUtils.Mutex,
+  withTimeout: asyncUtils.withTimeout,
+  retry: asyncUtils.retry,
+  sleep: asyncUtils.sleep,
+  debounce: asyncUtils.debounce,
+  throttle: asyncUtils.throttle,
+
+  // Error classes
+  AppError: errors.AppError,
+  GitError: errors.GitError,
+  ConfigError: errors.ConfigError,
+  ServerError: errors.ServerError,
+  ValidationError: errors.ValidationError,
+  ErrorHandler: errors.ErrorHandler,
+  isAuthError: errors.isAuthError,
+  isMergeConflict: errors.isMergeConflict,
+  isNetworkError: errors.isNetworkError,
+
+  // State management
+  Store: state.Store,
+  createStore: state.createStore,
+  getInitialState: state.getInitialState,
+
+  // UI utilities
+  ansi: ui.ansi,
+  box: ui.box,
+  sparkline: ui.sparkline,
+  indicators: ui.indicators,
+  stripAnsi: ui.stripAnsi,
+  visibleLength: ui.visibleLength,
+  truncate: ui.truncate,
+  pad: ui.pad,
+  padRight: ui.padRight,
+  padLeft: ui.padLeft,
+  getMaxBranchesForScreen: ui.getMaxBranchesForScreen,
+  drawBox: ui.drawBox,
+  clearArea: ui.clearArea,
+  wordWrap: ui.wordWrap,
+  horizontalLine: ui.horizontalLine,
+  style: ui.style,
+
+  // Renderer
+  renderer: rendererModule,
+
+  // Actions (keyboard handlers)
+  actions: actionsModule,
+
+  // Keybindings
+  keybindings: keybindingsModule,
+
+  // Git commands
+  parseDiffStats: gitCommands.parseDiffStats,
+  getDiffStats: gitCommands.getDiffStats,
+  execGit: gitCommands.execGit,
+  execGitSilent: gitCommands.execGitSilent,
+  isGitAvailable: gitCommands.isGitAvailable,
+  isGitRepository: gitCommands.isGitRepository,
+  getRemotes: gitCommands.getRemotes,
+  remoteExists: gitCommands.remoteExists,
+  fetch: gitCommands.fetch,
+  pull: gitCommands.pull,
+  log: gitCommands.log,
+  getCommitsByDay: gitCommands.getCommitsByDay,
+  hasUncommittedChanges: gitCommands.hasUncommittedChanges,
+  stash: gitCommands.stash,
+  stashPop: gitCommands.stashPop,
+  getChangedFiles: gitCommands.getChangedFiles,
+  deleteLocalBranch: gitCommands.deleteLocalBranch,
+
+  // Git branch operations
+  isValidBranchName: gitBranch.isValidBranchName,
+  sanitizeBranchName: gitBranch.sanitizeBranchName,
+  getCurrentBranch: gitBranch.getCurrentBranch,
+  getAllBranches: gitBranch.getAllBranches,
+  detectBranchChanges: gitBranch.detectBranchChanges,
+  checkout: gitBranch.checkout,
+  getPreviewData: gitBranch.getPreviewData,
+  generateSparkline: gitBranch.generateSparkline,
+  getLocalBranches: gitBranch.getLocalBranches,
+  localBranchExists: gitBranch.localBranchExists,
+  getGoneBranches: gitBranch.getGoneBranches,
+  deleteGoneBranches: gitBranch.deleteGoneBranches,
+
+  // Configuration schema
+  SERVER_MODES: configSchema.SERVER_MODES,
+  DEFAULTS: configSchema.DEFAULTS,
+  LIMITS: configSchema.LIMITS,
+  getDefaultConfig: configSchema.getDefaultConfig,
+  validatePort: configSchema.validatePort,
+  validateServerMode: configSchema.validateServerMode,
+  validatePollInterval: configSchema.validatePollInterval,
+  validateVisibleBranches: configSchema.validateVisibleBranches,
+  validateConfig: configSchema.validateConfig,
+  migrateConfig: configSchema.migrateConfig,
+
+  // Configuration loading
+  CONFIG_FILE_NAME: configLoader.CONFIG_FILE_NAME,
+  getConfigPath: configLoader.getConfigPath,
+  configExists: configLoader.configExists,
+  loadConfig: configLoader.loadConfig,
+  saveConfig: configLoader.saveConfig,
+  deleteConfig: configLoader.deleteConfig,
+  applyCliArgs: configLoader.applyCliArgs,
+  parseCliArgs: configLoader.parseCliArgs,
+  ensureConfig: configLoader.ensureConfig,
+
+  // Server process management
+  ProcessManager: serverProcess.ProcessManager,
+  parseCommand: serverProcess.parseCommand,
+
+  // CLI argument parsing
+  parseArgs: cliArgs.parseArgs,
+  applyCliArgsToConfig: cliArgs.applyCliArgsToConfig,
+  getHelpText: cliArgs.getHelpText,
+  CLI_PACKAGE_VERSION: cliArgs.PACKAGE_VERSION,
+
+  // Utility modules
+  formatTimeAgo: timeUtils.formatTimeAgo,
+  openInBrowser: browserUtils.openInBrowser,
+  playSound: soundUtils.playSound,
+
+  // Telemetry
+  telemetry: telemetryModule,
+
+  // Git remote URL utilities
+  parseRemoteUrl: gitRemote.parseRemoteUrl,
+  buildBranchUrl: gitRemote.buildBranchUrl,
+  detectPlatform: gitRemote.detectPlatform,
+  buildWebUrl: gitRemote.buildWebUrl,
+  extractSessionUrl: gitRemote.extractSessionUrl,
+};

package/src/polling/engine.js

@@ -0,0 +1,157 @@
+/**
+ * Polling engine — pure logic for branch change detection and sorting
+ * @module polling/engine
+ */
+
+const { isBaseBranch } = require('../git/pr');
+
+/**
+ * Detect new branches not previously known.
+ * @param {Array<{name: string, isNew?: boolean, newAt?: number}>} allBranches - All currently fetched branches
+ * @param {Set<string>} knownBranchNames - Previously known branch names
+ * @returns {Array<{name: string, isNew?: boolean, newAt?: number}>} Branches with isNew flag
+ */
+function detectNewBranches(allBranches, knownBranchNames) {
+  const now = Date.now();
+  const newBranches = [];
+  for (const branch of allBranches) {
+    if (!knownBranchNames.has(branch.name)) {
+      branch.isNew = true;
+      branch.newAt = now;
+      newBranches.push(branch);
+    }
+  }
+  return newBranches;
+}
+
+/**
+ * Detect deleted branches (were known but no longer exist in fetched set).
+ * @param {Set<string>} knownBranchNames - Previously known branch names
+ * @param {Set<string>} fetchedBranchNames - Currently fetched branch names
+ * @param {Array<{name: string, isDeleted?: boolean, deletedAt?: number}>} existingBranches - Previous branch list
+ * @returns {Array<{name: string, isDeleted?: boolean, deletedAt?: number}>} Deleted branches
+ */
+function detectDeletedBranches(knownBranchNames, fetchedBranchNames, existingBranches) {
+  const now = Date.now();
+  const deleted = [];
+  for (const knownName of knownBranchNames) {
+    if (!fetchedBranchNames.has(knownName)) {
+      const existing = existingBranches.find(b => b.name === knownName);
+      if (existing && !existing.isDeleted) {
+        existing.isDeleted = true;
+        existing.deletedAt = now;
+        deleted.push(existing);
+      }
+    }
+  }
+  return deleted;
+}
+
+/**
+ * Detect branches that have been updated (commit changed) since last poll.
+ * @param {Array<{name: string, commit: string, isDeleted?: boolean, justUpdated?: boolean}>} branches - Current branch list
+ * @param {Map<string, string>} previousStates - Map of branch name -> previous commit hash
+ * @param {string} currentBranch - Name of current branch (excluded from updates)
+ * @returns {Array<{name: string, commit: string, isDeleted?: boolean, justUpdated?: boolean}>} Updated branches
+ */
+function detectUpdatedBranches(branches, previousStates, currentBranch) {
+  const updated = [];
+  for (const branch of branches) {
+    if (branch.isDeleted) continue;
+    const prevCommit = previousStates.get(branch.name);
+    if (prevCommit && prevCommit !== branch.commit && branch.name !== currentBranch) {
+      branch.justUpdated = true;
+      updated.push(branch);
+    }
+  }
+  return updated;
+}
+
+/**
+ * Sort branches: new first, then by date, merged near bottom, deleted at bottom.
+ * @param {Array} branches - Branch list to sort
+ * @param {Map} prStatusMap - Map of branch name -> PR status
+ * @returns {Array} Sorted branches (mutates and returns input)
+ */
+function sortBranches(branches, prStatusMap) {
+  return branches.sort((a, b) => {
+    const aIsBase = isBaseBranch(a.name);
+    const bIsBase = isBaseBranch(b.name);
+    const aMerged = !aIsBase && prStatusMap.has(a.name) && prStatusMap.get(a.name).state === 'MERGED';
+    const bMerged = !bIsBase && prStatusMap.has(b.name) && prStatusMap.get(b.name).state === 'MERGED';
+    if (a.isDeleted && !b.isDeleted) return 1;
+    if (!a.isDeleted && b.isDeleted) return -1;
+    if (aMerged && !bMerged && !b.isDeleted) return 1;
+    if (!aMerged && bMerged && !a.isDeleted) return -1;
+    if (a.isNew && !b.isNew) return -1;
+    if (!a.isNew && b.isNew) return 1;
+    return b.date - a.date;
+  });
+}
+
+/**
+ * Calculate adaptive polling interval based on fetch duration.
+ * @param {number} fetchDuration - How long the fetch took (ms)
+ * @param {number} currentInterval - Current polling interval (ms)
+ * @param {number} baseInterval - Base/default polling interval (ms)
+ * @returns {{ interval: number, warning: string|null }}
+ */
+function calculateAdaptiveInterval(fetchDuration, currentInterval, baseInterval) {
+  if (fetchDuration > 30000) {
+    return {
+      interval: Math.min(currentInterval * 2, 60000),
+      warning: 'very_slow',
+    };
+  }
+  if (fetchDuration > 15000) {
+    return {
+      interval: currentInterval,
+      warning: 'slow',
+    };
+  }
+  if (fetchDuration < 5000 && currentInterval > baseInterval) {
+    return {
+      interval: baseInterval,
+      warning: 'restored',
+    };
+  }
+  return {
+    interval: currentInterval,
+    warning: null,
+  };
+}
+
+/**
+ * Restore selection index after branch list reorder.
+ * @param {Array<{name: string}>} branches - New branch list
+ * @param {string|null} previousName - Previously selected branch name
+ * @param {number} previousIndex - Previously selected index
+ * @returns {{ selectedIndex: number, selectedBranchName: string|null }}
+ */
+function restoreSelection(branches, previousName, previousIndex) {
+  if (previousName) {
+    const newIndex = branches.findIndex(b => b.name === previousName);
+    if (newIndex >= 0) {
+      return { selectedIndex: newIndex, selectedBranchName: previousName };
+    }
+    const clampedIndex = Math.min(previousIndex, Math.max(0, branches.length - 1));
+    return {
+      selectedIndex: clampedIndex,
+      selectedBranchName: branches[clampedIndex] ? branches[clampedIndex].name : null,
+    };
+  }
+  if (previousIndex >= branches.length) {
+    const idx = Math.max(0, branches.length - 1);
+    return { selectedIndex: idx, selectedBranchName: branches[idx] ? branches[idx].name : null };
+  }
+  return { selectedIndex: previousIndex, selectedBranchName: previousName };
+}
+
+module.exports = {
+  detectNewBranches,
+  detectDeletedBranches,
+  detectUpdatedBranches,
+  sortBranches,
+  calculateAdaptiveInterval,
+  restoreSelection,
+};

package/src/server/process.js

@@ -0,0 +1,329 @@
+/**
+ * Server process management for command mode
+ * Manages spawning, stopping, and monitoring of user's dev server
+ */
+
+const { spawn } = require('child_process');
+const { ServerError } = require('../utils/errors');
+
+/**
+ * @typedef {Object} ServerProcessState
+ * @property {import('child_process').ChildProcess|null} process - The server process
+ * @property {boolean} running - Is the server running
+ * @property {boolean} crashed - Did the server crash
+ * @property {Array<{timestamp: string, line: string, isError: boolean}>} logs - Server logs
+ */
+
+/**
+ * Maximum log lines to keep in buffer
+ */
+const MAX_LOG_LINES = 500;
+
+/**
+ * Grace period before force kill (ms)
+ */
+const KILL_GRACE_PERIOD = 3000;
+
+/**
+ * Restart delay after stop (ms)
+ */
+const RESTART_DELAY = 500;
+
+/**
+ * Parse a command string into command and arguments
+ * Handles quoted strings properly
+ * @param {string} commandString - Command string to parse
+ * @returns {{command: string, args: string[]}}
+ */
+function parseCommand(commandString) {
+  const args = [];
+  let current = '';
+  let inQuotes = false;
+  let quoteChar = '';
+
+  for (let i = 0; i < commandString.length; i++) {
+    const char = commandString[i];
+
+    if ((char === '"' || char === "'") && !inQuotes) {
+      inQuotes = true;
+      quoteChar = char;
+    } else if (char === quoteChar && inQuotes) {
+      inQuotes = false;
+      quoteChar = '';
+    } else if (char === ' ' && !inQuotes) {
+      if (current) {
+        args.push(current);
+        current = '';
+      }
+    } else {
+      current += char;
+    }
+  }
+
+  if (current) {
+    args.push(current);
+  }
+
+  return {
+    command: args[0] || '',
+    args: args.slice(1),
+  };
+}
+
+/**
+ * Server process manager
+ */
+class ProcessManager {
+  /**
+   * @param {Object} [options]
+   * @param {string} [options.cwd] - Working directory
+   * @param {Function} [options.onLog] - Log callback (line, isError)
+   * @param {Function} [options.onStateChange] - State change callback (state)
+   */
+  constructor(options = {}) {
+    this.cwd = options.cwd || process.cwd();
+    this.onLog = options.onLog || (() => {});
+    this.onStateChange = options.onStateChange || (() => {});
+
+    this.process = null;
+    this.running = false;
+    this.crashed = false;
+    this.logs = [];
+    this.command = '';
+  }
+
+  /**
+   * Get current state
+   * @returns {ServerProcessState}
+   */
+  getState() {
+    return {
+      process: this.process,
+      running: this.running,
+      crashed: this.crashed,
+      logs: [...this.logs],
+    };
+  }
+
+  /**
+   * Add a log entry
+   * @param {string} line - Log line
+   * @param {boolean} [isError=false] - Is error output
+   */
+  addLog(line, isError = false) {
+    const entry = {
+      timestamp: new Date().toLocaleTimeString(),
+      line,
+      isError,
+    };
+    this.logs.push(entry);
+    if (this.logs.length > MAX_LOG_LINES) {
+      this.logs.shift();
+    }
+    this.onLog(line, isError);
+  }
+
+  /**
+   * Clear log buffer
+   */
+  clearLogs() {
+    this.logs = [];
+  }
+
+  /**
+   * Start the server process
+   * @param {string} commandString - Command to run
+   * @returns {{success: boolean, error?: Error, pid?: number}}
+   */
+  start(commandString) {
+    if (!commandString) {
+      return {
+        success: false,
+        error: ServerError.startFailed(commandString, 'No command specified'),
+      };
+    }
+
+    // Stop existing process first
+    if (this.process) {
+      this.stop();
+    }
+
+    this.clearLogs();
+    this.crashed = false;
+    this.running = false;
+    this.command = commandString;
+
+    this.addLog(`$ ${commandString}`);
+
+    // Parse command
+    const { command, args } = parseCommand(commandString);
+
+    if (!command) {
+      const error = ServerError.startFailed(commandString, 'Invalid command');
+      this.crashed = true;
+      this.addLog(`Failed to start: Invalid command`, true);
+      this.notifyStateChange();
+      return { success: false, error };
+    }
+
+    // Spawn options
+    const isWindows = process.platform === 'win32';
+    /** @type {import('child_process').SpawnOptions} */
+    const spawnOptions = {
+      cwd: this.cwd,
+      env: { ...process.env, FORCE_COLOR: '1' },
+      shell: isWindows,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    };
+
+    try {
+      this.process = spawn(command, args, spawnOptions);
+      this.running = true;
+
+      // Handle stdout
+      this.process.stdout?.on('data', (data) => {
+        const lines = data.toString().split('\n').filter(Boolean);
+        lines.forEach((line) => this.addLog(line));
+      });
+
+      // Handle stderr
+      this.process.stderr?.on('data', (data) => {
+        const lines = data.toString().split('\n').filter(Boolean);
+        lines.forEach((line) => this.addLog(line, true));
+      });
+
+      // Handle error
+      this.process.on('error', (err) => {
+        this.running = false;
+        this.crashed = true;
+        this.addLog(`Error: ${err.message}`, true);
+        this.notifyStateChange();
+      });
+
+      // Handle close
+      this.process.on('close', (code) => {
+        this.running = false;
+        if (code !== 0 && code !== null) {
+          this.crashed = true;
+          this.addLog(`Process exited with code ${code}`, true);
+        } else {
+          this.addLog('Process stopped');
+        }
+        this.process = null;
+        this.notifyStateChange();
+      });
+
+      this.notifyStateChange();
+      return { success: true, pid: this.process.pid };
+    } catch (err) {
+      this.crashed = true;
+      this.addLog(`Failed to start: ${err.message}`, true);
+      this.notifyStateChange();
+      return {
+        success: false,
+        error: ServerError.startFailed(commandString, err.message),
+      };
+    }
+  }
+
+  /**
+   * Stop the server process
+   * @returns {boolean} - True if a process was stopped
+   */
+  stop() {
+    if (!this.process) {
+      return false;
+    }
+
+    // Capture reference before nulling — needed for deferred SIGKILL
+    const proc = this.process;
+
+    // Try graceful shutdown first
+    if (process.platform === 'win32') {
+      try {
+        spawn('taskkill', ['/pid', proc.pid.toString(), '/f', '/t']);
+      } catch (e) {
+        // Ignore taskkill errors
+      }
+    } else {
+      try {
+        proc.kill('SIGTERM');
+
+        // Force kill after grace period
+        const forceKillTimeout = setTimeout(() => {
+          try {
+            proc.kill('SIGKILL');
+          } catch (e) {
+            // Process may already be dead
+          }
+        }, KILL_GRACE_PERIOD);
+
+        // Clear timeout if process exits cleanly
+        proc.once('close', () => {
+          clearTimeout(forceKillTimeout);
+        });
+      } catch (e) {
+        // Process may already be dead
+      }
+    }
+
+    this.process = null;
+    this.running = false;
+    this.notifyStateChange();
+    return true;
+  }
+
+  /**
+   * Restart the server process
+   * @returns {Promise<{success: boolean, error?: Error, pid?: number}>}
+   */
+  async restart() {
+    const command = this.command;
+    this.stop();
+
+    // Wait before restarting
+    await new Promise((resolve) => setTimeout(resolve, RESTART_DELAY));
+
+    return this.start(command);
+  }
+
+  /**
+   * Check if server is running
+   * @returns {boolean}
+   */
+  isRunning() {
+    return this.running;
+  }
+
+  /**
+   * Check if server crashed
+   * @returns {boolean}
+   */
+  hasCrashed() {
+    return this.crashed;
+  }
+
+  /**
+   * Get server PID
+   * @returns {number|null}
+   */
+  getPid() {
+    return this.process ? this.process.pid : null;
+  }
+
+  /**
+   * Notify state change
+   * @private
+   */
+  notifyStateChange() {
+    this.onStateChange(this.getState());
+  }
+}
+
+module.exports = {
+  ProcessManager,
+  parseCommand,
+  MAX_LOG_LINES,
+  KILL_GRACE_PERIOD,
+  RESTART_DELAY,
+};