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

machineconfig/scripts/python/helpers/helpers_fire_command/fire_jobs_impl.py

@@ -0,0 +1,233 @@
+"""Pure Python implementation for fire_jobs route command - no typer dependencies."""
+
+from typing import Optional, Callable
+from pathlib import Path
+from machineconfig.scripts.python.helpers.helpers_fire_command.fire_jobs_args_helper import FireJobArgs
+
+RandStrFunc = Callable[[int], str]
+
+
+def route(args: FireJobArgs, fire_args: str) -> None:
+    """Route execution based on args configuration."""
+    from machineconfig.utils.path_helper import get_choice_file
+    from machineconfig.utils.accessories import get_repo_root, randstr
+
+    choice_file = get_choice_file(args.path, suffixes=None)
+    repo_root = get_repo_root(choice_file)
+    print(f"💾 Selected file: {choice_file}.\nRepo root: {repo_root}")
+
+    if args.marimo:
+        _handle_marimo(choice_file=choice_file, repo_root=repo_root, randstr_func=randstr)
+        return
+
+    kwargs_dict = _prepare_kwargs(args=args, choice_file=choice_file)
+    choice_function = _choose_function(args=args, choice_file=choice_file, kwargs_dict=kwargs_dict)
+    if isinstance(choice_function, tuple):
+        choice_function, choice_file, kwargs_dict = choice_function
+
+    command = _build_command(args=args, choice_file=choice_file, choice_function=choice_function, kwargs_dict=kwargs_dict, repo_root=repo_root, fire_args=fire_args, randstr_func=randstr)
+    command = _apply_command_modifiers(args=args, command=command, choice_file=choice_file, repo_root=repo_root, randstr_func=randstr)
+
+    from machineconfig.utils.code import exit_then_run_shell_script
+    exit_then_run_shell_script(script=command, strict=False)
+
+
+def _handle_marimo(choice_file: Path, repo_root: Optional[Path], randstr_func: RandStrFunc) -> None:
+    """Handle marimo notebook launch."""
+    print(f"🧽 Preparing to launch Marimo notebook for `{choice_file}`...")
+    tmp_dir = Path.home().joinpath(f"tmp_results/tmp_scripts/marimo/{choice_file.stem}_{randstr_func(10)}")
+    tmp_dir.mkdir(parents=True, exist_ok=True)
+    script = f"""
+cd {tmp_dir}
+uv run --python 3.14 --with marimo marimo convert {choice_file} -o marimo_nb.py
+uv run --project {repo_root} --with marimo marimo edit --host 0.0.0.0 marimo_nb.py
+"""
+    from machineconfig.utils.code import exit_then_run_shell_script
+    print(f"🚀 Launching Marimo notebook for `{choice_file}`...")
+    exit_then_run_shell_script(script)
+
+
+def _prepare_kwargs(args: FireJobArgs, choice_file: Path) -> dict[str, object]:
+    """Prepare kwargs dict from args."""
+    if choice_file.suffix == ".py":
+        from machineconfig.scripts.python.helpers.helpers_fire_command.fire_jobs_args_helper import extract_kwargs
+        return extract_kwargs(args)
+    return {}
+
+
+def _choose_function(args: FireJobArgs, choice_file: Path, kwargs_dict: dict[str, object]) -> Optional[str] | tuple[Optional[str], Path, dict[str, object]]:
+    """Choose function to run, possibly interactively."""
+    if args.choose_function:
+        from machineconfig.scripts.python.helpers.helpers_fire_command.fire_jobs_route_helper import choose_function_or_lines
+        choice_function, choice_file, kwargs_dict = choose_function_or_lines(choice_file, kwargs_dict)
+        return (choice_function, choice_file, kwargs_dict)
+    return args.function
+
+
+def _build_command(args: FireJobArgs, choice_file: Path, choice_function: Optional[str], kwargs_dict: dict[str, object], repo_root: Optional[Path], fire_args: str, randstr_func: RandStrFunc) -> str:
+    """Build the execution command."""
+    if choice_file.suffix == ".py":
+        exe_line = _build_python_exe_line(args=args, choice_file=choice_file, repo_root=repo_root)
+        choice_file_adjusted = _adjust_choice_file(args=args, choice_file=choice_file, repo_root=repo_root)
+
+        if args.script or (args.debug and args.choose_function):
+            choice_file = _create_import_script(choice_file=choice_file, choice_function=choice_function, kwargs_dict=kwargs_dict, repo_root=repo_root, randstr_func=randstr_func)
+            choice_file_adjusted = str(choice_file)
+
+        return _build_final_command(args=args, exe_line=exe_line, choice_file=choice_file, choice_file_adjusted=choice_file_adjusted, choice_function=choice_function, fire_args=fire_args)
+    elif choice_file.suffix in (".ps1", ".sh"):
+        return f". {choice_file}"
+    elif choice_file.suffix == "":
+        return str(choice_file)
+    else:
+        raise NotImplementedError(f"File type {choice_file.suffix} not supported, in the sense that I don't know how to fire it.")
+
+
+def _build_python_exe_line(args: FireJobArgs, choice_file: Path, repo_root: Optional[Path]) -> str:
+    """Build Python execution line."""
+    module_line = "-m" if args.module else ""
+    with_project = f"--project {repo_root} " if repo_root is not None else ""
+    interactive_line = "-i" if args.interactive else ""
+
+    if args.interactive:
+        from machineconfig.utils.ve import get_ve_path_and_ipython_profile
+        _ve_root_from_file, ipy_profile = get_ve_path_and_ipython_profile(init_path=choice_file)
+        if ipy_profile is None:
+            ipy_profile = "default"
+        ipython_line = f"--no-banner --profile {ipy_profile} "
+    else:
+        ipython_line = ""
+
+    if args.streamlit:
+        from machineconfig.scripts.python.helpers.helpers_fire_command.fire_jobs_route_helper import get_command_streamlit
+        interpreter_line = get_command_streamlit(choice_file=choice_file, environment=args.environment, repo_root=repo_root)
+    elif args.jupyter:
+        interpreter_line = "jupyter-lab"
+    else:
+        interpreter_line = "python" if not args.interactive else "ipython"
+
+    return f"uv run {with_project} {interpreter_line} {interactive_line} {module_line} {ipython_line}"
+
+
+def _adjust_choice_file(args: FireJobArgs, choice_file: Path, repo_root: Optional[Path]) -> str:
+    """Adjust choice file path for module mode."""
+    if args.module and choice_file.suffix == ".py":
+        if repo_root is not None:
+            return ".".join(Path(choice_file).relative_to(repo_root).parts).replace(".py", "")
+        else:
+            return ".".join(Path(choice_file).relative_to(Path.cwd()).parts).replace(".py", "")
+    return str(choice_file)
+
+
+def _create_import_script(choice_file: Path, choice_function: Optional[str], kwargs_dict: dict[str, object], repo_root: Optional[Path], randstr_func: RandStrFunc) -> Path:
+    """Create a script that imports the module and calls the function."""
+    from machineconfig.scripts.python.helpers.helpers_fire_command.file_wrangler import get_import_module_code, wrap_import_in_try_except
+    from machineconfig.utils.meta import lambda_to_python_script
+    from machineconfig.utils.code import print_code
+
+    import_code = get_import_module_code(str(choice_file))
+    import_code_robust = lambda_to_python_script(
+        lambda: wrap_import_in_try_except(
+            import_line=import_code, pyfile=str(choice_file), repo_root=str(repo_root) if repo_root is not None else None
+        ),
+        in_global=True,
+        import_module=False,
+    )
+    code_printing = lambda_to_python_script(
+        lambda: print_code(code=import_code_robust, lexer="python", desc="import as module code"),
+        in_global=True, import_module=False
+    )
+    print(f"🧩 Preparing import code for module import:\n{import_code}")
+    if choice_function is not None:
+        calling = f"""res = {choice_function}({("**" + str(kwargs_dict)) if kwargs_dict else ""})"""
+    else:
+        calling = """# No function selected to call. You can add your code here."""
+    new_choice_file = Path.home().joinpath(f"tmp_results/tmp_scripts/python/{Path(choice_file).parent.name}_{Path(choice_file).stem}_{randstr_func(10)}.py")
+    new_choice_file.parent.mkdir(parents=True, exist_ok=True)
+    new_choice_file.write_text(import_code_robust + "\n" + code_printing + "\n" + calling, encoding="utf-8")
+    return new_choice_file
+
+
+def _build_final_command(args: FireJobArgs, exe_line: str, choice_file: Path, choice_file_adjusted: str, choice_function: Optional[str], fire_args: str) -> str:
+    """Build the final command string."""
+    if args.debug:
+        import platform
+        if platform.system() == "Windows":
+            return f"{exe_line} -m ipdb {choice_file_adjusted} "
+        elif platform.system() in ["Linux", "Darwin"]:
+            return f"{exe_line} -m pudb {choice_file_adjusted} "
+        else:
+            raise NotImplementedError(f"Platform {platform.system()} not supported.")
+    elif args.module:
+        return f"{exe_line} {choice_file_adjusted} "
+    elif choice_function is not None and choice_file.suffix == ".py":
+        return f"{exe_line} -m fire {choice_file_adjusted} {choice_function} {fire_args}"
+    elif args.streamlit:
+        if args.holdDirectory:
+            return f"{exe_line} {choice_file}"
+        else:
+            return f"cd {choice_file.parent}\n{exe_line} {choice_file.name}\ncd {Path.cwd()}"
+    elif args.cmd:
+        return rf""" cd /d {choice_file.parent} & {exe_line} {choice_file.name} """
+    elif choice_file.suffix == "":
+        return f"{exe_line} {choice_file} {fire_args}"
+    else:
+        return f"{exe_line} {choice_file} "
+
+
+def _apply_command_modifiers(args: FireJobArgs, command: str, choice_file: Path, repo_root: Optional[Path], randstr_func: RandStrFunc) -> str:
+    """Apply various command modifiers based on args."""
+    from rich.panel import Panel
+    from rich.console import Console
+    from rich.syntax import Syntax
+
+    console = Console()
+
+    if args.cmd:
+        new_line = "\n"
+        command = rf"""start cmd -Argument "/k {command.replace(new_line, " & ")} " """
+
+    if args.submit_to_cloud:
+        command = f"""uv run python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
+        if args.function is not None:
+            command += f"--function {args.function} "
+
+    if args.optimized:
+        command = command.replace("python ", "python -OO ")
+
+    if args.zellij_tab is not None:
+        comman_path__ = Path.home().joinpath(f"tmp_results/tmp_scripts/zellij_commands/{choice_file.stem}_{randstr_func(10)}.sh")
+        comman_path__.parent.mkdir(parents=True, exist_ok=True)
+        comman_path__.write_text(command, encoding="utf-8")
+        console.print(Panel(Syntax(command, lexer="shell"), title=f"🔥 fire command @ {comman_path__}: "), style="bold red")
+        import subprocess
+
+        existing_tab_names = subprocess.run(["zellij", "action", "query-tab-names"], capture_output=True, text=True, check=True).stdout.splitlines()
+        if args.zellij_tab in existing_tab_names:
+            print(f"⚠️ Tab name `{args.zellij_tab}` already exists. Please choose a different name.")
+            args.zellij_tab += f"_{randstr_func(3)}"
+        from machineconfig.cluster.sessions_managers.zellij_local import run_command_in_zellij_tab
+
+        command = run_command_in_zellij_tab(command=str(comman_path__), tab_name=args.zellij_tab, cwd=None)
+
+    if args.watch:
+        command = "watchexec --restart --exts py,sh,ps1 " + command
+
+    if args.git_pull:
+        command = f"\ngit -C {choice_file.parent} pull\n" + command
+
+    if args.PathExport:
+        from machineconfig.scripts.python.helpers.helpers_fire_command.file_wrangler import add_to_path
+        export_line = add_to_path(path_variable="PYTHONPATH", directory=str(repo_root))
+        command = export_line + "\n" + command
+
+    if args.loop:
+        import platform
+        if platform.system() in ["Linux", "Darwin"]:
+            command = command + "\nsleep 0.5"
+        elif platform.system() == "Windows":
+            command = "$ErrorActionPreference = 'SilentlyContinue';\n" + command + "\nStart-Sleep -Seconds 0.5"
+        else:
+            raise NotImplementedError(f"Platform {platform.system()} not supported.")
+
+    return command

machineconfig/scripts/python/{helpers_fire_command → helpers/helpers_fire_command}/fire_jobs_route_helper.py

@@ -21,7 +21,7 @@ def choose_function_or_lines(choice_file: Path, kwargs_dict: dict[str, object])
     choice_function: Optional[str] = None
     
     if choice_file.suffix == ".py":
-        from machineconfig.scripts.python.helpers_fire_command.file_wrangler import parse_pyfile
+        from machineconfig.scripts.python.helpers.helpers_fire_command.file_wrangler import parse_pyfile
         options, func_args = parse_pyfile(file_path=str(choice_file))
         choice_function_tmp = choose_from_options(msg="Choose a function to run", options=options, tv=True, multi=False)
         assert isinstance(choice_function_tmp, str), f"choice_function must be a string. Got {type(choice_function_tmp)}"
@@ -54,8 +54,8 @@ def choose_function_or_lines(choice_file: Path, kwargs_dict: dict[str, object])
 
 
 def get_command_streamlit(choice_file: Path, environment: str, repo_root: Optional[Path]) -> str:
-    # from machineconfig.scripts.python.helpers_utils.path import get_machine_specs
-    from machineconfig.scripts.python.helpers_network.address import select_lan_ipv4
+    # from machineconfig.scripts.python.helpers.helpers_utils.path import get_machine_specs
+    from machineconfig.scripts.python.helpers.helpers_network.address import select_lan_ipv4
     res = select_lan_ipv4(prefer_vpn=False)
     if res is None:
         raise RuntimeError("Could not determine local LAN IPv4 address for streamlit app.")

machineconfig/scripts/python/helpers/helpers_msearch/msearch_impl.py

@@ -0,0 +1,248 @@
+"""Pure Python implementation for msearch command - no typer dependencies."""
+
+
+from typing import Optional
+
+
+def machineconfig_search(
+    path: str, ast: bool, symantic: bool, extension: str, file: bool, no_dotfiles: bool, rga: bool, edit: bool, install_dependencies: bool
+) -> None:
+    """Machineconfig search helper."""
+    
+
+    if install_dependencies:
+        _install_dependencies()
+        return
+    if symantic:
+        _run_symantic_search(extension=extension)
+        return
+    if ast:
+        _run_ast_search(directory=path)
+        return
+    if file:
+        _run_file_search(no_dotfiles=no_dotfiles, edit=edit)
+        return
+
+    from pathlib import Path
+    import sys
+    import tempfile
+    import io
+    is_temp_file = False
+    if not sys.stdin.isatty() and Path(path).is_dir():
+        # Use UTF-8 encoding to handle emoji and Unicode characters on Windows
+        if sys.stdin.encoding != 'utf-8':
+            stdin_wrapper = io.TextIOWrapper(sys.stdin.buffer, encoding='utf-8', errors='replace')
+            content = stdin_wrapper.read()
+        else:
+            content = sys.stdin.read()
+        if content:
+            tf = tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', delete=False, prefix="msearch_stdin_")
+            tf.write(content)
+            tf.close()
+            path = tf.name
+            is_temp_file = True
+
+    if Path(path).absolute().resolve().is_file():
+        from machineconfig.utils.code import exit_then_run_shell_script
+        code = search_file_with_context(path=path, is_temp_file=is_temp_file, edit=edit)
+        exit_then_run_shell_script(script=code, strict=False)
+        return
+
+    _run_text_search(rga=rga, directory=path)
+
+
+def _install_dependencies() -> None:
+    """Install required 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")
+    install_if_missing("rga")
+
+
+
+def search_file_with_context(path: str, is_temp_file: bool, edit: bool) -> str:
+    import platform
+    import base64
+    from pathlib import Path
+    abs_path = str(Path(path).absolute())
+    if platform.system() == "Linux" or platform.system() == "Darwin":
+        if edit:
+            code = """
+res=$(nl -ba -w1 -s' ' "$TEMP_FILE" | tv \
+--preview-command "bat --color=always --style=numbers --highlight-line {split: :0} $TEMP_FILE" \
+--preview-size 80 \
+--preview-offset "{split: :0}" \
+--source-output "{}")
+if [ -n "$res" ]; then
+    line=$(echo "$res" | cut -d' ' -f1)
+    hx "$TEMP_FILE:$line"
+fi
+"""
+        else:
+            code = """
+nl -ba -w1 -s' ' "$TEMP_FILE" | tv \
+--preview-command "bat --color=always --style=numbers --highlight-line {split: :0} $TEMP_FILE" \
+--preview-size 80 \
+--preview-offset "{split: :0}" \
+--source-output "{}" \
+| cut -d' ' -f2-
+"""
+        code = code.replace("$TEMP_FILE", abs_path)
+        if is_temp_file:
+            code += f"\nrm {path}"
+    elif platform.system() == "Windows":
+        # Windows: avoid piping INTO `tv` (it breaks TUI interactivity on Windows terminals).
+        # Use `tv --source-command` so stdin remains attached to the console.
+        # Note: using `cmd /C type` here has proven brittle due to quoting/command-line parsing
+        # differences; generate the numbered lines via a self-contained PowerShell command.
+        abs_path_escaped = abs_path.replace("'", "''")
+        # Use `-EncodedCommand` to avoid nested quoting issues across PowerShell/tv/cmd.
+        ps_script = (
+            "$OutputEncoding = [Console]::OutputEncoding = [System.Text.UTF8Encoding]::new(); "
+            "$i = 0; "
+            f"Get-Content -LiteralPath '{abs_path_escaped}' | ForEach-Object {{ $i = $i + 1; \"{{0}} {{1}}\" -f $i, $_ }}"
+        )
+        encoded = base64.b64encode(ps_script.encode("utf-16le")).decode("ascii")
+        source_cmd = f"powershell -NoProfile -ExecutionPolicy Bypass -EncodedCommand {encoded}"
+        source_cmd_ps_literal = source_cmd.replace("'", "''")
+        if edit:
+            code = f"""
+$sourceCmd = '{source_cmd_ps_literal}'
+$res = tv `
+--source-command $sourceCmd `
+--preview-command 'bat --color=always --style=numbers --highlight-line {{split: :0}} {abs_path}' `
+--preview-size 80 `
+--preview-offset "{{split: :0}}" `
+--source-output "{{}}"
+if ($res) {{
+    $line = $res.Split(' ')[0]
+    hx "{abs_path_escaped}:$line"
+}}
+"""
+        else:
+            code = f"""
+$sourceCmd = '{source_cmd_ps_literal}'
+tv `
+--source-command $sourceCmd `
+--preview-command 'bat --color=always --style=numbers --highlight-line {{split: :0}} {abs_path}' `
+--preview-size 80 `
+--preview-offset "{{split: :0}}" `
+--source-output "{{}}" | ForEach-Object {{ $_ -replace '^\\d+\\s+', '' }}
+"""
+        if is_temp_file:
+            code += f"\nRemove-Item '{abs_path_escaped}' -Force"
+    else:
+        raise RuntimeError(f"Unsupported platform, {platform.system()}")
+    return code
+
+def _run_symantic_search(extension: str) -> None:
+    """Run symantic search."""
+    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)
+
+
+def _run_ast_search(directory: str) -> None:
+    """Run AST search."""
+    from machineconfig.scripts.python.helpers.helpers_search.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)
+    except Exception as e:
+        print(f"❌ Error during selection: {e}")
+
+
+def _run_file_search(no_dotfiles: bool, edit: bool) -> None:
+    """Run file search."""
+    import platform
+
+    if not edit:
+        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
+
+    if platform.system() == "Linux" or platform.system() == "Darwin":
+        script = """
+selected=$({SOURCE_CMD} fzf --ansi --preview-window 'right:60%' --preview 'bat --color=always --style=numbers,grid,header --line-range :300 {}')
+if [ -n "$selected" ]; then
+    res=$(nl -ba -w1 -s' ' "$selected" | tv \
+    --preview-command "bat --color=always --style=numbers --highlight-line {split: :0} $selected" \
+    --preview-size 80 \
+    --preview-offset "{split: :0}" \
+    --source-output "{}")
+    if [ -n "$res" ]; then
+        line=$(echo "$res" | cut -d' ' -f1)
+        hx "$selected:$line"
+    fi
+fi
+"""
+        source_cmd = "" if not no_dotfiles else "fd | "
+        script = script.replace("{SOURCE_CMD}", source_cmd)
+    elif platform.system() == "Windows":
+        script = r"""
+$selected = {SOURCE_CMD} fzf --ansi --preview-window 'right:60%' --preview 'bat --color=always --style=numbers,grid,header --line-range :300 {}'
+if ($selected) {
+    $choicesPath = Join-Path $env:TEMP ("msearch_choices_" + [guid]::NewGuid().ToString() + ".txt")
+    $i = 0
+    Get-Content -LiteralPath "$selected" | ForEach-Object { $i = $i + 1; "{0} {1}" -f $i, $_ } | Set-Content -LiteralPath $choicesPath -Encoding utf8
+    $sourceCmd = 'cmd /C type "' + $choicesPath + '"'
+    $previewCmd = 'bat --color=always --style=numbers --highlight-line {split: :0} "' + $selected + '"'
+    $res = tv `
+    --source-command $sourceCmd `
+    --preview-command $previewCmd `
+    --preview-size 80 `
+    --preview-offset "{split: :0}" `
+    --source-output "{}"
+    Remove-Item -LiteralPath $choicesPath -Force -ErrorAction SilentlyContinue
+    if ($res) {
+        $line = $res.Split(' ')[0]
+        hx "$($selected):$line"
+    }
+}
+"""
+        source_cmd = "" if not no_dotfiles else "fd | "
+        script = script.replace("{SOURCE_CMD}", source_cmd)
+    else:
+        raise RuntimeError("Unsupported platform")
+
+    from machineconfig.utils.code import run_shell_script
+
+    run_shell_script(script=script)
+
+
+def _run_text_search(rga: bool, directory: Optional[str]) -> None:
+    """Run text search using fzf with ripgrep."""
+    from machineconfig.scripts.python.helpers.helpers_msearch import FZFG_LINUX_PATH, FZFG_WINDOWS_PATH
+    import platform
+
+    if platform.system() == "Linux" or platform.system() == "Darwin":
+        script = FZFG_LINUX_PATH.read_text(encoding="utf-8")
+    elif platform.system() == "Windows":
+        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
+    if directory:
+        script = "cd " + directory + "\n" + script
+    exit_then_run_shell_script(script=script, strict=False)

