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

machineconfig/scripts/python/croshell.py

@@ -1,226 +1,157 @@
-#!/usr/bin/env -S uv run --project
+#!/usr/bin/env -S uv run --no-dev --project
 
 """
 croshell
-"""
-
-import argparse
-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 typing import Optional
-from rich.console import Console
-from rich.panel import Panel
-from rich.text import Text  # Added import for rich.text
-# from machineconfig.utils.utils2 import pprint
-
-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_reduced 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 typing import Annotated, Optional
+import typer
+
+
+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,
+    profile: Annotated[Optional[str], typer.Option("--profile", "-P", help="ipython profile to use, defaults to default profile.")] = None,
+    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,
+    uv_with: Annotated[Optional[str], typer.Option("--uv-with", "-w", help="specify uv with packages to use")] = None,
+    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:
+    if uv_with is not None: user_uv_with_line = f"--with {uv_with} "
+    else: user_uv_with_line = ""
+
+    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 pathlib import Path
+    from machineconfig.utils.accessories import randstr
+    import json
     from rich.console import Console
-    from rich.syntax import Syntax
+    from rich.panel import Panel
     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 build_parser():
-    parser = argparse.ArgumentParser(description="Generic Parser to launch crocodile shell.")
-    # A FLAG:
-    parser.add_argument("--module", "-m", help="flag to run the file as a module as opposed to main.", action="store_true", default=False)  # default is running as main, unless indicated by --module flag.
-    parser.add_argument("--newWindow", "-w", help="flag for running in new window.", action="store_true", default=False)
-    parser.add_argument("--nonInteratctive", "-N", help="flag for a non-interactive session.", action="store_true", default=False)
-    parser.add_argument("--python", "-p", help="flag to use python over IPython.", action="store_true", default=False)
-    parser.add_argument("--fzf", "-F", help="search with fuzzy finder for python scripts and run them", action="store_true", default=False)
-
-    # OPTIONAL KEYWORD
-    parser.add_argument("--ve", "-v", help="virtual enviroment to use, defaults to activated ve, if existed, else ve.", default=None)
-    parser.add_argument("--profile", "-P", help="ipython profile to use, defaults to default profile.", default=None)
-    parser.add_argument("--read", "-r", dest="read", help="read a binary file.", default="")
-    parser.add_argument("--file", "-f", dest="file", help="python file path to interpret", default="")
-    parser.add_argument("--cmd", "-c", dest="cmd", help="python command to interpret", default="")
-    parser.add_argument("--terminal", "-t", dest="terminal", help="specify which terminal to be used. Default console host.", default="")  # can choose `wt`
-    parser.add_argument("--shell", "-S", dest="shell", help="specify which shell to be used. Defaults to CMD.", default="")
-    parser.add_argument("--jupyter", "-j", dest="jupyter", help="run in jupyter interactive console", action="store_true", default=False)
-    parser.add_argument("--stViewer", "-s", dest="streamlit_viewer", help="view in streamlit app", action="store_true", default=False)
-
-    args = parser.parse_args()
-    # print(f"Crocodile.run: args of the firing command = {args.__dict__}")
 
     # ==================================================================================
     # flags processing
-    interactivity = "" if args.nonInteratctive else "-i"
-    interpreter = "python" if args.python else "ipython"
-    ipython_profile: Optional[str] = args.profile
-    file = PathExtended.cwd()  # initialization value, could be modified according to args.
-
-    if args.cmd != "":
-        text = "🖥️  Executing command from CLI argument"
-        console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
-        import textwrap
-
-        program = textwrap.dedent(args.cmd)
-
-    elif args.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 = choose_from_options(msg="Choose a python file to run", options=options, fzf=True, multi=False)
-        assert isinstance(file, str)
-        program = PathExtended(file).read_text(encoding="utf-8")
-        text = f"📄 Selected file: {PathExtended(file).name}"
-        console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
-
-    elif args.file != "":
-        file = PathExtended(args.file.lstrip()).expanduser().absolute()
-        program = get_read_pyfile_pycode(file, as_module=args.module, cmd=args.cmd)
-        text1 = f"📄 Loading file: {file.name}"
-        text2 = f"🔄 Mode: {'Module' if args.module else 'Script'}"
-        console.print(Panel(f"{text1}\n{text2}", title="[bold blue]Info[/bold blue]"))
-
-    elif args.read != "":
-        if args.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 = PathExtended(str(args.read).lstrip()).expanduser().absolute()
-        program = get_read_data_pycode(str(file))
-        text = f"📄 Reading data from: {file.name}"
-        console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
-
+    interactivity = "-i"
+    interpreter = "python" if python else "ipython"
+    ipython_profile: Optional[str] = profile
+    file_obj = Path.cwd()  # initialization value, could be modified according to args.
+    if path is not None:
+        from machineconfig.utils.path_helper import get_choice_file
+        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)
+
+    from pathlib import Path
+    pyfile = Path.home().joinpath(f"tmp_results/tmp_scripts/python/croshell/{randstr()}/script.py")
     pyfile.parent.mkdir(parents=True, exist_ok=True)
