machineconfig 4.0__tar.gz → 4.1__tar.gz

{machineconfig-4.0/src/machineconfig.egg-info → machineconfig-4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: machineconfig
-Version: 4.0
+Version: 4.1
 Summary: Dotfiles management package
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0

{machineconfig-4.0 → machineconfig-4.1}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "machineconfig"
-version = "4.0"
+version = "4.01"
 description = "Dotfiles management package"
 readme = "README.md"
 license = {text = "Apache 2.0"}
@@ -52,22 +52,23 @@ docs = [
 
 [project.scripts]
 devops = "machineconfig.scripts.python.devops:app"
+fire = "machineconfig.scripts.python.fire_jobs:main_from_parser"
+fire_agents = "machineconfig.scripts.python.fire_agents:main"
+initai = "machineconfig.scripts.python.ai.initai:main"
+
 choose_wezterm_theme = "machineconfig.scripts.python.choose_wezterm_theme:main"
 cloud_copy = "machineconfig.scripts.python.cloud_copy:arg_parser"
 cloud_mount = "machineconfig.scripts.python.cloud_mount:arg_parser"
 cloud_repo_sync = "machineconfig.scripts.python.cloud_repo_sync:args_parser"
 cloud_sync = "machineconfig.scripts.python.cloud_sync:arg_parser"
-croshell = "machineconfig.scripts.python.croshell:arg_parser"
-fire = "machineconfig.scripts.python.fire_jobs:main_from_parser"
-fire_agents = "machineconfig.scripts.python.fire_agents:main"
 ftpx = "machineconfig.scripts.python.ftpx:main_from_parser"
-initai = "machineconfig.scripts.python.ai.initai:main"
-mount_nfs = "machineconfig.scripts.python.mount_nfs:main"
-mount_nw_drive = "machineconfig.scripts.python.mount_nw_drive:main"
 repos = "machineconfig.scripts.python.repos:main_from_parser"
 start_slidev = "machineconfig.scripts.python.start_slidev:arg_parser"
-wifi_conn = "machineconfig.scripts.python.wifi_conn:arg_parser"
 kill_process = "machineconfig.utils.procs:main"
+wifi_conn = "machineconfig.scripts.python.wifi_conn:arg_parser"
+mount_nfs = "machineconfig.scripts.python.mount_nfs:main"
+mount_nw_drive = "machineconfig.scripts.python.mount_nw_drive:main"
+croshell = "machineconfig.scripts.python.croshell:arg_parser"
 
 [tool.setuptools]
 package-dir = {"" = "src"}

machineconfig-4.1/src/machineconfig/cluster/sessions_managers/utils/load_balancer.py

@@ -0,0 +1,168 @@
+
+from machineconfig.utils.schemas.layouts.layout_types import TabConfig, LayoutConfig
+from machineconfig.utils.accessories import split_list
+from typing import Literal
+
+
+
+def split_tabs_by_weight(tabs: list[TabConfig], max_weight: int) -> list[list[TabConfig]]:
+    """Split tabs into chunks where each chunk's total weight <= max_weight."""
+    chunks: list[list[TabConfig]] = []
+    current_chunk: list[TabConfig] = []
+    current_weight = 0
+    for tab in tabs:
+        tab_weight = tab.get("tabWeight", 1)
+        if current_weight + tab_weight > max_weight and current_chunk:
+            chunks.append(current_chunk)
+            current_chunk = [tab]
+            current_weight = tab_weight
+        else:
+            current_chunk.append(tab)
+            current_weight += tab_weight
+    
+    if current_chunk:
+        chunks.append(current_chunk)
+    
+    return chunks
+
+
+def combine_tabs_into_super_tabs(tabs: list[TabConfig], num_super_tabs: int) -> list[TabConfig]:
+    """Combine tabs into num_super_tabs super tabs with combined commands."""
+    if len(tabs) <= num_super_tabs:
+        return tabs  # No need to combine
+    
+    tab_groups = split_list(tabs, to=num_super_tabs)
+    super_tabs: list[TabConfig] = []
+    for idx, group in enumerate(tab_groups):
+        if len(group) == 1:
+            super_tabs.append(group[0])
+        else:
+            combined_command = "; ".join(tab["command"] for tab in group)
+            combined_name = f"super_tab_{idx+1}"
+            # Use startDir of the first tab
+            start_dir = group[0]["startDir"]
+            # Sum weights
+            total_weight = sum(tab.get("tabWeight", 1) for tab in group)
+            super_tabs.append({
+                "tabName": combined_name,
+                "startDir": start_dir,
+                "command": combined_command,
+                "tabWeight": total_weight
+            })
+    return super_tabs
+
+
+def combine_tabs_by_weight_into_super_tabs(tabs: list[TabConfig], max_weight: int) -> list[TabConfig]:
+    """Combine tabs into super tabs where each super tab has weight <= max_weight."""
+    tab_groups = split_tabs_by_weight(tabs, max_weight=max_weight)
+    super_tabs: list[TabConfig] = []
+    for idx, group in enumerate(tab_groups):
+        if len(group) == 1:
+            super_tabs.append(group[0])
+        else:
+            combined_command = "; ".join(tab["command"] for tab in group)
+            combined_name = f"super_tab_{idx+1}"
+            start_dir = group[0]["startDir"]
+            total_weight = sum(tab.get("tabWeight", 1) for tab in group)
+            super_tabs.append({
+                "tabName": combined_name,
+                "startDir": start_dir,
+                "command": combined_command,
+                "tabWeight": total_weight
+            })
+    return super_tabs
+
+
+def restrict_num_tabs(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["number", "weight"], breaking_method: Literal["moreLayouts", "combineTabs"]) -> list[LayoutConfig]:
+    match threshold_type, breaking_method:
+        case "number", "moreLayouts":
+            return _restrict_num_tabs_helper1(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=threshold_type, breaking_method=breaking_method)
+        case "number", "combineTabs":
+            return _restrict_num_tabs_helper2(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=threshold_type, breaking_method=breaking_method)
+        case "weight", "moreLayouts":
+            return _restrict_num_tabs_helper3(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=threshold_type, breaking_method=breaking_method)
+        case "weight", "combineTabs":
+            return _restrict_num_tabs_helper4(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=threshold_type, breaking_method=breaking_method)
+        case _:
+            raise NotImplementedError(f"The combination {threshold_type}, {breaking_method} is not implemented")
+
+
+def _restrict_num_tabs_helper1(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["number"], breaking_method: Literal["moreLayouts"]) -> list[LayoutConfig]:
+    """When threshold is exceeded, create more layouts with max_thresh tabs each."""
+    new_layout_configs: list[LayoutConfig] = []
+    for a_layout_config in layout_configs:
+        if len(a_layout_config["layoutTabs"]) > max_thresh:
+            print(f"Layout '{a_layout_config['layoutName']}' has too many tabs ({len(a_layout_config['layoutTabs'])} > {max_thresh}). Splitting into multiple layouts.")
+            tab_chunks = split_list(a_layout_config["layoutTabs"], every=max_thresh)
+            for idx, tab_chunk in enumerate(tab_chunks):
+                new_layout_configs.append({
+                    "layoutName": f"{a_layout_config['layoutName']}_part{idx+1}",
+                    "layoutTabs": tab_chunk
+                })
+        else:
+            print(f"Layout '{a_layout_config['layoutName']}' has acceptable number of tabs ({len(a_layout_config['layoutTabs'])} <= {max_thresh}). Keeping as is.")
+            new_layout_configs.append(a_layout_config)
+    return new_layout_configs
+
+
+def _restrict_num_tabs_helper2(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["number"], breaking_method: Literal["combineTabs"]) -> list[LayoutConfig]:
+    """When threshold is exceeded, combine tabs into super tabs to reduce count to max_thresh."""
+    new_layout_configs: list[LayoutConfig] = []
+    for a_layout_config in layout_configs:
+        num_tabs = len(a_layout_config["layoutTabs"])
+        if num_tabs > max_thresh:
+            print(f"Layout '{a_layout_config['layoutName']}' has too many tabs ({num_tabs} > {max_thresh}). Combining into {max_thresh} super tabs.")
+            super_tabs = combine_tabs_into_super_tabs(a_layout_config["layoutTabs"], num_super_tabs=max_thresh)
+            new_layout_configs.append({
+                "layoutName": a_layout_config["layoutName"],
+                "layoutTabs": super_tabs
+            })
+        else:
+            print(f"Layout '{a_layout_config['layoutName']}' has acceptable number of tabs ({num_tabs} <= {max_thresh}). Keeping as is.")
+            new_layout_configs.append(a_layout_config)
+    return new_layout_configs
+
+
+def _restrict_num_tabs_helper3(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["weight"], breaking_method: Literal["moreLayouts"]) -> list[LayoutConfig]:
+    """When threshold is exceeded, create more layouts with max_thresh total weight each."""
+    new_layout_configs: list[LayoutConfig] = []
+    for a_layout_config in layout_configs:
+        layout_weight = sum(tab.get("tabWeight", 1) for tab in a_layout_config["layoutTabs"])
+        if layout_weight > max_thresh:
+            print(f"Layout '{a_layout_config['layoutName']}' has too much weight ({layout_weight} > {max_thresh}). Splitting into multiple layouts.")
+            tab_chunks = split_tabs_by_weight(a_layout_config["layoutTabs"], max_weight=max_thresh)
+            for idx, tab_chunk in enumerate(tab_chunks):
+                new_layout_configs.append({
+                    "layoutName": f"{a_layout_config['layoutName']}_part{idx+1}",
+                    "layoutTabs": tab_chunk
+                })
+        else:
+            print(f"Layout '{a_layout_config['layoutName']}' has acceptable total weight ({layout_weight} <= {max_thresh}). Keeping as is.")
+            new_layout_configs.append(a_layout_config)
+    return new_layout_configs
+
+
+def _restrict_num_tabs_helper4(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["weight"], breaking_method: Literal["combineTabs"]) -> list[LayoutConfig]:
+    """When threshold is exceeded, combine tabs into super tabs with weight <= max_thresh."""
+    new_layout_configs: list[LayoutConfig] = []
+    for a_layout_config in layout_configs:
+        layout_weight = sum(tab.get("tabWeight", 1) for tab in a_layout_config["layoutTabs"])
+        if layout_weight > max_thresh:
+            print(f"Layout '{a_layout_config['layoutName']}' has too much weight ({layout_weight} > {max_thresh}). Combining into super tabs with weight <= {max_thresh}.")
+            super_tabs = combine_tabs_by_weight_into_super_tabs(a_layout_config["layoutTabs"], max_weight=max_thresh)
+            new_layout_configs.append({
+                "layoutName": a_layout_config["layoutName"],
+                "layoutTabs": super_tabs
+            })
+        else:
+            print(f"Layout '{a_layout_config['layoutName']}' has acceptable total weight ({layout_weight} <= {max_thresh}). Keeping as is.")
+            new_layout_configs.append(a_layout_config)
+    return new_layout_configs
+
+
+def run(layouts: list[LayoutConfig]):
+    from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
+    manager = ZellijLocalManager(session_layouts=layouts)
+    manager.start_all_sessions(poll_interval=2, poll_seconds=2)
+    manager.run_monitoring_routine(wait_ms=2000)
+    manager.kill_all_sessions()

{machineconfig-4.0 → machineconfig-4.1}/src/machineconfig/cluster/sessions_managers/zellij_local.py

@@ -456,7 +456,7 @@ def run_zellij_layout(layout_config: LayoutConfig):
     layout_path = created_zellij_layout(layout_config, None)
     session_name = layout_config["layoutName"]
     try:
-        from machineconfig.cluster.sessions_managers.enhanced_command_runner import enhanced_zellij_session_start
+        from machineconfig.cluster.sessions_managers.utils.enhanced_command_runner import enhanced_zellij_session_start
 
         enhanced_zellij_session_start(session_name, layout_path)
     except ImportError:

machineconfig-4.1/src/machineconfig/jobs/installer/linux_scripts/q.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+cd $HOME/Downloads
+curl --proto '=https' --tlsv1.2 -sSf "https://desktop-release.q.us-east-1.amazonaws.com/latest/q-x86_64-linux.zip" -o "q.zip"
+unzip q.zip
+./q/install.sh  # goes to ~/.local/bin.
+rm q.zip
+rm -rfd q

{machineconfig-4.0 → machineconfig-4.1}/src/machineconfig/jobs/installer/packages_custom_dev.json

@@ -37,7 +37,7 @@
       }
     },
     {
-      "appName": "aider-chat",
+      "appName": "aider",
       "repoURL": "CMD",
       "doc": "Aider Chat",
       "fileNamePattern": {
@@ -53,6 +53,142 @@
         }
       }
     },
