607 lines
20 KiB
TypeScript
607 lines
20 KiB
TypeScript
import { create } from 'zustand';
|
|
import { devtools } from 'zustand/middleware';
|
|
import type {
|
|
GitStatus,
|
|
GitBranch,
|
|
GitLogResponse,
|
|
GitIdentitySummary,
|
|
} from '@/lib/api/types';
|
|
|
|
const GIT_POLL_BASE_INTERVAL = 5000;
|
|
const GIT_POLL_MAX_INTERVAL = 10000;
|
|
const GIT_POLL_BACKOFF_STEP = 5000;
|
|
const LOG_STALE_THRESHOLD = 10000;
|
|
const DIFF_PREFETCH_MAX_FILES = 25;
|
|
const DIFF_PREFETCH_CONCURRENCY = 4;
|
|
const DIFF_PREFETCH_TIMEOUT_MS = 15000;
|
|
|
|
interface DirectoryGitState {
|
|
isGitRepo: boolean | null;
|
|
status: GitStatus | null;
|
|
branches: GitBranch | null;
|
|
log: GitLogResponse | null;
|
|
identity: GitIdentitySummary | null;
|
|
diffCache: Map<string, { original: string; modified: string; fetchedAt: number }>;
|
|
lastStatusFetch: number;
|
|
lastStatusChange: number;
|
|
lastLogFetch: number;
|
|
logMaxCount: number;
|
|
}
|
|
|
|
interface GitStore {
|
|
|
|
directories: Map<string, DirectoryGitState>;
|
|
|
|
activeDirectory: string | null;
|
|
|
|
isLoadingStatus: boolean;
|
|
isLoadingLog: boolean;
|
|
isLoadingBranches: boolean;
|
|
isLoadingIdentity: boolean;
|
|
|
|
pollIntervalId: ReturnType<typeof setTimeout> | null;
|
|
currentPollInterval: number;
|
|
|
|
setActiveDirectory: (directory: string | null) => void;
|
|
getDirectoryState: (directory: string) => DirectoryGitState | null;
|
|
|
|
fetchStatus: (directory: string, git: GitAPI, options?: { silent?: boolean }) => Promise<boolean>;
|
|
fetchBranches: (directory: string, git: GitAPI) => Promise<void>;
|
|
fetchLog: (directory: string, git: GitAPI, maxCount?: number) => Promise<void>;
|
|
fetchIdentity: (directory: string, git: GitAPI) => Promise<void>;
|
|
fetchAll: (directory: string, git: GitAPI, options?: { force?: boolean }) => Promise<void>;
|
|
|
|
getDiff: (directory: string, filePath: string) => { original: string; modified: string; fetchedAt: number } | null;
|
|
setDiff: (directory: string, filePath: string, diff: { original: string; modified: string }) => void;
|
|
clearDiffCache: (directory: string) => void;
|
|
fetchAllDiffs: (directory: string, git: GitAPI) => Promise<void>;
|
|
|
|
setLogMaxCount: (directory: string, maxCount: number) => void;
|
|
|
|
startPolling: (git: GitAPI) => void;
|
|
stopPolling: () => void;
|
|
|
|
refresh: (git: GitAPI, options?: { force?: boolean }) => Promise<void>;
|
|
}
|
|
|
|
interface GitFileDiffResponse {
|
|
original: string;
|
|
modified: string;
|
|
path: string;
|
|
}
|
|
|
|
interface GitAPI {
|
|
checkIsGitRepository: (directory: string) => Promise<boolean>;
|
|
getGitStatus: (directory: string) => Promise<GitStatus>;
|
|
getGitBranches: (directory: string) => Promise<GitBranch>;
|
|
getGitLog: (directory: string, options?: { maxCount?: number }) => Promise<GitLogResponse>;
|
|
getCurrentGitIdentity: (directory: string) => Promise<GitIdentitySummary | null>;
|
|
getGitFileDiff: (directory: string, options: { path: string }) => Promise<GitFileDiffResponse>;
|
|
}
|
|
|
|
const createEmptyDirectoryState = (): DirectoryGitState => ({
|
|
isGitRepo: null,
|
|
status: null,
|
|
branches: null,
|
|
log: null,
|
|
identity: null,
|
|
diffCache: new Map(),
|
|
lastStatusFetch: 0,
|
|
lastStatusChange: 0,
|
|
lastLogFetch: 0,
|
|
logMaxCount: 25,
|
|
});
|
|
|
|
const haveDiffStatsChanged = (
|
|
previous?: GitStatus['diffStats'],
|
|
next?: GitStatus['diffStats']
|
|
): boolean => {
|
|
if (!previous && !next) return false;
|
|
if (!previous || !next) return true;
|
|
|
|
const paths = new Set([...Object.keys(previous), ...Object.keys(next)]);
|
|
for (const path of paths) {
|
|
const prevEntry = previous[path];
|
|
const nextEntry = next[path];
|
|
|
|
if (!prevEntry && !nextEntry) continue;
|
|
if (!prevEntry || !nextEntry) return true;
|
|
if (
|
|
prevEntry.insertions !== nextEntry.insertions ||
|
|
prevEntry.deletions !== nextEntry.deletions
|
|
) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
const hasStatusChanged = (oldStatus: GitStatus | null, newStatus: GitStatus | null): boolean => {
|
|
if (!oldStatus && !newStatus) return false;
|
|
if (!oldStatus || !newStatus) return true;
|
|
|
|
const oldFiles = oldStatus.files ?? [];
|
|
const newFiles = newStatus.files ?? [];
|
|
|
|
if (oldFiles.length !== newFiles.length) return true;
|
|
if (oldStatus.ahead !== newStatus.ahead) return true;
|
|
if (oldStatus.behind !== newStatus.behind) return true;
|
|
if (oldStatus.current !== newStatus.current) return true;
|
|
if (oldStatus.tracking !== newStatus.tracking) return true;
|
|
if (oldStatus.isClean !== newStatus.isClean) return true;
|
|
|
|
const oldPaths = new Set(oldFiles.map(f => `${f.path}:${f.index}:${f.working_dir}`));
|
|
for (const file of newFiles) {
|
|
if (!oldPaths.has(`${file.path}:${file.index}:${file.working_dir}`)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (haveDiffStatsChanged(oldStatus.diffStats, newStatus.diffStats)) return true;
|
|
|
|
return false;
|
|
};
|
|
|
|
const getChangedFilePaths = (oldStatus: GitStatus | null, newStatus: GitStatus | null): Set<string> => {
|
|
const changed = new Set<string>();
|
|
if (!newStatus) return changed;
|
|
|
|
const oldFiles = oldStatus?.files ?? [];
|
|
const newFiles = newStatus.files ?? [];
|
|
|
|
const oldFileMap = new Map(oldFiles.map((f) => [f.path, f] as const));
|
|
const newFileMap = new Map(newFiles.map((f) => [f.path, f] as const));
|
|
|
|
const allFilePaths = new Set<string>([...oldFileMap.keys(), ...newFileMap.keys()]);
|
|
for (const filePath of allFilePaths) {
|
|
const oldFile = oldFileMap.get(filePath);
|
|
const newFile = newFileMap.get(filePath);
|
|
|
|
// Added/removed/renamed
|
|
if (!oldFile || !newFile) {
|
|
changed.add(filePath);
|
|
continue;
|
|
}
|
|
|
|
// Index/worktree state changed (indicates actual content/state changed)
|
|
if (oldFile.index !== newFile.index || oldFile.working_dir !== newFile.working_dir) {
|
|
changed.add(filePath);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
const oldStats = oldStatus?.diffStats ?? {};
|
|
const newStats = newStatus.diffStats ?? {};
|
|
const allStatPaths = new Set<string>([...Object.keys(oldStats), ...Object.keys(newStats)]);
|
|
|
|
for (const filePath of allStatPaths) {
|
|
const oldEntry = oldStats[filePath];
|
|
const newEntry = newStats[filePath];
|
|
|
|
if (!oldEntry || !newEntry) {
|
|
changed.add(filePath);
|
|
continue;
|
|
}
|
|
|
|
if (oldEntry.insertions !== newEntry.insertions || oldEntry.deletions !== newEntry.deletions) {
|
|
changed.add(filePath);
|
|
}
|
|
}
|
|
|
|
return changed;
|
|
};
|
|
|
|
export const useGitStore = create<GitStore>()(
|
|
devtools(
|
|
(set, get) => ({
|
|
directories: new Map(),
|
|
activeDirectory: null,
|
|
isLoadingStatus: false,
|
|
isLoadingLog: false,
|
|
isLoadingBranches: false,
|
|
isLoadingIdentity: false,
|
|
pollIntervalId: null,
|
|
currentPollInterval: GIT_POLL_BASE_INTERVAL,
|
|
|
|
setActiveDirectory: (directory) => {
|
|
const { activeDirectory, directories } = get();
|
|
if (activeDirectory === directory) return;
|
|
|
|
if (directory && !directories.has(directory)) {
|
|
const newDirectories = new Map(directories);
|
|
newDirectories.set(directory, createEmptyDirectoryState());
|
|
set({ activeDirectory: directory, directories: newDirectories });
|
|
} else {
|
|
set({ activeDirectory: directory });
|
|
}
|
|
},
|
|
|
|
getDirectoryState: (directory) => {
|
|
return get().directories.get(directory) ?? null;
|
|
},
|
|
|
|
fetchStatus: async (directory, git, options = {}) => {
|
|
const { silent = false } = options;
|
|
const { directories } = get();
|
|
let dirState = directories.get(directory);
|
|
|
|
if (!dirState) {
|
|
dirState = createEmptyDirectoryState();
|
|
}
|
|
|
|
if (!silent) {
|
|
set({ isLoadingStatus: true });
|
|
}
|
|
|
|
let statusChanged = false;
|
|
|
|
try {
|
|
const isRepo = await git.checkIsGitRepository(directory);
|
|
|
|
if (!isRepo) {
|
|
const newDirectories = new Map(directories);
|
|
newDirectories.set(directory, {
|
|
...dirState,
|
|
isGitRepo: false,
|
|
status: null,
|
|
lastStatusFetch: Date.now(),
|
|
});
|
|
set({ directories: newDirectories, isLoadingStatus: false });
|
|
return false;
|
|
}
|
|
|
|
const newStatus = await git.getGitStatus(directory);
|
|
|
|
if (hasStatusChanged(dirState.status, newStatus)) {
|
|
statusChanged = true;
|
|
const newDirectories = new Map(get().directories);
|
|
const currentDirState = newDirectories.get(directory) ?? createEmptyDirectoryState();
|
|
|
|
const changedPaths = getChangedFilePaths(currentDirState.status, newStatus);
|
|
|
|
const oldPaths = new Set((currentDirState.status?.files ?? []).map((f) => f.path));
|
|
const newPaths = new Set((newStatus.files ?? []).map((f) => f.path));
|
|
|
|
const nextDiffCache = new Map(currentDirState.diffCache);
|
|
|
|
// Drop cache for removed files
|
|
for (const oldPath of oldPaths) {
|
|
if (!newPaths.has(oldPath)) {
|
|
nextDiffCache.delete(oldPath);
|
|
}
|
|
}
|
|
|
|
// Drop cache for files whose state/content changed
|
|
for (const filePath of changedPaths) {
|
|
nextDiffCache.delete(filePath);
|
|
}
|
|
|
|
const hasFileContentChange = changedPaths.size > 0;
|
|
|
|
newDirectories.set(directory, {
|
|
...currentDirState,
|
|
isGitRepo: true,
|
|
status: newStatus,
|
|
diffCache: nextDiffCache,
|
|
lastStatusFetch: Date.now(),
|
|
lastStatusChange: hasFileContentChange ? Date.now() : currentDirState.lastStatusChange,
|
|
});
|
|
set({ directories: newDirectories });
|
|
} else {
|
|
|
|
const newDirectories = new Map(get().directories);
|
|
const currentDirState = newDirectories.get(directory) ?? createEmptyDirectoryState();
|
|
newDirectories.set(directory, {
|
|
...currentDirState,
|
|
isGitRepo: true,
|
|
lastStatusFetch: Date.now(),
|
|
lastStatusChange: currentDirState.lastStatusChange,
|
|
});
|
|
set({ directories: newDirectories });
|
|
}
|
|
} catch (error) {
|
|
console.error('Failed to fetch git status:', error);
|
|
} finally {
|
|
if (!silent) {
|
|
set({ isLoadingStatus: false });
|
|
}
|
|
}
|
|
|
|
return statusChanged;
|
|
},
|
|
|
|
fetchBranches: async (directory, git) => {
|
|
set({ isLoadingBranches: true });
|
|
|
|
try {
|
|
const branches = await git.getGitBranches(directory);
|
|
const newDirectories = new Map(get().directories);
|
|
const dirState = newDirectories.get(directory) ?? createEmptyDirectoryState();
|
|
newDirectories.set(directory, { ...dirState, branches });
|
|
set({ directories: newDirectories });
|
|
} catch (error) {
|
|
console.error('Failed to fetch git branches:', error);
|
|
} finally {
|
|
set({ isLoadingBranches: false });
|
|
}
|
|
},
|
|
|
|
fetchLog: async (directory, git, maxCount) => {
|
|
const { directories } = get();
|
|
const dirState = directories.get(directory);
|
|
const effectiveMaxCount = maxCount ?? dirState?.logMaxCount ?? 25;
|
|
|
|
set({ isLoadingLog: true });
|
|
|
|
try {
|
|
const log = await git.getGitLog(directory, { maxCount: effectiveMaxCount });
|
|
const newDirectories = new Map(get().directories);
|
|
const currentDirState = newDirectories.get(directory) ?? createEmptyDirectoryState();
|
|
newDirectories.set(directory, {
|
|
...currentDirState,
|
|
log,
|
|
lastLogFetch: Date.now(),
|
|
logMaxCount: effectiveMaxCount,
|
|
});
|
|
set({ directories: newDirectories });
|
|
} catch (error) {
|
|
console.error('Failed to fetch git log:', error);
|
|
} finally {
|
|
set({ isLoadingLog: false });
|
|
}
|
|
},
|
|
|
|
fetchIdentity: async (directory, git) => {
|
|
set({ isLoadingIdentity: true });
|
|
|
|
try {
|
|
const identity = await git.getCurrentGitIdentity(directory);
|
|
const newDirectories = new Map(get().directories);
|
|
const dirState = newDirectories.get(directory) ?? createEmptyDirectoryState();
|
|
newDirectories.set(directory, { ...dirState, identity });
|
|
set({ directories: newDirectories });
|
|
} catch (error) {
|
|
console.error('Failed to fetch git identity:', error);
|
|
} finally {
|
|
set({ isLoadingIdentity: false });
|
|
}
|
|
},
|
|
|
|
fetchAll: async (directory, git, options = {}) => {
|
|
const { directories } = get();
|
|
let dirState = directories.get(directory);
|
|
|
|
if (!dirState) {
|
|
dirState = createEmptyDirectoryState();
|
|
const newDirectories = new Map(directories);
|
|
newDirectories.set(directory, dirState);
|
|
set({ directories: newDirectories });
|
|
}
|
|
|
|
const { force = false } = options;
|
|
const now = Date.now();
|
|
|
|
await get().fetchStatus(directory, git);
|
|
|
|
const updatedDirState = get().directories.get(directory);
|
|
if (!updatedDirState?.isGitRepo) return;
|
|
|
|
await get().fetchBranches(directory, git);
|
|
|
|
const logAge = now - (updatedDirState.lastLogFetch || 0);
|
|
if (force || logAge > LOG_STALE_THRESHOLD || !updatedDirState.log) {
|
|
await get().fetchLog(directory, git);
|
|
}
|
|
|
|
await get().fetchIdentity(directory, git);
|
|
|
|
// Pre-fetch all diffs so they're ready when user opens Diff tab
|
|
void get().fetchAllDiffs(directory, git);
|
|
},
|
|
|
|
getDiff: (directory, filePath) => {
|
|
const dirState = get().directories.get(directory);
|
|
return dirState?.diffCache.get(filePath) ?? null;
|
|
},
|
|
|
|
setDiff: (directory, filePath, diff) => {
|
|
const newDirectories = new Map(get().directories);
|
|
const dirState = newDirectories.get(directory) ?? createEmptyDirectoryState();
|
|
const newDiffCache = new Map(dirState.diffCache);
|
|
newDiffCache.set(filePath, { ...diff, fetchedAt: Date.now() });
|
|
newDirectories.set(directory, { ...dirState, diffCache: newDiffCache });
|
|
set({ directories: newDirectories });
|
|
},
|
|
|
|
clearDiffCache: (directory) => {
|
|
const newDirectories = new Map(get().directories);
|
|
const dirState = newDirectories.get(directory);
|
|
if (dirState) {
|
|
newDirectories.set(directory, { ...dirState, diffCache: new Map() });
|
|
set({ directories: newDirectories });
|
|
}
|
|
},
|
|
|
|
fetchAllDiffs: async (directory, git) => {
|
|
const dirState = get().directories.get(directory);
|
|
if (!dirState?.status?.files || dirState.status.files.length === 0) return;
|
|
|
|
const files = dirState.status.files;
|
|
|
|
// Find files that need fetching (no cache)
|
|
const filesToFetch = files.filter((file) => !dirState.diffCache.has(file.path));
|
|
|
|
const limitedFilesToFetch = filesToFetch.slice(0, DIFF_PREFETCH_MAX_FILES);
|
|
if (limitedFilesToFetch.length === 0) return;
|
|
|
|
let nextIndex = 0;
|
|
const results: Array<{ path: string; diff: { original: string; modified: string } }> = [];
|
|
|
|
const takeNext = () => {
|
|
const current = nextIndex;
|
|
nextIndex += 1;
|
|
return current < limitedFilesToFetch.length ? limitedFilesToFetch[current] : null;
|
|
};
|
|
|
|
const fetchWithTimeout = async (filePath: string) => {
|
|
const fetchPromise = git.getGitFileDiff(directory, { path: filePath });
|
|
const timeoutPromise = new Promise<never>((_, reject) => {
|
|
setTimeout(() => reject(new Error(`Timed out after ${DIFF_PREFETCH_TIMEOUT_MS}ms`)), DIFF_PREFETCH_TIMEOUT_MS);
|
|
});
|
|
const response = await Promise.race([fetchPromise, timeoutPromise]);
|
|
return {
|
|
path: filePath,
|
|
diff: { original: response.original ?? '', modified: response.modified ?? '' },
|
|
};
|
|
};
|
|
|
|
const worker = async () => {
|
|
for (;;) {
|
|
const next = takeNext();
|
|
if (!next) return;
|
|
try {
|
|
results.push(await fetchWithTimeout(next.path));
|
|
} catch {
|
|
// Ignore individual failures/timeouts during prefetch.
|
|
}
|
|
}
|
|
};
|
|
|
|
const workerCount = Math.min(DIFF_PREFETCH_CONCURRENCY, limitedFilesToFetch.length);
|
|
await Promise.allSettled(Array.from({ length: workerCount }, () => worker()));
|
|
|
|
// Update diff cache with results
|
|
const newDirectories = new Map(get().directories);
|
|
const currentDirState = newDirectories.get(directory);
|
|
if (!currentDirState) return;
|
|
|
|
const newDiffCache = new Map(currentDirState.diffCache);
|
|
const now = Date.now();
|
|
|
|
results.forEach((result) => {
|
|
newDiffCache.set(result.path, {
|
|
...result.diff,
|
|
fetchedAt: now
|
|
});
|
|
});
|
|
|
|
newDirectories.set(directory, { ...currentDirState, diffCache: newDiffCache });
|
|
set({ directories: newDirectories });
|
|
},
|
|
|
|
setLogMaxCount: (directory, maxCount) => {
|
|
const newDirectories = new Map(get().directories);
|
|
const dirState = newDirectories.get(directory) ?? createEmptyDirectoryState();
|
|
newDirectories.set(directory, { ...dirState, logMaxCount: maxCount });
|
|
set({ directories: newDirectories });
|
|
},
|
|
|
|
startPolling: (git) => {
|
|
const { pollIntervalId } = get();
|
|
if (pollIntervalId) return;
|
|
|
|
const schedulePoll = () => {
|
|
const { currentPollInterval } = get();
|
|
const timeoutId = setTimeout(async () => {
|
|
// Skip if tab not visible
|
|
if (typeof document !== 'undefined' && document.hidden) {
|
|
set({ pollIntervalId: schedulePoll() });
|
|
return;
|
|
}
|
|
|
|
const { activeDirectory } = get();
|
|
if (!activeDirectory) {
|
|
set({ pollIntervalId: schedulePoll() });
|
|
return;
|
|
}
|
|
|
|
const statusChanged = await get().fetchStatus(activeDirectory, git, { silent: true });
|
|
if (statusChanged) {
|
|
await get().fetchLog(activeDirectory, git);
|
|
// Pre-fetch all diffs so they're ready when user opens Diff tab
|
|
void get().fetchAllDiffs(activeDirectory, git);
|
|
// Reset to base interval on changes
|
|
set({ currentPollInterval: GIT_POLL_BASE_INTERVAL });
|
|
} else {
|
|
// Backoff when no changes
|
|
const newInterval = Math.min(
|
|
currentPollInterval + GIT_POLL_BACKOFF_STEP,
|
|
GIT_POLL_MAX_INTERVAL
|
|
);
|
|
set({ currentPollInterval: newInterval });
|
|
}
|
|
|
|
// Schedule next poll
|
|
const { pollIntervalId: currentId } = get();
|
|
if (currentId !== null) {
|
|
set({ pollIntervalId: schedulePoll() });
|
|
}
|
|
}, currentPollInterval);
|
|
|
|
return timeoutId;
|
|
};
|
|
|
|
set({ pollIntervalId: schedulePoll(), currentPollInterval: GIT_POLL_BASE_INTERVAL });
|
|
},
|
|
|
|
stopPolling: () => {
|
|
const { pollIntervalId } = get();
|
|
if (pollIntervalId) {
|
|
clearTimeout(pollIntervalId);
|
|
set({ pollIntervalId: null, currentPollInterval: GIT_POLL_BASE_INTERVAL });
|
|
}
|
|
},
|
|
|
|
refresh: async (git, options = {}) => {
|
|
const { activeDirectory } = get();
|
|
if (!activeDirectory) return;
|
|
await get().fetchAll(activeDirectory, git, options);
|
|
},
|
|
}),
|
|
{ name: 'git-store' }
|
|
)
|
|
);
|
|
|
|
export const useGitStatus = (directory: string | null) => {
|
|
return useGitStore((state) => {
|
|
if (!directory) return null;
|
|
return state.directories.get(directory)?.status ?? null;
|
|
});
|
|
};
|
|
|
|
export const useGitBranches = (directory: string | null) => {
|
|
return useGitStore((state) => {
|
|
if (!directory) return null;
|
|
return state.directories.get(directory)?.branches ?? null;
|
|
});
|
|
};
|
|
|
|
export const useGitLog = (directory: string | null) => {
|
|
return useGitStore((state) => {
|
|
if (!directory) return null;
|
|
return state.directories.get(directory)?.log ?? null;
|
|
});
|
|
};
|
|
|
|
export const useGitIdentity = (directory: string | null) => {
|
|
return useGitStore((state) => {
|
|
if (!directory) return null;
|
|
return state.directories.get(directory)?.identity ?? null;
|
|
});
|
|
};
|
|
|
|
export const useIsGitRepo = (directory: string | null) => {
|
|
return useGitStore((state) => {
|
|
if (!directory) return null;
|
|
return state.directories.get(directory)?.isGitRepo ?? null;
|
|
});
|
|
};
|
|
|
|
export const useGitFileCount = (directory: string | null) => {
|
|
return useGitStore((state) => {
|
|
if (!directory) return 0;
|
|
return state.directories.get(directory)?.status?.files?.length ?? 0;
|
|
});
|
|
};
|