worktree-add 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Łukasz Jerciński
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/worktree-add

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import("../dist/cli.js");

package/dist/cli.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env -S node --experimental-strip-types
+/**
+ * worktree-add.ts
+ *
+ * Create or reuse a Git worktree for <branch> as a sibling of the current worktree.
+ * Note: the destination is placed next to whichever worktree you run this from,
+ * not necessarily the original "main" checkout.
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env -S node --experimental-strip-types
+/**
+ * worktree-add.ts
+ *
+ * Create or reuse a Git worktree for <branch> as a sibling of the current worktree.
+ * Note: the destination is placed next to whichever worktree you run this from,
+ * not necessarily the original "main" checkout.
+ */
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { Command } from "commander";
+import packageJson from "../package.json" with { type: "json" };
+import { git, getRepositoryName, normalizeBranchName, toSafePathSegment, findWorktreeByBranchName, exitWithMessage, } from "./git/git.js";
+import { copyUntrackedFiles } from "./worktree/untracked-file-copy.js";
+import { fetchRemoteBranch, createWorktree } from "./git/worktree-creation.js";
+import { handleExistingDirectory } from "./worktree/destination-directory.js";
+import { setupProject } from "./project/setup.js";
+async function main(branchRaw) {
+    const branch = normalizeBranchName(branchRaw);
+    // Prevent attempting to add a worktree for a branch that is already checked out
+    const existingWorktree = findWorktreeByBranchName(branch);
+    if (existingWorktree) {
+        exitWithMessage(`Branch '${branch}' is already checked out in: ${existingWorktree}\n` +
+            "You cannot add another worktree for the same branch.\n" +
+            "Open that worktree instead or remove it before retrying.");
+    }
+    // Determine destination directory for the new worktree
+    const repoRoot = git("rev-parse", "--show-toplevel");
+    const repoName = getRepositoryName();
+    const branchDirectorySegment = toSafePathSegment(branch);
+    const destinationDirectory = path.join(path.dirname(repoRoot), `${repoName}-${branchDirectorySegment}`);
+    // Check if destination directory already exists
+    await handleExistingDirectory(destinationDirectory);
+    // Step 1: Fetch remote branch if it exists
+    fetchRemoteBranch(branch);
+    // Step 2: Create the worktree
+    createWorktree(branch, destinationDirectory);
+    // Step 3: Copy untracked files, excluding any on the denylist
+    await copyUntrackedFiles(repoRoot, destinationDirectory);
+    // Step 4: Install dependencies and run project-specific setup
+    await setupProject(destinationDirectory);
+    // Step 6: Open the new worktree in Cursor
+    console.log("➤ Opening Cursor …");
+    spawnSync("cursor", [destinationDirectory], { stdio: "inherit" });
+}
+const program = new Command()
+    .name(packageJson.name)
+    .description("Create or reuse a Git worktree for a branch as a sibling of the current worktree")
+    .version(packageJson.version)
+    .argument("<branch>", "branch name for the worktree")
+    .action(async (branch) => {
+    try {
+        await main(branch);
+    }
+    catch (error) {
+        console.error(error);
+        process.exitCode = 1;
+    }
+});
+program.parse();

