machineconfig 6.82__py3-none-any.whl → 8.51__py3-none-any.whl

machineconfig/scripts/python/helpers/helpers_utils/specs.py

@@ -0,0 +1,246 @@
+"""
+CPU Specification Helper.
+
+This module provides utilities to detect the CPU model and fetch Geekbench scores
+using the geekbench-browser-python tool.
+"""
+
+import platform
+import re
+import subprocess
+
+
+def get_cpu_name() -> str:
+    """
+    Detect the CPU model name across different operating systems.
+
+    Returns:
+        str: The detected CPU model name or 'Unknown CPU'.
+    """
+    system = platform.system()
+
+    if system == "Linux":
+        try:
+            with open("/proc/cpuinfo") as f:
+                for line in f:
+                    if "model name" in line:
+                        return line.split(":", 1)[1].strip()
+        except FileNotFoundError:
+            pass
+
+    elif system == "Windows":
+        try:
+            # shell=True might be needed for wmic depending on environment,
+            # but usually check_output with string list is safer if executable is in path.
+            # User provided: wmic cpu get name
+            output = subprocess.check_output("wmic cpu get name", shell=True).decode()
+            lines = output.strip().split("\n")
+            if len(lines) > 1:
+                return lines[1].strip()
+        except (subprocess.CalledProcessError, IndexError):
+            pass
+
+    elif system == "Darwin":
+        try:
+            return subprocess.check_output(
+                ["sysctl", "-n", "machdep.cpu.brand_string"]
+            ).decode().strip()
+        except subprocess.CalledProcessError:
+            pass
+
+    return "Unknown CPU"
+
+
+def clean_cpu_name(cpu_name: str) -> str:
+    """
+    Clean the CPU name to improve Geekbench search results.
+
+    Removes extra details like 'w/ Radeon Graphics', frequency, etc.
+
+    Args:
+        cpu_name (str): The raw CPU name string.
+
+    Returns:
+        str: A cleaned CPU name suitable for searching.
+    """
+    # Remove "w/ ..." or "with ..."
+    # Example: AMD Ryzen 7 8745HS w/ Radeon 780M Graphics -> AMD Ryzen 7 8745HS
+    cleaned = re.split(r"\s+(w/|with)\s+", cpu_name, flags=re.IGNORECASE)[0]
+
+    # Remove (R) and (TM) symbols which confuse regex search and are often noisy
+    cleaned = re.sub(r"\([RT]M?\)", "", cleaned, flags=re.IGNORECASE)
+
+    # Remove clock speed like " @ 3.00GHz", " 3.00GHz", " 3.2GHz"
+    cleaned = re.sub(r"\s+@?\s*\d+(\.\d+)?\s*GHz", "", cleaned, flags=re.IGNORECASE)
+
+    # Remove "12-Core Processor" etc if present (some linux distros add this)
+    cleaned = re.sub(r"\s+\d+-Core\s+Processor", "", cleaned, flags=re.IGNORECASE)
+
+    # Remove trailing "Processor" word if it's there
+    cleaned = re.sub(r"\s+Processor", "", cleaned, flags=re.IGNORECASE)
+
+    # Collapse multiple spaces
+    cleaned = re.sub(r"\s+", " ", cleaned)
+
+    return cleaned.strip()
+
+
+def run_geekbench_lookup(search_term: str) -> bool:
+    """
+    Run the geekbench search using uvx.
+
+    Args:
+        search_term (str): The CPU name to search for (supports Regex).
+
+    Returns:
+        bool: True if results were found, False otherwise.
+    """
+    # Note: uvx caches the tool so subsequent runs are fast.
+    # The 'gbr' tool uses pandas.str.contains(regex=True), so we can use regex patterns.
+    # We quote the search term to ensure it's treated as a single pattern containing spaces.
+    cmd = [
+        "uvx",
+        "--from",
+        "geekbench-browser-python",
+        "gbr",
+        search_term,
+        "--verbose",
+    ]
+    printable_cmd = " ".join(f'"{x}"' if " " in x else x for x in cmd)
+    print(f"Running: {printable_cmd}")
+    try:
+        # Capture output to check for results
+        # We enforce utf-8 encoding because 'geekbench-browser-python' likely outputs
+        # Unicode characters (Rich tables, box drawing) which can fail to decode or
+        # appear as garbage on Windows (default cp1252) if not handled.
+        result = subprocess.run(
+            cmd,
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+        )
+        output = result.stdout
+
+        # Check if we have data rows.
+        # Check iteratively for lines that look like data rows (Unicode or ASCII).
+        lines = output.splitlines()
+        has_data = False
+        for line in lines:
+            line_stripped = line.strip()
+            # Unicode table data row start (Light Vertical)
+            if "│" in line:
+                has_data = True
+                break
+            # ASCII table data row start (Pipe)
+            # Must exclude headers and separators which also start with pipe in ASCII mode.
+            if line_stripped.startswith("|"):
+                lower_line = line.lower()
+                # Skip header/separator lines
+                if "description" in lower_line or "single" in lower_line or "---" in line:
+                    continue
+                has_data = True
+                break
+        
+        if has_data:
+            print(output)
+            return True
+        else:
+            # If verbose debugging is needed, we could print output here.
+            # But normally if no table is found, the tool might have just printed log info to stderr.
+            # If it did print something to stdout that isn't a table, we probably shouldn't show it
+            # as a "result", but it might be helpful for debugging why it failed.
+            if output.strip():
+                 # Only print debug info if it's NOT just an empty table structure to avoid noise
+                 if not ("description" in output.lower() and ("---" in output or "│" in output)):
+                     print(f"Debug output from tool:\n{output}")
+            
+            print(f"No results found for '{search_term}'.")
+            return False
+
+    except subprocess.CalledProcessError:
+        print("Failed to retrieve Geekbench scores (command failed).")
+        return False
+    except FileNotFoundError:
+        print("Error: 'uvx' command not found. Please ensure 'uv' is installed.")
+        return False
+
+
+def main() -> None:
+    """Main entry point."""
+    cpu_name = get_cpu_name()
+    print(f"Detected CPU: {cpu_name}")
+
+    if cpu_name == "Unknown CPU":
+        print("Could not detect CPU name. Exiting.")
+        return
+
+    full_search_term = clean_cpu_name(cpu_name)
+    
+    # Retry logic: remove last word until we find something or run out of words
+    # We escape each word to ensure regex special characters (like +, (), etc) in the name
+    # are treated as literals, while preserving our ability to use regex wildcards later.
+    words = [re.escape(w) for w in full_search_term.split()]
+    
+    while words:
+        current_term = " ".join(words)
+        
+        # Heuristic: Don't search for extremely short generic terms if possible,
+        # but "AMD" or "Intel" might be what we end up with if nothing else works.
+        # Let's try at least length 2 words unless it's just 1 word left.
+        if len(words) > 1 and len(current_term) < 4:
+             words.pop()
+             continue
+
+        print(f"Search Term: {current_term}")
+        if run_geekbench_lookup(current_term):
+            return
+        
+        last_word = words[-1]
+        numeric_part = None
+
+        # Check if the last word starts with digits (e.g. 8745HS or 8745)
+        # We want to both strip suffix AND try wildcards.
+        match_digits = re.match(r"^(\d+)([a-zA-Z].*)?$", last_word)
+        
+        if match_digits:
+            numeric_part = match_digits.group(1)
+            suffix_part = match_digits.group(2) # May be None
+
+            # Intermediate Try 1: Strip suffix (e.g. 8745HS -> 8745)
+            if suffix_part and len(numeric_part) >= 3:
+                 intermediate_term = " ".join(words[:-1] + [numeric_part])
+                 if intermediate_term != current_term:
+                     print(f"Search Term: {intermediate_term} (stripped suffix)")
+                     if run_geekbench_lookup(intermediate_term):
+                        return
+            
+            # Intermediate Try 2: Wildcard/Regex search (e.g. 8745 -> 87..)
+            # The tool uses Regex, so we use dots '.' to match any character instead of '?'
+            if numeric_part and len(numeric_part) >= 3:
+                # If 4+ digits (e.g. 8745), replace last 2 with .. -> 87..
+                # If 3 digits (e.g. 780), replace last 1 with . -> 78.
+                if len(numeric_part) >= 4:
+                    wildcard_model = numeric_part[:-2] + ".."
+                else:
+                    wildcard_model = numeric_part[:-1] + "."
+                
+                wildcard_term = " ".join(words[:-1] + [wildcard_model])
+                
+                # Check duplication against current_term and the stripped version
+                stripped_term = " ".join(words[:-1] + [numeric_part])
+                if wildcard_term != current_term and wildcard_term != stripped_term:
+                     print(f"Search Term: {wildcard_term} (regex wildcard)")
+                     if run_geekbench_lookup(wildcard_term):
+                        return
+
+        # Remove last word for next iteration
+        words.pop()
+
+    print("Could not find any matching Geekbench scores.")
+
+
+if __name__ == "__main__":
+    main()

