@akiojin/gwt 4.1.0 → 4.2.0

package/src/utils/prompt.ts

@@ -1,17 +1,26 @@
 import readline from "node:readline";
 import { getTerminalStreams } from "./terminal.js";
 
-/**
- * Wait for Enter using the same terminal streams as Ink.
- * Falls back to no-op on non-interactive stdin to avoid blocking pipelines.
- */
-export async function waitForEnter(promptMessage: string): Promise<void> {
+type ReadlinePromptOptions<T> = {
+  fallback: T;
+  onAnswer: (answer: string) => T | undefined;
+  shouldSkip?: (terminal: ReturnType<typeof getTerminalStreams>) => boolean;
+};
+
+async function runReadlinePrompt<T>(
+  promptText: string,
+  { fallback, onAnswer, shouldSkip }: ReadlinePromptOptions<T>,
+): Promise<T> {
   const terminal = getTerminalStreams();
   const stdin = terminal.stdin as NodeJS.ReadStream | undefined;
   const stdout = terminal.stdout as NodeJS.WriteStream | undefined;
 
   if (!stdin || typeof stdin.on !== "function" || !stdin.isTTY) {
-    return;
+    return fallback;
+  }
+
+  if (shouldSkip?.(terminal)) {
+    return fallback;
   }
 
   terminal.exitRawMode?.();
@@ -30,10 +39,15 @@ export async function waitForEnter(promptMessage: string): Promise<void> {
     }
   }
 
-  await new Promise<void>((resolve) => {
+  return new Promise<T>((resolve) => {
     const rl = readline.createInterface({ input: stdin, output: stdout });
+    let finished = false;
 
     const cleanup = () => {
+      if (finished) {
+        return;
+      }
+      finished = true;
       rl.removeAllListeners();
       rl.close();
       const remover = (method: "off" | "removeListener") =>
@@ -61,7 +75,7 @@ export async function waitForEnter(promptMessage: string): Promise<void> {
 
     const onEnd = () => {
       cleanup();
-      resolve();
+      resolve(fallback);
     };
 
     rl.on("SIGINT", () => {
@@ -69,12 +83,67 @@ export async function waitForEnter(promptMessage: string): Promise<void> {
       process.exit(0);
     });
 
-    rl.question(`${promptMessage}\n`, () => {
+    rl.question(`${promptText}\n`, (answer) => {
+      const result = onAnswer(answer);
       cleanup();
-      resolve();
+      resolve(result !== undefined ? result : fallback);
     });
 
     stdin.once("end", onEnd);
     stdin.once("error", onEnd);
   });
 }
+
+/**
+ * Wait for Enter using the same terminal streams as Ink.
+ * Falls back to no-op on non-interactive stdin to avoid blocking pipelines.
+ */
+export async function waitForEnter(promptMessage: string): Promise<void> {
+  await runReadlinePrompt(promptMessage, {
+    fallback: undefined,
+    onAnswer: () => undefined,
+  });
+}
+
+/**
+ * Prompts the user for a yes/no confirmation in the terminal.
+ * Falls back to the default value on non-interactive stdin or fallback terminals.
+ *
+ * @param promptMessage - The message to display to the user
+ * @param options - Configuration options
+ * @param options.defaultValue - The default value when input is empty or stdin is non-interactive
+ * @returns A promise that resolves to true for yes, false for no
+ */
+export async function confirmYesNo(
+  promptMessage: string,
+  options: { defaultValue?: boolean } = {},
+): Promise<boolean> {
+  const fallback = options.defaultValue ?? false;
+
+  const suffix =
+    options.defaultValue === undefined
+      ? "[y/n]"
+      : options.defaultValue
+        ? "[Y/n]"
+        : "[y/N]";
+
+  const promptText = `${promptMessage} ${suffix}`.trim();
+
+  return runReadlinePrompt(promptText, {
+    fallback,
+    shouldSkip: (terminal) => terminal.usingFallback,
+    onAnswer: (answer) => {
+      const normalized = answer.trim().toLowerCase();
+      if (normalized === "y" || normalized === "yes") {
+        return true;
+      }
+      if (normalized === "n" || normalized === "no") {
+        return false;
+      }
+      if (normalized.length === 0 && options.defaultValue !== undefined) {
+        return options.defaultValue;
+      }
+      return undefined;
+    },
+  });
+}

package/src/worktree.ts

@@ -21,6 +21,7 @@ import {
   ensureGitignoreEntry,
   branchExists,
   getCurrentBranch,
+  getCurrentBranchName,
 } from "./git.js";
 import { getConfig } from "./config/index.js";
 import { GIT_CONFIG } from "./config/constants.js";
@@ -195,9 +196,55 @@ export async function listAdditionalWorktrees(): Promise<WorktreeInfo[]> {
 export async function worktreeExists(
   branchName: string,
 ): Promise<string | null> {
+  const resolution = await resolveWorktreePathForBranch(branchName);
+  return resolution.path;
+}
+
+/**
+ * Resolution result for a branch-associated worktree path.
+ */
+export interface WorktreePathResolution {
+  path: string | null;
+  mismatch?: {
+    path: string;
+    actualBranch: string | null;
+  };
+}
+
+/**
+ * Resolve a worktree path for the selected branch and verify the actual checkout.
+ */
+export async function resolveWorktreePathForBranch(
+  branchName: string,
+): Promise<WorktreePathResolution> {
   const worktrees = await listWorktrees();
   const worktree = worktrees.find((w) => w.branch === branchName);
-  return worktree ? worktree.path : null;
+  if (!worktree) {
+    return { path: null };
+  }
+
+  try {
+    const actualBranch = (await getCurrentBranchName(worktree.path)).trim();
+    if (!actualBranch || actualBranch !== branchName) {
+      return {
+        path: null,
+        mismatch: {
+          path: worktree.path,
+          actualBranch: actualBranch || null,
+        },
+      };
+    }
+  } catch {
+    return {
+      path: null,
+      mismatch: {
+        path: worktree.path,
+        actualBranch: null,
+      },
+    };
+  }
+
+  return { path: worktree.path };
 }
 
 export async function generateWorktreePath(