worktree-add 1.2.1 → 1.3.1

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>;

package/dist/worktree/untracked-file-copy.js

@@ -7,29 +7,71 @@ import * as fs from "node:fs/promises";
 import path from "node:path";
 import { git } from "../git/git.js";
 import { EXTRA_IGNORED_PATTERNS, globToRegExp, toPosixPath, } from "./file-patterns.js";
+import { getStatusLogger } from "../output/get-status-logger.js";
 /**
  * Copy untracked files from source to destination, excluding ignored patterns
  */
-export async function copyUntrackedFiles(repoRoot, destinationDirectory) {
+export async function copyUntrackedFiles(repoRoot, destinationDirectory, options) {
+    const logger = getStatusLogger(options?.logger);
+    const dryRun = options?.dryRun ?? false;
     const extraIgnoredRegexes = EXTRA_IGNORED_PATTERNS.map((pattern) => globToRegExp(pattern));
-    const untrackedEntries = git("ls-files", "--others", // untracked files
-    "--ignored", // ignored files
-    "--exclude-standard", // respect .gitignore rules
-    "-z")
-        .split("\0")
-        .filter(Boolean);
+    const untrackedEntries = new Set();
+    // Combine untracked-not-ignored (`--others`) and untracked-ignored (`--others --ignored`) entries.
+    // These sets should be disjoint, but we dedupe defensively.
+    const untrackedPaths = [
+        ...git("ls-files", "--others", "--exclude-standard", "--full-name", "-z", // null-separated output for safe parsing
+        { cwd: repoRoot })
+            .split("\0")
+            .filter(Boolean),
+        ...git("ls-files", "--others", "--ignored", "--exclude-standard", "--full-name", "-z", // null-separated output for safe parsing
+        { cwd: repoRoot })
+            .split("\0")
+            .filter(Boolean),
+    ];
+    for (const entry of untrackedPaths) {
+        untrackedEntries.add(entry);
+    }
     for (const relativePath of untrackedEntries) {
+        const resolvedSourcePath = path.resolve(repoRoot, relativePath);
+        const relativeToRoot = path.relative(repoRoot, resolvedSourcePath);
+        const escapesRepoRoot = path.isAbsolute(relativeToRoot) ||
+            relativeToRoot === ".." ||
+            relativeToRoot.startsWith(`..${path.sep}`);
+        if (escapesRepoRoot) {
+            logger.warn(`Skipping ${relativePath} (path escapes repo root).`);
+            continue;
+        }
         const posixPath = toPosixPath(relativePath);
         if (extraIgnoredRegexes.some((regex) => regex.test(posixPath))) {
             continue;
         }
-        const sourcePath = path.resolve(repoRoot, relativePath);
+        const sourcePath = resolvedSourcePath;
         const destinationPath = path.join(destinationDirectory, relativePath);
+        const destinationExists = await fs
+            .stat(destinationPath)
+            .then(() => true)
+            .catch((error) => {
+            if (error &&
+                typeof error === "object" &&
+                "code" in error &&
+                error.code === "ENOENT") {
+                return false;
+            }
+            throw error;
+        });
+        if (destinationExists) {
+            logger.detail(`Skipped ${relativePath} (destination already exists).`);
+            continue;
+        }
+        if (dryRun) {
+            logger.detail(`Would copy ${relativePath}`);
+            continue;
+        }
         await fs.mkdir(path.dirname(destinationPath), { recursive: true });
         await fs.cp(sourcePath, destinationPath, {
             recursive: true,
             errorOnExist: false,
         });
-        console.log(`  • copied ${relativePath}`);
+        logger.detail(`Copied ${relativePath}`);
     }
 }

package/package.json

@@ -2,8 +2,8 @@
   "name": "worktree-add",
   "author": "Łukasz Jerciński",
   "license": "MIT",
-  "version": "1.2.1",
-  "description": "Create a Git worktree next to your current repo for a branch, copy useful local files, install deps, and open it in your editor.",
+  "version": "1.3.1",
+  "description": "Create a Git worktree next to your current repo for a branch, copy useful local files, install deps, and open it in your apps.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Jercik/worktree-add.git"
@@ -52,7 +52,9 @@
     "node": ">=22.14.0"
   },
   "dependencies": {
+    "@commander-js/extra-typings": "^14.0.0",
     "commander": "^14.0.2",
+    "open": "^11.0.0",
     "package-manager-detector": "^1.6.0",
     "trash": "^10.0.1"
   },

