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

machineconfig/scripts/python/fire_agents_help_launch.py

@@ -2,14 +2,7 @@
 import random
 import shlex
 from pathlib import Path
-from typing import Literal, TypeAlias
-
-
-AGENTS: TypeAlias = Literal[
-    "cursor-agent", "gemini", "crush", "q"
-    # warp terminal
-]
-AGENT_NAME_FORMATTER = "agent_{idx}_cmd.sh"  # e.g., agent_0_cmd.sh
+from machineconfig.scripts.python.fire_agents_helper_types import AGENTS, AGENT_NAME_FORMATTER
 
 
 def get_gemini_api_keys() -> list[str]:

machineconfig/scripts/python/fire_agents_helper_types.py

@@ -0,0 +1,12 @@
+
+from typing import Literal, TypeAlias
+
+
+AGENTS: TypeAlias = Literal[
+    "cursor-agent", "gemini", "crush", "q"
+    # warp terminal
+]
+AGENT_NAME_FORMATTER = "agent_{idx}_cmd.sh"  # e.g., agent_0_cmd.sh
+
+SEARCH_STRATEGIES: TypeAlias = Literal["file_path", "keyword_search", "filename_pattern"]
+

machineconfig/scripts/python/fire_jobs.py

@@ -26,10 +26,6 @@ import typer
 
 
 def route(args: FireJobArgs, fire_args: str = "") -> None:
-    if args.layout:
-        from machineconfig.scripts.python.fire_jobs_layout_helper import handle_layout_args
-        return handle_layout_args(args.path, args.function)
-
     path_obj = sanitize_path(args.path)
     if not path_obj.exists():
         suffixes = {".py", ".sh", ".ps1"}
@@ -348,7 +344,6 @@ def main(
     Nprocess: Annotated[int, typer.Option("--Nprocess", "-p", help="Number of processes to use")] = 1,
     zellij_tab: Annotated[Optional[str], typer.Option("--zellij_tab", "-z", help="Open in a new zellij tab")] = None,
     watch: Annotated[bool, typer.Option("--watch", "-w", help="Watch the file for changes")] = False,
-    layout: Annotated[bool, typer.Option("--layout", "-L", help="Use layout configuration (Zellij Or WindowsTerminal)")] = False,
 ) -> None:
     """Main function to process fire jobs arguments."""
     
@@ -377,7 +372,6 @@ def main(
         Nprocess=Nprocess,
         zellij_tab=zellij_tab,
         watch=watch,
-        layout=layout,
     )
     try:
         route(args, fire_args)

machineconfig/scripts/python/fire_jobs_args_helper.py

@@ -27,7 +27,6 @@ class FireJobArgs:
     Nprocess: int = 1
     zellij_tab: Optional[str] = None
     watch: bool = False
-    layout: bool = False
 
 
 def extract_kwargs(args: FireJobArgs) -> dict[str, object]:

machineconfig/scripts/python/fire_jobs_layout_helper.py

@@ -1,30 +1,45 @@
+
 from pathlib import Path
-from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig, LayoutsFile
-from typing import Optional
-from machineconfig.scripts.python.helpers.helpers4 import search_for_files_of_interest
-from machineconfig.utils.options import choose_from_options
-from machineconfig.utils.path_helper import match_file_name, sanitize_path
-from machineconfig.utils.path_extended import PathExtended as PathExtended
+from typing import Optional, Literal
+import typer
+
+
+def load_balance(layout_path: Path = typer.Argument(..., help="Path to the layout.json file"),
+           max_thresh: int = typer.Option(..., help="Maximum tabs per layout"),
+           thresh_type: Literal['number', 'weight'] = typer.Option(..., help="Threshold type"),
+           breaking_method: Literal['moreLayouts', 'combineTabs'] = typer.Option(..., help="Breaking method"),
+           output_path: Optional[Path] = typer.Option(None, help="Path to write the adjusted layout.json file")):
+    """Adjust layout file to limit max tabs per layout, etc."""
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
+    import json
+    layoutfile: LayoutsFile = json.loads(layout_path.read_text())
+    layout_configs = layoutfile["layouts"]
+    from machineconfig.cluster.sessions_managers.utils.load_balancer import limit_tab_num
+    new_layouts = limit_tab_num(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=thresh_type, breaking_method=breaking_method)
+    layoutfile["layouts"] = new_layouts
+    target_file = output_path if output_path is not None else layout_path.parent / f'{layout_path.stem}_adjusted_{max_thresh}_{thresh_type}_{breaking_method}.json'
+    target_file.parent.mkdir(parents=True, exist_ok=True)
+    target_file.write_text(data=json.dumps(layoutfile, indent=4), encoding="utf-8")
+    typer.echo(f"Adjusted layout saved to {target_file}")
 
 
-def select_layout(layouts_json_file: Path, layouts_name: Optional[list[str]]) -> list[LayoutConfig]:
+def select_layout(layouts_json_file: Path, selected_layouts_names: Optional[list[str]], select_interactively: bool) -> list["LayoutConfig"]:
     import json