package/dist/git/git.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Run a git command synchronously and return its trimmed stdout.
+ * Any failure causes the script to throw.
+ * @param args Git command arguments. If the last argument is an object with a `cwd` property,
+ *             it will be used as the working directory for the command.
+ */
+export declare function git(...arguments_: [...string[], {
+    cwd?: string;
+}] | string[]): string;
+/**
+ * Normalize a Git branch reference to a simple branch name.
+ *
+ * This helper trims surrounding whitespace and removes common prefixes so the
+ * resulting string matches the short local branch name used by refs under
+ * `refs/heads/`.
+ */
+export declare function normalizeBranchName(name: string): string;
+/**
+ * Check if a local branch exists by verifying its ref.
+ */
+export declare function localBranchExists(branch: string): boolean;
+/**
+ * Check if a remote branch exists on origin.
+ */
+export declare function remoteBranchExists(branch: string): boolean;
+/**
+ * Convert an arbitrary string to a filesystem-safe single path segment.
+ *
+ * Use this helper when constructing directory names from branch names or other
+ * user-provided identifiers.
+ */
+export declare function toSafePathSegment(input: string): string;
+/**
+ * Check if a file exists at the given path.
+ */
+export declare function fileExists(p: string): Promise<boolean>;
+/**
+ * Print an error message and exit the process with status 1.
+ */
+export declare function exitWithMessage(message: string): never;
+/**
+ * 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 declare function confirm(message: string): Promise<boolean>;
+export { getRepositoryName, findWorktreeByBranchName, } from "./worktree-discovery.js";

package/dist/git/git.js

@@ -0,0 +1,129 @@
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as readline from "node:readline/promises";
+/**
+ * Run a git command synchronously and return its trimmed stdout.
+ * Any failure causes the script to throw.
+ * @param args Git command arguments. If the last argument is an object with a `cwd` property,
+ *             it will be used as the working directory for the command.
+ */
+export function git(...arguments_) {
+    let cwd;
+    let gitArguments;
+    // Check if the last argument is an options object
+    const lastArgument = arguments_.at(-1);
+    if (lastArgument &&
+        typeof lastArgument === "object" &&
+        "cwd" in lastArgument) {
+        cwd = lastArgument.cwd;
+        gitArguments = arguments_.slice(0, -1);
+    }
+    else {
+        gitArguments = arguments_;
+    }
+    const result = spawnSync("git", gitArguments, {
+        encoding: "utf8",
+        maxBuffer: 100 * 1024 * 1024, // 100 MB to accommodate large outputs
+        ...(cwd && { cwd }),
+    });
+    if (result.error)
+        throw result.error;
+    if (result.status !== 0) {
+        throw new Error(result.stderr || `git ${gitArguments[0] ?? "command"} failed`);
+    }
+    return result.stdout.trim();
+}
+/**
+ * Normalize a Git branch reference to a simple branch name.
+ *
+ * This helper trims surrounding whitespace and removes common prefixes so the
+ * resulting string matches the short local branch name used by refs under
+ * `refs/heads/`.
+ */
+export function normalizeBranchName(name) {
+    const trimmed = name.trim();
+    return trimmed
+        .replace(/^refs\/heads\//u, "")
+        .replace(/^refs\/remotes\/origin\//u, "")
+        .replace(/^remotes\/origin\//u, "")
+        .replace(/^origin\//u, "");
+}
+/**
+ * Check if a local branch exists by verifying its ref.
+ */
+export function localBranchExists(branch) {
+    try {
+        const normalized = normalizeBranchName(branch);
+        git("show-ref", "--verify", "--quiet", `refs/heads/${normalized}`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a remote branch exists on origin.
+ */
+export function remoteBranchExists(branch) {
+    try {
+        const normalized = normalizeBranchName(branch);
+        return !!git("ls-remote", "--heads", "origin", normalized);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Convert an arbitrary string to a filesystem-safe single path segment.
+ *
+ * Use this helper when constructing directory names from branch names or other
+ * user-provided identifiers.
+ */
+export function toSafePathSegment(input) {
+    return input
+        .trim()
+        .replaceAll(/[\\/:*?"<>|]/gu, "-")
+        .replaceAll(/\s+/gu, "-")
+        .replaceAll(/\.+$/gu, "")
+        .replaceAll(/-+/gu, "-");
+}
+/**
+ * Check if a file exists at the given path.
+ */
+export async function fileExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Print an error message and exit the process with status 1.
+ */
+export function exitWithMessage(message) {
+    console.error(message);
+    // eslint-disable-next-line unicorn/no-process-exit -- This is a CLI helper function
+    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
+ */
+export async function confirm(message) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = await rl.question(`${message} [y/N] `);
+        return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+    }
+    finally {
+        rl.close();
+    }
+}
+// Re-export worktree parsing functions for backward compatibility
+export { getRepositoryName, findWorktreeByBranchName, } from "./worktree-discovery.js";

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

@@ -0,0 +1,13 @@
+/**
+ * worktree-creation.ts
+ *
+ * Utilities for creating Git worktrees
+ */
+/**
+ * Fetch a remote branch if it exists locally but not remotely
+ */
+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

@@ -0,0 +1,38 @@
+/**
+ * worktree-creation.ts
+ *
+ * Utilities for creating Git worktrees
+ */
+import { spawnSync } from "node:child_process";
+import { git, localBranchExists, remoteBranchExists } from "./git.js";
+/**
+ * Fetch a remote branch if it exists locally but not remotely
+ */
+export function fetchRemoteBranch(branch) {
+    if (!localBranchExists(branch) && remoteBranchExists(branch)) {
+        console.log(`➤ Fetching origin/${branch} …`);
+        spawnSync("git", ["fetch", "origin", branch], {
+            stdio: "inherit",
+        });
+    }
+}
+/**
+ * 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);
+    }
+}

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

@@ -0,0 +1,15 @@
+/**
+ * worktree-discovery.ts
+ *
+ * Utilities for parsing Git worktree information
+ */
+/**
+ * Get the repository name from the main repository directory
+ * Works universally across all Git setups (worktrees, bare repos, no remotes, etc.)
+ */
+export declare function getRepositoryName(): string;
+/**
+ * Find the worktree path where the given branch is currently checked out.
+ * Returns the worktree path if found, otherwise undefined.
+ */
+export declare function findWorktreeByBranchName(branchName: string): string | undefined;

package/dist/git/worktree-discovery.js

@@ -0,0 +1,48 @@
+/**
+ * worktree-discovery.ts
+ *
+ * Utilities for parsing Git worktree information
+ */
+import path from "node:path";
+import { git } from "./git.js";
+/**
+ * Get the repository name from the main repository directory
+ * Works universally across all Git setups (worktrees, bare repos, no remotes, etc.)
+ */
+export function getRepositoryName() {
+    // Get the main worktree path from git worktree list
+    const wtList = git("worktree", "list", "--porcelain");
+    const mainLine = wtList.split(/\n/u).find((l) => l.startsWith("worktree "));
+    if (mainLine) {
+        // Extract path from "worktree /path/to/main/repo"
+        const mainWorktreePath = mainLine.replace(/^worktree\s+/u, "").trim();
+        return path.basename(mainWorktreePath);
+    }
+    // Fallback to current directory if worktree list fails
+    const repoRoot = git("rev-parse", "--show-toplevel");
+    return path.basename(repoRoot);
+}
+/**
+ * Find the worktree path where the given branch is currently checked out.
+ * Returns the worktree path if found, otherwise undefined.
+ */
+export function findWorktreeByBranchName(branchName) {
+    const wtList = git("worktree", "list", "--porcelain");
+    const wtLines = wtList.split(/\n/u);
+    let currentWorktreePath;
+    for (const line of wtLines) {
+        if (line.startsWith("worktree ")) {
+            currentWorktreePath = line.replace(/^worktree\s+/u, "").trim();
+        }
+        else if (line.startsWith("branch ") && currentWorktreePath) {
+            const referenceOrName = line.replace(/^branch\s+/u, "").trim();
+            const shortName = referenceOrName.startsWith("refs/heads/")
+                ? referenceOrName.slice("refs/heads/".length)
+                : referenceOrName;
+            if (shortName === branchName) {
+                return currentWorktreePath;
+            }
+        }
+    }
+    return undefined;
+}

package/dist/project/install-commands.d.ts

@@ -0,0 +1,19 @@
+/**
+ * install-commands.ts
+ *
+ * Package manager-specific install command logic
+ */
+type PackageManager = "npm" | "yarn" | "pnpm" | "bun" | "deno" | undefined;
+interface InstallCommand {
+    readonly command: string;
+    readonly args: string[];
+}
+/**
+ * Get the install command for the given package manager
+ */
+export declare function getInstallCommand(pm: PackageManager, cwd: string): Promise<InstallCommand>;
+/**
+ * Get the display message for an install command
+ */
+export declare function getInstallMessage(cmd: InstallCommand): string;
+export {};

package/dist/project/install-commands.js

@@ -0,0 +1,46 @@
+/**
+ * install-commands.ts
+ *
+ * Package manager-specific install command logic
+ */
+import path from "node:path";
+import { fileExists } from "../git/git.js";
+import { formatCommand, getYarnInstallArguments, } from "./package-manager-commands.js";
+/**
+ * Get the install command for the given package manager
+ */
+export async function getInstallCommand(pm, cwd) {
+    switch (pm) {
+        case "pnpm": {
+            return { command: "pnpm", args: ["install", "--frozen-lockfile"] };
+        }
+        case "yarn": {
+            const yarnArguments = getYarnInstallArguments(cwd);
+            return { command: "yarn", args: yarnArguments };
+        }
+        case "bun": {
+            return { command: "bun", args: ["install", "--frozen-lockfile"] };
+        }
+        case "deno": {
+            return { command: "deno", args: ["install", "--frozen"] };
+        }
+        case "npm":
+        case undefined: {
+            // Use npm ci if lockfile exists, otherwise npm install
+            const hasLockfile = await fileExists(path.join(cwd, "package-lock.json"));
+            if (hasLockfile) {
+                return { command: "npm", args: ["ci"] };
+            }
+            return { command: "npm", args: ["install"] };
+        }
+    }
+}
+/**
+ * Get the display message for an install command
+ */
+export function getInstallMessage(cmd) {
+    if (cmd.command === "npm" && cmd.args[0] === "ci") {
+        return "➤ Running npm ci (using package-lock.json) …";
+    }
+    return `➤ Running ${formatCommand(cmd.command, cmd.args)} …`;
+}

package/dist/project/next.d.ts

@@ -0,0 +1,7 @@
+/**
+ * next.ts
+ *
+ * Utilities for working with Next.js projects
+ */
+export declare const isNextProject: (directory: string) => Promise<boolean>;
+export declare const isNextTypegenSupported: (directory: string) => Promise<boolean>;

package/dist/project/next.js

@@ -0,0 +1,42 @@
+/**
+ * next.ts
+ *
+ * Utilities for working with Next.js projects
+ */
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import { runPackageManagerBinary } from "./package-manager.js";
+const loadPackageJson = async (directory) => {
+    const packageJsonPath = path.join(directory, "package.json");
+    try {
+        const content = await fs.readFile(packageJsonPath, "utf8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+};
+export const isNextProject = async (directory) => {
+    const packageJson = await loadPackageJson(directory);
+    if (!packageJson) {
+        return false;
+    }
+    return Boolean(packageJson.dependencies?.next ?? packageJson.devDependencies?.next);
+};
+export const isNextTypegenSupported = async (directory) => {
+    try {
+        const result = await runPackageManagerBinary(directory, "next", ["--help"], { stdio: "pipe" });
+        if (!result) {
+            return false;
+        }
+        return result.stdout
+            .split("\n")
+            .some((line) => line.trimStart().startsWith("typegen "));
+    }
+    catch {
+        return false;
+    }
+};

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

@@ -0,0 +1,11 @@
+/**
+ * package-manager-commands.ts
+ *
+ * Internal utilities for package manager operations
+ */
+export declare const formatCommand: (command: string, arguments_: string[]) => string;
+export declare const getYarnInstallArguments: (cwd: string) => string[];
+export declare const getBinaryRunCommand: (pm: "npm" | "yarn" | "pnpm" | "bun" | "deno" | undefined, binary: string, arguments_: string[]) => {
+    command: string;
+    args: string[];
+};

package/dist/project/package-manager-commands.js

@@ -0,0 +1,49 @@
+/**
+ * package-manager-commands.ts
+ *
+ * Internal utilities for package manager operations
+ */
+import { spawnSync } from "node:child_process";
+export const formatCommand = (command, arguments_) => {
+    return [command, ...arguments_].join(" ").trim();
+};
+const parseMajorVersion = (value) => {
+    const match = value.trim().match(/^(\d+)/u);
+    if (!match) {
+        return undefined;
+    }
+    const major = Number.parseInt(match[1] ?? "");
+    return Number.isNaN(major) ? undefined : major;
+};
+export const getYarnInstallArguments = (cwd) => {
+    const result = spawnSync("yarn", ["--version"], {
+        cwd,
+        encoding: "utf8",
+    });
+    if (!result.error && result.status === 0) {
+        const versionOutput = result.stdout;
+        const major = parseMajorVersion(versionOutput);
+        if (major !== undefined && major >= 2) {
+            return ["install", "--immutable"];
+        }
+    }
+    return ["install", "--frozen-lockfile"];
+};
+export const getBinaryRunCommand = (pm, binary, arguments_) => {
+    switch (pm) {
+        case "pnpm": {
+            return { command: "pnpm", args: ["exec", binary, ...arguments_] };
+        }
+        case "yarn": {
+            return { command: "yarn", args: [binary, ...arguments_] };
+        }
+        case "bun": {
+            return { command: "bun", args: ["x", binary, ...arguments_] };
+        }
+        case "npm":
+        case "deno":
+        case undefined: {
+            return { command: "npx", args: [binary, ...arguments_] };
+        }
+    }
+};

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

@@ -0,0 +1,18 @@
+/**
+ * package-manager.ts
+ *
+ * Helpers for detecting and running package managers
+ */
+interface RunOptions {
+    readonly stdio?: "inherit" | "pipe";
+}
+interface RunBinaryResult {
+    readonly stdout: string;
+    readonly stderr: string;
+}
+/**
+ * Install dependencies for a project using the detected package manager.
+ */
+export declare function installDependencies(cwd: string): Promise<void>;
+export declare function runPackageManagerBinary(cwd: string, binary: string, arguments_?: string[], options?: RunOptions): Promise<RunBinaryResult | undefined>;
+export {};

package/dist/project/package-manager.js

@@ -0,0 +1,63 @@
+/**
+ * package-manager.ts
+ *
+ * Helpers for detecting and running package managers
+ */
+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";
+const runOrThrow = (command, arguments_, cwd, options = {}) => {
+    const result = spawnSync(command, arguments_, {
+        cwd,
+        stdio: options.stdio ?? "inherit",
+        encoding: "utf8",
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status === null) {
+        const signal = result.signal ? ` (signal: ${result.signal})` : "";
+        throw new Error(`Command "${formatCommand(command, arguments_)}" terminated unexpectedly${signal}.`);
+    }
+    if (result.status !== 0) {
+        throw new Error(`Command "${formatCommand(command, arguments_)}" exited with code ${String(result.status)}.`);
+    }
+    return result;
+};
+/**
+ * Detect the package manager for a given project directory.
+ * Checks the packageManager field in package.json first, then falls back to lockfiles.
+ *
+ * @param cwd The project directory to detect the package manager for
+ * @returns The detected package manager name, or undefined if none detected
+ */
+async function detectPackageManager(cwd) {
+    const result = await detect({
+        cwd,
+        strategies: ["packageManager-field", "lockfile"],
+    });
+    return result?.name;
+}
+/**
+ * Install dependencies for a project using the detected package manager.
+ */
+export async function installDependencies(cwd) {
+    const pm = await detectPackageManager(cwd);
+    const cmd = await getInstallCommand(pm, cwd);
+    console.log(getInstallMessage(cmd));
+    runOrThrow(cmd.command, cmd.args, cwd);
+}
+export async function runPackageManagerBinary(cwd, binary, arguments_ = [], options = {}) {
+    const pm = await detectPackageManager(cwd);
+    const { command, args: commandArguments } = getBinaryRunCommand(pm, binary, arguments_);
+    console.log(`➤ Running ${formatCommand(command, commandArguments)} …`);
+    const result = runOrThrow(command, commandArguments, cwd, options);
+    if (options.stdio === "pipe") {
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+        };
+    }
+    return undefined;
+}

package/dist/project/setup.d.ts

@@ -0,0 +1,9 @@
+/**
+ * setup.ts
+ *
+ * Utilities for setting up project dependencies and build artifacts
+ */
+/**
+ * Install dependencies and run Next.js typegen if applicable
+ */
+export declare function setupProject(destinationDirectory: string): Promise<void>;

package/dist/project/setup.js

@@ -0,0 +1,31 @@
+/**
+ * setup.ts
+ *
+ * Utilities for setting up project dependencies and build artifacts
+ */
+import path from "node:path";
+import { fileExists } from "../git/git.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) {
+    const packageJsonPath = path.join(destinationDirectory, "package.json");
+    if (!(await fileExists(packageJsonPath))) {
+        return;
+    }
+    await installDependencies(destinationDirectory);
+    // 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 (hasTypegenSupport) {
+            console.log("➤ Running next typegen …");
+            await runPackageManagerBinary(destinationDirectory, "next", ["typegen"]);
+        }
+        else {
+            console.warn("! Skipping next typegen: installed Next.js CLI does not support this command.");
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+/**
+ * destination-directory.ts
+ *
+ * Utilities for managing worktree directories
+ */
+/**
+ * Check if directory exists and prompt for removal if needed
+ * Returns true if the directory should be created
+ */
+export declare function handleExistingDirectory(destinationDirectory: string): Promise<void>;

package/dist/worktree/destination-directory.js

@@ -0,0 +1,33 @@
+/**
+ * destination-directory.ts
+ *
+ * Utilities for managing worktree directories
+ */
+import { spawnSync } from "node:child_process";
+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) {
+    if (!(await fileExists(destinationDirectory))) {
+        return;
+    }
+    const proceed = await confirm(`Directory '${path.basename(destinationDirectory)}' already exists. Remove and recreate?`);
+    if (!proceed) {
+        console.log("Operation cancelled.");
+        // eslint-disable-next-line unicorn/no-process-exit -- User requested cancellation
+        process.exit(0);
+    }
+    // Remove the existing directory
+    console.log(`➤ Removing existing directory...`);
+    const result = spawnSync("rm", ["-rf", destinationDirectory], {
+        encoding: "utf8",
+    });
+    if (result.error)
+        throw result.error;
+    if (result.status !== 0) {
+        exitWithMessage(`Failed to remove existing directory: ${result.stderr}`);
+    }
+}

package/dist/worktree/file-patterns.d.ts

@@ -0,0 +1,8 @@
+/**
+ * file-patterns.ts
+ *
+ * Shared utilities for worktree file selection
+ */
+export declare const EXTRA_IGNORED_PATTERNS: string[];
+export declare const globToRegExp: (globPattern: string) => RegExp;
+export declare const toPosixPath: (value: string) => string;

package/dist/worktree/file-patterns.js

@@ -0,0 +1,53 @@
+/**
+ * file-patterns.ts
+ *
+ * Shared utilities for worktree file selection
+ */
+// Patterns for untracked files that should NOT be copied to new worktrees
+export const EXTRA_IGNORED_PATTERNS = [
+    "node_modules/**",
+    ".next/**",
+    ".nuxt/**",
+    ".output/**",
+    "dist/**",
+    "build/**",
+    "**/*.tsbuildinfo",
+    ".turbo/**",
+    ".cache/**",
+    "coverage/**",
+    ".venv/**",
+    "venv/**",
+    "__pycache__/**",
+    ".pytest_cache/**",
+    "target/**", // Rust
+    ".dart_tool/**", // Dart
+];
+const escapeForRegExp = (value) => value.replaceAll(/[\\^$*+?.()|[\]{}]/gu, String.raw `\$&`);
+export const globToRegExp = (globPattern) => {
+    let regexBody = "";
+    for (let index = 0; index < globPattern.length; index += 1) {
+        const character = globPattern.charAt(index);
+        if (character === "*") {
+            const nextCharacter = globPattern.charAt(index + 1);
+            if (nextCharacter === "*") {
+                regexBody += ".*";
+                index += 1;
+            }
+            else {
+                regexBody += "[^/]*";
+            }
+            continue;
+        }
+        if (character === "?") {
+            regexBody += "[^/]";
+            continue;
+        }
+        if (character === "/") {
+            regexBody += String.raw `\/`;
+            continue;
+        }
+        regexBody += escapeForRegExp(character);
+    }
+    return new RegExp(`^${regexBody}$`, "u");
+};
+export const toPosixPath = (value) => value.replaceAll("\\", "/");

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

@@ -0,0 +1,9 @@
+/**
+ * untracked-file-copy.ts
+ *
+ * Utilities for copying untracked files to worktrees
+ */
+/**
+ * Copy untracked files from source to destination, excluding ignored patterns
+ */
+export declare function copyUntrackedFiles(repoRoot: string, destinationDirectory: string): Promise<void>;

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

@@ -0,0 +1,35 @@
+/**
+ * untracked-file-copy.ts
+ *
+ * Utilities for copying untracked files to worktrees
+ */
+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";
+/**
+ * Copy untracked files from source to destination, excluding ignored patterns
+ */
+export async function copyUntrackedFiles(repoRoot, destinationDirectory) {
+    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);
+    for (const relativePath of untrackedEntries) {
+        const posixPath = toPosixPath(relativePath);
+        if (extraIgnoredRegexes.some((regex) => regex.test(posixPath))) {
+            continue;
+        }
+        const sourcePath = path.resolve(repoRoot, relativePath);
+        const destinationPath = path.join(destinationDirectory, relativePath);
+        await fs.mkdir(path.dirname(destinationPath), { recursive: true });
+        await fs.cp(sourcePath, destinationPath, {
+            recursive: true,
+            errorOnExist: false,
+        });
+        console.log(`  • copied ${relativePath}`);
+    }
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "worktree-add",
+  "author": "Łukasz Jerciński",
+  "license": "MIT",
+  "version": "1.0.0",
+  "description": "",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Jercik/worktree-add.git"
+  },
+  "type": "module",
+  "bin": {
+    "worktree-add": "bin/worktree-add"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "pnpm run rebuild && node bin/worktree-add",
+    "build": "tsc -p tsconfig.app.json",
+    "clean": "rm -rf dist *.tsbuildinfo",
+    "rebuild": "pnpm run clean && pnpm run build",
+    "prepare": "husky",
+    "prepublishOnly": "pnpm run rebuild",
+    "typecheck": "tsc -b --noEmit",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "lint": "eslint",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "knip": "knip",
+    "fta:check": "fta-check --threshold 55"
+  },
+  "keywords": [],
+  "packageManager": "pnpm@10.22.0",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "dependencies": {
+    "commander": "^14.0.2",
+    "package-manager-detector": "^1.5.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^20.1.0",
+    "@commitlint/config-conventional": "^20.0.0",
+    "@eslint/compat": "^1.3.2",
+    "@eslint/js": "^9.31.0",
+    "@total-typescript/ts-reset": "^0.6.1",
+    "@types/node": "^24.0.15",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/eslint-plugin": "^1.3.4",
+    "eslint": "^9.31.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-unicorn": "^62.0.0",
+    "fta-check": "^1.1.0",
+    "fta-cli": "^3.0.0",
+    "globals": "^16.5.0",
+    "husky": "^9.1.7",
+    "knip": "^5.66.4",
+    "prettier": "3.6.2",
+    "semantic-release": "^25.0.2",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.37.0",
+    "vitest": "^3.2.4"
+  }
+}