@akiojin/gwt 4.11.6 → 4.12.0

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/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/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,
+  );
+}

package/src/codex.ts

@@ -13,6 +13,10 @@ import {
   waitForCodexSessionId,
 } from "./utils/session.js";
 import { findCommand } from "./utils/command.js";
+import {
+  runAgentWithPty,
+  shouldCaptureAgentOutput,
+} from "./logging/agentOutput.js";
 
 const CODEX_CLI_PACKAGE = "@openai/codex";
 
@@ -96,6 +100,7 @@ export async function launchCodexCLI(
     model?: string;
     reasoningEffort?: CodexReasoningEffort;
     sessionId?: string | null;
+    branch?: string | null;
     version?: string | null;
   } = {},
 ): Promise<{ sessionId?: string | null }> {
@@ -175,8 +180,6 @@ export async function launchCodexCLI(
     terminal.exitRawMode();
     resetTerminalModes(terminal.stdout);
 
-    const childStdio = createChildStdio();
-
     const env = Object.fromEntries(
       Object.entries({
         ...process.env,
@@ -185,6 +188,8 @@ export async function launchCodexCLI(
         (entry): entry is [string, string] => typeof entry[1] === "string",
       ),
     );
+    const captureOutput = shouldCaptureAgentOutput(env);
+    const childStdio = captureOutput ? null : createChildStdio();
 
     // Auto-detect locally installed codex command
     const codexLookup = await findCommand("codex");
@@ -201,10 +206,57 @@ export async function launchCodexCLI(
         throw execError;
       }
     };
+    // Treat SIGHUP (1), SIGINT (2), SIGTERM (15) as normal exit signals
+    // SIGHUP can occur when the PTY closes, SIGINT/SIGTERM are user interrupts
+    const isNormalExitSignal = (signal?: number | null) =>
+      signal === 1 || signal === 2 || signal === 15;
+    const runCommand = async (command: string, commandArgs: string[]) => {
+      if (captureOutput) {
+        const result = await runAgentWithPty({
+          command,
+          args: commandArgs,
+          cwd: worktreePath,
+          env,
+          agentId: "codex-cli",
+        });
+        if (isNormalExitSignal(result.signal)) {
+          return;
+        }
+        if (result.exitCode !== null && result.exitCode !== 0) {
+          throw new Error(
+            `Codex CLI exited with code ${result.exitCode ?? "unknown"}`,
+          );
+        }
+        return;
+      }
+
+      if (!childStdio) {
+        return;
+      }
+
+      const child = execa(command, commandArgs, {
+        cwd: worktreePath,
+        stdin: childStdio.stdin,
+        stdout: childStdio.stdout,
+        stderr: childStdio.stderr,
+        env,
+      });
+      await execChild(child);
+    };
 
     // Determine execution strategy based on version selection
     // FR-063b: "installed" option only appears when local command exists
-    const selectedVersion = options.version ?? "installed";
+    const requestedVersion = options.version ?? "latest";
+    let selectedVersion = requestedVersion;
+
+    if (requestedVersion === "installed" && !codexLookup.path) {
+      writeTerminalLine(
+        chalk.yellow(
+          "   ⚠️  Installed codex command not found. Falling back to latest.",
+        ),
+      );
+      selectedVersion = "latest";
+    }
 
     // Log version information (FR-072)
     if (selectedVersion === "installed") {
@@ -220,30 +272,16 @@ export async function launchCodexCLI(
         writeTerminalLine(
           chalk.green("   ✨ Using locally installed codex command"),
         );
-        const child = execa(codexLookup.path, args, {
-          cwd: worktreePath,
-          stdin: childStdio.stdin,
-          stdout: childStdio.stdout,
-          stderr: childStdio.stderr,
-          env,
-        });
-        await execChild(child);
+        await runCommand(codexLookup.path, args);
       } else {
         // FR-067, FR-068: Use bunx with version suffix for latest/specific versions
         const packageWithVersion = `${CODEX_CLI_PACKAGE}@${selectedVersion}`;
         writeTerminalLine(chalk.cyan(`   🔄 Using bunx ${packageWithVersion}`));
 
-        const child = execa("bunx", [packageWithVersion, ...args], {
-          cwd: worktreePath,
-          stdin: childStdio.stdin,
-          stdout: childStdio.stdout,
-          stderr: childStdio.stderr,
-          env,
-        });
-        await execChild(child);
+        await runCommand("bunx", [packageWithVersion, ...args]);
       }
     } finally {
-      childStdio.cleanup();
+      childStdio?.cleanup();
     }
 
     // File-based session detection only - no stdout capture
@@ -257,6 +295,10 @@ export async function launchCodexCLI(
         preferClosestTo: finishedAt,
         windowMs: 10 * 60 * 1000,
         cwd: worktreePath,
+        branch: options.branch ?? null,
+        worktrees: options.branch
+          ? [{ path: worktreePath, branch: options.branch }]
+          : null,
       });
       const detectedSessionId = latest?.id ?? null;
       // When we explicitly resumed a specific session, keep that ID as the source of truth.

package/src/config/__tests__/saveSession.test.ts

@@ -53,7 +53,7 @@ describe("saveSession", () => {
     expect(loaded?.history?.[0]?.toolVersion).toBe("2.1.1");
   });
 
-  it("should save null toolVersion when not provided", async () => {
+  it("should save latest toolVersion when not provided", async () => {
     // Arrange
     const sessionData = {
       lastWorktreePath: testRepoRoot,
@@ -73,7 +73,7 @@ describe("saveSession", () => {
     // Assert
     expect(loaded).not.toBeNull();
     expect(loaded?.history).toHaveLength(1);
-    expect(loaded?.history?.[0]?.toolVersion).toBeNull();
+    expect(loaded?.history?.[0]?.toolVersion).toBe("latest");
   });
 
   it("should preserve toolVersion across multiple saves", async () => {

package/src/config/index.ts

@@ -48,6 +48,14 @@ const DEFAULT_CONFIG: AppConfig = {
   worktreeNamingPattern: "{repo}-{branch}",
 };
 
+function normalizeToolVersion(version?: string | null): string {
+  if (!version) {
+    return "latest";
+  }
+  const trimmed = version.trim();
+  return trimmed.length > 0 ? trimmed : "latest";
+}
+
 /**
  * 設定ファイルを読み込む
  */
@@ -121,6 +129,7 @@ export async function saveSession(
   try {
     const sessionPath = getSessionFilePath(sessionData.repositoryRoot);
     const sessionDir = path.dirname(sessionPath);
+    const resolvedToolVersion = normalizeToolVersion(sessionData.toolVersion);
 
     // ディレクトリを作成
     await mkdir(sessionDir, { recursive: true });
@@ -154,7 +163,7 @@ export async function saveSession(
         model: sessionData.model ?? null,
         reasoningLevel: sessionData.reasoningLevel ?? null,
         skipPermissions: sessionData.skipPermissions ?? false,
-        toolVersion: sessionData.toolVersion ?? null,
+        toolVersion: resolvedToolVersion,
         timestamp: sessionData.timestamp,
       };
       existingHistory = [...existingHistory, entry].slice(-100); // keep latest 100
@@ -166,6 +175,7 @@ export async function saveSession(
       lastSessionId: sessionData.lastSessionId ?? null,
       reasoningLevel: sessionData.reasoningLevel ?? null,
       skipPermissions: sessionData.skipPermissions ?? false,
+      toolVersion: resolvedToolVersion,
     };
 
     await writeFile(sessionPath, JSON.stringify(payload, null, 2), "utf-8");