machineconfig 5.15__py3-none-any.whl → 7.66__py3-none-any.whl

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

@@ -1,165 +1,147 @@
 """Devops Devapps Install"""
 
-from machineconfig.utils.installer import get_installers_system_groups
 import typer
-from rich.console import Console
-from rich.panel import Panel
-from rich.table import Table
-from typing import Optional, cast, get_args
-from machineconfig.jobs.installer.package_groups import PACKAGE_GROUPS, PACKAGE_GROUP2NAMES
-
-console = Console()
-
-
-def _handle_installer_not_found(search_term: str, all_installers: list["InstallerData"]) -> None:  # type: ignore
-    """Handle installer not found with friendly suggestions using fuzzy matching."""
-    from difflib import get_close_matches
-
-    all_names = []
-    for inst in all_installers:
-        exe_name = inst["appName"]
-        all_names.append(exe_name)
-    close_matches = get_close_matches(search_term, all_names, n=5, cutoff=0.4)
-    console.print(f"\n❌ '[red]{search_term}[/red]' was not found.", style="bold")
-
-    if close_matches:
-        console.print("🤔 Did you mean one of these?", style="yellow")
-        table = Table(show_header=False, box=None, pad_edge=False)
-        for i, match in enumerate(close_matches, 1):
-            table.add_row(f"[cyan]{i}.[/cyan]", f"[green]{match}[/green]")
-        console.print(table)
-    else:
-        console.print("📋 Here are some available options:", style="blue")
-        # Show first 10 installers as examples
-        sample_names = []
-        for inst in all_installers[:10]:
-            exe_name = inst["appName"]
-            sample_names.append(exe_name)
-
-        table = Table(show_header=False, box=None, pad_edge=False)
-        for i, name in enumerate(sample_names, 1):
-            table.add_row(f"[cyan]{i}.[/cyan]", f"[green]{name}[/green]")
-        console.print(table)
-
-        if len(all_installers) > 10:
-            console.print(f"   [dim]... and {len(all_installers) - 10} more[/dim]")
-
-    panel = Panel(f"[bold blue]💡 Use 'ia' to interactively browse all available installers.[/bold blue]\n[bold blue]💡 Use one of the categories: {list(get_args(PACKAGE_GROUPS))}[/bold blue]", title="[yellow]Helpful Tips[/yellow]", border_style="yellow")
-    console.print(panel)
-
-
-def main_with_parser():
-    import typer
-    app = typer.Typer()
-    app.command()(main)
-    app()
+from typing import Optional, Annotated
+from machineconfig.jobs.installer.package_groups import PACKAGE_GROUP2NAMES
 
 
 def main(
-    which: Optional[str] = typer.Option(None, "--which", "-w", help="Comma-separated list of program names to install."),
-    group: Optional[PACKAGE_GROUPS] = typer.Option(None, "--group", "-g", help=f"Group name (one of {list(get_args(PACKAGE_GROUPS))})"),
-    interactive: bool = typer.Option(False, "--interactive", "-ia", help="Interactive selection of programs to install."),
+    which: Annotated[Optional[str], typer.Argument(..., help="Comma-separated list of program/groups names to install (if --group flag is set).")] = None,
+    group: Annotated[bool, typer.Option(..., "--group", "-g", help="Treat 'which' as a group name. A group is bundle of apps.")] = False,
+    interactive: Annotated[bool, typer.Option(..., "--interactive", "-i", help="Interactive selection of programs to install.")] = False,
 ) -> None:
-    if which is not None:
-        return install_clis(clis_names=[x.strip() for x in which.split(",") if x.strip() != ""])
-    if group is not None:
-        return install_group(package_group=group)
     if interactive:
         return install_interactively()
