tinyhorse 0.2.2__tar.gz → 0.2.4__tar.gz

{tinyhorse-0.2.2/src/tinyhorse.egg-info → tinyhorse-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinyhorse
-Version: 0.2.2
+Version: 0.2.4
 Summary: Git-native project control for local and user-owned infrastructure
 Author: Tiny Horse contributors
 License-Expression: Apache-2.0
@@ -36,6 +36,10 @@ tinyhorse doctor
 
 # Recover on another machine.
 tinyhorse pull file:/srv/git/my-project.bundle ./my-project
+
+# Propose without moving canonical main; accept fast-forwards then parks.
+tinyhorse propose --id my-change
+tinyhorse accept my-change
 ```
 
 ## Google Drive login

{tinyhorse-0.2.2 → tinyhorse-0.2.4}/README.md

@@ -18,6 +18,10 @@ tinyhorse doctor
 
 # Recover on another machine.
 tinyhorse pull file:/srv/git/my-project.bundle ./my-project
+
+# Propose without moving canonical main; accept fast-forwards then parks.
+tinyhorse propose --id my-change
+tinyhorse accept my-change
 ```
 
 ## Google Drive login

{tinyhorse-0.2.2 → tinyhorse-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tinyhorse"
-version = "0.2.2"
+version = "0.2.4"
 description = "Git-native project control for local and user-owned infrastructure"
 readme = "README.md"
 requires-python = ">=3.10"

{tinyhorse-0.2.2 → tinyhorse-0.2.4}/src/tinyhorse/__init__.py

@@ -1,3 +1,3 @@
 """Tiny Horse: Git-native project control."""
 
-__version__ = "0.2.2"
+__version__ = "0.2.4"

{tinyhorse-0.2.2 → tinyhorse-0.2.4}/src/tinyhorse/cli.py

@@ -12,6 +12,7 @@ from .git import GitError, create_bundle, repository_state, verify_bundle
 from .storage import StorageError
 from .workflow import (
     WorkflowError,
+    accept,
     clone_project,
     doctor,
     freeze_writer,
@@ -21,6 +22,7 @@ from .workflow import (
     init_project,
     migrate_remote,
     projects,
+    propose,
     pull,
     push,
     tag_project,
@@ -146,6 +148,20 @@ def _parser() -> argparse.ArgumentParser:
     park.add_argument("path", nargs="?", default=".", help="git checkout (default: .)")
     park.add_argument("--force", action="store_true", help=force_help)
 
+    propose_cmd = sub.add_parser(
+        "propose",
+        help="publish refs/tinyhorse/propose/<id> without moving canonical main",
+    )
+    propose_cmd.add_argument("path", nargs="?", default=".", help="git checkout (default: .)")
+    propose_cmd.add_argument("--id", dest="proposal_id", help="proposal id (default: random)")
+
+    accept_cmd = sub.add_parser(
+        "accept",
+        help="fast-forward main to a proposal ref, then park",
+    )
+    accept_cmd.add_argument("proposal_id", help="id under refs/tinyhorse/propose/")
+    accept_cmd.add_argument("path", nargs="?", default=".", help="git checkout (default: .)")
+
     claim = sub.add_parser(
         "claim",
         help="tiny: restore a Drive project by name (same as clone)",
@@ -274,6 +290,10 @@ def main(argv: list[str] | None = None) -> int:
                 print(init_project(args.path, args.storage, args.project))
         elif args.command in ("push", "park"):
             print(push(args.path, force=args.force).to_json())
+        elif args.command == "propose":
+            print(propose(args.path, proposal_id=args.proposal_id).to_json())
+        elif args.command == "accept":
+            print(accept(args.path, proposal_id=args.proposal_id).to_json())
         elif args.command == "pull":
             print(pull(args.storage, args.destination).to_json())
         elif args.command == "doctor":

{tinyhorse-0.2.2 → tinyhorse-0.2.4}/src/tinyhorse/git.py

@@ -23,6 +23,7 @@ DURABLE_REF_PREFIXES = (
 )
 CACHE_REF_PREFIXES = ("refs/remotes/", "refs/pull/")
 WIP_REF_PREFIX = "refs/tinyhorse/wip/"
+PROPOSE_REF_PREFIX = "refs/tinyhorse/propose/"
 STASH_REF = "refs/stash"
 SEQUENCER_FILES = ("REBASE_HEAD", "MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD")
 SEQUENCER_DIRS = ("rebase-merge", "rebase-apply")

{tinyhorse-0.2.2 → tinyhorse-0.2.4}/src/tinyhorse/mcp.py

@@ -61,6 +61,29 @@ TOOLS = [
             "properties": {"path": {"type": "string"}},
         },
     },
+    {
+        "name": "propose",
+        "description": "Publish a proposal ref without moving canonical main.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string"},
+                "proposal_id": {"type": "string"},
+            },
+        },
+    },
+    {
+        "name": "accept",
+        "description": "Fast-forward main to a proposal and park.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string"},
+                "proposal_id": {"type": "string"},
+            },
+            "required": ["proposal_id"],
+        },
+    },
     {
         "name": "tag",
         "description": "Annotated git tag on this project, then park (tinyhorse tag).",
@@ -78,7 +101,7 @@ TOOLS = [
 
 HELP = """tinyhorse-mcp — stdio JSON-RPC 2.0 for Tiny Horse
 
-Tools: park, claim, doctor, from_zip, status, tag
+Tools: park, claim, doctor, from_zip, status, propose, accept, tag
 
 This process reads JSON-RPC from stdin. If you ran it in a terminal by
 mistake, this help is the intended output. Example:
@@ -123,6 +146,14 @@ def _handle(name: str, arguments: dict[str, Any]) -> dict[str, Any]:
         code, text = _run_cli(argv)
     elif name == "status":
         code, text = _run_cli(["status", arguments.get("path") or "."])
+    elif name == "propose":
+        argv = ["propose", arguments.get("path") or "."]
+        if arguments.get("proposal_id"):
+            argv.extend(["--id", arguments["proposal_id"]])
+        code, text = _run_cli(argv)
+    elif name == "accept":
+        argv = ["accept", arguments["proposal_id"], arguments.get("path") or "."]
+        code, text = _run_cli(argv)
     elif name == "tag":
         argv = ["tag", arguments["name"]]
         if arguments.get("path"):

{tinyhorse-0.2.2 → tinyhorse-0.2.4}/src/tinyhorse/storage.py

@@ -5,6 +5,7 @@ import json
 import mimetypes
 import os
 import shutil
+import time
 import urllib.error
 import urllib.parse
 import urllib.request
@@ -263,6 +264,22 @@ class GoogleDriveStorage:
         return self._v2_snapshot(meta["id"])
 
     def get(self, destination: str | Path) -> StorageObject:
+        # Drive sometimes moves the etag between the snapshot and the confirm
+        # even when the bytes still match. Retry that flap inside this read.
+        # A real content change still fails the md5 check or the later If-Match.
+        last: StorageConflictError | None = None
+        for attempt in range(3):
+            try:
+                return self._get_once(destination)
+            except StorageConflictError as exc:
+                last = exc
+                if "changed while downloading" not in str(exc) or attempt == 2:
+                    raise
+                time.sleep(0.2 * (attempt + 1))
+        assert last is not None
+        raise last
+
+    def _get_once(self, destination: str | Path) -> StorageObject:
         meta = self._find()
         if meta is None:
             raise StorageNotFoundError(f"storage object not found: {self.locator}")

{tinyhorse-0.2.2 → tinyhorse-0.2.4}/src/tinyhorse/workflow.py

@@ -5,6 +5,7 @@ import os
 import shutil
 import subprocess
 import tempfile
+import time
 import urllib.parse
 import uuid
 from dataclasses import asdict, dataclass
@@ -13,15 +14,18 @@ from pathlib import Path
 from .config import CONFIG_NAME, load_config, write_config
 from .git import (
     GitError,
+    PROPOSE_REF_PREFIX,
     bundle_head,
     create_bundle,
     durable_bundle_refs,
     durable_repository_refs,
+    park_wip,
     repository_state,
     restore_working_tree,
     sha256_file,
     verify_bundle,
 )
+from .git import _bundle_fetch_refspecs
 from .storage import (
     StorageConflictError,
     StorageError,
@@ -484,7 +488,25 @@ def push(repo: str | Path = ".", *, force: bool = False) -> SyncResult:
     tags/other durable refs, and refuse when canonical HEAD is ahead or divergent.
     ``force`` permits an intentional history rewrite/ref deletion, but storage must
     still be unchanged since the preflight read.
+
+    A preflight conflict (the download etag moved, or If-Match lost the race)
+    is retried inside this call. Readback mismatches are not retried: those
+    mean the write may already have landed.
     """
+    last: WorkflowError | None = None
+    for attempt in range(3):
+        try:
+            return _push_once(repo, force=force)
+        except WorkflowError as exc:
+            last = exc
+            if "during preflight" not in str(exc) or attempt == 2:
+                raise
+            time.sleep(0.5 * (attempt + 1))
+    assert last is not None
+    raise last
+
+
+def _push_once(repo: str | Path = ".", *, force: bool = False) -> SyncResult:
     if writer_frozen(repo) and not force:
         raise WorkflowError(
             "writer is frozen for this checkout (tinyhorse freeze-writer); "
@@ -564,6 +586,144 @@ def push(repo: str | Path = ".", *, force: bool = False) -> SyncResult:
     )
 
 
+def propose(repo: str | Path = ".", *, proposal_id: str | None = None) -> SyncResult:
+    """Publish refs/tinyhorse/propose/<id> without moving canonical main."""
+    if writer_frozen(repo):
+        raise WorkflowError(
+            "writer is frozen for this checkout (tinyhorse freeze-writer); "
+            "remove .git/tinyhorse-freeze before propose"
+        )
+    config = load_config(repo)
+    state = repository_state(repo)
+    backend = backend_for(config.storage)
+    proposal_id = (proposal_id or uuid.uuid4().hex[:12]).strip()
+    if not proposal_id or "/" in proposal_id or ".." in proposal_id:
+        raise WorkflowError("proposal_id must be a single path segment")
+    propose_ref = f"{PROPOSE_REF_PREFIX}{proposal_id}"
+    park_wip(state.root)
+    _git(["-C", str(state.root), "update-ref", propose_ref, state.head])
+
+    with tempfile.TemporaryDirectory(prefix="tinyhorse-propose-") as td:
+        td_path = Path(td)
+        canonical_bundle = td_path / "canonical.bundle"
+        staging = td_path / "staging.git"
+        out_bundle = td_path / "out.bundle"
+        verify_after = td_path / "after.bundle"
+        try:
+            expected = backend.get(canonical_bundle)
+        except StorageNotFoundError as exc:
+            raise WorkflowError("propose requires an existing canonical; park once first") from exc
+        verify_bundle(canonical_bundle)
+        canonical_head = bundle_head(canonical_bundle)
+
+        _git(["init", "--bare", str(staging)])
+        specs = _bundle_fetch_refspecs(canonical_bundle)
+        _git(
+            [
+                "-C",
+                str(staging),
+                "fetch",
+                "--quiet",
+                "--prune",
+                "--no-tags",
+                str(canonical_bundle),
+                *specs,
+            ]
+        )
+        _git(
+            [
+                "-C",
+                str(staging),
+                "fetch",
+                "--quiet",
+                str(state.root),
+                f"+{propose_ref}:{propose_ref}",
+            ]
+        )
+        try:
+            _git(
+                [
+                    "-C",
+                    str(staging),
+                    "fetch",
+                    "--quiet",
+                    str(state.root),
+                    "+refs/tinyhorse/wip/*:refs/tinyhorse/wip/*",
+                ]
+            )
+        except WorkflowError:
+            pass
+        _git(["-C", str(staging), "symbolic-ref", "HEAD", "refs/heads/main"])
+        refs = _git(
+            [
+                "-C",
+                str(staging),
+                "for-each-ref",
+                "--format=%(refname)",
+                "refs/heads",
+                "refs/tags",
+                "refs/tinyhorse",
+            ]
+        ).splitlines()
+        revisions = ["HEAD", *[ref for ref in refs if ref]]
+        _git(["-C", str(staging), "bundle", "create", str(out_bundle), *revisions])
+        verify_bundle(out_bundle)
+        if bundle_head(out_bundle) != canonical_head:
+            raise WorkflowError("propose would move canonical HEAD; aborted without writing storage")
+        local_digest = sha256_file(out_bundle)
+        try:
+            obj = backend.put_if_unchanged(out_bundle, expected)
+        except StorageConflictError as exc:
+            raise WorkflowError(
+                "propose aborted because canonical storage changed during preflight"
+            ) from exc
+        after_obj = backend.get(verify_after)
+        if sha256_file(verify_after) != local_digest:
+            raise WorkflowError("canonical readback bytes do not match the uploaded proposal bundle")
+        verify_bundle(verify_after)
+        after_head = bundle_head(verify_after)
+        if after_head != canonical_head:
+            raise WorkflowError("propose moved canonical HEAD; run tinyhorse doctor")
+
+    return SyncResult(
+        action="propose",
+        storage=config.storage,
+        local_head=state.head,
+        canonical_head=after_head,
+        canonical_modified_time=after_obj.modified_time or obj.modified_time,
+        canonical_size=after_obj.size if after_obj.size is not None else obj.size,
+    )
+
+
+def accept(repo: str | Path = ".", proposal_id: str | None = None) -> SyncResult:
+    """Fast-forward local main to a proposal ref, then park (moves canonical main)."""
+    if not proposal_id:
+        raise WorkflowError("accept requires a proposal_id")
+    if writer_frozen(repo):
+        raise WorkflowError(
+            "writer is frozen for this checkout (tinyhorse freeze-writer); "
+            "unfreeze before accept"
+        )
+    config = load_config(repo)
+    state = repository_state(repo)
+    backend = backend_for(config.storage)
+    propose_ref = f"{PROPOSE_REF_PREFIX}{proposal_id.strip()}"
+    with tempfile.TemporaryDirectory(prefix="tinyhorse-accept-") as td:
+        canonical_bundle = Path(td) / "canonical.bundle"
+        try:
+            backend.get(canonical_bundle)
+        except StorageNotFoundError as exc:
+            raise WorkflowError("accept requires an existing canonical") from exc
+        verify_bundle(canonical_bundle)
+        refs = durable_bundle_refs(canonical_bundle)
+        oid = refs.get(propose_ref)
+        if not oid:
+            raise WorkflowError(f"no such proposal: {propose_ref}")
+        _git(["-C", str(state.root), "fetch", "--quiet", str(canonical_bundle), f"+{propose_ref}:{propose_ref}"])
+        _git(["-C", str(state.root), "merge", "--ff-only", oid])
+    return push(repo)
+
+
 def _head_branch(heads: dict[str, str]) -> str | None:
     head = heads.get("HEAD")
     if head is None:

{tinyhorse-0.2.2 → tinyhorse-0.2.4/src/tinyhorse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinyhorse
-Version: 0.2.2
+Version: 0.2.4
 Summary: Git-native project control for local and user-owned infrastructure
 Author: Tiny Horse contributors
 License-Expression: Apache-2.0
@@ -36,6 +36,10 @@ tinyhorse doctor
 
 # Recover on another machine.
 tinyhorse pull file:/srv/git/my-project.bundle ./my-project
+
+# Propose without moving canonical main; accept fast-forwards then parks.
+tinyhorse propose --id my-change
+tinyhorse accept my-change
 ```
 
 ## Google Drive login

{tinyhorse-0.2.2 → tinyhorse-0.2.4}/tests/test_release_tool.py

@@ -24,7 +24,7 @@ class ReleaseToolTests(unittest.TestCase):
         pyproject_version, init_version = release.package_version(ROOT)
         self.assertEqual(pyproject_version, init_version)
         self.assertEqual(pyproject_version, __version__)
-        self.assertEqual(pyproject_version, "0.2.2")
+        self.assertEqual(pyproject_version, "0.2.4")
 
     def test_manifest_includes_release_tooling(self):
         manifest = (ROOT / "MANIFEST.in").read_text(encoding="utf-8")

{tinyhorse-0.2.2 → tinyhorse-0.2.4}/tests/test_storage.py

@@ -1,3 +1,4 @@
+import hashlib
 import json
 import os
 import tempfile
@@ -430,6 +431,72 @@ class StorageConflictTests(unittest.TestCase):
                     storage.put_if_unchanged(source, expected)
         self.assertIn("snapshot ETag", str(ctx.exception))
 
+    def test_google_drive_get_retries_when_etag_moves_during_download(self):
+        from tinyhorse.storage import StorageConflictError
+
+        content = b"bundle-bytes"
+        digest = hashlib.md5(content).hexdigest()
+        storage = GoogleDriveStorage("gdrive://folder/project.bundle", token="token")
+        listed = {
+            "id": "same-id",
+            "name": "project.bundle",
+            "size": str(len(content)),
+            "parents": ["folder"],
+        }
+
+        def snap(etag, version):
+            return {
+                "id": "same-id",
+                "title": "project.bundle",
+                "etag": etag,
+                "version": version,
+                "md5Checksum": digest,
+                "fileSize": str(len(content)),
+                "modifiedDate": "2026-09-22T00:00:00.000Z",
+                "parents": [{"id": "folder"}],
+            }
+
+        # First read: confirm etag moved. Second read: snapshot and confirm agree.
+        v2 = [
+            snap('"e1"', "10"),
+            snap('"e2"', "11"),
+            snap('"e2"', "11"),
+            snap('"e2"', "11"),
+        ]
+
+        def fake_request(url, *, method="GET", data=None, content_type=None, extra_headers=None, response_headers=None):
+            if "alt=media" in url:
+                return content
+            if "/drive/v2/files/" in url:
+                return json.dumps(v2.pop(0)).encode()
+            return json.dumps({"files": [listed]}).encode()
+
+        with tempfile.TemporaryDirectory() as td:
+            dest = Path(td) / "got.bundle"
+            with patch.object(storage, "_request", side_effect=fake_request):
+                with patch("tinyhorse.storage.time.sleep"):
+                    result = storage.get(dest)
+            self.assertEqual(dest.read_bytes(), content)
+            self.assertEqual(result.etag, '"e2"')
+            self.assertEqual(v2, [])
+
+        storage = GoogleDriveStorage("gdrive://folder/project.bundle", token="token")
+        flapping = [snap('"a"', "1"), snap('"b"', "2")] * 3
+
+        def always_flap(url, *, method="GET", data=None, content_type=None, extra_headers=None, response_headers=None):
+            if "alt=media" in url:
+                return content
+            if "/drive/v2/files/" in url:
+                return json.dumps(flapping.pop(0)).encode()
+            return json.dumps({"files": [listed]}).encode()
+
+        with tempfile.TemporaryDirectory() as td:
+            dest = Path(td) / "got.bundle"
+            with patch.object(storage, "_request", side_effect=always_flap):
+                with patch("tinyhorse.storage.time.sleep"):
+                    with self.assertRaises(StorageConflictError):
+                        storage.get(dest)
+
     def test_drive_http_412_is_storage_conflict(self):
         from tinyhorse.storage import StorageConflictError, _drive_request
 

{tinyhorse-0.2.2 → tinyhorse-0.2.4}/tests/test_workflow.py

@@ -8,7 +8,8 @@ from pathlib import Path
 from unittest.mock import patch
 
 from tinyhorse.git import repository_state
-from tinyhorse.workflow import WorkflowError, doctor, init_project, pull, push
+from tinyhorse.git import durable_bundle_refs
+from tinyhorse.workflow import WorkflowError, accept, doctor, init_project, propose, pull, push
 
 
 def git_env(home: Path) -> dict[str, str]:
@@ -99,6 +100,32 @@ class WorkflowTests(unittest.TestCase):
             self.assertFalse(health.ok)
             self.assertEqual(health.relation, "local_ahead")
 
+    def test_propose_does_not_move_canonical_main(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            repo = make_repo(root / "repo")
+            bundle = root / "repo.bundle"
+            init_project(repo, bundle.as_uri())
+            subprocess.run(["git", "add", ".tinyhorse.toml"], cwd=repo, check=True)
+            subprocess.run(["git", "commit", "-m", "config"], cwd=repo, check=True, stdout=subprocess.PIPE)
+            first = push(repo)
+            (repo / "idea.txt").write_text("proposal\n")
+            subprocess.run(["git", "add", "idea.txt"], cwd=repo, check=True)
+            subprocess.run(["git", "commit", "-m", "proposal"], cwd=repo, check=True, stdout=subprocess.PIPE)
+            local_head = subprocess.run(
+                ["git", "rev-parse", "HEAD"], cwd=repo, check=True, text=True, stdout=subprocess.PIPE
+            ).stdout.strip()
+            proposed = propose(repo, proposal_id="abc123")
+            self.assertEqual(proposed.action, "propose")
+            self.assertEqual(proposed.canonical_head, first.canonical_head)
+            self.assertNotEqual(local_head, first.canonical_head)
+            refs = durable_bundle_refs(bundle)
+            self.assertEqual(refs["HEAD"], first.canonical_head)
+            self.assertEqual(refs["refs/tinyhorse/propose/abc123"], local_head)
+            accepted = accept(repo, proposal_id="abc123")
+            self.assertEqual(accepted.canonical_head, local_head)
+            self.assertEqual(durable_bundle_refs(bundle)["HEAD"], local_head)
+
 
 if __name__ == "__main__":
     unittest.main()