gpt-5.2: fix tests and imports after git queries split

https://chatgpt.com/share/694135eb-10a8-800f-8b12-968612f605c7

Gemini
https://ai.studio/apps/drive/1QO9MaEklm2zZMDZ6XPP0LStuAooXs1NO

.github/workflows/ci.yml

@@ -28,8 +28,8 @@ jobs:
   test-virgin-root:
     uses: ./.github/workflows/test-virgin-root.yml
 
-  linter-shell:
-    uses: ./.github/workflows/linter-shell.yml
+  lint-shell:
+    uses: ./.github/workflows/lint-shell.yml
 
-  linter-python:
-    uses: ./.github/workflows/linter-python.yml
+  lint-python:
+    uses: ./.github/workflows/lint-python.yml

.github/workflows/lint-python.yml

@@ -4,7 +4,7 @@ on:
   workflow_call:
 
 jobs:
-  linter-python:
+  lint-python:
     runs-on: ubuntu-latest
 
     steps:

.github/workflows/lint-shell.yml

@@ -4,7 +4,7 @@ on:
   workflow_call:
 
 jobs:
-  linter-shell:
+  lint-shell:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4

.github/workflows/mark-stable.yml

@@ -29,16 +29,16 @@ jobs:
   test-virgin-root:
     uses: ./.github/workflows/test-virgin-root.yml
 
-  linter-shell:
-    uses: ./.github/workflows/linter-shell.yml
+  lint-shell:
+    uses: ./.github/workflows/lint-shell.yml
 
-  linter-python:
-    uses: ./.github/workflows/linter-python.yml
+  lint-python:
+    uses: ./.github/workflows/lint-python.yml
 
   mark-stable:
     needs:
-      - linter-shell
-      - linter-python
+      - lint-shell
+      - lint-python
       - test-unit
       - test-integration
       - test-env-nix

CHANGELOG.md

@@ -1,3 +1,36 @@
+## [1.8.0] - 2025-12-15
+
+* *** New Features: ***
+- **Silent Updates**: You can now use the `--silent` flag during installs and updates to suppress error messages for individual repositories and get a single summary at the end. This ensures the process continues even if some repositories fail, while still preserving interactive checks when not in silent mode.
+- **Repository Scaffolding**: The process for creating new repositories has been improved. You can now use templates to scaffold repositories with a preview and automatic mirror setup.
+
+*** Bug Fixes: ***
+- **Pip Installation**: Pip is now installed automatically on all supported systems. This includes `python-pip` for Arch and `python3-pip` for CentOS, Debian, Fedora, and Ubuntu, ensuring that pip is available for Python package installations.
+- **Pacman Keyring**: Fixed an issue on Arch Linux where package installation would fail due to missing keys. The pacman keyring is now properly initialized before installing packages.
+
+
+## [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
+
+
+## [1.7.0] - 2025-12-14
+
+* * New *pkgmgr publish* command to publish repository artifacts to PyPI based on the *MIRRORS* file.
+* Automatically selects the current repository when no explicit selection is given.
+* Publishes only when a semantic version tag is present on *HEAD*; otherwise skips with a clear info message.
+* Supports non-interactive mode for CI environments via *--non-interactive*.
+
+
 ## [1.6.4] - 2025-12-14
 
 * * Improved reliability of Nix installs and updates, including automatic resolution of profile conflicts and better handling of GitHub 403 rate limits.

MIRRORS

@@ -1,3 +1,4 @@
 git@github.com:kevinveenbirkenbach/package-manager.git
 ssh://git@git.veen.world:2201/kevinveenbirkenbach/pkgmgr.git
 ssh://git@code.infinito.nexus:2201/kevinveenbirkenbach/pkgmgr.git
+https://pypi.org/project/kpmx/

flake.nix

