machineconfig 4.8__py3-none-any.whl → 4.9__py3-none-any.whl

machineconfig/jobs/installer/package_groups.py

@@ -0,0 +1,154 @@
+from typing import Literal, TypeAlias, Union
+
+PACKAGES_NAMES_DEV = Literal[
+    "ngrok",
+    "Visual Studio Code",
+    "aider",
+    "github-copilot-cli",
+    "gemini",
+    "crush",
+    "opencode-ai",
+    "warp",
+    "q",
+    "cursor-cli",
+    "droid",
+    "Alacritty",
+    "Brave",
+    "bypass-paywalls-chrome",
+    "Cursor",
+    "espanso",
+    "Gorilla",
+    "lvim",
+    "nerdfont",
+    "Redis",
+    "Wezterm",
+    "winget",
+    "ytui-music",
+    "youtube-tui",
+    "termusic",
+    "kronos",
+    "transmission",
+    "nnn",
+    "exa",
+    "bytehound",
+    "atuin",
+    "browsh",
+    "carbonyl",
+    "patat",
+    "SqliteBrowser",
+    "DBeaver",
+    "rainfrog",
+    "duckdb",
+    "cpz",
+    "rmz",
+    "mermaid-cli",
+    "html2markdown",
+    "xcrawl3r",
+    "obsidian",
+    "marp",
+    "presenterm",
+    "pandoc",
+    "devcontainer",
+    "bitwarden",
+    "OBS Background removal",
+    "rustdesk",
+    "evcxr",
+    "forward-cli",
+    "bandwhich",
+    "ipinfo",
+    "dust",
+    "ots",
+    "ffsend",
+    "portal",
+    "qrcp",
+    "qrscan",
+    "termscp",
+    "qr",
+    "filebrowser",
+    "cloudreve",
+    "restic",
+    "syncthing",
+    "istio",
+    "openpomodoro-cli",
+    "rust-analyzer",
+    "kondo",
+    "tokei",
+    "lazygit",
+    "lazydocker",
+    "onefetch",
+    "gitcs",
+    "just",
+    "navi",
+    "tealdeer",
+    "sniffnet",
+    "hyperfine",
+    "ollama",
+    "cointop",
+    "vtm",
+    "edex-ui",
+    "extraterm",
+    "nushell",
+    "geckodriver",
+    "lolcatjs",
+    "figlet-cli",
+    "sharewifi",
+    "share-wifi",
+]
+
+PACKAGES_NAMES_ESSENTIAL = Literal[
+    "gh",
+    "hx",
+    "speedtest",
+    "pistol",
+    "diskonaut",
+    "xplr",
+    "btop",
+    "gotty",
+    "joshuto",
+    "zellij",
+    "boxes",
+    "ugrep",
+    "zoomit",
+    "ntop",
+    "devtunnel",
+    "bat",
+    "broot",
+    "btm",
+    "chatgpt",
+    "cloudflared",
+    "cpufetch",
+    "delta",
+    "dua",
+    "fastfetch",
+    "fd",
+    "fzf",
+    "gitui",
+    "glow",
+    "gum",
+    "lf",
+    "lsd",
+    "m365",
+    "mcfly",
+    "mods",
+    "mprocs",
+    "ouch",
+    "procs",
+    "rclone",
+    "rg",
+    "rga",
+    "starship",
+    "tere",
+    "topgrade",
+    "ttyd",
+    "viu",
+    "watchexec",
+    "yazi",
+    "zoxide",
+]
+
+PACKAGE_GROUPS: TypeAlias = Literal["ESSENTIAL", "DEV"]
+PACKAGE_GROUP2NAMES: dict[PACKAGE_GROUPS, list[str]] = {
+    "ESSENTIAL": list(PACKAGES_NAMES_ESSENTIAL.__args__),
+    "DEV": list(PACKAGES_NAMES_DEV.__args__),
+}
+_ = Union

machineconfig/scripts/python/devops_devapps_install.py

