@burglekitt/worktree 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Burglekitt
+
+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/README.md

@@ -0,0 +1,15 @@
+# Worktree
+
+A CLI tool for managing Git worktrees with enhanced functionality.
+
+![Worktree](https://media1.giphy.com/media/v1.Y2lkPTc5MGI3NjExNW51dHJlNHRzYnRwd3c3ZWZ0dzllZTB1d3VnaGQxd2s4eDJlbDhnaiZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/lqT2GstnDBVJE6qfkK/giphy.gif)
+
+## TODO
+
+- [x] Add `config` command to configure everything needed
+- [x] Add `branch` command to create new worktrees
+- [ ] Add `delete` command to delete worktrees
+- [ ] Add `checkout` command to create worktree from a remote branch
+- [ ] Add `cleanup` command to cleanup stale worktrees
+- [ ] Integrate with JIRA for automated branch naming
+- [ ] Integrate with ClickUp for automated branch naming

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node --loader ts-node/esm --no-warnings=ExperimentalWarning "%~dp0\dev" %*

package/bin/dev.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env -S node --loader ts-node/esm --disable-warning=ExperimentalWarning
+
+import { execute } from "@oclif/core";
+
+await execute({ development: true, dir: import.meta.url });

package/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/bin/run.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { execute } from "@oclif/core";
+
+await execute({ dir: import.meta.url });

package/dist/commands/branch.d.ts

@@ -0,0 +1,18 @@
+import { BaseCommand } from "../lib/base-command.js";
+export default class Branch extends BaseCommand {
+    static args: {
+        branchName: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        source: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    private confirmNonOriginSource;
+    private confirmRemoteNameConflict;
+    private getSourceBranch;
+    private validateBranchName;
+    private getBranchName;
+    run(): Promise<void>;
+}

package/dist/commands/branch.js

@@ -0,0 +1,75 @@
+import { confirm, input } from "@inquirer/prompts";
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../lib/base-command.js";
+import { copyEnvFilesFromRootPath } from "../lib/env.js";
+import { gitCreateWorktree, gitGetConfigValue, gitGetLocalBranches, gitGetRemoteBranches, } from "../lib/git.js";
+import { isValidBranchName } from "../lib/validators.js";
+export default class Branch extends BaseCommand {
+    static args = {
+        branchName: Args.string({ description: "Name of the branch to create" }),
+    };
+    static description = "Create a worktree branch";
+    static examples = [
+        "<%= config.bin %> <%= command.id %> my-new-branch",
+    ];
+    static flags = {
+        help: Flags.help({ char: "h", description: "Show branch help" }),
+        source: Flags.string({
+            char: "s",
+            description: "Source branch to create the worktree from",
+        }),
+    };
+    confirmNonOriginSource() {
+        const message = "The source branch does not start with 'origin/'. Are you sure you want to use a local source?";
+        return confirm({ message });
+    }
+    confirmRemoteNameConflict() {
+        const message = "A remote branch with the same name exists. Do you want to use the remote branch instead?";
+        return confirm({ message });
+    }
+    async getSourceBranch(sourceFlag) {
+        if (sourceFlag) {
+            const remoteBranches = await gitGetRemoteBranches();
+            if (sourceFlag.startsWith("origin/")) {
+                if (!remoteBranches.includes(sourceFlag)) {
+                    this.error(`Source branch doesn't exist: ${sourceFlag}`);
+                }
+                return sourceFlag;
+            }
+            if (await this.confirmNonOriginSource()) {
+                const localBranches = await gitGetLocalBranches();
+                if (!localBranches.includes(sourceFlag)) {
+                    this.error(`Source branch doesn't exist: ${sourceFlag}`);
+                }
+                if (remoteBranches.includes(`origin/${sourceFlag}`)) {
+                    if (await this.confirmRemoteNameConflict()) {
+                        return `origin/${sourceFlag}`;
+                    }
+                }
+                return sourceFlag;
+            }
+        }
+        return (await gitGetConfigValue("defaultSourceBranch")) || "origin/main";
+    }
+    validateBranchName(branchName) {
+        const result = isValidBranchName(branchName);
+        if (result !== true) {
+            this.error(result);
+        }
+        return true;
+    }
+    async getBranchName(branchNameArg) {
+        if (branchNameArg && this.validateBranchName(branchNameArg)) {
+            return branchNameArg;
+        }
+        return await input({ message: "Branch name", validate: isValidBranchName });
+    }
+    async run() {
+        const { args, flags } = await this.parse(Branch);
+        const branchName = await this.getBranchName(args.branchName);
+        const sourceBranch = await this.getSourceBranch(flags.source);
+        const projectPath = await gitCreateWorktree(branchName, sourceBranch);
+        await copyEnvFilesFromRootPath(projectPath);
+        await this.openWorktreePath(projectPath);
+    }
+}

package/dist/commands/branch.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/branch.test.js

@@ -0,0 +1,207 @@
+import { confirm, input } from "@inquirer/prompts";
+import { copyEnvFilesFromRootPath } from "../lib/env.js";
+import * as git from "../lib/git.js";
+import * as validators from "../lib/validators.js";
+import Branch from "./branch.js";
+// Mock the inquirer module
+vi.mock("@inquirer/prompts", () => ({
+    confirm: vi.fn(),
+    input: vi.fn(),
+}));
+// Mock env functions
+vi.mock("../lib/env.js", () => ({
+    copyEnvFilesFromRootPath: vi.fn().mockResolvedValue(undefined),
+}));
+describe("branch command", () => {
+    let branch;
+    let mockOpenWorktreePath;
+    const mockInput = vi.mocked(input);
+    const mockConfirm = vi.mocked(confirm);
+    const mockCopyEnvFiles = vi.mocked(copyEnvFilesFromRootPath);
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // biome-ignore lint/suspicious/noExplicitAny: Required for oclif testing
+        branch = new Branch([], {});
+        mockOpenWorktreePath = vi
+            // biome-ignore lint/suspicious/noExplicitAny: Required for spying on protected method
+            .spyOn(branch, "openWorktreePath")
+            .mockResolvedValue(undefined);
+    });
+    describe("basic functionality", () => {
+        it("should create worktree with valid branch name and default source", async () => {
+            const mockGitCreateWorktree = vi
+                .spyOn(git, "gitCreateWorktree")
+                .mockResolvedValue("/path/to/worktree");
+            vi.spyOn(git, "gitGetConfigValue").mockResolvedValue("origin/main");
+            // biome-ignore lint/suspicious/noExplicitAny: Required for oclif method mocking
+            branch.parse = vi.fn().mockResolvedValue({
+                args: { branchName: "feature/test" },
+                flags: {},
+            });
+            await branch.run();
+            expect(mockGitCreateWorktree).toHaveBeenCalledWith("feature/test", "origin/main");
+            expect(mockCopyEnvFiles).toHaveBeenCalledWith("/path/to/worktree");
+            expect(mockOpenWorktreePath).toHaveBeenCalledWith("/path/to/worktree");
+        });
+        it("should prompt for branch name when not provided", async () => {
+            mockInput.mockResolvedValue("prompted-branch");
+            const mockGitCreateWorktree = vi
+                .spyOn(git, "gitCreateWorktree")
+                .mockResolvedValue("/path/to/worktree");
+            vi.spyOn(git, "gitGetConfigValue").mockResolvedValue("origin/main");
+            // biome-ignore lint/suspicious/noExplicitAny: Required for oclif method mocking
+            branch.parse = vi.fn().mockResolvedValue({
+                args: {},
+                flags: {},
+            });
+            await branch.run();
+            expect(mockInput).toHaveBeenCalledWith({
+                message: "Branch name",
+                validate: validators.isValidBranchName,
+            });
+            expect(mockGitCreateWorktree).toHaveBeenCalledWith("prompted-branch", "origin/main");
+        });
+        it("should use custom source branch when provided", async () => {
+            const mockGitCreateWorktree = vi
+                .spyOn(git, "gitCreateWorktree")
+                .mockResolvedValue("/path/to/worktree");
+            vi.spyOn(git, "gitGetRemoteBranches").mockResolvedValue([
+                "origin/main",
+                "origin/develop",
+            ]);
+            // biome-ignore lint/suspicious/noExplicitAny: Required for oclif method mocking
+            branch.parse = vi.fn().mockResolvedValue({
+                args: { branchName: "feature/test" },
+                flags: { source: "origin/develop" },
+            });
+            await branch.run();
+            expect(mockGitCreateWorktree).toHaveBeenCalledWith("feature/test", "origin/develop");
+        });
+    });
+    describe("branch name validation", () => {
+        it("should validate branch name and throw error for invalid name", async () => {
+            // biome-ignore lint/suspicious/noExplicitAny: Required for oclif method mocking
+            branch.parse = vi.fn().mockResolvedValue({
+                args: { branchName: "invalid..branch" },
+                flags: {},
+            });
+            const mockError = vi.spyOn(branch, "error").mockImplementation(() => {
+                throw new Error("Branch name cannot contain double dots");
+            });
+            await expect(branch.run()).rejects.toThrow("Branch name cannot contain double dots");
+            expect(mockError).toHaveBeenCalledWith("Branch name cannot contain double dots");
+        });
+    });
+    describe("source branch handling", () => {
+        it("should handle non-existing origin source branch", async () => {
+            vi.spyOn(git, "gitGetRemoteBranches").mockResolvedValue(["origin/main"]);
+            // biome-ignore lint/suspicious/noExplicitAny: Required for oclif method mocking
+            branch.parse = vi.fn().mockResolvedValue({
+                args: { branchName: "feature/test" },
+                flags: { source: "origin/nonexistent" },
+            });
+            const mockError = vi.spyOn(branch, "error").mockImplementation(() => {
+                throw new Error("Source branch doesn't exist: origin/nonexistent");
+            });
+            await expect(branch.run()).rejects.toThrow("Source branch doesn't exist: origin/nonexistent");
+            expect(mockError).toHaveBeenCalledWith("Source branch doesn't exist: origin/nonexistent");
+        });
+        it("should handle local source branch with confirmation", async () => {
+            vi.spyOn(git, "gitGetRemoteBranches").mockResolvedValue(["origin/main"]);
+            vi.spyOn(git, "gitGetLocalBranches").mockResolvedValue([
+                "main",
+                "develop",
+            ]);
+            mockConfirm.mockResolvedValue(true);
+            const mockGitCreateWorktree = vi
+                .spyOn(git, "gitCreateWorktree")
+                .mockResolvedValue("/path/to/worktree");
+            // biome-ignore lint/suspicious/noExplicitAny: Required for oclif method mocking
+            branch.parse = vi.fn().mockResolvedValue({
+                args: { branchName: "feature/test" },
+                flags: { source: "develop" },
+            });
+            await branch.run();
+            expect(mockConfirm).toHaveBeenCalledWith({
+                message: "The source branch does not start with 'origin/'. Are you sure you want to use a local source?",
+            });
+            expect(mockGitCreateWorktree).toHaveBeenCalledWith("feature/test", "develop");
+        });
+        it("should handle local source branch with remote conflict confirmation", async () => {
+            vi.spyOn(git, "gitGetRemoteBranches").mockResolvedValue([
+                "origin/main",
+                "origin/develop",
+            ]);
+            vi.spyOn(git, "gitGetLocalBranches").mockResolvedValue([
+                "main",
+                "develop",
+            ]);
+            mockConfirm
+                .mockResolvedValueOnce(true) // Confirm using local source
+                .mockResolvedValueOnce(true); // Confirm using remote instead
+            const mockGitCreateWorktree = vi
+                .spyOn(git, "gitCreateWorktree")
+                .mockResolvedValue("/path/to/worktree");
+            // biome-ignore lint/suspicious/noExplicitAny: Required for oclif method mocking
+            branch.parse = vi.fn().mockResolvedValue({
+                args: { branchName: "feature/test" },
+                flags: { source: "develop" },
+            });
+            await branch.run();
+            expect(mockConfirm).toHaveBeenNthCalledWith(2, {
+                message: "A remote branch with the same name exists. Do you want to use the remote branch instead?",
+            });
+            expect(mockGitCreateWorktree).toHaveBeenCalledWith("feature/test", "origin/develop");
+        });
+        it("should fallback to origin/main when no default source is configured", async () => {
+            const mockGetConfigValue = vi
+                .spyOn(git, "gitGetConfigValue")
+                .mockResolvedValue("");
+            const mockGitCreateWorktree = vi
+                .spyOn(git, "gitCreateWorktree")
+                .mockResolvedValue("/path/to/worktree");
+            // biome-ignore lint/suspicious/noExplicitAny: Required for oclif method mocking
+            branch.parse = vi.fn().mockResolvedValue({
+                args: { branchName: "feature/test" },
+                flags: {},
+            });
+            await branch.run();
+            expect(mockGetConfigValue).toHaveBeenCalledWith("defaultSourceBranch");
+            expect(mockGitCreateWorktree).toHaveBeenCalledWith("feature/test", "origin/main");
+        });
+        it("should handle non-existing local source branch", async () => {
+            vi.spyOn(git, "gitGetRemoteBranches").mockResolvedValue(["origin/main"]);
+            vi.spyOn(git, "gitGetLocalBranches").mockResolvedValue(["main"]);
+            mockConfirm.mockResolvedValue(true);
+            // biome-ignore lint/suspicious/noExplicitAny: Required for oclif method mocking
+            branch.parse = vi.fn().mockResolvedValue({
+                args: { branchName: "feature/test" },
+                flags: { source: "nonexistent" },
+            });
+            const mockError = vi.spyOn(branch, "error").mockImplementation(() => {
+                throw new Error("Source branch doesn't exist: nonexistent");
+            });
+            await expect(branch.run()).rejects.toThrow("Source branch doesn't exist: nonexistent");
+            expect(mockError).toHaveBeenCalledWith("Source branch doesn't exist: nonexistent");
+        });
+        it("should reject using local source when confirmation is denied", async () => {
+            vi.spyOn(git, "gitGetRemoteBranches").mockResolvedValue(["origin/main"]);
+            mockConfirm.mockResolvedValue(false);
+            vi.spyOn(git, "gitGetConfigValue").mockResolvedValue("origin/main");
+            const mockGitCreateWorktree = vi
+                .spyOn(git, "gitCreateWorktree")
+                .mockResolvedValue("/path/to/worktree");
+            // biome-ignore lint/suspicious/noExplicitAny: Required for oclif method mocking
+            branch.parse = vi.fn().mockResolvedValue({
+                args: { branchName: "feature/test" },
+                flags: { source: "develop" },
+            });
+            await branch.run();
+            expect(mockConfirm).toHaveBeenCalledWith({
+                message: "The source branch does not start with 'origin/'. Are you sure you want to use a local source?",
+            });
+            // Should fallback to default source branch
+            expect(mockGitCreateWorktree).toHaveBeenCalledWith("feature/test", "origin/main");
+        });
+    });
+});

