@akiojin/gwt 4.11.6 → 4.12.1

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

@@ -7,6 +7,31 @@ import type { BranchInfo } from "../../types.js";
 
 // TDD: テストを先に書き、実装は後から行う
 
+const LOCAL_DATE_TIME_FORMATTER = new Intl.DateTimeFormat(undefined, {
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+  hour: "2-digit",
+  minute: "2-digit",
+  hour12: false,
+});
+
+const formatLocalDateTime = (timestampMs: number): string => {
+  const date = new Date(timestampMs);
+  const parts = LOCAL_DATE_TIME_FORMATTER.formatToParts(date);
+  const get = (type: Intl.DateTimeFormatPartTypes) =>
+    parts.find((part) => part.type === type)?.value;
+  const year = get("year");
+  const month = get("month");
+  const day = get("day");
+  const hour = get("hour");
+  const minute = get("minute");
+  if (!year || !month || !day || !hour || !minute) {
+    return LOCAL_DATE_TIME_FORMATTER.format(date);
+  }
+  return `${year}-${month}-${day} ${hour}:${minute}`;
+};
+
 describe("branchFormatter", () => {
   describe("buildLastToolUsageLabel with version", () => {
     const baseBranch: BranchInfo = {
@@ -31,7 +56,11 @@ describe("branchFormatter", () => {
       };
 
       const item = formatBranchItem(branch);
-      expect(item.lastToolUsageLabel).toBe("Claude@1.0.3 | 2024-01-08 12:00");
+      expect(item.lastToolUsageLabel).toBe(
+        `Claude@1.0.3 | ${formatLocalDateTime(
+          new Date("2024-01-08T12:00:00").getTime(),
+        )}`,
+      );
     });
 
     it("should format as 'ToolName@latest | 2024-01-08 12:00' when version is null", () => {
@@ -48,7 +77,11 @@ describe("branchFormatter", () => {
       };
 
       const item = formatBranchItem(branch);
-      expect(item.lastToolUsageLabel).toBe("Claude@latest | 2024-01-08 12:00");
+      expect(item.lastToolUsageLabel).toBe(
+        `Claude@latest | ${formatLocalDateTime(
+          new Date("2024-01-08T12:00:00").getTime(),
+        )}`,
+      );
     });
 
     it("should format as 'ToolName@latest | 2024-01-08 12:00' when version is undefined", () => {
@@ -64,7 +97,11 @@ describe("branchFormatter", () => {
       };
 
       const item = formatBranchItem(branch);
-      expect(item.lastToolUsageLabel).toBe("Claude@latest | 2024-01-08 12:00");
+      expect(item.lastToolUsageLabel).toBe(
+        `Claude@latest | ${formatLocalDateTime(
+          new Date("2024-01-08T12:00:00").getTime(),
+        )}`,
+      );
     });
 
     it("should format Codex with version", () => {
@@ -82,7 +119,9 @@ describe("branchFormatter", () => {
 
       const item = formatBranchItem(branch);
       expect(item.lastToolUsageLabel).toBe(
-        "Codex@2.1.0-beta.1 | 2024-01-08 15:30",
+        `Codex@2.1.0-beta.1 | ${formatLocalDateTime(
+          new Date("2024-01-08T15:30:00").getTime(),
+        )}`,
       );
     });
 
@@ -100,7 +139,11 @@ describe("branchFormatter", () => {
       };
 
       const item = formatBranchItem(branch);
-      expect(item.lastToolUsageLabel).toBe("Gemini@0.5.0 | 2024-01-08 09:15");
+      expect(item.lastToolUsageLabel).toBe(
+        `Gemini@0.5.0 | ${formatLocalDateTime(
+          new Date("2024-01-08T09:15:00").getTime(),
+        )}`,
+      );
     });
 
     it("should format custom tool with version", () => {
@@ -117,7 +160,11 @@ describe("branchFormatter", () => {
       };
 
       const item = formatBranchItem(branch);
-      expect(item.lastToolUsageLabel).toBe("MyTool@1.0.0 | 2024-01-08 10:00");
+      expect(item.lastToolUsageLabel).toBe(
+        `MyTool@1.0.0 | ${formatLocalDateTime(
+          new Date("2024-01-08T10:00:00").getTime(),
+        )}`,
+      );
     });
 
     it("should return null when lastToolUsage is undefined", () => {

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

@@ -0,0 +1,46 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import {
+  clearInstalledVersionCache,
+  getInstalledVersionCache,
+  prefetchInstalledVersions,
+  setInstalledVersionCache,
+} from "../installedVersionCache.js";
+
+describe("installedVersionCache", () => {
+  beforeEach(() => {
+    clearInstalledVersionCache();
+  });
+
+  it("stores and retrieves installed versions", () => {
+    setInstalledVersionCache("claude-code", {
+      version: "1.0.0",
+      path: "/usr/local/bin/claude",
+    });
+
+    const cached = getInstalledVersionCache("claude-code");
+    expect(cached).toEqual({
+      version: "1.0.0",
+      path: "/usr/local/bin/claude",
+    });
+  });
+
+  it("prefetches installed versions with custom fetcher", async () => {
+    await prefetchInstalledVersions(["claude-code", "codex-cli"], async (id) =>
+      id === "claude-code" ? { version: "2.0.0", path: "/opt/claude" } : null,
+    );
+
+    expect(getInstalledVersionCache("claude-code")).toEqual({
+      version: "2.0.0",
+      path: "/opt/claude",
+    });
+    expect(getInstalledVersionCache("codex-cli")).toBeNull();
+  });
+
+  it("stores null when fetcher throws", async () => {
+    await prefetchInstalledVersions(["gemini-cli"], async () => {
+      throw new Error("boom");
+    });
+
+    expect(getInstalledVersionCache("gemini-cli")).toBeNull();
+  });
+});

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

@@ -17,14 +17,42 @@ function mapToolLabel(toolId: string, toolLabel?: string): string {
   return "Custom";
 }
 
+const LOCAL_DATE_TIME_FORMATTER = new Intl.DateTimeFormat(undefined, {
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+  hour: "2-digit",
+  minute: "2-digit",
+  hour12: false,
+});
+
+const formatLocalDateTimeParts = (date: Date): string => {
+  const parts = LOCAL_DATE_TIME_FORMATTER.formatToParts(date);
+  const get = (type: Intl.DateTimeFormatPartTypes) =>
+    parts.find((part) => part.type === type)?.value;
+  const year = get("year");
+  const month = get("month");
+  const day = get("day");
+  const hour = get("hour");
+  const minute = get("minute");
+
+  if (!year || !month || !day || !hour || !minute) {
+    return LOCAL_DATE_TIME_FORMATTER.format(date);
+  }
+
+  return `${year}-${month}-${day} ${hour}:${minute}`;
+};
+
+export function formatLocalDateTime(timestampMs: number): string {
+  const date = new Date(timestampMs);
+  if (Number.isNaN(date.getTime())) {
+    return "";
+  }
+  return formatLocalDateTimeParts(date);
+}
+
 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}`;
+  return formatLocalDateTime(ts);
 }
 
 function buildLastToolUsageLabel(

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

@@ -1,9 +1,15 @@
 import type { SessionData, ToolSessionEntry } from "../../../config/index.js";
+import type { SessionSearchOptions } from "../../../utils/session/index.js";
 import {
+  findLatestClaudeSession,
   findLatestClaudeSessionId,
+  findLatestCodexSession,
   findLatestCodexSessionId,
+  findLatestGeminiSession,
   findLatestGeminiSessionId,
-} from "../../../utils/session.js";
+  findLatestOpenCodeSession,
+} from "../../../utils/session/index.js";
+import { listAllWorktrees } from "../../../worktree.js";
 
 export interface ContinueSessionContext {
   history: ToolSessionEntry[];
@@ -122,10 +128,10 @@ export function findLatestBranchSessionsByTool(
   const byBranch = history.filter((entry) => entry && entry.branch === branch);
   if (!byBranch.length) return [];
 
-  const scoped = worktreePath
+  const source = worktreePath
     ? byBranch.filter((entry) => entry.worktreePath === worktreePath)
     : byBranch;
-  const source = scoped.length ? scoped : byBranch;
+  if (!source.length) return [];
 
   const latestByTool = new Map<string, ToolSessionEntry>();
   for (const entry of source) {
@@ -142,3 +148,84 @@ export function findLatestBranchSessionsByTool(
     (a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0),
   );
 }
+
+export interface QuickStartRefreshContext {
+  branch: string;
+  worktreePath?: string | null;
+}
+
+export interface QuickStartSessionLookups {
+  findLatestCodexSession?: typeof findLatestCodexSession;
+  findLatestClaudeSession?: typeof findLatestClaudeSession;
+  findLatestGeminiSession?: typeof findLatestGeminiSession;
+  findLatestOpenCodeSession?: typeof findLatestOpenCodeSession;
+  listAllWorktrees?: typeof listAllWorktrees;
+}
+
+export async function refreshQuickStartEntries(
+  entries: ToolSessionEntry[],
+  context: QuickStartRefreshContext,
+  lookups: QuickStartSessionLookups = {},
+): Promise<ToolSessionEntry[]> {
+  if (!entries.length) return entries;
+  const worktreePath = context.worktreePath ?? null;
+  if (!worktreePath) return entries;
+
+  const lookupWorktrees = lookups.listAllWorktrees ?? listAllWorktrees;
+  let resolvedWorktrees: { path: string; branch: string }[] | null = null;
+  try {
+    const allWorktrees = await lookupWorktrees();
+    resolvedWorktrees = allWorktrees
+      .filter((entry) => entry?.path && entry?.branch)
+      .map((entry) => ({ path: entry.path, branch: entry.branch }));
+  } catch {
+    resolvedWorktrees = null;
+  }
+
+  const searchOptions: SessionSearchOptions = {
+    branch: context.branch,
+    ...(resolvedWorktrees && resolvedWorktrees.length > 0
+      ? { worktrees: resolvedWorktrees }
+      : {}),
+  };
+
+  const lookupCodex = lookups.findLatestCodexSession ?? findLatestCodexSession;
+  const lookupClaude =
+    lookups.findLatestClaudeSession ?? findLatestClaudeSession;
+  const lookupGemini =
+    lookups.findLatestGeminiSession ?? findLatestGeminiSession;
+  const lookupOpenCode =
+    lookups.findLatestOpenCodeSession ?? findLatestOpenCodeSession;
+
+  const updated = await Promise.all(
+    entries.map(async (entry) => {
+      let latest: { id: string; mtime: number } | null = null;
+      switch (entry.toolId) {
+        case "codex-cli":
+          latest = await lookupCodex(searchOptions);
+          break;
+        case "claude-code":
+          latest = await lookupClaude(worktreePath, searchOptions);
+          break;
+        case "gemini-cli":
+          latest = await lookupGemini(searchOptions);
+          break;
+        case "opencode":
+          latest = await lookupOpenCode(searchOptions);
+          break;
+        default:
+          return entry;
+      }
+
+      if (!latest?.id) return entry;
+      const updatedTimestamp = Math.max(entry.timestamp ?? 0, latest.mtime);
+      return {
+        ...entry,
+        sessionId: latest.id,
+        timestamp: updatedTimestamp,
+      };
+    }),
+  );
+
+  return updated.sort((a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0));
+}

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

@@ -0,0 +1,84 @@
+/**
+ * Installed version cache for coding agents (FR-017)
+ *
+ * Caches locally installed agent versions detected at startup
+ * to avoid async fetch during wizard navigation.
+ */
+
+import type { InstalledVersionInfo } from "./versionFetcher.js";
+import { fetchInstalledVersionForAgent } from "./versionFetcher.js";
+
+/**
+ * In-memory cache for installed versions
+ * Maps agentId -> InstalledVersionInfo | null
+ */
+const installedVersionCache = new Map<string, InstalledVersionInfo | null>();
+
+/**
+ * Type for installed version fetch function (injectable for testing)
+ */
+export type InstalledVersionFetcher = (
+  agentId: string,
+) => Promise<InstalledVersionInfo | null>;
+
+/**
+ * Get cached installed version for an agent
+ * @returns Cached info or null if not installed/unknown
+ */
+export function getInstalledVersionCache(
+  agentId: string,
+): InstalledVersionInfo | null {
+  const cached = installedVersionCache.get(agentId);
+  return cached ?? null;
+}
+
+/**
+ * Set installed version cache (for testing or direct population)
+ */
+export function setInstalledVersionCache(
+  agentId: string,
+  installed: InstalledVersionInfo | null,
+): void {
+  installedVersionCache.set(agentId, installed);
+}
+
+/**
+ * Clear installed version cache
+ */
+export function clearInstalledVersionCache(): void {
+  installedVersionCache.clear();
+}
+
+/**
+ * Prefetch installed versions for multiple agents in parallel
+ * This should be called at application startup
+ *
+ * @param agentIds - List of agent IDs to prefetch
+ * @param fetchFn - Optional custom fetch function (for testing)
+ */
+export async function prefetchInstalledVersions(
+  agentIds: string[],
+  fetchFn?: InstalledVersionFetcher,
+): Promise<void> {
+  const fetcher =
+    fetchFn ??
+    (async (agentId: string) => fetchInstalledVersionForAgent(agentId));
+
+  const results = await Promise.allSettled(
+    agentIds.map(async (agentId) => {
+      try {
+        const installed = await fetcher(agentId);
+        setInstalledVersionCache(agentId, installed);
+      } catch {
+        setInstalledVersionCache(agentId, null);
+      }
+    }),
+  );
+
+  // Swallow any rejections to keep startup non-blocking
+  for (const result of results) {
+    if (result.status === "rejected") {
+      // no-op
+    }
+  }
+}

package/src/cli/ui/utils/modelOptions.test.ts

@@ -75,6 +75,12 @@ describe("modelOptions", () => {
     ]);
   });
 
+  it("includes OpenCode default and custom options", () => {
+    expect(byId("opencode")).toEqual(["", "__custom__"]);
+    const defaultModel = getDefaultModelOption("opencode");
+    expect(defaultModel?.id).toBe("");
+  });
+
   it("normalizes known Claude model typos and casing", () => {
     expect(normalizeModelId("claude-code", "opuss")).toBe("opus");
     expect(normalizeModelId("claude-code", "Opus")).toBe("opus");

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

@@ -103,6 +103,19 @@ const MODEL_OPTIONS: Record<string, ModelOption[]> = {
       description: "Fastest for simple tasks",
     },
   ],
+  opencode: [
+    {
+      id: "",
+      label: "Default (Auto)",
+      description: "Use OpenCode default model",
+      isDefault: true,
+    },
+    {
+      id: "__custom__",
+      label: "Custom (provider/model)",
+      description: "Enter a provider/model identifier",
+    },
+  ],
 };
 
 export function getModelOptions(tool: CodingAgentId): ModelOption[] {
@@ -144,6 +157,9 @@ export function normalizeModelId(
   if (model === null || model === undefined) return model ?? null;
   const trimmed = model.trim();
   if (!trimmed) return null;
+  if (tool === "opencode" && trimmed === "__custom__") {
+    return null;
+  }
   if (tool === "claude-code") {
     const lower = trimmed.toLowerCase();
     if (lower === "opuss") return "opus";

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

@@ -0,0 +1,93 @@
+/**
+ * Version cache for coding agents (FR-028 ~ FR-031)
+ *
+ * Provides caching mechanism for npm package versions to avoid
+ * repeated API calls during wizard navigation.
+ */
+
+import type { VersionInfo } from "../../../utils/npmRegistry.js";
+
+/**
+ * In-memory cache for agent versions
+ * Maps agentId -> VersionInfo[]
+ */
+const versionCache = new Map<string, VersionInfo[]>();
+
+/**
+ * Type for version fetch function (injectable for testing)
+ */
+export type VersionFetcher = (agentId: string) => Promise<VersionInfo[]>;
+
+/**
+ * Get cached versions for an agent
+ * @returns Cached versions or null if not cached
+ */
+export function getVersionCache(agentId: string): VersionInfo[] | null {
+  const cached = versionCache.get(agentId);
+  return cached !== undefined ? cached : null;
+}
+
+/**
+ * Check if versions are cached for an agent
+ */
+export function isVersionCachePopulated(agentId: string): boolean {
+  return versionCache.has(agentId);
+}
+
+/**
+ * Clear all cached versions
+ */
+export function clearVersionCache(): void {
+  versionCache.clear();
+}
+
+/**
+ * Prefetch versions for multiple agents in parallel
+ * This should be called at application startup
+ *
+ * @param agentIds - List of agent IDs to prefetch versions for
+ * @param fetchFn - Optional custom fetch function (for testing)
+ */
+export async function prefetchAgentVersions(
+  agentIds: string[],
+  fetchFn?: VersionFetcher,
+): Promise<void> {
+  // Import default fetcher if not provided
+  const fetcher =
+    fetchFn ??
+    (async (agentId: string) => {
+      const { fetchVersionOptionsForAgent } =
+        await import("./versionFetcher.js");
+      return fetchVersionOptionsForAgent(agentId);
+    });
+
+  // Fetch all versions in parallel
+  const results = await Promise.allSettled(
+    agentIds.map(async (agentId) => {
+      try {
+        const versions = await fetcher(agentId);
+        versionCache.set(agentId, versions);
+      } catch {
+        // On error, don't set cache (getVersionCache will return null)
+      }
+    }),
+  );
+
+  // Log any failures for debugging (silently handled)
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result && result.status === "rejected") {
+      // Silently handle - cache will return null for this agent
+    }
+  }
+}
+
+/**
+ * Set versions in cache (for testing or direct population)
+ */
+export function setVersionCache(
+  agentId: string,
+  versions: VersionInfo[],
+): void {
+  versionCache.set(agentId, versions);
+}

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

@@ -0,0 +1,120 @@
+/**
+ * Version fetcher for coding agents
+ *
+ * Provides functions to fetch version information from npm registry
+ * and local installations.
+ */
+
+import type { VersionInfo } from "../../../utils/npmRegistry.js";
+import {
+  fetchPackageVersions,
+  parsePackageCommand,
+} from "../../../utils/npmRegistry.js";
+import { BUILTIN_CODING_AGENTS } from "../../../config/builtin-coding-agents.js";
+import { findCommand } from "../../../utils/command.js";
+import type { SelectInputItem } from "../components/solid/SelectInput.js";
+
+/**
+ * Get package name for an agent ID (only for bunx-type agents)
+ */
+export function getPackageNameForAgent(agentId: string): string | null {
+  const agent = BUILTIN_CODING_AGENTS.find((a) => a.id === agentId);
+  if (!agent || agent.type !== "bunx") {
+    return null;
+  }
+  const { packageName } = parsePackageCommand(agent.command);
+  return packageName;
+}
+
+/**
+ * Fetch version options for an agent from npm registry
+ */
+export async function fetchVersionOptionsForAgent(
+  agentId: string,
+): Promise<VersionInfo[]> {
+  const packageName = getPackageNameForAgent(agentId);
+  if (!packageName) {
+    return [];
+  }
+  return fetchPackageVersions(packageName);
+}
+
+/**
+ * Agent ID to command name mapping
+ */
+const AGENT_COMMAND_MAP: Record<string, string> = {
+  "claude-code": "claude",
+  "codex-cli": "codex",
+  "gemini-cli": "gemini",
+  opencode: "opencode",
+};
+
+/**
+ * Installed version information
+ */
+export interface InstalledVersionInfo {
+  version: string;
+  path: string;
+}
+
+/**
+ * Fetch installed version information for an agent
+ * Returns null if not installed locally
+ */
+export async function fetchInstalledVersionForAgent(
+  agentId: string,
+): Promise<InstalledVersionInfo | null> {
+  const commandName = AGENT_COMMAND_MAP[agentId];
+  if (!commandName) {
+    return null;
+  }
+
+  const result = await findCommand(commandName);
+  if (result.source !== "installed" || !result.path) {
+    return null;
+  }
+
+  // Version format: v1.0.3 -> 1.0.3
+  const version = result.version?.replace(/^v/, "") ?? "unknown";
+
+  return {
+    version,
+    path: result.path,
+  };
+}
+
+/**
+ * Convert VersionInfo to SelectInputItem for UI
+ */
+export function versionInfoToSelectItem(v: VersionInfo): SelectInputItem {
+  const item: SelectInputItem = {
+    label: v.isPrerelease ? `${v.version} (pre)` : v.version,
+    value: v.version,
+  };
+  if (v.publishedAt) {
+    item.description = new Date(v.publishedAt).toLocaleDateString();
+  }
+  return item;
+}
+
+/**
+ * Create installed option for SelectInput
+ */
+export function createInstalledOption(
+  installed: InstalledVersionInfo,
+): SelectInputItem {
+  return {
+    label: `installed@${installed.version}`,
+    value: "installed",
+    description: installed.path,
+  };
+}
+
+/**
+ * Get all bunx-type agent IDs
+ */
+export function getBunxAgentIds(): string[] {
+  return BUILTIN_CODING_AGENTS.filter((a) => a.type === "bunx").map(
+    (a) => a.id,
+  );
+}