machineconfig 4.6__tar.gz → 4.8__tar.gz

{machineconfig-4.6/src/machineconfig.egg-info → machineconfig-4.8}/PKG-INFO

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

{machineconfig-4.6 → machineconfig-4.8}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "machineconfig"
-version = "4.6"
+version = "4.8"
 description = "Dotfiles management package"
 readme = "README.md"
 license = {text = "Apache 2.0"}
@@ -54,7 +54,6 @@ 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:app"
 initai = "machineconfig.scripts.python.ai.initai:main"
 
 choose_wezterm_theme = "machineconfig.scripts.python.choose_wezterm_theme:main"
@@ -64,11 +63,14 @@ cloud_repo_sync = "machineconfig.scripts.python.cloud_repo_sync:args_parser"
 cloud_sync = "machineconfig.scripts.python.cloud_sync:arg_parser"
 ftpx = "machineconfig.scripts.python.ftpx:main_from_parser"
 repos = "machineconfig.scripts.python.repos:main_from_parser"
+
 start_slidev = "machineconfig.scripts.python.start_slidev: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]

{machineconfig-4.6 → machineconfig-4.8}/src/machineconfig/cluster/sessions_managers/wt_local_manager.py

@@ -5,10 +5,19 @@ import uuid
 import logging
 import subprocess
 from pathlib import Path
-from typing import Optional, Dict, List, Any
+from typing import TypedDict, Optional, Dict, List, Any
 from machineconfig.utils.scheduler import Scheduler
 from machineconfig.cluster.sessions_managers.wt_local import WTLayoutGenerator
 from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
+from machineconfig.cluster.sessions_managers.zellij_utils.monitoring_types import (
+    StartResult, GlobalSummary, ActiveSessionInfo, CommandStatus, CommandSummary
+)
+
+
+class WTSessionReport(TypedDict):
+    session_status: Dict[str, Any]  # WT-specific session status
+    commands_status: Dict[str, CommandStatus]
+    summary: CommandSummary
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -44,7 +53,7 @@ class WTLocalManager:
         """Get all managed session names."""
         return [manager.session_name for manager in self.managers if manager.session_name is not None]
 
-    def start_all_sessions(self) -> Dict[str, Any]:
+    def start_all_sessions(self) -> Dict[str, StartResult]:
         """Start all Windows Terminal sessions with their layouts."""
         results = {}
         for manager in self.managers:
@@ -75,7 +84,7 @@ class WTLocalManager:
 
         return results
 
-    def kill_all_sessions(self) -> Dict[str, Any]:
+    def kill_all_sessions(self) -> Dict[str, StartResult]:
         """Kill all managed Windows Terminal sessions."""
         results = {}
         for manager in self.managers:
@@ -119,7 +128,7 @@ class WTLocalManager:
                 commands.append("")
             return "\n".join(commands)
 
-    def check_all_sessions_status(self) -> Dict[str, Dict[str, Any]]:
+    def check_all_sessions_status(self) -> Dict[str, WTSessionReport]:
         """Check the status of all sessions and their commands."""
         status_report = {}
 
@@ -144,7 +153,7 @@ class WTLocalManager:
 
         return status_report
 
-    def get_global_summary(self) -> Dict[str, Any]:
+    def get_global_summary(self) -> GlobalSummary:
         """Get a global summary across all sessions."""
         all_status = self.check_all_sessions_status()
 
@@ -395,7 +404,7 @@ class WTLocalManager:
             logger.error(f"Failed to delete session {session_id}: {e}")
             return False
 
-    def list_active_sessions(self) -> List[Dict[str, Any]]:
+    def list_active_sessions(self) -> List[ActiveSessionInfo]:
         """List currently active Windows Terminal sessions managed by this instance."""
         active_sessions = []
 

{machineconfig-4.6 → machineconfig-4.8}/src/machineconfig/scripts/python/devops.py

@@ -1,37 +1,44 @@
 """devops with emojis"""
 
-from machineconfig.scripts.python.share_terminal import main as share_terminal_main
+import machineconfig.scripts.python.fire_agents as fire_agents
+import machineconfig.scripts.python.fire_jobs_layout_helper as fire_jobs_layout_helper
 import machineconfig.scripts.python.devops_devapps_install as installer_entry_point
+import machineconfig.scripts.python.share_terminal as share_terminal
+import machineconfig.scripts.python.repos as repos
 
-from platform import system
-from rich.console import Console
-from rich.panel import Panel
 import typer
 
-console = Console()
 app = typer.Typer(help="🛠️ DevOps operations with emojis", no_args_is_help=True)
 
 
