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

machineconfig/scripts/python/helpers/helpers_utils/specs.py

@@ -0,0 +1,246 @@
+"""
+CPU Specification Helper.
+
+This module provides utilities to detect the CPU model and fetch Geekbench scores
+using the geekbench-browser-python tool.
+"""
+
+import platform
+import re
+import subprocess
+
+
+def get_cpu_name() -> str:
+    """
+    Detect the CPU model name across different operating systems.
+
+    Returns:
+        str: The detected CPU model name or 'Unknown CPU'.
+    """
+    system = platform.system()
+
+    if system == "Linux":
+        try:
+            with open("/proc/cpuinfo") as f:
+                for line in f:
+                    if "model name" in line:
+                        return line.split(":", 1)[1].strip()
+        except FileNotFoundError:
+            pass
+
+    elif system == "Windows":
+        try:
+            # shell=True might be needed for wmic depending on environment,
+            # but usually check_output with string list is safer if executable is in path.
+            # User provided: wmic cpu get name
+            output = subprocess.check_output("wmic cpu get name", shell=True).decode()
+            lines = output.strip().split("\n")
+            if len(lines) > 1:
+                return lines[1].strip()
+        except (subprocess.CalledProcessError, IndexError):
+            pass
+
+    elif system == "Darwin":
+        try:
+            return subprocess.check_output(
+                ["sysctl", "-n", "machdep.cpu.brand_string"]
+            ).decode().strip()
+        except subprocess.CalledProcessError:
+            pass
+
+    return "Unknown CPU"
+
+
+def clean_cpu_name(cpu_name: str) -> str:
+    """
+    Clean the CPU name to improve Geekbench search results.
+
+    Removes extra details like 'w/ Radeon Graphics', frequency, etc.
+
+    Args:
+        cpu_name (str): The raw CPU name string.
+
+    Returns:
+        str: A cleaned CPU name suitable for searching.
+    """
+    # Remove "w/ ..." or "with ..."
+    # Example: AMD Ryzen 7 8745HS w/ Radeon 780M Graphics -> AMD Ryzen 7 8745HS
+    cleaned = re.split(r"\s+(w/|with)\s+", cpu_name, flags=re.IGNORECASE)[0]
+
+    # Remove (R) and (TM) symbols which confuse regex search and are often noisy
+    cleaned = re.sub(r"\([RT]M?\)", "", cleaned, flags=re.IGNORECASE)
+
+    # Remove clock speed like " @ 3.00GHz", " 3.00GHz", " 3.2GHz"
+    cleaned = re.sub(r"\s+@?\s*\d+(\.\d+)?\s*GHz", "", cleaned, flags=re.IGNORECASE)
+
+    # Remove "12-Core Processor" etc if present (some linux distros add this)
+    cleaned = re.sub(r"\s+\d+-Core\s+Processor", "", cleaned, flags=re.IGNORECASE)
+
+    # Remove trailing "Processor" word if it's there
+    cleaned = re.sub(r"\s+Processor", "", cleaned, flags=re.IGNORECASE)
+
+    # Collapse multiple spaces
+    cleaned = re.sub(r"\s+", " ", cleaned)
+
+    return cleaned.strip()
+
+
+def run_geekbench_lookup(search_term: str) -> bool:
+    """
+    Run the geekbench search using uvx.
+
+    Args:
+        search_term (str): The CPU name to search for (supports Regex).
+
+    Returns:
+        bool: True if results were found, False otherwise.
+    """
+    # Note: uvx caches the tool so subsequent runs are fast.
+    # The 'gbr' tool uses pandas.str.contains(regex=True), so we can use regex patterns.
+    # We quote the search term to ensure it's treated as a single pattern containing spaces.
+    cmd = [
+        "uvx",
+        "--from",
+        "geekbench-browser-python",
+        "gbr",
+        search_term,
+        "--verbose",
+    ]
+    printable_cmd = " ".join(f'"{x}"' if " " in x else x for x in cmd)
+    print(f"Running: {printable_cmd}")
+    try:
+        # Capture output to check for results
+        # We enforce utf-8 encoding because 'geekbench-browser-python' likely outputs
+        # Unicode characters (Rich tables, box drawing) which can fail to decode or
+        # appear as garbage on Windows (default cp1252) if not handled.
+        result = subprocess.run(
+            cmd,
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+        )
+        output = result.stdout
+
+        # Check if we have data rows.
+        # Check iteratively for lines that look like data rows (Unicode or ASCII).
+        lines = output.splitlines()
+        has_data = False
+        for line in lines:
+            line_stripped = line.strip()
+            # Unicode table data row start (Light Vertical)
+            if "│" in line:
+                has_data = True
+                break
+            # ASCII table data row start (Pipe)
+            # Must exclude headers and separators which also start with pipe in ASCII mode.
+            if line_stripped.startswith("|"):
+                lower_line = line.lower()
+                # Skip header/separator lines
+                if "description" in lower_line or "single" in lower_line or "---" in line:
+                    continue
+                has_data = True
+                break
+        
+        if has_data:
+            print(output)
+            return True
+        else:
+            # If verbose debugging is needed, we could print output here.
+            # But normally if no table is found, the tool might have just printed log info to stderr.
+            # If it did print something to stdout that isn't a table, we probably shouldn't show it
+            # as a "result", but it might be helpful for debugging why it failed.
+            if output.strip():
+                 # Only print debug info if it's NOT just an empty table structure to avoid noise
+                 if not ("description" in output.lower() and ("---" in output or "│" in output)):
+                     print(f"Debug output from tool:\n{output}")
+            
+            print(f"No results found for '{search_term}'.")
+            return False
+
+    except subprocess.CalledProcessError:
+        print("Failed to retrieve Geekbench scores (command failed).")
+        return False
+    except FileNotFoundError:
+        print("Error: 'uvx' command not found. Please ensure 'uv' is installed.")
+        return False
+
+
+def main() -> None:
+    """Main entry point."""
+    cpu_name = get_cpu_name()
+    print(f"Detected CPU: {cpu_name}")
+
+    if cpu_name == "Unknown CPU":
+        print("Could not detect CPU name. Exiting.")
+        return
+
+    full_search_term = clean_cpu_name(cpu_name)
+    
+    # Retry logic: remove last word until we find something or run out of words
+    # We escape each word to ensure regex special characters (like +, (), etc) in the name
+    # are treated as literals, while preserving our ability to use regex wildcards later.
+    words = [re.escape(w) for w in full_search_term.split()]
+    
+    while words:
+        current_term = " ".join(words)
+        
+        # Heuristic: Don't search for extremely short generic terms if possible,
+        # but "AMD" or "Intel" might be what we end up with if nothing else works.
+        # Let's try at least length 2 words unless it's just 1 word left.
+        if len(words) > 1 and len(current_term) < 4:
+             words.pop()
+             continue
+
+        print(f"Search Term: {current_term}")
+        if run_geekbench_lookup(current_term):
+            return
+        
+        last_word = words[-1]
+        numeric_part = None
+
+        # Check if the last word starts with digits (e.g. 8745HS or 8745)
+        # We want to both strip suffix AND try wildcards.
+        match_digits = re.match(r"^(\d+)([a-zA-Z].*)?$", last_word)
+        
+        if match_digits:
+            numeric_part = match_digits.group(1)
+            suffix_part = match_digits.group(2) # May be None
+
+            # Intermediate Try 1: Strip suffix (e.g. 8745HS -> 8745)
+            if suffix_part and len(numeric_part) >= 3:
+                 intermediate_term = " ".join(words[:-1] + [numeric_part])
+                 if intermediate_term != current_term:
+                     print(f"Search Term: {intermediate_term} (stripped suffix)")
+                     if run_geekbench_lookup(intermediate_term):
+                        return
+            
+            # Intermediate Try 2: Wildcard/Regex search (e.g. 8745 -> 87..)
+            # The tool uses Regex, so we use dots '.' to match any character instead of '?'
+            if numeric_part and len(numeric_part) >= 3:
+                # If 4+ digits (e.g. 8745), replace last 2 with .. -> 87..
+                # If 3 digits (e.g. 780), replace last 1 with . -> 78.
+                if len(numeric_part) >= 4:
+                    wildcard_model = numeric_part[:-2] + ".."
+                else:
+                    wildcard_model = numeric_part[:-1] + "."
+                
+                wildcard_term = " ".join(words[:-1] + [wildcard_model])
+                
+                # Check duplication against current_term and the stripped version
+                stripped_term = " ".join(words[:-1] + [numeric_part])
+                if wildcard_term != current_term and wildcard_term != stripped_term:
+                     print(f"Search Term: {wildcard_term} (regex wildcard)")
+                     if run_geekbench_lookup(wildcard_term):
+                        return
+
+        # Remove last word for next iteration
+        words.pop()
+
+    print("Could not find any matching Geekbench scores.")
+
+
+if __name__ == "__main__":
+    main()

