git-alibi 0.1.0__py3-none-any.whl

git_alibi/__init__.py

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

git_alibi/backup.py

@@ -0,0 +1,133 @@
+"""Backup of original commit timestamps, organised as rewrite snapshots.
+
+The backup file lives at <git_dir>/alibi/backup.json.
+
+Each call to ``save_rewrite`` appends one snapshot — capturing the before/after
+SHA and pre-rewrite timestamps for every commit touched by that run.  Multiple
+snapshots allow restoring to any previous state via SHA chaining:
+
+  sha_after[n]  ==  sha_before[n+1]
+
+so walking backwards through snapshots traces a commit from its current SHA
+all the way back to its original timestamps.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import TypedDict
+
+import git
+
+
+class RewriteCommit(TypedDict):
+    sha_before: str  # SHA of the commit before this rewrite
+    sha_after: str  # SHA of the commit after this rewrite
+    author_date: str  # author timestamp before this rewrite
+    committer_date: str  # committer timestamp before this rewrite
+
+
+class RewriteSnapshot(TypedDict):
+    id: int
+    timestamp: str
+    commits: list[RewriteCommit]
+
+
+def backup_path(repo: git.Repo) -> Path:
+    """Return the absolute path to the backup file for this repository.
+
+    Uses repo.common_dir when available (handles git worktrees correctly —
+    all worktrees share one backup in the main .git directory).  Falls back
+    to repo.git_dir for older GitPython versions.
+    """
+    git_dir = Path(getattr(repo, "common_dir", None) or repo.git_dir)
+    return git_dir / "alibi" / "backup.json"
+
+
+def _load(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception as exc:
+        raise RuntimeError(f"Failed to read backup file {path}: {exc}") from exc
+
+
+def _write(path: Path, data: dict) -> None:
+    """Atomically write data to path (via .tmp → rename)."""
+    tmp = path.with_suffix(".json.tmp")
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp.write_text(json.dumps(data, indent=2, ensure_ascii=True), encoding="utf-8")
+        tmp.replace(path)
+    except OSError as exc:
+        raise RuntimeError(f"Cannot write backup file {path}: {exc}") from exc
+
+
+def load_rewrites(repo: git.Repo) -> list[RewriteSnapshot]:
+    """Load all rewrite snapshots from the backup file.
+
+    Raises RuntimeError if no backup file exists or the format is unrecognised.
+    """
+    path = backup_path(repo)
+    if not path.exists():
+        raise RuntimeError(
+            f"No backup file found at {path}. "
+            "Run 'alibi rewrite' (without --no-backup) at least once to create one."
+        )
+    data = _load(path)
+    if "rewrites" not in data:
+        raise RuntimeError(
+            "Backup file is in an old format and cannot be used for restore. "
+            "Run 'alibi rewrite' again to create a new backup."
+        )
+    return data.get("rewrites", [])
+
+
+def save_rewrite(repo: git.Repo, commits: list[RewriteCommit]) -> int:
+    """Append a new rewrite snapshot to the backup file and return its ID.
+
+    Each call records the before/after SHA and pre-rewrite timestamps for
+    every commit touched by one alibi rewrite run.  Returns -1 and writes
+    nothing if commits is empty.
+    """
+    if not commits:
+        return -1
+
+    path = backup_path(repo)
+    data = _load(path)
+    now = datetime.now(timezone.utc).isoformat()
+
+    if not data or "rewrites" not in data:
+        data = {"created_at": now, "updated_at": now, "rewrites": []}
+
+    next_id = (data["rewrites"][-1]["id"] + 1) if data["rewrites"] else 1
+    data["rewrites"].append(
+        {
+            "id": next_id,
+            "timestamp": now,
+            "commits": commits,
+        }
+    )
+    data["updated_at"] = now
+
+    _write(path, data)
+    return next_id
+
+
+def remove_rewrites_from(repo: git.Repo, from_id: int) -> None:
+    """Remove the snapshot with the given ID and all subsequent snapshots.
+
+    Called after a successful restore to prune stale history — snapshots
+    after the restore point no longer reflect any real repo state.
+    """
+    path = backup_path(repo)
+    data = _load(path)
+    if not data or "rewrites" not in data:
+        return
+
+    data["rewrites"] = [r for r in data["rewrites"] if r["id"] < from_id]
+    data["updated_at"] = datetime.now(timezone.utc).isoformat()
+    _write(path, data)