@@ -2,10 +2,15 @@
 
 import typer
 from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
 from platform import system
 from typing import Optional, Literal, TypeAlias, cast, get_args, Annotated
 
-WHICH_CAT: TypeAlias = Literal["essentials", "essentialsDev", "systymPackages", "precheckedPackages", "ia"]
+console = Console()
+
+WHICH_CAT: TypeAlias = Literal["essentials", "essentialsDev", "systemPackages", "precheckedPackages", "ia"]
 
 
 def _handle_installer_not_found(search_term: str, all_installers: list["InstallerData"]) -> None:  # type: ignore
@@ -21,27 +26,37 @@ def _handle_installer_not_found(search_term: str, all_installers: list["Installe
     # Find close matches using fuzzy matching
     close_matches = get_close_matches(search_term, all_names, n=5, cutoff=0.4)
     
-    print(f"\n❌ '{search_term}' was not found.")
+    console.print(f"\n❌ '[red]{search_term}[/red]' was not found.", style="bold")
     
     if close_matches:
-        print("🤔 Did you mean one of these?")
+        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):
-            print(f"   {i}. {match}")
+            table.add_row(f"[cyan]{i}.[/cyan]", f"[green]{match}[/green]")
+        console.print(table)
     else:
-        print("📋 Here are some available options:")
+        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):
-            print(f"   {i}. {name}")
+            table.add_row(f"[cyan]{i}.[/cyan]", f"[green]{name}[/green]")
+        console.print(table)
         
         if len(all_installers) > 10:
-            print(f"   ... and {len(all_installers) - 10} more")
+            console.print(f"   [dim]... and {len(all_installers) - 10} more[/dim]")
     
-    print("\n💡 Use 'ia' to interactively browse all available installers.")
-    print(f"💡 Use one of the categories: {list(get_args(WHICH_CAT))}")
+    panel = Panel(
+        "[bold blue]💡 Use 'ia' to interactively browse all available installers.[/bold blue]\n"
+        f"[bold blue]💡 Use one of the categories: {list(get_args(WHICH_CAT))}[/bold blue]",
+        title="[yellow]Helpful Tips[/yellow]",
+        border_style="yellow"
+    )
+    console.print(panel)
 
 
 def main_with_parser():
@@ -60,7 +75,7 @@ def main(which: Annotated[Optional[str], typer.Argument(help=f"Choose a category
     if which != "ia" and which is not None:  # install by name
         total_messages: list[str] = []
         for a_which in which.split(",") if type(which) == str else which:
-            all_installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["GITHUB_ESSENTIAL", "CUSTOM_ESSENTIAL", "GITHUB_DEV", "CUSTOM_DEV"])
+            all_installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["ESSENTIAL", "DEV"])
 
             # Find installer by exe_name or name
             selected_installer = None
@@ -76,8 +91,11 @@ def main(which: Annotated[Optional[str], typer.Argument(help=f"Choose a category
                 return None
             message = Installer(selected_installer).install_robust(version=None)  # finish the task
             total_messages.append(message)
-        for a_message in total_messages:
-            print(a_message)
+        
+        if total_messages:
+            console.print("\n[bold green]📊 Installation Results:[/bold green]")
+            for a_message in total_messages:
+                console.print(f"[blue]• {a_message}[/blue]")
         return None
 
 
@@ -87,7 +105,7 @@ def install_interactively():
     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=["GITHUB_ESSENTIAL", "CUSTOM_ESSENTIAL", "GITHUB_DEV", "CUSTOM_DEV"])
+    installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["ESSENTIAL", "DEV"])
     with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}")) as progress:
         task = progress.add_task("✅ Checking installed programs...", total=len(installers))
         installer_options = []
@@ -110,17 +128,24 @@ def install_interactively():
             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)
