@akiojin/gwt 4.10.0 → 4.11.6

package/src/cli/ui/core/types.ts

@@ -0,0 +1,235 @@
+/**
+ * Core UI Types - Framework-agnostic type definitions
+ *
+ * These types are designed to be shared across CLI UI implementations and contain
+ * no framework-specific imports.
+ *
+ * @see specs/SPEC-d27be71b/spec.md - OpenTUI migration spec
+ */
+
+// ========================================
+// Navigation & Screen State
+// ========================================
+
+/**
+ * Screen types for UI navigation
+ */
+export type ScreenType =
+  | "branch-list"
+  | "log-list"
+  | "log-detail"
+  | "log-date-picker"
+  | "branch-creator"
+  | "branch-action-selector"
+  | "branch-quick-start"
+  | "coding-agent-selector"
+  | "model-selector"
+  | "session-selector"
+  | "execution-mode-selector"
+  | "batch-merge-progress"
+  | "batch-merge-result"
+  | "environment-profile"
+  | "help-overlay"; // New: OpenTUI overlay feature
+
+/**
+ * Screen visibility state
+ */
+export type ScreenState = "active" | "hidden";
+
+/**
+ * Generic screen definition
+ */
+export interface Screen<T = unknown> {
+  type: ScreenType;
+  state: ScreenState;
+  data?: T;
+}
+
+// ========================================
+// Selection & Navigation State
+// ========================================
+
+/**
+ * Generic selection state for lists
+ */
+export interface SelectionState {
+  selectedIndex: number;
+  highlightedIndex: number;
+  scrollOffset: number;
+}
+
+/**
+ * Scroll state for virtualized lists
+ */
+export interface ScrollState {
+  offset: number;
+  visibleCount: number;
+  totalCount: number;
+}
+
+/**
+ * Filter state for branch lists
+ */
+export interface FilterState {
+  searchQuery: string;
+  showWithWorktree: boolean;
+  showWithoutWorktree: boolean;
+  showLocal: boolean;
+  showRemote: boolean;
+  branchTypes: BranchCategory[];
+}
+
+// ========================================
+// Branch Types
+// ========================================
+
+/**
+ * Branch category for filtering and display
+ */
+export type BranchCategory =
+  | "feature"
+  | "bugfix"
+  | "hotfix"
+  | "release"
+  | "main"
+  | "develop"
+  | "other";
+
+/**
+ * Branch view mode
+ */
+export type BranchViewMode = "all" | "local" | "remote";
+
+/**
+ * Branch data type
+ */
+export type BranchDataType = "local" | "remote";
+
+/**
+ * Sync status with remote
+ */
+export type SyncStatus =
+  | "up-to-date"
+  | "ahead"
+  | "behind"
+  | "diverged"
+  | "no-upstream"
+  | "remote-only";
+
+/**
+ * Worktree status
+ */
+export type WorktreeStatus = "active" | "inaccessible" | undefined;
+
+// ========================================
+// Layout & Terminal
+// ========================================
+
+/**
+ * Terminal dimensions
+ */
+export interface TerminalSize {
+  width: number;
+  height: number;
+}
+
+/**
+ * Layout configuration
+ */
+export interface LayoutConfig {
+  terminalSize: TerminalSize;
+  headerLines: number;
+  footerLines: number;
+  contentHeight: number;
+}
+
+// ========================================
+// Statistics
+// ========================================
+
+/**
+ * Branch list statistics
+ */
+export interface BranchStatistics {
+  localCount: number;
+  remoteCount: number;
+  worktreeCount: number;
+  changesCount: number;
+  lastUpdated: Date;
+}
+
+// ========================================
+// Actions & Events
+// ========================================
+
+/**
+ * Branch action types
+ */
+export type BranchAction = "use-existing" | "create-new";
+
+/**
+ * Footer action definition
+ */
+export interface FooterAction {
+  key: string;
+  description: string;
+}
+
+// ========================================
+// Notification & Feedback
+// ========================================
+
+/**
+ * Notification tone for visual feedback
+ */
+export type NotificationTone = "info" | "success" | "warning" | "error";
+
+/**
+ * Notification message
+ */
+export interface Notification {
+  message: string;
+  tone: NotificationTone;
+  timestamp?: Date;
+}
+
+// ========================================
+// Loading & Progress
+// ========================================
+
+/**
+ * Loading state
+ */
+export interface LoadingState {
+  isLoading: boolean;
+  message?: string;
+  progress?: number; // 0-100
+}
+
+/**
+ * Async operation state
+ */
+export type AsyncState<T> =
+  | { status: "idle" }
+  | { status: "loading"; message?: string }
+  | { status: "success"; data: T }
+  | { status: "error"; error: Error };
+
+// ========================================
+// Merge Operations
+// ========================================
+
+/**
+ * Merge phase
+ */
+export type MergePhase = "fetch" | "worktree" | "merge" | "push" | "cleanup";
+
+/**
+ * Merge status
+ */
+export type MergeStatus = "success" | "skipped" | "failed";
+
+/**
+ * Push status
+ */
+export type PushStatus = "success" | "failed" | "not_executed";