-
-    if args.read != "":
-        title = "Reading Data"
-    elif args.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:
+        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 {user_uv_with_line} --with visidata vd {str(file_obj)}"
+        else:
+            fire_line = f"uv run --python 3.14 {user_uv_with_line}--with visidata,pyarrow vd {str(file_obj)}"
+    elif marimo:
+        if Path.home().joinpath("code/machineconfig").exists(): requirements = f"""{user_uv_with_line} --with marimo --project "{str(Path.home().joinpath("code/machineconfig"))}" """
+        else: requirements = f"""--python 3.14 {user_uv_with_line} user_uv_with_line--with "marimo,cowsay,machineconfig[plot]>=7.69" """
+        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"""{user_uv_with_line}  --with jupyterlab --project "{str(Path.home().joinpath("code/machineconfig"))}" """
+        else: requirements = f"""{user_uv_with_line} --with "cowsay,machineconfig[plot]>=7.69" """
+        fire_line = f"uv run {requirements} jupyter-lab {str(nb_target)}"
+    elif vscode:
+        user_uv_add = f"uv add {uv_with}" if uv_with is not None else ""
+        fire_line = f"""
+cd {str(pyfile.parent)}
+uv init --python 3.14
+uv venv
+uv add "cowsay,machineconfig[plot]>=7.69"
+uv add {user_uv_add}
+# code serve-web
+code --new-window {str(pyfile)}
 """
-    if args.jupyter:
-        fire_line = f"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"))
+        if interpreter == "ipython": profile = f" --profile {ipython_profile} --no-banner"
+        else: profile = ""
+        if Path.home().joinpath("code/machineconfig").exists(): ve_line = f"""{user_uv_with_line} --project "{str(Path.home().joinpath("code/machineconfig"))}" """
+        else: ve_line = f"""--python 3.14 {user_uv_with_line} --with "cowsay,machineconfig[plot]>=7.69" """
+        fire_line = f"uv run {ve_line} {interpreter} {interactivity} {profile} {str(pyfile)}"
 
-    # PROGRAM_PATH.write_text(data=final_program, encoding="utf-8")
-    # (PROGRAM_PATH + ".py").write_text(str(pyfile), encoding='utf-8')
-    import subprocess
+    from machineconfig.utils.code import exit_then_run_shell_script
+    exit_then_run_shell_script(fire_line, strict=False)
 
-    subprocess.run(final_program, shell=True, check=True)
 
-    # if platform.system() == "Windows":
-    # return subprocess.run([f"powershell", "-Command", res], shell=True, capture_output=False, text=True, check=True)
-    # else: return subprocess.run([res], shell=True, capture_output=False, text=True, check=True)
+def main() -> None:
+    typer.run(croshell)
 
 
 if __name__ == "__main__":
-    build_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,133 +1,47 @@
 """devops with emojis"""
 
