git-env 0.2.0__tar.gz → 0.4.0__tar.gz

git_env-0.4.0/LICENCE

@@ -0,0 +1,7 @@
+Copyright (c) 2026 Alex Ward
+
+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.

{git_env-0.2.0 → git_env-0.4.0}/PKG-INFO

@@ -1,26 +1,25 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: git-env
-Version: 0.2.0
+Version: 0.4.0
 Summary: Sync environment files across linked git worktrees
 Author: Alex Ward
 Author-email: Alex Ward <alxwrd@googlemail.com>
-Requires-Dist: arguably>=1.2.2
+License-Expression: MIT
+License-File: LICENCE
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 
 <div align="center">
     <h1><code>git-env</code></h1>
     <p align="center"><i>
-        Environment file syncronisation to your linked git worktrees
+        Copies untracked env files to your worktrees
     </i></p>
     <img width="256px" src="https://github.com/alxwrd/git-env/raw/main/.github/assets/man-reading-the-mail-768.png">
     <div align="center">
-        <a href="https://github.com/alxwrd/git-env/actions/workflows/test.yml"><img src="https://img.shields.io/github/actions/workflow/status/alxwrd/git-env/test.yml?branch=main&label=main"></a>
-        <a href="https://pypi.python.org/pypi/git-env"><img src="https://img.shields.io/pypi/v/git-env.svg"></a>
-        <a href="https://github.com/alxwrd/git-env/blob/main/LICENCE"><img src="https://img.shields.io/pypi/l/git-env.svg?"></a>
+        <a href="https://github.com/alxwrd/git-env/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/alxwrd/git-env/ci.yml?branch=main&label=main"></a>
+        <a href="https://pypi.python.org/pypi/git-env"><img src="https://img.shields.io/pypi/v/git-env"></a>
+        <a href="https://github.com/alxwrd/git-env/blob/main/LICENCE"><img src="https://img.shields.io/pypi/l/git-env"></a>
     </div>
-
-Copies untracked env files to your worktrees.
 </div>
 
 
@@ -35,10 +34,8 @@ git env sync                                 # copies .env from the primary
 
 ```plain
 $ git env sync
-
-copied  .env
-
-1 file synced.
+synced  .env
+2 files synced, 0 unchanged, 0 conflicts skipped
 ```
 
 Run it again later to pick up any changes made in the primary. By default,

{git_env-0.2.0 → git_env-0.4.0}/README.md

@@ -1,16 +1,14 @@
 <div align="center">
     <h1><code>git-env</code></h1>
     <p align="center"><i>
-        Environment file syncronisation to your linked git worktrees
+        Copies untracked env files to your worktrees
     </i></p>
     <img width="256px" src="https://github.com/alxwrd/git-env/raw/main/.github/assets/man-reading-the-mail-768.png">
     <div align="center">
-        <a href="https://github.com/alxwrd/git-env/actions/workflows/test.yml"><img src="https://img.shields.io/github/actions/workflow/status/alxwrd/git-env/test.yml?branch=main&label=main"></a>
-        <a href="https://pypi.python.org/pypi/git-env"><img src="https://img.shields.io/pypi/v/git-env.svg"></a>
-        <a href="https://github.com/alxwrd/git-env/blob/main/LICENCE"><img src="https://img.shields.io/pypi/l/git-env.svg?"></a>
+        <a href="https://github.com/alxwrd/git-env/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/alxwrd/git-env/ci.yml?branch=main&label=main"></a>
+        <a href="https://pypi.python.org/pypi/git-env"><img src="https://img.shields.io/pypi/v/git-env"></a>
+        <a href="https://github.com/alxwrd/git-env/blob/main/LICENCE"><img src="https://img.shields.io/pypi/l/git-env"></a>
     </div>
-
-Copies untracked env files to your worktrees.
 </div>
 
 
@@ -25,10 +23,8 @@ git env sync                                 # copies .env from the primary
 
 ```plain
 $ git env sync
-
-copied  .env
-
-1 file synced.
+synced  .env
+2 files synced, 0 unchanged, 0 conflicts skipped
 ```
 
 Run it again later to pick up any changes made in the primary. By default,

{git_env-0.2.0 → git_env-0.4.0}/pyproject.toml

@@ -1,15 +1,15 @@
 [project]
 name = "git-env"
-version = "0.2.0"
+version = "0.4.0"
 description = "Sync environment files across linked git worktrees"
 readme = "README.md"
 authors = [
     { name = "Alex Ward", email = "alxwrd@googlemail.com" }
 ]
+license = "MIT"
+license-files = ["LICENCE"]
 requires-python = ">=3.10"
-dependencies = [
-    "arguably>=1.2.2",
-]
+dependencies = []
 
 [project.scripts]
 git-env = "git_env:main"

git_env-0.4.0/src/git_env/_argparser.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import argparse
+from importlib.metadata import version
+
+from .shell_completions import SUPPORTED_SHELLS
+
+
+class GitEnvExit(Exception):
+    """Raised by command bodies to request a specific process exit code."""
+
+    def __init__(self, code: int) -> None:
+        super().__init__(code)
+        self.code = code
+
+
+def rewrite_help_subcommand(argv: list[str]) -> list[str]:
+    """Translate `git env help [subcommand]` into `git env [subcommand] --help`."""
+    if argv and argv[0] == "help":
+        return [*argv[1:], "--help"]
+    return argv
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="git env",
+        description="sync environment files across linked git worktrees",
+    )
+
+    parser.add_argument(
+        "--version", action="version", version=f"%(prog)s {version('git-env')}"
+    )
+    parser.add_argument(
+        "--porcelain",
+        action="store_true",
+        help="reserved for a future machine-readable output mode (not yet supported)",
+    )
+    parser.add_argument(
+        "--install-completions",
+        choices=SUPPORTED_SHELLS,
+        metavar="{" + "|".join(SUPPORTED_SHELLS) + "}",
+        help="print a completion snippet for the given shell; combine with --write to install",
+    )
+    parser.add_argument(
+        "--write",
+        action="store_true",
+        help="used with --install-completions: write the file instead of printing",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="print every file considered, including skips",
+    )
+    parser.add_argument(
+        "-q", "--quiet", action="store_true", help="suppress non-error output"
+    )
+
+    sub = parser.add_subparsers(dest="command")
+
+    p_sync = sub.add_parser(
+        "sync",
+        help="copy env files from primary worktree into current linked worktree",
+    )
+    p_sync.add_argument(
+        "-n", "--dry-run", action="store_true", help="print actions, change nothing"
+    )
+    p_sync.add_argument(
+        "-f",
+        "--force",
+        action="store_true",
+        help="overwrite local files even when they differ from primary",
+    )
+    p_sync.add_argument(
+        "--pattern",
+        action="append",
+        metavar="GLOB",
+        help="glob to sync, repeatable; overrides configured patterns",
+    )
+    p_sync.add_argument(
+        "--path", metavar="PATH", help="restrict to a subdirectory of the worktree"
+    )
+
+    return parser

git_env-0.4.0/src/git_env/cli.py

@@ -0,0 +1,120 @@
+"""Top-level CLI: dispatches `git env <subcommand>` via argparse.
+
+Exit codes are part of the spec's contract (see spec.md):
+  0 success, 1 sync conflicts skipped, 2 refused to run, 3 usage error, 4 I/O error.
+argparse itself always raises `SystemExit(2)` for usage errors (bad flag, unknown
+subcommand), which collides with our "refused to run" code. `GitEnvExit` lets
+command bodies signal an intentional exit code; any other `SystemExit(2)` reaching
+`main()` therefore came from argparse and is remapped to 3.
+"""
+
+from __future__ import annotations
+
+import sys
+
+from ._argparser import GitEnvExit, build_parser, rewrite_help_subcommand
+from .config import ConfigError, load_config
+from .output import Reporter
+from .repo import RepoError, check_primary_clean, detect_repository
+from .shell_completions import install_completions as render_completions_install
+from .sync import SyncIOError, run_sync
+
+
+def sync(
+    *,
+    pattern: list[str] | None = None,
+    path: str | None = None,
+    dry_run: bool = False,
+    force: bool = False,
+    reporter: Reporter,
+) -> None:
+    try:
+        repo = detect_repository()
+    except RepoError as exc:
+        reporter.error(str(exc))
+        raise GitEnvExit(2) from None
+
+    try:
+        config = load_config(repo.primary_root)
+    except ConfigError as exc:
+        reporter.error(str(exc))
+        raise GitEnvExit(3) from None
+
+    if pattern:
+        config = type(config)(**{**config.__dict__, "patterns": tuple(pattern)})
+
+    if not force:
+        dirty = check_primary_clean(repo.primary_root, config.patterns, config.exclude)
+        if dirty:
+            reporter.error(
+                "primary worktree has uncommitted changes to tracked env files: "
+                f"{', '.join(dirty)} (use --force to override)"
+            )
+            raise GitEnvExit(2)
+
+    try:
+        result = run_sync(
+            repo,
+            config,
+            dry_run=dry_run,
+            force=force,
+            path=path,
+            reporter=reporter,
+        )
+    except SyncIOError as exc:
+        reporter.error(str(exc))
+        raise GitEnvExit(4) from None
+
+    if dry_run:
+        raise GitEnvExit(1 if result.would_change or result.conflicts else 0)
+    raise GitEnvExit(result.exit_code)
+
+
+def main() -> None:
+    argv = rewrite_help_subcommand(sys.argv[1:])
+    try:
+        parser = build_parser()
+        args = parser.parse_args(argv)
+
+        if args.porcelain:
+            print(
+                "git env: --porcelain is reserved for a future version and is not yet"
+                " supported",
+                file=sys.stderr,
+            )
+            raise GitEnvExit(3)
+        if args.install_completions is not None:
+            print(
+                render_completions_install(args.install_completions, write=args.write)
+            )
+            raise GitEnvExit(0)
+        if args.write:
+            print("git env: --write requires --install-completions", file=sys.stderr)
+            raise GitEnvExit(3)
+        if args.verbose and args.quiet:
+            print(
+                "git env: --verbose and --quiet are mutually exclusive", file=sys.stderr
+            )
+            raise GitEnvExit(3)
+
+        reporter = Reporter(verbose=args.verbose, quiet=args.quiet)
+
+        match args.command:
+            case None:
+                parser.error("a subcommand is required, try 'git env --help'")
+            case "sync":
+                sync(
+                    pattern=args.pattern,
+                    path=args.path,
+                    dry_run=args.dry_run,
+                    force=args.force,
+                    reporter=reporter,
+                )
+
+    except GitEnvExit as exc:
+        sys.exit(exc.code)
+    except SystemExit as exc:
+        code = exc.code if isinstance(exc.code, int) else 1
+        if code == 2:
+            sys.exit(3)
+        raise

{git_env-0.2.0 → git_env-0.4.0}/src/git_env/config.py

@@ -6,6 +6,7 @@ local -> worktree) handled natively by `git config --get[-all]`.
 from __future__ import annotations
 
 import subprocess
+from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -89,7 +90,7 @@ def _parse_envsync_file(path: Path) -> dict[str, list[str]]:
     return values
 
 
-def _parse_bool(value: str, *, source: str) -> bool:
+def _parse_bool(value: str, source: str) -> bool:
     lowered = value.strip().lower()
     if lowered in _TRUE_VALUES:
         return True
@@ -98,7 +99,7 @@ def _parse_bool(value: str, *, source: str) -> bool:
     raise ConfigError(f"invalid boolean value for {source}: {value!r}")
 
 
-def _parse_int(value: str, *, source: str) -> int:
+def _parse_int(value: str, source: str) -> int:
     try:
         return int(value.strip())
     except ValueError as exc:
