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

machineconfig/jobs/installer/package_groups.py

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

machineconfig/scripts/python/devops.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/scripts/python/devops_devapps_install.py

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

machineconfig/scripts/python/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