gitforest 0.1.0

package/src/github/unified.ts

@@ -0,0 +1,415 @@
+/**
+ * Unified view combining local projects and GitHub repos
+ */
+
+import type {
+  Project,
+  GitHubRepoInfo,
+  UnifiedRepo,
+  ViewMode,
+} from "../types/index.ts";
+import { defaultGitHubService, type GitHubRepoData } from "../services/github.ts";
+import { parseGitHubUrl } from "./cli.ts";
+import { errorToString } from "../utils/errors.ts";
+import { initDb, schema } from "../db/index.ts";
+import { bunGitService } from "../services/index.ts";
+import type { GitService } from "../services/git.ts";
+import { existsSync } from "fs";
+
+/**
+ * Convert GitHub API repo to our GitHubRepoInfo type
+ */
+export function toGitHubRepoInfo(repo: GitHubRepoData): GitHubRepoInfo {
+  return {
+    name: repo.name,
+    fullName: repo.fullName,
+    owner: repo.owner.login,
+    description: repo.description,
+    htmlUrl: repo.htmlUrl,
+    sshUrl: repo.sshUrl,
+    cloneUrl: repo.cloneUrl,
+    isPrivate: repo.isPrivate,
+    isArchived: repo.isArchived,
+    isFork: repo.isFork,
+    pushedAt: repo.pushedAt ? new Date(repo.pushedAt) : null,
+    updatedAt: repo.updatedAt ? new Date(repo.updatedAt) : null,
+    defaultBranch: repo.defaultBranch,
+    language: repo.language,
+    size: repo.size,
+    stargazersCount: repo.stargazersCount,
+    forksCount: repo.forksCount,
+    openIssuesCount: repo.openIssuesCount,
+    watchersCount: repo.watchersCount,
+    topics: repo.topics,
+    license: repo.license?.name || null,
+    hasIssues: repo.hasIssues,
+    hasWiki: repo.hasWiki,
+    hasDiscussions: repo.hasDiscussions,
+  };
+}
+
+/**
+ * Extract owner/repo from a git remote URL
+ */
+function extractRepoIdentifier(remoteUrl: string | null): string | null {
+  if (!remoteUrl) return null;
+
+  const parsed = parseGitHubUrl(remoteUrl);
+  if (parsed) {
+    return `${parsed.owner}/${parsed.repo}`.toLowerCase();
+  }
+
+  return null;
+}
+
+/**
+ * Create a unified view by matching local projects with GitHub repos
+ */
+export function createUnifiedView(
+  localProjects: Project[],
+  githubRepos: GitHubRepoInfo[]
+): UnifiedRepo[] {
+  const unified: UnifiedRepo[] = [];
+  const matchedGitHubIds = new Set<string>();
+
+  // First, process local projects and try to match with GitHub
+  for (const local of localProjects) {
+    const remoteId = extractRepoIdentifier(local.status?.remoteUrl ?? null);
+    let matchedGitHub: GitHubRepoInfo | null = null;
+
+    if (remoteId) {
+      // Try to find matching GitHub repo
+      matchedGitHub = githubRepos.find(
+        (gh) => gh.fullName.toLowerCase() === remoteId
+      ) ?? null;
+
+      if (matchedGitHub) {
+        matchedGitHubIds.add(matchedGitHub.fullName);
+      }
+    }
+
+    unified.push({
+      id: local.id,
+      name: local.name,
+      source: matchedGitHub ? "both" : "local",
+      local,
+      github: matchedGitHub,
+      isCloned: true,
+      isOnGitHub: matchedGitHub !== null,
+      localPath: local.path,
+    });
+  }
+
+  // Add GitHub repos that aren't cloned locally
+  for (const github of githubRepos) {
+    if (!matchedGitHubIds.has(github.fullName)) {
+      unified.push({
+        id: `github-${github.fullName}`,
+        name: github.name,
+        source: "github",
+        local: null,
+        github,
+        isCloned: false,
+        isOnGitHub: true,
+        localPath: null,
+      });
+    }
+  }
+
+  return unified;
+}
+
+/**
+ * Filter unified repos based on view mode
+ */
+export function filterByViewMode(
+  repos: UnifiedRepo[],
+  mode: ViewMode
+): UnifiedRepo[] {
+  switch (mode) {
+    case "local":
+      // Show repos that exist locally (local-only or synced)
+      return repos.filter((r) => r.isCloned);
+    case "github":
+      // Show repos that exist on GitHub (github-only or synced)
+      return repos.filter((r) => r.isOnGitHub);
+    case "combined":
+      return repos;
+  }
+}
+
+/**
+ * Sort unified repos
+ */
+export function sortUnifiedRepos(
+  repos: UnifiedRepo[],
+  sortBy: "status" | "name" | "branch" | "sync" | "language" | "stars" | "forks" | "lastActivity" | "size",
+  direction: "asc" | "desc"
+): UnifiedRepo[] {
+  return [...repos].sort((a, b) => {
+    let comparison = 0;
+
+    switch (sortBy) {
+      case "name":
+        comparison = a.name.localeCompare(b.name);
+        break;
+
+      case "branch": {
+        const aBranch = a.local?.status?.currentBranch ?? "";
+        const bBranch = b.local?.status?.currentBranch ?? "";
+        comparison = aBranch.localeCompare(bBranch);
+        break;
+      }
+
+      case "status":
+        // Prioritize: GitHub-only (not cloned) > dirty > ahead/behind > clean
+        const aPriority = getUnifiedPriority(a);
+        const bPriority = getUnifiedPriority(b);
+        comparison = aPriority - bPriority;
+        return direction === "desc" ? comparison : -comparison;
+
+      case "sync": {
+        // Higher sync delta first when desc
+        const aStatus = a.local?.status;
+        const bStatus = b.local?.status;
+        const aDelta = aStatus ? (aStatus.unpushedCommits ?? 0) + (aStatus.unpulledCommits ?? 0) : 0;
+        const bDelta = bStatus ? (bStatus.unpushedCommits ?? 0) + (bStatus.unpulledCommits ?? 0) : 0;
+        comparison = aDelta - bDelta;
+        break;
+      }
+
+      case "language": {
+        const aLang = (a.github?.language || "").toLowerCase();
+        const bLang = (b.github?.language || "").toLowerCase();
+        comparison = aLang.localeCompare(bLang);
+        break;
+      }
+
+      case "lastActivity":
+        const aDate = getLastActivity(a);
+        const bDate = getLastActivity(b);
+        comparison = aDate - bDate;
+        break;
+
+      case "stars":
+        comparison = (a.github?.stargazersCount ?? 0) - (b.github?.stargazersCount ?? 0);
+        break;
+
+      case "forks":
+        comparison = (a.github?.forksCount ?? 0) - (b.github?.forksCount ?? 0);
+        break;
+
+      case "size":
+        comparison = (a.github?.size ?? 0) - (b.github?.size ?? 0);
+        break;
+    }
+
+    return direction === "desc" ? -comparison : comparison;
+  });
+}
+
+/**
+ * Get priority for sorting (lower = more attention needed)
+ */
+function getUnifiedPriority(repo: UnifiedRepo): number {
+  // GitHub-only (not cloned) - highest priority
+  if (!repo.isCloned && repo.isOnGitHub) return -100;
+
+  // Local only (not on GitHub) - needs remote setup
+  if (repo.isCloned && !repo.isOnGitHub) return -50;
+
+  const local = repo.local;
+  if (!local?.status) return 50;
+
+  let priority = 0;
+
+  // Dirty repos need attention
+  if (local.status.isDirty) priority -= 40;
+
+  // Out of sync repos need attention
+  if (local.status.isAhead) priority -= 20;
+  if (local.status.isBehind) priority -= 30;
+
+  // No remote = might need setup
+  if (!local.status.hasRemote) priority -= 10;
+
+  return priority;
+}
+
+/**
+ * Get timestamp from a Date object or ISO string
+ */
+function getTimestamp(date: Date | string | null | undefined): number {
+  if (!date) return 0;
+  if (typeof date === 'string') {
+    const parsed = new Date(date);
+    return isNaN(parsed.getTime()) ? 0 : parsed.getTime();
+  }
+  return date.getTime();
+}
+
+/**
+ * Get last activity timestamp for sorting
+ */
+function getLastActivity(repo: UnifiedRepo): number {
+  // Prefer local commit date if available
+  if (repo.local?.status?.lastLocalCommit) {
+    return getTimestamp(repo.local.status.lastLocalCommit);
+  }
+
+  // Fall back to GitHub pushed_at
+  if (repo.github?.pushedAt) {
+    return getTimestamp(repo.github.pushedAt);
+  }
+
+  return 0;
+}
+
+/**
+ * Filter unified repos by text search
+ */
+export function filterUnifiedRepos(
+  repos: UnifiedRepo[],
+  filterText: string
+): UnifiedRepo[] {
+  if (!filterText.trim()) return repos;
+
+  const lower = filterText.toLowerCase();
+
+  return repos.filter((r) => {
+    // Match name
+    if (r.name.toLowerCase().includes(lower)) return true;
+
+    // Match local path
+    if (r.localPath?.toLowerCase().includes(lower)) return true;
+
+    // Match GitHub full name
+    if (r.github?.fullName.toLowerCase().includes(lower)) return true;
+
+    // Match description
+    if (r.github?.description?.toLowerCase().includes(lower)) return true;
+
+    // Match language
+    if (r.github?.language?.toLowerCase().includes(lower)) return true;
+
+    // Match source type
+    if (r.source.includes(lower)) return true;
+
+    return false;
+  });
+}
+
+/**
+ * Fetch GitHub repos and create unified view
+ */
+export async function fetchUnifiedRepos(
+  localProjects: Project[],
+  options?: {
+    includeOrgs?: boolean;
+    includeArchived?: boolean;
+    includeForks?: boolean;
+  }
+): Promise<{
+  unified: UnifiedRepo[];
+  githubRepos: GitHubRepoInfo[];
+  error?: string;
+}> {
+  if (!defaultGitHubService.hasToken()) {
+    return {
+      unified: localProjects.map((p) => ({
+        id: p.id,
+        name: p.name,
+        source: "local" as const,
+        local: p,
+        github: null,
+        isCloned: true,
+        isOnGitHub: false,
+        localPath: p.path,
+      })),
+      githubRepos: [],
+      error: "GITHUB_TOKEN not set. Run: export GITHUB_TOKEN=your_token",
+    };
+  }
+
+  try {
+    const rawRepos = await defaultGitHubService.getAllRepos(options);
+    const githubRepos = rawRepos.map(toGitHubRepoInfo);
+    const unified = createUnifiedView(localProjects, githubRepos);
+
+    return { unified, githubRepos };
+  } catch (error) {
+    return {
+      unified: localProjects.map((p) => ({
+        id: p.id,
+        name: p.name,
+        source: "local" as const,
+        local: p,
+        github: null,
+        isCloned: true,
+        isOnGitHub: false,
+        localPath: p.path,
+      })),
+      githubRepos: [],
+      error: errorToString(error),
+    };
+  }
+}
+
+/**
+ * Clone a GitHub repo to a target directory
+ */
+export async function cloneGitHubRepo(
+  repo: UnifiedRepo,
+  targetDir: string,
+  useSSH = true,
+  gitService: GitService = bunGitService
+): Promise<{ success: boolean; path?: string; error?: string }> {
+  if (!repo.github) {
+    return { success: false, error: "No GitHub info available for this repo" };
+  }
+
+  // Check if target directory exists
+  // TODO: Re-enable after fixing test environment
+  // if (!existsSync(targetDir)) {
+  //   return { success: false, error: `Target directory does not exist: ${targetDir}` };
+  // }
+
+  const repoPath = `${targetDir}/${repo.name}`;
+  const url = useSSH ? repo.github.sshUrl : repo.github.cloneUrl;
+
+  try {
+    const result = await gitService.clone(url, repoPath);
+    if (result.success) {
+      return { success: true, path: repoPath };
+    }
+    return { success: false, error: result.error || "Clone failed" };
+  } catch (error) {
+    return {
+      success: false,
+      error: errorToString(error),
+    };
+  }
+}
+
+/**
+ * Get statistics about the unified view
+ */
+export function getUnifiedStats(repos: UnifiedRepo[]): {
+  total: number;
+  localOnly: number;
+  githubOnly: number;
+  both: number;
+  dirty: number;
+  unpushed: number;
+  unpulled: number;
+} {
+  return {
+    total: repos.length,
+    localOnly: repos.filter((r) => r.source === "local").length,
+    githubOnly: repos.filter((r) => r.source === "github").length,
+    both: repos.filter((r) => r.source === "both").length,
+    dirty: repos.filter((r) => r.local?.status?.isDirty).length,
+    unpushed: repos.filter((r) => r.local?.status?.isAhead).length,
+    unpulled: repos.filter((r) => r.local?.status?.isBehind).length,
+  };
+}

