gitforest 0.1.0

package/src/hooks/useUnifiedRepos.ts

@@ -0,0 +1,317 @@
+import { useEffect, useCallback, useRef } from "react";
+import { useStore } from "../state/store.tsx";
+import {
+  setProjects,
+  setLoading,
+  setError,
+  setMessage,
+  startAction,
+  endAction,
+  updateProgress,
+} from "../state/actions.ts";
+import { sortProjects, scanWithCache } from "../scanner/index.ts";
+import { cloneGitHubRepo, createUnifiedView, fetchUnifiedRepos } from "../github/unified.ts";
+import { fetchGitHubReposWithCache, loadGitHubReposFromCache } from "../github/cache.ts";
+import type { GitforestConfig, UnifiedRepo, Project, GitHubRepoInfo } from "../types/index.ts";
+import { errorToString } from "../utils/errors.ts";
+
+export function useUnifiedRepos(config: GitforestConfig) {
+  const { state, dispatch } = useStore();
+  const { sortBy, sortDirection } = state;
+  
+  // Track if we've done initial load
+  const hasLoadedRef = useRef(false);
+  const isRefreshingRef = useRef(false);
+
+  /**
+   * Load cached data immediately without showing loading state
+   * Returns true if cache was available
+   */
+  const loadFromCacheInstantly = useCallback(async (): Promise<{
+    localProjects: Project[];
+    githubRepos: GitHubRepoInfo[];
+    hasCachedData: boolean;
+  }> => {
+    try {
+      // Load both caches in parallel
+      const [localProjects, githubRepos] = await Promise.all([
+        scanWithCache(config),
+        loadGitHubReposFromCache(),
+      ]);
+
+      const hasCachedData = localProjects.length > 0;
+
+      if (hasCachedData) {
+        // Show cached data immediately
+        const sorted = sortProjects(localProjects, sortBy, sortDirection);
+        dispatch(setProjects(sorted));
+
+        // Create unified view with cached GitHub data
+        const unified = createUnifiedView(localProjects, githubRepos);
+        dispatch({ type: "SET_GITHUB_REPOS", payload: githubRepos });
+        dispatch({ type: "SET_UNIFIED_REPOS", payload: unified });
+        
+        // Don't show loading state since we have data
+        dispatch(setLoading(false));
+      }
+
+      return { localProjects, githubRepos, hasCachedData };
+    } catch (error) {
+      console.error("Failed to load from cache:", error);
+      return { localProjects: [], githubRepos: [], hasCachedData: false };
+    }
+  }, [config, dispatch, sortBy, sortDirection]);
+
+  /**
+   * Refresh data in background without blocking UI
+   */
+  const refreshInBackground = useCallback(async (
+    existingLocalProjects: Project[],
+    existingGithubRepos: GitHubRepoInfo[]
+  ) => {
+    // Prevent concurrent refreshes
+    if (isRefreshingRef.current) return;
+    isRefreshingRef.current = true;
+    
+    // Only raise refreshing flag if the run lasts beyond a small delay
+    let refreshTimer: ReturnType<typeof setTimeout> | null = null;
+    refreshTimer = setTimeout(() => {
+      dispatch({ type: "SET_REFRESHING", payload: true });
+    }, 400);
+    try {
+      // Refresh local projects and GitHub repos in parallel
+      const [freshLocalProjects, githubResult] = await Promise.all([
+        scanWithCache(config, { forceRefresh: true }),
+        fetchGitHubReposWithCache({
+          includeArchived: false,
+          includeForks: true,
+          includeOrgs: true,
+        }, 0), // TTL=0 forces fresh fetch
+      ]);
+
+      const freshSorted = sortProjects(freshLocalProjects, sortBy, sortDirection);
+      dispatch(setProjects(freshSorted));
+
+      // Update unified view
+      const freshUnified = createUnifiedView(freshLocalProjects, githubResult.repos);
+      dispatch({ type: "SET_GITHUB_REPOS", payload: githubResult.repos });
+      dispatch({ type: "SET_UNIFIED_REPOS", payload: freshUnified });
+
+      if (githubResult.error) {
+        dispatch({ type: "SET_GITHUB_ERROR", payload: githubResult.error });
+      }
+
+      // Show subtle refresh complete message
+      const localCount = freshUnified.filter(r => r.source === "local" || r.source === "both").length;
+      const githubOnlyCount = freshUnified.filter(r => r.source === "github").length;
+      dispatch(setMessage(`${localCount} local, ${githubOnlyCount} GitHub repos`));
+
+    } catch (error) {
+      console.error("Background refresh failed:", error);
+      // Don't show error to user since we have cached data
+    } finally {
+      if (refreshTimer) {
+        clearTimeout(refreshTimer);
+      }
+      dispatch({ type: "SET_REFRESHING", payload: false });
+      isRefreshingRef.current = false;
+    }
+  }, [config, dispatch, sortBy, sortDirection]);
+
+  /**
+   * Main load function - smart loading with cache-first strategy
+   */
+  const loadUnifiedRepos = useCallback(async () => {
+    // If we already have data, don't show loading state
+    const hasExistingData = state.unifiedRepos.length > 0;
+    
+    if (!hasExistingData) {
+      dispatch(setLoading(true));
+    }
+    dispatch({ type: "SET_GITHUB_ERROR", payload: null });
+
+    try {
+      // Step 1: Load from cache instantly
+      const { localProjects, githubRepos, hasCachedData } = await loadFromCacheInstantly();
+
+      if (hasCachedData) {
+        // We have cached data - refresh in background
+        hasLoadedRef.current = true;
+        
+        // Check if cache is stale and needs refresh
+        const now = Date.now();
+        const isLocalStale = localProjects.some(p => 
+          now - p.lastScanned.getTime() > config.cache.ttlSeconds * 1000
+        );
+        
+        if (isLocalStale) {
+          // Refresh in background without blocking
+          refreshInBackground(localProjects, githubRepos);
+        }
+      } else {
+        // No cache - do full load with loading indicator
+        dispatch(setLoading(true));
+        dispatch({ type: "SET_GITHUB_LOADING", payload: true });
+
+        const [freshLocalProjects, githubResult] = await Promise.all([
+          scanWithCache(config, { forceRefresh: true }),
+          fetchGitHubReposWithCache({
+            includeArchived: false,
+            includeForks: true,
+            includeOrgs: true,
+          }, config.cache.githubTtlSeconds),
+        ]);
+
+        const sorted = sortProjects(freshLocalProjects, sortBy, sortDirection);
+        dispatch(setProjects(sorted));
+
+        const unified = createUnifiedView(freshLocalProjects, githubResult.repos);
+        dispatch({ type: "SET_GITHUB_REPOS", payload: githubResult.repos });
+        dispatch({ type: "SET_UNIFIED_REPOS", payload: unified });
+
+        if (githubResult.error) {
+          dispatch({ type: "SET_GITHUB_ERROR", payload: githubResult.error });
+        }
+
+        const localCount = unified.filter(r => r.source === "local" || r.source === "both").length;
+        const githubOnlyCount = unified.filter(r => r.source === "github").length;
+        dispatch(setMessage(`Found ${localCount} local, ${githubOnlyCount} GitHub-only repos`));
+
+        hasLoadedRef.current = true;
+      }
+    } catch (error) {
+      dispatch(setError(errorToString(error)));
+    } finally {
+      dispatch(setLoading(false));
+      dispatch({ type: "SET_GITHUB_LOADING", payload: false });
+    }
+  }, [config, dispatch, sortBy, sortDirection, state.unifiedRepos.length, loadFromCacheInstantly, refreshInBackground]);
+
+  // Refresh only GitHub repos (faster, doesn't rescan filesystem)
+  // Uses existing local projects to avoid re-scanning
+  const refreshGitHub = useCallback(async () => {
+    // Don't show blocking loading state if we have data
+    const hasData = state.githubRepos.length > 0;
+    if (!hasData) {
+      dispatch({ type: "SET_GITHUB_LOADING", payload: true });
+    } else {
+      dispatch({ type: "SET_REFRESHING", payload: true });
+    }
+    dispatch({ type: "SET_GITHUB_ERROR", payload: null });
+
+    try {
+      // Force fresh fetch (TTL=0)
+      const { repos: freshGithubRepos, error } = await fetchGitHubReposWithCache({
+        includeArchived: false,
+        includeForks: true,
+        includeOrgs: true,
+      }, 0);
+
+      // Update unified view with fresh GitHub data
+      const unified = createUnifiedView(state.projects, freshGithubRepos);
+      dispatch({ type: "SET_GITHUB_REPOS", payload: freshGithubRepos });
+      dispatch({ type: "SET_UNIFIED_REPOS", payload: unified });
+      
+      if (error) {
+        dispatch({ type: "SET_GITHUB_ERROR", payload: error });
+      }
+    } catch (error) {
+      dispatch({ type: "SET_GITHUB_ERROR", payload: errorToString(error) });
+    } finally {
+      dispatch({ type: "SET_GITHUB_LOADING", payload: false });
+      dispatch({ type: "SET_REFRESHING", payload: false });
+    }
+  }, [state.projects, state.githubRepos.length, dispatch]);
+
+  // Clone a GitHub repo
+  const cloneRepo = useCallback(async (
+    repo: UnifiedRepo,
+    targetDir: string,
+    useSSH: boolean = true
+  ) => {
+    if (!repo.github) {
+      return { success: false, error: "No GitHub info available" };
+    }
+
+    dispatch({ type: "CLONE_REPO_START", payload: repo.id });
+    dispatch(startAction(`Cloning ${repo.name}`));
+
+    const result = await cloneGitHubRepo(repo, targetDir, useSSH);
+
+    dispatch(endAction());
+
+    if (result.success && result.path) {
+      dispatch({ type: "CLONE_REPO_COMPLETE", payload: { id: repo.id, localPath: result.path } });
+      dispatch(setMessage(`Cloned ${repo.name} to ${result.path}`));
+      // Refresh to show the newly cloned repo
+      await loadUnifiedRepos();
+    } else {
+      dispatch({ type: "CLONE_REPO_FAILED", payload: { id: repo.id, error: result.error || "Clone failed" } });
+      dispatch(setError(`Failed to clone ${repo.name}: ${result.error}`));
+    }
+
+    return result;
+  }, [dispatch, loadUnifiedRepos]);
+
+  // Batch clone multiple repos
+  const batchClone = useCallback(async (
+    repos: UnifiedRepo[],
+    targetDir: string,
+    useSSH: boolean = true
+  ) => {
+    const githubRepos = repos.filter(r => r.source === "github" && r.github);
+    
+    if (githubRepos.length === 0) {
+      dispatch(setMessage("No GitHub-only repos to clone"));
+      return { successful: 0, failed: 0 };
+    }
+
+    dispatch(startAction(`Cloning ${githubRepos.length} repos`));
+
+    let successful = 0;
+    let failed = 0;
+
+    for (let i = 0; i < githubRepos.length; i++) {
+      const repo = githubRepos[i]!;
+      dispatch(updateProgress(i + 1, githubRepos.length));
+      
+      const result = await cloneGitHubRepo(repo, targetDir, useSSH);
+      
+      if (result.success) {
+        successful++;
+      } else {
+        failed++;
+      }
+    }
+
+    dispatch(endAction());
+    dispatch(setMessage(`Cloned ${successful}/${githubRepos.length} repos`));
+
+    // Refresh to show newly cloned repos
+    await loadUnifiedRepos();
+
+    return { successful, failed };
+  }, [dispatch, loadUnifiedRepos]);
+
+  // Background refresh - delegates to refreshInBackground
+  const backgroundRefresh = useCallback(async () => {
+    // Don't refresh if we're already loading or during an action
+    if (state.isLoading || state.actionInProgress || isRefreshingRef.current) {
+      return;
+    }
+    await refreshInBackground(state.projects, state.githubRepos);
+  }, [state.isLoading, state.actionInProgress, state.projects, state.githubRepos, refreshInBackground]);
+
+  // Load on mount
+  useEffect(() => {
+    loadUnifiedRepos();
+  }, []);
+
+  return { 
+    loadUnifiedRepos, 
+    refreshGitHub, 
+    cloneRepo,
+    batchClone,
+    backgroundRefresh,
+  };
+}