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

machineconfig/scripts/python/{helpers_utils/path.py → helpers/helpers_utils/python.py}

@@ -1,10 +1,11 @@
 import typer
 from typing import Optional, Annotated, Literal, TypedDict, cast
+from machineconfig.utils.ssh_utils.abc import MACHINECONFIG_VERSION
 
 
 def tui_env(which: Annotated[Literal["PATH", "p", "ENV", "e"], typer.Argument(help="Which environment variable to display.")] = "ENV") -> None:
     """📚 NAVIGATE PATH variable with TUI"""
-    from machineconfig.scripts.python import env_manager as navigator
+    from machineconfig.scripts.python.helpers import helper_env as navigator
     from pathlib import Path
 
     match which:
@@ -17,50 +18,51 @@ def tui_env(which: Annotated[Literal["PATH", "p", "ENV", "e"], typer.Argument(he
     uv_with = ["textual"]
     uv_project_dir = None
     if not Path.home().joinpath("code/machineconfig").exists():
-        uv_with.append("machineconfig>=7.98")
+        uv_with.append(MACHINECONFIG_VERSION)
     else:
         uv_project_dir = str(Path.home().joinpath("code/machineconfig"))
     run_shell_script(
-        get_uv_command_executing_python_script(python_script=path.read_text(encoding="utf-8"), uv_with=uv_with, uv_project_dir=uv_project_dir)[0]
+        get_uv_command_executing_python_script(python_script=path.read_text(encoding="utf-8"), uv_with=uv_with, uv_project_dir=uv_project_dir)[0],
+        display_script=True,
+        clean_env=False,
     )
 
 
 def init_project(
     name: Annotated[Optional[str], typer.Option("--name", "-n", help="Name of the project.")] = None,
-    tmp_dir: Annotated[
-        bool, typer.Option("--tmp-dir", "-t", help="Use a temporary directory for the project initialization.")
-    ] = False,
-    python: Annotated[Literal["3.13", "3.14"], typer.Option("--python", "-p", help="Python version for the uv virtual environment.")] = "3.13",
-    libraries: Annotated[Optional[str], typer.Option("--libraries", "-l", help="Additional packages to include in the uv virtual environment.")] = None,
-    group: Annotated[Optional[str], typer.Option("--group", "-g", help="group of packages names (no separation) p:plot, t:types, l:linting, i:interactive, d:data")] = "ptlid",
-    # types_packages: Annotated[
-    #     bool, typer.Option("--types-packages/--no-types-packages", "-T/-NT", help="Include types packages for better type hinting.")
-    # ] = True,
-    # linting_debug_packages: Annotated[
-    #     bool, typer.Option("--linting-debug-packages/--no-linting-debug-packages", "-L/-NL", help="Include linting and debugging packages.")
-    # ] = True,
-    # ia_packages: Annotated[bool, typer.Option("--ia-packages/--no-ia-packages", "-I/-NI", help="Include interactive and IA packages.")] = True,
-    # plot_packages: Annotated[bool, typer.Option("--plot-packages/--no-plot-packages", "-P/-NP", help="Include plotting packages.")] = True,
-    # data_packages: Annotated[bool, typer.Option("--data-packages/--no-data-packages", "-D/-ND", help="Include data manipulation packages.")] = True,
-
+    tmp_dir: Annotated[bool, typer.Option("--tmp-dir", "-t", help="Use a temporary directory for the project initialization.")] = False,
+    python: Annotated[
+        Literal["3.11", "3.12", "3.13", "3.14"], typer.Option("--python", "-p", help="Python sub version for the uv virtual environment.")
+    ] = "3.13",
+    libraries: Annotated[
+        Optional[str], typer.Option("--libraries", "-l", help="Additional packages to include in the uv virtual environment (space separated).")
+    ] = None,
+    group: Annotated[
+        Optional[str], typer.Option("--group", "-g", help="group of packages names (no separation) p:plot, t:types, l:linting, i:interactive, d:data")
+    ] = "p,t,l,i,d",
 ) -> None:
     if libraries is not None:
         packages_add_line = f"uv add {libraries}"
     else:
         packages_add_line = ""
     from pathlib import Path
+
     if not tmp_dir:
         repo_root = Path.cwd()
         if not (repo_root / "pyproject.toml").exists():
             typer.echo(f"❌ Error: pyproject.toml not found in {repo_root}", err=True)
             raise typer.Exit(code=1)
         starting_code = ""
+        agents_line = ""
     else:
+        agents_line = """agents make-config"""
         if name is not None:
             from machineconfig.utils.accessories import randstr
+
             repo_root = Path.home().joinpath(f"tmp_results/tmp_projects/{name}")
         else:
             from machineconfig.utils.accessories import randstr
+
             repo_root = Path.home().joinpath(f"tmp_results/tmp_projects/{randstr(6)}")
         repo_root.mkdir(parents=True, exist_ok=True)
         print(f"Using temporary directory for project initialization: {repo_root}")
@@ -70,32 +72,49 @@ uv init --python {python}
 uv venv
 """
     print(f"Adding group `{group}` with common data science and plotting packages...")
-    total_packages: list[str] = []
+    total_packages: dict[str, list[str]] = {}
     if group is not None:
-        if "t" in group:
-            total_packages.append(
-                "types-python-dateutil types-pyyaml types-requests types-tqdm types-mysqlclient types-paramiko types-pytz types-sqlalchemy types-toml types-urllib3"
-            )
-        if "l" in group:
-            total_packages.append("mypy pyright ruff pylint pyrefly cleanpy ipdb pudb")
-        if "i" in group:
-            total_packages.append("ipython ipykernel jupyterlab nbformat marimo")
-        if "p" in group:
-            total_packages.append("python-magic matplotlib plotly kaleido")
-        if "d" in group:
-            total_packages.append("numpy pandas polars duckdb-engine sqlalchemy  psycopg2-binary pyarrow tqdm openpyxl")
+        packages = group.split(",")
+        if "t" in packages or "types" in packages:
+            total_packages["types"] = [
+                "types-python-dateutil",
+                "types-pyyaml",
+                "types-requests",
+                "types-tqdm",
+                "types-mysqlclient",
+                "types-paramiko",
+                "types-pytz",
+                "types-sqlalchemy",
+                "types-toml",
+                "types-urllib3",
+            ]
+        if "l" in packages:
+            total_packages["linting"] = ["mypy", "pyright", "ruff", "pylint", "pyrefly", "cleanpy", "ipdb", "pudb"]
+        if "i" in packages:
+            total_packages["interactive"] = ["ipython", "ipykernel", "jupyterlab", "nbformat", "marimo"]
+        if "p" in packages:
+            total_packages["plot"] = ["python-magic", "matplotlib", "plotly", "kaleido"]
+        if "d" in packages:
+            total_packages["data"] = ["numpy", "pandas", "polars", "duckdb-engine", "sqlalchemy", "psycopg2-binary", "pyarrow", "tqdm", "openpyxl"]
     from machineconfig.utils.ve import get_ve_activate_line
-
+    groups_packages_lines = "\n".join(
+        [f"uv add --group {group_name} {' '.join(packages)}" for group_name, packages in total_packages.items()]
+    )   
     script = f"""
 {starting_code}
 {packages_add_line}
-uv add --group {group} {" ".join(total_packages)}
+{groups_packages_lines}
 {get_ve_activate_line(ve_root=str(repo_root.joinpath(".venv")))}
+{agents_line}
 ls
 """
-    from machineconfig.utils.code import exit_then_run_shell_script
-
+    from machineconfig.utils.code import exit_then_run_shell_script, run_shell_script
     exit_then_run_shell_script(script)
+    _ = exit_then_run_shell_script, run_shell_script
+    # run_shell_script(script)
+    # if tempdir:
+    #     from machineconfig.scripts.python.ai.initai import add_ai_configs
+    #     add_ai_configs(repo_root=repo_root)
 
 
 def edit_file_with_hx(
@@ -142,13 +161,19 @@ class MachineSpecs(TypedDict):
     user: str
 
 
-def get_machine_specs() -> MachineSpecs:
+def get_machine_specs(hardware: Annotated[bool, typer.Option(..., "--hardware", "-h", help="Show compute capability")] = False) -> MachineSpecs:
     """Write print and return the local machine specs."""
+    if hardware:
+        from machineconfig.scripts.python.helpers.helpers_utils.specs import main
+        main()
+        import sys
+        sys.exit()
+
     import platform
-    from machineconfig.utils.code import get_uv_run_command
+    from machineconfig.utils.code import get_uv_command
 
-    uv_run_cmd = get_uv_run_command(platform=platform.system())  # type: ignore
-    command = f"""{uv_run_cmd} --with distro python -c "import distro; print(distro.name(pretty=True))" """
+    uv_cmd = get_uv_command(platform=platform.system())  # type: ignore
+    command = f"""{uv_cmd} run --with distro python -c "import distro; print(distro.name(pretty=True))" """
     import subprocess
     from pathlib import Path
     import socket

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

@@ -1,55 +1,140 @@
-
-from machineconfig.scripts.python.devops import get_app as get_devops_app
-from machineconfig.scripts.python.cloud import get_app as get_cloud_app
-from machineconfig.scripts.python.agents import get_app as get_agents_app
-from machineconfig.scripts.python.sessions import get_app as get_sessions_app
-from machineconfig.scripts.python.utils import get_app as get_utils_app
-
-from machineconfig.scripts.python.ftpx import ftpx as ftpx_func
-from machineconfig.scripts.python.croshell import croshell as croshell_func
-from machineconfig.scripts.python.fire_jobs import fire as get_fire_jobs_app
-from machineconfig.scripts.python.terminal import get_app as get_terminal_app
-
-def get_app():
-    import typer
-    app = typer.Typer(help="MachineConfig CLI - Manage your machine configurations and workflows", no_args_is_help=True, add_help_option=False, add_completion=False)
-    devops_app = get_devops_app()
-    app.add_typer(devops_app, name="devops", help="[d] DevOps related commands", no_args_is_help=True)
-    app.add_typer(devops_app, name="d", hidden=True)  # short alias
-
-    cloud_app = get_cloud_app()
-    app.add_typer(cloud_app, name="cloud", help="[c] Cloud management commands", no_args_is_help=True)
-    app.add_typer(cloud_app, name="c", hidden=True)  # short alias
-
-    sessions_app = get_sessions_app()
-    app.add_typer(sessions_app, name="sessions", help="[s] Session and layout management", no_args_is_help=True)
-    app.add_typer(sessions_app, name="s", hidden=True)  # short alias
-
-
-    agents_app = get_agents_app()
-    app.add_typer(agents_app, name="agents", help="[a] 🤖 AI Agents management commands", no_args_is_help=True)
-    app.add_typer(agents_app, name="a", hidden=True)  # short alias
-
-    app.command(name="fire", help="[f] Fire and manage jobs", no_args_is_help=False)(get_fire_jobs_app)
-    app.command(name="f", hidden=True, no_args_is_help=False)(get_fire_jobs_app)
-    app.command("ftpx", no_args_is_help=True, help="[ff] File transfer utility though SSH")(ftpx_func)
-    app.command("ff", no_args_is_help=True, hidden=True)(ftpx_func)  # short alias
-    app.command("croshell", no_args_is_help=False, help="[r] Cross-shell command execution")(croshell_func)
-    app.command("r", no_args_is_help=False, hidden=True)(croshell_func)  # short alias
-
-    utils_app = get_utils_app()
-    app.add_typer(utils_app, name="utils", help="[u] Utility commands", no_args_is_help=True)
-    app.add_typer(utils_app, name="u", hidden=True)  # short alias
-
-
-    terminal_app = get_terminal_app()
-    app.add_typer(terminal_app, name="terminal", help="[t] Terminal management commands", no_args_is_help=True)
-    app.add_typer(terminal_app, name="t", hidden=True)  # short alias
+"""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():
+def main() -> None:
     app = get_app()
     app()