package/dist/commands/config.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from "../lib/base-command.js";
+export default class Config extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        list: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        missing: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    private renderList;
+    private getPromptConfigNames;
+    private renderInput;
+    private isValidArgName;
+    run(): Promise<void>;
+}

package/dist/commands/config.js

@@ -0,0 +1,125 @@
+import { EOL } from "node:os";
+import { confirm, input } from "@inquirer/prompts";
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../lib/base-command.js";
+import { CONFIG_NAMES } from "../lib/constants.js";
+import { gitGetConfigValue, gitSetConfigValue } from "../lib/git.js";
+import { conjoin } from "../lib/utils.js";
+import { isValidBranch, isValidCommand, isValidEmail, validateConfigValue, } from "../lib/validators.js";
+export default class Config extends BaseCommand {
+    static description = "Configure worktree CLI settings";
+    static examples = ["<%= config.bin %> <%= command.id %>"];
+    static args = {
+        name: Args.string(),
+        value: Args.string(),
+    };
+    static flags = {
+        list: Flags.boolean({
+            char: "l",
+            description: "List all available variables",
+        }),
+        help: Flags.help({ char: "h", description: "Show config help" }),
+        missing: Flags.boolean({
+            char: "m",
+            description: "Only prompt missing variables",
+        }),
+    };
+    async renderList(missing) {
+        let count = 0;
+        for (const variable of CONFIG_NAMES) {
+            const value = await gitGetConfigValue(variable);
+            if (missing && value) {
+                continue;
+            }
+            this.log(value ? `${variable}=${value}` : variable);
+            count++;
+        }
+        if (missing && count === 0) {
+            this.log("No variables have missing values");
+        }
+    }
+    async getPromptConfigNames(missing) {
+        if (missing) {
+            const configNames = [];
+            for (const name of CONFIG_NAMES) {
+                if (!(await gitGetConfigValue(name))) {
+                    configNames.push(name);
+                }
+            }
+            return configNames;
+        }
+        return [...CONFIG_NAMES];
+    }
+    async renderInput(missing) {
+        const configNames = await this.getPromptConfigNames(missing);
+        const hasJiraPrompt = !!configNames.find((name) => name.startsWith("jira"));
+        // First check if there is anything to prompt
+        if (configNames.length === 0) {
+            this.log("No missing config found.");
+            return;
+        }
+        function shouldPrompt(name) {
+            return configNames.includes(name);
+        }
+        if (hasJiraPrompt &&
+            (await confirm({ message: "Do you want to configure Jira integration?" }))) {
+            if (shouldPrompt("jira.domain")) {
+                const jiraDomain = await input({
+                    message: "Jira subdomain or full domain",
+                });
+                await gitSetConfigValue("jira.domain", jiraDomain);
+            }
+            if (shouldPrompt("jira.email")) {
+                const jiraEmail = await input({
+                    message: "Jira email",
+                    validate: isValidEmail,
+                });
+                await gitSetConfigValue("jira.email", jiraEmail);
+            }
+        }
+        if (shouldPrompt("defaultSourceBranch")) {
+            const defaultBranchName = await input({
+                message: "Which branch should new worktrees be based on?",
+                default: "origin/main",
+                validate: isValidBranch,
+            });
+            await gitSetConfigValue("defaultSourceBranch", defaultBranchName);
+        }
+        if (shouldPrompt("codeEditor") &&
+            (await confirm({
+                message: "Do you want to automatically open the worktree in a code editor?",
+            }))) {
+            const codeEditor = await input({
+                message: "Command to open code editor?",
+                default: "code",
+                validate: isValidCommand,
+            });
+            await gitSetConfigValue("codeEditor", codeEditor);
+        }
+    }
+    isValidArgName(name) {
+        return CONFIG_NAMES.includes(name);
+    }
+    async run() {
+        const { args, flags } = await this.parse(Config);
+        if (args.name) {
+            if (!this.isValidArgName(args.name)) {
+                this.error([
+                    `Unknown config name: ${args.name}`,
+                    `Available variables: ${conjoin(CONFIG_NAMES)}`,
+                ].join(EOL));
+            }
+            if (args.value) {
+                await validateConfigValue(args.name, args.value);
+                await gitSetConfigValue(args.name, args.value);
+                return;
+            }
+            await gitGetConfigValue(args.name);
+            return;
+        }
+        if (flags.list) {
+            return this.renderList(flags.missing);
+        }
+        return this.renderInput(flags.missing);
+    }
+}