-    typer.echo("❌ You must provide either --which, --group, or --interactive/-ia option.")
+    if which is not None:
+        if group:
+            for a_group in [x.strip() for x in which.split(",") if x.strip() != ""]:
+                return install_group(package_group=a_group)
+        else:
+            return install_clis(clis_names=[x.strip() for x in which.split(",") if x.strip() != ""])
+    else:
+        if group:
+            from rich.console import Console
+            from rich.table import Table
+            console = Console()
+
+            typer.echo("❌ You must provide a group name when using the --group/-g option.")
+            res = get_group_name_to_repr()
+            console.print("[bold blue]Here are the available groups:[/bold blue]")
+            table = Table(show_header=True, header_style="bold magenta")
+            table.add_column("Group", style="cyan", no_wrap=True)
+            table.add_column("AppsBundled", style="green", overflow="fold")
+            for display, group_name in res.items():
+                # Parse display
+                if "   --   " in display:
+                    group_part, items_part = display.split("   --   ", 1)
+                    group_name_parsed = group_part.replace("📦 ", "").strip()
+                    items_str = items_part.strip()
+                else:
+                    group_name_parsed = display
+                    items_str = group_name
+                table.add_row(group_name_parsed, items_str)
+            console.print(table)
+            raise typer.Exit(1)
+    typer.echo("❌ You must provide either a program name/group name, or use --interactive/-ia option.")
     import click
     ctx = click.get_current_context()
     typer.echo(ctx.get_help())
     raise typer.Exit(1)
 
 
-def install_interactively():
-    from machineconfig.utils.options import choose_from_options
-    from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
-    from machineconfig.utils.installer import get_installers
-    from machineconfig.utils.installer_utils.installer_class import Installer
-    installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=None)
-    installer_options = []
-    for x in installers:
-        installer_options.append(Installer(installer_data=x).get_description())
-    
+def get_group_name_to_repr() -> dict[str, str]:
     # Build category options and maintain a mapping from display text to actual category name
     category_display_to_name: dict[str, str] = {}
     for group_name, group_values in PACKAGE_GROUP2NAMES.items():
         display = f"📦 {group_name:<20}" + "   --   " + f"{'|'.join(group_values):<60}"
         category_display_to_name[display] = group_name
-    
-    options_system = get_installers_system_groups()
-    for item in options_system:
-        display = f"📦 {item['appName']:<20}   --   {item['doc']:<60}"
-        category_display_to_name[display] = item['appName']
-    
-    options = list(category_display_to_name.keys()) + ["─" * 50] + installer_options
-    program_names = choose_from_options(multi=True, msg="Categories are prefixed with 📦", options=options, header="🚀 CHOOSE DEV APP OR CATEGORY", default="📦 essentials", fzf=True)
+    return category_display_to_name
+
+
+def install_interactively():
+    from machineconfig.utils.options import choose_from_options
+    from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
+    from machineconfig.utils.installer_utils.installer_runner import get_installers
+    from machineconfig.utils.installer_utils.installer_class import Installer
+    from rich.console import Console
+    from rich.panel import Panel
+    # from rich.table import Table
+    installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=None)
+    installer_options = [Installer(installer_data=x).get_description() for x in installers]
+    category_display_to_name = get_group_name_to_repr()
+    options = list(category_display_to_name.keys()) + installer_options
+    program_names = choose_from_options(multi=True, msg="Categories are prefixed with 📦", options=options, header="🚀 CHOOSE DEV APP OR CATEGORY", fzf=True)
     installation_messages: list[str] = []
     for _an_idx, a_program_name in enumerate(program_names):
-        if a_program_name.startswith("─"):  # 50 dashes separator
-            continue
         if a_program_name.startswith("📦 "):
             category_name = category_display_to_name.get(a_program_name)
             if category_name:
-                install_group(package_group=cast(PACKAGE_GROUPS, category_name))
+                install_group(package_group=category_name)
         else:
             installer_idx = installer_options.index(a_program_name)
             an_installer_data = installers[installer_idx]
             status_message = Installer(an_installer_data).install_robust(version=None)  # finish the task - this returns a status message, not a command
             installation_messages.append(status_message)
     if installation_messages:
