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

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

@@ -7,23 +7,28 @@ 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:
+        if tool_name is None:
             exe = downloaded_file_path.search("*.exe", r=True)[0]
             print(f"✅ Found executable: {exe}")
         else:
-            tmp = downloaded_file_path.search(f"{exe_name}.exe", r=True)
+            tmp = downloaded_file_path.search(f"{tool_name}.exe", r=True)
             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)
                 if len(search_res) == 0:
@@ -52,7 +57,13 @@ 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
@@ -64,16 +75,24 @@ def find_move_delete_linux(downloaded: PathExtended, tool_name: str, delete: Opt
             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}")
-            else:
-                exe = max(exe_search_res, key=lambda x: x.size("kb"))
+            if tool_name is None:  # no tool name provided, get the largest executable
+                search_res = downloaded.search("*", folders=False, files=True, r=True)
+                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.size("kb"))
                 print(f"✅ Selected largest executable ({exe.size('kb')} KB): {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}")
+                else:
+                    exe = max(exe_search_res, key=lambda x: x.size("kb"))
+                    print(f"✅ Selected largest executable ({exe.size('kb')} KB): {exe}")
 
     if rename_to and exe.name != rename_to:
         print(f"🏷️  Renaming '{exe.name}' to '{rename_to}'")
@@ -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"]
@@ -91,8 +91,12 @@ def get_installed_cli_apps():
     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
@@ -77,3 +76,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}"

machineconfig/utils/meta.py

@@ -5,7 +5,7 @@ from typing import Any
 
 
 def get_import_module_string(py_file: str) -> str:
-    from machineconfig.scripts.python.helpers_fire.helpers4 import get_import_module_code
+    from machineconfig.scripts.python.helpers_fire_command.file_wrangler import get_import_module_code
     from machineconfig.utils.accessories import get_repo_root
     from pathlib import Path
     repo_root = get_repo_root(Path(py_file))
@@ -29,7 +29,8 @@ except (ImportError, ModuleNotFoundError) as ex:
     return txt
 
 
-def lambda_to_python_script(lmb: Callable[[], Any], in_global: bool, import_module: bool) -> str:
+def lambda_to_python_script(lmb: Callable[[], Any],
+            in_global: bool, import_module: bool) -> str:
     """
     caveats: always use keyword arguments in the lambda call for best results.
     return statement not allowed in the wrapped function (otherwise it can be put in the global space)
@@ -55,6 +56,16 @@ def lambda_to_python_script(lmb: Callable[[], Any], in_global: bool, import_modu
     import types as _types
     from pathlib import Path as _Path
 
+    def _stringify_annotation(annotation: Any) -> Any:
+        if annotation is _inspect.Signature.empty or annotation is _inspect.Parameter.empty:
+            return annotation
+        if isinstance(annotation, str):
+            return annotation
+        try:
+            return _inspect.formatannotation(annotation)
+        except Exception:
+            return str(annotation)
+
     # sanity checks
     if not (callable(lmb) and isinstance(lmb, _types.LambdaType)):
         raise TypeError("Expected a lambda function object")
@@ -174,16 +185,18 @@ def lambda_to_python_script(lmb: Callable[[], Any], in_global: bool, import_modu
         else:
             new_default = param.default
 
-        # Recreate the Parameter (keeping annotation and kind)
+        normalized_annotation = _stringify_annotation(param.annotation)
+
         if new_default is _inspect.Parameter.empty:
-            new_param = _inspect.Parameter(name, param.kind, annotation=param.annotation)
+            new_param = _inspect.Parameter(name, param.kind, annotation=normalized_annotation)
         else:
             new_param = _inspect.Parameter(
-                name, param.kind, default=new_default, annotation=param.annotation
+                name, param.kind, default=new_default, annotation=normalized_annotation
             )
         new_params.append(new_param)
 
-    new_sig = _inspect.Signature(parameters=new_params, return_annotation=sig.return_annotation)
+    return_annotation = _stringify_annotation(sig.return_annotation)
+    new_sig = _inspect.Signature(parameters=new_params, return_annotation=return_annotation)
 
     # If in_global mode, return kwargs as global assignments + dedented body
     if in_global:
@@ -200,15 +213,11 @@ def lambda_to_python_script(lmb: Callable[[], Any], in_global: bool, import_modu
             
             # Build type annotation string if available
             if param.annotation is not _inspect.Parameter.empty:
-                # Try to get a nice string representation of the annotation
-                try:
-                    if hasattr(param.annotation, "__name__"):
-                        type_str = param.annotation.__name__
-                    else:
-                        type_str = str(param.annotation)
-                except Exception:
-                    type_str = str(param.annotation)
-                global_assignments.append(f"{name}: {type_str} = {repr(value)}")
+                annotation_literal = _stringify_annotation(param.annotation)
+                if isinstance(annotation_literal, str):
+                    global_assignments.append(f"{name}: {repr(annotation_literal)} = {repr(value)}")
+                else:
+                    global_assignments.append(f"{name} = {repr(value)}")
             else:
                 global_assignments.append(f"{name} = {repr(value)}")
         
@@ -230,12 +239,18 @@ def lambda_to_python_script(lmb: Callable[[], Any], in_global: bool, import_modu
         if lines[-1].startswith("return "):
             lines[-1] = lines[-1].replace("return ", "# return ", 1)
             result_text = "\n".join(lines)
-    if "Optional[" in result_text or "Any" in result_text or "Union[" in result_text or "Literal[" in result_text:
-        result_text = "from typing import *\n\n" + result_text
 
+    if "Optional" in result_text or "Any" in result_text or "Union" in result_text or "Literal" in result_text:
+        result_text = "from typing import Optional, Any, Union, Literal\n\n" + result_text
     if import_prefix:
         result_text = f"{import_prefix}{result_text}"
     return result_text
 
 if __name__ == "__main__":
-    pass
+    from machineconfig.utils.code import print_code
+    import_code_robust = "<import_code_robust>"
+    res = lambda_to_python_script(
+            lambda: print_code(code=import_code_robust, lexer="python", desc="import as module code"),
+            in_global=True, import_module=False
+        )
+    print(res)