@akiojin/gwt 2.6.1 → 2.8.0

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

@@ -25,6 +25,7 @@ vi.mock("../../../../git.ts", () => ({
   getAllBranches: vi.fn(),
   getRepositoryRoot: vi.fn(async () => "/repo"),
   deleteBranch: vi.fn(async () => undefined),
+  fetchAllRemotes: vi.fn(async () => undefined),
 }));
 
 const { mockIsProtectedBranchName, mockSwitchToProtectedBranch } = vi.hoisted(
@@ -60,6 +61,7 @@ import {
   getAllBranches,
   getRepositoryRoot,
   deleteBranch,
+  fetchAllRemotes,
 } from "../../../../git.ts";
 import {
   listAdditionalWorktrees,
@@ -72,6 +74,7 @@ import {
 const mockedGetAllBranches = getAllBranches as Mock;
 const mockedGetRepositoryRoot = getRepositoryRoot as Mock;
 const mockedDeleteBranch = deleteBranch as Mock;
+const mockedFetchAllRemotes = fetchAllRemotes as Mock;
 const mockedListAdditionalWorktrees = listAdditionalWorktrees as Mock;
 const mockedCreateWorktree = createWorktree as Mock;
 const mockedGenerateWorktreePath = generateWorktreePath as Mock;
@@ -95,6 +98,7 @@ describe("Navigation Integration Tests", () => {
     mockedListAdditionalWorktrees.mockReset();
     mockedGetRepositoryRoot.mockReset();
     mockedDeleteBranch.mockReset();
+    mockedFetchAllRemotes.mockReset();
     mockedCreateWorktree.mockReset();
     mockedGenerateWorktreePath.mockReset();
     mockedGetMergedPRWorktrees.mockReset();
@@ -267,6 +271,7 @@ describe("Protected Branch Navigation (T103)", () => {
     mockedListAdditionalWorktrees.mockReset();
     mockedGetRepositoryRoot.mockReset();
     mockedDeleteBranch.mockReset();
+    mockedFetchAllRemotes.mockReset();
     mockedCreateWorktree.mockReset();
     mockedGenerateWorktreePath.mockReset();
     mockedGetMergedPRWorktrees.mockReset();

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/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

@@ -3,11 +3,13 @@ import {
   getAllBranches,
   hasUnpushedCommitsInRepo,
   getRepositoryRoot,
+  fetchAllRemotes,
 } from "../../../git.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";
 
 export interface UseGitDataOptions {
   enableAutoRefresh?: boolean;
@@ -40,10 +42,28 @@ export function useGitData(options?: UseGitDataOptions): UseGitDataResult {
     setError(null);
 
     try {
-      const [branchesData, worktreesData] = await Promise.all([
-        getAllBranches(),
-        listAdditionalWorktrees(),
-      ]);
+      const repoRoot = await getRepositoryRoot();
+
+      // リモートブランチの最新情報を取得（失敗してもローカル表示は継続）
+      try {
+        await fetchAllRemotes({ cwd: repoRoot });
+      } catch (fetchError) {
+        if (process.env.DEBUG) {
+          console.warn("Failed to fetch remote branches", fetchError);
+        }
+      }
+
+      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);
@@ -61,9 +81,6 @@ export function useGitData(options?: UseGitDataOptions): UseGitDataResult {
         worktreeMap.set(worktree.branch, uiWorktreeInfo);
       }
 
-      // Get repository root for unpushed commits check
-      const repoRoot = await getRepositoryRoot();
-
       // Attach worktree info and check unpushed/PR status for local branches
       const enrichedBranches = await Promise.all(
         branchesData.map(async (branch) => {
@@ -108,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;
+}

package/src/git.ts

@@ -58,27 +58,103 @@ export async function isGitRepository(): Promise<boolean> {
  * @throws {GitError} リポジトリルートの取得に失敗した場合
  */
 export async function getRepositoryRoot(): Promise<string> {
+  const fs = await import("node:fs");
+  const path = await import("node:path");
+
+  const toExistingDir = (p: string): string => {
+    let current = path.resolve(p);
+    while (!fs.existsSync(current) && path.dirname(current) !== current) {
+      current = path.dirname(current);
+    }
+    if (!fs.existsSync(current)) {
+      return current;
+    }
+    try {
+      const stat = fs.statSync(current);
+      return stat.isDirectory() ? current : path.dirname(current);
+    } catch {
+      return current;
+    }
+  };
+
+  // 1) show-toplevel を最優先
+  try {
+    const { stdout } = await execa("git", ["rev-parse", "--show-toplevel"]);
+    const top = stdout.trim();
+    if (top) {
+      const marker = `${path.sep}.worktrees${path.sep}`;
+      const idx = top.indexOf(marker);
+      if (idx >= 0) {
+        // /repo/.worktrees/<name> → repo root = /repo
+        const parent = top.slice(0, idx);
+        const upTwo = path.resolve(top, "..", "..");
+        if (fs.existsSync(parent)) return toExistingDir(parent);
+        if (fs.existsSync(upTwo)) return toExistingDir(upTwo);
+      }
+      if (fs.existsSync(top)) {
+        return toExistingDir(top);
+      }
+      return toExistingDir(path.resolve(top, ".."));
+    }
+  } catch {
+    // fallback
+  }
+
+  // 2) git-common-dir 経由
   try {
-    // git rev-parse --git-common-dirを使用してメインリポジトリの.gitディレクトリを取得
     const { stdout: gitCommonDir } = await execa("git", [
       "rev-parse",
       "--git-common-dir",
     ]);
-    const gitDir = gitCommonDir.trim();
-
-    // .gitディレクトリの親ディレクトリがリポジトリルート
-    const path = await import("node:path");
-    const repoRoot = path.dirname(gitDir);
-
-    // 相対パスが返された場合（.gitなど）は、現在のディレクトリからの相対パスとして解決
-    if (!path.isAbsolute(repoRoot)) {
-      return path.resolve(repoRoot);
+    const gitDir = path.resolve(gitCommonDir.trim());
+    const parts = gitDir.split(path.sep);
+    const idxWorktrees = parts.lastIndexOf("worktrees");
+    if (idxWorktrees > 0) {
+      const repo = parts.slice(0, idxWorktrees).join(path.sep);
+      if (fs.existsSync(repo)) return toExistingDir(repo);
     }
+    const idxGit = parts.lastIndexOf(".git");
+    if (idxGit > 0) {
+      const repo = parts.slice(0, idxGit).join(path.sep);
+      if (fs.existsSync(repo)) return toExistingDir(repo);
+    }
+    return toExistingDir(path.dirname(gitDir));
+  } catch {
+    // fallback
+  }
 
-    return repoRoot;
-  } catch (error) {
-    throw new GitError("Failed to get repository root", error);
+  // 3) .git を上に辿って探す
+  let current = process.cwd();
+  const root = path.parse(current).root;
+  while (true) {
+    const candidate = path.join(current, ".git");
+    if (fs.existsSync(candidate)) {
+      if (fs.statSync(candidate).isDirectory()) {
+        return toExistingDir(current);
+      }
+      try {
+        const content = fs.readFileSync(candidate, "utf-8");
+        const match = content.match(/gitdir:\s*(.+)\s*/i);
+        const gitDirMatch = match?.[1];
+        if (gitDirMatch) {
+          const gitDirPath = path.resolve(current, gitDirMatch.trim());
+          const parts = gitDirPath.split(path.sep);
+          const idxWT = parts.lastIndexOf("worktrees");
+          if (idxWT > 0) {
+            const repo = parts.slice(0, idxWT).join(path.sep);
+            return toExistingDir(repo);
+          }
+          return toExistingDir(path.dirname(gitDirPath));
+        }
+      } catch {
+        // ignore and continue
+      }
+    }
+    if (current === root) break;
+    current = path.dirname(current);
   }
+
+  throw new GitError("Failed to get repository root");
 }
 
 /**
@@ -97,22 +173,33 @@ export async function getWorktreeRoot(): Promise<string> {
 
 export async function getCurrentBranch(): Promise<string | null> {
   try {
-    const { stdout } = await execa("git", ["branch", "--show-current"]);
+    const repoRoot = await getRepositoryRoot();
+    const { stdout } = await execa(
+      "git",
+      ["branch", "--show-current"],
+      { cwd: repoRoot },
+    );
     return stdout.trim() || null;
   } catch {
-    return null;
+    try {
+      const { stdout } = await execa("git", ["branch", "--show-current"]);
+      return stdout.trim() || null;
+    } catch {
+      return null;
+    }
   }
 }
 
 async function getBranchCommitTimestamps(
   refs: string[],
+  cwd?: string,
 ): Promise<Map<string, number>> {
   try {
-    const { stdout } = await execa("git", [
+    const { stdout = "" } = (await execa("git", [
       "for-each-ref",
       "--format=%(refname:short)%00%(committerdate:unix)",
       ...refs,
-    ]);
+    ], cwd ? { cwd } : undefined)) ?? { stdout: "" };
 
     const map = new Map<string, number>();
 
@@ -135,10 +222,9 @@ async function getBranchCommitTimestamps(
 export async function getLocalBranches(): Promise<BranchInfo[]> {
   try {
     const commitMap = await getBranchCommitTimestamps(["refs/heads"]);
-    const { stdout } = await execa("git", [
-      "branch",
-      "--format=%(refname:short)",
-    ]);
+    const { stdout = "" } =
+      (await execa("git", ["branch", "--format=%(refname:short)"])) ??
+      { stdout: "" };
     return stdout
       .split("\n")
       .filter((line) => line.trim())
@@ -156,19 +242,17 @@ export async function getLocalBranches(): Promise<BranchInfo[]> {
             : {}),
         } satisfies BranchInfo;
       });
-  } catch (error) {
-    throw new GitError("Failed to get local branches", error);
+  } catch (primaryError) {
+    throw new GitError("Failed to get local branches", primaryError);
   }
 }
 
 export async function getRemoteBranches(): Promise<BranchInfo[]> {
   try {
     const commitMap = await getBranchCommitTimestamps(["refs/remotes"]);
-    const { stdout } = await execa("git", [
-      "branch",
-      "-r",
-      "--format=%(refname:short)",
-    ]);
+    const { stdout = "" } =
+      (await execa("git", ["branch", "-r", "--format=%(refname:short)"])) ??
+      { stdout: "" };
     return stdout
       .split("\n")
       .filter((line) => line.trim() && !line.includes("HEAD"))
@@ -187,8 +271,8 @@ export async function getRemoteBranches(): Promise<BranchInfo[]> {
             : {}),
         } satisfies BranchInfo;
       });
-  } catch (error) {
-    throw new GitError("Failed to get remote branches", error);
+  } catch (primaryError) {
+    throw new GitError("Failed to get remote branches", primaryError);
   }
 }
 

package/src/index.ts

@@ -670,6 +670,9 @@ export async function handleAIToolWorkflow(
       lastWorktreePath: worktreePath,
       lastBranch: branch,
       lastUsedTool: tool,
+      toolLabel: toolConfig.displayName ?? tool,
+      mode,
+      model: model ?? null,
       timestamp: Date.now(),
       repositoryRoot: repoRoot,
     });

package/src/types/api.ts

@@ -30,6 +30,7 @@ export interface Branch {
     state: "open" | "merged" | "closed";
     mergedAt?: string | null;
   } | null;
+  lastToolUsage?: LastToolUsage | null;
 }
 
 /**
@@ -46,6 +47,7 @@ export interface Worktree {
   lastAccessedAt?: string | null; // ISO8601
   divergence?: Branch["divergence"];
   prInfo?: Branch["prInfo"];
+  lastToolUsage?: LastToolUsage | null;
 }
 
 /**
@@ -102,6 +104,16 @@ export interface CustomAITool {
   updatedAt?: string | null; // ISO8601
 }
 
+export interface LastToolUsage {
+  branch: string;
+  worktreePath: string | null;
+  toolId: string;
+  toolLabel: string;
+  mode?: "normal" | "continue" | "resume" | null;
+  model?: string | null;
+  timestamp: number; // epoch millis
+}
+
 /**
  * REST API Response wrappers
  */