@akiojin/gwt 2.11.0 → 2.12.0

package/src/config/index.ts

@@ -14,6 +14,9 @@ export interface SessionData {
   lastWorktreePath: string | null;
   lastBranch: string | null;
   lastUsedTool?: string;
+  lastSessionId?: string | null;
+  reasoningLevel?: string | null;
+  skipPermissions?: boolean | null;
   timestamp: number;
   repositoryRoot: string;
   mode?: "normal" | "continue" | "resume";
@@ -27,8 +30,11 @@ export interface ToolSessionEntry {
   worktreePath: string | null;
   toolId: string;
   toolLabel: string;
+  sessionId?: string | null;
   mode?: "normal" | "continue" | "resume" | null;
   model?: string | null;
+  reasoningLevel?: string | null;
+  skipPermissions?: boolean | null;
   timestamp: number;
 }
 
@@ -110,7 +116,10 @@ function getSessionFilePath(repositoryRoot: string): string {
   return path.join(sessionDir, `${repoName}_${repoHash}.json`);
 }
 
-export async function saveSession(sessionData: SessionData): Promise<void> {
+export async function saveSession(
+  sessionData: SessionData,
+  options: { skipHistory?: boolean } = {},
+): Promise<void> {
   try {
     const sessionPath = getSessionFilePath(sessionData.repositoryRoot);
     const sessionDir = path.dirname(sessionPath);
@@ -131,15 +140,22 @@ export async function saveSession(sessionData: SessionData): Promise<void> {
     }
 
     // 新しい履歴エントリを追加（branch/worktree/toolが揃っている場合のみ）
-    if (sessionData.lastBranch && sessionData.lastWorktreePath) {
+    if (
+      !options.skipHistory &&
+      sessionData.lastBranch &&
+      sessionData.lastWorktreePath
+    ) {
       const entry: ToolSessionEntry = {
         branch: sessionData.lastBranch,
         worktreePath: sessionData.lastWorktreePath,
         toolId: sessionData.lastUsedTool ?? "unknown",
         toolLabel:
           sessionData.toolLabel ?? sessionData.lastUsedTool ?? "Custom",
+        sessionId: sessionData.lastSessionId ?? null,
         mode: sessionData.mode ?? null,
         model: sessionData.model ?? null,
+        reasoningLevel: sessionData.reasoningLevel ?? null,
+        skipPermissions: sessionData.skipPermissions ?? false,
         timestamp: sessionData.timestamp,
       };
       existingHistory = [...existingHistory, entry].slice(-100); // keep latest 100
@@ -148,6 +164,9 @@ export async function saveSession(sessionData: SessionData): Promise<void> {
     const payload: SessionData = {
       ...sessionData,
       history: existingHistory,
+      lastSessionId: sessionData.lastSessionId ?? null,
+      reasoningLevel: sessionData.reasoningLevel ?? null,
+      skipPermissions: sessionData.skipPermissions ?? false,
     };
 
     await writeFile(sessionPath, JSON.stringify(payload, null, 2), "utf-8");
@@ -264,6 +283,7 @@ export async function getLastToolUsageMap(
         toolLabel: parsed.toolLabel ?? parsed.lastUsedTool ?? "Custom",
         mode: parsed.mode ?? null,
         model: parsed.model ?? null,
+        reasoningLevel: parsed.reasoningLevel ?? null,
         timestamp: parsed.timestamp ?? Date.now(),
       });
     }

package/src/gemini.ts

@@ -2,6 +2,7 @@ import { execa } from "execa";
 import chalk from "chalk";
 import { existsSync } from "fs";
 import { createChildStdio, getTerminalStreams } from "./utils/terminal.js";
+import { findLatestGeminiSessionId } from "./utils/session.js";
 
 const GEMINI_CLI_PACKAGE = "@google/gemini-cli@latest";
 
@@ -23,8 +24,9 @@ export async function launchGeminiCLI(
     extraArgs?: string[];
     envOverrides?: Record<string, string>;
     model?: string;
+    sessionId?: string | null;
   } = {},
-): Promise<void> {
+): Promise<{ sessionId?: string | null }> {
   const terminal = getTerminalStreams();
 
   try {
@@ -44,14 +46,68 @@ export async function launchGeminiCLI(
     }
 
     // Handle execution mode
+    const resumeSessionId =
+      options.sessionId && options.sessionId.trim().length > 0
+        ? options.sessionId.trim()
+        : null;
+
+    const buildArgs = (useResumeId: boolean) => {
+      const a: string[] = [];
+      if (options.model) {
+        a.push("--model", options.model);
+      }
+
+      switch (options.mode) {
+        case "continue":
+          if (useResumeId && resumeSessionId) {
+            a.push("--resume", resumeSessionId);
+          } else {
+            a.push("--resume");
+          }
+          break;
+        case "resume":
+          if (useResumeId && resumeSessionId) {
+            a.push("--resume", resumeSessionId);
+          } else {
+            a.push("--resume");
+          }
+          break;
+        case "normal":
+        default:
+          break;
+      }
+
+      if (options.skipPermissions) {
+        a.push("-y");
+      }
+      if (options.extraArgs && options.extraArgs.length > 0) {
+        a.push(...options.extraArgs);
+      }
+      return a;
+    };
+
+    const argsPrimary = buildArgs(true);
+    const argsFallback = buildArgs(false);
+
+    // Log selected mode/ID
     switch (options.mode) {
       case "continue":
-        args.push("-r", "latest");
-        console.log(chalk.cyan("   ⏭️  Continuing most recent session"));
+        if (resumeSessionId) {
+          console.log(
+            chalk.cyan(
+              `   ⏭️  Continuing specific session: ${resumeSessionId}`,
+            ),
+          );
+        } else {
+          console.log(chalk.cyan("   ⏭️  Continuing most recent session"));
+        }
         break;
       case "resume":
-        args.push("-r", "latest");
-        console.log(chalk.cyan("   🔄 Resuming session"));
+        if (resumeSessionId) {
+          console.log(chalk.cyan(`   🔄 Resuming session: ${resumeSessionId}`));
+        } else {
+          console.log(chalk.cyan("   🔄 Resuming session (latest)"));
+        }
         break;
       case "normal":
       default:
@@ -61,17 +117,10 @@ export async function launchGeminiCLI(
 
     // Handle skip permissions (YOLO mode)
     if (options.skipPermissions) {
-      args.push("-y");
       console.log(
         chalk.yellow("   ⚠️  Auto-approving all actions (YOLO mode)"),
       );
     }
-
-    // Append any pass-through arguments after our flags
-    if (options.extraArgs && options.extraArgs.length > 0) {
-      args.push(...options.extraArgs);
-    }
-
     terminal.exitRawMode();
 
     const baseEnv = {
@@ -84,46 +133,130 @@ export async function launchGeminiCLI(
     // Auto-detect locally installed gemini command
     const hasLocalGemini = await isGeminiCommandAvailable();
 
-    try {
-      if (hasLocalGemini) {
-        // Use locally installed gemini command
-        console.log(
-          chalk.green("   ✨ Using locally installed gemini command"),
-        );
-        await execa("gemini", args, {
+    // Capture session ID from Gemini's exit summary
+    let capturedSessionId: string | null = null;
+    const extractSessionId = (output: string | undefined) => {
+      if (!output) return;
+      // Gemini outputs "Session ID: <uuid>" in exit summary
+      // UUID may be split across lines due to terminal width
+      // First, find "Session ID:" and extract following hex characters
+      const sessionIdIndex = output.indexOf("Session ID:");
+      if (sessionIdIndex === -1) return;
+
+      // Extract text after "Session ID:" until we have enough hex chars for UUID
+      const afterLabel = output.slice(sessionIdIndex + "Session ID:".length);
+      // Remove all non-hex characters except dash, then extract UUID pattern
+      const hexOnly = afterLabel.replace(/[^0-9a-fA-F-]/g, "");
+      // UUID format: 8-4-4-4-12 = 32 hex chars + 4 dashes
+      const uuidMatch = hexOnly.match(
+        /^([0-9a-f]{8})-?([0-9a-f]{4})-?([0-9a-f]{4})-?([0-9a-f]{4})-?([0-9a-f]{12})/i,
+      );
+      if (uuidMatch) {
+        capturedSessionId = `${uuidMatch[1]}-${uuidMatch[2]}-${uuidMatch[3]}-${uuidMatch[4]}-${uuidMatch[5]}`;
+      }
+    };
+
+    const runGemini = async (runArgs: string[]): Promise<string | undefined> => {
+      // Capture stdout while passing through to terminal
+      // Store chunks to extract session ID after process exits
+      const outputChunks: string[] = [];
+
+      const runWithCapture = async (cmd: string, args: string[]) => {
+        const child = execa(cmd, args, {
           cwd: worktreePath,
           shell: true,
           stdin: childStdio.stdin,
-          stdout: childStdio.stdout,
+          stdout: "pipe",
           stderr: childStdio.stderr,
           env: baseEnv,
         } as any);
-      } else {
-        // Fallback to bunx
-        console.log(
-          chalk.cyan("   🔄 Falling back to bunx @google/gemini-cli@latest"),
-        );
+
+        // Pass stdout through to terminal while capturing
+        child.stdout?.on("data", (chunk: Buffer) => {
+          const text = chunk.toString("utf8");
+          outputChunks.push(text);
+          terminal.stdout.write(chunk);
+        });
+
+        await child;
+        return outputChunks.join("");
+      };
+
+      if (hasLocalGemini) {
         console.log(
-          chalk.yellow(
-            "   💡 Recommended: Install Gemini CLI globally for faster startup",
-          ),
+          chalk.green("   ✨ Using locally installed gemini command"),
         );
-        console.log(chalk.yellow("      npm install -g @google/gemini-cli"));
-        console.log("");
-        // Wait 2 seconds to let user read the message
-        await new Promise((resolve) => setTimeout(resolve, 2000));
-        await execa("bunx", [GEMINI_CLI_PACKAGE, ...args], {
-          cwd: worktreePath,
-          shell: true,
-          stdin: childStdio.stdin,
-          stdout: childStdio.stdout,
-          stderr: childStdio.stderr,
-          env: baseEnv,
-        } as any);
+        return await runWithCapture("gemini", runArgs);
+      }
+      console.log(
+        chalk.cyan("   🔄 Falling back to bunx @google/gemini-cli@latest"),
+      );
+      console.log(
+        chalk.yellow(
+          "   💡 Recommended: Install Gemini CLI globally for faster startup",
+        ),
+      );
+      console.log(chalk.yellow("      npm install -g @google/gemini-cli"));
+      console.log("");
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+      return await runWithCapture("bunx", [GEMINI_CLI_PACKAGE, ...runArgs]);
+    };
+
+    let output: string | undefined;
+    try {
+      // Try with explicit session ID first (if any), then fallback to --resume (latest) once
+      try {
+        output = await runGemini(argsPrimary);
+      } catch (err) {
+        const shouldRetry =
+          (options.mode === "resume" || options.mode === "continue") &&
+          resumeSessionId;
+        if (shouldRetry) {
+          console.log(
+            chalk.yellow(
+              `   ⚠️  Failed to resume session ${resumeSessionId}. Retrying with latest session...`,
+            ),
+          );
+          output = await runGemini(argsFallback);
+        } else {
+          throw err;
+        }
       }
     } finally {
       childStdio.cleanup();
     }
+
+    // Extract session ID from Gemini's exit summary output
+    extractSessionId(output);
+
+    // Fallback to file-based detection if stdout capture failed
+    if (!capturedSessionId) {
+      try {
+        capturedSessionId =
+          (await findLatestGeminiSessionId(worktreePath, {
+            cwd: worktreePath,
+          })) ??
+          resumeSessionId ??
+          null;
+      } catch {
+        capturedSessionId = resumeSessionId ?? null;
+      }
+    }
+
+    if (capturedSessionId) {
+      console.log(chalk.cyan(`\n   🆔 Session ID: ${capturedSessionId}`));
+      console.log(
+        chalk.gray(`   Resume command: gemini --resume ${capturedSessionId}`),
+      );
+    } else {
+      console.log(
+        chalk.yellow(
+          "\n   ℹ️  Could not determine Gemini session ID automatically.",
+        ),
+      );
+    }
+
+    return capturedSessionId ? { sessionId: capturedSessionId } : {};
   } catch (error: any) {
     const hasLocalGemini = await isGeminiCommandAvailable();
     let errorMessage: string;
@@ -181,7 +314,12 @@ export async function launchGeminiCLI(
 async function isGeminiCommandAvailable(): Promise<boolean> {
   try {
     const command = process.platform === "win32" ? "where" : "which";
-    await execa(command, ["gemini"], { shell: true });
+    await execa(command, ["gemini"], {
+      shell: true,
+      stdin: "ignore",
+      stdout: "ignore",
+      stderr: "ignore",
+    });
     return true;
   } catch {
     // gemini command not found in PATH

package/src/index.ts

@@ -35,9 +35,16 @@ import {
 } from "./utils/terminal.js";
 import { getToolById, getSharedEnvironment } from "./config/tools.js";
 import { launchCustomAITool } from "./launcher.js";
-import { saveSession } from "./config/index.js";
+import { saveSession, loadSession } from "./config/index.js";
+import {
+  findLatestCodexSession,
+  findLatestClaudeSession,
+  findLatestGeminiSession,
+} from "./utils/session.js";
 import { getPackageVersion } from "./utils.js";
+import { findLatestClaudeSessionId } from "./utils/session.js";
 import readline from "node:readline";
+import { resolveContinueSessionId } from "./cli/ui/utils/continueSession.js";
 import {
   installDependenciesForWorktree,
   DependencyInstallError,
@@ -273,6 +280,7 @@ async function mainInkUI(): Promise<SelectionResult | undefined> {
 
   let selectionResult: SelectionResult | undefined;
 
+  // Resume stdin to ensure it's ready for Ink.js
   if (typeof terminal.stdin.resume === "function") {
     terminal.stdin.resume();
   }
@@ -324,6 +332,7 @@ export async function handleAIToolWorkflow(
     skipPermissions,
     model,
     inferenceLevel,
+    sessionId: selectedSessionId,
   } = selectionResult;
 
   const branchLabel = displayName ?? branch;
@@ -564,26 +573,61 @@ export async function handleAIToolWorkflow(
 
     // Save selection immediately so "last tool" is reflected even if the tool
     // is interrupted or killed mid-run (e.g., Ctrl+C).
-    await saveSession({
-      lastWorktreePath: worktreePath,
-      lastBranch: branch,
-      lastUsedTool: tool,
-      toolLabel: toolConfig.displayName ?? tool,
-      mode,
-      model: model ?? null,
-      timestamp: Date.now(),
-      repositoryRoot: repoRoot,
-    });
+    await saveSession(
+      {
+        lastWorktreePath: worktreePath,
+        lastBranch: branch,
+        lastUsedTool: tool,
+        toolLabel: toolConfig.displayName ?? tool,
+        mode,
+        model: model ?? null,
+        reasoningLevel: inferenceLevel ?? null,
+        skipPermissions: skipPermissions ?? null,
+        timestamp: Date.now(),
+        repositoryRoot: repoRoot,
+      },
+      { skipHistory: true },
+    );
+
+    // Lookup saved session ID for continue/resume
+    let resumeSessionId: string | null =
+      selectedSessionId && selectedSessionId.length > 0
+        ? selectedSessionId
+        : null;
+    if (mode === "continue" || mode === "resume") {
+      const existingSession = await loadSession(repoRoot);
+      const history = existingSession?.history ?? [];
+
+      resumeSessionId =
+        resumeSessionId ??
+        (await resolveContinueSessionId({
+          history,
+          sessionData: existingSession,
+          branch,
+          toolId: tool,
+          repoRoot,
+        }));
+
+      if (!resumeSessionId) {
+        printWarning(
+          "No saved session ID found for this branch/tool. Falling back to tool default.",
+        );
+      }
+    }
+
+    const launchStartedAt = Date.now();
 
     // Launch selected AI tool
     // Builtin tools use their dedicated launch functions
     // Custom tools use the generic launchCustomAITool function
+    let launchResult: { sessionId?: string | null } | void;
     if (tool === "claude-code") {
       const launchOptions: {
         mode?: "normal" | "continue" | "resume";
         skipPermissions?: boolean;
         envOverrides?: Record<string, string>;
         model?: string;
+        sessionId?: string | null;
       } = {
         mode:
           mode === "resume"
@@ -593,11 +637,12 @@ export async function handleAIToolWorkflow(
               : "normal",
         skipPermissions,
         envOverrides: sharedEnv,
+        sessionId: resumeSessionId,
       };
       if (model) {
         launchOptions.model = model;
       }
-      await launchClaudeCode(worktreePath, launchOptions);
+      launchResult = await launchClaudeCode(worktreePath, launchOptions);
     } else if (tool === "codex-cli") {
       const launchOptions: {
         mode?: "normal" | "continue" | "resume";
@@ -605,6 +650,7 @@ export async function handleAIToolWorkflow(
         envOverrides?: Record<string, string>;
         model?: string;
         reasoningEffort?: CodexReasoningEffort;
+        sessionId?: string | null;
       } = {
         mode:
           mode === "resume"
@@ -614,6 +660,7 @@ export async function handleAIToolWorkflow(
               : "normal",
         bypassApprovals: skipPermissions,
         envOverrides: sharedEnv,
+        sessionId: resumeSessionId,
       };
       if (model) {
         launchOptions.model = model;
@@ -621,13 +668,14 @@ export async function handleAIToolWorkflow(
       if (inferenceLevel) {
         launchOptions.reasoningEffort = inferenceLevel as CodexReasoningEffort;
       }
-      await launchCodexCLI(worktreePath, launchOptions);
+      launchResult = await launchCodexCLI(worktreePath, launchOptions);
     } else if (tool === "gemini-cli") {
       const launchOptions: {
         mode?: "normal" | "continue" | "resume";
         skipPermissions?: boolean;
         envOverrides?: Record<string, string>;
         model?: string;
+        sessionId?: string | null;
       } = {
         mode:
           mode === "resume"
@@ -637,17 +685,19 @@ export async function handleAIToolWorkflow(
               : "normal",
         skipPermissions,
         envOverrides: sharedEnv,
+        sessionId: resumeSessionId,
       };
       if (model) {
         launchOptions.model = model;
       }
-      await launchGeminiCLI(worktreePath, launchOptions);
+      launchResult = await launchGeminiCLI(worktreePath, launchOptions);
     } else if (tool === "qwen-cli") {
       const launchOptions: {
         mode?: "normal" | "continue" | "resume";
         skipPermissions?: boolean;
         envOverrides?: Record<string, string>;
         model?: string;
+        sessionId?: string | null;
       } = {
         mode:
           mode === "resume"
@@ -657,15 +707,16 @@ export async function handleAIToolWorkflow(
               : "normal",
         skipPermissions,
         envOverrides: sharedEnv,
+        sessionId: resumeSessionId,
       };
       if (model) {
         launchOptions.model = model;
       }
-      await launchQwenCLI(worktreePath, launchOptions);
+      launchResult = await launchQwenCLI(worktreePath, launchOptions);
     } else {
       // Custom tool
       printInfo(`Launching custom tool: ${toolConfig.displayName}`);
-      await launchCustomAITool(toolConfig, {
+      launchResult = await launchCustomAITool(toolConfig, {
         mode:
           mode === "resume"
             ? "resume"
@@ -678,6 +729,83 @@ export async function handleAIToolWorkflow(
       });
     }
 
+    // Persist session with captured session ID (if any)
+    let finalSessionId =
+      (launchResult as { sessionId?: string | null } | undefined)?.sessionId ??
+      resumeSessionId ??
+      null;
+
+    if (!finalSessionId && tool === "claude-code") {
+      try {
+        finalSessionId = (await findLatestClaudeSessionId(worktreePath)) ?? null;
+      } catch {
+        finalSessionId = null;
+      }
+    }
+    const finishedAt = Date.now();
+
+    if (tool === "codex-cli") {
+      try {
+        const latest = await findLatestCodexSession({
+          since: launchStartedAt - 60_000,
+          until: finishedAt + 60_000,
+          preferClosestTo: finishedAt,
+          windowMs: 60 * 60 * 1000,
+          cwd: worktreePath,
+        });
+        if (latest) {
+          finalSessionId = latest.id;
+        }
+      } catch {
+        // ignore fallback failure
+      }
+    } else if (tool === "claude-code") {
+      try {
+        const latestClaude = await findLatestClaudeSession(worktreePath, {
+          since: launchStartedAt - 60_000,
+          until: finishedAt + 60_000,
+          preferClosestTo: finishedAt,
+          windowMs: 60 * 60 * 1000,
+        });
+        if (latestClaude) {
+          finalSessionId = latestClaude.id;
+        }
+      } catch {
+        // ignore
+      }
+    } else if (tool === "gemini-cli") {
+      try {
+        const latestGemini = await findLatestGeminiSession(worktreePath, {
+          since: launchStartedAt - 60_000,
+          until: finishedAt + 60_000,
+          preferClosestTo: finishedAt,
+          windowMs: 60 * 60 * 1000,
+          cwd: worktreePath,
+        });
+        if (latestGemini) {
+          finalSessionId = latestGemini.id;
+        }
+      } catch {
+        // ignore
+      }
+    }
+
+    await saveSession({
+      lastWorktreePath: worktreePath,
+      lastBranch: branch,
+      lastUsedTool: tool,
+      toolLabel: toolConfig.displayName ?? tool,
+      mode,
+      model: model ?? null,
+      reasoningLevel: inferenceLevel ?? null,
+      skipPermissions: skipPermissions ?? null,
+      timestamp: Date.now(),
+      repositoryRoot: repoRoot,
+      lastSessionId: finalSessionId,
+    });
+
+    // Small buffer before returning to branch list to avoid abrupt screen swap
+    await new Promise((resolve) => setTimeout(resolve, 3000));
     printInfo("Session completed successfully. Returning to main menu...");
     return;
   } catch (error) {