@akiojin/gwt 2.11.1 → 2.12.1

package/src/cli/ui/components/screens/BranchQuickStartScreen.tsx

@@ -0,0 +1,237 @@
+import React from "react";
+import { Box, Text, useInput } from "ink";
+import { Header } from "../parts/Header.js";
+import { Footer } from "../parts/Footer.js";
+import { Select, type SelectItem } from "../common/Select.js";
+import { useTerminalSize } from "../../hooks/useTerminalSize.js";
+
+export type QuickStartAction = "reuse-continue" | "reuse-new" | "manual";
+
+export interface BranchQuickStartOption {
+  toolId?: string | null;
+  toolLabel: string;
+  toolCategory?: "Codex" | "Claude" | "Gemini" | "Qwen" | "Other";
+  model?: string | null;
+  sessionId?: string | null;
+  inferenceLevel?: string | null;
+  skipPermissions?: boolean | null;
+}
+
+const REASONING_LABELS: Record<string, string> = {
+  low: "Low",
+  medium: "Medium",
+  high: "High",
+  xhigh: "Extra high",
+};
+
+const formatReasoning = (level?: string | null) =>
+  level ? REASONING_LABELS[level] ?? level : "Default";
+
+const formatSkip = (skip?: boolean | null) =>
+  skip === true ? "Yes" : skip === false ? "No" : "No";
+
+const supportsReasoning = (toolId?: string | null) =>
+  toolId === "codex-cli";
+
+const describe = (opt: BranchQuickStartOption, includeSessionId = true) => {
+  const parts = [`Model: ${opt.model ?? "default"}`];
+  if (supportsReasoning(opt.toolId)) {
+    parts.push(`Reasoning: ${formatReasoning(opt.inferenceLevel)}`);
+  }
+  parts.push(`Skip: ${formatSkip(opt.skipPermissions)}`);
+  if (includeSessionId) {
+    parts.push(opt.sessionId ? `ID: ${opt.sessionId}` : "No ID");
+  }
+  return parts.join(" / ");
+};
+
+type QuickStartItem = SelectItem & {
+  description: string;
+  disabled?: boolean;
+  toolId?: string | null;
+  action: QuickStartAction;
+  groupStart?: boolean;
+  category: string;
+  categoryColor: "cyan" | "yellow" | "magenta" | "green" | "white";
+};
+
+export interface BranchQuickStartScreenProps {
+  previousOptions: BranchQuickStartOption[];
+  loading?: boolean;
+  onBack: () => void;
+  onSelect: (action: QuickStartAction, toolId?: string | null) => void;
+  version?: string | null;
+  branchName: string;
+}
+
+export function BranchQuickStartScreen({
+  previousOptions,
+  loading = false,
+  onBack,
+  onSelect,
+  version,
+  branchName,
+}: BranchQuickStartScreenProps) {
+  const { rows } = useTerminalSize();
+  const containerHeight = rows && rows > 0 ? rows : undefined;
+
+  const CATEGORY_META = {
+    "codex-cli": { label: "Codex", color: "cyan" },
+    "claude-code": { label: "Claude", color: "yellow" },
+    "gemini-cli": { label: "Gemini", color: "magenta" },
+    "qwen-cli": { label: "Qwen", color: "green" },
+    other: { label: "Other", color: "white" },
+  } as const;
+
+  type CategoryMeta = (typeof CATEGORY_META)[keyof typeof CATEGORY_META];
+
+  const resolveCategory = (toolId?: string | null): CategoryMeta => {
+    switch (toolId) {
+      case "codex-cli":
+        return CATEGORY_META["codex-cli"];
+      case "claude-code":
+        return CATEGORY_META["claude-code"];
+      case "gemini-cli":
+        return CATEGORY_META["gemini-cli"];
+      case "qwen-cli":
+        return CATEGORY_META["qwen-cli"];
+      default:
+        return CATEGORY_META.other;
+    }
+  };
+
+  const items: QuickStartItem[] = previousOptions.length
+    ? (() => {
+        const order = ["Claude", "Codex", "Gemini", "Qwen", "Other"];
+      const sorted = [...previousOptions].sort((a, b) => {
+        const ca = resolveCategory(a.toolId).label;
+        const cb = resolveCategory(b.toolId).label;
+        return order.indexOf(ca) - order.indexOf(cb);
+      });
+
+      const flat: QuickStartItem[] = [];
+        sorted.forEach((opt, idx) => {
+          const cat = resolveCategory(opt.toolId);
+          const prevCat =
+            idx > 0 ? resolveCategory(sorted[idx - 1]?.toolId).label : null;
+          const isNewCategory = prevCat !== cat.label;
+
+        flat.push(
+          {
+            label: "Resume",
+            value: `reuse-continue:${opt.toolId ?? "unknown"}:${idx}`,
+            action: "reuse-continue",
+            toolId: opt.toolId ?? null,
+            description: describe(opt, true),
+            groupStart: isNewCategory && flat.length > 0,
+            category: cat.label,
+            categoryColor: cat.color,
+          },
+          {
+            label: "New",
+            value: `reuse-new:${opt.toolId ?? "unknown"}:${idx}`,
+            action: "reuse-new",
+            toolId: opt.toolId ?? null,
+            description: describe(opt, false),
+            groupStart: false,
+            category: cat.label,
+            categoryColor: cat.color,
+          },
+        );
+      });
+
+      return flat;
+    })()
+    : [
+        {
+          label: "Resume with previous settings",
+          value: "reuse-continue",
+          action: "reuse-continue",
+          description: "No previous settings (disabled)",
+          disabled: true,
+          category: CATEGORY_META.other.label,
+          categoryColor: CATEGORY_META.other.color,
+        },
+        {
+          label: "Start new with previous settings",
+          value: "reuse-new",
+          action: "reuse-new",
+          description: "No previous settings (disabled)",
+          disabled: true,
+          category: CATEGORY_META.other.label,
+          categoryColor: CATEGORY_META.other.color,
+        },
+      ];
+
+  items.push({
+    label: "Manual selection",
+    value: "manual",
+    action: "manual",
+    description: "Pick tool and model manually",
+    category: CATEGORY_META.other.label,
+    categoryColor: CATEGORY_META.other.color,
+  });
+
+  useInput((_, key) => {
+    if (key.escape) {
+      onBack();
+    }
+  });
+
+  return (
+    <Box flexDirection="column" height={containerHeight}>
+      <Header
+        title="Quick Start"
+        titleColor="cyan"
+        version={version}
+      />
+
+      <Box flexDirection="column" flexGrow={1} marginTop={1}>
+        <Box marginBottom={1} flexDirection="column">
+          <Text>
+            {loading
+              ? "Loading previous settings..."
+              : "Resume with previous settings, start new, or choose manually."}
+          </Text>
+          <Text color="gray">{`Branch: ${branchName}`}</Text>
+        </Box>
+        <Select
+          items={items}
+          onSelect={(item: QuickStartItem) => {
+            if (item.disabled) return;
+            onSelect(item.action, item.toolId ?? null);
+          }}
+          renderItem={(item: QuickStartItem, isSelected) => (
+            <Box
+              flexDirection="column"
+              marginTop={item.groupStart ? 1 : item.category === "Other" ? 1 : 0}
+            >
+              <Text>
+                <Text
+                  color={item.categoryColor}
+                  inverse={isSelected}
+                >
+                  {`[${item.category}] `}
+                </Text>
+                <Text inverse={isSelected}>
+                  {item.label}
+                  {item.disabled ? " (disabled)" : ""}
+                </Text>
+              </Text>
+              {item.description && (
+                <Text color="gray">  {item.description}</Text>
+              )}
+            </Box>
+          )}
+        />
+      </Box>
+
+      <Footer
+        actions={[
+          { key: "enter", description: "Select" },
+          { key: "esc", description: "Back" },
+        ]}
+      />
+    </Box>
+  );
+}