+    from machineconfig.utils.options import choose_from_options
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig, LayoutsFile
     layout_file: LayoutsFile = json.loads(layouts_json_file.read_text(encoding="utf-8"))
     if len(layout_file["layouts"]) == 0:
         raise ValueError(f"No layouts found in {layouts_json_file}")
-    if layouts_name is None:
+    if selected_layouts_names is None:  # choose all, or interactively
+        if not select_interactively:
+            return layout_file["layouts"]
         options = [layout["layoutName"] for layout in layout_file["layouts"]]
         from machineconfig.utils.options import choose_from_options
-        layouts_name = choose_from_options(multi=True, options=options, prompt="Choose a layout configuration:", fzf=True, msg="Choose one option")
-    print(f"Selected layout(s): {layouts_name}")
-    # layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"] == layouts_name), None)
-    # if layout_chosen is None:
-        # layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"].lower() == layouts_name.lower()), None)
-    # if layout_chosen is None:
-        # available_layouts = [layout["layoutName"] for layout in layout_file["layouts"]]
-        # raise ValueError(f"Layout '{layouts_name}' not found. Available layouts: {available_layouts}")
+        selected_layouts_names = choose_from_options(multi=True, options=options, prompt="Choose a layout configuration:", fzf=True, msg="Choose one option")
+    print(f"Selected layout(s): {selected_layouts_names}")
+    # Extract the configs from the names:
     layouts_chosen: list[LayoutConfig] = []
-    for name in layouts_name:
+    for name in selected_layouts_names:
         layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"] == name), None)
         if layout_chosen is None:
             layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"].lower() == name.lower()), None)
@@ -35,23 +50,11 @@ def select_layout(layouts_json_file: Path, layouts_name: Optional[list[str]]) ->
     return layouts_chosen
 
 
-def launch_layout(layout_config: LayoutConfig) -> Optional[Exception]:
-    import platform
-    if platform.system() == "Linux" or platform.system() == "Darwin":
-        print("🧑‍💻 Launching layout using Zellij terminal multiplexer...")
-        from machineconfig.cluster.sessions_managers.zellij_local import run_zellij_layout
-        run_zellij_layout(layout_config=layout_config)
-    elif platform.system() == "Windows":
-        print("🧑‍💻 Launching layout using Windows Terminal...")
-        from machineconfig.cluster.sessions_managers.wt_local import run_wt_layout
-
-        run_wt_layout(layout_config=layout_config)
-    else:
-        print(f"❌ Unsupported platform: {platform.system()}")
-    return None
-
-
-def handle_layout_args(layout_path: str, layouts: Optional[str]) -> None:
+def handle_layout_args(layout_path: str, select_layouts: Optional[str], select_interactively: bool) -> list["LayoutConfig"]:
+    from machineconfig.utils.path_extended import PathExtended
+    from machineconfig.scripts.python.helpers.helpers4 import search_for_files_of_interest
+    from machineconfig.utils.options import choose_from_options
+    from machineconfig.utils.path_helper import match_file_name, sanitize_path
     path_obj = sanitize_path(layout_path)
     if not path_obj.exists():
         choice_file = match_file_name(sub_string=layout_path, search_root=PathExtended.cwd(), suffixes={".json"})
@@ -63,5 +66,66 @@ def handle_layout_args(layout_path: str, layouts: Optional[str]) -> None:
         choice_file = PathExtended(choice_file)
     else:
         choice_file = path_obj