machineconfig/scripts/python/mcfg_entry.py

@@ -0,0 +1,143 @@
+"""Fast-loading CLI entry point using lazy imports.
+
+Submodules are only imported when their commands are actually invoked, not at startup.
+This makes `mcfg --help` much faster by avoiding loading heavy dependencies.
+"""
+from typing import Optional, Annotated
+import typer
+
+
+def fire(
+    ctx: typer.Context,
+    path: Annotated[str, typer.Argument(help="Path to the Python file to run")] = ".",
+    function: Annotated[Optional[str], typer.Argument(help="Function to run")] = None,
+    ve: Annotated[str, typer.Option("--ve", "-v", help="Virtual environment name")] = "",
+    cmd: Annotated[bool, typer.Option("--cmd", "-B", help="Create a cmd fire command to launch the job asynchronously")] = False,
+    interactive: Annotated[bool, typer.Option("--interactive", "-i", help="Whether to run the job interactively using IPython")] = False,
+    debug: Annotated[bool, typer.Option("--debug", "-d", help="Enable debug mode")] = False,
+    choose_function: Annotated[bool, typer.Option("--choose-function", "-c", help="Choose function interactively")] = False,
+    loop: Annotated[bool, typer.Option("--loop", "-l", help="Infinite recursion (runs again after completion/interruption)")] = False,
+    jupyter: Annotated[bool, typer.Option("--jupyter", "-j", help="Open in a jupyter notebook")] = False,
+    marimo: Annotated[bool, typer.Option("--marimo", "-M", help="Open in a marimo notebook")] = False,
+    module: Annotated[bool, typer.Option("--module", "-m", help="Launch the main file")] = False,
+    script: Annotated[bool, typer.Option("--script", "-s", help="Launch as a script without fire")] = False,
+    optimized: Annotated[bool, typer.Option("--optimized", "-O", help="Run the optimized version of the function")] = False,
+    zellij_tab: Annotated[Optional[str], typer.Option("--zellij-tab", "-z", help="Open in a new zellij tab")] = None,
+    submit_to_cloud: Annotated[bool, typer.Option("--submit-to-cloud", "-C", help="Submit to cloud compute")] = False,
+    remote: Annotated[bool, typer.Option("--remote", "-r", help="Launch on a remote machine")] = False,
+    streamlit: Annotated[bool, typer.Option("--streamlit", "-S", help="Run as streamlit app")] = False,
+    environment: Annotated[str, typer.Option("--environment", "-E", help="Choose ip, localhost, hostname or arbitrary url")] = "",
+    holdDirectory: Annotated[bool, typer.Option("--holdDirectory", "-D", help="Hold current directory and avoid cd'ing to the script directory")] = False,
+    PathExport: Annotated[bool, typer.Option("--PathExport", "-P", help="Augment the PYTHONPATH with repo root")] = False,
+    git_pull: Annotated[bool, typer.Option("--git-pull", "-g", help="Start by pulling the git repo")] = False,
+    watch: Annotated[bool, typer.Option("--watch", "-w", help="Watch the file for changes")] = False,
+) -> None:
+    """Fire and manage jobs."""
+    from machineconfig.scripts.python.fire_jobs import fire as fire_impl
+    fire_impl(ctx=ctx, path=path, function=function, ve=ve, cmd=cmd, interactive=interactive, debug=debug,
+              choose_function=choose_function, loop=loop, jupyter=jupyter, marimo=marimo, module=module,
+              script=script, optimized=optimized, zellij_tab=zellij_tab, submit_to_cloud=submit_to_cloud,
+              remote=remote, streamlit=streamlit, environment=environment, holdDirectory=holdDirectory,
+              PathExport=PathExport, git_pull=git_pull, watch=watch)
+
+
+def ftpx(
+    source: Annotated[str, typer.Argument(help="Source path (machine:path)")],
+    target: Annotated[str, typer.Argument(help="Target path (machine:path)")],
+    recursive: Annotated[bool, typer.Option("--recursive", "-r", help="Send recursively.")] = False,
+    zipFirst: Annotated[bool, typer.Option("--zipFirst", "-z", help="Zip before sending.")] = False,
+    cloud: Annotated[bool, typer.Option("--cloud", "-c", help="Transfer through the cloud.")] = False,
+    overwrite_existing: Annotated[bool, typer.Option("--overwrite-existing", "-o", help="Overwrite existing files on remote when sending from local to remote.")] = False,
+) -> None:
+    """File transfer utility though SSH."""
+    from machineconfig.scripts.python.ftpx import ftpx as ftpx_impl
+    ftpx_impl(source=source, target=target, recursive=recursive, zipFirst=zipFirst, cloud=cloud, overwrite_existing=overwrite_existing)
+
+
+def croshell(
+    path: Annotated[Optional[str], typer.Argument(help="path of file to read.")] = None,
+    project_path: Annotated[Optional[str], typer.Option("--project", "-p", help="specify uv project to use")] = None,
+    uv_with: Annotated[Optional[str], typer.Option("--uv-with", "-w", help="specify uv with packages to use")] = None,
+    marimo: Annotated[bool, typer.Option("--marimo", "-m", help="open the notebook using marimo if available")] = False,
+    jupyter: Annotated[bool, typer.Option("--jupyter", "-j", help="run in jupyter interactive console")] = False,
+    vscode: Annotated[bool, typer.Option("--vscode", "-c", help="open the script in vscode")] = False,
+    visidata: Annotated[bool, typer.Option("--visidata", "-v", help="open data file in visidata")] = False,
+    python: Annotated[bool, typer.Option("--python", "-P", help="flag to use python over IPython.")] = False,
+    profile: Annotated[Optional[str], typer.Option("--profile", "-r", help="ipython profile to use, defaults to default profile.")] = None,
+) -> None:
+    """Cross-shell command execution."""
+    from machineconfig.scripts.python.croshell import croshell as croshell_impl
+    croshell_impl(path=path, project_path=project_path, uv_with=uv_with, marimo=marimo, jupyter=jupyter, vscode=vscode, visidata=visidata, python=python, profile=profile)
+
+
+def devops(ctx: typer.Context) -> None:
+    """[d] DevOps related commands."""
+    from machineconfig.scripts.python.devops import get_app
+    get_app()(ctx.args, standalone_mode=not ctx.args)
+
+
+def cloud(ctx: typer.Context) -> None:
+    """[c] Cloud management commands."""
+    from machineconfig.scripts.python.cloud import get_app
+    get_app()(ctx.args, standalone_mode=not ctx.args)
+
+
+def sessions(ctx: typer.Context) -> None:
+    """[s] Session and layout management."""
+    from machineconfig.scripts.python.sessions import get_app
+    get_app()(ctx.args, standalone_mode=not ctx.args)
+
+
+def agents(ctx: typer.Context) -> None:
+    """[a] 🤖 AI Agents management commands."""
+    from machineconfig.scripts.python.agents import get_app
+    get_app()(ctx.args, standalone_mode=not ctx.args)
+
+
+def utils(ctx: typer.Context) -> None:
+    """[u] Utility commands."""
+    from machineconfig.scripts.python.utils import get_app
+    get_app()(ctx.args, standalone_mode=not ctx.args)
+
+
+def terminal(ctx: typer.Context) -> None:
+    """[t] Terminal management commands."""
+    from machineconfig.scripts.python.terminal import get_app
+    get_app()(ctx.args, standalone_mode=not ctx.args)
+
+
+def get_app() -> typer.Typer:
+    app = typer.Typer(help="MachineConfig CLI - Manage your machine configurations and workflows", no_args_is_help=True, add_help_option=True, add_completion=False)
+
+    ctx_settings: dict[str, object] = {"allow_extra_args": True, "allow_interspersed_args": True, "ignore_unknown_options": True, "help_option_names": []}
+
+    app.command(name="devops", help="[d] DevOps related commands", context_settings=ctx_settings)(devops)
+    app.command(name="d", hidden=True, context_settings=ctx_settings)(devops)
+    app.command(name="cloud", help="[c] Cloud management commands", context_settings=ctx_settings)(cloud)
+    app.command(name="c", hidden=True, context_settings=ctx_settings)(cloud)
+    app.command(name="sessions", help="[s] Session and layout management", context_settings=ctx_settings)(sessions)
+    app.command(name="s", hidden=True, context_settings=ctx_settings)(sessions)
+    app.command(name="agents", help="[a] 🤖 AI Agents management commands", context_settings=ctx_settings)(agents)
+    app.command(name="a", hidden=True, context_settings=ctx_settings)(agents)
+    app.command(name="utils", help="[u] Utility commands", context_settings=ctx_settings)(utils)
+    app.command(name="u", hidden=True, context_settings=ctx_settings)(utils)
+    app.command(name="terminal", help="[t] Terminal management commands", context_settings=ctx_settings)(terminal)
+    app.command(name="t", hidden=True, context_settings=ctx_settings)(terminal)
+
+    app.command(name="fire", help="[f] Fire and manage jobs", no_args_is_help=False, context_settings={"allow_extra_args": True, "allow_interspersed_args": False})(fire)
+    app.command(name="f", hidden=True, no_args_is_help=False, context_settings={"allow_extra_args": True, "allow_interspersed_args": False})(fire)
+    app.command("ftpx", no_args_is_help=True, help="[ff] File transfer utility though SSH")(ftpx)
+    app.command("ff", no_args_is_help=True, hidden=True)(ftpx)
+    app.command("croshell", no_args_is_help=False, help="[r] Cross-shell command execution")(croshell)
+    app.command("r", no_args_is_help=False, hidden=True)(croshell)
+
+    return app
+
+
+def main() -> None:
+    app = get_app()
+    app()
+
+
+if __name__ == "__main__":
+    main()

