machineconfig 6.82__py3-none-any.whl → 8.51__py3-none-any.whl

machineconfig/utils/installer_utils/{installer_abc.py → installer_locator_utils.py}

@@ -7,25 +7,30 @@ import subprocess
 import platform
 
 
-def find_move_delete_windows(downloaded_file_path: PathExtended, exe_name: Optional[str] = None, delete: bool = True, rename_to: Optional[str] = None):
-    print("🔍 PROCESSING WINDOWS EXECUTABLE 🔍")
-    if exe_name is not None and ".exe" in exe_name:
-        exe_name = exe_name.replace(".exe", "")
+def find_move_delete_windows(downloaded_file_path: PathExtended, tool_name: Optional[str], delete: bool, rename_to: Optional[str]):
+    # print("🔍 PROCESSING WINDOWS EXECUTABLE 🔍")
+    # if exe_name is not None and len(exe_name.split("+")) > 1:
+    #     last_result = None
+    #     for a_binary in [x.strip() for x in exe_name.split("+") if x.strip() != ""]:
+    #         last_result = find_move_delete_windows(downloaded_file_path=downloaded_file_path, exe_name=a_binary, delete=delete, rename_to=rename_to)
+    #     return last_result
+    if tool_name is not None and ".exe" in tool_name:
+        tool_name = tool_name.replace(".exe", "")
     if downloaded_file_path.is_file():
         exe = downloaded_file_path
         print(f"📄 Found direct executable file: {exe}")
     else:
         print(f"🔎 Searching for executable in: {downloaded_file_path}")
-        if exe_name is None:
-            exe = downloaded_file_path.search("*.exe", r=True)[0]
+        if tool_name is None:
+            exe = list(downloaded_file_path.rglob("*.exe"))[0]
             print(f"✅ Found executable: {exe}")
         else:
-            tmp = downloaded_file_path.search(f"{exe_name}.exe", r=True)
+            tmp = list(downloaded_file_path.rglob(f"{tool_name}.exe"))
             if len(tmp) == 1:
                 exe = tmp[0]
-                print(f"✅ Found exact match for {exe_name}.exe: {exe}")
+                print(f"✅ Found exact match for {tool_name}.exe: {exe}")
             else:
-                search_res = downloaded_file_path.search("*.exe", r=True)
+                search_res = list(downloaded_file_path.rglob("*.exe"))
                 if len(search_res) == 0:
                     print(f"❌ ERROR: No executable found in {downloaded_file_path}")
                     raise IndexError(f"No executable found in {downloaded_file_path}")
