machineconfig 3.7__py3-none-any.whl → 7.69__py3-none-any.whl

machineconfig/scripts/python/devops_devapps_install.py

@@ -1,202 +0,0 @@
-"""Devops Devapps Install"""
-
-# import subprocess
-from rich.progress import Progress, SpinnerColumn, TextColumn
-from machineconfig.utils.source_of_truth import LIBRARY_ROOT
-from machineconfig.utils.options import choose_from_options
-from machineconfig.utils.installer import get_installers, install_all
-from platform import system
-from typing import Any, Optional, Literal, TypeAlias, get_args
-
-
-WHICH_CAT: TypeAlias = Literal["AllEssentials", "EssentialsAndOthers", "SystemInstallers", "PrecheckedCloudInstaller"]
-
-
-def main(which: Optional[WHICH_CAT | str]) -> None:
-    if which is not None and which in get_args(WHICH_CAT):  # install by category
-        return get_programs_by_category(program_name=which)  # type: ignore
-
-    if which is not None:  # install by name
-        total_messages: list[str] = []
-        for a_which in which.split(",") if type(which) == str else which:
-            # Use get_installers to get properly converted installer objects
-            all_installers = get_installers(system=system(), dev=False) + get_installers(system=system(), dev=True)
-
-            # 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", "")
-                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
-            total_messages.append(message)
-        for a_message in total_messages:
-            print(a_message)
-        return None
-
-    # interactive installation
-    installers = get_installers(system=system(), dev=False) + get_installers(system=system(), dev=True)
-
-    # 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))
-        options = []
-        for x in installers:
-            options.append(x.get_description())
-            progress.update(task, advance=1)
-
-    options += list(get_args(WHICH_CAT))
-    # print("s"*1000)
-    program_names = choose_from_options(multi=True, msg="", options=options, header="🚀 CHOOSE DEV APP", default="AllEssentials")
-
-    total_commands = ""
-    installation_messages: list[str] = []
-    for _an_idx, a_program_name in enumerate(program_names):
-        print(f"""
-┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┃ 🔄 Processing: {a_program_name}
-┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-        if a_program_name in get_args(WHICH_CAT):
-            shell_commands = get_programs_by_category(program_name=a_program_name)  # type: ignore
-            total_commands += "\n" + shell_commands
-        else:
-            an_installer = installers[options.index(a_program_name)]
-            status_message = an_installer.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"""
-┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┃ 📦 Installing Category: {program_name}
-┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-    match program_name:
-        case "AllEssentials" | "EssentialsAndOthers":
-            installers_ = get_installers(dev=False, system=system())
-            if program_name == "EssentialsAndOthers":
-                installers_ += get_installers(dev=True, system=system())
-            install_all(installers=installers_)
-            program = ""
-
-        case "SystemInstallers":
-            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}
-            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")
-            program = ""
-            for name in program_names:
-                print(f"""
-┌────────────────────────────────────────────────────
-│ ⚙️  Installing: {name}
-└────────────────────────────────────────────────────""")
-                sub_program = options_system[name]
-                if sub_program.startswith("#winget"):
-                    sub_program = sub_program[1:]
-                program += "\n" + sub_program
-
-        # case "OtherDevApps":
-        #     installers = get_installers(dev=True, system=system())
-        #     options__: list[str] = [x.get_description() for x in tqdm(installers, desc="Checking installed programs")]
-        #     program_names = choose_from_options(multi=True, msg="", options=sorted(options__) + ["all"], header="CHOOSE DEV APP")
-        #     if "all" in program_names: program_names = options__
-        #     program = ""
-        #     print("Installing:")
-        #     L(program_names).print()
-        #     for name in program_names:
-        #         try:
-        #             idx = options__.index(name)
-        #         except ValueError as ve:
-        #             print(f"{name=}")
-        #             print(f"{options__=}")
-        #             raise ve
-        #         print(f"Installing {name}")
-        #         sub_program = installers[idx].install_robust(version=None)  # finish the task
-
-        case "PrecheckedCloudInstaller":
-            # from machineconfig.jobs.python.check_installations import PrecheckedCloudInstaller
-            # ci = PrecheckedCloudInstaller()
-            # ci.download_safe_apps(name="AllEssentials")
-            # program = ""
-            raise NotImplementedError("PrecheckedCloudInstaller is not implemented yet.")
-    return program
-
-
-def parse_apps_installer_linux(txt: str) -> dict[str, Any]:
-    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)
-        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
-    return res
-
-
-if __name__ == "__main__":
-    pass