-    for a_layout_config in select_layout(layouts_json_file=choice_file, layouts_name=layouts.split(",") if layouts else None):
-        launch_layout(layout_config=a_layout_config)
+    selected_layouts = select_layout(layouts_json_file=choice_file, selected_layouts_names=select_layouts.split(",") if select_layouts else None, select_interactively=select_interactively)
+    return selected_layouts
+
+
+def launch(layout_path: str = typer.Argument(..., help="Path to the layout.json file"),
+        max_tabs: int = typer.Option(10, help="A Sanity checker that throws an error if any layout exceeds the maximum number of tabs to launch."),
+        max_layouts: int = typer.Option(10, help="A Sanity checker that throws an error if the total number of layouts exceeds this number."),
+        sleep_inbetween: float = typer.Option(1.0, help="Sleep time in seconds between launching layouts"),
+        monitor: bool = typer.Option(False, help="Monitor the layout sessions for completion"),
+        parallel: bool = typer.Option(False, help="Launch multiple layouts in parallel"),
+        kill_upon_completion: bool = typer.Option(False, help="Kill session(s) upon completion (only relevant if monitor flag is set)"),
+        select: Optional[str] = typer.Option(None, help="Comma separated names of layouts to be selected from the layout file passed"),
+        select_interactively: bool = typer.Option(False, help="Select layouts interactively")
+        ):
+    """
+    """
+    layouts_selected = handle_layout_args(layout_path=layout_path, select_layouts=select, select_interactively=select_interactively)
+
+    # ============= Basic sanity checks =============
+    if len(layouts_selected) > max_layouts:
+        raise ValueError(f"Number of layouts {len(layouts_selected)} exceeds the maximum allowed {max_layouts}. Please adjust your layout file.")
+    for a_layout in layouts_selected:
+        if len(a_layout["layoutTabs"]) > max_tabs:
+            typer.echo(f"Layout '{a_layout.get('layoutName', 'Unnamed')}' has {len(a_layout['layoutTabs'])} tabs which exceeds the max of {max_tabs}.")
+            confirm = typer.confirm("Do you want to proceed with launching this layout?", default=False)
+            if not confirm:
+                typer.echo("Aborting launch.")
+                raise typer.Exit(0)
+
+    import time
+    import platform
+    if platform.system() == "Linux" or platform.system() == "Darwin":
+        from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
+        if not parallel: iterable = [[item] for item in layouts_selected]
+        else: iterable = [layouts_selected]
+        for i, a_layouts in enumerate(iterable):
+            manager = ZellijLocalManager(session_layouts=a_layouts)
+            manager.start_all_sessions(poll_interval=2, poll_seconds=2)
+            if monitor:
+                manager.run_monitoring_routine(wait_ms=2000)
+                if kill_upon_completion:
+                    manager.kill_all_sessions()
+            if i < len(layouts_selected) - 1:  # Don't sleep after the last layout
+                time.sleep(sleep_inbetween)
+    elif platform.system() == "Windows":
+        from machineconfig.cluster.sessions_managers.wt_local_manager import WTLocalManager
+        if not parallel: iterable = [[item] for item in layouts_selected]
+        else: iterable = [layouts_selected]
+        for i, a_layouts in enumerate(iterable):
+            manager = WTLocalManager(session_layouts=a_layouts)
+            manager.start_all_sessions()
+            if monitor:
+                manager.run_monitoring_routine(wait_ms=2000)
+                if kill_upon_completion:
+                    manager.kill_all_sessions()
+            if i < len(layouts_selected) - 1:  # Don't sleep after the last layout
+                time.sleep(sleep_inbetween)
+    else:
+        print(f"❌ Unsupported platform: {platform.system()}")
+
+
+if __name__ == "__main__":
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig

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/scripts/python/repos.py

