Release version 0.10.1

- Extend PATH probing to include /home/nix/.nix-profile/bin/nix (container mode).
- Automatically invoke init-nix.sh when nix is not found before first run.
- Ensure pkgmgr always attempts a one-time Nix initialization instead of failing prematurely.
- Improve error message to clarify that nix was still missing *after* initialization attempt.
- Keep existing flake-based execution path unchanged (exec nix run …).

This makes the wrapper fully reliable across Debian/Ubuntu package installs,
fresh containers, and minimal systems where Nix is not yet initialized.

https://chatgpt.com/share/693b005d-b250-800f-8830-ab71685f51b3

.dockerignore

@@ -25,7 +25,5 @@ venv/
 .DS_Store
 Thumbs.db
 
-# Arch pkg artifacts
-*.pkg.tar.*
-*.log
-package-manager-*
+# Logs
+*.log

.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: CI
+
+on:
+  push:
+    branches-ignore:
+      - main
+  pull_request:
+
+jobs:
+  test-unit:
+    uses: ./.github/workflows/test-unit.yml
+
+  test-integration:
+    uses: ./.github/workflows/test-integration.yml
+
+  test-container:
+    uses: ./.github/workflows/test-container.yml
+
+  test-e2e:
+    uses: ./.github/workflows/test-e2e.yml
+
+  test-virgin-user:
+    uses: ./.github/workflows/test-virgin-user.yml
+
+  test-virgin-root:
+    uses: ./.github/workflows/test-virgin-root.yml

.github/workflows/mark-stable.yml

@@ -0,0 +1,64 @@
+name: Mark stable commit
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  test-unit:
+    uses: ./.github/workflows/test-unit.yml
+
+  test-integration:
+    uses: ./.github/workflows/test-integration.yml
+
+  test-container:
+    uses: ./.github/workflows/test-container.yml
+
+  test-e2e:
+    uses: ./.github/workflows/test-e2e.yml
+
+  test-virgin-user:
+    uses: ./.github/workflows/test-virgin-user.yml
+
+  test-virgin-root:
+    uses: ./.github/workflows/test-virgin-root.yml
+
+  mark-stable:
+    needs:
+      - test-unit
+      - test-integration
+      - test-container
+      - test-e2e
+      - test-virgin-user
+      - test-virgin-root
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: write  # to move the tag
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Move 'stable' tag to this commit
+        run: |
+          set -euo pipefail
+
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+          echo "Tagging commit $GITHUB_SHA as stable…"
+
+          # delete local tag if exists
+          git tag -d stable 2>/dev/null || true
+          # delete remote tag if exists
+          git push origin :refs/tags/stable || true
+
+          # create new tag on this commit
+          git tag stable "$GITHUB_SHA"
+          git push origin stable
+
+          echo "✅ Stable tag updated."

.github/workflows/test-container.yml

@@ -0,0 +1,28 @@
+name: Test OS Containers
+
+on:
+  workflow_call:
+
+jobs:
+  test-container:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        distro: [arch, debian, ubuntu, fedora, centos]
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Show commit SHA
+        run: git rev-parse HEAD
+
+      - name: Show Docker version
+        run: docker version
+
+      - name: Run container tests (${{ matrix.distro }})
+        run: |
+          set -euo pipefail
+          distro="${{ matrix.distro }}" make test-container

.github/workflows/test-e2e.yml

@@ -1,18 +1,16 @@
-name: Test package-manager (e2e)
+name: Test End-To-End
 
 on:
-  push:
-    branches:
-      - main
-      - master
-      - develop
-      - "*"
-  pull_request:
+  workflow_call:
 
 jobs:
   test-e2e:
     runs-on: ubuntu-latest
-    timeout-minutes: 60  # E2E + all distros can be heavier
+    timeout-minutes: 60  # E2E can be heavier
+    strategy:
+      fail-fast: false
+      matrix:
+        distro: [arch, debian, ubuntu, fedora, centos]
 
     steps:
       - name: Checkout repository
@@ -21,5 +19,7 @@ jobs:
       - name: Show Docker version
         run: docker version
 
-      - name: Run E2E tests via make (all distros)
-        run: make test-e2e
+      - name: Run E2E tests via make (${{ matrix.distro }})
+        run: |
+          set -euo pipefail
+          distro="${{ matrix.distro }}" make test-e2e

.github/workflows/test-integration.yml

@@ -1,13 +1,7 @@
-name: Test package-manager (integration)
+name: Test Code Integration
 
 on:
-  push:
-    branches:
-      - main
-      - master
-      - develop
-      - "*"
-  pull_request:
+  workflow_call:
 
 jobs:
   test-integration:
@@ -21,9 +15,5 @@ jobs:
       - name: Show Docker version
         run: docker version
 
-      # Build Arch test image (same as used in test-unit and test-e2e)
-      - name: Build test images
-        run: make build
-
       - name: Run integration tests via make (Arch container)
-        run: make test-integration
+        run: make test-integration distro="arch"

.github/workflows/test-unit.yml

@@ -1,13 +1,7 @@
-name: Test package-manager (unit)
+name: Test Units
 
 on:
-  push:
-    branches:
-      - main
-      - master
-      - develop
-      - "*"
-  pull_request:
+  workflow_call:
 
 jobs:
   test-unit:
@@ -22,4 +16,4 @@ jobs:
         run: docker version
 
       - name: Run unit tests via make (Arch container)
-        run: make test-unit
+        run: make test-unit distro="arch"

.github/workflows/test-virgin-root.yml

@@ -0,0 +1,58 @@
+name: Test Virgin Root
+
+on:
+  workflow_call:
+
+jobs:
+  test-virgin-root:
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Show Docker version
+        run: docker version
+
+      - name: Virgin Arch pkgmgr flake test (root)
+        run: |
+          set -euo pipefail
+
+          echo ">>> Starting virgin ArchLinux container test (root, with shared caches)..."
+
+          docker run --rm \
+            -v "$PWD":/src \
+            -v pkgmgr_repos:/root/Repositories \
+            -v pkgmgr_pip_cache:/root/.cache/pip \
+            -w /src \
+            archlinux:latest \
+            bash -lc '
+              set -euo pipefail
+
+              echo ">>> Updating and upgrading Arch system..."
+              pacman -Syu --noconfirm git python python-pip nix >/dev/null
+
+              echo ">>> Creating isolated virtual environment for pkgmgr..."
+              python -m venv /tmp/pkgmgr-venv
+
+              echo ">>> Activating virtual environment..."
+              source /tmp/pkgmgr-venv/bin/activate
+
+              echo ">>> Upgrading pip (cached)..."
+              python -m pip install --upgrade pip >/dev/null
+
+              echo ">>> Installing pkgmgr from current source tree (cached pip)..."
+              python -m pip install /src >/dev/null
+
+              echo ">>> Enabling Nix experimental features..."
+              export NIX_CONFIG="experimental-features = nix-command flakes"
+
+              echo ">>> Running: pkgmgr update pkgmgr --clone-mode shallow --no-verification"
+              pkgmgr update pkgmgr --clone-mode shallow --no-verification
+
+              echo ">>> Running: pkgmgr version pkgmgr"
+              pkgmgr version pkgmgr
+
+              echo ">>> Virgin Arch (root) test completed successfully."
+            '

.github/workflows/test-virgin-user.yml

@@ -0,0 +1,73 @@
+name: Test Virgin User
+
+on:
+  workflow_call:
+
+jobs:
+  test-virgin-user:
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Show Docker version
+        run: docker version
+
+      - name: Virgin Arch pkgmgr user test (non-root with sudo)
+        run: |
+          set -euo pipefail
+
+          echo ">>> Starting virgin ArchLinux container test (non-root user with sudo)..."
+
+          docker run --rm \
+            -v "$PWD":/src \
+            archlinux:latest \
+            bash -lc '
+              set -euo pipefail
+
+              echo ">>> [root] Updating and upgrading Arch system..."
+              pacman -Syu --noconfirm git python python-pip sudo base-devel debugedit
+
+              echo ">>> [root] Creating non-root user dev..."
+              useradd -m dev
+
+              echo ">>> [root] Allowing passwordless sudo for dev..."
+              echo "dev ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers.d/dev
+              chmod 0440 /etc/sudoers.d/dev
+
+              echo ">>> [root] Adjusting ownership of /src for dev..."
+              chown -R dev:dev /src
+
+              echo ">>> [root] Running pkgmgr flow as non-root user dev..."
+              sudo -u dev env PKGMGR_DISABLE_NIX_FLAKE_INSTALLER=1 bash -lc "
+                set -euo pipefail
+                cd /src
+
+                echo \">>> [dev] Using user: \$(whoami)\"
+                echo \">>> [dev] Running scripts/installation/main.sh...\"
+                bash scripts/installation/main.sh
+
+                echo \">>> [dev] Activating venv...\"
+                . \"\$HOME/.venvs/pkgmgr/bin/activate\"
+
+                echo \">>> [dev] Installing pkgmgr into venv via pip...\"
+                python -m pip install /src >/dev/null
+
+                echo \">>> [dev] PKGMGR_DISABLE_NIX_FLAKE_INSTALLER=\$PKGMGR_DISABLE_NIX_FLAKE_INSTALLER\"
+                echo \">>> [dev] Updating managed repo package-manager via pkgmgr...\"
+                pkgmgr update pkgmgr --clone-mode shallow --no-verification
+
+                echo \">>> [dev] PATH:\"
+                echo \"\$PATH\"
+
+                echo \">>> [dev] which pkgmgr:\"
+                which pkgmgr || echo \">>> [dev] pkgmgr not found in PATH\"
+
+                echo \">>> [dev] Running: pkgmgr version pkgmgr\"
+                pkgmgr version pkgmgr
+              "
+
+              echo ">>> [root] Container flow finished."
+            '

.gitignore

@@ -1,9 +1,6 @@
 
 # Prevents unwanted files from being committed to version control.
 
-# Custom Config file
-config/config.yaml
-
 # Python bytecode
 __pycache__/
 *.pyc
@@ -15,8 +12,9 @@ venv/
 
 # Build artifacts
 dist/
