machineconfig 6.23__py3-none-any.whl → 8.12__py3-none-any.whl

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.helpers4 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,22 +155,60 @@ def run(ctx: typer.Context,
         print(f"❌ Unsupported platform: {platform.system()}")
 
 
-def kill_process():
-    from machineconfig.utils.procs import main
-    main()
+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)
-    from machineconfig.scripts.python.sessions_helpers.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("kill-process", no_args_is_help=False, help="[k] Choose a process to kill")(kill_process)
-    layouts_app.command("k", no_args_is_help=False, help="Choose a process to kill", hidden=True)(kill_process)
+    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=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

@@ -0,0 +1,136 @@
+
+import typer
+from typing import Annotated, Optional
+
+
+def strip_ansi_codes(text: str) -> str:
+    """Remove ANSI color codes from text."""
+    import re
+    return re.sub(r'\x1b\[[0-9;]*[a-zA-Z]', '', text)
+
+
+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 = """
+    zellij --layout st2
+    """
+        if kill_all:
+            cmd = f"""zellij kill-sessions
+    {cmd}"""
+        from machineconfig.utils.code import exit_then_run_shell_script
+        exit_then_run_shell_script(script=cmd, strict=True)
+        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()
+    if len(sessions) == 0:
+        print("No Zellij sessions found, creating a new one.")
+        result = """zellij --layout st2"""
+    elif len(sessions) == 1:
+        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_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_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]
+    result: list[tuple[str, str]] = []
+    for session_line in active_sessions:
+        session_name = session_line.split(" [Created")[0].strip()
+        # Query tab names for the session
+        tab_cmd = f"zellij  --session {session_name} action query-tab-names"
+        try:
+            tabs: list[str] = subprocess.check_output(tab_cmd, shell=True).decode().strip().split("\n")
+            for tab in tabs:
+                if tab.strip():
+                    result.append((session_name, tab.strip()))
+        except subprocess.CalledProcessError:
+            # Skip if query fails
+            continue
+    print(result)
+    return result
+
+
+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():
+        typer.echo(f"❌ Layouts file not found: {layouts_file}")
+        # available
+        raise typer.Exit(code=1)
+    import json
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
+    layouts_data: LayoutsFile = json.loads(layouts_file.read_text(encoding="utf-8"))
+    chosen_layout = next((a_layout for a_layout in layouts_data["layouts"] if a_layout["layoutName"] == layout_name), None)
+    if not chosen_layout:
+        typer.echo(f"❌ Layout '{layout_name}' not found in layouts file.")
+        available_layouts = [a_layout["layoutName"] for a_layout in layouts_data["layouts"]]
+        typer.echo(f"Available layouts: {', '.join(available_layouts)}")
+        raise typer.Exit(code=1)
+    from machineconfig.cluster.sessions_managers.wt_local import run_wt_layout
+    run_wt_layout(layout_config=chosen_layout)
+    # cmd = f'powershell -ExecutionPolicy Bypass -File "./{layout_name}_layout.ps1"'
+    # from machineconfig.utils.code import exit_then_run_shell_script
+    # exit_then_run_shell_script(cmd, strict=True)
+
+
+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=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=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=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():
+    app = get_app()
+    app()
+
+
+if __name__ == "__main__":
+    main()

machineconfig/scripts/python/utils.py

@@ -0,0 +1,62 @@
+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")] = "",
+                 interactive: Annotated[bool, typer.Option(..., "--interactive", "-i", help="Interactively choose the process to kill")] = True):
+    from machineconfig.utils.procs import main, ProcessManager
+    if interactive:
+        main()
+        return
+    _ = ProcessManager
+    # pm = ProcessManager()
+    # if command:
+    #     pm.filter_and_kill(name=command
+                        #    )
+
+
+def upgrade_packages():
+    from machineconfig.utils.upgrade_packages import generate_uv_add_commands
+    from pathlib import Path
+    generate_uv_add_commands(pyproject_path=Path.cwd() / "pyproject.toml", output_path=Path.cwd() / "pyproject_init.sh")
+
+
+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="k", no_args_is_help=False, help="Choose a process to kill", hidden=True)(kill_process)
+
+    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="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="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="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_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="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="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)
+    # app.command(name="c", no_args_is_help=True, hidden=True)(copy)
+
+    return app
+
+
+def main():
+    app = get_app()
+    app()

machineconfig/scripts/windows/wrap_mcfg.ps1