package/src/cli/ui/hooks/solid/useAsyncOperation.ts

@@ -0,0 +1,76 @@
+import { createMemo, createSignal, type Accessor } from "solid-js";
+import type { AsyncState } from "../../core/types.js";
+
+type AsyncOperation<T, Args extends unknown[]> = (...args: Args) => Promise<T>;
+
+export interface UseAsyncOperationOptions<T> {
+  initialState?: AsyncState<T>;
+  onSuccess?: (data: T) => void;
+  onError?: (error: Error) => void;
+  onFinally?: () => void;
+}
+
+export interface UseAsyncOperationResult<T, Args extends unknown[]> {
+  state: Accessor<AsyncState<T>>;
+  setState: (state: AsyncState<T>) => void;
+  isLoading: Accessor<boolean>;
+  error: Accessor<Error | null>;
+  data: Accessor<T | null>;
+  run: (...args: Args) => Promise<T>;
+  reset: () => void;
+}
+
+const toError = (err: unknown): Error =>
+  err instanceof Error ? err : new Error(String(err));
+
+export function useAsyncOperation<T, Args extends unknown[]>(
+  operation: AsyncOperation<T, Args>,
+  options: UseAsyncOperationOptions<T> = {},
+): UseAsyncOperationResult<T, Args> {
+  const [state, setStateInternal] = createSignal<AsyncState<T>>(
+    options.initialState ?? { status: "idle" },
+  );
+
+  const isLoading = createMemo(() => state().status === "loading");
+  const error = createMemo(() =>
+    state().status === "error" ? state().error : null,
+  );
+  const data = createMemo(() =>
+    state().status === "success" ? state().data : null,
+  );
+
+  const setState = (next: AsyncState<T>) => {
+    setStateInternal(next);
+  };
+
+  const run = async (...args: Args) => {
+    setState({ status: "loading" });
+    try {
+      const result = await operation(...args);
+      setState({ status: "success", data: result });
+      options.onSuccess?.(result);
+      return result;
+    } catch (err) {
+      const errorValue = toError(err);
+      setState({ status: "error", error: errorValue });
+      options.onError?.(errorValue);
+      throw errorValue;
+    } finally {
+      options.onFinally?.();
+    }
+  };
+
+  const reset = () => {
+    setState({ status: "idle" });
+  };
+
+  return {
+    state,
+    setState,
+    isLoading,
+    error,
+    data,
+    run,
+    reset,
+  };
+}

package/src/cli/ui/hooks/solid/useFilter.ts

