worktree-add 1.2.0 → 1.3.0

package/dist/git/extract-diagnostic-line.js

@@ -0,0 +1,13 @@
+export function extractDiagnosticLine(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const trimmed = message.trim();
+    const nonEmptyLines = trimmed
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    return (
+    // Best-effort: match English prefixes; localized messages fall back to the last non-empty line.
+    nonEmptyLines.find((line) => /(?:^|\s)(?:fatal:|error:)/iu.test(line)) ??
+        nonEmptyLines.at(-1) ??
+        trimmed);
+}

package/dist/git/fetch-remote-branch.d.ts

@@ -0,0 +1,9 @@
+import type { StatusLogger } from "../output/create-status-logger.js";
+export type RemoteBranchStatus = "exists" | "missing" | "unknown";
+export declare function fetchRemoteBranch(branch: string, options?: {
+    dryRun?: boolean;
+    logger?: StatusLogger;
+}): {
+    status: RemoteBranchStatus;
+    localExists: boolean;
+};

package/dist/git/fetch-remote-branch.js

@@ -0,0 +1,102 @@
+import { getStatusLogger } from "../output/get-status-logger.js";
+import { fetchOriginBranch, getAheadBehindCounts, getLocalBranchHead, getRemoteBranchHead, git, findWorktreeByBranchName, localBranchExists, normalizeBranchName, remoteBranchExists, } from "./git.js";
+import { extractDiagnosticLine } from "./extract-diagnostic-line.js";
+export function fetchRemoteBranch(branch, options) {
+    const logger = getStatusLogger(options?.logger);
+    const dryRun = options?.dryRun ?? false;
+    const normalized = normalizeBranchName(branch);
+    const localExists = localBranchExists(normalized);
+    if (localExists) {
+        let remoteExists;
+        try {
+            remoteExists = remoteBranchExists(normalized);
+        }
+        catch (error) {
+            const diagnostic = extractDiagnosticLine(error);
+            logger.warn(`Failed to query origin for '${normalized}': ${diagnostic}. Using existing local branch. (If you expected a remote branch, double-check your network connection and branch name.)`);
+            return { status: "unknown", localExists };
+        }
+        if (!remoteExists)
+            return { status: "missing", localExists };
+        try {
+            if (dryRun) {
+                logger.step(`Would fetch origin/${normalized}`);
+                logger.detail(`Dry run: local '${normalized}' may be fast-forwarded after fetch if it is behind origin/${normalized}.`);
+                return { status: "exists", localExists };
+            }
+            logger.step(`Fetching origin/${normalized} …`);
+            fetchOriginBranch(normalized);
+        }
+        catch (error) {
+            const diagnostic = extractDiagnosticLine(error);
+            logger.warn(`Failed to fetch origin/${normalized}: ${diagnostic}. Using existing local branch (origin status unknown).`);
+            return { status: "unknown", localExists };
+        }
+        const localHead = getLocalBranchHead(normalized);
+        const remoteHead = getRemoteBranchHead(normalized);
+        if (!localHead || !remoteHead || localHead === remoteHead) {
+            return { status: "exists", localExists };
+        }
+        let counts;
+        try {
+            counts = getAheadBehindCounts(localHead, remoteHead);
+        }
+        catch (error) {
+            const diagnostic = extractDiagnosticLine(error);
+            logger.warn(`Failed to compare local '${normalized}' with origin/${normalized}: ${diagnostic}. Using existing local branch as-is.`);
+            return { status: "exists", localExists };
+        }
+        const { ahead, behind } = counts;
+        if (ahead === 0 && behind > 0) {
+            // Note: dryRun returns before fetching, so this path only runs when dryRun is false.
+            // resolveWorktreeContext already blocks this, but keep as a defensive check.
+            const activeWorktree = findWorktreeByBranchName(normalized);
+            if (activeWorktree) {
+                logger.warn(`Local branch '${normalized}' is checked out in ${activeWorktree}; skipping fast-forward.`);
+                return { status: "exists", localExists };
+            }
+            logger.detail(`Fast-forwarding '${normalized}' from ${localHead} to ${remoteHead}.`);
+            logger.step(`Fast-forwarding local '${normalized}' to origin/${normalized} …`);
+            git("branch", "-f", "--", normalized, `origin/${normalized}`);
+            return { status: "exists", localExists };
+        }
+        if (ahead === 0 && behind === 0) {
+            // Defensive: rev-list should report differences when heads differ,
+            // but shallow/corrupted refs can yield 0/0 counts.
+            logger.warn(`Local branch '${normalized}' differs from origin/${normalized}, but Git reports no ahead/behind differences. Using existing local branch; if you encounter issues, try re-cloning the repository.`);
+            return { status: "exists", localExists };
+        }
+        const descriptors = [];
+        if (ahead > 0)
+            descriptors.push(`ahead by ${ahead}`);
+        if (behind > 0)
+            descriptors.push(`behind by ${behind}`);
+        const relationship = behind > 0 ? "has diverged from" : "is ahead of";
+        logger.warn(`Local branch '${normalized}' ${relationship} origin/${normalized} (${descriptors.join(" and ")}); using existing local branch as-is.`);
+        return { status: "exists", localExists };
+    }
+    let remoteExists;
+    try {
+        remoteExists = remoteBranchExists(normalized);
+    }
+    catch (error) {
+        const diagnostic = extractDiagnosticLine(error);
+        logger.warn(`Failed to reach origin to check whether '${normalized}' exists: ${diagnostic}. (If you expected a remote branch, double-check your network connection and branch name.)`);
+        return { status: "unknown", localExists };
+    }
+    if (!remoteExists)
+        return { status: "missing", localExists };
+    try {
+        if (dryRun) {
+            logger.step(`Would fetch origin/${normalized}`);
+            return { status: "exists", localExists };
+        }
+        logger.step(`Fetching origin/${normalized} …`);
+        fetchOriginBranch(normalized);
+    }
+    catch (error) {
+        const diagnostic = extractDiagnosticLine(error);
+        throw new Error(`Failed to fetch origin/${normalized}: ${diagnostic}. Cannot proceed without a local branch.`);
+    }
+    return { status: "exists", localExists };
+}