+    {
+      "appName": "github-copilot-cli",
+      "repoURL": "CMD",
+      "doc": "Terminal-based CLI agents and tools for productivity and coding.",
+      "fileNamePattern": {
+        "amd64": {
+          "linux": "npm install -g @github/copilot",
+          "windows": "npm install -g @github/copilot",
+          "macos": "npm install -g @github/copilot"
+        },
+        "arm64": {
+          "linux": "npm install -g @github/copilot",
+          "windows": "npm install -g @github/copilot",
+          "macos": "npm install -g @github/copilot"
+        }
+      }
+    },
+    {
+      "appName": "gemini",
+      "repoURL": "CMD",
+      "doc": "Terminal-based CLI agents and tools for productivity and coding.",
+      "fileNamePattern": {
+        "amd64": {
+          "linux": "npm install -g @google/gemini-cli",
+          "windows": "npm install -g @google/gemini-cli",
+          "macos": "npm install -g @google/gemini-cli"
+        },
+        "arm64": {
+          "linux": "npm install -g @google/gemini-cli",
+          "windows": "npm install -g @google/gemini-cli",
+          "macos": "npm install -g @google/gemini-cli"
+        }
+      }
+    },
+    {
+      "appName": "crush",
+      "repoURL": "CMD",
+      "doc": "Terminal-based CLI agents and tools for productivity and coding.",
+      "fileNamePattern": {
+        "amd64": {
+          "linux": "npm install -g @charmland/crush",
+          "windows": "npm install -g @charmland/crush",
+          "macos": "npm install -g @charmland/crush"
+        },
+        "arm64": {
+          "linux": "npm install -g @charmland/crush",
+          "windows": "npm install -g @charmland/crush",
+          "macos": "npm install -g @charmland/crush"
+        }
+      }
+    },
+    {
+      "appName": "opencode-ai",
+      "repoURL": "CMD",
+      "doc": "Terminal-based CLI agents and tools for productivity and coding.",
+      "fileNamePattern": {
+        "amd64": {
+          "linux": "npm install -g opencode-ai@latest",
+          "windows": "npm install -g opencode-ai@latest",
+          "macos": "npm install -g opencode-ai@latest"
+        },
+        "arm64": {
+          "linux": "npm install -g opencode-ai@latest",
+          "windows": "npm install -g opencode-ai@latest",
+          "macos": "npm install -g opencode-ai@latest"
+        }
+      }
+    },
+    {
+      "appName": "warp",
+      "repoURL": "CMD",
+      "doc": "Modern terminal with AI-powered features",
+      "fileNamePattern": {
+        "amd64": {
+          "linux": "https://app.warp.dev/download/cli?os=linux&package=deb&arch=x86_64",
+          "windows": null,
+          "macos": null
+        },
+        "arm64": {
+          "linux": "https://app.warp.dev/download/cli?os=linux&package=deb&arch=aarch64",
+          "windows": null,
+          "macos": null
+        }
+      }
+    },
+    {
+      "appName": "q",
+      "repoURL": "CMD",
+      "doc": "Q desktop application",
+      "fileNamePattern": {
+        "amd64": {
+          "linux": "q.sh",
+          "windows": null,
+          "macos": null
+        },
+        "arm64": {
+          "linux": null,
+          "windows": null,
+          "macos": null
+        }
+      }
+    },
+    {
+      "appName": "cursor-cli",
+      "repoURL": "CMD",
+      "doc": "Cursor CLI installer",
+      "fileNamePattern": {
+        "amd64": {
+          "linux": "curl https://cursor.com/install -fsS | bash",
+          "windows": null,
+          "macos": null
+        },
+        "arm64": {
+          "linux": null,
+          "windows": null,
+          "macos": null
+        }
+      }
+    },
+    {
+      "appName": "droid",
+      "repoURL": "CMD",
+      "doc": "Factory AI CLI installer",
+      "fileNamePattern": {
+        "amd64": {
+          "linux": "curl -fsSL https://app.factory.ai/cli | sh",
+          "windows": null,
+          "macos": null
+        },
+        "arm64": {
+          "linux": null,
+          "windows": null,
+          "macos": null
+        }
+      }
+    },
     {
       "appName": "Alacritty",
       "repoURL": "CMD",

{machineconfig-4.0 → machineconfig-4.1}/src/machineconfig/jobs/installer/packages_github_dev.json

@@ -245,17 +245,34 @@
       "doc": "🗃️ TUI DB Visualizer",
       "fileNamePattern": {
         "amd64": {
-          "linux": "rainfrog-{version}-x86_64-unknown-linux-gnu.tar.gz",
+          "linux": "rainfrog-{version}-x86_64-unknown-linux-musl.tar.gz",
           "macos": null,
           "windows": null
         },
         "arm64": {
-          "linux": "rainfrog-{version}-aarch64-unknown-linux-gnu.tar.gz",
+          "linux": "rainfrog-{version}-aarch64-unknown-linux-musl.tar.gz",
           "macos": null,
           "windows": null
         }
       }
     },