@@ -0,0 +1,63 @@
+function wrap_in_shell_script {
+    param(
+        [Parameter(Mandatory=$true)]
+        [string]$Command,
+        
+        [Parameter(ValueFromRemainingArguments=$true)]
+        [string[]]$Arguments
+    )
+    
+    # Generate a random name (based on current timestamp hashed with SHA256)
+    # Compute SHA256 of the timestamp string (don't pipe the string to Get-FileHash
+    # because that attempts to treat the input as a path). Take the first 16 hex
+    # chars as the random name.
+    $ts = Get-Date -Format o
+    try {
+        $sha = [System.Security.Cryptography.SHA256]::Create()
+        $bytes = [System.Text.Encoding]::UTF8.GetBytes($ts)
+        $hashBytes = $sha.ComputeHash($bytes)
+        $hash = [System.BitConverter]::ToString($hashBytes).Replace("-", "").ToLower()
+        $randomName = $hash.Substring(0, 16)
+    } finally {
+        if ($sha) { $sha.Dispose() }
+    }
+
+    # Define the output path
+    $env:OP_PROGRAM_PATH = "$HOME/tmp_results/tmp_scripts/machineconfig/${randomName}.ps1"
+
+    # Run the specified command with its arguments
+    & $Command @Arguments
+
+    # Check if the file exists
+    if (Test-Path $env:OP_PROGRAM_PATH) {
+        Write-Host "🚀 Taking over from python script @ $env:OP_PROGRAM_PATH"
+        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 " "
+        }
+        & $env:OP_PROGRAM_PATH
+        # Write-Host "✅ '$Command' execution completed."
+
+    } else {
+        # Write-Host "✅ '$Command' execution completed."
+        Write-Host " "
+    }
+
+    # Clean up the temporary environment variable so it doesn't leak to other processes/sessions
+    try {
+        Remove-Item Env:\OP_PROGRAM_PATH -ErrorAction SilentlyContinue
+    } catch {
+        # best-effort cleanup; ignore any errors
+    }
+
+    # Also explicitly clear the variable in the current process
+    $env:OP_PROGRAM_PATH = $null
+}
+
+# Call the function with any arguments passed to the script
+if ($args.Count -gt 0) {
+    wrap_in_shell_script @args
+}
+

machineconfig/settings/broot/conf.toml

@@ -2,4 +2,4 @@
 
 terminal_title = "{file} 🐄"
 
-capture_mouse: false
+capture_mouse = false

machineconfig/settings/helix/config.toml

@@ -25,3 +25,19 @@ enable = true
 max-wrap = 25 # increase value to reduce forced mid-word wrapping
 max-indent-retain = 0
 wrap-indicator = ""  # set wrap-indicator to "" to hide it
+
+
+# https://yazi-rs.github.io/docs/tips#helix-with-zellij
+# ~/.config/helix/config.toml
+[keys.normal]
+C-y = ":sh zellij run -n Yazi -c -f -x 10%% -y 10%% --width 80%% --height 80%% -- bash ~/.config/helix/yazi-picker.sh open %{buffer_name}"
+    
+# ~/.config/helix/config.toml
+
+# [keys.normal.C-y]
+# Open the file(s) in the current window
+# y = ":sh zellij run -n Yazi -c -f -x 10%% -y 10%% --width 80%% --height 80%% -- bash ~/.config/helix/yazi-picker.sh open %{buffer_name}"
+# Open the file(s) in a vertical split
+# v = ":sh zellij run -n Yazi -c -f -x 10%% -y 10%% --width 80%% --height 80%% -- bash ~/.config/helix/yazi-picker.sh vsplit %{buffer_name}"
+# Open the file(s) in a horizontal split
+# h = ":sh zellij run -n Yazi -c -f -x 10%% -y 10%% --width 80%% --height 80%% -- bash ~/.config/helix/yazi-picker.sh hsplit %{buffer_name}"

machineconfig/settings/helix/languages.toml

@@ -1,13 +1,22 @@
-# adopted from https://github.com/helix-editor/helix/wiki/How-to-install-the-default-language-servers#python---pyright--ruff--black
+# adopted from https://github.com/helix-editor/helix/wiki/Language-Server-Configurations
 # adopted from https://github.com/helix-editor/helix/discussions/6623
-# You will need: npm install pyright -g; pip install ruff-lsp; pip install black
+# You will need: uv add --dev pylsp-mypy python-lsp-server[all] pyright ruff-lsp
 
 [[language]]
 name = "python"
-language-servers = [ "pyright", "ruff" ]
+language-servers = ["pylsp", "pyright", "ruff", "pyrefly"]
+
+[language-server.pyrefly]
+command = "pyrefly"
+args = [ "lsp" ]
+
+[language-server.pylsp.config.pylsp]
+plugins.pylsp_mypy.enabled = true
+plugins.pylsp_mypy.live_mode = true
+
 
 [language-server.pyright.config.python.analysis]
