@akiojin/gwt 4.10.0 → 4.12.0

package/src/cli/ui/hooks/useAppInput.ts

@@ -1,172 +0,0 @@
-import { useCallback, useEffect, useRef } from "react";
-import { useInput, type Key } from "ink";
-
-// WSL/Windows can emit split escape sequences with higher latency.
-export const ESCAPE_SEQUENCE_TIMEOUT_MS = 80;
-
-type InputHandler = (input: string, key: Key) => void;
-type Options = { isActive?: boolean };
-
-type BufferedEvent = { input: string; key: Key };
-
-type PendingEscape = {
-  escapeEvent: BufferedEvent;
-  bufferedEvents: BufferedEvent[];
-  timeoutId: ReturnType<typeof setTimeout> | null;
-};
-
-const createEmptyKey = (): Key => ({
-  upArrow: false,
-  downArrow: false,
-  leftArrow: false,
-  rightArrow: false,
-  pageDown: false,
-  pageUp: false,
-  return: false,
-  escape: false,
-  ctrl: false,
-  shift: false,
-  tab: false,
-  backspace: false,
-  delete: false,
-  meta: false,
-});
-
-function parseArrowDirection(
-  sequence: string,
-): "up" | "down" | "left" | "right" | null {
-  if (!sequence) {
-    return null;
-  }
-
-  const first = sequence[0];
-  if (first !== "[" && first !== "O") {
-    return null;
-  }
-
-  const last = sequence.at(-1);
-  if (!last) {
-    return null;
-  }
-
-  switch (last.toUpperCase()) {
-    case "A":
-      return "up";
-    case "B":
-      return "down";
-    case "C":
-      return "right";
-    case "D":
-      return "left";
-    default:
-      return null;
-  }
-}
-
-/**
- * Ink `useInput` wrapper that buffers an initial Escape press to disambiguate
- * between a real Escape key and a split ANSI escape sequence (e.g., arrow keys
- * in WSL2/Windows terminals).
- *
- * When an Escape is received, waits briefly for subsequent characters. If they
- * form an arrow sequence (e.g., `[A`, `[B`, `OA`), emits a synthetic arrow
- * `Key`. Otherwise, forwards the original Escape keypress.
- *
- * @param inputHandler - Callback invoked for each normalized input event
- * @param options - Optional Ink input options (e.g., `{ isActive: false }`)
- */
-export function useAppInput(
-  inputHandler: InputHandler,
-  options?: Options,
-): void {
-  const handlerRef = useRef(inputHandler);
-  const pendingRef = useRef<PendingEscape | null>(null);
-
-  useEffect(() => {
-    handlerRef.current = inputHandler;
-  }, [inputHandler]);
-
-  const clearPending = useCallback(() => {
-    const pending = pendingRef.current;
-    if (pending?.timeoutId) {
-      clearTimeout(pending.timeoutId);
-    }
-    pendingRef.current = null;
-  }, []);
-
-  const flushPending = useCallback(() => {
-    const pending = pendingRef.current;
-    if (!pending) {
-      return;
-    }
-
-    clearPending();
-    handlerRef.current(pending.escapeEvent.input, pending.escapeEvent.key);
-    for (const event of pending.bufferedEvents) {
-      handlerRef.current(event.input, event.key);
-    }
-  }, [clearPending]);
-
-  useEffect(() => {
-    if (options?.isActive === false) {
-      clearPending();
-    }
-  }, [options?.isActive, clearPending]);
-
-  useEffect(() => clearPending, [clearPending]);
-
-  useInput((input, key) => {
-    const pending = pendingRef.current;
-
-    if (!pending) {
-      if (key.escape) {
-        const timeoutId = setTimeout(flushPending, ESCAPE_SEQUENCE_TIMEOUT_MS);
-        pendingRef.current = {
-          escapeEvent: { input, key },
-          bufferedEvents: [],
-          timeoutId,
-        };
-        return;
-      }
-
-      handlerRef.current(input, key);
-      return;
-    }
-
-    if (pending.timeoutId) {
-      clearTimeout(pending.timeoutId);
-    }
-
-    pending.bufferedEvents.push({ input, key });
-
-    const [firstEvent] = pending.bufferedEvents;
-    const firstInput = firstEvent?.input;
-
-    if (firstInput && firstInput !== "[" && firstInput !== "O") {
-      flushPending();
-      return;
-    }
-
-    const sequence = pending.bufferedEvents
-      .map((event) => event.input)
-      .join("");
-    const arrow = parseArrowDirection(sequence);
-    if (arrow) {
-      clearPending();
-      const arrowKey = createEmptyKey();
-      if (arrow === "up") {
-        arrowKey.upArrow = true;
-      } else if (arrow === "down") {
-        arrowKey.downArrow = true;
-      } else if (arrow === "left") {
-        arrowKey.leftArrow = true;
-      } else if (arrow === "right") {
-        arrowKey.rightArrow = true;
-      }
-      handlerRef.current("", arrowKey);
-      return;
-    }
-
-    pending.timeoutId = setTimeout(flushPending, ESCAPE_SEQUENCE_TIMEOUT_MS);
-  }, options);
-}

