git-watchtower 2.1.9 → 2.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-watchtower",
-  "version": "2.1.9",
+  "version": "2.1.10",
   "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/branch.js

@@ -3,7 +3,7 @@
  * Provides branch management and parsing
  */
 
-const { execGit, fetch, hasUncommittedChanges, getCommitsByDay, log, deleteLocalBranch } = require('./commands');
+const { execGit, fetch, hasRemoteChanges, hasUncommittedChanges, getCommitsByDay, log, deleteLocalBranch } = require('./commands');
 const { GitError, ValidationError } = require('../utils/errors');
 
 // Valid git branch name pattern (conservative)
@@ -91,9 +91,20 @@ async function getAllBranches(options = {}) {
   const { remoteName = 'origin', fetch: shouldFetch = true, cwd } = options;
 
   try {
-    // Optionally fetch first
+    // Optionally fetch first. Probe via `git ls-remote --heads` first
+    // (cheap: lists refs without downloading objects) and skip the full
+    // fetch when the remote's refs exactly match our local cache. On a
+    // mostly-idle repo this turns most poll cycles into a single short
+    // advertise instead of a multi-megabyte object negotiation. When
+    // refs differ — including the new-branch and deleted-branch cases —
+    // we fall through to the regular fetch + prune. A null probe result
+    // (network/auth/missing-remote) also falls through, so an unrelated
+    // probe failure can't masquerade as "no changes."
     if (shouldFetch) {
-      await fetch(remoteName, { prune: true, all: true, cwd });
+      const changed = await hasRemoteChanges(remoteName, { cwd });
+      if (changed !== false) {
+        await fetch(remoteName, { prune: true, all: true, cwd });
+      }
     }
 
     const branchList = [];

package/src/git/commands.js

@@ -201,6 +201,82 @@ async function fetch(remoteName = 'origin', options = {}) {
   }
 }
 
+/**
+ * Probe whether the configured remote has any refs that differ from our
+ * local `refs/remotes/<remote>/` cache. Uses `git ls-remote --heads`
+ * which advertises remote refs over the wire without downloading any
+ * objects — much cheaper than `git fetch` on large repos.
+ *
+ * Comparison is exact across both directions:
+ *   - sha mismatch on a shared ref → changed
+ *   - ref missing locally (new branch) → changed
+ *   - ref missing on remote (deleted, needs prune) → changed
+ *
+ * Returns `null` when the probe itself failed (network, auth, missing
+ * remote). Callers should fall through to a real fetch in that case
+ * rather than treating "couldn't tell" as "no changes."
+ *
+ * @param {string} remoteName
+ * @param {Object} [options]
+ * @param {string} [options.cwd]
+ * @returns {Promise<boolean|null>}
+ */
+async function hasRemoteChanges(remoteName, options = {}) {
+  const { cwd } = options;
+
+  // Probe over the wire — list refs only, no object download.
+  const probeResult = await execGitOptional(
+    ['ls-remote', '--heads', '--quiet', remoteName],
+    { cwd, timeout: FETCH_TIMEOUT }
+  );
+  if (!probeResult) return null;
+
+  const remoteRefs = new Map();
+  for (const line of probeResult.stdout.split('\n').filter(Boolean)) {
+    // Format: "<sha>\trefs/heads/<branch>"
+    const tab = line.indexOf('\t');
+    if (tab === -1) continue;
+    const sha = line.slice(0, tab);
+    const ref = line.slice(tab + 1);
+    if (ref.startsWith('refs/heads/')) {
+      remoteRefs.set(ref.slice('refs/heads/'.length), sha);
+    }
+  }
+
+  // What we already have locally for this remote.
+  const localResult = await execGitOptional(
+    ['for-each-ref', '--format=%(refname:short) %(objectname)', `refs/remotes/${remoteName}/`],
+    { cwd, timeout: SHORT_TIMEOUT }
+  );
+  if (!localResult) return null;
+
+  const localRefs = new Map();
+  const prefix = `${remoteName}/`;
+  for (const line of localResult.stdout.split('\n').filter(Boolean)) {
+    const space = line.indexOf(' ');
+    if (space === -1) continue;
+    const refShort = line.slice(0, space);
+    const sha = line.slice(space + 1);
+    if (!refShort.startsWith(prefix)) continue;
+    const name = refShort.slice(prefix.length);
+    // Skip the symbolic <remote>/HEAD ref — ls-remote --heads doesn't
+    // advertise it, so including it would cause a false-positive size
+    // mismatch.
+    if (name === 'HEAD') continue;
+    localRefs.set(name, sha);
+  }
+
+  // Different ref count → addition or deletion on remote.
+  if (remoteRefs.size !== localRefs.size) return true;
+
+  // Same count, any sha mismatch → update on shared ref.
+  for (const [name, sha] of remoteRefs) {
+    if (localRefs.get(name) !== sha) return true;
+  }
+
+  return false;
+}
+
 /**
  * Pull from remote
  * @param {string} remoteName - Remote name
@@ -512,6 +588,7 @@ module.exports = {
   getRemotes,
   remoteExists,
   fetch,
+  hasRemoteChanges,
   pull,
   log,
   getCommitsByDay,