package/dist/commands/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/config.test.js

@@ -0,0 +1,109 @@
+import * as git from "../lib/git.js";
+import * as validators from "../lib/validators.js";
+import Config from "./config.js";
+describe("config command", () => {
+    let config;
+    let mockConsoleLog;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // biome-ignore lint/suspicious/noExplicitAny: Required for oclif testing
+        config = new Config([], {});
+        mockConsoleLog = vi.spyOn(console, "log").mockImplementation(() => { });
+    });
+    describe("--list flag", () => {
+        it("should list all config values when they exist", async () => {
+            // Mock the parse method to simulate --list flag
+            // biome-ignore lint/suspicious/noExplicitAny: Required for oclif method mocking
+            config.parse = vi.fn().mockResolvedValue({
+                args: {},
+                flags: { list: true, missing: false },
+            });
+            vi.spyOn(git, "gitGetConfigValue")
+                .mockResolvedValueOnce("https://test.atlassian.net") // jira.domain
+                .mockResolvedValueOnce("test@example.com") // jira.email
+                .mockResolvedValueOnce("api-token-123") // jira.apiToken
+                .mockResolvedValueOnce("code") // codeEditor
+                .mockResolvedValueOnce("origin/main"); // defaultSourceBranch
+            await config.run();
+            expect(mockConsoleLog).toHaveBeenCalledWith("jira.domain=https://test.atlassian.net");
+            expect(mockConsoleLog).toHaveBeenCalledWith("jira.email=test@example.com");
+            expect(mockConsoleLog).toHaveBeenCalledWith("jira.apiToken=api-token-123");
+            expect(mockConsoleLog).toHaveBeenCalledWith("codeEditor=code");
+            expect(mockConsoleLog).toHaveBeenCalledWith("defaultSourceBranch=origin/main");
+        });
+        it("should list config names when values are missing", async () => {
+            // biome-ignore lint/suspicious/noExplicitAny: Required for oclif method mocking
+            config.parse = vi.fn().mockResolvedValue({
+                args: {},
+                flags: { list: true, missing: false },
+            });
+            vi.spyOn(git, "gitGetConfigValue").mockResolvedValue(""); // All empty
+            await config.run();
+            expect(mockConsoleLog).toHaveBeenCalledWith("jira.domain");
+            expect(mockConsoleLog).toHaveBeenCalledWith("jira.email");
+            expect(mockConsoleLog).toHaveBeenCalledWith("jira.apiToken");
+            expect(mockConsoleLog).toHaveBeenCalledWith("codeEditor");
+            expect(mockConsoleLog).toHaveBeenCalledWith("defaultSourceBranch");
+        });
+        it("should handle --missing flag with no missing values", async () => {
+            // biome-ignore lint/suspicious/noExplicitAny: Required for oclif method mocking
+            config.parse = vi.fn().mockResolvedValue({
+                args: {},
+                flags: { list: true, missing: true },
+            });
+            vi.spyOn(git, "gitGetConfigValue").mockResolvedValue("some-value"); // All have values
+            await config.run();
+            expect(mockConsoleLog).toHaveBeenCalledWith("No variables have missing values");
+        });
+    });
+    describe("setting config values", () => {
+        it("should set a valid config value", async () => {
+            const mockSetConfigValue = vi
+                .spyOn(git, "gitSetConfigValue")
+                .mockResolvedValue();
+            const mockValidateConfigValue = vi
+                .spyOn(validators, "validateConfigValue")
+                .mockResolvedValue();
+            // Mock the parse method to return the args we want
+            // biome-ignore lint/suspicious/noExplicitAny: Required for oclif method mocking
+            config.parse = vi.fn().mockResolvedValue({
+                args: { name: "jira.email", value: "test@example.com" },
+                flags: {},
+            });
+            await config.run();
+            expect(mockValidateConfigValue).toHaveBeenCalledWith("jira.email", "test@example.com");
+            expect(mockSetConfigValue).toHaveBeenCalledWith("jira.email", "test@example.com");
+        });
+        it("should get config value when only name is provided", async () => {
+            const mockGetConfigValue = vi
+                .spyOn(git, "gitGetConfigValue")
+                .mockResolvedValue("test@example.com");
+            // biome-ignore lint/suspicious/noExplicitAny: Required for oclif method mocking
+            config.parse = vi.fn().mockResolvedValue({
+                args: { name: "jira.email" },
+                flags: {},
+            });
+            await config.run();
+            expect(mockGetConfigValue).toHaveBeenCalledWith("jira.email");
+        });
+    });
+    describe("error handling", () => {
+        it("should handle unknown config name", async () => {
+            // biome-ignore lint/suspicious/noExplicitAny: Required for oclif method mocking
+            config.parse = vi.fn().mockResolvedValue({
+                args: { name: "unknown.setting", value: "test" },
+                flags: {},
+            });
+            await expect(config.run()).rejects.toThrow("Unknown config name: unknown.setting");
+        });
+        it("should handle invalid config value", async () => {
+            vi.spyOn(validators, "validateConfigValue").mockRejectedValue(new validators.InvalidConfigValueError("Invalid email address"));
+            // biome-ignore lint/suspicious/noExplicitAny: Required for oclif method mocking
+            config.parse = vi.fn().mockResolvedValue({
+                args: { name: "jira.email", value: "invalid-email" },
+                flags: {},
+            });
+            await expect(config.run()).rejects.toThrow("Invalid email address");
+        });
+    });
+});