machineconfig/scripts/python/mcfg_entry.py

@@ -1,55 +1,140 @@
-
-from machineconfig.scripts.python.devops import get_app as get_devops_app
-from machineconfig.scripts.python.cloud import get_app as get_cloud_app
-from machineconfig.scripts.python.agents import get_app as get_agents_app
-from machineconfig.scripts.python.sessions import get_app as get_sessions_app
-from machineconfig.scripts.python.utils import get_app as get_utils_app
-
-from machineconfig.scripts.python.ftpx import ftpx as ftpx_func
-from machineconfig.scripts.python.croshell import croshell as croshell_func
-from machineconfig.scripts.python.fire_jobs import fire as get_fire_jobs_app
-from machineconfig.scripts.python.terminal import get_app as get_terminal_app
-
-def get_app():
-    import typer
-    app = typer.Typer(help="MachineConfig CLI - Manage your machine configurations and workflows", no_args_is_help=True, add_help_option=False, add_completion=False)
-    devops_app = get_devops_app()
-    app.add_typer(devops_app, name="devops", help="[d] DevOps related commands", no_args_is_help=True)
-    app.add_typer(devops_app, name="d", hidden=True)  # short alias
-
-    cloud_app = get_cloud_app()
-    app.add_typer(cloud_app, name="cloud", help="[c] Cloud management commands", no_args_is_help=True)
-    app.add_typer(cloud_app, name="c", hidden=True)  # short alias
-
-    sessions_app = get_sessions_app()
-    app.add_typer(sessions_app, name="sessions", help="[s] Session and layout management", no_args_is_help=True)
-    app.add_typer(sessions_app, name="s", hidden=True)  # short alias
-
-
-    agents_app = get_agents_app()
-    app.add_typer(agents_app, name="agents", help="[a] 🤖 AI Agents management commands", no_args_is_help=True)
-    app.add_typer(agents_app, name="a", hidden=True)  # short alias
-
-    app.command(name="fire", help="[f] Fire and manage jobs", no_args_is_help=False)(get_fire_jobs_app)
-    app.command(name="f", hidden=True, no_args_is_help=False)(get_fire_jobs_app)
-    app.command("ftpx", no_args_is_help=True, help="[ff] File transfer utility though SSH")(ftpx_func)
-    app.command("ff", no_args_is_help=True, hidden=True)(ftpx_func)  # short alias
-    app.command("croshell", no_args_is_help=False, help="[r] Cross-shell command execution")(croshell_func)
-    app.command("r", no_args_is_help=False, hidden=True)(croshell_func)  # short alias
-
-    utils_app = get_utils_app()
-    app.add_typer(utils_app, name="utils", help="[u] Utility commands", no_args_is_help=True)
-    app.add_typer(utils_app, name="u", hidden=True)  # short alias
-
-
-    terminal_app = get_terminal_app()
-    app.add_typer(terminal_app, name="terminal", help="[t] Terminal management commands", no_args_is_help=True)
-    app.add_typer(terminal_app, name="t", hidden=True)  # short alias
+"""Fast-loading CLI entry point using lazy imports.
+
+Submodules are only imported when their commands are actually invoked, not at startup.
+This makes `mcfg --help` much faster by avoiding loading heavy dependencies.
+"""
+from typing import Optional, Annotated
+import typer
+
+
+def fire(
+    ctx: typer.Context,
+    path: Annotated[str, typer.Argument(help="Path to the Python file to run")] = ".",
+    function: Annotated[Optional[str], typer.Argument(help="Function to run")] = None,
+    ve: Annotated[str, typer.Option("--ve", "-v", help="Virtual environment name")] = "",
+    cmd: Annotated[bool, typer.Option("--cmd", "-B", help="Create a cmd fire command to launch the job asynchronously")] = False,
+    interactive: Annotated[bool, typer.Option("--interactive", "-i", help="Whether to run the job interactively using IPython")] = False,
+    debug: Annotated[bool, typer.Option("--debug", "-d", help="Enable debug mode")] = False,
+    choose_function: Annotated[bool, typer.Option("--choose-function", "-c", help="Choose function interactively")] = False,
+    loop: Annotated[bool, typer.Option("--loop", "-l", help="Infinite recursion (runs again after completion/interruption)")] = False,
+    jupyter: Annotated[bool, typer.Option("--jupyter", "-j", help="Open in a jupyter notebook")] = False,
+    marimo: Annotated[bool, typer.Option("--marimo", "-M", help="Open in a marimo notebook")] = False,
+    module: Annotated[bool, typer.Option("--module", "-m", help="Launch the main file")] = False,
+    script: Annotated[bool, typer.Option("--script", "-s", help="Launch as a script without fire")] = False,
+    optimized: Annotated[bool, typer.Option("--optimized", "-O", help="Run the optimized version of the function")] = False,
+    zellij_tab: Annotated[Optional[str], typer.Option("--zellij-tab", "-z", help="Open in a new zellij tab")] = None,
+    submit_to_cloud: Annotated[bool, typer.Option("--submit-to-cloud", "-C", help="Submit to cloud compute")] = False,
+    remote: Annotated[bool, typer.Option("--remote", "-r", help="Launch on a remote machine")] = False,
+    streamlit: Annotated[bool, typer.Option("--streamlit", "-S", help="Run as streamlit app")] = False,
+    environment: Annotated[str, typer.Option("--environment", "-E", help="Choose ip, localhost, hostname or arbitrary url")] = "",
+    holdDirectory: Annotated[bool, typer.Option("--holdDirectory", "-D", help="Hold current directory and avoid cd'ing to the script directory")] = False,
+    PathExport: Annotated[bool, typer.Option("--PathExport", "-P", help="Augment the PYTHONPATH with repo root")] = False,
+    git_pull: Annotated[bool, typer.Option("--git-pull", "-g", help="Start by pulling the git repo")] = False,
+    watch: Annotated[bool, typer.Option("--watch", "-w", help="Watch the file for changes")] = False,
+) -> None:
+    """Fire and manage jobs."""
+    from machineconfig.scripts.python.fire_jobs import fire as fire_impl
+    fire_impl(ctx=ctx, path=path, function=function, ve=ve, cmd=cmd, interactive=interactive, debug=debug,
+              choose_function=choose_function, loop=loop, jupyter=jupyter, marimo=marimo, module=module,
+              script=script, optimized=optimized, zellij_tab=zellij_tab, submit_to_cloud=submit_to_cloud,
+              remote=remote, streamlit=streamlit, environment=environment, holdDirectory=holdDirectory,
+              PathExport=PathExport, git_pull=git_pull, watch=watch)
+
+
+def ftpx(
+    source: Annotated[str, typer.Argument(help="Source path (machine:path)")],
+    target: Annotated[str, typer.Argument(help="Target path (machine:path)")],
+    recursive: Annotated[bool, typer.Option("--recursive", "-r", help="Send recursively.")] = False,
+    zipFirst: Annotated[bool, typer.Option("--zipFirst", "-z", help="Zip before sending.")] = False,
+    cloud: Annotated[bool, typer.Option("--cloud", "-c", help="Transfer through the cloud.")] = False,
+    overwrite_existing: Annotated[bool, typer.Option("--overwrite-existing", "-o", help="Overwrite existing files on remote when sending from local to remote.")] = False,
+) -> None:
+    """File transfer utility though SSH."""
+    from machineconfig.scripts.python.ftpx import ftpx as ftpx_impl
+    ftpx_impl(source=source, target=target, recursive=recursive, zipFirst=zipFirst, cloud=cloud, overwrite_existing=overwrite_existing)
+
+
+def croshell(
+    path: Annotated[Optional[str], typer.Argument(help="path of file to read.")] = None,
+    project_path: Annotated[Optional[str], typer.Option("--project", "-p", help="specify uv project to use")] = None,
+    uv_with: Annotated[Optional[str], typer.Option("--uv-with", "-w", help="specify uv with packages to use")] = None,
+    marimo: Annotated[bool, typer.Option("--marimo", "-m", help="open the notebook using marimo if available")] = False,
+    jupyter: Annotated[bool, typer.Option("--jupyter", "-j", help="run in jupyter interactive console")] = False,
+    vscode: Annotated[bool, typer.Option("--vscode", "-c", help="open the script in vscode")] = False,
+    visidata: Annotated[bool, typer.Option("--visidata", "-v", help="open data file in visidata")] = False,
+    python: Annotated[bool, typer.Option("--python", "-P", help="flag to use python over IPython.")] = False,
+    profile: Annotated[Optional[str], typer.Option("--profile", "-r", help="ipython profile to use, defaults to default profile.")] = None,
+) -> None:
+    """Cross-shell command execution."""
+    from machineconfig.scripts.python.croshell import croshell as croshell_impl
+    croshell_impl(path=path, project_path=project_path, uv_with=uv_with, marimo=marimo, jupyter=jupyter, vscode=vscode, visidata=visidata, python=python, profile=profile)
+
+
+def devops(ctx: typer.Context) -> None:
+    """[d] DevOps related commands."""
+    from machineconfig.scripts.python.devops import get_app
+    get_app()(ctx.args, standalone_mode=not ctx.args)
+
+
+def cloud(ctx: typer.Context) -> None:
+    """[c] Cloud management commands."""
+    from machineconfig.scripts.python.cloud import get_app
+    get_app()(ctx.args, standalone_mode=not ctx.args)
+
+
+def sessions(ctx: typer.Context) -> None:
+    """[s] Session and layout management."""
+    from machineconfig.scripts.python.sessions import get_app
+    get_app()(ctx.args, standalone_mode=not ctx.args)
+
+
+def agents(ctx: typer.Context) -> None:
+    """[a] 🤖 AI Agents management commands."""
+    from machineconfig.scripts.python.agents import get_app
+    get_app()(ctx.args, standalone_mode=not ctx.args)
+
+
+def utils(ctx: typer.Context) -> None:
+    """[u] Utility commands."""
+    from machineconfig.scripts.python.utils import get_app
+    get_app()(ctx.args, standalone_mode=not ctx.args)
+
+
+def terminal(ctx: typer.Context) -> None:
+    """[t] Terminal management commands."""
+    from machineconfig.scripts.python.terminal import get_app
+    get_app()(ctx.args, standalone_mode=not ctx.args)
+
+
+def get_app() -> typer.Typer:
+    app = typer.Typer(help="MachineConfig CLI - Manage your machine configurations and workflows", no_args_is_help=True, add_help_option=True, add_completion=False)
+
+    ctx_settings: dict[str, object] = {"allow_extra_args": True, "allow_interspersed_args": True, "ignore_unknown_options": True, "help_option_names": []}
+
+    app.command(name="devops", help="[d] DevOps related commands", context_settings=ctx_settings)(devops)
+    app.command(name="d", hidden=True, context_settings=ctx_settings)(devops)
+    app.command(name="cloud", help="[c] Cloud management commands", context_settings=ctx_settings)(cloud)
+    app.command(name="c", hidden=True, context_settings=ctx_settings)(cloud)
+    app.command(name="sessions", help="[s] Session and layout management", context_settings=ctx_settings)(sessions)
+    app.command(name="s", hidden=True, context_settings=ctx_settings)(sessions)
+    app.command(name="agents", help="[a] 🤖 AI Agents management commands", context_settings=ctx_settings)(agents)
+    app.command(name="a", hidden=True, context_settings=ctx_settings)(agents)
+    app.command(name="utils", help="[u] Utility commands", context_settings=ctx_settings)(utils)
+    app.command(name="u", hidden=True, context_settings=ctx_settings)(utils)
+    app.command(name="terminal", help="[t] Terminal management commands", context_settings=ctx_settings)(terminal)
+    app.command(name="t", hidden=True, context_settings=ctx_settings)(terminal)
+
+    app.command(name="fire", help="[f] Fire and manage jobs", no_args_is_help=False, context_settings={"allow_extra_args": True, "allow_interspersed_args": False})(fire)
+    app.command(name="f", hidden=True, no_args_is_help=False, context_settings={"allow_extra_args": True, "allow_interspersed_args": False})(fire)
+    app.command("ftpx", no_args_is_help=True, help="[ff] File transfer utility though SSH")(ftpx)
+    app.command("ff", no_args_is_help=True, hidden=True)(ftpx)
+    app.command("croshell", no_args_is_help=False, help="[r] Cross-shell command execution")(croshell)
+    app.command("r", no_args_is_help=False, hidden=True)(croshell)
 
     return app
 
 