package/dist/git/git.d.ts

@@ -21,8 +21,30 @@ export declare function normalizeBranchName(name: string): string;
 export declare function localBranchExists(branch: string): boolean;
 /**
  * Check if a remote branch exists on origin.
+ *
+ * Note: this function may throw on network/auth failures or when the `origin`
+ * remote is missing/misconfigured. Callers that want a degraded-mode fallback
+ * should wrap it in try/catch.
  */
 export declare function remoteBranchExists(branch: string): boolean;
+/**
+ * Fetch a branch from origin into the remote-tracking ref.
+ *
+ * This does not update any local branch heads.
+ */
+export declare function fetchOriginBranch(branch: string): void;
+/**
+ * Get the current head commit for a local branch.
+ */
+export declare function getLocalBranchHead(branch: string): string | undefined;
+/**
+ * Get the current head commit for a remote-tracking branch.
+ */
+export declare function getRemoteBranchHead(branch: string): string | undefined;
+export declare function getAheadBehindCounts(localHead: string, remoteHead: string): {
+    ahead: number;
+    behind: number;
+};
 /**
  * Convert an arbitrary string to a filesystem-safe single path segment.
  *

package/dist/git/git.js

@@ -24,6 +24,8 @@ export function git(...arguments_) {
     const result = spawnSync("git", gitArguments, {
         encoding: "utf8",
         maxBuffer: 100 * 1024 * 1024, // 100 MB to accommodate large outputs
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
         ...(cwd && { cwd }),
     });
     if (result.error)
@@ -63,16 +65,61 @@ export function localBranchExists(branch) {
 }
 /**
  * Check if a remote branch exists on origin.
+ *
+ * Note: this function may throw on network/auth failures or when the `origin`
+ * remote is missing/misconfigured. Callers that want a degraded-mode fallback
+ * should wrap it in try/catch.
  */
 export function remoteBranchExists(branch) {
+    const normalized = normalizeBranchName(branch);
+    // Use a fully-qualified ref to avoid option-parsing ambiguity for branch
+    // names starting with '-'.
+    return !!git("ls-remote", "--heads", "origin", `refs/heads/${normalized}`);
+}
+/**
+ * Fetch a branch from origin into the remote-tracking ref.
+ *
+ * This does not update any local branch heads.
+ */
+export function fetchOriginBranch(branch) {
+    const normalized = normalizeBranchName(branch);
+    const refspec = `+refs/heads/${normalized}:refs/remotes/origin/${normalized}`;
+    git("fetch", "origin", "--", refspec);
+}
+/**
+ * Get the current head commit for a local branch.
+ */
+export function getLocalBranchHead(branch) {
     try {
         const normalized = normalizeBranchName(branch);
-        return !!git("ls-remote", "--heads", "origin", normalized);
+        return git("rev-parse", `refs/heads/${normalized}`);
     }
     catch {
-        return false;
+        return undefined;
     }
 }