-BOX_WIDTH = 150  # width for box drawing
+agents_app = typer.Typer(help="🤖 AI Agents management subcommands")
+agents_app.command("create")(fire_agents.create)
+agents_app.command("collect")(fire_agents.collect)
+app.add_typer(agents_app, name="agents")
+
+layouts_app = typer.Typer(help="Layouts management subcommands")
+layouts_app.command("launch")(fire_jobs_layout_helper.launch)
+layouts_app.command("load-balance")(fire_jobs_layout_helper.load_balance)
+app.add_typer(layouts_app, name="session")
+
+app.command(name="install", help="📦 Install essential packages")(installer_entry_point.main)
+app.command(name="share-terminal", help="📡 Share terminal via web browser")(share_terminal.main)
+app.command(name="repos", help="📁 Manage git repositories")(repos.main)
+
+ssh_app = typer.Typer(help="🔐 SSH operations subcommands", no_args_is_help=True)
+app.add_typer(ssh_app, name="ssh")
 
 
 @app.command()
 def update():
     """🔄 UPDATE essential repos"""
-    console.print(Panel("🔄 Updating essential repositories...", width=BOX_WIDTH, border_style="blue"))
     import machineconfig.scripts.python.devops_update_repos as helper
     helper.main()
 
 
-app.command(name="install", help="📦 Install essential packages")(installer_entry_point.main)
-app.command(name="share-terminal", help="📡 Share terminal via web browser")(share_terminal_main)
-
-
-
 @app.command()
 def symlinks():
     """🔗 SYMLINKS of dotfiles."""
-    console.print(Panel("🔗 Setting up symlinks, PATH, and shell profile...", width=BOX_WIDTH, border_style="blue"))
     import machineconfig.profile.create as helper
     helper.main_symlinks()
 
@@ -39,7 +46,6 @@ def symlinks():
 @app.command()
 def profile():
     """🔗 Update shell profile."""
-    console.print(Panel("🔗 Setting up symlinks, PATH, and shell profile...", width=BOX_WIDTH, border_style="blue"))
     import machineconfig.profile.create as helper
     helper.main_profile()
 
@@ -47,48 +53,35 @@ def profile():
 @app.command()
 def symlinks_new():
     """🆕 SYMLINKS new"""
-    console.print(Panel("🔄 Creating new symlinks...", width=BOX_WIDTH, border_style="blue"))
     import machineconfig.jobs.python.python_ve_symlink as helper
     helper.main()
 
 
-@app.command()
-def ssh_add_key():
+@ssh_app.command()
+def add_key():
     """🔑 SSH add pub key to this machine"""
-    console.print(Panel("🔑 Adding public SSH key to this machine...", width=BOX_WIDTH, border_style="blue"))
     import machineconfig.scripts.python.devops_add_ssh_key as helper
     helper.main()
-
-
-@app.command()
-def ssh_add_identity():
+@ssh_app.command()
+def add_identity():
     """🗝️ SSH add identity (private key) to this machine"""
-    console.print(Panel("🗝️  Adding SSH identity (private key) to this machine...", width=BOX_WIDTH, border_style="blue"))
     import machineconfig.scripts.python.devops_add_identity as helper
     helper.main()
-
-
-@app.command()
-def ssh_connect():
+@ssh_app.command()
+def connect():
     """🔐 SSH use key pair to connect two machines"""
-    console.print(Panel("❌ ERROR: Not Implemented\nSSH key pair connection feature is not yet implemented", title_align="left", border_style="red", width=BOX_WIDTH))
     raise NotImplementedError
-
-
-@app.command()
-def ssh_setup():
+@ssh_app.command()
+def setup():
     """📡 SSH setup"""
-    console.print(Panel("📡 Setting up SSH...", width=BOX_WIDTH, border_style="blue"))
     _program_windows = """Invoke-WebRequest https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_windows/openssh_all.ps1 | Invoke-Expression  # https://github.com/thisismygitrepo.keys"""
     _program_linux = """curl https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_linux/openssh_all.sh | sudo bash  # https://github.com/thisismygitrepo.keys"""
     import subprocess
+    from platform import system
     subprocess.run(_program_linux if system() == "Linux" else _program_windows, shell=True, check=True)
-
-
-@app.command()
-def ssh_setup_wsl():
+@ssh_app.command()
+def setup_wsl():
     """🐧 SSH setup wsl"""
-    console.print(Panel("🐧 Setting up SSH for WSL...", width=BOX_WIDTH, border_style="blue"))
     import subprocess
     subprocess.run("curl https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_linux/openssh_wsl.sh | sudo bash", shell=True, check=True)
 
