Release version 1.7.2

- Resolve primary remote via RepoMirrorContext (origin → file order → config → default)
- Always set origin fetch and push URL to primary
- Add additional mirrors as extra push URLs without duplication
- Update remote provisioning and setup commands to use context-based resolution
- Adjust and extend unit tests to cover new origin/push behavior

https://chatgpt.com/share/693f4538-42d4-800f-98c2-2ec264fd2e19

CHANGELOG.md

@@ -1,3 +1,12 @@
+## [1.7.2] - 2025-12-15
+
+* * Git mirrors are now resolved consistently (origin → MIRRORS file → config → default).
+* The `origin` remote is always enforced to use the primary URL for both fetch and push.
+* Additional mirrors are added as extra push targets without duplication.
+* Local and remote mirror setup behaves more predictably and consistently.
+* Improved test coverage ensures stable origin and push URL handling.
+
+
 ## [1.7.1] - 2025-12-14
 
 * Patched package-manager to kpmx to publish on pypi

flake.nix

@@ -32,7 +32,7 @@
         rec {
           pkgmgr = pyPkgs.buildPythonApplication {
             pname   = "package-manager";
-            version = "1.7.1";
+            version = "1.7.2";
 
             # Use the git repo as source
             src = ./.;

packaging/arch/PKGBUILD

@@ -1,7 +1,7 @@
 # Maintainer: Kevin Veen-Birkenbach <info@veen.world>
 
 pkgname=package-manager
-pkgver=1.7.1
+pkgver=1.7.2
 pkgrel=1
 pkgdesc="Local-flake wrapper for Kevin's package-manager (Nix-based)."
 arch=('any')

packaging/debian/changelog

@@ -1,3 +1,13 @@
+package-manager (1.7.2-1) unstable; urgency=medium
+
+  * * Git mirrors are now resolved consistently (origin → MIRRORS file → config → default).
+* The `origin` remote is always enforced to use the primary URL for both fetch and push.
+* Additional mirrors are added as extra push targets without duplication.
+* Local and remote mirror setup behaves more predictably and consistently.
+* Improved test coverage ensures stable origin and push URL handling.
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Mon, 15 Dec 2025 00:53:26 +0100
+
 package-manager (1.7.1-1) unstable; urgency=medium
 
   * Patched package-manager to kpmx to publish on pypi

packaging/fedora/package-manager.spec

@@ -1,5 +1,5 @@
 Name:           package-manager
-Version:        1.7.1
+Version:        1.7.2
 Release:        1%{?dist}
 Summary:        Wrapper that runs Kevin's package-manager via Nix flake
 
@@ -74,6 +74,13 @@ echo ">>> package-manager removed. Nix itself was not removed."
 /usr/lib/package-manager/
 
 %changelog
+* Mon Dec 15 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 1.7.2-1
+- * Git mirrors are now resolved consistently (origin → MIRRORS file → config → default).
+* The `origin` remote is always enforced to use the primary URL for both fetch and push.
+* Additional mirrors are added as extra push targets without duplication.
+* Local and remote mirror setup behaves more predictably and consistently.
+* Improved test coverage ensures stable origin and push URL handling.
+
 * Sun Dec 14 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 1.7.1-1
 - Patched package-manager to kpmx to publish on pypi
 

pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kpmx"
-version = "1.7.1"
+version = "1.7.2"
 description = "Kevin's package-manager tool (pkgmgr)"
 readme = "README.md"
 requires-python = ">=3.9"

src/pkgmgr/actions/mirror/git_remote.py

@@ -1,20 +1,15 @@
 from __future__ import annotations
 
 import os
+from typing import List, Optional, Set
 
 from pkgmgr.core.command.run import run_command
 from pkgmgr.core.git import GitError, run_git
-from typing import List, Optional, Set
 
 from .types import MirrorMap, RepoMirrorContext, Repository
 
 
 def build_default_ssh_url(repo: Repository) -> Optional[str]:
-    """
-    Build a simple SSH URL from repo config if no explicit mirror is defined.
-
-    Example: git@github.com:account/repository.git
-    """
     provider = repo.get("provider")
     account = repo.get("account")
     name = repo.get("repository")
@@ -23,95 +18,82 @@ def build_default_ssh_url(repo: Repository) -> Optional[str]:
     if not provider or not account or not name:
         return None
 
-    provider = str(provider)
-    account = str(account)
-    name = str(name)
-
     if port:
         return f"ssh://git@{provider}:{port}/{account}/{name}.git"
 
-    # GitHub-style shorthand
     return f"git@{provider}:{account}/{name}.git"
 
 
 def determine_primary_remote_url(
     repo: Repository,
-    resolved_mirrors: MirrorMap,
+    ctx: RepoMirrorContext,
 ) -> Optional[str]:
     """
-    Determine the primary remote URL in a consistent way:
+    Priority order:
-
+      1. origin from resolved mirrors
-      1. resolved_mirrors["origin"]
+      2. MIRRORS file order
-      2. any resolved mirror (first by name)
+      3. config mirrors order
-      3. default SSH URL from provider/account/repository
+      4. default SSH URL
     """
-    if "origin" in resolved_mirrors:
+    resolved = ctx.resolved_mirrors
-        return resolved_mirrors["origin"]
 
-    if resolved_mirrors:
+    if resolved.get("origin"):
-        first_name = sorted(resolved_mirrors.keys())[0]
+        return resolved["origin"]
-        return resolved_mirrors[first_name]
+
+    for mirrors in (ctx.file_mirrors, ctx.config_mirrors):
+        for _, url in mirrors.items():
+            if url:
+                return url
 
     return build_default_ssh_url(repo)
 
 
 def _safe_git_output(args: List[str], cwd: str) -> Optional[str]:
-    """
-    Run a Git command via run_git and return its stdout, or None on failure.
-    """
     try:
         return run_git(args, cwd=cwd)
     except GitError:
         return None
 
 
-def current_origin_url(repo_dir: str) -> Optional[str]:
-    """
-    Return the current URL for remote 'origin', or None if not present.
-    """
-    output = _safe_git_output(["remote", "get-url", "origin"], cwd=repo_dir)
-    if not output:
-        return None
-    url = output.strip()
-    return url or None
-
-
 def has_origin_remote(repo_dir: str) -> bool:
-    """
+    out = _safe_git_output(["remote"], cwd=repo_dir)
-    Check whether a remote called 'origin' exists in the repository.
+    return bool(out and "origin" in out.split())
-    """
-    output = _safe_git_output(["remote"], cwd=repo_dir)
-    if not output:
-        return False
-    names = output.split()
-    return "origin" in names
 
 
-def _ensure_push_urls_for_origin(
+def _set_origin_fetch_and_push(repo_dir: str, url: str, preview: bool) -> None:
+    fetch = f"git remote set-url origin {url}"
+    push = f"git remote set-url --push origin {url}"
+
+    if preview:
+        print(f"[PREVIEW] Would run in {repo_dir!r}: {fetch}")
+        print(f"[PREVIEW] Would run in {repo_dir!r}: {push}")
+        return
+
+    run_command(fetch, cwd=repo_dir, preview=False)
+    run_command(push, cwd=repo_dir, preview=False)
+
+
+def _ensure_additional_push_urls(
     repo_dir: str,
     mirrors: MirrorMap,
+    primary: str,
     preview: bool,
 ) -> None:
-    """
+    desired: Set[str] = {u for u in mirrors.values() if u and u != primary}
-    Ensure that all mirror URLs are present as push URLs on 'origin'.
-    """
-    desired: Set[str] = {url for url in mirrors.values() if url}
     if not desired:
         return
 
-    existing_output = _safe_git_output(
+    out = _safe_git_output(
         ["remote", "get-url", "--push", "--all", "origin"],
         cwd=repo_dir,
     )
-    existing = set(existing_output.splitlines()) if existing_output else set()
+    existing = set(out.splitlines()) if out else set()
 
-    missing = sorted(desired - existing)
+    for url in sorted(desired - existing):
-    for url in missing:
         cmd = f"git remote set-url --add --push origin {url}"
         if preview:
             print(f"[PREVIEW] Would run in {repo_dir!r}: {cmd}")
         else:
-            print(f"[INFO] Adding push URL to 'origin': {url}")
             run_command(cmd, cwd=repo_dir, preview=False)
 
 
@@ -120,60 +102,32 @@ def ensure_origin_remote(
     ctx: RepoMirrorContext,
     preview: bool,
 ) -> None:
-    """
-    Ensure that a usable 'origin' remote exists and has all push URLs.
-    """
     repo_dir = ctx.repo_dir
-    resolved_mirrors = ctx.resolved_mirrors
 
     if not os.path.isdir(os.path.join(repo_dir, ".git")):
-        print(f"[WARN] {repo_dir} is not a Git repository (no .git directory).")
+        print(f"[WARN] {repo_dir} is not a Git repository.")
         return
 
-    url = determine_primary_remote_url(repo, resolved_mirrors)
+    primary = determine_primary_remote_url(repo, ctx)
+    if not primary:
+        print("[WARN] No primary mirror URL could be determined.")
+        return
 
     if not has_origin_remote(repo_dir):
-        if not url:
+        cmd = f"git remote add origin {primary}"
-            print(
-                "[WARN] Could not determine URL for 'origin' remote. "
-                "Please configure mirrors or provider/account/repository."
-            )
-            return
-
-        cmd = f"git remote add origin {url}"
         if preview:
             print(f"[PREVIEW] Would run in {repo_dir!r}: {cmd}")
         else:
-            print(f"[INFO] Adding 'origin' remote in {repo_dir}: {url}")
             run_command(cmd, cwd=repo_dir, preview=False)
-    else:
-        current = current_origin_url(repo_dir)
-        if current == url or not url:
-            print(
-                "[INFO] 'origin' already points to "
-                f"{current or '<unknown>'} (no change needed)."
-            )
-        else:
-            # We do not auto-change origin here, only log the mismatch.
-            print(
-                "[INFO] 'origin' exists with URL "
-                f"{current or '<unknown>'}; not changing to {url}."
-            )
 
-    # Ensure all mirrors are present as push URLs
+        _set_origin_fetch_and_push(repo_dir, primary, preview)
-    _ensure_push_urls_for_origin(repo_dir, resolved_mirrors, preview)
+
+    _ensure_additional_push_urls(repo_dir, ctx.resolved_mirrors, primary, preview)
 
 
 def is_remote_reachable(url: str, cwd: Optional[str] = None) -> bool:
-    """
-    Check whether a remote repository is reachable via `git ls-remote`.
-
-    This does NOT modify anything; it only probes the remote.
-    """
-    workdir = cwd or os.getcwd()
     try:
-        # --exit-code → non-zero exit code if the remote does not exist
+        run_git(["ls-remote", "--exit-code", url], cwd=cwd or os.getcwd())
-        run_git(["ls-remote", "--exit-code", url], cwd=workdir)
         return True
     except GitError:
         return False

src/pkgmgr/actions/mirror/remote_provision.py

@@ -1,4 +1,3 @@
-# src/pkgmgr/actions/mirror/remote_provision.py
 from __future__ import annotations
 
 from typing import List
@@ -19,36 +18,28 @@ def ensure_remote_repository(
     preview: bool,
 ) -> None:
     ctx = build_context(repo, repositories_base_dir, all_repos)
-    resolved_mirrors = ctx.resolved_mirrors
 
-    primary_url = determine_primary_remote_url(repo, resolved_mirrors)
+    primary_url = determine_primary_remote_url(repo, ctx)
     if not primary_url:
-        print("[INFO] No remote URL could be derived; skipping remote provisioning.")
+        print("[INFO] No primary URL found; skipping remote provisioning.")
         return
 
-    host_raw, owner_from_url, name_from_url = parse_repo_from_git_url(primary_url)
+    host_raw, owner, name = parse_repo_from_git_url(primary_url)
     host = normalize_provider_host(host_raw)
 
-    if not host or not owner_from_url or not name_from_url:
+    if not host or not owner or not name:
-        print("[WARN] Could not derive host/owner/repository from URL; cannot ensure remote repo.")
+        print("[WARN] Could not parse remote URL:", primary_url)
-        print(f"       url={primary_url!r}")
-        print(f"       host={host!r}, owner={owner_from_url!r}, repository={name_from_url!r}")
         return
 
-    print("------------------------------------------------------------")
-    print(f"[REMOTE ENSURE] {ctx.identifier}")
-    print(f"[REMOTE ENSURE] host: {host}")
-    print("------------------------------------------------------------")
-
     spec = RepoSpec(
-        host=str(host),
+        host=host,
-        owner=str(owner_from_url),
+        owner=owner,
-        name=str(name_from_url),
+        name=name,
         private=bool(repo.get("private", True)),
         description=str(repo.get("description", "")),
     )
 
-    provider_kind = str(repo.get("provider", "")).strip().lower() or None
+    provider_kind = str(repo.get("provider", "")).lower() or None
 
     try:
         result = ensure_remote_repo(
@@ -66,5 +57,3 @@ def ensure_remote_repository(
             print(f"[REMOTE ENSURE] URL: {result.url}")
     except Exception as exc:  # noqa: BLE001
         print(f"[ERROR] Remote provisioning failed: {exc}")
-
-    print()

src/pkgmgr/actions/mirror/setup_cmd.py

@@ -1,4 +1,3 @@
-# src/pkgmgr/actions/mirror/setup_cmd.py
 from __future__ import annotations
 
 from typing import List
@@ -9,6 +8,7 @@ from .remote_check import probe_mirror
 from .remote_provision import ensure_remote_repository
 from .types import Repository
 
+
 def _setup_local_mirrors_for_repo(
     repo: Repository,
     repositories_base_dir: str,
@@ -22,7 +22,7 @@ def _setup_local_mirrors_for_repo(
     print(f"[MIRROR SETUP:LOCAL] dir: {ctx.repo_dir}")
     print("------------------------------------------------------------")
 
-    ensure_origin_remote(repo, ctx, preview=preview)
+    ensure_origin_remote(repo, ctx, preview)
     print()
 
 
@@ -34,7 +34,6 @@ def _setup_remote_mirrors_for_repo(
     ensure_remote: bool,
 ) -> None:
     ctx = build_context(repo, repositories_base_dir, all_repos)
-    resolved_mirrors = ctx.resolved_mirrors
 
     print("------------------------------------------------------------")
     print(f"[MIRROR SETUP:REMOTE] {ctx.identifier}")
@@ -44,37 +43,28 @@ def _setup_remote_mirrors_for_repo(
     if ensure_remote:
         ensure_remote_repository(
             repo,
-            repositories_base_dir=repositories_base_dir,
+            repositories_base_dir,
-            all_repos=all_repos,
+            all_repos,
-            preview=preview,
+            preview,
         )
 
-    if not resolved_mirrors:
+    if not ctx.resolved_mirrors:
-        primary_url = determine_primary_remote_url(repo, resolved_mirrors)
+        primary = determine_primary_remote_url(repo, ctx)
-        if not primary_url:
+        if not primary:
-            print("[INFO] No mirrors configured and no primary URL available.")
-            print()
             return
 
-        ok, error_message = probe_mirror(primary_url, ctx.repo_dir)
+        ok, msg = probe_mirror(primary, ctx.repo_dir)
-        if ok:
+        print("[OK]" if ok else "[WARN]", primary)
-            print(f"[OK] primary: {primary_url}")
+        if msg:
-        else:
+            print(msg)
-            print(f"[WARN] primary: {primary_url}")
-            for line in error_message.splitlines():
-                print(f"         {line}")
-
         print()
         return
 
-    for name, url in sorted(resolved_mirrors.items()):
+    for name, url in ctx.resolved_mirrors.items():
-        ok, error_message = probe_mirror(url, ctx.repo_dir)
+        ok, msg = probe_mirror(url, ctx.repo_dir)
-        if ok:
+        print(f"[OK] {name}: {url}" if ok else f"[WARN] {name}: {url}")
-            print(f"[OK] {name}: {url}")
+        if msg:
-        else:
+            print(msg)
-            print(f"[WARN] {name}: {url}")
-            for line in error_message.splitlines():
-                print(f"         {line}")
 
     print()
 
@@ -91,17 +81,17 @@ def setup_mirrors(
     for repo in selected_repos:
         if local:
             _setup_local_mirrors_for_repo(
-                repo=repo,
+                repo,
-                repositories_base_dir=repositories_base_dir,
+                repositories_base_dir,
-                all_repos=all_repos,
+                all_repos,
-                preview=preview,
+                preview,
             )
 
         if remote:
             _setup_remote_mirrors_for_repo(
-                repo=repo,
+                repo,
-                repositories_base_dir=repositories_base_dir,
+                repositories_base_dir,
-                all_repos=all_repos,
+                all_repos,
-                preview=preview,
+                preview,
-                ensure_remote=ensure_remote,
+                ensure_remote,
             )

src/pkgmgr/actions/publish/workflow.py

@@ -84,10 +84,13 @@ def publish(
         raise RuntimeError("No build artifacts found in dist/.")
 
     resolver = TokenResolver()
+
+    # Store PyPI token per OS user (keyring is already user-scoped).
+    # Do NOT scope by project name.
     token = resolver.get_token(
         provider_kind="pypi",
         host=target.host,
-        owner=target.project,
+        owner=None,
         options=ResolutionOptions(
             interactive=interactive,
             allow_prompt=allow_prompt,

src/pkgmgr/cli/commands/release.py

@@ -1,31 +1,17 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-"""
-Release command wiring for the pkgmgr CLI.
-
-This module implements the `pkgmgr release` subcommand on top of the
-generic selection logic from cli.dispatch. It does not define its
-own subparser; the CLI surface is configured in cli.parser.
-
-Responsibilities:
-  - Take the parsed argparse.Namespace for the `release` command.
-  - Use the list of selected repositories provided by dispatch_command().
-  - Optionally list affected repositories when --list is set.
-  - For each selected repository, run pkgmgr.actions.release.release(...) in
-    the context of that repository directory.
-"""
-
 from __future__ import annotations
 
 import os
+import sys
 from typing import Any, Dict, List
 
+from pkgmgr.actions.publish import publish as run_publish
+from pkgmgr.actions.release import release as run_release
 from pkgmgr.cli.context import CLIContext
 from pkgmgr.core.repository.dir import get_repo_dir
 from pkgmgr.core.repository.identifier import get_repo_identifier
-from pkgmgr.actions.release import release as run_release
-
 
 Repository = Dict[str, Any]
 
@@ -35,23 +21,10 @@ def handle_release(
     ctx: CLIContext,
     selected: List[Repository],
 ) -> None:
-    """
-    Handle the `pkgmgr release` subcommand.
-
-    Flow:
-      1) Use the `selected` repositories as computed by dispatch_command().
-      2) If --list is given, print the identifiers of the selected repos
-         and return without running any release.
-      3) For each selected repository:
-           - Resolve its identifier and local directory.
-           - Change into that directory.
-           - Call pkgmgr.actions.release.release(...) with the parsed options.
-    """
     if not selected:
         print("[pkgmgr] No repositories selected for release.")
         return
 
-    # List-only mode: show which repositories would be affected.
     if getattr(args, "list", False):
         print("[pkgmgr] Repositories that would be affected by this release:")
         for repo in selected:
@@ -62,29 +35,22 @@ def handle_release(
     for repo in selected:
         identifier = get_repo_identifier(repo, ctx.all_repositories)
 
-        repo_dir = repo.get("directory")
+        try:
-        if not repo_dir:
+            repo_dir = repo.get("directory") or get_repo_dir(ctx.repositories_base_dir, repo)
-            try:
+        except Exception as exc:
-                repo_dir = get_repo_dir(ctx.repositories_base_dir, repo)
+            print(f"[WARN] Skipping repository {identifier}: failed to resolve directory: {exc}")
-            except Exception:
-                repo_dir = None
-
-        if not repo_dir or not os.path.isdir(repo_dir):
-            print(
-                f"[WARN] Skipping repository {identifier}: "
-                "local directory does not exist."
-            )
             continue
 
-        print(
+        if not os.path.isdir(repo_dir):
-            f"[pkgmgr] Running release for repository {identifier} "
+            print(f"[WARN] Skipping repository {identifier}: directory missing.")
-            f"in '{repo_dir}'..."
+            continue
-        )
+
+        print(f"[pkgmgr] Running release for repository {identifier}...")
 
-        # Change to repo directory and invoke the helper.
         cwd_before = os.getcwd()
         try:
             os.chdir(repo_dir)
+
             run_release(
                 pyproject_path="pyproject.toml",
                 changelog_path="CHANGELOG.md",
@@ -94,5 +60,17 @@ def handle_release(
                 force=getattr(args, "force", False),
                 close=getattr(args, "close", False),
             )
+
+            if not getattr(args, "no_publish", False):
+                print(f"[pkgmgr] Running publish for repository {identifier}...")
+                is_tty = sys.stdin.isatty()
+                run_publish(
+                    repo=repo,
+                    repo_dir=repo_dir,
+                    preview=getattr(args, "preview", False),
+                    interactive=is_tty,
+                    allow_prompt=is_tty,
+                )
+
         finally:
             os.chdir(cwd_before)

src/pkgmgr/cli/parser/release_cmd.py

@@ -21,22 +21,22 @@ def add_release_subparser(
             "and updating the changelog."
         ),
     )
+
     release_parser.add_argument(
         "release_type",
         choices=["major", "minor", "patch"],
         help="Type of version increment for the release (major, minor, patch).",
     )
+
     release_parser.add_argument(
         "-m",
         "--message",
         default=None,
-        help=(
+        help="Optional release message to add to the changelog and tag.",
-            "Optional release message to add to the changelog and tag."
-        ),
     )
-    # Generic selection / preview / list / extra_args
+
     add_identifier_arguments(release_parser)
-    # Close current branch after successful release
+
     release_parser.add_argument(
         "--close",
         action="store_true",
@@ -45,7 +45,7 @@ def add_release_subparser(
             "repository, if it is not main/master."
         ),
     )
-    # Force: skip preview+confirmation and run release directly
+
     release_parser.add_argument(
         "-f",
         "--force",
@@ -55,3 +55,9 @@ def add_release_subparser(
             "release directly."
         ),
     )
+
+    release_parser.add_argument(
+        "--no-publish",
+        action="store_true",
+        help="Do not run publish automatically after a successful release.",
+    )

tests/integration/test_release_publish_hook.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from types import SimpleNamespace
+from unittest.mock import patch
+
+
+class TestIntegrationReleasePublishHook(unittest.TestCase):
+    def _ctx(self) -> SimpleNamespace:
+        # Minimal CLIContext shape used by handle_release()
+        return SimpleNamespace(
+            repositories_base_dir="/tmp",
+            all_repositories=[],
+        )
+
+    def _parse(self, argv: list[str]):
+        from pkgmgr.cli.parser import create_parser
+
+        parser = create_parser("pkgmgr test")
+        return parser.parse_args(argv)
+
+    def test_release_runs_publish_by_default_and_respects_tty(self) -> None:
+        from pkgmgr.cli.commands.release import handle_release
+
+        with tempfile.TemporaryDirectory() as td:
+            selected = [{"directory": td}]
+
+            # Go through real parser to ensure CLI surface is wired correctly
+            args = self._parse(["release", "patch"])
+
+            with patch("pkgmgr.cli.commands.release.run_release") as m_release, patch(
+                "pkgmgr.cli.commands.release.run_publish"
+            ) as m_publish, patch(
+                "pkgmgr.cli.commands.release.sys.stdin.isatty", return_value=False
+            ):
+                handle_release(args=args, ctx=self._ctx(), selected=selected)
+
+            m_release.assert_called_once()
+            m_publish.assert_called_once()
+
+            _, kwargs = m_publish.call_args
+            self.assertEqual(kwargs["repo"], selected[0])
+            self.assertEqual(kwargs["repo_dir"], td)
+            self.assertFalse(kwargs["interactive"])
+            self.assertFalse(kwargs["allow_prompt"])
+
+    def test_release_skips_publish_when_no_publish_flag_set(self) -> None:
+        from pkgmgr.cli.commands.release import handle_release
+
+        with tempfile.TemporaryDirectory() as td:
+            selected = [{"directory": td}]
+
+            args = self._parse(["release", "patch", "--no-publish"])
+
+            with patch("pkgmgr.cli.commands.release.run_release") as m_release, patch(
+                "pkgmgr.cli.commands.release.run_publish"
+            ) as m_publish:
+                handle_release(args=args, ctx=self._ctx(), selected=selected)
+
+            m_release.assert_called_once()
+            m_publish.assert_not_called()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/unit/pkgmgr/actions/mirror/test_git_remote.py

@@ -1,6 +1,3 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
 from __future__ import annotations
 
 import unittest
@@ -9,117 +6,61 @@ from unittest.mock import patch
 from pkgmgr.actions.mirror.git_remote import (
     build_default_ssh_url,
     determine_primary_remote_url,
-    current_origin_url,
     has_origin_remote,
 )
-from pkgmgr.actions.mirror.types import MirrorMap, Repository
+from pkgmgr.actions.mirror.types import RepoMirrorContext
 
 
 class TestMirrorGitRemote(unittest.TestCase):
-    """
+    def _ctx(self, *, file=None, config=None) -> RepoMirrorContext:
-    Unit tests for SSH URL and primary remote selection logic.
+        return RepoMirrorContext(
-    """
+            identifier="repo",
+            repo_dir="/tmp/repo",
+            config_mirrors=config or {},
+            file_mirrors=file or {},
+        )
 
-    def test_build_default_ssh_url_without_port(self) -> None:
+    def test_build_default_ssh_url(self) -> None:
-        repo: Repository = {
+        repo = {
             "provider": "github.com",
-            "account": "kevinveenbirkenbach",
+            "account": "alice",
-            "repository": "package-manager",
+            "repository": "repo",
         }
+        self.assertEqual(
+            build_default_ssh_url(repo),
+            "git@github.com:alice/repo.git",
+        )
 
-        url = build_default_ssh_url(repo)
+    def test_determine_primary_prefers_origin(self) -> None:
-        self.assertEqual(url, "git@github.com:kevinveenbirkenbach/package-manager.git")
+        repo = {"provider": "github.com", "account": "alice", "repository": "repo"}
+        ctx = self._ctx(config={"origin": "git@github.com:alice/repo.git"})
+        self.assertEqual(
+            determine_primary_remote_url(repo, ctx),
+            "git@github.com:alice/repo.git",
+        )
 
-    def test_build_default_ssh_url_with_port(self) -> None:
+    def test_determine_primary_uses_file_order(self) -> None:
-        repo: Repository = {
+        repo = {"provider": "github.com", "account": "alice", "repository": "repo"}
-            "provider": "code.cymais.cloud",
+        ctx = self._ctx(
-            "account": "kevinveenbirkenbach",
+            file={
-            "repository": "pkgmgr",
+                "first": "git@a/first.git",
-            "port": 2201,
+                "second": "git@a/second.git",
-        }
+            }
+        )
+        self.assertEqual(
+            determine_primary_remote_url(repo, ctx),
+            "git@a/first.git",
+        )
 
-        url = build_default_ssh_url(repo)
+    def test_determine_primary_fallback_default(self) -> None:
-        self.assertEqual(url, "ssh://git@code.cymais.cloud:2201/kevinveenbirkenbach/pkgmgr.git")
+        repo = {"provider": "github.com", "account": "alice", "repository": "repo"}
+        ctx = self._ctx()
+        self.assertEqual(
+            determine_primary_remote_url(repo, ctx),
+            "git@github.com:alice/repo.git",
+        )
 
-    def test_build_default_ssh_url_missing_fields_returns_none(self) -> None:
+    @patch("pkgmgr.actions.mirror.git_remote._safe_git_output")
-        repo: Repository = {
+    def test_has_origin_remote(self, m_out) -> None:
-            "provider": "github.com",
+        m_out.return_value = "origin\nupstream\n"
-            "account": "kevinveenbirkenbach",
-        }
-
-        url = build_default_ssh_url(repo)
-        self.assertIsNone(url)
-
-    def test_determine_primary_remote_url_prefers_origin_in_resolved_mirrors(self) -> None:
-        repo: Repository = {
-            "provider": "github.com",
-            "account": "kevinveenbirkenbach",
-            "repository": "package-manager",
-        }
-        mirrors: MirrorMap = {
-            "origin": "git@github.com:kevinveenbirkenbach/package-manager.git",
-            "backup": "ssh://git@git.veen.world:2201/kevinveenbirkenbach/pkgmgr.git",
-        }
-
-        url = determine_primary_remote_url(repo, mirrors)
-        self.assertEqual(url, "git@github.com:kevinveenbirkenbach/package-manager.git")
-
-    def test_determine_primary_remote_url_uses_any_mirror_if_no_origin(self) -> None:
-        repo: Repository = {
-            "provider": "github.com",
-            "account": "kevinveenbirkenbach",
-            "repository": "package-manager",
-        }
-        mirrors: MirrorMap = {
-            "backup": "ssh://git@git.veen.world:2201/kevinveenbirkenbach/pkgmgr.git",
-            "mirror2": "ssh://git@code.cymais.cloud:2201/kevinveenbirkenbach/pkgmgr.git",
-        }
-
-        url = determine_primary_remote_url(repo, mirrors)
-        self.assertEqual(url, "ssh://git@git.veen.world:2201/kevinveenbirkenbach/pkgmgr.git")
-
-    def test_determine_primary_remote_url_falls_back_to_default_ssh(self) -> None:
-        repo: Repository = {
-            "provider": "github.com",
-            "account": "kevinveenbirkenbach",
-            "repository": "package-manager",
-        }
-        mirrors: MirrorMap = {}
-
-        url = determine_primary_remote_url(repo, mirrors)
-        self.assertEqual(url, "git@github.com:kevinveenbirkenbach/package-manager.git")
-
-    @patch("pkgmgr.actions.mirror.git_remote.run_git")
-    def test_current_origin_url_returns_value(self, mock_run_git) -> None:
-        mock_run_git.return_value = "git@github.com:alice/repo.git\n"
-        self.assertEqual(current_origin_url("/tmp/repo"), "git@github.com:alice/repo.git")
-        mock_run_git.assert_called_once_with(["remote", "get-url", "origin"], cwd="/tmp/repo")
-
-    @patch("pkgmgr.actions.mirror.git_remote.run_git")
-    def test_current_origin_url_returns_none_on_git_error(self, mock_run_git) -> None:
-        from pkgmgr.core.git import GitError
-
-        mock_run_git.side_effect = GitError("fail")
-        self.assertIsNone(current_origin_url("/tmp/repo"))
-
-    @patch("pkgmgr.actions.mirror.git_remote.run_git")
-    def test_has_origin_remote_true(self, mock_run_git) -> None:
-        mock_run_git.return_value = "origin\nupstream\n"
         self.assertTrue(has_origin_remote("/tmp/repo"))
-        mock_run_git.assert_called_once_with(["remote"], cwd="/tmp/repo")
-
-    @patch("pkgmgr.actions.mirror.git_remote.run_git")
-    def test_has_origin_remote_false_on_missing_remote(self, mock_run_git) -> None:
-        mock_run_git.return_value = "upstream\n"
-        self.assertFalse(has_origin_remote("/tmp/repo"))
-
-    @patch("pkgmgr.actions.mirror.git_remote.run_git")
-    def test_has_origin_remote_false_on_git_error(self, mock_run_git) -> None:
-        from pkgmgr.core.git import GitError
-
-        mock_run_git.side_effect = GitError("fail")
-        self.assertFalse(has_origin_remote("/tmp/repo"))
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/unit/pkgmgr/actions/mirror/test_git_remote_primary_push.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import unittest
+from unittest.mock import patch
+
+from pkgmgr.actions.mirror.git_remote import ensure_origin_remote
+from pkgmgr.actions.mirror.types import RepoMirrorContext
+
+
+class TestGitRemotePrimaryPush(unittest.TestCase):
+    def test_origin_created_and_extra_push_added(self) -> None:
+        repo = {"provider": "github.com", "account": "alice", "repository": "repo"}
+        ctx = RepoMirrorContext(
+            identifier="repo",
+            repo_dir="/tmp/repo",
+            config_mirrors={},
+            file_mirrors={
+                "primary": "git@github.com:alice/repo.git",
+                "backup": "git@github.com:alice/repo-backup.git",
+            },
+        )
+
+        executed: list[str] = []
+
+        def fake_run(cmd: str, cwd: str, preview: bool) -> None:
+            executed.append(cmd)
+
+        def fake_git(args, cwd):
+            if args == ["remote"]:
+                return ""
+            if args == ["remote", "get-url", "--push", "--all", "origin"]:
+                return "git@github.com:alice/repo.git\n"
+            return ""
+
+        with patch("os.path.isdir", return_value=True), patch(
+            "pkgmgr.actions.mirror.git_remote.run_command", side_effect=fake_run
+        ), patch(
+            "pkgmgr.actions.mirror.git_remote._safe_git_output", side_effect=fake_git
+        ):
+            ensure_origin_remote(repo, ctx, preview=False)
+
+        self.assertEqual(
+            executed,
+            [
+                "git remote add origin git@github.com:alice/repo.git",
+                "git remote set-url origin git@github.com:alice/repo.git",
+                "git remote set-url --push origin git@github.com:alice/repo.git",
+                "git remote set-url --add --push origin git@github.com:alice/repo-backup.git",
+            ],
+        )

tests/unit/pkgmgr/actions/mirror/test_setup_cmd.py

@@ -1,123 +1,101 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
 from __future__ import annotations
 
 import unittest
-from unittest.mock import MagicMock, PropertyMock, patch
+from unittest.mock import patch
 
 from pkgmgr.actions.mirror.setup_cmd import setup_mirrors
+from pkgmgr.actions.mirror.types import RepoMirrorContext
 
 
 class TestMirrorSetupCmd(unittest.TestCase):
-    """
+    def _ctx(
-    Unit tests for mirror setup orchestration (local + remote).
-    """
-
-    @patch("pkgmgr.actions.mirror.setup_cmd.ensure_origin_remote")
-    @patch("pkgmgr.actions.mirror.setup_cmd.build_context")
-    def test_setup_mirrors_local_calls_ensure_origin_remote(
         self,
-        mock_build_context,
+        *,
-        mock_ensure_origin,
+        repo_dir: str = "/tmp/repo",
-    ) -> None:
+        resolved: dict[str, str] | None = None,
-        ctx = MagicMock()
+    ) -> RepoMirrorContext:
-        ctx.identifier = "repo-id"
+        # RepoMirrorContext derives resolved via property (config + file)
-        ctx.repo_dir = "/tmp/repo"
+        # We feed mirrors via file_mirrors to keep insertion order realistic.
-        ctx.config_mirrors = {}
+        return RepoMirrorContext(
-        ctx.file_mirrors = {}
+            identifier="repo-id",
-        type(ctx).resolved_mirrors = PropertyMock(return_value={})
+            repo_dir=repo_dir,
-        mock_build_context.return_value = ctx
+            config_mirrors={},
+            file_mirrors=resolved or {},
+        )
 
-        repo = {"provider": "github.com", "account": "alice", "repository": "repo"}
+    @patch("pkgmgr.actions.mirror.setup_cmd.build_context")
+    @patch("pkgmgr.actions.mirror.setup_cmd.ensure_origin_remote")
+    def test_setup_mirrors_local_calls_ensure_origin_remote(self, m_ensure, m_ctx) -> None:
+        m_ctx.return_value = self._ctx(repo_dir="/tmp/repo", resolved={"primary": "git@x/y.git"})
 
+        repos = [{"provider": "github.com", "account": "alice", "repository": "repo"}]
         setup_mirrors(
-            selected_repos=[repo],
+            selected_repos=repos,
-            repositories_base_dir="/base",
+            repositories_base_dir="/tmp",
-            all_repos=[repo],
+            all_repos=repos,
             preview=True,
             local=True,
             remote=False,
             ensure_remote=False,
         )
 
-        mock_ensure_origin.assert_called_once()
+        self.assertEqual(m_ensure.call_count, 1)
-        args, kwargs = mock_ensure_origin.call_args
+        args, kwargs = m_ensure.call_args
-        self.assertEqual(args[0], repo)
+
-        self.assertEqual(kwargs.get("preview"), True)
+        # ensure_origin_remote(repo, ctx, preview) may be positional or kw.
+        # Accept both to avoid coupling tests to call style.
+        if "preview" in kwargs:
+            self.assertTrue(kwargs["preview"])
+        else:
+            # args: (repo, ctx, preview)
+            self.assertTrue(args[2])
 
-    @patch("pkgmgr.actions.mirror.setup_cmd.ensure_remote_repository")
-    @patch("pkgmgr.actions.mirror.setup_cmd.probe_mirror")
     @patch("pkgmgr.actions.mirror.setup_cmd.build_context")
-    def test_setup_mirrors_remote_provisions_when_enabled(
-        self,
-        mock_build_context,
-        mock_probe,
-        mock_ensure_remote_repository,
-    ) -> None:
-        ctx = MagicMock()
-        ctx.identifier = "repo-id"
-        ctx.repo_dir = "/tmp/repo"
-        ctx.config_mirrors = {"origin": "git@github.com:alice/repo.git"}
-        ctx.file_mirrors = {}
-        type(ctx).resolved_mirrors = PropertyMock(return_value={"origin": "git@github.com:alice/repo.git"})
-        mock_build_context.return_value = ctx
-
-        mock_probe.return_value = (True, "")
-
-        repo = {"provider": "github.com", "account": "alice", "repository": "repo"}
-
-        setup_mirrors(
-            selected_repos=[repo],
-            repositories_base_dir="/base",
-            all_repos=[repo],
-            preview=False,
-            local=False,
-            remote=True,
-            ensure_remote=True,
-        )
-
-        mock_ensure_remote_repository.assert_called_once()
-        mock_probe.assert_called_once()
-
-    @patch("pkgmgr.actions.mirror.setup_cmd.ensure_remote_repository")
     @patch("pkgmgr.actions.mirror.setup_cmd.probe_mirror")
-    @patch("pkgmgr.actions.mirror.setup_cmd.build_context")
+    @patch("pkgmgr.actions.mirror.setup_cmd.determine_primary_remote_url")
-    def test_setup_mirrors_remote_probes_all_resolved_mirrors(
+    def test_setup_mirrors_remote_no_mirrors_probes_primary(self, m_primary, m_probe, m_ctx) -> None:
-        self,
+        m_ctx.return_value = self._ctx(repo_dir="/tmp/repo", resolved={})
-        mock_build_context,
+        m_primary.return_value = "git@github.com:alice/repo.git"
-        mock_probe,
+        m_probe.return_value = (True, "")
-        mock_ensure_remote_repository,
-    ) -> None:
-        ctx = MagicMock()
-        ctx.identifier = "repo-id"
-        ctx.repo_dir = "/tmp/repo"
-        ctx.config_mirrors = {}
-        ctx.file_mirrors = {}
-        type(ctx).resolved_mirrors = PropertyMock(
-            return_value={
-                "mirror": "git@github.com:alice/repo.git",
-                "backup": "ssh://git@git.veen.world:2201/alice/repo.git",
-            }
-        )
-        mock_build_context.return_value = ctx
-
-        mock_probe.return_value = (True, "")
-
-        repo = {"provider": "github.com", "account": "alice", "repository": "repo"}
 
+        repos = [{"provider": "github.com", "account": "alice", "repository": "repo"}]
         setup_mirrors(
-            selected_repos=[repo],
+            selected_repos=repos,
-            repositories_base_dir="/base",
+            repositories_base_dir="/tmp",
-            all_repos=[repo],
+            all_repos=repos,
-            preview=False,
+            preview=True,
             local=False,
             remote=True,
             ensure_remote=False,
         )
 
-        mock_ensure_remote_repository.assert_not_called()
+        m_primary.assert_called()
-        self.assertEqual(mock_probe.call_count, 2)
+        m_probe.assert_called_with("git@github.com:alice/repo.git", "/tmp/repo")
+
+    @patch("pkgmgr.actions.mirror.setup_cmd.build_context")
+    @patch("pkgmgr.actions.mirror.setup_cmd.probe_mirror")
+    def test_setup_mirrors_remote_with_mirrors_probes_each(self, m_probe, m_ctx) -> None:
+        m_ctx.return_value = self._ctx(
+            repo_dir="/tmp/repo",
+            resolved={
+                "origin": "git@github.com:alice/repo.git",
+                "backup": "ssh://git@git.veen.world:2201/alice/repo.git",
+            },
+        )
+        m_probe.return_value = (True, "")
+
+        repos = [{"provider": "github.com", "account": "alice", "repository": "repo"}]
+        setup_mirrors(
+            selected_repos=repos,
+            repositories_base_dir="/tmp",
+            all_repos=repos,
+            preview=True,
+            local=False,
+            remote=True,
+            ensure_remote=False,
+        )
+
+        self.assertEqual(m_probe.call_count, 2)
 
 
 if __name__ == "__main__":

tests/unit/pkgmgr/cli/commands/test_release_publish_hook.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import os
+import tempfile
+import unittest
+from types import SimpleNamespace
+from unittest.mock import patch
+
+
+class TestCLIReleasePublishHook(unittest.TestCase):
+    def _ctx(self) -> SimpleNamespace:
+        # Minimal CLIContext shape used by handle_release
+        return SimpleNamespace(
+            repositories_base_dir="/tmp",
+            all_repositories=[],
+        )
+
+    def test_release_runs_publish_by_default_and_respects_tty(self) -> None:
+        from pkgmgr.cli.commands.release import handle_release
+
+        with tempfile.TemporaryDirectory() as td:
+            repo = {"directory": td}
+
+            args = SimpleNamespace(
+                list=False,
+                release_type="patch",
+                message=None,
+                preview=False,
+                force=False,
+                close=False,
+                no_publish=False,
+            )
+
+            with patch("pkgmgr.cli.commands.release.run_release") as m_release, patch(
+                "pkgmgr.cli.commands.release.run_publish"
+            ) as m_publish, patch(
+                "pkgmgr.cli.commands.release.sys.stdin.isatty", return_value=False
+            ):
+                handle_release(args=args, ctx=self._ctx(), selected=[repo])
+
+            m_release.assert_called_once()
+            m_publish.assert_called_once()
+
+            _, kwargs = m_publish.call_args
+            self.assertEqual(kwargs["repo"], repo)
+            self.assertEqual(kwargs["repo_dir"], td)
+            self.assertFalse(kwargs["interactive"])
+            self.assertFalse(kwargs["allow_prompt"])
+
+    def test_release_skips_publish_when_no_publish_flag_set(self) -> None:
+        from pkgmgr.cli.commands.release import handle_release
+
+        with tempfile.TemporaryDirectory() as td:
+            repo = {"directory": td}
+
+            args = SimpleNamespace(
+                list=False,
+                release_type="patch",
+                message=None,
+                preview=False,
+                force=False,
+                close=False,
+                no_publish=True,
+            )
+
+            with patch("pkgmgr.cli.commands.release.run_release") as m_release, patch(
+                "pkgmgr.cli.commands.release.run_publish"
+            ) as m_publish:
+                handle_release(args=args, ctx=self._ctx(), selected=[repo])
+
+            m_release.assert_called_once()
+            m_publish.assert_not_called()
+
+
+if __name__ == "__main__":
+    unittest.main()