@@ -0,0 +1,86 @@
+import { createMemo, createSignal, type Accessor } from "solid-js";
+
+type MaybeAccessor<T> = T | (() => T);
+
+type StringSetter = (value: string | ((prev: string) => string)) => void;
+
+type BooleanSetter = (value: boolean | ((prev: boolean) => boolean)) => void;
+
+export interface UseFilterOptions<T> {
+  items: MaybeAccessor<T[]>;
+  initialQuery?: string;
+  initialActive?: boolean;
+  normalizeQuery?: (query: string) => string;
+  filter?: (item: T, normalizedQuery: string) => boolean;
+}
+
+export interface UseFilterResult<T> {
+  query: Accessor<string>;
+  setQuery: StringSetter;
+  normalizedQuery: Accessor<string>;
+  isActive: Accessor<boolean>;
+  setActive: BooleanSetter;
+  filteredItems: Accessor<T[]>;
+  clear: () => void;
+  activate: () => void;
+  deactivate: () => void;
+  toggle: () => void;
+}
+
+const resolveMaybe = <T>(value: MaybeAccessor<T>): T =>
+  typeof value === "function" ? (value as () => T)() : value;
+
+const defaultNormalizeQuery = (query: string): string =>
+  query.trim().toLowerCase();
+
+export function useFilter<T>(options: UseFilterOptions<T>): UseFilterResult<T> {
+  const [query, setQueryInternal] = createSignal(options.initialQuery ?? "");
+  const [isActive, setActiveInternal] = createSignal(
+    options.initialActive ?? false,
+  );
+
+  const normalizedQuery = createMemo(() => {
+    const normalize = options.normalizeQuery ?? defaultNormalizeQuery;
+    return normalize(query());
+  });
+
+  const filteredItems = createMemo(() => {
+    const items = resolveMaybe(options.items) ?? [];
+    const currentQuery = normalizedQuery();
+    const filter = options.filter;
+
+    if (!filter || !currentQuery) {
+      return items;
+    }
+
+    return items.filter((item) => filter(item, currentQuery));
+  });
+
+  const setQuery: StringSetter = (value) => {
+    const next = typeof value === "function" ? value(query()) : value;
+    setQueryInternal(next);
+  };
+
+  const setActive: BooleanSetter = (value) => {
+    const next = typeof value === "function" ? value(isActive()) : value;
+    setActiveInternal(next);
+  };
+
+  const clear = () => setQuery("");
+  const activate = () => setActive(true);
+  const deactivate = () => setActive(false);
+  const toggle = () => setActive((prev) => !prev);
+
+  return {
+    query,
+    setQuery,
+    normalizedQuery,
+    isActive,
+    setActive,
+    filteredItems,
+    clear,
+    activate,
+    deactivate,
+    toggle,
+  };
+}

package/src/cli/ui/hooks/solid/useGitOperations.ts

@@ -0,0 +1,80 @@
+import { createMemo, createSignal, type Accessor } from "solid-js";
+import type { AsyncState } from "../../core/types.js";
+import type { WorktreeConfig } from "../../types.js";
+import {
+  createWorktree,
+  generateWorktreePath,
+  removeWorktree,
+} from "../../../worktree.js";
+import { deleteBranch, getRepositoryRoot } from "../../../git.js";
+
+export interface UseGitOperationsResult {
+  state: Accessor<AsyncState<unknown>>;
+  isLoading: Accessor<boolean>;
+  error: Accessor<Error | null>;
+  run: <T>(operation: () => Promise<T>) => Promise<T>;
+  reset: () => void;
+  getRepositoryRoot: () => Promise<string>;
+  generateWorktreePath: (
+    repoRoot: string,
+    branchName: string,
+  ) => Promise<string>;
+  createWorktree: (config: WorktreeConfig) => Promise<void>;
+  removeWorktree: (worktreePath: string, force?: boolean) => Promise<void>;
+  deleteBranch: (branchName: string, force?: boolean) => Promise<void>;
+}
+
+const toError = (err: unknown): Error =>
+  err instanceof Error ? err : new Error(String(err));
+
+/**
+ * Solid hook to perform git/worktree operations with shared async state.
+ */
+export function useGitOperations(): UseGitOperationsResult {
+  const [state, setState] = createSignal<AsyncState<unknown>>({
+    status: "idle",
+  });
+
+  const isLoading = createMemo(() => state().status === "loading");
+  const error = createMemo(() =>
+    state().status === "error" ? state().error : null,
+  );
+
+  const run = async <T>(operation: () => Promise<T>): Promise<T> => {
+    setState({ status: "loading" });
+    try {
+      const result = await operation();
+      setState({ status: "success", data: result });
+      return result;
+    } catch (err) {
+      const errorValue = toError(err);
+      setState({ status: "error", error: errorValue });
+      throw errorValue;
+    }
+  };
+
+  const reset = () => setState({ status: "idle" });
+
+  const runGetRepositoryRoot = () => run(() => getRepositoryRoot());
+  const runGenerateWorktreePath = (repoRoot: string, branchName: string) =>
+    run(() => generateWorktreePath(repoRoot, branchName));
+  const runCreateWorktree = (config: WorktreeConfig) =>
+    run(() => createWorktree(config));
+  const runRemoveWorktree = (worktreePath: string, force = false) =>
+    run(() => removeWorktree(worktreePath, force));
+  const runDeleteBranch = (branchName: string, force = false) =>
+    run(() => deleteBranch(branchName, force));
+
+  return {
+    state,
+    isLoading,
+    error,
+    run,
+    reset,
+    getRepositoryRoot: runGetRepositoryRoot,
+    generateWorktreePath: runGenerateWorktreePath,
+    createWorktree: runCreateWorktree,
+    removeWorktree: runRemoveWorktree,
+    deleteBranch: runDeleteBranch,
+  };
+}

