ccmanager 4.1.23 → 4.1.24

package/dist/hooks/useGitStatus.d.ts

@@ -7,6 +7,11 @@ import { Worktree } from '../types/index.js';
  * Both are fetched together so they appear at the same time.
  * Handles cancellation via AbortController.
  *
+ * Each poll cycle fetches every worktree concurrently and commits the results in
+ * a single state update, skipping the update entirely when nothing changed. This
+ * keeps a poll cycle to at most one re-render of the consumer (the menu) instead
+ * of one per worktree, so background polling does not stutter keyboard navigation.
+ *
  * @param worktrees - Array of worktrees to monitor
  * @param defaultBranch - Default branch for comparisons (null disables polling)
  * @param updateInterval - Polling interval in milliseconds (default: 5000)

package/dist/hooks/useGitStatus.js

@@ -9,6 +9,11 @@ import { getGitStatusLimited, getLastCommitDateLimited, } from '../utils/gitStat
  * Both are fetched together so they appear at the same time.
  * Handles cancellation via AbortController.
  *
+ * Each poll cycle fetches every worktree concurrently and commits the results in
+ * a single state update, skipping the update entirely when nothing changed. This
+ * keeps a poll cycle to at most one re-render of the consumer (the menu) instead
+ * of one per worktree, so background polling does not stutter keyboard navigation.
+ *
  * @param worktrees - Array of worktrees to monitor
  * @param defaultBranch - Default branch for comparisons (null disables polling)
  * @param updateInterval - Polling interval in milliseconds (default: 5000)