machineconfig/scripts/python/devops_update_repos.py

@@ -1,180 +0,0 @@
-"""Update repositories with fancy output"""
-
-import git
-from pathlib import Path
-from machineconfig.scripts.python.repos_helper_update import RepositoryUpdateResult, run_uv_sync, update_repository
-from machineconfig.utils.path_extended import PathExtended as PathExtended
-from machineconfig.utils.source_of_truth import DEFAULTS_PATH
-from machineconfig.utils.io import read_ini
-
-
-def _display_summary(results: list[RepositoryUpdateResult]) -> None:
-    """Display a comprehensive summary of all repository update operations."""
-    print("\n" + "=" * 80)
-    print("📊 REPOSITORY UPDATE SUMMARY")
-    print("=" * 80)
-
-    # Calculate statistics
-    total_repos = len(results)
-    successful_repos = sum(1 for r in results if r["status"] == "success")
-    error_repos = sum(1 for r in results if r["status"] == "error")
-    skipped_repos = sum(1 for r in results if r["status"] == "skipped")
-    auth_failed_repos = sum(1 for r in results if r["status"] == "auth_failed")
-
-    repos_with_changes = sum(1 for r in results if r["commits_changed"])
-    repos_with_uncommitted = sum(1 for r in results if r["had_uncommitted_changes"])
-    repos_with_dep_changes = sum(1 for r in results if r["dependencies_changed"])
-    uv_sync_runs = sum(1 for r in results if r["uv_sync_ran"])
-    uv_sync_successes = sum(1 for r in results if r["uv_sync_ran"] and r["uv_sync_success"])
-
-    # Overview statistics
-    print("📈 OVERVIEW:")
-    print(f"   Total repositories processed: {total_repos}")
-    print(f"   ✅ Successful updates: {successful_repos}")
-    print(f"   ❌ Failed updates: {error_repos}")
-    print(f"   ⏭️  Skipped: {skipped_repos}")
-    if auth_failed_repos > 0:
-        print(f"   🔐 Authentication failed: {auth_failed_repos}")
-    print()
-
-    print("🔄 CHANGES:")
-    print(f"   Repositories with new commits: {repos_with_changes}")
-    print(f"   Repositories with dependency changes: {repos_with_dep_changes}")
-    print(f"   Repositories with uncommitted changes: {repos_with_uncommitted}")
-    print()
-
-    print("📦 UV SYNC:")
-    print(f"   uv sync operations attempted: {uv_sync_runs}")
-    print(f"   uv sync operations successful: {uv_sync_successes}")
-    if uv_sync_runs > uv_sync_successes:
-        print(f"   uv sync operations failed: {uv_sync_runs - uv_sync_successes}")
-    print()
-
-    # Detailed results per repository
-    print("📋 DETAILED RESULTS:")
-    for result in results:
-        repo_name = Path(result["repo_path"]).name
-        status_icon = {"success": "✅", "error": "❌", "skipped": "⏭️", "auth_failed": "🔐"}.get(result["status"], "❓")
-        print(f"   {status_icon} {repo_name}")
-
-        if result["status"] == "error" and result["error_message"]:
-            print(f"      💥 Error: {result['error_message']}")
-
-        if result["commits_changed"]:
-            print(f"      🔄 Updated: {result['commit_before'][:8]} → {result['commit_after'][:8]}")
-        elif result["status"] == "success":
-            print("      📍 Already up to date")
-
-        if result["had_uncommitted_changes"]:
-            files_str = ", ".join(result["uncommitted_files"])
-            print(f"      ⚠️  Had uncommitted changes: {files_str}")
-
-        if result["dependencies_changed"]:
-            changes = []
-            if result["pyproject_changed"]:
-                changes.append("pyproject.toml")
-            print(f"      📋 Dependencies changed: {', '.join(changes)}")
-
-        if result["uv_sync_ran"]:
-            sync_status = "✅" if result["uv_sync_success"] else "❌"
-            print(f"      📦 uv sync: {sync_status}")
-
-        if result["is_machineconfig_repo"] and result["permissions_updated"]:
-            print("      🛠  Updated permissions for machineconfig files")
-
-        if result["remotes_processed"]:
-            print(f"      📡 Processed remotes: {', '.join(result['remotes_processed'])}")
-        if result["remotes_skipped"]:
-            print(f"      ⏭️  Skipped remotes: {', '.join(result['remotes_skipped'])}")
-
-    print("\n" + "=" * 80)
-
-    # Final status
-    if error_repos == 0 and auth_failed_repos == 0:
-        print("🎉 All repositories processed successfully!")
-    elif successful_repos > 0:
-        print(f"⚠️  {successful_repos}/{total_repos} repositories processed successfully")
-    else:
-        print("❌ No repositories were successfully processed")
-    print("=" * 80)
-
-
-def main(verbose: bool = True, allow_password_prompt: bool = False) -> None:
-    """Main function to update all configured repositories."""
-    _ = verbose
-    repos: list[PathExtended] = [PathExtended.home() / "code/machineconfig", PathExtended.home() / "code/crocodile"]
-    try:
-        tmp = read_ini(DEFAULTS_PATH)["general"]["repos"].split(",")
-        if tmp[-1] == "":
-            tmp = tmp[:-1]
-        for item in tmp:
-            item_obj = PathExtended(item).expanduser()
-            if item_obj not in repos:
-                repos.append(item_obj)
-    except (FileNotFoundError, KeyError, IndexError):
-        print(f"""
-┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┃ 🚫 Configuration Error: Missing {DEFAULTS_PATH} or section [general] or key repos
-┃ ℹ️  Using default repositories instead
-┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-        print("""
-┌────────────────────────────────────────────────────────────────
-│ ✨ Example Configuration:
-│
-│ [general]
-│ repos = ~/code/repo1,~/code/repo2
-│ rclone_config_name = onedrivePersonal
-│ email_config_name = Yahoo3
-│ to_email = myemail@email.com
-└────────────────────────────────────────────────────────────────""")
-
-    # Process repositories
-    results: list[RepositoryUpdateResult] = []
-    repos_with_changes = []
-
-    for expanded_path in repos:
-        try:
-            repo = git.Repo(str(expanded_path), search_parent_directories=True)
-            # Update repository and get detailed results
-            result = update_repository(repo, allow_password_prompt=allow_password_prompt, auto_sync=True)
-            results.append(result)
-
-            # Keep track of repos with dependency changes for additional uv sync
-            if result["dependencies_changed"] and not result["uv_sync_ran"]:
-                repos_with_changes.append(Path(repo.working_dir))
-
-        except Exception as ex:
-            # Create a result for failed repos
-            error_result: RepositoryUpdateResult = {
-                "repo_path": str(expanded_path),
-                "status": "error",
-                "had_uncommitted_changes": False,
-                "uncommitted_files": [],
-                "commit_before": "",
-                "commit_after": "",
-                "commits_changed": False,
-                "pyproject_changed": False,
-                "dependencies_changed": False,
-                "uv_sync_ran": False,
-                "uv_sync_success": False,
-                "remotes_processed": [],
-                "remotes_skipped": [],
-                "error_message": str(ex),
-                "is_machineconfig_repo": False,
-                "permissions_updated": False,
-            }
-            results.append(error_result)
-            print(f"""❌ Repository Error: Path: {expanded_path}
-Exception: {ex}
-{"-" * 50}""")
-
-    # Run uv sync for repositories where pyproject.toml changed but sync wasn't run yet
-    for repo_path in repos_with_changes:
-        run_uv_sync(repo_path)
-
-    # Generate and display summary
-    _display_summary(results)
-
-
-if __name__ == "__main__":
-    main()

machineconfig/scripts/python/dotfile.py

@@ -1,52 +0,0 @@
-"""Like yadm and dotter."""
-
-from machineconfig.utils.path_extended import PathExtended as PathExtended
-from machineconfig.utils.links import symlink_func
-from machineconfig.utils.source_of_truth import LIBRARY_ROOT, REPO_ROOT
-import argparse
-
-
-def main():
-    parser = argparse.ArgumentParser(description="FTP client")
-
-    parser.add_argument("file", help="file/folder path.", default="")
-    # FLAGS
-    parser.add_argument("--overwrite", "-o", help="Overwrite.", action="store_true")  # default is False
-    # optional
-    parser.add_argument("-d", "--dest", help="destination folder", default="")
-
-    args = parser.parse_args()
-    orig_path = PathExtended(args.file).expanduser().absolute()
-    if args.dest == "":
-        if "Local" in str(orig_path):
-            junction = orig_path.split(at="Local", sep=-1)[1]
-        elif "Roaming" in str(orig_path):
-            junction = orig_path.split(at="Roaming", sep=-1)[1]
-        elif ".config" in str(orig_path):
-            junction = orig_path.split(at=".config", sep=-1)[1]
-        else:
-            junction = orig_path.rel2home()
-        new_path = PathExtended(REPO_ROOT).joinpath(junction)
-    else:
-        dest_path = PathExtended(args.dest).expanduser().absolute()
-        dest_path.mkdir(parents=True, exist_ok=True)
-        new_path = dest_path.joinpath(orig_path.name)
-
-    symlink_func(this=orig_path, to_this=new_path, prioritize_to_this=args.overwrite)
-
-    print("""
-┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┃ ✅ Symbolic Link Created Successfully
-┃
-┃ 🔄 To enshrine this mapping, add the following to mapper.toml:
-┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-    print(f"""
-📝 Edit configuration file: nano {PathExtended(LIBRARY_ROOT)}/symlinks/mapper.toml
-
-[{new_path.parent.name}]
-{orig_path.name.split(".")[0]} = {{ this = '{orig_path.collapseuser().as_posix()}', to_this = '{new_path.collapseuser().as_posix()}' }}
-""")
-
-
-if __name__ == "__main__":
-    main()

machineconfig/scripts/python/fire_agents.py

@@ -1,176 +0,0 @@
-"""Utility to launch 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, get_args, Iterable, TypeAlias, Literal
-import json
-import sys
-
-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, 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"]
-
-
-def _write_list_file(target: Path, files: Iterable[Path]) -> None:
-    target.parent.mkdir(parents=True, exist_ok=True)
-    target.write_text("\n".join(str(f) for f in files), encoding="utf-8")
-
-
-def get_prompt_material(search_strategy: SEARCH_STRATEGIES, repo_root: Path) -> tuple[Path, str]:
-    if search_strategy == "file_path":
-        file_path_input = input("Enter path to target file: ").strip()
-        if not file_path_input:
-            print("No file path provided. Exiting.")
-            sys.exit(1)
-        target_file_path = Path(file_path_input).expanduser().resolve()
-        if not target_file_path.exists() or not target_file_path.is_file():
-            print(f"Invalid file path: {target_file_path}")
-            sys.exit(1)
-        separator = input("Enter separator [\\n]: ").strip() or "\n"
-    elif search_strategy == "keyword_search":
-        keyword = input("Enter keyword to search recursively for all .py files containing it: ").strip()
-        if not keyword:
-            print("No keyword supplied. Exiting.")
-            sys.exit(1)
-        matching_files = search_python_files(repo_root, keyword)
-        if not matching_files:
-            print(f"💥 No .py files found containing keyword: {keyword}")
-            sys.exit(1)
-        for idx, mf in enumerate(matching_files):
-            print(f"{idx:>3}: {mf}")
-        print(f"\nFound {len(matching_files)} .py files containing keyword: {keyword}")
-        target_file_path = repo_root / ".ai" / "target_file.txt"
-        _write_list_file(target_file_path, matching_files)
-        separator = "\n"
-    elif search_strategy == "filename_pattern":
-        pattern = input("Enter filename pattern (e.g., '*.py', '*test*', 'config.*'): ").strip()
-        if not pattern:
-            print("No pattern supplied. Exiting.")
-            sys.exit(1)
-        matching_files = search_files_by_pattern(repo_root, pattern)
-        if not matching_files:
-            print(f"💥 No files found matching pattern: {pattern}")
-            sys.exit(1)
-        for idx, mf in enumerate(matching_files):
-            print(f"{idx:>3}: {mf}")
-        print(f"\nFound {len(matching_files)} files matching pattern: {pattern}")
-        target_file_path = repo_root / ".ai" / "target_file.txt"
-        _write_list_file(target_file_path, matching_files)
-        separator = "\n"
-    else:
-        raise ValueError(f"Unknown search strategy: {search_strategy}")
-    return target_file_path, separator
-
-
-def main():  # noqa: C901 - (complexity acceptable for CLI glue)
-    repo_root = get_repo_root(Path.cwd())
-    if repo_root is None:
-        print("💥 Could not determine the repository root. Please run this script from within a git repository.")
-        sys.exit(1)
-    print(f"Operating @ {repo_root}")
-
-    search_strategy = cast(SEARCH_STRATEGIES, choose_from_options(multi=False, msg="Choose one option", header="Choose search strategy:", options=get_args(SEARCH_STRATEGIES)))
-    splitting_strategy = cast(SPLITTING_STRATEGY, choose_from_options(multi=False, msg="Choose one option", header="Choose prompt splitting strategy:", options=get_args(SPLITTING_STRATEGY)))
-    agent_selected = cast(AGENTS, choose_from_options(multi=False, msg="Choose one option", header="Select agent type", options=get_args(AGENTS)))
-    print("Enter prefix prompt (end with Ctrl-D / Ctrl-Z):")
-    prompt_prefix = "\n".join(sys.stdin.readlines())
-    job_name = input("Enter job name [AI_AGENTS]: ") or "AI_Agents"
-    keep_material_in_separate_file_input = input("Keep prompt material in separate file? [y/N]: ").strip().lower() == "y"
-
-    prompt_material_path, separator = get_prompt_material(search_strategy=search_strategy, repo_root=repo_root)
-    match splitting_strategy:
-        case "agent_cap":
-            agent_cap_input = input(f"Enter maximum number of agents/splits [default: {DEFAULT_AGENT_CAP}]: ").strip()
-            agent_cap = int(agent_cap_input) if agent_cap_input else DEFAULT_AGENT_CAP
-            task_rows = None
-        case "task_rows":
-            task_rows_input: str = input("Enter number of rows/tasks per agent [13]: ").strip() or "13"
-            task_rows = int(task_rows_input)
-            agent_cap = None
-    prompt_material_re_splitted = chunk_prompts(prompt_material_path, splitting_strategy, agent_cap=agent_cap, task_rows=task_rows, joiner=separator)
-
-    agents_dir = prep_agent_launch(repo_root=repo_root, prompts_material=prompt_material_re_splitted, keep_material_in_separate_file=keep_material_in_separate_file_input, prompt_prefix=prompt_prefix, agent=agent_selected, job_name=job_name)
-    layoutfile = get_agents_launch_layout(session_root=agents_dir)
-
-    regenerate_py_code = f"""
-#!/usr/bin/env uv run --python 3.13 --with machineconfig
-#!/usr/bin/env uv run --project $HOME/code/machineconfig
-
-from machineconfig.scripts.python.fire_agents import *
-
-repo_root = Path("{repo_root}")
-search_strategy = "{search_strategy}"
-splitting_strategy = "{splitting_strategy}"
-agent_selected = "{agent_selected}"
-prompt_prefix = '''{prompt_prefix}'''
-job_name = "{job_name}"
-keep_material_in_separate_file_input = {keep_material_in_separate_file_input}
-separator = "{separator}"
-prompt_material_path = Path("{prompt_material_path}")
-agent_cap = {agent_cap}
-task_rows = {task_rows}
-
-prompt_material_re_splitted = chunk_prompts(prompt_material_path, splitting_strategy, agent_cap=agent_cap, task_rows=task_rows, joiner=separator)
-agents_dir = prep_agent_launch(repo_root=repo_root, prompts_material=prompt_material_re_splitted, keep_material_in_separate_file=keep_material_in_separate_file_input, prompt_prefix=prompt_prefix, agent=agent_selected, job_name=job_name)
-layout = get_agents_launch_layout(session_root=agents_dir)
-
-(agents_dir / "aa_agents_relaunch.py").write_text(data=regenerate_py_code, encoding="utf-8")
-(agents_dir / "layout.json").write_text(data=json.dumps(layout, indent=2), encoding="utf-8")
-
-if len(layout["layoutTabs"]) > 25:
-    print("Too many agents (>25) to launch. Skipping launch.")
-    sys.exit(0)
-manager = ZellijLocalManager(session_layouts=[layout])
-manager.start_all_sessions()
-manager.run_monitoring_routine()
-
-"""
-    (agents_dir / "aa_agents_relaunch.py").write_text(data=regenerate_py_code, encoding="utf-8")
-    (agents_dir / "layout.json").write_text(data=json.dumps(layoutfile, indent=2), encoding="utf-8")
-
-    MAX_TABS = 10
-    if len(layoutfile["layouts"][0]["layoutTabs"]) > MAX_TABS:
-        print(f"Too many tabs (>{MAX_TABS}) to launch. Skipping launch.")
-        sys.exit(0)
-    from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
-
-    manager = ZellijLocalManager(session_layouts=layoutfile["layouts"])
-    manager.start_all_sessions(poll_interval=2, poll_seconds=2)
-    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
-    from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
-
-    for idx, layout_tabs_chunk in enumerate(split(layout_tabs, every=every)):
-        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
-    from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
-
-    for _idx, layout_chunk in enumerate(split(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()