ccmanager 4.1.23 → 4.1.25

package/dist/hooks/useGitStatus.d.ts

@@ -1,4 +1,6 @@
 import { Worktree } from '../types/index.js';
+/** Clear the module-level git-status cache. Intended for tests. */
+export declare function clearGitStatusCache(): void;
 /**
  * Custom hook for polling git status and commit dates of worktrees with Effect-based execution
  *
@@ -7,6 +9,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

@@ -1,6 +1,58 @@
 import { useEffect, useState } from 'react';
 import { Effect, Exit, Cause, Option } from 'effect';
 import { getGitStatusLimited, getLastCommitDateLimited, } from '../utils/gitStatus.js';
+/**
+ * Module-level cache of the last fetched git status, keyed by worktree path.
+ *
+ * The menu is fully unmounted and remounted on every return to it (App renders
+ * `<Menu key={menuKey} />`, and the key changes on navigation), which would
+ * otherwise wipe this hook's state and force every worktree to flash
+ * "[fetching...]" and refetch from scratch each time. Seeding state from this
+ * cache shows each worktree's last known status instantly; background polling
+ * still refreshes it. Entries are intentionally not pruned so switching between
+ * projects keeps each project's cached status.
+ */
+const statusCache = new Map();
+/** Clear the module-level git-status cache. Intended for tests. */
+export function clearGitStatusCache() {
+    statusCache.clear();
+}
+/**
+ * Merge any cached status onto the given worktrees so a remount can show the
+ * last known status immediately instead of "[fetching...]". Returns the same
+ * array reference when nothing was cached, so React can skip a re-render.
+ */
+function hydrateFromCache(worktrees) {
+    let changed = false;
+    const next = worktrees.map(wt => {
+        const cached = statusCache.get(wt.path);
+        if (!cached) {
+            return wt;
+        }
+        changed = true;
+        return {
+            ...wt,
+            gitStatus: cached.gitStatus,
+            gitStatusError: cached.gitStatusError,
+            lastCommitDate: cached.lastCommitDate,
+        };
+    });
+    return changed ? next : worktrees;
+}
+/** Record a worktree's latest status update into the module-level cache. */
+function cacheStatusUpdate(path, update) {
+    const next = { ...statusCache.get(path) };
+    if ('gitStatus' in update) {
+        next.gitStatus = update.gitStatus;
+    }
+    if ('gitStatusError' in update) {
+        next.gitStatusError = update.gitStatusError;
+    }
+    if ('lastCommitDate' in update) {
+        next.lastCommitDate = update.lastCommitDate;
+    }
+    statusCache.set(path, next);
+}
 /**
  * Custom hook for polling git status and commit dates of worktrees with Effect-based execution
  *
@@ -9,78 +61,120 @@ 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)
  * @returns Array of worktrees with updated gitStatus, gitStatusError, and lastCommitDate fields
  */
 export function useGitStatus(worktrees, defaultBranch, updateInterval = 5000) {
-    const [worktreesWithStatus, setWorktreesWithStatus] = useState(worktrees);
+    const [worktreesWithStatus, setWorktreesWithStatus] = useState(() => hydrateFromCache(worktrees));
     useEffect(() => {
         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);
+            }
         };
-        setWorktreesWithStatus(worktrees);
-        // Start fetching for each worktree
-        worktrees.forEach(worktree => {
-            scheduleUpdate(worktree);
+        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(hydrateFromCache(worktrees));
+        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);
+            cacheStatusUpdate(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 +185,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 +195,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/dist/hooks/useGitStatus.test.js

@@ -3,7 +3,7 @@ import React from 'react';
 import { render, cleanup } from 'ink-testing-library';
 import { Text } from 'ink';
 import { Effect, Exit } from 'effect';
-import { useGitStatus } from './useGitStatus.js';
+import { useGitStatus, clearGitStatusCache } from './useGitStatus.js';
 import { getGitStatusLimited, getLastCommitDateLimited, } from '../utils/gitStatus.js';
 import { GitError } from '../types/errors.js';
 // Mock the gitStatus module
@@ -29,6 +29,9 @@ describe('useGitStatus', () => {
     });
     beforeEach(() => {
         vi.useFakeTimers();
+        // The status cache is module-level and persists across tests; clear it so
+        // each test starts from a cold cache.
+        clearGitStatusCache();
         mockGetGitStatus.mockClear();
         mockGetLastCommitDate.mockClear();
         // Default: return a date for all worktrees
@@ -66,6 +69,27 @@ describe('useGitStatus', () => {
         expect(hookResult[0]?.gitStatus).toEqual(gitStatus1);
         expect(hookResult[1]?.gitStatus).toEqual(gitStatus2);
     });
+    it('should hydrate from cache on remount so status shows immediately', async () => {
+        const worktrees = [createWorktree('/path1')];
+        const gitStatus1 = createGitStatus(7, 2);
+        mockGetGitStatus.mockReturnValue(Effect.succeed(gitStatus1));
+        let hookResult = [];
+        const TestComponent = () => {
+            hookResult = useGitStatus(worktrees, 'main', 100);
+            return React.createElement(Text, null, 'test');
+        };
+        // First mount: fetch populates the module-level cache.
+        const first = render(React.createElement(TestComponent));
+        await vi.waitFor(() => {
+            expect(hookResult[0]?.gitStatus).toEqual(gitStatus1);
+        });
+        first.unmount();
+        // Remount: cached status must be present on the very first render, before
+        // any new fetch resolves, so the menu does not flash "[fetching...]".
+        hookResult = [];
+        render(React.createElement(TestComponent));
+        expect(hookResult[0]?.gitStatus).toEqual(gitStatus1);
+    });
     it('should handle empty worktree array', () => {
         let hookResult = [];
         const TestComponent = () => {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "4.1.23",
+	"version": "4.1.25",
 	"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.25",
+		"@kodaikabasawa/ccmanager-darwin-x64": "4.1.25",
+		"@kodaikabasawa/ccmanager-linux-arm64": "4.1.25",
+		"@kodaikabasawa/ccmanager-linux-x64": "4.1.25",
+		"@kodaikabasawa/ccmanager-win32-x64": "4.1.25"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",