package/src/cli/ui/hooks/solid/useKeyHandler.ts

@@ -0,0 +1,103 @@
+import { useKeyboard } from "@opentui/solid";
+import type { KeyEvent } from "@opentui/core";
+import {
+  defaultKeybindings,
+  getKeybindingsForContext,
+  type KeybindingDef,
+  type Modifiers,
+  type UIAction,
+} from "../../core/keybindings.js";
+
+type MaybeAccessor<T> = T | (() => T);
+
+export interface UseKeyHandlerOptions {
+  context?: MaybeAccessor<string | undefined>;
+  keybindings?: MaybeAccessor<KeybindingDef[] | undefined>;
+  isActive?: MaybeAccessor<boolean>;
+  onAction: (action: UIAction, event: KeyEvent) => void;
+}
+
+const NORMALIZED_KEY_NAMES: Record<string, string> = {
+  enter: "return",
+  linefeed: "return",
+  pageup: "pageUp",
+  pagedown: "pageDown",
+  esc: "escape",
+};
+
+const resolveMaybe = <T>(value: MaybeAccessor<T> | undefined): T | undefined =>
+  typeof value === "function" ? (value as () => T)() : value;
+
+const normalizeKeyName = (name: string): string =>
+  NORMALIZED_KEY_NAMES[name] ?? name;
+
+const normalizeModifiers = (modifiers?: Modifiers) => ({
+  ctrl: modifiers?.ctrl ?? false,
+  shift: modifiers?.shift ?? false,
+  alt: modifiers?.alt ?? false,
+  meta: modifiers?.meta ?? false,
+});
+
+const getEventModifiers = (event: KeyEvent) => ({
+  ctrl: event.ctrl,
+  shift: event.shift,
+  alt: Boolean(event.option || event.meta),
+  meta: Boolean(event.super || event.hyper),
+});
+
+const resolveBindings = (
+  context?: string,
+  keybindings?: KeybindingDef[],
+): KeybindingDef[] => {
+  if (keybindings !== undefined) {
+    return keybindings;
+  }
+  if (context) {
+    return getKeybindingsForContext(context);
+  }
+  return defaultKeybindings;
+};
+
+const matchesKeybinding = (
+  binding: KeybindingDef,
+  event: KeyEvent,
+): boolean => {
+  const eventKey = normalizeKeyName(event.name);
+  if (eventKey !== binding.key.key) {
+    return false;
+  }
+
+  const expected = normalizeModifiers(binding.key.modifiers);
+  const actual = getEventModifiers(event);
+
+  return (
+    expected.ctrl === actual.ctrl &&
+    expected.shift === actual.shift &&
+    expected.alt === actual.alt &&
+    expected.meta === actual.meta
+  );
+};
+
+/**
+ * OpenTUI keyboard handler that maps key events to UI actions.
+ */
+export function useKeyHandler(options: UseKeyHandlerOptions): void {
+  useKeyboard((event) => {
+    if (resolveMaybe(options.isActive) === false) {
+      return;
+    }
+
+    const context = resolveMaybe(options.context);
+    const bindings = resolveBindings(
+      context,
+      resolveMaybe(options.keybindings),
+    );
+
+    for (const binding of bindings) {
+      if (matchesKeybinding(binding, event)) {
+        options.onAction(binding.action, event);
+        return;
+      }
+    }
+  });
+}