@@ -20,67 +25,103 @@ export function useGitStatus(worktrees, defaultBranch, updateInterval = 5000) {
         if (!defaultBranch) {
             return;
         }
-        const timeouts = new Map();
-        const activeRequests = new Map();
+        const activeRequests = new Set();
         let isCleanedUp = false;
-        const fetchStatus = async (worktree, abortController) => {
-            // Fetch git status and last commit date in parallel
-            const [statusExit, dateExit] = await Promise.all([
-                Effect.runPromiseExit(getGitStatusLimited(worktree.path), {
-                    signal: abortController.signal,
-                }),
-                Effect.runPromiseExit(getLastCommitDateLimited(worktree.path), {
-                    signal: abortController.signal,
-                }),
-            ]);
-            // Update worktree state with both results at once
-            handleStatusExit(statusExit, dateExit, worktree.path, setWorktreesWithStatus);
-        };
-        const scheduleUpdate = (worktree) => {
+        let cycleTimeout;
+        const fetchStatus = async (worktree) => {
             const abortController = new AbortController();
-            activeRequests.set(worktree.path, abortController);
-            fetchStatus(worktree, abortController)
-                .catch(() => {
-                // Ignore errors - the fetch failed or was aborted
-            })
-                .finally(() => {
-                const isActive = () => !isCleanedUp && !abortController.signal.aborted;
-                if (isActive()) {
-                    const timeout = setTimeout(() => {
-                        if (isActive()) {
-                            scheduleUpdate(worktree);
-                        }
-                    }, updateInterval);
-                    timeouts.set(worktree.path, timeout);
-                }
-            });
+            activeRequests.add(abortController);
+            try {
+                // Fetch git status and last commit date in parallel
+                const [statusExit, dateExit] = await Promise.all([
+                    Effect.runPromiseExit(getGitStatusLimited(worktree.path), {
+                        signal: abortController.signal,
+                    }),
+                    Effect.runPromiseExit(getLastCommitDateLimited(worktree.path), {
+                        signal: abortController.signal,
+                    }),
+                ]);
+                return { path: worktree.path, statusExit, dateExit };
+            }
+            finally {
+                activeRequests.delete(abortController);
+            }
+        };
+        const runCycle = async () => {
+            // Fetch all worktrees concurrently. The underlying Effects are already
+            // concurrency-limited, so this does not spawn an unbounded number of git
+            // subprocesses at once.
+            const results = await Promise.all(worktrees.map(worktree => fetchStatus(worktree)));
+            if (isCleanedUp) {
+                return;
+            }
+            // Apply every worktree's result in one state update so the consumer
+            // re-renders at most once per cycle.
+            applyStatusResults(results, setWorktreesWithStatus);
+            if (!isCleanedUp) {
+                cycleTimeout = setTimeout(() => {
+                    if (!isCleanedUp) {
+                        runCycle();
+                    }
+                }, updateInterval);
+            }
         };
         setWorktreesWithStatus(worktrees);
-        // Start fetching for each worktree
-        worktrees.forEach(worktree => {
-            scheduleUpdate(worktree);
+        runCycle().catch(() => {
+            // Ignore errors - the fetch failed or was aborted
         });
         return () => {
             isCleanedUp = true;
-            timeouts.forEach(timeout => clearTimeout(timeout));
+            if (cycleTimeout) {
+                clearTimeout(cycleTimeout);
+            }
             activeRequests.forEach(controller => controller.abort());
         };
     }, [worktrees, defaultBranch, updateInterval]);
     return worktreesWithStatus;
 }
 /**
- * Handle the Exit results from Effect.runPromiseExit and update worktree state
+ * Apply a cycle's worth of status results in a single state update.
  *
- * Updates both gitStatus and lastCommitDate in a single state update so they
- * appear at the same time in the UI.
+ * Builds the next worktree array by merging each result onto the matching
+ * worktree, but only when the result actually changes a field. When nothing
+ * changed, the previous array reference is returned so React skips the re-render
+ * (and any downstream items rebuild) entirely.
  *
- * @param statusExit - Exit result from git status Effect
- * @param dateExit - Exit result from commit date Effect
- * @param worktreePath - Path of the worktree being updated
+ * @param results - Per-worktree status/date Exit results for this cycle
  * @param setWorktreesWithStatus - State setter function
  */
-function handleStatusExit(statusExit, dateExit, worktreePath, setWorktreesWithStatus) {
-    // Build the update object from both results
+function applyStatusResults(results, setWorktreesWithStatus) {
+    const updatesByPath = new Map();
+    for (const result of results) {
+        const update = buildStatusUpdate(result.statusExit, result.dateExit);
+        if (update) {
+            updatesByPath.set(result.path, update);
+        }
+    }
+    if (updatesByPath.size === 0) {
+        return;
+    }
+    setWorktreesWithStatus(prev => {
+        let changed = false;
+        const next = prev.map(wt => {
+            const update = updatesByPath.get(wt.path);
+            if (!update || isUpdateNoop(wt, update)) {
+                return wt;
+            }
+            changed = true;
+            return { ...wt, ...update };
+        });
+        return changed ? next : prev;
+    });
+}
+/**
+ * Build the update object for a single worktree from its Exit results.
+ *
+ * @returns A partial worktree to merge, or null when there is nothing to update
+ *   (e.g. the status fetch was interrupted and the commit date failed).
+ */
+function buildStatusUpdate(statusExit, dateExit) {
     const update = {};
     let hasUpdate = false;
     if (Exit.isSuccess(statusExit)) {
@@ -91,9 +132,8 @@ function handleStatusExit(statusExit, dateExit, worktreePath, setWorktreesWithSt
     else if (Exit.isFailure(statusExit)) {
         const failure = Cause.failureOption(statusExit.cause);
         if (Option.isSome(failure)) {
-            const gitError = failure.value;
             update.gitStatus = undefined;
-            update.gitStatusError = formatGitError(gitError);
+            update.gitStatusError = formatGitError(failure.value);
             hasUpdate = true;
         }
     }
@@ -102,9 +142,42 @@ function handleStatusExit(statusExit, dateExit, worktreePath, setWorktreesWithSt
         hasUpdate = true;
     }
     // Silently ignore commit date errors (e.g., empty repo)
-    if (hasUpdate) {
-        setWorktreesWithStatus(prev => prev.map(wt => (wt.path === worktreePath ? { ...wt, ...update } : wt)));
+    return hasUpdate ? update : null;
+}
+/**
+ * Determine whether applying `update` to `wt` would change any field, so that
+ * no-op updates can be dropped before they trigger a re-render.
+ */
+function isUpdateNoop(wt, update) {
+    if ('gitStatus' in update &&
+        !isSameGitStatus(wt.gitStatus, update.gitStatus)) {
+        return false;
+    }
+    if ('gitStatusError' in update &&
+        wt.gitStatusError !== update.gitStatusError) {
+        return false;
+    }
+    if ('lastCommitDate' in update) {
+        const prevTime = wt.lastCommitDate?.getTime();
+        const nextTime = update.lastCommitDate?.getTime();
+        if (prevTime !== nextTime) {
+            return false;
+        }
+    }
+    return true;
+}
+function isSameGitStatus(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (!a || !b) {
+        return false;
     }
+    return (a.filesAdded === b.filesAdded &&
+        a.filesDeleted === b.filesDeleted &&
+        a.aheadCount === b.aheadCount &&
+        a.behindCount === b.behindCount &&
+        a.parentBranch === b.parentBranch);
 }
 /**
  * Format GitError into a user-friendly error message

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "4.1.23",
+	"version": "4.1.24",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",
@@ -41,11 +41,11 @@
 		"bin"
 	],
 	"optionalDependencies": {
-		"@kodaikabasawa/ccmanager-darwin-arm64": "4.1.23",
-		"@kodaikabasawa/ccmanager-darwin-x64": "4.1.23",
-		"@kodaikabasawa/ccmanager-linux-arm64": "4.1.23",
-		"@kodaikabasawa/ccmanager-linux-x64": "4.1.23",
-		"@kodaikabasawa/ccmanager-win32-x64": "4.1.23"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "4.1.24",
+		"@kodaikabasawa/ccmanager-darwin-x64": "4.1.24",
+		"@kodaikabasawa/ccmanager-linux-arm64": "4.1.24",
+		"@kodaikabasawa/ccmanager-linux-x64": "4.1.24",
+		"@kodaikabasawa/ccmanager-win32-x64": "4.1.24"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",