-    print("\n📊 INSTALLATION SUMMARY:")
-    print("=" * 50)
-    for message in installation_messages:
-        print(message)
+    if installation_messages:
+        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 get_programs_by_category(program_name: WHICH_CAT):
-    print(f"""
-┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┃ 📦 Installing Category: {program_name}
-┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
+    panel = Panel(
+        f"[bold yellow]Installing programs from category: [green]{program_name}[/green][/bold yellow]",
+        title="[bold blue]📦 Category Installation[/bold blue]",
+        border_style="blue",
+        padding=(1, 2)
+    )
+    console.print(panel)
     from machineconfig.utils.source_of_truth import LIBRARY_ROOT
     from machineconfig.utils.installer import get_installers, install_all
     from machineconfig.utils.installer_utils.installer_abc import parse_apps_installer_linux, parse_apps_installer_windows
@@ -128,31 +153,59 @@ def get_programs_by_category(program_name: WHICH_CAT):
     from machineconfig.utils.options import choose_from_options
     match program_name:
         case "essentials":
-            installers_ = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["GITHUB_ESSENTIAL", "CUSTOM_ESSENTIAL"])
+            installers_ = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["ESSENTIAL"])
             install_all(installers_data=installers_)
         case "essentialsDev":
-            installers_ = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["GITHUB_DEV", "CUSTOM_DEV", "GITHUB_ESSENTIAL", "CUSTOM_ESSENTIAL"])
+            installers_ = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["DEV", "ESSENTIAL"])
             install_all(installers_data=installers_)
-        case "systymPackages":
+        case "systemPackages":
             if system() == "Windows":
                 options_system = parse_apps_installer_windows(LIBRARY_ROOT.joinpath("setup_windows/apps.ps1").read_text(encoding="utf-8"))
             elif system() == "Linux":
-                options_system_1 = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps_dev.sh").read_text(encoding="utf-8"))
-                options_system_2 = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps.sh").read_text(encoding="utf-8"))
-                options_system = {**options_system_1, **options_system_2}
+                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")
-            program_names = choose_from_options(multi=True, msg="", options=sorted(list(options_system.keys())), header="🚀 CHOOSE DEV APP", fzf=True)
+            
+            # Create display options that include descriptions for user selection
+            display_options = []
+            for group_name, (description, _) in options_system.items():
+                if description:
+                    display_options.append(f"{group_name:<20} - {description}")
+                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 name in program_names:
-                print(f"""
-┌────────────────────────────────────────────────────
-│ ⚙️  Installing: {name}
-└────────────────────────────────────────────────────""")
-                sub_program = options_system[name]
+            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
+            from pathlib import Path
+            if system() == "Windows":
+                temp_script_path = Path("C:/Windows/Temp/temp_install_script.ps1")
+                lexer = "powershell"
+            else:
+                temp_script_path = Path("/tmp/temp_install_script.sh")
+                lexer = "bash"
+            temp_script_path.write_text(program, encoding="utf-8")
+            console.print(f"📝 [blue]Temporary script written to:[/blue] [green]{temp_script_path}[/green]")
+            from rich.syntax import Syntax
+            console.print(Panel(Syntax(code=program, lexer=lexer), title="📄 Installation Program", subtitle="shell code"), style="bold red")
+            console.print("🚀 [bold yellow]Starting installation...[/bold yellow]")
+            if system() == "Windows":
+                import subprocess
+                subprocess.run(["powershell", "-ExecutionPolicy", "Bypass", "-File", str(temp_script_path)], check=True)
+            elif system() == "Linux":
+                import subprocess
+                subprocess.run(["bash", str(temp_script_path)], check=True)
+            console.print("✅ [bold green]Installation completed.[/bold green]")
+            temp_script_path.unlink(missing_ok=True)
         case "ia":
             install_interactively()
         case "precheckedPackages":

machineconfig/scripts/python/interactive.py

@@ -81,24 +81,7 @@ def install_windows_desktop_apps() -> bool:
     """Install Windows desktop applications using winget."""
     if system() != "Windows":
         console.print("❌ This function is only available on Windows systems.", style="bold red")
-        return False
-    
-    console.print(Panel("💻 [bold cyan]WINDOWS DESKTOP APPS[/bold cyan]\n[italic]Installing Brave, Windows Terminal, PowerShell, and VSCode[/italic]", border_style="cyan"))
-    
-    # Install winget applications
-    winget_commands = [
-        ('winget install --no-upgrade --name "Windows Terminal" --Id "Microsoft.WindowsTerminal" --source winget --scope user --accept-package-agreements --accept-source-agreements', "Installing Windows Terminal"),
-        ('winget install --no-upgrade --name "Powershell" --Id "Microsoft.PowerShell" --source winget --scope user --accept-package-agreements --accept-source-agreements', "Installing PowerShell"),
-        ('winget install --no-upgrade --name "Brave" --Id "Brave.Brave" --source winget --scope user --accept-package-agreements --accept-source-agreements', "Installing Brave Browser"),
-        ('winget install --no-upgrade --name "Microsoft Visual Studio Code" --Id "Microsoft.VisualStudioCode" --source winget --scope user --accept-package-agreements --accept-source-agreements', "Installing Visual Studio Code"),
-    ]
-    
-    success = True
-    for command, description in winget_commands:
-        if not run_command(command, description):
-            success = False
-    
-    # Install Nerd Fonts via Python
+        return False   
     console.print("🔧 Installing Nerd Fonts", style="bold cyan")
     try:
         from machineconfig.jobs.installer.custom_dev.nerfont_windows_helper import install_nerd_fonts
@@ -106,19 +89,14 @@ def install_windows_desktop_apps() -> bool:
         console.print("✅ Nerd Fonts installed successfully", style="bold green")
     except Exception as e:
         console.print(f"❌ Error installing Nerd Fonts: {e}", style="bold red")
-        success = False
-    
-    # Set Windows Terminal settings via Python
     console.print("🔧 Setting Windows Terminal settings", style="bold cyan")
     try:
         from machineconfig.setup_windows.wt_and_pwsh.set_wt_settings import main as set_wt_settings_main
         set_wt_settings_main()
         console.print("✅ Windows Terminal settings configured successfully", style="bold green")
     except Exception as e:
-        console.print(f"❌ Error setting Windows Terminal settings: {e}", style="bold red")
-        success = False
-    
-    return success
+        console.print(f"❌ Error setting Windows Terminal settings: {e}", style="bold red")    
+    return True
 
 
 def get_installation_choices() -> list[str]:
@@ -162,9 +140,13 @@ def execute_installations(selected_options: list[str]) -> None:
             run_command(f"bash {script}", "Installing Linux base system applications")
 
     if "upgrade_system" in selected_options:
-        console.print(Panel("🔄 [bold magenta]SYSTEM UPDATE[/bold magenta]\n[italic]Package management[/italic]", border_style="magenta"))
-        run_command("sudo nala upgrade -y", "Upgrading system packages")
-
+        if system() == "Windows":
+            console.print("❌ System upgrade is not applicable on Windows via this script.", style="bold red")
+        elif system() == "Linux":
+            console.print(Panel("🔄 [bold magenta]SYSTEM UPDATE[/bold magenta]\n[italic]Package management[/italic]", border_style="magenta"))
+            run_command("sudo nala upgrade -y", "Upgrading system packages")
+        else:
+            console.print(f"❌ System upgrade not supported on {system()}.", style="bold red")
     if "install_uv_repos" in selected_options:
         console.print(Panel("🐍 [bold green]PYTHON ENVIRONMENT[/bold green]\n[italic]Virtual environment setup[/italic]", border_style="green"))
         from machineconfig import setup_linux as module
@@ -212,9 +194,6 @@ Set-Service -Name sshd -StartupType 'Automatic'"""
 
     if "install_dev_tools" in selected_options:
         console.print(Panel("🛠️  [bold bright_blue]DEVELOPMENT TOOLS[/bold bright_blue]\n[italic]Software development packages[/italic]", border_style="bright_blue"))
-        run_command("(curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh) || true", "Installing Rust toolchain")
-        run_command("sudo nala install libssl-dev -y", "Installing libssl-dev")
-        run_command("sudo nala install ffmpeg -y", "Installing ffmpeg")
         console.print("🔧 Installing development applications", style="bold cyan")
         try:
             from machineconfig.scripts.python.devops_devapps_install import main as devops_devapps_install_main

machineconfig/utils/installer.py

@@ -2,7 +2,8 @@
 
 from machineconfig.utils.installer_utils.installer_abc import check_if_installed_already
 from machineconfig.utils.installer_utils.installer_class import Installer
-from machineconfig.utils.schemas.installer.installer_types import APP_INSTALLER_CATEGORY, InstallerData, InstallerDataFiles, get_normalized_arch, get_os_name, OPERATING_SYSTEMS, CPU_ARCHITECTURES
+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
 
@@ -18,7 +19,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=["GITHUB_ESSENTIAL", "CUSTOM_ESSENTIAL"])
+    installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["ESSENTIAL"])
     installers_github = []
     for inst__ in installers:
         app_name = inst__["appName"]
