git-worm 0.1.0__py3-none-any.whl

git_worm/__main__.py

@@ -0,0 +1,8 @@
+from xclif import Cli
+
+from . import routes
+
+cli = Cli.from_routes(routes, local_config=".git-worm.toml")
+
+if __name__ == "__main__":
+    cli()

git_worm/config.py

@@ -0,0 +1,35 @@
+"""Parse .git-worm.toml configuration."""
+
+from __future__ import annotations
+
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class ShareRule:
+    path: str
+    strategy: str  # "copy", "reflink", "symlink", "ignore"
+
+
+@dataclass
+class Config:
+    worktree_dir: str = ".worktrees"
+    share_rules: list[ShareRule] = field(default_factory=list)
+
+
+def load_config(path: Path) -> Config | None:
+    """Load config from a TOML file. Returns None if file doesn't exist."""
+    if not path.exists():
+        return None
+    with open(path, "rb") as f:
+        data = tomllib.load(f)
+    share_rules = [
+        ShareRule(path=rule["path"], strategy=rule["strategy"])
+        for rule in data.get("share", [])
+    ]
+    return Config(
+        worktree_dir=data.get("worktree_dir", ".worktrees"),
+        share_rules=share_rules,
+    )

git_worm/files.py

@@ -0,0 +1,246 @@
+"""Gitignored file detection and copy/reflink/symlink logic."""
+
+from __future__ import annotations
+
+import platform
+import shutil
+import subprocess
+from concurrent.futures import ThreadPoolExecutor
+from fnmatch import fnmatch
+from pathlib import Path
+
+from git_worm.config import ShareRule
+
+EXCLUDED_NAMES = {".git", ".worktrees"}
+_IS_MACOS = platform.system() == "Darwin"
+
+
+def _reflink_cmd(src: Path, dst: Path, *, recursive: bool = False) -> list[str]:
+    """Build a cp command that attempts copy-on-write cloning."""
+    if _IS_MACOS:
+        # macOS APFS: cp -c (clone)
+        flags = "-ac" if recursive else "-c"
+    else:
+        # Linux: cp --reflink=auto
+        flags = "-a --reflink=auto" if recursive else "--reflink=auto"
+    return ["cp", *flags.split(), str(src), str(dst)]
+
+
+def _has_tracked_files(repo: Path, directory: str) -> bool:
+    """Check if a directory contains any files tracked by git."""
+    result = subprocess.run(
+        ["git", "ls-files", directory],
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return bool(result.stdout.strip())
+
+
+def get_ignored_entries(repo: Path) -> list[Path]:
+    """Get gitignored files and directories in the repo.
+
+    Returns top-level entries when the entire directory is ignored.
+    For tracked directories that contain ignored files, returns the
+    individual ignored file paths instead.
+    """
+    result = subprocess.run(
+        ["git", "status", "--ignored", "--porcelain"],
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    entries = []
+    seen: set[str] = set()
+    for line in result.stdout.splitlines():
+        if not line.startswith("!! "):
+            continue
+        rel = line.removeprefix("!! ").rstrip("/")
+        top_level = rel.split("/")[0]
+        if top_level in EXCLUDED_NAMES:
+            continue
+        path = repo / top_level
+        if not path.exists():
+            continue
+        if top_level in seen:
+            continue
+        # If this is a directory that also has tracked files, we can't
+        # copy the whole thing — get the individual ignored files instead.
+        if path.is_dir() and _has_tracked_files(repo, top_level):
+            seen.add(top_level)
+            nested = _get_ignored_files_in(repo, top_level)
+            entries.extend(nested)
+        else:
+            seen.add(top_level)
+            entries.append(path)
+    return entries
+
+
+def _get_ignored_files_in(repo: Path, directory: str) -> list[Path]:
+    """Get individual ignored file paths within a partially-tracked directory."""
+    result = subprocess.run(
+        ["git", "status", "--ignored", "--porcelain", directory],
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    paths = []
+    for line in result.stdout.splitlines():
+        if not line.startswith("!! "):
+            continue
+        rel = line.removeprefix("!! ").rstrip("/")
+        path = repo / rel
+        if path.exists():
+            paths.append(path)
+    return paths
+
+
+# Directories where copying is useless because the contents are symlinks
+# or other indirection that won't survive a copy. The toolchain must be
+# re-run in the worktree to regenerate them correctly.
+#
+# Each entry maps a directory name to a list of marker groups.
+# A marker group is a tuple of filenames that must ALL exist for the match.
+# If ANY group matches, the directory should be skipped.
+_UNCOPYABLE_DIRS: dict[str, list[tuple[str, ...]]] = {
+    # JS/TS — pnpm/bun use hardlinks into a global store, Yarn PnP
+    # replaces node_modules entirely, Deno uses URL imports.
+    # Plain npm/yarn classic have real files worth copying.
+    "node_modules": [
+        ("pnpm-lock.yaml",),
+        ("bun.lockb",),
+        ("bun.lock",),
+        ("yarn.lock", ".pnp.cjs"),
+        ("yarn.lock", ".pnp.mjs"),
+        ("deno.lock",),
+    ],
+}
+
+
+def _is_uncopyable(entry_name: str, repo: Path) -> bool:
+    """Check if a directory uses indirection that won't survive copying."""
+    groups = _UNCOPYABLE_DIRS.get(entry_name)
+    if groups is None:
+        return False
+    return any(
+        all((repo / m).exists() for m in group)
+        for group in groups
+    )
+
+
+def should_skip_node_modules(repo: Path) -> bool:
+    """Detect if the package manager handles node_modules efficiently."""
+    return _is_uncopyable("node_modules", repo)
+
+
+def copy_entry(
+    entry: Path,
+    src_root: Path,
+    dst_root: Path,
+    *,
+    strategy: str,
+) -> dict[str, str]:
+    """Copy a single file or directory using the given strategy.
+
+    Returns a dict with 'name' and 'action' keys describing what happened.
+    """
+    rel = entry.relative_to(src_root)
+    dst = dst_root / rel
+    name = str(rel)
+
+    if strategy == "ignore":
+        return {"name": name, "action": "ignored"}
+
+    if strategy == "symlink":
+        dst.symlink_to(entry.resolve())
+        return {"name": name, "action": "symlinked"}
+
+    if strategy == "copy":
+        if entry.is_dir():
+            shutil.copytree(entry, dst)
+        else:
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(entry, dst)
+        return {"name": name, "action": "copied"}
+
+    if strategy == "reflink":
+        if entry.is_dir():
+            try:
+                subprocess.run(
+                    _reflink_cmd(entry, dst, recursive=True),
+                    check=True,
+                    capture_output=True,
+                )
+                return {"name": name, "action": "COW"}
+            except (subprocess.CalledProcessError, FileNotFoundError):
+                shutil.copytree(entry, dst)
+                return {"name": name, "action": "copied (COW unavailable)"}
+        else:
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            try:
+                subprocess.run(
+                    _reflink_cmd(entry, dst),
+                    check=True,
+                    capture_output=True,
+                )
+                return {"name": name, "action": "COW"}
+            except (subprocess.CalledProcessError, FileNotFoundError):
+                shutil.copy2(entry, dst)
+                return {"name": name, "action": "copied (COW unavailable)"}
+
+    return {"name": name, "action": f"unknown strategy: {strategy}"}
+
+
+def _default_strategy(entry: Path, repo: Path) -> str:
+    """Determine the default strategy for an ignored entry."""
+    if entry.is_dir() and _is_uncopyable(entry.name, repo):
+        return "ignore"
+    if entry.is_dir():
+        return "reflink"
+    return "copy"
+
+
+def _match_rule(entry_name: str, rules: list[ShareRule]) -> ShareRule | None:
+    """Find the first matching share rule for an entry name."""
+    for rule in rules:
+        if fnmatch(entry_name, rule.path):
+            return rule
+    return None
+
+
+def copy_ignored_files(
+    src: Path,
+    dst: Path,
+    *,
+    share_rules: list[ShareRule] | None = None,
+) -> list[dict[str, str]]:
+    """Copy all gitignored files from src to dst.
+
+    If share_rules is provided, it replaces default behavior entirely.
+    """
+    entries = get_ignored_entries(src)
+
+    # Resolve strategies and filter entries
+    work: list[tuple[Path, str]] = []
+    for entry in entries:
+        name = entry.name
+        if share_rules is not None:
+            rule = _match_rule(name, share_rules)
+            if rule is None:
+                continue
+            strategy = rule.strategy
+        else:
+            strategy = _default_strategy(entry, src)
+        work.append((entry, strategy))
+
+    if len(work) <= 3:
+        return [copy_entry(e, src, dst, strategy=s) for e, s in work]
+
+    with ThreadPoolExecutor() as pool:
+        futures = [
+            pool.submit(copy_entry, e, src, dst, strategy=s) for e, s in work
+        ]
+        return [f.result() for f in futures]

git_worm/routes/__init__.py

@@ -0,0 +1,6 @@
+from xclif import command
+
+
+@command("git-worm")
+def _() -> None:
+    """A better git worktree manager."""

git_worm/routes/list.py

@@ -0,0 +1,44 @@
+import rich
+from rich.tree import Tree
+
+from git_worm.worktree import list_worktrees, is_dirty, is_merged
+from xclif import command
+
+from pathlib import Path
+
+
+@command("list", "ls")
+def _() -> None:
+    """List all worktrees."""
+    worktrees = list_worktrees()
+
+    if not worktrees:
+        rich.print("[dim]No worktrees found.[/dim]")
+        return
+
+    tree = Tree("[bold]Worktrees[/bold]")
+    for i, wt in enumerate(worktrees):
+        path = wt["path"]
+        branch = wt.get("branch", wt.get("head", "???")[:8])
+        is_bare = wt.get("bare") == "true"
+        is_detached = wt.get("detached") == "true"
+        is_primary = i == 0
+
+        if is_bare:
+            label = f"[dim]{path}[/dim] [italic](bare)[/italic]"
+        elif is_detached:
+            label = f"[bold]{branch}[/bold] [dim]{path}[/dim] [yellow](detached)[/yellow]"
+        else:
+            dirty = is_dirty(Path(path))
+            merged = is_merged(branch)
+            status = ""
+            if dirty:
+                status += " [red][italic]dirty[/italic][/red]"
+            if merged:
+                status += " [green](merged)[/green]"
+            branch_fmt = f"[bold blue]{branch}[/bold blue]" if is_primary else f"[bold]{branch}[/bold]"
+            label = f"{branch_fmt} [dim]{path}[/dim]{status}"
+
+        tree.add(label)
+
+    rich.print(tree)

git_worm/routes/new.py

@@ -0,0 +1,72 @@
+from typing import Annotated
+
+import rich
+
+from git_worm.config import load_config
+from git_worm.files import copy_ignored_files
+from git_worm.worktree import add_worktree, find_repo_root
+from xclif import Arg, Option, WithConfig, command
+from xclif.context import get_context
+
+
+@command("new", "add")
+def _(
+    branch: Annotated[str, Arg(description="Branch name to check out (or create with --from)")],
+    from_ref: Annotated[str, Option(name="from", description="Create branch from this ref")] = "",
+    worktree_dir: WithConfig[str] = ".worktrees",
+    *branches: str,
+) -> None:
+    """Create one or more new worktrees for branches."""
+    all_branches = (branch, *branches)
+    repo = find_repo_root()
+    config = load_config(repo / ".git-worm.toml")
+
+    failed = False
+    for b in all_branches:
+        wt_path = repo / worktree_dir / b
+
+        if wt_path.exists():
+            rich.print(f"[bold red]Error:[/bold red] Worktree already exists at [bold]{wt_path}[/bold]")
+            failed = True
+            continue
+
+        # Create the worktree
+        add_worktree(wt_path, b, from_ref=from_ref or None)
+
+        # Ensure .worktrees/.gitignore exists
+        wt_dir = repo / worktree_dir
+        gitignore = wt_dir / ".gitignore"
+        if not gitignore.exists():
+            gitignore.write_text("*\n")
+
+        # Copy gitignored files
+        share_rules = config.share_rules if config else None
+        results = copy_ignored_files(repo, wt_path, share_rules=share_rules)
+
+        # Print summary
+        copied = [r for r in results if r["action"] != "ignored"]
+        rich.print(f"\n[bold green]Created worktree[/bold green] [bold]{b}[/bold] @ [dim]{wt_path}[/dim]")
+        if results and get_context().verbosity >= 1:
+            if copied:
+                rich.print(f"[dim]Copied {len(copied)} ignored file(s)[/dim]")
+            for r in results:
+                action = r["action"]
+                name = r["name"]
+                icon = {"copied": "+", "COW": "~", "symlinked": "->", "ignored": "x"}.get(
+                    action, "+"
+                )
+                if action == "ignored":
+                    rich.print(f"  [dim]{icon} {name} ({action})[/dim]")
+                elif action == "symlinked":
+                    rich.print(f"  [cyan]{icon}[/cyan] {name} [dim]({action})[/dim]")
+                elif action == "COW":
+                    rich.print(f"  [magenta]{icon}[/magenta] {name} [dim]({action})[/dim]")
+                else:
+                    rich.print(f"  [green]{icon}[/green] {name} [dim]({action})[/dim]")
+
+    if len(all_branches) == 1 and not failed:
+        wt_path = repo / worktree_dir / all_branches[0]
+        rich.print(f"\n[dim]Go to your new worktree with[/dim] [bold]cd {wt_path}[/bold]")
+
+    if failed:
+        return 1

git_worm/routes/prune.py

@@ -0,0 +1,72 @@
+import subprocess
+from pathlib import Path
+from typing import Annotated
+
+import rich
+
+from git_worm.worktree import find_repo_root, list_worktrees, remove_worktree
+from xclif import Option, command
+
+
+@command()
+def _(
+    merged: Annotated[bool, Option(description="Also remove worktrees whose branches are fully merged into main")] = False,
+) -> None:
+    """Remove stale worktree administrative files.
+
+    Runs `git worktree prune` to clean up refs for worktrees that have
+    been deleted manually without using `git worm rm`.
+    """
+    result = subprocess.run(
+        ["git", "worktree", "prune", "--verbose"],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    if result.stderr.strip():
+        for line in result.stderr.strip().splitlines():
+            rich.print(f"[dim]pruned:[/dim] {line}")
+    else:
+        rich.print("[dim]Nothing to prune.[/dim]")
+
+    if merged:
+        _prune_merged()
+
+
+def _prune_merged() -> None:
+    """Remove worktrees whose branches are fully merged into the main branch."""
+    repo = find_repo_root()
+    worktrees = list_worktrees()
+
+    # Find the main branch name (first worktree is the primary one)
+    if not worktrees:
+        return
+    main_branch = worktrees[0].get("branch")
+    if not main_branch:
+        return
+
+    # Get branches merged into the main branch
+    result = subprocess.run(
+        ["git", "branch", "--merged", main_branch],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    merged_branches = {
+        line.strip().lstrip("*+ ")
+        for line in result.stdout.splitlines()
+        if not line.startswith("*")
+    }
+
+    pruned = False
+    for wt in worktrees[1:]:  # skip the primary worktree
+        branch = wt.get("branch")
+        if not branch or branch not in merged_branches:
+            continue
+        path = Path(wt["path"])
+        remove_worktree(path)
+        rich.print(f"[bold green]Removed merged worktree[/bold green] [bold]{branch}[/bold]")
+        pruned = True
+
+    if not pruned:
+        rich.print("[dim]No merged worktrees to remove.[/dim]")

git_worm/routes/remove.py

@@ -0,0 +1,41 @@
+from typing import Annotated
+
+import rich
+
+from git_worm.worktree import find_repo_root, is_dirty, remove_worktree
+from xclif import Arg, Option, WithConfig, command
+
+
+@command("remove", "rm")
+def _(
+    branch: Annotated[str, Arg(description="Name of the worktree to remove")],
+    force: Annotated[bool, Option(description="Remove even if the worktree has uncommitted changes")] = False,
+    worktree_dir: WithConfig[str] = ".worktrees",
+    *branches: str,
+) -> None:
+    """Remove one or more worktrees."""
+    branches = (branch, *branches)
+    repo = find_repo_root()
+
+    failed = False
+    for b in branches:
+        wt_path = repo / worktree_dir / b
+
+        if not wt_path.exists():
+            rich.print(f"[bold red]Error:[/bold red] No worktree found at [bold]{wt_path}[/bold]")
+            failed = True
+            continue
+
+        if not force and is_dirty(wt_path):
+            rich.print(
+                f"[bold yellow]Warning:[/bold yellow] Worktree [bold]{b}[/bold] has uncommitted changes.\n"
+                f"Use [bold]--force[/bold] to remove anyway."
+            )
+            failed = True
+            continue
+
+        remove_worktree(wt_path, force=force)
+        rich.print(f"[bold green]Removed worktree[/bold green] [bold]{b}[/bold]")
+
+    if failed:
+        return 1

git_worm/routes/shell_init.py

@@ -0,0 +1,37 @@
+from xclif import command
+
+
+@command("shell-init")
+def _() -> None:
+    """Output a `worm` shell function that wraps git-worm with cd integration.
+
+    The `worm switch` command will cd into the worktree directory,
+    which is not possible with a plain subprocess. All other commands
+    are forwarded to git-worm as-is.
+
+    Add `eval "$(git-worm shell-init)"` to your shell rc file.
+    """
+    print("""\
+worm() {
+    if [ "$1" = "switch" ] && [ -n "$2" ]; then
+        local wt_dir
+        wt_dir="$(git rev-parse --show-toplevel)/.worktrees/$2"
+        if [ -d "$wt_dir" ]; then
+            cd "$wt_dir"
+            echo "Switched to worktree '$2' @ $wt_dir"
+        else
+            echo "Error: No worktree found for '$2'" >&2
+            return 1
+        fi
+    elif [ "$1" = "new" ]; then
+        local _worm_out _worm_cd
+        _worm_out="$(git-worm "$@")" || { echo "$_worm_out"; return 1; }
+        _worm_cd="$(echo "$_worm_out" | grep 'Go to your new worktree with cd ' | cut -d: -f2-)"
+        echo "$_worm_out" | grep -v 'Go to your new worktree with cd '
+        if [ -n "$_worm_cd" ] && [ -d "$_worm_cd" ]; then
+            cd "$_worm_cd"
+        fi
+    else
+        git-worm "$@"
+    fi
+}""")

git_worm/routes/switch.py

@@ -0,0 +1,22 @@
+from typing import Annotated
+
+import rich
+
+from git_worm.worktree import find_repo_root
+from xclif import Arg, WithConfig, command
+
+
+@command()
+def _(
+    branch: Annotated[str, Arg(description="Name of the worktree to switch to")],
+    worktree_dir: WithConfig[str] = ".worktrees",
+) -> None:
+    """Print the path to a worktree."""
+    repo = find_repo_root()
+    wt_path = repo / worktree_dir / branch
+
+    if not wt_path.exists():
+        rich.print(f"[bold red]Error:[/bold red] No worktree found for [bold]{branch}[/bold]")
+        return 1
+
+    rich.print(f"Worktree for [bold]{branch}[/bold] @ [bold]{wt_path}[/bold]")

git_worm/worktree.py

@@ -0,0 +1,101 @@
+"""Thin wrapper around git worktree commands."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+
+def add_worktree(path: Path, branch: str, *, from_ref: str | None = None) -> None:
+    """Create a new worktree. Creates a new branch if from_ref is given."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if from_ref is not None:
+        subprocess.run(
+            ["git", "worktree", "add", "-b", branch, str(path), from_ref],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    else:
+        subprocess.run(
+            ["git", "worktree", "add", "-b", branch, str(path), "HEAD"],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+
+
+def remove_worktree(path: Path, *, force: bool = False) -> None:
+    """Remove a worktree."""
+    cmd = ["git", "worktree", "remove", str(path)]
+    if force:
+        cmd.append("--force")
+    subprocess.run(cmd, check=True, capture_output=True, text=True)
+
+
+def list_worktrees() -> list[dict[str, str]]:
+    """List all worktrees. Returns list of dicts with 'path', 'head', 'branch' keys."""
+    result = subprocess.run(
+        ["git", "worktree", "list", "--porcelain"],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    worktrees = []
+    current: dict[str, str] = {}
+    for line in result.stdout.splitlines():
+        if line.startswith("worktree "):
+            if current:
+                worktrees.append(current)
+            current = {"path": str(Path(line.removeprefix("worktree ")))}
+        elif line.startswith("HEAD "):
+            current["head"] = line.removeprefix("HEAD ")
+        elif line.startswith("branch "):
+            current["branch"] = line.removeprefix("branch ").removeprefix("refs/heads/")
+        elif line == "bare":
+            current["bare"] = "true"
+        elif line == "detached":
+            current["detached"] = "true"
+    if current:
+        worktrees.append(current)
+    return worktrees
+
+
+def find_repo_root() -> Path:
+    """Find the git repo root from cwd."""
+    result = subprocess.run(
+        ["git", "rev-parse", "--show-toplevel"],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return Path(result.stdout.strip())
+
+
+def is_merged(branch: str) -> bool:
+    """Check if a branch has been merged into the main branch (not itself)."""
+    result = subprocess.run(
+        ["git", "branch", "--merged", "HEAD"],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    # Exclude the current branch (prefixed with '*') — it's not "merged", it IS HEAD
+    merged = {
+        line.strip().lstrip("* ")
+        for line in result.stdout.splitlines()
+        if not line.startswith("*")
+    }
+    return branch in merged
+
+
+def is_dirty(path: Path) -> bool:
+    """Check if a worktree has uncommitted changes."""
+    result = subprocess.run(
+        ["git", "status", "--porcelain"],
+        cwd=path,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return bool(result.stdout.strip())

git_worm-0.1.0.dist-info/METADATA

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: git-worm
+Version: 0.1.0
+Summary: A better git worktree manager
+Project-URL: Homepage, https://github.com/ThatXliner/git-worm
+Project-URL: Repository, https://github.com/ThatXliner/git-worm
+Project-URL: Issues, https://github.com/ThatXliner/git-worm/issues
+Author-email: Bryan Hu <thatxliner@gmail.com>
+License-Expression: Unlicense
+License-File: LICENSE
+Keywords: cli,git,worktree
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: The Unlicense (Unlicense)
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.12
+Requires-Dist: xclif>=0.4.0
+Description-Content-Type: text/markdown
+
+# git-worm
+
+> Git WORktree Manager
+
+[![CI](https://github.com/ThatXliner/git-worm/actions/workflows/ci.yml/badge.svg)](https://github.com/ThatXliner/git-worm/actions/workflows/ci.yml)
+
+https://github.com/user-attachments/assets/916af237-e959-43fc-9046-067929ad874f
+
+A better git worktree manager. Built with [Xclif](https://github.com/ThatXliner/xclif).
+
+## Why?
+
+`git worktree` is powerful but raw. git-worm adds:
+
+- **Automatic file management** — gitignored files (`.env`, `.venv`, `node_modules`, etc.) are copied into new worktrees so switching feels like `git switch`
+- **Smart package manager detection** — pnpm/bun/Yarn PnP users don't get unnecessary `node_modules` copies
+- **Nice UI** — Rich-formatted output, tree views, colored status. You can also create multiple worktrees in one command!
+
+## Install
+
+Requires Python 3.12+
+
+```bash
+pip install git-worm
+```
+
+Or with [uv](https://github.com/astral-sh/uv):
+
+```bash
+uv tool install git-worm
+```
+
+## Usage
+
+Because of [Xclif](https://github.com/ThatXliner/xclif), git-worm automatically gets a very nice-looking help page
+
+![Help](./help.png)
+
+```bash
+# Create a new worktree (copies .env, .venv, etc. automatically)
+git worm new feat-login
+
+# Create from a specific ref
+git worm new feat-login --from-ref main
+
+# List all worktrees
+git worm list
+
+# Print worktree path
+git worm switch feat-login
+
+# Remove a worktree
+git worm rm feat-login
+
+# Remove even if dirty
+git worm rm feat-login --force
+
+# Shell integration (add to .bashrc/.zshrc)
+eval "$(git-worm shell-init)"
+# Then: worm switch feat-login  (auto-cds)
+```
+
+### Shell integration
+
+`git-worm shell-init` outputs a `worm` shell function that wraps `git-worm`. This is needed because `worm switch` needs to `cd` into the worktree directory, which a plain subprocess can't do. All other commands are forwarded to `git-worm` as-is.
+
+Add this to your `.bashrc` or `.zshrc`:
+
+```bash
+eval "$(git-worm shell-init)"
+```
+
+Then use `worm` instead of `git-worm`:
+
+```bash
+worm new feat-login
+worm switch feat-login  # cds into the worktree
+worm list
+```
+
+## Configuration
+
+Optional `.git-worm.toml` in your repo root:
+
+```toml
+[settings]
+worktree_dir = ".worktrees"  # default
+
+[[share]]
+path = ".env*"
+strategy = "copy"
+
+[[share]]
+path = "node_modules"
+strategy = "ignore"
+
+[[share]]
+path = "target"
+strategy = "symlink"
+```
+
+Strategies: `copy`, `reflink` (COW, falls back to copy), `symlink`, `ignore`.
+
+When a config file is present, it replaces the default behavior entirely.
+
+## Default Behavior (no config)
+
+1. All gitignored files/dirs are detected
+2. `.git/` and `.worktrees/` are excluded
+3. Files are plain-copied, directories are reflinked (with copy fallback)
+4. `node_modules/` is skipped if pnpm, bun, or Yarn PnP is detected
+
+## License
+
+Public Domain

git_worm-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+git_worm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+git_worm/__main__.py,sha256=TmT9mB6g_kE8g4tlls_Kv002M302t6WDGVBrffpXgME,144
+git_worm/config.py,sha256=ihoQ3yiiND8wPBTjbLUcj-ouPR7BBI0XGo9pdwuPpRo,888
+git_worm/files.py,sha256=rJZ3qrZUnkqhZa_pg_JYkVTjfJSFB_A05K2iO7nTM6I,7840
+git_worm/worktree.py,sha256=sG0gJ2jTaQ2SHAnCyHU65aet56mwWab0P7g2S3oqq-0,3099
+git_worm/routes/__init__.py,sha256=TytV6xqzqcLISLrM4u-jmRvNlzOTNpUEsYraQ0qGeGI,107
+git_worm/routes/list.py,sha256=MQKCliFQNzCs2MJuuenSn2vuyHuXwDbmLqOLEPSa0Lg,1340
+git_worm/routes/new.py,sha256=roKfXSdvKLFGN-xWNOmTt4z2M1kvjgJFKSdGLdhxUO4,2798
+git_worm/routes/prune.py,sha256=6bAUvOIQZK36N6_NAmdXiTDExIpXG3mKqwUkjpfsV7I,2098
+git_worm/routes/remove.py,sha256=2c4a3LLx97byfQNYtXJHPB0mrvOe7f4139Xob_Mo2lM,1301
+git_worm/routes/shell_init.py,sha256=mp8RTu9Ujt0QtLe4UQY8AbbPVIU7KIQ5ZPtgVcyOxB8,1213
+git_worm/routes/switch.py,sha256=6SUqiZab0mO8QYSOV_pnJ3lLZJLYEzk7rMi8T_pbJaw,627
+git_worm-0.1.0.dist-info/METADATA,sha256=yyrDCZsawDvXeYeTmnvPhPUWJbjWWCDMCRoB9TjU_7A,3644
+git_worm-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+git_worm-0.1.0.dist-info/entry_points.txt,sha256=ArQorxkJPKfClAYLg44LYD_VEW6z3QgJzO40djPxJyo,51
+git_worm-0.1.0.dist-info/licenses/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
+git_worm-0.1.0.dist-info/RECORD,,

git_worm-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

git_worm-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+git-worm = git_worm.__main__:cli

git_worm-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <https://unlicense.org>