machineconfig/scripts/python/{helpers_msearch → helpers/helpers_msearch}/scripts_linux/fzfg

@@ -2,9 +2,11 @@
 # fzf and ggrep with switch keys for modes
 # https://github.com/junegunn/fzf/blob/master/ADVANCED.md#switching-between-ripgrep-mode-and-fzf-mode
 
+
+
 # Switch between Ripgrep launcher mode (CTRL-R) and fzf filtering mode (CTRL-F)
 RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
-INITIAL_QUERY="${*:-}"
+INITIAL_QUERY=""
 IFS=: read -ra selected < <(
   FZF_DEFAULT_COMMAND="$RG_PREFIX $(printf %q "$INITIAL_QUERY")" \
   fzf --ansi \
@@ -19,5 +21,4 @@ IFS=: read -ra selected < <(
       --preview 'bat --color=always {1} --highlight-line {2}' \
       --preview-window 'up,60%,border-bottom,+{2}+3/3,~3'
 )
-[ -n "${selected[0]}" ] && hx "${selected[0]}:${selected[1]}:${selected[2]}"
-"
+[ -n "${selected[0]}" ] && hx "${selected[0]}:${selected[1]}:${selected[2]}"

machineconfig/scripts/python/helpers/helpers_msearch/scripts_linux/search_with_context.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+
+# This script allows searching through input (stdin) using 'tv' (television)
+# while showing the context around the matching line in the preview window.
+#
+# Usage: command | ./search_with_context.sh
+# Example: hyperfine --help | ./search_with_context.sh
+
+# set -o pipefail
+
+
+# Create a temporary file to store the stdin input
+TEMP_FILE=$(mktemp)
+# Capture stdin to the temp file
+cat > "$TEMP_FILE"
+# Ensure cleanup of the temp file on exit
+trap "rm -f $TEMP_FILE" EXIT
+
+# Run tv with the following configuration:
+# 1. `nl -ba -w1 -s' '`: Add line numbers to the input (e.g., "1 line content").
+#    -ba: number all lines
+#    -w1: width of line numbers (minimal)
+#    -s' ': separator is a single space
+#
+# 2. `tv`: The television fuzzy finder.
+#
+# 3. `--preview-command`: Use `bat` to show the file content.
+#    - `--color=always`: Force color output for the preview.
+#    - `--highlight-line {split: :0}`: Highlight the line number extracted from the entry.
+#      `{split: :0}` splits the entry by space (default) and takes the first field (index 0), which is the line number.
+#    - `$TEMP_FILE`: The file to preview.
+#
+# 4. `--preview-offset`: Scroll the preview to the matching line.
+#    - `{split: :0}`: Use the extracted line number as the offset.
+#
+# 5. `--source-output`: Define what `tv` outputs when an entry is selected.
+#    - `{}`: Output the full entry (including the line number).
+#
+# 6. `cut -d' ' -f2-`: Post-process the output to remove the line number.
+#    - `-d' '`: Delimiter is space.
+#    - `-f2-`: Keep fields from 2 onwards (dropping the line number).
+
+nl -ba -w1 -s' ' "$TEMP_FILE" | tv \
+    --preview-command "bat --color=always --highlight-line {split: :0} $TEMP_FILE" \
+    --preview-size 80 \
+    --preview-offset "{split: :0}" \
+    --source-output "{}" \
+    | cut -d' ' -f2-

machineconfig/scripts/python/{helpers_msearch → helpers/helpers_msearch}/scripts_windows/fzfg.ps1

@@ -9,7 +9,7 @@ if ($null -eq $QueryTokens) {
     $QueryTokens = @()
 }
 
-$initialQuery = if ($QueryTokens.Count -gt 0) { [string]::Join(' ', $QueryTokens) } else { '' }
+$initialQuery = ''
 $rgPrefix = 'rg --column --line-number --no-heading --color=always --smart-case '
 
 $escapedDefault = if ($initialQuery.Length -gt 0) {

machineconfig/scripts/python/helpers/helpers_navigator/__init__.py

@@ -0,0 +1,20 @@
+"""
+Helper modules for the devops navigator TUI application.
+"""
+
+from machineconfig.scripts.python.helpers.helpers_navigator.data_models import CommandInfo, ArgumentInfo
+from machineconfig.scripts.python.helpers.helpers_navigator.command_builder import CommandBuilderScreen
+from machineconfig.scripts.python.helpers.helpers_navigator.command_tree import CommandTree
+from machineconfig.scripts.python.helpers.helpers_navigator.command_detail import CommandDetail
+from machineconfig.scripts.python.helpers.helpers_navigator.search_bar import SearchBar
+from machineconfig.scripts.python.helpers.helpers_navigator.main_app import CommandNavigatorApp
+
+__all__ = [
+    "CommandInfo",
+    "ArgumentInfo",
+    "CommandBuilderScreen",
+    "CommandTree",
+    "CommandDetail",
+    "SearchBar",
+    "CommandNavigatorApp",
+]