machineconfig 5.15__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,156 +2,153 @@
 
 """
 croshell
+
 """
 
 from typing import Annotated, Optional
 import typer
-from machineconfig.utils.path_extended import 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):
-    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:
-    from machineconfig.utils.files.read import Read
-    dat = Read.read(p)
-    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 main(
+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.")] = "",
     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,
-    visidata: Annotated[bool, typer.Option("--visidata", "-V", help="open data file in visidata")] = 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 = "-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 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 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 = """
-
 #%%
-
-from machineconfig.utils.files.headers import print_header, print_logo
-print_header()
-print_logo("CROCODILE")
-from pathlib import Path
-
 """
-
-    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)
 
     title = "Reading Data"
-    python_program = preprogram + add_print_header_pycode(str(pyfile), title=title) + program
+    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()))
 
+    # 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:
-        fire_line = f"uv run --with visidata,pyarrow vd {str(file_obj)}"
+        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:
-        fire_line = f"code --new-window {str(pyfile)}"
+        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:
         if interpreter == "ipython": profile = f" --profile {ipython_profile} --no-banner"
         else: profile = ""
-        fire_line = f"uv run --python 3.13 --with machineconfig[plot] {interpreter} {interactivity} {profile} {str(pyfile)}"
+        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)}"
 
-    from machineconfig.utils.code import run_shell_script
-    run_shell_script(fire_line)
+    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,106 +1,47 @@
 """devops with emojis"""
 
-import machineconfig.utils.installer_utils.installer as installer_entry_point
-import machineconfig.scripts.python.share_terminal as share_terminal
-import machineconfig.scripts.python.repos as repos
-
-from machineconfig import __version__
 import typer
-
-
-app = typer.Typer(help=f"🛠️ DevOps operations @ machineconfig {__version__}", no_args_is_help=True)
-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.add_typer(repos.app, name="repos", help="📁 Manage git repositories")
-
-ssh_app = typer.Typer(help="🔐 SSH operations subcommands", no_args_is_help=True)
-app.add_typer(ssh_app, name="ssh")
-
-
-@app.command()
-def update():
-    """🔄 UPDATE essential repos"""
-    import machineconfig.scripts.python.devops_update_repos as helper
-    helper.main()
-
-
-@app.command()
-def symlinks():
-    """🔗 SYMLINKS of dotfiles."""
-    import machineconfig.profile.create as helper
-    helper.main_symlinks()
-
-
-@app.command()
-def profile():
-    """🔗 Update shell profile."""
-    import machineconfig.profile.create as helper
-    helper.main_profile()
-
-
-@app.command()
-def symlinks_new():
-    """🆕 SYMLINKS new"""
-    import machineconfig.jobs.python.python_ve_symlink as helper
-    helper.main()
-
-
-@ssh_app.command()
-def add_key():
-    """🔑 SSH add pub key to this machine"""
-    import machineconfig.scripts.python.devops_add_ssh_key as helper
-    helper.main()
-@ssh_app.command()
-def add_identity():
-    """🗝️ SSH add identity (private key) to this machine"""
-    import machineconfig.scripts.python.devops_add_identity as helper
-    helper.main()
-@ssh_app.command()
-def connect():
-    """🔐 SSH use key pair to connect two machines"""
-    raise NotImplementedError
-@ssh_app.command()
-def setup():
-    """📡 SSH setup"""
-    _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
-    from platform import system
-    subprocess.run(_program_linux if system() == "Linux" else _program_windows, shell=True, check=True)
-@ssh_app.command()
-def setup_wsl():
-    """🐧 SSH setup wsl"""
-    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"""
-    from machineconfig.scripts.python.devops_backup_retrieve import main_backup_retrieve
-    main_backup_retrieve(direction="BACKUP")
-
-
-@app.command()
-def retrieve():
-    """📥 RETRIEVE"""
-    from machineconfig.scripts.python.devops_backup_retrieve import main_backup_retrieve
-    main_backup_retrieve(direction="RETRIEVE")
-
-
-@app.command()
-def scheduler():
-    """⏰ SCHEDULER"""
-    # from machineconfig.scripts.python.scheduler import main as helper
-    # helper()
-
-@app.command()
-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()

machineconfig/scripts/python/devops_navigator.py

@@ -0,0 +1,10 @@
+"""
+TUI for navigating through machineconfig command structure using Textual.
+"""
+
+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}"]