package/src/cli/ui/hooks/useBatchMerge.ts

@@ -1,96 +0,0 @@
-import { useState, useCallback } from "react";
-import { BatchMergeService } from "../../../services/BatchMergeService.js";
-import type {
-  BatchMergeConfig,
-  BatchMergeProgress,
-  BatchMergeResult,
-  BranchMergeStatus,
-} from "../types.js";
-
-/**
- * useBatchMerge hook - Manages batch merge state and execution
- * @see specs/SPEC-ee33ca26/plan.md - Service layer integration
- */
-export function useBatchMerge() {
-  const [isExecuting, setIsExecuting] = useState(false);
-  const [progress, setProgress] = useState<BatchMergeProgress | null>(null);
-  const [statuses, setStatuses] = useState<BranchMergeStatus[]>([]);
-  const [result, setResult] = useState<BatchMergeResult | null>(null);
-  const [error, setError] = useState<Error | null>(null);
-
-  const service = new BatchMergeService();
-
-  /**
-   * Execute batch merge
-   */
-  const executeBatchMerge = useCallback(
-    async (config: BatchMergeConfig) => {
-      try {
-        setIsExecuting(true);
-        setProgress(null);
-        setStatuses([]);
-        setResult(null);
-        setError(null);
-
-        const mergeResult = await service.executeBatchMerge(
-          config,
-          (progressUpdate) => {
-            setProgress(progressUpdate);
-
-            // Update statuses as branches are processed
-            // This is a simplified version; real implementation would track completed branches
-          },
-        );
-
-        setResult(mergeResult);
-        setStatuses(mergeResult.statuses);
-        return mergeResult;
-      } catch (err) {
-        const error = err instanceof Error ? err : new Error(String(err));
-        setError(error);
-        throw error;
-      } finally {
-        setIsExecuting(false);
-        setProgress(null);
-      }
-    },
-    [service],
-  );
-
-  /**
-   * Determine source branch automatically
-   */
-  const determineSourceBranch = useCallback(async () => {
-    return await service.determineSourceBranch();
-  }, [service]);
-
-  /**
-   * Get target branches
-   */
-  const getTargetBranches = useCallback(async () => {
-    return await service.getTargetBranches();
-  }, [service]);
-
-  /**
-   * Reset state
-   */
-  const reset = useCallback(() => {
-    setIsExecuting(false);
-    setProgress(null);
-    setStatuses([]);
-    setResult(null);
-    setError(null);
-  }, []);
-
-  return {
-    isExecuting,
-    progress,
-    statuses,
-    result,
-    error,
-    executeBatchMerge,
-    determineSourceBranch,
-    getTargetBranches,
-    reset,
-  };
-}

package/src/cli/ui/hooks/useGitData.ts