machineconfig/scripts/python/msearch.py

@@ -0,0 +1,26 @@
+"""msearch - Machineconfig search helper."""
+
+import typer
+from typing import Annotated
+
+
+def machineconfig_search(
+    path: Annotated[str, typer.Argument(help="The directory/file to search")] = ".",
+    ast: Annotated[bool, typer.Option(..., "--ast", "-a", help="The abstract syntax tree search/ tree sitter search of symbols")] = False,
+    symantic: Annotated[bool, typer.Option(..., "--symantic", "-s", help="The symantic search of symbols")] = False,
+    extension: Annotated[str, typer.Option(..., "--extension", "-E", help="File extension to filter by (e.g., .py, .js)")] = "",
+    file: Annotated[bool, typer.Option(..., "--file", "-f", help="File search using fzf")] = False,
+    no_dotfiles: Annotated[bool, typer.Option(..., "--no-dotfiles", "-D", help="Exclude dotfiles from search")] = False,
+    rga: Annotated[bool, typer.Option(..., "--rga", "-A", help="Use ripgrep-all for searching all (non text files) instead of ripgrep")] = False,
+    edit: Annotated[bool, typer.Option(..., "--edit", "-e", help="Open selection in editor (helix)")] = False,
+    install_dependencies: Annotated[bool, typer.Option(..., "--install-req", "-i", help="Install required dependencies if missing")] = False,
+) -> None:
+    """Machineconfig search helper."""
+    from machineconfig.scripts.python.helpers.helpers_msearch.msearch_impl import machineconfig_search as impl
+    impl(path=path, ast=ast, symantic=symantic, extension=extension, file=file, no_dotfiles=no_dotfiles, rga=rga, edit=edit, install_dependencies=install_dependencies)
+
+
+def main() -> None:
+    app = typer.Typer(add_completion=False, no_args_is_help=True)
+    app.command(name="msearch", help=machineconfig_search.__doc__, short_help="machineconfig search helper", no_args_is_help=False)(machineconfig_search)
+    app()