@@ -5,12 +5,6 @@ in the event that username@github.com is not mentioned in the remote url.
 
 """
 
-from machineconfig.utils.io import read_ini
-from machineconfig.utils.source_of_truth import CONFIG_PATH, DEFAULTS_PATH
-from machineconfig.utils.path_extended import PathExtended as PathExtended
-from machineconfig.scripts.python.repos_helper_record import main as record_repos
-from machineconfig.scripts.python.repos_helper_clone import clone_repos
-from machineconfig.scripts.python.repos_helper_action import perform_git_operations
 
 import typer
 from typing import Annotated, Optional
@@ -34,6 +28,13 @@ def main(
     print("📂 Welcome to the Repository Manager")
     print("=" * 50 + "\n")
 
+    from machineconfig.utils.io import read_ini
+    from machineconfig.utils.source_of_truth import CONFIG_PATH, DEFAULTS_PATH
+    from machineconfig.utils.path_extended import PathExtended as PathExtended
+    from machineconfig.scripts.python.repos_helper_record import main as record_repos
+    from machineconfig.scripts.python.repos_helper_clone import clone_repos
+    from machineconfig.scripts.python.repos_helper_action import perform_git_operations
+
     if directory == "":
         repos_root = PathExtended.home().joinpath("code")  # it is a positional argument, can never be empty.
     else:

machineconfig/scripts/python/share_terminal.py

@@ -3,10 +3,7 @@
 from pathlib import Path
 from typing import Optional, Annotated
 import typer
-from rich.console import Console
-from rich.panel import Panel
-from rich.text import Text
-from rich.align import Align
+
 
 
 """
@@ -21,6 +18,11 @@ reference:
 
 def display_terminal_url(local_ip_v4: str, port: int, protocol: str = "http") -> None:
     """Display a flashy, unmissable terminal URL announcement."""
+
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.text import Text
+    from rich.align import Align
     console = Console()
     
     # Create the main message with styling

machineconfig/setup_linux/web_shortcuts/interactive.sh

@@ -6,4 +6,4 @@ echo """
 ======================================================================="""
 
 curl https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_linux/ve.sh | bash
-$HOME/.local/bin/uv run --python 3.13 --with machineconfig devops ia
+$HOME/.local/bin/uv run --python 3.13 --with machineconfig devops interactive

machineconfig/setup_windows/web_shortcuts/interactive.ps1

@@ -9,4 +9,4 @@ Invoke-WebRequest -Uri "https://raw.githubusercontent.com/thisismygitrepo/machin
 .\ve.ps1
 rm ve.ps1
 
-uv run --python 3.13 --with machineconfig devops ia
+uv run --python 3.13 --with machineconfig devops interactive

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

machineconfig/utils/procs.py

@@ -58,10 +58,8 @@ class ProcessManager:
         title = "📊  INITIALIZING PROCESS MANAGER"
         console.print(Panel(title, title="[bold blue]Process Info[/bold blue]", border_style="blue"))
         process_info = []
-
         with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}")) as progress:
             progress.add_task("🔍 Reading system processes...", total=None)
-
             for proc in psutil.process_iter():
                 try:
                     mem_usage_mb = proc.memory_info().rss / (1024 * 1024)
@@ -162,7 +160,6 @@ class ProcessManager:
         console.print(Panel("", title="[bold blue]Process Info[/bold blue]", border_style="blue"))
 
     def kill(self, names: Optional[list[str]] = None, pids: Optional[list[int]] = None, commands: Optional[list[str]] = None):
-        # header for process termination
         title = "💀  PROCESS TERMINATION"
         console.print(Panel(title, title="[bold blue]Process Info[/bold blue]", border_style="blue"))
         if names is None and pids is None and commands is None:
@@ -241,7 +238,6 @@ def get_age(create_time: Any) -> str:
 
 def main():
     from machineconfig.utils.procs import ProcessManager
-
     ProcessManager().choose_and_kill()
 
 

machineconfig/utils/schemas/installer/installer_types.py

@@ -2,7 +2,6 @@ from typing import TypedDict, Literal, TypeAlias, Optional
 import platform
 
 
-APP_INSTALLER_CATEGORY: TypeAlias = Literal["GITHUB_ESSENTIAL", "CUSTOM_ESSENTIAL", "GITHUB_DEV", "CUSTOM_DEV"]
 CPU_ARCHITECTURES: TypeAlias = Literal["amd64", "arm64"]
 OPERATING_SYSTEMS: TypeAlias = Literal["windows", "linux", "macos"]