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

machineconfig/scripts/python/fire_agents_help_launch.py

@@ -1,143 +0,0 @@
-from machineconfig.utils.accessories import randstr
-
-import random
-import shlex
-from pathlib import Path
-from typing import Literal, TypeAlias
-
-
-AGENTS: TypeAlias = Literal[
-    "cursor-agent", "gemini", "crush", "q", "onlyPrepPromptFiles"
-    # warp terminal
-]
-AGENT_NAME_FORMATTER = "agent_{idx}_cmd.sh"  # e.g., agent_0_cmd.sh
-
-
-def get_gemini_api_keys() -> list[str]:
-    from machineconfig.utils.io import read_ini
-
-    config = read_ini(Path.home().joinpath("dotfiles/creds/llm/gemini/api_keys.ini"))
-    res: list[str] = []
-    for a_section_name in list(config.sections()):
-        a_section = config[a_section_name]
-        if "api_key" in a_section:
-            api_key = a_section["api_key"].strip()
-            if api_key:
-                res.append(api_key)
-    print(f"Found {len(res)} Gemini API keys configured.")
-    return res
-
-
-def prep_agent_launch(repo_root: Path, prompts_material: list[str], prompt_prefix: str, keep_material_in_separate_file: bool, agent: AGENTS, *, job_name: str) -> Path:
-    session_root = repo_root / ".ai" / f"tmp_prompts/{job_name}_{randstr()}"
-    session_root.mkdir(parents=True, exist_ok=True)
-    prompt_folder = session_root / "prompts"
-    prompt_folder.mkdir(parents=True, exist_ok=True)
-
-    all_materials_scripts: list[Path] = []
-    for idx, a_prompt_material in enumerate(prompts_material):
-        prompt_root = prompt_folder / f"agent_{idx}"
-        prompt_root.mkdir(parents=True, exist_ok=True)
-        prompt_path = prompt_root / f"agent_{idx}_prompt.txt"
-        if keep_material_in_separate_file:
-            prompt_material_path = prompt_root / f"agent_{idx}_material.txt"
-            prompt_material_path.write_text(a_prompt_material, encoding="utf-8")
-            prompt_path.write_text(prompt_prefix + f"""\nPlease only look @ {prompt_material_path}. You don't need to do any other work beside the content of this material file.""", encoding="utf-8")
-            all_materials_scripts.append(prompt_material_path)
-        else:
-            prompt_material_path = prompt_path
-            prompt_path.write_text(prompt_prefix + """\nPlease only look @ the following:\n""" + a_prompt_material, encoding="utf-8")
-
-        agent_cmd_launch_path = prompt_root / AGENT_NAME_FORMATTER.format(idx=idx)  # e.g., agent_0_cmd.sh
-        random_sleep_time = random.uniform(0, 5)
-        cmd_prefix = f"""
-#!/usr/bin/env bash
-
-# AGENT-{idx}-LAUNCH-SCRIPT
-# Auto-generated by fire_agents.py
-
-export FIRE_AGENTS_AGENT_NAME="{agent}"
-export FIRE_AGENTS_JOB_NAME="{job_name}"
-export FIRE_AGENTS_PROMPT_FILE="{prompt_path}"
-export FIRE_AGENTS_MATERIAL_FILE="{prompt_material_path}"
-export FIRE_AGENTS_AGENT_LAUNCHER="{agent_cmd_launch_path}"
-
-echo "Sleeping for {random_sleep_time:.2f} seconds to stagger agent startups..."
-sleep {random_sleep_time:.2f}
-echo "Launching agent {agent} with prompt from {prompt_path}"
-echo "Launching agent {agent} with command from {agent_cmd_launch_path}"
-echo "--------START OF AGENT OUTPUT--------"
-sleep 0.1
-
-"""
-        match agent:
-            case "gemini":
-                model = "gemini-2.5-pro"
-                # model = "gemini-2.5-flash-lite"
-                # model = None  # auto-select
-                # if model is None:
-                #     model_arg = ""
-                # else:
-                model_arg = f"--model {shlex.quote(model)}"
-                # Need a real shell for the pipeline; otherwise '| gemini ...' is passed as args to 'cat'
-                safe_path = shlex.quote(str(prompt_path))
-                api_keys = get_gemini_api_keys()
-                api_key = api_keys[idx % len(api_keys)] if api_keys else ""
-                # Export the environment variable so it's available to subshells
-                cmd = f"""
-export GEMINI_API_KEY={shlex.quote(api_key)}
-echo "Using Gemini API key $GEMINI_API_KEY"
-bash -lc 'cat {safe_path} | gemini {model_arg} --yolo --prompt'
-"""
-            case "cursor-agent":
-                # As originally implemented
-                cmd = f"""
-
-cursor-agent --print --output-format text < {prompt_path}
-
-"""
-            case "crush":
-                cmd = f"""
-crush run {prompt_path}
-"""
-            case "q":
-                cmd = f"""
-q chat --no-interactive --trust-all-tools {prompt_path}
-"""
-            case "onlyPrepPromptFiles":
-                cmd = f"""
-echo "Prepared prompt file at {prompt_path}"
-"""
-            case _:
-                raise ValueError(f"Unsupported agent type: {agent}")
-        cmd_postfix = """
-sleep 0.1
-echo "---------END OF AGENT OUTPUT---------"
-"""
-        agent_cmd_launch_path.write_text(cmd_prefix + cmd + cmd_postfix, encoding="utf-8")
-
-    # print(f"Launching a template with #{len(tab_config)} agents")
-    if len(all_materials_scripts) > 0:
-        all_materials_list_path = session_root / "all_materials_redistributed.txt"
-        all_materials_list_path.write_text("\n".join(str(p) for p in all_materials_scripts), encoding="utf-8")
-        print(f"All prompt materials listed @ {all_materials_list_path}")
-    return session_root
-
-
-def get_agents_launch_layout(session_root: Path):
-    from machineconfig.utils.schemas.layouts.layout_types import TabConfig, LayoutConfig, LayoutsFile
-
-    tab_config: list[TabConfig] = []
-    prompt_root = session_root / "prompts"
-    all_dirs_under_prompts = [d for d in prompt_root.iterdir() if d.is_dir()]
-    launch_agents_squentially = ""
-    for a_prompt_dir in all_dirs_under_prompts:
-        idx = a_prompt_dir.name.split("_")[-1]  # e.g., agent_0 -> 0
-        agent_cmd_path = a_prompt_dir / AGENT_NAME_FORMATTER.format(idx=idx)
-        fire_cmd = f"bash {shlex.quote(str(agent_cmd_path))}"
-        tab_config.append(TabConfig(tabName=f"Agent{idx}", startDir=str(session_root.parent.parent.parent), command=fire_cmd))
-        launch_agents_squentially += f". {shlex.quote(str(agent_cmd_path))}\n"
-    layout = LayoutConfig(layoutName="Agents", layoutTabs=tab_config)
-    (session_root / "launch_all_agents_sequentially.sh").write_text(launch_agents_squentially, encoding="utf-8")
-    layouts_file: LayoutsFile = LayoutsFile(version="1.0", layouts=[layout])
-    return layouts_file

