gitforest 0.1.0

package/src/hooks/useKeyBindings.ts

@@ -0,0 +1,656 @@
+import { useInput, useApp } from "ink";
+import { useStore, useFilteredProjects, useSelectedProjects, useFilteredUnifiedRepos, useSelectedUnifiedRepos } from "../state/store.tsx";
+import {
+  moveCursor,
+  toggleSelection,
+  selectAll,
+  deselectAll,
+  setMode,
+  setFilter,
+  cycleSort,
+  setSort,
+  setMessage,
+  startAction,
+  endAction,
+  updateProgress,
+} from "../state/actions.ts";
+import { batchPull as defaultBatchPull, batchPush as defaultBatchPush, batchFetch as defaultBatchFetch } from "../operations/batch.ts";
+import { initGitInProject as defaultInitGitInProject } from "../git/operations.ts";
+import { executeCommand as defaultExecuteCommand, findCommandByKey as defaultFindCommandByKey } from "../operations/commands.ts";
+import { errorToString } from "../utils/errors.ts";
+import type { GitforestConfig, ConfirmDialogState, QuickFilter, ViewMode, DetailModalState, UnifiedRepo, CommandConfig, Project, BatchResult, OperationResult } from "../types/index.ts";
+
+/**
+ * Dependencies that can be injected for testing
+ */
+export interface KeyBindingDeps {
+  batchPull: (projects: Project[], options?: { concurrency?: number; onProgress?: (current: number, total: number) => void }) => Promise<BatchResult>;
+  batchPush: (projects: Project[], options?: { concurrency?: number; onProgress?: (current: number, total: number) => void }) => Promise<BatchResult>;
+  batchFetch: (projects: Project[], options?: { concurrency?: number; onProgress?: (current: number, total: number) => void }) => Promise<BatchResult>;
+  initGitInProject: (path: string) => Promise<OperationResult>;
+  executeCommand: (command: CommandConfig, projectPath: string) => Promise<{ success: boolean; output?: string; error?: string }>;
+  findCommandByKey: (commands: CommandConfig[], key: string) => CommandConfig | undefined;
+}
+
+interface UseKeyBindingsOptions {
+  config: GitforestConfig;
+  onRefresh: () => Promise<void>;
+  deps?: Partial<KeyBindingDeps>;
+}
+
+export function useKeyBindings({ config, onRefresh, deps }: UseKeyBindingsOptions) {
+  const { state, dispatch } = useStore();
+  const { exit } = useApp();
+  const filteredProjects = useFilteredProjects();
+  const selectedProjects = useSelectedProjects();
+  const filteredUnifiedRepos = useFilteredUnifiedRepos();
+  const selectedUnifiedRepos = useSelectedUnifiedRepos();
+
+  // Use injected dependencies or defaults
+  const batchPull = deps?.batchPull ?? defaultBatchPull;
+  const batchPush = deps?.batchPush ?? defaultBatchPush;
+  const batchFetch = deps?.batchFetch ?? defaultBatchFetch;
+  const initGitInProject = deps?.initGitInProject ?? defaultInitGitInProject;
+  const executeCommand = deps?.executeCommand ?? defaultExecuteCommand;
+  const findCommandByKey = deps?.findCommandByKey ?? defaultFindCommandByKey;
+
+  // Helper function to execute a custom command on selected repos
+  async function handleCommandExecution(command: CommandConfig, repos: UnifiedRepo[]) {
+    // If no repos explicitly selected, use the current cursor position
+    let targetRepos = repos;
+    if (targetRepos.length === 0) {
+      const currentRepo = filteredUnifiedRepos[state.cursorIndex];
+      if (currentRepo) {
+        targetRepos = [currentRepo];
+      }
+    }
+
+    // Filter to repos with local paths
+    const localRepos = targetRepos.filter((r) => r.localPath || r.local?.path);
+    
+    if (localRepos.length === 0) {
+      dispatch(setMessage("No local projects selected"));
+      return;
+    }
+
+    const projectPath = localRepos[0]!.localPath || localRepos[0]!.local!.path;
+    
+    dispatch(startAction(`Running: ${command.name}`));
+    
+    try {
+      const result = await executeCommand(command, projectPath);
+      dispatch(endAction());
+      
+      if (result.success) {
+        if (result.output) {
+          // Show truncated output
+          const shortOutput = result.output.length > 50 
+            ? result.output.slice(0, 50) + "..." 
+            : result.output;
+          dispatch(setMessage(`${command.name}: ${shortOutput}`));
+        } else {
+          dispatch(setMessage(`${command.name}: Done`));
+        }
+      } else {
+        dispatch(setMessage(`${command.name} failed: ${result.error}`));
+      }
+    } catch (error) {
+      dispatch(endAction());
+      dispatch(setMessage(`${command.name} failed: ${error instanceof Error ? error.message : String(error)}`));
+    }
+  }
+
+  // Helper function to fetch README content
+  async function fetchReadme(repo: UnifiedRepo): Promise<{ content: string | null; error: string | null }> {
+    // Try local README first
+    if (repo.localPath) {
+      try {
+        const readmePath = `${repo.localPath}/README.md`;
+        const file = Bun.file(readmePath);
+        if (await file.exists()) {
+          const content = await file.text();
+          return { content, error: null };
+        }
+      } catch {}
+    }
+    
+    // Try GitHub API
+    if (repo.github) {
+      try {
+        const response = await fetch(
+          `https://api.github.com/repos/${repo.github.fullName}/readme`,
+          {
+            headers: {
+              'Accept': 'application/vnd.github.raw',
+              'Authorization': `Bearer ${process.env.GITHUB_TOKEN}`,
+            },
+          }
+        );
+        if (response.ok) {
+          const content = await response.text();
+          return { content, error: null };
+        }
+      } catch {}
+    }
+    
+    return { content: null, error: "README not found" };
+  }
+
+  useInput(async (input, key) => {
+    const { mode, cursorIndex, selectedIndices } = state;
+
+    // Handle filter mode separately
+    if (mode === "filter") {
+      if (key.escape) {
+        dispatch(setMode("normal"));
+        dispatch(setFilter(""));
+        return;
+      }
+      if (key.return) {
+        dispatch(setMode("normal"));
+        return;
+      }
+      // Let TextInput handle other keys
+      return;
+    }
+
+    // Handle detail modal mode
+    if (mode === "detail") {
+      if (key.escape) {
+        dispatch({ type: "HIDE_DETAIL_MODAL" });
+        return;
+      }
+      // j/k to scroll README
+      if (input === "j") {
+        dispatch({ type: "UPDATE_DETAIL_MODAL", payload: { 
+          readmeScrollOffset: (state.detailModal?.readmeScrollOffset ?? 0) + 1 
+        }});
+        return;
+      }
+      if (input === "k") {
+        dispatch({ type: "UPDATE_DETAIL_MODAL", payload: { 
+          readmeScrollOffset: Math.max(0, (state.detailModal?.readmeScrollOffset ?? 0) - 1)
+        }});
+        return;
+      }
+      // Actions in modal - these should trigger the onAction callback
+      // For now, just close modal and perform action
+      if (input === "p" || input === "P" || input === "f") {
+        // Let the existing handlers work, but close modal first
+        dispatch({ type: "HIDE_DETAIL_MODAL" });
+        // Don't return - let it fall through to normal handling
+      }
+      if (input === "o") {
+        // Open in browser - need to implement
+        const repo = state.detailModal?.repo;
+        if (repo?.github?.htmlUrl) {
+          // Use Bun to open URL
+          try {
+            await Bun.$`open ${repo.github.htmlUrl}`.quiet();
+          } catch (error) {
+            dispatch(setMessage(`Failed to open browser: ${errorToString(error)}`));
+          }
+        }
+        return;
+      }
+      if (input === "d") {
+        // Open in editor
+        const repo = state.detailModal?.repo;
+        if (repo?.localPath) {
+          const editor = process.env.EDITOR || "code";
+          try {
+            await Bun.$`${editor} ${repo.localPath}`.quiet();
+          } catch (error) {
+            dispatch(setMessage(`Failed to open editor: ${errorToString(error)}`));
+          }
+        }
+        return;
+      }
+      return; // Don't process other keys in detail mode
+    }
+
+    // Handle filter options mode
+    if (mode === "filter-options") {
+      // Any key closes the overlay
+      dispatch(setMode("normal"));
+      return;
+    }
+
+    // Handle help mode
+    if (mode === "help") {
+      dispatch(setMode("normal"));
+      return;
+    }
+
+    // Handle clone dialog mode
+    if (mode === "clone") {
+      if (key.escape) {
+        dispatch({ type: "HIDE_CLONE_DIALOG" });
+        dispatch(setMode("normal"));
+        return;
+      }
+      // Let CloneDialog handle other keys
+      return;
+    }
+
+    // Handle command palette mode
+    if (mode === "command-palette") {
+      if (key.escape) {
+        dispatch(setMode("normal"));
+        return;
+      }
+      
+      // Find and execute command by key
+      const command = findCommandByKey(config.commands, input);
+      if (command) {
+        await handleCommandExecution(command, selectedUnifiedRepos);
+        dispatch(setMode("normal"));
+        return;
+      }
+      return;
+    }
+
+    // Global keys that work in any mode
+    if (input === "q" || (key.ctrl && input === "c")) {
+      exit();
+      return;
+    }
+
+    if (input === "?") {
+      dispatch(setMode("help"));
+      return;
+    }
+
+    // F key for filter options overlay
+    if (input === "F") {
+      dispatch(setMode("filter-options"));
+      return;
+    }
+
+    // x key for command palette
+    if (input === "x") {
+      if (config.commands.length === 0) {
+        dispatch(setMessage("No commands configured"));
+        return;
+      }
+      dispatch(setMode("command-palette"));
+      return;
+    }
+
+    // Tab - cycle view mode
+    if (key.tab) {
+      const modes: ViewMode[] = ["local", "github", "combined"];
+      const unifiedState = state as any;
+      const currentMode: ViewMode = unifiedState.viewMode || "local";
+      const currentIdx = modes.indexOf(currentMode);
+      if (currentIdx === -1) return; // Safety check
+      const nextIdx = (currentIdx + 1) % modes.length;
+      const nextMode = modes[nextIdx]!;
+      dispatch({ type: "SET_VIEW_MODE", payload: nextMode });
+      const modeLabels: Record<ViewMode, string> = { local: "Local only", github: "GitHub only", combined: "All repos" };
+      dispatch(setMessage(`View: ${modeLabels[nextMode]}`));
+      return;
+    }
+
+    // Navigation
+    if (input === "j" || key.downArrow) {
+      dispatch(moveCursor(cursorIndex + 1));
+      return;
+    }
+
+    if (input === "k" || key.upArrow) {
+      dispatch(moveCursor(cursorIndex - 1));
+      return;
+    }
+
+    // Enter - open detail modal
+    if (key.return) {
+      const currentRepo = filteredUnifiedRepos[cursorIndex];
+      if (currentRepo) {
+        // Fetch README content (async)
+        const detailState: DetailModalState = {
+          repo: currentRepo,
+          readmeContent: null,
+          readmeLoading: true,
+          readmeError: null,
+          readmeScrollOffset: 0,
+        };
+        dispatch({ type: "SHOW_DETAIL_MODAL", payload: detailState });
+        
+        // Fetch README in background
+        fetchReadme(currentRepo).then(({ content, error }) => {
+          dispatch({ type: "UPDATE_DETAIL_MODAL", payload: {
+            readmeContent: content,
+            readmeLoading: false,
+            readmeError: error,
+          }});
+        });
+      }
+      return;
+    }
+
+    if (input === "g") {
+      dispatch(moveCursor(0));
+      return;
+    }
+
+    if (input === "G") {
+      const unifiedState = state as any;
+      const currentViewMode = unifiedState.viewMode || "combined";
+      const itemCount = currentViewMode === "local" ? filteredProjects.length : filteredUnifiedRepos.length;
+      dispatch(moveCursor(itemCount - 1));
+      return;
+    }
+
+    // Selection
+    if (input === " ") {
+      dispatch(toggleSelection(cursorIndex));
+      return;
+    }
+
+    if (input === "a") {
+      const unifiedState = state as any;
+      const currentViewMode = unifiedState.viewMode || "combined";
+      const itemCount = currentViewMode === "local" ? filteredProjects.length : filteredUnifiedRepos.length;
+      if (selectedIndices.size === itemCount) {
+        dispatch(deselectAll());
+      } else {
+        dispatch(selectAll());
+      }
+      return;
+    }
+
+    // Filter
+    if (input === "/") {
+      dispatch(setMode("filter"));
+      return;
+    }
+
+    // Sort - 's' cycles field, 'S' reverses direction
+    if (input === "s") {
+      dispatch(cycleSort());
+      return;
+    }
+    
+    if (input === "S") {
+      const newDirection = state.sortDirection === 'desc' ? 'asc' : 'desc';
+      dispatch(setSort(state.sortBy, newDirection));
+      dispatch(setMessage(`Sort: ${state.sortBy} ${newDirection === 'desc' ? '↓' : '↑'}`));
+      return;
+    }
+
+    // Quick filters (1=dirty, 2=unpushed, 3=no-remote, 4=github-only, 5=local-only, 6=private, 7=public, 8=archived, 9=forks, 0=all)
+    const quickFilterMap: Record<string, QuickFilter> = {
+      "0": "all",
+      "1": "dirty",
+      "2": "unpushed",
+      "3": "no-remote",
+      "4": "github-only",
+      "5": "local-only",
+      "6": "private",
+      "7": "public",
+      "8": "archived",
+      "9": "forks",
+    };
+
+    if (input in quickFilterMap) {
+      const newFilter = quickFilterMap[input]!;
+      dispatch({ type: "SET_QUICK_FILTER", payload: newFilter });
+      const filterNames: Record<QuickFilter, string> = {
+        all: "All projects",
+        dirty: "Dirty projects",
+        unpushed: "Unpushed commits",
+        "no-remote": "No remote",
+        "github-only": "GitHub only",
+        "local-only": "Local only",
+        private: "Private repos",
+        public: "Public repos",
+        archived: "Archived repos",
+        forks: "Forked repos",
+      };
+      dispatch(setMessage(`Filter: ${filterNames[newFilter]}`));
+      return;
+    }
+
+    // Refresh
+    if (input === "r") {
+      dispatch({ type: "SET_REFRESHING", payload: true });
+      await onRefresh();
+      dispatch({ type: "SET_REFRESHING", payload: false });
+      dispatch(setMessage("Refresh complete"));
+      return;
+    }
+
+    // Git operations
+    if (input === "p") {
+      // Push selected
+      const gitProjects = selectedProjects.filter(
+        (p) => p.type === "git" && p.status?.hasRemote && p.status?.isAhead
+      );
+
+      if (gitProjects.length === 0) {
+        dispatch(setMessage("No projects to push"));
+        return;
+      }
+
+      dispatch(startAction("Pushing"));
+
+      const result = await batchPush(gitProjects, { concurrency: config.scan.concurrency, onProgress: (current, total) => {
+        dispatch(updateProgress(current, total));
+      }});
+
+      dispatch(endAction());
+      
+      // Show detailed push result
+      if (result.failed > 0) {
+        const failedNames = result.results
+          .filter(r => !r.success)
+          .map((_, i) => gitProjects[i]?.name)
+          .filter(Boolean)
+          .slice(0, 3)
+          .join(", ");
+        const moreCount = result.failed > 3 ? ` +${result.failed - 3} more` : "";
+        dispatch(setMessage(`Pushed ${result.successful}/${result.total} (failed: ${failedNames}${moreCount})`));
+      } else {
+        const pushedNames = gitProjects.slice(0, 3).map(p => p.name).join(", ");
+        const moreCount = gitProjects.length > 3 ? ` +${gitProjects.length - 3} more` : "";
+        dispatch(setMessage(`Pushed: ${pushedNames}${moreCount}`));
+      }
+
+      // Refresh after success to reflect latest state
+      await onRefresh();
+      return;
+    }
+
+    if (input === "P") {
+      // Pull all
+      const gitProjects = filteredProjects.filter(
+        (p) => p.type === "git" && p.status?.hasRemote
+      );
+
+      if (gitProjects.length === 0) {
+        dispatch(setMessage("No projects with remotes"));
+        return;
+      }
+
+      dispatch(startAction("Pulling"));
+
+      const result = await batchPull(gitProjects, { concurrency: config.scan.concurrency, onProgress: (current, total) => {
+        dispatch(updateProgress(current, total));
+      }});
+
+      dispatch(endAction());
+      
+      // Show detailed pull result
+      if (result.failed > 0) {
+        dispatch(setMessage(`Pulled ${result.successful}/${result.total} (${result.failed} failed)`));
+      } else {
+        dispatch(setMessage(`Pulled ${result.successful} projects successfully`));
+      }
+
+      await onRefresh();
+      return;
+    }
+
+    if (input === "f") {
+      // Fetch all
+      const gitProjects = filteredProjects.filter(
+        (p) => p.type === "git" && p.status?.hasRemote
+      );
+
+      if (gitProjects.length === 0) {
+        dispatch(setMessage("No projects with remotes"));
+        return;
+      }
+
+      dispatch(startAction("Fetching"));
+
+      const result = await batchFetch(gitProjects, { concurrency: config.scan.concurrency, onProgress: (current, total) => {
+        dispatch(updateProgress(current, total));
+      }});
+
+      dispatch(endAction());
+      
+      // Show detailed fetch result
+      if (result.failed > 0) {
+        dispatch(setMessage(`Fetched ${result.successful}/${result.total} (${result.failed} failed)`));
+      } else {
+        dispatch(setMessage(`Fetched ${result.successful} projects`));
+      }
+
+      await onRefresh();
+      return;
+    }
+
+    if (input === "i") {
+      // Init git in selected non-git projects
+      const nonGitProjects = selectedProjects.filter((p) => p.type === "non-git");
+
+      if (nonGitProjects.length === 0) {
+        dispatch(setMessage("No non-git projects selected"));
+        return;
+      }
+
+      dispatch(startAction(`Initializing ${nonGitProjects.length} projects`));
+
+      let success = 0;
+      for (const project of nonGitProjects) {
+        const result = await initGitInProject(project.path);
+        if (result.success) success++;
+      }
+
+      dispatch(endAction());
+      dispatch(
+        setMessage(`Initialized ${success}/${nonGitProjects.length} projects`)
+      );
+
+      // Refresh after init
+      await onRefresh();
+      return;
+    }
+
+    // GitHub operations
+    if (input === "c") {
+      // Create GitHub repo - show confirmation dialog
+      const gitProjects = selectedProjects.filter(
+        (p) => p.type === "git" && !p.status?.hasRemote
+      );
+
+      if (gitProjects.length === 0) {
+        dispatch(setMessage("No git projects without remotes selected"));
+        return;
+      }
+
+      const dialogState: ConfirmDialogState = {
+        operation: "create",
+        title: "Create GitHub Repos",
+        message: "Create GitHub repositories for:",
+        items: gitProjects.map((p) => p.name),
+        projectPaths: gitProjects.map((p) => p.path),
+        showVisibilityToggle: true,
+      };
+
+      dispatch({ type: "SHOW_CONFIRM_DIALOG", payload: dialogState });
+      return;
+    }
+
+    if (input === "C") {
+      // Setup: init git (if needed) + create GitHub repo + push
+      const eligibleProjects = selectedProjects.filter(
+        (p) => p.type === "non-git" || (p.type === "git" && !p.status?.hasRemote)
+      );
+
+      if (eligibleProjects.length === 0) {
+        dispatch(setMessage("No projects need setup (all have remotes)"));
+        return;
+      }
+
+      const dialogState: ConfirmDialogState = {
+        operation: "setup",
+        title: "Setup Projects",
+        message: "Init git (if needed) and create GitHub repos for:",
+        items: eligibleProjects.map((p) => `${p.name}${p.type === "non-git" ? " (will init)" : ""}`),
+        projectPaths: eligibleProjects.map((p) => p.path),
+        showVisibilityToggle: true,
+      };
+
+      dispatch({ type: "SHOW_CONFIRM_DIALOG", payload: dialogState });
+      return;
+    }
+
+    if (input === "A") {
+      // Archive GitHub repos - show confirmation dialog
+      const gitProjects = selectedProjects.filter(
+        (p) => p.type === "git" && p.status?.hasRemote
+      );
+
+      if (gitProjects.length === 0) {
+        dispatch(setMessage("No git projects with remotes selected"));
+        return;
+      }
+
+      const dialogState: ConfirmDialogState = {
+        operation: "archive",
+        title: "Archive GitHub Repos",
+        message: "Archive these repositories on GitHub:",
+        items: gitProjects.map((p) => p.name),
+        projectPaths: gitProjects.map((p) => p.path),
+        showVisibilityToggle: false,
+      };
+
+      dispatch({ type: "SHOW_CONFIRM_DIALOG", payload: dialogState });
+      return;
+    }
+
+    // D - Clone GitHub repos
+    if (input === "D") {
+      const githubOnlyRepos = selectedUnifiedRepos.filter(r => r.source === "github");
+      
+      if (githubOnlyRepos.length === 0) {
+        dispatch(setMessage("No GitHub-only repos selected to clone"));
+        return;
+      }
+      
+      dispatch({ 
+        type: "SHOW_CLONE_DIALOG", 
+        payload: {
+          repos: githubOnlyRepos,
+          directories: config.directories,
+          selectedDirIndex: 0,
+          useSSH: true,
+        }
+      });
+      return;
+    }
+
+    // Custom commands - check if input matches a configured command key
+    // This allows executing commands directly from main list without command palette
+    if (config.commands.length > 0) {
+      const command = findCommandByKey(config.commands, input);
+      if (command) {
+        await handleCommandExecution(command, selectedUnifiedRepos);
+        return;
+      }
+    }
+  });
+}

