@akiojin/gwt 2.7.4 → 2.9.0

package/src/cli/ui/__tests__/integration/navigation.test.tsx

@@ -307,6 +307,57 @@ describe("Protected Branch Navigation (T103)", () => {
     branchActionSpy.mockRestore();
   });
 
+  it("prefills AI tool selector with last used tool for the branch", async () => {
+    const branchesWithUsage: BranchInfo[] = [
+      {
+        name: "feature/with-usage",
+        type: "local",
+        branchType: "feature",
+        isCurrent: false,
+        lastToolUsage: {
+          branch: "feature/with-usage",
+          worktreePath: "/repo/.worktrees/feature-with-usage",
+          toolId: "codex-cli",
+          toolLabel: "Codex",
+          timestamp: Date.now(),
+        },
+      },
+    ];
+
+    mockedGetAllBranches.mockResolvedValue(branchesWithUsage);
+    mockedListAdditionalWorktrees.mockResolvedValue([]);
+
+    const onExit = vi.fn();
+    render(<App onExit={onExit} />);
+
+    await waitFor(() => {
+      const latestProps = branchListProps.find((p) => p.branches?.length);
+      expect(latestProps?.branches?.length ?? 0).toBeGreaterThan(0);
+    });
+
+    // Simulate selecting the branch from the list
+    const listProps =
+      branchListProps.find((p) => p.branches?.length) ??
+      branchListProps.at(-1);
+    expect(listProps?.branches?.length).toBeGreaterThan(0);
+    listProps.onSelect(listProps.branches[0]);
+
+    await waitFor(() => {
+      expect(branchActionProps.length).toBeGreaterThan(0);
+    });
+
+    // Use existing branch (non-protected) to navigate to AI tool selector
+    const actionProps = branchActionProps.at(-1);
+    actionProps.onUseExisting();
+
+    await waitFor(() => {
+      expect(aiToolScreenProps.length).toBeGreaterThan(0);
+    });
+
+    const props = aiToolScreenProps.at(-1) as { initialToolId?: string };
+    expect(props.initialToolId).toBe("codex-cli");
+  });
+
   it("switches local protected branches via root workflow and navigates to AI tool", async () => {
     mockedGetAllBranches.mockResolvedValue(baseBranches);
     mockedListAdditionalWorktrees.mockResolvedValue([]);

package/src/cli/ui/__tests__/utils/branchFormatter.test.ts

@@ -45,6 +45,30 @@ describe("branchFormatter", () => {
       expect(result.value).toBe("feature/new-ui");
     });
 
+    it("should include last tool usage label when present", () => {
+      const branchInfo: BranchInfo = {
+        name: "feature/tool",
+        type: "local",
+        branchType: "feature",
+        isCurrent: false,
+        lastToolUsage: {
+          branch: "feature/tool",
+          worktreePath: "/tmp/wt",
+          toolId: "codex-cli",
+          toolLabel: "Codex",
+          mode: "normal",
+          timestamp: Date.UTC(2025, 10, 26, 14, 3), // 2025-11-26 14:03 UTC
+          model: "gpt-5.1-codex",
+        },
+      };
+
+      const result = formatBranchItem(branchInfo);
+
+      expect(result.lastToolUsageLabel).toContain("Codex");
+      expect(result.lastToolUsageLabel).toContain("New");
+      expect(result.lastToolUsageLabel).toContain("2025-11-26");
+    });
+
     it("should format a bugfix branch", () => {
       const branchInfo: BranchInfo = {
         name: "bugfix/security-issue",
@@ -59,6 +83,19 @@ describe("branchFormatter", () => {
       expect(result.label).toContain("bugfix/security-issue");
     });
 
+    it("should set lastToolUsageLabel to null when no usage exists", () => {
+      const branchInfo: BranchInfo = {
+        name: "feature/no-usage",
+        type: "local",
+        branchType: "feature",
+        isCurrent: false,
+      };
+
+      const result = formatBranchItem(branchInfo);
+
+      expect(result.lastToolUsageLabel).toBeNull();
+    });
+
     it("should format a hotfix branch", () => {
       const branchInfo: BranchInfo = {
         name: "hotfix/critical-bug",

package/src/cli/ui/components/App.tsx

@@ -110,6 +110,7 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
   const [lastModelByTool, setLastModelByTool] = useState<
     Record<AITool, ModelSelectionResult | undefined>
   >({});
+  const [preferredToolId, setPreferredToolId] = useState<AITool | null>(null);
 
   // PR cleanup feedback
   const [cleanupIndicators, setCleanupIndicators] = useState<
@@ -200,6 +201,19 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
     }
   }, [branches, hiddenBranches]);
 
+  // Update preferred tool when branch or data changes
+  useEffect(() => {
+    if (!selectedBranch) return;
+    const branchMatch =
+      branches.find((b) => b.name === selectedBranch.name) ||
+      branches.find(
+        (b) =>
+          selectedBranch.branchType === "remote" &&
+          b.name === selectedBranch.displayName,
+      );
+    setPreferredToolId(branchMatch?.lastToolUsage?.toolId ?? null);
+  }, [branches, selectedBranch]);
+
   useEffect(
     () => () => {
       if (completionTimerRef.current) {
@@ -387,6 +401,7 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
       setSelectedTool(null);
       setSelectedModel(null);
       setCreationSourceBranch(null);
+      setPreferredToolId(item.lastToolUsage?.toolId ?? null);
 
       if (protectedSelected) {
         setCleanupFooterMessage({
@@ -419,6 +434,8 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
 
   const handleWorktreeSelect = useCallback(
     (worktree: WorktreeItem) => {
+      const lastTool = branches.find((b) => b.name === worktree.branch)
+        ?.lastToolUsage?.toolId;
       setSelectedBranch({
         name: worktree.branch,
         displayName: worktree.branch,
@@ -428,6 +445,7 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
       setSelectedTool(null);
       setSelectedModel(null);
       setCreationSourceBranch(null);
+      setPreferredToolId(lastTool ?? null);
       setCleanupFooterMessage(null);
       navigateTo("ai-tool-selector");
     },
@@ -436,6 +454,7 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
       navigateTo,
       setCleanupFooterMessage,
       setCreationSourceBranch,
+      branches,
     ],
   );
 
@@ -541,6 +560,7 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
         });
         setSelectedTool(null);
         setSelectedModel(null);
+        setPreferredToolId(null);
         setCleanupFooterMessage(null);
 
         navigateTo("ai-tool-selector");
@@ -900,6 +920,7 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
             onBack={goBack}
             onSelect={handleToolSelect}
             version={version}
+            initialToolId={selectedTool ?? preferredToolId ?? null}
           />
         );
 

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

@@ -18,6 +18,7 @@ export interface AIToolSelectorScreenProps {
   onBack: () => void;
   onSelect: (tool: AITool) => void;
   version?: string | null;
+  initialToolId?: AITool | null;
 }
 
 /**
@@ -30,10 +31,12 @@ export function AIToolSelectorScreen({
   onBack,
   onSelect,
   version,
+  initialToolId,
 }: AIToolSelectorScreenProps) {
   const { rows } = useTerminalSize();
   const [toolItems, setToolItems] = useState<AIToolItem[]>([]);
   const [isLoading, setIsLoading] = useState(true);
+  const [selectedIndex, setSelectedIndex] = useState<number>(0);
 
   // Load tools from getAllTools()
   useEffect(() => {
@@ -61,6 +64,13 @@ export function AIToolSelectorScreen({
         });
 
         setToolItems(items);
+
+        // Decide initial cursor position based on last used tool
+        const idx =
+          initialToolId && items.length > 0
+            ? items.findIndex((item) => item.value === initialToolId)
+            : 0;
+        setSelectedIndex(idx >= 0 ? idx : 0);
       } catch (error) {
         // If loading fails, show error in console but don't crash
         console.error("Failed to load tools:", error);
@@ -72,7 +82,17 @@ export function AIToolSelectorScreen({
     };
 
     loadTools();
-  }, []);
+  }, [initialToolId]);
+
+  // Update selection when props or items change
+  useEffect(() => {
+    if (isLoading || toolItems.length === 0) return;
+    const idx =
+      initialToolId && toolItems.length > 0
+        ? toolItems.findIndex((item) => item.value === initialToolId)
+        : 0;
+    setSelectedIndex(idx >= 0 ? idx : 0);
+  }, [initialToolId, toolItems, isLoading]);
 
   // Handle keyboard input
   // Note: Select component handles Enter and arrow keys
@@ -110,7 +130,12 @@ export function AIToolSelectorScreen({
             No tools available. Please check your configuration.
           </Text>
         ) : (
-          <Select items={toolItems} onSelect={handleSelect} />
+          <Select
+            items={toolItems}
+            onSelect={handleSelect}
+            selectedIndex={selectedIndex}
+            onSelectedIndexChange={setSelectedIndex}
+          />
         )}
       </Box>
 

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

@@ -279,7 +279,12 @@ export function BranchListScreen({
       // Use a small safety margin to avoid terminal-dependent wrapping
       const columns = Math.max(20, context.columns - 1);
       const arrow = isSelected ? ">" : " ";
-      const timestampText = formatLatestCommit(item.latestCommitTimestamp);
+      const commitText = formatLatestCommit(item.latestCommitTimestamp);
+      const infoText =
+        item.lastToolUsage && item.lastToolUsageLabel
+          ? item.lastToolUsageLabel
+          : `${chalk.gray("Unknown")}${commitText !== "---" ? ` | ${commitText}` : ""}`;
+      const timestampText = infoText;
       const timestampWidth = stringWidth(timestampText);
 
       const indicatorInfo = cleanupUI?.indicators?.[item.name];

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

@@ -9,6 +9,7 @@ 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";
 
 export interface UseGitDataOptions {
   enableAutoRefresh?: boolean;
@@ -52,10 +53,17 @@ export function useGitData(options?: UseGitDataOptions): UseGitDataResult {
         }
       }
 
-      const [branchesData, worktreesData] = await Promise.all([
-        getAllBranches(),
-        listAdditionalWorktrees(),
-      ]);
+      const branchesData = await getAllBranches();
+      let worktreesData: GitWorktreeInfo[] = [];
+      try {
+        worktreesData = await listAdditionalWorktrees();
+      } catch (err) {
+        if (process.env.DEBUG) {
+          console.error("Failed to list additional worktrees:", err);
+        }
+        worktreesData = [];
+      }
+      const lastToolUsageMap = await getLastToolUsageMap(repoRoot);
 
       // Store worktrees separately
       setWorktrees(worktreesData);
@@ -117,6 +125,9 @@ export function useGitData(options?: UseGitDataOptions): UseGitDataResult {
                   },
                 }
               : {}),
+            ...(lastToolUsageMap.get(branch.name)
+              ? { lastToolUsage: lastToolUsageMap.get(branch.name) ?? null }
+              : {}),
           };
         }),
       );

package/src/cli/ui/types.ts

@@ -5,8 +5,11 @@ export interface WorktreeInfo {
   isAccessible?: boolean;
 }
 
+import type { LastToolUsage } from "../../types/api.js";
+
 export type AITool = string;
 export type InferenceLevel = "low" | "medium" | "high" | "xhigh";
+export type { LastToolUsage } from "../../types/api.js";
 
 export interface ModelOption {
   id: string;
@@ -35,6 +38,7 @@ export interface BranchInfo {
   openPR?: { number: number; title: string };
   mergedPR?: { number: number; mergedAt: string };
   latestCommitTimestamp?: number;
+  lastToolUsage?: LastToolUsage | null;
 }
 
 export interface BranchChoice {
@@ -204,6 +208,7 @@ export interface BranchItem extends BranchInfo {
   hasChanges: boolean;
   label: string;
   value: string;
+  lastToolUsageLabel?: string | null;
 }
 
 /**

package/src/cli/ui/utils/branchFormatter.ts

@@ -6,6 +6,7 @@ import type {
   WorktreeInfo,
 } from "../types.js";
 import stringWidth from "string-width";
+import chalk from "chalk";
 
 // Icon mappings
 const branchIcons: Record<BranchType, string> = {
@@ -69,6 +70,51 @@ export interface FormatOptions {
   hasChanges?: boolean;
 }
 
+function mapToolLabel(toolId: string, toolLabel?: string): string {
+  if (toolId === "claude-code") return "Claude";
+  if (toolId === "codex-cli") return "Codex";
+  if (toolId === "gemini-cli") return "Gemini";
+  if (toolId === "qwen-cli") return "Qwen";
+  if (toolLabel) return toolLabel;
+  return "Custom";
+}
+
+function mapModeLabel(
+  mode?: "normal" | "continue" | "resume" | null,
+): string | null {
+  if (mode === "normal") return "New";
+  if (mode === "continue") return "Continue";
+  if (mode === "resume") return "Resume";
+  return null;
+}
+
+function formatTimestamp(ts: number): string {
+  const date = new Date(ts);
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  return `${year}-${month}-${day} ${hours}:${minutes}`;
+}
+
+function buildLastToolUsageLabel(
+  usage?: BranchInfo["lastToolUsage"] | null,
+): string | null {
+  if (!usage) return null;
+  const toolText = mapToolLabel(usage.toolId, usage.toolLabel);
+  const modeText = mapModeLabel(usage.mode);
+  const timestamp = usage.timestamp ? formatTimestamp(usage.timestamp) : null;
+  const parts = [toolText];
+  if (modeText) {
+    parts.push(modeText);
+  }
+  if (timestamp) {
+    parts.push(timestamp);
+  }
+  return parts.join(" | ");
+}
+
 /**
  * Converts BranchInfo to BranchItem with display properties
  */
@@ -171,6 +217,7 @@ export function formatBranchItem(
     hasChanges,
     label,
     value: branch.name,
+    lastToolUsageLabel: buildLastToolUsageLabel(branch.lastToolUsage),
   };
 }
 

package/src/config/index.ts

@@ -16,6 +16,20 @@ export interface SessionData {
   lastUsedTool?: string;
   timestamp: number;
   repositoryRoot: string;
+  mode?: "normal" | "continue" | "resume";
+  model?: string | null;
+  toolLabel?: string | null;
+  history?: ToolSessionEntry[];
+}
+
+export interface ToolSessionEntry {
+  branch: string;
+  worktreePath: string | null;
+  toolId: string;
+  toolLabel: string;
+  mode?: "normal" | "continue" | "resume" | null;
+  model?: string | null;
+  timestamp: number;
 }
 
 const DEFAULT_CONFIG: AppConfig = {
@@ -104,7 +118,38 @@ export async function saveSession(sessionData: SessionData): Promise<void> {
     // ディレクトリを作成
     await mkdir(sessionDir, { recursive: true });
 
-    await writeFile(sessionPath, JSON.stringify(sessionData, null, 2), "utf-8");
+    // 既存履歴を読み込み（後方互換のため失敗は無視）
+    let existingHistory: ToolSessionEntry[] = [];
+    try {
+      const currentContent = await readFile(sessionPath, "utf-8");
+      const parsed = JSON.parse(currentContent) as SessionData;
+      if (Array.isArray(parsed.history)) {
+        existingHistory = parsed.history;
+      }
+    } catch {
+      // ignore
+    }
+
+    // 新しい履歴エントリを追加（branch/worktree/toolが揃っている場合のみ）
+    if (sessionData.lastBranch && sessionData.lastWorktreePath) {
+      const entry: ToolSessionEntry = {
+        branch: sessionData.lastBranch,
+        worktreePath: sessionData.lastWorktreePath,
+        toolId: sessionData.lastUsedTool ?? "unknown",
+        toolLabel: sessionData.toolLabel ?? sessionData.lastUsedTool ?? "Custom",
+        mode: sessionData.mode ?? null,
+        model: sessionData.model ?? null,
+        timestamp: sessionData.timestamp,
+      };
+      existingHistory = [...existingHistory, entry].slice(-100); // keep latest 100
+    }
+
+    const payload: SessionData = {
+      ...sessionData,
+      history: existingHistory,
+    };
+
+    await writeFile(sessionPath, JSON.stringify(payload, null, 2), "utf-8");
   } catch (error) {
     // セッション保存の失敗は致命的ではないため、エラーをログに出力するのみ
     if (process.env.DEBUG_SESSION) {
@@ -192,3 +237,44 @@ export async function getAllSessions(): Promise<SessionData[]> {
     return [];
   }
 }
+
+/**
+ * 各ブランチの最新ツール利用履歴を取得
+ */
+export async function getLastToolUsageMap(
+  repositoryRoot: string,
+): Promise<Map<string, ToolSessionEntry>> {
+  const map = new Map<string, ToolSessionEntry>();
+  try {
+    const sessionPath = getSessionFilePath(repositoryRoot);
+    const content = await readFile(sessionPath, "utf-8");
+    const parsed = JSON.parse(content) as SessionData;
+
+    const history: ToolSessionEntry[] = Array.isArray(parsed.history)
+      ? parsed.history
+      : [];
+
+    // 後方互換: historyが無い場合はlastUsedToolを1件扱い
+    if (!history.length && parsed.lastBranch && parsed.lastWorktreePath) {
+      history.push({
+        branch: parsed.lastBranch,
+        worktreePath: parsed.lastWorktreePath,
+        toolId: parsed.lastUsedTool ?? "unknown",
+        toolLabel: parsed.toolLabel ?? parsed.lastUsedTool ?? "Custom",
+        mode: parsed.mode ?? null,
+        model: parsed.model ?? null,
+        timestamp: parsed.timestamp ?? Date.now(),
+      });
+    }
+
+    for (const entry of history) {
+      const existing = map.get(entry.branch);
+      if (!existing || existing.timestamp < entry.timestamp) {
+        map.set(entry.branch, entry);
+      }
+    }
+  } catch {
+    // セッションファイルが無い/壊れている場合は空のMapを返す
+  }
+  return map;
+}