package/src/cli/ui/components/screens/ExecutionModeSelectorScreen.tsx

@@ -28,6 +28,7 @@ export interface ExecutionModeSelectorScreenProps {
   onBack: () => void;
   onSelect: (result: ExecutionModeResult) => void;
   version?: string | null;
+  continueSessionId?: string | null;
 }
 
 /**
@@ -40,6 +41,7 @@ export function ExecutionModeSelectorScreen({
   onBack,
   onSelect,
   version,
+  continueSessionId = null,
 }: ExecutionModeSelectorScreenProps) {
   const { rows } = useTerminalSize();
   const [step, setStep] = useState<1 | 2>(1);
@@ -67,7 +69,9 @@ export function ExecutionModeSelectorScreen({
       description: "Start fresh session",
     },
     {
-      label: "Continue",
+      label: continueSessionId
+        ? `Continue (ID: ${continueSessionId})`
+        : "Continue",
       value: "continue",
       description: "Continue from last session",
     },

package/src/cli/ui/components/screens/ModelSelectorScreen.tsx

@@ -230,7 +230,7 @@ export function ModelSelectorScreen({
   return (
     <Box flexDirection="column" height={rows}>
       <Header
-        title={step === "model" ? "Model Selection" : "Inference Level"}
+        title={step === "model" ? "Model Selection" : "Reasoning Level"}
         titleColor="blue"
         version={version}
       />

package/src/cli/ui/components/screens/SessionSelectorScreen.tsx

@@ -8,10 +8,18 @@ import { useTerminalSize } from "../../hooks/useTerminalSize.js";
 export interface SessionItem {
   label: string;
   value: string;
+  secondary?: string;
 }
 
 export interface SessionSelectorScreenProps {
-  sessions: string[];
+  sessions: {
+    sessionId: string;
+    branch: string;
+    toolLabel?: string | null;
+    timestamp?: number;
+  }[];
+  loading?: boolean;
+  errorMessage?: string | null;
   onBack: () => void;
   onSelect: (session: string) => void;
   version?: string | null;
@@ -23,6 +31,8 @@ export interface SessionSelectorScreenProps {
  */
 export function SessionSelectorScreen({
   sessions,
+  loading = false,
+  errorMessage = null,
   onBack,
   onSelect,
   version,
@@ -38,10 +48,18 @@ export function SessionSelectorScreen({
   });
 
   // Format sessions for Select component
-  const sessionItems: SessionItem[] = sessions.map((session) => ({
-    label: session,
-    value: session,
-  }));
+  const sessionItems: SessionItem[] = sessions.map((session) => {
+    const startedAt =
+      typeof session.timestamp === "number"
+        ? new Date(session.timestamp).toLocaleString()
+        : "unknown time";
+    const toolLabel = session.toolLabel ?? "unknown";
+    const label = `${session.branch} • ${toolLabel} • ${session.sessionId} (${startedAt})`;
+    return {
+      label,
+      value: session.sessionId,
+    };
+  });
 
   // Handle session selection
   const handleSelect = (item: SessionItem) => {
@@ -84,13 +102,23 @@ export function SessionSelectorScreen({
 
       {/* Content */}
       <Box flexDirection="column" flexGrow={1}>
-        {sessions.length === 0 ? (
+        {loading ? (
+          <Box>
+            <Text dimColor>Loading sessions...</Text>
+          </Box>
+        ) : sessions.length === 0 ? (
           <Box>
             <Text dimColor>No sessions found</Text>
           </Box>
         ) : (
           <Select items={sessionItems} onSelect={handleSelect} limit={limit} />
         )}
+
+        {errorMessage ? (
+          <Box marginTop={1}>
+            <Text color="red">{errorMessage}</Text>
+          </Box>
+        ) : null}
       </Box>
 
       {/* Footer */}

package/src/cli/ui/types.ts

@@ -184,6 +184,7 @@ export type ScreenType =
   | "branch-list"
   | "branch-creator"
   | "branch-action-selector"
+  | "branch-quick-start"
   | "ai-tool-selector"
   | "model-selector"
   | "session-selector"

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

@@ -0,0 +1,106 @@
+import type { SessionData, ToolSessionEntry } from "../../../config/index.js";
+
+export interface ContinueSessionContext {
+  history: ToolSessionEntry[];
+  sessionData: SessionData | null;
+  branch: string;
+  toolId: string;
+  repoRoot: string | null;
+}
+
+/**
+ * 指定されたブランチ/ツールに紐づく最新セッションIDを解決する。
+ * 1. 履歴(history)の最新マッチを優先
+ * 2. lastSessionId がブランチ/ツール一致であれば利用
+ * 3. それでも無い場合、同一ブランチ/ツールであればツール固有の保存場所から検出
+ */
+export async function resolveContinueSessionId(
+  context: ContinueSessionContext,
+): Promise<string | null> {
+  const {
+    history,
+    sessionData,
+    branch,
+    toolId,
+    repoRoot,
+  } = context;
+
+  // 1) 履歴から最新マッチを探す（末尾から遡る）
+  for (let i = history.length - 1; i >= 0; i -= 1) {
+    const entry = history[i];
+    if (
+      entry &&
+      entry.branch === branch &&
+      entry.toolId === toolId &&
+      entry.sessionId
+    ) {
+      return entry.sessionId;
+    }
+  }
+
+  // 2) lastSessionId が一致する場合はそれを返す
+  if (
+    sessionData?.lastSessionId &&
+    sessionData.lastBranch === branch &&
+    sessionData.lastUsedTool === toolId
+  ) {
+    return sessionData.lastSessionId;
+  }
+
+  return null;
+}
+
+export function findLatestBranchSession(
+  history: ToolSessionEntry[],
+  branch: string,
+  toolId?: string | null,
+): ToolSessionEntry | null {
+  const byBranch = history.filter((entry) => entry && entry.branch === branch);
+  if (!byBranch.length) return null;
+
+  const pickLatest = (entries: ToolSessionEntry[]) =>
+    entries.reduce<ToolSessionEntry | null>((latest, entry) => {
+      if (!latest) return entry;
+      const latestTs = latest.timestamp ?? 0;
+      const currentTs = entry.timestamp ?? 0;
+      return currentTs >= latestTs ? entry : latest;
+    }, null);
+
+  if (toolId) {
+    const byTool = byBranch.filter((entry) => entry.toolId === toolId);
+    if (byTool.length) {
+      return pickLatest(byTool);
+    }
+  }
+
+  return pickLatest(byBranch);
+}
+
+export function findLatestBranchSessionsByTool(
+  history: ToolSessionEntry[],
+  branch: string,
+  worktreePath?: string | null,
+): ToolSessionEntry[] {
+  const byBranch = history.filter((entry) => entry && entry.branch === branch);
+  if (!byBranch.length) return [];
+
+  const scoped = worktreePath
+    ? byBranch.filter((entry) => entry.worktreePath === worktreePath)
+    : byBranch;
+  const source = scoped.length ? scoped : byBranch;
+
+  const latestByTool = new Map<string, ToolSessionEntry>();
+  for (const entry of source) {
+    if (!entry.toolId) continue;
+    const current = latestByTool.get(entry.toolId);
+    const currentTs = current?.timestamp ?? 0;
+    const entryTs = entry.timestamp ?? 0;
+    if (!current || entryTs >= currentTs) {
+      latestByTool.set(entry.toolId, entry);
+    }
+  }
+
+  return Array.from(latestByTool.values()).sort(
+    (a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0),
+  );
+}

package/src/codex.ts

@@ -3,6 +3,10 @@ import chalk from "chalk";
 import { platform } from "os";
 import { existsSync } from "fs";
 import { createChildStdio, getTerminalStreams } from "./utils/terminal.js";
+import {
+  findLatestCodexSession,
+  waitForCodexSessionId,
+} from "./utils/session.js";
 
 const CODEX_CLI_PACKAGE = "@openai/codex@latest";
 
@@ -17,6 +21,8 @@ export const buildDefaultCodexArgs = (
 ): string[] => [
   "--enable",
   "web_search_request",
+  "--enable",
+  "skills",
   `--model=${model}`,
   "--sandbox",
   "workspace-write",
@@ -53,9 +59,11 @@ export async function launchCodexCLI(
     envOverrides?: Record<string, string>;
     model?: string;
     reasoningEffort?: CodexReasoningEffort;
+    sessionId?: string | null;
   } = {},
-): Promise<void> {
+): Promise<{ sessionId?: string | null }> {
   const terminal = getTerminalStreams();
+  const startedAt = Date.now();
 
   try {
     if (!existsSync(worktreePath)) {
@@ -73,14 +81,40 @@ export async function launchCodexCLI(
     console.log(chalk.green(`   🎯 Model: ${model}`));
     console.log(chalk.green(`   🧠 Reasoning: ${reasoningEffort}`));
 
+    const resumeSessionId =
+      options.sessionId && options.sessionId.trim().length > 0
+        ? options.sessionId.trim()
+        : null;
+
+    // Start polling session files immediately to catch the session created right after launch.
+    const sessionProbe = waitForCodexSessionId({ startedAt, cwd: worktreePath }).catch(
+      () => null,
+    );
+
     switch (options.mode) {
       case "continue":
-        args.push("resume", "--last");
-        console.log(chalk.cyan("   ⏭️  Resuming last Codex session"));
+        if (resumeSessionId) {
+          args.push("resume", resumeSessionId);
+          console.log(
+            chalk.cyan(
+              `   ⏭️  Resuming specific Codex session: ${resumeSessionId}`,
+            ),
+          );
+        } else {
+          args.push("resume", "--last");
+          console.log(chalk.cyan("   ⏭️  Resuming last Codex session"));
+        }
         break;
       case "resume":
-        args.push("resume");
-        console.log(chalk.cyan("   🔄 Resume command"));
+        if (resumeSessionId) {
+          args.push("resume", resumeSessionId);
+          console.log(
+            chalk.cyan(`   🔄 Resuming Codex session: ${resumeSessionId}`),
+          );
+        } else {
+          args.push("resume");
+          console.log(chalk.cyan("   🔄 Resume command"));
+        }
         break;
       case "normal":
       default:
@@ -101,6 +135,8 @@ export async function launchCodexCLI(
 
     args.push(...codexArgs);
 
+    console.log(chalk.gray(`   📋 Args: ${args.join(" ")}`));
+
     terminal.exitRawMode();
 
     const childStdio = createChildStdio();
@@ -108,16 +144,63 @@ export async function launchCodexCLI(
     const env = { ...process.env, ...(options.envOverrides ?? {}) };
 
     try {
-      await execa("bunx", [CODEX_CLI_PACKAGE, ...args], {
+      const execChild = async (child: any) => {
+        try {
+          await child;
+        } catch (execError: any) {
+          // Treat SIGINT/SIGTERM as normal exit (user pressed Ctrl+C)
+          if (execError.signal === "SIGINT" || execError.signal === "SIGTERM") {
+            return;
+          }
+          throw execError;
+        }
+      };
+
+      const child = execa("bunx", [CODEX_CLI_PACKAGE, ...args], {
         cwd: worktreePath,
+        shell: true,
         stdin: childStdio.stdin,
         stdout: childStdio.stdout,
         stderr: childStdio.stderr,
         env,
       } as any);
+      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
+    let capturedSessionId: string | null = null;
+    const finishedAt = Date.now();
+    try {
+      const latest = await findLatestCodexSession({
+        since: startedAt,
+        until: finishedAt + 30_000,
+        preferClosestTo: finishedAt,
+        windowMs: 10 * 60 * 1000,
+        cwd: worktreePath,
+      });
+      // Priority: latest on disk > resumeSessionId
+      capturedSessionId = latest?.id ?? resumeSessionId ?? null;
+    } catch {
+      capturedSessionId = resumeSessionId ?? null;
+    }
+
+    if (capturedSessionId) {
+      console.log(chalk.cyan(`\n   🆔 Session ID: ${capturedSessionId}`));
+      console.log(
+        chalk.gray(`   Resume command: codex resume ${capturedSessionId}`),
+      );
+    } else {
+      console.log(
+        chalk.yellow(
+          "\n   ℹ️  Could not determine Codex session ID automatically.",
+        ),
+      );
+    }
+
+    return capturedSessionId ? { sessionId: capturedSessionId } : {};
   } catch (error: any) {
     const errorMessage =
       error.code === "ENOENT"
@@ -142,6 +225,8 @@ export async function launchCodexCLI(
     }
 
     throw new CodexError(errorMessage, error);
+  } finally {
+    terminal.exitRawMode();
   }
 }
 

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