-typeCheckingMode = "basic"
+typeCheckingMode = "strict"
 
 [language-server.ruff]
 command = "ruff-lsp"

machineconfig/settings/helix/yazi-picker.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+paths=$(yazi "$2" --chooser-file=/dev/stdout | while read -r; do printf "%q " "$REPLY"; done)
+
+if [[ -n "$paths" ]]; then
+	zellij action toggle-floating-panes
+	zellij action write 27 # send <Escape> key
+	zellij action write-chars ":$1 $paths"
+	zellij action write 13 # send <Enter> key
+else
+	zellij action toggle-floating-panes
+fi

machineconfig/settings/lf/linux/exe/lfcd.sh

@@ -13,6 +13,7 @@
 #     bind '"\C-o":"lfcd\C-m"'  # bash
 #     bindkey -s '^o' 'lfcd\n'  # zsh
 #
+
 lfcd () {
     # 🔄 Create temporary file for directory tracking
     tmp="$(mktemp)"

machineconfig/settings/lf/linux/exe/previewer.sh

@@ -20,8 +20,9 @@ case "$file" in
     echo "x: $x, y: $y, width: $width, height: $height"
     
     if [ -n "$x" ]; then
-        echo "📐 Dimensions provided by caller, passing to viu"
-        viu "$file" -x "$x" -y "$y" -w "$width" -h "$height"
+        # echo "📐 Dimensions provided by caller, passing to viu"
+        # viu "$file" -x "$x" -y "$y" -w "$width" -h "$height"
+        # chafa --fit-width -f sixel "$file"
         echo "✅ Finished viu"
         chafa "$file"
         echo "✅ Finished chafa"

machineconfig/settings/lf/linux/lfrc

@@ -14,8 +14,8 @@ set number true  # show line numbers
 
 set preview true        # preview file on the right pane
 # set previewer chafa --format sixel --work 9 --optimize 9 --stretch --zoom --size 140x80
-set previewer ~/code/machineconfig/src/machineconfig/settings/lf/linux/exe/previewer.sh
-set cleaner ~/code/machineconfig/src/machineconfig/settings/lf/linux/exe/cleaner.sh
+set previewer ~/.config/machineconfig/settings/lf/linux/exe/previewer.sh
+set cleaner ~/.config/machineconfig/settings/lf/linux/exe/cleaner.sh
 # set previewer pistol
 
 # set sixels true
@@ -48,7 +48,7 @@ set ratios '1:2:3'  # ratio of pane widths
 
 
 # test image viewer
-map Q !~/code/machineconfig/src/machineconfig/settings/lf/linux/exe/previewer.sh "$f"
+map Q !~/.config/machineconfig/settings/lf/linux/exe/previewer.sh "$f"
 
 # key bindings
 map vmap v  # default is invert
@@ -70,7 +70,6 @@ map <c-u>  # half-up
 # e edit
 map e  # edit modal key.
 map eh $hx $f
-map eH !source ~/code/machineconfig/.venv/bin/activate;hx $f
 map en $nano $f
 map el $lvim $f
 map ev $nvim $f
@@ -84,12 +83,12 @@ map <enter> open
 map w
 map ww bash
 # map wp $powershell
-map wr $~/scripts/croshell
+map wr $croshell
 # map wm $cmd
-map i !~/code/machineconfig/src/machineconfig/settings/lf/linux/exe/previewer.sh $f
+map i !~/.config/machineconfig/settings/lf/linux/exe/previewer.sh $f
 map I !cat $f | gum pager
-map R $~/scripts/croshell -r $f
-map O $~/scripts/croshell -rj $f
+map R $croshell $f
+map O $croshell -j $f
 
 
 # o file/folder Operations
@@ -118,8 +117,8 @@ map jD cd ~/Downloads
 map jx cd ~/dotfiles
 # map jm cd ~/code/machineconfig/src/machineconfig
 map jh cd ~
-map jj $~/scripts/croshell -j --read $f
-# map jj $lvim ~/code/machineconfig/src/machineconfig/settings/lf/linux/lfrc
+map jj $croshell -j --read $f
+# map jj $lvim ~/.config/machineconfig/settings/lf/linux/lfrc
 
 # from https://github.com/gokcehan/lf/wiki/Integrations#zoxide
 cmd zi ${{
@@ -163,7 +162,7 @@ cmd fzf_jump ${{
 }}
 
 
-cmd fzf2g $(~/scripts/fzf2g.sh $args[1])
+cmd fzf2g $(fzf2g.sh $args[1])
 # map F $nano fzf2g $args[1]
 
 

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"