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

machineconfig/utils/installer_utils/installer_cli.py

@@ -0,0 +1,175 @@
+"""Devops Devapps Install
+
+
+sudo apt update && sudo apt install -y \
+  git gcc g++ clang \
+  yasm nasm pkg-config \
+  meson ninja-build \
+  autoconf automake libtool \
+  libx11-dev libxext-dev libxrandr-dev libxrender-dev libxss-dev \
+  libvdpau-dev libgl1-mesa-dev libegl1-mesa-dev libxv-dev \
+  libasound2-dev libpulse-dev \
+  libfribidi-dev libfreetype-dev libfontconfig1-dev libharfbuzz-dev \
+  libjpeg-dev libssl-dev zlib1g-dev python3-pip
+
+
+"""
+
+from machineconfig.utils.installer_utils.installer_helper import get_group_name_to_repr
+import typer
+from typing import Annotated, Optional
+
+
+
+def main_installer_cli(
+    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 interactive:
+        return install_interactively()
+    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.")
+            from machineconfig.utils.installer_utils.installer_helper import get_group_name_to_repr
+            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_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", tv=True)
+    installation_messages: list[str] = []
+    for _an_idx, a_program_name in enumerate(program_names):
+        if a_program_name.startswith("📦 "):
+            category_name = category_display_to_name.get(a_program_name)
+            if 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_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
+    from machineconfig.jobs.installer.package_groups import PACKAGE_GROUP2NAMES
+    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 install_clis(clis_names: list[str]):
+    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
+    all_installers_data = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=None)
+    total_messages: list[str] = []
+    for a_cli_name in clis_names:
+        if "github.com" in a_cli_name.lower():
+            from machineconfig.utils.installer_utils.install_from_url import install_from_github_url
+            install_from_github_url(github_url=a_cli_name)
+            continue
+        elif a_cli_name.startswith("https://") or a_cli_name.startswith("http://"):
+            print(f"⏳ Installing from binary URL: {a_cli_name} ...")
+            from machineconfig.utils.installer_utils.install_from_url import install_from_binary_url
+            install_from_binary_url(binary_url=a_cli_name)
+            continue
+        selected_installer = None
+        for installer in all_installers_data:
+            app_name = installer["appName"]
+            if app_name.lower() == a_cli_name.lower():
+                selected_installer = installer
+                break
+        if selected_installer is None:
+            from machineconfig.utils.installer_utils.installer_helper import handle_installer_not_found
+            handle_installer_not_found(a_cli_name, all_installers_data)
+            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) -> bool:
+    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 True
+    print(f"⏳ {which} not found. Installing...")
+    from machineconfig.utils.installer_utils.installer_cli import main_installer_cli
+    try:
+        main_installer_cli(which=which, interactive=False)
+        return True
+    except Exception as e:
+        print(f"❌ Error installing {which}: {e}")
+    return False
+
+if __name__ == "__main__":
+    from machineconfig.utils.schemas.installer.installer_types import InstallerData
+    from machineconfig.utils.installer_utils.installer_class import Installer
+    _ = InstallerData, Installer
+    pass

machineconfig/utils/installer_utils/installer_helper.py