@@ -1,347 +0,0 @@
-import { useState, useEffect, useCallback, useRef } from "react";
-import {
-  getAllBranches,
-  hasUnpushedCommitsInRepo,
-  getRepositoryRoot,
-  fetchAllRemotes,
-  collectUpstreamMap,
-  getBranchDivergenceStatuses,
-} from "../../../git.js";
-import { GIT_CONFIG } from "../../../config/constants.js";
-import { listAdditionalWorktrees } from "../../../worktree.js";
-import { getPullRequestByBranch } from "../../../github.js";
-import type { BranchInfo, WorktreeInfo } from "../types.js";
-import type { WorktreeInfo as GitWorktreeInfo } from "../../../worktree.js";
-import { getLastToolUsageMap } from "../../../config/index.js";
-import { hasUncommittedChanges } from "../../../git.js";
-
-export interface UseGitDataOptions {
-  enableAutoRefresh?: boolean;
-  refreshInterval?: number; // milliseconds (default: 5000ms = 5s)
-}
-
-export interface UseGitDataResult {
-  branches: BranchInfo[];
-  worktrees: GitWorktreeInfo[];
-  loading: boolean;
-  error: Error | null;
-  refresh: () => void;
-  lastUpdated: Date | null;
-}
-
-export const GIT_DATA_TIMEOUT_MS = 30000; // 30 seconds for large repositories
-const PER_BRANCH_TIMEOUT_MS = 5000; // 5 seconds per branch operation
-
-async function withTimeout<T>(
-  label: string,
-  promise: Promise<T>,
-  timeoutMs: number,
-  fallback: T,
-): Promise<T> {
-  let timeoutId: ReturnType<typeof setTimeout> | null = null;
-  let timedOut = false;
-
-  const timeoutPromise = new Promise<T>((resolve) => {
-    timeoutId = setTimeout(() => {
-      timedOut = true;
-      resolve(fallback);
-    }, timeoutMs);
-  });
-
-  const guarded = promise.catch((error) => {
-    if (process.env.DEBUG) {
-      console.warn(`Failed to resolve ${label}`, error);
-    }
-    return fallback;
-  });
-
-  const result = await Promise.race([guarded, timeoutPromise]);
-
-  if (timedOut && process.env.DEBUG) {
-    console.warn(`Timed out waiting for ${label}`);
-  }
-
-  if (timeoutId) {
-    clearTimeout(timeoutId);
-  }
-
-  return result;
-}
-
-/**
- * Hook to fetch and manage Git data (branches and worktrees)
- * @param options - Configuration options for auto-refresh and polling interval
- */
-export function useGitData(options?: UseGitDataOptions): UseGitDataResult {
-  const { enableAutoRefresh = false, refreshInterval = 5000 } = options || {};
-  const [branches, setBranches] = useState<BranchInfo[]>([]);
-  const [worktrees, setWorktrees] = useState<GitWorktreeInfo[]>([]);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<Error | null>(null);
-  const [lastUpdated, setLastUpdated] = useState<Date | null>(null);
-
-  // キャッシュ機構: 初回ロード完了を追跡（useRef で再レンダリングを防ぐ）
-  const hasLoadedOnceRef = useRef(false);
-
-  const loadData = useCallback(async (forceRefresh = false) => {
-    // キャッシュがあり、強制リフレッシュでなければスキップ
-    if (hasLoadedOnceRef.current && !forceRefresh) {
-      return;
-    }
-
-    setLoading(true);
-    setError(null);
-
-    try {
-      const repoRoot = await withTimeout(
-        "repository root",
-        getRepositoryRoot(),
-        GIT_DATA_TIMEOUT_MS,
-        process.cwd(),
-      );
-
-      // リモートブランチの最新情報を取得（失敗してもローカル表示は継続）
-      void fetchAllRemotes({
-        cwd: repoRoot,
-        timeoutMs: GIT_CONFIG.FETCH_TIMEOUT,
-      }).catch((fetchError) => {
-        if (process.env.DEBUG) {
-          console.warn("Failed to fetch remote branches", fetchError);
-        }
-      });
-
-      const branchesData = await withTimeout(
-        "branches",
-        getAllBranches(repoRoot),
-        GIT_DATA_TIMEOUT_MS,
-        [],
-      );
-      let worktreesData: GitWorktreeInfo[] = [];
-      try {
-        worktreesData = await withTimeout(
-          "worktrees",
-          listAdditionalWorktrees(),
-          GIT_DATA_TIMEOUT_MS,
-          [],
-        );
-      } catch (err) {
-        if (process.env.DEBUG) {
-          console.error("Failed to list additional worktrees:", err);
-        }
-        worktreesData = [];
-      }
-
-      // enrich worktrees with uncommitted status (only for accessible paths)
-      worktreesData = await Promise.all(
-        worktreesData.map(async (wt) => {
-          if (wt.isAccessible === false) {
-            return wt;
-          }
-          try {
-            const hasUncommitted = await withTimeout(
-              "worktree status",
-              hasUncommittedChanges(wt.path),
-              PER_BRANCH_TIMEOUT_MS,
-              false,
-            );
-            return { ...wt, hasUncommittedChanges: hasUncommitted };
-          } catch {
-            return wt;
-          }
-        }),
-      );
-
-      const lastToolUsageMap = await withTimeout(
-        "last tool usage",
-        getLastToolUsageMap(repoRoot),
-        GIT_DATA_TIMEOUT_MS,
-        new Map(),
-      );
-
-      // upstream情報とdivergence情報を取得
-      const [upstreamMap, divergenceStatuses] = await Promise.all([
-        withTimeout(
-          "upstream map",
-          collectUpstreamMap(repoRoot),
-          GIT_DATA_TIMEOUT_MS,
-          new Map<string, string>(),
-        ),
-        withTimeout(
-          "divergence",
-          getBranchDivergenceStatuses({ cwd: repoRoot }).catch(() => []),
-          GIT_DATA_TIMEOUT_MS,
-          [],
-        ),
-      ]);
-
-      // divergenceをMapに変換
-      const divergenceMap = new Map(
-        divergenceStatuses.map((s) => [
-          s.branch,
-          {
-            ahead: s.localAhead,
-            behind: s.remoteAhead,
-            upToDate: s.localAhead === 0 && s.remoteAhead === 0,
-          },
-        ]),
-      );
-
-      // ローカルブランチ名のSet（重複除去用）
-      const localBranchNames = new Set(
-        branchesData.filter((b) => b.type === "local").map((b) => b.name),
-      );
-
-      // リモートブランチ名のSet（hasRemoteCounterpart判定用）
-      const remoteBranchNames = new Set(
-        branchesData
-          .filter((b) => b.type === "remote")
-          .map((b) => b.name.replace(/^origin\//, "")),
-      );
-
-      // Store worktrees separately
-      setWorktrees(worktreesData);
-
-      // Map worktrees to branches
-      const worktreeMap = new Map<string, WorktreeInfo>();
-      for (const worktree of worktreesData) {
-        // Convert worktree.ts WorktreeInfo to ui/types.ts WorktreeInfo
-        const uiWorktreeInfo: WorktreeInfo = {
-          path: worktree.path,
-          locked: false, // worktree.ts doesn't expose locked status
-          prunable: worktree.isAccessible === false,
-          isAccessible: worktree.isAccessible ?? true, // Default to true if undefined
-          ...(worktree.hasUncommittedChanges !== undefined
-            ? { hasUncommittedChanges: worktree.hasUncommittedChanges }
-            : {}),
-        };
-        worktreeMap.set(worktree.branch, uiWorktreeInfo);
-      }
-
-      // リモートブランチの重複除去（ローカルに同名がある場合は除外）
-      const filteredBranches = branchesData.filter((branch) => {
-        if (branch.type === "remote") {
-          const remoteBranchBaseName = branch.name.replace(/^origin\//, "");
-          return !localBranchNames.has(remoteBranchBaseName);
-        }
-        return true;
-      });
-
-      // Attach worktree info and check unpushed/PR status for local branches
-      const enrichedBranches = await Promise.all(
-        filteredBranches.map(async (branch) => {
-          const worktreeInfo = worktreeMap.get(branch.name);
-          let hasUnpushed = false;
-          let prInfo = null;
-
-          // Only check unpushed commits and PR status for local branches
-          if (branch.type === "local") {
-            try {
-              // Check for unpushed commits
-              [hasUnpushed, prInfo] = await Promise.all([
-                withTimeout(
-                  "unpushed commits",
-                  hasUnpushedCommitsInRepo(branch.name, repoRoot),
-                  PER_BRANCH_TIMEOUT_MS,
-                  false,
-                ),
-                withTimeout(
-                  "pull request",
-                  getPullRequestByBranch(branch.name),
-                  PER_BRANCH_TIMEOUT_MS,
-                  null,
-                ),
-              ]);
-            } catch (error) {
-              // Silently ignore errors to avoid breaking the UI
-              if (process.env.DEBUG) {
-                console.error(
-                  `Failed to check status for ${branch.name}:`,
-                  error,
-                );
-              }
-            }
-          }
-
-          // upstream/divergence/hasRemoteCounterpart情報を付加
-          const upstream =
-            branch.type === "local"
-              ? (upstreamMap.get(branch.name) ?? null)
-              : null;
-          const divergence =
-            branch.type === "local"
-              ? (divergenceMap.get(branch.name) ?? null)
-              : null;
-          const hasRemoteCounterpart =
-            branch.type === "local"
-              ? remoteBranchNames.has(branch.name)
-              : false;
-
-          return {
-            ...branch,
-            ...(worktreeInfo ? { worktree: worktreeInfo } : {}),
-            ...(hasUnpushed ? { hasUnpushedCommits: true } : {}),
-            ...(prInfo?.state === "OPEN"
-              ? { openPR: { number: prInfo.number, title: prInfo.title } }
-              : {}),
-            ...(prInfo?.state === "MERGED" && prInfo.mergedAt
-              ? {
-                  mergedPR: {
-                    number: prInfo.number,
-                    mergedAt: prInfo.mergedAt,
-                  },
-                }
-              : {}),
-            ...(lastToolUsageMap.get(branch.name)
-              ? { lastToolUsage: lastToolUsageMap.get(branch.name) ?? null }
-              : {}),
-            ...(upstream !== null ? { upstream } : {}),
-            ...(divergence !== null ? { divergence } : {}),
-            ...(hasRemoteCounterpart ? { hasRemoteCounterpart } : {}),
-          };
-        }),
-      );
-
-      setBranches(enrichedBranches);
-      setLastUpdated(new Date());
-      hasLoadedOnceRef.current = true; // 初回ロード完了をマーク
-    } catch (err) {
-      setError(err instanceof Error ? err : new Error(String(err)));
-      setBranches([]);
-      setWorktrees([]);
-    } finally {
-      setLoading(false);
-    }
-  }, []);
-
-  const refresh = useCallback(() => {
-    loadData(true); // forceRefresh = true で強制的にデータを再取得
-  }, [loadData]);
-
-  useEffect(() => {
-    loadData();
-  }, [loadData]);
-
-  // Auto-refresh polling (if enabled)
-  useEffect(() => {
-    if (!enableAutoRefresh) {
-      return;
-    }
-
-    const intervalId = setInterval(() => {
-      loadData();
-    }, refreshInterval);
-
-    return () => {
-      clearInterval(intervalId);
-    };
-  }, [enableAutoRefresh, refreshInterval, loadData]);
-
-  return {
-    branches,
-    worktrees,
-    loading,
-    error,
-    refresh,
-    lastUpdated,
-  };
-}