@@ -96,7 +89,6 @@ def ssh_setup_wsl():
 @app.command()
 def backup():
     """💾 BACKUP"""
-    console.print(Panel("💾 Creating backup...", width=BOX_WIDTH, border_style="blue"))
     from machineconfig.scripts.python.devops_backup_retrieve import main_backup_retrieve
     main_backup_retrieve(direction="BACKUP")
 
@@ -104,7 +96,6 @@ def backup():
 @app.command()
 def retrieve():
     """📥 RETRIEVE"""
-    console.print(Panel("📥 Retrieving backup...", width=BOX_WIDTH, border_style="blue"))
     from machineconfig.scripts.python.devops_backup_retrieve import main_backup_retrieve
     main_backup_retrieve(direction="RETRIEVE")
 
@@ -112,16 +103,16 @@ def retrieve():
 @app.command()
 def scheduler():
     """⏰ SCHEDULER"""
-    console.print(Panel("⏰ Setting up scheduler...", width=BOX_WIDTH, border_style="blue"))
     # from machineconfig.scripts.python.scheduler import main as helper
     # helper()
 
-@app.command("ia")
+@app.command()
 def interactive():
     """🤖 INTERACTIVE configuration of machine."""
     from machineconfig.scripts.python.interactive import main
     main()
 
 
+
 if __name__ == "__main__":
     pass

{machineconfig-4.6 → machineconfig-4.8}/src/machineconfig/scripts/python/fire_agents.py

@@ -1,35 +1,11 @@
 """Utilitfrom pathlib import Path
-from typing import cast, get_args, Iterable, Optional, TypeAlias, Literal
-import json
-import typer
-
-from machineconfig.scripts.python.fire_agents_help_launch import prep_agent_launch, get_agents_launch_layout, AGENTS
-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
-from machineconfig.utils.accessories import get_repo_rootch multiple AI agent prompts in a Zellij session.
 
-Improved design notes:
-  * Clear separation of: input collection, prompt preparation, agent launch.
-  * Configurable max agent cap (default 15) with interactive confirmation if exceeded.
-  * Added type aliases + docstrings for maintainability.
-  * Preserves original core behavior & command generation for each agent type.
 """
 
 from pathlib import Path
-from typing import cast, Iterable, Optional, TypeAlias, Literal, get_args
-import json
-import time
+from typing import cast, Iterable, Optional, get_args
 import typer
-
-from machineconfig.scripts.python.fire_agents_help_launch import prep_agent_launch, get_agents_launch_layout, AGENTS
-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
-from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
-from machineconfig.utils.accessories import get_repo_root, randstr
-
-SEARCH_STRATEGIES: TypeAlias = Literal["file_path", "keyword_search", "filename_pattern"]
-
-app = typer.Typer()
+from machineconfig.scripts.python.fire_agents_helper_types import AGENTS
 
 
 def _write_list_file(target: Path, files: Iterable[Path]) -> None:
@@ -37,7 +13,6 @@ def _write_list_file(target: Path, files: Iterable[Path]) -> None:
     target.write_text("\n".join(str(f) for f in files), encoding="utf-8")
 
 