machineconfig/scripts/python/fire_agents_load_balancer.py

@@ -1,50 +0,0 @@
-from typing import Literal, TypeAlias
-from math import ceil
-from pathlib import Path
-
-
-SPLITTING_STRATEGY: TypeAlias = Literal[
-    "agent_cap",  # User decides number of agents, rows/tasks determined automatically
-    "task_rows",  # User decides number of rows/tasks, number of agents determined automatically
-]
-DEFAULT_AGENT_CAP = 6
-
-
-def chunk_prompts(prompt_material_path: Path, strategy: SPLITTING_STRATEGY, joiner: str, *, agent_cap: int | None, task_rows: int | None) -> list[str]:
-    """Chunk prompts based on splitting strategy.
-
-    Args:
-        prompts: List of prompts to chunk
-        strategy: Either 'agent_cap' or 'task_rows'
-        agent_cap: Maximum number of agents (used with 'agent_cap' strategy)
-        task_rows: Number of rows/tasks per agent (used with 'task_rows' strategy)
-    """
-    prompts = [p for p in prompt_material_path.read_text(encoding="utf-8", errors="ignore").split(joiner) if p.strip() != ""]  # drop blank entries
-
-    if strategy == "agent_cap":
-        if agent_cap is None:
-            raise ValueError("agent_cap must be provided when using 'agent_cap' strategy")
-
-        if len(prompts) <= agent_cap:
-            return prompts
-
-        print(f"Chunking {len(prompts)} prompts into groups for up to {agent_cap} agents because it exceeds the cap.")
-        chunk_size = ceil(len(prompts) / agent_cap)
-        grouped: list[str] = []
-        for i in range(0, len(prompts), chunk_size):
-            grouped.append(joiner.join(prompts[i : i + chunk_size]))
-        return grouped
-
-    elif strategy == "task_rows":
-        if task_rows is None:
-            raise ValueError("task_rows must be provided when using 'task_rows' strategy")
-        if task_rows >= len(prompts):
-            return prompts
-        print(f"Chunking {len(prompts)} prompts into groups of {task_rows} rows/tasks each.")
-        grouped: list[str] = []
-        for i in range(0, len(prompts), task_rows):
-            grouped.append(joiner.join(prompts[i : i + task_rows]))
-        return grouped
-
-    else:
-        raise ValueError(f"Unknown splitting strategy: {strategy}")

