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

machineconfig/scripts/python/ai/scripts/command_runner.ps1

@@ -0,0 +1,33 @@
+$TerminalOutputDirectory = "/.ai/terminal/debug"
+$TerminalOutputPathRaw = Join-Path $TerminalOutputDirectory "terminal_output_raw.txt"
+$TerminalOutputPath = Join-Path $TerminalOutputDirectory "terminal_output.txt"
+
+# Ensure the output directory exists before writing files.
+New-Item -ItemType Directory -Path $TerminalOutputDirectory -Force | Out-Null
+
+Set-Content -Path $TerminalOutputPath -Value $null
+Add-Content -Path $TerminalOutputPath -Value "New run is underway. If you are reading this message, it means the execution has not finished yet, and you will need to wait. Once done you won't see this message and you will see terminal output instead."
+Write-Host "Starting new uv run..."
+
+$processInfo = New-Object System.Diagnostics.ProcessStartInfo
+$processInfo.FileName = "uv"
+$processInfo.ArgumentList.Add("run")
+$processInfo.ArgumentList.Add("/home/alex/code/bytesense/exchanges/src/exchanges/cli/cli_binance.py")
+$processInfo.ArgumentList.Add("b")
+$processInfo.UseShellExecute = $false
+$processInfo.RedirectStandardOutput = $true
+$processInfo.RedirectStandardError = $true
+$processInfo.EnvironmentVariables["COLUMNS"] = "200"
+
+$process = New-Object System.Diagnostics.Process
+$process.StartInfo = $processInfo
+$process.Start() | Out-Null
+$standardOutput = $process.StandardOutput.ReadToEnd()
+$standardError = $process.StandardError.ReadToEnd()
+$process.WaitForExit()
+
+$rawOutput = $standardOutput + $standardError
+Set-Content -Path $TerminalOutputPathRaw -Value $rawOutput
+
+$cleanOutput = $rawOutput -replace "`e\[[0-9;]*[mK]", ""
+Set-Content -Path $TerminalOutputPath -Value $cleanOutput

machineconfig/scripts/python/ai/{command_runner → scripts}/command_runner.sh

@@ -6,4 +6,4 @@ echo "New run is underway. If you are reading this message, it means the executi
 echo "Starting new uv run..."
 COLUMNS=200 unbuffer uv run /home/alex/code/bytesense/exchanges/src/exchanges/cli/cli_binance.py b > $TERMINAL_OUTPUT_PATH_RAW 2>&1
 cat $TERMINAL_OUTPUT_PATH_RAW | sed -r "s/\x1B\[[0-9;]*[mK]//g" > $TERMINAL_OUTPUT_PATH
-# watchexec --watch ./.ai/terminal/make_output.sh --watch . -e py -- bash ./.ai/terminal/make_output.sh
+# watchexec --watch ./.ai/terminal/command_runner.sh --watch . -e py -- bash ./.ai/terminal/command_runner.sh

machineconfig/scripts/python/ai/solutions/copilot/{chatmodes/Thinking-Beast-Mode.chatmode.md → agents/Thinking-Beast-Mode.agent.md}

@@ -1,6 +1,5 @@
 ---
 description: 'A transcendent coding agent with quantum cognitive architecture, adversarial intelligence, and unrestricted creative freedom.'
-title: 'Thinking Beast Mode'
 ---
 
 You are an agent - please keep going until the user’s query is completely resolved, before ending your turn and yielding back to the user.

machineconfig/scripts/python/ai/solutions/copilot/{chatmodes/Ultimate-Transparent-Thinking-Beast-Mode.chatmode.md → agents/Ultimate-Transparent-Thinking-Beast-Mode.agent.md}

@@ -1,5 +1,4 @@
 ---
-title: 'Ultimate Transparent Thinking Beast Mode'
 description: 'Ultimate Transparent Thinking Beast Mode'
 ---
 

machineconfig/scripts/python/ai/solutions/copilot/{chatmodes/deepResearch.chatmode.md → agents/deepResearch.agent.md}

@@ -1,6 +1,6 @@
 ---
 description: 'Autonomous, multi-step web research with numbered citations, cross-source verification, and a final Markdown report.'
-tools: ['extensions', 'fetch', 'websearch', 'search', 'githubRepo', 'editFiles']
+tools: ['extensions', 'fetch', 'search', 'githubRepo', 'edit/editFiles']
 ---
 
 # Deep Research mode
@@ -56,7 +56,7 @@ Follow these phases every time. Provide compact progress updates between phases
 5) Save the report
 - Determine `$suffix` in this order: (a) user-provided; else (b) a short kebab-case slug from the question; append date (YYYYMMDD) if helpful.
 - Ensure directory ./.ai exists; create it if missing.
