git-restore-filemode 0.1.0__py3-none-any.whl

git_restore_filemode/__init__.py

@@ -0,0 +1,4 @@
+"""Python launcher package for git-restore-filemode."""
+
+__all__ = ["__version__"]
+__version__ = "0.1.0"

git_restore_filemode/__main__.py

@@ -0,0 +1,14 @@
+import subprocess
+import sys
+
+from .installer import ensure_executable
+
+
+def main() -> int:
+    executable = ensure_executable()
+    completed = subprocess.run([str(executable), *sys.argv[1:]], check=False)
+    return completed.returncode
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

git_restore_filemode/installer.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import subprocess
+import tarfile
+import tempfile
+import urllib.error
+import urllib.request
+from importlib import metadata
+from pathlib import Path
+
+from . import __version__
+
+BINARY_NAME = "git-restore-filemode"
+REPO_OWNER = os.environ.get("GIT_RESTORE_FILEMODE_REPO_OWNER", "yonathan-ashebir")
+REPO_NAME = os.environ.get("GIT_RESTORE_FILEMODE_REPO_NAME", "git-restore-filemode")
+REPO_URL = f"https://github.com/{REPO_OWNER}/{REPO_NAME}"
+
+
+def ensure_executable() -> Path:
+    target = os.environ.get("GIT_RESTORE_FILEMODE_TARGET") or detect_target()
+    release = release_version()
+    executable = cache_path(release, target)
+
+    if executable.exists():
+        return executable
+
+    executable.parent.mkdir(parents=True, exist_ok=True)
+    if not install_from_release(executable, release, target):
+        install_from_cargo(executable, release, target)
+    executable.chmod(0o755)
+    return executable
+
+
+def release_version() -> str:
+    override = os.environ.get("GIT_RESTORE_FILEMODE_VERSION")
+    if override:
+        return override
+
+    try:
+        package_version = metadata.version("git-restore-filemode")
+    except metadata.PackageNotFoundError:
+        package_version = __version__
+
+    return f"v{package_version}"
+
+
+def cache_path(release: str, target: str) -> Path:
+    cache_root = os.environ.get("GIT_RESTORE_FILEMODE_CACHE_DIR")
+    if cache_root:
+        root = Path(cache_root)
+    elif platform.system() == "Windows":
+        root = Path(os.environ.get("LOCALAPPDATA", Path.home() / "AppData" / "Local"))
+        root /= "git-restore-filemode"
+    elif platform.system() == "Darwin":
+        root = Path.home() / "Library" / "Caches" / "git-restore-filemode"
+    else:
+        root = Path(os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache"))
+        root /= "git-restore-filemode"
+
+    return root / release / target / executable_name(target)
+
+
+def detect_target() -> str:
+    system = platform.system()
+    machine = platform.machine().lower()
+
+    arch = {
+        "x86_64": "x86_64",
+        "amd64": "x86_64",
+        "aarch64": "aarch64",
+        "arm64": "aarch64",
+    }.get(machine)
+
+    if not arch:
+        raise RuntimeError(f"unsupported CPU architecture: {platform.machine()}")
+
+    if system == "Linux":
+        return f"{arch}-unknown-linux"
+    if system == "Darwin":
+        return f"{arch}-apple-darwin"
+    if system == "Windows":
+        return f"{arch}-pc-windows-msvc"
+
+    raise RuntimeError(f"unsupported operating system: {system}")
+
+
+def executable_name(target: str) -> str:
+    return f"{BINARY_NAME}.exe" if "windows" in target or "-pc-" in target else BINARY_NAME
+
+
+def rust_target_for_platform(target: str) -> str:
+    if target == "x86_64-unknown-linux":
+        return "x86_64-unknown-linux-musl"
+    if target == "aarch64-unknown-linux":
+        return "aarch64-unknown-linux-musl"
+    return target
+
+
+def install_from_release(destination: Path, release: str, target: str) -> bool:
+    asset = f"{BINARY_NAME}-{target}.tar.gz"
+    if release == "latest":
+        url = f"{REPO_URL}/releases/latest/download/{asset}"
+    else:
+        url = f"{REPO_URL}/releases/download/{release}/{asset}"
+
+    with tempfile.TemporaryDirectory() as tmp:
+        archive = Path(tmp) / asset
+        try:
+            download(url, archive)
+            extract_binary(archive, destination)
+            return True
+        except (OSError, RuntimeError, tarfile.TarError, urllib.error.URLError):
+            return False
+
+
+def download(url: str, destination: Path) -> None:
+    request = urllib.request.Request(url)
+    token = os.environ.get("GITHUB_TOKEN")
+    if token:
+        request.add_header("Authorization", f"Bearer {token}")
+
+    with urllib.request.urlopen(request, timeout=60) as response:
+        with destination.open("wb") as output:
+            shutil.copyfileobj(response, output)
+
+
+def extract_binary(archive: Path, destination: Path) -> None:
+    expected_names = {BINARY_NAME, f"{BINARY_NAME}.exe"}
+    with tarfile.open(archive, "r:gz") as tar:
+        for member in tar.getmembers():
+            if Path(member.name).name not in expected_names or not member.isfile():
+                continue
+
+            source = tar.extractfile(member)
+            if source is None:
+                continue
+
+            with source:
+                with destination.open("wb") as output:
+                    shutil.copyfileobj(source, output)
+            return
+
+    raise RuntimeError(f"{archive} did not contain {BINARY_NAME}")
+
+
+def install_from_cargo(destination: Path, release: str, target: str) -> None:
+    cargo = shutil.which("cargo")
+    rustc = shutil.which("rustc")
+    if not cargo or not rustc:
+        raise RuntimeError(
+            "no matching release asset was available, and Rust/Cargo was not found"
+        )
+
+    with tempfile.TemporaryDirectory() as tmp:
+        cargo_root = Path(tmp) / "cargo-root"
+        rust_target = rust_target_for_platform(target)
+        rustup = shutil.which("rustup")
+        if rustup:
+            subprocess.run([rustup, "target", "add", rust_target], check=True)
+
+        args = [
+            cargo,
+            "install",
+            "--locked",
+            "--git",
+            REPO_URL,
+            "--target",
+            rust_target,
+            "--bin",
+            BINARY_NAME,
+            "--root",
+            str(cargo_root),
+        ]
+        if release != "latest":
+            args.insert(5, release)
+            args.insert(5, "--tag")
+
+        subprocess.run(args, check=True)
+
+        built = cargo_root / "bin" / executable_name(target)
+        if not built.exists():
+            built = cargo_root / "bin" / rust_target / executable_name(target)
+        if not built.exists():
+            raise RuntimeError(f"cargo install did not produce {built}")
+
+        shutil.copy2(built, destination)

git_restore_filemode-0.1.0.dist-info/METADATA

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: git-restore-filemode
+Version: 0.1.0
+Summary: Restore Git-tracked executable file modes without restoring file contents.
+Author: Yonathan Ashebir
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yonathan-ashebir/git-restore-filemode
+Project-URL: Repository, https://github.com/yonathan-ashebir/git-restore-filemode
+Project-URL: Issues, https://github.com/yonathan-ashebir/git-restore-filemode/issues
+Keywords: git,filemode,chmod,restore
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# git-restore-filemode
+
+`git-restore-filemode` is a simple Git extension command that restores only Git's
+tracked executable bit for regular files. It follows the destination/source
+defaults of `git restore`, but it never restores file contents.
+
+```sh
+curl -fsSL https://raw.githubusercontent.com/yonathan-ashebir/git-restore-filemode/main/install.sh | bash
+```
+
+## Examples
+
+Restore working tree file modes from the index:
+
+```sh
+git restore-filemode -- script.sh
+```
+
+Restore staged file modes from `HEAD`:
+
+```sh
+git restore-filemode --staged -- script.sh
+```
+
+Restore both the index and working tree from a specific commit:
+
+```sh
+git restore-filemode --source=HEAD~1 --staged --worktree -- bin/
+```
+
+## Supported options
+
+- `-s`, `--source <tree-ish>`: restore file modes from a tree-ish.
+- `-S`, `--staged`: restore the index.
+- `-W`, `--worktree`: restore the working tree.
+- `--ignore-unmerged`: skip unmerged index entries when restoring from the index.
+- `--pathspec-from-file <file>`: read pathspecs from a file, or `-` for stdin.
+- `--pathspec-file-nul`: split `--pathspec-from-file` input on NUL bytes.
+- `-q`, `--quiet`: suppress non-fatal messages.
+
+Default source selection matches `git restore`:
+
+- Working tree restore defaults to the index.
+- Staged restore defaults to `HEAD`.
+- `--source` overrides the default source.
+
+## Install
+
+### Bash script
+
+```sh
+curl -fsSL https://raw.githubusercontent.com/yonathan-ashebir/git-restore-filemode/main/install.sh | bash
+```
+
+Attempts system dependent global (system) installation path, falling back to user. Accepts --user and --system flags to force use either. Downloads compatible binary when available, building from source otherwise (requires cargo/rust)
+
+### Python
+
+```sh
+uv tool install git-restore-filemode
+pip install --user git-restore-filemode
+```
+
+The Python package installs a small launcher named `git-restore-filemode`. On
+first run it downloads the matching release executable into a per-user cache, or
+falls back to Cargo when Rust is installed.
+
+### Node
+
+```sh
+npm install -g git-restore-filemode
+pnpm add -g git-restore-filemode
+bun install -g git-restore-filemode
+```
+
+The npm package follows the same release-download-first behavior and keeps the
+native executable inside the installed package.
+
+### Cargo
+
+```sh
+cargo install --path .
+```
+
+After this package is published to crates.io, the direct install command will
+be:
+
+```sh
+cargo install git-restore-filemode
+```
+
+## Notes
+
+Only regular Git blobs with modes `100644` and `100755` are restorable. Symlinks,
+submodules, missing working tree files, and non-regular paths are not changed.
+
+Registry metadata for PyPI and npm is included, but publishing those packages is
+intentionally left for a later release step.
+
+## Release Targets
+
+- Linux x64 static: `x86_64-unknown-linux`
+- Linux ARM64 static: `aarch64-unknown-linux`
+- macOS Intel: `x86_64-apple-darwin`
+- macOS Apple Silicon: `aarch64-apple-darwin`
+- Windows x64: `x86_64-pc-windows-msvc`
+- Windows ARM64: `aarch64-pc-windows-msvc`

git_restore_filemode-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+git_restore_filemode/__init__.py,sha256=veWvzJ6mcfvl2Kj2wGq_BpVGisq4_phKkK7KSUIG6UM,105
+git_restore_filemode/__main__.py,sha256=ILEPRrsQhCIpDvYfmjzpxM23aDnY3ZBQ2iE7rsSNO70,297
+git_restore_filemode/installer.py,sha256=iNYxrtEsrXMVriagafFvE3Q5rPqST1iw0SwLtSeK8fk,5898
+git_restore_filemode-0.1.0.dist-info/licenses/LICENSE,sha256=XYV2E81xnZ0ACyZ2Z3CYavh2c9aypUN8jNOYqjhReaM,1073
+git_restore_filemode-0.1.0.dist-info/METADATA,sha256=vFy_g0j1AZPXKfHJmyVDFx93zgiKH5wrVMVfw0UYYKw,3899
+git_restore_filemode-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+git_restore_filemode-0.1.0.dist-info/entry_points.txt,sha256=0_ZNNyEic8LcqVbQowft6-_0EQmX4UYokOkGGvtS5ok,76
+git_restore_filemode-0.1.0.dist-info/top_level.txt,sha256=YtWCGYOgQtIA-bQiYIcu_vhpRgMFO2erWIHhp0P9CV8,21
+git_restore_filemode-0.1.0.dist-info/RECORD,,

git_restore_filemode-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

git_restore_filemode-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+git-restore-filemode = git_restore_filemode.__main__:main

git_restore_filemode-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yonathan Ashebir
+
+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_restore_filemode-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+git_restore_filemode