package/dist/lib/base-command.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "@oclif/core";
+import type { CommandError } from "@oclif/core/interfaces";
+export declare abstract class BaseCommand extends Command {
+    protected openWorktreePath(path: string): Promise<void>;
+    protected catch(error: CommandError): Promise<any>;
+}

package/dist/lib/base-command.js

@@ -0,0 +1,36 @@
+import { exec } from "node:child_process";
+import { Command } from "@oclif/core";
+import chalk from "chalk";
+import ora from "ora";
+import { gitGetConfigValue } from "./git.js";
+export class BaseCommand extends Command {
+    async openWorktreePath(path) {
+        const codeEditor = await gitGetConfigValue("codeEditor");
+        if (codeEditor) {
+            const spinner = ora(`Opening in ${codeEditor}`).start();
+            exec(`${codeEditor} ${path}`, (error) => {
+                if (error) {
+                    spinner.fail(error.message);
+                }
+                else {
+                    spinner.succeed();
+                }
+            });
+        }
+        else {
+            this.log(`${chalk.green("✔")} Worktree created in ${path}`);
+        }
+    }
+    async catch(error) {
+        if (error instanceof Error) {
+            if (error.name === "ExitPromptError") {
+                // Silently exit
+                this.exit();
+            }
+            // Color the error message red for better visibility
+            this.log(chalk.red(`Error: ${error.message}`));
+            this.exit();
+        }
+        return super.catch(error);
+    }
+}

