git-omit 0.0.1__py3-none-any.whl

git_omit/__init__.py

@@ -0,0 +1,6 @@
+try:
+    from ._version import __version__
+except ImportError:
+    __version__ = "0.0.0"
+
+__all__ = ["__version__"]

git_omit/__main__.py

@@ -0,0 +1,3 @@
+from .cli import cli
+
+raise SystemExit(cli())

git_omit/_version.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

git_omit/_version.pyi

@@ -0,0 +1 @@
+__version__: str

git_omit/cli.py

@@ -0,0 +1,188 @@
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+from git_omit import __version__
+
+
+class GitError(RuntimeError):
+    pass
+
+
+def _git(*args: str) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["git", *args],
+        check=False,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        encoding="utf-8",
+        errors="surrogateescape",
+    )
+
+
+def _git_stdout(*args: str) -> str:
+    result = _git(*args)
+    if result.returncode != 0:
+        message = result.stderr.strip() or "git command failed"
+        raise GitError(message)
+    return result.stdout.strip()
+
+
+def _git_path(path: str) -> Path:
+    value = _git_stdout("rev-parse", "--git-path", path)
+    return Path(value).resolve()
+
+
+def _exclude_path() -> Path:
+    return _git_path("info/exclude")
+
+
+def _read_lines(path: Path) -> list[str]:
+    if not path.exists():
+        return []
+    return path.read_text(encoding="utf-8").splitlines()
+
+
+def _write_lines(path: Path, lines: list[str]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    content = "\n".join(lines)
+    if content:
+        content += "\n"
+    path.write_text(content, encoding="utf-8")
+
+
+def hidden_patterns() -> list[str]:
+    return [
+        line
+        for line in _read_lines(_exclude_path())
+        if line.strip() and not line.lstrip().startswith("#")
+    ]
+
+
+def hide(patterns: list[str]) -> None:
+    path = _exclude_path()
+    lines = _read_lines(path)
+    existing = set(lines)
+    changed = False
+
+    for pattern in patterns:
+        value = pattern.strip()
+        if value and value not in existing:
+            lines.append(value)
+            existing.add(value)
+            changed = True
+
+    if changed:
+        _write_lines(path, lines)
+
+
+def unhide(patterns: list[str]) -> None:
+    targets = {pattern.strip() for pattern in patterns if pattern.strip()}
+    if not targets:
+        return
+
+    path = _exclude_path()
+    lines = _read_lines(path)
+    next_lines = [line for line in lines if line not in targets]
+    if len(next_lines) != len(lines):
+        _write_lines(path, next_lines)
+
+
+def freeze(paths: list[str]) -> None:
+    _run_update_index("--skip-worktree", paths)
+
+
+def unfreeze(paths: list[str]) -> None:
+    _run_update_index("--no-skip-worktree", paths)
+
+
+def _run_update_index(flag: str, paths: list[str]) -> None:
+    result = _git("update-index", flag, "--", *paths)
+    if result.returncode != 0:
+        message = result.stderr.strip() or "git update-index failed"
+        raise GitError(message)
+
+
+def frozen_paths() -> list[str]:
+    result = _git("ls-files", "-v", "-z")
+    if result.returncode != 0:
+        message = result.stderr.strip() or "git ls-files failed"
+        raise GitError(message)
+
+    paths: list[str] = []
+    for record in result.stdout.split("\0"):
+        if record.startswith("S "):
+            paths.append(record[2:])
+    return paths
+
+
+def list_items() -> None:
+    for pattern in hidden_patterns():
+        print(f"hide\t{pattern}")
+    for path in frozen_paths():
+        print(f"freeze\t{path}")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="git-omit",
+        description="Keep local Git noise local.",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    hide_parser = subparsers.add_parser(
+        "hide", help="Add patterns to .git/info/exclude"
+    )
+    hide_parser.add_argument("patterns", nargs="+")
+
+    unhide_parser = subparsers.add_parser(
+        "unhide", help="Remove patterns from .git/info/exclude"
+    )
+    unhide_parser.add_argument("patterns", nargs="+")
+
+    freeze_parser = subparsers.add_parser(
+        "freeze", help="Mark tracked files as skip-worktree"
+    )
+    freeze_parser.add_argument("paths", nargs="+")
+
+    unfreeze_parser = subparsers.add_parser(
+        "unfreeze", help="Clear skip-worktree from tracked files"
+    )
+    unfreeze_parser.add_argument("paths", nargs="+")
+
+    subparsers.add_parser("list", help="List hidden patterns and frozen paths")
+    return parser
+
+
+def cli(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    try:
+        match args.command:
+            case "hide":
+                hide(args.patterns)
+            case "unhide":
+                unhide(args.patterns)
+            case "freeze":
+                freeze(args.paths)
+            case "unfreeze":
+                unfreeze(args.paths)
+            case "list":
+                list_items()
+    except GitError as exc:
+        print(f"git-omit: {exc}", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(cli())

git_omit-0.0.1.dist-info/METADATA

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: git-omit
+Version: 0.0.1
+Summary: Small Git helpers for local-only ignores and tracked files you want Git to leave alone
+Author-email: Noai-oss <jiuwoxiao@outlook.com>
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# git-omit
+
+Small Git helpers for local-only ignores and tracked files you want Git to leave alone.
+
+## Local ignores
+
+| Kind | Git mechanism | Use when |
+| --- | --- | --- |
+| Untracked | `.git/info/exclude` | The file should stay local and untracked |
+| Tracked | `skip-worktree` | The file is tracked, but local changes should be left alone |
+
+## Installation
+
+```sh
+uv tool install git-omit
+# or from GitHub
+uv tool install git+https://github.com/Noai-oss/git-omit
+```
+
+## Commands
+
+| Command | Example | Effect |
+| --- | --- | --- |
+| `git-omit hide <pattern>...` | `git-omit hide '*.log'` | Add patterns to `.git/info/exclude` |
+| `git-omit unhide <pattern>...` | `git-omit unhide '*.log'` | Remove patterns from `.git/info/exclude` |
+| `git-omit freeze <path>...` | `git-omit freeze config.local.json` | Mark tracked files as `skip-worktree` |
+| `git-omit unfreeze <path>...` | `git-omit unfreeze config.local.json` | Clear `skip-worktree` |
+| `git-omit list` | `git-omit list` | Print hidden patterns and frozen paths |
+| `git-omit --version` | `git-omit --version` | Print the version |
+
+We recommend quoting glob patterns, like `'*.log'`, so your shell passes them unchanged.
+
+`git-omit list` prints tab-separated lines:
+
+```text
+hide    *.log
+freeze  config.local.json
+```

git_omit-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+git_omit/__init__.py,sha256=0VRY0I6G4MGwHEY4kTlK2iqXyv2PB7ueHrYt6WMm74k,116
+git_omit/__main__.py,sha256=TOJrcKFbI6FZfkCu5urVrBqu8GnpP45SUDpJFE4cCDE,46
+git_omit/_version.py,sha256=ry5O5SW74ugwOUMKSV2_LbWjYa8B0IEvUm7S-lHPA2c,23
+git_omit/_version.pyi,sha256=Y25n44pyE3vp92MiABKrcK3IWRyQ1JG1rZ4Ufqy2nC0,17
+git_omit/cli.py,sha256=6EyaJyyrXpu8WLW6KXm8AGxkHMSGQxFji6bNRaBhMG4,4844
+git_omit-0.0.1.dist-info/METADATA,sha256=daWGXhX2vlJ3IxhXLTQ6J_XWZBBoKwQCIKGKUFTqhaw,1544
+git_omit-0.0.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+git_omit-0.0.1.dist-info/entry_points.txt,sha256=RmtMe53O3dY7j0Uq2sJi-PcuJlvJSlULm2mYn5w5Zuw,46
+git_omit-0.0.1.dist-info/RECORD,,

git_omit-0.0.1.dist-info/WHEEL

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

git_omit-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+git-omit = git_omit.cli:cli