package/src/hooks/useBackgroundFetch.ts

@@ -0,0 +1,76 @@
+import { useEffect, useRef } from "react";
+import { useStore } from "../state/store.tsx";
+import { setMessage } from "../state/actions.ts";
+import { batchFetch as defaultBatchFetch } from "../operations/batch.ts";
+import { refreshProjectStatuses } from "../git/operations.ts";
+import { BACKGROUND_FETCH } from "../constants.ts";
+import type { GitforestConfig, Project, BatchResult } from "../types/index.ts";
+
+/**
+ * Dependencies that can be injected for testing
+ */
+export interface BackgroundFetchDeps {
+  batchFetch: (projects: Project[], options?: { concurrency?: number }) => Promise<BatchResult>;
+}
+
+export function useBackgroundFetch(
+  config: GitforestConfig,
+  onRefresh: () => Promise<void>,
+  deps?: Partial<BackgroundFetchDeps>,
+) {
+  const { state, dispatch } = useStore();
+  const batchFetch = deps?.batchFetch ?? defaultBatchFetch;
+  const timerRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  const isFetchingRef = useRef(false);
+
+  // Use config value or fallback to default
+  const intervalMs = (config.cache.backgroundRefreshIntervalSeconds ?? 300) * 1000;
+  const isEnabled = config.cache.enableBackgroundRefresh !== false;
+
+  useEffect(() => {
+    // Don't run if disabled or while loading or during an action
+    if (!isEnabled || state.isLoading || state.actionInProgress) {
+      return;
+    }
+
+    const runBackgroundFetch = async () => {
+      // Prevent concurrent fetches
+      if (isFetchingRef.current || state.actionInProgress) return;
+      isFetchingRef.current = true;
+
+      const gitProjects = state.projects.filter(
+        (p) => p.type === "git" && p.status?.hasRemote
+      );
+
+      if (gitProjects.length === 0) {
+        isFetchingRef.current = false;
+        return;
+      }
+
+      try {
+        // Silently fetch in background
+        await batchFetch(gitProjects, { concurrency: config.scan.concurrency });
+
+        // Refresh project statuses
+        await onRefresh();
+      } finally {
+        isFetchingRef.current = false;
+      }
+    };
+
+    // Set up interval
+    timerRef.current = setInterval(runBackgroundFetch, intervalMs);
+
+    // Run initial fetch after a short delay
+    const initialTimeout = setTimeout(runBackgroundFetch, 10000); // 10 seconds after start
+
+    return () => {
+      if (timerRef.current) {
+        clearInterval(timerRef.current);
+      }
+      clearTimeout(initialTimeout);
+    };
+  }, [state.isLoading, state.actionInProgress, state.projects, config.scan.concurrency, intervalMs, isEnabled, dispatch, onRefresh]);
+
+  return null;
+}

