Release version 0.6.0

Changes included:
• GitHub Actions workflow: rename job from 'test-unit' to 'test-container' to match intent.
• RPM packaging: replace %{_libdir}/package-manager with a fixed /usr/lib/package-manager
  to avoid lib/lib64 divergence on CentOS and ensure pkgmgr + Nix flake resolution works
  consistently across distros.
• Docker entrypoint: add automatic CA-bundle detection and set NIX_SSL_CERT_FILE to fix
  TLS issues on CentOS ('unable to get local issuer certificate') when Nix fetches flake
  inputs.

These updates stabilize container-based tests and unify the runtime environment
for Fedora, CentOS, and other distributions.

Reference:
ChatGPT conversation: https://chatgpt.com/share/6937aa72-d33c-800f-a63f-c353e92de6b3

.github/workflows/test-container.yml

@@ -0,0 +1,25 @@
+name: Test Distribution Containers
+
+on:
+  push:
+    branches:
+      - main
+      - master
+      - develop
+      - "*"
+  pull_request:
+
+jobs:
+  test-container:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Show Docker version
+        run: docker version
+
+      - name: Run container tests
+        run: make test-container

.gitignore

@@ -15,7 +15,7 @@ venv/
 
 # Build artifacts
 dist/
-build/
+build/*
 *.egg-info/
 
 # Editor files
@@ -31,4 +31,11 @@ Thumbs.db
 
 # Ignore logs
 *.log
-package-manager-*
+package-manager-*
+
+# debian 
+debian/package-manager/
+debian/debhelper-build-stamp
+debian/files
+debian/.debhelper/
+debian/package-manager.substvars

CHANGELOG.md

@@ -1,3 +1,18 @@
+## [0.6.0] - 2025-12-09
+
+* Expose DISTROS and BASE_IMAGE_* variables as exported Makefile environment variables so all build and test commands can consume them dynamically. By exporting these values, every Make target (e.g., build, build-no-cache, build-missing, test-container, test-unit, test-e2e) and every delegated script in scripts/build/ and scripts/test/ now receives a consistent view of the supported distributions and their base container images. This change removes duplicated definitions across scripts, ensures reproducible builds, and allows build tooling to react automatically when new distros or base images are added to the Makefile.
+
+
+## [0.5.1] - 2025-12-09
+
+* Refine pkgmgr release CLI close wiring and integration tests for --close flag (ChatGPT: https://chatgpt.com/share/69376b4e-8440-800f-9d06-535ec1d7a40e)
+
+
+## [0.5.0] - 2025-12-09
+
+* Add pkgmgr branch close subcommand, extend CLI parser wiring, and add unit tests for branch handling and version version-selection logic (see ChatGPT conversation: https://chatgpt.com/share/693762a3-9ea8-800f-a640-bc78170953d1)
+
+
 ## [0.4.3] - 2025-12-09
 
 * Implement current-directory repository selection for release and proxy commands, unify selection semantics across CLI layers, extend release workflow with --close, integrate branch closing logic, fix wiring for get_repo_identifier/get_repo_dir, update packaging files (PKGBUILD, spec, flake.nix, pyproject), and add comprehensive unit/e2e tests for release and branch commands (see ChatGPT conversation: https://chatgpt.com/share/69375cfe-9e00-800f-bd65-1bd5937e1696)

Dockerfile

@@ -4,87 +4,6 @@
 ARG BASE_IMAGE=archlinux:latest
 FROM ${BASE_IMAGE}
 
-# ------------------------------------------------------------
-# System base + conditional package tool installation
-#
-# Important:
-# - We do NOT install Nix directly here via curl.
-# - Nix is installed/initialized by init-nix.sh, which is invoked
-#   from the system packaging hooks (Arch .install, Debian postinst,
-#   RPM %post).
-# ------------------------------------------------------------
-RUN set -e; \
-    if [ -f /etc/os-release ]; then . /etc/os-release; else echo "No /etc/os-release found" && exit 1; fi; \
-    echo "Detected base image: ${ID:-unknown} (like: ${ID_LIKE:-})"; \
-    \
-    if [ "$ID" = "arch" ]; then \
-        pacman -Syu --noconfirm && \
-        pacman -S --noconfirm --needed \
-            base-devel \
-            git \
-            rsync \
-            curl \
-            ca-certificates \
-            xz && \
-        pacman -Scc --noconfirm; \
-    elif [ "$ID" = "debian" ]; then \
-        apt-get update && \
-        DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
-            build-essential \
-            debhelper \
-            dpkg-dev \
-            git \
-            rsync \
-            bash \
-            curl \
-            ca-certificates \
-            xz-utils && \
-        rm -rf /var/lib/apt/lists/*; \
-    elif [ "$ID" = "ubuntu" ]; then \
-        apt-get update && \
-        DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
-            build-essential \
-            debhelper \
-            dpkg-dev \
-            git \
-            tzdata \
-            lsb-release \
-            rsync \
-            bash \
-            curl \
-            ca-certificates \
-            xz-utils && \
-        rm -rf /var/lib/apt/lists/*; \
-    elif [ "$ID" = "fedora" ]; then \
-        dnf -y update && \
-        dnf -y install \
-            git \
-            rsync \
-            rpm-build \
-            make \
-            gcc \
-            bash \
-            curl \
-            ca-certificates \
-            xz && \
-        dnf clean all; \
-    elif [ "$ID" = "centos" ]; then \
-        dnf -y update && \
-        dnf -y install \
-            git \
-            rsync \
-            rpm-build \
-            make \
-            gcc \
-            bash \
-            curl-minimal \
-            ca-certificates \
-            xz && \
-        dnf clean all; \
-    else \
-        echo "Unsupported base image: ${ID}" && exit 1; \
-    fi
-
 # ------------------------------------------------------------
 # Nix environment defaults
 #
@@ -96,94 +15,38 @@ ENV NIX_CONFIG="experimental-features = nix-command flakes"
 # ------------------------------------------------------------
 # Unprivileged user for Arch package build (makepkg)
 # ------------------------------------------------------------
-RUN useradd -m builder || true
+RUN useradd -m aur_builder || true
+
+# ------------------------------------------------------------
+# Copy scripts and install distro dependencies
+# ------------------------------------------------------------
+WORKDIR /build
+
+# Copy only scripts first so dependency installation can run early
+COPY scripts/ scripts/
+RUN find scripts -type f -name '*.sh' -exec chmod +x {} \;
+
+# Install distro-specific build dependencies (and AUR builder on Arch)
+RUN scripts/installation/run-dependencies.sh
+
+# ------------------------------------------------------------
+# Select distro-specific Docker entrypoint
+# ------------------------------------------------------------
+# Docker entrypoint (distro-agnostic, nutzt run-package.sh)
+# ------------------------------------------------------------
+COPY scripts/docker/entry.sh /usr/local/bin/docker-entry.sh
+RUN chmod +x /usr/local/bin/docker-entry.sh
 
 # ------------------------------------------------------------
 # Build and install distro-native package-manager package
-#
-# - Arch:    PKGBUILD  -> pacman -U
-# - Debian:  debhelper -> dpkg-buildpackage -> apt install ./package-manager_*.deb
-# - Ubuntu:  same as Debian
-# - Fedora:  rpmbuild  -> dnf/dnf5/yum install package-manager-*.rpm
-# - CentOS:  rpmbuild  -> dnf/yum install package-manager-*.rpm
-#
-# Nix is NOT manually installed here; it is handled by init-nix.sh.
+# via Makefile `install` target (calls scripts/installation/run-package.sh)
 # ------------------------------------------------------------
-WORKDIR /build
 COPY . .
+RUN find scripts -type f -name '*.sh' -exec chmod +x {} \;
 
 RUN set -e; \
-    . /etc/os-release; \
-    if [ "$ID" = "arch" ]; then \
-        echo 'Building Arch package (makepkg --nodeps)...'; \
-        chown -R builder:builder /build; \
-        su builder -c "cd /build && rm -f package-manager-*.pkg.tar.* && makepkg --noconfirm --clean --nodeps"; \
-        \
-        echo 'Installing generated Arch package...'; \
-        pacman -U --noconfirm package-manager-*.pkg.tar.*; \
-    elif [ "$ID" = "debian" ] || [ "$ID" = "ubuntu" ]; then \
-        echo 'Building Debian/Ubuntu package...'; \
-        dpkg-buildpackage -us -uc -b; \
-        \
-        echo 'Installing generated DEB package...'; \
-        apt-get update && \
-        DEBIAN_FRONTEND=noninteractive apt-get install -y ./../package-manager_*.deb && \
-        rm -rf /var/lib/apt/lists/*; \
-    elif [ "$ID" = "fedora" ] || [ "$ID" = "centos" ]; then \
-        echo 'Setting up rpmbuild dirs...'; \
-        mkdir -p /root/rpmbuild/{BUILD,RPMS,SOURCES,SPECS,SRPMS}; \
-        \
-        echo "Extracting version from package-manager.spec..."; \
-        version=$(grep -E '^Version:' /build/package-manager.spec | awk '{print $2}'); \
-        if [ -z "$version" ]; then echo 'ERROR: Version missing!' && exit 1; fi; \
-        srcdir="package-manager-${version}"; \
-        \
-        echo "Preparing source tree for RPM: $srcdir"; \
-        rm -rf "/tmp/$srcdir"; \
-        mkdir -p "/tmp/$srcdir"; \
-        cp -a /build/. "/tmp/$srcdir/"; \
-        \
-        echo "Creating source tarball: /root/rpmbuild/SOURCES/$srcdir.tar.gz"; \
-        tar czf "/root/rpmbuild/SOURCES/$srcdir.tar.gz" -C /tmp "$srcdir"; \
-        \
-        echo 'Copying SPEC...'; \
-        cp /build/package-manager.spec /root/rpmbuild/SPECS/; \
-        \
-        echo 'Running rpmbuild...'; \
-        cd /root/rpmbuild/SPECS && rpmbuild -bb package-manager.spec; \
-        \
-        echo 'Installing generated RPM (local, offline)...'; \
-        rpm_path=$(find /root/rpmbuild/RPMS -name "package-manager-*.rpm" | head -n1); \
-        if [ -z "$rpm_path" ]; then echo 'ERROR: RPM not found!' && exit 1; fi; \
-        \
-        if command -v dnf5 >/dev/null 2>&1; then \
-            echo 'Using dnf5 to install local RPM (no remote repos)...'; \
-            if ! dnf5 install -y --disablerepo='*' "$rpm_path"; then \
-                echo 'dnf5 failed, falling back to rpm -i --nodeps'; \
-                rpm -i --nodeps "$rpm_path"; \
-            fi; \
-        elif command -v dnf >/dev/null 2>&1; then \
-            echo 'Using dnf to install local RPM (no remote repos)...'; \
-            if ! dnf install -y --disablerepo='*' "$rpm_path"; then \
-                echo 'dnf failed, falling back to rpm -i --nodeps'; \
-                rpm -i --nodeps "$rpm_path"; \
-            fi; \
-        elif command -v yum >/dev/null 2>&1; then \
-            echo 'Using yum to install local RPM (no remote repos)...'; \
-            if ! yum localinstall -y --disablerepo='*' "$rpm_path"; then \
-                echo 'yum failed, falling back to rpm -i --nodeps'; \
-                rpm -i --nodeps "$rpm_path"; \
-            fi; \
-        else \
-            echo 'No dnf/dnf5/yum found, falling back to rpm -i --nodeps...'; \
-            rpm -i --nodeps "$rpm_path"; \
-        fi; \
-        \
-        rm -rf "/tmp/$srcdir"; \
-    else \
-        echo "Unsupported distro: ${ID}"; \
-        exit 1; \
-    fi; \
+    echo "Building and installing package-manager via make install..."; \
+    make install; \
     rm -rf /build
 
 # ------------------------------------------------------------
@@ -191,8 +54,5 @@ RUN set -e; \
 # ------------------------------------------------------------
 WORKDIR /src
 
-COPY scripts/docker-entry-dev.sh /usr/local/bin/docker-entry-dev.sh
-RUN chmod +x /usr/local/bin/docker-entry-dev.sh
-
-ENTRYPOINT ["/usr/local/bin/docker-entry-dev.sh"]
-CMD ["--help"]
+ENTRYPOINT ["/usr/local/bin/docker-entry.sh"]
+CMD ["pkgmgr", "--help"]

Makefile

@@ -1,5 +1,6 @@
-.PHONY: install setup uninstall aur_builder_setup \
-        test build build-no-cache test-unit test-e2e test-integration
+.PHONY: install setup uninstall \
+        test build build-no-cache test-unit test-e2e test-integration \
+        test-container
 
 # ------------------------------------------------------------
 # Local Nix cache directories in the repo
@@ -9,267 +10,72 @@ NIX_CACHE_VOLUME := pkgmgr_nix_cache
 
 # ------------------------------------------------------------
 # Distro list and base images
+# (kept for documentation/reference; actual build logic is in scripts/build)
 # ------------------------------------------------------------
 DISTROS := arch debian ubuntu fedora centos
+BASE_IMAGE_ARCH   := archlinux:latest
+BASE_IMAGE_DEBIAN := debian:stable-slim
+BASE_IMAGE_UBUNTU := ubuntu:latest
+BASE_IMAGE_FEDORA := fedora:latest
+BASE_IMAGE_CENTOS := quay.io/centos/centos:stream9
 
-BASE_IMAGE_arch   := archlinux:latest
-BASE_IMAGE_debian := debian:stable-slim
-BASE_IMAGE_ubuntu := ubuntu:latest
-BASE_IMAGE_fedora := fedora:latest
-BASE_IMAGE_centos := quay.io/centos/centos:stream9
-
-# Helper to echo which image is used for which distro (purely informational)
-define echo_build_info
-	@echo "Building image for distro '$(1)' with base image '$(2)'..."
-endef
+# Make them available in scripts
+export DISTROS
+export BASE_IMAGE_ARCH  
+export BASE_IMAGE_DEBIAN
+export BASE_IMAGE_UBUNTU
+export BASE_IMAGE_FEDORA
+export BASE_IMAGE_CENTOS
 
 # ------------------------------------------------------------
-# PKGMGR setup (wrapper)
+# PKGMGR setup (developer wrapper -> scripts/installation/main.sh)
 # ------------------------------------------------------------
-setup: install
-	@echo "Running pkgmgr setup via main.py..."
-	@if [ -x "$$HOME/.venvs/pkgmgr/bin/python" ]; then \
-		echo "Using virtualenv Python at $$HOME/.venvs/pkgmgr/bin/python"; \
-		"$$HOME/.venvs/pkgmgr/bin/python" main.py install; \
-	else \
-		echo "Virtualenv not found, falling back to system python3"; \
-		python3 main.py install; \
-	fi
+setup:
+	@bash scripts/installation/main.sh
 
 # ------------------------------------------------------------
-# Docker build targets: build all images
+# Docker build targets (delegated to scripts/build)
 # ------------------------------------------------------------
 build-no-cache:
-	@for distro in $(DISTROS); do \
-		case "$$distro" in \
-			arch)   base_image="$(BASE_IMAGE_arch)" ;; \
-			debian) base_image="$(BASE_IMAGE_debian)" ;; \
-			ubuntu) base_image="$(BASE_IMAGE_ubuntu)" ;; \
-			fedora) base_image="$(BASE_IMAGE_fedora)" ;; \
-			centos) base_image="$(BASE_IMAGE_centos)" ;; \
-			*)      echo "Unknown distro '$$distro'" >&2; exit 1 ;; \
-		esac; \
-		echo "Building test image 'package-manager-test-$$distro' with no cache (BASE_IMAGE=$$base_image)..."; \
-		docker build --no-cache \
-			--build-arg BASE_IMAGE="$$base_image" \
-			-t "package-manager-test-$$distro" . || exit $$?; \
-	done
+	@bash scripts/build/build-image-no-cache.sh
 
 build:
-	@for distro in $(DISTROS); do \
-		case "$$distro" in \
-			arch)   base_image="$(BASE_IMAGE_arch)" ;; \
-			debian) base_image="$(BASE_IMAGE_debian)" ;; \
-			ubuntu) base_image="$(BASE_IMAGE_ubuntu)" ;; \
-			fedora) base_image="$(BASE_IMAGE_fedora)" ;; \
-			centos) base_image="$(BASE_IMAGE_centos)" ;; \
-			*)      echo "Unknown distro '$$distro'" >&2; exit 1 ;; \
-		esac; \
-		echo "Building test image 'package-manager-test-$$distro' (BASE_IMAGE=$$base_image)..."; \
-		docker build \
-			--build-arg BASE_IMAGE="$$base_image" \
-			-t "package-manager-test-$$distro" . || exit $$?; \
-	done
-
-build-arch:
-	@base_image="$(BASE_IMAGE_arch)"; \
-	echo "Building test image 'package-manager-test-arch' (BASE_IMAGE=$$base_image)..."; \
-	docker build \
-		--build-arg BASE_IMAGE="$$base_image" \
-		-t "package-manager-test-arch" . || exit $$?;
+	@bash scripts/build/build-image.sh
 
 # ------------------------------------------------------------
-# Test targets
+# Test targets (delegated to scripts/test)
 # ------------------------------------------------------------
 
-# Unit tests: only in Arch container (fastest feedback), via Nix devShell
-test-unit: build-arch
-	@echo "============================================================"
-	@echo ">>> Running UNIT tests in Arch container (via Nix devShell)"
-	@echo "============================================================"
-	docker run --rm \
-		-v "$$(pwd):/src" \
-		--workdir /src \
-		--entrypoint bash \
-		"package-manager-test-arch" \
-		-c '\
-			set -e; \
-			if [ -f /etc/os-release ]; then . /etc/os-release; fi; \
-			echo "Detected container distro: $${ID:-unknown} (like: $${ID_LIKE:-})"; \
-			echo "Running Python unit tests (tests/unit) via nix develop..."; \
-			git config --global --add safe.directory /src || true; \
-			cd /src; \
-			nix develop .#default --no-write-lock-file -c \
-				python -m unittest discover \
-					-s tests/unit \
-					-t /src \
-					-p "test_*.py"; \
-		'
+test-unit:
+	@bash scripts/test/test-unit.sh
 
-# Integration tests: also in Arch container, via Nix devShell
-test-integration: build-arch
-	@echo "============================================================"
-	@echo ">>> Running INTEGRATION tests in Arch container (via Nix devShell)"
-	@echo "============================================================"
-	docker run --rm \
-		-v "$$(pwd):/src" \
-		--workdir /src \
-		--entrypoint bash \
-		"package-manager-test-arch" \
-		-c '\
-			set -e; \
-			if [ -f /etc/os-release ]; then . /etc/os-release; fi; \
-			echo "Detected container distro: $${ID:-unknown} (like: $${ID_LIKE:-})"; \
-			echo "Running Python integration tests (tests/integration) via nix develop..."; \
-			git config --global --add safe.directory /src || true; \
-			cd /src; \
-			nix develop .#default --no-write-lock-file -c \
-				python -m unittest discover \
-					-s tests/integration \
-					-t /src \
-					-p "test_*.py"; \
-		'
+test-integration:
+	@bash scripts/test/test-integration.sh
 
-# End-to-end tests: run in all distros via Nix devShell (tests/e2e)
-test-e2e: build
-	@echo "Ensuring Docker Nix volumes exist (auto-created if missing)..."
-	@echo "Running E2E tests inside Nix devShell with cached store for all distros: $(DISTROS)"
+test-e2e:
+	@bash scripts/test/test-e2e.sh
 
-	@for distro in $(DISTROS); do \
-		echo "============================================================"; \
-		echo ">>> Running E2E tests in container for distro: $$distro"; \
-		echo "============================================================"; \
-		# Only for Arch: mount /nix as volume, for others use image-installed Nix \
-		if [ "$$distro" = "arch" ]; then \
-			NIX_STORE_MOUNT="-v $(NIX_STORE_VOLUME):/nix"; \
-		else \
-			NIX_STORE_MOUNT=""; \
-		fi; \
-		docker run --rm \
-			-v "$$(pwd):/src" \
-			$$NIX_STORE_MOUNT \
-			-v "$(NIX_CACHE_VOLUME):/root/.cache/nix" \
-			--workdir /src \
-			--entrypoint bash \
-			"package-manager-test-$$distro" \
-			-c '\
-				set -e; \
-				if [ -f /etc/os-release ]; then . /etc/os-release; fi; \
-				echo "Detected container distro: $${ID:-unknown} (like: $${ID_LIKE:-})"; \
-				echo "Preparing Nix environment..."; \
-				if [ -f "/nix/var/nix/profiles/default/etc/profile.d/nix-daemon.sh" ]; then \
-					. "/nix/var/nix/profiles/default/etc/profile.d/nix-daemon.sh"; \
-				fi; \
-				if [ -f "$$HOME/.nix-profile/etc/profile.d/nix.sh" ]; then \
-					. "$$HOME/.nix-profile/etc/profile.d/nix.sh"; \
-				fi; \
-				PATH="/nix/var/nix/profiles/default/bin:$$HOME/.nix-profile/bin:$$PATH"; \
-				export PATH; \
-				echo "PATH is now:"; \
-				echo "$$PATH"; \
-				NIX_CMD=""; \
-				if command -v nix >/dev/null 2>&1; then \
-					echo "Found nix on PATH:"; \
-					command -v nix; \
-					NIX_CMD="nix"; \
-				else \
-					echo "nix not found on PATH, scanning /nix/store for a nix binary..."; \
-					for path in /nix/store/*-nix-*/bin/nix; do \
-						if [ -x "$$path" ]; then \
-							echo "Found nix binary at $$path"; \
-							NIX_CMD="$$path"; \
-							break; \
-						fi; \
-					done; \
-				fi; \
-				if [ -z "$$NIX_CMD" ]; then \
-					echo "ERROR: nix binary not found anywhere – cannot run devShell"; \
-					exit 1; \
-				fi; \
-				echo "Using Nix command: $$NIX_CMD"; \
-				echo "Run E2E tests inside Nix devShell (tests/e2e)..."; \
-				git config --global --add safe.directory /src || true; \
-				cd /src; \
-				"$$NIX_CMD" develop .#default --no-write-lock-file -c \
-					python3 -m unittest discover \
-						-s /src/tests/e2e \
-						-p "test_*.py"; \
-			' || exit $$?; \
-	done
+test-container:
+	@bash scripts/test/test-container.sh
+
+# ------------------------------------------------------------
+# Build only missing container images
+# ------------------------------------------------------------
+build-missing:
+	@bash scripts/build/build-image-missing.sh
 
 # Combined test target for local + CI (unit + e2e + integration)