@@ -116,36 +117,20 @@ def _resolve_multi(
     return list(default)
 
 
-def _resolve_bool(
-    config_key: str, envsync: dict[str, list[str]], envsync_key: str, default: bool, cwd: Path
-) -> bool:
+def _resolve(
+    config_key: str,
+    envsync: dict[str, list[str]],
+    envsync_key: str,
+    default: str | bool | int,
+    cwd: Path,
+    parse: Callable[[str, str], str | bool | int] | None = None,
+) -> str | bool | int:
     value = _git_config_get(config_key, cwd)
     if value is not None:
-        return _parse_bool(value, source=config_key)
+        return parse(value, config_key) if parse else value
     if envsync_key in envsync:
-        return _parse_bool(envsync[envsync_key][-1], source=f".envsync:{envsync_key}")
-    return default
-
-
-def _resolve_int(
-    config_key: str, envsync: dict[str, list[str]], envsync_key: str, default: int, cwd: Path
-) -> int:
-    value = _git_config_get(config_key, cwd)
-    if value is not None:
-        return _parse_int(value, source=config_key)
-    if envsync_key in envsync:
-        return _parse_int(envsync[envsync_key][-1], source=f".envsync:{envsync_key}")
-    return default
-
-
-def _resolve_str(
-    config_key: str, envsync: dict[str, list[str]], envsync_key: str, default: str, cwd: Path
-) -> str:
-    value = _git_config_get(config_key, cwd)
-    if value is not None:
-        return value
-    if envsync_key in envsync:
-        return envsync[envsync_key][-1]
+        raw = envsync[envsync_key][-1]
+        return parse(raw, f".envsync:{envsync_key}") if parse else raw
     return default
 
 
@@ -164,17 +149,13 @@ def load_config(primary_root: Path) -> SyncConfig:
     exclude = _resolve_multi(
         "env.sync.exclude", envsync, "exclude", DEFAULT_EXCLUDE, primary_root
     )
-    follow_symlinks = _resolve_bool(
-        "env.sync.followSymlinks",
-        envsync,
-        "followSymlinks",
-        DEFAULT_FOLLOW_SYMLINKS,
-        primary_root,
+    follow_symlinks = _resolve(
+        "env.sync.followSymlinks", envsync, "followSymlinks", DEFAULT_FOLLOW_SYMLINKS, primary_root, _parse_bool
     )
-    max_file_size = _resolve_int(
-        "env.sync.maxFileSize", envsync, "maxFileSize", DEFAULT_MAX_FILE_SIZE, primary_root
+    max_file_size = _resolve(
+        "env.sync.maxFileSize", envsync, "maxFileSize", DEFAULT_MAX_FILE_SIZE, primary_root, _parse_int
     )
-    on_conflict = _resolve_str(
+    on_conflict = _resolve(
         "env.sync.onConflict", envsync, "onConflict", DEFAULT_ON_CONFLICT, primary_root
     )
     if on_conflict not in VALID_ON_CONFLICT:
@@ -182,15 +163,15 @@ def load_config(primary_root: Path) -> SyncConfig:
             f"invalid env.sync.onConflict value: {on_conflict!r}"
             f" (expected one of {sorted(VALID_ON_CONFLICT)})"
         )
-    backup = _resolve_bool(
-        "env.sync.backup", envsync, "backup", DEFAULT_BACKUP, primary_root
+    backup = _resolve(
+        "env.sync.backup", envsync, "backup", DEFAULT_BACKUP, primary_root, _parse_bool
     )
 
     return SyncConfig(
         patterns=tuple(patterns),
         exclude=tuple(exclude),
-        follow_symlinks=follow_symlinks,
-        max_file_size=max_file_size,
-        on_conflict=on_conflict,
-        backup=backup,
+        follow_symlinks=bool(follow_symlinks),
+        max_file_size=int(max_file_size),  # type: ignore[arg-type]
+        on_conflict=str(on_conflict),
+        backup=bool(backup),
     )

{git_env-0.2.0 → git_env-0.4.0}/src/git_env/discovery.py

@@ -32,10 +32,6 @@ class DiscoveredFile:
     absolute_path: Path
     """Absolute path to the file (symlink target if followed)."""
 
-    size: int
-
-    is_symlink: bool
-
 
 @dataclass(frozen=True)
 class DiscoveryWarning:
@@ -106,10 +102,6 @@ class _IgnoreMatcher:
                 ignored = not negate
         return ignored
 
-    @property
-    def empty(self) -> bool:
-        return not self._rules
-
 
 def _load_ignore_matcher(primary_root: Path) -> _IgnoreMatcher:
     ignore_file = primary_root / ".envsyncignore"
@@ -152,7 +144,7 @@ def discover_env_files(
                 continue
             if child.is_symlink() and not config.follow_symlinks:
                 continue
-            if not ignore.empty and ignore.matches(rel_child_posix, is_dir=True):
+            if ignore.matches(rel_child_posix, is_dir=True):
                 continue
             kept_dirnames.append(dirname)
         dirnames[:] = kept_dirnames
@@ -166,7 +158,7 @@ def discover_env_files(
                 continue
             if _matches_any(filename, config.exclude):
                 continue
-            if not ignore.empty and ignore.matches(rel_posix, is_dir=False):
+            if ignore.matches(rel_posix, is_dir=False):
                 continue
 
             is_symlink = abs_path.is_symlink()
@@ -195,8 +187,6 @@ def discover_env_files(
                 DiscoveredFile(
                     relative_path=rel_path,
                     absolute_path=abs_path,
-                    size=stat_result.st_size,
-                    is_symlink=is_symlink,
                 )
             )
 

{git_env-0.2.0 → git_env-0.4.0}/src/git_env/repo.py

@@ -9,6 +9,12 @@ from dataclasses import dataclass
 from pathlib import Path
 
 
+@dataclass(frozen=True)
+class ShellResult:
+    ok: bool
+    out: str
+
+
 class RepoError(Exception):
     """Raised when the current location is not a usable linked worktree.
 
@@ -33,20 +39,7 @@ class Repository:
     """Absolute path to the current (linked) worktree's root directory."""
 
 
-def _git(*args: str, cwd: Path | None = None) -> str:
-    try:
-        result = subprocess.run(
-            ["git", *args],
-            cwd=cwd,
-            capture_output=True,
-            text=True,
-        )
-    except FileNotFoundError as exc:
-        raise RepoError("git executable not found on PATH") from exc
-    return result.stdout.strip()
-
-
-def _git_ok(*args: str, cwd: Path | None = None) -> tuple[bool, str]:
+def _git(*args: str, cwd: Path | None = None) -> ShellResult:
     try:
         result = subprocess.run(
             ["git", *args],
@@ -56,7 +49,7 @@ def _git_ok(*args: str, cwd: Path | None = None) -> tuple[bool, str]:
         )
     except FileNotFoundError as exc:
         raise RepoError("git executable not found on PATH") from exc
-    return result.returncode == 0, result.stdout.strip()
+    return ShellResult(ok=result.returncode == 0, out=result.stdout.strip())
 
 
 def detect_repository(cwd: Path | None = None) -> Repository:
@@ -69,21 +62,21 @@ def detect_repository(cwd: Path | None = None) -> Repository:
     """
     cwd = (cwd or Path.cwd()).resolve()
 
-    inside_ok, inside_out = _git_ok("rev-parse", "--is-inside-work-tree", cwd=cwd)
-    bare_ok, bare_out = _git_ok("rev-parse", "--is-bare-repository", cwd=cwd)
+    inside = _git("rev-parse", "--is-inside-work-tree", cwd=cwd)
+    bare = _git("rev-parse", "--is-bare-repository", cwd=cwd)
 
     # A bare repo has no work tree, so --is-inside-work-tree reports "false" (not
     # an error) even when we *are* inside a git dir. Check bare-ness first so that
     # case gets its own message instead of the generic "not inside a worktree" one.
-    if bare_ok and bare_out == "true":
+    if bare.ok and bare.out == "true":
         raise RepoError("bare repositories are not supported")
 
-    if not inside_ok or inside_out != "true":
+    if not inside.ok or inside.out != "true":
         raise RepoError("not inside a git worktree")
 
-    git_dir = Path(_git("rev-parse", "--path-format=absolute", "--git-dir", cwd=cwd))
+    git_dir = Path(_git("rev-parse", "--path-format=absolute", "--git-dir", cwd=cwd).out)
     git_common_dir = Path(
-        _git("rev-parse", "--path-format=absolute", "--git-common-dir", cwd=cwd)
+        _git("rev-parse", "--path-format=absolute", "--git-common-dir", cwd=cwd).out
     )
 
     if git_dir.resolve() == git_common_dir.resolve():
@@ -95,7 +88,7 @@ def detect_repository(cwd: Path | None = None) -> Repository:
 
     primary_root = git_common_dir.resolve().parent
     worktree_root = Path(
-        _git("rev-parse", "--path-format=absolute", "--show-toplevel", cwd=cwd)
+        _git("rev-parse", "--path-format=absolute", "--show-toplevel", cwd=cwd).out
     ).resolve()
 
     _check_pwd_within_worktree(worktree_root)

{git_env-0.2.0 → git_env-0.4.0}/src/git_env/shell_completions.py

@@ -30,15 +30,11 @@ class CompletionTarget:
     enable_snippet: str
 
 
-def _xdg_data_home() -> Path:
-    return Path(os.environ.get("XDG_DATA_HOME") or Path.home() / ".local" / "share")
-
-
 def completion_target(shell: str) -> CompletionTarget:
     """Resolve the standard user-level install path and rc snippet for `shell`."""
     home = Path.home()
     if shell == "bash":
-        path = _xdg_data_home() / "bash-completion" / "completions" / "git-env"
+        path = Path(os.environ.get("XDG_DATA_HOME") or home / ".local" / "share") / "bash-completion" / "completions" / "git-env"
         snippet = f'source "{path}"'
     elif shell == "zsh":
         path = home / ".zsh" / "completions" / "_git-env"

{git_env-0.2.0 → git_env-0.4.0}/src/git_env/sync.py

@@ -48,12 +48,6 @@ class SyncResult:
         return 0
 
 
-def _filter_path(files: list[DiscoveredFile], path: str | None) -> list[DiscoveredFile]:
-    if path is None:
-        return files
-    prefix = Path(path)
-    return [f for f in files if prefix in (f.relative_path, *f.relative_path.parents)]
-
 
 def _resolve_dest(worktree_root: Path, relative_path: Path) -> Path:
     """Resolve `relative_path` against `worktree_root`, refusing escapes.
@@ -173,7 +167,9 @@ def run_sync(
 ) -> SyncResult:
     """Sync env files from `repo.primary_root` into `repo.worktree_root`."""
     files, warnings = discover_env_files(repo.primary_root, config)
-    files = _filter_path(files, path)
+    if path is not None:
+        prefix = Path(path)
+        files = [f for f in files if prefix in (f.relative_path, *f.relative_path.parents)]
 
     for warning in warnings:
         reporter.warn(f"{warning.relative_path}: {warning.message}")

git_env-0.2.0/src/git_env/cli.py

@@ -1,183 +0,0 @@
-"""Top-level CLI: dispatches `git env <subcommand>` via arguably.
-
-Exit codes are part of the spec's contract (see spec.md):
-  0 success, 1 sync conflicts skipped, 2 refused to run, 3 usage error, 4 I/O error.
-argparse itself always raises `SystemExit(2)` for usage errors (bad flag, unknown
-subcommand), which collides with our "refused to run" code. `GitEnvExit` lets
-command bodies signal an intentional exit code; any other `SystemExit(2)` reaching
-`main()` therefore came from argparse and is remapped to 3.
-"""
-
-from __future__ import annotations
-
-import sys
-
-import arguably
-
-from .config import ConfigError, load_config
-from .output import Reporter
-from .repo import RepoError, check_primary_clean, detect_repository
-from .shell_completions import SUPPORTED_SHELLS
-from .shell_completions import install_completions as render_completions_install
-from .sync import SyncIOError, run_sync
-
-#: Names set aside for future official subcommands (see spec.md Extensibility).
-RESERVED_SUBCOMMANDS = frozenset({"push", "diff", "status", "list", "edit", "check"})
-
-
-class GitEnvExit(Exception):
-    """Raised by command bodies to request a specific process exit code."""
-
-    def __init__(self, code: int) -> None:
-        super().__init__(code)
-        self.code = code
-
-
-@arguably.command
-def __root__(
-    *, porcelain: bool = False, install_completions: str | None = None, write: bool = False
-) -> None:
-    """
-    git env: sync environment files across linked git worktrees.
-
-    Args:
-        porcelain: reserved for a future machine-readable output mode (not yet supported)
-        install_completions: print a completion snippet for [bash|zsh|fish]; combine with
-            --write to install the completion file instead of printing it
-        write: used with --install-completions, write the completion file to its standard
-            location instead of printing a snippet
-    """
-    if porcelain:
-        print(
-            "git env: --porcelain is reserved for a future version and is not yet"
-            " supported",
-            file=sys.stderr,
-        )
-        raise GitEnvExit(3)
-    if install_completions is not None:
-        if install_completions not in SUPPORTED_SHELLS:
-            print(
-                "git env: --install-completions expects one of "
-                f"{', '.join(SUPPORTED_SHELLS)}, got {install_completions!r}",
-                file=sys.stderr,
-            )
-            raise GitEnvExit(3)
-        print(render_completions_install(install_completions, write=write))
-        raise GitEnvExit(0)
-    if write:
-        print("git env: --write requires --install-completions", file=sys.stderr)
-        raise GitEnvExit(3)
-    if arguably.is_target():
-        arguably.error("a subcommand is required, try 'git env --help'")
-
-
-@arguably.command
-def sync(
-    *,
-    dry_run: bool = False,
-    force: bool = False,
-    verbose: bool = False,
-    quiet: bool = False,
-    pattern: list[str] | None = None,
-    path: str | None = None,
-) -> None:
-    """
-    Copy env files from the primary worktree into the current linked worktree.
-
-    Args:
-        dry_run: [-n] print actions, change nothing
-        force: [-f] overwrite local files even when they differ from the primary
-        verbose: [-v] print every file considered, including skips
-        quiet: [-q] suppress non-error output
-        pattern: glob to sync, repeatable; overrides configured patterns for this run
-        path: restrict to a subdirectory of the worktree
-    """
-    if verbose and quiet:
-        print("git env sync: --verbose and --quiet are mutually exclusive", file=sys.stderr)
-        raise GitEnvExit(3)
-
-    reporter = Reporter(verbose=verbose, quiet=quiet)
-
-    try:
-        repo = detect_repository()
-    except RepoError as exc:
-        reporter.error(str(exc))
-        raise GitEnvExit(2) from None
-
-    try:
-        config = load_config(repo.primary_root)
-    except ConfigError as exc:
-        reporter.error(str(exc))
-        raise GitEnvExit(3) from None
-
-    if pattern:
-        config = type(config)(**{**config.__dict__, "patterns": tuple(pattern)})
-
-    if not force:
-        dirty = check_primary_clean(repo.primary_root, config.patterns, config.exclude)
-        if dirty:
-            reporter.error(
-                "primary worktree has uncommitted changes to tracked env files: "
-                f"{', '.join(dirty)} (use --force to override)"
-            )
-            raise GitEnvExit(2)
-
-    try:
-        result = run_sync(
-            repo,
-            config,
-            dry_run=dry_run,
-            force=force,
-            path=path,
-            reporter=reporter,
-        )
-    except SyncIOError as exc:
-        reporter.error(str(exc))
-        raise GitEnvExit(4) from None
-
-    if dry_run:
-        raise GitEnvExit(1 if result.would_change or result.conflicts else 0)
-    raise GitEnvExit(result.exit_code)
-
-
-def _rewrite_help_subcommand(argv: list[str]) -> list[str]:
-    """Translate `git env help [subcommand]` into `git env [subcommand] --help`."""
-    if argv and argv[0] == "help":
-        rest = argv[1:]
-        return [*rest, "--help"]
-    return argv
-
-
-def _reject_reserved_subcommand(argv: list[str]) -> None:
-    """Give a clearer error than argparse's "invalid choice" for reserved names."""
-    for token in argv:
-        if token == "--":
-            return
-        if token.startswith("-"):
-            continue
-        if token in RESERVED_SUBCOMMANDS:
-            print(
-                f"git env: '{token}' is reserved for future use and is not yet"
-                " implemented",
-                file=sys.stderr,
-            )
-            raise GitEnvExit(3)
-        return
-
-
-def main() -> None:
-    argv = _rewrite_help_subcommand(sys.argv[1:])
-    sys.argv = [sys.argv[0], *argv]
-    try:
-        _reject_reserved_subcommand(argv)
-        arguably.run(
-            name="git env",
-            version_flag=True,
-        )
-    except GitEnvExit as exc:
-        sys.exit(exc.code)
-    except SystemExit as exc:
-        code = exc.code if isinstance(exc.code, int) else 1
-        if code == 2:
-            sys.exit(3)
-        raise