git-watchtower 1.14.0 → 1.14.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-watchtower",
-  "version": "1.14.0",
+  "version": "1.14.2",
   "description": "Terminal-based Git branch monitor with activity sparklines and optional dev server with live reload",
   "main": "bin/git-watchtower.js",
   "bin": {

package/src/git/commands.js

@@ -198,7 +198,13 @@ async function log(branchName, options = {}) {
 }
 
 /**
- * Get commit count by day for sparkline
+ * Get commit count by day for sparkline.
+ *
+ * Buckets commits by local calendar date rather than by dividing a ms
+ * difference by 86 400 000, which breaks on DST transitions (a
+ * spring-forward day is only 23 h, causing Math.floor(23/24) = 0 and
+ * merging yesterday's commits into today's bucket).
+ *
  * @param {string} branchName - Branch name
  * @param {number} [days=7] - Number of days
  * @param {string} [cwd] - Working directory
@@ -215,15 +221,23 @@ async function getCommitsByDay(branchName, days = 7, cwd) {
 
     if (!stdout) return counts;
 
+    // Build a map from "YYYY-MM-DD" → bucket index. Using setDate()
+    // to step backwards is DST-safe because it adjusts the calendar
+    // day without relying on a fixed ms offset.
     const today = new Date();
-    today.setHours(0, 0, 0, 0);
+    const dayBuckets = new Map();
+    for (let i = 0; i < days; i++) {
+      const d = new Date(today.getFullYear(), today.getMonth(), today.getDate() - i);
+      const key = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+      dayBuckets.set(key, days - 1 - i);
+    }
 
     for (const line of stdout.split('\n').filter(Boolean)) {
       const commitDate = new Date(line);
-      commitDate.setHours(0, 0, 0, 0);
-      const daysDiff = Math.floor((today.getTime() - commitDate.getTime()) / (1000 * 60 * 60 * 24));
-      if (daysDiff >= 0 && daysDiff < days) {
-        counts[days - 1 - daysDiff]++;
+      const key = `${commitDate.getFullYear()}-${String(commitDate.getMonth() + 1).padStart(2, '0')}-${String(commitDate.getDate()).padStart(2, '0')}`;
+      const idx = dayBuckets.get(key);
+      if (idx !== undefined) {
+        counts[idx]++;
       }
     }
   } catch (error) {

package/src/server/process.js

@@ -265,38 +265,13 @@ class ProcessManager {
       return false;
     }
 
-    // Capture reference before nulling — needed for deferred SIGKILL
+    // Capture reference before nulling — needed for deferred force-kill
     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
-      }
+      this._stopWindows(proc);
     } else {
-      try {
-        // Kill the entire process group (negative PID) so that
-        // grandchildren (e.g. npm -> node -> vite) are also terminated.
-        process.kill(-proc.pid, 'SIGTERM');
-
-        // Force kill after grace period
-        const forceKillTimeout = setTimeout(() => {
-          try {
-            process.kill(-proc.pid, 'SIGKILL');
-          } catch (e) {
-            // Process group may already be dead
-          }
-        }, KILL_GRACE_PERIOD);
-
-        // Clear timeout if process exits cleanly
-        proc.once('close', () => {
-          clearTimeout(forceKillTimeout);
-        });
-      } catch (e) {
-        // Process group may already be dead
-      }
+      this._stopUnix(proc);
     }
 
     this.process = null;
@@ -305,6 +280,77 @@ class ProcessManager {
     return true;
   }
 
+  /**
+   * Unix stop: SIGTERM the process group, then SIGKILL after a grace period.
+   * The grace timer is unref'd so it doesn't keep the event loop alive when
+   * the main process wants to exit.
+   * @param {import('child_process').ChildProcess} proc
+   * @private
+   */
+  _stopUnix(proc) {
+    // If the process has already exited, there's nothing to signal.
+    if (proc.exitCode !== null || proc.signalCode !== null) return;
+
+    try {
+      process.kill(-proc.pid, 'SIGTERM');
+    } catch (e) {
+      // Process group may already be dead
+      return;
+    }
+
+    const forceKillTimeout = setTimeout(() => {
+      // Re-check: process may have exited during the grace period.
+      if (proc.exitCode !== null || proc.signalCode !== null) return;
+      try {
+        process.kill(-proc.pid, 'SIGKILL');
+      } catch (e) {
+        // Process group may already be dead
+      }
+    }, KILL_GRACE_PERIOD);
+
+    // Don't let this timer keep the event loop alive on shutdown.
+    forceKillTimeout.unref();
+
+    // Clear early if the process exits before the grace period.
+    proc.once('close', () => {
+      clearTimeout(forceKillTimeout);
+    });
+  }
+
+  /**
+   * Windows stop: taskkill /t (tree kill). If the process doesn't exit
+   * within the grace period, retry with /f (force).
+   * @param {import('child_process').ChildProcess} proc
+   * @private
+   */
+  _stopWindows(proc) {
+    if (proc.exitCode !== null || proc.signalCode !== null) return;
+
+    try {
+      spawn('taskkill', ['/pid', proc.pid.toString(), '/t']);
+    } catch (e) {
+      // Ignore spawn errors (PID already gone, etc.)
+      return;
+    }
+
+    // Fallback: force-kill if the process is still alive after the
+    // grace period. This mirrors the Unix SIGTERM → SIGKILL pattern.
+    const forceKillTimeout = setTimeout(() => {
+      if (proc.exitCode !== null || proc.signalCode !== null) return;
+      try {
+        spawn('taskkill', ['/pid', proc.pid.toString(), '/f', '/t']);
+      } catch (e) {
+        // Ignore — process may already be dead
+      }
+    }, KILL_GRACE_PERIOD);
+
+    forceKillTimeout.unref();
+
+    proc.once('close', () => {
+      clearTimeout(forceKillTimeout);
+    });
+  }
+
   /**
    * Restart the server process
    * @returns {Promise<{success: boolean, error?: Error, pid?: number}>}