@@ -0,0 +1,129 @@
+from machineconfig.jobs.installer.package_groups import PACKAGE_GROUP2NAMES
+from machineconfig.utils.schemas.installer.installer_types import InstallerData
+from pathlib import Path
+from machineconfig.utils.path_extended import DECOMPRESS_SUPPORTED_FORMATS, PathExtended
+from machineconfig.utils.source_of_truth import INSTALL_TMP_DIR
+
+
+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
+    return category_display_to_name
+
+
+def handle_installer_not_found(search_term: str, app_apps: list[InstallerData]) -> 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
+    all_names = sorted([inst["appName"] for inst in app_apps])
+    name_to_doc = {inst["appName"]: inst["doc"] for inst in app_apps}
+    all_descriptions = {f"{inst['appName']}: {inst['doc']}": inst["appName"] for inst in app_apps}
+
+    close_name_matches = get_close_matches(search_term, all_names, n=5, cutoff=0.4)
+    close_description_matches = get_close_matches(search_term, list(all_descriptions.keys()), n=5, cutoff=0.4)
+
+    search_lower = search_term.lower()
+    substring_matches = [
+        inst["appName"]
+        for inst in app_apps
+        if search_lower in inst["appName"].lower() or search_lower in inst["doc"].lower()
+    ]
+
+    ordered_matches: list[str] = list(
+        dict.fromkeys(
+            close_name_matches
+            + [all_descriptions[desc] for desc in close_description_matches]
+            + substring_matches
+        )
+    )
+    top_matches = ordered_matches[:10]
+    console = Console()
+
+    console.print(f"\n❌ '[red]{search_term}[/red]' was not found.", style="bold")
+    if top_matches:
+        console.print("🤔 Did you mean one of these?", style="yellow")
+        table = Table(show_header=True, header_style="bold", box=None, pad_edge=False)
+        table.add_column("#", justify="right", width=3)
+        table.add_column("Installer", style="green")
+        table.add_column("Description", style="dim", overflow="fold")
+        for i, match in enumerate(top_matches, 1):
+            table.add_row(f"[cyan]{i}[/cyan]", match, name_to_doc.get(match, ""))
+        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=True, header_style="bold", box=None, pad_edge=False)
+        table.add_column("#", justify="right", width=3)
+        table.add_column("Installer", style="green")
+        table.add_column("Description", style="dim", overflow="fold")
+        for i, name in enumerate(sample_names, 1):
+            table.add_row(f"[cyan]{i}[/cyan]", name, name_to_doc.get(name, ""))
+        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_deb_package(downloaded: Path) -> None:
+    from rich import print as rprint
+    from rich.panel import Panel
+    print(f"📦 Installing .deb package: {downloaded}")
+    import platform
+    import subprocess
+    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:
+        from rich.console import Group
+        desc = "Installing .deb"
+        sub_panels = []
+        if result.stdout:
+            sub_panels.append(Panel(result.stdout, title="STDOUT", style="blue"))
+        if result.stderr:
+            sub_panels.append(Panel(result.stderr, title="STDERR", style="red"))
+        group_content = Group(f"❌ {desc} failed\nReturn code: {result.returncode}", *sub_panels)
+        rprint(Panel(group_content, title=desc, style="red"))
+    print("🗑️  Cleaning up .deb package...")
+    if downloaded.is_file():
+        downloaded.unlink(missing_ok=True)
+    elif downloaded.is_dir():
+        import shutil
+        shutil.rmtree(downloaded, ignore_errors=True)
+
+
+def download_and_prepare(download_url: str) -> PathExtended:
+    # archive_path = PathExtended(download_url).download(folder=INSTALL_TMP_DIR)
+    from machineconfig.scripts.python.helpers_utils.download import download
+    downloaded_object = download(download_url, output_dir=str(INSTALL_TMP_DIR))
+    if downloaded_object is None:
+        raise ValueError(f"Failed to download from URL: {download_url}")
+    archive_path = PathExtended(downloaded_object)
+    extracted_path = archive_path
+    if extracted_path.is_file() and any(ext in archive_path.suffixes for ext in DECOMPRESS_SUPPORTED_FORMATS):
+        extracted_path = archive_path.decompress()
+        # print(f"Decompressed {archive_path} to {extracted_path}")
+        archive_path.delete(sure=True)
+        if extracted_path.is_dir():
+            nested_items = list(extracted_path.glob("*"))
+            if len(nested_items) == 1:
+                nested_path = PathExtended(nested_items[0])
+                if nested_path.is_file() and any(ex in nested_path.suffixes for ex in DECOMPRESS_SUPPORTED_FORMATS):
+                    extracted_path = nested_path.decompress()
+                    nested_path.delete(sure=True)
+    elif extracted_path.is_dir() and len(extracted_path.search("*", r=True)) == 1:
+        only_file_in = next(extracted_path.glob("*"))
+        if only_file_in.is_file() and any(ext in str(only_file_in) for ext in DECOMPRESS_SUPPORTED_FORMATS):  # further decompress
+            extracted_path = only_file_in.decompress()
+            only_file_in.delete(sure=True)
+    return extracted_path

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
 
@@ -8,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(f"\n{'=' * 80}\n🔍 PROCESSING WINDOWS EXECUTABLE 🔍\n{'=' * 80}")
-    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:
@@ -53,8 +57,14 @@ 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):
-    print(f"\n{'=' * 80}\n🔍 PROCESSING LINUX EXECUTABLE 🔍\n{'=' * 80}")
+def find_move_delete_linux(downloaded: PathExtended, tool_name: Optional[str], delete: bool, rename_to: Optional[str]):
+    # if len(tool_name.split("+")) > 1:
+    #     last_result = None
+    #     for a_binary in [x.strip() for x in tool_name.split("+") if x.strip() != ""]:
+    #         last_result = find_move_delete_linux(downloaded=downloaded, tool_name=a_binary, delete=False, rename_to=rename_to)
+    #     return last_result
+
+    print("🔍 PROCESSING LINUX EXECUTABLE 🔍")
     if downloaded.is_file():
         exe = downloaded
         print(f"📄 Found direct executable file: {exe}")
@@ -65,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}'")
@@ -108,33 +126,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 +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