machineconfig/scripts/python/fire_jobs_args_helper.py

@@ -1,84 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional
-import argparse
-
-
-@dataclass
-class FireJobArgs:
-    """Type-safe dataclass for fire_jobs command line arguments."""
-
-    path: str = "."
-    function: Optional[str] = None
-    ve: str = ""
-    cmd: bool = False
-    interactive: bool = False
-    debug: bool = False
-    choose_function: bool = False
-    loop: bool = False
-    jupyter: bool = False
-    submit_to_cloud: bool = False
-    remote: bool = False
-    module: bool = False
-    streamlit: bool = False
-    environment: str = ""
-    holdDirectory: bool = False
-    PathExport: bool = False
-    git_pull: bool = False
-    optimized: bool = False
-    Nprocess: int = 1
-    zellij_tab: Optional[str] = None
-    watch: bool = False
-    kw: Optional[list[str]] = None
-    layout: bool = False
-
-
-def get_args() -> FireJobArgs:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("path", nargs="?", type=str, help="The directory containing the jobs", default=".")
-    parser.add_argument("function", nargs="?", type=str, help="Fuction to run", default=None)
-    parser.add_argument("--ve", "-v", type=str, help="virtual enviroment name", default="")
-    parser.add_argument("--cmd", "-B", action="store_true", help="Create a cmd fire command to launch the the job asynchronously.")
-    parser.add_argument("--interactive", "-i", action="store_true", help="Whether to run the job interactively using IPython")
-    parser.add_argument("--debug", "-d", action="store_true", help="debug")
-    parser.add_argument("--choose_function", "-c", action="store_true", help="debug")
-    parser.add_argument("--loop", "-l", action="store_true", help="infinite recusion (runs again after completion/interruption)")
-    parser.add_argument("--jupyter", "-j", action="store_true", help="open in a jupyter notebook")
-    parser.add_argument("--submit_to_cloud", "-C", action="store_true", help="submit to cloud compute")
-    parser.add_argument("--remote", "-r", action="store_true", help="launch on a remote machine")
-    parser.add_argument("--module", "-m", action="store_true", help="launch the main file")
-    parser.add_argument("--streamlit", "-S", action="store_true", help="run as streamlit app")
-    parser.add_argument("--environment", "-E", type=str, help="Choose ip, localhost, hostname or arbitrary url", default="")
-    parser.add_argument("--holdDirectory", "-D", action="store_true", help="hold current directory and avoid cd'ing to the script directory")
-    parser.add_argument("--PathExport", "-P", action="store_true", help="augment the PYTHONPATH with repo root.")
-    parser.add_argument("--git_pull", "-g", action="store_true", help="Start by pulling the git repo")
-    parser.add_argument("--optimized", "-O", action="store_true", help="Run the optimized version of the function")
-    parser.add_argument("--Nprocess", "-p", type=int, help="Number of processes to use", default=1)
-    parser.add_argument("--zellij_tab", "-z", type=str, dest="zellij_tab", help="open in a new zellij tab")
-    parser.add_argument("--watch", "-w", action="store_true", help="watch the file for changes")
-    parser.add_argument("--kw", nargs="*", default=None, help="keyword arguments to pass to the function in the form of k1 v1 k2 v2 ... (meaning k1=v1, k2=v2, etc)")
-    parser.add_argument("--layout", "-L", action="store_true", help="use layout configuration (Zellij Or WindowsTerminal)")
-
-    try:
-        args_raw = parser.parse_args()
-    except Exception as ex:
-        print(f"❌ Failed to parse arguments: {ex}")
-        parser.print_help()
-        raise ex
-    args = FireJobArgs(**vars(args_raw))
-    return args
-
-
-def extract_kwargs(args: FireJobArgs) -> dict[str, object]:
-    str2obj = {"True": True, "False": False, "None": None}
-    if args.kw is not None:
-        assert len(args.kw) % 2 == 0, f"args.kw must be a list of even length. Got {len(args.kw)}"
-        kwargs = dict(zip(args.kw[::2], args.kw[1::2]))
-        kwargs: dict[str, object]
-        for key, value in kwargs.items():
-            if value in str2obj:
-                kwargs[key] = str2obj[str(value)]
-        if args.function is None:  # if user passed arguments and forgot to pass function, then assume they want to run the main function.
-            args.choose_function = True
-    else:
-        kwargs = {}
-    return kwargs