@@ -32,7 +32,7 @@
         rec {
           pkgmgr = pyPkgs.buildPythonApplication {
             pname   = "package-manager";
-            version = "1.6.4";
+            version = "1.8.0";
 
             # Use the git repo as source
             src = ./.;
@@ -49,6 +49,7 @@
             # Runtime dependencies (matches [project.dependencies] in pyproject.toml)
             propagatedBuildInputs = [
               pyPkgs.pyyaml
+              pyPkgs.jinja2
               pyPkgs.pip
             ];
 
@@ -78,6 +79,7 @@
           pythonWithDeps = python.withPackages (ps: [
             ps.pip
             ps.pyyaml
+            ps.jinja2
           ]);
         in
         {

packaging/arch/PKGBUILD

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

packaging/debian/changelog

@@ -1,3 +1,40 @@
+package-manager (1.8.0-1) unstable; urgency=medium
+
+  * *** New Features: ***
+- **Silent Updates**: You can now use the `--silent` flag during installs and updates to suppress error messages for individual repositories and get a single summary at the end. This ensures the process continues even if some repositories fail, while still preserving interactive checks when not in silent mode.
+- **Repository Scaffolding**: The process for creating new repositories has been improved. You can now use templates to scaffold repositories with a preview and automatic mirror setup.
+
+*** Bug Fixes: ***
+- **Pip Installation**: Pip is now installed automatically on all supported systems. This includes `python-pip` for Arch and `python3-pip` for CentOS, Debian, Fedora, and Ubuntu, ensuring that pip is available for Python package installations.
+- **Pacman Keyring**: Fixed an issue on Arch Linux where package installation would fail due to missing keys. The pacman keyring is now properly initialized before installing packages.
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Mon, 15 Dec 2025 13:37:42 +0100
+
+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
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Sun, 14 Dec 2025 21:19:11 +0100
+
+package-manager (1.7.0-1) unstable; urgency=medium
+
+  * * New *pkgmgr publish* command to publish repository artifacts to PyPI based on the *MIRRORS* file.
+* Automatically selects the current repository when no explicit selection is given.
+* Publishes only when a semantic version tag is present on *HEAD*; otherwise skips with a clear info message.
+* Supports non-interactive mode for CI environments via *--non-interactive*.
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Sun, 14 Dec 2025 21:10:06 +0100
+
 package-manager (1.6.4-1) unstable; urgency=medium
 
   * * Improved reliability of Nix installs and updates, including automatic resolution of profile conflicts and better handling of GitHub 403 rate limits.

packaging/fedora/package-manager.spec

@@ -1,5 +1,5 @@
 Name:           package-manager
-Version:        1.6.4
+Version:        1.8.0
 Release:        1%{?dist}
 Summary:        Wrapper that runs Kevin's package-manager via Nix flake
 
@@ -74,6 +74,31 @@ 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.8.0-1
+- *** New Features: ***
+- **Silent Updates**: You can now use the `--silent` flag during installs and updates to suppress error messages for individual repositories and get a single summary at the end. This ensures the process continues even if some repositories fail, while still preserving interactive checks when not in silent mode.
+- **Repository Scaffolding**: The process for creating new repositories has been improved. You can now use templates to scaffold repositories with a preview and automatic mirror setup.
+
+*** Bug Fixes: ***
+- **Pip Installation**: Pip is now installed automatically on all supported systems. This includes `python-pip` for Arch and `python3-pip` for CentOS, Debian, Fedora, and Ubuntu, ensuring that pip is available for Python package installations.
+- **Pacman Keyring**: Fixed an issue on Arch Linux where package installation would fail due to missing keys. The pacman keyring is now properly initialized before installing packages.
+
+* 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
+
+* Sun Dec 14 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 1.7.0-1
+- * New *pkgmgr publish* command to publish repository artifacts to PyPI based on the *MIRRORS* file.
+* Automatically selects the current repository when no explicit selection is given.
+* Publishes only when a semantic version tag is present on *HEAD*; otherwise skips with a clear info message.
+* Supports non-interactive mode for CI environments via *--non-interactive*.
+
 * Sun Dec 14 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 1.6.4-1
 - * Improved reliability of Nix installs and updates, including automatic resolution of profile conflicts and better handling of GitHub 403 rate limits.
 * More stable launcher behavior in packaged and virtual-env setups.

pyproject.toml

@@ -6,8 +6,8 @@ requires = [
 build-backend = "setuptools.build_meta"
 
 [project]
-name = "package-manager"
-version = "1.6.4"
+name = "kpmx"
+version = "1.8.0"
 description = "Kevin's package-manager tool (pkgmgr)"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -21,6 +21,7 @@ authors = [
 dependencies = [
   "PyYAML>=6.0",
   "tomli; python_version < \"3.11\"",
+  "jinja2>=3.1"
 ]
 
 [project.urls]

scripts/installation/arch/dependencies.sh

@@ -6,6 +6,13 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 echo "[arch/dependencies] Installing Arch build dependencies..."
 
 pacman -Syu --noconfirm
+
+if ! pacman-key --list-sigs &>/dev/null; then
+    echo "[arch/dependencies] Initializing pacman keyring..."
+    pacman-key --init
+    pacman-key --populate archlinux
+fi
+
 pacman -S --noconfirm --needed \
   base-devel \
   git \
@@ -13,6 +20,7 @@ pacman -S --noconfirm --needed \
   curl \
   ca-certificates \
   python \
+  python-pip \
   xz
 
 pacman -Scc --noconfirm

scripts/installation/centos/dependencies.sh

@@ -14,6 +14,7 @@ dnf -y install \
   curl-minimal \
   ca-certificates \
   python3 \
+  python3-pip \
   sudo \
   xz
 

scripts/installation/debian/dependencies.sh

@@ -15,6 +15,7 @@ DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
   ca-certificates \
   python3 \
   python3-venv \
+  python3-pip \
   xz-utils
 
 rm -rf /var/lib/apt/lists/*

scripts/installation/fedora/dependencies.sh

@@ -14,6 +14,7 @@ dnf -y install \
   curl \
   ca-certificates \
   python3 \
+  python3-pip \
   xz
 
 dnf clean all

scripts/installation/ubuntu/dependencies.sh

@@ -17,6 +17,7 @@ DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
   make \
   python3 \
   python3-venv \
+  python3-pip \
   ca-certificates \
   xz-utils
 

src/pkgmgr/actions/__init__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+# expose subpackages for patch() / resolve_name() friendliness
+from . import release as release  # noqa: F401
+
+__all__ = ["release"]

src/pkgmgr/actions/branch/close_branch.py

@@ -1,7 +1,21 @@
 from __future__ import annotations
+
 from typing import Optional
-from pkgmgr.core.git import run_git, GitError, get_current_branch
-from .utils import _resolve_base_branch
+
+from pkgmgr.core.git.errors import GitError
+from pkgmgr.core.git.queries import get_current_branch
+from pkgmgr.core.git.commands import (
+    GitDeleteRemoteBranchError,
+    checkout,
+    delete_local_branch,
+    delete_remote_branch,
+    fetch,
+    merge_no_ff,
+    pull,
+    push,
+)
+
+from pkgmgr.core.git.queries import resolve_base_branch
 
 
 def close_branch(
@@ -14,7 +28,6 @@ def close_branch(
     """
     Merge a feature branch into the base branch and delete it afterwards.
     """
-
     # Determine branch name
     if not name:
         try:
@@ -25,7 +38,7 @@ def close_branch(
     if not name:
         raise RuntimeError("Branch name must not be empty.")
 
-    target_base = _resolve_base_branch(base_branch, fallback_base, cwd=cwd)
+    target_base = resolve_base_branch(base_branch, fallback_base, cwd=cwd)
 
     if name == target_base:
         raise RuntimeError(
@@ -42,58 +55,20 @@ def close_branch(
             print("Aborted closing branch.")
             return
 
-    # Fetch
-    try:
-        run_git(["fetch", "origin"], cwd=cwd)
-    except GitError as exc:
-        raise RuntimeError(
-            f"Failed to fetch from origin before closing branch {name!r}: {exc}"
-        ) from exc
+    # Execute workflow (commands raise specific GitError subclasses)
+    fetch("origin", cwd=cwd)
+    checkout(target_base, cwd=cwd)
+    pull("origin", target_base, cwd=cwd)
+    merge_no_ff(name, cwd=cwd)
+    push("origin", target_base, cwd=cwd)
 
-    # Checkout base
-    try:
-        run_git(["checkout", target_base], cwd=cwd)
-    except GitError as exc:
-        raise RuntimeError(
-            f"Failed to checkout base branch {target_base!r}: {exc}"
-        ) from exc
+    # Delete local branch (safe delete by default)
+    delete_local_branch(name, cwd=cwd, force=False)
 
-    # Pull latest
+    # Delete remote branch (special-case error message)
     try:
-        run_git(["pull", "origin", target_base], cwd=cwd)
-    except GitError as exc:
-        raise RuntimeError(
-            f"Failed to pull latest changes for base branch {target_base!r}: {exc}"
-        ) from exc
-
-    # Merge
-    try:
-        run_git(["merge", "--no-ff", name], cwd=cwd)
-    except GitError as exc:
-        raise RuntimeError(
-            f"Failed to merge branch {name!r} into {target_base!r}: {exc}"
-        ) from exc
-
-    # Push result
-    try:
-        run_git(["push", "origin", target_base], cwd=cwd)
-    except GitError as exc:
-        raise RuntimeError(
-            f"Failed to push base branch {target_base!r} after merge: {exc}"
-        ) from exc
-
-    # Delete local
-    try:
-        run_git(["branch", "-d", name], cwd=cwd)
-    except GitError as exc:
-        raise RuntimeError(
-            f"Failed to delete local branch {name!r}: {exc}"
-        ) from exc
-
-    # Delete remote
-    try:
-        run_git(["push", "origin", "--delete", name], cwd=cwd)
-    except GitError as exc:
+        delete_remote_branch("origin", name, cwd=cwd)
+    except GitDeleteRemoteBranchError as exc:
         raise RuntimeError(
             f"Branch {name!r} deleted locally, but remote deletion failed: {exc}"
         ) from exc

src/pkgmgr/actions/branch/drop_branch.py

@@ -1,7 +1,16 @@
 from __future__ import annotations
+
 from typing import Optional
-from pkgmgr.core.git import run_git, GitError, get_current_branch
-from .utils import _resolve_base_branch
+
+from pkgmgr.core.git.errors import GitError
+from pkgmgr.core.git.queries import get_current_branch
+from pkgmgr.core.git.commands import (
+    GitDeleteRemoteBranchError,
+    delete_local_branch,
+    delete_remote_branch,
+)
+
+from pkgmgr.core.git.queries import resolve_base_branch
 
 
 def drop_branch(
@@ -14,7 +23,6 @@ def drop_branch(
     """
     Delete a branch locally and remotely without merging.
     """
-
     if not name:
         try:
             name = get_current_branch(cwd=cwd)
@@ -24,7 +32,7 @@ def drop_branch(
     if not name:
         raise RuntimeError("Branch name must not be empty.")
 
-    target_base = _resolve_base_branch(base_branch, fallback_base, cwd=cwd)
+    target_base = resolve_base_branch(base_branch, fallback_base, cwd=cwd)
 
     if name == target_base:
         raise RuntimeError(
@@ -40,16 +48,12 @@ def drop_branch(
             print("Aborted dropping branch.")
             return
 
-    # Local delete
+    delete_local_branch(name, cwd=cwd, force=False)
+    
+    # Remote delete (special-case message)
     try:
-        run_git(["branch", "-d", name], cwd=cwd)
-    except GitError as exc:
-        raise RuntimeError(f"Failed to delete local branch {name!r}: {exc}") from exc
-
-    # Remote delete
-    try:
-        run_git(["push", "origin", "--delete", name], cwd=cwd)
-    except GitError as exc:
+        delete_remote_branch("origin", name, cwd=cwd)
+    except GitDeleteRemoteBranchError as exc:
         raise RuntimeError(
             f"Branch {name!r} was deleted locally, but remote deletion failed: {exc}"
         ) from exc

src/pkgmgr/actions/branch/open_branch.py

@@ -1,7 +1,15 @@
 from __future__ import annotations
+
 from typing import Optional
-from pkgmgr.core.git import run_git, GitError
-from .utils import _resolve_base_branch
+
+from pkgmgr.core.git.commands import (
+    checkout,
+    create_branch,
+    fetch,
+    pull,
+    push_upstream,
+)
+from pkgmgr.core.git.queries import resolve_base_branch
 
 
 def open_branch(
@@ -13,7 +21,6 @@ def open_branch(
     """
     Create and push a new feature branch on top of a base branch.
     """
-
     # Request name interactively if not provided
     if not name:
         name = input("Enter new branch name: ").strip()
@@ -21,44 +28,13 @@ def open_branch(
     if not name:
         raise RuntimeError("Branch name must not be empty.")
 
-    resolved_base = _resolve_base_branch(base_branch, fallback_base, cwd=cwd)
+    resolved_base = resolve_base_branch(base_branch, fallback_base, cwd=cwd)
 
-    # 1) Fetch from origin
-    try:
-        run_git(["fetch", "origin"], cwd=cwd)
-    except GitError as exc:
-        raise RuntimeError(
-            f"Failed to fetch from origin before creating branch {name!r}: {exc}"
-        ) from exc
+    # Workflow (commands raise specific GitError subclasses)
+    fetch("origin", cwd=cwd)
+    checkout(resolved_base, cwd=cwd)
+    pull("origin", resolved_base, cwd=cwd)
 
-    # 2) Checkout base branch
-    try:
-        run_git(["checkout", resolved_base], cwd=cwd)
-    except GitError as exc:
-        raise RuntimeError(
-            f"Failed to checkout base branch {resolved_base!r}: {exc}"
-        ) from exc
-
-    # 3) Pull latest changes
-    try:
-        run_git(["pull", "origin", resolved_base], cwd=cwd)
-    except GitError as exc:
-        raise RuntimeError(
-            f"Failed to pull latest changes for base branch {resolved_base!r}: {exc}"
-        ) from exc
-
-    # 4) Create new branch
-    try:
-        run_git(["checkout", "-b", name], cwd=cwd)
-    except GitError as exc:
-        raise RuntimeError(
-            f"Failed to create new branch {name!r} from base {resolved_base!r}: {exc}"
-        ) from exc
-
-    # 5) Push new branch
-    try:
-        run_git(["push", "-u", "origin", name], cwd=cwd)
-    except GitError as exc:
-        raise RuntimeError(
-            f"Failed to push new branch {name!r} to origin: {exc}"
-        ) from exc
+    # Create new branch from resolved base and push it with upstream tracking
+    create_branch(name, resolved_base, cwd=cwd)
+    push_upstream("origin", name, cwd=cwd)

src/pkgmgr/actions/branch/utils.py

@@ -1,27 +0,0 @@
-from __future__ import annotations
-from pkgmgr.core.git import run_git, GitError
-
-
-def _resolve_base_branch(
-    preferred: str,
-    fallback: str,
-    cwd: str,
-) -> str:
-    """
-    Resolve the base branch to use.
-
-    Try `preferred` first (default: main),
-    fall back to `fallback` (default: master).
-
-    Raise RuntimeError if neither exists.
-    """
-    for candidate in (preferred, fallback):
-        try:
-            run_git(["rev-parse", "--verify", candidate], cwd=cwd)
-            return candidate
-        except GitError:
-            continue
-
-    raise RuntimeError(
-        f"Neither {preferred!r} nor {fallback!r} exist in this repository."
-    )

src/pkgmgr/actions/changelog/__init__.py

@@ -3,17 +3,16 @@
 
 """
 Helpers to generate changelog information from Git history.
-
-This module provides a small abstraction around `git log` so that
-CLI commands can request a changelog between two refs (tags, branches,
-commits) without dealing with raw subprocess calls.
 """
 
 from __future__ import annotations
 
 from typing import Optional
 
-from pkgmgr.core.git import run_git, GitError
+from pkgmgr.core.git.queries import (
+    get_changelog,
+    GitChangelogQueryError,
+)
 
 
 def generate_changelog(
@@ -25,48 +24,20 @@ def generate_changelog(
     """
     Generate a plain-text changelog between two Git refs.
 
-    Parameters
-    ----------
-    cwd:
-        Repository directory in which to run Git commands.
-    from_ref:
-        Optional starting reference (exclusive). If provided together
-        with `to_ref`, the range `from_ref..to_ref` is used.
-        If only `from_ref` is given, the range `from_ref..HEAD` is used.
-    to_ref:
-        Optional end reference (inclusive). If omitted, `HEAD` is used.
-    include_merges:
-        If False (default), merge commits are filtered out.
-
-    Returns
-    -------
-    str
-        The output of `git log` formatted as a simple text changelog.
-        If no commits are found or Git fails, an explanatory message
-        is returned instead of raising.
+    Returns a human-readable message instead of raising.
     """
-    # Determine the revision range
     if to_ref is None:
         to_ref = "HEAD"
 
-    if from_ref:
-        rev_range = f"{from_ref}..{to_ref}"
-    else:
-        rev_range = to_ref
-
-    # Use a custom pretty format that includes tags/refs (%d)
-    cmd = [
-        "log",
-        "--pretty=format:%h %d %s",
-    ]
-    if not include_merges:
-        cmd.append("--no-merges")
-    cmd.append(rev_range)
-
+    rev_range = f"{from_ref}..{to_ref}" if from_ref else to_ref
     try:
-        output = run_git(cmd, cwd=cwd)
-    except GitError as exc:
-        # Do not raise to the CLI, return a human-readable error instead.
+        output = get_changelog(
+            cwd=cwd,
+            from_ref=from_ref,
+            to_ref=to_ref,
+            include_merges=include_merges,
+        )
+    except GitChangelogQueryError as exc:
         return (
             f"[ERROR] Failed to generate changelog in {cwd!r} "
             f"for range {rev_range!r}:\n{exc}"

src/pkgmgr/actions/install/__init__.py

@@ -16,7 +16,7 @@ Responsibilities:
 from __future__ import annotations
 
 import os
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 from pkgmgr.core.repository.identifier import get_repo_identifier
 from pkgmgr.core.repository.dir import get_repo_dir
@@ -93,6 +93,7 @@ def _verify_repo(
     repo_dir: str,
     no_verification: bool,
     identifier: str,
+    silent: bool,
 ) -> bool:
     """
     Verify a repository using the configured verification data.
@@ -111,10 +112,15 @@ def _verify_repo(
         print(f"Warning: Verification failed for {identifier}:")
         for err in errors:
             print(f"  - {err}")
-        choice = input("Continue anyway? [y/N]: ").strip().lower()
-        if choice != "y":
-            print(f"Skipping installation for {identifier}.")
-            return False
+
+        if silent:
+            # Non-interactive mode: continue with a warning.
+            print(f"[Warning] Continuing despite verification failure for {identifier} (--silent).")
+        else:
+            choice = input("Continue anyway? [y/N]: ").strip().lower()
+            if choice != "y":
+                print(f"Skipping installation for {identifier}.")
+                return False
 
     return True
 
@@ -163,6 +169,8 @@ def install_repos(
     clone_mode: str,
     update_dependencies: bool,
     force_update: bool = False,
+    silent: bool = False,
+    emit_summary: bool = True,
 ) -> None:
     """
     Install one or more repositories according to the configured installers
@@ -170,45 +178,72 @@ def install_repos(
 
     If force_update=True, installers of the currently active layer are allowed
     to run again (upgrade/refresh), even if that layer is already loaded.
+
+    If silent=True, repository failures are downgraded to warnings and the
+    overall command never exits non-zero because of per-repository failures.
     """
     pipeline = InstallationPipeline(INSTALLERS)
+    failures: List[Tuple[str, str]] = []
 
     for repo in selected_repos:
         identifier = get_repo_identifier(repo, all_repos)
 
-        repo_dir = _ensure_repo_dir(
-            repo=repo,
-            repositories_base_dir=repositories_base_dir,
-            all_repos=all_repos,
-            preview=preview,
-            no_verification=no_verification,
-            clone_mode=clone_mode,
-            identifier=identifier,
-        )
-        if not repo_dir:
+        try:
+            repo_dir = _ensure_repo_dir(
+                repo=repo,
+                repositories_base_dir=repositories_base_dir,
+                all_repos=all_repos,
+                preview=preview,
+                no_verification=no_verification,
+                clone_mode=clone_mode,
+                identifier=identifier,
+            )
+            if not repo_dir:
+                failures.append((identifier, "clone/ensure repo directory failed"))
+                continue
+
+            if not _verify_repo(
+                repo=repo,
+                repo_dir=repo_dir,
+                no_verification=no_verification,
+                identifier=identifier,
+                silent=silent,
+            ):
+                continue
+
+            ctx = _create_context(
+                repo=repo,
+                identifier=identifier,
+                repo_dir=repo_dir,
+                repositories_base_dir=repositories_base_dir,
+                bin_dir=bin_dir,
+                all_repos=all_repos,
+                no_verification=no_verification,
+                preview=preview,
+                quiet=quiet,
+                clone_mode=clone_mode,
+                update_dependencies=update_dependencies,
+                force_update=force_update,
+            )
+
+            pipeline.run(ctx)
+
+        except SystemExit as exc:
+            code = exc.code if isinstance(exc.code, int) else str(exc.code)
+            failures.append((identifier, f"installer failed (exit={code})"))
+            if not quiet:
+                print(f"[Warning] install: repository {identifier} failed (exit={code}). Continuing...")
+            continue
+        except Exception as exc:
+            failures.append((identifier, f"unexpected error: {exc}"))
+            if not quiet:
+                print(f"[Warning] install: repository {identifier} hit an unexpected error: {exc}. Continuing...")
             continue
 
-        if not _verify_repo(
-            repo=repo,
-            repo_dir=repo_dir,
-            no_verification=no_verification,
-            identifier=identifier,
-        ):
-            continue
+    if failures and emit_summary and not quiet:
+        print("\n[pkgmgr] Installation finished with warnings:")
+        for ident, msg in failures:
+            print(f"  - {ident}: {msg}")
 
-        ctx = _create_context(
-            repo=repo,
-            identifier=identifier,
-            repo_dir=repo_dir,
-            repositories_base_dir=repositories_base_dir,
-            bin_dir=bin_dir,
-            all_repos=all_repos,
-            no_verification=no_verification,
-            preview=preview,
-            quiet=quiet,
-            clone_mode=clone_mode,
-            update_dependencies=update_dependencies,
-            force_update=force_update,
-        )
-
-        pipeline.run(ctx)
+    if failures and not silent:
+        raise SystemExit(1)

src/pkgmgr/actions/mirror/git_remote.py

@@ -1,20 +1,26 @@
 from __future__ import annotations
 
 import os
+from typing import 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 pkgmgr.core.git.errors import GitError
+from pkgmgr.core.git.commands import (
+    GitAddRemoteError,
+    GitAddRemotePushUrlError,
+    GitSetRemoteUrlError,
+    add_remote,
+    add_remote_push_url,
+    set_remote_url,
+)
+from pkgmgr.core.git.queries import (
+    get_remote_push_urls,
+    list_remotes,
+)
 
 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,96 +29,73 @@ 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:
-
-      1. resolved_mirrors["origin"]
-      2. any resolved mirror (first by name)
-      3. default SSH URL from provider/account/repository
+    Priority order:
+      1. origin from resolved mirrors
+      2. MIRRORS file order
+      3. config mirrors order
+      4. default SSH URL
     """
-    if "origin" in resolved_mirrors:
-        return resolved_mirrors["origin"]
+    resolved = ctx.resolved_mirrors
 
-    if resolved_mirrors:
-        first_name = sorted(resolved_mirrors.keys())[0]
-        return resolved_mirrors[first_name]
+    if resolved.get("origin"):
+        return resolved["origin"]
+
+    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:
-    """
-    Check whether a remote called 'origin' exists in the repository.
-    """
-    output = _safe_git_output(["remote"], cwd=repo_dir)
-    if not output:
+    try:
+        return "origin" in list_remotes(cwd=repo_dir)
+    except GitError:
         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:
+    """
+    Ensure origin has fetch URL and push URL set to the primary URL.
+    Preview is handled by the underlying git runner.
+    """
+    set_remote_url("origin", url, cwd=repo_dir, push=False, preview=preview)
+    set_remote_url("origin", url, cwd=repo_dir, push=True, preview=preview)
+
+
+def _ensure_additional_push_urls(
     repo_dir: str,
     mirrors: MirrorMap,
+    primary: str,
     preview: bool,
 ) -> None:
     """
-    Ensure that all mirror URLs are present as push URLs on 'origin'.
+    Ensure all mirror URLs (except primary) are configured as additional push URLs for origin.
+    Preview is handled by the underlying git runner.
     """
-    desired: Set[str] = {url for url in mirrors.values() if url}
+    desired: Set[str] = {u for u in mirrors.values() if u and u != primary}
     if not desired:
         return
 
-    existing_output = _safe_git_output(
-        ["remote", "get-url", "--push", "--all", "origin"],
-        cwd=repo_dir,
-    )
-    existing = set(existing_output.splitlines()) if existing_output else set()
+    try:
+        existing = get_remote_push_urls("origin", cwd=repo_dir)
+    except GitError:
+        existing = set()
 
-    missing = 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)
+    for url in sorted(desired - existing):
+        add_remote_push_url("origin", url, cwd=repo_dir, preview=preview)
 
 
 def ensure_origin_remote(
@@ -120,60 +103,34 @@ 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
 
+    # 1) Ensure origin exists
     if not has_origin_remote(repo_dir):
-        if not url:
-            print(
-                "[WARN] Could not determine URL for 'origin' remote. "
-                "Please configure mirrors or provider/account/repository."
-            )
-            return
+        try:
+            add_remote("origin", primary, cwd=repo_dir, preview=preview)
+        except GitAddRemoteError as exc:
+            print(f"[WARN] Failed to add origin remote: {exc}")
+            return  # without origin we cannot reliably proceed
 
-        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
-    _ensure_push_urls_for_origin(repo_dir, resolved_mirrors, 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()
+    # 2) Ensure origin fetch+push URLs are correct (ALWAYS, even if origin already existed)
     try:
-        # --exit-code → non-zero exit code if the remote does not exist
-        run_git(["ls-remote", "--exit-code", url], cwd=workdir)
-        return True
-    except GitError:
-        return False
+        _set_origin_fetch_and_push(repo_dir, primary, preview)
+    except GitSetRemoteUrlError as exc:
+        # Do not abort: still try to add additional push URLs
+        print(f"[WARN] Failed to set origin URLs: {exc}")
+
+    # 3) Ensure additional push URLs for mirrors
+    try:
+        _ensure_additional_push_urls(repo_dir, ctx.resolved_mirrors, primary, preview)
+    except GitAddRemotePushUrlError as exc:
+        print(f"[WARN] Failed to add additional push URLs: {exc}")

src/pkgmgr/actions/mirror/remote_check.py

@@ -1,21 +0,0 @@
-# src/pkgmgr/actions/mirror/remote_check.py
-from __future__ import annotations
-
-from typing import Tuple
-
-from pkgmgr.core.git import GitError, run_git
-
-
-def probe_mirror(url: str, repo_dir: str) -> Tuple[bool, str]:
-    """
-    Probe a remote mirror URL using `git ls-remote`.
-
-    Returns:
-      (True, "") on success,
-      (False, error_message) on failure.
-    """
-    try:
-        run_git(["ls-remote", url], cwd=repo_dir)
-        return True, ""
-    except GitError as exc:
-        return False, str(exc)

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:
-        print("[WARN] Could not derive host/owner/repository from URL; cannot ensure remote repo.")
-        print(f"       url={primary_url!r}")
-        print(f"       host={host!r}, owner={owner_from_url!r}, repository={name_from_url!r}")
+    if not host or not owner or not name:
+        print("[WARN] Could not parse remote URL:", primary_url)
         return
 
-    print("------------------------------------------------------------")
-    print(f"[REMOTE ENSURE] {ctx.identifier}")
-    print(f"[REMOTE ENSURE] host: {host}")
-    print("------------------------------------------------------------")
-
     spec = RepoSpec(
-        host=str(host),
-        owner=str(owner_from_url),
-        name=str(name_from_url),
+        host=host,
+        owner=owner,
+        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,14 +1,14 @@
-# src/pkgmgr/actions/mirror/setup_cmd.py
 from __future__ import annotations
 
 from typing import List
 
 from .context import build_context
 from .git_remote import ensure_origin_remote, determine_primary_remote_url
-from .remote_check import probe_mirror
+from pkgmgr.core.git.queries import probe_remote_reachable
 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,23 @@ def _setup_remote_mirrors_for_repo(
     if ensure_remote:
         ensure_remote_repository(
             repo,
-            repositories_base_dir=repositories_base_dir,
-            all_repos=all_repos,
-            preview=preview,
+            repositories_base_dir,
+            all_repos,
+            preview,
         )
 
-    if not resolved_mirrors:
-        primary_url = determine_primary_remote_url(repo, resolved_mirrors)
-        if not primary_url:
-            print("[INFO] No mirrors configured and no primary URL available.")
-            print()
+    if not ctx.resolved_mirrors:
+        primary = determine_primary_remote_url(repo, ctx)
+        if not primary:
             return
-
-        ok, error_message = probe_mirror(primary_url, ctx.repo_dir)
-        if ok:
-            print(f"[OK] primary: {primary_url}")
-        else:
-            print(f"[WARN] primary: {primary_url}")
-            for line in error_message.splitlines():
-                print(f"         {line}")
-
+        ok = probe_remote_reachable(primary, cwd=ctx.repo_dir)
+        print("[OK]" if ok else "[WARN]", primary)
         print()
         return
 
-    for name, url in sorted(resolved_mirrors.items()):
-        ok, error_message = probe_mirror(url, ctx.repo_dir)
-        if ok:
-            print(f"[OK] {name}: {url}")
-        else:
-            print(f"[WARN] {name}: {url}")
-            for line in error_message.splitlines():
-                print(f"         {line}")
+    for name, url in ctx.resolved_mirrors.items():
+        ok = probe_remote_reachable(url, cwd=ctx.repo_dir)
+        print(f"[OK] {name}: {url}" if ok else f"[WARN] {name}: {url}")
 
     print()
 
@@ -91,17 +76,17 @@ def setup_mirrors(
     for repo in selected_repos:
         if local:
             _setup_local_mirrors_for_repo(
-                repo=repo,
-                repositories_base_dir=repositories_base_dir,
-                all_repos=all_repos,
-                preview=preview,
+                repo,
+                repositories_base_dir,
+                all_repos,
+                preview,
             )
 
         if remote:
             _setup_remote_mirrors_for_repo(
-                repo=repo,
-                repositories_base_dir=repositories_base_dir,
-                all_repos=all_repos,
-                preview=preview,
-                ensure_remote=ensure_remote,
+                repo,
+                repositories_base_dir,
+                all_repos,
+                preview,
+                ensure_remote,
             )

src/pkgmgr/actions/publish/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from .workflow import publish
+
+__all__ = ["publish"]

src/pkgmgr/actions/publish/git_tags.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from pkgmgr.core.git.queries import get_tags_at_ref
+from pkgmgr.core.version.semver import SemVer, is_semver_tag
+
+
+def head_semver_tags(cwd: str = ".") -> list[str]:
+    tags = get_tags_at_ref("HEAD", cwd=cwd)
+    tags = [t for t in tags if is_semver_tag(t) and t.startswith("v")]
+    return sorted(tags, key=SemVer.parse)

src/pkgmgr/actions/publish/pypi_url.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from urllib.parse import urlparse
+
+from .types import PyPITarget
+
+
+def parse_pypi_project_url(url: str) -> PyPITarget | None:
+    u = (url or "").strip()
+    if not u:
+        return None
+
+    parsed = urlparse(u)
+    host = (parsed.netloc or "").lower()
+    path = (parsed.path or "").strip("/")
+
+    if host not in ("pypi.org", "test.pypi.org"):
+        return None
+
+    parts = [p for p in path.split("/") if p]
+    if len(parts) >= 2 and parts[0] == "project":
+        return PyPITarget(host=host, project=parts[1])
+
+    return None

src/pkgmgr/actions/publish/types.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class PyPITarget:
+    host: str
+    project: str

src/pkgmgr/actions/publish/workflow.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import glob
+import os
+import shutil
+import subprocess
+
+from pkgmgr.actions.mirror.io import read_mirrors_file
+from pkgmgr.actions.mirror.types import Repository
+from pkgmgr.core.credentials.resolver import ResolutionOptions, TokenResolver
+from pkgmgr.core.version.semver import SemVer
+
+from .git_tags import head_semver_tags
+from .pypi_url import parse_pypi_project_url
+
+
+def _require_tool(module: str) -> None:
+    try:
+        subprocess.run(
+            ["python", "-m", module, "--help"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=True,
+        )
+    except Exception as exc:
+        raise RuntimeError(
+            f"Required Python module '{module}' is not available. "
+            f"Install it via: pip install {module}"
+        ) from exc
+
+
+def publish(
+    repo: Repository,
+    repo_dir: str,
+    *,
+    preview: bool = False,
+    interactive: bool = True,
+    allow_prompt: bool = True,
+) -> None:
+    mirrors = read_mirrors_file(repo_dir)
+
+    targets = []
+    for url in mirrors.values():
+        t = parse_pypi_project_url(url)
+        if t:
+            targets.append(t)
+
+    if not targets:
+        print("[INFO] No PyPI mirror found. Skipping publish.")
+        return
+
+    if len(targets) > 1:
+        raise RuntimeError("Multiple PyPI mirrors found; refusing to publish.")
+
+    tags = head_semver_tags(cwd=repo_dir)
+    if not tags:
+        print("[INFO] No version tag on HEAD. Skipping publish.")
+        return
+
+    tag = max(tags, key=SemVer.parse)
+    target = targets[0]
+
+    print(f"[INFO] Publishing {target.project} for tag {tag}")
+
+    if preview:
+        print("[PREVIEW] Would build and upload to PyPI.")
+        return
+
+    _require_tool("build")
+    _require_tool("twine")
+
+    dist_dir = os.path.join(repo_dir, "dist")
+    if os.path.isdir(dist_dir):
+        shutil.rmtree(dist_dir, ignore_errors=True)
+
+    subprocess.run(
+        ["python", "-m", "build"],
+        cwd=repo_dir,
+        check=True,
+    )
+
+    artifacts = sorted(glob.glob(os.path.join(dist_dir, "*")))
+    if not artifacts:
+        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=None,
+        options=ResolutionOptions(
+            interactive=interactive,
+            allow_prompt=allow_prompt,
+            save_prompt_token_to_keyring=True,
+        ),
+    ).token
+
+    env = dict(os.environ)
+    env["TWINE_USERNAME"] = "__token__"
+    env["TWINE_PASSWORD"] = token
+
+    subprocess.run(
+        ["python", "-m", "twine", "upload", *artifacts],
+        cwd=repo_dir,
+        env=env,
+        check=True,
+    )
+
+    print("[INFO] Publish completed.")

src/pkgmgr/actions/release/versioning.py

@@ -7,7 +7,7 @@ Version discovery and bumping helpers for the release workflow.
 
 from __future__ import annotations
 
-from pkgmgr.core.git import get_tags
+from pkgmgr.core.git.queries import get_tags
 from pkgmgr.core.version.semver import (
     SemVer,
     find_latest_version,

src/pkgmgr/actions/release/workflow.py

@@ -1,4 +1,3 @@
-# src/pkgmgr/actions/release/workflow.py
 from __future__ import annotations
 
 import os
@@ -6,7 +5,8 @@ import sys
 from typing import Optional
 
 from pkgmgr.actions.branch import close_branch
-from pkgmgr.core.git import get_current_branch, GitError
+from pkgmgr.core.git import GitError
+from pkgmgr.core.git.queries import get_current_branch
 from pkgmgr.core.repository.paths import resolve_repo_paths
 
 from .files import (

src/pkgmgr/actions/repository/create.py

@@ -1,143 +1,257 @@
+from __future__ import annotations
+
 import os
+import re
 import subprocess
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, Tuple
+from urllib.parse import urlparse
+
 import yaml
+
+from pkgmgr.actions.mirror.io import write_mirrors_file
+from pkgmgr.actions.mirror.setup_cmd import setup_mirrors
+from pkgmgr.actions.repository.scaffold import render_default_templates
 from pkgmgr.core.command.alias import generate_alias
 from pkgmgr.core.config.save import save_user_config
 
-def create_repo(identifier, config_merged, user_config_path, bin_dir, remote=False, preview=False):
-    """
-    Creates a new repository by performing the following steps:
-    
-    1. Parses the identifier (provider:port/account/repository) and adds a new entry to the user config
-       if it is not already present. The provider part is split into provider and port (if provided).
-    2. Creates the local repository directory and initializes a Git repository.
-    3. If --remote is set, checks for an existing "origin" remote (removing it if found),
-       adds the remote using a URL built from provider, port, account, and repository,
-       creates an initial commit (e.g. with a README.md), and pushes to the remote.
-       The push is attempted on both "main" and "master" branches.
-    """
-    parts = identifier.split("/")
+Repository = Dict[str, Any]
+
+_NAME_RE = re.compile(r"^[a-z0-9_-]+$")
+
+
+@dataclass(frozen=True)
+class RepoParts:
+    host: str
+    port: Optional[str]
+    owner: str
+    name: str
+
+
+def _run(cmd: str, cwd: str, preview: bool) -> None:
+    if preview:
+        print(f"[Preview] Would run in {cwd}: {cmd}")
+        return
+    subprocess.run(cmd, cwd=cwd, shell=True, check=True)
+
+
+def _git_get(key: str) -> str:
+    try:
+        out = subprocess.run(
+            f"git config --get {key}",
+            shell=True,
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        return (out.stdout or "").strip()
+    except Exception:
+        return ""
+
+
+def _split_host_port(host_with_port: str) -> Tuple[str, Optional[str]]:
+    if ":" in host_with_port:
+        host, port = host_with_port.split(":", 1)
+        return host, port or None
+    return host_with_port, None
+
+
+def _strip_git_suffix(name: str) -> str:
+    return name[:-4] if name.endswith(".git") else name
+
+
+def _parse_git_url(url: str) -> RepoParts:
+    if url.startswith("git@") and "://" not in url:
+        left, right = url.split(":", 1)
+        host = left.split("@", 1)[1]
+        path = right.lstrip("/")
+        owner, name = path.split("/", 1)
+        return RepoParts(host=host, port=None, owner=owner, name=_strip_git_suffix(name))
+
+    parsed = urlparse(url)
+    host = (parsed.hostname or "").strip()
+    port = str(parsed.port) if parsed.port else None
+    path = (parsed.path or "").strip("/")
+
+    if not host or not path or "/" not in path:
+        raise ValueError(f"Could not parse git URL: {url}")
+
+    owner, name = path.split("/", 1)
+    return RepoParts(host=host, port=port, owner=owner, name=_strip_git_suffix(name))
+
+
+def _parse_identifier(identifier: str) -> RepoParts:
+    ident = identifier.strip()
+
+    if "://" in ident or ident.startswith("git@"):
+        return _parse_git_url(ident)
+
+    parts = ident.split("/")
     if len(parts) != 3:
-        print("Identifier must be in the format 'provider:port/account/repository' (port is optional).")
+        raise ValueError("Identifier must be URL or 'provider(:port)/owner/repo'.")
+
+    host_with_port, owner, name = parts
+    host, port = _split_host_port(host_with_port)
+    return RepoParts(host=host, port=port, owner=owner, name=name)
+
+
+def _ensure_valid_repo_name(name: str) -> None:
+    if not name or not _NAME_RE.fullmatch(name):
+        raise ValueError("Repository name must match: lowercase a-z, 0-9, '_' and '-'.")
+
+
+def _repo_homepage(host: str, owner: str, name: str) -> str:
+    return f"https://{host}/{owner}/{name}"
+
+
+def _build_default_primary_url(parts: RepoParts) -> str:
+    if parts.port:
+        return f"ssh://git@{parts.host}:{parts.port}/{parts.owner}/{parts.name}.git"
+    return f"git@{parts.host}:{parts.owner}/{parts.name}.git"
+
+
+def _write_default_mirrors(repo_dir: str, primary: str, name: str, preview: bool) -> None:
+    mirrors = {"origin": primary, "pypi": f"https://pypi.org/project/{name}/"}
+    write_mirrors_file(repo_dir, mirrors, preview=preview)
+
+
+def _git_init_and_initial_commit(repo_dir: str, preview: bool) -> None:
+    _run("git init", cwd=repo_dir, preview=preview)
+    _run("git add -A", cwd=repo_dir, preview=preview)
+
+    if preview:
+        print(f'[Preview] Would run in {repo_dir}: git commit -m "Initial commit"')
         return
 
-    provider_with_port, account, repository = parts
-    # Split provider and port if a colon is present.
-    if ":" in provider_with_port:
-        provider_name, port = provider_with_port.split(":", 1)
-    else:
-        provider_name = provider_with_port
-        port = None
+    subprocess.run('git commit -m "Initial commit"', cwd=repo_dir, shell=True, check=False)
 
-    # Check if the repository is already present in the merged config (including port)
-    exists = False
-    for repo in config_merged.get("repositories", []):
-        if (repo.get("provider") == provider_name and 
-            repo.get("account") == account and 
-            repo.get("repository") == repository):
-            exists = True
-            print(f"Repository {identifier} already exists in the configuration.")
-            break
+
+def _git_push_main_or_master(repo_dir: str, preview: bool) -> None:
+    _run("git branch -M main", cwd=repo_dir, preview=preview)
+    try:
+        _run("git push -u origin main", cwd=repo_dir, preview=preview)
+        return
+    except subprocess.CalledProcessError:
+        pass
+
+    try:
+        _run("git branch -M master", cwd=repo_dir, preview=preview)
+        _run("git push -u origin master", cwd=repo_dir, preview=preview)
+    except subprocess.CalledProcessError as exc:
+        print(f"[WARN] Push failed: {exc}")
+
+
+def create_repo(
+    identifier: str,
+    config_merged: Dict[str, Any],
+    user_config_path: str,
+    bin_dir: str,
+    *,
+    remote: bool = False,
+    preview: bool = False,
+) -> None:
+    parts = _parse_identifier(identifier)
+    _ensure_valid_repo_name(parts.name)
+
+    directories = config_merged.get("directories") or {}
+    base_dir = os.path.expanduser(str(directories.get("repositories", "~/Repositories")))
+    repo_dir = os.path.join(base_dir, parts.host, parts.owner, parts.name)
+
+    author_name = _git_get("user.name") or "Unknown Author"
+    author_email = _git_get("user.email") or "unknown@example.invalid"
+
+    homepage = _repo_homepage(parts.host, parts.owner, parts.name)
+    primary_url = _build_default_primary_url(parts)
+
+    repositories = config_merged.get("repositories") or []
+    exists = any(
+        (
+            r.get("provider") == parts.host
+            and r.get("account") == parts.owner
+            and r.get("repository") == parts.name
+        )
+        for r in repositories
+    )
 
     if not exists:
-        # Create a new entry with an automatically generated alias.
-        new_entry = {
-            "provider": provider_name,
-            "port": port,
-            "account": account,
-            "repository": repository,
-            "alias": generate_alias({"repository": repository, "provider": provider_name, "account": account}, bin_dir, existing_aliases=set()),
-            "verified": {}  # No initial verification info
+        new_entry: Repository = {
+            "provider": parts.host,
+            "port": parts.port,
+            "account": parts.owner,
+            "repository": parts.name,
+            "homepage": homepage,
+            "alias": generate_alias(
+                {"repository": parts.name, "provider": parts.host, "account": parts.owner},
+                bin_dir,
+                existing_aliases=set(),
+            ),
+            "verified": {},
         }
-        # Load or initialize the user configuration.
+
         if os.path.exists(user_config_path):
-            with open(user_config_path, "r") as f:
+            with open(user_config_path, "r", encoding="utf-8") as f:
                 user_config = yaml.safe_load(f) or {}
         else:
             user_config = {"repositories": []}
+
         user_config.setdefault("repositories", [])
         user_config["repositories"].append(new_entry)
-        save_user_config(user_config, user_config_path)
-        print(f"Repository {identifier} added to the configuration.")
-        # Also update the merged configuration object.
-        config_merged.setdefault("repositories", []).append(new_entry)
 
-    # Create the local repository directory based on the configured base directory.
-    base_dir = os.path.expanduser(config_merged["directories"]["repositories"])
-    repo_dir = os.path.join(base_dir, provider_name, account, repository)
-    if not os.path.exists(repo_dir):
-        os.makedirs(repo_dir, exist_ok=True)
-        print(f"Local repository directory created: {repo_dir}")
-    else:
-        print(f"Local repository directory already exists: {repo_dir}")
-
-    # Initialize a Git repository if not already initialized.
-    if not os.path.exists(os.path.join(repo_dir, ".git")):
-        cmd_init = "git init"
         if preview:
-            print(f"[Preview] Would execute: '{cmd_init}' in {repo_dir}")
+            print(f"[Preview] Would save user config: {user_config_path}")
         else:
-            subprocess.run(cmd_init, cwd=repo_dir, shell=True, check=True)
-            print(f"Git repository initialized in {repo_dir}.")
+            save_user_config(user_config, user_config_path)
+
+        config_merged.setdefault("repositories", []).append(new_entry)
+        repo = new_entry
+        print(f"[INFO] Added repository to configuration: {parts.host}/{parts.owner}/{parts.name}")
     else:
-        print("Git repository is already initialized.")
+        repo = next(
+            r
+            for r in repositories
+            if (
+                r.get("provider") == parts.host
+                and r.get("account") == parts.owner
+                and r.get("repository") == parts.name
+            )
+        )
+        print(f"[INFO] Repository already in configuration: {parts.host}/{parts.owner}/{parts.name}")
+
+    if preview:
+        print(f"[Preview] Would ensure directory exists: {repo_dir}")
+    else:
+        os.makedirs(repo_dir, exist_ok=True)
+
+    tpl_context = {
+        "provider": parts.host,
+        "port": parts.port,
+        "account": parts.owner,
+        "repository": parts.name,
+        "homepage": homepage,
+        "author_name": author_name,
+        "author_email": author_email,
+        "license_text": f"All rights reserved by {author_name}",
+        "primary_remote": primary_url,
+    }
+
+    render_default_templates(repo_dir, context=tpl_context, preview=preview)
+    _git_init_and_initial_commit(repo_dir, preview=preview)
+
+    _write_default_mirrors(repo_dir, primary=primary_url, name=parts.name, preview=preview)
+
+    repo.setdefault("mirrors", {})
+    repo["mirrors"].setdefault("origin", primary_url)
+    repo["mirrors"].setdefault("pypi", f"https://pypi.org/project/{parts.name}/")
+
+    setup_mirrors(
+        selected_repos=[repo],
+        repositories_base_dir=base_dir,
+        all_repos=config_merged.get("repositories", []),
+        preview=preview,
+        local=True,
+        remote=True,
+        ensure_remote=bool(remote),
+    )
 
     if remote:
-        # Create a README.md if it does not exist to have content for an initial commit.
-        readme_path = os.path.join(repo_dir, "README.md")
-        if not os.path.exists(readme_path):
-            if preview:
-                print(f"[Preview] Would create README.md in {repo_dir}.")
-            else:
-                with open(readme_path, "w") as f:
-                    f.write(f"# {repository}\n")
-                subprocess.run("git add README.md", cwd=repo_dir, shell=True, check=True)
-                subprocess.run('git commit -m "Initial commit"', cwd=repo_dir, shell=True, check=True)
-                print("README.md created and initial commit made.")
-
-        # Build the remote URL.
-        if provider_name.lower() == "github.com":
-            remote_url = f"git@{provider_name}:{account}/{repository}.git"
-        else:
-            if port:
-                remote_url = f"ssh://git@{provider_name}:{port}/{account}/{repository}.git"
-            else:
-                remote_url = f"ssh://git@{provider_name}/{account}/{repository}.git"
-
-        # Check if the remote "origin" already exists.
-        cmd_list = "git remote"
-        if preview:
-            print(f"[Preview] Would check for existing remotes in {repo_dir}")
-            remote_exists = False  # Assume no remote in preview mode.
-        else:
-            result = subprocess.run(cmd_list, cwd=repo_dir, shell=True, capture_output=True, text=True, check=True)
-            remote_list = result.stdout.strip().split()
-            remote_exists = "origin" in remote_list
-
-        if remote_exists:
-            # Remove the existing remote "origin".
-            cmd_remove = "git remote remove origin"
-            if preview:
-                print(f"[Preview] Would execute: '{cmd_remove}' in {repo_dir}")
-            else:
-                subprocess.run(cmd_remove, cwd=repo_dir, shell=True, check=True)
-                print("Existing remote 'origin' removed.")
-
-        # Now add the new remote.
-        cmd_remote = f"git remote add origin {remote_url}"
-        if preview:
-            print(f"[Preview] Would execute: '{cmd_remote}' in {repo_dir}")
-        else:
-            try:
-                subprocess.run(cmd_remote, cwd=repo_dir, shell=True, check=True)
-                print(f"Remote 'origin' added: {remote_url}")
-            except subprocess.CalledProcessError:
-                print(f"Failed to add remote using URL: {remote_url}.")
-
-        # Push the initial commit to the remote repository
-        cmd_push = "git push -u origin master"
-        if preview:
-            print(f"[Preview] Would execute: '{cmd_push}' in {repo_dir}")
-        else:
-            subprocess.run(cmd_push, cwd=repo_dir, shell=True, check=True)
-            print("Initial push to the remote repository completed.")
+        _git_push_main_or_master(repo_dir, preview=preview)

src/pkgmgr/actions/repository/scaffold.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+try:
+    from jinja2 import Environment, FileSystemLoader, StrictUndefined
+except Exception as exc:  # pragma: no cover
+    Environment = None  # type: ignore[assignment]
+    FileSystemLoader = None  # type: ignore[assignment]
+    StrictUndefined = None  # type: ignore[assignment]
+    _JINJA_IMPORT_ERROR = exc
+else:
+    _JINJA_IMPORT_ERROR = None
+
+
+def _repo_root_from_here(anchor: Optional[Path] = None) -> str:
+    """
+    Prefer git root (robust in editable installs / different layouts).
+    Fallback to a conservative relative parent lookup.
+    """
+    here = (anchor or Path(__file__)).resolve().parent
+    try:
+        r = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            cwd=str(here),
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if r.returncode == 0:
+            top = (r.stdout or "").strip()
+            if top:
+                return top
+    except Exception:
+        pass
+
+    # Fallback: src/pkgmgr/actions/repository/scaffold.py -> <repo root> = parents[5]
+    p = (anchor or Path(__file__)).resolve()
+    if len(p.parents) < 6:
+        raise RuntimeError(f"Unexpected path depth for: {p}")
+    return str(p.parents[5])
+
+
+def _templates_dir() -> str:
+    return os.path.join(_repo_root_from_here(), "templates", "default")
+
+
+def render_default_templates(
+    repo_dir: str,
+    *,
+    context: Dict[str, Any],
+    preview: bool,
+) -> None:
+    """
+    Render templates/default/*.j2 into repo_dir.
+    Keeps create.py clean: create.py calls this function only.
+    """
+    tpl_dir = _templates_dir()
+    if not os.path.isdir(tpl_dir):
+        raise RuntimeError(f"Templates directory not found: {tpl_dir}")
+
+    # Preview mode: do not require Jinja2 at all. We only print planned outputs.
+    if preview:
+        for root, _, files in os.walk(tpl_dir):
+            for fn in files:
+                if not fn.endswith(".j2"):
+                    continue
+                abs_src = os.path.join(root, fn)
+                rel_src = os.path.relpath(abs_src, tpl_dir)
+                rel_out = rel_src[:-3]
+                print(f"[Preview] Would render template: {rel_src} -> {rel_out}")
+        return
+
+    if Environment is None or FileSystemLoader is None or StrictUndefined is None:
+        raise RuntimeError(
+            "Jinja2 is required for repo templates but is not available. "
+            f"Import error: {_JINJA_IMPORT_ERROR}"
+        )
+
+    env = Environment(
+        loader=FileSystemLoader(tpl_dir),
+        undefined=StrictUndefined,
+        autoescape=False,
+        keep_trailing_newline=True,
+    )
+
+    for root, _, files in os.walk(tpl_dir):
+        for fn in files:
+            if not fn.endswith(".j2"):
+                continue
+
+            abs_src = os.path.join(root, fn)
+            rel_src = os.path.relpath(abs_src, tpl_dir)
+            rel_out = rel_src[:-3]
+            abs_out = os.path.join(repo_dir, rel_out)
+
+            os.makedirs(os.path.dirname(abs_out), exist_ok=True)
+            template = env.get_template(rel_src)
+            rendered = template.render(**context)
+
+            with open(abs_out, "w", encoding="utf-8") as f:
+                f.write(rendered)

src/pkgmgr/actions/update/manager.py

@@ -3,7 +3,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterable
+from typing import Any, Iterable, List, Tuple
 
 from pkgmgr.actions.update.system_updater import SystemUpdater
 
@@ -30,32 +30,73 @@ class UpdateManager:
         quiet: bool,
         update_dependencies: bool,
         clone_mode: str,
+        silent: bool = False,
         force_update: bool = True,
     ) -> None:
         from pkgmgr.actions.install import install_repos
         from pkgmgr.actions.repository.pull import pull_with_verification
+        from pkgmgr.core.repository.identifier import get_repo_identifier
 
-        pull_with_verification(
-            selected_repos,
-            repositories_base_dir,
-            all_repos,
-            [],
-            no_verification,
-            preview,
-        )
+        failures: List[Tuple[str, str]] = []
 
-        install_repos(
-            selected_repos,
-            repositories_base_dir,
-            bin_dir,
-            all_repos,
-            no_verification,
-            preview,
-            quiet,
-            clone_mode,
-            update_dependencies,
-            force_update=force_update,
-        )
+        for repo in list(selected_repos):
+            identifier = get_repo_identifier(repo, all_repos)
+
+            try:
+                pull_with_verification(
+                    [repo],
+                    repositories_base_dir,
+                    all_repos,
+                    [],
+                    no_verification,
+                    preview,
+                )
+            except SystemExit as exc:
+                code = exc.code if isinstance(exc.code, int) else str(exc.code)
+                failures.append((identifier, f"pull failed (exit={code})"))
+                if not quiet:
+                    print(f"[Warning] update: pull failed for {identifier} (exit={code}). Continuing...")
+                continue
+            except Exception as exc:
+                failures.append((identifier, f"pull failed: {exc}"))
+                if not quiet:
+                    print(f"[Warning] update: pull failed for {identifier}: {exc}. Continuing...")
+                continue
+
+            try:
+                install_repos(
+                    [repo],
+                    repositories_base_dir,
+                    bin_dir,
+                    all_repos,
+                    no_verification,
+                    preview,
+                    quiet,
+                    clone_mode,
+                    update_dependencies,
+                    force_update=force_update,
+                    silent=silent,
+                    emit_summary=False,
+                )
+            except SystemExit as exc:
+                code = exc.code if isinstance(exc.code, int) else str(exc.code)
+                failures.append((identifier, f"install failed (exit={code})"))
+                if not quiet:
+                    print(f"[Warning] update: install failed for {identifier} (exit={code}). Continuing...")
+                continue
+            except Exception as exc:
+                failures.append((identifier, f"install failed: {exc}"))
+                if not quiet:
+                    print(f"[Warning] update: install failed for {identifier}: {exc}. Continuing...")
+                continue
+
+        if failures and not quiet:
+            print("\n[pkgmgr] Update finished with warnings:")
+            for ident, msg in failures:
+                print(f"  - {ident}: {msg}")
+
+        if failures and not silent:
+            raise SystemExit(1)
 
         if system_update:
             self._system_updater.run(preview=preview)

src/pkgmgr/cli/commands/__init__.py

@@ -2,6 +2,7 @@ from .repos import handle_repos_command
 from .config import handle_config
 from .tools import handle_tools_command
 from .release import handle_release
+from .publish import handle_publish
 from .version import handle_version
 from .make import handle_make
 from .changelog import handle_changelog
@@ -13,6 +14,7 @@ __all__ = [
     "handle_config",
     "handle_tools_command",
     "handle_release",
+    "handle_publish",
     "handle_version",
     "handle_make",
     "handle_changelog",

src/pkgmgr/cli/commands/changelog.py

@@ -7,7 +7,7 @@ from typing import Any, Dict, List, Optional, Tuple
 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.core.git import get_tags
+from pkgmgr.core.git.queries import get_tags
 from pkgmgr.core.version.semver import extract_semver_from_tags
 from pkgmgr.actions.changelog import generate_changelog
 

src/pkgmgr/cli/commands/publish.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import os
+from typing import Any, Dict, List
+
+from pkgmgr.actions.publish import publish
+from pkgmgr.cli.context import CLIContext
+from pkgmgr.core.repository.dir import get_repo_dir
+from pkgmgr.core.repository.identifier import get_repo_identifier
+
+Repository = Dict[str, Any]
+
+
+def handle_publish(args, ctx: CLIContext, selected: List[Repository]) -> None:
+    if not selected:
+        print("[pkgmgr] No repositories selected for publish.")
+        return
+
+    for repo in selected:
+        identifier = get_repo_identifier(repo, ctx.all_repositories)
+        repo_dir = repo.get("directory") or get_repo_dir(ctx.repositories_base_dir, repo)
+
+        if not os.path.isdir(repo_dir):
+            print(f"[WARN] Skipping {identifier}: directory missing.")
+            continue
+
+        print(f"[pkgmgr] Publishing repository {identifier}...")
+        publish(
+            repo=repo,
+            repo_dir=repo_dir,
+            preview=getattr(args, "preview", False),
+            interactive=not getattr(args, "non_interactive", False),
+            allow_prompt=not getattr(args, "non_interactive", False),
+        )

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")
-        if not repo_dir:
-            try:
-                repo_dir = get_repo_dir(ctx.repositories_base_dir, repo)
-            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."
-            )
+        try:
+            repo_dir = repo.get("directory") or get_repo_dir(ctx.repositories_base_dir, repo)
+        except Exception as exc:
+            print(f"[WARN] Skipping repository {identifier}: failed to resolve directory: {exc}")
             continue
 
-        print(
-            f"[pkgmgr] Running release for repository {identifier} "
-            f"in '{repo_dir}'..."
-        )
+        if not os.path.isdir(repo_dir):
+            print(f"[WARN] Skipping repository {identifier}: directory missing.")
+            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/commands/repos.py

@@ -68,6 +68,7 @@ def handle_repos_command(
             args.clone_mode,
             args.dependencies,
             force_update=getattr(args, "update", False),
+            silent=getattr(args, "silent", False),
         )
         return
 

src/pkgmgr/cli/commands/version.py

@@ -7,7 +7,7 @@ from typing import Any, Dict, List, Optional, Tuple
 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.core.git import get_tags
+from pkgmgr.core.git.queries import get_tags
 from pkgmgr.core.version.semver import SemVer, find_latest_version
 from pkgmgr.core.version.installed import (
     get_installed_python_version,

src/pkgmgr/cli/dispatch.py

@@ -1,6 +1,3 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
 from __future__ import annotations
 
 import os
@@ -16,6 +13,7 @@ from pkgmgr.cli.commands import (
     handle_repos_command,
     handle_tools_command,
     handle_release,
+    handle_publish,
     handle_version,
     handle_config,
     handle_make,
@@ -24,40 +22,20 @@ from pkgmgr.cli.commands import (
     handle_mirror_command,
 )
 
-def _has_explicit_selection(args) -> bool:
-    """
-    Return True if the user explicitly selected repositories via
-    identifiers / --all / --category / --tag / --string.
-    """
-    identifiers = getattr(args, "identifiers", []) or []
-    use_all = getattr(args, "all", False)
-    categories = getattr(args, "category", []) or []
-    tags = getattr(args, "tag", []) or []
-    string_filter = getattr(args, "string", "") or ""
 
+def _has_explicit_selection(args) -> bool:
     return bool(
-        use_all
-        or identifiers
-        or categories
-        or tags
-        or string_filter
+        getattr(args, "all", False)
+        or getattr(args, "identifiers", [])
+        or getattr(args, "category", [])
+        or getattr(args, "tag", [])
+        or getattr(args, "string", "")
     )
 
 
-def _select_repo_for_current_directory(
-    ctx: CLIContext,
-) -> List[Dict[str, Any]]:
-    """
-    Heuristic: find the repository whose local directory matches the
-    current working directory or is the closest parent.
-
-    Example:
-      - Repo directory: /home/kevin/Repositories/foo
-      - CWD:           /home/kevin/Repositories/foo/subdir
-      → 'foo' is selected.
-    """
+def _select_repo_for_current_directory(ctx: CLIContext) -> List[Dict[str, Any]]:
     cwd = os.path.abspath(os.getcwd())
-    candidates: List[tuple[str, Dict[str, Any]]] = []
+    matches = []
 
     for repo in ctx.all_repositories:
         repo_dir = repo.get("directory")
@@ -65,33 +43,24 @@ def _select_repo_for_current_directory(
             try:
                 repo_dir = get_repo_dir(ctx.repositories_base_dir, repo)
             except Exception:
-                repo_dir = None
-        if not repo_dir:
-            continue
+                continue
 
-        repo_dir_abs = os.path.abspath(os.path.expanduser(repo_dir))
-        if cwd == repo_dir_abs or cwd.startswith(repo_dir_abs + os.sep):
-            candidates.append((repo_dir_abs, repo))
+        repo_dir = os.path.abspath(os.path.expanduser(repo_dir))
+        if cwd == repo_dir or cwd.startswith(repo_dir + os.sep):
+            matches.append((repo_dir, repo))
 
-    if not candidates:
+    if not matches:
         return []
 
-    # Pick the repo with the longest (most specific) path.
-    candidates.sort(key=lambda item: len(item[0]), reverse=True)
-    return [candidates[0][1]]
+    matches.sort(key=lambda x: len(x[0]), reverse=True)
+    return [matches[0][1]]
 
 
 def dispatch_command(args, ctx: CLIContext) -> None:
-    """
-    Dispatch the parsed arguments to the appropriate command handler.
-    """
-
-    # First: proxy commands (git / docker / docker compose / make wrapper etc.)
     if maybe_handle_proxy(args, ctx):
         return
 
-    # Commands that operate on repository selections
-    commands_with_selection: List[str] = [
+    commands_with_selection = {
         "install",
         "update",
         "deinstall",
@@ -103,31 +72,25 @@ def dispatch_command(args, ctx: CLIContext) -> None:
         "list",
         "make",
         "release",
+        "publish",
         "version",
         "changelog",
         "explore",
         "terminal",
         "code",
         "mirror",
-    ]
+    }
 
-    if getattr(args, "command", None) in commands_with_selection:
-        if _has_explicit_selection(args):
-            # Classic selection logic (identifiers / --all / filters)
-            selected = get_selected_repos(args, ctx.all_repositories)
-        else:
-            # Default per help text: repository of current folder.
-            selected = _select_repo_for_current_directory(ctx)
-            # If none is found, leave 'selected' empty.
-            # Individual handlers will then emit a clear message instead
-            # of silently picking an unrelated repository.
+    if args.command in commands_with_selection:
+        selected = (
+            get_selected_repos(args, ctx.all_repositories)
+            if _has_explicit_selection(args)
+            else _select_repo_for_current_directory(ctx)
+        )
     else:
         selected = []
 
-    # ------------------------------------------------------------------ #
-    # Repos-related commands
-    # ------------------------------------------------------------------ #
-    if args.command in (
+    if args.command in {
         "install",
         "deinstall",
         "delete",
@@ -136,15 +99,13 @@ def dispatch_command(args, ctx: CLIContext) -> None:
         "shell",
         "create",
         "list",
-    ):
+    }:
         handle_repos_command(args, ctx, selected)
         return
 
-    # ------------------------------------------------------------
-    # update
-    # ------------------------------------------------------------
     if args.command == "update":
         from pkgmgr.actions.update import UpdateManager
+
         UpdateManager().run(
             selected_repos=selected,
             repositories_base_dir=ctx.repositories_base_dir,
@@ -156,25 +117,23 @@ def dispatch_command(args, ctx: CLIContext) -> None:
             quiet=args.quiet,
             update_dependencies=args.dependencies,
             clone_mode=args.clone_mode,
+            silent=getattr(args, "silent", False),
             force_update=True,
         )
         return
 
-
-    # ------------------------------------------------------------------ #
-    # Tools (explore / terminal / code)
-    # ------------------------------------------------------------------ #
     if args.command in ("explore", "terminal", "code"):
         handle_tools_command(args, ctx, selected)
         return
 
-    # ------------------------------------------------------------------ #
-    # Release / Version / Changelog / Config / Make / Branch
-    # ------------------------------------------------------------------ #
     if args.command == "release":
         handle_release(args, ctx, selected)
         return
 
+    if args.command == "publish":
+        handle_publish(args, ctx, selected)
+        return
+
     if args.command == "version":
         handle_version(args, ctx, selected)
         return

src/pkgmgr/cli/parser/__init__.py

@@ -1,68 +1,73 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
 from __future__ import annotations
 
 import argparse
 
 from pkgmgr.cli.proxy import register_proxy_commands
 
-from .common import SortedSubParsersAction
-from .install_update import add_install_update_subparsers
-from .config_cmd import add_config_subparsers
-from .navigation_cmd import add_navigation_subparsers
 from .branch_cmd import add_branch_subparsers
-from .release_cmd import add_release_subparser
-from .version_cmd import add_version_subparser
 from .changelog_cmd import add_changelog_subparser
+from .common import SortedSubParsersAction
+from .config_cmd import add_config_subparsers
+from .install_update import add_install_update_subparsers
 from .list_cmd import add_list_subparser
 from .make_cmd import add_make_subparsers
 from .mirror_cmd import add_mirror_subparsers
+from .navigation_cmd import add_navigation_subparsers
+from .publish_cmd import add_publish_subparser
+from .release_cmd import add_release_subparser
+from .version_cmd import add_version_subparser
 
 
 def create_parser(description_text: str) -> argparse.ArgumentParser:
-    """
-    Create the top-level argument parser for pkgmgr.
-    """
     parser = argparse.ArgumentParser(
         description=description_text,
         formatter_class=argparse.RawTextHelpFormatter,
     )
+
     subparsers = parser.add_subparsers(
         dest="command",
         help="Subcommands",
         action=SortedSubParsersAction,
     )
 
-    # Core repo operations
+    # create
+    p_create = subparsers.add_parser(
+        "create",
+        help="Create a new repository (scaffold + config).",
+    )
+    p_create.add_argument(
+        "identifiers",
+        nargs="+",
+        help="Repository identifier(s): URL or 'provider(:port)/owner/repo'.",
+    )
+    p_create.add_argument(
+        "--remote",
+        action="store_true",
+        help="Also push an initial commit to the remote (main/master).",
+    )
+    p_create.add_argument(
+        "--preview",
+        action="store_true",
+        help="Print actions without writing files or executing commands.",
+    )
+
     add_install_update_subparsers(subparsers)
     add_config_subparsers(subparsers)
-
-    # Navigation / tooling around repos
     add_navigation_subparsers(subparsers)
 
-    # Branch & release workflow
     add_branch_subparsers(subparsers)
     add_release_subparser(subparsers)
+    add_publish_subparser(subparsers)
 
-    # Info commands
     add_version_subparser(subparsers)
     add_changelog_subparser(subparsers)
     add_list_subparser(subparsers)
 
-    # Make wrapper
     add_make_subparsers(subparsers)
-
-    # Mirror management
     add_mirror_subparsers(subparsers)
 
-    # Proxy commands (git, docker, docker compose, ...)
     register_proxy_commands(subparsers)
-
     return parser
 
 
-__all__ = [
-    "create_parser",
-    "SortedSubParsersAction",
-]
+__all__ = ["create_parser", "SortedSubParsersAction"]

src/pkgmgr/cli/parser/common.py

@@ -168,3 +168,10 @@ def add_install_update_arguments(subparser: argparse.ArgumentParser) -> None:
         default="ssh",
         help="Specify clone mode (default: ssh).",
     )
+
+    _add_option_if_missing(
+        subparser,
+        "--silent",
+        action="store_true",
+        help="Continue with other repositories if one fails; downgrade errors to warnings.",
+    )

src/pkgmgr/cli/parser/publish_cmd.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import argparse
+
+from .common import add_identifier_arguments
+
+
+def add_publish_subparser(subparsers: argparse._SubParsersAction) -> None:
+    parser = subparsers.add_parser(
+        "publish",
+        help="Publish repository artifacts (e.g. PyPI) based on MIRRORS.",
+    )
+    add_identifier_arguments(parser)
+
+    parser.add_argument(
+        "--non-interactive",
+        action="store_true",
+        help="Disable interactive credential prompts (CI mode).",
+    )

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=(
-            "Optional release message to add to the changelog and tag."
-        ),
+        help="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.",
+    )

src/pkgmgr/core/git/__init__.py

@@ -1,5 +1,4 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
+from __future__ import annotations
 
 """
 Lightweight helper functions around Git commands.
@@ -9,84 +8,10 @@ logic (release, version, changelog) does not have to deal with the
 details of subprocess handling.
 """
 
-from __future__ import annotations
+from .errors import GitError
+from .run import run
 
-import subprocess
-from typing import List, Optional
-
-
-class GitError(RuntimeError):
-    """Raised when a Git command fails in an unexpected way."""
-
-
-def run_git(args: List[str], cwd: str = ".") -> str:
-    """
-    Run a Git command and return its stdout as a stripped string.
-
-    Raises GitError if the command fails.
-    """
-    cmd = ["git"] + args
-    try:
-        result = subprocess.run(
-            cmd,
-            cwd=cwd,
-            check=True,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-        )
-    except subprocess.CalledProcessError as exc:
-        raise GitError(
-            f"Git command failed in {cwd!r}: {' '.join(cmd)}\n"
-            f"Exit code: {exc.returncode}\n"
-            f"STDOUT:\n{exc.stdout}\n"
-            f"STDERR:\n{exc.stderr}"
-        ) from exc
-
-    return result.stdout.strip()
-
-
-def get_tags(cwd: str = ".") -> List[str]:
-    """
-    Return a list of all tags in the repository in `cwd`.
-
-    If there are no tags, an empty list is returned.
-    """
-    try:
-        output = run_git(["tag"], cwd=cwd)
-    except GitError as exc:
-        # If the repo has no tags or is not a git repo, surface a clear error.
-        # You can decide later if you want to treat this differently.
-        if "not a git repository" in str(exc):
-            raise
-        # No tags: stdout may just be empty; treat this as empty list.
-        return []
-
-    if not output:
-        return []
-
-    return [line.strip() for line in output.splitlines() if line.strip()]
-
-
-def get_head_commit(cwd: str = ".") -> Optional[str]:
-    """
-    Return the current HEAD commit hash, or None if it cannot be determined.
-    """
-    try:
-        output = run_git(["rev-parse", "HEAD"], cwd=cwd)
-    except GitError:
-        return None
-    return output or None
-
-
-def get_current_branch(cwd: str = ".") -> Optional[str]:
-    """
-    Return the current branch name, or None if it cannot be determined.
-
-    Note: In detached HEAD state this will return 'HEAD'.
-    """
-    try:
-        output = run_git(["rev-parse", "--abbrev-ref", "HEAD"], cwd=cwd)
-    except GitError:
-        return None
-    return output or None
+__all__ = [
+    "GitError",
+    "run"
+]

src/pkgmgr/core/git/commands/__init__.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from .checkout import GitCheckoutError, checkout
+from .delete_local_branch import GitDeleteLocalBranchError, delete_local_branch
+from .delete_remote_branch import GitDeleteRemoteBranchError, delete_remote_branch
+from .fetch import GitFetchError, fetch
+from .merge_no_ff import GitMergeError, merge_no_ff
+from .pull import GitPullError, pull
+from .push import GitPushError, push
+from .create_branch import GitCreateBranchError, create_branch
+from .push_upstream import GitPushUpstreamError, push_upstream
+
+from .add_remote import GitAddRemoteError, add_remote
+from .set_remote_url import GitSetRemoteUrlError, set_remote_url
+from .add_remote_push_url import GitAddRemotePushUrlError, add_remote_push_url
+
+__all__ = [
+    "fetch",
+    "checkout",
+    "pull",
+    "merge_no_ff",
+    "push",
+    "delete_local_branch",
+    "delete_remote_branch",
+    "create_branch",
+    "push_upstream",
+    "add_remote",
+    "set_remote_url",
+    "add_remote_push_url",
+    "GitFetchError",
+    "GitCheckoutError",
+    "GitPullError",
+    "GitMergeError",
+    "GitPushError",
+    "GitDeleteLocalBranchError",
+    "GitDeleteRemoteBranchError",
+    "GitCreateBranchError",
+    "GitPushUpstreamError",
+    "GitAddRemoteError",
+    "GitSetRemoteUrlError",
+    "GitAddRemotePushUrlError",
+]

src/pkgmgr/core/git/commands/add_remote.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from ..errors import GitError, GitCommandError
+from ..run import run
+
+
+class GitAddRemoteError(GitCommandError):
+    """Raised when adding a remote fails."""
+
+
+def add_remote(
+    name: str,
+    url: str,
+    *,
+    cwd: str = ".",
+    preview: bool = False,
+) -> None:
+    """
+    Add a new remote.
+
+    Equivalent to:
+      git remote add <name> <url>
+    """
+    try:
+        run(
+            ["remote", "add", name, url],
+            cwd=cwd,
+            preview=preview,
+        )
+    except GitError as exc:
+        raise GitAddRemoteError(
+            f"Failed to add remote {name!r} with URL {url!r}.",
+            cwd=cwd,
+        ) from exc

src/pkgmgr/core/git/commands/add_remote_push_url.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from ..errors import GitError, GitCommandError
+from ..run import run
+
+
+class GitAddRemotePushUrlError(GitCommandError):
+    """Raised when adding an additional push URL to a remote fails."""
+
+
+def add_remote_push_url(
+    remote: str,
+    url: str,
+    *,
+    cwd: str = ".",
+    preview: bool = False,
+) -> None:
+    """
+    Add an additional push URL to a remote.
+
+    Equivalent to:
+      git remote set-url --add --push <remote> <url>
+    """
+    try:
+        run(
+            ["remote", "set-url", "--add", "--push", remote, url],
+            cwd=cwd,
+            preview=preview,
+        )
+    except GitError as exc:
+        raise GitAddRemotePushUrlError(
+            f"Failed to add push url {url!r} to remote {remote!r}.",
+            cwd=cwd,
+        ) from exc

src/pkgmgr/core/git/commands/checkout.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from ..errors import GitError, GitCommandError
+from ..run import run
+
+
+class GitCheckoutError(GitCommandError):
+    """Raised when checking out a branch fails."""
+
+
+def checkout(branch: str, cwd: str = ".") -> None:
+    try:
+        run(["checkout", branch], cwd=cwd)
+    except GitError as exc:
+        raise GitCheckoutError(
+            f"Failed to checkout branch {branch!r}.",
+            cwd=cwd,
+        ) from exc

src/pkgmgr/core/git/commands/create_branch.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from ..errors import GitError, GitCommandError
+from ..run import run
+
+
+class GitCreateBranchError(GitCommandError):
+    """Raised when creating a new branch fails."""
+
+
+def create_branch(branch: str, base: str, cwd: str = ".") -> None:
+    """
+    Create a new branch from a base branch.
+
+    Equivalent to: git checkout -b <branch> <base>
+    """
+    try:
+        run(["checkout", "-b", branch, base], cwd=cwd)
+    except GitError as exc:
+        raise GitCreateBranchError(
+            f"Failed to create branch {branch!r} from base {base!r}.",
+            cwd=cwd,
+        ) from exc

src/pkgmgr/core/git/commands/delete_local_branch.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from ..errors import GitError, GitCommandError
+from ..run import run
+
+
+class GitDeleteLocalBranchError(GitCommandError):
+    """Raised when deleting a local branch fails."""
+
+
+def delete_local_branch(branch: str, cwd: str = ".", force: bool = False) -> None:
+    flag = "-D" if force else "-d"
+    try:
+        run(["branch", flag, branch], cwd=cwd)
+    except GitError as exc:
+        raise GitDeleteLocalBranchError(
+            f"Failed to delete local branch {branch!r} (flag {flag}).",
+            cwd=cwd,
+        ) from exc

src/pkgmgr/core/git/commands/delete_remote_branch.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from ..errors import GitError, GitCommandError
+from ..run import run
+
+
+class GitDeleteRemoteBranchError(GitCommandError):
+    """Raised when deleting a remote branch fails."""
+
+
+def delete_remote_branch(remote: str, branch: str, cwd: str = ".") -> None:
+    try:
+        run(["push", remote, "--delete", branch], cwd=cwd)
+    except GitError as exc:
+        raise GitDeleteRemoteBranchError(
+            f"Failed to delete remote branch {branch!r} on {remote!r}.",
+            cwd=cwd,
+        ) from exc

src/pkgmgr/core/git/commands/fetch.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from ..errors import GitError, GitCommandError
+from ..run import run
+
+
+class GitFetchError(GitCommandError):
+    """Raised when fetching from a remote fails."""
+
+
+def fetch(remote: str = "origin", cwd: str = ".") -> None:
+    try:
+        run(["fetch", remote], cwd=cwd)
+    except GitError as exc:
+        raise GitFetchError(
+            f"Failed to fetch from remote {remote!r}.",
+            cwd=cwd,
+        ) from exc

src/pkgmgr/core/git/commands/merge_no_ff.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from ..errors import GitError, GitCommandError
+from ..run import run
+
+
+class GitMergeError(GitCommandError):
+    """Raised when merging a branch fails."""
+
+
+def merge_no_ff(branch: str, cwd: str = ".") -> None:
+    try:
+        run(["merge", "--no-ff", branch], cwd=cwd)
+    except GitError as exc:
+        raise GitMergeError(
+            f"Failed to merge branch {branch!r} with --no-ff.",
+            cwd=cwd,
+        ) from exc

src/pkgmgr/core/git/commands/pull.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from ..errors import GitError, GitCommandError
+from ..run import run
+
+
+class GitPullError(GitCommandError):
+    """Raised when pulling from a remote branch fails."""
+
+
+def pull(remote: str, branch: str, cwd: str = ".") -> None:
+    try:
+        run(["pull", remote, branch], cwd=cwd)
+    except GitError as exc:
+        raise GitPullError(
+            f"Failed to pull {remote!r}/{branch!r}.",
+            cwd=cwd,
+        ) from exc

src/pkgmgr/core/git/commands/push.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from ..errors import GitError, GitCommandError
+from ..run import run
+
+
+class GitPushError(GitCommandError):
+    """Raised when pushing to a remote fails."""
+
+
+def push(remote: str, ref: str, cwd: str = ".") -> None:
+    try:
+        run(["push", remote, ref], cwd=cwd)
+    except GitError as exc:
+        raise GitPushError(
+            f"Failed to push ref {ref!r} to remote {remote!r}.",
+            cwd=cwd,
+        ) from exc

src/pkgmgr/core/git/commands/push_upstream.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from ..errors import GitError, GitCommandError
+from ..run import run
+
+
+class GitPushUpstreamError(GitCommandError):
+    """Raised when pushing a branch with upstream tracking fails."""
+
+
+def push_upstream(remote: str, branch: str, cwd: str = ".") -> None:
+    """
+    Push a branch and set upstream tracking.
+
+    Equivalent to: git push -u <remote> <branch>
+    """
+    try:
+        run(["push", "-u", remote, branch], cwd=cwd)
+    except GitError as exc:
+        raise GitPushUpstreamError(
+            f"Failed to push branch {branch!r} to {remote!r} with upstream tracking.",
+            cwd=cwd,
+        ) from exc

src/pkgmgr/core/git/commands/set_remote_url.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from ..errors import GitError, GitCommandError
+from ..run import run
+
+
+class GitSetRemoteUrlError(GitCommandError):
+    """Raised when setting a remote URL fails."""
+
+
+def set_remote_url(
+    remote: str,
+    url: str,
+    *,
+    cwd: str = ".",
+    push: bool = False,
+    preview: bool = False,
+) -> None:
+    """
+    Set the fetch or push URL of a remote.
+
+    Equivalent to:
+      git remote set-url <remote> <url>
+    or:
+      git remote set-url --push <remote> <url>
+    """
+    args = ["remote", "set-url"]
+    if push:
+        args.append("--push")
+    args += [remote, url]
+
+    try:
+        run(
+            args,
+            cwd=cwd,
+            preview=preview,
+        )
+    except GitError as exc:
+        mode = "push" if push else "fetch"
+        raise GitSetRemoteUrlError(
+            f"Failed to set {mode} url for remote {remote!r} to {url!r}.",
+            cwd=cwd,
+        ) from exc

src/pkgmgr/core/git/errors.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+
+class GitError(RuntimeError):
+    """Base error raised for Git related failures."""
+
+
+class GitCommandError(GitError):
+    """
+    Base class for state-changing git command failures.
+
+    Use subclasses to provide stable error types for callers.
+    """
+    def __init__(self, message: str, *, cwd: str = ".") -> None:
+        super().__init__(message)
+        self.cwd = cwd

src/pkgmgr/core/git/queries/__init__.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from .get_current_branch import get_current_branch
+from .get_head_commit import get_head_commit
+from .get_tags import get_tags
+from .resolve_base_branch import GitBaseBranchNotFoundError, resolve_base_branch
+from .list_remotes import list_remotes
+from .get_remote_push_urls import get_remote_push_urls
+from .probe_remote_reachable import probe_remote_reachable
+from .get_changelog import get_changelog, GitChangelogQueryError
+from .get_tags_at_ref import get_tags_at_ref, GitTagsAtRefQueryError
+
+__all__ = [
+    "get_current_branch",
+    "get_head_commit",
+    "get_tags",
+    "resolve_base_branch",
+    "GitBaseBranchNotFoundError",
+    "list_remotes",
+    "get_remote_push_urls",
+    "probe_remote_reachable",
+    "get_changelog",
+    "GitChangelogQueryError",
+    "get_tags_at_ref",
+    "GitTagsAtRefQueryError",
+]

src/pkgmgr/core/git/queries/get_changelog.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from ..errors import GitError
+from ..run import run
+
+
+class GitChangelogQueryError(GitError):
+    """Raised when querying the git changelog fails."""
+
+
+def get_changelog(
+    *,
+    cwd: str,
+    from_ref: Optional[str] = None,
+    to_ref: Optional[str] = None,
+    include_merges: bool = False,
+) -> str:
+    """
+    Return a plain-text changelog between two Git refs.
+
+    Uses:
+      git log --pretty=format:%h %d %s [--no-merges] <range>
+
+    Raises:
+      GitChangelogQueryError on failure.
+    """
+    if to_ref is None:
+        to_ref = "HEAD"
+
+    rev_range = f"{from_ref}..{to_ref}" if from_ref else to_ref
+
+    cmd = ["log", "--pretty=format:%h %d %s"]
+    if not include_merges:
+        cmd.append("--no-merges")
+    cmd.append(rev_range)
+
+    try:
+        return run(cmd, cwd=cwd)
+    except GitError as exc:
+        raise GitChangelogQueryError(
+            f"Failed to query changelog for range {rev_range!r}.",
+        ) from exc

src/pkgmgr/core/git/queries/get_current_branch.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing import Optional
+from ..errors import GitError
+from ..run import run
+
+
+def get_current_branch(cwd: str = ".") -> Optional[str]:
+    """
+    Return the current branch name, or None if it cannot be determined.
+
+    Note: In detached HEAD state this will return 'HEAD'.
+    """
+    try:
+        output = run(["rev-parse", "--abbrev-ref", "HEAD"], cwd=cwd)
+    except GitError:
+        return None
+    return output or None

src/pkgmgr/core/git/queries/get_head_commit.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from ..errors import GitError
+from ..run import run
+
+
+def get_head_commit(cwd: str = ".") -> Optional[str]:
+    """
+    Return the current HEAD commit hash, or None if it cannot be determined.
+    """
+    try:
+        output = run(["rev-parse", "HEAD"], cwd=cwd)
+    except GitError:
+        return None
+    return output or None

src/pkgmgr/core/git/queries/get_remote_push_urls.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from typing import Set
+
+from ..errors import GitError
+from ..run import run
+
+
+def get_remote_push_urls(remote: str, cwd: str = ".") -> Set[str]:
+    """
+    Return all push URLs configured for a remote.
+
+    Equivalent to:
+      git remote get-url --push --all <remote>
+
+    Raises GitError if the command fails.
+    """
+    output = run(["remote", "get-url", "--push", "--all", remote], cwd=cwd)
+    if not output:
+        return set()
+    return {line.strip() for line in output.splitlines() if line.strip()}

src/pkgmgr/core/git/queries/get_tags.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import List
+
+from ..errors import GitError
+from ..run import run
+
+
+def get_tags(cwd: str = ".") -> List[str]:
+    """
+    Return a list of all tags in the repository in `cwd`.
+
+    If there are no tags, an empty list is returned.
+    """
+    try:
+        output = run(["tag"], cwd=cwd)
+    except GitError as exc:
+        # If the repo is not a git repo, surface a clear error.
+        if "not a git repository" in str(exc):
+            raise
+        # Otherwise, treat as "no tags" (e.g., empty stdout).
+        return []
+
+    if not output:
+        return []
+
+    return [line.strip() for line in output.splitlines() if line.strip()]

src/pkgmgr/core/git/queries/get_tags_at_ref.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import List
+
+from ..errors import GitError
+from ..run import run
+
+
+class GitTagsAtRefQueryError(GitError):
+    """Raised when querying tags for a ref fails."""
+
+
+def get_tags_at_ref(ref: str, *, cwd: str = ".") -> List[str]:
+    """
+    Return all git tags pointing at a given ref.
+
+    Equivalent to:
+      git tag --points-at <ref>
+    """
+    try:
+        output = run(["tag", "--points-at", ref], cwd=cwd)
+    except GitError as exc:
+        raise GitTagsAtRefQueryError(
+            f"Failed to query tags at ref {ref!r}.",
+        ) from exc
+
+    if not output:
+        return []
+
+    return [line.strip() for line in output.splitlines() if line.strip()]

src/pkgmgr/core/git/queries/list_remotes.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing import List
+
+from ..errors import GitError
+from ..run import run
+
+
+def list_remotes(cwd: str = ".") -> List[str]:
+    """
+    Return a list of configured git remotes (e.g. ['origin', 'upstream']).
+
+    Raises GitError if the command fails.
+    """
+    output = run(["remote"], cwd=cwd)
+    if not output:
+        return []
+    return [line.strip() for line in output.splitlines() if line.strip()]

src/pkgmgr/core/git/queries/probe_remote_reachable.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from ..errors import GitError
+from ..run import run
+
+
+def probe_remote_reachable(url: str, cwd: str = ".") -> bool:
+    """
+    Check whether a remote URL is reachable.
+
+    Equivalent to:
+      git ls-remote --exit-code <url>
+
+    Returns:
+      True if reachable, False otherwise.
+    """
+    try:
+        run(["ls-remote", "--exit-code", url], cwd=cwd)
+        return True
+    except GitError:
+        return False

src/pkgmgr/core/git/queries/resolve_base_branch.py

@@ -0,0 +1,66 @@
+# src/pkgmgr/core/git/queries/resolve_base_branch.py
+from __future__ import annotations
+
+from ..errors import GitError
+from ..run import run
+
+
+class GitBaseBranchNotFoundError(GitError):
+    """Raised when neither preferred nor fallback base branch exists."""
+
+
+def _is_branch_missing_error(exc: GitError) -> bool:
+    """
+    Heuristic: Detect errors that indicate the branch/ref does not exist.
+
+    We intentionally *do not* swallow other errors like:
+      - not a git repository
+      - permission issues
+      - corrupted repository
+    """
+    msg = str(exc).lower()
+
+    # Common git messages when verifying a non-existing ref/branch.
+    patterns = [
+        "needed a single revision",
+        "unknown revision or path not in the working tree",
+        "not a valid object name",
+        "ambiguous argument",
+        "bad revision",
+        "fatal: invalid object name",
+        "fatal: ambiguous argument",
+    ]
+
+    return any(p in msg for p in patterns)
+
+
+def resolve_base_branch(
+    preferred: str = "main",
+    fallback: str = "master",
+    cwd: str = ".",
+) -> str:
+    """
+    Resolve the base branch to use.
+
+    Try `preferred` first (default: main),
+    fall back to `fallback` (default: master).
+
+    Raises GitBaseBranchNotFoundError if neither exists.
+    Raises GitError for other git failures (e.g., not a git repository).
+    """
+    last_missing_error: GitError | None = None
+
+    for candidate in (preferred, fallback):
+        try:
+            run(["rev-parse", "--verify", candidate], cwd=cwd)
+            return candidate
+        except GitError as exc:
+            if _is_branch_missing_error(exc):
+                last_missing_error = exc
+                continue
+            raise  # anything else is a real problem -> bubble up
+
+    # Both candidates missing -> raise specific error
+    raise GitBaseBranchNotFoundError(
+        f"Neither {preferred!r} nor {fallback!r} exist in this repository."
+    ) from last_missing_error

src/pkgmgr/core/git/run.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import subprocess
+from typing import List
+
+from .errors import GitError
+
+
+def run(
+    args: List[str],
+    *,
+    cwd: str = ".",
+    preview: bool = False,
+) -> str:
+    """
+    Run a Git command and return its stdout as a stripped string.
+
+    If preview=True, the command is printed but NOT executed.
+
+    Raises GitError if execution fails.
+    """
+    cmd = ["git"] + args
+    cmd_str = " ".join(cmd)
+
+    if preview:
+        print(f"[PREVIEW] Would run in {cwd!r}: {cmd_str}")
+        return ""
+
+    try:
+        result = subprocess.run(
+            cmd,
+            cwd=cwd,
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+    except subprocess.CalledProcessError as exc:
+        raise GitError(
+            f"Git command failed in {cwd!r}: {cmd_str}\n"
+            f"Exit code: {exc.returncode}\n"
+            f"STDOUT:\n{exc.stdout}\n"
+            f"STDERR:\n{exc.stderr}"
+        ) from exc
+
+    return result.stdout.strip()

templates/default/.gitignore.j2

@@ -0,0 +1,5 @@
+.venv/
+dist/
+build/
+__pycache__/
+*.pyc

templates/default/LICENSE.j2

@@ -0,0 +1 @@
+{{ license_text }}

templates/default/README.md.j2

@@ -0,0 +1,6 @@
+# {{ repository }}
+
+Homepage: {{ homepage }}
+
+## Author
+{{ author_name }} <{{ author_email }}>

templates/default/flake.nix.j2

@@ -0,0 +1,11 @@
+{
+  description = "{{ repository }}";
+  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+  outputs = { self, nixpkgs }:
+  let system = "x86_64-linux"; pkgs = import nixpkgs { inherit system; };
+  in {
+    devShells.${system}.default = pkgs.mkShell {
+      packages = with pkgs; [ python312 python312Packages.pytest python312Packages.ruff ];
+    };
+  };
+}

templates/default/pyproject.toml.j2

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "{{ repository }}"
+version = "0.1.0"
+description = ""
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "{{ author_name }}", email = "{{ author_email }}" }]
+license = { text = "{{ license_text }}" }
+urls = { Homepage = "{{ homepage }}" }
+
+dependencies = []
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

tests/e2e/test_publish_commands.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import unittest
+
+
+PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+
+
+def _run_help(cmd: list[str], label: str) -> str:
+    print(f"\n[TEST] Running ({label}): {' '.join(cmd)}")
+    proc = subprocess.run(
+        cmd,
+        cwd=PROJECT_ROOT,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,
+        env=os.environ.copy(),
+    )
+    print(proc.stdout.rstrip())
+
+    # For --help we expect success (0). Anything else is an error.
+    if proc.returncode != 0:
+        raise AssertionError(
+            f"[TEST] Help command failed ({label}).\n"
+            f"Command: {' '.join(cmd)}\n"
+            f"Exit code: {proc.returncode}\n"
+            f"--- output ---\n{proc.stdout}\n"
+        )
+
+    return proc.stdout
+
+
+class TestPublishHelpE2E(unittest.TestCase):
+    def test_pkgmgr_publish_help(self) -> None:
+        out = _run_help(["pkgmgr", "publish", "--help"], "pkgmgr publish --help")
+        self.assertIn("usage:", out)
+        self.assertIn("publish", out)
+
+    def test_pkgmgr_help_mentions_publish(self) -> None:
+        out = _run_help(["pkgmgr", "--help"], "pkgmgr --help")
+        self.assertIn("publish", out)
+
+    def test_nix_run_pkgmgr_publish_help(self) -> None:
+        if shutil.which("nix") is None:
+            self.skipTest("nix is not available in this environment")
+
+        out = _run_help(
+            ["nix", "run", ".#pkgmgr", "--", "publish", "--help"],
+            "nix run .#pkgmgr -- publish --help",
+        )
+        self.assertIn("usage:", out)
+        self.assertIn("publish", out)
+
+    def test_nix_run_pkgmgr_help_mentions_publish(self) -> None:
+        if shutil.which("nix") is None:
+            self.skipTest("nix is not available in this environment")
+
+        out = _run_help(
+            ["nix", "run", ".#pkgmgr", "--", "--help"],
+            "nix run .#pkgmgr -- --help",
+        )
+        self.assertIn("publish", out)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/e2e/test_repos_create_preview_output.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import io
+import unittest
+from contextlib import redirect_stdout
+from unittest.mock import patch
+
+from pkgmgr.actions.repository.create import create_repo
+
+
+class TestE2ECreateRepoPreviewOutput(unittest.TestCase):
+    def test_create_repo_preview_prints_expected_steps(self) -> None:
+        cfg = {"directories": {"repositories": "/tmp/Repositories"}, "repositories": []}
+
+        out = io.StringIO()
+        with (
+            redirect_stdout(out),
+            patch("pkgmgr.actions.repository.create.os.path.exists", return_value=False),
+            patch("pkgmgr.actions.repository.create.generate_alias", return_value="repo"),
+            patch("pkgmgr.actions.repository.create.save_user_config"),
+            patch("pkgmgr.actions.repository.create.os.makedirs"),
+            patch("pkgmgr.actions.repository.create.render_default_templates"),
+            patch("pkgmgr.actions.repository.create.write_mirrors_file"),
+            patch("pkgmgr.actions.repository.create.setup_mirrors"),
+            patch("pkgmgr.actions.repository.create.subprocess.run"),
+        ):
+            create_repo(
+                "github.com/acme/repo",
+                cfg,
+                "/tmp/user.yml",
+                "/tmp/bin",
+                remote=False,
+                preview=True,
+            )
+
+        s = out.getvalue()
+        self.assertIn("[Preview] Would save user config:", s)
+        self.assertIn("[Preview] Would ensure directory exists:", s)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/e2e/test_update_all_no_system.py

@@ -96,6 +96,7 @@ class TestIntegrationUpdateAllshallowNoSystem(unittest.TestCase):
                 "--clone-mode",
                 "shallow",
                 "--no-verification",
+                "--silent",
             ]
             self._run_cmd(["pkgmgr", *args], label="pkgmgr", env=env)
             pkgmgr_help_debug()
@@ -110,6 +111,7 @@ class TestIntegrationUpdateAllshallowNoSystem(unittest.TestCase):
                 "--clone-mode",
                 "shallow",
                 "--no-verification",
+                "--silent",
             ]
             self._run_cmd(
                 ["nix", "run", ".#pkgmgr", "--", *args],

tests/integration/test_mirror_commands.py

@@ -27,18 +27,10 @@ from unittest.mock import MagicMock, PropertyMock, patch
 
 
 class TestIntegrationMirrorCommands(unittest.TestCase):
-    """
-    Integration tests for `pkgmgr mirror` commands.
-    """
+    """Integration tests for `pkgmgr mirror` commands."""
 
     def _run_pkgmgr(self, args: List[str], extra_env: Optional[Dict[str, str]] = None) -> str:
-        """
-        Execute pkgmgr with the given arguments and return captured output.
-
-        - Treat SystemExit(0) or SystemExit(None) as success.
-        - Any other exit code is considered a test failure.
-        - Mirror commands are patched to avoid network/destructive operations.
-        """
+        """Execute pkgmgr with the given arguments and return captured output."""
         original_argv = list(sys.argv)
         original_env = dict(os.environ)
         buffer = io.StringIO()
@@ -64,8 +56,7 @@ class TestIntegrationMirrorCommands(unittest.TestCase):
             try:
                 importlib.import_module(module_name)
             except ModuleNotFoundError:
-                # If the module truly doesn't exist, create=True may still allow patching
-                # in some cases, but dotted resolution can still fail. Best-effort.
+                # Best-effort: allow patch(create=True) even if a symbol moved.
                 pass
             return patch(target, create=True, **kwargs)
 
@@ -95,10 +86,9 @@ class TestIntegrationMirrorCommands(unittest.TestCase):
                 stack.enter_context(_p("pkgmgr.actions.mirror.setup_cmd.build_context", return_value=dummy_ctx))
                 stack.enter_context(_p("pkgmgr.actions.mirror.remote_provision.build_context", return_value=dummy_ctx))
 
-                # Deterministic remote probing (covers setup + likely check implementations)
-                stack.enter_context(_p("pkgmgr.actions.mirror.remote_check.probe_mirror", return_value=(True, "")))
-                stack.enter_context(_p("pkgmgr.actions.mirror.setup_cmd.probe_mirror", return_value=(True, "")))
-                stack.enter_context(_p("pkgmgr.actions.mirror.git_remote.is_remote_reachable", return_value=True))
+                # Deterministic remote probing (new refactor: probe_remote_reachable)
+                stack.enter_context(_p("pkgmgr.core.git.queries.probe_remote_reachable", return_value=True))
+                stack.enter_context(_p("pkgmgr.actions.mirror.setup_cmd.probe_remote_reachable", return_value=True))
 
                 # setup_cmd imports ensure_origin_remote directly:
                 stack.enter_context(_p("pkgmgr.actions.mirror.setup_cmd.ensure_origin_remote", return_value=None))
@@ -113,9 +103,6 @@ class TestIntegrationMirrorCommands(unittest.TestCase):
                     )
                 )
 
-                # Extra safety: if anything calls remote_check.run_git directly, make it inert
-                stack.enter_context(_p("pkgmgr.actions.mirror.remote_check.run_git", return_value="dummy"))
-
                 with redirect_stdout(buffer), redirect_stderr(buffer):
                     try:
                         runpy.run_module("pkgmgr", run_name="__main__")
@@ -134,10 +121,6 @@ class TestIntegrationMirrorCommands(unittest.TestCase):
             os.environ.clear()
             os.environ.update(original_env)
 
-    # ------------------------------------------------------------
-    # Tests
-    # ------------------------------------------------------------
-
     def test_mirror_help(self) -> None:
         output = self._run_pkgmgr(["mirror", "--help"])
         self.assertIn("usage:", output.lower())

tests/integration/test_publish_integration.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import io
+import os
+import shutil
+import subprocess
+import tempfile
+import unittest
+from contextlib import redirect_stdout
+from types import SimpleNamespace
+
+from pkgmgr.cli.commands.publish import handle_publish
+
+
+def _run(cmd: list[str], cwd: str) -> None:
+    subprocess.run(
+        cmd,
+        cwd=cwd,
+        check=True,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+
+class TestIntegrationPublish(unittest.TestCase):
+    def setUp(self) -> None:
+        if shutil.which("git") is None:
+            self.skipTest("git is required for this integration test")
+
+        self.tmp = tempfile.TemporaryDirectory()
+        self.repo_dir = self.tmp.name
+
+        # Initialize git repository
+        _run(["git", "init"], cwd=self.repo_dir)
+        _run(["git", "config", "user.email", "ci@example.invalid"], cwd=self.repo_dir)
+        _run(["git", "config", "user.name", "CI"], cwd=self.repo_dir)
+
+        with open(os.path.join(self.repo_dir, "README.md"), "w", encoding="utf-8") as f:
+            f.write("test\n")
+
+        _run(["git", "add", "README.md"], cwd=self.repo_dir)
+        _run(["git", "commit", "-m", "init"], cwd=self.repo_dir)
+        _run(["git", "tag", "-a", "v1.2.3", "-m", "v1.2.3"], cwd=self.repo_dir)
+
+        # Create MIRRORS file with PyPI target
+        with open(os.path.join(self.repo_dir, "MIRRORS"), "w", encoding="utf-8") as f:
+            f.write("https://pypi.org/project/pkgmgr/\n")
+
+    def tearDown(self) -> None:
+        self.tmp.cleanup()
+
+    def test_publish_preview_end_to_end(self) -> None:
+        ctx = SimpleNamespace(
+            repositories_base_dir=self.repo_dir,
+            all_repositories=[
+                {
+                    "name": "pkgmgr",
+                    "directory": self.repo_dir,
+                }
+            ],
+        )
+
+        selected = [
+            {
+                "name": "pkgmgr",
+                "directory": self.repo_dir,
+            }
+        ]
+
+        args = SimpleNamespace(
+            preview=True,
+            non_interactive=False,
+        )
+
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            handle_publish(args=args, ctx=ctx, selected=selected)
+
+        out = buf.getvalue()
+
+        self.assertIn("[pkgmgr] Publishing repository", out)
+        self.assertIn("[INFO] Publishing pkgmgr for tag v1.2.3", out)
+        self.assertIn("[PREVIEW] Would build and upload to PyPI.", out)
+
+        # Preview must not create dist/
+        self.assertFalse(os.path.isdir(os.path.join(self.repo_dir, "dist")))
+
+    def test_publish_skips_without_pypi_mirror(self) -> None:
+        with open(os.path.join(self.repo_dir, "MIRRORS"), "w", encoding="utf-8") as f:
+            f.write("git@github.com:example/example.git\n")
+
+        ctx = SimpleNamespace(
+            repositories_base_dir=self.repo_dir,
+            all_repositories=[
+                {
+                    "name": "pkgmgr",
+                    "directory": self.repo_dir,
+                }
+            ],
+        )
+
+        selected = [
+            {
+                "name": "pkgmgr",
+                "directory": self.repo_dir,
+            }
+        ]
+
+        args = SimpleNamespace(
+            preview=True,
+            non_interactive=False,
+        )
+
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            handle_publish(args=args, ctx=ctx, selected=selected)
+
+        out = buf.getvalue()
+        self.assertIn("[INFO] No PyPI mirror found. Skipping publish.", out)

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/integration/test_repos_create_preview.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import importlib
+import io
+import unittest
+from contextlib import redirect_stdout
+from types import SimpleNamespace
+from unittest.mock import patch
+
+
+class TestIntegrationReposCreatePreview(unittest.TestCase):
+    def test_repos_create_preview_wires_create_repo(self) -> None:
+        # Import lazily to avoid hard-failing if the CLI module/function name differs.
+        try:
+            repos_mod = importlib.import_module("pkgmgr.cli.commands.repos")
+        except Exception as exc:
+            self.skipTest(f"CLI module not available: {exc}")
+
+        handle = getattr(repos_mod, "handle_repos_command", None)
+        if handle is None:
+            self.skipTest("handle_repos_command not found in pkgmgr.cli.commands.repos")
+
+        ctx = SimpleNamespace(
+            repositories_base_dir="/tmp/Repositories",
+            binaries_dir="/tmp/bin",
+            all_repositories=[],
+            config_merged={"directories": {"repositories": "/tmp/Repositories"}, "repositories": []},
+            user_config_path="/tmp/user.yml",
+        )
+
+        args = SimpleNamespace(
+            command="create",
+            identifiers=["github.com/acme/repo"],
+            remote=False,
+            preview=True,
+        )
+
+        out = io.StringIO()
+        with (
+            redirect_stdout(out),
+            patch("pkgmgr.cli.commands.repos.create_repo") as create_repo,
+        ):
+            handle(args, ctx, selected=[])
+
+        create_repo.assert_called_once()
+        called = create_repo.call_args.kwargs
+        self.assertEqual(called["remote"], False)
+        self.assertEqual(called["preview"], True)
+        self.assertEqual(create_repo.call_args.args[0], "github.com/acme/repo")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/integration/test_update_silent_continues.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+import unittest
+from unittest.mock import patch
+
+from pkgmgr.actions.update.manager import UpdateManager
+
+
+class TestUpdateSilentContinues(unittest.TestCase):
+    def test_update_continues_on_failures_and_silent_controls_exit_code(self) -> None:
+        """
+        Integration test for UpdateManager:
+          - pull failure on repo A should not stop repo B/C
+          - install failure on repo B should not stop repo C
+          - without silent -> SystemExit(1) at end if any failures
+          - with silent -> no SystemExit even if there are failures
+        """
+
+        repos = [
+            {"provider": "github", "account": "example", "repository": "repo-a"},
+            {"provider": "github", "account": "example", "repository": "repo-b"},
+            {"provider": "github", "account": "example", "repository": "repo-c"},
+        ]
+
+        # We patch the internal calls used by UpdateManager:
+        # - pull_with_verification is called once per repo
+        # - install_repos is called once per repo that successfully pulled
+        #
+        # We simulate:
+        #   repo-a: pull fails
+        #   repo-b: pull ok, install fails
+        #   repo-c: pull ok, install ok
+        pull_calls = []
+        install_calls = []
+
+        def pull_side_effect(selected_repos, *_args, **_kwargs):
+            # selected_repos is a list with exactly one repo in our implementation.
+            repo = selected_repos[0]
+            pull_calls.append(repo["repository"])
+            if repo["repository"] == "repo-a":
+                raise SystemExit(2)
+            return None
+
+        def install_side_effect(selected_repos, *_args, **kwargs):
+            repo = selected_repos[0]
+            install_calls.append((repo["repository"], kwargs.get("silent"), kwargs.get("emit_summary")))
+            if repo["repository"] == "repo-b":
+                raise SystemExit(3)
+            return None
+
+        # Patch at the exact import locations used inside UpdateManager.run()
+        with patch("pkgmgr.actions.repository.pull.pull_with_verification", side_effect=pull_side_effect), patch(
+            "pkgmgr.actions.install.install_repos", side_effect=install_side_effect
+        ):
+            # 1) silent=True: should NOT raise (even though failures happened)
+            UpdateManager().run(
+                selected_repos=repos,
+                repositories_base_dir="/tmp/repos",
+                bin_dir="/tmp/bin",
+                all_repos=repos,
+                no_verification=True,
+                system_update=False,
+                preview=True,
+                quiet=True,
+                update_dependencies=False,
+                clone_mode="shallow",
+                silent=True,
+                force_update=True,
+            )
+
+            # Ensure it tried all pulls, and installs happened for B and C only.
+            self.assertEqual(pull_calls, ["repo-a", "repo-b", "repo-c"])
+            self.assertEqual([r for r, _silent, _emit in install_calls], ["repo-b", "repo-c"])
+
+            # Ensure UpdateManager suppressed install summary spam by passing emit_summary=False.
+            for _repo_name, _silent, emit_summary in install_calls:
+                self.assertFalse(emit_summary)
+
+            # Reset tracking for the non-silent run
+            pull_calls.clear()
+            install_calls.clear()
+
+            # 2) silent=False: should raise SystemExit(1) at end due to failures
+            with self.assertRaises(SystemExit) as cm:
+                UpdateManager().run(
+                    selected_repos=repos,
+                    repositories_base_dir="/tmp/repos",
+                    bin_dir="/tmp/bin",
+                    all_repos=repos,
+                    no_verification=True,
+                    system_update=False,
+                    preview=True,
+                    quiet=True,
+                    update_dependencies=False,
+                    clone_mode="shallow",
+                    silent=False,
+                    force_update=True,
+                )
+            self.assertEqual(cm.exception.code, 1)
+
+            # Still must have processed all repos (continue-on-failure behavior).
+            self.assertEqual(pull_calls, ["repo-a", "repo-b", "repo-c"])
+            self.assertEqual([r for r, _silent, _emit in install_calls], ["repo-b", "repo-c"])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/unit/pkgmgr/actions/branch/__init__.py

@@ -1,33 +0,0 @@
-import unittest
-from unittest.mock import patch
-
-from pkgmgr.actions.branch.utils import _resolve_base_branch
-from pkgmgr.core.git import GitError
-
-
-class TestResolveBaseBranch(unittest.TestCase):
-    @patch("pkgmgr.actions.branch.utils.run_git")
-    def test_resolves_preferred(self, run_git):
-        run_git.return_value = None
-        result = _resolve_base_branch("main", "master", cwd=".")
-        self.assertEqual(result, "main")
-        run_git.assert_called_with(["rev-parse", "--verify", "main"], cwd=".")
-
-    @patch("pkgmgr.actions.branch.utils.run_git")
-    def test_resolves_fallback(self, run_git):
-        run_git.side_effect = [
-            GitError("main missing"),
-            None,
-        ]
-        result = _resolve_base_branch("main", "master", cwd=".")
-        self.assertEqual(result, "master")
-
-    @patch("pkgmgr.actions.branch.utils.run_git")
-    def test_raises_when_no_branch_exists(self, run_git):
-        run_git.side_effect = GitError("missing")
-        with self.assertRaises(RuntimeError):
-            _resolve_base_branch("main", "master", cwd=".")
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/unit/pkgmgr/actions/branch/test_close_branch.py

@@ -2,54 +2,129 @@ import unittest
 from unittest.mock import patch
 
 from pkgmgr.actions.branch.close_branch import close_branch
-from pkgmgr.core.git import GitError
+from pkgmgr.core.git.errors import GitError
+from pkgmgr.core.git.commands import GitDeleteRemoteBranchError
 
 
 class TestCloseBranch(unittest.TestCase):
-    @patch("pkgmgr.actions.branch.close_branch.input", return_value="y")
+    @patch("builtins.input", return_value="y")
     @patch("pkgmgr.actions.branch.close_branch.get_current_branch", return_value="feature-x")
-    @patch("pkgmgr.actions.branch.close_branch._resolve_base_branch", return_value="main")
-    @patch("pkgmgr.actions.branch.close_branch.run_git")
-    def test_close_branch_happy_path(self, run_git, resolve, current, input_mock):
+    @patch("pkgmgr.actions.branch.close_branch.resolve_base_branch", return_value="main")
+    @patch("pkgmgr.actions.branch.close_branch.fetch")
+    @patch("pkgmgr.actions.branch.close_branch.checkout")
+    @patch("pkgmgr.actions.branch.close_branch.pull")
+    @patch("pkgmgr.actions.branch.close_branch.merge_no_ff")
+    @patch("pkgmgr.actions.branch.close_branch.push")
+    @patch("pkgmgr.actions.branch.close_branch.delete_local_branch")
+    @patch("pkgmgr.actions.branch.close_branch.delete_remote_branch")
+    def test_close_branch_happy_path(
+        self,
+        delete_remote_branch,
+        delete_local_branch,
+        push,
+        merge_no_ff,
+        pull,
+        checkout,
+        fetch,
+        _resolve,
+        _current,
+        _input_mock,
+    ) -> None:
         close_branch(None, cwd=".")
-        expected = [
-            (["fetch", "origin"],),
-            (["checkout", "main"],),
-            (["pull", "origin", "main"],),
-            (["merge", "--no-ff", "feature-x"],),
-            (["push", "origin", "main"],),
-            (["branch", "-d", "feature-x"],),
-            (["push", "origin", "--delete", "feature-x"],),
-        ]
-        actual = [call.args for call in run_git.call_args_list]
-        self.assertEqual(actual, expected)
+        fetch.assert_called_once_with("origin", cwd=".")
+        checkout.assert_called_once_with("main", cwd=".")
+        pull.assert_called_once_with("origin", "main", cwd=".")
+        merge_no_ff.assert_called_once_with("feature-x", cwd=".")
+        push.assert_called_once_with("origin", "main", cwd=".")
+        delete_local_branch.assert_called_once_with("feature-x", cwd=".", force=False)
+        delete_remote_branch.assert_called_once_with("origin", "feature-x", cwd=".")
 
     @patch("pkgmgr.actions.branch.close_branch.get_current_branch", return_value="main")
-    @patch("pkgmgr.actions.branch.close_branch._resolve_base_branch", return_value="main")
-    def test_refuses_to_close_base_branch(self, resolve, current):
+    @patch("pkgmgr.actions.branch.close_branch.resolve_base_branch", return_value="main")
+    def test_refuses_to_close_base_branch(self, _resolve, _current) -> None:
         with self.assertRaises(RuntimeError):
             close_branch(None)
 
-    @patch("pkgmgr.actions.branch.close_branch.input", return_value="n")
+    @patch("builtins.input", return_value="n")
     @patch("pkgmgr.actions.branch.close_branch.get_current_branch", return_value="feature-x")
-    @patch("pkgmgr.actions.branch.close_branch._resolve_base_branch", return_value="main")
-    @patch("pkgmgr.actions.branch.close_branch.run_git")
-    def test_close_branch_aborts_on_no(self, run_git, resolve, current, input_mock):
+    @patch("pkgmgr.actions.branch.close_branch.resolve_base_branch", return_value="main")
+    @patch("pkgmgr.actions.branch.close_branch.fetch")
+    def test_close_branch_aborts_on_no(self, fetch, _resolve, _current, _input_mock) -> None:
         close_branch(None, cwd=".")
-        run_git.assert_not_called()
+        fetch.assert_not_called()
 
+    @patch("builtins.input")
     @patch("pkgmgr.actions.branch.close_branch.get_current_branch", return_value="feature-x")
-    @patch("pkgmgr.actions.branch.close_branch._resolve_base_branch", return_value="main")
-    @patch("pkgmgr.actions.branch.close_branch.run_git")
-    def test_close_branch_force_skips_prompt(self, run_git, resolve, current):
+    @patch("pkgmgr.actions.branch.close_branch.resolve_base_branch", return_value="main")
+    @patch("pkgmgr.actions.branch.close_branch.fetch")
+    @patch("pkgmgr.actions.branch.close_branch.checkout")
+    @patch("pkgmgr.actions.branch.close_branch.pull")
+    @patch("pkgmgr.actions.branch.close_branch.merge_no_ff")
+    @patch("pkgmgr.actions.branch.close_branch.push")
+    @patch("pkgmgr.actions.branch.close_branch.delete_local_branch")
+    @patch("pkgmgr.actions.branch.close_branch.delete_remote_branch")
+    def test_close_branch_force_skips_prompt(
+        self,
+        delete_remote_branch,
+        delete_local_branch,
+        push,
+        merge_no_ff,
+        pull,
+        checkout,
+        fetch,
+        _resolve,
+        _current,
+        input_mock,
+    ) -> None:
         close_branch(None, cwd=".", force=True)
-        self.assertGreater(len(run_git.call_args_list), 0)
+
+        # no interactive prompt when forced
+        input_mock.assert_not_called()
+
+        # workflow still runs (but is mocked)
+        fetch.assert_called_once_with("origin", cwd=".")
+        checkout.assert_called_once_with("main", cwd=".")
+        pull.assert_called_once_with("origin", "main", cwd=".")
+        merge_no_ff.assert_called_once_with("feature-x", cwd=".")
+        push.assert_called_once_with("origin", "main", cwd=".")
+        delete_local_branch.assert_called_once_with("feature-x", cwd=".", force=False)
+        delete_remote_branch.assert_called_once_with("origin", "feature-x", cwd=".")
 
     @patch("pkgmgr.actions.branch.close_branch.get_current_branch", side_effect=GitError("fail"))
-    def test_close_branch_errors_if_cannot_detect_branch(self, current):
+    def test_close_branch_errors_if_cannot_detect_branch(self, _current) -> None:
         with self.assertRaises(RuntimeError):
             close_branch(None)
 
+    @patch("builtins.input", return_value="y")
+    @patch("pkgmgr.actions.branch.close_branch.get_current_branch", return_value="feature-x")
+    @patch("pkgmgr.actions.branch.close_branch.resolve_base_branch", return_value="main")
+    @patch("pkgmgr.actions.branch.close_branch.fetch")
+    @patch("pkgmgr.actions.branch.close_branch.checkout")
+    @patch("pkgmgr.actions.branch.close_branch.pull")
+    @patch("pkgmgr.actions.branch.close_branch.merge_no_ff")
+    @patch("pkgmgr.actions.branch.close_branch.push")
+    @patch("pkgmgr.actions.branch.close_branch.delete_local_branch")
+    @patch(
+        "pkgmgr.actions.branch.close_branch.delete_remote_branch",
+        side_effect=GitDeleteRemoteBranchError("boom", cwd="."),
+    )
+    def test_close_branch_remote_delete_failure_is_wrapped(
+        self,
+        _delete_remote_branch,
+        _delete_local_branch,
+        _push,
+        _merge_no_ff,
+        _pull,
+        _checkout,
+        _fetch,
+        _resolve,
+        _current,
+        _input_mock,
+    ) -> None:
+        with self.assertRaises(RuntimeError) as ctx:
+            close_branch(None, cwd=".")
+        self.assertIn("remote deletion failed", str(ctx.exception))
+
 
 if __name__ == "__main__":
     unittest.main()

tests/unit/pkgmgr/actions/branch/test_drop_branch.py

@@ -2,49 +2,79 @@ import unittest
 from unittest.mock import patch
 
 from pkgmgr.actions.branch.drop_branch import drop_branch
-from pkgmgr.core.git import GitError
+from pkgmgr.core.git.errors import GitError
+from pkgmgr.core.git.commands import GitDeleteRemoteBranchError
 
 
 class TestDropBranch(unittest.TestCase):
-    @patch("pkgmgr.actions.branch.drop_branch.input", return_value="y")
+    @patch("builtins.input", return_value="y")
     @patch("pkgmgr.actions.branch.drop_branch.get_current_branch", return_value="feature-x")
-    @patch("pkgmgr.actions.branch.drop_branch._resolve_base_branch", return_value="main")
-    @patch("pkgmgr.actions.branch.drop_branch.run_git")
-    def test_drop_branch_happy_path(self, run_git, resolve, current, input_mock):
+    @patch("pkgmgr.actions.branch.drop_branch.resolve_base_branch", return_value="main")
+    @patch("pkgmgr.actions.branch.drop_branch.delete_local_branch")
+    @patch("pkgmgr.actions.branch.drop_branch.delete_remote_branch")
+    def test_drop_branch_happy_path(self, delete_remote, delete_local, _resolve, _current, _input_mock) -> None:
         drop_branch(None, cwd=".")
-        expected = [
-            (["branch", "-d", "feature-x"],),
-            (["push", "origin", "--delete", "feature-x"],),
-        ]
-        actual = [call.args for call in run_git.call_args_list]
-        self.assertEqual(actual, expected)
+        delete_local.assert_called_once_with("feature-x", cwd=".", force=False)
+        delete_remote.assert_called_once_with("origin", "feature-x", cwd=".")
 
     @patch("pkgmgr.actions.branch.drop_branch.get_current_branch", return_value="main")
-    @patch("pkgmgr.actions.branch.drop_branch._resolve_base_branch", return_value="main")
-    def test_refuses_to_drop_base_branch(self, resolve, current):
+    @patch("pkgmgr.actions.branch.drop_branch.resolve_base_branch", return_value="main")
+    def test_refuses_to_drop_base_branch(self, _resolve, _current) -> None:
         with self.assertRaises(RuntimeError):
             drop_branch(None)
 
-    @patch("pkgmgr.actions.branch.drop_branch.input", return_value="n")
+    @patch("builtins.input", return_value="n")
     @patch("pkgmgr.actions.branch.drop_branch.get_current_branch", return_value="feature-x")
-    @patch("pkgmgr.actions.branch.drop_branch._resolve_base_branch", return_value="main")
-    @patch("pkgmgr.actions.branch.drop_branch.run_git")
-    def test_drop_branch_aborts_on_no(self, run_git, resolve, current, input_mock):
+    @patch("pkgmgr.actions.branch.drop_branch.resolve_base_branch", return_value="main")
+    @patch("pkgmgr.actions.branch.drop_branch.delete_local_branch")
+    def test_drop_branch_aborts_on_no(self, delete_local, _resolve, _current, _input_mock) -> None:
         drop_branch(None, cwd=".")
-        run_git.assert_not_called()
+        delete_local.assert_not_called()
 
+    @patch("builtins.input")
     @patch("pkgmgr.actions.branch.drop_branch.get_current_branch", return_value="feature-x")
-    @patch("pkgmgr.actions.branch.drop_branch._resolve_base_branch", return_value="main")
-    @patch("pkgmgr.actions.branch.drop_branch.run_git")
-    def test_drop_branch_force_skips_prompt(self, run_git, resolve, current):
+    @patch("pkgmgr.actions.branch.drop_branch.resolve_base_branch", return_value="main")
+    @patch("pkgmgr.actions.branch.drop_branch.delete_local_branch")
+    @patch("pkgmgr.actions.branch.drop_branch.delete_remote_branch")
+    def test_drop_branch_force_skips_prompt(
+        self,
+        delete_remote,
+        delete_local,
+        _resolve,
+        _current,
+        input_mock,
+    ) -> None:
         drop_branch(None, cwd=".", force=True)
-        self.assertGreater(len(run_git.call_args_list), 0)
+
+        input_mock.assert_not_called()
+        delete_local.assert_called_once_with("feature-x", cwd=".", force=False)
+        delete_remote.assert_called_once_with("origin", "feature-x", cwd=".")
 
     @patch("pkgmgr.actions.branch.drop_branch.get_current_branch", side_effect=GitError("fail"))
-    def test_drop_branch_errors_if_no_branch_detected(self, current):
+    def test_drop_branch_errors_if_no_branch_detected(self, _current) -> None:
         with self.assertRaises(RuntimeError):
             drop_branch(None)
 
+    @patch("builtins.input", return_value="y")
+    @patch("pkgmgr.actions.branch.drop_branch.get_current_branch", return_value="feature-x")
+    @patch("pkgmgr.actions.branch.drop_branch.resolve_base_branch", return_value="main")
+    @patch("pkgmgr.actions.branch.drop_branch.delete_local_branch")
+    @patch(
+        "pkgmgr.actions.branch.drop_branch.delete_remote_branch",
+        side_effect=GitDeleteRemoteBranchError("boom", cwd="."),
+    )
+    def test_drop_branch_remote_delete_failure_is_wrapped(
+        self,
+        _delete_remote,
+        _delete_local,
+        _resolve,
+        _current,
+        _input_mock,
+    ) -> None:
+        with self.assertRaises(RuntimeError) as ctx:
+            drop_branch(None, cwd=".")
+        self.assertIn("remote deletion failed", str(ctx.exception))
+
 
 if __name__ == "__main__":
     unittest.main()

tests/unit/pkgmgr/actions/branch/test_open_branch.py

@@ -5,29 +5,55 @@ from pkgmgr.actions.branch.open_branch import open_branch
 
 
 class TestOpenBranch(unittest.TestCase):
-    @patch("pkgmgr.actions.branch.open_branch._resolve_base_branch", return_value="main")
-    @patch("pkgmgr.actions.branch.open_branch.run_git")
-    def test_open_branch_executes_git_commands(self, run_git, resolve):
+    @patch("pkgmgr.actions.branch.open_branch.resolve_base_branch", return_value="main")
+    @patch("pkgmgr.actions.branch.open_branch.fetch")
+    @patch("pkgmgr.actions.branch.open_branch.checkout")
+    @patch("pkgmgr.actions.branch.open_branch.pull")
+    @patch("pkgmgr.actions.branch.open_branch.create_branch")
+    @patch("pkgmgr.actions.branch.open_branch.push_upstream")
+    def test_open_branch_executes_git_commands(
+        self,
+        push_upstream,
+        create_branch,
+        pull,
+        checkout,
+        fetch,
+        _resolve,
+    ) -> None:
         open_branch("feature-x", base_branch="main", cwd=".")
-        expected_calls = [
-            (["fetch", "origin"],),
-            (["checkout", "main"],),
-            (["pull", "origin", "main"],),
-            (["checkout", "-b", "feature-x"],),
-            (["push", "-u", "origin", "feature-x"],),
-        ]
-        actual = [call.args for call in run_git.call_args_list]
-        self.assertEqual(actual, expected_calls)
+
+        fetch.assert_called_once_with("origin", cwd=".")
+        checkout.assert_called_once_with("main", cwd=".")
+        pull.assert_called_once_with("origin", "main", cwd=".")
+        create_branch.assert_called_once_with("feature-x", "main", cwd=".")
+        push_upstream.assert_called_once_with("origin", "feature-x", cwd=".")
 
     @patch("builtins.input", return_value="auto-branch")
-    @patch("pkgmgr.actions.branch.open_branch._resolve_base_branch", return_value="main")
-    @patch("pkgmgr.actions.branch.open_branch.run_git")
-    def test_open_branch_prompts_for_name(self, run_git, resolve, input_mock):
+    @patch("pkgmgr.actions.branch.open_branch.resolve_base_branch", return_value="main")
+    @patch("pkgmgr.actions.branch.open_branch.fetch")
+    @patch("pkgmgr.actions.branch.open_branch.checkout")
+    @patch("pkgmgr.actions.branch.open_branch.pull")
+    @patch("pkgmgr.actions.branch.open_branch.create_branch")
+    @patch("pkgmgr.actions.branch.open_branch.push_upstream")
+    def test_open_branch_prompts_for_name(
+        self,
+        push_upstream,
+        create_branch,
+        pull,
+        checkout,
+        fetch,
+        _resolve,
+        _input_mock,
+    ) -> None:
         open_branch(None)
-        calls = [call.args for call in run_git.call_args_list]
-        self.assertEqual(calls[3][0][0], "checkout")  # verify git executed normally
 
-    def test_open_branch_rejects_empty_name(self):
+        fetch.assert_called_once_with("origin", cwd=".")
+        checkout.assert_called_once_with("main", cwd=".")
+        pull.assert_called_once_with("origin", "main", cwd=".")
+        create_branch.assert_called_once_with("auto-branch", "main", cwd=".")
+        push_upstream.assert_called_once_with("origin", "auto-branch", cwd=".")
+
+    def test_open_branch_rejects_empty_name(self) -> None:
         with patch("builtins.input", return_value=""):
             with self.assertRaises(RuntimeError):
                 open_branch(None)

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,49 @@ 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):
-    """
-    Unit tests for SSH URL and primary remote selection logic.
-    """
+    def _ctx(self, *, file=None, config=None) -> RepoMirrorContext:
+        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:
-        repo: Repository = {
-            "provider": "github.com",
-            "account": "kevinveenbirkenbach",
-            "repository": "package-manager",
-        }
+    def test_build_default_ssh_url(self) -> None:
+        repo = {"provider": "github.com", "account": "alice", "repository": "repo"}
+        self.assertEqual(build_default_ssh_url(repo), "git@github.com:alice/repo.git")
 
-        url = build_default_ssh_url(repo)
-        self.assertEqual(url, "git@github.com:kevinveenbirkenbach/package-manager.git")
+    def test_determine_primary_prefers_origin_in_resolved(self) -> None:
+        # resolved_mirrors = config + file (file wins), so put origin in file.
+        repo = {"provider": "github.com", "account": "alice", "repository": "repo"}
+        ctx = self._ctx(file={"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:
-        repo: Repository = {
-            "provider": "code.cymais.cloud",
-            "account": "kevinveenbirkenbach",
-            "repository": "pkgmgr",
-            "port": 2201,
-        }
+    def test_determine_primary_falls_back_to_file_order(self) -> None:
+        repo = {"provider": "github.com", "account": "alice", "repository": "repo"}
+        ctx = self._ctx(file={"first": "git@a/first.git", "second": "git@a/second.git"})
+        self.assertEqual(determine_primary_remote_url(repo, ctx), "git@a/first.git")
 
-        url = build_default_ssh_url(repo)
-        self.assertEqual(url, "ssh://git@code.cymais.cloud:2201/kevinveenbirkenbach/pkgmgr.git")
+    def test_determine_primary_falls_back_to_config_order(self) -> None:
+        repo = {"provider": "github.com", "account": "alice", "repository": "repo"}
+        ctx = self._ctx(config={"cfg1": "git@c/one.git", "cfg2": "git@c/two.git"})
+        self.assertEqual(determine_primary_remote_url(repo, ctx), "git@c/one.git")
 
-    def test_build_default_ssh_url_missing_fields_returns_none(self) -> None:
-        repo: Repository = {
-            "provider": "github.com",
-            "account": "kevinveenbirkenbach",
-        }
+    def test_determine_primary_fallback_default(self) -> None:
+        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")
 
-        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"
+    @patch("pkgmgr.actions.mirror.git_remote.list_remotes", return_value=["origin", "backup"])
+    def test_has_origin_remote_true(self, _m_list) -> None:
         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"
+    @patch("pkgmgr.actions.mirror.git_remote.list_remotes", return_value=["backup"])
+    def test_has_origin_remote_false(self, _m_list) -> None:
         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,65 @@
+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"}
+
+        # Use file_mirrors so ctx.resolved_mirrors contains both, no setattr (frozen dataclass!)
+        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",
+            },
+        )
+
+        with patch("os.path.isdir", return_value=True):
+            with patch("pkgmgr.actions.mirror.git_remote.has_origin_remote", return_value=False), patch(
+                "pkgmgr.actions.mirror.git_remote.add_remote"
+            ) as m_add_remote, patch(
+                "pkgmgr.actions.mirror.git_remote.set_remote_url"
+            ) as m_set_remote_url, patch(
+                "pkgmgr.actions.mirror.git_remote.get_remote_push_urls", return_value=set()
+            ), patch(
+                "pkgmgr.actions.mirror.git_remote.add_remote_push_url"
+            ) as m_add_push:
+                ensure_origin_remote(repo, ctx, preview=False)
+
+        # determine_primary_remote_url falls back to file order (primary first)
+        m_add_remote.assert_called_once_with(
+            "origin",
+            "git@github.com:alice/repo.git",
+            cwd="/tmp/repo",
+            preview=False,
+        )
+
+        m_set_remote_url.assert_any_call(
+            "origin",
+            "git@github.com:alice/repo.git",
+            cwd="/tmp/repo",
+            push=False,
+            preview=False,
+        )
+        m_set_remote_url.assert_any_call(
+            "origin",
+            "git@github.com:alice/repo.git",
+            cwd="/tmp/repo",
+            push=True,
+            preview=False,
+        )
+
+        m_add_push.assert_called_once_with(
+            "origin",
+            "git@github.com:alice/repo-backup.git",
+            cwd="/tmp/repo",
+            preview=False,
+        )

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

@@ -1,52 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-from __future__ import annotations
-
-import unittest
-from unittest.mock import patch
-
-from pkgmgr.actions.mirror.remote_check import probe_mirror
-from pkgmgr.core.git import GitError
-
-
-class TestRemoteCheck(unittest.TestCase):
-    """
-    Unit tests for non-destructive remote probing (git ls-remote).
-    """
-
-    @patch("pkgmgr.actions.mirror.remote_check.run_git")
-    def test_probe_mirror_success_returns_true_and_empty_message(self, mock_run_git) -> None:
-        mock_run_git.return_value = "dummy-output"
-
-        ok, message = probe_mirror(
-            "ssh://git@code.example.org:2201/alice/repo.git",
-            "/tmp/some-repo",
-        )
-
-        self.assertTrue(ok)
-        self.assertEqual(message, "")
-        mock_run_git.assert_called_once_with(
-            ["ls-remote", "ssh://git@code.example.org:2201/alice/repo.git"],
-            cwd="/tmp/some-repo",
-        )
-
-    @patch("pkgmgr.actions.mirror.remote_check.run_git")
-    def test_probe_mirror_failure_returns_false_and_error_message(self, mock_run_git) -> None:
-        mock_run_git.side_effect = GitError("Git command failed (simulated)")
-
-        ok, message = probe_mirror(
-            "ssh://git@code.example.org:2201/alice/repo.git",
-            "/tmp/some-repo",
-        )
-
-        self.assertFalse(ok)
-        self.assertIn("Git command failed", message)
-        mock_run_git.assert_called_once_with(
-            ["ls-remote", "ssh://git@code.example.org:2201/alice/repo.git"],
-            cwd="/tmp/some-repo",
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,123 +1,95 @@
-#!/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):
-    """
-    Unit tests for mirror setup orchestration (local + remote).
-    """
+    def _ctx(self, *, repo_dir: str = "/tmp/repo", resolved: dict[str, str] | None = None) -> RepoMirrorContext:
+        # resolved_mirrors is a @property combining config+file. Put it into file_mirrors.
+        return RepoMirrorContext(
+            identifier="repo",
+            repo_dir=repo_dir,
+            config_mirrors={},
+            file_mirrors=resolved or {},
+        )
 
-    @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,
-    ) -> 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={})
-        mock_build_context.return_value = ctx
-
-        repo = {"provider": "github.com", "account": "alice", "repository": "repo"}
+    @patch("pkgmgr.actions.mirror.setup_cmd.ensure_origin_remote")
+    def test_setup_mirrors_local_calls_ensure_origin_remote(self, m_ensure, m_ctx) -> None:
+        ctx = self._ctx(repo_dir="/tmp/repo", resolved={"primary": "git@x/y.git"})
+        m_ctx.return_value = ctx
 
+        repos = [{"provider": "github.com", "account": "alice", "repository": "repo"}]
         setup_mirrors(
-            selected_repos=[repo],
-            repositories_base_dir="/base",
-            all_repos=[repo],
+            selected_repos=repos,
+            repositories_base_dir="/tmp",
+            all_repos=repos,
             preview=True,
             local=True,
             remote=False,
             ensure_remote=False,
         )
 
-        mock_ensure_origin.assert_called_once()
-        args, kwargs = mock_ensure_origin.call_args
-        self.assertEqual(args[0], repo)
-        self.assertEqual(kwargs.get("preview"), True)
+        # ensure_origin_remote(repo, ctx, preview) is called positionally in your code
+        m_ensure.assert_called_once()
+        args, kwargs = m_ensure.call_args
+
+        self.assertEqual(args[0], repos[0])
+        self.assertIs(args[1], ctx)
+        self.assertEqual(kwargs.get("preview", args[2] if len(args) >= 3 else None), True)
 
-    @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"}
+    @patch("pkgmgr.actions.mirror.setup_cmd.determine_primary_remote_url")
+    @patch("pkgmgr.actions.mirror.setup_cmd.probe_remote_reachable")
+    def test_setup_mirrors_remote_no_mirrors_probes_primary(self, m_probe, m_primary, m_ctx) -> None:
+        m_ctx.return_value = self._ctx(repo_dir="/tmp/repo", resolved={})
+        m_primary.return_value = "git@github.com:alice/repo.git"
+        m_probe.return_value = True
 
+        repos = [{"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")
-    def test_setup_mirrors_remote_probes_all_resolved_mirrors(
-        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 = {}
-        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"}
-
-        setup_mirrors(
-            selected_repos=[repo],
-            repositories_base_dir="/base",
-            all_repos=[repo],
-            preview=False,
+            selected_repos=repos,
+            repositories_base_dir="/tmp",
+            all_repos=repos,
+            preview=True,
             local=False,
             remote=True,
             ensure_remote=False,
         )
 
-        mock_ensure_remote_repository.assert_not_called()
-        self.assertEqual(mock_probe.call_count, 2)
+        m_primary.assert_called()
+        m_probe.assert_called_once_with("git@github.com:alice/repo.git", cwd="/tmp/repo")
+
+    @patch("pkgmgr.actions.mirror.setup_cmd.build_context")
+    @patch("pkgmgr.actions.mirror.setup_cmd.probe_remote_reachable")
+    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)
+        m_probe.assert_any_call("git@github.com:alice/repo.git", cwd="/tmp/repo")
+        m_probe.assert_any_call("ssh://git@git.veen.world:2201/alice/repo.git", cwd="/tmp/repo")
 
 
 if __name__ == "__main__":

tests/unit/pkgmgr/actions/publish/test_git_tags.py

@@ -0,0 +1,14 @@
+import unittest
+from unittest.mock import patch
+
+from pkgmgr.actions.publish.git_tags import head_semver_tags
+
+
+class TestHeadSemverTags(unittest.TestCase):
+    @patch("pkgmgr.actions.publish.git_tags.get_tags_at_ref", return_value=[])
+    def test_no_tags(self, _mock_get_tags_at_ref) -> None:
+        self.assertEqual(head_semver_tags(), [])
+
+    @patch("pkgmgr.actions.publish.git_tags.get_tags_at_ref", return_value=["v2.0.0", "nope", "v1.0.0", "v1.2.0"])
+    def test_filters_and_sorts_semver(self, _mock_get_tags_at_ref) -> None:
+        self.assertEqual(head_semver_tags(), ["v1.0.0", "v1.2.0", "v2.0.0"])

tests/unit/pkgmgr/actions/publish/test_pypi_url.py

@@ -0,0 +1,13 @@
+
+import unittest
+from pkgmgr.actions.publish.pypi_url import parse_pypi_project_url
+
+
+class TestParsePyPIUrl(unittest.TestCase):
+    def test_valid_pypi_url(self):
+        t = parse_pypi_project_url("https://pypi.org/project/example/")
+        self.assertIsNotNone(t)
+        self.assertEqual(t.project, "example")
+
+    def test_invalid_url(self):
+        self.assertIsNone(parse_pypi_project_url("https://example.com/foo"))

tests/unit/pkgmgr/actions/publish/test_workflow_preview.py

@@ -0,0 +1,21 @@
+
+import unittest
+from unittest.mock import patch
+
+from pkgmgr.actions.publish.workflow import publish
+
+
+class TestPublishWorkflowPreview(unittest.TestCase):
+    @patch("pkgmgr.actions.publish.workflow.read_mirrors_file")
+    @patch("pkgmgr.actions.publish.workflow.head_semver_tags")
+    def test_preview_does_not_build(self, mock_tags, mock_mirrors):
+        mock_mirrors.return_value = {
+            "pypi": "https://pypi.org/project/example/"
+        }
+        mock_tags.return_value = ["v1.0.0"]
+
+        publish(
+            repo={},
+            repo_dir=".",
+            preview=True,
+        )

tests/unit/pkgmgr/actions/repository/test_create_parsing.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import unittest
+
+from pkgmgr.actions.repository.create import (
+    RepoParts,
+    _parse_identifier,
+    _parse_git_url,
+    _strip_git_suffix,
+    _split_host_port,
+)
+
+
+class TestRepositoryCreateParsing(unittest.TestCase):
+    def test_strip_git_suffix(self) -> None:
+        self.assertEqual(_strip_git_suffix("repo.git"), "repo")
+        self.assertEqual(_strip_git_suffix("repo"), "repo")
+
+    def test_split_host_port(self) -> None:
+        self.assertEqual(_split_host_port("example.com"), ("example.com", None))
+        self.assertEqual(_split_host_port("example.com:2222"), ("example.com", "2222"))
+        self.assertEqual(_split_host_port("example.com:"), ("example.com", None))
+
+    def test_parse_identifier_plain(self) -> None:
+        parts = _parse_identifier("github.com/owner/repo")
+        self.assertIsInstance(parts, RepoParts)
+        self.assertEqual(parts.host, "github.com")
+        self.assertEqual(parts.port, None)
+        self.assertEqual(parts.owner, "owner")
+        self.assertEqual(parts.name, "repo")
+
+    def test_parse_identifier_with_port(self) -> None:
+        parts = _parse_identifier("gitea.example.com:2222/org/repo")
+        self.assertEqual(parts.host, "gitea.example.com")
+        self.assertEqual(parts.port, "2222")
+        self.assertEqual(parts.owner, "org")
+        self.assertEqual(parts.name, "repo")
+
+    def test_parse_git_url_scp_style(self) -> None:
+        parts = _parse_git_url("git@github.com:owner/repo.git")
+        self.assertEqual(parts.host, "github.com")
+        self.assertEqual(parts.port, None)
+        self.assertEqual(parts.owner, "owner")
+        self.assertEqual(parts.name, "repo")
+
+    def test_parse_git_url_https(self) -> None:
+        parts = _parse_git_url("https://github.com/owner/repo.git")
+        self.assertEqual(parts.host, "github.com")
+        self.assertEqual(parts.port, None)
+        self.assertEqual(parts.owner, "owner")
+        self.assertEqual(parts.name, "repo")
+
+    def test_parse_git_url_ssh_with_port(self) -> None:
+        parts = _parse_git_url("ssh://git@gitea.example.com:2222/org/repo.git")
+        self.assertEqual(parts.host, "gitea.example.com")
+        self.assertEqual(parts.port, "2222")
+        self.assertEqual(parts.owner, "org")
+        self.assertEqual(parts.name, "repo")
+
+
+if __name__ == "__main__":
+    unittest.main()