+/**
+ * Get the current head commit for a remote-tracking branch.
+ */
+export function getRemoteBranchHead(branch) {
+    try {
+        const normalized = normalizeBranchName(branch);
+        return git("rev-parse", `refs/remotes/origin/${normalized}`);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function getAheadBehindCounts(localHead, remoteHead) {
+    const output = git("rev-list", "--left-right", "--count", `${localHead}...${remoteHead}`);
+    const [aheadRaw, behindRaw] = output.split(/\s+/u);
+    const ahead = Number.parseInt(aheadRaw ?? "0");
+    const behind = Number.parseInt(behindRaw ?? "0");
+    return {
+        ahead: Number.isNaN(ahead) ? 0 : ahead,
+        behind: Number.isNaN(behind) ? 0 : behind,
+    };
+}
 /**
  * Convert an arbitrary string to a filesystem-safe single path segment.
  *
@@ -108,22 +155,29 @@ export function exitWithMessage(message) {
     process.exit(1);
 }
 /**
- * Prompts user for yes/no confirmation
- * @param message The message to display to the user
- * @returns Promise<boolean> - true if user confirms, false otherwise
+ * Prompt for input and return the user's response.
  */
-export async function confirm(message) {
+async function prompt(message) {
     const rl = readline.createInterface({
         input: process.stdin,
-        output: process.stdout,
+        output: process.stderr,
     });
     try {
-        const answer = await rl.question(`${message} [y/N] `);
-        return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+        return await rl.question(message);
     }
     finally {
         rl.close();
     }
 }
+/**
+ * Prompts user for yes/no confirmation
+ * @param message The message to display to the user
+ * @returns Promise<boolean> - true if user confirms, false otherwise
+ */
+export async function confirm(message) {
+    const answer = await prompt(`${message} [y/N] `);
+    const normalized = answer.trim().toLowerCase();
+    return normalized === "y" || normalized === "yes";
+}
 // Re-export worktree parsing functions for backward compatibility
 export { getRepositoryName, findWorktreeByBranchName, } from "./worktree-discovery.js";

package/dist/git/remove-worktree.d.ts

@@ -0,0 +1 @@
+export declare function removeWorktree(destinationDirectory: string): void;

package/dist/git/remove-worktree.js

@@ -0,0 +1,4 @@
+import { git } from "./git.js";
+export function removeWorktree(destinationDirectory) {
+    git("worktree", "remove", "--force", "--", destinationDirectory);
+}

package/dist/output/create-status-logger.d.ts

@@ -0,0 +1,13 @@
+export type StatusLogger = {
+    readonly step: (message: string) => void;
+    readonly success: (message: string) => void;
+    readonly detail: (message: string) => void;
+    readonly warn: (message: string) => void;
+};
+type StatusLoggerOptions = {
+    readonly verbose: boolean;
+    readonly dryRun: boolean;
+    readonly decorate: boolean;
+};
+export declare function createStatusLogger(options: StatusLoggerOptions): StatusLogger;
+export {};

package/dist/output/create-status-logger.js

@@ -0,0 +1,32 @@
+const emit = (message) => {
+    console.error(message);
+};
+export function createStatusLogger(options) {
+    const shouldLogSteps = options.verbose || options.dryRun;
+    const shouldLogDetails = options.verbose || options.dryRun;
+    const stepPrefix = options.decorate ? "➤ " : "";
+    const successPrefix = options.decorate ? "✓ " : "";
+    const warningPrefix = options.decorate ? "⚠ " : "Warning: ";
+    const detailPrefix = options.decorate ? "  • " : "  - ";
+    const dryRunPrefix = options.dryRun ? "DRY RUN: " : "";
+    return {
+        step(message) {
+            if (!shouldLogSteps)
+                return;
+            emit(`${dryRunPrefix}${stepPrefix}${message}`);
+        },
+        success(message) {
+            if (!options.verbose)
+                return;
+            emit(`${dryRunPrefix}${successPrefix}${message}`);
+        },
+        detail(message) {
+            if (!shouldLogDetails)
+                return;
+            emit(`${dryRunPrefix}${detailPrefix}${message}`);
+        },
+        warn(message) {
+            emit(`${warningPrefix}${message}`);
+        },
+    };
+}

package/dist/output/get-status-logger.d.ts

@@ -0,0 +1,2 @@
+import type { StatusLogger } from "./create-status-logger.js";
+export declare function getStatusLogger(logger: StatusLogger | undefined): StatusLogger;

package/dist/output/get-status-logger.js

@@ -0,0 +1,12 @@
+// Fallback logger only emits warnings so important signals aren't dropped.
+const fallbackLogger = {
+    step() { },
+    success() { },
+    detail() { },
+    warn(message) {
+        console.error(message);
+    },
+};
+export function getStatusLogger(logger) {
+    return logger ?? fallbackLogger;
+}

package/dist/project/install-commands.js

@@ -40,7 +40,7 @@ export async function getInstallCommand(pm, cwd) {
  */
 export function getInstallMessage(cmd) {
     if (cmd.command === "npm" && cmd.args[0] === "ci") {
-        return "➤ Running npm ci (using package-lock.json) …";
+        return "Running npm ci (using package-lock.json) …";
     }
-    return `➤ Running ${formatCommand(cmd.command, cmd.args)} …`;
+    return `Running ${formatCommand(cmd.command, cmd.args)} …`;
 }

package/dist/project/next.d.ts

@@ -3,5 +3,8 @@
  *
  * Utilities for working with Next.js projects
  */
+import type { StatusLogger } from "../output/create-status-logger.js";
 export declare const isNextProject: (directory: string) => Promise<boolean>;
-export declare const isNextTypegenSupported: (directory: string) => Promise<boolean>;
+export declare const isNextTypegenSupported: (directory: string, options?: {
+    logger?: StatusLogger;
+}) => Promise<boolean>;

package/dist/project/next.js

@@ -26,9 +26,9 @@ export const isNextProject = async (directory) => {
     }
     return Boolean(packageJson.dependencies?.next ?? packageJson.devDependencies?.next);
 };
-export const isNextTypegenSupported = async (directory) => {
+export const isNextTypegenSupported = async (directory, options = {}) => {
     try {
-        const result = await runPackageManagerBinary(directory, "next", ["--help"], { stdio: "pipe" });
+        const result = await runPackageManagerBinary(directory, "next", ["--help"], { stdio: "pipe", logger: options.logger });
         if (!result) {
             return false;
         }

package/dist/project/package-manager.d.ts

@@ -3,8 +3,11 @@
  *
  * Helpers for detecting and running package managers
  */
+import type { StatusLogger } from "../output/create-status-logger.js";
 interface RunOptions {
     readonly stdio?: "inherit" | "pipe";
+    readonly dryRun?: boolean;
+    readonly logger?: StatusLogger;
 }
 interface RunBinaryResult {
     readonly stdout: string;
@@ -13,6 +16,9 @@ interface RunBinaryResult {
 /**
  * Install dependencies for a project using the detected package manager.
  */
-export declare function installDependencies(cwd: string): Promise<void>;
+export declare function installDependencies(cwd: string, options?: {
+    dryRun?: boolean;
+    logger?: StatusLogger;
+}): Promise<void>;
 export declare function runPackageManagerBinary(cwd: string, binary: string, arguments_?: string[], options?: RunOptions): Promise<RunBinaryResult | undefined>;
 export {};

package/dist/project/package-manager.js

@@ -7,6 +7,7 @@ import { spawnSync } from "node:child_process";
 import { detect } from "package-manager-detector/detect";
 import { formatCommand, getBinaryRunCommand, } from "./package-manager-commands.js";
 import { getInstallCommand, getInstallMessage } from "./install-commands.js";
+import { getStatusLogger } from "../output/get-status-logger.js";
 const runOrThrow = (command, arguments_, cwd, options = {}) => {
     const result = spawnSync(command, arguments_, {
         cwd,
@@ -42,16 +43,24 @@ async function detectPackageManager(cwd) {
 /**
  * Install dependencies for a project using the detected package manager.
  */
-export async function installDependencies(cwd) {
+export async function installDependencies(cwd, options = {}) {
+    const logger = getStatusLogger(options.logger);
+    const dryRun = options.dryRun ?? false;
     const pm = await detectPackageManager(cwd);
     const cmd = await getInstallCommand(pm, cwd);
-    console.log(getInstallMessage(cmd));
+    logger.step(getInstallMessage(cmd));
+    if (dryRun)
+        return;
     runOrThrow(cmd.command, cmd.args, cwd);
 }
 export async function runPackageManagerBinary(cwd, binary, arguments_ = [], options = {}) {
+    const logger = getStatusLogger(options.logger);
+    const dryRun = options.dryRun ?? false;
     const pm = await detectPackageManager(cwd);
     const { command, args: commandArguments } = getBinaryRunCommand(pm, binary, arguments_);
-    console.log(`➤ Running ${formatCommand(command, commandArguments)} …`);
+    logger.step(`Running ${formatCommand(command, commandArguments)} …`);
+    if (dryRun)
+        return undefined;
     const result = runOrThrow(command, commandArguments, cwd, options);
     if (options.stdio === "pipe") {
         return {

package/dist/project/setup.d.ts

@@ -3,7 +3,11 @@
  *
  * Utilities for setting up project dependencies and build artifacts
  */
+import type { StatusLogger } from "../output/create-status-logger.js";
 /**
  * Install dependencies and run Next.js typegen if applicable
  */
-export declare function setupProject(destinationDirectory: string): Promise<void>;
+export declare function setupProject(destinationDirectory: string, options?: {
+    dryRun?: boolean;
+    logger?: StatusLogger;
+}): Promise<void>;

package/dist/project/setup.js

@@ -5,27 +5,35 @@
  */
 import path from "node:path";
 import { fileExists } from "../git/git.js";
+import { getStatusLogger } from "../output/get-status-logger.js";
 import { installDependencies, runPackageManagerBinary, } from "./package-manager.js";
 import { isNextProject, isNextTypegenSupported } from "./next.js";
 /**
  * Install dependencies and run Next.js typegen if applicable
  */
-export async function setupProject(destinationDirectory) {
+export async function setupProject(destinationDirectory, options = {}) {
+    const logger = getStatusLogger(options.logger);
+    const dryRun = options.dryRun ?? false;
     const packageJsonPath = path.join(destinationDirectory, "package.json");
     if (!(await fileExists(packageJsonPath))) {
         return;
     }
-    await installDependencies(destinationDirectory);
+    await installDependencies(destinationDirectory, { dryRun, logger });
     // Run Next.js type generation if applicable
     if (await isNextProject(destinationDirectory)) {
-        console.log("➤ Checking Next.js CLI typegen support …");
-        const hasTypegenSupport = await isNextTypegenSupported(destinationDirectory);
+        if (dryRun) {
+            logger.step("Would run next typegen if supported");
+            return;
+        }
+        logger.step("Checking Next.js CLI typegen support …");
+        const hasTypegenSupport = await isNextTypegenSupported(destinationDirectory, { logger });
         if (hasTypegenSupport) {
-            console.log("➤ Running next typegen …");
-            await runPackageManagerBinary(destinationDirectory, "next", ["typegen"]);
+            await runPackageManagerBinary(destinationDirectory, "next", ["typegen"], {
+                logger,
+            });
         }
         else {
-            console.warn("! Skipping next typegen: installed Next.js CLI does not support this command.");
+            logger.warn("Skipping next typegen: installed Next.js CLI does not support this command.");
         }
     }
 }

package/dist/worktree/destination-directory.d.ts

@@ -3,8 +3,15 @@
  *
  * Utilities for managing worktree directories
  */
+import type { StatusLogger } from "../output/create-status-logger.js";
 /**
- * Check if directory exists and prompt for removal if needed
- * Returns true if the directory should be created
+ * Check if directory exists and handle removal if needed.
  */
-export declare function handleExistingDirectory(destinationDirectory: string): Promise<void>;
+type HandleExistingDirectoryOptions = {
+    readonly dryRun?: boolean;
+    readonly assumeYes?: boolean;
+    readonly interactive?: boolean;
+    readonly logger?: StatusLogger;
+};
+export declare function handleExistingDirectory(destinationDirectory: string, options?: HandleExistingDirectoryOptions): Promise<boolean>;
+export {};

package/dist/worktree/destination-directory.js

@@ -15,31 +15,109 @@
  * may not be visible in a GUI. Files can be recovered by navigating to
  * the platform-specific trash location.
  */
-import trash from "trash";
 import path from "node:path";
-import { fileExists, confirm, exitWithMessage } from "../git/git.js";
-/**
- * Check if directory exists and prompt for removal if needed
- * Returns true if the directory should be created
- */
-export async function handleExistingDirectory(destinationDirectory) {
+import trash from "trash";
+import { fileExists, confirm, exitWithMessage, git } from "../git/git.js";
+import { getStatusLogger } from "../output/get-status-logger.js";
+export async function handleExistingDirectory(destinationDirectory, options = {}) {
     if (!(await fileExists(destinationDirectory))) {
-        return;
+        return true;
+    }
+    const logger = getStatusLogger(options.logger);
+    const dryRun = options.dryRun ?? false;
+    const assumeYes = options.assumeYes ?? false;
+    const interactive = options.interactive ?? false;
+    const isTty = process.stdin.isTTY;
+    const ciValue = process.env.CI?.toLowerCase();
+    const isCi = ciValue === "true" || ciValue === "1";
+    const directoryName = path.basename(destinationDirectory);
+    if (dryRun) {
+        if (!assumeYes) {
+            // Explicit --interactive in CI without a TTY can't prompt; call it out.
+            if (isCi && interactive && !isTty) {
+                logger.warn(`Dry run: directory '${directoryName}' already exists, and CI mode is enabled. Interactive prompts are disabled in CI. Re-run with --yes to move the directory to trash, or remove it manually.`);
+                return false;
+            }
+            if (!interactive) {
+                const ciHint = isCi ? " (CI is enabled)" : "";
+                logger.warn(`Dry run: directory '${directoryName}' already exists${ciHint}. Refusing to prompt in non-interactive mode. Re-run with --interactive to confirm, or --yes to move it to trash.`);
+                return false;
+            }
+            if (!isTty) {
+                logger.warn(`Dry run: directory '${directoryName}' already exists, but stdin is not a TTY. Re-run with --yes to move it to trash, or remove it manually.`);
+                return false;
+            }
+            logger.step(`Would prompt to move existing directory '${directoryName}' to trash`);
+            return false;
+        }
+        logger.step(`Would move existing directory '${directoryName}' to trash`);
+        return true;
+    }
+    if (!assumeYes) {
+        // Explicit --interactive in CI without a TTY can't prompt; call it out.
+        if (isCi && interactive && !isTty) {
+            exitWithMessage(`Directory '${directoryName}' already exists, and CI mode is enabled.\n` +
+                "Interactive prompts are disabled in CI.\n" +
+                "Re-run with --yes to move the directory to trash, or remove it manually.");
+        }
+        if (!interactive) {
+            const ciHint = isCi ? " (CI is enabled)" : "";
+            exitWithMessage(`Directory '${directoryName}' already exists${ciHint}.\n` +
+                "Refusing to prompt in non-interactive mode.\n" +
+                "Re-run with --interactive to confirm, or --yes to move it to trash.");
+        }
+        if (!isTty) {
+            exitWithMessage(`Directory '${directoryName}' already exists, but stdin is not a TTY.\n` +
+                "Re-run with --yes to move it to trash, or remove it manually.");
+        }
+        const proceed = await confirm(`Directory '${directoryName}' already exists. Move to trash and recreate? (You can restore it from your system trash if needed)`);
+        if (!proceed) {
+            console.error("Operation cancelled.");
+            // eslint-disable-next-line unicorn/no-process-exit -- User requested cancellation
+            process.exit(0);
+        }
+    }
+    const resolvedDestination = path.resolve(destinationDirectory);
+    let shouldPruneWorktree = false;
+    try {
+        const worktreeList = git("worktree", "list", "--porcelain");
+        const lines = worktreeList.split(/\n/u);
+        for (const line of lines) {
+            if (!line.startsWith("worktree "))
+                continue;
+            const worktreePath = line.replace(/^worktree\s+/u, "").trim();
+            if (path.resolve(worktreePath) === resolvedDestination) {
+                shouldPruneWorktree = true;
+                break;
+            }
+        }
     }
-    const proceed = await confirm(`Directory '${path.basename(destinationDirectory)}' already exists. Move to trash and recreate? (You can restore it from your system trash if needed)`);
-    if (!proceed) {
-        console.log("Operation cancelled.");
-        // eslint-disable-next-line unicorn/no-process-exit -- User requested cancellation
-        process.exit(0);
+    catch (error) {
+        const details = error instanceof Error ? (error.stack ?? error.message) : String(error);
+        logger.detail(`Error checking for existing worktree registration: ${details}`);
     }
     // Move the existing directory to trash
-    console.log(`➤ Moving existing directory to trash...`);
+    logger.step(`Moving existing directory '${directoryName}' to trash...`);
     try {
         await trash(destinationDirectory);
-        console.log("✓ Directory moved to trash successfully");
+        logger.success("Directory moved to trash successfully");
     }
     catch (error) {
-        console.error("Error details:", error);
+        const details = error instanceof Error ? (error.stack ?? error.message) : String(error);
+        logger.detail(`Error details: ${details}`);
         exitWithMessage(`Failed to move existing directory to trash: ${error instanceof Error ? error.message : String(error)}`);
     }
+    if (!shouldPruneWorktree) {
+        return true;
+    }
+    logger.detail(`Pruning stale worktree registration for '${directoryName}'.`);
+    try {
+        git("worktree", "prune");
+    }
+    catch (error) {
+        const details = error instanceof Error ? (error.stack ?? error.message) : String(error);
+        logger.detail(`Error details: ${details}`);
+        exitWithMessage(`Failed to prune stale worktree registration for '${directoryName}'. Run 'git worktree prune' and retry.`);
+    }
+    return true;
 }

package/dist/worktree/untracked-file-copy.d.ts

@@ -3,7 +3,11 @@
  *
  * Utilities for copying untracked files to worktrees
  */
+import type { StatusLogger } from "../output/create-status-logger.js";
 /**
  * Copy untracked files from source to destination, excluding ignored patterns
  */
-export declare function copyUntrackedFiles(repoRoot: string, destinationDirectory: string): Promise<void>;
+export declare function copyUntrackedFiles(repoRoot: string, destinationDirectory: string, options?: {
+    dryRun?: boolean;
+    logger?: StatusLogger;
+}): Promise<void>;