mooring 0.2.3__tar.gz → 0.2.4__tar.gz

{mooring-0.2.3 → mooring-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mooring
-Version: 0.2.3
+Version: 0.2.4
 Summary: Git-free marimo notebook sharing via GitHub
 Requires-Python: <3.13,>=3.12
 Requires-Dist: altair

{mooring-0.2.3 → mooring-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mooring"
-version = "0.2.3"
+version = "0.2.4"
 description = "Git-free marimo notebook sharing via GitHub"
 readme = "README.md"
 requires-python = ">=3.12,<3.13"

{mooring-0.2.3 → mooring-0.2.4}/src/mooring/__init__.py

@@ -1,3 +1,3 @@
 """Mooring: git-free marimo notebook sharing via GitHub."""
 
-__version__ = "0.2.3"
+__version__ = "0.2.4"

{mooring-0.2.3 → mooring-0.2.4}/src/mooring/auth.py

@@ -40,6 +40,26 @@ class AuthError(Exception):
     pass
 
 
+def device_flow_hint(host: str, exc: Exception) -> str:
+    """A friendly one-line explanation for a failed device-code request.
+
+    Names the host (and HTTP status, if any) so a misrouted login is obvious,
+    and only suggests setting a host when the request went to the default
+    github.com — a real GHE host that 404s has a different cause (device flow
+    disabled, or a client_id from the wrong instance).
+    """
+    status = getattr(getattr(exc, "response", None), "status_code", None)
+    head = f"Couldn't start GitHub login against {host}"
+    head += f" (HTTP {status})." if status else f": {exc}"
+    if host == githost.DEFAULT_HOST:
+        head += (
+            " If this repo is on GitHub Enterprise, set its host: run "
+            '`mooring login --host ghe.example.com`, or add `host = "ghe.example.com"` '
+            "under [github] in your config."
+        )
+    return head
+
+
 @dataclass
 class DeviceCode:
     device_code: str

{mooring-0.2.3 → mooring-0.2.4}/src/mooring/cli.py

@@ -73,7 +73,13 @@ def _build_parser() -> argparse.ArgumentParser:
     hub.add_argument("--no-browser", action="store_true", help="don't open a browser tab")
     hub.add_argument("--port", type=int, default=None, help="fixed port for the hub server")
 
-    sub.add_parser("login", help="log in to GitHub via device flow")
+    login = sub.add_parser("login", help="log in to GitHub via device flow")
+    login.add_argument(
+        "--host",
+        default=None,
+        help="GitHub host or URL for GitHub Enterprise (e.g. ghe.example.com); "
+        "saved as the global host before logging in",
+    )
     sub.add_parser("logout", help="forget the stored GitHub token")
     sub.add_parser("whoami", help="show the logged-in GitHub user")
     status = sub.add_parser("status", help="show sync status of workspace files")
@@ -98,7 +104,10 @@ def _build_parser() -> argparse.ArgumentParser:
     repo_use = repo_sub.add_parser("use", help="switch the active repo")
     repo_use.add_argument("alias")
     repo_rm = repo_sub.add_parser("remove", help="forget a repo (local files are kept)")
-    repo_rm.add_argument("alias")
+    repo_rm.add_argument("alias", nargs="?", default=None, help="alias to remove (omit when using --all)")
+    repo_rm.add_argument(
+        "--all", dest="all_repos", action="store_true", help="remove every registered repo"
+    )
 
     pull = sub.add_parser("pull", help="download changes from the team repo")
     pull_grp = pull.add_mutually_exclusive_group()
@@ -143,8 +152,8 @@ def _print_paths(cfg: config.Config) -> None:
     print(f"  config file : {paths.user_config_file()}")
     print(f"  workspace   : {cfg.workspace()}")
     print(f"  logs        : {paths.user_log_dir()}")
-    hint = legacy_workspace_hint(cfg)
-    if hint:
+    hints = (legacy_workspace_hint(cfg), paths.synced_folder_hint(cfg.workspace()))
+    for hint in (h for h in hints if h):
         print(f"  note        : {hint}")
 
 
@@ -162,6 +171,13 @@ def legacy_workspace_hint(cfg: config.Config) -> str:
     return ""
 
 
+def workspace_hint(cfg: config.Config) -> str:
+    """Combined workspace warnings (legacy location + cloud-sync folder) for the
+    hub and selftest, joined into one line."""
+    hints = (legacy_workspace_hint(cfg), paths.synced_folder_hint(cfg.workspace()))
+    return "  ".join(h for h in hints if h)
+
+
 def cmd_selftest(app_cfg: config.AppConfig, cfg: config.Config) -> int:
     import importlib.metadata
 
@@ -220,15 +236,28 @@ def _client(cfg: config.Config):
     return GitHubClient(_require_token(cfg), cfg.owner, cfg.repo, host=cfg.host)
 
 
-def cmd_login(cfg: config.Config) -> int:
-    from mooring import auth
+def cmd_login(cfg: config.Config, host: str | None = None) -> int:
+    import requests
 
+    from mooring import auth, config_store
+
+    if host is not None:
+        try:
+            new_host = config_store.set_host(host)
+        except ValueError as exc:
+            sys.exit(str(exc))
+        print(f"Saved GitHub host: {new_host}")
+        cfg = config.load_config()  # pick up the host just written
     if not cfg.client_id:
         sys.exit(
             "No OAuth client_id configured. Set [github] client_id in "
             f"{paths.user_config_file()}."
         )
-    device = auth.start_device_flow(cfg.client_id, host=cfg.host)
+    print(f"Requesting device code from {cfg.host}…")
+    try:
+        device = auth.start_device_flow(cfg.client_id, host=cfg.host)
+    except (auth.AuthError, requests.RequestException) as exc:
+        sys.exit(auth.device_flow_hint(cfg.host, exc))
     print(f"Open {device.verification_uri} and enter code: {device.user_code}")
     print("Waiting for authorization...")
     token = auth.poll_for_token(cfg.client_id, device)
@@ -414,6 +443,20 @@ def cmd_repo(app_cfg: config.AppConfig, args: argparse.Namespace) -> int:
         print(f"Active repo is now {args.alias!r}.")
         return 0
     if args.repo_command == "remove":
+        if getattr(args, "all_repos", False):
+            aliases = list(app_cfg.aliases)
+            if not aliases:
+                print("No repos registered.")
+                return 0
+            config_store.remove_all_repos()
+            telemetry.log_event("repo_remove", alias="*")
+            print(
+                f"Removed all {len(aliases)} repo(s): {', '.join(aliases)}. "
+                "Workspace folders were kept; delete them manually."
+            )
+            return 0
+        if not args.alias:
+            sys.exit("Specify a repo alias to remove, or use --all.")
         try:
             ws = app_cfg.config_for(args.alias).workspace()
             config_store.remove_repo(args.alias)
@@ -451,7 +494,7 @@ def _dispatch(
         port = getattr(args, "port", None)
         return run_hub(app_cfg, open_browser=not no_browser, port=port)
     if command == "login":
-        return cmd_login(cfg)
+        return cmd_login(cfg, getattr(args, "host", None))
     if command == "logout":
         return cmd_logout(cfg)
     if command == "whoami":

{mooring-0.2.3 → mooring-0.2.4}/src/mooring/config_store.py

@@ -83,6 +83,19 @@ def add_repo(
     write_user_data(data)
 
 
+def set_host(host: str) -> str:
+    """Persist the global GitHub host; returns the normalized value.
+
+    Host is a single [github] setting shared by every repo, independent of the
+    [repos] registry, so this writes [github].host without materializing repos.
+    """
+    normalized = githost.normalize_host(host)
+    data = read_user_data()
+    data.setdefault("github", {})["host"] = normalized
+    write_user_data(data)
+    return normalized
+
+
 def remove_repo(alias: str) -> None:
     data = _materialized(read_user_data())
     if alias not in data["repos"] or alias in RESERVED_ALIASES:
@@ -97,6 +110,18 @@ def remove_repo(alias: str) -> None:
     write_user_data(data)
 
 
+def remove_all_repos() -> None:
+    """Clear the entire repo registry. Workspaces and the saved token are kept.
+
+    An explicit empty [repos] is authoritative — it also overrides any
+    owner/repo baked into the packaged default (repo_specs_from_data treats a
+    present [repos] section as the whole truth).
+    """
+    data = read_user_data()
+    data["repos"] = {}
+    write_user_data(data)
+
+
 def set_active(alias: str) -> None:
     data = _materialized(read_user_data())
     if alias not in data["repos"] or alias in RESERVED_ALIASES:

{mooring-0.2.3 → mooring-0.2.4}/src/mooring/hub/server.py

@@ -23,7 +23,7 @@ from starlette.routing import Mount, Route
 from starlette.staticfiles import StaticFiles
 
 from mooring import __version__, auth, config, config_store, pbip, sync, telemetry
-from mooring.cli import SELFTEST_PACKAGES, legacy_workspace_hint
+from mooring.cli import SELFTEST_PACKAGES, workspace_hint
 from mooring.editor import EditorServer, _free_port
 from mooring.github import AuthFailed, GitHubClient, GitHubError, compare_url
 
@@ -88,7 +88,7 @@ class Hub:
             "branch": cfg.branch,
             "host": cfg.host,
             "workspace": str(cfg.workspace()),
-            "workspace_hint": legacy_workspace_hint(cfg),
+            "workspace_hint": workspace_hint(cfg),
             "repos": [
                 {
                     "alias": s.alias,
@@ -211,7 +211,9 @@ class Hub:
         try:
             device = auth.start_device_flow(self.cfg.client_id, host=self.cfg.host)
         except Exception as exc:  # noqa: BLE001 - shown in the UI
-            return JSONResponse({"error": str(exc)}, status_code=502)
+            return JSONResponse(
+                {"error": auth.device_flow_hint(self.cfg.host, exc)}, status_code=502
+            )
         with self._lock:
             self._device = device
             self._poll_interval = device.interval

mooring-0.2.4/src/mooring/paths.py

@@ -0,0 +1,64 @@
+"""Filesystem locations for config, logs, and the notebook workspace."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import platformdirs
+
+APP_NAME = "mooring"
+
+
+def user_config_dir() -> Path:
+    # roaming=True so the config follows the user profile on managed Windows networks
+    return Path(platformdirs.user_config_dir(APP_NAME, appauthor=False, roaming=True))
+
+
+def user_config_file() -> Path:
+    return user_config_dir() / "config.toml"
+
+
+def user_log_dir() -> Path:
+    return Path(platformdirs.user_log_dir(APP_NAME, appauthor=False))
+
+
+def default_workspace(owner: str, repo: str) -> Path:
+    # Keyed by owner AND repo so same-named repos under different owners
+    # don't share a workspace.
+    return Path(platformdirs.user_documents_dir()) / APP_NAME / owner / repo
+
+
+def legacy_workspace(repo: str) -> Path:
+    """The pre-multi-repo default (keyed by repo name only), kept for hints."""
+    return Path(platformdirs.user_documents_dir()) / APP_NAME / repo
+
+
+def synced_folder_provider(workspace: Path) -> str:
+    """Name of the cloud-sync service the workspace sits inside, or "" — these
+    revert/merge files (including .mooring/manifest.json) behind mooring's back,
+    which corrupts sync state. Windows redirects Documents into OneDrive, so the
+    default workspace silently lands there. Matched conservatively per path
+    component to avoid false positives (e.g. "sandbox", "toolbox")."""
+    for part in (p.lower() for p in workspace.parts):
+        if part.startswith("onedrive"):  # "OneDrive", "OneDrive - Contoso"
+            return "OneDrive"
+        if part == "dropbox":
+            return "Dropbox"
+        if part in ("google drive", "googledrive", "my drive"):
+            return "Google Drive"
+        if part in ("box", "box sync"):
+            return "Box"
+        if "icloud" in part:  # "iCloudDrive", "com~apple~CloudDocs"
+            return "iCloud"
+    return ""
+
+
+def synced_folder_hint(workspace: Path) -> str:
+    provider = synced_folder_provider(workspace)
+    if not provider:
+        return ""
+    return (
+        f"This workspace is inside {provider}. Cloud sync can revert or merge "
+        "mooring's files behind its back and corrupt sync state — move it to a "
+        "local folder (set MOORING_WORKSPACE, or the repo's 'workspace' path)."
+    )

{mooring-0.2.3 → mooring-0.2.4}/src/mooring/sync.py

@@ -183,6 +183,17 @@ def _remote_entries(
     return {e.path: e.sha for e in client.get_tree(head, cfg.folders) if is_synced_path(e.path)}
 
 
+def _review_tree(client: GitHubClient, cfg: Config, branch: str) -> dict[str, str]:
+    """The synced-file blob shas currently on an existing review branch, keyed by
+    path — the base shas needed to write further commits onto it."""
+    review_head = client.get_branch_head(branch)
+    return {
+        e.path: e.sha
+        for e in client.get_tree(review_head, cfg.folders)
+        if is_synced_path(e.path)
+    }
+
+
 def compute_status(
     mft: manifest_mod.Manifest,
     local: dict[str, str],
@@ -222,7 +233,15 @@ def _reconcile_review(
         return False
     changed = False
     for path, sent in list(mft.review_files.items()):
-        if remote.get(path) == sent:  # blob shas are content-addressed
+        if remote.get(path) == sent:  # blob shas are content-addressed: merged
+            # The proposal landed on cfg.branch, so it is now the sync base.
+            # Advance the base too: otherwise it stays at the pre-proposal blob,
+            # and any edits made after the merge classify as a spurious CONFLICT
+            # that neither pull (skips) nor push (blocks) can clear.
+            if sent is None:
+                mft.files.pop(path, None)
+            else:
+                mft.files[path] = sent
             del mft.review_files[path]
             changed = True
     if not mft.review_files:
@@ -355,19 +374,46 @@ def push(
         for f in report.by_state(FileState.IN_REVIEW):
             if f.path in wanted:
                 result.lines.append(
-                    f"in review {f.path} (already proposed — edit it again to push directly)"
+                    f"in review {f.path} (no local changes — already in the proposal)"
                 )
 
+    # A candidate that belongs to an open proposal keeps going to the review
+    # branch, so the (still-unapproved) PR picks up the new edits instead of them
+    # landing on cfg.branch behind the reviewer's back. Reaching cfg.branch means
+    # merging/closing the PR first — _reconcile_review then clears the state.
+    review_tree = (
+        _review_tree(client, cfg, mft.review_branch)
+        if mft.review_branch and any(f.path in mft.review_files for f in candidates)
+        else {}
+    )
+
     last_commit = ""
+    touched_review = False
+    stale_remote = False
     for index, f in enumerate(candidates):
         if index > 0 and throttle:
             sleep(throttle)  # contents-API writes trip secondary rate limits if rapid
+        in_review = bool(mft.review_branch) and f.path in mft.review_files
+        target = mft.review_branch if in_review else cfg.branch
+        base = review_tree.get(f.path) if in_review else f.base_sha
+        dest = " → review branch (PR)" if in_review else ""
+        response: dict | None = None
         if f.state is FileState.DELETED_LOCAL:
-            response = client.delete_file(
-                f.path, message or f"Delete {f.path} via mooring", cfg.branch, f.base_sha
-            )
-            mft.files.pop(f.path, None)
-            result.lines.append(f"deleted  {f.path}")
+            if not in_review:
+                response = client.delete_file(
+                    f.path, message or f"Delete {f.path} via mooring", target, base
+                )
+                mft.files.pop(f.path, None)
+                result.lines.append(f"deleted  {f.path}")
+            elif base is not None:
+                response = client.delete_file(
+                    f.path, message or f"Propose deleting {f.path} via mooring", target, base
+                )
+                mft.review_files[f.path] = None
+                result.lines.append(f"deleted  {f.path}{dest}")
+            else:
+                mft.review_files[f.path] = None
+                result.lines.append(f"deleted  {f.path} (already absent on review branch)")
         else:
             data = gitsha.read_for_push(workspace / f.path, f.path)
             size_mb = len(data) / (1024 * 1024)
@@ -383,25 +429,50 @@ def push(
                     f.path,
                     data,
                     message or f"Update {f.path} via mooring",
-                    cfg.branch,
-                    base_sha=f.base_sha,
+                    target,
+                    base_sha=base,
                 )
             except RemoteConflict:
                 result.blocked_conflicts.append(f.path)
-                result.lines.append(f"conflict {f.path} (remote changed — pull first)")
+                if base is None:
+                    # We tried to *create* the file but it already exists on the
+                    # target — our cached remote view is stale (manifest out of
+                    # sync with cfg.branch). Force the next pull to refetch.
+                    stale_remote = True
+                    reason = "already on the remote — pull first"
+                elif in_review:
+                    reason = "review branch changed — refresh and retry"
+                else:
+                    reason = "remote changed — pull first"
+                result.lines.append(f"conflict {f.path} ({reason})")
                 continue
-            mft.files[f.path] = response["content"]["sha"]
-            result.lines.append(f"pushed   {f.path}")
-        mft.review_files.pop(f.path, None)  # a direct push supersedes a stale proposal
-        commit = response.get("commit", {}).get("sha", "")
-        if commit:
-            last_commit = commit
+            if in_review:
+                mft.review_files[f.path] = response["content"]["sha"]
+            else:
+                mft.files[f.path] = response["content"]["sha"]
+                mft.review_files.pop(f.path, None)
+            result.lines.append(f"pushed   {f.path}{dest}")
+        if in_review:
+            touched_review = True
+        else:  # only cfg.branch writes advance the sync base
+            commit = (response or {}).get("commit", {}).get("sha", "")
+            if commit:
+                last_commit = commit
         result.pushed += 1
 
     if not mft.review_files:
         mft.review_branch = ""
+    if touched_review and mft.review_branch:
+        result.review_branch = mft.review_branch
+        result.compare_url = compare_url(
+            cfg.owner, cfg.repo, cfg.branch, mft.review_branch, host=cfg.host
+        )
     if last_commit:
         mft.head_commit = last_commit
+    if stale_remote:
+        # Drop the head-commit short-circuit in _remote_entries so the next pull
+        # refetches the live tree and rebuilds a consistent manifest.
+        mft.head_commit = ""
     mft.branch = cfg.branch
     manifest_mod.save(workspace, mft)
     return result
@@ -447,12 +518,7 @@ def propose(
 
     branch_name = mft.review_branch
     if branch_name:
-        review_head = client.get_branch_head(branch_name)
-        review_tree = {
-            e.path: e.sha
-            for e in client.get_tree(review_head, cfg.folders)
-            if is_synced_path(e.path)
-        }
+        review_tree = _review_tree(client, cfg, branch_name)
     else:
         # A fresh branch forks from head, so its tree is exactly `remote`.
         review_tree = dict(remote)
@@ -509,9 +575,18 @@ def propose(
                 )
             except RemoteConflict:
                 result.blocked_conflicts.append(f.path)
-                result.lines.append(
-                    f"conflict {f.path} (review branch changed — refresh and retry)"
-                )
+                if base is None:
+                    # Creating a file that already exists on cfg.branch (and thus
+                    # on the freshly-forked review branch): our cached remote view
+                    # is stale. Invalidate it so the next pull refetches and heals.
+                    mft.head_commit = ""
+                    result.lines.append(
+                        f"conflict {f.path} (already on the remote — pull first)"
+                    )
+                else:
+                    result.lines.append(
+                        f"conflict {f.path} (review branch changed — refresh and retry)"
+                    )
                 continue
             mft.review_files[f.path] = response["content"]["sha"]
             result.lines.append(f"proposed {f.path}")

{mooring-0.2.3 → mooring-0.2.4}/tests/test_auth.py

@@ -58,6 +58,35 @@ def test_device_flow_on_enterprise_host():
     assert auth.poll_once("client123", device).token == "gho_ghe"
 
 
+class _Resp:
+    def __init__(self, status_code):
+        self.status_code = status_code
+
+
+def test_device_flow_hint_default_host_suggests_enterprise():
+    exc = Exception("boom")
+    exc.response = _Resp(404)
+    msg = auth.device_flow_hint("github.com", exc)
+    assert "github.com" in msg
+    assert "404" in msg
+    assert "GitHub Enterprise" in msg
+    assert "--host" in msg
+
+
+def test_device_flow_hint_enterprise_host_no_suggestion():
+    exc = Exception("boom")
+    exc.response = _Resp(404)
+    msg = auth.device_flow_hint("ghe.example", exc)
+    assert "ghe.example" in msg
+    assert "404" in msg
+    assert "GitHub Enterprise" not in msg
+
+
+def test_device_flow_hint_without_status_uses_message():
+    msg = auth.device_flow_hint("ghe.example", Exception("connection refused"))
+    assert "connection refused" in msg
+
+
 @responses.activate
 def test_poll_until_token_with_slow_down():
     responses.add(responses.POST, auth.token_url(), json={"error": "authorization_pending"})

{mooring-0.2.3 → mooring-0.2.4}/tests/test_cli_repo.py

@@ -58,6 +58,83 @@ def test_repo_use_unknown_alias_exits():
     assert "Unknown repo alias" in str(exc.value)
 
 
+def test_repo_remove_all(capsys):
+    cli.main(["repo", "add", "acme/nbs"])
+    cli.main(["repo", "add", "acme/lab", "--no-use"])
+    assert cli.main(["repo", "remove", "--all"]) == 0
+    out = capsys.readouterr().out
+    assert "Removed all 2 repo(s)" in out
+    data = tomllib.loads(paths.user_config_file().read_text("utf-8"))
+    assert data["repos"] == {}
+
+
+def test_repo_remove_all_when_empty(capsys):
+    assert cli.main(["repo", "remove", "--all"]) == 0
+    assert "No repos registered." in capsys.readouterr().out
+
+
+def test_repo_remove_requires_alias_or_all():
+    cli.main(["repo", "add", "acme/nbs"])
+    with pytest.raises(SystemExit) as exc:
+        cli.main(["repo", "remove"])
+    assert "Specify a repo alias" in str(exc.value)
+
+
+def test_login_with_host_persists_and_uses_it(capsys, monkeypatch):
+    from mooring import auth, github
+
+    monkeypatch.setenv("MOORING_CLIENT_ID", "cid")
+    seen = {}
+
+    def fake_start(client_id, host="github.com", **kw):
+        seen["host"] = host
+        return auth.DeviceCode("d", "ABCD-1234", "https://x/login/device", 5, 900, host=host)
+
+    monkeypatch.setattr(auth, "start_device_flow", fake_start)
+    monkeypatch.setattr(auth, "poll_for_token", lambda *a, **k: "gho_tok")
+    monkeypatch.setattr(auth, "save_token", lambda *a, **k: None)
+
+    class FakeClient:
+        def __init__(self, *a, **k):
+            pass
+
+        def get_user(self):
+            return {"login": "octo"}
+
+    monkeypatch.setattr(github, "GitHubClient", FakeClient)
+
+    assert cli.main(["login", "--host", "https://GHE.Example/"]) == 0
+    assert seen["host"] == "ghe.example"  # normalized host passed to the flow
+    data = tomllib.loads(paths.user_config_file().read_text("utf-8"))
+    assert data["github"]["host"] == "ghe.example"  # and persisted
+    out = capsys.readouterr().out
+    assert "Saved GitHub host: ghe.example" in out
+    assert "Requesting device code from ghe.example" in out
+
+
+def test_login_failure_shows_enterprise_hint(monkeypatch):
+    import requests
+
+    from mooring import auth
+
+    monkeypatch.setenv("MOORING_CLIENT_ID", "cid")
+
+    class Resp:
+        status_code = 404
+
+    def boom(*a, **k):
+        err = requests.HTTPError("404 ...")
+        err.response = Resp()
+        raise err
+
+    monkeypatch.setattr(auth, "start_device_flow", boom)
+    with pytest.raises(SystemExit) as exc:
+        cli.main(["login"])  # no --host → default github.com
+    msg = str(exc.value)
+    assert "github.com" in msg
+    assert "GitHub Enterprise" in msg
+
+
 def test_repo_add_malformed_slug_exits():
     with pytest.raises(SystemExit):
         cli.main(["repo", "add", "just-a-name"])

{mooring-0.2.3 → mooring-0.2.4}/tests/test_config_store.py

@@ -97,3 +97,29 @@ def test_set_active_and_unknown_alias():
 def test_alias_validation_rejects(alias):
     with pytest.raises(ValueError):
         config_store.add_repo(alias, "acme", "nbs")
+
+
+def test_set_host_normalizes_and_persists():
+    config_store.add_repo("team", "acme", "nbs", client_id="cid")
+    assert config_store.set_host("https://GHE.Example.com/") == "ghe.example.com"
+    data = tomllib.loads(paths.user_config_file().read_text("utf-8"))
+    assert data["github"]["host"] == "ghe.example.com"
+    assert data["repos"]["active"] == "team"  # registry untouched
+    assert config.load_app_config().host == "ghe.example.com"
+
+
+def test_set_host_rejects_junk():
+    with pytest.raises(ValueError):
+        config_store.set_host("not a host!")
+
+
+def test_remove_all_repos_clears_registry_keeps_github():
+    config_store.add_repo("team", "acme", "nbs", client_id="cid", host="ghe.example")
+    config_store.add_repo("lab", "acme", "lab", make_active=False)
+    config_store.remove_all_repos()
+    app = config.load_app_config()
+    assert app.repos == ()
+    assert not app.config_for(None).is_configured
+    # [github] (client_id + host) survives the registry wipe
+    assert app.client_id == "cid"
+    assert app.host == "ghe.example"

mooring-0.2.4/tests/test_paths.py

@@ -0,0 +1,33 @@
+"""Workspace-location hints (cloud-sync folder detection)."""
+
+from pathlib import Path
+
+import pytest
+
+from mooring import paths
+
+
+@pytest.mark.parametrize(
+    ("workspace", "provider"),
+    [
+        ("C:/Users/phil/OneDrive/Documents/mooring/acme/nbs", "OneDrive"),
+        ("C:/Users/phil/OneDrive - Contoso/Documents/mooring/nbs", "OneDrive"),
+        ("C:/Users/phil/Dropbox/mooring/nbs", "Dropbox"),
+        ("G:/My Drive/mooring/nbs", "Google Drive"),
+        ("C:/Users/phil/Box/mooring/nbs", "Box"),
+        ("C:/Users/phil/iCloudDrive/mooring/nbs", "iCloud"),
+        # local paths and lookalikes must NOT trip the heuristic
+        ("C:/Users/phil/Documents/mooring/nbs", ""),
+        ("/home/phil/projects/sandbox/mooring/nbs", ""),  # 'sandbox' != 'box'
+        ("C:/dev/toolbox/mooring/nbs", ""),
+    ],
+)
+def test_synced_folder_provider(workspace, provider):
+    assert paths.synced_folder_provider(Path(workspace)) == provider
+
+
+def test_synced_folder_hint_text():
+    hint = paths.synced_folder_hint(Path("C:/Users/phil/OneDrive/Documents/mooring/nbs"))
+    assert "OneDrive" in hint
+    assert "MOORING_WORKSPACE" in hint
+    assert paths.synced_folder_hint(Path("C:/dev/mooring/nbs")) == ""

{mooring-0.2.3 → mooring-0.2.4}/tests/test_sync.py

@@ -260,6 +260,27 @@ def test_merge_observed_clears_review_and_next_propose_is_fresh(cfg):
     assert result.review_branch == "mooring/phil/20260612-1030"
 
 
+def test_merge_then_keep_editing_pushes_cleanly(cfg):
+    """After a proposal merges, editing the notebook again and pushing must go
+    straight to main without a spurious conflict — the sync base advanced to the
+    merged content rather than staying at the pre-proposal blob."""
+    client = FakeClient({"notebooks/a.py": b"v1\n"})
+    sync.pull(client, cfg)
+    write_local(cfg, "notebooks/a.py", "v2\n")
+    sync.propose(client, cfg, sleep=lambda s: None, now=NOW1)
+    client.merge(BRANCH1)  # PR merged to main
+    write_local(cfg, "notebooks/a.py", "v3\n")  # keep working on the same notebook
+    report = sync.status(client, cfg)
+    assert [f.state for f in report.files] == [FileState.MODIFIED]  # not CONFLICT
+    result = sync.push(client, cfg, sleep=lambda s: None)
+    assert result.blocked_conflicts == []
+    assert result.pushed == 1
+    assert client.blobs[client.tree["notebooks/a.py"]] == b"v3\n"
+    mft = manifest.load(cfg.workspace())
+    assert mft.review_branch == ""
+    assert mft.files["notebooks/a.py"] == client.tree["notebooks/a.py"]
+
+
 def test_deleted_review_branch_clears_review(cfg):
     client = FakeClient({"notebooks/a.py": b"v1\n"})
     sync.pull(client, cfg)
@@ -337,18 +358,111 @@ def test_push_skips_in_review_files(cfg):
     assert client.blobs[client.tree["notebooks/a.py"]] == b"v1\n"
 
 
-def test_direct_push_supersedes_proposal(cfg):
+def test_push_routes_in_review_edits_to_review_branch(cfg):
     client = FakeClient({"notebooks/a.py": b"v1\n"})
     sync.pull(client, cfg)
     write_local(cfg, "notebooks/a.py", "v2\n")
     sync.propose(client, cfg, sleep=lambda s: None, now=NOW1)
-    write_local(cfg, "notebooks/a.py", "v3\n")  # edited again: pushable directly
+    write_local(cfg, "notebooks/a.py", "v3\n")  # further edit while the PR is open
     result = sync.push(client, cfg, sleep=lambda s: None)
     assert result.pushed == 1
-    assert client.blobs[client.tree["notebooks/a.py"]] == b"v3\n"
+    # main is untouched; the edit lands on the review branch (the open PR)
+    assert client.blobs[client.tree["notebooks/a.py"]] == b"v1\n"
+    assert client.blobs[client.trees[BRANCH1]["notebooks/a.py"]] == b"v3\n"
+    # review state is preserved and updated, sync base unchanged
     mft = manifest.load(cfg.workspace())
-    assert mft.review_branch == ""
-    assert mft.review_files == {}
+    assert mft.review_branch == BRANCH1
+    assert mft.review_files["notebooks/a.py"] == client.trees[BRANCH1]["notebooks/a.py"]
+    assert mft.files["notebooks/a.py"] == client.tree["notebooks/a.py"]
+    # the PR link is surfaced and the file settles back to in-review
+    assert result.review_branch == BRANCH1
+    assert result.compare_url
+    report = sync.status(client, cfg)
+    assert [f.state for f in report.files] == [FileState.IN_REVIEW]
+
+
+def test_push_in_review_does_not_advance_main(cfg):
+    client = FakeClient({"notebooks/a.py": b"v1\n"})
+    sync.pull(client, cfg)
+    write_local(cfg, "notebooks/a.py", "v2\n")
+    sync.propose(client, cfg, sleep=lambda s: None, now=NOW1)
+    head_before = manifest.load(cfg.workspace()).head_commit
+    write_local(cfg, "notebooks/a.py", "v3\n")
+    sync.push(client, cfg, sleep=lambda s: None)
+    assert manifest.load(cfg.workspace()).head_commit == head_before
+
+
+def test_push_mixed_routes_each_to_its_branch(cfg):
+    client = FakeClient({"notebooks/a.py": b"v1\n"})
+    sync.pull(client, cfg)
+    write_local(cfg, "notebooks/a.py", "v2\n")
+    sync.propose(client, cfg, paths=["notebooks/a.py"], sleep=lambda s: None, now=NOW1)
+    write_local(cfg, "notebooks/a.py", "v3\n")  # in-review file, edited again
+    write_local(cfg, "notebooks/b.py", "new\n")  # brand-new, not part of the PR
+    result = sync.push(client, cfg, sleep=lambda s: None)
+    assert result.pushed == 2
+    # in-review edit went to the PR branch; the new file went straight to main
+    assert client.blobs[client.trees[BRANCH1]["notebooks/a.py"]] == b"v3\n"
+    assert client.blobs[client.tree["notebooks/a.py"]] == b"v1\n"
+    assert client.blobs[client.tree["notebooks/b.py"]] == b"new\n"
+    assert "notebooks/b.py" not in client.trees[BRANCH1]
+
+
+def test_push_in_review_delete_targets_review_branch(cfg):
+    client = FakeClient({"notebooks/a.py": b"v1\n", "notebooks/b.py": b"v1\n"})
+    sync.pull(client, cfg)
+    write_local(cfg, "notebooks/b.py", "v2\n")
+    sync.propose(client, cfg, paths=["notebooks/b.py"], sleep=lambda s: None, now=NOW1)
+    (cfg.workspace() / "notebooks/b.py").unlink()  # delete the proposed file
+    result = sync.push(client, cfg, sleep=lambda s: None)
+    assert result.pushed == 1
+    assert "notebooks/b.py" not in client.trees[BRANCH1]  # removed on the PR branch
+    assert "notebooks/b.py" in client.tree  # main untouched
+    mft = manifest.load(cfg.workspace())
+    assert mft.review_branch == BRANCH1
+    assert mft.review_files["notebooks/b.py"] is None
+
+
+def test_propose_create_conflict_on_stale_manifest_self_heals(cfg):
+    """A manifest whose `files` lost a path that is still on cfg.branch (e.g. an
+    external tool like OneDrive reverted it) made propose mis-see the file as new,
+    fork a branch that already had it, and fail to create it. The conflict must
+    now say 'pull first' and invalidate the head cache so the next pull heals it."""
+    client = FakeClient({"notebooks/a.py": b"v1\n"})
+    sync.pull(client, cfg)
+    # Corrupt the manifest: drop a.py but keep head_commit pointing at the same
+    # commit, so _remote_entries serves the stale cache (no live refetch).
+    mft = manifest.load(cfg.workspace())
+    assert mft.head_commit == client.head
+    del mft.files["notebooks/a.py"]
+    manifest.save(cfg.workspace(), mft)
+
+    result = sync.propose(client, cfg, sleep=lambda s: None, now=NOW1)
+    assert result.proposed == 0
+    assert result.blocked_conflicts == ["notebooks/a.py"]
+    assert any("already on the remote" in line for line in result.lines)
+    assert manifest.load(cfg.workspace()).head_commit == ""  # cache invalidated
+
+    # The next pull refetches the live tree and rebuilds a consistent manifest.
+    sync.pull(client, cfg)
+    healed = manifest.load(cfg.workspace())
+    assert "notebooks/a.py" in healed.files
+    assert healed.head_commit == client.head
+    assert sync.status(client, cfg).by_state(FileState.CONFLICT) == []
+
+
+def test_push_create_conflict_on_stale_manifest_invalidates_cache(cfg):
+    client = FakeClient({"notebooks/a.py": b"v1\n"})
+    sync.pull(client, cfg)
+    mft = manifest.load(cfg.workspace())
+    del mft.files["notebooks/a.py"]
+    manifest.save(cfg.workspace(), mft)
+
+    result = sync.push(client, cfg, sleep=lambda s: None)
+    assert result.pushed == 0
+    assert result.blocked_conflicts == ["notebooks/a.py"]
+    assert any("already on the remote" in line for line in result.lines)
+    assert manifest.load(cfg.workspace()).head_commit == ""
 
 
 # -- resolve --------------------------------------------------------------------

{mooring-0.2.3 → mooring-0.2.4}/uv.lock

@@ -450,7 +450,7 @@ wheels = [
 
 [[package]]
 name = "mooring"
-version = "0.2.3"
+version = "0.2.4"
 source = { editable = "." }
 dependencies = [
     { name = "altair" },

mooring-0.2.3/src/mooring/paths.py

@@ -1,33 +0,0 @@
-"""Filesystem locations for config, logs, and the notebook workspace."""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import platformdirs
-
-APP_NAME = "mooring"
-
-
-def user_config_dir() -> Path:
-    # roaming=True so the config follows the user profile on managed Windows networks
-    return Path(platformdirs.user_config_dir(APP_NAME, appauthor=False, roaming=True))
-
-
-def user_config_file() -> Path:
-    return user_config_dir() / "config.toml"
-
-
-def user_log_dir() -> Path:
-    return Path(platformdirs.user_log_dir(APP_NAME, appauthor=False))
-
-
-def default_workspace(owner: str, repo: str) -> Path:
-    # Keyed by owner AND repo so same-named repos under different owners
-    # don't share a workspace.
-    return Path(platformdirs.user_documents_dir()) / APP_NAME / owner / repo
-
-
-def legacy_workspace(repo: str) -> Path:
-    """The pre-multi-repo default (keyed by repo name only), kept for hints."""
-    return Path(platformdirs.user_documents_dir()) / APP_NAME / repo