+        console = Console()
+
         panel = Panel("\n".join([f"[blue]• {message}[/blue]" for message in installation_messages]), title="[bold green]📊 Installation Summary[/bold green]", border_style="green", padding=(1, 2))
         console.print(panel)
 
 
-def install_group(package_group: PACKAGE_GROUPS):
-    panel = Panel(f"[bold yellow]Installing programs from category: [green]{package_group}[/green][/bold yellow]", title="[bold blue]📦 Category Installation[/bold blue]", border_style="blue", padding=(1, 2))
-    console.print(panel)
-    from machineconfig.utils.installer import get_installers, install_bulk
+def install_group(package_group: str):
+    from machineconfig.utils.installer_utils.installer_runner import get_installers, install_bulk
     from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
+    from rich.console import Console
+    from rich.panel import Panel
+    # from rich.table import Table
     if package_group in PACKAGE_GROUP2NAMES:
+        panel = Panel(f"[bold yellow]Installing programs from category: [green]{package_group}[/green][/bold yellow]", title="[bold blue]📦 Category Installation[/bold blue]", border_style="blue", padding=(1, 2))
+        console = Console()
+        console.print(panel)
         installers_ = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=[package_group])
         install_bulk(installers_data=installers_)
+        return
+    console = Console()
+    console.print(f"❌ ERROR: Unknown package group: {package_group}. Available groups are: {list(PACKAGE_GROUP2NAMES.keys())}")
+def _handle_installer_not_found(search_term: str, all_names: list[str]) -> None:  # type: ignore
+    """Handle installer not found with friendly suggestions using fuzzy matching."""
+    from difflib import get_close_matches
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.table import Table
+    close_matches = get_close_matches(search_term, all_names, n=5, cutoff=0.4)
+    console = Console()
+
+    console.print(f"\n❌ '[red]{search_term}[/red]' was not found.", style="bold")
+    if close_matches:
+        console.print("🤔 Did you mean one of these?", style="yellow")
+        table = Table(show_header=False, box=None, pad_edge=False)
+        for i, match in enumerate(close_matches, 1):
+            table.add_row(f"[cyan]{i}.[/cyan]", f"[green]{match}[/green]")
+        console.print(table)
     else:
-        options_system = get_installers_system_groups()
-        from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
-        from machineconfig.utils.code import run_shell_script
-        for an_item in options_system:
-            if an_item["appName"] == package_group:
-                program = an_item["fileNamePattern"][get_normalized_arch()][get_os_name()]
-                if program is not None:
-                    run_shell_script(program)
-                    break
-
-
-def choose_from_system_package_groups(options_system: dict[str, tuple[str, str]]) -> str:
-    from machineconfig.utils.options import choose_from_options
-    display_options = []
-    for group_name, (description, _) in options_system.items():
-        if description:
-            display_options.append(f"{group_name:<20} - {description}")
+        console.print("📋 Here are some available options:", style="blue")
+        # Show first 10 installers as examples
+        if len(all_names) > 10:
+            sample_names = all_names[:10]
         else:
-            display_options.append(group_name)
-    program_names = choose_from_options(multi=True, msg="", options=sorted(display_options), header="🚀 CHOOSE DEV APP", fzf=True)
-    program = ""
-    for display_name in program_names:
-        # Extract the actual group name (everything before " - " if present)
-        group_name = display_name.split(" - ")[0].strip() if " - " in display_name else display_name.strip()
-        console.print(f"\n[bold cyan]⚙️  Installing: [yellow]{group_name}[/yellow][/bold cyan]", style="bold")
-        _, sub_program = options_system[group_name]  # Extract content from tuple
-        if sub_program.startswith("#winget"):
-            sub_program = sub_program[1:]
-        program += "\n" + sub_program
-    return program
+            sample_names = all_names
+        table = Table(show_header=False, box=None, pad_edge=False)
+        for i, name in enumerate(sample_names, 1):
+            table.add_row(f"[cyan]{i}.[/cyan]", f"[green]{name}[/green]")
+        console.print(table)
+        if len(all_names) > 10:
+            console.print(f"   [dim]... and {len(all_names) - 10} more[/dim]")
 
