machineconfig 3.99__py3-none-any.whl → 7.66__py3-none-any.whl

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

@@ -1,14 +1,36 @@
+
 from pathlib import Path
+import platform
 
 from machineconfig.utils.source_of_truth import LIBRARY_ROOT
 
 
 def create_dot_scripts(repo_root: Path) -> None:
     scripts_dir = LIBRARY_ROOT.joinpath("scripts/python/ai/scripts")
-    target_dir = repo_root.joinpath(".scripts")
+    target_dir = repo_root.joinpath(".ai/scripts")
+    import shutil
+    shutil.rmtree(target_dir, ignore_errors=True)
     target_dir.mkdir(parents=True, exist_ok=True)
-    for script_path in scripts_dir.iterdir():
-        target_dir.joinpath(script_path.name).write_text(data=script_path.read_text(encoding="utf-8"), encoding="utf-8")
+    import platform
+    if platform.system() == "Windows":
+        script_path = scripts_dir.joinpath("lint_and_type_check.ps1")
+    elif platform.system() in ["Linux", "Darwin"]:
+        script_path = scripts_dir.joinpath("lint_and_type_check.sh")
+    else:
+        raise NotImplementedError(f"Platform {platform.system()} is not supported.")
+    target_dir.joinpath(script_path.name).write_text(data=script_path.read_text(encoding="utf-8"), encoding="utf-8")
+
+
+def adjust_for_os(config_path: Path) -> str:
+    if config_path.suffix not in [".md", ".txt"]:
+        return config_path.read_text(encoding="utf-8")
+    english_text = config_path.read_text(encoding="utf-8")
+    if platform.system() == "Windows":
+        return english_text.replace("bash", "PowerShell").replace("sh ", "pwsh ").replace("./", ".\\").replace(".sh", ".ps1")
+    elif platform.system() in ["Linux", "Darwin"]:
+        return english_text.replace("PowerShell", "bash").replace("pwsh ", "sh ").replace(".\\", "./").replace(".ps1", ".sh")
+    else:
+        raise NotImplementedError(f"Platform {platform.system()} is not supported.")
 
 
 def adjust_gitignore(repo_root: Path) -> None:
@@ -22,10 +44,11 @@ def adjust_gitignore(repo_root: Path) -> None:
         ".links",
         "notebooks",
         ".ai",
-        ".scripts",
         "GEMINI.md",
         "CLAUDE.md",
+        "CRUSH.md",
         ".cursor",
+        ".clinerules",
         ".github/instructions",
         ".github/chatmodes",
         ".github/prompts",

machineconfig/scripts/python/ai/vscode_tasks.py

@@ -0,0 +1,37 @@
+import json
+from pathlib import Path
+from typing import Any
+
+
+def add_lint_and_type_check_task(repo_root: Path) -> None:
+    vscode_dir = repo_root / ".vscode"
+    vscode_dir.mkdir(parents=True, exist_ok=True)
+    tasks_json_path = vscode_dir / "tasks.json"
+
+    task_to_add = {
+        "label": "lint_and_type_check",
+        "type": "shell",
+        "linux": {"command": "bash", "args": ["./.ai/scripts/lint_and_type_check.sh"]},
+        "osx": {"command": "bash", "args": ["./.ai/scripts/lint_and_type_check.sh"]},
+        "windows": {"command": "pwsh", "args": ["-File", "./.ai/scripts/lint_and_type_check.ps1"]},
+        "presentation": {"reveal": "always", "panel": "new"},
+        "problemMatcher": [],
+    }
+
+    if tasks_json_path.exists():
+        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)
+    else:
+        tasks_config = {"version": "2.0.0", "tasks": [task_to_add]}
+
+    with tasks_json_path.open("w") as f:
+        json.dump(tasks_config, f, indent="\t")

machineconfig/scripts/python/cloud.py