@@ -91,30 +92,30 @@ def get_installed_cli_apps():
     return apps
 
 
-def get_installers(os: OPERATING_SYSTEMS, arch: CPU_ARCHITECTURES, which_cats: list[APP_INSTALLER_CATEGORY]) -> list[InstallerData]:
+def get_installers(os: OPERATING_SYSTEMS, arch: CPU_ARCHITECTURES, which_cats: list[PACKAGE_GROUPS]) -> list[InstallerData]:
     print(f"\n{'=' * 80}\n🔍 LOADING INSTALLER CONFIGURATIONS 🔍\n{'=' * 80}")
-    res_all = get_all_installer_data_files(which_cats=which_cats)
+    res_all = get_all_installer_data_files()
+    acceptable_apps_names: list[str] = []
+    for cat in which_cats:
+        acceptable_apps_names += PACKAGE_GROUP2NAMES[cat]
     all_installers: list[InstallerData] = []
-    for _category, installer_data_files in res_all.items():
-        suitable_installers = []
-        for an_installer in installer_data_files["installers"]:
-            if an_installer["fileNamePattern"][arch][os] is None:
+    for installer_data in res_all:
+        if installer_data["appName"] in acceptable_apps_names:
+            if installer_data["fileNamePattern"][arch][os] is None:
                 continue