package/src/hooks/useProjects.ts

@@ -0,0 +1,47 @@
+import { useEffect, useCallback } from "react";
+import { useStore } from "../state/store.tsx";
+import {
+  setProjects,
+  setLoading,
+  setError,
+  setMessage,
+} from "../state/actions.ts";
+import { scanAllDirectories, sortProjects } from "../scanner/index.ts";
+import type { GitforestConfig } from "../types/index.ts";
+import { errorToString } from "../utils/errors.ts";
+
+export function useProjects(config: GitforestConfig) {
+  const { state, dispatch } = useStore();
+  const { sortBy, sortDirection } = state;
+
+  const loadProjects = useCallback(async () => {
+    dispatch(setLoading(true));
+    dispatch(setError(null));
+
+    try {
+      const projects = await scanAllDirectories(config);
+      const sorted = sortProjects(projects, sortBy, sortDirection);
+      dispatch(setProjects(sorted));
+      dispatch(setMessage(`Found ${projects.length} projects`));
+    } catch (error) {
+      dispatch(setError(errorToString(error)));
+    } finally {
+      dispatch(setLoading(false));
+    }
+  }, [config, dispatch, sortBy, sortDirection]);
+
+  // Load on mount
+  useEffect(() => {
+    loadProjects();
+  }, []);
+
+  // Re-sort when sort changes
+  useEffect(() => {
+    if (state.projects.length > 0 && !state.isLoading) {
+      const sorted = sortProjects(state.projects, sortBy, sortDirection);
+      dispatch(setProjects(sorted));
+    }
+  }, [sortBy, sortDirection]);
+
+  return { loadProjects };
+}