@@ -0,0 +1,29 @@
+
+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
+
+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
+
+    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
+
+    return app
+
+
+def main():
+    app = get_app()
+    app()
+
+
+if __name__ == "__main__":
+    pass
+    # a = get_app()(asdf)

machineconfig/scripts/python/croshell.py

@@ -2,217 +2,153 @@
 
 """
 croshell
+
 """
 
 from typing import Annotated, Optional
 import typer
-from machineconfig.utils.path_extended import PathExtended as PathExtended
-from machineconfig.utils.accessories import randstr
-
-from machineconfig.utils.options import choose_from_options
-from machineconfig.utils.ve import get_ve_activate_line
-from rich.console import Console
-from rich.panel import Panel
-from rich.text import Text
-
-console = Console()
-
-
-def add_print_header_pycode(path: str, title: str):
-    return f"""
-try:
-    from crocodile.file_management import P as PathExtended
-except ImportError:
-    from machineconfig.utils.path_extended import PathExtended
-pycode = PathExtended(r'{path}').read_text(encoding="utf-8")
-pycode = pycode.split("except Exception: print(pycode)")[2]
-
-try:
-    from rich.text import Text
-    from rich.panel import Panel
-    from rich.console import Console
-    from rich.syntax import Syntax
-    console = Console()
-    if pycode.strip() != "":
-        console.print(Panel(Syntax(pycode, lexer="python"), title='{title}'), style="bold red")
-except Exception: print(pycode)
-"""
 
 
-def get_read_data_pycode(path: str):
-    # We need to be careful here since we're generating Python code as a string
-    # that will use f-strings itself
-    return f"""
-from rich.panel import Panel
-from rich.text import Text
-from rich.console import Console
-console = Console()
-p = PathExtended(r'{path}').absolute()
-try:
-    dat = p.readit()
-    if isinstance(dat, dict):
-        panel_title = f"📄 File Data: {{p.name}}"
-        console.print(Panel(Text(str(dat), justify="left"), title=panel_title, expand=False))
-        pprint(dat, PathExtended.name)
-    else:
-        panel_title = f"📄 Successfully read the file: {{p.name}}"
-        console.print(Panel(Text(str(dat), justify="left"), title=panel_title, expand=False))
-except Exception as e:
-    error_message = f'''❌ ERROR READING FILE\nFile: {{p.name}}\nError: {{e}}'''
-    console.print(Panel(Text(error_message, justify="left"), title="Error", expand=False, border_style="red"))
-"""
-
-
-def get_read_pyfile_pycode(path: PathExtended, as_module: bool, cmd: str = ""):
-    if as_module:
-        pycode = rf"""
-import sys
-sys.path.append(r'{path.parent}')
-from {path.stem} import *
-{cmd}
-"""
-    else:
-        pycode = f"""
-__file__ = PathExtended(r'{path}')
-{path.read_text(encoding="utf-8")}
-"""
-    return pycode
-
-
-def main(
-    module: Annotated[bool, typer.Option("--module", "-m", help="flag to run the file as a module as opposed to main.")] = False,
-    newWindow: Annotated[bool, typer.Option("--newWindow", "-w", help="flag for running in new window.")] = False,
-    nonInteratctive: Annotated[bool, typer.Option("--nonInteratctive", "-N", help="flag for a non-interactive session.")] = False,
+def croshell(
+    path: Annotated[Optional[str], typer.Argument(help="path of file to read.")] = None,
     python: Annotated[bool, typer.Option("--python", "-p", help="flag to use python over IPython.")] = False,
-    fzf: Annotated[bool, typer.Option("--fzf", "-F", help="search with fuzzy finder for python scripts and run them")] = False,
-    ve: Annotated[Optional[str], typer.Option("--ve", "-v", help="virtual enviroment to use, defaults to activated ve, if existed, else ve.")] = None,
     profile: Annotated[Optional[str], typer.Option("--profile", "-P", help="ipython profile to use, defaults to default profile.")] = None,
-    read: Annotated[str, typer.Option("--read", "-r", help="read a binary file.")] = "",
-    file: Annotated[str, typer.Option("--file", "-f", help="python file path to interpret")] = "",
-    cmd: Annotated[str, typer.Option("--cmd", "-c", help="python command to interpret")] = "",
-    terminal: Annotated[str, typer.Option("--terminal", "-t", help="specify which terminal to be used. Default console host.")] = "",
-    shell: Annotated[str, typer.Option("--shell", "-S", help="specify which shell to be used. Defaults to CMD.")] = "",
     jupyter: Annotated[bool, typer.Option("--jupyter", "-j", help="run in jupyter interactive console")] = False,
-    streamlit_viewer: Annotated[bool, typer.Option("--stViewer", "-s", help="view in streamlit app")] = 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,
 ) -> None:
+    from machineconfig.scripts.python.helpers_croshell.crosh import get_read_python_file_pycode, get_read_data_pycode
+    from machineconfig.utils.meta import lambda_to_python_script
+    from machineconfig.utils.path_helper import get_choice_file
+    from machineconfig.utils.path_extended import PathExtended
+    from pathlib import Path
+    from machineconfig.utils.accessories import randstr
+    import json
+    from rich.console import Console
+    from rich.panel import Panel
+    console = Console()
+
     # ==================================================================================
     # flags processing
-    interactivity = "" if nonInteratctive else "-i"
+    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 cmd != "":
-        text = "🖥️  Executing command from CLI argument"
-        console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
-        import textwrap
-
-        program = textwrap.dedent(cmd)
-
-    elif fzf:
-        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 file != "":
-        file_obj = PathExtended(file.lstrip()).expanduser().absolute()
-        program = get_read_pyfile_pycode(file_obj, as_module=module, cmd=cmd)
-        text1 = f"📄 Loading file: {file_obj.name}"
-        text2 = f"🔄 Mode: {'Module' if module else 'Script'}"
-        console.print(Panel(f"{text1}\n{text2}", title="[bold blue]Info[/bold blue]"))
-
-    elif read != "":
-        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")
-            return None
-        file_obj = PathExtended(str(read).lstrip()).expanduser().absolute()
-        program = get_read_data_pycode(str(file_obj))
-        text = f"📄 Reading data from: {file_obj.name}"
-        console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
-
+    file_obj = Path.cwd()  # initialization value, could be modified according to args.
+    if path is not None:
+        choice_file = get_choice_file(path=path, suffixes={".*"})
+        if choice_file.suffix == ".py":
+            program = choice_file.read_text(encoding="utf-8")
+            text = f"📄 Selected file: {choice_file.name}"
+            console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
+        else:
+            program = lambda_to_python_script(lambda: get_read_data_pycode(path=str(choice_file)),
+                                              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 = """
-
 #%%
-try:
-    from crocodile.croshell import *
-    print_header()
-    print_logo(logo="crocodile")
-except ImportError:
-    print("Crocodile not found, skipping import.")
-from pathlib import Path
-print(f"🐊 Crocodile Shell | Running @ {Path.cwd()}")
 """
-
-    pyfile = PathExtended.tmp().joinpath(f"tmp_scripts/python/croshell/{randstr()}.py")
+    def preprogram_func():
+        from machineconfig.utils.files.headers import print_header, print_logo
+        print_header()
+        print_logo("Machineconfig")
+        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)
 
-    if read != "":
-        title = "Reading Data"
-    elif file != "":
-        title = "Running Python File"
-    else:
-        title = "Executed code"
-    total_program = preprogram + add_print_header_pycode(str(pyfile), title=title) + program
-
-    pyfile.write_text(total_program, encoding="utf-8")
-
+    title = "Reading Data"
+    def_code = lambda_to_python_script(lambda: get_read_python_file_pycode(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()))
-    activate_ve_line = get_ve_activate_line(ve_root="$HOME/code/machineconfig/.venv")
-    final_program = f"""
-#!/bin/bash
-
-{activate_ve_line}
 
-"""
+    # prepare notebook target path (avoid relying on locals())
+    nb_target = pyfile.with_suffix(".ipynb")
     if jupyter:
-        fire_line = f"code --new-window {str(pyfile)}"
+        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,cowsay,machineconfig[plot]>=7.66" """
+        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 "cowsay,machineconfig[plot]>=7.66" """
+        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 "cowsay,machineconfig[plot]>=7.66"
+# code serve-web
+code --new-window {str(pyfile)}
+"""
     else:
-        fire_line = interpreter
-        if interpreter == "ipython":
-            fire_line += f" {interactivity} --profile {ipython_profile} --no-banner"
-        fire_line += f" {str(pyfile)}"
-
-    final_program += fire_line
-
-    title = "🚀 LAUNCHING SCRIPT"
-    text1 = f"📄 Script: {pyfile}"
-    text2 = f"🔥 Command: {fire_line}"
-    launch_message = f"{title}   \n{text1}\n{text2}"
-    console.print(Panel(Text(launch_message, justify="left"), expand=False, border_style="blue"))
-
-    # PROGRAM_PATH.write_text(data=final_program, encoding="utf-8")
-    # (PROGRAM_PATH + ".py").write_text(str(pyfile), encoding='utf-8')
-    import subprocess
+        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 "cowsay,machineconfig[plot]>=7.66" """
+        # 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)}"
 
-    subprocess.run(final_program, shell=True, check=True)
+    from machineconfig.utils.code import exit_then_run_shell_script
+    exit_then_run_shell_script(fire_line, strict=False)
 
 
-def arg_parser() -> None:
-    typer.run(main)
+def main() -> None:
+    typer.run(croshell)
 
 
 if __name__ == "__main__":
-    arg_parser()
+    # 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/define.py

@@ -0,0 +1,31 @@
+
+"""
+Minimalist programs that only print scripts without frills so it can be sourced by by shell.
+"""
+
+
+import typer
+
+
+def define_scripts():
+    import platform
+    if platform.system() != "Linux":
+        raise RuntimeError("This command is only supported on Linux systems.")
+    from machineconfig.setup_linux import INTERACTIVE as script_path
+    script = script_path.read_text(encoding="utf-8")
+    print(script)
+
+
+def get_app():
+    app = typer.Typer(add_completion=False, no_args_is_help=True)
+    app.command(name="scripts", help="define all scripts", no_args_is_help=False)(define_scripts)
+    return app
+
+def main():
+    # return app
+    app = get_app()
+    app()
+
+
+# if __name__ == "__main__":
+#     main()

machineconfig/scripts/python/devops.py

@@ -1,127 +1,47 @@
 """devops with emojis"""
 
-from machineconfig.scripts.python.share_terminal import main as share_terminal_main
-import machineconfig.scripts.python.devops_devapps_install as installer_entry_point
-
-from platform import system
-from rich.console import Console
-from rich.panel import Panel
 import typer
-
-console = Console()
-app = typer.Typer(help="🛠️ DevOps operations with emojis", no_args_is_help=True)
-
-
-BOX_WIDTH = 150  # width for box drawing
-
-
-@app.command()
-def update():
-    """🔄 UPDATE essential repos"""
-    console.print(Panel("🔄 Updating essential repositories...", width=BOX_WIDTH, border_style="blue"))
-    import machineconfig.scripts.python.devops_update_repos as helper
-    helper.main()
-
-
-app.command(name="install", help="📦 Install essential packages")(installer_entry_point.main)
-app.command(name="share-terminal", help="📡 Share terminal via web browser")(share_terminal_main)
-
-
-
-@app.command()
-def symlinks():
-    """🔗 SYMLINKS of dotfiles."""
-    console.print(Panel("🔗 Setting up symlinks, PATH, and shell profile...", width=BOX_WIDTH, border_style="blue"))
-    import machineconfig.profile.create as helper
-    helper.main_symlinks()
-
-
-@app.command()
-def profile():
-    """🔗 Update shell profile."""
-    console.print(Panel("🔗 Setting up symlinks, PATH, and shell profile...", width=BOX_WIDTH, border_style="blue"))
-    import machineconfig.profile.create as helper
-    helper.main_profile()
-
-
-@app.command()
-def symlinks_new():
-    """🆕 SYMLINKS new"""
-    console.print(Panel("🔄 Creating new symlinks...", width=BOX_WIDTH, border_style="blue"))
-    import machineconfig.jobs.python.python_ve_symlink as helper
-    helper.main()
-
-
-@app.command()
-def ssh_add_key():
-    """🔑 SSH add pub key to this machine"""
-    console.print(Panel("🔑 Adding public SSH key to this machine...", width=BOX_WIDTH, border_style="blue"))
-    import machineconfig.scripts.python.devops_add_ssh_key as helper
-    helper.main()
-
-
-@app.command()
-def ssh_add_identity():
-    """🗝️ SSH add identity (private key) to this machine"""
-    console.print(Panel("🗝️  Adding SSH identity (private key) to this machine...", width=BOX_WIDTH, border_style="blue"))
-    import machineconfig.scripts.python.devops_add_identity as helper
-    helper.main()
-
-
-@app.command()
-def ssh_connect():
-    """🔐 SSH use key pair to connect two machines"""
-    console.print(Panel("❌ ERROR: Not Implemented\nSSH key pair connection feature is not yet implemented", title_align="left", border_style="red", width=BOX_WIDTH))
-    raise NotImplementedError
-
-
-@app.command()
-def ssh_setup():
-    """📡 SSH setup"""
-    console.print(Panel("📡 Setting up SSH...", width=BOX_WIDTH, border_style="blue"))
-    _program_windows = """Invoke-WebRequest https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_windows/openssh_all.ps1 | Invoke-Expression  # https://github.com/thisismygitrepo.keys"""
-    _program_linux = """curl https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_linux/openssh_all.sh | sudo bash  # https://github.com/thisismygitrepo.keys"""
-    import subprocess
-    subprocess.run(_program_linux if system() == "Linux" else _program_windows, shell=True, check=True)
-
-
-@app.command()
-def ssh_setup_wsl():
-    """🐧 SSH setup wsl"""
-    console.print(Panel("🐧 Setting up SSH for WSL...", width=BOX_WIDTH, border_style="blue"))
-    import subprocess
-    subprocess.run("curl https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_linux/openssh_wsl.sh | sudo bash", shell=True, check=True)
-
-
-@app.command()
-def backup():
-    """💾 BACKUP"""
-    console.print(Panel("💾 Creating backup...", width=BOX_WIDTH, border_style="blue"))
-    from machineconfig.scripts.python.devops_backup_retrieve import main_backup_retrieve
-    main_backup_retrieve(direction="BACKUP")
-
-
-@app.command()
-def retrieve():
-    """📥 RETRIEVE"""
-    console.print(Panel("📥 Retrieving backup...", width=BOX_WIDTH, border_style="blue"))
-    from machineconfig.scripts.python.devops_backup_retrieve import main_backup_retrieve
-    main_backup_retrieve(direction="RETRIEVE")
-
-
-@app.command()
-def scheduler():
-    """⏰ SCHEDULER"""
-    console.print(Panel("⏰ Setting up scheduler...", width=BOX_WIDTH, border_style="blue"))
-    # from machineconfig.scripts.python.scheduler import main as helper
-    # helper()
-
-@app.command("ia")
-def interactive():
-    """🤖 INTERACTIVE configuration of machine."""
-    from machineconfig.scripts.python.interactive import main
-    main()
-
-
-if __name__ == "__main__":
-    pass
+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
+
+
+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", "-i", help="Interactive selection of programs to install.")] = False,
+    ) -> None:
+        """📦 Install packages"""
+        import machineconfig.utils.installer_utils.installer_cli 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)
+    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
+
+
+def main():
+    app = get_app()
+    app()