machineconfig/scripts/python/sessions.py

@@ -1,152 +1,86 @@
+"""Sessions management commands - lazy loading subcommands."""
 
-from pathlib import Path
 from typing import Optional, Literal, Annotated
 import typer
 
-def balance_load(layout_path: Annotated[Path, typer.Argument(..., help="Path to the layout.json file")],
-           max_thresh: Annotated[int, typer.Option(..., help="Maximum tabs per layout")],
-           thresh_type: Annotated[Literal['number', 'weight'], typer.Option(..., help="Threshold type")],
-           breaking_method: Annotated[Literal['moreLayouts', 'combineTabs'], typer.Option(..., help="Breaking method")],
-           output_path: Annotated[Optional[Path], typer.Option(..., help="Path to write the adjusted layout.json file")] = None):
+
+def balance_load(
+    layout_path: Annotated[str, typer.Argument(..., help="Path to the layout.json file")],
+    max_thresh: Annotated[int, typer.Option(..., "--max-threshold", "-m", help="Maximum tabs per layout")],
+    thresh_type: Annotated[Literal["number", "n", "weight", "w"], typer.Option(..., "--threshold-type", "-t", help="Threshold type")],
+    breaking_method: Annotated[Literal["moreLayouts", "ml", "combineTabs", "ct"], typer.Option(..., "--breaking-method", "-b", help="Breaking method")],
+    output_path: Annotated[Optional[str], typer.Option(..., "--output-path", "-o", help="Path to write the adjusted layout.json file")] = None,
+) -> None:
     """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 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 find_layout_file(layout_path: str, ) -> Path:
-    from machineconfig.utils.path_extended import PathExtended
-    from machineconfig.scripts.python.helpers_fire.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
-    return choice_file
-
-
-def run(ctx: typer.Context,
-           layout_path: Annotated[Optional[str], typer.Argument(..., help="Path to the layout.json file")] = None,
-        max_tabs: Annotated[int, typer.Option(..., help="A Sanity checker that throws an error if any layout exceeds the maximum number of tabs to launch.")] = 10,
-        max_layouts: Annotated[int, typer.Option(..., help="A Sanity checker that throws an error if the total number of *parallel layouts exceeds this number.")] = 10,
-        sleep_inbetween: Annotated[float, typer.Option(..., help="Sleep time in seconds between launching layouts")] = 1.0,
-        monitor: Annotated[bool, typer.Option(..., "--monitor", "-m", help="Monitor the layout sessions for completion")] = False,
-        parallel: Annotated[bool, typer.Option(..., "--parallel", "-p", help="Launch multiple layouts in parallel")] = False,
-        kill_upon_completion: Annotated[bool, typer.Option(..., "--kill-upon-completion", "-k", help="Kill session(s) upon completion (only relevant if monitor flag is set)")] = False,
-        choose: Annotated[Optional[str], typer.Option(..., "--choose", "-c", help="Comma separated names of layouts to be selected from the layout file passed")] = None,
-        choose_interactively: Annotated[bool, typer.Option(..., "--choose-interactively", "-ia", help="Select layouts interactively")] = False
-        ):
-    """
-    Launch terminal sessions based on a layout configuration file.
-    """
+    from machineconfig.scripts.python.helpers.helpers_sessions.sessions_impl import balance_load as impl
+    impl(layout_path=layout_path, max_thresh=max_thresh, thresh_type=thresh_type, breaking_method=breaking_method, output_path=output_path)
+
+
+def run(
+    ctx: typer.Context,
+    layout_path: Annotated[Optional[str], typer.Argument(..., help="Path to the layout.json file")] = None,
+    sleep_inbetween: Annotated[float, typer.Option(..., "--sleep-inbetween", "-si", help="Sleep time in seconds between launching layouts")] = 1.0,
+    monitor: Annotated[bool, typer.Option(..., "--monitor", "-m", help="Monitor the layout sessions for completion")] = False,
+    parallel: Annotated[bool, typer.Option(..., "--parallel", "-p", help="Launch multiple layouts in parallel")] = False,
+    kill_upon_completion: Annotated[bool, typer.Option(..., "--kill-upon-completion", "-k", help="Kill session(s) upon completion (only relevant if monitor flag is set)")] = False,
+    choose: Annotated[Optional[str], typer.Option(..., "--choose", "-c", help="Comma separated names of layouts to be selected from the layout file passed")] = None,
+    choose_interactively: Annotated[bool, typer.Option(..., "--choose-interactively", "-i", help="Select layouts interactively")] = False,
+    subsitute_home: Annotated[bool, typer.Option(..., "--substitute-home", "-sh", help="Substitute ~ and $HOME in layout file with actual home directory path")] = False,
+    max_tabs: Annotated[int, typer.Option(..., "--max-tabs", "-mt", help="A Sanity checker that throws an error if any layout exceeds the maximum number of tabs to launch.")] = 25,
+    max_layouts: Annotated[int, typer.Option(..., "--max-layouts", "-ml", help="A Sanity checker that throws an error if the total number of *parallel layouts exceeds this number.")] = 25,
+) -> None:
+    """Launch terminal sessions based on a layout configuration file."""
     if layout_path is None:
         typer.echo(ctx.get_help())
         raise typer.Exit()
-    layout_path_resolved = find_layout_file(layout_path=layout_path)
-    layouts_selected = select_layout(layouts_json_file=layout_path_resolved, selected_layouts_names=choose.split(",") if choose else None, select_interactively=choose_interactively)
-
-    # ============= Basic sanity checks =============
-    if parallel and 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()}")
-
-
-def get_app():
-    layouts_app = typer.Typer(help="Layouts management subcommands", no_args_is_help=True, add_help_option=False, add_completion=False)
-    from machineconfig.scripts.python.helpers_sessions.sessions_multiprocess import create_from_function
-    layouts_app.command("create-from-function", no_args_is_help=True, help="[c] Create a layout from a function")(create_from_function)
-    layouts_app.command("c", no_args_is_help=True, help="Create a layout from a function", hidden=True)(create_from_function)
-    layouts_app.command("run", no_args_is_help=True, help="[r] Run the selected layout(s)")(run)
-    layouts_app.command("r", no_args_is_help=True, help="Run the selected layout(s)", hidden=True)(run)
-    layouts_app.command("balance-load", no_args_is_help=True, help="[b] Balance the load across sessions")(balance_load)
-    layouts_app.command("b", no_args_is_help=True, help="Balance the load across sessions", hidden=True)(balance_load)
+    from machineconfig.scripts.python.helpers.helpers_sessions.sessions_impl import run_layouts
+    try:
+        run_layouts(layout_path=layout_path, max_tabs=max_tabs, max_layouts=max_layouts, sleep_inbetween=sleep_inbetween, monitor=monitor, parallel=parallel, kill_upon_completion=kill_upon_completion, choose=choose, choose_interactively=choose_interactively, subsitute_home=subsitute_home)
+    except ValueError as e:
+        typer.echo(str(e))
+        raise typer.Exit(1) from e
+
+
+def create_template(
+    name: Annotated[Optional[str], typer.Argument(..., help="Name of the layout template to create")] = None,
+    num_tabs: Annotated[int, typer.Option(..., "--num-tabs", "-t", help="Number of tabs to include in the template")] = 3,
+) -> None:
+    """Create a layout template file."""
+    from machineconfig.scripts.python.helpers.helpers_sessions.sessions_impl import create_template as impl
+    impl(name=name, num_tabs=num_tabs)
+
+
+def create_from_function(
+    num_process: Annotated[int, typer.Option(..., "--num-process", "-n", help="Number of parallel processes to run")],
+    path: Annotated[str, typer.Option(..., "--path", "-p", help="Path to a Python or Shell script file or a directory containing such files")] = ".",
+    function: Annotated[Optional[str], typer.Option(..., "--function", "-f", help="Function to run from the Python file. If not provided, you will be prompted to choose.")] = None,
+) -> None:
+    """Create a layout from a function to run in multiple processes."""
+    from machineconfig.scripts.python.helpers.helpers_sessions.sessions_multiprocess import create_from_function as impl
+    impl(num_process=num_process, path=path, function=function)
+
+
+def get_app() -> typer.Typer:
+    layouts_app = typer.Typer(help="Layouts management subcommands", no_args_is_help=True, add_help_option=True, add_completion=False)
+
+    layouts_app.command("create-from-function", no_args_is_help=True, short_help="[c] Create a layout from a function")(create_from_function)
+    layouts_app.command("c", no_args_is_help=True, hidden=True)(create_from_function)
+
+    layouts_app.command("run", no_args_is_help=True, help=run.__doc__, short_help="[r] Run the selected layout(s)")(run)
+    layouts_app.command("r", no_args_is_help=True, help=run.__doc__, hidden=True)(run)
+
+    layouts_app.command("balance-load", no_args_is_help=True, help=balance_load.__doc__, short_help="[b] Balance the load across sessions")(balance_load)
+    layouts_app.command("b", no_args_is_help=True, help=balance_load.__doc__, hidden=True)(balance_load)
 
+    layouts_app.command("create-template", no_args_is_help=False, help=create_template.__doc__, short_help="[t] Create a layout template file")(create_template)
+    layouts_app.command("t", no_args_is_help=False, help=create_template.__doc__, hidden=True)(create_template)
     return layouts_app
 
 
-def main():
+def main() -> None:
     layouts_app = get_app()
     layouts_app()
 
 
 if __name__ == "__main__":
-    from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
+    pass