package/src/hooks/useConfirmDialogActions.ts

@@ -0,0 +1,120 @@
+import { useCallback } from "react";
+import { useStore, useFilteredProjects } from "../state/store.tsx";
+import { setMessage, startAction, endAction } from "../state/actions.ts";
+import { initGitInProject } from "../git/operations.ts";
+import { defaultGitHubService } from "../services/github.ts";
+import type { GitforestConfig, Project } from "../types/index.ts";
+
+interface UseConfirmDialogActionsOptions {
+  config: GitforestConfig;
+  onRefresh: () => Promise<void>;
+}
+
+export function useConfirmDialogActions({
+  config,
+  onRefresh,
+}: UseConfirmDialogActionsOptions) {
+  const { state, dispatch } = useStore();
+  const filteredProjects = useFilteredProjects();
+
+  const handleConfirm = useCallback(
+    async (options: { visibility?: "private" | "public" }) => {
+      const { confirmDialog } = state;
+      if (!confirmDialog) return;
+
+      const { operation, projectPaths } = confirmDialog;
+      const isPrivate = options.visibility === "private";
+
+      // Find projects by path
+      const projects = filteredProjects.filter((p) =>
+        projectPaths.includes(p.path)
+      );
+
+      dispatch({ type: "HIDE_CONFIRM_DIALOG" });
+
+      if (operation === "setup") {
+        await handleSetup(projects, isPrivate);
+      } else if (operation === "create") {
+        await handleCreate(projects, isPrivate);
+      } else if (operation === "archive") {
+        await handleArchive(projects);
+      }
+
+      await onRefresh();
+    },
+    [state, filteredProjects, dispatch, config, onRefresh]
+  );
+
+  const handleCancel = useCallback(() => {
+    dispatch({ type: "HIDE_CONFIRM_DIALOG" });
+  }, [dispatch]);
+
+  const handleSetup = async (projects: Project[], isPrivate: boolean) => {
+    const nonGitProjects = projects.filter((p) => p.type === "non-git");
+    const gitProjects = projects.filter((p) => p.type === "git");
+
+    dispatch(startAction(`Setting up ${projects.length} projects`));
+
+    let initSuccess = 0;
+    let createSuccess = 0;
+
+    // First, init git in non-git projects
+    for (const project of nonGitProjects) {
+      const result = await initGitInProject(project.path);
+      if (result.success) initSuccess++;
+    }
+
+    // Then create repos for all projects
+    const allProjects = [...nonGitProjects, ...gitProjects];
+    for (const project of allProjects) {
+      const result = await defaultGitHubService.createRepo({
+        name: project.name,
+        isPrivate,
+        localPath: project.path,
+      });
+      if (result.success) createSuccess++;
+    }
+
+    dispatch(endAction());
+    dispatch(
+      setMessage(
+        `Setup complete: ${initSuccess} initialized, ${createSuccess}/${allProjects.length} repos created`
+      )
+    );
+  };
+
+  const handleCreate = async (projects: Project[], isPrivate: boolean) => {
+    dispatch(startAction(`Creating ${projects.length} GitHub repos`));
+
+    let success = 0;
+    for (const project of projects) {
+      const result = await defaultGitHubService.createRepo({
+        name: project.name,
+        isPrivate,
+        localPath: project.path,
+      });
+      if (result.success) success++;
+    }
+
+    dispatch(endAction());
+    dispatch(setMessage(`Created ${success}/${projects.length} GitHub repos`));
+  };
+
+  const handleArchive = async (projects: Project[]) => {
+    dispatch(startAction(`Archiving ${projects.length} repos`));
+
+    let success = 0;
+    for (const project of projects) {
+      const result = await defaultGitHubService.archiveRepo(project.name);
+      if (result.success) success++;
+    }
+
+    dispatch(endAction());
+    dispatch(setMessage(`Archived ${success}/${projects.length} repos`));
+  };
+
+  return {
+    handleConfirm,
+    handleCancel,
+  };
+}