@akiojin/gwt 4.5.1 → 4.6.1

package/src/cli/ui/components/screens/BranchListScreen.tsx

@@ -10,6 +10,7 @@ import { useSpinnerFrame } from "../common/SpinnerIcon.js";
 import { useAppInput } from "../../hooks/useAppInput.js";
 import { useTerminalSize } from "../../hooks/useTerminalSize.js";
 import type { BranchItem, Statistics, BranchViewMode } from "../../types.js";
+import type { ToolStatus } from "../../hooks/useToolStatus.js";
 import stringWidth from "string-width";
 import stripAnsi from "strip-ansi";
 import chalk from "chalk";
@@ -109,13 +110,18 @@ export interface BranchListScreenProps {
   testOnViewModeChange?: (mode: BranchViewMode) => void;
   selectedBranches?: string[];
   onToggleSelect?: (branchName: string) => void;
+  /**
+   * AIツールのインストール状態配列
+   * @see specs/SPEC-3b0ed29b/spec.md FR-019, FR-021
+   */
+  toolStatuses?: ToolStatus[] | undefined;
 }
 
 /**
  * BranchListScreen - Main screen for branch selection
  * Layout: Header + Stats + Branch List + Footer
  */
-export function BranchListScreen({
+export const BranchListScreen = React.memo(function BranchListScreen({
   branches,
   stats,
   onSelect,
@@ -138,6 +144,7 @@ export function BranchListScreen({
   testOnViewModeChange,
   selectedBranches = [],
   onToggleSelect,
+  toolStatuses,
 }: BranchListScreenProps) {
   const { rows } = useTerminalSize();
   const selectedSet = useMemo(
@@ -274,8 +281,14 @@ export function BranchListScreen({
     let result = branches;
 
     // Apply view mode filter
-    if (viewMode !== "all") {
-      result = result.filter((branch) => branch.type === viewMode);
+    if (viewMode === "local") {
+      result = result.filter((branch) => branch.type === "local");
+    } else if (viewMode === "remote") {
+      // リモート専用ブランチ OR ローカルだがリモートにも存在するブランチ
+      result = result.filter(
+        (branch) =>
+          branch.type === "remote" || branch.hasRemoteCounterpart === true,
+      );
     }
 
     // Apply search filter
@@ -446,11 +459,9 @@ export function BranchListScreen({
       const indicatorInfo = cleanupUI?.indicators?.[item.name];
       let leadingIndicator: string;
       if (indicatorInfo) {
-        // Use spinner frame if isSpinning, otherwise use static icon
-        let indicatorIcon =
-          indicatorInfo.isSpinning && spinnerFrame
-            ? spinnerFrame
-            : indicatorInfo.icon;
+        // Use static spinner icon if isSpinning to avoid re-render dependency
+        // The static "⠋" provides visual feedback without causing flicker
+        let indicatorIcon = indicatorInfo.isSpinning ? "⠋" : indicatorInfo.icon;
         if (indicatorIcon && indicatorInfo.color && !isSelected) {
           switch (indicatorInfo.color) {
             case "cyan":
@@ -588,7 +599,6 @@ export function BranchListScreen({
       truncateToWidth,
       selectedSet,
       colorToolLabel,
-      spinnerFrame,
     ],
   );
 
@@ -625,6 +635,22 @@ export function BranchListScreen({
         )}
       </Box>
 
+      {/* Tool Status - FR-019, FR-021 */}
+      {toolStatuses && toolStatuses.length > 0 && (
+        <Box>
+          <Text dimColor>Tools: </Text>
+          {toolStatuses.map((tool, index) => (
+            <React.Fragment key={tool.id}>
+              <Text>{tool.name}: </Text>
+              <Text color={tool.status === "installed" ? "green" : "yellow"}>
+                {tool.status}
+              </Text>
+              {index < toolStatuses.length - 1 && <Text dimColor> | </Text>}
+            </React.Fragment>
+          ))}
+        </Box>
+      )}
+
       {/* Stats */}
       <Box>
         <Stats stats={stats} lastUpdated={lastUpdated} viewMode={viewMode} />
@@ -708,4 +734,4 @@ export function BranchListScreen({
       <Footer actions={footerActions} />
     </Box>
   );
-}
+});

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

@@ -0,0 +1,68 @@
+/**
+ * AIツール状態管理フック
+ *
+ * 各AIツール（Claude Code、Codex、Gemini）のインストール状態を
+ * gwt起動時に検出し、キャッシュして提供します。
+ * @see specs/SPEC-3b0ed29b/spec.md FR-017〜FR-021
+ */
+
+import { useState, useEffect, useCallback } from "react";
+import {
+  detectAllToolStatuses,
+  type ToolStatus,
+} from "../../../utils/command.js";
+
+export interface UseToolStatusResult {
+  /** ツール状態の配列（ロード中は空配列） */
+  tools: ToolStatus[];
+  /** ロード中フラグ */
+  loading: boolean;
+  /** エラー（なければnull） */
+  error: Error | null;
+  /** ツール状態を再検出（通常は不要、デバッグ用） */
+  refresh: () => Promise<void>;
+}
+
+/**
+ * AIツール状態管理フック
+ *
+ * コンポーネントでAIツールのインストール状態を取得するためのフック。
+ * 初回マウント時に自動的に全ツールの状態を検出してキャッシュします。
+ *
+ * キャッシュされた結果は、ブランチ選択時やツール起動時に再利用され、
+ * 毎回の検出オーバーヘッドを削減します（FR-020）。
+ */
+export function useToolStatus(): UseToolStatusResult {
+  const [tools, setTools] = useState<ToolStatus[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  // ツール状態を検出
+  const refresh = useCallback(async () => {
+    try {
+      setLoading(true);
+      setError(null);
+      const statuses = await detectAllToolStatuses();
+      setTools(statuses);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  // 初回マウント時に検出（FR-017: 起動時に検出してキャッシュ）
+  useEffect(() => {
+    refresh();
+  }, [refresh]);
+
+  return {
+    tools,
+    loading,
+    error,
+    refresh,
+  };
+}
+
+// Re-export ToolStatus type for convenience
+export type { ToolStatus };

package/src/gemini.ts

@@ -6,7 +6,7 @@ import {
   getTerminalStreams,
   resetTerminalModes,
 } from "./utils/terminal.js";
-import { isCommandAvailable } from "./utils/command.js";
+import { findCommand } from "./utils/command.js";
 import { findLatestGeminiSessionId } from "./utils/session.js";
 
 const GEMINI_CLI_PACKAGE = "@google/gemini-cli@latest";
@@ -152,7 +152,7 @@ export async function launchGeminiCLI(
     const childStdio = createChildStdio();
 
     // Auto-detect locally installed gemini command
-    const hasLocalGemini = await isCommandAvailable("gemini");
+    const geminiLookup = await findCommand("gemini");
 
     // Preserve TTY for interactive UI (colors/width) by inheriting stdout/stderr.
     // Session ID is determined via file-based detection after exit.
@@ -184,11 +184,12 @@ export async function launchGeminiCLI(
         await execChild(child);
       };
 
-      if (hasLocalGemini) {
+      if (geminiLookup.source === "installed" && geminiLookup.path) {
+        // Use the full path to avoid PATH issues in non-interactive shells
         console.log(
           chalk.green("   ✨ Using locally installed gemini command"),
         );
-        return await run("gemini", runArgs);
+        return await run(geminiLookup.path, runArgs);
       }
       console.log(
         chalk.cyan("   🔄 Falling back to bunx @google/gemini-cli@latest"),
@@ -263,7 +264,9 @@ export async function launchGeminiCLI(
 
     return capturedSessionId ? { sessionId: capturedSessionId } : {};
   } catch (error: unknown) {
-    const hasLocalGemini = await isCommandAvailable("gemini");
+    const geminiCheck = await findCommand("gemini");
+    const hasLocalGemini =
+      geminiCheck.source === "installed" && geminiCheck.path !== null;
     let errorMessage: string;
     const err = error as NodeJS.ErrnoException;
 

package/src/index.ts

@@ -267,6 +267,7 @@ async function mainInkUI(): Promise<SelectionResult | undefined> {
       stdin: terminal.stdin,
       stdout: terminal.stdout,
       stderr: terminal.stderr,
+      patchConsole: false,
     },
   );
 

package/src/utils/command.ts

@@ -1,26 +1,188 @@
 import { execa } from "execa";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
 
 /**
- * Checks whether a command is available in the current PATH.
- *
- * Uses `where` on Windows and `which` on other platforms.
+ * Known installation paths for common AI CLI tools.
+ * These are checked as fallback when `which`/`where` fails.
+ */
+const KNOWN_INSTALL_PATHS: Record<string, { unix: string[]; win32: string[] }> =
+  {
+    claude: {
+      unix: [
+        join(homedir(), ".bun", "bin", "claude"),
+        join(homedir(), ".local", "bin", "claude"),
+        "/usr/local/bin/claude",
+      ],
+      win32: [
+        join(
+          process.env.LOCALAPPDATA ?? "",
+          "Programs",
+          "claude",
+          "claude.exe",
+        ),
+        join(homedir(), ".bun", "bin", "claude.exe"),
+      ],
+    },
+    codex: {
+      unix: [
+        join(homedir(), ".bun", "bin", "codex"),
+        join(homedir(), ".local", "bin", "codex"),
+        "/usr/local/bin/codex",
+      ],
+      win32: [join(homedir(), ".bun", "bin", "codex.exe")],
+    },
+    gemini: {
+      unix: [
+        join(homedir(), ".bun", "bin", "gemini"),
+        join(homedir(), ".local", "bin", "gemini"),
+        "/usr/local/bin/gemini",
+      ],
+      win32: [join(homedir(), ".bun", "bin", "gemini.exe")],
+    },
+  };
+
+/**
+ * Builtin AI tools with their command names and display names.
+ */
+const BUILTIN_TOOLS = [
+  { id: "claude-code", commandName: "claude", displayName: "Claude" },
+  { id: "codex-cli", commandName: "codex", displayName: "Codex" },
+  { id: "gemini-cli", commandName: "gemini", displayName: "Gemini" },
+] as const;
+
+/**
+ * Result of command lookup.
+ */
+export interface CommandLookupResult {
+  available: boolean;
+  path: string | null;
+  source: "installed" | "bunx";
+}
+
+/**
+ * Tool status information for display.
+ */
+export interface ToolStatus {
+  id: string;
+  name: string;
+  status: "installed" | "bunx";
+  path: string | null;
+}
+
+/**
+ * Module-level cache for command lookup results.
+ * This cache persists for the lifetime of the process (FR-020).
+ */
+const commandLookupCache = new Map<string, CommandLookupResult>();
+
+/**
+ * Clears the command lookup cache.
+ * Primarily for testing purposes.
+ */
+export function clearCommandLookupCache(): void {
+  commandLookupCache.clear();
+}
+
+/**
+ * Finds a command by checking PATH first, then fallback paths.
+ * Results are cached for the lifetime of the process (FR-020).
  *
- * @param commandName - Command name to look up (e.g. `claude`, `npx`, `gemini`)
- * @returns true if the command exists in PATH
+ * @param commandName - Command name to look up (e.g. `claude`, `codex`, `gemini`)
+ * @returns CommandLookupResult with availability, path, and source
  */
-export async function isCommandAvailable(
+export async function findCommand(
   commandName: string,
-): Promise<boolean> {
+): Promise<CommandLookupResult> {
+  // Check cache first (FR-020: 再検出を行わない)
+  const cached = commandLookupCache.get(commandName);
+  if (cached) {
+    return cached;
+  }
+
+  let lookupResult: CommandLookupResult | null = null;
+
+  // Step 1: Try standard which/where lookup
   try {
-    const command = process.platform === "win32" ? "where" : "which";
-    await execa(command, [commandName], {
+    const lookupCommand = process.platform === "win32" ? "where" : "which";
+    const execResult = await execa(lookupCommand, [commandName], {
       shell: true,
       stdin: "ignore",
-      stdout: "ignore",
+      stdout: "pipe",
       stderr: "ignore",
     });
-    return true;
+    const foundPath = execResult.stdout.trim().split("\n")[0];
+    if (foundPath) {
+      lookupResult = { available: true, path: foundPath, source: "installed" };
+    }
   } catch {
-    return false;
+    // which/where failed, try fallback paths
+  }
+
+  // Step 2: Check known installation paths as fallback
+  if (!lookupResult) {
+    const knownPaths = KNOWN_INSTALL_PATHS[commandName];
+    if (knownPaths) {
+      const pathsToCheck =
+        process.platform === "win32" ? knownPaths.win32 : knownPaths.unix;
+
+      for (const p of pathsToCheck) {
+        if (p && existsSync(p)) {
+          lookupResult = { available: true, path: p, source: "installed" };
+          break;
+        }
+      }
+    }
+  }
+
+  // Step 3: Fall back to bunx (always available for known tools)
+  if (!lookupResult) {
+    lookupResult = { available: true, path: null, source: "bunx" };
   }
+
+  // Cache the result (FR-020)
+  commandLookupCache.set(commandName, lookupResult);
+
+  return lookupResult;
+}
+
+/**
+ * Checks whether a command is available in the current PATH.
+ *
+ * Uses `where` on Windows and `which` on other platforms.
+ * If the standard lookup fails, checks known installation paths
+ * as a fallback for common tools.
+ *
+ * @param commandName - Command name to look up (e.g. `claude`, `npx`, `gemini`)
+ * @returns true if the command exists in PATH or known paths
+ */
+export async function isCommandAvailable(
+  commandName: string,
+): Promise<boolean> {
+  const result = await findCommand(commandName);
+  return result.available;
+}
+
+/**
+ * Detects installation status for all builtin AI tools.
+ *
+ * This function is designed to be called once at application startup
+ * and cached for the duration of the session.
+ *
+ * @returns Array of ToolStatus for all builtin tools
+ */
+export async function detectAllToolStatuses(): Promise<ToolStatus[]> {
+  const results = await Promise.all(
+    BUILTIN_TOOLS.map(async (tool) => {
+      const result = await findCommand(tool.commandName);
+      return {
+        id: tool.id,
+        name: tool.displayName,
+        status: result.source,
+        path: result.path,
+      };
+    }),
+  );
+  return results;
 }