package/dist/lib/cli.d.ts

@@ -0,0 +1,6 @@
+interface CmdOptions {
+    debug?: boolean;
+}
+export declare function cmd(cmd: string, { debug }?: CmdOptions): Promise<string>;
+export declare function commandExists(command: string): Promise<boolean>;
+export {};

package/dist/lib/cli.js

@@ -0,0 +1,30 @@
+import { exec } from "node:child_process";
+export function cmd(cmd, { debug = false } = {}) {
+    return new Promise((resolve, reject) => {
+        if (debug) {
+            console.log(`DEBUG: ${cmd}`);
+            resolve("");
+            return;
+        }
+        exec(cmd, (error, stdout) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(stdout?.trim() ?? "");
+        });
+    });
+}
+export async function commandExists(command) {
+    try {
+        // Extract the base command
+        const baseCommand = command.split(" ")[0];
+        // Use 'which' on *nix, 'where' on Windows
+        const checkCommand = process.platform === "win32" ? "where" : "which";
+        await cmd(`${checkCommand} ${baseCommand}`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const CONFIG_NAMES: readonly ["jira.domain", "jira.email", "jira.apiToken", "codeEditor", "defaultSourceBranch"];
+export type ConfigName = (typeof CONFIG_NAMES)[number];

package/dist/lib/constants.js

@@ -0,0 +1,7 @@
+export const CONFIG_NAMES = [
+    "jira.domain",
+    "jira.email",
+    "jira.apiToken",
+    "codeEditor",
+    "defaultSourceBranch",
+];

package/dist/lib/env.d.ts

@@ -0,0 +1 @@
+export declare function copyEnvFilesFromRootPath(destinationWorktreePath: string): Promise<void>;

package/dist/lib/env.js

@@ -0,0 +1,21 @@
+import fs from "node:fs";
+import { glob } from "glob";
+import ora from "ora";
+import { gitGetRootPath } from "./git.js";
+export async function copyEnvFilesFromRootPath(destinationWorktreePath) {
+    const gitRootPath = await gitGetRootPath();
+    // Find both .env and .env.local files
+    const envResults = await glob(`${gitRootPath}/**/.{env,env.local}`, {
+        ignore: ["node_modules/**"],
+    });
+    const rootEnvFiles = envResults
+        // Change to a relative path
+        .map((filePath) => filePath.substring(gitRootPath.length + 1));
+    for (const envFile of rootEnvFiles) {
+        const sourceFile = `${gitRootPath}/${envFile}`;
+        const destinationFile = `${destinationWorktreePath}/${envFile}`;
+        const spinner = ora(`Copying ${sourceFile} to worktree`).start();
+        fs.copyFileSync(sourceFile, destinationFile);
+        spinner.succeed();
+    }
+}

package/dist/lib/git.d.ts

@@ -0,0 +1,12 @@
+import type { ConfigName } from "./constants.js";
+export declare function gitGetConfigValue(name: ConfigName): Promise<string>;
+export declare function gitSetConfigValue(name: ConfigName, value: string): Promise<void>;
+export declare function gitFetch(): Promise<string>;
+export declare function gitGetRootPath(): Promise<string>;
+export declare function gitGetLocalBranches(): Promise<string[]>;
+export declare function gitGetRemoteBranches(): Promise<string[]>;
+interface GitCreateWorktreeOptions {
+    isRemoteBranch?: boolean;
+}
+export declare function gitCreateWorktree(branchName: string, sourceBranch: string, { isRemoteBranch }?: GitCreateWorktreeOptions): Promise<string>;
+export {};

package/dist/lib/git.js

@@ -0,0 +1,89 @@
+import { EOL } from "node:os";
+import path from "node:path";
+import ora from "ora";
+import { cmd } from "./cli.js";
+export async function gitGetConfigValue(name) {
+    try {
+        return await cmd(`git config burglekitt.worktree.${name}`);
+    }
+    catch {
+        return "";
+    }
+}
+export async function gitSetConfigValue(name, value) {
+    await cmd(`git config burglekitt.worktree.${name} "${value}"`);
+}
+async function gitCmdShowTopLevel() {
+    return cmd("git rev-parse  --show-toplevel");
+}
+async function gitCmdGitPath() {
+    return cmd("git rev-parse --absolute-git-dir");
+}
+export async function gitFetch() {
+    return cmd("git fetch --prune");
+}
+export async function gitGetRootPath() {
+    try {
+        const topLevelPath = await gitCmdShowTopLevel();
+        if (!topLevelPath.includes(".worktrees/")) {
+            return topLevelPath;
+        }
+        const gitPathResult = await gitCmdGitPath();
+        const gitPath = gitPathResult.split("/.git")[0];
+        return gitPath;
+    }
+    catch {
+        throw new Error(`Git: Unable find the root path. Are you in a git repository?`);
+    }
+}
+export async function gitGetLocalBranches() {
+    const res = await cmd("git --no-pager branch");
+    return res.split(EOL).map((branch) => {
+        const trimmed = branch.trim();
+        if (trimmed.includes(" ")) {
+            return trimmed.split(" ")[1];
+        }
+        return trimmed;
+    });
+}
+export async function gitGetRemoteBranches() {
+    const res = await cmd("git --no-pager branch -r");
+    return res.split(EOL).map((branch) => {
+        const trimmed = branch.trim();
+        if (trimmed.includes(" ")) {
+            return trimmed.split(" ")[1];
+        }
+        return trimmed;
+    });
+}
+export async function gitCreateWorktree(branchName, sourceBranch, { isRemoteBranch = false } = {}) {
+    const spinner = ora(`Creating worktree ${branchName}`).start();
+    try {
+        const currentPath = process.env.PWD;
+        const gitRootPath = await gitGetRootPath();
+        const worktreesRootPath = `../${path.basename(gitRootPath)}.worktrees`;
+        const worktreePath = `${worktreesRootPath}/${branchName}`;
+        const absoluteWorktreePath = `${gitRootPath}.worktrees/${branchName}`;
+        // cd into the root path so we can create a relative worktree. This ensures that
+        // everything stays in sync in case the project is moved in the filesystem.
+        const cdRoot = `cd ${gitRootPath}`;
+        // Fetch the latest changes from the remote
+        const gitFetch = "git fetch";
+        // If adding from a remote branch, allow tracking
+        const addWorktree = isRemoteBranch
+            ? `git worktree add ${worktreePath} ${branchName}`
+            : `git worktree add --no-track -b ${branchName} ${worktreePath} ${sourceBranch}`;
+        // Go back
+        const gotoBack = `cd ${currentPath}`;
+        // Run them all in sequence
+        await cmd(`${cdRoot} && ${gitFetch} && ${addWorktree} && ${gotoBack}`);
+        // Stop the spinner
+        spinner.succeed();
+        // Return the absolute path to the new worktree
+        return absoluteWorktreePath;
+    }
+    catch (error) {
+        spinner.fail(error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+}

package/dist/lib/utils.d.ts

@@ -0,0 +1 @@
+export declare function conjoin(arr: readonly (string | number)[], conjunction?: "and" | "or"): string;

package/dist/lib/utils.js

@@ -0,0 +1,11 @@
+export function conjoin(arr, conjunction = "and") {
+    if (arr.length === 0)
+        return "";
+    if (arr.length === 1)
+        return String(arr[0]);
+    if (arr.length === 2)
+        return `${arr[0]} ${conjunction} ${arr[1]}`;
+    const allButLast = arr.slice(0, -1).join(", ");
+    const last = arr[arr.length - 1];
+    return `${allButLast} ${conjunction} ${last}`;
+}

package/dist/lib/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/utils.test.js

@@ -0,0 +1,22 @@
+import { conjoin } from "./utils.js";
+describe("conjoin", () => {
+    it.each `
+		input                              | conjunction  | expected
+		${[]}                              | ${undefined} | ${""}
+		${["apple"]}                       | ${undefined} | ${"apple"}
+		${[42]}                            | ${undefined} | ${"42"}
+		${["apple", "banana"]}             | ${undefined} | ${"apple and banana"}
+		${[1, 2]}                          | ${undefined} | ${"1 and 2"}
+		${["apple", "banana"]}             | ${"or"}      | ${"apple or banana"}
+		${[1, 2]}                          | ${"or"}      | ${"1 or 2"}
+		${["apple", "banana", "cherry"]}   | ${undefined} | ${"apple, banana and cherry"}
+		${[1, 2, 3, 4]}                    | ${undefined} | ${"1, 2, 3 and 4"}
+		${["apple", "banana", "cherry"]}   | ${"or"}      | ${"apple, banana or cherry"}
+		${[1, 2, 3, 4, 5]}                 | ${"or"}      | ${"1, 2, 3, 4 or 5"}
+		${["item1", 2, "item3"]}           | ${undefined} | ${"item1, 2 and item3"}
+		${[100, "apples", 200, "oranges"]} | ${"or"}      | ${"100, apples, 200 or oranges"}
+	`('should return "$expected" for input $input with conjunction "$conjunction"', ({ input, conjunction, expected }) => {
+        const result = conjunction ? conjoin(input, conjunction) : conjoin(input);
+        expect(result).toBe(expected);
+    });
+});

package/dist/lib/validators.d.ts

@@ -0,0 +1,8 @@
+export declare function isValidEmail(value: string): true | string;
+export declare function isValidCommand(value: string): Promise<true | string>;
+export declare function isValidBranch(value: string): Promise<true | string>;
+export declare function isValidBranchName(value: string): true | string;
+export declare function isValidConfigValue(configName: string, value: string): Promise<true | string>;
+export declare class InvalidConfigValueError extends Error {
+}
+export declare function validateConfigValue(configName: string, value: string): Promise<void>;

package/dist/lib/validators.js

@@ -0,0 +1,68 @@
+import { commandExists } from "./cli.js";
+import { gitGetLocalBranches, gitGetRemoteBranches } from "./git.js";
+export function isValidEmail(value) {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value) || "Invalid email address";
+}
+export async function isValidCommand(value) {
+    if (!(await commandExists(value))) {
+        return `Command not found: ${value}`;
+    }
+    return true;
+}
+export async function isValidBranch(value) {
+    const branches = value.startsWith("origin/")
+        ? await gitGetRemoteBranches()
+        : await gitGetLocalBranches();
+    return branches.includes(value) || `Branch not found: ${value}`;
+}
+export function isValidBranchName(value) {
+    if (!value || value.trim() === "") {
+        return "Branch name cannot be empty";
+    }
+    // Git branch naming rules
+    const invalidPatterns = [
+        { regex: /^\./, message: "Branch name cannot start with a dot" },
+        { regex: /\.\.$/, message: "Branch name cannot end with double dots" },
+        { regex: /\.\./, message: "Branch name cannot contain double dots" },
+        { regex: /\s/, message: "Branch name cannot contain spaces" },
+        {
+            regex: /[~^:\\*?[\]@{]/,
+            message: "Branch name contains invalid characters",
+        },
+        { regex: /\.$/, message: "Branch name cannot end with a dot" },
+        { regex: /\/$/, message: "Branch name cannot end with a slash" },
+        {
+            regex: /\/\//,
+            message: "Branch name cannot contain consecutive slashes",
+        },
+        { regex: /^\//, message: "Branch name cannot start with a slash" },
+        { regex: /\.$/, message: "Branch name cannot end with a dot" },
+        { regex: /\.lock$/, message: "Branch name cannot end with '.lock'" },
+    ];
+    for (const { regex, message } of invalidPatterns) {
+        if (regex.test(value)) {
+            return message;
+        }
+    }
+    return true;
+}
+export async function isValidConfigValue(configName, value) {
+    switch (configName) {
+        case "jira.email":
+            return isValidEmail(value);
+        case "defaultSourceBranch":
+            return isValidBranch(value);
+        case "codeEditor":
+            return await isValidCommand(value);
+        default:
+            return true;
+    }
+}
+export class InvalidConfigValueError extends Error {
+}
+export async function validateConfigValue(configName, value) {
+    const validationResult = await isValidConfigValue(configName, value);
+    if (validationResult !== true) {
+        throw new InvalidConfigValueError(validationResult);
+    }
+}

package/dist/lib/validators.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/validators.test.js

@@ -0,0 +1,122 @@
+import * as cli from "./cli.js";
+import * as git from "./git.js";
+import { isValidBranch, isValidBranchName, isValidCommand, isValidEmail, } from "./validators.js";
+describe("isValidEmail", () => {
+    it.each `
+		email                             | expected                   | description
+		${"user@example.com"}             | ${true}                    | ${"valid basic email"}
+		${"test.email@domain.co.uk"}      | ${true}                    | ${"valid email with dots and co.uk"}
+		${"user+tag@example.org"}         | ${true}                    | ${"valid email with plus sign"}
+		${"user_name@example.net"}        | ${true}                    | ${"valid email with underscore"}
+		${"123@example.com"}              | ${true}                    | ${"valid email with numbers"}
+		${"user-name@example-site.com"}   | ${true}                    | ${"valid email with hyphens"}
+		${"a@b.co"}                       | ${true}                    | ${"valid minimal email"}
+		${"user@subdomain.example.com"}   | ${true}                    | ${"valid email with subdomain"}
+		${"user@example.info"}            | ${true}                    | ${"valid email with .info tld"}
+		${"plainaddress"}                 | ${"Invalid email address"} | ${"missing @ symbol"}
+		${"@example.com"}                 | ${"Invalid email address"} | ${"missing local part"}
+		${"user@"}                        | ${"Invalid email address"} | ${"missing domain"}
+		${"user..double.dot@example.com"} | ${true}                    | ${"double dots in local part (allowed by current regex)"}
+		${"user@.example.com"}            | ${true}                    | ${"domain starts with dot (allowed by current regex)"}
+		${"user@example."}                | ${"Invalid email address"} | ${"domain ends with dot"}
+		${"user@com"}                     | ${"Invalid email address"} | ${"missing top-level domain"}
+		${"user name@example.com"}        | ${"Invalid email address"} | ${"space in local part"}
+		${"user@example com"}             | ${"Invalid email address"} | ${"space in domain"}
+		${""}                             | ${"Invalid email address"} | ${"empty string"}
+		${"user@@example.com"}            | ${"Invalid email address"} | ${"double @ symbol"}
+		${"user@example..com"}            | ${true}                    | ${"double dots in domain (allowed by current regex)"}
+	`('should return $expected for "$email" ($description)', ({ email, expected }) => {
+        expect(isValidEmail(email)).toBe(expected);
+    });
+});
+describe("isValidCommand", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it.each `
+		command                    | commandExists | expected                                      | description
+		${"git"}                   | ${true}       | ${true}                                       | ${"existing command"}
+		${"node"}                  | ${true}       | ${true}                                       | ${"another existing command"}
+		${"git status"}            | ${true}       | ${true}                                       | ${"command with arguments"}
+		${"nonexistent"}           | ${false}      | ${"Command not found: nonexistent"}           | ${"non-existing command"}
+		${"fake-cmd"}              | ${false}      | ${"Command not found: fake-cmd"}              | ${"another non-existing command"}
+		${"bad command with args"} | ${false}      | ${"Command not found: bad command with args"} | ${"non-existing command with args"}
+	`('should return $expected for "$command" when commandExists returns $commandExists ($description)', async ({ command, commandExists, expected }) => {
+        // Mock the commandExists function
+        vi.spyOn(cli, "commandExists").mockResolvedValue(commandExists);
+        expect(await isValidCommand(command)).toBe(expected);
+        expect(cli.commandExists).toHaveBeenCalledWith(command);
+    });
+});
+describe("isValidBranch", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Mock console.log to avoid cluttering test output
+        vi.spyOn(console, "log").mockImplementation(() => { });
+    });
+    it.each `
+		branch                   | branchType  | availableBranches                                           | expected                                  | description
+		${"main"}                | ${"local"}  | ${["main", "develop", "feature/test"]}                      | ${true}                                   | ${"existing local branch"}
+		${"develop"}             | ${"local"}  | ${["main", "develop", "feature/test"]}                      | ${true}                                   | ${"another existing local branch"}
+		${"feature/test"}        | ${"local"}  | ${["main", "develop", "feature/test"]}                      | ${true}                                   | ${"local branch with slash"}
+		${"nonexistent"}         | ${"local"}  | ${["main", "develop", "feature/test"]}                      | ${"Branch not found: nonexistent"}        | ${"non-existing local branch"}
+		${"origin/main"}         | ${"remote"} | ${["origin/main", "origin/develop", "origin/feature/test"]} | ${true}                                   | ${"existing remote branch"}
+		${"origin/develop"}      | ${"remote"} | ${["origin/main", "origin/develop", "origin/feature/test"]} | ${true}                                   | ${"another existing remote branch"}
+		${"origin/feature/test"} | ${"remote"} | ${["origin/main", "origin/develop", "origin/feature/test"]} | ${true}                                   | ${"remote branch with slash"}
+		${"origin/nonexistent"}  | ${"remote"} | ${["origin/main", "origin/develop", "origin/feature/test"]} | ${"Branch not found: origin/nonexistent"} | ${"non-existing remote branch"}
+		${"upstream/main"}       | ${"remote"} | ${["origin/main", "origin/develop"]}                        | ${"Branch not found: upstream/main"}      | ${"different remote prefix"}
+	`('should return $expected for "$branch" when $branchType branches are $availableBranches ($description)', async ({ branch, branchType, availableBranches, expected }) => {
+        if (branchType === "local") {
+            vi.spyOn(git, "gitGetLocalBranches").mockResolvedValue(availableBranches);
+            vi.spyOn(git, "gitGetRemoteBranches").mockResolvedValue([]);
+        }
+        else {
+            vi.spyOn(git, "gitGetRemoteBranches").mockResolvedValue(availableBranches);
+            vi.spyOn(git, "gitGetLocalBranches").mockResolvedValue([]);
+        }
+        const result = await isValidBranch(branch);
+        expect(result).toBe(expected);
+        if (branch.startsWith("origin/")) {
+            expect(git.gitGetRemoteBranches).toHaveBeenCalled();
+            expect(git.gitGetLocalBranches).not.toHaveBeenCalled();
+        }
+        else {
+            expect(git.gitGetLocalBranches).toHaveBeenCalled();
+            expect(git.gitGetRemoteBranches).not.toHaveBeenCalled();
+        }
+    });
+});
+describe("isValidBranchName", () => {
+    it.each `
+		branchName               | expected                                            | description
+		${"main"}                | ${true}                                             | ${"valid simple branch name"}
+		${"feature/new-feature"} | ${true}                                             | ${"valid branch with slash"}
+		${"bugfix/fix-123"}      | ${true}                                             | ${"valid branch with numbers"}
+		${"release/v1.0.0"}      | ${true}                                             | ${"valid release branch"}
+		${"user/john-doe"}       | ${true}                                             | ${"valid branch with hyphens"}
+		${"feature_branch"}      | ${true}                                             | ${"valid branch with underscores"}
+		${"123-branch"}          | ${true}                                             | ${"valid branch starting with numbers"}
+		${""}                    | ${"Branch name cannot be empty"}                    | ${"empty string"}
+		${"   "}                 | ${"Branch name cannot be empty"}                    | ${"whitespace only"}
+		${".hidden"}             | ${"Branch name cannot start with a dot"}            | ${"starts with dot"}
+		${"feature..branch"}     | ${"Branch name cannot contain double dots"}         | ${"contains double dots"}
+		${"branch.."}            | ${"Branch name cannot end with double dots"}        | ${"ends with double dots"}
+		${"feature branch"}      | ${"Branch name cannot contain spaces"}              | ${"contains spaces"}
+		${"branch~1"}            | ${"Branch name contains invalid characters"}        | ${"contains tilde"}
+		${"branch^master"}       | ${"Branch name contains invalid characters"}        | ${"contains caret"}
+		${"branch:colon"}        | ${"Branch name contains invalid characters"}        | ${"contains colon"}
+		${"branch\\backslash"}   | ${"Branch name contains invalid characters"}        | ${"contains backslash"}
+		${"branch*star"}         | ${"Branch name contains invalid characters"}        | ${"contains asterisk"}
+		${"branch?question"}     | ${"Branch name contains invalid characters"}        | ${"contains question mark"}
+		${"branch[bracket"}      | ${"Branch name contains invalid characters"}        | ${"contains bracket"}
+		${"branch@at"}           | ${"Branch name contains invalid characters"}        | ${"contains at sign"}
+		${"branch."}             | ${"Branch name cannot end with a dot"}              | ${"ends with dot"}
+		${"branch/"}             | ${"Branch name cannot end with a slash"}            | ${"ends with slash"}
+		${"feature//double"}     | ${"Branch name cannot contain consecutive slashes"} | ${"consecutive slashes"}
+		${"/starts-slash"}       | ${"Branch name cannot start with a slash"}          | ${"starts with slash"}
+		${"branch.lock"}         | ${"Branch name cannot end with '.lock'"}            | ${"ends with .lock"}
+	`('should return $expected for "$branchName" ($description)', ({ branchName, expected }) => {
+        const result = isValidBranchName(branchName);
+        expect(result).toBe(expected);
+    });
+});

package/dist/test-setup.d.ts

@@ -0,0 +1,3 @@
+declare const mockCmd: ReturnType<typeof vi.fn>;
+declare function expectCommands(...commands: string[]): void;
+export { mockCmd, expectCommands };

package/dist/test-setup.js

@@ -0,0 +1,28 @@
+// Global mock for the cmd function to prevent actual shell command execution
+const mockCmd = vi.fn();
+let expectedCommands = [];
+vi.mock("./lib/cli.js", () => ({
+    cmd: mockCmd,
+    commandExists: vi.fn().mockResolvedValue(true),
+}));
+beforeEach(() => {
+    // Clear all mocks before each test
+    vi.clearAllMocks();
+    expectedCommands = [];
+});
+afterEach(() => {
+    // Assert that no unexpected commands were called
+    const actualCalls = mockCmd.mock.calls.map((call) => call[0]);
+    const unexpectedCalls = actualCalls.filter((call) => !expectedCommands.includes(call));
+    if (unexpectedCalls.length > 0) {
+        console.warn(`Unexpected cmd calls detected:\n${unexpectedCalls
+            .map((call) => `  - ${call}`)
+            .join("\n")}`);
+    }
+});
+// Helper function for tests to declare expected commands
+function expectCommands(...commands) {
+    expectedCommands.push(...commands);
+}
+// Export the mock and helper for use in tests
+export { mockCmd, expectCommands };

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@burglekitt/worktree",
+  "version": "0.1.0",
+  "description": "A CLI tool for managing git worktrees with enhanced workflow features",
+  "main": "./bin/run.js",
+  "type": "module",
+  "scripts": {
+    "build": "shx rm -rf dist && tsc -b",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "format": "biome format",
+    "format:fix": "biome format --write",
+    "lint": "biome lint",
+    "lint:fix": "biome lint --write"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md"
+  ],
+  "keywords": [
+    "git",
+    "worktree",
+    "cli",
+    "workflow"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/burglekitt/worktree.git"
+  },
+  "homepage": "https://github.com/burglekitt/worktree",
+  "license": "MIT",
+  "packageManager": "pnpm@10.32.1+sha512.a706938f0e89ac1456b6563eab4edf1d1faf3368d1191fc5c59790e96dc918e4456ab2e67d613de1043d2e8c81f87303e6b40d4ffeca9df15ef1ad567348f2be",
+  "bin": {
+    "worktree": "./bin/run.js",
+    "@burglekitt/worktree": "./bin/run.js"
+  },
+  "oclif": {
+    "bin": "worktree",
+    "commands": "./dist/commands",
+    "dirname": "worktree",
+    "topicSeparator": " "
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.3.0",
+    "@oclif/core": "^4.8.3",
+    "chalk": "^5.6.2",
+    "glob": "^13.0.6",
+    "ora": "^9.3.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.4.6",
+    "@oclif/test": "^4.1.16",
+    "@types/node": "^18.19.130",
+    "shx": "^0.4.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}