ccmanager 3.11.2 → 3.11.3

package/dist/hooks/useGitStatus.d.ts

@@ -1,13 +1,15 @@
 import { Worktree } from '../types/index.js';
 /**
- * Custom hook for polling git status of worktrees with Effect-based execution
+ * Custom hook for polling git status and commit dates of worktrees with Effect-based execution
  *
- * Fetches git status for each worktree at regular intervals using Effect.runPromiseExit
- * and updates worktree state with results. Handles cancellation via AbortController.
+ * Fetches git status and last commit date for each worktree at regular intervals
+ * using Effect.runPromiseExit and updates worktree state with results.
+ * Both are fetched together so they appear at the same time.
+ * Handles cancellation via AbortController.
  *
  * @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 and gitStatusError fields
+ * @returns Array of worktrees with updated gitStatus, gitStatusError, and lastCommitDate fields
  */
 export declare function useGitStatus(worktrees: Worktree[], defaultBranch: string | null, updateInterval?: number): Worktree[];

package/dist/hooks/useGitStatus.js

@@ -1,16 +1,18 @@
 import { useEffect, useState } from 'react';
 import { Effect, Exit, Cause, Option } from 'effect';
-import { getGitStatusLimited } from '../utils/gitStatus.js';
+import { getGitStatusLimited, getLastCommitDateLimited, } from '../utils/gitStatus.js';
 /**
- * Custom hook for polling git status of worktrees with Effect-based execution
+ * Custom hook for polling git status and commit dates of worktrees with Effect-based execution
  *
- * Fetches git status for each worktree at regular intervals using Effect.runPromiseExit
- * and updates worktree state with results. Handles cancellation via AbortController.
+ * Fetches git status and last commit date for each worktree at regular intervals
+ * using Effect.runPromiseExit and updates worktree state with results.
+ * Both are fetched together so they appear at the same time.
+ * Handles cancellation via AbortController.
  *
  * @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 and gitStatusError fields
+ * @returns Array of worktrees with updated gitStatus, gitStatusError, and lastCommitDate fields
  */
 export function useGitStatus(worktrees, defaultBranch, updateInterval = 5000) {
     const [worktreesWithStatus, setWorktreesWithStatus] = useState(worktrees);
@@ -22,12 +24,17 @@ export function useGitStatus(worktrees, defaultBranch, updateInterval = 5000) {
         const activeRequests = new Map();
         let isCleanedUp = false;
         const fetchStatus = async (worktree, abortController) => {
-            // Execute the Effect to get git status with cancellation support
-            const exit = await Effect.runPromiseExit(getGitStatusLimited(worktree.path), {
-                signal: abortController.signal,
-            });
-            // Update worktree state based on exit result
-            handleStatusExit(exit, worktree.path, setWorktreesWithStatus);
+            // 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) => {
             const abortController = new AbortController();
@@ -62,35 +69,42 @@ export function useGitStatus(worktrees, defaultBranch, updateInterval = 5000) {
     return worktreesWithStatus;
 }
 /**
- * Handle the Exit result from Effect.runPromiseExit and update worktree state
+ * Handle the Exit results from Effect.runPromiseExit and update worktree state
  *
- * Uses pattern matching on Exit to distinguish between success, failure, and interruption.
- * Success updates gitStatus, failure updates gitStatusError, interruption is ignored.
+ * Updates both gitStatus and lastCommitDate in a single state update so they
+ * appear at the same time in the UI.
  *
- * @param exit - Exit result from Effect execution
+ * @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 setWorktreesWithStatus - State setter function
  */
-function handleStatusExit(exit, worktreePath, setWorktreesWithStatus) {
-    if (Exit.isSuccess(exit)) {
-        // Success: update gitStatus and clear error
-        const gitStatus = exit.value;
-        setWorktreesWithStatus(prev => prev.map(wt => wt.path === worktreePath
-            ? { ...wt, gitStatus, gitStatusError: undefined }
-            : wt));
+function handleStatusExit(statusExit, dateExit, worktreePath, setWorktreesWithStatus) {
+    // Build the update object from both results
+    const update = {};
+    let hasUpdate = false;
+    if (Exit.isSuccess(statusExit)) {
+        update.gitStatus = statusExit.value;
+        update.gitStatusError = undefined;
+        hasUpdate = true;
     }
-    else if (Exit.isFailure(exit)) {
-        // Failure: extract error and update gitStatusError
-        const failure = Cause.failureOption(exit.cause);
+    else if (Exit.isFailure(statusExit)) {
+        const failure = Cause.failureOption(statusExit.cause);
         if (Option.isSome(failure)) {
             const gitError = failure.value;
-            const errorMessage = formatGitError(gitError);
-            setWorktreesWithStatus(prev => prev.map(wt => wt.path === worktreePath
-                ? { ...wt, gitStatus: undefined, gitStatusError: errorMessage }
-                : wt));
+            update.gitStatus = undefined;
+            update.gitStatusError = formatGitError(gitError);
+            hasUpdate = true;
         }
     }
-    // Interruption: no state update - the request was cancelled
+    if (Exit.isSuccess(dateExit)) {
+        update.lastCommitDate = dateExit.value;
+        hasUpdate = true;
+    }
+    // Silently ignore commit date errors (e.g., empty repo)
+    if (hasUpdate) {
+        setWorktreesWithStatus(prev => prev.map(wt => (wt.path === worktreePath ? { ...wt, ...update } : wt)));
+    }
 }
 /**
  * Format GitError into a user-friendly error message

package/dist/hooks/useGitStatus.test.js

@@ -4,14 +4,16 @@ import { render, cleanup } from 'ink-testing-library';
 import { Text } from 'ink';
 import { Effect, Exit } from 'effect';
 import { useGitStatus } from './useGitStatus.js';
-import { getGitStatusLimited } from '../utils/gitStatus.js';
+import { getGitStatusLimited, getLastCommitDateLimited, } from '../utils/gitStatus.js';
 import { GitError } from '../types/errors.js';
 // Mock the gitStatus module
 vi.mock('../utils/gitStatus.js', () => ({
     getGitStatusLimited: vi.fn(),
+    getLastCommitDateLimited: vi.fn(),
 }));
 describe('useGitStatus', () => {
     const mockGetGitStatus = getGitStatusLimited;
+    const mockGetLastCommitDate = getLastCommitDateLimited;
     const createWorktree = (path) => ({
         path,
         branch: 'main',
@@ -28,6 +30,9 @@ describe('useGitStatus', () => {
     beforeEach(() => {
         vi.useFakeTimers();
         mockGetGitStatus.mockClear();
+        mockGetLastCommitDate.mockClear();
+        // Default: return a date for all worktrees
+        mockGetLastCommitDate.mockReturnValue(Effect.succeed(new Date('2025-01-01T00:00:00Z')));
     });
     afterEach(() => {
         vi.useRealTimers();
@@ -123,6 +128,13 @@ describe('useGitStatus', () => {
                 resolveEffect = resume;
             });
         });
+        // Also make commit date async so Promise.all waits for both
+        let resolveDateEffect = null;
+        mockGetLastCommitDate.mockImplementation(() => {
+            return Effect.async(resume => {
+                resolveDateEffect = resume;
+            });
+        });
         const TestComponent = () => {
             useGitStatus(worktrees, 'main', 100);
             return React.createElement(Text, null, 'test');
@@ -136,8 +148,9 @@ describe('useGitStatus', () => {
         await vi.advanceTimersByTimeAsync(250);
         // Should not have started a second fetch yet
         expect(mockGetGitStatus).toHaveBeenCalledTimes(1);
-        // Complete the first fetch
+        // Complete the first fetch (both status and date)
         resolveEffect(Exit.succeed(createGitStatus(1, 0)));
+        resolveDateEffect(Exit.succeed(new Date('2025-01-01T00:00:00Z')));
         // Wait for the promise to resolve
         await vi.waitFor(() => {
             expect(fetchCount).toBe(1);
@@ -162,6 +175,12 @@ describe('useGitStatus', () => {
                 });
             });
         });
+        // Also make commit date async so it doesn't resolve before status
+        mockGetLastCommitDate.mockImplementation(() => {
+            return Effect.async(_resume => {
+                return Effect.sync(() => { });
+            });
+        });
         const TestComponent = ({ worktrees }) => {
             useGitStatus(worktrees, 'main', 100);
             return React.createElement(Text, null, 'test');

package/dist/services/worktreeService.js

@@ -662,21 +662,6 @@ export class WorktreeService {
                 if (mainWorktree && mainWorktree.path.includes('.git/modules')) {
                     mainWorktree.path = self.gitRootPath;
                 }
-                // Fetch last commit date for each worktree
-                for (const wt of worktrees) {
-                    try {
-                        const dateStr = execSync('git log -1 --format=%aI', {
-                            cwd: wt.path,
-                            encoding: 'utf8',
-                        }).trim();
-                        if (dateStr) {
-                            wt.lastCommitDate = new Date(dateStr);
-                        }
-                    }
-                    catch {
-                        // Ignore errors (e.g., empty repo)
-                    }
-                }
                 // Sort worktrees by last session if requested
                 if (sortByLastSession) {
                     worktrees.sort((a, b) => {

package/dist/utils/gitStatus.d.ts

@@ -41,6 +41,14 @@ export interface GitStatus {
  */
 export declare const getGitStatus: (worktreePath: string) => Effect.Effect<GitStatus, GitError>;
 export declare const getGitStatusLimited: (worktreePath: string) => Effect.Effect<GitStatus, GitError, never>;
+/**
+ * Get the last commit date for a worktree
+ *
+ * @param worktreePath - Absolute path to the worktree directory
+ * @returns Effect containing the commit date or GitError
+ */
+export declare const getLastCommitDate: (worktreePath: string) => Effect.Effect<Date, GitError>;
+export declare const getLastCommitDateLimited: (worktreePath: string) => Effect.Effect<Date, GitError, never>;
 export declare function formatGitFileChanges(status: GitStatus): string;
 export declare function formatGitAheadBehind(status: GitStatus): string;
 export declare function formatGitStatus(status: GitStatus): string;

package/dist/utils/gitStatus.js

@@ -62,6 +62,24 @@ export const getGitStatus = (worktreePath) => Effect.gen(function* () {
     };
 });
 export const getGitStatusLimited = createEffectConcurrencyLimited((worktreePath) => getGitStatus(worktreePath), 10);
+/**
+ * Get the last commit date for a worktree
+ *
+ * @param worktreePath - Absolute path to the worktree directory
+ * @returns Effect containing the commit date or GitError
+ */
+export const getLastCommitDate = (worktreePath) => Effect.flatMap(runGit(['log', '-1', '--format=%aI'], worktreePath), result => {
+    const dateStr = result.stdout.trim();
+    if (dateStr) {
+        return Effect.succeed(new Date(dateStr));
+    }
+    return Effect.fail(new GitError({
+        command: 'git log -1 --format=%aI',
+        exitCode: 0,
+        stderr: 'No commits found',
+    }));
+});
+export const getLastCommitDateLimited = createEffectConcurrencyLimited((worktreePath) => getLastCommitDate(worktreePath), 10);
 export function formatGitFileChanges(status) {
     const parts = [];
     const colors = {

package/package.json

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