-test: build test-unit test-e2e test-integration
+test: build-missing test-container test-unit test-e2e test-integration
 
 # ------------------------------------------------------------
-# Installer for host systems (original logic)
+# System install (native packages, calls scripts/installation/run-package.sh)
 # ------------------------------------------------------------
 install:
-	@if [ -n "$$IN_NIX_SHELL" ]; then \
-		echo "Nix shell detected (IN_NIX_SHELL=1). Skipping venv/pip install – handled by Nix flake."; \
-	else \
-		echo "Making 'main.py' executable..."; \
-		chmod +x main.py; \
-		echo "Checking if global user virtual environment exists..."; \
-		mkdir -p "$$HOME/.venvs"; \
-		if [ ! -d "$$HOME/.venvs/pkgmgr" ]; then \
-			echo "Creating global venv at $$HOME/.venvs/pkgmgr..."; \
-			python3 -m venv "$$HOME/.venvs/pkgmgr"; \
-		fi; \
-		echo "Installing required Python packages into $$HOME/.venvs/pkgmgr..."; \
-		"$$HOME/.venvs/pkgmgr/bin/python" -m ensurepip --upgrade; \
-		"$$HOME/.venvs/pkgmgr/bin/pip" install --upgrade pip setuptools wheel; \
-		echo "Looking for requirements.txt / _requirements.txt..."; \
-		if [ -f requirements.txt ]; then \
-			echo "Installing Python packages from requirements.txt..."; \
-			"$$HOME/.venvs/pkgmgr/bin/pip" install -r requirements.txt; \
-		elif [ -f _requirements.txt ]; then \
-			echo "Installing Python packages from _requirements.txt..."; \
-			"$$HOME/.venvs/pkgmgr/bin/pip" install -r _requirements.txt; \
-		else \
-			echo "No requirements.txt or _requirements.txt found, skipping dependency installation."; \
-		fi; \
-		echo "Ensuring $$HOME/.bashrc and $$HOME/.zshrc exist..."; \
-		touch "$$HOME/.bashrc" "$$HOME/.zshrc"; \
-		echo "Ensuring automatic activation of $$HOME/.venvs/pkgmgr for this user..."; \
-		for rc in "$$HOME/.bashrc" "$$HOME/.zshrc"; do \
-			rc_line='if [ -d "$${HOME}/.venvs/pkgmgr" ]; then . "$${HOME}/.venvs/pkgmgr/bin/activate"; if [ -n "$${PS1:-}" ]; then echo "Global Python virtual environment '\''~/.venvs/pkgmgr'\'' activated."; fi; fi'; \
-			grep -qxF "$${rc_line}" "$$rc" || echo "$${rc_line}" >> "$$rc"; \
-		done; \
-		echo "Arch/Manjaro detection and optional AUR setup..."; \
-		if command -v pacman >/dev/null 2>&1; then \
-			$(MAKE) aur_builder_setup; \
-		else \
-			echo "Not Arch-based (no pacman). Skipping aur_builder/yay setup."; \
-		fi; \
-		echo "Installation complete. Please restart your shell (or 'exec bash' or 'exec zsh') for the changes to take effect."; \
-	fi
-
-# ------------------------------------------------------------
-# AUR builder setup — only on Arch/Manjaro
-# ------------------------------------------------------------
-aur_builder_setup:
-	@echo "Setting up aur_builder and yay (Arch/Manjaro)..."
-	@sudo pacman -Syu --noconfirm
-	@sudo pacman -S --needed --noconfirm base-devel git sudo
-	@if ! getent group aur_builder >/dev/null; then sudo groupadd -r aur_builder; fi
-	@if ! id -u aur_builder >/dev/null 2>&1; then sudo useradd -m -r -g aur_builder -s /bin/bash aur_builder; fi
-	@echo '%aur_builder ALL=(ALL) NOPASSWD: /usr/bin/pacman' | sudo tee /etc/sudoers.d/aur_builder >/dev/null
-	@sudo chmod 0440 /etc/sudoers.d/aur_builder
-	@if ! sudo -u aur_builder bash -lc 'command -v yay >/dev/null'; then \
-		sudo -u aur_builder bash -lc 'cd ~ && rm -rf yay && git clone https://aur.archlinux.org/yay.git && cd yay && makepkg -si --noconfirm'; \
-	else \
-		echo "yay already installed."; \
-	fi
-	@echo "aur_builder/yay setup complete."
+	@echo "Building and installing distro-native package-manager for this system..."
+	@bash scripts/installation/run-package.sh
 
 # ------------------------------------------------------------
 # Uninstall target
 # ------------------------------------------------------------
 uninstall:
-	@echo "Removing global user virtual environment if it exists..."
-	@rm -rf "$$HOME/.venvs/pkgmgr"
-	@echo "Cleaning up $$HOME/.bashrc and $$HOME/.zshrc entries..."
-	@for rc in "$$HOME/.bashrc" "$$HOME/.zshrc"; do \
-		sed -i '/\.venvs\/pkgmgr\/bin\/activate"; if \[ -n "\$${PS1:-}" \]; then echo "Global Python virtual environment '\''~\/\.venvs\/pkgmgr'\'' activated."; fi; fi/d' "$$rc"; \
-	done
-	@echo "Uninstallation complete. Please restart your shell (or 'exec bash' or 'exec zsh') for the changes to fully apply."
+	@bash scripts/uninstall.sh

PKGBUILD

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

debian/changelog

@@ -1,3 +1,21 @@
+package-manager (0.6.0-1) unstable; urgency=medium
+
+  * Expose DISTROS and BASE_IMAGE_* variables as exported Makefile environment variables so all build and test commands can consume them dynamically. By exporting these values, every Make target (e.g., build, build-no-cache, build-missing, test-container, test-unit, test-e2e) and every delegated script in scripts/build/ and scripts/test/ now receives a consistent view of the supported distributions and their base container images. This change removes duplicated definitions across scripts, ensures reproducible builds, and allows build tooling to react automatically when new distros or base images are added to the Makefile.
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Tue, 09 Dec 2025 05:59:58 +0100
+
+package-manager (0.5.1-1) unstable; urgency=medium
+
+  * Refine pkgmgr release CLI close wiring and integration tests for --close flag (ChatGPT: https://chatgpt.com/share/69376b4e-8440-800f-9d06-535ec1d7a40e)
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Tue, 09 Dec 2025 01:21:31 +0100
+
+package-manager (0.5.0-1) unstable; urgency=medium
+
+  * Add pkgmgr branch close subcommand, extend CLI parser wiring, and add unit tests for branch handling and version version-selection logic (see ChatGPT conversation: https://chatgpt.com/share/693762a3-9ea8-800f-a640-bc78170953d1)
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Tue, 09 Dec 2025 00:44:16 +0100
+
 package-manager (0.4.3-1) unstable; urgency=medium
 
   * Implement current-directory repository selection for release and proxy commands, unify selection semantics across CLI layers, extend release workflow with --close, integrate branch closing logic, fix wiring for get_repo_identifier/get_repo_dir, update packaging files (PKGBUILD, spec, flake.nix, pyproject), and add comprehensive unit/e2e tests for release and branch commands (see ChatGPT conversation: https://chatgpt.com/share/69375cfe-9e00-800f-bd65-1bd5937e1696)

flake.nix

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

package-manager.spec

@@ -1,5 +1,5 @@
 Name:           package-manager
-Version:        0.4.3
+Version:        0.6.0
 Release:        1%{?dist}
 Summary:        Wrapper that runs Kevin's package-manager via Nix flake
 
@@ -35,35 +35,36 @@ available on the system.
 %install
 rm -rf %{buildroot}
 install -d %{buildroot}%{_bindir}
-install -d %{buildroot}%{_libdir}/package-manager
+# Install project tree into a fixed, architecture-independent location.
+install -d %{buildroot}/usr/lib/package-manager
 
 # Copy full project source into /usr/lib/package-manager
-cp -a . %{buildroot}%{_libdir}/package-manager/
+cp -a . %{buildroot}/usr/lib/package-manager/
 
 # Wrapper
 install -m0755 scripts/pkgmgr-wrapper.sh %{buildroot}%{_bindir}/pkgmgr
 
 # Shared Nix init script (ensure it is executable in the installed tree)
-install -m0755 scripts/init-nix.sh %{buildroot}%{_libdir}/package-manager/init-nix.sh
+install -m0755 scripts/init-nix.sh %{buildroot}/usr/lib/package-manager/init-nix.sh
 
 # Remove packaging-only and development artefacts from the installed tree
 rm -rf \
-  %{buildroot}%{_libdir}/package-manager/PKGBUILD \
-  %{buildroot}%{_libdir}/package-manager/Dockerfile \
-  %{buildroot}%{_libdir}/package-manager/debian \
-  %{buildroot}%{_libdir}/package-manager/.git \
-  %{buildroot}%{_libdir}/package-manager/.github \
-  %{buildroot}%{_libdir}/package-manager/tests \
-  %{buildroot}%{_libdir}/package-manager/.gitignore \
-  %{buildroot}%{_libdir}/package-manager/__pycache__ \
-  %{buildroot}%{_libdir}/package-manager/.gitkeep || true
+  %{buildroot}/usr/lib/package-manager/PKGBUILD \
+  %{buildroot}/usr/lib/package-manager/Dockerfile \
+  %{buildroot}/usr/lib/package-manager/debian \
+  %{buildroot}/usr/lib/package-manager/.git \
+  %{buildroot}/usr/lib/package-manager/.github \
+  %{buildroot}/usr/lib/package-manager/tests \
+  %{buildroot}/usr/lib/package-manager/.gitignore \
+  %{buildroot}/usr/lib/package-manager/__pycache__ \
+  %{buildroot}/usr/lib/package-manager/.gitkeep || true
 
 %post
 # Initialize Nix (if needed) after installing the package-manager files.
-if [ -x %{_libdir}/package-manager/init-nix.sh ]; then
-    %{_libdir}/package-manager/init-nix.sh || true
+if [ -x /usr/lib/package-manager/init-nix.sh ]; then
+    /usr/lib/package-manager/init-nix.sh || true
 else
-    echo ">>> Warning: %{_libdir}/package-manager/init-nix.sh not found or not executable."
+    echo ">>> Warning: /usr/lib/package-manager/init-nix.sh not found or not executable."
 fi
 
 %postun
@@ -73,7 +74,7 @@ echo ">>> package-manager removed. Nix itself was not removed."
 %doc README.md
 %license LICENSE
 %{_bindir}/pkgmgr
-%{_libdir}/package-manager/
+/usr/lib/package-manager/
 
 %changelog
 * Sat Dec 06 2025 Kevin Veen-Birkenbach <info@veen.world> - 0.1.1-1

pkgmgr/cli_core/parser.py

@@ -316,7 +316,7 @@ def create_parser(description_text: str) -> argparse.ArgumentParser:
     # ------------------------------------------------------------
     branch_parser = subparsers.add_parser(
         "branch",
-        help="Branch-related utilities (e.g. open feature branches)",
+        help="Branch-related utilities (e.g. open/close feature branches)",
     )
     branch_subparsers = branch_parser.add_subparsers(
         dest="subcommand",
@@ -342,6 +342,27 @@ def create_parser(description_text: str) -> argparse.ArgumentParser:
         help="Base branch to create the new branch from (default: main)",
     )
 
+    branch_close = branch_subparsers.add_parser(
+        "close",
+        help="Merge a feature branch into base and delete it",
+    )
+    branch_close.add_argument(
+        "name",
+        nargs="?",
+        help=(
+            "Name of the branch to close (optional; current branch is used "
+            "if omitted)"
+        ),
+    )
+    branch_close.add_argument(
+        "--base",
+        default="main",
+        help=(
+            "Base branch to merge into (default: main; falls back to master "
+            "internally if main does not exist)"
+        ),
+    )
+
     # ------------------------------------------------------------
     # release
     # ------------------------------------------------------------

pyproject.toml

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

scripts/build/build-image-missing.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "${SCRIPT_DIR}/resolve-base-image.sh"
+
+echo "============================================================"
+echo ">>> Building ONLY missing container images"
+echo "============================================================"
+
+for distro in $DISTROS; do
+    IMAGE="package-manager-test-$distro"
+    BASE_IMAGE="$(resolve_base_image "$distro")"
+
+    if docker image inspect "$IMAGE" >/dev/null 2>&1; then
+        echo "[build-missing] Image already exists: $IMAGE (skipping)"
+        continue
+    fi
+
+    echo
+    echo "------------------------------------------------------------"
+    echo "[build-missing] Building missing image: $IMAGE"
+    echo "BASE_IMAGE = $BASE_IMAGE"
+    echo "------------------------------------------------------------"
+
+    docker build \
+        --build-arg BASE_IMAGE="$BASE_IMAGE" \
+        -t "$IMAGE" \
+        .
+done
+
+echo
+echo "============================================================"
+echo ">>> build-missing: Done"
+echo "============================================================"

scripts/build/build-image-no-cache.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "${SCRIPT_DIR}/resolve-base-image.sh"
+
+for distro in $DISTROS; do
+  base_image="$(resolve_base_image "$distro")"
+
+  echo ">>> Building test image for distro '$distro' with NO CACHE (BASE_IMAGE=$base_image)..."
+
+  docker build \
+    --no-cache \
+    --build-arg BASE_IMAGE="$base_image" \
+    -t "package-manager-test-$distro" \
+    .
+done

scripts/build/build-image.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "${SCRIPT_DIR}/resolve-base-image.sh"
+
+for distro in $DISTROS; do
+  base_image="$(resolve_base_image "$distro")"
+
+  echo ">>> Building test image for distro '$distro' (BASE_IMAGE=$base_image)..."
+
+  docker build \
+    --build-arg BASE_IMAGE="$base_image" \
+    -t "package-manager-test-$distro" \
+    .
+done

scripts/build/resolve-base-image.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+resolve_base_image() {
+  local distro="$1"
+
+  case "$distro" in
+    arch)   echo "$BASE_IMAGE_ARCH" ;;
+    debian) echo "$BASE_IMAGE_DEBIAN" ;;
+    ubuntu) echo "$BASE_IMAGE_UBUNTU" ;;
+    fedora) echo "$BASE_IMAGE_FEDORA" ;;
+    centos) echo "$BASE_IMAGE_CENTOS" ;;
+    *)
+      echo "ERROR: Unknown distro '$distro'" >&2
+      exit 1
+      ;;
+  esac
+}