-from machineconfig.utils.options import choose_from_options
-
-from platform import system
-from enum import Enum
-from typing import Optional
-from rich.console import Console
-from rich.panel import Panel
-
-console = Console()
-
-BOX_WIDTH = 150  # width for box drawing
-
-
-class Options(Enum):
-    update = "🔄 UPDATE essential repos"
-    cli_install = "⚙️ DEVAPPS install"
-    sym_path_shell = "🔗 SYMLINKS, SHELL PROFILE, FONT, TERMINAL SETTINGS."
-    sym_new = "🆕 SYMLINKS new"
-    ssh_add_pubkey = "🔑 SSH add pub key to this machine"
-    ssh_add_id = "🗝️ SSH add identity (private key) to this machine"
-    ssh_use_pair = "🔐 SSH use key pair to connect two machines"
-    ssh_setup = "📡 SSH setup"
-    ssh_setup_wsl = "🐧 SSH setup wsl"
-    backup = "💾 BACKUP"
-    retreive = "📥 RETRIEVE"
-    scheduler = "⏰ SCHEDULER"
-
-
-def args_parser():
-    console.print(Panel("🛠️  DevOps Tool Suite", title_align="left", border_style="blue", width=BOX_WIDTH))
-    import argparse
-
-    parser = argparse.ArgumentParser()
-    new_line = "\n\n"
-    parser.add_argument("-w", "--which", help=f"""which option to run\nChoose one of those:\n{new_line.join([f"{item.name}: {item.value}" for item in list(Options)])}""", type=str, default=None)  # , choices=[op.value for op in Options]
-    args = parser.parse_args()
-    main(which=args.which)
-
-
-def main(which: Optional[str] = None):
-    # PathExtended(_program_PATH).delete(sure=True, verbose=False)
-    console.print(Panel("🚀 Initializing DevOps operation...", width=BOX_WIDTH, border_style="blue"))
-    options = [op.value for op in Options]
-    if which is None:
-        try:
-            choice_key = choose_from_options(msg="", options=options, header="🛠️ DEVOPS", default=options[0], multi=False)
-        except KeyboardInterrupt:
-            console.print(Panel("❌ Operation cancelled by user", title_align="left", border_style="red", width=BOX_WIDTH))
-            return
-    else:
-        choice_key = Options[which].value
-
-    console.print(Panel(f"🔧 SELECTED OPERATION\n{choice_key}", title_align="left", border_style="green", width=BOX_WIDTH))
-
-    if choice_key == Options.update.value:
-        console.print(Panel("🔄 Updating essential repositories...", width=BOX_WIDTH, border_style="blue"))
-        import machineconfig.scripts.python.devops_update_repos as helper
-
-        helper.main()
-    elif choice_key == Options.cli_install.value:
-        console.print(Panel("⚙️  Installing development applications...", width=BOX_WIDTH, border_style="blue"))
-        import machineconfig.scripts.python.devops_devapps_install as helper
-
-        helper.main(which=None)
-
-    elif choice_key == Options.sym_new.value:
-        console.print(Panel("🔄 Creating new symlinks...", width=BOX_WIDTH, border_style="blue"))
-        import machineconfig.jobs.python.python_ve_symlink as helper
-
-        helper.main()
-
-    elif choice_key == Options.sym_path_shell.value:
-        console.print(Panel("🔗 Setting up symlinks, PATH, and shell profile...", width=BOX_WIDTH, border_style="blue"))
-        import machineconfig.profile.create as helper
-
-        helper.main()
-        "echo '✅ done with symlinks'"
-
-    elif choice_key == Options.ssh_add_pubkey.value:
-        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()
-
-    elif choice_key == Options.ssh_use_pair.value:
-        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
-
-    elif choice_key == Options.ssh_add_id.value:  # so that you can SSH directly withuot pointing to identity key.
-        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()
-
-    elif choice_key == Options.ssh_setup.value:
-        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"""
-        _program_linux if system() == "Linux" else _program_windows
-        import subprocess
-
-        subprocess.run(_program_linux if system() == "Linux" else _program_windows, shell=True, check=True)
-
-    elif choice_key == Options.ssh_setup_wsl.value:
-        console.print(Panel("🐧 Setting up SSH for WSL...", width=BOX_WIDTH, border_style="blue"))
-        """curl https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_linux/openssh_wsl.sh | sudo bash"""
-
-    elif choice_key == Options.backup.value:
-        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")
-
-    elif choice_key == Options.retreive.value:
-        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")
-
-    elif choice_key == Options.scheduler.value:
-        console.print(Panel("⏰ Setting up scheduler...", width=BOX_WIDTH, border_style="blue"))
-        # from machineconfig.scripts.python.scheduler import main as helper
-        # helper()
-
-    else:
-        console.print(Panel("❌ ERROR: Invalid choice", title_align="left", border_style="red", width=BOX_WIDTH))
-        raise ValueError(f"Unimplemented choice: {choice_key}")
-
-
-if __name__ == "__main__":
-    args_parser()
+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
+
+
+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_installer_cli(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()

machineconfig/scripts/python/devops_navigator.py

@@ -0,0 +1,6 @@
+from machineconfig.scripts.python.helpers_navigator import CommandNavigatorApp
+
+
+if __name__ == "__main__":
+    app = CommandNavigatorApp()
+    app.run()

machineconfig/scripts/python/env_manager/__init__.py

@@ -0,0 +1 @@
+a = 2

machineconfig/scripts/python/env_manager/path_manager_backend.py

@@ -0,0 +1,47 @@
+"""Cross-platform PATH explorer backend."""
+
+import os
+import platform
+from pathlib import Path
+from typing import Literal
+
+
+PlatformType = Literal["Windows", "Linux", "Darwin"]
+
+
+def get_platform() -> PlatformType:
+    """Get the current platform."""
+    return platform.system()  # type: ignore[return-value]
+
+
+def get_path_entries() -> list[str]:
+    """Get all PATH entries for the current platform."""
+    path_str = os.environ.get("PATH", "")
+    separator = ";" if get_platform() == "Windows" else ":"
+    return [entry for entry in path_str.split(separator) if entry.strip()]
+
+
+def get_directory_contents(directory: str, max_items: int = 50) -> list[str]:
+    """Get contents of a directory, limited to max_items."""
+    try:
+        path = Path(directory)
+        if not path.exists():
+            return ["⚠️  Directory does not exist"]
+        if not path.is_dir():
+            return ["⚠️  Not a directory"]
+        
+        items = []
+        for item in sorted(path.iterdir(), key=lambda p: (not p.is_dir(), p.name.lower())):
+            if len(items) >= max_items:
+                items.append(f"... and {sum(1 for _ in path.iterdir()) - max_items} more items")
+                break
+            prefix = "📁 " if item.is_dir() else "📄 "
+            items.append(f"{prefix}{item.name}")
+        
+        if not items:
+            return ["📭 Empty directory"]
+        return items
+    except PermissionError:
+        return ["⚠️  Permission denied"]
+    except Exception as e:
+        return [f"⚠️  Error: {e!s}"]