-def main():
+def main() -> None:
     app = get_app()
     app()
 

machineconfig/scripts/python/msearch.py

@@ -1,72 +1,26 @@
+"""msearch - Machineconfig search helper."""
 
 import typer
 from typing import Annotated
 
 
 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" 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
-    exit_then_run_shell_script(script=script, strict=False)
+    path: Annotated[str, typer.Argument(help="The directory/file 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,
+    edit: Annotated[bool, typer.Option(..., "--edit", "-e", help="Open selection in editor (helix)")] = False,
+    install_dependencies: Annotated[bool, typer.Option(..., "--install-req", "-i", help="Install required dependencies if missing")] = False,
+) -> None:
+    """Machineconfig search helper."""
+    from machineconfig.scripts.python.helpers.helpers_msearch.msearch_impl import machineconfig_search as impl
+    impl(path=path, ast=ast, symantic=symantic, extension=extension, file=file, no_dotfiles=no_dotfiles, rga=rga, edit=edit, install_dependencies=install_dependencies)
 
 
-def main():
+def main() -> None:
     app = typer.Typer(add_completion=False, no_args_is_help=True)
     app.command(name="msearch", help=machineconfig_search.__doc__, short_help="machineconfig search helper", no_args_is_help=False)(machineconfig_search)
     app()