scripts/docker-entry-dev.sh

@@ -1,22 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-echo "[entry] Using /src as working tree for package-manager..."
-cd /src
-
-# Optional: altes Paket entfernen
-echo "[entry] Removing existing 'package-manager' Arch package (if installed)..."
-pacman -Rns --noconfirm package-manager || true
-
-# Build-Owner richtig setzen (falls /src vom Host kommt)
-echo "[entry] Fixing ownership of /src for user 'builder'..."
-chown -R builder:builder /src
-
-echo "[entry] Rebuilding Arch package from /src as user 'builder'..."
-su builder -c "cd /src && makepkg -s --noconfirm --clean"
-
-echo "[entry] Installing freshly built package-manager-*.pkg.tar.*..."
-pacman -U --noconfirm /src/package-manager-*.pkg.tar.*
-
-echo "[entry] Handing off to pkgmgr with args: $*"
-exec pkgmgr "$@"

scripts/docker/entry.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# ---------------------------------------------------------------------------
+# Ensure Nix has access to a valid CA bundle (TLS trust store)
+# ---------------------------------------------------------------------------
+if [[ -z "${NIX_SSL_CERT_FILE:-}" ]]; then
+  if [[ -f /etc/ssl/certs/ca-certificates.crt ]]; then
+    # Debian/Ubuntu-style path
+    export NIX_SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt
+    echo "[docker] Using CA bundle: ${NIX_SSL_CERT_FILE}"
+  elif [[ -f /etc/pki/tls/certs/ca-bundle.crt ]]; then
+    # Fedora/RHEL/CentOS-style path
+    export NIX_SSL_CERT_FILE=/etc/pki/tls/certs/ca-bundle.crt
+    echo "[docker] Using CA bundle: ${NIX_SSL_CERT_FILE}"
+  else
+    echo "[docker] WARNING: No CA bundle found for Nix (NIX_SSL_CERT_FILE not set)."
+    echo "[docker] HTTPS access for Nix flakes may fail."
+  fi
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+echo "[docker] Starting package-manager container"
+
+# Distro info for logging
+if [[ -f /etc/os-release ]]; then
+  # shellcheck disable=SC1091
+  . /etc/os-release
+  echo "[docker] Detected distro: ${ID:-unknown} (like: ${ID_LIKE:-})"
+fi
+
+# Always use /src (mounted from host) as working directory
+echo "[docker] Using /src as working directory"
+cd /src
+
+# ------------------------------------------------------------
+# DEV mode: build/install package-manager from current /src
+# ------------------------------------------------------------
+if [[ "${PKGMGR_DEV:-0}" == "1" ]]; then
+  echo "[docker] DEV mode enabled (PKGMGR_DEV=1)"
+  echo "[docker] Rebuilding package-manager from /src via scripts/installation/run-package.sh..."
+
+  if [[ -x scripts/installation/run-package.sh ]]; then
+    bash scripts/installation/run-package.sh
+  else
+    echo "[docker] ERROR: scripts/installation/run-package.sh not found or not executable"
+    exit 1
+  fi
+fi
+
+# ------------------------------------------------------------
+# Hand-off to pkgmgr / arbitrary command
+# ------------------------------------------------------------
+if [[ $# -eq 0 ]]; then
+  echo "[docker] No arguments provided. Showing pkgmgr help..."
+  exec pkgmgr --help
+else
+  echo "[docker] Executing command: $*"
+  exec "$@"
+fi

scripts/init-nix.sh

@@ -1,44 +1,208 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-echo ">>> Initializing Nix environment for package-manager..."
+echo "[init-nix] Starting Nix initialization..."
 
-# 1. /nix store
-if [ ! -d /nix ]; then
-  echo ">>> Creating /nix store directory"
-  mkdir -m 0755 /nix
-  chown root:root /nix
+# ---------------------------------------------------------------------------
+# Helper: detect whether we are inside a container (Docker/Podman/etc.)
+# ---------------------------------------------------------------------------
+is_container() {
+  # Docker / Podman markers
+  if [[ -f /.dockerenv ]] || [[ -f /run/.containerenv ]]; then
+    return 0
+  fi
+
+  # cgroup hints
+  if grep -qiE 'docker|container|podman|lxc' /proc/1/cgroup 2>/dev/null; then
+    return 0
+  fi
+
+  # Environment variable used by some runtimes
+  if [[ -n "${container:-}" ]]; then
+    return 0
+  fi
+
+  return 1
+}
+
+# ---------------------------------------------------------------------------
+# Helper: ensure Nix binaries are on PATH (multi-user or single-user)
+# ---------------------------------------------------------------------------
+ensure_nix_on_path() {
+  # Multi-user profile (daemon install)
+  if [[ -x /nix/var/nix/profiles/default/bin/nix ]]; then
+    export PATH="/nix/var/nix/profiles/default/bin:${PATH}"
+  fi
+
+  # Single-user profile (current user)
+  if [[ -x "${HOME}/.nix-profile/bin/nix" ]]; then
+    export PATH="${HOME}/.nix-profile/bin:${PATH}"
+  fi
+
+  # Single-user profile for dedicated "nix" user (container case)
+  if [[ -x /home/nix/.nix-profile/bin/nix ]]; then
+    export PATH="/home/nix/.nix-profile/bin:${PATH}"
+  fi
+}
+
+# ---------------------------------------------------------------------------
+# Fast path: Nix already available
+# ---------------------------------------------------------------------------
+if command -v nix >/dev/null 2>&1; then
+  echo "[init-nix] Nix already available on PATH: $(command -v nix)"
+  exit 0
 fi
 
-# 2. Enable nix-daemon if available
-if command -v systemctl >/dev/null 2>&1 && systemctl list-unit-files | grep -q nix-daemon.service; then
-  echo ">>> Enabling nix-daemon.service"
-  systemctl enable --now nix-daemon.service 2>/dev/null || true
+ensure_nix_on_path
+
+if command -v nix >/dev/null 2>&1; then
+  echo "[init-nix] Nix found after adjusting PATH: $(command -v nix)"
+  exit 0
+fi
+
+echo "[init-nix] Nix not found, starting installation logic..."
+
+IN_CONTAINER=0
+if is_container; then
+  IN_CONTAINER=1
+  echo "[init-nix] Detected container environment."
 else
-  echo ">>> Warning: nix-daemon.service not found or systemctl not available."
+  echo "[init-nix] No container detected."
 fi
 
-# 3. Ensure nix-users group
-if ! getent group nix-users >/dev/null 2>&1; then
-  echo ">>> Creating nix-users group"
-  groupadd -r nix-users 2>/dev/null || true
-fi
+# ---------------------------------------------------------------------------
+# Container + root: install Nix as dedicated "nix" user (single-user)
+# ---------------------------------------------------------------------------
+if [[ "${IN_CONTAINER}" -eq 1 && "${EUID:-0}" -eq 0 ]]; then
+  echo "[init-nix] Running as root inside a container – using dedicated 'nix' user."
 
-# 4. Add users to nix-users (best-effort)
-if command -v loginctl >/dev/null 2>&1; then
-  for user in $(loginctl list-users | awk 'NR>1 {print $2}'); do
-    if id "$user" >/dev/null 2>&1; then
-      echo ">>> Adding user '$user' to nix-users"
-      usermod -aG nix-users "$user" 2>/dev/null || true
+  # Ensure nixbld group (required by Nix)
+  if ! getent group nixbld >/dev/null 2>&1; then
+    echo "[init-nix] Creating group 'nixbld'..."
+    groupadd -r nixbld
+  fi
+
+  # Ensure Nix build users (nixbld1..nixbld10) as members of nixbld
+  for i in $(seq 1 10); do
+    if ! id "nixbld$i" >/dev/null 2>&1; then
+      echo "[init-nix] Creating build user nixbld$i..."
+      # -r: system account, -g: primary group, -G: supplementary (ensures membership is listed)
+      useradd -r -g nixbld -G nixbld -s /usr/sbin/nologin "nixbld$i"
     fi
   done
-elif command -v logname >/dev/null 2>&1; then
-  USERNAME="$(logname 2>/dev/null || true)"
-  if [ -n "$USERNAME" ] && id "$USERNAME" >/dev/null 2>&1; then
-    echo ">>> Adding user '$USERNAME' to nix-users"
-    usermod -aG nix-users "$USERNAME" 2>/dev/null || true
+
+  # Ensure "nix" user (home at /home/nix)
+  if ! id nix >/dev/null 2>&1; then
+    echo "[init-nix] Creating user 'nix'..."
+    useradd -m -r -g nixbld -s /usr/bin/bash nix
+  fi
+
+  # Create /nix directory and hand it to nix user (prevents installer sudo prompt)
+  if [[ ! -d /nix ]]; then
+    echo "[init-nix] Creating /nix with owner nix:nixbld..."
+    mkdir -m 0755 /nix
+    chown nix:nixbld /nix
+  fi
+
+  # Run Nix single-user installer as "nix"
+  echo "[init-nix] Installing Nix as user 'nix' (single-user, --no-daemon)..."
+  if command -v sudo >/dev/null 2>&1; then
+    sudo -u nix bash -lc 'sh <(curl -L https://nixos.org/nix/install) --no-daemon'
+  else
+    su - nix -c 'sh <(curl -L https://nixos.org/nix/install) --no-daemon'
+  fi
+
+  # After installation, expose nix to root via PATH and symlink
+  ensure_nix_on_path
+
+  if [[ -x /home/nix/.nix-profile/bin/nix ]]; then
+    if [[ ! -e /usr/local/bin/nix ]]; then
+      echo "[init-nix] Creating /usr/local/bin/nix symlink -> /home/nix/.nix-profile/bin/nix"
+      ln -s /home/nix/.nix-profile/bin/nix /usr/local/bin/nix
+    fi
+  fi
+
+  ensure_nix_on_path
+
+  if command -v nix >/dev/null 2>&1; then
+    echo "[init-nix] Nix successfully installed (container mode) at: $(command -v nix)"
+  else
+    echo "[init-nix] WARNING: Nix installation finished in container, but 'nix' is still not on PATH."
+  fi
+
+  # Optionally add PATH hints to /etc/profile (best effort)
+  if [[ -w /etc/profile ]]; then
+    if ! grep -q 'Nix profiles' /etc/profile 2>/dev/null; then
+      cat <<'EOF' >> /etc/profile
+
+# Nix profiles (added by package-manager init-nix.sh)
+if [ -d /nix/var/nix/profiles/default/bin ]; then
+  PATH="/nix/var/nix/profiles/default/bin:$PATH"
+fi
+if [ -d "$HOME/.nix-profile/bin" ]; then
+  PATH="$HOME/.nix-profile/bin:$PATH"
+fi
+EOF
+      echo "[init-nix] Appended Nix PATH setup to /etc/profile (container mode)."
+    fi
+  fi
+
+  echo "[init-nix] Nix initialization complete (container root mode)."
+  exit 0
+fi
+
+# ---------------------------------------------------------------------------
+# Non-container or non-root container: normal installer paths
+# ---------------------------------------------------------------------------
+if [[ "${IN_CONTAINER}" -eq 0 ]]; then
+  # Real host
+  if command -v systemctl >/dev/null 2>&1; then
+    echo "[init-nix] Host with systemd – using multi-user install (--daemon)."
+    sh <(curl -L https://nixos.org/nix/install) --daemon
+  else
+    if [[ "${EUID:-0}" -eq 0 ]]; then
+      echo "[init-nix] WARNING: Running as root without systemd on host."
+      echo "[init-nix] Falling back to single-user install (--no-daemon), but this is not recommended."
+      sh <(curl -L https://nixos.org/nix/install) --no-daemon
+    else
+      echo "[init-nix] Non-root host without systemd – using single-user install (--no-daemon)."
+      sh <(curl -L https://nixos.org/nix/install) --no-daemon
+    fi
+  fi
+else
+  # Container, but not root (rare)
+  echo "[init-nix] Container as non-root user – using single-user install (--no-daemon)."
+  sh <(curl -L https://nixos.org/nix/install) --no-daemon
+fi
+
+# ---------------------------------------------------------------------------
+# After installation: fix PATH (runtime + shell profiles)
+# ---------------------------------------------------------------------------
+ensure_nix_on_path
+
+if ! command -v nix >/dev/null 2>&1; then
+  echo "[init-nix] WARNING: Nix installation finished, but 'nix' is still not on PATH."
+  echo "[init-nix] You may need to source your shell profile manually."
+  exit 0
+fi
+
+echo "[init-nix] Nix successfully installed at: $(command -v nix)"
+
+# Update global /etc/profile if writable (helps especially on minimal systems)
+if [[ -w /etc/profile ]]; then
+  if ! grep -q 'Nix profiles' /etc/profile 2>/dev/null; then
+    cat <<'EOF' >> /etc/profile
+
+# Nix profiles (added by package-manager init-nix.sh)
+if [ -d /nix/var/nix/profiles/default/bin ]; then
+  PATH="/nix/var/nix/profiles/default/bin:$PATH"
+fi
+if [ -d "$HOME/.nix-profile/bin" ]; then
+  PATH="$HOME/.nix-profile/bin:$PATH"
+fi
+EOF
+    echo "[init-nix] Appended Nix PATH setup to /etc/profile"
   fi
 fi
 
-echo ">>> Nix initialization complete."
-echo ">>> You may need to log out and log back in to activate group membership."
+echo "[init-nix] Nix initialization complete."

scripts/installation/arch/aur-builder-setup.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# ------------------------------------------------------------
+# aur-builder-setup.sh
+#
+# Setup helper for an 'aur_builder' user and yay on Arch-based
+# systems. Intended for host usage and can also be used in
+# containers if desired.
+# ------------------------------------------------------------
+
+echo "[aur-builder-setup] Checking for pacman..."
+if ! command -v pacman >/dev/null 2>&1; then
+  echo "[aur-builder-setup] pacman not found – this is not an Arch-based system. Skipping."
+  exit 0
+fi
+
+if [[ "${EUID:-0}" -ne 0 ]]; then
+  ROOT_CMD="sudo"
+else
+  ROOT_CMD=""
+fi
+
+echo "[aur-builder-setup] Installing base-devel, git, sudo..."
+${ROOT_CMD} pacman -Syu --noconfirm
+${ROOT_CMD} pacman -S --needed --noconfirm base-devel git sudo
+
+echo "[aur-builder-setup] Ensuring aur_builder group/user..."
+if ! getent group aur_builder >/dev/null 2>&1; then
+  ${ROOT_CMD} groupadd -r aur_builder
+fi
+
+if ! id -u aur_builder >/dev/null 2>&1; then
+  ${ROOT_CMD} useradd -m -r -g aur_builder -s /bin/bash aur_builder
+fi
+
+echo "[aur-builder-setup] Configuring sudoers for aur_builder..."
+${ROOT_CMD} bash -c "echo '%aur_builder ALL=(ALL) NOPASSWD: /usr/bin/pacman' > /etc/sudoers.d/aur_builder"
+${ROOT_CMD} chmod 0440 /etc/sudoers.d/aur_builder
+
+if command -v sudo >/dev/null 2>&1; then
+  RUN_AS_AUR=(sudo -u aur_builder bash -lc)
+else
+  RUN_AS_AUR=(su - aur_builder -c)
+fi
+
+echo "[aur-builder-setup] Ensuring yay is installed for aur_builder..."
+if ! "${RUN_AS_AUR[@]}" 'command -v yay >/dev/null 2>&1'; then
+  "${RUN_AS_AUR[@]}" 'cd ~ && rm -rf yay && git clone https://aur.archlinux.org/yay.git && cd yay && makepkg -si --noconfirm'
+else
+  echo "[aur-builder-setup] yay already installed."
+fi
+
+echo "[aur-builder-setup] Done."

scripts/installation/arch/dependencies.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+echo "[arch/dependencies] Installing Arch build dependencies..."
+
+pacman -Syu --noconfirm
+pacman -S --noconfirm --needed \
+  base-devel \
+  git \
+  rsync \
+  curl \
+  ca-certificates \
+  xz
+
+pacman -Scc --noconfirm
+
+# Always run AUR builder setup for Arch
+AUR_SETUP="${SCRIPT_DIR}/aur-builder-setup.sh"
+
+if [[ ! -x "${AUR_SETUP}" ]]; then
+  echo "[arch/dependencies] ERROR: AUR builder setup script not found or not executable: ${AUR_SETUP}"
+  exit 1
+fi
+
+echo "[arch/dependencies] Running AUR builder setup..."
+bash "${AUR_SETUP}"
+
+echo "[arch/dependencies] Done."

scripts/installation/arch/package.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "[arch/package] Building Arch package (makepkg --nodeps)..."
+
+if id aur_builder >/dev/null 2>&1; then
+  echo "[arch/package] Using 'aur_builder' user for makepkg..."
+  chown -R aur_builder:aur_builder "$(pwd)"
+  su aur_builder -c "cd '$(pwd)' && rm -f package-manager-*.pkg.tar.* && makepkg --noconfirm --clean --nodeps"
+else
+  echo "[arch/package] WARNING: user 'aur_builder' not found, running makepkg as current user..."
+  rm -f package-manager-*.pkg.tar.*
+  makepkg --noconfirm --clean --nodeps
+fi
+
+echo "[arch/package] Installing generated Arch package..."
+pacman -U --noconfirm package-manager-*.pkg.tar.*
+
+echo "[arch/package] Done."

scripts/installation/centos/dependencies.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "[centos/dependencies] Installing CentOS build dependencies..."
+
+dnf -y update
+dnf -y install \
+  git \
+  rsync \
+  rpm-build \
+  make \
+  gcc \
+  bash \
+  curl-minimal \
+  ca-certificates \
+  xz
+
+dnf clean all
+
+echo "[centos/dependencies] Done."

scripts/installation/centos/package.sh

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "[centos/package] Setting up rpmbuild directories..."
+mkdir -p /root/rpmbuild/{BUILD,RPMS,SOURCES,SPECS,SRPMS}
+
+echo "[centos/package] Extracting version from package-manager.spec..."
+version="$(grep -E '^Version:' package-manager.spec | awk '{print $2}')"
+if [[ -z "${version}" ]]; then
+  echo "ERROR: Version missing!"
+  exit 1
+fi
+
+srcdir="package-manager-${version}"
+echo "[centos/package] Preparing source tree: ${srcdir}"
+rm -rf "/tmp/${srcdir}"
+mkdir -p "/tmp/${srcdir}"
+cp -a . "/tmp/${srcdir}/"
+
+echo "[centos/package] Creating source tarball..."
+tar czf "/root/rpmbuild/SOURCES/${srcdir}.tar.gz" -C /tmp "${srcdir}"
+
+echo "[centos/package] Copying SPEC..."
+cp package-manager.spec /root/rpmbuild/SPECS/
+
+echo "[centos/package] Running rpmbuild..."
+cd /root/rpmbuild/SPECS
+rpmbuild -bb package-manager.spec
+
+echo "[centos/package] Installing generated RPM (local, offline, forced reinstall)..."
+rpm_path="$(find /root/rpmbuild/RPMS -name 'package-manager-*.rpm' | head -n1)"
+if [[ -z "${rpm_path}" ]]; then
+  echo "ERROR: RPM not found!"
+  exit 1
+fi
+
+# ------------------------------------------------------------
+# Forced reinstall, always overwrite old version
+# ------------------------------------------------------------
+echo "[centos/package] Forcing reinstall via rpm -Uvh --replacepkgs --force"
+rpm -Uvh --replacepkgs --force "${rpm_path}"
+
+# Keep structure: remove temp directory afterwards
+rm -rf "/tmp/${srcdir}"
+
+echo "[centos/package] Done."

scripts/installation/debian/dependencies.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "[debian/dependencies] Installing Debian build dependencies..."
+
+apt-get update
+DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
+  build-essential \
+  debhelper \
+  dpkg-dev \
+  git \
+  rsync \
+  bash \
+  curl \
+  ca-certificates \
+  xz-utils
+
+rm -rf /var/lib/apt/lists/*
+
+echo "[debian/dependencies] Done."

scripts/installation/debian/package.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "[debian/package] Building Debian package..."
+
+dpkg-buildpackage -us -uc -b
+
+echo "[debian/package] Installing generated DEB package..."
+apt-get update
+DEBIAN_FRONTEND=noninteractive apt-get install -y ./../package-manager_*.deb
+rm -rf /var/lib/apt/lists/*
+
+echo "[debian/package] Done."

scripts/installation/fedora/dependencies.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "[fedora/dependencies] Installing Fedora build dependencies..."
+
+dnf -y update
+dnf -y install \
+  git \
+  rsync \
+  rpm-build \
+  make \
+  gcc \
+  bash \
+  curl \
+  ca-certificates \
+  python3 \
+  xz
+
+dnf clean all
+
+echo "[fedora/dependencies] Done."

scripts/installation/fedora/package.sh

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "[fedora/package] Setting up rpmbuild directories..."
+mkdir -p /root/rpmbuild/{BUILD,RPMS,SOURCES,SPECS,SRPMS}
+
+echo "[fedora/package] Extracting version from package-manager.spec..."
+version="$(grep -E '^Version:' package-manager.spec | awk '{print $2}')"
+if [[ -z "${version}" ]]; then
+  echo "ERROR: Version missing!"
+  exit 1
+fi
+
+srcdir="package-manager-${version}"
+echo "[fedora/package] Preparing source tree: ${srcdir}"
+rm -rf "/tmp/${srcdir}"
+mkdir -p "/tmp/${srcdir}"
+cp -a . "/tmp/${srcdir}/"
+
+echo "[fedora/package] Creating source tarball..."
+tar czf "/root/rpmbuild/SOURCES/${srcdir}.tar.gz" -C /tmp "${srcdir}"
+
+echo "[fedora/package] Copying SPEC..."
+cp package-manager.spec /root/rpmbuild/SPECS/
+
+echo "[fedora/package] Running rpmbuild..."
+cd /root/rpmbuild/SPECS
+rpmbuild -bb package-manager.spec
+
+echo "[fedora/package] Installing generated RPM (local, offline, forced reinstall)..."
+rpm_path="$(find /root/rpmbuild/RPMS -name 'package-manager-*.rpm' | head -n1)"
+if [[ -z "${rpm_path}" ]]; then
+  echo "ERROR: RPM not found!"
+  exit 1
+fi
+
+# Always force (re)install the freshly built RPM, even if the same
+# version is already installed. This is what we want in dev/test containers.
+rpm -Uvh --replacepkgs --force "${rpm_path}"
+
+rm -rf "/tmp/${srcdir}"
+
+echo "[fedora/package] Done."

scripts/installation/lib.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+detect_os_id() {
+  if [[ -f /etc/os-release ]]; then
+    # shellcheck disable=SC1091
+    . /etc/os-release
+    echo "${ID:-unknown}"
+  else
+    echo "unknown"
+  fi
+}

scripts/installation/main.sh

@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# ------------------------------------------------------------
+# main.sh
+#
+# Developer setup entrypoint.
+#
+# Responsibilities:
+#   - If inside a Nix shell (IN_NIX_SHELL=1):
+#       * Skip venv creation and dependency installation
+#       * Run `python3 main.py install`
+#   - Otherwise:
+#       * Create ~/.venvs/pkgmgr virtual environment if missing
+#       * Install Python dependencies into that venv
+#       * Append auto-activation to ~/.bashrc and ~/.zshrc
+#       * Run `main.py install` using the venv Python
+# ------------------------------------------------------------
+
+echo "[installation/main] Starting developer setup..."
+
+PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+cd "${PROJECT_ROOT}"
+
+VENV_DIR="${HOME}/.venvs/pkgmgr"
+RC_LINE='if [ -d "${HOME}/.venvs/pkgmgr" ]; then . "${HOME}/.venvs/pkgmgr/bin/activate"; if [ -n "${PS1:-}" ]; then echo "Global Python virtual environment '\''~/.venvs/pkgmgr'\'' activated."; fi; fi'
+
+# ------------------------------------------------------------
+# Nix shell mode: do not touch venv, only run main.py install
+# ------------------------------------------------------------
+if [[ -n "${IN_NIX_SHELL:-}" ]]; then
+    echo "[installation/main] Nix shell detected (IN_NIX_SHELL=1)."
+    echo "[installation/main] Skipping virtualenv creation and dependency installation."
+    echo "[installation/main] Running main.py install via system python3..."
+    python3 main.py install
+    echo "[installation/main] Developer setup finished (Nix mode)."
+    exit 0
+fi
+
+# ------------------------------------------------------------
+# Normal host mode: create/update venv and run main.py install
+# ------------------------------------------------------------
+
+echo "[installation/main] Ensuring main.py is executable..."
+chmod +x main.py || true
+
+echo "[installation/main] Ensuring global virtualenv root: ${HOME}/.venvs"
+mkdir -p "${HOME}/.venvs"
+
+if [[ ! -d "${VENV_DIR}" ]]; then
+    echo "[installation/main] Creating virtual environment at: ${VENV_DIR}"
+    python3 -m venv "${VENV_DIR}"
+else
+    echo "[installation/main] Virtual environment already exists at: ${VENV_DIR}"
+fi
+
+echo "[installation/main] Installing Python tooling into venv..."
+"${VENV_DIR}/bin/python" -m ensurepip --upgrade
+"${VENV_DIR}/bin/pip" install --upgrade pip setuptools wheel
+
+if [[ -f "requirements.txt" ]]; then
+    echo "[installation/main] Installing dependencies from requirements.txt..."
+    "${VENV_DIR}/bin/pip" install -r requirements.txt
+elif [[ -f "_requirements.txt" ]]; then
+    echo "[installation/main] Installing dependencies from _requirements.txt..."
+    "${VENV_DIR}/bin/pip" install -r _requirements.txt
+else
+    echo "[installation/main] No requirements.txt or _requirements.txt found. Skipping dependency installation."
+fi
+
+echo "[installation/main] Ensuring ~/.bashrc and ~/.zshrc exist..."
+touch "${HOME}/.bashrc" "${HOME}/.zshrc"
+
+echo "[installation/main] Ensuring venv auto-activation is present in shell rc files..."
+for rc in "${HOME}/.bashrc" "${HOME}/.zshrc"; do
+    if ! grep -qxF "${RC_LINE}" "$rc"; then
+        echo "${RC_LINE}" >> "$rc"
+        echo "[installation/main] Appended auto-activation to $rc"
+    else
+        echo "[installation/main] Auto-activation already present in $rc"
+    fi
+done
+
+echo "[installation/main] Running main.py install via venv Python..."
+"${VENV_DIR}/bin/python" main.py install
+
+echo
+echo "[installation/main] Developer setup complete."
+echo "Restart your shell (or run 'exec bash' or 'exec zsh') to activate the environment."

scripts/installation/run-dependencies.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# shellcheck source=/dev/null
+source "${SCRIPT_DIR}/lib.sh"
+
+OS_ID="$(detect_os_id)"
+
+echo "[run-dependencies] Detected OS: ${OS_ID}"
+
+case "${OS_ID}" in
+  arch|debian|ubuntu|fedora|centos)
+    DEP_SCRIPT="${SCRIPT_DIR}/${OS_ID}/dependencies.sh"
+    ;;
+  *)
+    echo "[run-dependencies] Unsupported OS: ${OS_ID}"
+    exit 1
+    ;;
+esac
+
+if [[ ! -f "${DEP_SCRIPT}" ]]; then
+  echo "[run-dependencies] Dependency script not found: ${DEP_SCRIPT}"
+  exit 1
+fi
+
+echo "[run-dependencies] Executing: ${DEP_SCRIPT}"
+exec bash "${DEP_SCRIPT}"

scripts/installation/run-package.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# shellcheck source=/dev/null
+source "${SCRIPT_DIR}/lib.sh"
+
+OS_ID="$(detect_os_id)"
+
+echo "[run-package] Detected OS: ${OS_ID}"
+
+case "${OS_ID}" in
+  arch|debian|ubuntu|fedora|centos)
+    PKG_SCRIPT="${SCRIPT_DIR}/${OS_ID}/package.sh"
+    ;;
+  *)
+    echo "[run-package] Unsupported OS: ${OS_ID}"
+    exit 1
+    ;;
+esac
+
+if [[ ! -f "${PKG_SCRIPT}" ]]; then
+  echo "[run-package] Package script not found: ${PKG_SCRIPT}"
+  exit 1
+fi
+
+echo "[run-package] Executing: ${PKG_SCRIPT}"
+exec bash "${PKG_SCRIPT}"

scripts/installation/ubuntu/dependencies.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "[ubuntu/dependencies] Installing Ubuntu build dependencies..."
+
+apt-get update
+DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
+  build-essential \
+  debhelper \
+  dpkg-dev \
+  git \
+  tzdata \
+  lsb-release \
+  rsync \
+  bash \
+  curl \
+  ca-certificates \
+  xz-utils
+
+rm -rf /var/lib/apt/lists/*
+
+echo "[ubuntu/dependencies] Done."

scripts/installation/ubuntu/package.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "[ubuntu/package] Building Ubuntu (Debian-style) package..."
+
+dpkg-buildpackage -us -uc -b
+
+echo "[ubuntu/package] Installing generated DEB package..."
+apt-get update
+DEBIAN_FRONTEND=noninteractive apt-get install -y ./../package-manager_*.deb
+rm -rf /var/lib/apt/lists/*
+
+echo "[ubuntu/package] Done."

scripts/pkgmgr-wrapper.sh

@@ -1,10 +1,40 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
+# Ensure NIX_CONFIG has our defaults if not already set
 if [[ -z "${NIX_CONFIG:-}" ]]; then
   export NIX_CONFIG="experimental-features = nix-command flakes"
 fi
 
 FLAKE_DIR="/usr/lib/package-manager"
 
-exec nix run "${FLAKE_DIR}#pkgmgr" -- "$@"
+# ------------------------------------------------------------
+# Try to ensure that "nix" is on PATH
+# ------------------------------------------------------------
+if ! command -v nix >/dev/null 2>&1; then
+  # Common locations for Nix installations
+  CANDIDATES=(
+    "/nix/var/nix/profiles/default/bin/nix"
+    "${HOME:-/root}/.nix-profile/bin/nix"
+  )
+
+  for candidate in "${CANDIDATES[@]}"; do
+    if [[ -x "$candidate" ]]; then
+      # Prepend the directory of the candidate to PATH
+      PATH="$(dirname "$candidate"):${PATH}"
+      export PATH
+      break
+    fi
+  done
+fi
+
+# ------------------------------------------------------------
+# Primary (and only) path: use Nix flake if available
+# ------------------------------------------------------------
+if command -v nix >/dev/null 2>&1; then
+  exec nix run "${FLAKE_DIR}#pkgmgr" -- "$@"
+fi
+
+echo "[pkgmgr-wrapper] ERROR: 'nix' binary not found on PATH."
+echo "[pkgmgr-wrapper] Nix is required to run pkgmgr (no Python fallback)."
+exit 1

scripts/test/test-common.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+detect_container_distro() {
+  if [[ -f /etc/os-release ]]; then
+    # shellcheck disable=SC1091
+    . /etc/os-release
+    echo "${ID:-unknown}"
+  else
+    echo "unknown"
+  fi
+}

scripts/test/test-container.sh

@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "============================================================"
+echo ">>> Running sanity test: verifying test containers start"
+echo "============================================================"
+
+for distro in $DISTROS; do
+    IMAGE="package-manager-test-$distro"
+
+    echo
+    echo "------------------------------------------------------------"
+    echo ">>> Testing container: $IMAGE"
+    echo "------------------------------------------------------------"
+
+    echo "[test-container] Running: docker run --rm --entrypoint pkgmgr $IMAGE --help"
+    echo
+
+    # Run the command and capture the output
+    if OUTPUT=$(docker run --rm \
+            -e PKGMGR_DEV=1 \
+            -v "$(pwd):/src" \
+            -v "pkgmgr_nix_cache:/root/.cache/nix" \
+            "$IMAGE" 2>&1); then
+        echo "$OUTPUT"
+        echo
+        echo "[test-container] SUCCESS: $IMAGE responded to 'pkgmgr --help'"
+
+    else
+        echo "$OUTPUT"
+        echo
+        echo "[test-container] ERROR: $IMAGE failed to run 'pkgmgr --help'"
+        exit 1
+    fi
+done
+
+echo
+echo "============================================================"
+echo ">>> All containers passed the sanity check"
+echo "============================================================"

scripts/test/test-e2e.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo ">>> Running E2E tests in all distros: $DISTROS"
+
+for distro in $DISTROS; do
+  echo "============================================================"
+  echo ">>> Running E2E tests: $distro"
+  echo "============================================================"
+
+  MOUNT_NIX=""
+  if [[ "$distro" == "arch" ]]; then
+    MOUNT_NIX="-v pkgmgr_nix_store:/nix"
+  fi
+
+  docker run --rm \
+    -v "$(pwd):/src" \
+    $MOUNT_NIX \
+    -v "pkgmgr_nix_cache:/root/.cache/nix" \
+    -e PKGMGR_DEV=1 \
+    --workdir /src \
+    --entrypoint bash \
+    "package-manager-test-$distro" \
+    -c '
+      set -e;
+
+      if [ -f /etc/os-release ]; then
+        . /etc/os-release;
+      fi;
+
+      echo "Running tests inside distro: $ID";
+
+      # Try to load nix environment
+      if [ -f "/nix/var/nix/profiles/default/etc/profile.d/nix-daemon.sh" ]; then
+        . "/nix/var/nix/profiles/default/etc/profile.d/nix-daemon.sh";
+      fi
+
+      if [ -f "$HOME/.nix-profile/etc/profile.d/nix.sh" ]; then
+        . "$HOME/.nix-profile/etc/profile.d/nix.sh";
+      fi
+
+      PATH="/nix/var/nix/profiles/default/bin:$HOME/.nix-profile/bin:$PATH";
+
+      command -v nix >/dev/null || {
+        echo "ERROR: nix not found.";
+        exit 1;
+      }
+
+      git config --global --add safe.directory /src || true;
+
+      nix develop .#default --no-write-lock-file -c \
+        python3 -m unittest discover \
+          -s /src/tests/e2e \
+          -p "test_*.py";
+    '
+done

scripts/test/test-integration.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "============================================================"
+echo ">>> Running INTEGRATION tests in Arch container"
+echo "============================================================"
+
+docker run --rm \
+  -v "$(pwd):/src" \
+  -v "pkgmgr_nix_cache:/root/.cache/nix" \
+  --workdir /src \
+  -e PKGMGR_DEV=1 \
+  --entrypoint bash \
+  "package-manager-test-arch" \
+  -c '
+    set -e;
+    git config --global --add safe.directory /src || true;
+    nix develop .#default --no-write-lock-file -c \
+      python -m unittest discover \
+        -s tests/integration \
+        -t /src \
+        -p "test_*.py";
+  '

scripts/test/test-unit.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "============================================================"
+echo ">>> Running UNIT tests in Arch container"
+echo "============================================================"
+
+docker run --rm \
+  -v "$(pwd):/src" \
+  -v "pkgmgr_nix_cache:/root/.cache/nix" \
+  --workdir /src \
+  -e PKGMGR_DEV=1 \
+  --entrypoint bash \
+  "package-manager-test-arch" \
+  -c '
+    set -e;
+    git config --global --add safe.directory /src || true;
+    nix develop .#default --no-write-lock-file -c \
+      python -m unittest discover \
+        -s tests/unit \
+        -t /src \
+        -p "test_*.py";
+  '

scripts/uninstall.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "[uninstall] Starting pkgmgr uninstall..."
+
+VENV_DIR="${HOME}/.venvs/pkgmgr"
+
+# ------------------------------------------------------------
+# Remove virtual environment
+# ------------------------------------------------------------
+echo "[uninstall] Removing global user virtual environment if it exists..."
+if [[ -d "$VENV_DIR" ]]; then
+    rm -rf "$VENV_DIR"
+    echo "[uninstall] Removed: $VENV_DIR"
+else
+    echo "[uninstall] No venv found at: $VENV_DIR"
+fi
+
+# ------------------------------------------------------------
+# Remove auto-activation lines from shell RC files
+# ------------------------------------------------------------
+RC_PATTERN='\.venvs\/pkgmgr\/bin\/activate"; if \[ -n "\$${PS1:-}" \]; then echo "Global Python virtual environment '\''~\/\.venvs\/pkgmgr'\'' activated."; fi; fi'
+
+echo "[uninstall] Cleaning up ~/.bashrc and ~/.zshrc entries..."
+for rc in "$HOME/.bashrc" "$HOME/.zshrc"; do
+    if [[ -f "$rc" ]]; then
+        sed -i "/$RC_PATTERN/d" "$rc"
+        echo "[uninstall] Cleaned $rc"
+    else
+        echo "[uninstall] File not found: $rc (skipped)"
+    fi
+done
+
+echo "[uninstall] Done. Restart your shell (or run 'exec bash' or 'exec zsh') to apply changes."

tests/e2e/test_integration_release_commands.py

@@ -4,10 +4,17 @@
 """
 End-to-end style integration tests for the `pkgmgr release` CLI command.
 
-These tests exercise the top-level `pkgmgr` entry point by invoking
-the module as `__main__` and verifying that the underlying
-`pkgmgr.release.release()` function is called with the expected
-arguments, in particular the new `close` flag.
+These tests exercise the real top-level entry point (main.py) and mock
+the high-level helper used by the CLI wiring
+(pkgmgr.cli_core.commands.release.run_release) to ensure that argument
+parsing and dispatch behave as expected, in particular the new `close`
+flag.
+
+The tests simulate real CLI calls like:
+
+    pkgmgr release minor --preview --close
+
+by manipulating sys.argv and executing main.py as __main__ via runpy.
 """
 
 from __future__ import annotations
@@ -21,55 +28,110 @@ from unittest.mock import patch
 class TestIntegrationReleaseCommand(unittest.TestCase):
     """Integration tests for `pkgmgr release` wiring."""
 
-    def _run_pkgmgr(self, argv: list[str]) -> None:
+    def _run_pkgmgr(self, extra_args: list[str]) -> None:
         """
-        Helper to invoke the `pkgmgr` console script via `run_module`.
+        Helper to invoke the `pkgmgr` console script via the real
+        entry point (main.py).
 
         This simulates a real CLI call like:
 
-            pkgmgr release minor --preview --close
+            pkgmgr <extra_args...>
+
+        by setting sys.argv accordingly and executing main.py as
+        __main__ using runpy.run_module.
         """
         original_argv = list(sys.argv)
         try:
-            sys.argv = argv
-            # Entry point: the `pkgmgr` module is the console script.
-            runpy.run_module("pkgmgr", run_name="__main__")
+            # argv[0] is the program name; the rest are CLI arguments.
+            sys.argv = ["pkgmgr"] + list(extra_args)
+            runpy.run_module("main", run_name="__main__")
         finally:
             sys.argv = original_argv
 
-    @patch("pkgmgr.release.release")
-    def test_release_without_close_flag(self, mock_release) -> None:
+    # ------------------------------------------------------------------
+    # Behaviour without --close
+    # ------------------------------------------------------------------
+
+    @patch("pkgmgr.cli_core.commands.release.run_release")
+    @patch("pkgmgr.cli_core.dispatch._select_repo_for_current_directory")
+    def test_release_without_close_flag(
+        self,
+        mock_select_repo,
+        mock_run_release,
+    ) -> None:
         """
         Calling `pkgmgr release patch --preview` should *not* enable
         the `close` flag by default.
         """
-        self._run_pkgmgr(["pkgmgr", "release", "patch", "--preview"])
+        # Ensure that the dispatch layer always selects a repository,
+        # independent of any real config in the test environment.
+        mock_select_repo.return_value = [
+            {
+                "directory": ".",
+                "provider": "local",
+                "account": "test",
+                "repository": "dummy",
+            }
+        ]
 
-        mock_release.assert_called_once()
-        _args, kwargs = mock_release.call_args
+        self._run_pkgmgr(["release", "patch", "--preview"])
+
+        mock_run_release.assert_called_once()
+        _args, kwargs = mock_run_release.call_args
 
         # CLI wiring
         self.assertEqual(kwargs.get("release_type"), "patch")
-        self.assertTrue(kwargs.get("preview"), "preview should be True when --preview is used")
+        self.assertTrue(
+            kwargs.get("preview"),
+            "preview should be True when --preview is used",
+        )
         # Default: no --close → close=False
-        self.assertFalse(kwargs.get("close"), "close must be False when --close is not given")
+        self.assertFalse(
+            kwargs.get("close"),
+            "close must be False when --close is not given",
+        )
 
-    @patch("pkgmgr.release.release")
-    def test_release_with_close_flag(self, mock_release) -> None:
+    # ------------------------------------------------------------------
+    # Behaviour with --close
+    # ------------------------------------------------------------------
+
+    @patch("pkgmgr.cli_core.commands.release.run_release")
+    @patch("pkgmgr.cli_core.dispatch._select_repo_for_current_directory")
+    def test_release_with_close_flag(
+        self,
+        mock_select_repo,
+        mock_run_release,
+    ) -> None:
         """
         Calling `pkgmgr release minor --preview --close` should pass
-        close=True into pkgmgr.release.release().
+        close=True into the helper used by the CLI wiring.
         """
-        self._run_pkgmgr(["pkgmgr", "release", "minor", "--preview", "--close"])
+        # Again: make sure there is always a selected repository.
+        mock_select_repo.return_value = [
+            {
+                "directory": ".",
+                "provider": "local",
+                "account": "test",
+                "repository": "dummy",
+            }
+        ]
 
-        mock_release.assert_called_once()
-        _args, kwargs = mock_release.call_args
+        self._run_pkgmgr(["release", "minor", "--preview", "--close"])
+
+        mock_run_release.assert_called_once()
+        _args, kwargs = mock_run_release.call_args
 
         # CLI wiring
         self.assertEqual(kwargs.get("release_type"), "minor")
-        self.assertTrue(kwargs.get("preview"), "preview should be True when --preview is used")
+        self.assertTrue(
+            kwargs.get("preview"),
+            "preview should be True when --preview is used",
+        )
         # With --close → close=True
-        self.assertTrue(kwargs.get("close"), "close must be True when --close is given")
+        self.assertTrue(
+            kwargs.get("close"),
+            "close must be True when --close is given",
+        )
 
 
 if __name__ == "__main__":

tests/unit/pkgmgr/cli_core/test_branch_cli.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Unit tests for the `pkgmgr branch` CLI wiring.
+
+These tests verify that:
+  - The argument parser creates the correct structure for
+    `branch open` and `branch close`.
+  - `handle_branch` calls the corresponding helper functions
+    with the expected arguments (including base branch and cwd).
+"""
+
+from __future__ import annotations
+
+import unittest
+from unittest.mock import patch
+
+from pkgmgr.cli_core.parser import create_parser
+from pkgmgr.cli_core.commands.branch import handle_branch
+
+
+class TestBranchCLI(unittest.TestCase):
+    """
+    Tests for the branch subcommands implemented in cli_core.
+    """
+
+    def _create_parser(self):
+        """
+        Create the top-level parser with a minimal description.
+        """
+        return create_parser("pkgmgr test parser")
+
+    @patch("pkgmgr.cli_core.commands.branch.open_branch")
+    def test_branch_open_with_name_and_base(self, mock_open_branch):
+        """
+        Ensure that `pkgmgr branch open <name> --base <branch>` calls
+        open_branch() with the correct parameters.
+        """
+        parser = self._create_parser()
+        args = parser.parse_args(
+            ["branch", "open", "feature/test-branch", "--base", "develop"]
+        )
+
+        # Sanity check: parser wiring
+        self.assertEqual(args.command, "branch")
+        self.assertEqual(args.subcommand, "open")
+        self.assertEqual(args.name, "feature/test-branch")
+        self.assertEqual(args.base, "develop")
+
+        # ctx is currently unused by handle_branch, so we can pass None
+        handle_branch(args, ctx=None)
+
+        mock_open_branch.assert_called_once()
+        _args, kwargs = mock_open_branch.call_args
+
+        self.assertEqual(kwargs.get("name"), "feature/test-branch")
+        self.assertEqual(kwargs.get("base_branch"), "develop")
+        self.assertEqual(kwargs.get("cwd"), ".")
+
+    @patch("pkgmgr.cli_core.commands.branch.close_branch")
+    def test_branch_close_with_name_and_base(self, mock_close_branch):
+        """
+        Ensure that `pkgmgr branch close <name> --base <branch>` calls
+        close_branch() with the correct parameters.
+        """
+        parser = self._create_parser()
+        args = parser.parse_args(
+            ["branch", "close", "feature/old-branch", "--base", "main"]
+        )
+
+        # Sanity check: parser wiring
+        self.assertEqual(args.command, "branch")
+        self.assertEqual(args.subcommand, "close")
+        self.assertEqual(args.name, "feature/old-branch")
+        self.assertEqual(args.base, "main")
+
+        handle_branch(args, ctx=None)
+
+        mock_close_branch.assert_called_once()
+        _args, kwargs = mock_close_branch.call_args
+
+        self.assertEqual(kwargs.get("name"), "feature/old-branch")
+        self.assertEqual(kwargs.get("base_branch"), "main")
+        self.assertEqual(kwargs.get("cwd"), ".")
+
+    @patch("pkgmgr.cli_core.commands.branch.close_branch")
+    def test_branch_close_without_name_uses_none(self, mock_close_branch):
+        """
+        Ensure that `pkgmgr branch close` without a name passes name=None
+        into close_branch(), leaving branch resolution to the helper.
+        """
+        parser = self._create_parser()
+        args = parser.parse_args(["branch", "close"])
+
+        # Parser wiring: no name → None
+        self.assertEqual(args.command, "branch")
+        self.assertEqual(args.subcommand, "close")
+        self.assertIsNone(args.name)
+
+        handle_branch(args, ctx=None)
+
+        mock_close_branch.assert_called_once()
+        _args, kwargs = mock_close_branch.call_args
+
+        self.assertIsNone(kwargs.get("name"))
+        self.assertEqual(kwargs.get("base_branch"), "main")
+        self.assertEqual(kwargs.get("cwd"), ".")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/unit/pkgmgr/test_cli.py

@@ -42,7 +42,7 @@ def _fake_config() -> Dict[str, Any]:
             "workspaces": "/tmp/pkgmgr-workspaces",
         },
         # The actual list of repositories is not used directly by the tests,
-        # because we mock get_selected_repos(). It must exist, though.
+        # because we mock the selection logic. It must exist, though.
         "repositories": [],
     }
 
@@ -54,8 +54,9 @@ class TestCliVersion(unittest.TestCase):
     Each test:
     - Runs in a temporary working directory.
     - Uses a fake configuration via load_config().
-    - Uses a mocked get_selected_repos() that returns a single repo
-      pointing to the temporary directory.
+    - Uses the same selection logic as the new CLI:
+      * dispatch_command() calls _select_repo_for_current_directory()
+        when there is no explicit selection.
     """
 
     def setUp(self) -> None:
@@ -64,31 +65,30 @@ class TestCliVersion(unittest.TestCase):
         self._old_cwd = os.getcwd()
         os.chdir(self._tmp_dir.name)
 
+        # Define a fake repo pointing to our temp dir
+        self._fake_repo = {
+            "provider": "github.com",
+            "account": "test",
+            "repository": "pkgmgr-test",
+            "directory": self._tmp_dir.name,
+        }
+
         # Patch load_config so cli.main() does not read real config files
         self._patch_load_config = mock.patch(
             "pkgmgr.cli.load_config", return_value=_fake_config()
         )
         self.mock_load_config = self._patch_load_config.start()
 
-        # Patch get_selected_repos so that 'version' operates on our temp dir.
-        # In the new modular CLI this function is used inside
-        # pkgmgr.cli_core.dispatch, so we patch it there.
-        def _fake_selected_repos(args, all_repositories):
-            return [
-            {
-                "provider": "github.com",
-                "account": "test",
-                "repository": "pkgmgr-test",
-                "directory": self._tmp_dir.name,
-            }
-        ]
-
-
-        self._patch_get_selected_repos = mock.patch(
-            "pkgmgr.cli_core.dispatch.get_selected_repos",
-            side_effect=_fake_selected_repos,
+        # Patch the "current directory" selection used by dispatch_command().
+        # This matches the new behaviour: without explicit identifiers,
+        # version uses _select_repo_for_current_directory(ctx).
+        self._patch_select_repo_for_current_directory = mock.patch(
+            "pkgmgr.cli_core.dispatch._select_repo_for_current_directory",
+            return_value=[self._fake_repo],
+        )
+        self.mock_select_repo_for_current_directory = (
+            self._patch_select_repo_for_current_directory.start()
         )
-        self.mock_get_selected_repos = self._patch_get_selected_repos.start()
 
         # Keep a reference to the original sys.argv, so we can restore it
         self._old_argv = list(sys.argv)
@@ -98,7 +98,7 @@ class TestCliVersion(unittest.TestCase):
         sys.argv = self._old_argv
 
         # Stop all patches
-        self._patch_get_selected_repos.stop()
+        self._patch_select_repo_for_current_directory.stop()
         self._patch_load_config.stop()
 
         # Restore working directory
@@ -224,7 +224,7 @@ class TestCliVersion(unittest.TestCase):
         # Arrange: pyproject.toml exists
         self._write_pyproject("0.0.1")
 
-        # Arrange: no tags returned (again: patch handle_version's get_tags)
+        # Arrange: no tags returned
         with mock.patch(
             "pkgmgr.cli_core.commands.version.get_tags",
             return_value=[],