+    panel = Panel(f"[bold blue]💡 Use 'ia' to interactively browse all available installers.[/bold blue]\n[bold blue]💡 Use one of the categories: {list(PACKAGE_GROUP2NAMES.keys())}[/bold blue]", title="[yellow]Helpful Tips[/yellow]", border_style="yellow")
+    console.print(panel)
 
 def install_clis(clis_names: list[str]):
     from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
-    from machineconfig.utils.installer import get_installers
+    from machineconfig.utils.installer_utils.installer_runner import get_installers
     from machineconfig.utils.installer_utils.installer_class import Installer
-
+    from rich.console import Console
     total_messages: list[str] = []
     for a_which in clis_names:
         all_installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=None)
@@ -170,15 +152,25 @@ def install_clis(clis_names: list[str]):
                 selected_installer = installer
                 break
         if selected_installer is None:
-            _handle_installer_not_found(a_which, all_installers)
+            _handle_installer_not_found(a_which, all_names=[inst["appName"] for inst in all_installers])
             return None
         message = Installer(selected_installer).install_robust(version=None)  # finish the task
         total_messages.append(message)
     if total_messages:
+        console = Console()
         console.print("\n[bold green]📊 Installation Results:[/bold green]")
         for a_message in total_messages:
             console.print(f"[blue]• {a_message}[/blue]")
     return None
+def install_if_missing(which: str):
+    from machineconfig.utils.installer_utils.installer_locator_utils import check_tool_exists
+    exists = check_tool_exists(which)
+    if exists:
+        print(f"✅ {which} is already installed.")
+        return
+    print(f"⏳ {which} not found. Installing...")
+    from machineconfig.utils.installer_utils.installer_cli import main
+    main(which=which, interactive=False)
 
 
 if __name__ == "__main__":

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

@@ -1,4 +1,3 @@
-
 from machineconfig.utils.path_extended import PathExtended
 from machineconfig.utils.source_of_truth import WINDOWS_INSTALL_PATH, LINUX_INSTALL_PATH, INSTALL_VERSION_ROOT
 
@@ -9,7 +8,7 @@ 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(f"\n{'=' * 80}\n🔍 PROCESSING WINDOWS EXECUTABLE 🔍\n{'=' * 80}")
+    print("🔍 PROCESSING WINDOWS EXECUTABLE 🔍")
     if exe_name is not None and ".exe" in exe_name:
         exe_name = exe_name.replace(".exe", "")
     if downloaded_file_path.is_file():