-build/
+build/*
 *.egg-info/
+package-manager-*
 
 # Editor files
 .vscode/
@@ -28,7 +26,9 @@ Thumbs.db
 
 # Nix Cache to speed up tests
 .nix/
+.nix-dev-installed
 
 # Ignore logs
 *.log
-package-manager-*
+
+result

CHANGELOG.md

@@ -1,3 +1,201 @@
+## [0.10.1] - 2025-12-11
+
+* Fixed Debian\Ubuntu to pass container e2e tests
+
+
+## [0.10.0] - 2025-12-11
+
+* **Changes since v0.9.1**
+
+**Mirror System**
+
+* Added SSH mirror support including multi-push and remote probing
+* Introduced mirror management commands and refactored the CLI parser into modules
+
+**CI/CD**
+
+* Migrated to reusable workflows with improved debugging instrumentation
+* Made stable-tag automation reliable for workflow_run events and permissions
+* Ensured deterministic test results by rebuilding all test containers with no-cache
+
+**E2E and Container Tests**
+
+* Fixed Git safe.directory handling across all containers
+* Restored Dockerfile ENTRYPOINT to resolve Nix TLS issues
+* Fixed missing volume errors and hardened the E2E runner
+* Added full Nix flake E2E test matrix across all distro containers
+* Disabled Nix sandboxing for cross-distro builds where required
+
+**Nix and Python Environment**
+
+* Unified Nix Python environment and introduced lazy CLI imports
+* Ensured PyYAML availability and improved Python 3.13 compatibility
+* Refactored flake.nix to remove side effects and rely on generic python3
+
+**Packaging**
+
+* Removed Debian’s hard dependency on Nix
+* Restructured packaging layout and refined build paths
+* Excluded assets from Arch PKGBUILD rsync
+* Cleaned up obsolete ignore files
+
+**Repository Layout**
+
+* Restructured repository to align local, Nix-based, and distro-based build workflows
+* Added Arch support and refined build/purge scripts
+
+
+## [0.9.1] - 2025-12-10
+
+* * Refactored installer: new `venv-create.sh`, cleaner root/user setup flow, updated README with architecture map.
+* Split virgin tests into root/user workflows; stabilized Nix installer across distros; improved test scripts with dynamic distro selection and isolated Nix stores.
+* Fixed repository directory resolution; improved `pkgmgr path` and `pkgmgr shell`; added full unit/E2E coverage.
+* Removed deprecated files and updated `.gitignore`.
+
+
+## [0.9.0] - 2025-12-10
+
+* Introduce a virgin Arch-based Nix flake E2E workflow that validates pkgmgr’s full flake installation path using shared caches for faster and reproducible CI runs.
+
+
+## [0.8.0] - 2025-12-10
+
+* **v0.7.15 — Installer & Command Resolution Improvements**
+
+* Introduced a unified **layer-based installer pipeline** with clear precedence (OS-packages, Nix, Python, Makefile).
+* Reworked installer structure and improved Python/Nix/Makefile installers, including isolated Python venvs and refined flake-output handling.
+* Fully rewrote **command resolution** with stronger typing, safer fallbacks, and explicit support for `command: null` to mark library-only repositories.
+* Added extensive **unit and integration tests** for installer capability ordering, command resolution, and Nix/Python installer behavior.
+* Expanded documentation with capability hierarchy diagrams and scenario matrices.
+* Removed deprecated repository entries and obsolete configuration files.
+
+
+## [0.7.14] - 2025-12-10
+
+* Fixed the clone-all integration test so that `SystemExit(0)` from the proxy is treated as a successful command instead of a failure.
+
+
+## [0.7.13] - 2025-12-10
+
+### Fix tools path resolution and add tests
+
+- Fixed a crash in `pkgmgr code` caused by missing `directory` metadata by introducing `_resolve_repository_path()` with proper fallbacks to `repositories_base_dir` / `repositories_dir`.
+- Updated `explore`, `terminal` and `code` tool commands to use the new resolver.
+- Improved VS Code workspace generation and path handling.
+- Added unit & E2E tests for tool commands.
+
+
+## [0.7.12] - 2025-12-09
+
+* Fixed self refering alias during setup
+
+
+## [0.7.11] - 2025-12-09
+
+* test: fix installer unit tests for OS packages and Nix dev shell
+
+
+## [0.7.10] - 2025-12-09
+
+* Fixed test_install_pkgmgr_shallow.py
+
+
+## [0.7.9] - 2025-12-09
+
+* 'main' and 'master' are now both accepted as branches for branch close merge
+
+
+## [0.7.8] - 2025-12-09
+
+* Missing pyproject.toml doesn't lead to an error during release
+
+
+## [0.7.7] - 2025-12-09
+
+* Added TEST_PATTERN parameter to execute dedicated tests
+
+
+## [0.7.6] - 2025-12-09
+
+* Fixed pull --preview bug in e2e test
+
+
+## [0.7.5] - 2025-12-09
+
+* Fixed wrong directory permissions for nix
+
+
+## [0.7.4] - 2025-12-09
+
+* Fixed missing build in test workflow -> Tests pass now
+
+
+## [0.7.3] - 2025-12-09
+
+* Fixed bug: Ignored packages are now ignored
+
+
+## [0.7.2] - 2025-12-09
+
+* Implemented Changelog Support for Fedora and Debian
+
+
+## [0.7.1] - 2025-12-09
+
+* Fix floating 'latest' tag logic: dereference annotated target (vX.Y.Z^{}), add tag message to avoid Git errors, ensure best-effort update without blocking releases, and update unit tests (see ChatGPT conversation: https://chatgpt.com/share/69383024-efa4-800f-a875-129b81fa40ff).
+
+
+## [0.7.0] - 2025-12-09
+
+* Add Git helpers for branch sync and floating 'latest' tag in the release workflow, ensure main/master are updated from origin before tagging, and extend unit/e2e tests including 'pkgmgr release --help' coverage (see ChatGPT conversation: https://chatgpt.com/share/69383024-efa4-800f-a875-129b81fa40ff)
+
+
+## [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)
+
+
+## [0.4.2] - 2025-12-09
+
+* Wire pkgmgr release CLI to new helper and add unit tests (see ChatGPT conversation: https://chatgpt.com/share/69374f09-c760-800f-92e4-5b44a4510b62)
+
+
+## [0.4.1] - 2025-12-08
+
+* Add branch close subcommand and integrate release close/editor flow (ChatGPT: https://chatgpt.com/share/69374f09-c760-800f-92e4-5b44a4510b62)
+
+
+## [0.4.0] - 2025-12-08
+
+* Add branch closing helper and --close flag to release command, including CLI wiring and tests (see https://chatgpt.com/share/69374aec-74ec-800f-bde3-5d91dfdb9b91)
+
+## [0.3.0] - 2025-12-08
+
+* Massive refactor and feature expansion:
+- Complete rewrite of config loading system (layered defaults + user config)
+- New selection engine (--string, --category, --tag)
+- Overhauled list output (colored statuses, alias highlight)
+- New config update logic + default YAML sync
+- Improved proxy command handling
+- Full CLI routing refactor
+- Expanded E2E tests for list, proxy, and selection logic
+Konversation: https://chatgpt.com/share/693745c3-b8d8-800f-aa29-c8481a2ffae1
+
 ## [0.2.0] - 2025-12-08
 
 * Add preview-first release workflow and extended packaging support (see ChatGPT conversation: https://chatgpt.com/share/693722b4-af9c-800f-bccc-8a4036e99630)

Dockerfile

@@ -1,89 +1,11 @@
 # ------------------------------------------------------------
 # Base image selector — overridden by Makefile
 # ------------------------------------------------------------
-ARG BASE_IMAGE=archlinux:latest
+ARG BASE_IMAGE
 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
+RUN echo "BASE_IMAGE=${BASE_IMAGE}" && \
+    cat /etc/os-release || true
 
 # ------------------------------------------------------------
 # Nix environment defaults
@@ -96,94 +18,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 +57,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"]

MIRRORS

@@ -0,0 +1,3 @@
+git@github.com:kevinveenbirkenbach/package-manager.git
+ssh://git@git.veen.world:2201/kevinveenbirkenbach/pkgmgr.git
+ssh://git@code.cymais.cloud:2201/kevinveenbirkenbach/pkgmgr.git

Makefile

@@ -1,275 +1,87 @@
-.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
+
+# Distro
+# Options: arch debian ubuntu fedora centos
+distro ?= arch
+export distro
 
 # ------------------------------------------------------------
-# Local Nix cache directories in the repo
+# Base images
+# (kept for documentation/reference; actual build logic is in scripts/build)
 # ------------------------------------------------------------
-NIX_STORE_VOLUME := pkgmgr_nix_store
-NIX_CACHE_VOLUME := pkgmgr_nix_cache
+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
+
+# Make them available in scripts
+export BASE_IMAGE_ARCH  
+export BASE_IMAGE_DEBIAN
+export BASE_IMAGE_UBUNTU
+export BASE_IMAGE_FEDORA
+export BASE_IMAGE_CENTOS
+
+# PYthon Unittest Pattern
+TEST_PATTERN	:= test_*.py
+export TEST_PATTERN
 
 # ------------------------------------------------------------
-# Distro list and base images
+# PKGMGR setup (developer wrapper -> scripts/installation/main.sh)
 # ------------------------------------------------------------
-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
-
-# 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
+setup:
+	@bash scripts/installation/main.sh
 
 # ------------------------------------------------------------
-# PKGMGR setup (wrapper)
-# ------------------------------------------------------------
-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
-
-# ------------------------------------------------------------
-# 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: build-missing
+	@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: build-missing
+	@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: build-missing
+	@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
-
-# Combined test target for local + CI (unit + e2e + integration)
-test: build test-unit test-e2e test-integration
+test-container: build-missing
+	@bash scripts/test/test-container.sh
 
 # ------------------------------------------------------------
-# Installer for host systems (original logic)
+# Build only missing container images
+# ------------------------------------------------------------
+build-missing:
+	@bash scripts/build/build-image-missing.sh
+
+# Combined test target for local + CI (unit + integration + e2e)
+test: test-container test-unit test-integration test-e2e
+
+delete-volumes: 
+	@docker volume rm pkgmgr_nix_store_${distro} pkgmgr_nix_cache_${distro} || true
+
+purge: delete-volumes build-no-cache
+
+# ------------------------------------------------------------
+# 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

README.md

@@ -24,6 +24,15 @@
 - **Custom Aliases:**  
   Generate and manage custom aliases for easy command invocation.
 
+## Architecture & Setup Map 🗺️
+
+The following diagram provides a full overview of PKGMGR’s package structure,
+installation layers, and setup controller flow:
+
+![PKGMGR Architecture](assets/map.png)
+
+**Diagram status:** *Stand: 11. Dezember 2025*  
+**Always-up-to-date version:** https://s.veen.world/pkgmgrmp
 
 ## Installation ⚙️
 
@@ -51,55 +60,6 @@ The `make setup` command will:
 - Install required packages from `requirements.txt`.
 - Execute `python main.py install` to complete the installation.
 
-## Docker Quickstart 🐳
-
-Alternatively to installing locally, you can use Docker: build the image with
-
-```bash
-docker build --no-cache -t pkgmgr .
-```
-
-or alternativ pull it via
-
-```bash
-docker pull kevinveenbirkenbach/pkgmgr:latest
-```
-
-and then run
-
-```bash
-docker run --rm pkgmgr --help
-```
-
-## Usage 📖
-
-Run the script with different commands. For example:
-
-- **Install all packages:**
-  ```bash
-  pkgmgr install --all
-  ```
-- **Pull updates for a specific repository:**
-  ```bash
-  pkgmgr pull pkgmgr
-  ```
-- **Commit changes with extra Git parameters:**
-  ```bash
-  pkgmgr commit pkgmgr -- -m "Your commit message"
-  ```
-- **List all configured packages:**
-  ```bash
-  pkgmgr config show
-  ```
-- **Manage configuration:**
-  ```bash
-  pkgmgr config init
-  pkgmgr config add
-  pkgmgr config edit
-  pkgmgr config delete <identifier>
-  pkgmgr config ignore <identifier> --set true
-  ```
-
 ## License 📄
 
 This project is licensed under the MIT License.
@@ -108,9 +68,3 @@ This project is licensed under the MIT License.
 
 Kevin Veen-Birkenbach  
 [https://www.veen.world](https://www.veen.world)
-
----
-
-**Repository:** [github.com/kevinveenbirkenbach/package-manager](https://github.com/kevinveenbirkenbach/package-manager)
-
-*Created with AI 🤖 - [View conversation](https://chatgpt.com/share/67c728c4-92d0-800f-8945-003fa9bf27c6)*

TODO.md

@@ -0,0 +1,6 @@
+# to-dos
+
+For the following checkout the implementation map:
+
+- Implement TAGS
+- Implement SIGNING_KEY

config/defaults.yaml

@@ -380,17 +380,6 @@ repositories:
       - 44D8F11FD62F878E
       - B5690EEEBB952194
 
-- account: kevinveenbirkenbach
-  alias: infinito-presentation
-  description: This repository contains a Infinito.Nexus presentation designed for customers, end-users, investors, developers, and administrators, offering tailored content and insights for each group.
-  homepage: https://github.com/kevinveenbirkenbach/infinito-presentation
-  provider: github.com
-  repository: infinito-presentation
-  verified:
-    gpg_keys:
-      - 44D8F11FD62F878E
-      - B5690EEEBB952194
-
 - account: kevinveenbirkenbach
   description: A lightweight Python utility to generate dynamic color schemes from a single base color. Provides HSL-based color transformations for theming, UI design, and CSS variable generation. Optimized for integration in Python projects, Flask applications, and Ansible roles.
   homepage: https://github.com/kevinveenbirkenbach/colorscheme-generator
@@ -599,17 +588,6 @@ repositories:
       - 44D8F11FD62F878E
       - B5690EEEBB952194
 
-- account: kevinveenbirkenbach
-  desciption: Infinito Inventory Builder — a containerized web application that dynamically generates Ansible inventory files from invokable Infinito.Nexus roles through an interactive, browser-based interface.
-  homepage: https://github.com/kevinveenbirkenbach/infinito-inventory-builder
-  alias: invbuild
-  provider: github.com
-  repository: infinito-inventory-builder
-  verified:
-    gpg_keys:
-      - 44D8F11FD62F878E
-      - B5690EEEBB952194
-
 - account: kevinveenbirkenbach
   desciption: A simple Python CLI tool to safely rename Linux user accounts using usermod — including home directory migration and validation checks.
   homepage: https://github.com/kevinveenbirkenbach/user-rename

debian/changelog

@@ -1,23 +0,0 @@
-package-manager (0.2.0-1) unstable; urgency=medium
-
-  * Add preview-first release workflow and extended packaging support (see ChatGPT conversation: https://chatgpt.com/share/693722b4-af9c-800f-bccc-8a4036e99630)
-
- -- Kevin Veen-Birkenbach <kevin@veen.world>  Mon, 08 Dec 2025 20:31:19 +0100
-
-package-manager (0.1.0-1) unstable; urgency=medium
-
-  * Updated to correct version
-
- -- Kevin Veen-Birkenbach <kevin@veen.world>  Mon, 08 Dec 2025 20:24:49 +0100
-
-package-manager (0.1.0-1) unstable; urgency=medium
-
-  * Implement unified release helper with preview mode, multi-packaging version bumps, and new integration/unit tests (see ChatGPT conversation 2025-12-08: https://chatgpt.com/share/693722b4-af9c-800f-bccc-8a4036e99630)
-
- -- Kevin Veen-Birkenbach <kevin@veen.world>  Mon, 08 Dec 2025 20:15:13 +0100
-
-package-manager (0.1.1-1) unstable; urgency=medium
-
-  * Initial release.
-
- -- Kevin Veen-Birkenbach <info@veen.world>  Sat, 06 Dec 2025 16:30:00 +0100

flake.lock

@@ -0,0 +1,27 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1765186076,
+        "narHash": "sha256-hM20uyap1a0M9d344I692r+ik4gTMyj60cQWO+hAYP8=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "addf7cf5f383a3101ecfba091b98d0a1263dc9b8",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -26,12 +26,17 @@
       packages = forAllSystems (system:
         let
           pkgs = nixpkgs.legacyPackages.${system};
+
+          # Single source of truth for pkgmgr: Python 3.11
+          # - Matches pyproject.toml: requires-python = ">=3.11"
+          # - Uses python311Packages so that PyYAML etc. are available
+          python = pkgs.python311;
           pyPkgs = pkgs.python311Packages;
         in
         rec {
           pkgmgr = pyPkgs.buildPythonApplication {
             pname   = "package-manager";
-            version = "0.2.0";
+            version = "0.10.1";
 
             # Use the git repo as source
             src = ./.;
@@ -45,18 +50,17 @@
               pyPkgs.wheel
             ];
 
-            # Runtime dependencies (matches [project.dependencies])
+            # Runtime dependencies (matches [project.dependencies] in pyproject.toml)
             propagatedBuildInputs = [
               pyPkgs.pyyaml
-              # Add more here if needed, e.g.:
-              # pyPkgs.click
-              # pyPkgs.rich
+              pyPkgs.pip
             ];
 
             doCheck = false;
 
             pythonImportsCheck = [ "pkgmgr" ];
           };
+
           default = pkgmgr;
         }
       );
@@ -67,23 +71,42 @@
       devShells = forAllSystems (system:
         let
           pkgs = nixpkgs.legacyPackages.${system};
-          pkgmgrPkg = self.packages.${system}.pkgmgr;
 
           ansiblePkg =
             if pkgs ? ansible-core then pkgs.ansible-core
             else pkgs.ansible;
+
+          # Use the same Python version as the package (3.11)
+          python = pkgs.python311;
+
+          pythonWithDeps = python.withPackages (ps: [
+            ps.pip
+            ps.pyyaml
+          ]);
         in
         {
           default = pkgs.mkShell {
             buildInputs = [
-              pkgmgrPkg
+              pythonWithDeps
               pkgs.git
               ansiblePkg
             ];
 
             shellHook = ''
+              # Ensure our Python with dependencies is preferred on PATH
+              export PATH=${pythonWithDeps}/bin:$PATH
+
+              # Ensure src/ layout is importable:
+              #   pkgmgr lives in ./src/pkgmgr
+              export PYTHONPATH="$PWD/src:${PYTHONPATH:-}"
+              # Also add repo root in case tools/tests rely on it
+              export PYTHONPATH="$PWD:$PYTHONPATH"
+
               echo "Entered pkgmgr development shell for ${system}"
-              echo "pkgmgr CLI is available via the flake build"
+              echo "Python used in this shell:"
+              python --version
+              echo "pkgmgr CLI (from source) is available via:"
+              echo "  python -m pkgmgr.cli --help"
             '';
           };
         }

main.py

@@ -1,6 +1,14 @@
 #!/usr/bin/env python3
+import sys
+from pathlib import Path
+
+# Ensure local src/ overrides installed package
+ROOT = Path(__file__).resolve().parent
+SRC = ROOT / "src"
+if SRC.is_dir():
+    sys.path.insert(0, str(SRC))
 
 from pkgmgr.cli import main
 
 if __name__ == "__main__":
-    main()
+    main()

package-manager.spec

@@ -1,80 +0,0 @@
-Name:           package-manager
-Version:        0.2.0
-Release:        1%{?dist}
-Summary:        Wrapper that runs Kevin's package-manager via Nix flake
-
-License:        MIT
-URL:            https://github.com/kevinveenbirkenbach/package-manager
-Source0:        %{name}-%{version}.tar.gz
-
-BuildArch:      noarch
-
-# NOTE:
-# Nix is a runtime requirement, but it is *not* declared here as a hard
-# RPM dependency, because many distributions do not ship a "nix" RPM.
-# Instead, Nix is installed and initialized by init-nix.sh, which is
-# called in the %post scriptlet below.
-
-%description
-This package provides the `pkgmgr` command, which runs Kevin's package
-manager via a local Nix flake:
-
-  nix run /usr/lib/package-manager#pkgmgr -- ...
-
-Nix is a runtime requirement and is installed/initialized by the
-init-nix.sh helper during package installation if it is not yet
-available on the system.
-
-%prep
-%setup -q
-
-%build
-# No build step required; we ship the project tree as-is.
-:
-
-%install
-rm -rf %{buildroot}
-install -d %{buildroot}%{_bindir}
-install -d %{buildroot}%{_libdir}/package-manager
-
-# Copy full project source into /usr/lib/package-manager
-cp -a . %{buildroot}%{_libdir}/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
-
-# 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
-
-%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
-else
-    echo ">>> Warning: %{_libdir}/package-manager/init-nix.sh not found or not executable."
-fi
-
-%postun
-echo ">>> package-manager removed. Nix itself was not removed."
-
-%files
-%doc README.md
-%license LICENSE
-%{_bindir}/pkgmgr
-%{_libdir}/package-manager/
-
-%changelog
-* Sat Dec 06 2025 Kevin Veen-Birkenbach <info@veen.world> - 0.1.1-1
-- Initial RPM packaging for package-manager

packaging/arch/.gitignore

@@ -0,0 +1,6 @@
+# Arch pkg artifacts
+*.pkg.tar.*
+*.log
+package-manager-*
+src/
+pkg/

packaging/arch/PKGBUILD

@@ -1,7 +1,7 @@
 # Maintainer: Kevin Veen-Birkenbach <info@veen.world>
 
 pkgname=package-manager
-pkgver=0.2.0
+pkgver=0.9.1
 pkgrel=1
 pkgdesc="Local-flake wrapper for Kevin's package-manager (Nix-based)."
 arch=('any')
@@ -15,7 +15,7 @@ makedepends=('rsync')
 install=${pkgname}.install
 
 # Local source checkout — avoids the tarball requirement.
-# This assumes you build the package from inside the main project repository.
+# We build from the project root (two levels above packaging/arch/).
 source=()
 sha256sums=()
 
@@ -24,12 +24,18 @@ _srcdir_name="source"
 
 prepare() {
   mkdir -p "$srcdir/$_srcdir_name"
+
+  local project_root
+  project_root="$(cd "$startdir/../.." && pwd)"
+
   rsync -a \
     --exclude=".git" \
     --exclude=".github" \
     --exclude="pkg" \
     --exclude="srcpkg" \
-    "$startdir/" "$srcdir/$_srcdir_name/"
+    --exclude="packaging" \
+    --exclude="assets" \
+    "$project_root/" "$srcdir/$_srcdir_name/"
 }
 
 build() {
@@ -62,7 +68,8 @@ package() {
     "$pkgdir/usr/lib/package-manager/PKGBUILD" \
     "$pkgdir/usr/lib/package-manager/Dockerfile" \
     "$pkgdir/usr/lib/package-manager/debian" \
+    "$pkgdir/usr/lib/package-manager/packaging" \
     "$pkgdir/usr/lib/package-manager/.gitignore" \
     "$pkgdir/usr/lib/package-manager/__pycache__" \
-    "$pkgdir/usr/lib/package-manager/.gitkeep"
+    "$pkgdir/usr/lib/package-manager/.gitkeep" || true
 }

packaging/debian/.gitignore

@@ -0,0 +1,6 @@
+# debian 
+package-manager/
+debhelper-build-stamp
+files
+.debhelper/
+package-manager.substvars

packaging/debian/changelog

@@ -0,0 +1,197 @@
+package-manager (0.9.1-1) unstable; urgency=medium
+
+  * * Refactored installer: new `venv-create.sh`, cleaner root/user setup flow, updated README with architecture map.
+* Split virgin tests into root/user workflows; stabilized Nix installer across distros; improved test scripts with dynamic distro selection and isolated Nix stores.
+* Fixed repository directory resolution; improved `pkgmgr path` and `pkgmgr shell`; added full unit/E2E coverage.
+* Removed deprecated files and updated `.gitignore`.
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Wed, 10 Dec 2025 22:56:01 +0100
+
+package-manager (0.9.0-1) unstable; urgency=medium
+
+  * Introduce a virgin Arch-based Nix flake E2E workflow that validates pkgmgr’s full flake installation path using shared caches for faster and reproducible CI runs.
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Wed, 10 Dec 2025 18:38:07 +0100
+
+package-manager (0.8.0-1) unstable; urgency=medium
+
+  * **v0.7.15 — Installer & Command Resolution Improvements**
+
+* Introduced a unified **layer-based installer pipeline** with clear precedence (OS-packages, Nix, Python, Makefile).
+* Reworked installer structure and improved Python/Nix/Makefile installers, including isolated Python venvs and refined flake-output handling.
+* Fully rewrote **command resolution** with stronger typing, safer fallbacks, and explicit support for `command: null` to mark library-only repositories.
+* Added extensive **unit and integration tests** for installer capability ordering, command resolution, and Nix/Python installer behavior.
+* Expanded documentation with capability hierarchy diagrams and scenario matrices.
+* Removed deprecated repository entries and obsolete configuration files.
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Wed, 10 Dec 2025 17:31:57 +0100
+
+package-manager (0.7.14-1) unstable; urgency=medium
+
+  * Fixed the clone-all integration test so that `SystemExit(0)` from the proxy is treated as a successful command instead of a failure.
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Wed, 10 Dec 2025 10:38:33 +0100
+
+package-manager (0.7.13-1) unstable; urgency=medium
+
+  * Automated release.
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Wed, 10 Dec 2025 10:27:24 +0100
+
+package-manager (0.7.12-1) unstable; urgency=medium
+
+  * Fixed self refering alias during setup
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Tue, 09 Dec 2025 23:36:35 +0100
+
+package-manager (0.7.11-1) unstable; urgency=medium
+
+  * test: fix installer unit tests for OS packages and Nix dev shell
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Tue, 09 Dec 2025 23:16:46 +0100
+
+package-manager (0.7.10-1) unstable; urgency=medium
+
+  * Fixed test_install_pkgmgr_shallow.py
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Tue, 09 Dec 2025 22:57:08 +0100
+
+package-manager (0.7.9-1) unstable; urgency=medium
+
+  * 'main' and 'master' are now both accepted as branches for branch close merge
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Tue, 09 Dec 2025 21:19:13 +0100
+
+package-manager (0.7.8-1) unstable; urgency=medium
+
+  * Missing pyproject.toml doesn't lead to an error during release
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Tue, 09 Dec 2025 21:03:24 +0100
+
+package-manager (0.7.7-1) unstable; urgency=medium
+
+  * Added TEST_PATTERN parameter to execute dedicated tests
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Tue, 09 Dec 2025 17:54:38 +0100
+
+package-manager (0.7.6-1) unstable; urgency=medium
+
+  * Fixed pull --preview bug in e2e test
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Tue, 09 Dec 2025 17:14:19 +0100
+
+package-manager (0.7.5-1) unstable; urgency=medium
+
+  * Fixed wrong directory permissions for nix
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Tue, 09 Dec 2025 16:45:42 +0100
+
+package-manager (0.7.4-1) unstable; urgency=medium
+
+  * Fixed missing build in test workflow -> Tests pass now
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Tue, 09 Dec 2025 16:22:00 +0100
+
+package-manager (0.7.3-1) unstable; urgency=medium
+
+  * Fixed bug: Ignored packages are now ignored
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Tue, 09 Dec 2025 16:08:31 +0100
+
+package-manager (0.7.2-1) unstable; urgency=medium
+
+  * Implemented Changelog Support for Fedora and Debian
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Tue, 09 Dec 2025 15:48:58 +0100
+
+package-manager (0.7.1-1) unstable; urgency=medium
+
+  * Fix floating 'latest' tag logic: dereference annotated target (vX.Y.Z^{}), add tag message to avoid Git errors, ensure best-effort update without blocking releases, and update unit tests (see ChatGPT conversation: https://chatgpt.com/share/69383024-efa4-800f-a875-129b81fa40ff).
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Tue, 09 Dec 2025 15:26:54 +0100
+
+package-manager (0.7.0-1) unstable; urgency=medium
+
+  * Add Git helpers for branch sync and floating 'latest' tag in the release workflow, ensure main/master are updated from origin before tagging, and extend unit/e2e tests including 'pkgmgr release --help' coverage (see ChatGPT conversation: https://chatgpt.com/share/69383024-efa4-800f-a875-129b81fa40ff)
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Tue, 09 Dec 2025 15:21:03 +0100
+
+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)
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Tue, 09 Dec 2025 00:29:08 +0100
+
+package-manager (0.4.2-1) unstable; urgency=medium
+
+  * Wire pkgmgr release CLI to new helper and add unit tests (see ChatGPT conversation: https://chatgpt.com/share/69374f09-c760-800f-92e4-5b44a4510b62)
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Tue, 09 Dec 2025 00:03:46 +0100
+
+package-manager (0.4.1-1) unstable; urgency=medium
+
+  * Add branch close subcommand and integrate release close/editor flow (ChatGPT: https://chatgpt.com/share/69374f09-c760-800f-92e4-5b44a4510b62)
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Mon, 08 Dec 2025 23:20:28 +0100
+
+package-manager (0.4.0-1) unstable; urgency=medium
+
+  * Add branch closing helper and --close flag to release command, including CLI wiring and tests (see https://chatgpt.com/share/69374aec-74ec-800f-bde3-5d91dfdb9b91)
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Mon, 08 Dec 2025 23:02:43 +0100
+
+package-manager (0.3.0-1) unstable; urgency=medium
+
+  * Massive refactor and feature expansion:
+- Complete rewrite of config loading system (layered defaults + user config)
+- New selection engine (--string, --category, --tag)
+- Overhauled list output (colored statuses, alias highlight)
+- New config update logic + default YAML sync
+- Improved proxy command handling
+- Full CLI routing refactor
+- Expanded E2E tests for list, proxy, and selection logic
+Konversation: https://chatgpt.com/share/693745c3-b8d8-800f-aa29-c8481a2ffae1
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Mon, 08 Dec 2025 22:40:49 +0100
+
+package-manager (0.2.0-1) unstable; urgency=medium
+
+  * Add preview-first release workflow and extended packaging support (see ChatGPT conversation: https://chatgpt.com/share/693722b4-af9c-800f-bccc-8a4036e99630)
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Mon, 08 Dec 2025 20:31:19 +0100
+
+package-manager (0.1.0-1) unstable; urgency=medium
+
+  * Updated to correct version
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Mon, 08 Dec 2025 20:24:49 +0100
+
+package-manager (0.1.0-1) unstable; urgency=medium
+
+  * Implement unified release helper with preview mode, multi-packaging version bumps, and new integration/unit tests (see ChatGPT conversation 2025-12-08: https://chatgpt.com/share/693722b4-af9c-800f-bccc-8a4036e99630)
+
+ -- Kevin Veen-Birkenbach <kevin@veen.world>  Mon, 08 Dec 2025 20:15:13 +0100
+
+package-manager (0.1.1-1) unstable; urgency=medium
+
+  * Initial release.
+
+ -- Kevin Veen-Birkenbach <info@veen.world>  Sat, 06 Dec 2025 16:30:00 +0100

packaging/debian/control

@@ -9,7 +9,7 @@ Homepage: https://github.com/kevinveenbirkenbach/package-manager
 
 Package: package-manager
 Architecture: any
-Depends: nix, ${misc:Depends}
+Depends: ${misc:Depends}
 Description: Wrapper that runs Kevin's package-manager via Nix flake
  This package provides the `pkgmgr` command, which runs Kevin's package
  manager via a local Nix flake

packaging/fedora/package-manager.spec

@@ -0,0 +1,139 @@
+Name:           package-manager
+Version:        0.9.1
+Release:        1%{?dist}
+Summary:        Wrapper that runs Kevin's package-manager via Nix flake
+
+License:        MIT
+URL:            https://github.com/kevinveenbirkenbach/package-manager
+Source0:        %{name}-%{version}.tar.gz
+
+BuildArch:      noarch
+
+# NOTE:
+# Nix is a runtime requirement, but it is *not* declared here as a hard
+# RPM dependency, because many distributions do not ship a "nix" RPM.
+# Instead, Nix is installed and initialized by init-nix.sh, which is
+# called in the %post scriptlet below.
+
+%description
+This package provides the `pkgmgr` command, which runs Kevin's package
+manager via a local Nix flake:
+
+  nix run /usr/lib/package-manager#pkgmgr -- ...
+
+Nix is a runtime requirement and is installed/initialized by the
+init-nix.sh helper during package installation if it is not yet
+available on the system.
+
+%prep
+%setup -q
+
+%build
+# No build step required; we ship the project tree as-is.
+:
+
+%install
+rm -rf %{buildroot}
+install -d %{buildroot}%{_bindir}
+# 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}/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}/usr/lib/package-manager/init-nix.sh
+
+# Remove packaging-only and development artefacts from the installed tree
+rm -rf \
+  %{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 /usr/lib/package-manager/init-nix.sh ]; then
+    /usr/lib/package-manager/init-nix.sh || true
+else
+    echo ">>> Warning: /usr/lib/package-manager/init-nix.sh not found or not executable."
+fi
+
+%postun
+echo ">>> package-manager removed. Nix itself was not removed."
+
+%files
+%doc README.md
+%license LICENSE
+%{_bindir}/pkgmgr
+/usr/lib/package-manager/
+
+%changelog
+* Wed Dec 10 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 0.9.1-1
+- * Refactored installer: new `venv-create.sh`, cleaner root/user setup flow, updated README with architecture map.
+* Split virgin tests into root/user workflows; stabilized Nix installer across distros; improved test scripts with dynamic distro selection and isolated Nix stores.
+* Fixed repository directory resolution; improved `pkgmgr path` and `pkgmgr shell`; added full unit/E2E coverage.
+* Removed deprecated files and updated `.gitignore`.
+
+* Wed Dec 10 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 0.9.0-1
+- Introduce a virgin Arch-based Nix flake E2E workflow that validates pkgmgr’s full flake installation path using shared caches for faster and reproducible CI runs.
+
+* Wed Dec 10 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 0.8.0-1
+- **v0.7.15 — Installer & Command Resolution Improvements**
+
+* Introduced a unified **layer-based installer pipeline** with clear precedence (OS-packages, Nix, Python, Makefile).
+* Reworked installer structure and improved Python/Nix/Makefile installers, including isolated Python venvs and refined flake-output handling.
+* Fully rewrote **command resolution** with stronger typing, safer fallbacks, and explicit support for `command: null` to mark library-only repositories.
+* Added extensive **unit and integration tests** for installer capability ordering, command resolution, and Nix/Python installer behavior.
+* Expanded documentation with capability hierarchy diagrams and scenario matrices.
+* Removed deprecated repository entries and obsolete configuration files.
+
+* Wed Dec 10 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 0.7.14-1
+- Fixed the clone-all integration test so that `SystemExit(0)` from the proxy is treated as a successful command instead of a failure.
+
+* Wed Dec 10 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 0.7.13-1
+- Automated release.
+
+* Tue Dec 09 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 0.7.12-1
+- Fixed self refering alias during setup
+
+* Tue Dec 09 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 0.7.11-1
+- test: fix installer unit tests for OS packages and Nix dev shell
+
+* Tue Dec 09 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 0.7.10-1
+- Fixed test_install_pkgmgr_shallow.py
+
+* Tue Dec 09 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 0.7.9-1
+- 'main' and 'master' are now both accepted as branches for branch close merge
+
+* Tue Dec 09 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 0.7.8-1
+- Missing pyproject.toml doesn't lead to an error during release
+
+* Tue Dec 09 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 0.7.7-1
+- Added TEST_PATTERN parameter to execute dedicated tests
+
+* Tue Dec 09 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 0.7.6-1
+- Fixed pull --preview bug in e2e test
+
+* Tue Dec 09 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 0.7.5-1
+- Fixed wrong directory permissions for nix
+
+* Tue Dec 09 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 0.7.4-1
+- Fixed missing build in test workflow -> Tests pass now
+
+* Tue Dec 09 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 0.7.3-1
+- Fixed bug: Ignored packages are now ignored
+
+* Tue Dec 09 2025 Kevin Veen-Birkenbach <kevin@veen.world> - 0.7.2-1
+- Implemented Changelog Support for Fedora and Debian
+
+* Sat Dec 06 2025 Kevin Veen-Birkenbach <info@veen.world> - 0.1.1-1
+- Initial RPM packaging for package-manager

pkgmgr.yml

@@ -1,7 +0,0 @@
-version: 1
-
-author: "Kevin Veen-Birkenbach"
-url: "https://github.com/kevinveenbirkenbach/package-manager"
-description: "A configurable Python-based package manager for managing multiple repositories via Bash."
-
-dependencies: []

pkgmgr/branch_commands.py

@@ -1,80 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-High-level helpers for branch-related operations.
-
-This module encapsulates the actual Git logic so the CLI layer
-(pkgmgr.cli_core.commands.branch) stays thin and testable.
-"""
-
-from __future__ import annotations
-
-from typing import Optional
-
-from pkgmgr.git_utils import run_git, GitError
-
-
-def open_branch(
-    name: Optional[str],
-    base_branch: str = "main",
-    cwd: str = ".",
-) -> None:
-    """
-    Create and push a new feature branch on top of `base_branch`.
-
-    Steps:
-      1) git fetch origin
-      2) git checkout <base_branch>
-      3) git pull origin <base_branch>
-      4) git checkout -b <name>
-      5) git push -u origin <name>
-
-    If `name` is None or empty, the user is prompted on stdin.
-    """
-
-    if not name:
-        name = input("Enter new branch name: ").strip()
-
-    if not name:
-        raise RuntimeError("Branch name must not be empty.")
-
-    # 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
-
-    # 2) Checkout base branch
-    try:
-        run_git(["checkout", base_branch], cwd=cwd)
-    except GitError as exc:
-        raise RuntimeError(
-            f"Failed to checkout base branch {base_branch!r}: {exc}"
-        ) from exc
-
-    # 3) Pull latest changes on base
-    try:
-        run_git(["pull", "origin", base_branch], cwd=cwd)
-    except GitError as exc:
-        raise RuntimeError(
-            f"Failed to pull latest changes for base branch {base_branch!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 {base_branch!r}: {exc}"
-        ) from exc
-
-    # 5) Push and set upstream
-    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

pkgmgr/cli_core/__init__.py

@@ -1,5 +0,0 @@
-from .context import CLIContext
-from .parser import create_parser
-from .dispatch import dispatch_command
-
-__all__ = ["CLIContext", "create_parser", "dispatch_command"]

pkgmgr/cli_core/commands/config.py

@@ -1,140 +0,0 @@
-from __future__ import annotations
-
-import os
-import sys
-from typing import Any, Dict, List
-
-import yaml
-
-from pkgmgr.cli_core.context import CLIContext
-from pkgmgr.config_init import config_init
-from pkgmgr.interactive_add import interactive_add
-from pkgmgr.resolve_repos import resolve_repos
-from pkgmgr.save_user_config import save_user_config
-from pkgmgr.show_config import show_config
-from pkgmgr.run_command import run_command
-
-
-def _load_user_config(user_config_path: str) -> Dict[str, Any]:
-    """
-    Load the user config file, returning a default structure if it does not exist.
-    """
-    if os.path.exists(user_config_path):
-        with open(user_config_path, "r") as f:
-            return yaml.safe_load(f) or {"repositories": []}
-    return {"repositories": []}
-
-
-def handle_config(args, ctx: CLIContext) -> None:
-    """
-    Handle the 'config' command and its subcommands.
-    """
-
-    user_config_path = ctx.user_config_path
-
-    # --------------------------------------------------------
-    # config show
-    # --------------------------------------------------------
-    if args.subcommand == "show":
-        if args.all or (not args.identifiers):
-            show_config([], user_config_path, full_config=True)
-        else:
-            selected = resolve_repos(args.identifiers, ctx.all_repositories)
-            if selected:
-                show_config(
-                    selected,
-                    user_config_path,
-                    full_config=False,
-                )
-        return
-
-    # --------------------------------------------------------
-    # config add
-    # --------------------------------------------------------
-    if args.subcommand == "add":
-        interactive_add(ctx.config_merged, user_config_path)
-        return
-
-    # --------------------------------------------------------
-    # config edit
-    # --------------------------------------------------------
-    if args.subcommand == "edit":
-        run_command(f"nano {user_config_path}")
-        return
-
-    # --------------------------------------------------------
-    # config init
-    # --------------------------------------------------------
-    if args.subcommand == "init":
-        user_config = _load_user_config(user_config_path)
-        config_init(
-            user_config,
-            ctx.config_merged,
-            ctx.binaries_dir,
-            user_config_path,
-        )
-        return
-
-    # --------------------------------------------------------
-    # config delete
-    # --------------------------------------------------------
-    if args.subcommand == "delete":
-        user_config = _load_user_config(user_config_path)
-
-        if args.all or not args.identifiers:
-            print("You must specify identifiers to delete.")
-            return
-
-        to_delete = resolve_repos(
-            args.identifiers,
-            user_config.get("repositories", []),
-        )
-        new_repos = [
-            entry
-            for entry in user_config.get("repositories", [])
-            if entry not in to_delete
-        ]
-        user_config["repositories"] = new_repos
-        save_user_config(user_config, user_config_path)
-        print(f"Deleted {len(to_delete)} entries from user config.")
-        return
-
-    # --------------------------------------------------------
-    # config ignore
-    # --------------------------------------------------------
-    if args.subcommand == "ignore":
-        user_config = _load_user_config(user_config_path)
-
-        if args.all or not args.identifiers:
-            print("You must specify identifiers to modify ignore flag.")
-            return
-
-        to_modify = resolve_repos(
-            args.identifiers,
-            user_config.get("repositories", []),
-        )
-
-        for entry in user_config["repositories"]:
-            key = (
-                entry.get("provider"),
-                entry.get("account"),
-                entry.get("repository"),
-            )
-            for mod in to_modify:
-                mod_key = (
-                    mod.get("provider"),
-                    mod.get("account"),
-                    mod.get("repository"),
-                )
-                if key == mod_key:
-                    entry["ignore"] = args.set == "true"
-                    print(
-                        f"Set ignore for {key} to {entry['ignore']}"
-                    )
-
-        save_user_config(user_config, user_config_path)
-        return
-
-    # If we end up here, something is wrong with subcommand routing
-    print(f"Unknown config subcommand: {args.subcommand}")
-    sys.exit(2)

pkgmgr/cli_core/commands/release.py

@@ -1,76 +0,0 @@
-from __future__ import annotations
-
-import os
-import sys
-from typing import Any, Dict, List, Optional
-
-from pkgmgr.cli_core.context import CLIContext
-from pkgmgr.get_repo_dir import get_repo_dir
-from pkgmgr import release as rel
-
-
-Repository = Dict[str, Any]
-
-
-def handle_release(
-    args,
-    ctx: CLIContext,
-    selected: List[Repository],
-) -> None:
-    """
-    Handle the 'release' command.
-
-    Creates a release by incrementing the version and updating the changelog
-    in a single selected repository.
-
-    Important:
-      - Releases are strictly limited to exactly ONE repository.
-      - Using --all or specifying multiple identifiers for release does
-        not make sense and is therefore rejected.
-      - The --preview flag is respected and passed through to the release
-        implementation so that no changes are made in preview mode.
-    """
-
-    if not selected:
-        print("No repositories selected for release.")
-        sys.exit(1)
-
-    if len(selected) > 1:
-        print(
-            "[ERROR] Release operations are limited to a single repository.\n"
-            "Do not use --all or multiple identifiers with 'pkgmgr release'."
-        )
-        sys.exit(1)
-
-    original_dir = os.getcwd()
-
-    repo = selected[0]
-
-    repo_dir: Optional[str] = repo.get("directory")
-    if not repo_dir:
-        repo_dir = get_repo_dir(ctx.repositories_base_dir, repo)
-
-    if not os.path.isdir(repo_dir):
-        print(
-            f"[ERROR] Repository directory does not exist locally: {repo_dir}"
-        )
-        sys.exit(1)
-
-    pyproject_path = os.path.join(repo_dir, "pyproject.toml")
-    changelog_path = os.path.join(repo_dir, "CHANGELOG.md")
-
-    print(
-        f"Releasing repository '{repo.get('repository')}' in '{repo_dir}'..."
-    )
-
-    os.chdir(repo_dir)
-    try:
-        rel.release(
-            pyproject_path=pyproject_path,
-            changelog_path=changelog_path,
-            release_type=args.release_type,
-            message=args.message,
-            preview=getattr(args, "preview", False),
-        )
-    finally:
-        os.chdir(original_dir)

pkgmgr/cli_core/commands/repos.py

@@ -1,161 +0,0 @@
-from __future__ import annotations
-
-import sys
-from typing import Any, Dict, List
-
-from pkgmgr.cli_core.context import CLIContext
-from pkgmgr.install_repos import install_repos
-from pkgmgr.deinstall_repos import deinstall_repos
-from pkgmgr.delete_repos import delete_repos
-from pkgmgr.update_repos import update_repos
-from pkgmgr.status_repos import status_repos
-from pkgmgr.list_repositories import list_repositories
-from pkgmgr.run_command import run_command
-from pkgmgr.create_repo import create_repo
-
-
-Repository = Dict[str, Any]
-
-
-def handle_repos_command(
-    args,
-    ctx: CLIContext,
-    selected: List[Repository],
-) -> None:
-    """
-    Handle repository-related commands:
-    - install / update / deinstall / delete / status
-    - path / shell
-    - create / list
-    """
-
-    # --------------------------------------------------------
-    # install / update
-    # --------------------------------------------------------
-    if args.command == "install":
-        install_repos(
-            selected,
-            ctx.repositories_base_dir,
-            ctx.binaries_dir,
-            ctx.all_repositories,
-            args.no_verification,
-            args.preview,
-            args.quiet,
-            args.clone_mode,
-            args.dependencies,
-        )
-        return
-
-    if args.command == "update":
-        update_repos(
-            selected,
-            ctx.repositories_base_dir,
-            ctx.binaries_dir,
-            ctx.all_repositories,
-            args.no_verification,
-            args.system,
-            args.preview,
-            args.quiet,
-            args.dependencies,
-            args.clone_mode,
-        )
-        return
-
-    # --------------------------------------------------------
-    # deinstall / delete
-    # --------------------------------------------------------
-    if args.command == "deinstall":
-        deinstall_repos(
-            selected,
-            ctx.repositories_base_dir,
-            ctx.binaries_dir,
-            ctx.all_repositories,
-            preview=args.preview,
-        )
-        return
-
-    if args.command == "delete":
-        delete_repos(
-            selected,
-            ctx.repositories_base_dir,
-            ctx.all_repositories,
-            preview=args.preview,
-        )
-        return
-
-    # --------------------------------------------------------
-    # status
-    # --------------------------------------------------------
-    if args.command == "status":
-        status_repos(
-            selected,
-            ctx.repositories_base_dir,
-            ctx.all_repositories,
-            args.extra_args,
-            list_only=args.list,
-            system_status=args.system,
-            preview=args.preview,
-        )
-        return
-
-    # --------------------------------------------------------
-    # path
-    # --------------------------------------------------------
-    if args.command == "path":
-        for repository in selected:
-            print(repository["directory"])
-        return
-
-    # --------------------------------------------------------
-    # shell
-    # --------------------------------------------------------
-    if args.command == "shell":
-        if not args.shell_command:
-            print("No shell command specified.")
-            sys.exit(2)
-        command_to_run = " ".join(args.shell_command)
-        for repository in selected:
-            print(
-                f"Executing in '{repository['directory']}': {command_to_run}"
-            )
-            run_command(
-                command_to_run,
-                cwd=repository["directory"],
-                preview=args.preview,
-            )
-        return
-
-    # --------------------------------------------------------
-    # create
-    # --------------------------------------------------------
-    if args.command == "create":
-        if not args.identifiers:
-            print(
-                "No identifiers provided. Please specify at least one identifier "
-                "in the format provider/account/repository."
-            )
-            sys.exit(1)
-
-        for identifier in args.identifiers:
-            create_repo(
-                identifier,
-                ctx.config_merged,
-                ctx.user_config_path,
-                ctx.binaries_dir,
-                remote=args.remote,
-                preview=args.preview,
-            )
-        return
-
-    # --------------------------------------------------------
-    # list
-    # --------------------------------------------------------
-    if args.command == "list":
-        list_repositories(
-            ctx.all_repositories,
-            ctx.repositories_base_dir,
-            ctx.binaries_dir,
-            search_filter=args.search,
-            status_filter=args.status,
-        )
-        return

pkgmgr/cli_core/commands/tools.py

@@ -1,83 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-
-from typing import Any, Dict, List
-
-from pkgmgr.cli_core.context import CLIContext
-from pkgmgr.run_command import run_command
-from pkgmgr.get_repo_identifier import get_repo_identifier
-
-
-Repository = Dict[str, Any]
-
-
-def handle_tools_command(
-    args,
-    ctx: CLIContext,
-    selected: List[Repository],
-) -> None:
-    """
-    Handle integration commands:
-    - explore (file manager)
-    - terminal (GNOME Terminal)
-    - code (VS Code workspace)
-    """
-
-    # --------------------------------------------------------
-    # explore
-    # --------------------------------------------------------
-    if args.command == "explore":
-        for repository in selected:
-            run_command(
-                f"nautilus {repository['directory']} & disown"
-            )
-        return
-
-    # --------------------------------------------------------
-    # terminal
-    # --------------------------------------------------------
-    if args.command == "terminal":
-        for repository in selected:
-            run_command(
-                f'gnome-terminal --tab --working-directory="{repository["directory"]}"'
-            )
-        return
-
-    # --------------------------------------------------------
-    # code
-    # --------------------------------------------------------
-    if args.command == "code":
-        if not selected:
-            print("No repositories selected.")
-            return
-
-        identifiers = [
-            get_repo_identifier(repo, ctx.all_repositories)
-            for repo in selected
-        ]
-        sorted_identifiers = sorted(identifiers)
-        workspace_name = "_".join(sorted_identifiers) + ".code-workspace"
-
-        workspaces_dir = os.path.expanduser(
-            ctx.config_merged.get("directories").get("workspaces")
-        )
-        os.makedirs(workspaces_dir, exist_ok=True)
-        workspace_file = os.path.join(workspaces_dir, workspace_name)
-
-        folders = [{"path": repository["directory"]} for repository in selected]
-
-        workspace_data = {
-            "folders": folders,
-            "settings": {},
-        }
-        if not os.path.exists(workspace_file):
-            with open(workspace_file, "w") as f:
-                json.dump(workspace_data, f, indent=4)
-            print(f"Created workspace file: {workspace_file}")
-        else:
-            print(f"Using existing workspace file: {workspace_file}")
-
-        run_command(f'code "{workspace_file}"')
-        return

pkgmgr/cli_core/dispatch.py

@@ -1,94 +0,0 @@
-from __future__ import annotations
-
-import sys
-from typing import List
-
-from pkgmgr.cli_core.context import CLIContext
-from pkgmgr.cli_core.proxy import maybe_handle_proxy
-from pkgmgr.get_selected_repos import get_selected_repos
-
-from pkgmgr.cli_core.commands import (
-    handle_repos_command,
-    handle_tools_command,
-    handle_release,
-    handle_version,
-    handle_config,
-    handle_make,
-    handle_changelog,
-    handle_branch,
-)
-
-
-def dispatch_command(args, ctx: CLIContext) -> None:
-    """
-    Top-level command dispatcher.
-
-    Responsible for:
-    - computing selected repositories (where applicable)
-    - delegating to the correct command handler module
-    """
-
-    # 1) Proxy commands (git, docker, docker compose) short-circuit.
-    if maybe_handle_proxy(args, ctx):
-        return
-
-    # 2) Determine if this command uses repository selection.
-    commands_with_selection: List[str] = [
-        "install",
-        "update",
-        "deinstall",
-        "delete",
-        "status",
-        "path",
-        "shell",
-        "code",
-        "explore",
-        "terminal",
-        "release",
-        "version",
-        "make",
-        "changelog",
-        # intentionally NOT "branch" – it operates on cwd only
-    ]
-
-    if args.command in commands_with_selection:
-        selected = get_selected_repos(
-            getattr(args, "all", False),
-            ctx.all_repositories,
-            getattr(args, "identifiers", []),
-        )
-    else:
-        selected = []
-
-    # 3) Delegate based on command.
-    if args.command in (
-        "install",
-        "update",
-        "deinstall",
-        "delete",
-        "status",
-        "path",
-        "shell",
-        "create",
-        "list",
-    ):
-        handle_repos_command(args, ctx, selected)
-    elif args.command in ("code", "explore", "terminal"):
-        handle_tools_command(args, ctx, selected)
-    elif args.command == "release":
-        handle_release(args, ctx, selected)
-    elif args.command == "version":
-        handle_version(args, ctx, selected)
-    elif args.command == "changelog":
-        handle_changelog(args, ctx, selected)
-    elif args.command == "config":
-        handle_config(args, ctx)
-    elif args.command == "make":
-        handle_make(args, ctx, selected)
-    elif args.command == "branch":
-        # Branch commands currently operate on the current working
-        # directory only, not on the pkgmgr repository selection.
-        handle_branch(args, ctx)
-    else:
-        print(f"Unknown command: {args.command}")
-        sys.exit(2)

pkgmgr/cli_core/parser.py

@@ -1,410 +0,0 @@
-from __future__ import annotations
-
-import argparse
-
-from pkgmgr.cli_core.proxy import register_proxy_commands
-
-
-class SortedSubParsersAction(argparse._SubParsersAction):
-    """
-    Subparsers action that keeps choices sorted alphabetically.
-    """
-
-    def add_parser(self, name, **kwargs):
-        parser = super().add_parser(name, **kwargs)
-        self._choices_actions.sort(key=lambda a: a.dest)
-        return parser
-
-
-def add_identifier_arguments(subparser: argparse.ArgumentParser) -> None:
-    """
-    Attach generic repository selection arguments to a subparser.
-    """
-    subparser.add_argument(
-        "identifiers",
-        nargs="*",
-        help=(
-            "Identifier(s) for repositories. "
-            "Default: Repository of current folder."
-        ),
-    )
-    subparser.add_argument(
-        "--all",
-        action="store_true",
-        default=False,
-        help=(
-            "Apply the subcommand to all repositories in the config. "
-            "Some subcommands ask for confirmation. If you want to give this "
-            "confirmation for all repositories, pipe 'yes'. E.g: "
-            "yes | pkgmgr {subcommand} --all"
-        ),
-    )
-    subparser.add_argument(
-        "--preview",
-        action="store_true",
-        help="Preview changes without executing commands",
-    )
-    subparser.add_argument(
-        "--list",
-        action="store_true",
-        help="List affected repositories (with preview or status)",
-    )
-    subparser.add_argument(
-        "-a",
-        "--args",
-        nargs=argparse.REMAINDER,
-        dest="extra_args",
-        help="Additional parameters to be attached.",
-        default=[],
-    )
-
-
-def add_install_update_arguments(subparser: argparse.ArgumentParser) -> None:
-    """
-    Attach shared flags for install/update-like commands.
-    """
-    add_identifier_arguments(subparser)
-    subparser.add_argument(
-        "-q",
-        "--quiet",
-        action="store_true",
-        help="Suppress warnings and info messages",
-    )
-    subparser.add_argument(
-        "--no-verification",
-        action="store_true",
-        default=False,
-        help="Disable verification via commit/gpg",
-    )
-    subparser.add_argument(
-        "--dependencies",
-        action="store_true",
-        help="Also pull and update dependencies",
-    )
-    subparser.add_argument(
-        "--clone-mode",
-        choices=["ssh", "https", "shallow"],
-        default="ssh",
-        help=(
-            "Specify the clone mode: ssh, https, or shallow "
-            "(HTTPS shallow clone; default: ssh)"
-        ),
-    )
-
-
-def create_parser(description_text: str) -> argparse.ArgumentParser:
-    """
-    Create and configure the top-level argument parser for pkgmgr.
-
-    This function defines *only* the CLI surface (arguments & subcommands),
-    but no business logic.
-    """
-    parser = argparse.ArgumentParser(
-        description=description_text,
-        formatter_class=argparse.RawTextHelpFormatter,
-    )
-    subparsers = parser.add_subparsers(
-        dest="command",
-        help="Subcommands",
-        action=SortedSubParsersAction,
-    )
-
-    # ------------------------------------------------------------
-    # install / update
-    # ------------------------------------------------------------
-    install_parser = subparsers.add_parser(
-        "install",
-        help="Setup repository/repositories alias links to executables",
-    )
-    add_install_update_arguments(install_parser)
-
-    update_parser = subparsers.add_parser(
-        "update",
-        help="Update (pull + install) repository/repositories",
-    )
-    add_install_update_arguments(update_parser)
-    update_parser.add_argument(
-        "--system",
-        action="store_true",
-        help="Include system update commands",
-    )
-
-    # ------------------------------------------------------------
-    # deinstall / delete
-    # ------------------------------------------------------------
-    deinstall_parser = subparsers.add_parser(
-        "deinstall",
-        help="Remove alias links to repository/repositories",
-    )
-    add_identifier_arguments(deinstall_parser)
-
-    delete_parser = subparsers.add_parser(
-        "delete",
-        help="Delete repository/repositories alias links to executables",
-    )
-    add_identifier_arguments(delete_parser)
-
-    # ------------------------------------------------------------
-    # create
-    # ------------------------------------------------------------
-    create_parser = subparsers.add_parser(
-        "create",
-        help=(
-            "Create new repository entries: add them to the config if not "
-            "already present, initialize the local repository, and push "
-            "remotely if --remote is set."
-        ),
-    )
-    add_identifier_arguments(create_parser)
-    create_parser.add_argument(
-        "--remote",
-        action="store_true",
-        help="If set, add the remote and push the initial commit.",
-    )
-
-    # ------------------------------------------------------------
-    # status
-    # ------------------------------------------------------------
-    status_parser = subparsers.add_parser(
-        "status",
-        help="Show status for repository/repositories or system",
-    )
-    add_identifier_arguments(status_parser)
-    status_parser.add_argument(
-        "--system",
-        action="store_true",
-        help="Show system status",
-    )
-
-    # ------------------------------------------------------------
-    # config
-    # ------------------------------------------------------------
-    config_parser = subparsers.add_parser(
-        "config",
-        help="Manage configuration",
-    )
-    config_subparsers = config_parser.add_subparsers(
-        dest="subcommand",
-        help="Config subcommands",
-        required=True,
-    )
-
-    config_show = config_subparsers.add_parser(
-        "show",
-        help="Show configuration",
-    )
-    add_identifier_arguments(config_show)
-
-    config_subparsers.add_parser(
-        "add",
-        help="Interactively add a new repository entry",
-    )
-
-    config_subparsers.add_parser(
-        "edit",
-        help="Edit configuration file with nano",
-    )
-
-    config_subparsers.add_parser(
-        "init",
-        help="Initialize user configuration by scanning the base directory",
-    )
-
-    config_delete = config_subparsers.add_parser(
-        "delete",
-        help="Delete repository entry from user config",
-    )
-    add_identifier_arguments(config_delete)
-
-    config_ignore = config_subparsers.add_parser(
-        "ignore",
-        help="Set ignore flag for repository entries in user config",
-    )
-    add_identifier_arguments(config_ignore)
-    config_ignore.add_argument(
-        "--set",
-        choices=["true", "false"],
-        required=True,
-        help="Set ignore to true or false",
-    )
-
-    # ------------------------------------------------------------
-    # path / explore / terminal / code / shell
-    # ------------------------------------------------------------
-    path_parser = subparsers.add_parser(
-        "path",
-        help="Print the path(s) of repository/repositories",
-    )
-    add_identifier_arguments(path_parser)
-
-    explore_parser = subparsers.add_parser(
-        "explore",
-        help="Open repository in Nautilus file manager",
-    )
-    add_identifier_arguments(explore_parser)
-
-    terminal_parser = subparsers.add_parser(
-        "terminal",
-        help="Open repository in a new GNOME Terminal tab",
-    )
-    add_identifier_arguments(terminal_parser)
-
-    code_parser = subparsers.add_parser(
-        "code",
-        help="Open repository workspace with VS Code",
-    )
-    add_identifier_arguments(code_parser)
-
-    shell_parser = subparsers.add_parser(
-        "shell",
-        help="Execute a shell command in each repository",
-    )
-    add_identifier_arguments(shell_parser)
-    shell_parser.add_argument(
-        "-c",
-        "--command",
-        nargs=argparse.REMAINDER,
-        dest="shell_command",
-        help="The shell command (and its arguments) to execute in each repository",
-        default=[],
-    )
-
-    # ------------------------------------------------------------
-    # branch
-    # ------------------------------------------------------------
-    branch_parser = subparsers.add_parser(
-        "branch",
-        help="Branch-related utilities (e.g. open feature branches)",
-    )
-    branch_subparsers = branch_parser.add_subparsers(
-        dest="subcommand",
-        help="Branch subcommands",
-        required=True,
-    )
-
-    branch_open = branch_subparsers.add_parser(
-        "open",
-        help="Create and push a new branch on top of a base branch",
-    )
-    branch_open.add_argument(
-        "name",
-        nargs="?",
-        help="Name of the new branch (optional; will be asked interactively if omitted)",
-    )
-    branch_open.add_argument(
-        "--base",
-        default="main",
-        help="Base branch to create the new branch from (default: main)",
-    )
-
-
-    # ------------------------------------------------------------
-    # release
-    # ------------------------------------------------------------
-    release_parser = subparsers.add_parser(
-        "release",
-        help=(
-            "Create a release for repository/ies by incrementing version "
-            "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="",
-        help=(
-            "Optional release message to add to the changelog and tag."
-        ),
-    )
-    add_identifier_arguments(release_parser)
-
-    # ------------------------------------------------------------
-    # version
-    # ------------------------------------------------------------
-    version_parser = subparsers.add_parser(
-        "version",
-        help=(
-            "Show version information for repository/ies "
-            "(git tags, pyproject.toml, flake.nix, PKGBUILD, debian, spec, Ansible Galaxy)."
-        ),
-    )
-    add_identifier_arguments(version_parser)
-
-    # ------------------------------------------------------------
-    # changelog
-    # ------------------------------------------------------------
-    changelog_parser = subparsers.add_parser(
-        "changelog",
-        help=(
-            "Show changelog derived from Git history. "
-            "By default, shows the changes between the last two SemVer tags."
-        ),
-    )
-    changelog_parser.add_argument(
-        "range",
-        nargs="?",
-        default="",
-        help=(
-            "Optional tag or range (e.g. v1.2.3 or v1.2.0..v1.2.3). "
-            "If omitted, the changelog between the last two SemVer "
-            "tags is shown."
-        ),
-    )
-    add_identifier_arguments(changelog_parser)
-
-    # ------------------------------------------------------------
-    # list
-    # ------------------------------------------------------------
-    list_parser = subparsers.add_parser(
-        "list",
-        help="List all repositories with details and status",
-    )
-    list_parser.add_argument(
-        "--search",
-        default="",
-        help="Filter repositories that contain the given string",
-    )
-    list_parser.add_argument(
-        "--status",
-        type=str,
-        default="",
-        help="Filter repositories by status (case insensitive)",
-    )
-
-    # ------------------------------------------------------------
-    # make (wrapper around make in repositories)
-    # ------------------------------------------------------------
-    make_parser = subparsers.add_parser(
-        "make",
-        help="Executes make commands",
-    )
-    add_identifier_arguments(make_parser)
-    make_subparsers = make_parser.add_subparsers(
-        dest="subcommand",
-        help="Make subcommands",
-        required=True,
-    )
-
-    make_install = make_subparsers.add_parser(
-        "install",
-        help="Executes the make install command",
-    )
-    add_identifier_arguments(make_install)
-
-    make_deinstall = make_subparsers.add_parser(
-        "deinstall",
-        help="Executes the make deinstall command",
-    )
-    add_identifier_arguments(make_deinstall)
-
-    # ------------------------------------------------------------
-    # Proxy commands (git, docker, docker compose)
-    # ------------------------------------------------------------
-    register_proxy_commands(subparsers)
-
-    return parser

pkgmgr/config_init.py

@@ -1,75 +0,0 @@
-import subprocess
-import os
-from pkgmgr.generate_alias import generate_alias
-from pkgmgr.save_user_config import save_user_config
-
-def config_init(user_config, defaults_config, bin_dir,USER_CONFIG_PATH:str):
-    """
-    Scan the base directory (defaults_config["base"]) for repositories.
-    The folder structure is assumed to be:
-      {base}/{provider}/{account}/{repository}
-    For each repository found, automatically determine:
-      - provider, account, repository from folder names.
-      - verified: the latest commit (via 'git log -1 --format=%H').
-      - alias: generated from the repository name using generate_alias().
-    Repositories already defined in defaults_config["repositories"] or user_config["repositories"] are skipped.
-    """
-    repositories_base_dir = os.path.expanduser(defaults_config["directories"]["repositories"])
-    if not os.path.isdir(repositories_base_dir):
-        print(f"Base directory '{repositories_base_dir}' does not exist.")
-        return
-
-    default_keys = {(entry.get("provider"), entry.get("account"), entry.get("repository"))
-                    for entry in defaults_config.get("repositories", [])}
-    existing_keys = {(entry.get("provider"), entry.get("account"), entry.get("repository"))
-                     for entry in user_config.get("repositories", [])}
-    existing_aliases = {entry.get("alias") for entry in user_config.get("repositories", []) if entry.get("alias")}
-
-    new_entries = []
-    for provider in os.listdir(repositories_base_dir):
-        provider_path = os.path.join(repositories_base_dir, provider)
-        if not os.path.isdir(provider_path):
-            continue
-        for account in os.listdir(provider_path):
-            account_path = os.path.join(provider_path, account)
-            if not os.path.isdir(account_path):
-                continue
-            for repo_name in os.listdir(account_path):
-                repo_path = os.path.join(account_path, repo_name)
-                if not os.path.isdir(repo_path):
-                    continue
-                key = (provider, account, repo_name)
-                if key in default_keys or key in existing_keys:
-                    continue
-                try:
-                    result = subprocess.run(
-                        ["git", "log", "-1", "--format=%H"],
-                        cwd=repo_path,
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.PIPE,
-                        text=True,
-                        check=True,
-                    )
-                    verified = result.stdout.strip()
-                except Exception as e:
-                    verified = ""
-                    print(f"Could not determine latest commit for {repo_name} ({provider}/{account}): {e}")
-
-                entry = {
-                    "provider": provider,
-                    "account": account,
-                    "repository": repo_name,
-                    "verified": {"commit": verified},
-                    "ignore": True
-                }
-                alias = generate_alias({"repository": repo_name, "provider": provider, "account": account}, bin_dir, existing_aliases)
-                entry["alias"] = alias
-                existing_aliases.add(alias)
-                new_entries.append(entry)
-                print(f"Adding new repo entry: {entry}")
-
-    if new_entries:
-        user_config.setdefault("repositories", []).extend(new_entries)
-        save_user_config(user_config,USER_CONFIG_PATH)
-    else:
-        print("No new repositories found.")

pkgmgr/get_selected_repos.py

@@ -1,29 +0,0 @@
-import os
-import sys
-from .resolve_repos import resolve_repos
-from .filter_ignored import filter_ignored
-from .get_repo_dir import get_repo_dir
-
-def get_selected_repos(show_all: bool, all_repos_list, identifiers=None):
-    if show_all:
-        selected = all_repos_list 
-    else:
-        selected = resolve_repos(identifiers, all_repos_list)
-    
-    # If no repositories were found using the provided identifiers,
-    # try to automatically select based on the current directory:
-    if not selected:
-        current_dir = os.getcwd()
-        directory_name = os.path.basename(current_dir)
-        # Pack the directory name in a list since resolve_repos expects a list.
-        auto_selected = resolve_repos([directory_name], all_repos_list)
-        if auto_selected:
-            # Check if the path of the first auto-selected repository matches the current directory.
-            if os.path.abspath(auto_selected[0].get("directory")) == os.path.abspath(current_dir):
-                print(f"Repository {auto_selected[0]['repository']} has been auto-selected by path.")
-                selected = auto_selected
-    filtered = filter_ignored(selected)
-    if not filtered:
-        print("Error: No repositories had been selected.")
-        sys.exit(4)
-    return filtered

pkgmgr/install_repos.py

@@ -1,294 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-Repository installation pipeline for pkgmgr.
-
-This module orchestrates the installation of repositories by:
-
-  1. Ensuring the repository directory exists (cloning if necessary).
-  2. Verifying the repository according to the configured policies.
-  3. Creating executable links using create_ink(), after resolving the
-     appropriate command via resolve_command_for_repo().
-  4. Running a sequence of modular installer components that handle
-     specific technologies or manifests (PKGBUILD, Nix flakes, Python
-     via pyproject.toml, Makefile, OS-specific package metadata).
-
-The goal is to keep this file thin and delegate most logic to small,
-focused installer classes.
-"""
-
-import os
-from typing import List, Dict, Any
-
-from pkgmgr.get_repo_identifier import get_repo_identifier
-from pkgmgr.get_repo_dir import get_repo_dir
-from pkgmgr.create_ink import create_ink
-from pkgmgr.verify import verify_repository
-from pkgmgr.clone_repos import clone_repos
-from pkgmgr.context import RepoContext
-from pkgmgr.resolve_command import resolve_command_for_repo
-
-# Installer implementations
-from pkgmgr.installers.os_packages import (
-    ArchPkgbuildInstaller,
-    DebianControlInstaller,
-    RpmSpecInstaller,
-)
-from pkgmgr.installers.nix_flake import NixFlakeInstaller
-from pkgmgr.installers.python import PythonInstaller
-from pkgmgr.installers.makefile import MakefileInstaller
-
-
-# Layering:
-#   1) OS packages: PKGBUILD / debian/control / RPM spec  → os-deps.*
-#   2) Nix flakes (flake.nix)                            → e.g. python-runtime, make-install
-#   3) Python (pyproject.toml)                           → e.g. python-runtime, make-install
-#   4) Makefile fallback                                 → e.g. make-install
-INSTALLERS = [
-    ArchPkgbuildInstaller(),        # Arch
-    DebianControlInstaller(),       # Debian/Ubuntu
-    RpmSpecInstaller(),             # Fedora/RHEL/CentOS
-    NixFlakeInstaller(),            # flake.nix (Nix layer)
-    PythonInstaller(),              # pyproject.toml
-    MakefileInstaller(),            # generic 'make install'
-]
-
-
-def _ensure_repo_dir(
-    repo: Dict[str, Any],
-    repositories_base_dir: str,
-    all_repos: List[Dict[str, Any]],
-    preview: bool,
-    no_verification: bool,
-    clone_mode: str,
-    identifier: str,
-) -> str:
-    """
-    Ensure the repository directory exists. If not, attempt to clone it.
-
-    Returns the repository directory path or an empty string if cloning failed.
-    """
-    repo_dir = get_repo_dir(repositories_base_dir, repo)
-
-    if not os.path.exists(repo_dir):
-        print(f"Repository directory '{repo_dir}' does not exist. Cloning it now...")
-        clone_repos(
-            [repo],
-            repositories_base_dir,
-            all_repos,
-            preview,
-            no_verification,
-            clone_mode,
-        )
-        if not os.path.exists(repo_dir):
-            print(f"Cloning failed for repository {identifier}. Skipping installation.")
-            return ""
-
-    return repo_dir
-
-
-def _verify_repo(
-    repo: Dict[str, Any],
-    repo_dir: str,
-    no_verification: bool,
-    identifier: str,
-) -> bool:
-    """
-    Verify the repository using verify_repository().
-
-    Returns True if installation should proceed, False if it should be skipped.
-    """
-    verified_info = repo.get("verified")
-    verified_ok, errors, commit_hash, signing_key = verify_repository(
-        repo,
-        repo_dir,
-        mode="local",
-        no_verification=no_verification,
-    )
-
-    if not no_verification and verified_info and not verified_ok:
-        print(f"Warning: Verification failed for {identifier}:")
-        for err in errors:
-            print(f"  - {err}")
-        choice = input("Proceed with installation? (y/N): ").strip().lower()
-        if choice != "y":
-            print(f"Skipping installation for {identifier}.")
-            return False
-
-    return True
-
-
-def _create_context(
-    repo: Dict[str, Any],
-    identifier: str,
-    repo_dir: str,
-    repositories_base_dir: str,
-    bin_dir: str,
-    all_repos: List[Dict[str, Any]],
-    no_verification: bool,
-    preview: bool,
-    quiet: bool,
-    clone_mode: str,
-    update_dependencies: bool,
-) -> RepoContext:
-    """
-    Build a RepoContext for the given repository and parameters.
-    """
-    return RepoContext(
-        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,
-    )
-
-
-def install_repos(
-    selected_repos: List[Dict[str, Any]],
-    repositories_base_dir: str,
-    bin_dir: str,
-    all_repos: List[Dict[str, Any]],
-    no_verification: bool,
-    preview: bool,
-    quiet: bool,
-    clone_mode: str,
-    update_dependencies: bool,
-) -> None:
-    """
-    Install repositories by creating symbolic links and processing standard
-    manifest files (PKGBUILD, flake.nix, Python manifests, Makefile, etc.)
-    via dedicated installer components.
-
-    Any installer failure (SystemExit) is treated as fatal and will abort
-    the current installation.
-    """
-    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:
-            continue
-
-        if not _verify_repo(
-            repo=repo,
-            repo_dir=repo_dir,
-            no_verification=no_verification,
-            identifier=identifier,
-        ):
-            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,
-        )
-
-        # ------------------------------------------------------------
-        # Resolve the command for this repository before creating the link.
-        # If no command is resolved, no link will be created.
-        # ------------------------------------------------------------
-        resolved_command = resolve_command_for_repo(
-            repo=repo,
-            repo_identifier=identifier,
-            repo_dir=repo_dir,
-        )
-
-        if resolved_command:
-            repo["command"] = resolved_command
-        else:
-            repo.pop("command", None)
-
-        # ------------------------------------------------------------
-        # Create the symlink using create_ink (if a command is set).
-        # ------------------------------------------------------------
-        create_ink(
-            repo,
-            repositories_base_dir,
-            bin_dir,
-            all_repos,
-            quiet=quiet,
-            preview=preview,
-        )
-
-        # Track which logical capabilities have already been provided by
-        # earlier installers for this repository. This allows us to skip
-        # installers that would only duplicate work (e.g. Python runtime
-        # already provided by Nix flake → skip pyproject/Makefile).
-        provided_capabilities: set[str] = set()
-
-        # Run all installers that support this repository, but only if they
-        # provide at least one capability that is not yet satisfied.
-        for installer in INSTALLERS:
-            if not installer.supports(ctx):
-                continue
-
-            caps = installer.discover_capabilities(ctx)
-
-            # If the installer declares capabilities and *all* of them are
-            # already provided, we can safely skip it.
-            if caps and caps.issubset(provided_capabilities):
-                if not quiet:
-                    print(
-                        f"Skipping installer {installer.__class__.__name__} "
-                        f"for {identifier} – capabilities {caps} already provided."
-                    )
-                continue
-
-            # ------------------------------------------------------------
-            # Debug output + clear error if an installer fails
-            # ------------------------------------------------------------
-            if not quiet:
-                print(
-                    f"[pkgmgr] Running installer {installer.__class__.__name__} "
-                    f"for {identifier} in '{repo_dir}' "
-                    f"(new capabilities: {caps or '∅'})..."
-                )
-
-            try:
-                installer.run(ctx)
-            except SystemExit as exc:
-                exit_code = exc.code if isinstance(exc.code, int) else str(exc.code)
-
-                print(
-                    f"[ERROR] Installer {installer.__class__.__name__} failed "
-                    f"for repository {identifier} (dir: {repo_dir}) "
-                    f"with exit code {exit_code}."
-                )
-                print(
-                    "[ERROR] This usually means an underlying command failed "
-                    "(e.g. 'make install', 'nix build', 'pip install', ...)."
-                )
-                print(
-                    "[ERROR] Check the log above for the exact command output. "
-                    "You can also run this repository in isolation via:\n"
-                    f"        pkgmgr install {identifier} --clone-mode shallow --no-verification"
-                )
-
-                # Re-raise so that CLI/tests fail clearly,
-                # but now with much more context.
-                raise
-
-            # Only merge capabilities if the installer succeeded
-            provided_capabilities.update(caps)

pkgmgr/installers/__init__.py

@@ -1,19 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-Installer package for pkgmgr.
-
-This exposes all installer classes so users can import them directly from
-pkgmgr.installers.
-"""
-
-from pkgmgr.installers.base import BaseInstaller  # noqa: F401
-from pkgmgr.installers.nix_flake import NixFlakeInstaller  # noqa: F401
-from pkgmgr.installers.python import PythonInstaller  # noqa: F401
-from pkgmgr.installers.makefile import MakefileInstaller  # noqa: F401
-
-# OS-specific installers
-from pkgmgr.installers.os_packages.arch_pkgbuild import ArchPkgbuildInstaller  # noqa: F401
-from pkgmgr.installers.os_packages.debian_control import DebianControlInstaller  # noqa: F401
-from pkgmgr.installers.os_packages.rpm_spec import RpmSpecInstaller  # noqa: F401

pkgmgr/installers/makefile.py

@@ -1,93 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-Installer that triggers `make install` if a Makefile is present and
-the Makefile actually defines an 'install' target.
-
-This is useful for repositories that expose a standard Makefile-based
-installation step.
-"""
-
-import os
-import re
-
-from pkgmgr.context import RepoContext
-from pkgmgr.installers.base import BaseInstaller
-from pkgmgr.run_command import run_command
-
-
-class MakefileInstaller(BaseInstaller):
-    """Run `make install` if a Makefile with an 'install' target exists."""
-
-    # Logical layer name, used by capability matchers.
-    layer = "makefile"
-
-    MAKEFILE_NAME = "Makefile"
-
-    def supports(self, ctx: RepoContext) -> bool:
-        """Return True if a Makefile exists in the repository directory."""
-        makefile_path = os.path.join(ctx.repo_dir, self.MAKEFILE_NAME)
-        return os.path.exists(makefile_path)
-
-    def _has_install_target(self, makefile_path: str) -> bool:
-        """
-        Check whether the Makefile defines an 'install' target.
-
-        We treat the presence of a real install target as either:
-          - a line starting with 'install:' (optionally preceded by whitespace), or
-          - a .PHONY line that lists 'install' as one of the targets.
-        """
-        try:
-            with open(makefile_path, "r", encoding="utf-8", errors="ignore") as f:
-                content = f.read()
-        except OSError:
-            # If we cannot read the Makefile for some reason, assume no target.
-            return False
-
-        # install: ...
-        if re.search(r"^\s*install\s*:", content, flags=re.MULTILINE):
-            return True
-
-        # .PHONY: ... install ...
-        if re.search(r"^\s*\.PHONY\s*:\s*.*\binstall\b", content, flags=re.MULTILINE):
-            return True
-
-        return False
-
-    def run(self, ctx: RepoContext) -> None:
-        """
-        Execute `make install` in the repository directory, but only if an
-        'install' target is actually defined in the Makefile.
-
-        Any failure in `make install` is treated as a fatal error and will
-        propagate as SystemExit from run_command().
-        """
-        makefile_path = os.path.join(ctx.repo_dir, self.MAKEFILE_NAME)
-
-        if not os.path.exists(makefile_path):
-            # Should normally not happen if supports() was checked before,
-            # but keep this guard for robustness.
-            if not ctx.quiet:
-                print(
-                    f"[pkgmgr] Makefile '{makefile_path}' not found, "
-                    "skipping make install."
-                )
-            return
-
-        if not self._has_install_target(makefile_path):
-            if not ctx.quiet:
-                print(
-                    "[pkgmgr] Skipping Makefile install: no 'install' target "
-                    f"found in {makefile_path}."
-                )
-            return
-
-        if not ctx.quiet:
-            print(
-                f"[pkgmgr] Running 'make install' in {ctx.repo_dir} "
-                "(install target detected in Makefile)."
-            )
-
-        cmd = "make install"
-        run_command(cmd, cwd=ctx.repo_dir, preview=ctx.preview)

pkgmgr/installers/nix_flake.py

@@ -1,106 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-Installer for Nix flakes.
-
-If a repository contains flake.nix and the 'nix' command is available, this
-installer will try to install profile outputs from the flake.
-
-Behavior:
-  - If flake.nix is present and `nix` exists on PATH:
-      * First remove any existing `package-manager` profile entry (best-effort).
-      * Then install the flake outputs (`pkgmgr`, `default`) via `nix profile install`.
-  - Failure installing `pkgmgr` is treated as fatal.
-  - Failure installing `default` is logged as an error/warning but does not abort.
-"""
-
-import os
-import shutil
-from typing import TYPE_CHECKING
-
-from pkgmgr.installers.base import BaseInstaller
-from pkgmgr.run_command import run_command
-
-if TYPE_CHECKING:
-    from pkgmgr.context import RepoContext
-    from pkgmgr.install_repos import InstallContext
-
-
-class NixFlakeInstaller(BaseInstaller):
-    """Install Nix flake profiles for repositories that define flake.nix."""
-
-    # Logical layer name, used by capability matchers.
-    layer = "nix"
-
-    FLAKE_FILE = "flake.nix"
-    PROFILE_NAME = "package-manager"
-
-    def supports(self, ctx: "RepoContext") -> bool:
-        """
-        Only support repositories that:
-          - Have a flake.nix
-          - And have the `nix` command available.
-        """
-        if shutil.which("nix") is None:
-            return False
-        flake_path = os.path.join(ctx.repo_dir, self.FLAKE_FILE)
-        return os.path.exists(flake_path)
-
-    def _ensure_old_profile_removed(self, ctx: "RepoContext") -> None:
-        """
-        Best-effort removal of an existing profile entry.
-
-        This handles the "already provides the following file" conflict by
-        removing previous `package-manager` installations before we install
-        the new one.
-
-        Any error in `nix profile remove` is intentionally ignored, because
-        a missing profile entry is not a fatal condition.
-        """
-        if shutil.which("nix") is None:
-            return
-
-        cmd = f"nix profile remove {self.PROFILE_NAME} || true"
-        try:
-            # NOTE: no allow_failure here → matches the existing unit tests
-            run_command(cmd, cwd=ctx.repo_dir, preview=ctx.preview)
-        except SystemExit:
-            # Unit tests explicitly assert this is swallowed
-            pass
-
-    def run(self, ctx: "InstallContext") -> None:
-        """
-        Install Nix flake profile outputs (pkgmgr, default).
-
-        Any failure installing `pkgmgr` is treated as fatal (SystemExit).
-        A failure installing `default` is logged but does not abort.
-        """
-        # Reuse supports() to keep logic in one place
-        if not self.supports(ctx):  # type: ignore[arg-type]
-            return
-
-        print("Nix flake detected, attempting to install profile outputs...")
-
-        # Handle the "already installed" case up-front:
-        self._ensure_old_profile_removed(ctx)  # type: ignore[arg-type]
-
-        for output in ("pkgmgr", "default"):
-            cmd = f"nix profile install {ctx.repo_dir}#{output}"
-
-            try:
-                # For 'default' we don't want the process to exit on error
-                allow_failure = output == "default"
-                run_command(cmd, cwd=ctx.repo_dir, preview=ctx.preview, allow_failure=allow_failure)
-                print(f"Nix flake output '{output}' successfully installed.")
-            except SystemExit as e:
-                print(f"[Error] Failed to install Nix flake output '{output}': {e}")
-                if output == "pkgmgr":
-                    # Broken main CLI install → fatal
-                    raise
-                # For 'default' we log and continue
-                print(
-                    "[Warning] Continuing despite failure to install 'default' "
-                    "because 'pkgmgr' is already installed."
-                )
-                break

pkgmgr/installers/os_packages/rpm_spec.py

@@ -1,160 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-Installer for RPM-based packages defined in *.spec files.
-
-This installer:
-
-  1. Installs build dependencies via dnf/yum builddep (where available)
-  2. Uses rpmbuild to build RPMs from the provided .spec file
-  3. Installs the resulting RPMs via `rpm -i`
-
-It targets RPM-based systems (Fedora / RHEL / CentOS / Rocky / Alma, etc.).
-"""
-
-import glob
-import os
-import shutil
-
-from typing import List, Optional
-
-from pkgmgr.context import RepoContext
-from pkgmgr.installers.base import BaseInstaller
-from pkgmgr.run_command import run_command
-
-
-class RpmSpecInstaller(BaseInstaller):
-    """
-    Build and install RPM-based packages from *.spec files.
-
-    This installer is responsible for the full build + install of the
-    application on RPM-like systems.
-    """
-
-    # Logical layer name, used by capability matchers.
-    layer = "os-packages"
-
-    def _is_rpm_like(self) -> bool:
-        """
-        Basic RPM-like detection:
-
-          - rpmbuild must be available
-          - at least one of dnf / yum / yum-builddep must be present
-        """
-        if shutil.which("rpmbuild") is None:
-            return False
-
-        has_dnf = shutil.which("dnf") is not None
-        has_yum = shutil.which("yum") is not None
-        has_yum_builddep = shutil.which("yum-builddep") is not None
-
-        return has_dnf or has_yum or has_yum_builddep
-
-    def _spec_path(self, ctx: RepoContext) -> Optional[str]:
-        """Return the first *.spec file in the repository root, if any."""
-        pattern = os.path.join(ctx.repo_dir, "*.spec")
-        matches = sorted(glob.glob(pattern))
-        if not matches:
-            return None
-        return matches[0]
-
-    def supports(self, ctx: RepoContext) -> bool:
-        """
-        This installer is supported if:
-          - we are on an RPM-based system (rpmbuild + dnf/yum/yum-builddep available), and
-          - a *.spec file exists in the repository root.
-        """
-        if not self._is_rpm_like():
-            return False
-
-        return self._spec_path(ctx) is not None
-
-    def _find_built_rpms(self) -> List[str]:
-        """
-        Find RPMs built by rpmbuild.
-
-        By default, rpmbuild outputs RPMs into:
-          ~/rpmbuild/RPMS/*/*.rpm
-        """
-        home = os.path.expanduser("~")
-        pattern = os.path.join(home, "rpmbuild", "RPMS", "**", "*.rpm")
-        return sorted(glob.glob(pattern, recursive=True))
-
-    def _install_build_dependencies(self, ctx: RepoContext, spec_path: str) -> None:
-        """
-        Install build dependencies for the given .spec file.
-
-        Strategy (best-effort):
-
-          1. If dnf is available:
-               sudo dnf builddep -y <spec>
-          2. Else if yum-builddep is available:
-               sudo yum-builddep -y <spec>
-          3. Else if yum is available:
-               sudo yum-builddep -y <spec>   # Some systems provide it via yum plugin
-          4. Otherwise: print a warning and skip automatic builddep install.
-
-        Any failure in builddep installation is treated as fatal (SystemExit),
-        consistent with other installer steps.
-        """
-        spec_basename = os.path.basename(spec_path)
-
-        if shutil.which("dnf") is not None:
-            cmd = f"sudo dnf builddep -y {spec_basename}"
-        elif shutil.which("yum-builddep") is not None:
-            cmd = f"sudo yum-builddep -y {spec_basename}"
-        elif shutil.which("yum") is not None:
-            # Some distributions ship yum-builddep as a plugin.
-            cmd = f"sudo yum-builddep -y {spec_basename}"
-        else:
-            print(
-                "[Warning] No suitable RPM builddep tool (dnf/yum-builddep/yum) found. "
-                "Skipping automatic build dependency installation for RPM."
-            )
-            return
-
-        # Run builddep in the repository directory so relative spec paths work.
-        run_command(cmd, cwd=ctx.repo_dir, preview=ctx.preview)
-
-    def run(self, ctx: RepoContext) -> None:
-        """
-        Build and install RPM-based packages.
-
-        Steps:
-          1. dnf/yum builddep <spec> (automatic build dependency installation)
-          2. rpmbuild -ba path/to/spec
-          3. sudo rpm -i ~/rpmbuild/RPMS/*/*.rpm
-        """
-        spec_path = self._spec_path(ctx)
-        if not spec_path:
-            return
-
-        # 1) Install build dependencies
-        self._install_build_dependencies(ctx, spec_path)
-
-        # 2) Build RPMs
-        # Use the full spec path, but run in the repo directory.
-        spec_basename = os.path.basename(spec_path)
-        build_cmd = f"rpmbuild -ba {spec_basename}"
-        run_command(build_cmd, cwd=ctx.repo_dir, preview=ctx.preview)
-
-        # 3) Find built RPMs
-        rpms = self._find_built_rpms()
-        if not rpms:
-            print(
-                "[Warning] No RPM files found after rpmbuild. "
-                "Skipping RPM package installation."
-            )
-            return
-
-        # 4) Install RPMs
-        if shutil.which("rpm") is None:
-            print(
-                "[Warning] rpm binary not found on PATH. "
-                "Cannot install built RPMs."
-            )
-            return
-
-        install_cmd = "sudo rpm -i " + " ".join(rpms)
-        run_command(install_cmd, cwd=ctx.repo_dir, preview=ctx.preview)

pkgmgr/installers/python.py

@@ -1,68 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-Installer for Python projects based on pyproject.toml.
-
-Strategy:
-  - Determine a pip command in this order:
-      1. $PKGMGR_PIP (explicit override, e.g. ~/.venvs/pkgmgr/bin/pip)
-      2. sys.executable -m pip (current interpreter)
-      3. "pip" from PATH as last resort
-  - If pyproject.toml exists: pip install .
-
-All installation failures are treated as fatal errors (SystemExit).
-"""
-
-import os
-import sys
-
-from pkgmgr.installers.base import BaseInstaller
-from pkgmgr.run_command import run_command
-
-
-class PythonInstaller(BaseInstaller):
-    """Install Python projects and dependencies via pip."""
-
-    # Logical layer name, used by capability matchers.
-    layer = "python"
-
-    def supports(self, ctx) -> bool:
-        """
-        Return True if this installer should handle the given repository.
-
-        Only pyproject.toml is supported as the single source of truth
-        for Python dependencies and packaging metadata.
-        """
-        repo_dir = ctx.repo_dir
-        return os.path.exists(os.path.join(repo_dir, "pyproject.toml"))
-
-    def _pip_cmd(self) -> str:
-        """
-        Resolve the pip command to use.
-        """
-        explicit = os.environ.get("PKGMGR_PIP", "").strip()
-        if explicit:
-            return explicit
-
-        if sys.executable:
-            return f"{sys.executable} -m pip"
-
-        return "pip"
-
-    def run(self, ctx) -> None:
-        """
-        Install Python project defined via pyproject.toml.
-
-        Any pip failure is propagated as SystemExit.
-        """
-        pip_cmd = self._pip_cmd()
-
-        pyproject = os.path.join(ctx.repo_dir, "pyproject.toml")
-        if os.path.exists(pyproject):
-            print(
-                f"pyproject.toml found in {ctx.identifier}, "
-                f"installing Python project..."
-            )
-            cmd = f"{pip_cmd} install ."
-            run_command(cmd, cwd=ctx.repo_dir, preview=ctx.preview)

pkgmgr/list_repositories.py

@@ -1,108 +0,0 @@
-import os
-from pkgmgr.get_repo_identifier import get_repo_identifier
-from pkgmgr.get_repo_dir import get_repo_dir
-
-def list_repositories(all_repos, repositories_base_dir, bin_dir, search_filter="", status_filter=""):
-    """
-    Lists all repositories with their attributes and status information.
-    The repositories are sorted in ascending order by their identifier.
-
-    Parameters:
-      all_repos (list): List of repository configurations.
-      repositories_base_dir (str): The base directory where repositories are located.
-      bin_dir (str): The directory where executable wrappers are stored.
-      search_filter (str): Filter for repository attributes (case insensitive).
-      status_filter (str): Filter for computed status info (case insensitive).
-
-    For each repository, the identifier is printed in bold, the description (if available)
-    in italic, then all other attributes and computed status are printed.
-    If the repository is installed, a hint is displayed under the attributes.
-    Repositories are filtered out if either the search_filter is not found in any attribute or
-    if the status_filter is not found in the computed status string.
-    """
-    search_filter = search_filter.lower() if search_filter else ""
-    status_filter = status_filter.lower() if status_filter else ""
-
-    # Define status colors using colors not used for other attributes:
-    # Avoid red (for ignore), blue (for homepage) and yellow (for verified).
-    status_colors = {
-        "Installed": "\033[1;32m",       # Green
-        "Not Installed": "\033[1;35m",   # Magenta
-        "Cloned": "\033[1;36m",          # Cyan
-        "Clonable": "\033[1;37m",        # White
-        "Ignored": "\033[38;5;208m",     # Orange (extended)
-        "Active": "\033[38;5;129m",      # Light Purple (extended)
-        "Installable": "\033[38;5;82m"   # Light Green (extended)
-    }
-
-    # Sort all repositories by their identifier in ascending order.
-    sorted_repos = sorted(all_repos, key=lambda repo: get_repo_identifier(repo, all_repos))
-
-    for repo in sorted_repos:
-        # Combine all attribute values into one string for filtering.
-        repo_text = " ".join(str(v) for v in repo.values()).lower()
-        if search_filter and search_filter not in repo_text:
-            continue
-
-        # Compute status information for the repository.
-        identifier = get_repo_identifier(repo, all_repos)
-        executable_path = os.path.join(bin_dir, identifier)
-        repo_dir = get_repo_dir(repositories_base_dir, repo)
-        status_list = []
-
-        # Check if the executable exists (Installed).
-        if os.path.exists(executable_path):
-            status_list.append("Installed")
-        else:
-            status_list.append("Not Installed")
-        # Check if the repository directory exists (Cloned).
-        if os.path.exists(repo_dir):
-            status_list.append("Cloned")
-        else:
-            status_list.append("Clonable")
-        # Mark ignored repositories.
-        if repo.get("ignore", False):
-            status_list.append("Ignored")
-        else:
-            status_list.append("Active")
-        # Define installable as cloned but not installed.
-        if os.path.exists(repo_dir) and not os.path.exists(executable_path):
-            status_list.append("Installable")
-
-        # Build a colored status string.
-        colored_statuses = [f"{status_colors.get(s, '')}{s}\033[0m" for s in status_list]
-        status_str = ", ".join(colored_statuses)
-
-        # If a status_filter is provided, only display repos whose status contains the filter.
-        if status_filter and status_filter not in status_str.lower():
-            continue
-
-        # Display repository details:
-        # Print the identifier in bold.
-        print(f"\033[1m{identifier}\033[0m")
-        # Print the description in italic if it exists.
-        description = repo.get("description")
-        if description:
-            print(f"\n\033[3m{description}\033[0m")
-        print("\nAttributes:")
-        # Loop through all attributes.
-        for key, value in repo.items():
-            formatted_value = str(value)
-            # Special formatting for the "verified" attribute (yellow).
-            if key == "verified" and value:
-                formatted_value = f"\033[1;33m{value}\033[0m"
-            # Special formatting for the "ignore" flag (red if True).
-            if key == "ignore" and value:
-                formatted_value = f"\033[1;31m{value}\033[0m"
-            if key == "description":
-                continue
-            # Highlight homepage in blue.
-            if key.lower() == "homepage" and value:
-                formatted_value = f"\033[1;34m{value}\033[0m"
-            print(f"  {key}: {formatted_value}")
-        # Always display the computed status.
-        print(f"  Status: {status_str}")
-        # If the repository is installed, display a hint for more info.
-        if os.path.exists(executable_path):
-            print(f"\nMore information and help: \033[1;4mpkgmgr {identifier} --help\033[0m\n")
-        print("-" * 40)

pkgmgr/load_config.py

@@ -1,30 +0,0 @@
-import sys
-import yaml
-import os
-from .get_repo_dir import get_repo_dir
-DEFAULT_CONFIG_PATH = os.path.join(os.path.dirname(os.path.realpath(__file__)), "../","config", "defaults.yaml")
-
-def load_config(user_config_path):
-    """Load configuration from defaults and merge in user config if present."""
-    if not os.path.exists(DEFAULT_CONFIG_PATH):
-        print(f"Default configuration file '{DEFAULT_CONFIG_PATH}' not found.")
-        sys.exit(5)
-    with open(DEFAULT_CONFIG_PATH, 'r') as f:
-        config = yaml.safe_load(f)
-    if "directories" not in config or "repositories" not in config:
-        print("Default config file must contain 'directories' and 'repositories' keys.")
-        sys.exit(6)
-    if os.path.exists(user_config_path):
-        with open(user_config_path, 'r') as f:
-            user_config = yaml.safe_load(f)
-        if user_config:
-            if "directories" in user_config:
-                config["directories"] = user_config["directories"]
-            if "repositories" in user_config:
-                config["repositories"].extend(user_config["repositories"])
-    for repository in config["repositories"]:
-        # You can overwritte the directory path in the config
-        if "directory" not in repository:
-            directory = get_repo_dir(config["directories"]["repositories"], repository)
-            repository["directory"] = os.path.expanduser(directory)
-    return config

pkgmgr/pull_with_verification.py

@@ -1,48 +0,0 @@
-import os
-import subprocess
-import sys
-from pkgmgr.get_repo_identifier import get_repo_identifier
-from pkgmgr.get_repo_dir import get_repo_dir
-from pkgmgr.verify import verify_repository
-
-def pull_with_verification(
-    selected_repos,
-    repositories_base_dir,
-    all_repos,
-    extra_args,
-    no_verification,
-    preview:bool):
-    """
-    Executes "git pull" for each repository with verification.
-    
-    Uses the verify_repository function in "pull" mode.
-    If verification fails (and verification info is set) and --no-verification is not enabled,
-    the user is prompted to confirm the pull.
-    """
-    for repo in selected_repos:
-        repo_identifier = get_repo_identifier(repo, all_repos)
-        repo_dir = get_repo_dir(repositories_base_dir, repo)
-        if not os.path.exists(repo_dir):
-            print(f"Repository directory '{repo_dir}' not found for {repo_identifier}.")
-            continue
-
-        verified_info = repo.get("verified")
-        verified_ok, errors, commit_hash, signing_key = verify_repository(repo, repo_dir, mode="pull", no_verification=no_verification)
-
-        if not no_verification and verified_info and not verified_ok:
-            print(f"Warning: Verification failed for {repo_identifier}:")
-            for err in errors:
-                print(f"  - {err}")
-            choice = input("Proceed with 'git pull'? (y/N): ").strip().lower()
-            if choice != "y":
-                continue
-
-        full_cmd = f"git pull {' '.join(extra_args)}"
-        if preview:
-            print(f"[Preview] In '{repo_dir}': {full_cmd}")
-        else:
-            print(f"Running in '{repo_dir}': {full_cmd}")
-            result = subprocess.run(full_cmd, cwd=repo_dir, shell=True)
-            if result.returncode != 0:
-                print(f"'git pull' for {repo_identifier} failed with exit code {result.returncode}.")
-                sys.exit(result.returncode)

pkgmgr/release.py

@@ -1,882 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-pkgmgr/release.py
-
-Release helper for pkgmgr.
-
-Responsibilities (Milestone 7):
-  - Determine the next semantic version based on existing Git tags.
-  - Update pyproject.toml with the new version.
-  - Update additional packaging files (flake.nix, PKGBUILD,
-    debian/changelog, RPM spec) where present.
-  - Prepend a basic entry to CHANGELOG.md.
-  - Commit, tag, and push the release on the current branch.
-
-Additional behaviour:
-  - If `preview=True` (from --preview), no files are written and no
-    Git commands are executed. Instead, a detailed summary of the
-    planned changes and commands is printed.
-  - If `preview=False` and not forced, the release is executed in two
-    phases:
-      1) Preview-only run (dry-run).
-      2) Interactive confirmation, then real release if confirmed.
-    This confirmation can be skipped with the `-f/--force` flag.
-"""
-
-from __future__ import annotations
-
-import argparse
-import os
-import re
-import subprocess
-import sys
-import tempfile
-from datetime import date, datetime
-from typing import Optional, Tuple
-
-from pkgmgr.git_utils import get_tags, get_current_branch, GitError
-from pkgmgr.versioning import (
-    SemVer,
-    find_latest_version,
-    bump_major,
-    bump_minor,
-    bump_patch,
-)
-
-
-# ---------------------------------------------------------------------------
-# Helpers for Git + version discovery
-# ---------------------------------------------------------------------------
-
-
-def _determine_current_version() -> SemVer:
-    """
-    Determine the current semantic version from Git tags.
-
-    Behaviour:
-      - If there are no tags or no SemVer-compatible tags, return 0.0.0.
-      - Otherwise, use the latest SemVer tag as current version.
-    """
-    tags = get_tags()
-    if not tags:
-        return SemVer(0, 0, 0)
-
-    latest = find_latest_version(tags)
-    if latest is None:
-        return SemVer(0, 0, 0)
-
-    _tag, ver = latest
-    return ver
-
-
-def _bump_semver(current: SemVer, release_type: str) -> SemVer:
-    """
-    Bump the given SemVer according to the release type.
-
-    release_type must be one of: "major", "minor", "patch".
-    """
-    if release_type == "major":
-        return bump_major(current)
-    if release_type == "minor":
-        return bump_minor(current)
-    if release_type == "patch":
-        return bump_patch(current)
-
-    raise ValueError(f"Unknown release type: {release_type!r}")
-
-
-# ---------------------------------------------------------------------------
-# Low-level Git command helper
-# ---------------------------------------------------------------------------
-
-
-def _run_git_command(cmd: str) -> None:
-    """
-    Run a Git (or shell) command with basic error reporting.
-
-    The command is executed via the shell, primarily for readability
-    when printed (as in 'git commit -am "msg"').
-    """
-    print(f"[GIT] {cmd}")
-    try:
-        subprocess.run(cmd, shell=True, check=True)
-    except subprocess.CalledProcessError as exc:
-        print(f"[ERROR] Git command failed: {cmd}")
-        print(f"        Exit code: {exc.returncode}")
-        if exc.stdout:
-            print("--- stdout ---")
-            print(exc.stdout)
-        if exc.stderr:
-            print("--- stderr ---")
-            print(exc.stderr)
-        raise GitError(f"Git command failed: {cmd}") from exc
-
-
-# ---------------------------------------------------------------------------
-# Editor helper for interactive changelog messages
-# ---------------------------------------------------------------------------
-
-
-def _open_editor_for_changelog(initial_message: Optional[str] = None) -> str:
-    """
-    Open $EDITOR (fallback 'nano') so the user can enter a changelog message.
-
-    The temporary file is pre-filled with commented instructions and an
-    optional initial_message. Lines starting with '#' are ignored when the
-    message is read back.
-
-    Returns the final message (may be empty string if user leaves it blank).
-    """
-    editor = os.environ.get("EDITOR", "nano")
-
-    with tempfile.NamedTemporaryFile(
-        mode="w+",
-        delete=False,
-        encoding="utf-8",
-    ) as tmp:
-        tmp_path = tmp.name
-        # Prefill with instructions as comments
-        tmp.write(
-            "# Write the changelog entry for this release.\n"
-            "# Lines starting with '#' will be ignored.\n"
-            "# Empty result will fall back to a generic message.\n\n"
-        )
-        if initial_message:
-            tmp.write(initial_message.strip() + "\n")
-        tmp.flush()
-
-    # Open editor
-    subprocess.call([editor, tmp_path])
-
-    # Read back content
-    try:
-        with open(tmp_path, "r", encoding="utf-8") as f:
-            content = f.read()
-    finally:
-        try:
-            os.remove(tmp_path)
-        except OSError:
-            pass
-
-    # Filter out commented lines and return joined text
-    lines = [
-        line for line in content.splitlines()
-        if not line.strip().startswith("#")
-    ]
-    return "\n".join(lines).strip()
-
-
-# ---------------------------------------------------------------------------
-# File update helpers (pyproject + extra packaging + changelog)
-# ---------------------------------------------------------------------------
-
-
-def update_pyproject_version(
-    pyproject_path: str,
-    new_version: str,
-    preview: bool = False,
-) -> None:
-    """
-    Update the version in pyproject.toml with the new version.
-
-    The function looks for a line matching:
-
-        version = "X.Y.Z"
-
-    and replaces the version part with the given new_version string.
-
-    It does not try to parse the full TOML structure here. This keeps the
-    implementation small and robust as long as the version line follows
-    the standard pattern.
-
-    Behaviour:
-      - In normal mode: write the updated content back to the file.
-      - In preview mode: do NOT write, only report what would change.
-    """
-    try:
-        with open(pyproject_path, "r", encoding="utf-8") as f:
-            content = f.read()
-    except FileNotFoundError:
-        print(f"[ERROR] pyproject.toml not found at: {pyproject_path}")
-        sys.exit(1)
-
-    pattern = r'^(version\s*=\s*")([^"]+)(")'
-    new_content, count = re.subn(
-        pattern,
-        lambda m: f'{m.group(1)}{new_version}{m.group(3)}',
-        content,
-        flags=re.MULTILINE,
-    )
-
-    if count == 0:
-        print("[ERROR] Could not find version line in pyproject.toml")
-        sys.exit(1)
-
-    if preview:
-        print(f"[PREVIEW] Would update pyproject.toml version to {new_version}")
-        return
-
-    with open(pyproject_path, "w", encoding="utf-8") as f:
-        f.write(new_content)
-
-    print(f"Updated pyproject.toml version to {new_version}")
-
-
-def update_flake_version(
-    flake_path: str,
-    new_version: str,
-    preview: bool = False,
-) -> None:
-    """
-    Update the version in flake.nix, if present.
-
-    Looks for a line like:
-        version = "1.2.3";
-
-    and replaces the string inside the quotes. If the file does not
-    exist or no version line is found, this is treated as a non-fatal
-    condition and only a log message is printed.
-    """
-    if not os.path.exists(flake_path):
-        print("[INFO] flake.nix not found, skipping.")
-        return
-
-    try:
-        with open(flake_path, "r", encoding="utf-8") as f:
-            content = f.read()
-    except Exception as exc:
-        print(f"[WARN] Could not read flake.nix: {exc}")
-        return
-
-    pattern = r'(version\s*=\s*")([^"]+)(")'
-    new_content, count = re.subn(
-        pattern,
-        lambda m: f'{m.group(1)}{new_version}{m.group(3)}',
-        content,
-    )
-
-    if count == 0:
-        print("[WARN] No version assignment found in flake.nix, skipping.")
-        return
-
-    if preview:
-        print(f"[PREVIEW] Would update flake.nix version to {new_version}")
-        return
-
-    with open(flake_path, "w", encoding="utf-8") as f:
-        f.write(new_content)
-
-    print(f"Updated flake.nix version to {new_version}")
-
-
-def update_pkgbuild_version(
-    pkgbuild_path: str,
-    new_version: str,
-    preview: bool = False,
-) -> None:
-    """
-    Update the version in PKGBUILD, if present.
-
-    Expects:
-        pkgver=1.2.3
-        pkgrel=1
-
-    Behaviour:
-      - Set pkgver to the new_version (e.g. 1.2.3).
-      - Reset pkgrel to 1.
-
-    If the file does not exist, this is non-fatal and only a log
-    message is printed.
-    """
-    if not os.path.exists(pkgbuild_path):
-        print("[INFO] PKGBUILD not found, skipping.")
-        return
-
-    try:
-        with open(pkgbuild_path, "r", encoding="utf-8") as f:
-            content = f.read()
-    except Exception as exc:
-        print(f"[WARN] Could not read PKGBUILD: {exc}")
-        return
-
-    # Update pkgver
-    ver_pattern = r"^(pkgver\s*=\s*)(.+)$"
-    new_content, ver_count = re.subn(
-        ver_pattern,
-        lambda m: f"{m.group(1)}{new_version}",
-        content,
-        flags=re.MULTILINE,
-    )
-
-    if ver_count == 0:
-        print("[WARN] No pkgver line found in PKGBUILD.")
-        new_content = content  # revert to original if we didn't change anything
-
-    # Reset pkgrel to 1
-    rel_pattern = r"^(pkgrel\s*=\s*)(.+)$"
-    new_content, rel_count = re.subn(
-        rel_pattern,
-        lambda m: f"{m.group(1)}1",
-        new_content,
-        flags=re.MULTILINE,
-    )
-
-    if rel_count == 0:
-        print("[WARN] No pkgrel line found in PKGBUILD.")
-
-    if preview:
-        print(f"[PREVIEW] Would update PKGBUILD to pkgver={new_version}, pkgrel=1")
-        return
-
-    with open(pkgbuild_path, "w", encoding="utf-8") as f:
-        f.write(new_content)
-
-    print(f"Updated PKGBUILD to pkgver={new_version}, pkgrel=1")
-
-
-def update_spec_version(
-    spec_path: str,
-    new_version: str,
-    preview: bool = False,
-) -> None:
-    """
-    Update the version in an RPM spec file, if present.
-
-    Assumes a file like 'package-manager.spec' with lines:
-
-        Version: 1.2.3
-        Release: 1%{?dist}
-
-    Behaviour:
-      - Set 'Version:' to new_version.
-      - Reset 'Release:' to '1' while preserving any macro suffix,
-        e.g. '1%{?dist}'.
-
-    If the file does not exist, this is non-fatal and only a log
-    message is printed.
-    """
-    if not os.path.exists(spec_path):
-        print("[INFO] RPM spec file not found, skipping.")
-        return
-
-    try:
-        with open(spec_path, "r", encoding="utf-8") as f:
-            content = f.read()
-    except Exception as exc:
-        print(f"[WARN] Could not read spec file: {exc}")
-        return
-
-    # Update Version:
-    ver_pattern = r"^(Version:\s*)(.+)$"
-    new_content, ver_count = re.subn(
-        ver_pattern,
-        lambda m: f"{m.group(1)}{new_version}",
-        content,
-        flags=re.MULTILINE,
-    )
-
-    if ver_count == 0:
-        print("[WARN] No 'Version:' line found in spec file.")
-
-    # Reset Release:
-    rel_pattern = r"^(Release:\s*)(.+)$"
-
-    def _release_repl(m: re.Match[str]) -> str:  # type: ignore[name-defined]
-        rest = m.group(2).strip()
-        # Reset numeric prefix to "1" and keep any suffix (e.g. % macros).
-        match = re.match(r"^(\d+)(.*)$", rest)
-        if match:
-            suffix = match.group(2)
-        else:
-            suffix = ""
-        return f"{m.group(1)}1{suffix}"
-
-    new_content, rel_count = re.subn(
-        rel_pattern,
-        _release_repl,
-        new_content,
-        flags=re.MULTILINE,
-    )
-
-    if rel_count == 0:
-        print("[WARN] No 'Release:' line found in spec file.")
-
-    if preview:
-        print(
-            f"[PREVIEW] Would update spec file "
-            f"{os.path.basename(spec_path)} to Version: {new_version}, Release: 1..."
-        )
-        return
-
-    with open(spec_path, "w", encoding="utf-8") as f:
-        f.write(new_content)
-
-    print(
-        f"Updated spec file {os.path.basename(spec_path)} "
-        f"to Version: {new_version}, Release: 1..."
-    )
-
-
-def update_changelog(
-    changelog_path: str,
-    new_version: str,
-    message: Optional[str] = None,
-    preview: bool = False,
-) -> str:
-    """
-    Prepend a new release section to CHANGELOG.md with the new version,
-    current date, and a message.
-
-    Behaviour:
-      - If message is None and preview is False:
-          → open $EDITOR (fallback 'nano') to let the user enter a message.
-      - If message is None and preview is True:
-          → use a generic automated message.
-      - The resulting changelog entry is printed to stdout.
-      - Returns the final message text used.
-    """
-    today = date.today().isoformat()
-
-    # Resolve message
-    if message is None:
-        if preview:
-            # Do not open editor in preview mode; keep it non-interactive.
-            message = "Automated release."
-        else:
-            print(
-                "\n[INFO] No release message provided, opening editor for "
-                "changelog entry...\n"
-            )
-            editor_message = _open_editor_for_changelog()
-            if not editor_message:
-                message = "Automated release."
-            else:
-                message = editor_message
-
-    header = f"## [{new_version}] - {today}\n"
-    header += f"\n* {message}\n\n"
-
-    if os.path.exists(changelog_path):
-        try:
-            with open(changelog_path, "r", encoding="utf-8") as f:
-                changelog = f.read()
-        except Exception as exc:
-            print(f"[WARN] Could not read existing CHANGELOG.md: {exc}")
-            changelog = ""
-    else:
-        changelog = ""
-
-    new_changelog = header + "\n" + changelog if changelog else header
-
-    # Show the entry that will be written
-    print("\n================ CHANGELOG ENTRY ================")
-    print(header.rstrip())
-    print("=================================================\n")
-
-    if preview:
-        print(f"[PREVIEW] Would prepend new entry for {new_version} to CHANGELOG.md")
-        return message
-
-    with open(changelog_path, "w", encoding="utf-8") as f:
-        f.write(new_changelog)
-
-    print(f"Updated CHANGELOG.md with version {new_version}")
-
-    return message
-
-
-# ---------------------------------------------------------------------------
-# Debian changelog helpers (with Git config fallback for maintainer)
-# ---------------------------------------------------------------------------
-
-
-def _get_git_config_value(key: str) -> Optional[str]:
-    """
-    Try to read a value from `git config --get <key>`.
-
-    Returns the stripped value or None if not set / on error.
-    """
-    try:
-        result = subprocess.run(
-            ["git", "config", "--get", key],
-            capture_output=True,
-            text=True,
-            check=False,
-        )
-    except Exception:
-        return None
-
-    value = result.stdout.strip()
-    return value or None
-
-
-def _get_debian_author() -> Tuple[str, str]:
-    """
-    Determine the maintainer name/email for debian/changelog entries.
-
-    Priority:
-      1. DEBFULLNAME / DEBEMAIL
-      2. GIT_AUTHOR_NAME / GIT_AUTHOR_EMAIL
-      3. git config user.name / user.email
-      4. Fallback: 'Unknown Maintainer' / 'unknown@example.com'
-    """
-    name = os.environ.get("DEBFULLNAME")
-    email = os.environ.get("DEBEMAIL")
-
-    if not name:
-        name = os.environ.get("GIT_AUTHOR_NAME")
-    if not email:
-        email = os.environ.get("GIT_AUTHOR_EMAIL")
-
-    if not name:
-        name = _get_git_config_value("user.name")
-    if not email:
-        email = _get_git_config_value("user.email")
-
-    if not name:
-        name = "Unknown Maintainer"
-    if not email:
-        email = "unknown@example.com"
-
-    return name, email
-
-
-def update_debian_changelog(
-    debian_changelog_path: str,
-    package_name: str,
-    new_version: str,
-    message: Optional[str] = None,
-    preview: bool = False,
-) -> None:
-    """
-    Prepend a new entry to debian/changelog, if it exists.
-
-    The first line typically looks like:
-        package-name (1.2.3-1) unstable; urgency=medium
-
-    We generate a new stanza at the top with Debian-style version
-    'X.Y.Z-1'. If the file does not exist, this function does nothing.
-    """
-    if not os.path.exists(debian_changelog_path):
-        print("[INFO] debian/changelog not found, skipping.")
-        return
-
-    debian_version = f"{new_version}-1"
-    now = datetime.now().astimezone()
-    # Debian-like date string, e.g. "Mon, 08 Dec 2025 12:34:56 +0100"
-    date_str = now.strftime("%a, %d %b %Y %H:%M:%S %z")
-
-    author_name, author_email = _get_debian_author()
-
-    first_line = f"{package_name} ({debian_version}) unstable; urgency=medium"
-    body_line = (
-        message.strip() if message else f"Automated release {new_version}."
-    )
-    stanza = (
-        f"{first_line}\n\n"
-        f"  * {body_line}\n\n"
-        f" -- {author_name} <{author_email}>  {date_str}\n\n"
-    )
-
-    if preview:
-        print(
-            "[PREVIEW] Would prepend the following stanza to debian/changelog:\n"
-            f"{stanza}"
-        )
-        return
-
-    try:
-        with open(debian_changelog_path, "r", encoding="utf-8") as f:
-            existing = f.read()
-    except Exception as exc:
-        print(f"[WARN] Could not read debian/changelog: {exc}")
-        existing = ""
-
-    new_content = stanza + existing
-
-    with open(debian_changelog_path, "w", encoding="utf-8") as f:
-        f.write(new_content)
-
-    print(f"Updated debian/changelog with version {debian_version}")
-
-
-# ---------------------------------------------------------------------------
-# Internal implementation (single-phase, preview or real)
-# ---------------------------------------------------------------------------
-
-
-def _release_impl(
-    pyproject_path: str = "pyproject.toml",
-    changelog_path: str = "CHANGELOG.md",
-    release_type: str = "patch",
-    message: Optional[str] = None,
-    preview: bool = False,
-) -> None:
-    """
-    Internal implementation that performs a single-phase release.
-
-    If `preview` is True:
-      - No files are written.
-      - No git commands are executed.
-      - Planned actions are printed.
-
-    If `preview` is False:
-      - Files are updated.
-      - Git commit, tag, and push are executed.
-    """
-    # 1) Determine the current version from Git tags.
-    current_ver = _determine_current_version()
-
-    # 2) Compute the next version.
-    new_ver = _bump_semver(current_ver, release_type)
-    new_ver_str = str(new_ver)
-    new_tag = new_ver.to_tag(with_prefix=True)
-
-    mode = "PREVIEW" if preview else "REAL"
-    print(f"Release mode: {mode}")
-    print(f"Current version: {current_ver}")
-    print(f"New version:     {new_ver_str} ({release_type})")
-
-    # Determine repository root based on pyproject location
-    repo_root = os.path.dirname(os.path.abspath(pyproject_path))
-
-    # 2) Update files.
-    update_pyproject_version(pyproject_path, new_ver_str, preview=preview)
-    # Let update_changelog resolve or edit the message; reuse it for debian.
-    message = update_changelog(
-        changelog_path,
-        new_ver_str,
-        message=message,
-        preview=preview,
-    )
-
-    # Additional packaging files (non-fatal if missing)
-    flake_path = os.path.join(repo_root, "flake.nix")
-    update_flake_version(flake_path, new_ver_str, preview=preview)
-
-    pkgbuild_path = os.path.join(repo_root, "PKGBUILD")
-    update_pkgbuild_version(pkgbuild_path, new_ver_str, preview=preview)
-
-    spec_path = os.path.join(repo_root, "package-manager.spec")
-    update_spec_version(spec_path, new_ver_str, preview=preview)
-
-    debian_changelog_path = os.path.join(repo_root, "debian", "changelog")
-    # Use repo directory name as a simple default for package name
-    package_name = os.path.basename(repo_root) or "package-manager"
-    update_debian_changelog(
-        debian_changelog_path,
-        package_name=package_name,
-        new_version=new_ver_str,
-        message=message,
-        preview=preview,
-    )
-
-    # 3) Git operations: stage, commit, tag, push.
-    commit_msg = f"Release version {new_ver_str}"
-    tag_msg = message or commit_msg
-
-    try:
-        branch = get_current_branch() or "main"
-    except GitError:
-        branch = "main"
-    print(f"Releasing on branch: {branch}")
-
-    # Stage all relevant packaging files so they are included in the commit
-    files_to_add = [
-        pyproject_path,
-        changelog_path,
-        flake_path,
-        pkgbuild_path,
-        spec_path,
-        debian_changelog_path,
-    ]
-    existing_files = [p for p in files_to_add if p and os.path.exists(p)]
-
-    if preview:
-        for path in existing_files:
-            print(f"[PREVIEW] Would run: git add {path}")
-        print(f'[PREVIEW] Would run: git commit -am "{commit_msg}"')
-        print(f'[PREVIEW] Would run: git tag -a {new_tag} -m "{tag_msg}"')
-        print(f"[PREVIEW] Would run: git push origin {branch}")
-        print("[PREVIEW] Would run: git push origin --tags")
-        print("Preview completed. No changes were made.")
-        return
-
-    for path in existing_files:
-        _run_git_command(f"git add {path}")
-
-    _run_git_command(f'git commit -am "{commit_msg}"')
-    _run_git_command(f'git tag -a {new_tag} -m "{tag_msg}"')
-    _run_git_command(f"git push origin {branch}")
-    _run_git_command("git push origin --tags")
-
-    print(f"Release {new_ver_str} completed.")
-
-
-# ---------------------------------------------------------------------------
-# Public release entry point (with preview-first + confirmation logic)
-# ---------------------------------------------------------------------------
-
-
-def release(
-    pyproject_path: str = "pyproject.toml",
-    changelog_path: str = "CHANGELOG.md",
-    release_type: str = "patch",
-    message: Optional[str] = None,
-    preview: bool = False,
-    force: bool = False,
-) -> None:
-    """
-    High-level release entry point.
-
-    Modes:
-
-    - preview=True:
-        * Single-phase PREVIEW only.
-        * No files are changed, no git commands are executed.
-        * `force` is ignored in this mode.
-
-    - preview=False, force=True:
-        * Single-phase REAL release, no interactive preview.
-        * Files are changed and git commands are executed immediately.
-
-    - preview=False, force=False:
-        * Two-phase flow (intended default for interactive CLI use):
-            1) PREVIEW: dry-run, printing all planned actions.
-            2) Ask the user for confirmation:
-                 "Proceed with the actual release? [y/N]: "
-               If confirmed, perform the REAL release.
-               Otherwise, abort without changes.
-
-        * In non-interactive environments (stdin not a TTY), the
-          confirmation step is skipped automatically and a single
-          REAL phase is executed, to avoid blocking on input().
-    """
-    # Explicit preview mode: just do a single PREVIEW phase and exit.
-    if preview:
-        _release_impl(
-            pyproject_path=pyproject_path,
-            changelog_path=changelog_path,
-            release_type=release_type,
-            message=message,
-            preview=True,
-        )
-        return
-
-    # Non-preview, but forced: run REAL release directly.
-    if force:
-        _release_impl(
-            pyproject_path=pyproject_path,
-            changelog_path=changelog_path,
-            release_type=release_type,
-            message=message,
-            preview=False,
-        )
-        return
-
-    # Non-interactive environment? Skip confirmation to avoid blocking.
-    if not sys.stdin.isatty():
-        _release_impl(
-            pyproject_path=pyproject_path,
-            changelog_path=changelog_path,
-            release_type=release_type,
-            message=message,
-            preview=False,
-        )
-        return
-
-    # Interactive two-phase flow:
-    print("[INFO] Running preview before actual release...\n")
-    _release_impl(
-        pyproject_path=pyproject_path,
-        changelog_path=changelog_path,
-        release_type=release_type,
-        message=message,
-        preview=True,
-    )
-
-    # Ask for confirmation
-    try:
-        answer = input("Proceed with the actual release? [y/N]: ").strip().lower()
-    except (EOFError, KeyboardInterrupt):
-        print("\n[INFO] Release aborted (no confirmation).")
-        return
-
-    if answer not in ("y", "yes"):
-        print("Release aborted by user. No changes were made.")
-        return
-
-    print("\n[INFO] Running REAL release...\n")
-    _release_impl(
-        pyproject_path=pyproject_path,
-        changelog_path=changelog_path,
-        release_type=release_type,
-        message=message,
-        preview=False,
-    )
-
-
-# ---------------------------------------------------------------------------
-# CLI entry point for standalone use
-# ---------------------------------------------------------------------------
-
-
-def _parse_args(argv: Optional[list[str]] = None) -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="pkgmgr release helper")
-    parser.add_argument(
-        "release_type",
-        choices=["major", "minor", "patch"],
-        help="Type of release (major/minor/patch).",
-    )
-    parser.add_argument(
-        "-m",
-        "--message",
-        dest="message",
-        default=None,
-        help="Release message to use for changelog and tag.",
-    )
-    parser.add_argument(
-        "--pyproject",
-        dest="pyproject",
-        default="pyproject.toml",
-        help="Path to pyproject.toml (default: pyproject.toml)",
-    )
-    parser.add_argument(
-        "--changelog",
-        dest="changelog",
-        default="CHANGELOG.md",
-        help="Path to CHANGELOG.md (default: CHANGELOG.md)",
-    )
-    parser.add_argument(
-        "--preview",
-        action="store_true",
-        help=(
-            "Preview release changes without modifying files or running git. "
-            "This mode never executes the real release."
-        ),
-    )
-    parser.add_argument(
-        "-f",
-        "--force",
-        dest="force",
-        action="store_true",
-        help=(
-            "Skip the interactive preview+confirmation step and run the "
-            "release directly."
-        ),
-    )
-    return parser.parse_args(argv)
-
-
-if __name__ == "__main__":
-    args = _parse_args()
-    release(
-        pyproject_path=args.pyproject,
-        changelog_path=args.changelog,
-        release_type=args.release_type,
-        message=args.message,
-        preview=args.preview,
-        force=args.force,
-    )

pkgmgr/resolve_command.py

@@ -1,113 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-Command resolver for repositories.
-
-This module determines the correct command to expose via symlink.
-It implements the following priority:
-
-1. Explicit command in repo config                 → command
-2. System package manager binary (/usr/...)        → NO LINK (respect OS)
-3. Nix profile binary (~/.nix-profile/bin/<id>)    → command
-4. Python / non-system console script on PATH      → command
-5. Fallback: repository's main.sh or main.py       → command
-6. If nothing is available                         → raise error
-
-The actual symlink creation is handled by create_ink(). This resolver
-only decides *what* should be used as the entrypoint, or whether no
-link should be created at all.
-"""
-
-import os
-import shutil
-from typing import Optional
-
-
-def resolve_command_for_repo(repo, repo_identifier: str, repo_dir: str) -> Optional[str]:
-    """
-    Determine the command for this repository.
-
-    Returns:
-        str  → path to the command (a symlink should be created)
-        None → do NOT create a link (e.g. system package already provides it)
-
-    On total failure (no suitable command found at any layer), this function
-    raises SystemExit with a descriptive error message.
-    """
-    # ------------------------------------------------------------
-    # 1. Explicit command defined by repository config
-    # ------------------------------------------------------------
-    explicit = repo.get("command")
-    if explicit:
-        return explicit
-
-    home = os.path.expanduser("~")
-
-    def is_executable(path: str) -> bool:
-        return os.path.exists(path) and os.access(path, os.X_OK)
-
-    # ------------------------------------------------------------
-    # 2. System package manager binary via PATH
-    #
-    #    If the binary lives under /usr/, we treat it as a system-managed
-    #    package (e.g. installed via pacman/apt/yum). In that case, pkgmgr
-    #    does NOT create a link at all and defers entirely to the OS.
-    # ------------------------------------------------------------
-    path_candidate = shutil.which(repo_identifier)
-    system_binary: Optional[str] = None
-    non_system_binary: Optional[str] = None
-
-    if path_candidate:
-        if path_candidate.startswith("/usr/"):
-            system_binary = path_candidate
-        else:
-            non_system_binary = path_candidate
-
-    if system_binary:
-        # Respect system package manager: do not create a link.
-        if repo.get("debug", False):
-            print(
-                f"[pkgmgr] System binary for '{repo_identifier}' found at "
-                f"{system_binary}; no symlink will be created."
-            )
-        return None
-
-    # ------------------------------------------------------------
-    # 3. Nix profile binary (~/.nix-profile/bin/<identifier>)
-    # ------------------------------------------------------------
-    nix_candidate = os.path.join(home, ".nix-profile", "bin", repo_identifier)
-    if is_executable(nix_candidate):
-        return nix_candidate
-
-    # ------------------------------------------------------------
-    # 4. Python / non-system console script on PATH
-    #
-    #    Here we reuse the non-system PATH candidate (e.g. from a venv or
-    #    a user-local install like ~/.local/bin). This is treated as a
-    #    valid command target.
-    # ------------------------------------------------------------
-    if non_system_binary and is_executable(non_system_binary):
-        return non_system_binary
-
-    # ------------------------------------------------------------
-    # 5. Fallback: main.sh / main.py inside the repository
-    # ------------------------------------------------------------
-    main_sh = os.path.join(repo_dir, "main.sh")
-    main_py = os.path.join(repo_dir, "main.py")
-
-    if is_executable(main_sh):
-        return main_sh
-
-    if is_executable(main_py) or os.path.exists(main_py):
-        return main_py
-
-    # ------------------------------------------------------------
-    # 6. Nothing found → treat as a hard error
-    # ------------------------------------------------------------
-    raise SystemExit(
-        f"No executable command could be resolved for repository '{repo_identifier}'. "
-        "No explicit 'command' configured, no system-managed binary under /usr/, "
-        "no Nix profile binary, no non-system console script on PATH, and no "
-        "main.sh/main.py found in the repository."
-    )

pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "package-manager"
-version = "0.2.0"
+version = "0.10.1"
 description = "Kevin's package-manager tool (pkgmgr)"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -39,13 +39,13 @@ pkgmgr = "pkgmgr.cli:main"
 # -----------------------------
 # setuptools configuration
 # -----------------------------
-# We use find_packages(), not a fixed list,
-# and explicitly include pkgmgr* and config*
+# Source layout: all packages live under "src/"
+[tool.setuptools]
+package-dir = { "" = "src", "config" = "config" }
 
 [tool.setuptools.packages.find]
-where = ["."]
+where = ["src", "."]
 include = ["pkgmgr*", "config*"]
 
-# Ensure defaults.yaml is shipped inside wheels & nix builds
 [tool.setuptools.package-data]
 "config" = ["defaults.yaml"]

scripts/build/build-image-missing.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "${SCRIPT_DIR}/resolve-base-image.sh"
+
+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)"
+    exit 0
+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" \
+    .

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

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "${SCRIPT_DIR}/resolve-base-image.sh"
+
+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" \
+  .

scripts/build/build-image.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "${SCRIPT_DIR}/resolve-base-image.sh"
+
+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" \
+  .

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,92 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# ---------------------------------------------------------------------------
+# Detect and export a valid CA bundle so Nix, Git, curl and Python tooling
+# can successfully perform HTTPS requests on all distros (Debian, Ubuntu,
+# Fedora, RHEL, CentOS, etc.)
+# ---------------------------------------------------------------------------
+detect_ca_bundle() {
+  # Common CA bundle locations across major Linux distributions
+  local candidates=(
+    /etc/ssl/certs/ca-certificates.crt                       # Debian/Ubuntu
+    /etc/ssl/cert.pem                                       # Some distros
+    /etc/pki/tls/certs/ca-bundle.crt                        # Fedora/RHEL/CentOS
+    /etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem       # CentOS/RHEL extracted bundle
+    /etc/ssl/ca-bundle.pem                                  # Generic fallback
+  )
+
+  for path in "${candidates[@]}"; do
+    if [[ -f "$path" ]]; then
+      echo "$path"
+      return 0
+    fi
+  done
+
+  return 1
+}
+
+# Use existing NIX_SSL_CERT_FILE if provided, otherwise auto-detect
+CA_BUNDLE="${NIX_SSL_CERT_FILE:-}"
+
+if [[ -z "${CA_BUNDLE}" ]]; then
+  CA_BUNDLE="$(detect_ca_bundle || true)"
+fi
+
+if [[ -n "${CA_BUNDLE}" ]]; then
+  # Export for Nix (critical)
+  export NIX_SSL_CERT_FILE="${CA_BUNDLE}"
+
+  # Export for Git, Python requests, curl, etc.
+  export SSL_CERT_FILE="${CA_BUNDLE}"
+  export REQUESTS_CA_BUNDLE="${CA_BUNDLE}"
+  export GIT_SSL_CAINFO="${CA_BUNDLE}"
+
+  echo "[docker] Using CA bundle: ${CA_BUNDLE}"
+else
+  echo "[docker] WARNING: No CA certificate bundle found."
+  echo "[docker] HTTPS access for Nix flakes and other tools may fail."
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+echo "[docker] Starting package-manager container"
+
+# ---------------------------------------------------------------------------
+# Log distribution info
+# ---------------------------------------------------------------------------
+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: rebuild package-manager from the mounted /src tree
+# ---------------------------------------------------------------------------
+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 or 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,237 @@
 #!/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'..."
+    # Resolve a valid shell path across distros:
+    # - Debian/Ubuntu: /bin/bash
+    # - Arch:          /usr/bin/bash (often symlinked)
+    # Fall back to /bin/sh on ultra-minimal systems.
+    BASH_SHELL="$(command -v bash || true)"
+    if [[ -z "${BASH_SHELL}" ]]; then
+      BASH_SHELL="/bin/sh"
+    fi
+    useradd -m -r -g nixbld -s "${BASH_SHELL}" nix
+  fi
+
+  # Ensure /nix exists and is writable by the "nix" user.
+  #
+  # In some base images (or previous runs), /nix may already exist and be
+  # owned by root. In that case the Nix single-user installer will abort with:
+  #
+  #   "directory /nix exists, but is not writable by you"
+  #
+  # To keep container runs idempotent and robust, we always enforce
+  # ownership nix:nixbld here.
+  if [[ ! -d /nix ]]; then
+    echo "[init-nix] Creating /nix with owner nix:nixbld..."
+    mkdir -m 0755 /nix
+    chown nix:nixbld /nix
+  else
+    current_owner="$(stat -c '%U' /nix 2>/dev/null || echo '?')"
+    current_group="$(stat -c '%G' /nix 2>/dev/null || echo '?')"
+    if [[ "${current_owner}" != "nix" || "${current_group}" != "nixbld" ]]; then
+      echo "[init-nix] /nix already exists with owner ${current_owner}:${current_group} – fixing to nix:nixbld..."
+      chown -R nix:nixbld /nix
+    else
+      echo "[init-nix] /nix already exists with correct owner nix:nixbld."
+    fi
+
+    if [[ ! -w /nix ]]; then
+      echo "[init-nix] WARNING: /nix is still not writable after chown; Nix installer may fail."
+    fi
+  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,30 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "[arch/package] Building Arch package (makepkg --nodeps)..."
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "${SCRIPT_DIR}/../../.." && pwd)"
+PKG_DIR="${PROJECT_ROOT}/packaging/arch"
+
+if [[ ! -f "${PKG_DIR}/PKGBUILD" ]]; then
+  echo "[arch/package] ERROR: PKGBUILD not found in ${PKG_DIR}"
+  exit 1
+fi
+
+cd "${PKG_DIR}"
+
+if id aur_builder >/dev/null 2>&1; then
+  echo "[arch/package] Using 'aur_builder' user for makepkg..."
+  chown -R aur_builder:aur_builder "${PKG_DIR}"
+  su aur_builder -c "cd '${PKG_DIR}' && 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,21 @@
+#!/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 \
+  sudo \
+  xz
+
+dnf clean all
+
+echo "[centos/dependencies] Done."

scripts/installation/centos/package.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "[centos/package] Setting up rpmbuild directories..."
+mkdir -p /root/rpmbuild/{BUILD,RPMS,SOURCES,SPECS,SRPMS}
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "${SCRIPT_DIR}/../../.." && pwd)"
+SPEC_PATH="${PROJECT_ROOT}/packaging/fedora/package-manager.spec"
+
+if [[ ! -f "${SPEC_PATH}" ]]; then
+  echo "[centos/package] ERROR: SPEC file not found: ${SPEC_PATH}"
+  exit 1
+fi
+
+echo "[centos/package] Extracting version from package-manager.spec..."
+version="$(grep -E '^Version:' "${SPEC_PATH}" | 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 "${PROJECT_ROOT}/." "/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 "${SPEC_PATH}" /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,32 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "[debian/package] Building Debian package..."
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "${SCRIPT_DIR}/../../.." && pwd)"
+
+BUILD_ROOT="/tmp/package-manager-debian-build"
+rm -rf "${BUILD_ROOT}"
+mkdir -p "${BUILD_ROOT}"
+
+echo "[debian/package] Syncing project sources to ${BUILD_ROOT}..."
+rsync -a \
+  --exclude 'packaging/debian' \
+  "${PROJECT_ROOT}/" "${BUILD_ROOT}/"
+
+echo "[debian/package] Overlaying debian/ metadata from packaging/debian..."
+mkdir -p "${BUILD_ROOT}/debian"
+cp -a "${PROJECT_ROOT}/packaging/debian/." "${BUILD_ROOT}/debian/"
+
+cd "${BUILD_ROOT}"
+
+echo "[debian/package] Running dpkg-buildpackage..."
+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,52 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "[fedora/package] Setting up rpmbuild directories..."
+mkdir -p /root/rpmbuild/{BUILD,RPMS,SOURCES,SPECS,SRPMS}
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "${SCRIPT_DIR}/../../.." && pwd)"
+SPEC_PATH="${PROJECT_ROOT}/packaging/fedora/package-manager.spec"
+
+if [[ ! -f "${SPEC_PATH}" ]]; then
+  echo "[fedora/package] ERROR: SPEC file not found: ${SPEC_PATH}"
+  exit 1
+fi
+
+echo "[fedora/package] Extracting version from package-manager.spec..."
+version="$(grep -E '^Version:' "${SPEC_PATH}" | 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 "${PROJECT_ROOT}/." "/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 "${SPEC_PATH}" /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,87 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# ------------------------------------------------------------
+# main.sh
+#
+# Developer / system setup entrypoint.
+#
+# Responsibilities:
+#   - If inside a Nix shell (IN_NIX_SHELL=1):
+#       * Skip venv creation and dependency installation
+#       * Run `python3 main.py install`
+#   - If running as root (EUID=0):
+#       * Run system-level installer (run-package.sh)
+#   - Otherwise (normal user):
+#       * 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 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'
+
+# ------------------------------------------------------------
+# 1) 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] Setup finished (Nix mode)."
+    exit 0
+fi
+
+# ------------------------------------------------------------
+# 2) Root mode: system / distro-level installation
+# ------------------------------------------------------------
+if [[ "${EUID:-$(id -u)}" -eq 0 ]]; then
+    echo "[installation/main] Running as root (EUID=0)."
+    echo "[installation/main] Skipping user virtualenv and shell RC modifications."
+    echo "[installation/main] Delegating to scripts/installation/run-package.sh..."
+    bash scripts/installation/run-package.sh
+    echo "[installation/main] Root/system setup complete."
+    exit 0
+fi
+
+# ------------------------------------------------------------
+# 3) Normal user mode: dev setup with venv
+# ------------------------------------------------------------
+
+echo "[installation/main] Running in normal user mode (developer setup)."
+
+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"
+
+echo "[installation/main] Creating/updating virtualenv via helper..."
+PKGMGR_VENV_DIR="${VENV_DIR}" bash scripts/installation/venv-create.sh
+
+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,35 @@
+#!/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)"
+
+# Map Manjaro to Arch
+if [[ "${OS_ID}" == "manjaro" ]]; then
+  echo "[run-package] Mapping OS 'manjaro' → 'arch'"
+  OS_ID="arch"
+fi
+
+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,32 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "[ubuntu/package] Building Ubuntu (Debian-style) package..."
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "${SCRIPT_DIR}/../../.." && pwd)"
+
+BUILD_ROOT="/tmp/package-manager-ubuntu-build"
+rm -rf "${BUILD_ROOT}"
+mkdir -p "${BUILD_ROOT}"
+
+echo "[ubuntu/package] Syncing project sources to ${BUILD_ROOT}..."
+rsync -a \
+  --exclude 'packaging/debian' \
+  "${PROJECT_ROOT}/" "${BUILD_ROOT}/"
+
+echo "[ubuntu/package] Overlaying debian/ metadata from packaging/debian..."
+mkdir -p "${BUILD_ROOT}/debian"
+cp -a "${PROJECT_ROOT}/packaging/debian/." "${BUILD_ROOT}/debian/"
+
+cd "${BUILD_ROOT}"
+
+echo "[ubuntu/package] Running dpkg-buildpackage..."
+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/installation/venv-create.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# venv-create.sh
+#
+# Small helper to create/update a Python virtual environment for pkgmgr.
+#
+# Usage:
+#   PKGMGR_VENV_DIR=/home/dev/.venvs/pkgmgr bash scripts/installation/venv-create.sh
+# or
+#   bash scripts/installation/venv-create.sh /home/dev/.venvs/pkgmgr
+
+PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+cd "${PROJECT_ROOT}"
+
+VENV_DIR="${PKGMGR_VENV_DIR:-${1:-${HOME}/.venvs/pkgmgr}}"
+
+echo "[venv-create] Using VENV_DIR=${VENV_DIR}"
+
+echo "[venv-create] Ensuring virtualenv parent directory exists..."
+mkdir -p "$(dirname "${VENV_DIR}")"
+
+if [[ ! -d "${VENV_DIR}" ]]; then
+    echo "[venv-create] Creating virtual environment at: ${VENV_DIR}"
+    python3 -m venv "${VENV_DIR}"
+else
+    echo "[venv-create] Virtual environment already exists at: ${VENV_DIR}"
+fi
+
+echo "[venv-create] 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 "[venv-create] Installing dependencies from requirements.txt..."
+    "${VENV_DIR}/bin/pip" install -r requirements.txt
+elif [[ -f "_requirements.txt" ]]; then
+    echo "[venv-create] Installing dependencies from _requirements.txt..."
+    "${VENV_DIR}/bin/pip" install -r _requirements.txt
+else
+    echo "[venv-create] No requirements.txt or _requirements.txt found. Skipping dependency installation."
+fi
+
+echo "[venv-create] Done."

scripts/pkgmgr-wrapper.sh

@@ -1,10 +1,48 @@
 #!/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 (common locations + container user)
+# ---------------------------------------------------------------------------
+if ! command -v nix >/dev/null 2>&1; then
+  CANDIDATES=(
+    "/nix/var/nix/profiles/default/bin/nix"
+    "${HOME:-/root}/.nix-profile/bin/nix"
+    "/home/nix/.nix-profile/bin/nix"
+  )
+
+  for candidate in "${CANDIDATES[@]}"; do
+    if [[ -x "$candidate" ]]; then
+      PATH="$(dirname "$candidate"):${PATH}"
+      export PATH
+      break
+    fi
+  done
+fi
+
+# ---------------------------------------------------------------------------
+# If nix is still missing, try to run init-nix.sh once
+# ---------------------------------------------------------------------------
+if ! command -v nix >/dev/null 2>&1; then
+  if [[ -x "${FLAKE_DIR}/init-nix.sh" ]]; then
+    "${FLAKE_DIR}/init-nix.sh" || true
+  fi
+fi
+
+# ---------------------------------------------------------------------------
+# Primary 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 after init."
+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,32 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+IMAGE="package-manager-test-$distro"
+
+echo
+echo "------------------------------------------------------------"
+echo ">>> Testing container: $IMAGE"
+echo "------------------------------------------------------------"
+echo "[test-container] Inspect image metadata:"
+docker image inspect "$IMAGE" | sed -n '1,40p'
+
+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 pkgmgr_nix_store_${distro}:/nix \
+        -v "$(pwd):/src" \
+        -v "pkgmgr_nix_cache_${distro}:/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

scripts/test/test-e2e.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "============================================================"
+echo ">>> Running E2E tests: $distro"
+echo "============================================================"
+
+docker run --rm \
+  -v "$(pwd):/src" \
+  -v "pkgmgr_nix_store_${distro}:/nix" \
+  -v "pkgmgr_nix_cache_${distro}:/root/.cache/nix" \
+  -e PKGMGR_DEV=1 \
+  -e TEST_PATTERN="${TEST_PATTERN}" \
+  --workdir /src \
+  "package-manager-test-${distro}" \
+  bash -lc '
+    set -euo pipefail
+
+    # Load distro info
+    if [ -f /etc/os-release ]; then
+      . /etc/os-release
+    fi
+
+    echo "Running tests inside distro: ${ID:-unknown}"
+
+    # Load Nix environment if available
+    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
+    }
+
+    # Mark the mounted repository as safe to avoid Git ownership errors.
+    # Newer Git (e.g. on Ubuntu) complains about the gitdir (/src/.git),
+    # older versions about the worktree (/src). Nix turns "." into the
+    # flake input "git+file:///src", which then uses Git under the hood.
+    if command -v git >/dev/null 2>&1; then
+      # Worktree path
+      git config --global --add safe.directory /src || true
+      # Gitdir path shown in the "dubious ownership" error
+      git config --global --add safe.directory /src/.git || true
+      # Ephemeral CI containers: allow all paths as a last resort
+      git config --global --add safe.directory '*' || true
+    fi
+
+    # Run the E2E tests inside the Nix development shell
+    nix develop .#default --no-write-lock-file -c \
+      python3 -m unittest discover \
+        -s /src/tests/e2e \
+        -p "$TEST_PATTERN"
+  '

scripts/test/test-integration.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "============================================================"
+echo ">>> Running INTEGRATION tests in ${distro} container"
+echo "============================================================"
+
+docker run --rm \
+  -v "$(pwd):/src" \
+  -v pkgmgr_nix_store_${distro}:/nix \
+  -v "pkgmgr_nix_cache_${distro}:/root/.cache/nix" \
+  --workdir /src \
+  -e PKGMGR_DEV=1 \
+  -e TEST_PATTERN="${TEST_PATTERN}" \
+  "package-manager-test-${distro}" \
+  bash -lc '
+    set -e;
+    git config --global --add safe.directory /src || true;
+    nix develop .#default --no-write-lock-file -c \
+      python3 -m unittest discover \
+        -s tests/integration \
+        -t /src \
+        -p "$TEST_PATTERN";
+  '

scripts/test/test-unit.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "============================================================"
+echo ">>> Running UNIT tests in ${distro} container"
+echo "============================================================"
+
+docker run --rm \
+  -v "$(pwd):/src" \
+  -v "pkgmgr_nix_cache_${distro}:/root/.cache/nix" \
+  -v pkgmgr_nix_store_${distro}:/nix \
+  --workdir /src \
+  -e PKGMGR_DEV=1 \
+  -e TEST_PATTERN="${TEST_PATTERN}" \
+  "package-manager-test-${distro}" \
+  bash -lc '
+    set -e;
+    git config --global --add safe.directory /src || true;
+    nix develop .#default --no-write-lock-file -c \
+      python3 -m unittest discover \
+        -s tests/unit \
+        -t /src \
+        -p "$TEST_PATTERN";
+  '

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."

src/pkgmgr/__init__.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Top-level pkgmgr package.
+
+We deliberately avoid importing heavy submodules (like the CLI)
+on import to keep unit tests fast and to not require optional
+dependencies (like PyYAML) unless they are actually used.
+
+Accessing ``pkgmgr.cli`` will load the CLI module lazily via
+``__getattr__``. This keeps patterns like
+
+    from pkgmgr import cli
+
+working as expected in tests and entry points.
+"""
+
+from __future__ import annotations
+
+from importlib import import_module
+from typing import Any
+
+__all__ = ["cli"]
+
+
+def __getattr__(name: str) -> Any:
+  """
+  Lazily expose ``pkgmgr.cli`` as attribute on the top-level package.
+
+  This keeps ``import pkgmgr`` lightweight while still allowing
+  ``from pkgmgr import cli`` in tests and entry points.
+  """
+  if name == "cli":
+      return import_module("pkgmgr.cli")
+  raise AttributeError(f"module 'pkgmgr' has no attribute {name!r}")

src/pkgmgr/actions/branch/__init__.py

@@ -0,0 +1,235 @@
+# pkgmgr/actions/branch/__init__.py
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+High-level helpers for branch-related operations.
+
+This module encapsulates the actual Git logic so the CLI layer
+(pkgmgr.cli.commands.branch) stays thin and testable.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from pkgmgr.core.git import run_git, GitError, get_current_branch
+
+
+# ---------------------------------------------------------------------------
+# Branch creation (open)
+# ---------------------------------------------------------------------------
+
+def open_branch(
+    name: Optional[str],
+    base_branch: str = "main",
+    fallback_base: str = "master",
+    cwd: str = ".",
+) -> None:
+    """
+    Create and push a new feature branch on top of a base branch.
+
+    The base branch is resolved by:
+        1. Trying 'base_branch' (default: 'main')
+        2. Falling back to 'fallback_base' (default: 'master')
+
+    Steps:
+        1) git fetch origin
+        2) git checkout <resolved_base>
+        3) git pull origin <resolved_base>
+        4) git checkout -b <name>
+        5) git push -u origin <name>
+
+    If `name` is None or empty, the user is prompted to enter one.
+    """
+
+    # Request name interactively if not provided
+    if not name:
+        name = input("Enter new branch name: ").strip()
+
+    if not name:
+        raise RuntimeError("Branch name must not be empty.")
+
+    # Resolve which base branch to use (main or master)
+    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
+
+    # 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 for base branch
+    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 to origin
+    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
+
+
+# ---------------------------------------------------------------------------
+# Base branch resolver (shared by open/close)
+# ---------------------------------------------------------------------------
+
+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."
+    )
+
+
+# ---------------------------------------------------------------------------
+# Branch closing (merge + deletion)
+# ---------------------------------------------------------------------------
+
+def close_branch(
+    name: Optional[str],
+    base_branch: str = "main",
+    fallback_base: str = "master",
+    cwd: str = ".",
+) -> None:
+    """
+    Merge a feature branch into the base branch and delete it afterwards.
+
+    Steps:
+        1) Determine the branch name (argument or current branch)
+        2) Resolve base branch (main/master)
+        3) Ask for confirmation
+        4) git fetch origin
+        5) git checkout <base>
+        6) git pull origin <base>
+        7) git merge --no-ff <name>
+        8) git push origin <base>
+        9) Delete branch locally
+       10) Delete branch on origin (best effort)
+    """
+
+    # 1) Determine which branch should be closed
+    if not name:
+        try:
+            name = get_current_branch(cwd=cwd)
+        except GitError as exc:
+            raise RuntimeError(f"Failed to detect current branch: {exc}") from exc
+
+    if not name:
+        raise RuntimeError("Branch name must not be empty.")
+
+    # 2) Resolve base branch
+    target_base = _resolve_base_branch(base_branch, fallback_base, cwd=cwd)
+
+    if name == target_base:
+        raise RuntimeError(
+            f"Refusing to close base branch {target_base!r}. "
+            "Please specify a feature branch."
+        )
+
+    # 3) Ask user for confirmation
+    prompt = (
+        f"Merge branch '{name}' into '{target_base}' and delete it afterwards? "
+        "(y/N): "
+    )
+    answer = input(prompt).strip().lower()
+    if answer != "y":
+        print("Aborted closing branch.")
+        return
+
+    # 4) Fetch from origin
+    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
+
+    # 5) 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
+
+    # 6) Pull latest base state
+    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
+
+    # 7) Merge the feature branch
+    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
+
+    # 8) Push updated base
+    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
+
+    # 9) Delete branch locally
+    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
+
+    # 10) Delete branch on origin (best effort)
+    try:
+        run_git(["push", "origin", "--delete", name], cwd=cwd)
+    except GitError as exc:
+        raise RuntimeError(
+            f"Branch {name!r} was deleted locally, but remote deletion failed: {exc}"
+        ) from exc

src/pkgmgr/actions/changelog/__init__.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 
 from typing import Optional
 
-from pkgmgr.git_utils import run_git, GitError
+from pkgmgr.core.git import run_git, GitError
 
 
 def generate_changelog(

src/pkgmgr/actions/config/init.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Initialize user configuration by scanning the repositories base directory.
+
+This module scans the path:
+
+    defaults_config["directories"]["repositories"]
+
+with the expected structure:
+
+    {base}/{provider}/{account}/{repository}
+
+For each discovered repository, the function:
+  • derives provider, account, repository from the folder structure
+  • (optionally) determines the latest commit hash via git log
+  • generates a unique CLI alias
+  • marks ignore=True for newly discovered repos
+  • skips repos already known in defaults or user config
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from typing import Any, Dict
+
+from pkgmgr.core.command.alias import generate_alias
+from pkgmgr.core.config.save import save_user_config
+
+
+def config_init(
+    user_config: Dict[str, Any],
+    defaults_config: Dict[str, Any],
+    bin_dir: str,
+    user_config_path: str,
+) -> None:
+    """
+    Scan the repositories base directory and add missing entries
+    to the user configuration.
+    """
+
+    # ------------------------------------------------------------
+    # Announce where we will write the result
+    # ------------------------------------------------------------
+    print("============================================================")
+    print(f"[INIT] Writing user configuration to:")
+    print(f"       {user_config_path}")
+    print("============================================================")
+
+    repositories_base_dir = os.path.expanduser(
+        defaults_config["directories"]["repositories"]
+    )
+
+    print(f"[INIT] Scanning repository base directory:")
+    print(f"       {repositories_base_dir}")
+    print("")
+
+    if not os.path.isdir(repositories_base_dir):
+        print(f"[ERROR] Base directory does not exist: {repositories_base_dir}")
+        return
+
+    default_keys = {
+        (entry.get("provider"), entry.get("account"), entry.get("repository"))
+        for entry in defaults_config.get("repositories", [])
+    }
+    existing_keys = {
+        (entry.get("provider"), entry.get("account"), entry.get("repository"))
+        for entry in user_config.get("repositories", [])
+    }
+    existing_aliases = {
+        entry.get("alias")
+        for entry in user_config.get("repositories", [])
+        if entry.get("alias")
+    }
+
+    new_entries = []
+    scanned = 0
+    skipped = 0
+
+    # ------------------------------------------------------------
+    # Actual scanning
+    # ------------------------------------------------------------
+    for provider in os.listdir(repositories_base_dir):
+        provider_path = os.path.join(repositories_base_dir, provider)
+        if not os.path.isdir(provider_path):
+            continue
+
+        print(f"[SCAN] Provider: {provider}")
+
+        for account in os.listdir(provider_path):
+            account_path = os.path.join(provider_path, account)
+            if not os.path.isdir(account_path):
+                continue
+
+            print(f"[SCAN]   Account: {account}")
+
+            for repo_name in os.listdir(account_path):
+                repo_path = os.path.join(account_path, repo_name)
+                if not os.path.isdir(repo_path):
+                    continue
+
+                scanned += 1
+                key = (provider, account, repo_name)
+
+                # Already known?
+                if key in default_keys:
+                    skipped += 1
+                    print(f"[SKIP]     (defaults)       {provider}/{account}/{repo_name}")
+                    continue
+                if key in existing_keys:
+                    skipped += 1
+                    print(f"[SKIP]     (user-config)    {provider}/{account}/{repo_name}")
+                    continue
+
+                print(f"[ADD]      {provider}/{account}/{repo_name}")
+
+                # Determine commit hash
+                try:
+                    result = subprocess.run(
+                        ["git", "log", "-1", "--format=%H"],
+                        cwd=repo_path,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        text=True,
+                        check=True,
+                    )
+                    verified = result.stdout.strip()
+                    print(f"[INFO]       Latest commit: {verified}")
+                except Exception as exc:
+                    verified = ""
+                    print(f"[WARN]       Could not read commit: {exc}")
+
+                entry = {
+                    "provider": provider,
+                    "account": account,
+                    "repository": repo_name,
+                    "verified": {"commit": verified},
+                    "ignore": True,
+                }
+
+                # Alias generation
+                alias = generate_alias(
+                    {
+                        "repository": repo_name,
+                        "provider": provider,
+                        "account": account,
+                    },
+                    bin_dir,
+                    existing_aliases,
+                )
+                entry["alias"] = alias
+                existing_aliases.add(alias)
+                print(f"[INFO]       Alias generated: {alias}")
+
+                new_entries.append(entry)
+
+            print("")  # blank line between accounts
+
+    # ------------------------------------------------------------
+    # Summary
+    # ------------------------------------------------------------
+    print("============================================================")
+    print(f"[DONE] Scanned repositories:  {scanned}")
+    print(f"[DONE] Skipped (known):       {skipped}")
+    print(f"[DONE] New entries discovered: {len(new_entries)}")
+    print("============================================================")
+
+    # ------------------------------------------------------------
+    # Save if needed
+    # ------------------------------------------------------------
+    if new_entries:
+        user_config.setdefault("repositories", []).extend(new_entries)
+        save_user_config(user_config, user_config_path)
+        print(f"[SAVE] Wrote user configuration to:")
+        print(f"       {user_config_path}")
+    else:
+        print("[INFO] No new repositories were added.")
+
+    print("============================================================")

src/pkgmgr/actions/config/show.py

@@ -1,5 +1,5 @@
 import yaml
-from .load_config import load_config
+from pkgmgr.core.config.load import load_config
 
 def show_config(selected_repos, user_config_path, full_config=False):
     """Display configuration for one or more repositories, or the entire merged config."""

src/pkgmgr/actions/install/__init__.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+High-level entry point for repository installation.
+
+Responsibilities:
+
+  - Ensure the repository directory exists (clone if necessary).
+  - Verify the repository (GPG / commit checks).
+  - Build a RepoContext object.
+  - Delegate the actual installation decision logic to InstallationPipeline.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Dict, List
+
+from pkgmgr.core.repository.identifier import get_repo_identifier
+from pkgmgr.core.repository.dir import get_repo_dir
+from pkgmgr.core.repository.verify import verify_repository
+from pkgmgr.actions.repository.clone import clone_repos
+from pkgmgr.actions.install.context import RepoContext
+from pkgmgr.actions.install.installers.os_packages import (
+    ArchPkgbuildInstaller,
+    DebianControlInstaller,
+    RpmSpecInstaller,
+)
+from pkgmgr.actions.install.installers.nix_flake import (
+    NixFlakeInstaller,
+)
+from pkgmgr.actions.install.installers.python import PythonInstaller
+from pkgmgr.actions.install.installers.makefile import (
+    MakefileInstaller,
+)
+from pkgmgr.actions.install.pipeline import InstallationPipeline
+
+
+Repository = Dict[str, Any]
+
+# All available installers, in the order they should be considered.
+INSTALLERS = [
+    ArchPkgbuildInstaller(),
+    DebianControlInstaller(),
+    RpmSpecInstaller(),
+    NixFlakeInstaller(),
+    PythonInstaller(),
+    MakefileInstaller(),
+]
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _ensure_repo_dir(
+    repo: Repository,
+    repositories_base_dir: str,
+    all_repos: List[Repository],
+    preview: bool,
+    no_verification: bool,
+    clone_mode: str,
+    identifier: str,
+) -> str | None:
+    """
+    Compute and, if necessary, clone the repository directory.
+
+    Returns the absolute repository path or None if cloning ultimately failed.
+    """
+    repo_dir = get_repo_dir(repositories_base_dir, repo)
+
+    if not os.path.exists(repo_dir):
+        print(
+            f"Repository directory '{repo_dir}' does not exist. "
+            f"Cloning it now..."
+        )
+        clone_repos(
+            [repo],
+            repositories_base_dir,
+            all_repos,
+            preview,
+            no_verification,
+            clone_mode,
+        )
+        if not os.path.exists(repo_dir):
+            print(
+                f"Cloning failed for repository {identifier}. "
+                f"Skipping installation."
+            )
+            return None
+
+    return repo_dir
+
+
+def _verify_repo(
+    repo: Repository,
+    repo_dir: str,
+    no_verification: bool,
+    identifier: str,
+) -> bool:
+    """
+    Verify a repository using the configured verification data.
+
+    Returns True if verification is considered okay and installation may continue.
+    """
+    verified_info = repo.get("verified")
+    verified_ok, errors, _commit_hash, _signing_key = verify_repository(
+        repo,
+        repo_dir,
+        mode="local",
+        no_verification=no_verification,
+    )
+
+    if not no_verification and verified_info and not verified_ok:
+        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
+
+    return True
+
+
+def _create_context(
+    repo: Repository,
+    identifier: str,
+    repo_dir: str,
+    repositories_base_dir: str,
+    bin_dir: str,
+    all_repos: List[Repository],
+    no_verification: bool,
+    preview: bool,
+    quiet: bool,
+    clone_mode: str,
+    update_dependencies: bool,
+) -> RepoContext:
+    """
+    Build a RepoContext instance for the given repository.
+    """
+    return RepoContext(
+        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,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def install_repos(
+    selected_repos: List[Repository],
+    repositories_base_dir: str,
+    bin_dir: str,
+    all_repos: List[Repository],
+    no_verification: bool,
+    preview: bool,
+    quiet: bool,
+    clone_mode: str,
+    update_dependencies: bool,
+) -> None:
+    """
+    Install one or more repositories according to the configured installers
+    and the CLI layer precedence rules.
+    """
+    pipeline = InstallationPipeline(INSTALLERS)
+
+    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:
+            continue
+
+        if not _verify_repo(
+            repo=repo,
+            repo_dir=repo_dir,
+            no_verification=no_verification,
+            identifier=identifier,
+        ):
+            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,
+        )
+
+        pipeline.run(ctx)

src/pkgmgr/actions/install/capabilities.py

@@ -38,7 +38,7 @@ from abc import ABC, abstractmethod
 from typing import Iterable, TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from pkgmgr.context import RepoContext
+    from pkgmgr.actions.install.context import RepoContext
 
 
 # ---------------------------------------------------------------------------

src/pkgmgr/actions/install/installers/__init__.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Installer package for pkgmgr.
+
+This exposes all installer classes so users can import them directly from
+pkgmgr.actions.install.installers.
+"""
+
+from pkgmgr.actions.install.installers.base import BaseInstaller  # noqa: F401
+from pkgmgr.actions.install.installers.nix_flake import NixFlakeInstaller  # noqa: F401
+from pkgmgr.actions.install.installers.python import PythonInstaller  # noqa: F401
+from pkgmgr.actions.install.installers.makefile import MakefileInstaller  # noqa: F401
+
+# OS-specific installers
+from pkgmgr.actions.install.installers.os_packages.arch_pkgbuild import ArchPkgbuildInstaller  # noqa: F401
+from pkgmgr.actions.install.installers.os_packages.debian_control import DebianControlInstaller  # noqa: F401
+from pkgmgr.actions.install.installers.os_packages.rpm_spec import RpmSpecInstaller  # noqa: F401

src/pkgmgr/actions/install/installers/base.py

@@ -8,8 +8,8 @@ Base interface for all installer components in the pkgmgr installation pipeline.
 from abc import ABC, abstractmethod
 from typing import Set
 
-from pkgmgr.context import RepoContext
-from pkgmgr.capabilities import CAPABILITY_MATCHERS
+from pkgmgr.actions.install.context import RepoContext
+from pkgmgr.actions.install.capabilities import CAPABILITY_MATCHERS
 
 
 class BaseInstaller(ABC):

src/pkgmgr/actions/install/installers/makefile.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import os
+import re
+
+from pkgmgr.actions.install.context import RepoContext
+from pkgmgr.actions.install.installers.base import BaseInstaller
+from pkgmgr.core.command.run import run_command
+
+
+class MakefileInstaller(BaseInstaller):
+    """
+    Generic installer that runs `make install` if a Makefile with an
+    install target is present.
+
+    Safety rules:
+      - If PKGMGR_DISABLE_MAKEFILE_INSTALLER=1 is set, this installer
+        is globally disabled.
+      - The higher-level InstallationPipeline ensures that Makefile
+        installation does not run if a stronger CLI layer already owns
+        the command (e.g. Nix or OS packages).
+    """
+
+    layer = "makefile"
+    MAKEFILE_NAME = "Makefile"
+
+    def supports(self, ctx: RepoContext) -> bool:
+        """
+        Return True if this repository has a Makefile and the installer
+        is not globally disabled.
+        """
+        # Optional global kill switch.
+        if os.environ.get("PKGMGR_DISABLE_MAKEFILE_INSTALLER") == "1":
+            if not ctx.quiet:
+                print(
+                    "[INFO] MakefileInstaller is disabled via "
+                    "PKGMGR_DISABLE_MAKEFILE_INSTALLER."
+                )
+            return False
+
+        makefile_path = os.path.join(ctx.repo_dir, self.MAKEFILE_NAME)
+        return os.path.exists(makefile_path)
+
+    def _has_install_target(self, makefile_path: str) -> bool:
+        """
+        Heuristically check whether the Makefile defines an install target.
+
+        We look for:
+
+          - a plain 'install:' target, or
+          - any 'install-*:' style target.
+        """
+        try:
+            with open(makefile_path, "r", encoding="utf-8", errors="ignore") as f:
+                content = f.read()
+        except OSError:
+            return False
+
+        # Simple heuristics: look for "install:" or targets starting with "install-"
+        if re.search(r"^install\s*:", content, flags=re.MULTILINE):
+            return True
+
+        if re.search(r"^install-[a-zA-Z0-9_-]*\s*:", content, flags=re.MULTILINE):
+            return True
+
+        return False
+
+    def run(self, ctx: RepoContext) -> None:
+        """
+        Execute `make install` in the repository directory if an install
+        target exists.
+        """
+        makefile_path = os.path.join(ctx.repo_dir, self.MAKEFILE_NAME)
+
+        if not os.path.exists(makefile_path):
+            if not ctx.quiet:
+                print(
+                    f"[pkgmgr] Makefile '{makefile_path}' not found, "
+                    "skipping MakefileInstaller."
+                )
+            return
+
+        if not self._has_install_target(makefile_path):
+            if not ctx.quiet:
+                print(
+                    f"[pkgmgr] No 'install' target found in {makefile_path}."
+                )
+            return
+
+        if not ctx.quiet:
+            print(
+                f"[pkgmgr] Running 'make install' in {ctx.repo_dir} "
+                f"(MakefileInstaller)"
+            )
+
+        cmd = "make install"
+        run_command(cmd, cwd=ctx.repo_dir, preview=ctx.preview)

src/pkgmgr/actions/install/installers/nix_flake.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Installer for Nix flakes.
+
+If a repository contains flake.nix and the 'nix' command is available, this
+installer will try to install profile outputs from the flake.
+
+Behavior:
+  - If flake.nix is present and `nix` exists on PATH:
+      * First remove any existing `package-manager` profile entry (best-effort).
+      * Then install one or more flake outputs via `nix profile install`.
+  - For the package-manager repo:
+      * `pkgmgr` is mandatory (CLI), `default` is optional.
+  - For all other repos:
+      * `default` is mandatory.
+
+Special handling:
+  - If PKGMGR_DISABLE_NIX_FLAKE_INSTALLER=1 is set, the installer is
+    globally disabled (useful for CI or debugging).
+
+The higher-level InstallationPipeline and CLI-layer model decide when this
+installer is allowed to run, based on where the current CLI comes from
+(e.g. Nix, OS packages, Python, Makefile).
+"""
+
+import os
+import shutil
+from typing import TYPE_CHECKING, List, Tuple
+
+from pkgmgr.actions.install.installers.base import BaseInstaller
+from pkgmgr.core.command.run import run_command
+
+if TYPE_CHECKING:
+    from pkgmgr.actions.install.context import RepoContext
+    from pkgmgr.actions.install import InstallContext
+
+
+class NixFlakeInstaller(BaseInstaller):
+    """Install Nix flake profiles for repositories that define flake.nix."""
+
+    # Logical layer name, used by capability matchers.
+    layer = "nix"
+
+    FLAKE_FILE = "flake.nix"
+    PROFILE_NAME = "package-manager"
+
+    def supports(self, ctx: "RepoContext") -> bool:
+        """
+        Only support repositories that:
+          - Are NOT explicitly disabled via PKGMGR_DISABLE_NIX_FLAKE_INSTALLER=1,
+          - Have a flake.nix,
+          - And have the `nix` command available.
+        """
+        # Optional global kill-switch for CI or debugging.
+        if os.environ.get("PKGMGR_DISABLE_NIX_FLAKE_INSTALLER") == "1":
+            print(
+                "[INFO] PKGMGR_DISABLE_NIX_FLAKE_INSTALLER=1 – "
+                "NixFlakeInstaller is disabled."
+            )
+            return False
+
+        # Nix must be available.
+        if shutil.which("nix") is None:
+            return False
+
+        # flake.nix must exist in the repository.
+        flake_path = os.path.join(ctx.repo_dir, self.FLAKE_FILE)
+        return os.path.exists(flake_path)
+
+    def _ensure_old_profile_removed(self, ctx: "RepoContext") -> None:
+        """
+        Best-effort removal of an existing profile entry.
+
+        This handles the "already provides the following file" conflict by
+        removing previous `package-manager` installations before we install
+        the new one.
+
+        Any error in `nix profile remove` is intentionally ignored, because
+        a missing profile entry is not a fatal condition.
+        """
+        if shutil.which("nix") is None:
+            return
+
+        cmd = f"nix profile remove {self.PROFILE_NAME} || true"
+        try:
+            # NOTE: no allow_failure here → matches the existing unit tests
+            run_command(cmd, cwd=ctx.repo_dir, preview=ctx.preview)
+        except SystemExit:
+            # Unit tests explicitly assert this is swallowed
+            pass
+
+    def _profile_outputs(self, ctx: "RepoContext") -> List[Tuple[str, bool]]:
+        """
+        Decide which flake outputs to install and whether failures are fatal.
+
+        Returns a list of (output_name, allow_failure) tuples.
+
+        Rules:
+          - For the package-manager repo (identifier 'pkgmgr' or 'package-manager'):
+                [("pkgmgr", False), ("default", True)]
+          - For all other repos:
+                [("default", False)]
+        """
+        ident = ctx.identifier
+
+        if ident in {"pkgmgr", "package-manager"}:
+            # pkgmgr: main CLI output is "pkgmgr" (mandatory),
+            # "default" is nice-to-have (non-fatal).
+            return [("pkgmgr", False), ("default", True)]
+
+        # Generic repos: we expect a sensible "default" package/app.
+        # Failure to install it is considered fatal.
+        return [("default", False)]
+
+    def run(self, ctx: "InstallContext") -> None:
+        """
+        Install Nix flake profile outputs.
+
+        For the package-manager repo, failure installing 'pkgmgr' is fatal,
+        failure installing 'default' is non-fatal.
+        For other repos, failure installing 'default' is fatal.
+        """
+        # Reuse supports() to keep logic in one place.
+        if not self.supports(ctx):  # type: ignore[arg-type]
+            return
+
+        outputs = self._profile_outputs(ctx)  # list of (name, allow_failure)
+
+        print(
+            "Nix flake detected in "
+            f"{ctx.identifier}, attempting to install profile outputs: "
+            + ", ".join(name for name, _ in outputs)
+        )
+
+        # Handle the "already installed" case up-front for the shared profile.
+        self._ensure_old_profile_removed(ctx)  # type: ignore[arg-type]
+
+        for output, allow_failure in outputs:
+            cmd = f"nix profile install {ctx.repo_dir}#{output}"
+
+            try:
+                run_command(
+                    cmd,
+                    cwd=ctx.repo_dir,
+                    preview=ctx.preview,
+                    allow_failure=allow_failure,
+                )
+                print(f"Nix flake output '{output}' successfully installed.")
+            except SystemExit as e:
+                print(f"[Error] Failed to install Nix flake output '{output}': {e}")
+                if not allow_failure:
+                    # Mandatory output failed → fatal for the pipeline.
+                    raise
+                # Optional output failed → log and continue.
+                print(
+                    "[Warning] Continuing despite failure to install "
+                    f"optional output '{output}'."
+                )