package/dist/git/parse-branch-head-mismatch-choice.d.ts

@@ -1,7 +0,0 @@
-/**
- * parse-branch-head-mismatch-choice.ts
- *
- * Pure helpers for parsing interactive choices in the branch-head mismatch flow.
- */
-export type ResolutionChoice = "keep-local" | "update-local" | "abort";
-export declare function parseResolutionChoice(input: string, defaultChoice: ResolutionChoice): ResolutionChoice | undefined;

package/dist/git/parse-branch-head-mismatch-choice.js

@@ -1,26 +0,0 @@
-/**
- * parse-branch-head-mismatch-choice.ts
- *
- * Pure helpers for parsing interactive choices in the branch-head mismatch flow.
- */
-export function parseResolutionChoice(input, defaultChoice) {
-    const normalized = input.trim().toLowerCase();
-    if (normalized === "")
-        return defaultChoice;
-    if (normalized === "1" || normalized === "keep" || normalized === "local") {
-        return "keep-local";
-    }
-    if (normalized === "2" ||
-        normalized === "update" ||
-        normalized === "remote") {
-        return "update-local";
-    }
-    if (normalized === "3" ||
-        normalized === "abort" ||
-        normalized === "a" ||
-        normalized === "q" ||
-        normalized === "quit") {
-        return "abort";
-    }
-    return undefined;
-}

package/dist/git/resolve-branch-head-mismatch.d.ts

@@ -1,6 +0,0 @@
-/**
- * resolve-branch-head-mismatch.ts
- *
- * Warn and resolve mismatched local/remote branch heads.
- */
-export declare function resolveBranchHeadMismatch(branch: string): Promise<boolean>;

package/dist/git/resolve-branch-head-mismatch.js