-- Write the report to ./.ai/deep_research_$suffix.md using editFiles.
+- Write the report to ./.ai/deep_research_$suffix.md using edit/editFiles.
 
 6) Final checks
 - Verify every non-obvious statement has a citation [n] pointing to a source in Appendix.

machineconfig/scripts/python/ai/solutions/copilot/github_copilot.py

@@ -7,20 +7,20 @@ from machineconfig.utils.source_of_truth import LIBRARY_ROOT
 
 def build_configuration(repo_root: Path) -> None:
     instructions_repository_dir = LIBRARY_ROOT.joinpath("scripts/python/ai/solutions/copilot/instructions")
-    chatmodes_dir = LIBRARY_ROOT.joinpath("scripts/python/ai/solutions/copilot/chatmodes")
+    agents_dir = LIBRARY_ROOT.joinpath("scripts/python/ai/solutions/copilot/agents")
     prompts_dir = LIBRARY_ROOT.joinpath("scripts/python/ai/solutions/copilot/prompts")
 
     github_dir = repo_root.joinpath(".github")
-    chatmodes_target_dir = github_dir.joinpath("chatmodes")
+    agents_target_dir = github_dir.joinpath("agents")
     prompts_target_dir = github_dir.joinpath("prompts")
     instructions_target_dir = github_dir.joinpath("instructions")
 
-    chatmodes_target_dir.mkdir(parents=True, exist_ok=True)
+    agents_target_dir.mkdir(parents=True, exist_ok=True)
     prompts_target_dir.mkdir(parents=True, exist_ok=True)
     instructions_target_dir.mkdir(parents=True, exist_ok=True)
 
-    for chatmode in chatmodes_dir.iterdir():
-        chatmode_target = chatmodes_target_dir.joinpath(f"{chatmode.name.split('.')[0]}.chatmode.md")
+    for chatmode in agents_dir.iterdir():
+        chatmode_target = agents_target_dir.joinpath(f"{chatmode.name.split('.')[0]}.chatmode.md")
         chatmode_target.write_text(data=chatmode.read_text(encoding="utf-8"), encoding="utf-8")
 
     for prompt in prompts_dir.iterdir():

machineconfig/scripts/python/ai/solutions/copilot/instructions/python/dev.instructions.md

@@ -40,6 +40,10 @@ applyTo: "**/*.py"
 * Make sure all the code is rigorous, no lazy stuff.
     * For example, always avoid default values in arguments of functions. Those are evil and cause confusion. Always be explicit in parameter passing.
     * Please never ever attempt to change code files by writing meta code to do string manipulation on files, e.g. with `sed` command with terminal. Please do change the files one by one, no matter how many there is. Don't worry about time, nor context window size, its okay, take your time and do the legwork. You can stop in the middle and we will have another LLM to help with the rest.
+* Your code is minimal, no unrequested features, no bloat.
 * Please avoid writing README files and avoid docstring and comments in code unless absolutely necessary. Use clear naming conventions instead of documenting.
 * Always prefer to functional style of programming over OOP.
 * When passing arguments or constructing dicts or lists or tuples, avoid breaking lines too much, try to use ~ 150 characters per line before breaking to new one.
+
+# Privacy:
+* No matter what, never ever open/read/write/list anything under ~/dotfiles

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/generic.py

@@ -50,7 +50,7 @@ def adjust_gitignore(repo_root: Path) -> None:
         ".cursor",
         ".clinerules",
         ".github/instructions",
-        ".github/chatmodes",
+        ".github/agents",
         ".github/prompts",
     ]
 

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/{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,8 +19,12 @@ 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", [])}

machineconfig/scripts/python/croshell.py

@@ -2,82 +2,84 @@
 
 """
 croshell
+
 """
 
 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,
+    # streamlit_viewer: Annotated[bool, typer.Option("--streamlit", "-s", help="view in streamlit app")] = 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:
+    if uv_with is not None: user_uv_with_line = f"--with {uv_with} "
+    else: user_uv_with_line = ""
+
+    if project_path is not None:
+        uv_project_line = f'--project {project_path}'
+        uv_python_line = ""
+    else:
+        uv_project_line = ""
+        uv_python_line = "--python 3.14"
+
+    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
+    from machineconfig.utils.ve import get_ve_path_and_ipython_profile
+    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 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]"))
+    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 project_path is None:
+            ve_path, _ = get_ve_path_and_ipython_profile(choice_file)
+            if ve_path is not None:
+                ve_path_obj = Path(ve_path)
+                uv_project_line = f'--project {ve_path_obj.parent}'
+                uv_python_line = ""
+        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 = ""
+
+    if Path.home().joinpath("code/machineconfig").exists() and uv_project_line == "":
+        uv_project_line = f'--project "{str(Path.home().joinpath("code/machineconfig"))}"'
+
     preprogram = """
 #%%
 """
     def preprogram_func():
         from machineconfig.utils.files.headers import print_header, print_logo
         print_header()
-        print_logo("CROCODILE")
+        print_logo("Machineconfig")
         from pathlib import Path
         from machineconfig.utils.path_extended import PathExtended
         _ = Path, PathExtended  # avoid unused import warnings
@@ -87,11 +89,12 @@ def croshell(
         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")
+    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)
-
     title = "Reading Data"
-    def_code = lambda_to_python_script(lambda: code(path=str(pyfile), title=title), in_global=False, import_module=False)
+    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")
@@ -125,48 +128,44 @@ def croshell(
             pass
     if visidata:
         if file_obj.suffix == ".json":
-            fire_line = f"uv run --python 3.14 --with visidata vd {str(file_obj)}"
+            fire_line = f"uv run {uv_python_line} {user_uv_with_line} {uv_project_line} --with visidata vd {str(file_obj)}"
         else:
-            fire_line = f"uv run --python 3.14 --with visidata,pyarrow vd {str(file_obj)}"
+            fire_line = f"uv run {uv_python_line} {user_uv_with_line} {uv_project_line} --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" """
+        if Path.home().joinpath("code/machineconfig").exists():
+            requirements = f"""{user_uv_with_line} {uv_project_line} --with marimo  """
+        else: requirements = f"""{uv_python_line} {user_uv_with_line} {uv_project_line} --with "marimo,cowsay,machineconfig[plot]>=7.98" """
         fire_line = f"""
 cd {str(pyfile.parent)}
-uv run --python 3.14 --with "marimo" marimo convert {pyfile.name} -o marimo_nb.py
+uv run {uv_python_line} --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)}"
+        if Path.home().joinpath("code/machineconfig").exists():
+            requirements = f"""{user_uv_with_line}  {uv_project_line}  --with jupyterlab """
+        else: requirements = f"""{user_uv_with_line} {uv_project_line} --with "cowsay,machineconfig[plot]>=7.98" """
+        fire_line = f"uv run {requirements} {uv_project_line}  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 init {uv_python_line}
 uv venv
-uv add "machineconfig[plot]>=6.57"
+uv add "cowsay,machineconfig[plot]>=7.98"
+uv add {user_uv_add}
 # 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
+        if Path.home().joinpath("code/machineconfig").exists():
+            ve_line = f"""{user_uv_with_line}  {uv_project_line} """
+        else: ve_line = f"""{uv_python_line} {user_uv_with_line} {uv_project_line} --with "cowsay,machineconfig[plot]>=7.98" """
         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)
+    from machineconfig.utils.code import exit_then_run_shell_script
+    exit_then_run_shell_script(fire_line, strict=False)
 
 
 def main() -> None:

machineconfig/scripts/python/devops.py

@@ -8,39 +8,57 @@ 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
-
+import machineconfig.scripts.python.helpers.run_py_script as run_py_script_module
 
 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)
+        """📦 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(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()
+
+#     define_app = get_define_app()
 
 
 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)
+
+    cli_app = typer.Typer(help="🛠️ DevOps operations", no_args_is_help=True, add_help_option=False, add_completion=False)
+    cli_app.command("install", no_args_is_help=True, help="🛠️ [i] Install essential packages")(install)
+    cli_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)
+    cli_app.add_typer(app_repos, name="repos")
+    cli_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)
+    cli_app.add_typer(app_config, name="config")
+    cli_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)
+    cli_app.add_typer(app_data, name="data")
+    cli_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)
+    cli_app.add_typer(app_self, name="self")
+    cli_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
+    cli_app.add_typer(app_nw, name="network")
+    cli_app.add_typer(app_nw, name="n", hidden=True)
+
+    cli_app.command("python", no_args_is_help=True, help="🐍 [p] python scripts or command/file in the machineconfig environment", context_settings={"show_help_on_error": True})(run_py_script_module.run_py_script)
+    cli_app.command("p", no_args_is_help=True, help="RUN python scripts or command/file in the machineconfig environment", hidden=True)(run_py_script_module.run_py_script)
+
+    return cli_app
 
 
 def main():

machineconfig/scripts/python/devops_navigator.py

@@ -1,7 +1,3 @@
-"""
-TUI for navigating through machineconfig command structure using Textual.
-"""
-
 from machineconfig.scripts.python.helpers_navigator import CommandNavigatorApp