@@ -33,8 +38,8 @@ def find_move_delete_windows(downloaded_file_path: PathExtended, exe_name: Optio
                     exe = search_res[0]
                     print(f"✅ Found single executable: {exe}")
                 else:
-                    exe = max(search_res, key=lambda x: x.size("kb"))
-                    print(f"✅ Selected largest executable ({exe.size('kb')} KB): {exe}")
+                    exe = max(search_res, key=lambda x: x.stat().st_size)
+                    print(f"✅ Selected largest executable ({round(exe.stat().st_size / 1024, 1)} KB): {exe}")
         if rename_to and exe.name != rename_to:
             print(f"🏷️  Renaming '{exe.name}' to '{rename_to}'")
             exe = exe.with_name(name=rename_to, inplace=True)
@@ -52,28 +57,42 @@ def find_move_delete_windows(downloaded_file_path: PathExtended, exe_name: Optio
     return exe_new_location
 
 
-def find_move_delete_linux(downloaded: PathExtended, tool_name: str, delete: Optional[bool] = True, rename_to: Optional[str] = None):
+def find_move_delete_linux(downloaded: PathExtended, tool_name: Optional[str], delete: bool, rename_to: Optional[str]):
+    # if len(tool_name.split("+")) > 1:
+    #     last_result = None
+    #     for a_binary in [x.strip() for x in tool_name.split("+") if x.strip() != ""]:
+    #         last_result = find_move_delete_linux(downloaded=downloaded, tool_name=a_binary, delete=False, rename_to=rename_to)
+    #     return last_result
+
     print("🔍 PROCESSING LINUX EXECUTABLE 🔍")
     if downloaded.is_file():
         exe = downloaded
         print(f"📄 Found direct executable file: {exe}")
     else:
         print(f"🔎 Searching for executable in: {downloaded}")
-        res = downloaded.search(f"*{tool_name}*", folders=False, r=True)
+        res = [p for p in downloaded.rglob(f"*{tool_name}*") if p.is_file()]
         if len(res) == 1:
             exe = res[0]
             print(f"✅ Found match for pattern '*{tool_name}*': {exe}")
         else:
-            exe_search_res = downloaded.search(tool_name, folders=False, r=True)
-            if len(exe_search_res) == 0:
-                print(f"❌ ERROR: No search results for `{tool_name}` in `{downloaded}`")
-                raise IndexError(f"No executable found in {downloaded}")
-            elif len(exe_search_res) == 1:
-                exe = exe_search_res[0]
-                print(f"✅ Found exact match for '{tool_name}': {exe}")
+            if tool_name is None:  # no tool name provided, get the largest executable
+                search_res = [p for p in downloaded.rglob("*") if p.is_file()]
+                if len(search_res) == 0:
+                    print(f"❌ ERROR: No search results in `{downloaded}`")
+                    raise IndexError(f"No executable found in {downloaded}")
+                exe = max(search_res, key=lambda x: x.stat().st_size)
+                print(f"✅ Selected largest executable ({round(exe.stat().st_size / 1024, 1)} KB): {exe}")
             else:
-                exe = max(exe_search_res, key=lambda x: x.size("kb"))
-                print(f"✅ Selected largest executable ({exe.size('kb')} KB): {exe}")
+                exe_search_res = [p for p in downloaded.rglob(tool_name) if p.is_file()]
+                if len(exe_search_res) == 0:
+                    print(f"❌ ERROR: No search results for `{tool_name}` in `{downloaded}`")
+                    raise IndexError(f"No executable found in {downloaded}")
+                elif len(exe_search_res) == 1:
+                    exe = exe_search_res[0]
+                    print(f"✅ Found exact match for '{tool_name}': {exe}")
+                else:
+                    exe = max(exe_search_res, key=lambda x: x.stat().st_size)
+                    print(f"✅ Selected largest executable ({round(exe.stat().st_size / 1024, 1)} KB): {exe}")
 
     if rename_to and exe.name != rename_to:
         print(f"🏷️  Renaming '{exe.name}' to '{rename_to}'")
@@ -136,7 +155,7 @@ def check_tool_exists(tool_name: str) -> bool:
             version = result.stdout.strip().lstrip('v')
             nvm_bin_path = Path.home() / ".nvm" / "versions" / "node" / f"v{version}" / "bin" / tool_name
             npm_check = nvm_bin_path.is_file()
-        except subprocess.CalledProcessError:
+        except (subprocess.CalledProcessError, FileNotFoundError):
             pass
         return npm_check
     else:
@@ -191,71 +210,3 @@ def check_if_installed_already(exe_name: str, version: Optional[str], use_cache:
     return ("⚠️ NotInstalled", "None", version or "unknown")
 
 
-def parse_apps_installer_linux(txt: str) -> dict[str, tuple[str, str]]:
-    """Parse Linux shell installation scripts into logical chunks.
-    
-    Splits scripts by # --GROUP:<name>:<description> comment signatures into a dictionary
-    mapping block names to (description, shell script content) tuples.
-    
-    Returns:
-        dict[str, tuple[str, str]]: Dictionary mapping block/section names to (description, installation_script) tuples
-    """
-    chunks = txt.split('# --GROUP:')
-    res: dict[str, tuple[str, str]] = {}
-    
-    for chunk in chunks[1:]:  # Skip first empty chunk before first group
-        lines = chunk.split('\n')
-        # First line contains the group name and description in format "NAME:DESCRIPTION"
-        group_line = lines[0].strip()
-        
-        # Extract group name and description
-        if ':' in group_line:
-            parts = group_line.split(':', 1)  # Split only on first colon
-            group_name = parts[0].strip()
-            group_description = parts[1].strip() if len(parts) > 1 else ""
-        else:
-            group_name = group_line
-            group_description = ""
-        
-        # Rest is the content
-        content = '\n'.join(lines[1:]).strip()
-        
-        if group_name and content:
-            res[group_name] = (group_description, content)
-    
-    return res
-
-
-def parse_apps_installer_windows(txt: str) -> dict[str, tuple[str, str]]:
-    """Parse Windows PowerShell installation scripts into logical chunks.
-    
-    Splits scripts by # --GROUP:<name>:<description> comment signatures into a dictionary
-    mapping block names to (description, PowerShell script content) tuples.
-    
-    Returns:
-        dict[str, tuple[str, str]]: Dictionary mapping block/section names to (description, installation_script) tuples
-    """
-    chunks = txt.split('# --GROUP:')
-    res: dict[str, tuple[str, str]] = {}
-    
-    for chunk in chunks[1:]:  # Skip first chunk before first group
-        lines = chunk.split('\n')
-        # First line contains the group name and description in format "NAME:DESCRIPTION"
-        group_line = lines[0].strip()
-        
-        # Extract group name and description
-        if ':' in group_line:
-            parts = group_line.split(':', 1)  # Split only on first colon
-            group_name = parts[0].strip()
-            group_description = parts[1].strip() if len(parts) > 1 else ""
-        else:
-            group_name = group_line
-            group_description = ""
-        
-        # Rest is the content
-        content = '\n'.join(lines[1:]).strip()
-        
-        if group_name and content:
-            res[group_name] = (group_description, content)
-    
-    return res

machineconfig/utils/{installer.py → installer_utils/installer_runner.py}

@@ -1,9 +1,9 @@
 """package manager"""
 
-from machineconfig.utils.installer_utils.installer_abc import check_if_installed_already, parse_apps_installer_linux, parse_apps_installer_windows
+from machineconfig.utils.installer_utils.installer_locator_utils import check_if_installed_already
 from machineconfig.utils.installer_utils.installer_class import Installer
 from machineconfig.utils.schemas.installer.installer_types import InstallerData, InstallerDataFiles, get_normalized_arch, get_os_name, OPERATING_SYSTEMS, CPU_ARCHITECTURES
-from machineconfig.jobs.installer.package_groups import PACKAGE_GROUPS, PACKAGE_GROUP2NAMES
+from machineconfig.jobs.installer.package_groups import PACKAGE_GROUP2NAMES
 from machineconfig.utils.path_extended import PathExtended
 from machineconfig.utils.source_of_truth import INSTALL_VERSION_ROOT, LINUX_INSTALL_PATH
 from machineconfig.utils.io import read_json
@@ -18,7 +18,7 @@ from joblib import Parallel, delayed
 def check_latest():
     console = Console()  # Added console initialization
     console.print(Panel("🔍  CHECKING FOR LATEST VERSIONS", title="Status", expand=False))  # Replaced print with Panel
-    installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["ESSENTIAL"])
+    installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["termabc"])
     installers_github = []
     for inst__ in installers:
         app_name = inst__["appName"]
@@ -75,24 +75,28 @@ def get_installed_cli_apps():
     print("🔍 LISTING INSTALLED CLI APPS 🔍")
     if platform.system() == "Windows":
         print("🪟 Searching for Windows executables...")
-        apps = PathExtended.home().joinpath("AppData/Local/Microsoft/WindowsApps").search("*.exe", not_in=["notepad"])
+        apps = [p for p in PathExtended.home().joinpath("AppData/Local/Microsoft/WindowsApps").glob("*.exe") if "notepad" not in str(p)]
     elif platform.system() in ["Linux", "Darwin"]:
         print(f"🐧 Searching for {platform.system()} executables...")
         if platform.system() == "Linux":
-            apps = PathExtended(LINUX_INSTALL_PATH).search("*") + PathExtended("/usr/local/bin").search("*")
+            apps = list(PathExtended(LINUX_INSTALL_PATH).glob("*")) + list(PathExtended("/usr/local/bin").glob("*"))
         else:  # Darwin/macOS
-            apps = PathExtended("/usr/local/bin").search("*") + PathExtended("/opt/homebrew/bin").search("*")
+            apps = list(PathExtended("/usr/local/bin").glob("*")) + list(PathExtended("/opt/homebrew/bin").glob("*"))
     else:
         error_msg = f"❌ ERROR: System {platform.system()} not supported"
         print(error_msg)
         raise NotImplementedError(error_msg)
-    apps = [app for app in apps if app.size("kb") > 0.1 and not app.is_symlink()]  # no symlinks like paint and wsl and bash
+    apps = [app for app in apps if (app.stat().st_size / 1024) > 0.1 and not app.is_symlink()]  # no symlinks like paint and wsl and bash
     print(f"✅ Found {len(apps)} installed applications")
     return apps
 
 
-def get_installers(os: OPERATING_SYSTEMS, arch: CPU_ARCHITECTURES, which_cats: Optional[list[PACKAGE_GROUPS]]) -> list[InstallerData]:
-    res_all = get_all_installer_data_files()
+def get_installers(os: OPERATING_SYSTEMS, arch: CPU_ARCHITECTURES, which_cats: Optional[list[str]]) -> list[InstallerData]:
+    import machineconfig.jobs.installer as module
+    from pathlib import Path
+    res_raw: InstallerDataFiles = read_json(Path(module.__file__).parent.joinpath("installer_data.json"))
+    res_all: list[InstallerData] = res_raw["installers"]
+
     acceptable_apps_names: list[str] | None = None
     if which_cats is not None:
         acceptable_apps_names = []
@@ -105,40 +109,17 @@ def get_installers(os: OPERATING_SYSTEMS, arch: CPU_ARCHITECTURES, which_cats: O
         if acceptable_apps_names is not None:
             if installer_data["appName"] not in acceptable_apps_names:
                 continue
-        if installer_data["fileNamePattern"][arch][os] is None:
-            continue
+        try:
+            if installer_data["fileNamePattern"][arch][os] is None:
+                continue
+        except KeyError as ke:
+            print(f"❌ ERROR: Missing key in installer data: {ke}")
+            print(f"Installer data: {installer_data}")
+            raise KeyError(f"Missing key in installer data: {ke}")
         all_installers.append(installer_data)
     return all_installers
 
 
-def get_all_installer_data_files() -> list[InstallerData]:
-    import machineconfig.jobs.installer as module
-    from pathlib import Path
-    res_raw: InstallerDataFiles = read_json(Path(module.__file__).parent.joinpath("installer_data.json"))
-    res_final: list[InstallerData] = res_raw["installers"]
-    return res_final
-
-
-def dynamically_extract_installers_system_groups_from_scripts():
-    res_final: list[InstallerData] = []
-    from platform import system
-    if system() == "Windows":
-        from machineconfig.setup_windows import APPS
-        options_system = parse_apps_installer_windows(APPS.read_text(encoding="utf-8"))
-    elif system() == "Linux" or system() == "Darwin":
-        from machineconfig.setup_linux import APPS
-        options_system = parse_apps_installer_linux(APPS.read_text(encoding="utf-8"))
-    elif system() == "Darwin":
-        from machineconfig.setup_mac import APPS
-        options_system = parse_apps_installer_linux(APPS.read_text(encoding="utf-8"))
-    else:
-        raise NotImplementedError(f"❌ System {system()} not supported")
-    os_name = get_os_name()
-    for group_name, (docs, script) in options_system.items():
-        item: InstallerData = {"appName": group_name, "doc": docs, "repoURL": "CMD", "fileNamePattern": {"amd64": {os_name: script}, "arm64": {os_name: script}}}
-        res_final.append(item)
-    return res_final
-
 
 def install_bulk(installers_data: list[InstallerData], safe: bool = False, jobs: int = 10, fresh: bool = False):
     print("🚀 BULK INSTALLATION PROCESS 🚀")
@@ -146,33 +127,8 @@ def install_bulk(installers_data: list[InstallerData], safe: bool = False, jobs:
         print("🧹 Fresh install requested - clearing version cache...")
         PathExtended(INSTALL_VERSION_ROOT).delete(sure=True)
         print("✅ Version cache cleared")
-
     if safe:
         pass
-        # print("⚠️  Safe installation mode activated...")
-        # from machineconfig.jobs.python.check_installations import APP_SUMMARY_PATH
-        # if platform.system().lower() == "windows":
-        #     print("🪟 Moving applications to Windows Apps folder...")
-        #     # PathExtended.get_env().WindowsPaths().WindowsApps)
-        #     folder = PathExtended.home().joinpath("AppData/Local/Microsoft/WindowsApps")
-        #     apps_dir.search("*").apply(lambda app: app.move(folder=folder))
-        # elif platform.system().lower() in ["linux", "darwin"]:
-        #     system_name = "Linux" if platform.system().lower() == "linux" else "macOS"
-        #     print(f"🐧 Moving applications to {system_name} bin folder...")
-        #     if platform.system().lower() == "linux":
-        #         install_path = LINUX_INSTALL_PATH
-        #     else:  # Darwin/macOS
-        #         install_path = "/usr/local/bin"
-        #     Terminal().run(f"sudo mv {apps_dir.as_posix()}/* {install_path}/").capture().print_if_unsuccessful(desc=f"MOVING executable to {install_path}", strict_err=True, strict_returncode=True)
-        # else:
-        #     error_msg = f"❌ ERROR: System {platform.system()} not supported"
-        #     print(error_msg)
-        #     raise NotImplementedError(error_msg)
-
-        # apps_dir.delete(sure=True)
-        # print(f"✅ Safe installation completed\n{'='*80}")
-        # return None
-
     print(f"🚀 Starting installation of {len(installers_data)} packages...")
     print("📦 INSTALLING FIRST PACKAGE 📦")
     Installer(installers_data[0]).install(version=None)
@@ -214,7 +170,6 @@ def get_machineconfig_version() -> str:
     from importlib.metadata import PackageNotFoundError, version as _pkg_version
     from pathlib import Path
     import tomllib
-
     name: str = "machineconfig"
     try:
         return _pkg_version(name)

machineconfig/utils/io.py

@@ -1,4 +1,3 @@
-from __future__ import annotations
 
 from typing import Any, Union, Optional, Mapping
 from pathlib import Path
@@ -56,19 +55,36 @@ def read_ini(path: "Path", encoding: Optional[str] = None):
     return res
 
 
+def remove_c_style_comments(text: str) -> str:
+    import re
+    # Step 1: Escape URLs (https:// or any URLs you want to protect)
+    url_pattern = r'https?://[^\s]*'
+    urls = re.findall(url_pattern, text)
+    url_map = {url: f"__URL{index}__" for index, url in enumerate(urls)}
+    
+    # Temporarily replace URLs with placeholders
+    for url, placeholder in url_map.items():
+        text = text.replace(url, placeholder)
+    
+    # Step 2: Remove C-style comments
+    # Remove all // single-line comments
+    text = re.sub(r'//.*', '', text)
+    # Remove all /* … */ block comments (non-greedy)
+    text = re.sub(r'/\*.*?\*/', '', text, flags=re.DOTALL)
+    
+    # Step 3: Restore URLs
+    for url, placeholder in url_map.items():
+        text = text.replace(placeholder, url)
+    
+    return text
+
+
 def read_json(path: "Path", r: bool = False, **kwargs: Any) -> Any:  # return could be list or dict etc
     import json
     try:
         mydict = json.loads(Path(path).read_text(encoding="utf-8"), **kwargs)
     except Exception:
-        import re
-        def remove_comments(text: str) -> str:
-            # remove all // single-line comments
-            text = re.sub(r'//.*', '', text)
-            # remove all /* … */ block comments (non-greedy)
-            text = re.sub(r'/\*.*?\*/', '', text, flags=re.DOTALL)
-            return text
-        mydict = json.loads(remove_comments(Path(path).read_text(encoding="utf-8")), **kwargs)
+        mydict = json.loads(remove_c_style_comments(Path(path).read_text(encoding="utf-8")), **kwargs)
     _ = r
     return mydict
 
@@ -77,3 +93,72 @@ def from_pickle(path: Path) -> Any:
     import pickle
 
     return pickle.loads(path.read_bytes())
+
+
+def pwd2key(password: str, salt: Optional[bytes] = None, iterations: int = 10) -> bytes:  # Derive a secret key from a given password and salt"""
+    import base64
+    if salt is None:
+        import hashlib
+        m = hashlib.sha256()
+        m.update(password.encode(encoding="utf-8"))
+        return base64.urlsafe_b64encode(s=m.digest())  # make url-safe bytes required by Ferent.
+    from cryptography.hazmat.primitives import hashes
+    from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+    return base64.urlsafe_b64encode(PBKDF2HMAC(algorithm=hashes.SHA256(), length=32, salt=salt, iterations=iterations, backend=None).derive(password.encode()))
+
+
+def encrypt(msg: bytes, key: Optional[bytes] = None, pwd: Optional[str] = None, salted: bool = True, iteration: Optional[int] = None, gen_key: bool = False) -> bytes:
+    import base64
+    from cryptography.fernet import Fernet
+
+    salt, iteration = None, None
+    if pwd is not None:  # generate it from password
+        assert (key is None) and (type(pwd) is str), "❌ You can either pass key or pwd, or none of them, but not both."
+        import secrets
+        iteration = iteration or secrets.randbelow(exclusive_upper_bound=1_000_000)
+        salt = secrets.token_bytes(nbytes=16) if salted else None
+        key_resolved = pwd2key(password=pwd, salt=salt, iterations=iteration)
+    elif key is None:
+        if gen_key:
+            key_resolved = Fernet.generate_key()
+            Path.home().joinpath("dotfiles/creds/data/encrypted_files_key.bytes").write_bytes(key_resolved)
+        else:
+            try:
+                key_resolved = Path.home().joinpath("dotfiles/creds/data/encrypted_files_key.bytes").read_bytes()
+                print(f"⚠️ Using key from: {Path.home().joinpath('dotfiles/creds/data/encrypted_files_key.bytes')}")
+            except FileNotFoundError as err:
+                print("\n" * 3, "~" * 50, """Consider Loading up your dotfiles or pass `gen_key=True` to make and save one.""", "~" * 50, "\n" * 3)
+                raise FileNotFoundError(err) from err
+    elif isinstance(key, (str, Path)):
+        key_resolved = Path(key).read_bytes()  # a path to a key file was passed, read it:
+    elif type(key) is bytes:
+        key_resolved = key  # key passed explicitly
+    else:
+        raise TypeError("❌ Key must be either a path, bytes object or None.")
+    code = Fernet(key=key_resolved).encrypt(msg)
+    if pwd is not None and salt is not None and iteration is not None:
+        return base64.urlsafe_b64encode(b"%b%b%b" % (salt, iteration.to_bytes(4, "big"), base64.urlsafe_b64decode(code)))
+    return code
+
+
+def decrypt(token: bytes, key: Optional[bytes] = None, pwd: Optional[str] = None, salted: bool = True) -> bytes:
+    import base64
+    if pwd is not None:
+        assert key is None, "❌ You can either pass key or pwd, or none of them, but not both."
+        if salted:
+            decoded = base64.urlsafe_b64decode(token)
+            salt, iterations, token = decoded[:16], decoded[16:20], base64.urlsafe_b64encode(decoded[20:])
+            key_resolved = pwd2key(password=pwd, salt=salt, iterations=int.from_bytes(bytes=iterations, byteorder="big"))
+        else:
+            key_resolved = pwd2key(password=pwd)  # trailing `;` prevents IPython from caching the result.
+    elif type(key) is bytes:
+        assert pwd is None, "❌ You can either pass key or pwd, or none of them, but not both."
+        key_resolved = key  # passsed explicitly
+    elif key is None:
+        key_resolved = Path.home().joinpath("dotfiles/creds/data/encrypted_files_key.bytes").read_bytes()  # read from file
+    elif isinstance(key, (str, Path)):
+        key_resolved = Path(key).read_bytes()  # passed a path to a file containing kwy
+    else:
+        raise TypeError(f"❌ Key must be either str, P, Path, bytes or None. Recieved: {type(key)}")
+    from cryptography.fernet import Fernet
+    return Fernet(key=key_resolved).decrypt(token)

machineconfig/utils/links.py

@@ -1,4 +1,5 @@
 from machineconfig.utils.path_extended import PathExtended, PLike
+from machineconfig.profile.create_links_export import ON_CONFLICT_STRICT
 from machineconfig.utils.accessories import randstr
 from rich.console import Console
 from rich.panel import Panel
@@ -96,18 +97,18 @@ def build_links(target_paths: list[tuple[PLike, str]], repo_root: PLike):
 
 
 def symlink_map(config_file_default_path: PathExtended, self_managed_config_file_path: PathExtended,
-                 on_conflict: Literal["throwError", "overwriteSelfManaged", "backupSelfManaged", "overwriteDefaultPath", "backupDefaultPath"]
+                 on_conflict: ON_CONFLICT_STRICT
                  ) -> OperationResult:
     """helper function. creates a symlink from `config_file_default_path` to `self_managed_config_file_path`.
 
     Returns a dict with 'action' and 'details' keys describing what was done.
 
     on_conflict strategies:
-    - throwError: Raise exception when files differ
-    - overwriteSelfManaged: Delete self_managed_config_file_path (self-managed), move config_file_default_path to self_managed_config_file_path, create symlink
-    - backupSelfManaged: Backup self_managed_config_file_path (self-managed), move config_file_default_path to self_managed_config_file_path, create symlink
-    - overwriteDefaultPath: Delete config_file_default_path (default path), create symlink to self_managed_config_file_path
-    - backupDefaultPath: Backup config_file_default_path (default path), create symlink to self_managed_config_file_path
+    - throw-error: Raise exception when files differ
+    - overwrite-self-managed: Delete self_managed_config_file_path (self-managed), move config_file_default_path to self_managed_config_file_path, create symlink
+    - backup-self-managed: Backup self_managed_config_file_path (self-managed), move config_file_default_path to self_managed_config_file_path, create symlink
+    - overwrite-default-path: Delete config_file_default_path (default path), create symlink to self_managed_config_file_path
+    - backup-default-path: Backup config_file_default_path (default path), create symlink to self_managed_config_file_path
 
     Note: `config_file_default_path` is the default system location, `self_managed_config_file_path` is the self-managed config location
 
@@ -162,32 +163,41 @@ def symlink_map(config_file_default_path: PathExtended, self_managed_config_file
                     config_file_default_path.delete(sure=True)
                 else:
                     # Files are different, use on_conflict strategy
-                    if on_conflict == "throwError":
-                        raise RuntimeError(f"Conflict detected: {config_file_default_path} and {self_managed_config_file_path} both exist with different content")
-                    elif on_conflict == "overwriteSelfManaged":
-                        action_taken = "backing_up_target"
-                        details = "Overwriting self-managed config, moving default path to self-managed location"
-                        console.print(Panel(f"📦 OVERWRITE SELF-MANAGED | Deleting {self_managed_config_file_path}, moving {config_file_default_path} to {self_managed_config_file_path}", title="Overwrite Self-Managed", expand=False))
-                        self_managed_config_file_path.delete(sure=True)
-                        config_file_default_path.move(path=self_managed_config_file_path)
-                    elif on_conflict == "backupSelfManaged":
-                        backup_name = f"{self_managed_config_file_path}.orig_{randstr()}"
-                        action_taken = "backing_up_target"
-                        details = f"Backed up self-managed config to {backup_name}"
-                        console.print(Panel(f"📦 BACKUP SELF-MANAGED | Moving {self_managed_config_file_path} to {backup_name}, moving {config_file_default_path} to {self_managed_config_file_path}", title="Backup Self-Managed", expand=False))
-                        self_managed_config_file_path.move(path=backup_name)
-                        config_file_default_path.move(path=self_managed_config_file_path)
-                    elif on_conflict == "overwriteDefaultPath":
-                        action_taken = "backupConfigDefaultPath"
-                        details = "Overwriting default path, creating symlink to self-managed config"
-                        console.print(Panel(f"📦 OVERWRITE DEFAULT | Deleting {config_file_default_path}, creating symlink to {self_managed_config_file_path}", title="Overwrite Default", expand=False))
-                        config_file_default_path.delete(sure=True)
-                    elif on_conflict == "backupDefaultPath":
-                        backup_name = f"{config_file_default_path}.orig_{randstr()}"
-                        action_taken = "backupConfigDefaultPath"
-                        details = f"Backed up default path to {backup_name}"
-                        console.print(Panel(f"📦 BACKUP DEFAULT | Moving {config_file_default_path} to {backup_name}, creating symlink to {self_managed_config_file_path}", title="Backup Default", expand=False))
-                        config_file_default_path.move(path=backup_name)
+                    import subprocess
+                    command = f"""delta  --paging never --side-by-side "{config_file_default_path}" "{self_managed_config_file_path}" """
+                    try:
+                        console.print(Panel(f"🆘 CONFLICT DETECTED | Showing diff between {config_file_default_path} and {self_managed_config_file_path}", title="Conflict Detected", expand=False))
+                        subprocess.run(command, shell=True, check=True)
+                    except Exception:
+                        console.print(Panel("⚠️ Could not show diff using 'delta'. Please install 'delta' for better diff visualization.", title="Delta Not Found", expand=False))
+
+                    match on_conflict:
+                        case "throw-error":
+                            raise RuntimeError(f"Conflict detected: {config_file_default_path} and {self_managed_config_file_path} both exist with different content")
+                        case "overwrite-self-managed":
+                            action_taken = "backing_up_target"
+                            details = "Overwriting self-managed config, moving default path to self-managed location"
+                            console.print(Panel(f"📦 OVERWRITE SELF-MANAGED | Deleting {self_managed_config_file_path}, moving {config_file_default_path} to {self_managed_config_file_path}", title="Overwrite Self-Managed", expand=False))
+                            self_managed_config_file_path.delete(sure=True)
+                            config_file_default_path.move(path=self_managed_config_file_path)
+                        case "backup-self-managed":
+                            backup_name = f"{self_managed_config_file_path}.orig_{randstr()}"
+                            action_taken = "backing_up_target"
+                            details = f"Backed up self-managed config to {backup_name}"
+                            console.print(Panel(f"📦 BACKUP SELF-MANAGED | Moving {self_managed_config_file_path} to {backup_name}, moving {config_file_default_path} to {self_managed_config_file_path}", title="Backup Self-Managed", expand=False))
+                            self_managed_config_file_path.move(path=backup_name)
+                            config_file_default_path.move(path=self_managed_config_file_path)
+                        case "overwrite-default-path":
+                            action_taken = "backupConfigDefaultPath"
+                            details = "Overwriting default path, creating symlink to self-managed config"
+                            console.print(Panel(f"📦 OVERWRITE DEFAULT | Deleting {config_file_default_path}, creating symlink to {self_managed_config_file_path}", title="Overwrite Default", expand=False))
+                            config_file_default_path.delete(sure=True)
+                        case "backup-default-path":
+                            backup_name = f"{config_file_default_path}.orig_{randstr()}"
+                            action_taken = "backupConfigDefaultPath"
+                            details = f"Backed up default path to {backup_name}"
+                            console.print(Panel(f"📦 BACKUP DEFAULT | Moving {config_file_default_path} to {backup_name}, creating symlink to {self_managed_config_file_path}", title="Backup Default", expand=False))
+                            config_file_default_path.move(path=backup_name)
         else:
             # self_managed_config_file_path doesn't exist
             if config_file_default_path.is_symlink():
@@ -235,7 +245,7 @@ def symlink_map(config_file_default_path: PathExtended, self_managed_config_file
         return {"action": action_taken, "details": details}
 
 
-def copy_map(config_file_default_path: PathExtended, self_managed_config_file_path: PathExtended, on_conflict: Literal["throwError", "overwriteSelfManaged", "backupSelfManaged", "overwriteDefaultPath", "backupDefaultPath"]) -> OperationResult:
+def copy_map(config_file_default_path: PathExtended, self_managed_config_file_path: PathExtended, on_conflict: ON_CONFLICT_STRICT) -> OperationResult:
     config_file_default_path = PathExtended(config_file_default_path).expanduser().absolute()
     self_managed_config_file_path = PathExtended(self_managed_config_file_path).expanduser().absolute()
     
@@ -282,28 +292,36 @@ def copy_map(config_file_default_path: PathExtended, self_managed_config_file_pa
                     config_file_default_path.delete(sure=True)
                 else:
                     # Files are different, use on_conflict strategy
+                    import subprocess
+                    command = f"""delta  --paging never --side-by-side "{config_file_default_path}" "{self_managed_config_file_path}" """
+                    try:
+                        console.print(Panel(f"🆘 CONFLICT DETECTED | Showing diff between {config_file_default_path} and {self_managed_config_file_path}", title="Conflict Detected", expand=False))
+                        subprocess.run(command, shell=True, check=True)
+                    except Exception:
+                        console.print(Panel("⚠️ Could not show diff using 'delta'. Please install 'delta' for better diff visualization.", title="Delta Not Found", expand=False))
+
                     match on_conflict:
-                        case "throwError":
+                        case "throw-error":
                             raise RuntimeError(f"Conflict detected: {config_file_default_path} and {self_managed_config_file_path} both exist with different content")
-                        case "overwriteSelfManaged":
+                        case "overwrite-self-managed":
                             action_taken = "backing_up_target"
                             details = "Overwriting self-managed config with default path content"
                             console.print(Panel(f"📦 OVERWRITE SELF-MANAGED | Deleting {self_managed_config_file_path}, moving {config_file_default_path} to {self_managed_config_file_path}", title="Overwrite Self-Managed", expand=False))
                             self_managed_config_file_path.delete(sure=True)
                             config_file_default_path.move(path=self_managed_config_file_path)
-                        case "backupSelfManaged":
+                        case "backup-self-managed":
                             backup_name = f"{self_managed_config_file_path}.orig_{randstr()}"
                             action_taken = "backing_up_target"
                             details = f"Backed up self-managed config to {backup_name}"
                             console.print(Panel(f"📦 BACKUP SELF-MANAGED | Moving {self_managed_config_file_path} to {backup_name}, moving {config_file_default_path} to {self_managed_config_file_path}", title="Backup Self-Managed", expand=False))
                             self_managed_config_file_path.move(path=backup_name)
                             config_file_default_path.move(path=self_managed_config_file_path)
-                        case "overwriteDefaultPath":
+                        case "overwrite-default-path":
                             action_taken = "backupConfigDefaultPath"
                             details = "Overwriting default path with self-managed config"
                             console.print(Panel(f"📦 OVERWRITE DEFAULT | Deleting {config_file_default_path}, will copy from {self_managed_config_file_path}", title="Overwrite Default", expand=False))
                             config_file_default_path.delete(sure=True)
-                        case "backupDefaultPath":
+                        case "backup-default-path":
                             backup_name = f"{config_file_default_path}.orig_{randstr()}"
                             action_taken = "backupConfigDefaultPath"
                             details = f"Backed up default path to {backup_name}"