machineconfig 7.49__py3-none-any.whl → 7.64__py3-none-any.whl

machineconfig/setup_windows/web_shortcuts/interactive.ps1

@@ -3,16 +3,16 @@
 iex (iwr "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_windows/uv.ps1").Content
 iex (iwr "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/scripts/windows/wrap_mcfg.ps1").Content
 
-function devops   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.49" devops $args }
-function cloud    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.49" cloud $args }
-function agents   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.49" agents $args }
-function sessions { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.49" sessions $args }
-function ftpx     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.49" ftpx $args }
-function fire     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.49" fire $args }
-function croshell { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.49" croshell $args }
-function utils    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.49" utils $args }
-function terminal { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.49" terminal $args }
-function msearch    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.49" msearch $args }
+function devops   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" devops $args }
+function cloud    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" cloud $args }
+function agents   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" agents $args }
+function sessions { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" sessions $args }
+function ftpx     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" ftpx $args }
+function fire     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" fire $args }
+function croshell { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" croshell $args }
+function utils    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" utils $args }
+function terminal { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" terminal $args }
+function msearch  { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" msearch $args }
 
 function d { wrap_in_shell_script devops @args }
 function c { wrap_in_shell_script cloud @args }
@@ -26,3 +26,5 @@ function t { wrap_in_shell_script terminal @args }
 function ms { wrap_in_shell_script msearch @args }
 
 Write-Host "mcfg command aliases are now defined in this PowerShell session."
+
+devops self interactive

machineconfig/setup_windows/web_shortcuts/quick_init.ps1

@@ -0,0 +1,16 @@
+
+iex (iwr "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_windows/uv.ps1").Content
+# iex (iwr "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/scripts/windows/wrap_mcfg.ps1").Content
+uv tool install --upgrade  --python 3.14 machineconfig both
+
+devops install --group sysabc
+
+# configs
+devops config copy-assets both
+devops config public --method copy --on-conflict overwrite-default-path --which all
+devops config shell
+devops config shell --which nushell
+
+wt  # start Windows Terminal to pick up config changes
+devops install --group termabc
+devops install --group gui

machineconfig/utils/code.py

@@ -132,7 +132,7 @@ def exit_then_run_shell_script(script: str, strict: bool = False):
             op_program_path = Path.home().joinpath("tmp_results", "tmp_scripts", "manual_run", f"manual_script_{randstr()}{suffix}")
             op_program_path.parent.mkdir(parents=True, exist_ok=True)
             op_program_path.write_text(script, encoding="utf-8")
-            print_code(script, lexer=lexer, desc="script to run manually")
+            print_code(code=script, lexer=lexer, desc="script to run manually")
             console.print("[bold yellow]⚠️  STRICT MODE:[/bold yellow] [cyan]Please run the script manually via your shell by executing:[/cyan]")
             console.print(f"[green]{str(op_program_path)}[/green]")
             console.print("[red]❌ OP_PROGRAM_PATH environment variable is not set in strict mode.[/red]")
@@ -145,7 +145,7 @@ def exit_then_run_shell_script(script: str, strict: bool = False):
         op_program_path.write_text(script, encoding="utf-8")
         console.print("[cyan]🚀 Handing over to shell script runner via OP_PROGRAM_PATH:[/cyan]")
         console.print(f"[bold green]{str(op_program_path)}[/bold green]")
-        print_code(script, lexer="shell", desc="script to run via OP_PROGRAM_PATH")
+        print_code(code=script, lexer="shell", desc="script to run via OP_PROGRAM_PATH")
     else:
         if op_program_path is not None and exists:
             console.print(f"[yellow]⚠️  OP_PROGRAM_PATH @ {str(op_program_path)} already exists.[/yellow] [cyan]Falling back to direct execution.[/cyan]")

machineconfig/utils/files/headers.py

@@ -25,7 +25,7 @@ def print_header():
     table.add_row("Virtual Environment", os.getenv('VIRTUAL_ENV', 'None'))
     table.add_row("Running @", str(Path.cwd()))
 
-    from machineconfig.utils.installer import get_machineconfig_version
+    from machineconfig.utils.installer_utils.installer_runner import get_machineconfig_version
 
     console.print(Panel(table, title=f"[bold blue]✨ 🐊 Machineconfig Shell {get_machineconfig_version()} ✨ Made with 🐍 | Built with ❤️[/bold blue]", border_style="blue"))
 def print_logo(logo: str):
@@ -44,7 +44,7 @@ def print_logo(logo: str):
             _default_art = Path(random.choice(glob.glob(str(Path(__file__).parent.joinpath("art", "*")))))
             print(_default_art.read_text())
     elif platform.system() in ["Linux", "Darwin"]:  # Explicitly handle both Linux and macOS
-        from machineconfig.utils.installer_utils.installer_abc import is_executable_in_path
+        from machineconfig.utils.installer_utils.installer_locator_utils import is_executable_in_path
         avail_cowsay = is_executable_in_path("cowsay")
         avail_lolcat = is_executable_in_path("lolcat")
         avail_boxes = is_executable_in_path("boxes")

machineconfig/utils/installer_utils/installer_class.py

@@ -1,7 +1,6 @@
-from machineconfig.utils.path_extended import PathExtended
-from machineconfig.utils.installer_utils.installer_abc import find_move_delete_linux, find_move_delete_windows
+from machineconfig.utils.path_extended import PathExtended, DECOMPRESS_SUPPORTED_FORMATS
 from machineconfig.utils.source_of_truth import INSTALL_TMP_DIR, INSTALL_VERSION_ROOT
-from machineconfig.utils.installer_utils.installer_abc import check_tool_exists
+from machineconfig.utils.installer_utils.installer_locator_utils import find_move_delete_linux, find_move_delete_windows, check_tool_exists
 from machineconfig.utils.schemas.installer.installer_types import InstallerData, get_os_name, get_normalized_arch
 
 import platform
@@ -11,6 +10,24 @@ from typing import Optional, Any
 from urllib.parse import urlparse
 
 
+
+def install_deb_package(downloaded: PathExtended) -> None:
+    print(f"📦 Installing .deb package: {downloaded}")
+    assert platform.system() == "Linux"
+    result = subprocess.run(f"sudo nala install -y {downloaded}", shell=True, capture_output=True, text=True)
+    success = result.returncode == 0 and result.stderr == ""
+    if not success:
+        desc = "Installing .deb"
+        print(f"❌ {desc} failed")
+        if result.stdout:
+            print(f"STDOUT: {result.stdout}")
+        if result.stderr:
+            print(f"STDERR: {result.stderr}")
+        print(f"Return code: {result.returncode}")
+    print("🗑️  Cleaning up .deb package...")
+    downloaded.delete(sure=True)
+
+
 class Installer:
     def __init__(self, installer_data: InstallerData):
         self.installer_data: InstallerData = installer_data
@@ -42,10 +59,8 @@ class Installer:
             result_new = subprocess.run(f"{exe_name} --version", shell=True, capture_output=True, text=True)
             new_version_cli = result_new.stdout.strip()
             if old_version_cli == new_version_cli:
-                # print(f"ℹ️  Same version detected: {old_version_cli}")
                 return f"""📦️ 😑 {exe_name}, same version: {old_version_cli}"""
             else:
-                # print(f"🚀 Update successful: {old_version_cli} ➡️ {new_version_cli}")
                 return f"""📦️ 🤩 {exe_name} updated from {old_version_cli} ➡️ TO ➡️  {new_version_cli}"""
         except Exception as ex:
             exe_name = self._get_exe_name()
@@ -69,8 +84,6 @@ class Installer:
                 desc = package_manager + " installation"
                 version_to_be_installed = package_manager + "Latest"
                 result = subprocess.run(installer_arch_os, shell=True, capture_output=True, text=False)
-                # from machineconfig.utils.code import run_shell_script
-                # result = run_shell_script(installer_arch_os)
                 success = result.returncode == 0 and result.stderr == "".encode()
                 if not success:
                     print(f"❌ {desc} failed")
@@ -80,7 +93,6 @@ class Installer:
                         print(f"STDERR: {result.stderr}")
                     print(f"Return code: {result.returncode}")
             elif installer_arch_os.endswith((".sh", ".py", ".ps1")):
-                # search for the script, see which path ends with the script name
                 import machineconfig.jobs.installer as module
                 from pathlib import Path
                 search_root = Path(module.__file__).parent
@@ -106,9 +118,14 @@ class Installer:
                     runpy.run_path(str(installer_path), run_name=None)["main"](self.installer_data, version=version)
                     version_to_be_installed = str(version)
             elif installer_arch_os.startswith("https://"):  # its a url to be downloaded
-                downloaded_object = PathExtended(installer_arch_os).download(folder=INSTALL_TMP_DIR)
+                # downloaded_object = PathExtended(installer_arch_os).download(folder=INSTALL_TMP_DIR)
+                from machineconfig.scripts.python.helpers_utils.download import download
+                downloaded_object = download(installer_arch_os, output_dir=str(INSTALL_TMP_DIR))
+                if downloaded_object is None:
+                    raise ValueError(f"Failed to download from URL: {installer_arch_os}")
                 # object is either a zip containing a binary or a straight out binary.
-                if downloaded_object.suffix in [".zip", ".tar.gz"]:
+                downloaded_object = PathExtended(downloaded_object)
+                if downloaded_object.suffix in DECOMPRESS_SUPPORTED_FORMATS:
                     downloaded_object = downloaded_object.decompress()
                 if downloaded_object.suffix in [".exe", ""]:  # likely an executable
                     if platform.system() == "Windows":
@@ -131,26 +148,17 @@ class Installer:
                         print(f"🔄 Renaming to correct name: {new_exe_name}")
                         exe.with_name(name=new_exe_name, inplace=True, overwrite=True)
                     version_to_be_installed = "downloaded_binary"
+                elif downloaded_object.suffix in [".deb"]:
+                    install_deb_package(downloaded_object)
+                    version_to_be_installed = "downloaded_deb"
+                else:
+                    raise ValueError(f"Downloaded file is not an executable: {downloaded_object}")
             else:
                 raise NotImplementedError(f"CMD installation method not implemented for: {installer_arch_os}")
         else:
             assert repo_url.startswith("https://github.com/"), f"repoURL must be a GitHub URL, got {repo_url}"
-            downloaded, version_to_be_installed = self.download(version=version)
-            if str(downloaded).endswith(".deb"):
-                print(f"📦 Installing .deb package: {downloaded}")
-                assert platform.system() == "Linux"
-                result = subprocess.run(f"sudo nala install -y {downloaded}", shell=True, capture_output=True, text=True)
-                success = result.returncode == 0 and result.stderr == ""
-                if not success:
-                    desc = "Installing .deb"
-                    print(f"❌ {desc} failed")
-                    if result.stdout:
-                        print(f"STDOUT: {result.stdout}")
-                    if result.stderr:
-                        print(f"STDERR: {result.stderr}")
-                    print(f"Return code: {result.returncode}")
-                print("🗑️  Cleaning up .deb package...")
-                downloaded.delete(sure=True)
+            downloaded, version_to_be_installed = self.binary_download(version=version)
+            if str(downloaded).endswith(".deb"): install_deb_package(downloaded)
             else:
                 if platform.system() == "Windows":
                     exe = find_move_delete_windows(downloaded_file_path=downloaded, exe_name=exe_name, delete=True, rename_to=exe_name.replace(".exe", "") + ".exe")
@@ -173,13 +181,13 @@ class Installer:
                     exe.with_name(name=new_exe_name, inplace=True, overwrite=True)
         INSTALL_VERSION_ROOT.joinpath(exe_name).parent.mkdir(parents=True, exist_ok=True)
         INSTALL_VERSION_ROOT.joinpath(exe_name).write_text(version_to_be_installed or "unknown", encoding="utf-8")
-    def download(self, version: Optional[str]) -> tuple[PathExtended, str]:
+    def binary_download(self, version: Optional[str]) -> tuple[PathExtended, str]:
         exe_name = self._get_exe_name()
         repo_url = self.installer_data["repoURL"]
         # app_name = self.installer_data["appName"]
         download_link: Optional[str] = None
         version_to_be_installed: Optional[str] = None
-        if "github" not in repo_url or ".zip" in repo_url or ".tar.gz" in repo_url:
+        if "github" not in repo_url or (any(ext in repo_url for ext in DECOMPRESS_SUPPORTED_FORMATS)):
             # Direct download URL
             download_link = repo_url
             version_to_be_installed = "predefined_url"
@@ -200,10 +208,11 @@ class Installer:
         assert download_link is not None, "download_link must be set"
         assert version_to_be_installed is not None, "version_to_be_installed must be set"
         downloaded = PathExtended(download_link).download(folder=INSTALL_TMP_DIR).decompress()
+        if downloaded.is_dir() and len(downloaded.search("*", r=True)) == 1:
+            only_file_in = next(downloaded.glob("*"))
+            if only_file_in.is_file() and only_file_in.suffix in DECOMPRESS_SUPPORTED_FORMATS:  # further decompress
+                downloaded = only_file_in.decompress()
         return downloaded, version_to_be_installed
-
-    # --------------------------- Arch / template helpers ---------------------------
-
     @staticmethod
     def _get_repo_name_from_url(repo_url: str) -> str:
         """Extract owner/repo from GitHub URL."""
@@ -218,23 +227,16 @@ class Installer:
     def _fetch_github_release_data(repo_name: str, version: Optional[str] = None) -> Optional[dict[str, Any]]:
         """Fetch release data from GitHub API using requests."""
         import requests
-        
         try:
-            if version and version.lower() != "latest":
-                # Fetch specific version
+            if version and version.lower() != "latest":  # Fetch specific version
                 url = f"https://api.github.com/repos/{repo_name}/releases/tags/{version}"
-            else:
-                # Fetch latest release
+            else:   # Fetch latest release
                 url = f"https://api.github.com/repos/{repo_name}/releases/latest"
-            
             response = requests.get(url, timeout=30)
-            
             if response.status_code != 200:
                 print(f"❌ Failed to fetch data for {repo_name}: HTTP {response.status_code}")
                 return None
-                
             response_data = response.json()
-            
             # Check if API returned an error
             if "message" in response_data:
                 if "API rate limit exceeded" in response_data.get("message", ""):

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

@@ -1,56 +1,14 @@
 """Devops Devapps Install"""
 
-from machineconfig.utils.installer import dynamically_extract_installers_system_groups_from_scripts
 import typer
-from rich.console import Console
-from rich.panel import Panel
-from rich.table import Table
-from typing import Optional, cast, get_args, Annotated
-from machineconfig.jobs.installer.package_groups import PACKAGE_GROUPS, PACKAGE_GROUP2NAMES
-
-console = Console()
-
-
-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
-    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
-        if len(all_names) > 10:
-            sample_names = all_names[:10]
-        else:
-            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(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: 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", "-ia", help="Interactive selection of programs to install.")] = False,
+    interactive: Annotated[bool, typer.Option(..., "--interactive", "-i", help="Interactive selection of programs to install.")] = False,
 ) -> None:
     if interactive:
         return install_interactively()
@@ -62,8 +20,12 @@ def main(
             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_static_groups_combined_with_dynamic_groups_extracted()
+            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)
@@ -87,100 +49,99 @@ def main(
     raise typer.Exit(1)
 
 
-def get_static_groups_combined_with_dynamic_groups_extracted():
+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 = dynamically_extract_installers_system_groups_from_scripts()
-    for item in options_system:
-        display = f"📦 {item['appName']:<20}   --   {item['doc']:<60}"
-        category_display_to_name[display] = item['appName']
     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 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
+    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 = []
-    for x in installers:
-        installer_options.append(Installer(installer_data=x).get_description())
-
-    category_display_to_name = get_static_groups_combined_with_dynamic_groups_extracted()
-    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)
+    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: str):
-    from machineconfig.utils.installer import get_installers, install_bulk
+    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
-    options_system = dynamically_extract_installers_system_groups_from_scripts()
-    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:
-            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)
-            program = an_item["fileNamePattern"][get_normalized_arch()][get_os_name()]
-            if program is not None:
-                run_shell_script(program)
-                break
-    else:
-        console.print(f"❌ [red]Group '{package_group}' not found.[/red]", style="bold")
-        _handle_installer_not_found(package_group, all_names=list(PACKAGE_GROUP2NAMES.keys()) + [item['appName'] for item in options_system])
-
+    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()
 
-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(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
+        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)
@@ -196,20 +157,19 @@ def install_clis(clis_names: list[str]):
         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_abc import check_tool_exists
+    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 import main
+    from machineconfig.utils.installer_utils.installer_cli import main
     main(which=which, interactive=False)
 
 

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

@@ -191,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