+    {
+      "appName": "duckdb",
+      "repoURL": "https://github.com/duckdb/duckdb",
+      "doc": "🗃️ An in-process SQL OLAP database management system",
+      "fileNamePattern": {
+        "amd64": {
+          "linux": "duckdb_cli-linux-amd64.zip",
+          "macos": "duckdb_cli-osx-universal.zip",
+          "windows": "duckdb_cli-windows-amd64.zip"
+        },
+        "arm64": {
+          "linux": "duckdb_cli-linux-arm64.zip",  
+          "macos": "duckdb_cli-osx-universal.zip",
+          "windows": "duckdb_cli-windows-arm64.zip"
+        }
+      }
+    },
     {
       "appName": "cpz",
       "repoURL": "https://github.com/SUPERCILEX/fuc",

{machineconfig-4.0 → machineconfig-4.1}/src/machineconfig/jobs/installer/packages_github_essential.json

@@ -409,23 +409,6 @@
         }
       }
     },
-    {
-      "appName": "gemini-cli",
-      "repoURL": "CMD",
-      "doc": "🤖 Gemini CLI is a command line interface for Google Gemini AI.",
-      "fileNamePattern": {
-        "amd64": {
-          "linux": "npm install -g @google/gemini-cli",
-          "macos": "npm install -g @google/gemini-cli",
-          "windows": "npm install -g @google/gemini-cli"
-        },
-        "arm64": {
-          "linux": "npm install -g @google/gemini-cli",
-          "macos": "npm install -g @google/gemini-cli",
-          "windows": "npm install -g @google/gemini-cli"
-        }
-      }
-    },
     {
       "appName": "gitui",
       "repoURL": "https://github.com/gitui-org/gitui",

machineconfig-4.1/src/machineconfig/jobs/linux/msc/cli_agents.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+
+# Vscode extensions for AI-assisted coding.
+# Github copilot
+# Roo
+# Cline
+# Kilocode
+# Continue
+# CodeGPT
+# qodo (and cli)
+
+# Editors based on AI
+# Kiro
+# Cursor
+# Warp

{machineconfig-4.0 → machineconfig-4.1}/src/machineconfig/scripts/python/devops_devapps_install.py

@@ -8,6 +8,42 @@ from typing import Optional, Literal, TypeAlias, cast, get_args, Annotated
 WHICH_CAT: TypeAlias = Literal["essentials", "essentialsDev", "systymPackages", "precheckedPackages", "ia"]
 
 
+def _handle_installer_not_found(search_term: str, all_installers: list["InstallerData"]) -> None:  # type: ignore
+    """Handle installer not found with friendly suggestions using fuzzy matching."""
+    from difflib import get_close_matches
+    
+    # Get all possible names (both exe names and app names)
+    all_names = []
+    for inst in all_installers:
+        exe_name = inst["appName"]
+        all_names.append(exe_name)
+    
+    # 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.")
+    
+    if close_matches:
+        print("🤔 Did you mean one of these?")
+        for i, match in enumerate(close_matches, 1):
+            print(f"   {i}. {match}")
+    else:
+        print("📋 Here are some available options:")
+        # Show first 10 installers as examples
+        sample_names = []
+        for inst in all_installers[:10]:
+            exe_name = inst["appName"]
+            sample_names.append(exe_name)        
+        for i, name in enumerate(sample_names, 1):
+            print(f"   {i}. {name}")
+        
+        if len(all_installers) > 10:
+            print(f"   ... and {len(all_installers) - 10} more")
+    
+    print("\n💡 Use 'ia' to interactively browse all available installers.")
+    print(f"💡 Use one of the categories: {list(get_args(WHICH_CAT))}")
+
+
 def main_with_parser():
     import typer
     app = typer.Typer()
@@ -20,6 +56,7 @@ def main(which: Annotated[Optional[str], typer.Argument(help=f"Choose a category
         return get_programs_by_category(program_name=which)  # type: ignore
     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
     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:
@@ -28,22 +65,16 @@ def main(which: Annotated[Optional[str], typer.Argument(help=f"Choose a category
             # Find installer by exe_name or name
             selected_installer = None
             for installer in all_installers:
-                exe_name = installer.installer_data.get("exeName", "")
-                app_name = installer.installer_data.get("appName", "")
+                exe_name = installer["appName"]
+                app_name = installer["appName"]
                 if exe_name == a_which or app_name == a_which:
                     selected_installer = installer
                     break
 
             if selected_installer is None:
-                available_names = [f"{inst.installer_data.get('exeName', 'unknown')} ({inst.installer_data.get('appName', 'unknown')})" for inst in all_installers[:10]]  # Show first 10
-                raise ValueError(f"{a_which=} not found. Available installers include: {available_names}")
-
-            print(f"""
-┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┃ 🔧 Installing: {a_which}
-┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-            print(selected_installer)
-            message = selected_installer.install_robust(version=None)  # finish the task
+                _handle_installer_not_found(a_which, all_installers)
+                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)
@@ -55,58 +86,35 @@ def install_interactively():
     from machineconfig.utils.options import choose_from_options
     from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
     from machineconfig.utils.installer import get_installers
+    from machineconfig.utils.installer_utils.installer_class import Installer
     installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["GITHUB_ESSENTIAL", "CUSTOM_ESSENTIAL", "GITHUB_DEV", "CUSTOM_DEV"])
-    # Check installed programs with progress indicator
     with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}")) as progress:
         task = progress.add_task("✅ Checking installed programs...", total=len(installers))
         installer_options = []
         for x in installers:
-            installer_options.append(x.get_description())
+            installer_options.append(Installer(installer_data=x).get_description())
             progress.update(task, advance=1)
-
-    # Add category options at the beginning for better visibility
     category_options = [f"📦 {cat}" for cat in get_args(WHICH_CAT)]
-    options = category_options + ["─" * 50] + installer_options
-    
+    options = category_options + ["─" * 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)
-
-    total_commands = ""
     installation_messages: list[str] = []
     for _an_idx, a_program_name in enumerate(program_names):
-        # Skip separator lines
         if a_program_name.startswith("─"):
             continue
-            
-        print(f"""
-┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┃ 🔄 Processing: {a_program_name}
-┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-        
-        # Handle category options (remove emoji prefix)
         if a_program_name.startswith("📦 "):
             category_name = a_program_name[2:]  # Remove "📦 " prefix
             if category_name in get_args(WHICH_CAT):
                 get_programs_by_category(program_name=cast(WHICH_CAT, category_name))
         else:
-            # Handle individual installer options
             installer_idx = installer_options.index(a_program_name)
-            an_installer = installers[installer_idx]
-            status_message = an_installer.install_robust(version=None)  # finish the task - this returns a status message, not a command
+            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 all installation status messages
     print("\n📊 INSTALLATION SUMMARY:")
     print("=" * 50)
     for message in installation_messages:
         print(message)
 
-    # Only run shell commands if there are any (from category installations)
-    if total_commands.strip():
-        import subprocess
-
-        print("\n🚀 Running additional shell commands...")
-        subprocess.run(total_commands, shell=True, check=True)
-
 
 def get_programs_by_category(program_name: WHICH_CAT):
     print(f"""
@@ -121,10 +129,10 @@ def get_programs_by_category(program_name: WHICH_CAT):
     match program_name:
         case "essentials":
             installers_ = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["GITHUB_ESSENTIAL", "CUSTOM_ESSENTIAL"])
-            install_all(installers=installers_)
+            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"])
-            install_all(installers=installers_)
+            install_all(installers_data=installers_)
         case "systymPackages":
             if system() == "Windows":
                 options_system = parse_apps_installer_windows(LIBRARY_ROOT.joinpath("setup_windows/apps.ps1").read_text(encoding="utf-8"))
@@ -156,4 +164,7 @@ def get_programs_by_category(program_name: WHICH_CAT):
 
 
 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-4.0 → machineconfig-4.1}/src/machineconfig/scripts/python/fire_agents.py

@@ -16,7 +16,6 @@ from machineconfig.scripts.python.fire_agents_help_launch import prep_agent_laun
 from machineconfig.scripts.python.fire_agents_help_search import search_files_by_pattern, search_python_files
 from machineconfig.scripts.python.fire_agents_load_balancer import chunk_prompts, SPLITTING_STRATEGY, DEFAULT_AGENT_CAP
 from machineconfig.utils.options import choose_from_options
-from machineconfig.utils.schemas.layouts.layout_types import TabConfig, LayoutConfig
 from machineconfig.utils.accessories import get_repo_root
 
 SEARCH_STRATEGIES: TypeAlias = Literal["file_path", "keyword_search", "filename_pattern"]
@@ -150,26 +149,5 @@ manager.run_monitoring_routine()
     manager.run_monitoring_routine(wait_ms=2000)
 
 
-def split_too_many_tabs_to_run_in_sequential_sessions(layout_tabs: list[TabConfig], every: int):
-    from machineconfig.utils.accessories import split_list
-    from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
-
-    for idx, layout_tabs_chunk in enumerate(split_list(layout_tabs, every=every, to=None)):
-        a_layout_file: LayoutConfig = {"layoutName": f"split_{idx}", "layoutTabs": layout_tabs_chunk}
-        manager = ZellijLocalManager(session_layouts=[a_layout_file])
-        manager.start_all_sessions(poll_interval=2, poll_seconds=2)
-        manager.run_monitoring_routine(wait_ms=2000)
-        manager.kill_all_sessions()
-
-
-def split_too_many_layouts_to_run_in_sequential_sessions(layouts: list[LayoutConfig], every: int):
-    from machineconfig.utils.accessories import split_list
-    from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
-    for _idx, layout_chunk in enumerate(split_list(layouts, every=every)):
-        manager = ZellijLocalManager(session_layouts=layout_chunk)
-        manager.start_all_sessions(poll_interval=2, poll_seconds=2)
-        manager.run_monitoring_routine(wait_ms=2000)
-
-
 if __name__ == "__main__":  # pragma: no cover
     main()