Line 179 in installer_core.py right now:

    os.system(f"sudo cat ./src/ashpk_core.py ./src/distros/{distro}/ashpk.py > /mnt/.snapshots/ash/ash")

👆 Overall, this method of concatenating the core file with the distro-specific file is not ideal because it does not enforce a common API. I also recommend using a tool like pyright to catch some of the low-hanging bugs you have right now, and this isn't really doable when you're referencing functions from another file with no importing.

I think you can improve things by setting up some basic core classes that can be subclassed by distro.

For example, it would be better to do something like this:

src/ashpk_core.py

class AshPkCore(object):
    # [...] your core functions could stay mostly as-is
    def install(self, snapshot, pkg):
        # [...]
        self.install_package(snapshot, pkg)
        # [...]
    def install_live(self, pkg):
        # [...]
        self.install_package_live(tmp, pkg)
        # [...]

    # [...] distro-specific classes should override these:
    def install_package(self, snapshot, pkg):
        pass
    def install_package_live(self, snapshot, pkg):
        pass

src/distros/arch/ashpk.py

from src.ashpk_core import AshPkCore

class AshPkArch(AshPkCore):
    # The core functions are inherited from the base class.
    # Here, you are subclassing the core and defining only the distro-specifics.
    def install_package(self, snapshot, pkg):
        try:
            subprocess.run(f"chroot /.snapshots/rootfs/snapshot-chr{snapshot} pacman -S {pkg} --overwrite '/var/*'", shell=True, check=True)
        except subprocess.CalledProcessError as e:
            print(f"F: Install failed and changes discarded: {e.output}.")
            sys.exit(1)

    def install_package_live(self, tmp, pkg):
        try:
            subprocess.run(f"chroot /.snapshots/rootfs/snapshot-{tmp} pacman -Sy --overwrite \\* --noconfirm {pkg} >/dev/null 2>&1", shell=True, check=True)
            print("Done!")
        except subprocess.CalledProcessError as e:
            print(f"F: Live install failed and changes discarded: {e.output}.")
            sys.exit(1)
    # [...]

src/distros/debian/ashpk.py

from src.ashpk_core import AshPkCore

class AshPkDebian(AshPkCore):
    # [...]
    def install_package(self, snapshot, pkg):
        try:
            subprocess.run(f"chroot /.snapshots/rootfs/snapshot-chr{snapshot} apt-get install -f -y {pkg}", shell=True, check=True) ### --overwrite '/var/*'
        except subprocess.CalledProcessError as e:
            print(f"F: Install failed and changes discarded: {e.output}.")
            sys.exit(1)

    def install_package_live(self, tmp, pkg):
        try:
            subprocess.run(f"chroot /.snapshots/rootfs/snapshot-{tmp} apt-get install -y {pkg} >/dev/null 2>&1", shell=True, check=True) ### --overwrite \\*
            print("Done!")
        except subprocess.CalledProcessError as e:
            print(f"F: Live install failed and changes discarded: {e.output}.")
            sys.exit(1)
    # [...]

Then there is no need to concat these files together.

Line 179 in installer_core.py would simply be:

    os.system(f"sudo cp ./src/distros/{distro}/ashpk.py /mnt/.snapshots/ash/ash")

and you would get more meaningful output out of pyright while developing.

This concept could be applied to all of the components listed. Everything just needs a core API and implementation details separated.

@duhdugg Thanks for the write-up. The reason I went with simply concatenating was to keep ash as a single file. It was brought up here: https://discord.com/channels/484200829230776321/484200829230776323/1012190933149827124

Now, I think it might be inevitable to let go of this single file executable ideal as Ash gets bigger. I'm interested to start a brainstorm.

Also, let me know what you think of profile folder. YAML etc can definitely be used to standardize the approach. What we have right now is rudimentary as it is a just a POC to get things done and out the door!

I think we should move towards a proper configuration language. We should try to keep as much stuff as possible generalized and cut down the distribution-specific code to a minimum - even when handling these profiles.
Maybe we could split the codebase a bit more - we could have separate interfaces for handling packages, for services across different init systems and for working with snapshots - these would then allow us to handle the different operations consistently with more abstractions in place.
Fedora Silverblue does it's configuration with YAML. Silverblue is quite different from Ash in a variety of ways but I still think some of this could be used for future reference.
https://pagure.io/workstation-ostree-config/tree/main

Currently, this is structure of codebase:

|-- distros
|   |-- arch
|   |   |-- ashpk.py
|   |   |-- installer.py
|   |-- cachyos
|   |   |-- ashpk.py
|   |   |-- installer.py
|   |-- debian
|   |   |-- ashpk.py
|   |   |-- installer.py
|   `-- fedora
|       |-- ashpk.py
|       |-- base.repo
|       |-- installer.py
|-- prep
|   |-- arch_live.sh
|   |-- cachyos_live.sh
|   |-- debian_live.sh
|   |-- fedora_live.sh
`-- profiles
    |-- gnome
    |   |-- packages_arch.txt
    |   |-- packages_cachyos.txt
    |   |-- packages_debian.txt
    |   |-- packages_fedora.txt
    |-- jwm
    |   |-- packages_arch.txt
    |   |-- packages_cachyos.txt
    |   |-- packages_debian.txt
    |   |-- packages_fedora.txt
    `-- xfce
        |-- packages_arch.txt
        |-- packages_cachyos.txt
        |-- packages_debian.txt
        `-- packages_fedora.txt

Let's put it on paper... formulate and have a birds-view of the new config management we're talking about. @CuBeRJAN or anyone else: Can you make a design file (using draw.io or whatever tool) and make a PR so we can get the ball rolling?

@duhdugg I have made a bit of change to the project now. I'm still not using classes. I'm not opposed to it and as you mentioned it just needs a few modifications that are quite trivial.

We might use classes if need arises more over time.

Please feel free to push PRs etc.