@@ -54,7 +53,7 @@ def find_move_delete_windows(downloaded_file_path: PathExtended, exe_name: Optio
 
 
 def find_move_delete_linux(downloaded: PathExtended, tool_name: str, delete: Optional[bool] = True, rename_to: Optional[str] = None):
-    print(f"\n{'=' * 80}\n🔍 PROCESSING LINUX EXECUTABLE 🔍\n{'=' * 80}")
+    print("🔍 PROCESSING LINUX EXECUTABLE 🔍")
     if downloaded.is_file():
         exe = downloaded
         print(f"📄 Found direct executable file: {exe}")
@@ -108,33 +107,52 @@ def find_move_delete_linux(downloaded: PathExtended, tool_name: str, delete: Opt
         print("✅ Temporary files removed")
 
     exe_new_location = PathExtended(LINUX_INSTALL_PATH).joinpath(exe.name)
-    print(f"✅ Executable installed at: {exe_new_location}\n{'=' * 80}")
+    print(f"✅ Executable installed at: {exe_new_location}")
     return exe_new_location
 
 
 def check_tool_exists(tool_name: str) -> bool:
     if platform.system() == "Windows":
-        tool_name = tool_name.replace(".exe", "") + ".exe"
-        res1 = any([Path(WINDOWS_INSTALL_PATH).joinpath(tool_name).is_file(), Path.home().joinpath("AppData/Roaming/npm").joinpath(tool_name).is_file()])
-        tool_name = tool_name.replace(".exe", "") + ".exe"
-        res2 = any([Path(WINDOWS_INSTALL_PATH).joinpath(tool_name).is_file(), Path.home().joinpath("AppData/Roaming/npm").joinpath(tool_name).is_file()])
-        return res1 or res2
+        tool_name_exe = tool_name.replace(".exe", "") + ".exe"
+        res1 = any([Path(WINDOWS_INSTALL_PATH).joinpath(tool_name_exe).is_file(), Path.home().joinpath("AppData/Roaming/npm").joinpath(tool_name_exe).is_file()])
+        if res1:
+            return True
+        tool_name_no_exe = tool_name.replace(".exe", "")
+        res2 = any([Path(WINDOWS_INSTALL_PATH).joinpath(tool_name_no_exe).is_file(), Path.home().joinpath("AppData/Roaming/npm").joinpath(tool_name_no_exe).is_file()])
+        return res2
     elif platform.system() in ["Linux", "Darwin"]:
         root_path = Path(LINUX_INSTALL_PATH)
-        return any([Path("/usr/local/bin").joinpath(tool_name).is_file(), Path("/usr/bin").joinpath(tool_name).is_file(), root_path.joinpath(tool_name).is_file()])
+        standard_checks = [
+            Path("/usr/local/bin").joinpath(tool_name).is_file(),
+            Path("/usr/bin").joinpath(tool_name).is_file(),
+            root_path.joinpath(tool_name).is_file()
+        ]
+        if any(standard_checks):
+            return True
+        # Check for npm packages via nvm
+        npm_check = False
+        try:
+            result = subprocess.run(["node", "--version"], capture_output=True, text=True, check=True)
+            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:
+            pass
+        return npm_check
     else:
         raise NotImplementedError(f"platform {platform.system()} not implemented")
-def is_executable_in_path(executable_name: str) -> bool:
+
+def is_executable_in_path(name: str) -> bool:
     import os
     path_dirs = os.environ['PATH'].split(os.pathsep)
     for path_dir in path_dirs:
-        path_to_executable = os.path.join(path_dir, executable_name)
+        path_to_executable = os.path.join(path_dir, name)
         if os.path.isfile(path_to_executable) and os.access(path_to_executable, os.X_OK): return True
     return False
 
 
 def check_if_installed_already(exe_name: str, version: Optional[str], use_cache: bool) -> tuple[str, str, str]:
-    print(f"\n{'=' * 80}\n🔍 CHECKING INSTALLATION STATUS: {exe_name} 🔍\n{'=' * 80}")
+    print(f"🔍 CHECKING INSTALLATION STATUS: {exe_name} 🔍")
     INSTALL_VERSION_ROOT.joinpath(exe_name).parent.mkdir(parents=True, exist_ok=True)
     tmp_path = INSTALL_VERSION_ROOT.joinpath(exe_name)
 
@@ -173,71 +191,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,17 +1,15 @@
 """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 rich.console import Console
-from rich.panel import Panel
-
+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, LIBRARY_ROOT
+from machineconfig.utils.source_of_truth import INSTALL_VERSION_ROOT, LINUX_INSTALL_PATH
 from machineconfig.utils.io import read_json
 
+from rich.console import Console
+from rich.panel import Panel
 from typing import Any, Optional
 import platform
 from joblib import Parallel, delayed
@@ -20,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"]
@@ -65,16 +63,16 @@ def check_latest():
 
     # Print each group
     for status, items in grouped_data.items():
-        print(f"\n{status.upper()}:")
-        print("-" * 60)
+        console.print(f"\n[bold]{status.upper()}:[/bold]")
+        console.rule(style="dim")
         for item in items:
-            print(f"  {item['Tool']:<20} | Current: {item['Current Version']:<15} | New: {item['New Version']}")
-    print("-" * 60)
-    print(f"{'═' * 80}")
+            console.print(f"  {item['Tool']:<20} | Current: {item['Current Version']:<15} | New: {item['New Version']}")
+    console.rule(style="dim")
+    console.rule(style="bold blue")
 
 
 def get_installed_cli_apps():
-    print(f"\n{'=' * 80}\n🔍 LISTING INSTALLED CLI APPS 🔍\n{'=' * 80}")
+    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"])
@@ -89,12 +87,11 @@ def get_installed_cli_apps():
         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
-    print(f"✅ Found {len(apps)} installed applications\n{'=' * 80}")
+    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]:
-    print(f"\n{'=' * 80}\n🔍 LOADING INSTALLER CONFIGURATIONS 🔍\n{'=' * 80}")
+def get_installers(os: OPERATING_SYSTEMS, arch: CPU_ARCHITECTURES, which_cats: Optional[list[str]]) -> list[InstallerData]:
     res_all = get_all_installer_data_files()
     acceptable_apps_names: list[str] | None = None
     if which_cats is not None:
@@ -108,84 +105,38 @@ 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)
-    print(f"✅ Loaded {len(all_installers)} installer configurations\n{'=' * 80}")
     return all_installers
 
 
 def get_all_installer_data_files() -> list[InstallerData]:
-    print(f"\n{'=' * 80}\n📂 LOADING CONFIGURATION FILES 📂\n{'=' * 80}")
     import machineconfig.jobs.installer as module
     from pathlib import Path
-    print("📂 Loading configuration files...")
     res_raw: InstallerDataFiles = read_json(Path(module.__file__).parent.joinpath("installer_data.json"))
     res_final: list[InstallerData] = res_raw["installers"]
-    print(f"Loaded: {len(res_final)} installer categories")
-    return res_final
-
-
-def get_installers_system_groups():
-    res_final: list[InstallerData] = []
-    from platform import system
-    if system() == "Windows":
-        options_system = parse_apps_installer_windows(LIBRARY_ROOT.joinpath("setup_windows/apps.ps1").read_text(encoding="utf-8"))
-    elif system() == "Linux" or system() == "Darwin":
-        options_system = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps.sh").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(f"\n{'=' * 80}\n🚀 BULK INSTALLATION PROCESS 🚀\n{'=' * 80}")
+    print("🚀 BULK INSTALLATION PROCESS 🚀")
     if fresh:
         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(f"\n{'=' * 80}\n📦 INSTALLING FIRST PACKAGE 📦\n{'=' * 80}")
+    print("📦 INSTALLING FIRST PACKAGE 📦")
     Installer(installers_data[0]).install(version=None)
     installers_remaining = installers_data[1:]
-    print(f"\n{'=' * 80}\n📦 INSTALLING REMAINING PACKAGES 📦\n{'=' * 80}")
+    print("📦 INSTALLING REMAINING PACKAGES 📦")
 
     # Use joblib for parallel processing of remaining installers
     res = Parallel(n_jobs=jobs)(delayed(lambda x: Installer(x).install_robust(version=None))(installer) for installer in installers_remaining)
@@ -218,4 +169,23 @@ def install_bulk(installers_data: list[InstallerData], safe: bool = False, jobs:
     print("\n" * 2)
 
 
-
+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)
+    except PackageNotFoundError:
+        pass
+    root: Path = Path(__file__).resolve().parents[2]
+    pyproject: Path = root / "pyproject.toml"
+    if pyproject.is_file():
+        with pyproject.open("rb") as f:
+            data: dict[str, object] = tomllib.load(f)
+        project = data.get("project")
+        if isinstance(project, dict):
+            version = project.get("version")
+            if isinstance(version, str) and version:
+                return version
+    return "0.0.0"