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

machineconfig/scripts/python/ai/solutions/copilot/instructions/python/watch_exec.prompt.md

@@ -0,0 +1,20 @@
+
+
+* I have started a watch-exec server in my terminal and its working now.
+* I have set it up to re-run the shell script `.ai/terminal/debug/command_runner.sh` automatically.
+    * A re-run is triggered upon any change of any python file in the repo, or, any change in the command_runner.sh script itself.
+* The shell script itself runs the python file we are working on using uv.
+* The script redirects the output from terminal to the file ./.ai* Run takes 50 ms only. So by the time you finish editing any python file or the command runner script, the new output is ready for you to read in that text file.
+* Run takes 50 ms only. So by the time you finish editing any python file or the command runner script, the new output is ready for you to read in that text file.
+
+# Why did I set this up?
+* Because this makes it much faster for you to iterate because pulling the terminal and closing it every time is a bit slow.
+* You no longer need the terminal.
+
+
+# What should you do now?
+Please iterate like this:
+* Please use the terminal_output.txt as your main iteration driver (fix any problems you see there).
+* Change `command_runner.sh` if you need to change which python file to run or how to run it.
+
+

machineconfig/scripts/python/ai/solutions/crush/crush.py

@@ -7,7 +7,7 @@ ref: https://github.com/charmbracelet/crush
 
 from pathlib import Path
 import platform
-from machineconfig.scripts.python.ai.solutions._shared import get_generic_instructions_path
+from machineconfig.scripts.python.ai.utils.shared import get_generic_instructions_path
 
 
 

machineconfig/scripts/python/ai/solutions/cursor/cursors.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from machineconfig.scripts.python.ai.solutions._shared import get_generic_instructions_path
+from machineconfig.scripts.python.ai.utils.shared import get_generic_instructions_path
 
 
 def build_configuration(repo_root: Path) -> None:

machineconfig/scripts/python/ai/solutions/gemini/gemini.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from machineconfig.scripts.python.ai.solutions._shared import get_generic_instructions_path
+from machineconfig.scripts.python.ai.utils.shared import get_generic_instructions_path
 from machineconfig.utils.source_of_truth import LIBRARY_ROOT
 
 def build_configuration(repo_root: Path) -> None:

machineconfig/scripts/python/ai/solutions/gemini/settings.json