-            suitable_installers.append(an_installer)
-        all_installers.extend(suitable_installers)
+            all_installers.append(installer_data)
     print(f"✅ Loaded {len(all_installers)} installer configurations\n{'=' * 80}")
     return all_installers
 
 
-def get_all_installer_data_files(which_cats: list[APP_INSTALLER_CATEGORY]) -> dict[APP_INSTALLER_CATEGORY, InstallerDataFiles]:
+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_final: dict[APP_INSTALLER_CATEGORY, InstallerDataFiles] = {key: read_json(Path(module.__file__).parent.joinpath(f"packages_{key.lower()}.json")) for key in which_cats}
+    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")
-    for k, v in res_final.items():
-        print(f" - {k}: {len(v['installers'])} items")
     return res_final
 
 

machineconfig/utils/installer_utils/github_release_bulk.py

@@ -109,8 +109,7 @@ def main() -> None:
     current_dir = Path(__file__).parent
     installer_dir = current_dir.parent.parent / "jobs" / "installer"
     
-    standard_json = installer_dir / "packages_standard.json"
-    dev_json = installer_dir / "packages_dev.json"
+    standard_json = installer_dir / "installer_data.json"
     output_json = current_dir / "github_releases.json"
     
     print("🔍 Starting GitHub release data extraction...")
@@ -125,16 +124,7 @@ def main() -> None:
         all_github_repos.update(repos)
         print(f"   Found {len(repos)} GitHub repos")
     else:
-        print(f"⚠️  File not found: {standard_json}")
-        
-    if dev_json.exists():
-        print(f"📄 Reading {dev_json.name}...")
-        repos = extract_github_repos_from_json(dev_json)
-        all_github_repos.update(repos)
-        print(f"   Found {len(repos)} GitHub repos")
-    else:
-        print(f"⚠️  File not found: {dev_json}")
-    
+        print(f"⚠️  File not found: {standard_json}")    
     print(f"🎯 Total unique GitHub repositories found: {len(all_github_repos)}")
     
     if not all_github_repos:

machineconfig/utils/installer_utils/installer_abc.py

@@ -3,7 +3,7 @@ from machineconfig.utils.path_extended import PathExtended as PathExtended
 from machineconfig.utils.source_of_truth import WINDOWS_INSTALL_PATH, LINUX_INSTALL_PATH, INSTALL_VERSION_ROOT
 
 from pathlib import Path
-from typing import Any, Optional
+from typing import Optional
 import subprocess
 import platform
 
@@ -166,75 +166,71 @@ 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, Any]:
+def parse_apps_installer_linux(txt: str) -> dict[str, tuple[str, str]]:
     """Parse Linux shell installation scripts into logical chunks.
     
-    Supports two formats:
-    1. Legacy format with 'yes '' | sed 3q; echo "----------------------------- installing' delimiter
-    2. New format with # --BLOCK:<name>-- comment signatures
+    Splits scripts by # --GROUP:<name>:<description> comment signatures into a dictionary
+    mapping block names to (description, shell script content) tuples.
     
     Returns:
-        dict[str, str]: Dictionary mapping block/section names to their installation scripts
+        dict[str, tuple[str, str]]: Dictionary mapping block/section names to (description, installation_script) tuples
     """
-    # Try new block format first
-    if "# --BLOCK:" in txt:
-        import re
-        # Split by block signatures: # --BLOCK:<name>--
-        blocks = re.split(r'# --BLOCK:([^-]+)--', txt)
-        res: dict[str, str] = {}
+    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 = ""
         
-        # Process blocks in pairs (block_name, block_content)
-        for i in range(1, len(blocks), 2):
-            if i + 1 < len(blocks):
-                block_name = blocks[i].strip()
-                block_content = blocks[i + 1].strip()
-                if block_content:
-                    res[block_name] = block_content
+        # Rest is the content
+        content = '\n'.join(lines[1:]).strip()
         
-        return res
+        if group_name and content:
+            res[group_name] = (group_description, content)
     
-    # Legacy format fallback
-    txts = txt.split("""yes '' | sed 3q; echo "----------------------------- installing """)
-    res = {}
-    for chunk in txts[1:]:
-        try:
-            k = chunk.split("----")[0].rstrip().lstrip()
-            v = "\n".join(chunk.split("\n")[1:])
-            res[k] = v
-        except IndexError as e:
-            print(f"""
-❌ Error parsing chunk:
-{"-" * 50}
-{chunk}
-{"-" * 50}""")
-            raise e
     return res
 
 
-def parse_apps_installer_windows(txt: str) -> dict[str, Any]:
-    chunks: list[str] = []
-    for idx, item in enumerate(txt.split(sep="winget install")):
-        if idx == 0:
-            continue
-        if idx == 1:
-            chunks.append(item)
+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:
-            chunks.append("winget install" + item)
-    # progs = L(txt.splitlines()).filter(lambda x: x.startswith("winget ") or x.startswith("#winget"))
-    res: dict[str, str] = {}
-    for a_chunk in chunks:
-        try:
-            name = a_chunk.split("--name ")[1]
-            if "--Id" not in name:
-                print(f"⚠️  Warning: {name} does not have an Id, skipping")
-                continue
-            name = name.split(" --Id ", maxsplit=1)[0].strip('"').strip('"')
-            res[name] = a_chunk
-        except IndexError as e:
-            print(f"""
-❌ Error parsing chunk:
-{"-" * 50}
-{a_chunk}
-{"-" * 50}""")
-            raise e
+            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