@@ -1,79 +0,0 @@
-/**
- * resolve-branch-head-mismatch.ts
- *
- * Warn and resolve mismatched local/remote branch heads.
- */
-import { confirm, fetchOriginBranch, getLocalBranchHead, getRemoteBranchHead, git, localBranchExists, normalizeBranchName, prompt, remoteBranchExists, } from "./git.js";
-import { parseResolutionChoice } from "./parse-branch-head-mismatch-choice.js";
-const shortHash = (value) => value.slice(0, 7);
-const 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,
-    };
-};
-const promptResolution = async (branch, localHead, remoteHead, ahead, behind) => {
-    const updateLabel = ahead > 0
-        ? `Update local branch to match origin (drops ${ahead} local commit${ahead === 1 ? "" : "s"})`
-        : "Update local branch to match origin (fast-forward)";
-    const defaultChoice = ahead === 0 && behind > 0 ? "update-local" : "keep-local";
-    const defaultIndex = defaultChoice === "update-local" ? "2" : "1";
-    console.warn(`⚠️  Local branch '${branch}' and origin/${branch} point to different commits.`);
-    console.warn(`  local:  ${shortHash(localHead)}`);
-    console.warn(`  origin: ${shortHash(remoteHead)}`);
-    if (ahead > 0 || behind > 0) {
-        const descriptors = [];
-        if (ahead > 0)
-            descriptors.push(`ahead by ${ahead}`);
-        if (behind > 0)
-            descriptors.push(`behind by ${behind}`);
-        console.warn(`  local is ${descriptors.join(" and ")} relative to origin`);
-    }
-    console.warn("Choose how to proceed:");
-    console.warn("  1) Keep local branch (use local head for the worktree)");
-    console.warn(`  2) ${updateLabel}`);
-    console.warn("  3) Abort");
-    for (;;) {
-        const answer = await prompt(`Select an option (default: ${defaultIndex}): `);
-        const choice = parseResolutionChoice(answer, defaultChoice);
-        if (choice)
-            return choice;
-        console.warn("Please enter 1, 2, or 3.");
-    }
-};
-export async function resolveBranchHeadMismatch(branch) {
-    const normalized = normalizeBranchName(branch);
-    if (!localBranchExists(normalized) || !remoteBranchExists(normalized)) {
-        return true;
-    }
-    console.warn(`➤ Fetching origin/${normalized} to check for divergence …`);
-    fetchOriginBranch(normalized);
-    const localHead = getLocalBranchHead(normalized);
-    const remoteHead = getRemoteBranchHead(normalized);
-    if (!localHead || !remoteHead || localHead === remoteHead) {
-        return true;
-    }
-    const { ahead, behind } = getAheadBehindCounts(localHead, remoteHead);
-    const resolution = await promptResolution(normalized, localHead, remoteHead, ahead, behind);
-    if (resolution === "abort") {
-        console.warn("Operation cancelled.");
-        return false;
-    }
-    if (resolution === "keep-local") {
-        return true;
-    }
-    if (ahead > 0) {
-        const confirmed = await confirm(`Updating local '${normalized}' will discard ${ahead} local commit${ahead === 1 ? "" : "s"} not on origin. Continue?`);
-        if (!confirmed) {
-            console.warn("Operation cancelled.");
-            return false;
-        }
-    }
-    console.warn(`➤ Updating local branch '${normalized}' to origin/${normalized} …`);
-    git("branch", "-f", "--", normalized, `origin/${normalized}`);
-    return true;
-}

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

@@ -1,13 +0,0 @@
-/**
- * worktree-creation.ts
- *
- * Utilities for creating Git worktrees
- */
-/**
- * Fetch a remote branch if it exists remotely but not locally.
- */
-export declare function fetchRemoteBranch(branch: string): void;
-/**
- * Create a worktree for the given branch at the specified destination
- */
-export declare function createWorktree(branch: string, destinationDirectory: string): void;

package/dist/git/worktree-creation.js

@@ -1,35 +0,0 @@
-/**
- * worktree-creation.ts
- *
- * Utilities for creating Git worktrees
- */
-import { fetchOriginBranch, git, localBranchExists, remoteBranchExists, } from "./git.js";
-/**
- * Fetch a remote branch if it exists remotely but not locally.
- */
-export function fetchRemoteBranch(branch) {
-    if (!localBranchExists(branch) && remoteBranchExists(branch)) {
-        console.log(`➤ Fetching origin/${branch} …`);
-        fetchOriginBranch(branch);
-    }
-}
-/**
- * Create a worktree for the given branch at the specified destination
- */
-export function createWorktree(branch, destinationDirectory) {
-    if (localBranchExists(branch)) {
-        // Reuse existing local branch
-        console.log(`➤ git worktree add ${destinationDirectory} ${branch}`);
-        git("worktree", "add", destinationDirectory, branch);
-    }
-    else if (remoteBranchExists(branch)) {
-        // Create new local branch tracking the remote branch
-        console.log(`➤ git worktree add --track -b ${branch} ${destinationDirectory} origin/${branch}`);
-        git("worktree", "add", "--track", "-b", branch, destinationDirectory, `origin/${branch}`);
-    }
-    else {
-        // Create new branch in the worktree from current HEAD
-        console.log(`➤ git worktree add -b ${branch} ${destinationDirectory}`);
-        git("worktree", "add", "-b", branch, destinationDirectory);
-    }
-}