@@ -1,4 +1,7 @@
 {
+  "general": {
+    "previewFeatures": true
+  },
   // Appearance
   "theme": "Default",          // Could also be "GitHub", "Dracula", etc.
 

machineconfig/scripts/python/ai/{generate_files.py → utils/generate_files.py}

@@ -247,7 +247,7 @@ def create_repo_symlinks(repo_root: Path) -> None:
         symlink_path.symlink_to(repo_root, target_is_directory=True)
 
 
-def main(
+def make_todo_files(
     pattern: Annotated[str, typer.Argument(help="Pattern or keyword to match files by")],
     repo: Annotated[str, typer.Argument(help="Repository path. Can be any directory within a git repository.")] = str(Path.cwd()),
     strategy: Annotated[Literal["name", "keywords"], typer.Option("-s", "--strategy", help="Strategy to filter files: 'name' for filename matching, 'keywords' for content matching")] = "name",
@@ -344,5 +344,5 @@ def create_symlink_command(num: Annotated[int, typer.Argument(help="Number of sy
     console.print(Panel(f"✅ SUCCESS | Created {num} symlinks to {repo_root} in ~/code_copies/", border_style="bold green", expand=False))
 
 if __name__ == "__main__":
-    typer.run(main)
+    typer.run(make_todo_files)
     # typer.run(create_symlink_command)

machineconfig/scripts/python/ai/{solutions → utils}/generic.py

@@ -40,21 +40,8 @@ def adjust_gitignore(repo_root: Path) -> None:
 
     dot_git_ignore_content = dot_git_ignore_path.read_text(encoding="utf-8")
     entries_to_add: list[str] = []
-    required_entries: list[str] = [
-        ".links",
-        "notebooks",
-        ".ai",
-        "GEMINI.md",
-        "CLAUDE.md",
-        "CRUSH.md",
-        ".cursor",
-        ".clinerules",
-        ".github/instructions",
-        ".github/chatmodes",
-        ".github/prompts",
-    ]
-
-    for entry in required_entries:
+    from machineconfig.utils.source_of_truth import EXCLUDE_DIRS
+    for entry in EXCLUDE_DIRS:
         if entry not in dot_git_ignore_content:
             entries_to_add.append(entry)
 

machineconfig/scripts/python/ai/{vscode_tasks.py → utils/vscode_tasks.py}

@@ -1,5 +1,6 @@
 import json
 from pathlib import Path
+from typing import Any
 
 
 def add_lint_and_type_check_task(repo_root: Path) -> None:
@@ -18,13 +19,20 @@ def add_lint_and_type_check_task(repo_root: Path) -> None:
     }
 
     if tasks_json_path.exists():
-        with tasks_json_path.open("r") as f:
-            tasks_config = json.load(f)
+        json_data = tasks_json_path.read_text(encoding="utf-8")
+        if not json_data.strip():
+            tasks_config: dict[str, Any] = {"version": "2.0.0", "tasks": []}
+        else:
+            tasks_config = json.loads(json_data)
+            assert isinstance(tasks_config, dict)
         if "tasks" not in tasks_config:
             tasks_config["tasks"] = []
-        existing_labels = {task.get("label") for task in tasks_config.get("tasks", [])}
-        if "lintAndTypeCheck" not in existing_labels:
-            tasks_config["tasks"].append(task_to_add)
+        
+        # Remove any existing entries with the same label to prevent duplicates
+        tasks_config["tasks"] = [
+            t for t in tasks_config["tasks"] if t.get("label") != task_to_add["label"]
+        ]
+        tasks_config["tasks"].append(task_to_add)
     else:
         tasks_config = {"version": "2.0.0", "tasks": [task_to_add]}
 

machineconfig/scripts/python/cloud.py

@@ -1,20 +1,67 @@
+"""Cloud management commands - lazy loading subcommands."""
 
 import typer
-from machineconfig.scripts.python.helpers_cloud.cloud_sync import main as sync_main
-from machineconfig.scripts.python.helpers_cloud.cloud_copy import main as copy_main
-from machineconfig.scripts.python.helpers_cloud.cloud_mount import mount as mount_main
+from typing import Optional, Annotated
 
-def get_app():
-    app = typer.Typer(add_completion=False, no_args_is_help=True)
 
-    app.command(name="sync", no_args_is_help=True, help="""🔄 [s] Synchronize files/folders between local and cloud storage.""")(sync_main)
-    app.command(name="s", no_args_is_help=True, hidden=True)(sync_main)  # short alias
+def sync(
+    source: Annotated[str, typer.Argument(help="source")],
+    target: Annotated[str, typer.Argument(help="target")],
+    transfers: Annotated[int, typer.Option("--transfers", "-t", help="Number of threads in syncing.")] = 10,
+    root: Annotated[str, typer.Option("--root", "-R", help="Remote root.")] = "myhome",
+    key: Annotated[Optional[str], typer.Option("--key", "-k", help="Key for encryption")] = None,
+    pwd: Annotated[Optional[str], typer.Option("--pwd", "-P", help="Password for encryption")] = None,
+    encrypt: Annotated[bool, typer.Option("--encrypt", "-e", help="Decrypt after receiving.")] = False,
+    zip_: Annotated[bool, typer.Option("--zip", "-z", help="unzip after receiving.")] = False,
+    bisync: Annotated[bool, typer.Option("--bisync", "-b", help="Bidirectional sync.")] = False,
+    delete: Annotated[bool, typer.Option("--delete", "-D", help="Delete files in remote that are not in local.")] = False,
+    verbose: Annotated[bool, typer.Option("--verbose", "-v", help="Verbosity of mprocs to show details of syncing.")] = False,
+) -> None:
+    """🔄 Synchronize files/folders between local and cloud storage."""
+    from machineconfig.scripts.python.helpers.helpers_cloud.cloud_sync import main as sync_main
+    sync_main(source=source, target=target, transfers=transfers, root=root, key=key, pwd=pwd, encrypt=encrypt, zip_=zip_, bisync=bisync, delete=delete, verbose=verbose)
 
-    app.command(name="copy", no_args_is_help=True, short_help="""📤 [c] Upload or 📥 Download files/folders to/from cloud storage services like Google Drive, Dropbox, OneDrive, etc.""")(copy_main)
-    app.command(name="c", no_args_is_help=True, hidden=True)(copy_main)  # short alias
 
-    app.command(name="mount", no_args_is_help=True, short_help="""🔗 [m] Mount cloud storage services like Google Drive, Dropbox, OneDrive, etc. as local drives.""")(mount_main)
-    app.command(name="m", no_args_is_help=True, hidden=True)(mount_main)  # short alias
+def copy(
+    source: Annotated[str, typer.Argument(help="📂 file/folder path to be taken from here.")],
+    target: Annotated[str, typer.Argument(help="🎯 file/folder path to be be sent to here.")],
+    overwrite: Annotated[bool, typer.Option("--overwrite", "-o", help="✍️ Overwrite existing file.")] = False,
+    share: Annotated[bool, typer.Option("--share", "-s", help="🔗 Share file / directory")] = False,
+    rel2home: Annotated[bool, typer.Option("--relative2home", "-r", help="🏠 Relative to `myhome` folder")] = False,
+    root: Annotated[Optional[str], typer.Option("--root", "-R", help="🌳 Remote root. None is the default, unless rel2home is raied, making the default `myhome`.")] = None,
+    key: Annotated[Optional[str], typer.Option("--key", "-k", help="🔑 Key for encryption")] = None,
+    pwd: Annotated[Optional[str], typer.Option("--password", "-p", help="🔒 Password for encryption")] = None,
+    encrypt: Annotated[bool, typer.Option("--encrypt", "-e", help="🔐 Encrypt before sending.")] = False,
+    zip_: Annotated[bool, typer.Option("--zip", "-z", help="📦 unzip after receiving.")] = False,
+    os_specific: Annotated[bool, typer.Option("--os-specific", "-O", help="💻 choose path specific for this OS.")] = False,
+    config: Annotated[Optional[str], typer.Option("--config", "-c", help="⚙️ path to cloud.json file.")] = None,
+) -> None:
+    """📤 Upload or 📥 Download files/folders to/from cloud storage services."""
+    from machineconfig.scripts.python.helpers.helpers_cloud.cloud_copy import main as copy_main
+    copy_main(source=source, target=target, overwrite=overwrite, share=share, rel2home=rel2home, root=root, key=key, pwd=pwd, encrypt=encrypt, zip_=zip_, os_specific=os_specific, config=config)
+
+
+def mount(
+    cloud: Annotated[Optional[str], typer.Option(help="cloud to mount")] = None,
+    destination: Annotated[Optional[str], typer.Option(help="destination to mount")] = None,
+    network: Annotated[Optional[str], typer.Option(help="mount network drive")] = None,
+) -> None:
+    """🔗 Mount cloud storage services as local drives."""
+    from machineconfig.scripts.python.helpers.helpers_cloud.cloud_mount import mount as mount_main
+    mount_main(cloud=cloud, destination=destination, network=network)
+
+
+def get_app() -> typer.Typer:
+    app = typer.Typer(add_completion=False, no_args_is_help=True, help="☁️ Cloud management commands")
+
+    app.command(name="sync", no_args_is_help=True, short_help="🔄 [s] Synchronize files/folders between local and cloud storage.")(sync)
+    app.command(name="s", no_args_is_help=True, hidden=True)(sync)
+
+    app.command(name="copy", no_args_is_help=True, short_help="📤 [c] Upload or 📥 Download files/folders to/from cloud storage.")(copy)
+    app.command(name="c", no_args_is_help=True, hidden=True)(copy)
+
+    app.command(name="mount", no_args_is_help=True, short_help="🔗 [m] Mount cloud storage services as local drives.")(mount)
+    app.command(name="m", no_args_is_help=True, hidden=True)(mount)
 
     return app
 

machineconfig/scripts/python/croshell.py

@@ -1,172 +1,25 @@
 #!/usr/bin/env -S uv run --no-dev --project
 
-"""
-croshell
-"""
+"""croshell - Cross-shell command execution."""
 
 from typing import Annotated, Optional
-from machineconfig.scripts.python.helpers_croshell.crosh import code, get_read_data_pycode
-from machineconfig.utils.meta import lambda_to_python_script
 import typer
-from machineconfig.utils.path_extended import PathExtended
-from pathlib import Path
-from machineconfig.utils.accessories import randstr
-import json
-from machineconfig.utils.options import choose_from_options
-from rich.console import Console
-from rich.panel import Panel
-
-
-console = Console()
 
 
 def croshell(
-    path: Annotated[Optional[str], typer.Argument(help="path of file to read.")] = "",
-    python: Annotated[bool, typer.Option("--python", "-p", help="flag to use python over IPython.")] = False,
-    profile: Annotated[Optional[str], typer.Option("--profile", "-P", help="ipython profile to use, defaults to default profile.")] = None,
+    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,
-    streamlit_viewer: Annotated[bool, typer.Option("--streamlit", "-s", help="view in streamlit app")] = False,
     visidata: Annotated[bool, typer.Option("--visidata", "-v", help="open data file in visidata")] = False,
-    marimo: Annotated[bool, typer.Option("--marimo", "-m", help="open the notebook using marimo if available")] = 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:
-    # ==================================================================================
-    # flags processing
-    interactivity = "-i"
-    interpreter = "python" if python else "ipython"
-    ipython_profile: Optional[str] = profile
-    file_obj = PathExtended.cwd()  # initialization value, could be modified according to args.
-
-    if path == ".":
-        text = "🔍 Searching for Python files..."
-        console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
-        options = [str(item) for item in PathExtended.cwd().search("*.py", r=True)]
-        file_selected = choose_from_options(msg="Choose a python file to run", options=options, fzf=True, multi=False)
-        assert isinstance(file_selected, str)
-        program = PathExtended(file_selected).read_text(encoding="utf-8")
-        text = f"📄 Selected file: {PathExtended(file_selected).name}"
-        console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
-
-    elif path != "" and path is not None:
-        if streamlit_viewer:
-            #             text = "📊 STARTING STREAMLIT VIEWER"
-            #             console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
-            #             from machineconfig.scripts.python.viewer import run
-            #             py_file_path = run(data_path=args.read, data=None, get_figure=None)
-            #             final_program = f"""
-            # #!/bin/bash
-            # streamlit run {py_file_path}
-            # """
-            #             PROGRAM_PATH.write_text(data=final_program, encoding="utf-8")
-            print("Streamlit viewer is not yet implemented in this version.")
-            return None
-        file_obj = PathExtended(str(path).lstrip()).expanduser().absolute()
-        program = lambda_to_python_script(lambda: get_read_data_pycode(path=str(file_obj)), in_global=True, import_module=False)
-        text = f"📄 Reading data from: {file_obj.name}"
-        console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
-    else:  # if nothing is specified, then run in interactive mode.
-        # text = "⌨️  Entering interactive mode"
-        # console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
-        # from machineconfig.scripts.python.croshell import InteractiveShell
-        # InteractiveShell().run()
-        # return None
-        program = ""
-    preprogram = """
-#%%
-"""
-    def preprogram_func():
-        from machineconfig.utils.files.headers import print_header, print_logo
-        print_header()
-        print_logo("CROCODILE")
-        from pathlib import Path
-        from machineconfig.utils.path_extended import PathExtended
-        _ = Path, PathExtended  # avoid unused import warnings
-    import inspect, textwrap
-    from types import FunctionType
-    def get_body_simple_function_no_args(f: FunctionType):
-        return textwrap.dedent("\n".join(inspect.getsource(f).splitlines()[1:]))
-    preprogram += get_body_simple_function_no_args(preprogram_func)
-
-    pyfile = PathExtended.tmp().joinpath(f"tmp_scripts/python/croshell/{randstr()}/script.py")
-    pyfile.parent.mkdir(parents=True, exist_ok=True)
-
-    title = "Reading Data"
-    def_code = lambda_to_python_script(lambda: code(path=str(pyfile), title=title), in_global=False, import_module=False)
-    # print(def_code)
-    python_program = preprogram + "\n\n" + def_code + program
-    pyfile.write_text(python_program, encoding="utf-8")
-    # ve_root_from_file, ipython_profile = get_ve_path_and_ipython_profile(PathExtended(file))
-    ipython_profile = ipython_profile if ipython_profile is not None else "default"
-    # ve_activateion_line = get_ve_activate_line(ve_name=args.ve or ve_profile_suggested, a_path=str(PathExtended.cwd()))
-
-    # prepare notebook target path (avoid relying on locals())
-    nb_target = pyfile.with_suffix(".ipynb")
-    if jupyter:
-        try:
-            nb_path = pyfile.with_suffix(".ipynb")
-            nb_content = {
-                "cells": [
-                    {
-                        "cell_type": "code",
-                        "metadata": {"language": "python"},
-                        "source": [python_program],
-                        "outputs": [],
-                        "execution_count": None,
-                    }
-                ],
-                "metadata": {},
-                "nbformat": 4,
-                "nbformat_minor": 5,
-            }
-            nb_path.write_text(json.dumps(nb_content), encoding="utf-8")
-            nb_target = nb_path
-        except Exception:
-            # if writing fails, fall back to the default nb_target already set
-            pass
-    if visidata:
-        if file_obj.suffix == ".json":
-            fire_line = f"uv run --python 3.14 --with visidata vd {str(file_obj)}"
-        else:
-            fire_line = f"uv run --python 3.14 --with visidata,pyarrow vd {str(file_obj)}"
-    elif marimo:
-        if Path.home().joinpath("code/machineconfig").exists(): requirements = f"""--with marimo --project "{str(Path.home().joinpath("code/machineconfig"))}" """
-        else: requirements = """--python 3.14 --with "marimo,machineconfig[plot]>=6.57" """
-        fire_line = f"""
-cd {str(pyfile.parent)}
-uv run --python 3.14 --with "marimo" marimo convert {pyfile.name} -o marimo_nb.py
-uv run {requirements} marimo edit --host 0.0.0.0 marimo_nb.py
-"""
-    elif jupyter:
-        if Path.home().joinpath("code/machineconfig").exists(): requirements = f"""--project "{str(Path.home().joinpath("code/machineconfig"))}" --with jupyterlab """
-        else: requirements = """--with "machineconfig[plot]>=6.57" """
-        fire_line = f"uv run {requirements} jupyter-lab {str(nb_target)}"
-    elif vscode:
-        fire_line = f"""
-cd {str(pyfile.parent)}
-uv init --python 3.14
-uv venv
-uv add "machineconfig[plot]>=6.57"
-# code serve-web
-code --new-window {str(pyfile)}
-"""
-    else:
-        if interpreter == "ipython": profile = f" --profile {ipython_profile} --no-banner"
-        else: profile = ""
-        if Path.home().joinpath("code/machineconfig").exists(): ve_line = f"""--project "{str(Path.home().joinpath("code/machineconfig"))}" """
-        else: ve_line = """--python 3.14 --with "machineconfig[plot]>=6.57" """
-        # ve_path_maybe, ipython_profile_maybe = get_ve_path_and_ipython_profile(Path.cwd())
-        # --python 3.14
-        fire_line = f"uv run {ve_line} {interpreter} {interactivity} {profile} {str(pyfile)}"
-
-    import os
-    program_path_maybe = os.environ.get("OP_PROGRAM_PATH", None)
-    if program_path_maybe is not None:
-        program_path_obj = PathExtended(program_path_maybe)
-        program_path_obj.parent.mkdir(parents=True, exist_ok=True)
-        program_path_obj.write_text(data=fire_line, encoding="utf-8")
-    else:
-        from machineconfig.utils.code import run_shell_script
-        run_shell_script(fire_line, clean_env=False)
+    """Cross-shell command execution."""
+    from machineconfig.scripts.python.helpers.helpers_croshell.croshell_impl import croshell as impl
+    impl(path=path, project_path=project_path, uv_with=uv_with, marimo=marimo, jupyter=jupyter, vscode=vscode, visidata=visidata, python=python, profile=profile)
 
 
 def main() -> None:
@@ -174,9 +27,4 @@ def main() -> None:
 
 
 if __name__ == "__main__":
-    # def func(flag: Annotated[bool, typer.Option("--flag/-nf", help="dummy flag for debugging", flag_value=False, is_flag=True)]=True):
-    #     console.print(f"flag: {flag}")
-    # app = typer.Typer()
-    # app.command()(func)
-    # app()
     main()

machineconfig/scripts/python/devops.py

@@ -1,46 +1,83 @@
-"""devops with emojis"""
+"""devops with emojis - lazy loading subcommands."""
 
 import typer
-from typing import Optional, Annotated
-
-import machineconfig.scripts.python.helpers_devops.cli_repos as cli_repos
-import machineconfig.scripts.python.helpers_devops.cli_config as cli_config
-import machineconfig.scripts.python.helpers_devops.cli_self as cli_self
-import machineconfig.scripts.python.helpers_devops.cli_data as cli_data
-import machineconfig.scripts.python.helpers_devops.cli_nw as cli_network
+from typing import Optional, Annotated, Literal
 
 
 def install(which: Annotated[Optional[str], typer.Argument(..., help="Comma-separated list of program names to install, or group name if --group flag is set.")] = None,
         group: Annotated[bool, typer.Option(..., "--group", "-g", help="Treat 'which' as a group name. A group is bundle of apps.")] = False,
-        interactive: Annotated[bool, typer.Option(..., "--interactive", "-ia", help="Interactive selection of programs to install.")] = False,
+        interactive: Annotated[bool, typer.Option(..., "--interactive", "-i", help="Interactive selection of programs to install.")] = False,
     ) -> None:
-        """📦 Install essential packages"""
-        import machineconfig.utils.installer_utils.installer as installer_entry_point
-        installer_entry_point.main(which=which, group=group, interactive=interactive)
-
-
-def get_app():
-    app = typer.Typer(help="🛠️ DevOps operations", no_args_is_help=True, add_help_option=False,
-                      add_completion=False)
-    _ = install
-    app.command("install", no_args_is_help=True, help="🛠️ [i] Install essential packages")(install)
-    app.command("i", no_args_is_help=True, help="Install essential packages", hidden=True)(install)
-    app_repos = cli_repos.get_app()
-    app.add_typer(app_repos, name="repos")
-    app.add_typer(app_repos, name="r", hidden=True)
-    app_config = cli_config.get_app()
-    app.add_typer(app_config, name="config")
-    app.add_typer(app_config, name="c", hidden=True)
-    app_data = cli_data.get_app()
-    app.add_typer(app_data, name="data")
-    app.add_typer(app_data, name="d", hidden=True)
-    app_self = cli_self.get_app()
-    app.add_typer(app_self, name="self")
-    app.add_typer(app_self, name="s", hidden=True)
-    app_nw = cli_network.get_app()
-    app.add_typer(app_nw, name="network")
-    app.add_typer(app_nw, name="n", hidden=True)
-    return app
+        """📦 Install packages"""
+        import machineconfig.utils.installer_utils.installer_cli as installer_entry_point
+        installer_entry_point.main_installer_cli(which=which, group=group, interactive=interactive)
+
+
+def repos(ctx: typer.Context) -> None:
+    """📁 [r] Manage development repositories"""
+    import machineconfig.scripts.python.helpers.helpers_devops.cli_repos as cli_repos
+    cli_repos.get_app()(ctx.args, standalone_mode=False)
+
+
+def config(ctx: typer.Context) -> None:
+    """⚙️ [c] Configuration management"""
+    import machineconfig.scripts.python.helpers.helpers_devops.cli_config as cli_config
+    cli_config.get_app()(ctx.args, standalone_mode=False)
+
+
+def data(ctx: typer.Context) -> None:
+    """💾 [d] Data management"""
+    import machineconfig.scripts.python.helpers.helpers_devops.cli_data as cli_data
+    cli_data.get_app()(ctx.args, standalone_mode=False)
+
+
+def self_cmd(ctx: typer.Context) -> None:
+    """🔧 [s] Self management"""
+    import machineconfig.scripts.python.helpers.helpers_devops.cli_self as cli_self
+    cli_self.get_app()(ctx.args, standalone_mode=False)
+
+
+def network(ctx: typer.Context) -> None:
+    """🌐 [n] Network management"""
+    import machineconfig.scripts.python.helpers.helpers_devops.cli_nw as cli_network
+    cli_network.get_app()(ctx.args, standalone_mode=False)
+
+
+def execute(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Name of script to run, e.g., 'a' for a.py, or command to execute")] = "",
+    where: Annotated[Literal["all", "a", "private", "p", "public", "b", "library", "l", "dynamic", "d", "custom", "c"], typer.Option("--where", "-w", help="Where to look for the script")] = "all",
+    interactive: Annotated[bool, typer.Option(..., "--interactive", "-i", help="Interactive selection of scripts to run")] = False,
+    command: Annotated[Optional[bool], typer.Option(..., "--command", "-c", help="Run as command")] = False,
+    list_scripts: Annotated[bool, typer.Option(..., "--list", "-l", help="List available scripts in all locations")] = False,
+) -> None:
+    """🚀 Execute python/shell scripts from pre-defined directories or as command."""
+    import machineconfig.scripts.python.helpers.helpers_devops.run_script as run_py_script_module
+    run_py_script_module.run_py_script(ctx=ctx, name=name, where=where, interactive=interactive, command=command, list_scripts=list_scripts)
+
+
+def get_app() -> typer.Typer:
+    cli_app = typer.Typer(help="🛠️ DevOps operations", 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": []}
+
+    cli_app.command("install", no_args_is_help=True, help=install.__doc__, short_help="🛠️ [i] Install essential packages")(install)
+    cli_app.command("i", no_args_is_help=True, help=install.__doc__, hidden=True)(install)
+
+    cli_app.command("repos", help="📁 [r] Manage development repositories", context_settings=ctx_settings)(repos)
+    cli_app.command("r", hidden=True, context_settings=ctx_settings)(repos)
+    cli_app.command("config", help="🔩 [c] Configuration management", context_settings=ctx_settings)(config)
+    cli_app.command("c", hidden=True, context_settings=ctx_settings)(config)
+    cli_app.command("data", help="💾 [d] Data management", context_settings=ctx_settings)(data)
+    cli_app.command("d", hidden=True, context_settings=ctx_settings)(data)
+    cli_app.command("self", help="🔧 [s] Self management", context_settings=ctx_settings)(self_cmd)
+    cli_app.command("s", hidden=True, context_settings=ctx_settings)(self_cmd)
+    cli_app.command("network", help="🌐 [n] Network management", context_settings=ctx_settings)(network)
+    cli_app.command("n", hidden=True, context_settings=ctx_settings)(network)
+
+    cli_app.command("execute", no_args_is_help=True, short_help="🚀 [e] Execute python/shell scripts from pre-defined directories or as command")(execute)
+    cli_app.command("e", no_args_is_help=True, hidden=True)(execute)
+
+    return cli_app
 
 
 def main():

machineconfig/scripts/python/devops_navigator.py

@@ -1,10 +1,20 @@
-"""
-TUI for navigating through machineconfig command structure using Textual.
-"""
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "machineconfig>=8.51",
+#     "textual",
+# ]
+# ///
 
-from machineconfig.scripts.python.helpers_navigator import CommandNavigatorApp
+"""Textual TUI for navigating `machineconfig` command structure."""
+
+
+def main() -> None:
+    from machineconfig.scripts.python.helpers.helpers_navigator.main_app import CommandNavigatorApp
+
+    CommandNavigatorApp().run()
 
 
 if __name__ == "__main__":
-    app = CommandNavigatorApp()
-    app.run()
+    main()