@akiojin/gwt 4.9.1 → 4.11.6

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

@@ -1,4 +1,9 @@
 import type { SessionData, ToolSessionEntry } from "../../../config/index.js";
+import {
+  findLatestClaudeSessionId,
+  findLatestCodexSessionId,
+  findLatestGeminiSessionId,
+} from "../../../utils/session.js";
 
 export interface ContinueSessionContext {
   history: ToolSessionEntry[];
@@ -6,6 +11,10 @@ export interface ContinueSessionContext {
   branch: string;
   toolId: string;
   repoRoot: string | null;
+  lookupLatestSessionId?: (params: {
+    toolId: string;
+    worktreePath: string;
+  }) => Promise<string | null>;
 }
 
 /**
@@ -41,6 +50,41 @@ export async function resolveContinueSessionId(
     return sessionData.lastSessionId;
   }
 
+  const latestEntry = findLatestBranchSession(history, branch, toolId);
+  const worktreePath = latestEntry?.worktreePath ?? null;
+  if (!worktreePath) {
+    return null;
+  }
+
+  if (context.lookupLatestSessionId) {
+    const lookupResult = await context.lookupLatestSessionId({
+      toolId,
+      worktreePath,
+    });
+    return lookupResult ?? null;
+  }
+
+  return lookupLatestSessionIdForTool(toolId, worktreePath);
+}
+
+async function lookupLatestSessionIdForTool(
+  toolId: string,
+  worktreePath: string,
+): Promise<string | null> {
+  try {
+    if (toolId === "claude-code") {
+      return await findLatestClaudeSessionId(worktreePath);
+    }
+    if (toolId === "codex-cli") {
+      return await findLatestCodexSessionId({ cwd: worktreePath });
+    }
+    if (toolId === "gemini-cli") {
+      return await findLatestGeminiSessionId(worktreePath);
+    }
+  } catch {
+    return null;
+  }
+
   return null;
 }
 

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

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect } from "bun:test";
 import {
   getModelOptions,
   getDefaultInferenceForModel,

package/src/codex.ts

@@ -6,10 +6,15 @@ import {
   createChildStdio,
   getTerminalStreams,
   resetTerminalModes,
+  writeTerminalLine,
 } from "./utils/terminal.js";
-import { findLatestCodexSession } from "./utils/session.js";
+import {
+  findLatestCodexSession,
+  waitForCodexSessionId,
+} from "./utils/session.js";
+import { findCommand } from "./utils/command.js";
 
-const CODEX_CLI_PACKAGE = "@openai/codex@latest";
+const CODEX_CLI_PACKAGE = "@openai/codex";
 
 /**
  * Reasoning effort levels supported by Codex CLI.
@@ -91,6 +96,7 @@ export async function launchCodexCLI(
     model?: string;
     reasoningEffort?: CodexReasoningEffort;
     sessionId?: string | null;
+    version?: string | null;
   } = {},
 ): Promise<{ sessionId?: string | null }> {
   const terminal = getTerminalStreams();
@@ -101,16 +107,16 @@ export async function launchCodexCLI(
       throw new Error(`Worktree path does not exist: ${worktreePath}`);
     }
 
-    console.log(chalk.blue("🚀 Launching Codex CLI..."));
-    console.log(chalk.gray(`   Working directory: ${worktreePath}`));
+    writeTerminalLine(chalk.blue("🚀 Launching Codex CLI..."));
+    writeTerminalLine(chalk.gray(`   Working directory: ${worktreePath}`));
 
     const args: string[] = [];
     const model = options.model ?? DEFAULT_CODEX_MODEL;
     const reasoningEffort =
       options.reasoningEffort ?? DEFAULT_CODEX_REASONING_EFFORT;
 
-    console.log(chalk.green(`   🎯 Model: ${model}`));
-    console.log(chalk.green(`   🧠 Reasoning: ${reasoningEffort}`));
+    writeTerminalLine(chalk.green(`   🎯 Model: ${model}`));
+    writeTerminalLine(chalk.green(`   🧠 Reasoning: ${reasoningEffort}`));
 
     const resumeSessionId =
       options.sessionId && options.sessionId.trim().length > 0
@@ -124,36 +130,36 @@ export async function launchCodexCLI(
       case "continue":
         if (resumeSessionId) {
           args.push("resume", resumeSessionId);
-          console.log(
+          writeTerminalLine(
             chalk.cyan(
               `   ⏭️  Resuming specific Codex session: ${resumeSessionId}`,
             ),
           );
         } else {
           args.push("resume", "--last");
-          console.log(chalk.cyan("   ⏭️  Resuming last Codex session"));
+          writeTerminalLine(chalk.cyan("   ⏭️  Resuming last Codex session"));
         }
         break;
       case "resume":
         if (resumeSessionId) {
           args.push("resume", resumeSessionId);
-          console.log(
+          writeTerminalLine(
             chalk.cyan(`   🔄 Resuming Codex session: ${resumeSessionId}`),
           );
         } else {
           args.push("resume");
-          console.log(chalk.cyan("   🔄 Resume command"));
+          writeTerminalLine(chalk.cyan("   🔄 Resume command"));
         }
         break;
       case "normal":
       default:
-        console.log(chalk.green("   ✨ Starting new session"));
+        writeTerminalLine(chalk.green("   ✨ Starting new session"));
         break;
     }
 
     if (options.bypassApprovals) {
       args.push("--yolo");
-      console.log(chalk.yellow("   ⚠️  Bypassing approvals and sandbox"));
+      writeTerminalLine(chalk.yellow("   ⚠️  Bypassing approvals and sandbox"));
     }
 
     if (options.extraArgs && options.extraArgs.length > 0) {
@@ -164,7 +170,7 @@ export async function launchCodexCLI(
 
     args.push(...codexArgs);
 
-    console.log(chalk.gray(`   📋 Args: ${args.join(" ")}`));
+    writeTerminalLine(chalk.gray(`   📋 Args: ${args.join(" ")}`));
 
     terminal.exitRawMode();
     resetTerminalModes(terminal.stdout);
@@ -180,34 +186,68 @@ export async function launchCodexCLI(
       ),
     );
 
-    try {
-      const execChild = async (child: Promise<unknown>) => {
-        try {
-          await child;
-        } catch (execError: unknown) {
-          // Treat SIGINT/SIGTERM as normal exit (user pressed Ctrl+C)
-          const signal = (execError as { signal?: unknown })?.signal;
-          if (signal === "SIGINT" || signal === "SIGTERM") {
-            return;
-          }
-          throw execError;
+    // Auto-detect locally installed codex command
+    const codexLookup = await findCommand("codex");
+
+    const execChild = async (child: Promise<unknown>) => {
+      try {
+        await child;
+      } catch (execError: unknown) {
+        // Treat SIGINT/SIGTERM as normal exit (user pressed Ctrl+C)
+        const signal = (execError as { signal?: unknown })?.signal;
+        if (signal === "SIGINT" || signal === "SIGTERM") {
+          return;
         }
-      };
+        throw execError;
+      }
+    };
 
-      const child = execa("bunx", [CODEX_CLI_PACKAGE, ...args], {
-        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";
+
+    // Log version information (FR-072)
+    if (selectedVersion === "installed") {
+      writeTerminalLine(chalk.green(`   📦 Version: installed`));
+    } else {
+      writeTerminalLine(chalk.green(`   📦 Version: @${selectedVersion}`));
+    }
+
+    try {
+      if (selectedVersion === "installed" && codexLookup.path) {
+        // FR-066: Use locally installed command when "installed" is selected
+        // FR-063b guarantees local command exists when this option is shown
+        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);
+      } 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);
+      }
     } finally {
       childStdio.cleanup();
     }
 
     // File-based session detection only - no stdout capture
-    // Use only findLatestCodexSession with short timeout, skip sessionProbe to avoid hanging
+    // Use only file inspection with a short wait to avoid hanging
     let capturedSessionId: string | null = null;
     const finishedAt = Date.now();
     try {
@@ -226,14 +266,25 @@ export async function launchCodexCLI(
     } catch {
       capturedSessionId = usedExplicitSessionId ? resumeSessionId : null;
     }
+    const shouldSkipWait =
+      typeof process !== "undefined" &&
+      (process.env?.NODE_ENV === "test" || Boolean(process.env?.VITEST));
+    if (!capturedSessionId && !shouldSkipWait) {
+      capturedSessionId = await waitForCodexSessionId({
+        startedAt,
+        timeoutMs: 15_000,
+        pollIntervalMs: 1_000,
+        cwd: worktreePath,
+      });
+    }
 
     if (capturedSessionId) {
-      console.log(chalk.cyan(`\n   🆔 Session ID: ${capturedSessionId}`));
-      console.log(
+      writeTerminalLine(chalk.cyan(`\n   🆔 Session ID: ${capturedSessionId}`));
+      writeTerminalLine(
         chalk.gray(`   Resume command: codex resume ${capturedSessionId}`),
       );
     } else {
-      console.log(
+      writeTerminalLine(
         chalk.yellow(
           "\n   ℹ️  Could not determine Codex session ID automatically.",
         ),
@@ -250,19 +301,25 @@ export async function launchCodexCLI(
         : `Failed to launch Codex CLI: ${details || "Unknown error"}`;
 
     if (platform() === "win32") {
-      console.error(chalk.red("\n💡 Windows troubleshooting tips:"));
-      console.error(
+      writeTerminalLine(
+        chalk.red("\n💡 Windows troubleshooting tips:"),
+        "stderr",
+      );
+      writeTerminalLine(
         chalk.yellow(
           "   1. Confirm that Bun is installed and bunx is available",
         ),
+        "stderr",
       );
-      console.error(
+      writeTerminalLine(
         chalk.yellow(
           '   2. Run "bunx @openai/codex@latest -- --help" to verify the setup',
         ),
+        "stderr",
       );
-      console.error(
+      writeTerminalLine(
         chalk.yellow("   3. Restart your terminal or IDE to refresh PATH"),
+        "stderr",
       );
     }
 
@@ -278,12 +335,12 @@ export async function launchCodexCLI(
  */
 export async function isCodexAvailable(): Promise<boolean> {
   try {
-    await execa("bunx", [CODEX_CLI_PACKAGE, "--help"]);
+    await execa("bunx", [`${CODEX_CLI_PACKAGE}@latest`, "--help"]);
     return true;
   } catch (error: unknown) {
     const err = error as NodeJS.ErrnoException;
     if (err.code === "ENOENT") {
-      console.error(chalk.yellow("\n⚠️  bunx command not found"));
+      writeTerminalLine(chalk.yellow("\n⚠️  bunx command not found"), "stderr");
     }
     return false;
   }

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

@@ -0,0 +1,143 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdir, rm } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+import { saveSession, loadSession } from "../index.js";
+
+describe("saveSession", () => {
+  let testDir: string;
+  let testRepoRoot: string;
+
+  beforeEach(async () => {
+    // Create a unique temporary directory for each test
+    testDir = join(
+      tmpdir(),
+      `gwt-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    testRepoRoot = join(testDir, "test-repo");
+    await mkdir(testRepoRoot, { recursive: true });
+  });
+
+  afterEach(async () => {
+    // Clean up temporary directory
+    try {
+      await rm(testDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  it("should save toolVersion to session history", async () => {
+    // Arrange
+    const sessionData = {
+      lastWorktreePath: testRepoRoot,
+      lastBranch: "feature/test",
+      lastUsedTool: "claude-code",
+      toolLabel: "Claude Code",
+      mode: "normal" as const,
+      model: "opus",
+      reasoningLevel: "high",
+      skipPermissions: false,
+      toolVersion: "2.1.1",
+      timestamp: Date.now(),
+      repositoryRoot: testRepoRoot,
+    };
+
+    // Act
+    await saveSession(sessionData);
+    const loaded = await loadSession(testRepoRoot);
+
+    // Assert
+    expect(loaded).not.toBeNull();
+    expect(loaded?.history).toHaveLength(1);
+    expect(loaded?.history?.[0]?.toolVersion).toBe("2.1.1");
+  });
+
+  it("should save null toolVersion when not provided", async () => {
+    // Arrange
+    const sessionData = {
+      lastWorktreePath: testRepoRoot,
+      lastBranch: "feature/test",
+      lastUsedTool: "claude-code",
+      toolLabel: "Claude Code",
+      mode: "normal" as const,
+      model: "opus",
+      timestamp: Date.now(),
+      repositoryRoot: testRepoRoot,
+    };
+
+    // Act
+    await saveSession(sessionData);
+    const loaded = await loadSession(testRepoRoot);
+
+    // Assert
+    expect(loaded).not.toBeNull();
+    expect(loaded?.history).toHaveLength(1);
+    expect(loaded?.history?.[0]?.toolVersion).toBeNull();
+  });
+
+  it("should preserve toolVersion across multiple saves", async () => {
+    // Arrange - first save with version 1.0.0
+    await saveSession({
+      lastWorktreePath: testRepoRoot,
+      lastBranch: "feature/test",
+      lastUsedTool: "claude-code",
+      toolLabel: "Claude Code",
+      toolVersion: "1.0.0",
+      timestamp: Date.now() - 1000,
+      repositoryRoot: testRepoRoot,
+    });
+
+    // Act - second save with version 2.0.0
+    await saveSession({
+      lastWorktreePath: testRepoRoot,
+      lastBranch: "feature/test",
+      lastUsedTool: "claude-code",
+      toolLabel: "Claude Code",
+      toolVersion: "2.0.0",
+      timestamp: Date.now(),
+      repositoryRoot: testRepoRoot,
+    });
+
+    const loaded = await loadSession(testRepoRoot);
+
+    // Assert - should have 2 entries with different versions
+    expect(loaded?.history).toHaveLength(2);
+    // History is stored oldest first (newest at the end)
+    expect(loaded?.history?.[0]?.toolVersion).toBe("1.0.0");
+    expect(loaded?.history?.[1]?.toolVersion).toBe("2.0.0");
+  });
+
+  it("should not add to history when skipHistory is true", async () => {
+    // Arrange - first save
+    await saveSession({
+      lastWorktreePath: testRepoRoot,
+      lastBranch: "feature/test",
+      lastUsedTool: "claude-code",
+      toolLabel: "Claude Code",
+      toolVersion: "1.0.0",
+      timestamp: Date.now(),
+      repositoryRoot: testRepoRoot,
+    });
+
+    // Act - second save with skipHistory
+    await saveSession(
+      {
+        lastWorktreePath: testRepoRoot,
+        lastBranch: "feature/test",
+        lastUsedTool: "claude-code",
+        toolLabel: "Claude Code",
+        toolVersion: "2.0.0",
+        timestamp: Date.now(),
+        repositoryRoot: testRepoRoot,
+      },
+      { skipHistory: true },
+    );
+
+    const loaded = await loadSession(testRepoRoot);
+
+    // Assert - should still have only 1 entry
+    expect(loaded?.history).toHaveLength(1);
+    expect(loaded?.history?.[0]?.toolVersion).toBe("1.0.0");
+  });
+});

package/src/config/builtin-coding-agents.ts

@@ -17,7 +17,7 @@ export const CLAUDE_CODE_TOOL: CodingAgent = {
   id: "claude-code",
   displayName: "Claude Code",
   type: "bunx",
-  command: "@anthropic-ai/claude-code@latest",
+  command: "@anthropic-ai/claude-code",
   modeArgs: {
     normal: [],
     continue: ["-c"],
@@ -36,7 +36,7 @@ export const CODEX_CLI_TOOL: CodingAgent = {
   id: "codex-cli",
   displayName: "Codex",
   type: "bunx",
-  command: "@openai/codex@latest",
+  command: "@openai/codex",
   defaultArgs: Array.from(CODEX_DEFAULT_ARGS),
   modeArgs: {
     normal: [],
@@ -52,7 +52,7 @@ export const GEMINI_CLI_TOOL: CodingAgent = {
   id: "gemini-cli",
   displayName: "Gemini",
   type: "bunx",
-  command: "@google/gemini-cli@latest",
+  command: "@google/gemini-cli",
   modeArgs: {
     normal: [],
     continue: ["-r", "latest"],
@@ -61,6 +61,21 @@ export const GEMINI_CLI_TOOL: CodingAgent = {
   permissionSkipArgs: ["-y"],
 };
 
+/**
+ * OpenCode のビルトイン定義
+ */
+export const OPENCODE_TOOL: CodingAgent = {
+  id: "opencode",
+  displayName: "OpenCode",
+  type: "bunx",
+  command: "opencode-ai",
+  modeArgs: {
+    normal: [],
+    continue: ["-c"],
+    resume: ["-s"],
+  },
+};
+
 /**
  * すべてのビルトインコーディングエージェント
  */
@@ -68,4 +83,5 @@ export const BUILTIN_CODING_AGENTS: CodingAgent[] = [
   CLAUDE_CODE_TOOL,
   CODEX_CLI_TOOL,
   GEMINI_CLI_TOOL,
+  OPENCODE_TOOL,
 ];

package/src/config/index.ts

@@ -22,6 +22,7 @@ export interface SessionData {
   mode?: "normal" | "continue" | "resume";
   model?: string | null;
   toolLabel?: string | null;
+  toolVersion?: string | null;
   history?: ToolSessionEntry[];
 }
 
@@ -35,6 +36,7 @@ export interface ToolSessionEntry {
   model?: string | null;
   reasoningLevel?: string | null;
   skipPermissions?: boolean | null;
+  toolVersion?: string | null;
   timestamp: number;
 }
 
@@ -152,6 +154,7 @@ export async function saveSession(
         model: sessionData.model ?? null,
         reasoningLevel: sessionData.reasoningLevel ?? null,
         skipPermissions: sessionData.skipPermissions ?? false,
+        toolVersion: sessionData.toolVersion ?? null,
         timestamp: sessionData.timestamp,
       };
       existingHistory = [...existingHistory, entry].slice(-100); // keep latest 100
@@ -277,6 +280,7 @@ export async function getLastToolUsageMap(
         worktreePath: parsed.lastWorktreePath,
         toolId: parsed.lastUsedTool ?? "unknown",
         toolLabel: parsed.toolLabel ?? parsed.lastUsedTool ?? "Custom",
+        sessionId: parsed.lastSessionId ?? null,
         mode: parsed.mode ?? null,
         model: parsed.model ?? null,
         reasoningLevel: parsed.reasoningLevel ?? null,

package/src/config/tools.ts

@@ -52,6 +52,22 @@ export async function loadCodingAgentsConfig(): Promise<CodingAgentsConfig> {
     const content = await readFile(TOOLS_CONFIG_PATH, "utf-8");
     const config = JSON.parse(content) as CodingAgentsConfig;
 
+    // マイグレーション: customTools → customCodingAgents (後方互換性)
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const legacyConfig = config as any;
+    if (!config.customCodingAgents && legacyConfig.customTools) {
+      config.customCodingAgents = legacyConfig.customTools;
+      logger.warn(
+        { path: TOOLS_CONFIG_PATH },
+        "Migrating deprecated 'customTools' to 'customCodingAgents'",
+      );
+    }
+
+    // フォールバック: undefined/null → 空配列
+    if (!config.customCodingAgents) {
+      config.customCodingAgents = [];
+    }
+
     // 検証
     validateCodingAgentsConfig(config);