-@app.command()
 def create(
     context_path: Optional[Path] = typer.Option(None, help="Path to the context file"),
     keyword_search: Optional[str] = typer.Option(None, help="Keyword to search in Python files"),
@@ -52,6 +27,13 @@ def create(
     output_path: Optional[Path] = typer.Option(None, help="Path to write the layout.json file"),
     agents_dir: Optional[Path] = typer.Option(None, help="Directory to store agent files. If not provided, will be constructed automatically."),
 ):
+
+    from machineconfig.scripts.python.fire_agents_help_launch import prep_agent_launch, get_agents_launch_layout
+    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
+    from machineconfig.utils.accessories import get_repo_root, randstr
+    import json
+
     # validate mutual exclusive
     context_options = [context_path, keyword_search, filename_pattern]
     provided_context = [opt for opt in context_options if opt is not None]
@@ -131,48 +113,6 @@ fire_agents create --context-path "{prompt_material_path}" \\
     typer.echo(f"Ceated layout in {layout_output_path}")
 
 
-@app.command()
-def run(layout_path: Path = typer.Argument(..., help="Path to the layout.json file"),
-        max_tabs: int = typer.Option(6, help="Maximum number of tabs to launch"),
-        sleep_inbetween: float = typer.Option(1.0, help="Sleep time in seconds between launching layouts"),
-        kill_upon_completion: bool = typer.Option(False, help="Kill the layout sessions upon completion")):
-    layoutfile: LayoutsFile = json.loads(layout_path.read_text())
-    for a_layout in layoutfile["layouts"]:
-        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)
-    from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
-    for i, a_layouts in enumerate(layoutfile["layouts"]):
-        manager = ZellijLocalManager(session_layouts=[a_layouts])
-        manager.start_all_sessions(poll_interval=2, poll_seconds=2)
-        manager.run_monitoring_routine(wait_ms=2000)
-        if kill_upon_completion:
-            manager.kill_all_sessions()
-        if i < len(layoutfile["layouts"]) - 1:  # Don't sleep after the last layout
-            time.sleep(sleep_inbetween)
-
-
-@app.command(help="Adjust layout file to limit max tabs per layout, etc.")
-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")):
-    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}")
-
-
-@app.command()
 def collect(
     agent_dir: Path = typer.Argument(..., help="Path to the agent directory containing the prompts folder"),
     output_path: Path = typer.Argument(..., help="Path to write the concatenated material files"),
@@ -214,5 +154,44 @@ def collect(
     typer.echo(f"Concatenated material written to {output_path}")
 
 
+def template():
+    template_bash = """#!/bin/bash
+JOB_NAME="outpatient_mapping"
+REPO_ROOT="$HOME/code/work/winter_planning/"
+CONTEXT_PATH="$REPO_ROOT/data/outpatient_mapping/op_services_collected.csv"
+PROMPT_PATH="$REPO_ROOT/data/outpatient_mapping/prompt"
+
+AGENTS_DIR="$REPO_ROOT/.ai/agents/$JOB_NAME"
+LAYOUT_PATH="$REPO_ROOT/.ai/agents/$JOB_NAME/layout_unbalanced.json"
+LAYOUT_BALANCED_PATH="$REPO_ROOT/.ai/agents/$JOB_NAME/layout_balanced.json"
+
+fire_agents create --context-path $CONTEXT_PATH --tasks-per-prompt 10 --agent crush --prompt-path $PROMPT_PATH --keep-separate --output-path $LAYOUT_PATH --agents-dir $AGENTS_DIR
+fire_agents load-balance $LAYOUT_PATH --max-thresh 6 --breaking-method moreLayouts --thresh-type number  --output-path $LAYOUT_BALANCED_PATH
+
+fire_agents run $LAYOUT_BALANCED_PATH --kill-upon-completion
+fire_agents collect $AGENTS_DIR "$REPO_ROOT/.ai/agents/$JOB_NAME/collected.txt"
+"""
+    template_powershell = """
+
+"""
+    from platform import system
+    if system() == "Linux":
+        template = template_bash
+    elif system() == "Windows":
+        template = template_powershell
+    else:
+        raise typer.BadParameter(f"Unsupported OS: {system()}")
+
+    from machineconfig.utils.accessories import get_repo_root
+    repo_root = get_repo_root(Path.cwd())
+    if repo_root is None:
+        typer.echo("💥 Could not determine the repository root. Please run this script from within a git repository.")
+        raise typer.Exit(1)
+    save_path = repo_root / ".ai" / "agents" / "template_fire_agents.sh"
+    save_path.parent.mkdir(parents=True, exist_ok=True)
+    save_path.write_text(template, encoding="utf-8")
+    typer.echo(f"Template bash script written to {save_path}")
+
+
 if __name__ == "__main__":  # pragma: no cover
-    app()
+    pass

{machineconfig-4.6 → machineconfig-4.8}/src/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-4.8/src/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-4.6 → machineconfig-4.8}/src/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-4.6 → machineconfig-4.8}/src/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-4.8/src/machineconfig/scripts/python/fire_jobs_layout_helper.py

@@ -0,0 +1,131 @@
+
+from pathlib import Path
+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, 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 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
+        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 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)
+        if layout_chosen is None:
+            available_layouts = [layout["layoutName"] for layout in layout_file["layouts"]]
+            raise ValueError(f"Layout '{name}' not found. Available layouts: {available_layouts}")
+        layouts_chosen.append(layout_chosen)
+    return layouts_chosen
+
+
+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"})
+    elif path_obj.is_dir():
+        print(f"🔍 Searching recursively for Python, PowerShell and Shell scripts in directory `{path_obj}`")
+        files = search_for_files_of_interest(path_obj)
+        print(f"🔍 Got #{len(files)} results.")
+        choice_file = choose_from_options(multi=False, options=files, fzf=True, msg="Choose one option")
+        choice_file = PathExtended(choice_file)
+    else:
+        choice_file = path_obj
+    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-4.6 → machineconfig-4.8}/src/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: