machineconfig 7.50__py3-none-any.whl → 8.14__py3-none-any.whl

machineconfig/scripts/python/msearch.py

@@ -1,21 +1,72 @@
 
 import typer
+from typing import Annotated
 
 
-def machineconfig_find():
+def machineconfig_search(
+        directory: Annotated[str, typer.Option(..., "--directory", "-d", help="The directory to search")] = ".",
+        ast: Annotated[bool, typer.Option(..., "--ast", "-a", help="The abstract syntax tree search/ tree sitter search of symbols")] = False,
+        symantic: Annotated[bool, typer.Option(..., "--symantic", "-s", help="The symantic search of symbols")] = False,
+        extension: Annotated[str, typer.Option(..., "--extension", "-e", help="File extension to filter by (e.g., .py, .js)")] = "",
+        file: Annotated[bool, typer.Option(..., "--file", "-f", help="File search using fzf")] = False,
+        no_dotfiles: Annotated[bool, typer.Option(..., "--no-dotfiles", "-D", help="Exclude dotfiles from search")] = False,
+        rga: Annotated[bool, typer.Option(..., "--rga", "-A", help="Use ripgrep-all for searching all (non text files) instead of ripgrep")] = False,
+        install_dependencies: Annotated[bool, typer.Option(..., "--install-req", "-p", help="Install required dependencies if missing")] = False
+        ):
+    """machineconfig search helper"""
+    if install_dependencies:
+        from machineconfig.utils.installer_utils.installer_cli import install_if_missing
+        install_if_missing("fzf")
+        install_if_missing("tv")
+        install_if_missing("bat")
+        install_if_missing("fd")
+        install_if_missing("rg")  # ripgrep
+        install_if_missing("rga")  # ripgrep-all
+        # install_if_missing("tree-sitter-cli")
+        return
+    if symantic:
+        script = ""
+        for an_ex in extension.split(","):
+            script = script + f"""\nparse *.{an_ex} """
+        from machineconfig.utils.code import run_shell_script
+        run_shell_script(script=script)
+        return
+    if ast:
+        from machineconfig.scripts.python.helpers.ast_search import get_repo_symbols
+        symbols = get_repo_symbols(directory)
+        from machineconfig.utils.options import choose_from_options
+        try:
+            res = choose_from_options(options=symbols, msg="Select a symbol to search for:", tv=True, multi=False)
+            from rich import print_json
+            import json
+            res_json = json.dumps(res, indent=4)
+            print_json(res_json)
+            return None
+        except Exception as e:
+            print(f"❌ Error during selection: {e}")
+            return None
+    if file:
+        script = """fzf --ansi --preview-window 'right:60%' --preview 'bat --color=always --style=numbers,grid,header --line-range :300 {}' """
+        if no_dotfiles:
+            script = "fd | " + script
+        from machineconfig.utils.code import run_shell_script
+        run_shell_script(script=script)
+        return
     from machineconfig.scripts.python.helpers_msearch import FZFG_LINUX_PATH, FZFG_WINDOWS_PATH
     import platform
-    if platform.system() == "Linux":
-        script_path = FZFG_LINUX_PATH
+    if platform.system() == "Linux" or platform.system() == "Darwin":
+        script = FZFG_LINUX_PATH.read_text(encoding="utf-8")
     elif platform.system() == "Windows":
-        script_path = FZFG_WINDOWS_PATH
+        script = FZFG_WINDOWS_PATH.read_text(encoding="utf-8")
     else:
         raise RuntimeError("Unsupported platform")
+    if rga:
+        script = script.replace("rg ", "rga ").replace("ripgrep", "ripgrep-all")
     from machineconfig.utils.code import exit_then_run_shell_script
-    exit_then_run_shell_script(script=script_path.read_text(encoding="utf-8"), strict=False)
+    exit_then_run_shell_script(script=script, strict=False)
 
 
 def main():
     app = typer.Typer(add_completion=False, no_args_is_help=True)
-    app.command(name="msearch", help="machineconfig search helper", no_args_is_help=False)(machineconfig_find)
+    app.command(name="msearch", help=machineconfig_search.__doc__, short_help="machineconfig search helper", no_args_is_help=False)(machineconfig_search)
     app()

machineconfig/scripts/python/sessions.py

@@ -1,32 +1,56 @@
 
-from pathlib import Path
 from typing import Optional, Literal, Annotated
 import typer
 
-def balance_load(layout_path: Annotated[Path, typer.Argument(..., help="Path to the layout.json file")],
-           max_thresh: Annotated[int, typer.Option(..., help="Maximum tabs per layout")],
-           thresh_type: Annotated[Literal['number', 'weight'], typer.Option(..., help="Threshold type")],
-           breaking_method: Annotated[Literal['moreLayouts', 'combineTabs'], typer.Option(..., help="Breaking method")],
-           output_path: Annotated[Optional[Path], typer.Option(..., help="Path to write the adjusted layout.json file")] = None):
+
+def balance_load(layout_path: Annotated[str, typer.Argument(..., help="Path to the layout.json file")],
+           max_thresh: Annotated[int, typer.Option(..., "--max-threshold", "-m", help="Maximum tabs per layout")],
+           thresh_type: Annotated[Literal['number', 'n', 'weight', 'w'], typer.Option(..., "--threshold-type", "-t", help="Threshold type")],
+           breaking_method: Annotated[Literal['moreLayouts', 'ml', 'combineTabs', 'ct'], typer.Option(..., "--breaking-method", "-b", help="Breaking method")],
+           output_path: Annotated[Optional[str], typer.Option(..., "--output-path", "-o", help="Path to write the adjusted layout.json file")] = None):
     """Adjust layout file to limit max tabs per layout, etc."""
+    thresh_type_resolved: dict[str, Literal['number', 'weight']] = {
+        'number': 'number',
+        'n': 'number',
+        'weight': 'weight',
+        'w': 'weight'
+    }
+    breaking_method_resolved: dict[str, Literal['moreLayouts', 'combineTabs']] = {
+        'moreLayouts': 'moreLayouts',
+        'ml': 'moreLayouts',
+        'combineTabs': 'combineTabs',
+        'ct': 'combineTabs'
+    }
+    from pathlib import Path
+    layout_path_obj = Path(layout_path).expanduser().absolute()
+
     from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
     import json
-    layoutfile: LayoutsFile = json.loads(layout_path.read_text())
+    layoutfile: LayoutsFile = json.loads(layout_path_obj.read_text())
     layout_configs = layoutfile["layouts"]
     from machineconfig.cluster.sessions_managers.utils.load_balancer import limit_tab_num
-    new_layouts = limit_tab_num(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=thresh_type, breaking_method=breaking_method)
+    new_layouts = limit_tab_num(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=thresh_type_resolved[thresh_type], breaking_method=breaking_method_resolved[breaking_method])
     layoutfile["layouts"] = new_layouts
-    target_file = output_path if output_path is not None else layout_path.parent / f'{layout_path.stem}_adjusted_{max_thresh}_{thresh_type}_{breaking_method}.json'
+    target_file = Path(output_path) if output_path is not None else layout_path_obj.parent / f'{layout_path_obj.stem}_adjusted_{max_thresh}_{thresh_type}_{breaking_method}.json'
     target_file.parent.mkdir(parents=True, exist_ok=True)
     target_file.write_text(data=json.dumps(layoutfile, indent=4), encoding="utf-8")
     typer.echo(f"Adjusted layout saved to {target_file}")
 
 
-def select_layout(layouts_json_file: Path, selected_layouts_names: Optional[list[str]], select_interactively: bool) -> list["LayoutConfig"]:
+def select_layout(layouts_json_file: str, selected_layouts_names: Optional[list[str]], select_interactively: bool,
+                  subsitute_home: bool
+                  ) -> list["LayoutConfig"]:
     import json
     from machineconfig.utils.options import choose_from_options
     from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
-    layout_file: LayoutsFile = json.loads(layouts_json_file.read_text(encoding="utf-8"))
+    from pathlib import Path
+    json_str = Path(layouts_json_file).read_text(encoding="utf-8")
+    if subsitute_home:
+        json_str = json_str.replace("~", str(Path.home())).replace("$HOME", str(Path.home()))
+        json_str = json_str.replace("""Command": "f """, """Command": "~/.config/machineconfig/scripts/wrap_mcfg fire """)
+        json_str = json_str.replace("""Command": "s """, """Command": "~/.config/machineconfig/scripts/wrap_mcfg sessions """)
+
+    layout_file: LayoutsFile = json.loads(json_str)
     if len(layout_file["layouts"]) == 0:
         raise ValueError(f"No layouts found in {layouts_json_file}")
     if selected_layouts_names is None:  # choose all, or interactively
@@ -34,7 +58,7 @@ def select_layout(layouts_json_file: Path, selected_layouts_names: Optional[list
             return layout_file["layouts"]
         options = [layout["layoutName"] for layout in layout_file["layouts"]]
         from machineconfig.utils.options import choose_from_options
-        selected_layouts_names = choose_from_options(multi=True, options=options, prompt="Choose a layout configuration:", fzf=True, msg="Choose one option")
+        selected_layouts_names = choose_from_options(multi=True, options=options, prompt="Choose a layout configuration:", tv=True, msg="Choose one option")
     print(f"Selected layout(s): {selected_layouts_names}")
     # Extract the configs from the names:
     layouts_chosen: list[LayoutConfig] = []
@@ -49,35 +73,36 @@ def select_layout(layouts_json_file: Path, selected_layouts_names: Optional[list
     return layouts_chosen
 
 
-def find_layout_file(layout_path: str, ) -> Path:
-    from machineconfig.utils.path_extended import PathExtended
-    from machineconfig.scripts.python.helpers_fire_command.file_wrangler import search_for_files_of_interest
+def find_layout_file(layout_path: str, ) -> str:
+    from machineconfig.utils.path_helper import search_for_files_of_interest
     from machineconfig.utils.options import choose_from_options
     from machineconfig.utils.path_helper import match_file_name, sanitize_path
+    from pathlib import Path
     path_obj = sanitize_path(layout_path)
     if not path_obj.exists():
-        choice_file = match_file_name(sub_string=layout_path, search_root=PathExtended.cwd(), suffixes={".json"})
+        choice_file = match_file_name(sub_string=layout_path, search_root=Path.cwd(), suffixes={".json"})
     elif path_obj.is_dir():
         print(f"🔍 Searching recursively for Python, PowerShell and Shell scripts in directory `{path_obj}`")
-        files = search_for_files_of_interest(path_obj)
+        files = search_for_files_of_interest(path_obj, suffixes={".py", ".sh", ".ps1"})
         print(f"🔍 Got #{len(files)} results.")
-        choice_file = choose_from_options(multi=False, options=files, fzf=True, msg="Choose one option")
-        choice_file = PathExtended(choice_file)
+        choice_file = choose_from_options(multi=False, options=files, tv=True, msg="Choose one option")
+        choice_file = Path(choice_file).expanduser().absolute()
     else:
         choice_file = path_obj
-    return choice_file
+    return str(choice_file)
 
 
 def run(ctx: typer.Context,
            layout_path: Annotated[Optional[str], typer.Argument(..., help="Path to the layout.json file")] = None,
-        max_tabs: Annotated[int, typer.Option(..., help="A Sanity checker that throws an error if any layout exceeds the maximum number of tabs to launch.")] = 10,
-        max_layouts: Annotated[int, typer.Option(..., help="A Sanity checker that throws an error if the total number of *parallel layouts exceeds this number.")] = 10,
-        sleep_inbetween: Annotated[float, typer.Option(..., help="Sleep time in seconds between launching layouts")] = 1.0,
+        max_tabs: Annotated[int, typer.Option(..., "--max-tabs", "-mt", help="A Sanity checker that throws an error if any layout exceeds the maximum number of tabs to launch.")] = 10,
+        max_layouts: Annotated[int, typer.Option(..., "--max-layouts", "-ml", help="A Sanity checker that throws an error if the total number of *parallel layouts exceeds this number.")] = 10,
+        sleep_inbetween: Annotated[float, typer.Option(..., "--sleep-inbetween", "-si", help="Sleep time in seconds between launching layouts")] = 1.0,
         monitor: Annotated[bool, typer.Option(..., "--monitor", "-m", help="Monitor the layout sessions for completion")] = False,
         parallel: Annotated[bool, typer.Option(..., "--parallel", "-p", help="Launch multiple layouts in parallel")] = False,
         kill_upon_completion: Annotated[bool, typer.Option(..., "--kill-upon-completion", "-k", help="Kill session(s) upon completion (only relevant if monitor flag is set)")] = False,
         choose: Annotated[Optional[str], typer.Option(..., "--choose", "-c", help="Comma separated names of layouts to be selected from the layout file passed")] = None,
-        choose_interactively: Annotated[bool, typer.Option(..., "--choose-interactively", "-ia", help="Select layouts interactively")] = False
+        choose_interactively: Annotated[bool, typer.Option(..., "--choose-interactively", "-i", help="Select layouts interactively")] = False,
+        subsitute_home: Annotated[bool, typer.Option(..., "--substitute-home", "-sh", help="Substitute ~ and $HOME in layout file with actual home directory path")] = False,
         ):
     """
     Launch terminal sessions based on a layout configuration file.
@@ -86,7 +111,7 @@ def run(ctx: typer.Context,
         typer.echo(ctx.get_help())
         raise typer.Exit()
     layout_path_resolved = find_layout_file(layout_path=layout_path)
-    layouts_selected = select_layout(layouts_json_file=layout_path_resolved, selected_layouts_names=choose.split(",") if choose else None, select_interactively=choose_interactively)
+    layouts_selected = select_layout(layouts_json_file=layout_path_resolved, selected_layouts_names=choose.split(",") if choose else None, select_interactively=choose_interactively, subsitute_home=subsitute_home)
 
     # ============= Basic sanity checks =============
     if parallel and len(layouts_selected) > max_layouts:
@@ -130,16 +155,60 @@ def run(ctx: typer.Context,
         print(f"❌ Unsupported platform: {platform.system()}")
 
 
+def create_template(name: Annotated[Optional[str], typer.Argument(..., help="Name of the layout template to create")] = None,
+                    num_tabs: Annotated[int, typer.Option(..., "--num-tabs", "-t", help="Number of tabs to include in the template")] = 3,
+                    ):
+    """Create a layout template file."""
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile, TabConfig
+    from pathlib import Path
+    tabs: list[TabConfig] = []
+    for i in range(1, num_tabs + 1):
+        tab: TabConfig = {
+            "tabName": f"Tab{i}",
+            "startDir": "~/" + str(Path.cwd().relative_to(Path.home())),
+            "command": "bash",
+        }
+        tabs.append(tab)
+    layouts: list[LayoutConfig] = [
+        {
+            "layoutName": f"{Path.cwd().name}Layout",
+            "layoutTabs": tabs,
+        }
+    ]
+    file: LayoutsFile = {
+        "$schema": "https://bit.ly/cfglayout",  # type: ignore
+        "version": "0.1",
+        "layouts": layouts
+    }
+    import json
+    json_string = json.dumps(file, indent=4)
+    if name is None:
+        layout_path = Path.cwd() / "layout.json"
+    else:
+        layout_path = Path.cwd() / (name.replace(".json", "") + ".json")
+    layout_path.parent.mkdir(parents=True, exist_ok=True)
+    if layout_path.exists():
+        print(f"❌ File {layout_path} already exists. Aborting to avoid overwriting.")
+        return
+    layout_path.write_text(json_string, encoding="utf-8")
+    print(f"✅ Created layout template at {layout_path}")
+
+
 def get_app():
     layouts_app = typer.Typer(help="Layouts management subcommands", no_args_is_help=True, add_help_option=False, add_completion=False)
     from machineconfig.scripts.python.helpers_sessions.sessions_multiprocess import create_from_function
-    layouts_app.command("create-from-function", no_args_is_help=True, help="[c] Create a layout from a function")(create_from_function)
-    layouts_app.command("c", no_args_is_help=True, help="Create a layout from a function", hidden=True)(create_from_function)
-    layouts_app.command("run", no_args_is_help=True, help="[r] Run the selected layout(s)")(run)
-    layouts_app.command("r", no_args_is_help=True, help="Run the selected layout(s)", hidden=True)(run)
-    layouts_app.command("balance-load", no_args_is_help=True, help="[b] Balance the load across sessions")(balance_load)
-    layouts_app.command("b", no_args_is_help=True, help="Balance the load across sessions", hidden=True)(balance_load)
 
+    layouts_app.command("create-from-function", no_args_is_help=True, help=create_from_function.__doc__, short_help="[c] Create a layout from a function")(create_from_function)
+    layouts_app.command("c", no_args_is_help=True, help=create_from_function.__doc__, hidden=True)(create_from_function)
+
+    layouts_app.command("run", no_args_is_help=True, help=run.__doc__, short_help="[r] Run the selected layout(s)")(run)
+    layouts_app.command("r", no_args_is_help=True, help=run.__doc__, hidden=True)(run)
+
+    layouts_app.command("balance-load", no_args_is_help=True, help=balance_load.__doc__, short_help="[b] Balance the load across sessions")(balance_load)
+    layouts_app.command("b", no_args_is_help=True, help=balance_load.__doc__, hidden=True)(balance_load)
+
+    layouts_app.command("create-template", no_args_is_help=False, help=create_template.__doc__, short_help="[t] Create a layout template file")(create_template)
+    layouts_app.command("t", no_args_is_help=False, help=create_template.__doc__, hidden=True)(create_template)
     return layouts_app
 
 

machineconfig/scripts/python/terminal.py

@@ -1,7 +1,6 @@
-import subprocess
-# from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
+
 import typer
-from typing import Annotated
+from typing import Annotated, Optional
 
 
 def strip_ansi_codes(text: str) -> str:
@@ -11,8 +10,14 @@ def strip_ansi_codes(text: str) -> str:
 
 
 def choose_zellij_session(
+        name: Annotated[Optional[str], typer.Argument(help="Name of the Zellij session to attach to. If not provided, a list will be shown to choose from.")] = None,
         new_session: Annotated[bool, typer.Option("--new-session", "-n", help="Create a new Zellij session instead of attaching to an existing one.", show_default=True)] = False,
         kill_all: Annotated[bool, typer.Option("--kill-all", "-k", help="Kill all existing Zellij sessions before creating a new one.", show_default=True)] = False):
+    """Choose a Zellij session to attach to."""
+    if name is not None:
+        result = f"zellij attach {name}"
+        from machineconfig.utils.code import exit_then_run_shell_script
+        exit_then_run_shell_script(result, strict=True)
 
     if new_session:
         cmd = """
@@ -26,10 +31,12 @@ def choose_zellij_session(
         typer.Exit()
         return
     cmd = "zellij list-sessions"
+    import subprocess
     sessions: list[str] = subprocess.check_output(cmd, shell=True).decode().strip().split("\n")
     # filter out empty lines and keep raw lines (they contain creation info)
     sessions = [s for s in sessions if s.strip()]
     sessions.sort(key=lambda s: "EXITED" in s)
+
     if "current" in sessions:
         print("Already in a Zellij session, avoiding nesting and exiting.")
         raise typer.Exit()
@@ -37,32 +44,33 @@ def choose_zellij_session(
         print("No Zellij sessions found, creating a new one.")
         result = """zellij --layout st2"""
     elif len(sessions) == 1:
-        session = sessions[0].split(" [Created")[0]
-        print(f"Only one Zellij session found: {session}, attaching to it.")
-        result = f"zellij attach {session}"
+        session_name = sessions[0].split(" [Created")[0]
+        print(f"Only one Zellij session found: {session_name}, attaching to it.")
+        result = f"zellij attach {session_name}"
     else:
         from machineconfig.utils.options import choose_from_options
         # Artificially inject a "NEW SESSION" option so the user can create one from the list
         NEW_SESSION_LABEL = "NEW SESSION"
         options = [NEW_SESSION_LABEL] + sessions
-        session = choose_from_options(msg="Choose a Zellij session to attach to:", multi=False, options=options, fzf=True)
-        # If the user chose the artificial option, start a new session (same as --new-session)
-        if session == NEW_SESSION_LABEL:
+        session_name = choose_from_options(msg="Choose a Zellij session to attach to:", multi=False, options=options, tv=True)
+        if session_name == NEW_SESSION_LABEL:
             cmd = "zellij --layout st2"
             if kill_all:
                 cmd = f"zellij kill-sessions\n{cmd}"
             from machineconfig.utils.code import exit_then_run_shell_script
             exit_then_run_shell_script(cmd, strict=True)
             raise typer.Exit()
-        session = session.split(" [Created")[0]
-        result = f"zellij attach {session}"
+        session_name = session_name.split(" [Created")[0]
+        result = f"zellij attach {session_name}"
     from machineconfig.utils.code import exit_then_run_shell_script
     exit_then_run_shell_script(result, strict=True)
 
 
 
 def get_session_tabs() -> list[tuple[str, str]]:
+    """Get all Zellij session tabs."""
     cmd = "zellij list-sessions"
+    import subprocess
     sessions: list[str] = subprocess.check_output(cmd, shell=True).decode().strip().split("\n")
     sessions = [strip_ansi_codes(s) for s in sessions]
     active_sessions = [s for s in sessions if "EXITED" not in s]
@@ -84,6 +92,7 @@ def get_session_tabs() -> list[tuple[str, str]]:
 
 
 def start_wt(layout_name: Annotated[str, typer.Argument(help="Layout name to start.")]):
+    """Start a Windows Terminal layout by name."""
     from pathlib import Path
     layouts_file = Path.home().joinpath("dotfiles/machineconfig/layouts.json")
     if not layouts_file.exists():
@@ -108,14 +117,14 @@ def start_wt(layout_name: Annotated[str, typer.Argument(help="Layout name to sta
 
 def get_app():
     app = typer.Typer(help="🖥️ Terminal utilities", no_args_is_help=True, add_help_option=False)
-    app.command(name="attach-to-zellij", no_args_is_help=False, help="[z] Choose a Zellij session to attach to")(choose_zellij_session)
-    app.command(name="z", hidden=True, no_args_is_help=False, help="[z] Choose a Zellij session to attach to")(choose_zellij_session)
+    app.command(name="attach-to-zellij", no_args_is_help=False, help=choose_zellij_session.__doc__, short_help="[z] Choose a Zellij session to attach to")(choose_zellij_session)
+    app.command(name="z", hidden=True, no_args_is_help=False, help=choose_zellij_session.__doc__)(choose_zellij_session)
 
-    app.command(name="start-wt", no_args_is_help=True, help="[w] Start a Windows Terminal layout by name.")(start_wt)
-    app.command(name="w", hidden=True, no_args_is_help=True, help="[w] Start a Windows Terminal layout by name.")(start_wt)
+    app.command(name="start-wt", no_args_is_help=True, help=start_wt.__doc__, short_help="[w] Start a Windows Terminal layout by name.")(start_wt)
+    app.command(name="w", hidden=True, no_args_is_help=True, help=start_wt.__doc__)(start_wt)
 
-    app.command(name="get-session-tabs", no_args_is_help=False, help="[zt] Get all Zellij session tabs.")(get_session_tabs)
-    app.command(name="zt", hidden=True, no_args_is_help=False, help="[zt] Get all Zellij session tabs.")(get_session_tabs)
+    app.command(name="get-session-tabs", no_args_is_help=False, help=get_session_tabs.__doc__, short_help="[zt] Get all Zellij session tabs.")(get_session_tabs)
+    app.command(name="zt", hidden=True, no_args_is_help=False, help=get_session_tabs.__doc__)(get_session_tabs)
     return app
 
 def main():

machineconfig/scripts/python/utils.py

@@ -1,9 +1,10 @@
-
-
-from machineconfig.scripts.python.helpers_devops.cli_utils import download, merge_pdfs, get_machine_specs, init_project, compress_pdf, edit
+from machineconfig.scripts.python.helpers_utils.pdf import merge_pdfs, compress_pdf
+from machineconfig.scripts.python.helpers_utils.python import edit_file_with_hx, get_machine_specs, init_project, tui_env
+from machineconfig.scripts.python.helpers_utils.download import download
 import typer
 from typing import Annotated
 
+
 def kill_process(
         # name: Annotated[Optional[str], typer.Option(..., "--name", "-n", help="Name of the process to kill")],
                 #  command: Annotated[str, typer.Option(..., "--command", "-c", help="Match by command line instead of process name")] = "",
@@ -27,24 +28,27 @@ def upgrade_packages():
 
 def get_app() -> typer.Typer:
     app = typer.Typer(help="🛠️ utilities operations", no_args_is_help=True, add_help_option=False, add_completion=False)
-    app.command(name="kill-process", no_args_is_help=False, help="[k] Choose a process to kill")(kill_process)
+    app.command(name="kill-process", no_args_is_help=False, help="⚔️ [k] Choose a process to kill")(kill_process)
     app.command(name="k", no_args_is_help=False, help="Choose a process to kill", hidden=True)(kill_process)
 
-    app.command(name="upgrade-packages", no_args_is_help=False, help="[up] Upgrade project dependencies.")(upgrade_packages)
+    app.command("environment", no_args_is_help=False, help="📚 [v] NAVIGATE ENV/PATH variable with TUI")(tui_env)
+    app.command("v", no_args_is_help=False, help="NAVIGATE ENV/PATH variable with TUI", hidden=True)(tui_env)
+
+    app.command(name="upgrade-packages", no_args_is_help=False, help="⬆️ [up] Upgrade project dependencies.")(upgrade_packages)
     app.command(name="up", no_args_is_help=False, hidden=True)(upgrade_packages)
 
-    app.command(name="download", no_args_is_help=True, help="[d] Download a file from a URL and optionally decompress it.")(download)
+    app.command(name="download", no_args_is_help=True, help="⬇️ [d] Download a file from a URL and optionally decompress it.")(download)
     app.command(name="d", no_args_is_help=True, hidden=True)(download)
-    app.command(name="get-machine-specs", no_args_is_help=False, help="[g] Get machine specifications.")(get_machine_specs)
+    app.command(name="get-machine-specs", no_args_is_help=False, help="💻 [g] Get machine specifications.")(get_machine_specs)
     app.command(name="g", no_args_is_help=False, hidden=True)(get_machine_specs)
-    app.command(name="init-project", no_args_is_help=False, help="[i] Initialize a project with a uv virtual environment and install dev packages.")(init_project)
+    app.command(name="init-project", no_args_is_help=False, help="🚀 [i] Initialize a project with a uv virtual environment and install dev packages.")(init_project)
     app.command(name="i", no_args_is_help=False, hidden=True)(init_project)
-    app.command(name="edit", no_args_is_help=False, help="[e] Open a file in the default editor.")(edit)
-    app.command(name="e", no_args_is_help=False, hidden=True)(edit)
+    app.command(name="edit", no_args_is_help=False, help="✏️ [e] Open a file in the default editor.")(edit_file_with_hx)
+    app.command(name="e", no_args_is_help=False, hidden=True)(edit_file_with_hx)
 
-    app.command(name="pdf-merge", no_args_is_help=True, help="[pm] Merge two PDF files into one.")(merge_pdfs)
+    app.command(name="pdf-merge", no_args_is_help=True, help="📄 [pm] Merge two PDF files into one.")(merge_pdfs)
     app.command(name="pm", no_args_is_help=True, hidden=True)(merge_pdfs)
-    app.command(name="pdf-compress", no_args_is_help=True, help="[pc] Compress a PDF file.")(compress_pdf)
+    app.command(name="pdf-compress", no_args_is_help=True, help="📦 [pc] Compress a PDF file.")(compress_pdf)
     app.command(name="pc", no_args_is_help=True, hidden=True)(compress_pdf)
 
     # app.command(name="copy", no_args_is_help=True, help="[c] Copy files or directories.")(copy)
@@ -52,9 +56,7 @@ def get_app() -> typer.Typer:
 
     return app
 
-# def func():
-#     import pycr
 
 def main():
     app = get_app()
-    app()
+    app()

machineconfig/scripts/windows/wrap_mcfg.ps1

@@ -34,12 +34,15 @@ function wrap_in_shell_script {
         try {
             bat --style=full --theme=OneHalfDark --paging=never "$env:OP_PROGRAM_PATH"
         } catch {
-            Write-Host "⚠️ Warning: Failed to display script content with 'bat'. Proceeding to execute the script."
+            # Write-Host "⚠️ Warning: Failed to display script content with 'bat'. Proceeding to execute the script."
+            Write-Host " "
         }
         & $env:OP_PROGRAM_PATH
-        Write-Host "✅ '$Command' execution completed."
+        # Write-Host "✅ '$Command' execution completed."
+
     } else {
-        Write-Host "✅ '$Command' execution completed."
+        # Write-Host "✅ '$Command' execution completed."
+        Write-Host " "
     }
 
     # Clean up the temporary environment variable so it doesn't leak to other processes/sessions

machineconfig/settings/lf/windows/lfcd.ps1

@@ -17,7 +17,7 @@
 
 function lfcd {
     $tmp = [System.IO.Path]::GetTempFileName()
-    ~\AppData\Local\Microsoft\WindowsApps\lf.exe -last-dir-path="$tmp" $args
+    & "$env:USERPROFILE\AppData\Local\Microsoft\WindowsApps\lf.exe" -last-dir-path="$tmp" $args
     if (Test-Path -PathType Leaf "$tmp")
     {
         $dir = Get-Content "$tmp"

machineconfig/settings/linters/.ruff.toml

@@ -63,7 +63,7 @@ exclude = ["*.ipynb"]
 # exclude = ["generated"]
 
 docstring-code-format = false
-docstring-code-line-length = 150
+docstring-code-line-length = 200
 # Use `\n` line endings for all files
 line-ending = "lf"
 skip-magic-trailing-comma = true

machineconfig/settings/shells/bash/init.sh

@@ -57,7 +57,7 @@ alias r='wrap_in_shell_script croshell'
 alias u='wrap_in_shell_script utils'
 alias t='wrap_in_shell_script terminal'
 alias ms='wrap_in_shell_script msearch'
-alias x='. $CONFIG_ROOT/scripts/linux/wrap_mcfg explore'
+alias x='wrap_in_shell_script explore'
 
 # alias gcs='gh copilot suggest -t shell'
 # alias gcg='gh copilot suggest -t git'
@@ -89,7 +89,34 @@ eval "$(zoxide init bash)"
 eval "$(starship init bash)"
 # LEVE THIS IN THE END TO AVOID EXECUTION FAILURE OF THE REST OF THE SCRIPT
 # from https://github.com/cantino/mcfly
-eval "$(mcfly init bash)"
+if command -v mcfly &> /dev/null; then
+    eval "$(mcfly init bash)"
+else
+    # eval "$(tv init bash)"
+    tv_shell_history() {
+        _disable_bracketed_paste
+        local current_prompt="${READLINE_LINE:0:$READLINE_POINT}"
+        local output
+        # move to the next line so that the prompt is not overwritten
+        printf "\n"
+        # Get history using tv with the same arguments as zsh version
+        output=$(tv bash-history --input "$current_prompt" --inline)
+
+        if [[ -n "$output" ]]; then
+            # Clear the right side of cursor and set new line
+            READLINE_LINE="$output"
+            READLINE_POINT=${#READLINE_LINE}
+            # Uncomment this to automatically accept the line
+            # (i.e. run the command without having to press enter twice)
+            # accept-line() { echo; }; accept-line
+        fi
+        # move the cursor back to the previous line
+        printf "\033[A"
+        _enable_bracketed_paste
+    }
+    bind -x '"\C-r": tv_shell_history'
+fi
+
 
 # Show elapsed runtime
 # _show_elapsed

machineconfig/settings/shells/ipy/profiles/default/startup/playext.py

@@ -27,7 +27,7 @@
 # def print_code_interactive(_):
 #     res = get_names()
 #     from machineconfig.utils.utils import choose_from_options
-#     choice = choose_from_options(multi=False, options=res["<class 'function'>"], msg="Choose a type to inspect", fzf=True)
+#     choice = choose_from_options(multi=False, options=res["<class 'function'>"], msg="Choose a type to inspect", tv=True)
 #     obj = eval(choice, globals(), locals())  # type: ignore  # pylint: disable=eval-used
 #     from rich.syntax import Syntax
 #     import inspect

machineconfig/settings/shells/nushell/config.nu

@@ -1,3 +1,3 @@
+# machineconfig Nushell configuration loader
 
-
-use C:\Users\aalsaf01\.config\machineconfig\settings\shells\nushell\init.nu
+use "~/.config/machineconfig/settings/shells/nushell/init.nu"

machineconfig/settings/shells/nushell/env.nu

@@ -1,13 +1,52 @@
+# machineconfig Nushell environment setup
 
+def reduce_non_empty [segments: list<string>] -> list<string> {
+	segments
+	| reduce --fold [] { |segment, acc|
+		if (($segment | str length) > 0) {
+			$acc | append $segment
+		} else {
+			$acc
+		}
+	}
+}
 
-# as per https://github.com/starship/starship?tab=readme-ov-file#step-1-install-starship
-mkdir ~/.cache/starship
-starship init nu | save -f ~/.cache/starship/init.nu
+let default_root = ($env.HOME | path join ".config" "machineconfig")
+let config_root = (
+	$env.CONFIG_ROOT?
+	| default $default_root
+	| path expand
+)
 
+load-env { CONFIG_ROOT: $config_root }
 
+let existing_segments = (
+	$env.PATH?
+	| default ""
+	| split row (char esep)
+	| reduce_non_empty
+)
 
-# echo $nu.env-path
-# as per https://github.com/ajeetdsouza/zoxide?tab=readme-ov-file#installation
-zoxide init nushell | save -f ~/.zoxide.nu
+let desired_paths = [
+	($config_root | path join "scripts")
+	($env.HOME | path join "dotfiles" "scripts" "linux")
+	($env.HOME | path join ".local" "bin")
+	($env.HOME | path join ".cargo" "bin")
+	"/usr/games"
+]
+
+let merged_segments = (
+	$desired_paths
+	| reduce --fold $existing_segments { |entry, acc|
+		if (($entry | path exists) and (not ($entry in $acc))) {
+			$acc | append $entry
+		} else {
+			$acc
+		}
+	}
+)
+
+let new_path = ($merged_segments | str join (char esep))
+load-env { PATH: $new_path }