machineconfig/scripts/python/fire_jobs_layout_helper.py

@@ -1,66 +0,0 @@
-from pathlib import Path
-from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig, LayoutsFile
-from typing import Optional, TYPE_CHECKING
-from machineconfig.scripts.python.helpers.helpers4 import search_for_files_of_interest
-from machineconfig.utils.options import choose_from_options
-from machineconfig.utils.path_helper import match_file_name, sanitize_path
-from machineconfig.utils.path_extended import PathExtended as PathExtended
-
-if TYPE_CHECKING:
-    from machineconfig.scripts.python.fire_jobs_args_helper import FireJobArgs
-
-
-def select_layout(layouts_json_file: Path, layout_name: Optional[str]):
-    import json
-
-    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 layout_name is None:
-        options = [layout["layoutName"] for layout in layout_file["layouts"]]
-        from machineconfig.utils.options import choose_from_options
-
-        layout_name = choose_from_options(multi=False, options=options, prompt="Choose a layout configuration:", fzf=True, msg="Choose one option")
-    print(f"Selected layout: {layout_name}")
-    layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"] == layout_name), None)
-    if layout_chosen is None:
-        layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"].lower() == layout_name.lower()), None)
-    if layout_chosen is None:
-        available_layouts = [layout["layoutName"] for layout in layout_file["layouts"]]
-        raise ValueError(f"Layout '{layout_name}' not found. Available layouts: {available_layouts}")
-    return layout_chosen
-
-
-def launch_layout(layout_config: LayoutConfig) -> Optional[Exception]:
-    import platform
-
-    if platform.system() == "Linux" or platform.system() == "Darwin":
-        print("🧑‍💻 Launching layout using Zellij terminal multiplexer...")
-        from machineconfig.cluster.sessions_managers.zellij_local import run_zellij_layout
-
-        run_zellij_layout(layout_config=layout_config)
-    elif platform.system() == "Windows":
-        print("🧑‍💻 Launching layout using Windows Terminal...")
-        from machineconfig.cluster.sessions_managers.wt_local import run_wt_layout
-
-        run_wt_layout(layout_config=layout_config)
-    else:
-        print(f"❌ Unsupported platform: {platform.system()}")
-    return None
-
-
-def handle_layout_args(args: "FireJobArgs") -> None:
-    # args.function = args.path
-    # args.path = "layout.json"
-    path_obj = sanitize_path(args.path)
-    if not path_obj.exists():
-        choice_file = match_file_name(sub_string=args.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
-    launch_layout(layout_config=select_layout(layouts_json_file=choice_file, layout_name=args.function))

machineconfig/scripts/python/get_zellij_cmd.py

@@ -1,15 +0,0 @@
-from pathlib import Path
-
-
-def get_zellij_cmd(wd1: Path, wd2: Path) -> str:
-    _ = wd1, wd2
-    lines = [
-        """ zellij action new-tab --name gitdiff""",
-        """zellij action new-pane --direction down --name local --cwd ./data """,
-        """zellij action write-chars "cd '{wd1}'; git status" """,
-        """zellij action move-focus up; zellij action close-pane """,
-        """zellij action new-pane --direction down --name remote --cwd code """,
-        """zellij action write-chars "cd '{wd2}' """,
-        """git status" """,
-    ]
-    return "; ".join(lines)

machineconfig/scripts/python/gh_models.py

@@ -1,104 +0,0 @@
-# # as per https://github.com/marketplace/models/azure-openai/o1-preview
-# from openai import OpenAI
-# from machineconfig.utils.path_reduced import P as PathExtended
-# from machineconfig.utils.utils2 import read_ini
-# from rich import print as rprint
-# from rich.panel import Panel
-# from typing import Any
-
-
-# gh_token = read_ini(PathExtended.home().joinpath("dotfiles/creds/git/git_host_tokens.ini"))['thisismygitrepo']['newLongterm']
-# endpoint = "https://models.inference.ai.azure.com"
-# model_name_preferences = ["o3-mini", "o1-preview", "o1-mini", "GPT-4o", "GPT-4-o-mini"]
-# client__ = OpenAI(
-#     base_url=endpoint,
-#     api_key=gh_token,
-# )
-
-
-# def get_response(client: Any, model_name: str, messages: list[dict[str, str]]):
-#     print(f"""
-# ┌────────────────────────────────────────────────────────────────
-# │ 🤖 Querying Model: {model_name}
-# │    Sending request to API...
-# └────────────────────────────────────────────────────────────────""")
-#     try:
-#         response = client.chat.completions.create(
-#             messages=messages,
-#             model=model_name
-#         )
-#         return response.choices
-#     except Exception as e:
-#         print(f"""
-# ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-# ┃ ❌ API Error with model {model_name}
-# ┃    {str(e)}
-# ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-#         return None
-
-
-# def interactive_chat():
-#     conversation_history = []
-#     model_index = 0
-#     model_name = model_name_preferences[model_index]
-
-#     print("""
-# ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-# ┃ 🚀 Interactive Chat Started
-# ┃    Type your message and press Enter to chat
-# ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-
-#     while True:
-#         header = f" 🤖 Using Model: {model_name} "
-#         print(f"\n{header.center(80, '═')}\n")
-
-#         while True:
-#             try:
-#                 user_input = input("💬 You: ")
-#                 conversation_history.append({"role": "user", "content": user_input})
-
-#                 while True:
-#                     choices = get_response(client__, model_name, conversation_history)
-#                     if choices is None:
-#                         model_index += 1
-#                         model_name = model_name_preferences[model_index % len(model_name_preferences)]
-#                         print(f"""
-# ┌────────────────────────────────────────────────────────────────
-# │ 🔄 Model Switch
-# │    Now using: {model_name}
-# └────────────────────────────────────────────────────────────────""")
-#                         continue
-#                     else:
-#                         break
-
-#                 for a_choice in choices:
-#                     response_content = a_choice.message.content
-#                     print("\n" * 2)
-#                     try:
-#                         rprint(Panel(
-#                             f"{response_content}",
-#                             title=f"🤖 AI ({model_name})",
-#                             border_style="blue"
-#                         ))
-#                     except Exception:
-#                         # Fallback if rich formatting fails
-#                         print(f"""
-# ┌────────────────────────────────────────────────────────────────
-# │ 🤖 AI ({model_name}):
-# │
-# {response_content}
-# └────────────────────────────────────────────────────────────────""")
-
-#                     conversation_history.append({"role": "assistant", "content": response_content})
-#                     print("\n")
-#             except KeyboardInterrupt:
-#                 print("""
-# ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-# ┃ 👋 Chat Session Ended
-# ┃    Thank you for using the interactive chat!
-# ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-#                 return
-
-
-# if __name__ == "__main__":
-#     interactive_chat()

machineconfig/scripts/python/helpers/repo_sync_helpers.py

@@ -1,114 +0,0 @@
-from machineconfig.utils.path_extended import PathExtended as PathExtended
-from machineconfig.utils.terminal import Terminal
-from machineconfig.scripts.python.get_zellij_cmd import get_zellij_cmd
-from machineconfig.utils.source_of_truth import CONFIG_PATH, DEFAULTS_PATH
-from machineconfig.utils.io import read_ini
-from machineconfig.utils.code import write_shell_script_to_file
-import platform
-from rich.console import Console
-from rich.panel import Panel
-
-console = Console()
-
-
-def delete_remote_repo_copy_and_push_local(remote_repo: str, local_repo: str, cloud: str):
-    console.print(Panel("🗑️  Deleting remote repo copy and pushing local copy", title="[bold blue]Repo Sync[/bold blue]", border_style="blue"))
-    repo_sync_root = PathExtended(remote_repo).expanduser().absolute()
-    repo_root_path = PathExtended(local_repo).expanduser().absolute()
-    repo_sync_root.delete(sure=True)
-    print("🧹 Removed temporary remote copy")
-    from git.remote import Remote
-    from git.repo import Repo
-
-    try:
-        Remote.remove(Repo(repo_root_path), "originEnc")
-        console.print(Panel("🔗 Removed originEnc remote reference", border_style="blue"))
-    except Exception:
-        pass  # type: ignore
-    console.print(Panel("📈 Deleting remote repository copy and pushing local changes", width=150, border_style="blue"))
-
-    repo_root_path.to_cloud(cloud=cloud, zip=True, encrypt=True, rel2home=True, os_specific=False)
-
-    console.print(Panel("✅ Repository successfully pushed to cloud", title="[bold green]Repo Sync[/bold green]", border_style="green"))
-
-
-# import sys
-# import subprocess
-
-
-def get_wt_cmd(wd1: PathExtended, wd2: PathExtended) -> str:
-    lines = [
-        f"""wt --window 0 new-tab --profile pwsh --title "gitdiff" --tabColor `#3b04d1 --startingDirectory {wd1} ` --colorScheme "Solarized Dark" """,
-        f"""split-pane --horizontal --profile pwsh --startingDirectory {wd2} --size 0.5 --colorScheme "Tango Dark" -- pwsh -Interactive """,
-    ]
-    return " `; ".join(lines)
-
-
-def inspect_repos(repo_local_root: str, repo_remote_root: str):
-    console.print(Panel(f"📂 Local:  {repo_local_root}\n📂 Remote: {repo_remote_root}", title="[bold blue]🔍 Inspecting Repositories[/bold blue]", border_style="blue"))
-
-    if platform.system() == "Windows":
-        program = get_wt_cmd(wd1=PathExtended(repo_local_root), wd2=PathExtended(repo_local_root))
-        write_shell_script_to_file(shell_script=program)
-        return None
-    elif platform.system() in ["Linux", "Darwin"]:
-        program = get_zellij_cmd(wd1=PathExtended(repo_local_root), wd2=PathExtended(repo_remote_root))
-        write_shell_script_to_file(shell_script=program)
-        return None
-    else:
-        raise NotImplementedError(f"Platform {platform.system()} not implemented.")
-
-
-def fetch_dotfiles():
-    console.print(Panel("📁 Fetching Dotfiles", title="[bold blue]Dotfiles[/bold blue]", border_style="blue"))
-
-    cloud_resolved = read_ini(DEFAULTS_PATH)["general"]["rclone_config_name"]
-    console.print(Panel(f"⚠️  Using default cloud: `{cloud_resolved}` from {DEFAULTS_PATH}", width=150, border_style="yellow"))
-
-    dotfiles_local = PathExtended.home().joinpath("dotfiles")
-    CONFIG_PATH.joinpath("remote").mkdir(parents=True, exist_ok=True)
-    dotfiles_remote = PathExtended(CONFIG_PATH).joinpath("remote", dotfiles_local.rel2home())
-    remote_path = dotfiles_local.get_remote_path(rel2home=True, os_specific=False, root="myhome") + ".zip.enc"
-
-    console.print(Panel("📥 Downloading dotfiles from cloud...", width=150, border_style="blue"))
-
-    dotfiles_remote.from_cloud(remotepath=remote_path, cloud=cloud_resolved, unzip=True, decrypt=True, rel2home=True, os_specific=False, pwd=None)
-
-    console.print(Panel("🗑️  Removing old dotfiles and replacing with cloud version...", width=150, border_style="blue"))
-
-    dotfiles_local.delete(sure=True)
-    dotfiles_remote.move(folder=PathExtended.home())
-    script = f"""
-# rm -rf {dotfiles_local}
-# mv {dotfiles_remote} {dotfiles_local}
-"""
-    if platform.system() == "Linux":
-        script += """
-sudo chmod 600 $HOME/.ssh/*
-sudo chmod 700 $HOME/.ssh
-sudo chmod +x $HOME/dotfiles/scripts/linux -R
-"""
-    shell_path = write_shell_script_to_file(shell_script=script)
-    Terminal().run(f". {shell_path}", shell="bash").capture().print()
-
-    console.print(Panel("✅ Dotfiles successfully fetched and installed", title="[bold green]Dotfiles[/bold green]", border_style="green"))
-
-
-def check_dotfiles_version_is_beyond(commit_dtm: str, update: bool) -> bool:
-    dotfiles_path = str(PathExtended.home().joinpath("dotfiles"))
-    from git import Repo
-
-    repo = Repo(path=dotfiles_path)
-    last_commit = repo.head.commit
-    dtm = last_commit.committed_datetime
-    from datetime import datetime  # make it tz unaware
-
-    dtm = datetime(dtm.year, dtm.month, dtm.day, dtm.hour, dtm.minute, dtm.second)
-    res = dtm > datetime.fromisoformat(commit_dtm)
-    if res is False and update is True:
-        console = Console()
-        console.print(Panel(f"🔄 UPDATE REQUIRED | Updating dotfiles because {dtm} < {datetime.fromisoformat(commit_dtm)}", border_style="bold blue", expand=False))
-        from machineconfig.scripts.python.cloud_repo_sync import main
-
-        main(cloud=None, path=dotfiles_path)
-    return res