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

machineconfig/scripts/python/helpers/helpers_sessions/sessions_impl.py

@@ -0,0 +1,177 @@
+"""Pure Python implementations for sessions commands - no typer dependencies."""
+
+from typing import Optional, Literal
+from pathlib import Path
+
+
+def balance_load(
+    layout_path: str,
+    max_thresh: int,
+    thresh_type: Literal["number", "n", "weight", "w"],
+    breaking_method: Literal["moreLayouts", "ml", "combineTabs", "ct"],
+    output_path: Optional[str],
+) -> 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"}
+
+    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_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_resolved[thresh_type], breaking_method=breaking_method_resolved[breaking_method])
+    layoutfile["layouts"] = new_layouts
+    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")
+    print(f"Adjusted layout saved to {target_file}")
+
+
+def select_layout(layouts_json_file: str, selected_layouts_names: Optional[list[str]], select_interactively: bool, subsitute_home: bool) -> list["LayoutConfig"]:  # type: ignore[name-defined]
+    """Select layout(s) from a layout file."""
+    import json
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile, LayoutConfig
+    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:
+        if not select_interactively:
+            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:", tv=True, msg="Choose one option")
+    print(f"Selected layout(s): {selected_layouts_names}")
+    layouts_chosen: list[LayoutConfig] = []
+    for name in selected_layouts_names:
+        layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"] == name), None)
+        if layout_chosen is None:
+            layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"].lower() == name.lower()), None)
+        if layout_chosen is None:
+            available_layouts = [layout["layoutName"] for layout in layout_file["layouts"]]
+            raise ValueError(f"Layout '{name}' not found. Available layouts: {available_layouts}")
+        layouts_chosen.append(layout_chosen)
+    return layouts_chosen
+
+
+def find_layout_file(layout_path: str) -> str:
+    """Find layout file from a path."""
+    from machineconfig.utils.path_helper import search_for_files_of_interest, match_file_name, sanitize_path
+    from machineconfig.utils.options import choose_from_options
+    path_obj = sanitize_path(layout_path)
+    if not path_obj.exists():
+        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, suffixes={".py", ".sh", ".ps1"})
+        print(f"🔍 Got #{len(files)} results.")
+        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 str(choice_file)
+
+
+def run_layouts(
+    layout_path: Optional[str],
+    max_tabs: int,
+    max_layouts: int,
+    sleep_inbetween: float,
+    monitor: bool,
+    parallel: bool,
+    kill_upon_completion: bool,
+    choose: Optional[str],
+    choose_interactively: bool,
+    subsitute_home: bool,
+) -> None:
+    """Launch terminal sessions based on a layout configuration file."""
+    if layout_path is None:
+        raise ValueError("layout_path is required")
+
+    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, subsitute_home=subsitute_home)
+
+    if parallel and len(layouts_selected) > max_layouts:
+        raise ValueError(f"Number of layouts {len(layouts_selected)} exceeds the maximum allowed {max_layouts}. Please adjust your layout file.")
+    for a_layout in layouts_selected:
+        if len(a_layout["layoutTabs"]) > max_tabs:
+            raise ValueError(f"Layout '{a_layout.get('layoutName', 'Unnamed')}' has {len(a_layout['layoutTabs'])} tabs which exceeds the max of {max_tabs}.")
+
+    import time
+    import platform
+    if platform.system() == "Linux" or platform.system() == "Darwin":
+        from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
+        if not parallel:
+            iterable = [[item] for item in layouts_selected]
+        else:
+            iterable = [layouts_selected]
+        for i, a_layouts in enumerate(iterable):
+            manager = ZellijLocalManager(session_layouts=a_layouts)
+            manager.start_all_sessions(poll_interval=2, poll_seconds=2)
+            if monitor:
+                manager.run_monitoring_routine(wait_ms=2000)
+                if kill_upon_completion:
+                    manager.kill_all_sessions()
+            if i < len(layouts_selected) - 1:
+                time.sleep(sleep_inbetween)
+    elif platform.system() == "Windows":
+        from machineconfig.cluster.sessions_managers.wt_local_manager import WTLocalManager
+        if not parallel:
+            iterable = [[item] for item in layouts_selected]
+        else:
+            iterable = [layouts_selected]
+        for i, a_layouts in enumerate(iterable):
+            manager = WTLocalManager(session_layouts=a_layouts)
+            manager.start_all_sessions()
+            if monitor:
+                manager.run_monitoring_routine(wait_ms=2000)
+                if kill_upon_completion:
+                    manager.kill_all_sessions()
+            if i < len(layouts_selected) - 1:
+                time.sleep(sleep_inbetween)
+    else:
+        print(f"❌ Unsupported platform: {platform.system()}")
+
+
+def create_template(name: Optional[str], num_tabs: int) -> None:
+    """Create a layout template file."""
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile, TabConfig, LayoutConfig
+    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}")

machineconfig/scripts/python/{helpers_sessions → helpers/helpers_sessions}/sessions_multiprocess.py

@@ -45,7 +45,7 @@ def create_from_function(
 
     # =========================  choosing function to run
     if function is None or function.strip() == "":
-        from machineconfig.scripts.python.helpers_fire_command.fire_jobs_route_helper import choose_function_or_lines
+        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={})
     else:
         choice_function = function

machineconfig/scripts/python/helpers/helpers_terminal/terminal_impl.py

@@ -0,0 +1,96 @@
+import re
+import subprocess
+from pathlib import Path
+
+
+_ANSI_ESCAPE_RE = re.compile(
+    r"(?:\x1B|\u001B|\033)\[[0-?]*[ -/]*[@-~]|\[[0-9;?]+[ -/]*[@-~]|\[m"
+)
+
+
+def strip_ansi_codes(text: str) -> str:
+    return _ANSI_ESCAPE_RE.sub("", text)
+
+
+def choose_zellij_session(name: str | None, new_session: bool, kill_all: bool) -> tuple[str, str | None]:
+    """Choose a Zellij session. Returns tuple of (action, script_to_run) where action is 'run_script', 'exit', or 'error'."""
+    if name is not None:
+        return ("run_script", f"zellij attach {name}")
+    if new_session:
+        cmd = "zellij --layout st2"
+        if kill_all:
+            cmd = f"zellij kill-all-sessions --yes\n{cmd}"
+        return ("run_script", cmd)
+    cmd = "zellij list-sessions"
+    try:
+        sessions: list[str] = subprocess.check_output(cmd, shell=True).decode().strip().split("\n")
+    except subprocess.CalledProcessError:
+        sessions = []
+    sessions = [s for s in sessions if s.strip()]
+    # print(f"Found Zellij sessions: {sessions}")
+    sessions.sort(key=lambda s: "EXITED" in s)
+    if "current" in sessions:
+        return ("error", "Already in a Zellij session, avoiding nesting and exiting.")
+    if len(sessions) == 0:
+        return ("run_script", "zellij --layout st2")
+    if len(sessions) == 1:
+        sn = strip_ansi_codes(sessions[0])
+        session_name = sn.split(" [Created")[0]
+        return ("run_script", f"zellij attach {session_name}")
+    from machineconfig.utils.options import choose_from_options
+    NEW_SESSION_LABEL = "NEW SESSION"
+    KILL_ALL_AND_NEW_LABEL = "KILL ALL SESSIONS & START NEW"
+    options = sessions + [NEW_SESSION_LABEL, KILL_ALL_AND_NEW_LABEL]
+    try:
+        session_name = choose_from_options(msg="Choose a Zellij session to attach to:", multi=False, options=options, tv=True)
+    except Exception as e:
+        return ("error", f"Error choosing Zellij session: {e}")
+    if session_name == NEW_SESSION_LABEL:
+        cmd = "zellij --layout st2"
+        if kill_all:
+            cmd = f"zellij kill-all-sessions --yes\n{cmd}"
+        return ("run_script", cmd)
+    if session_name == KILL_ALL_AND_NEW_LABEL:
+        return ("run_script", "zellij kill-all-sessions --yes\nzellij --layout st2")
+    session_name_clean = strip_ansi_codes(session_name)
+    session_name_clean = session_name_clean.split(" [Created")[0]
+    return ("run_script", f"zellij attach {session_name_clean}")
+
+
+def get_session_tabs() -> list[tuple[str, str]]:
+    cmd = "zellij list-sessions"
+    try:
+        sessions: list[str] = subprocess.check_output(cmd, shell=True).decode().strip().split("\n")
+    except subprocess.CalledProcessError:
+        sessions = []
+    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()
+        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:
+            continue
+    return result
+
+
+def start_wt(layout_name: str) -> tuple[str, str | None]:
+    """Start a Windows Terminal layout by name. Returns tuple of (status, message) where status is 'success' or 'error'."""
+    import json
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
+    from machineconfig.cluster.sessions_managers.wt_local import run_wt_layout
+    layouts_file = Path.home().joinpath("dotfiles/machineconfig/layouts.json")
+    if not layouts_file.exists():
+        return ("error", f"❌ Layouts file not found: {layouts_file}")
+    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:
+        available_layouts = [a_layout["layoutName"] for a_layout in layouts_data["layouts"]]
+        return ("error", f"❌ Layout '{layout_name}' not found in layouts file.\nAvailable layouts: {', '.join(available_layouts)}")
+    run_wt_layout(layout_config=chosen_layout)
+    return ("success", None)

machineconfig/scripts/python/{helpers_utils → helpers/helpers_utils}/download.py

@@ -22,7 +22,7 @@ def download(
     if output is not None and output_dir is not None:
         typer.echo("❌ Error: --output and --output-dir cannot be used together.", err=True)
         return None
-    typer.echo(f"📥 Downloading from: {url}")
+    typer.echo(f"    {url}")
 
     def _sanitize_candidate_filename(name: str) -> Optional[str]:
         candidate = Path(name).name.strip()

machineconfig/scripts/python/{helpers_utils → helpers/helpers_utils}/python.py

@@ -1,11 +1,10 @@
-from tempfile import tempdir
 import typer
 from typing import Optional, Annotated, Literal, TypedDict, cast
 
 
 def tui_env(which: Annotated[Literal["PATH", "p", "ENV", "e"], typer.Argument(help="Which environment variable to display.")] = "ENV") -> None:
     """📚 NAVIGATE PATH variable with TUI"""
-    from machineconfig.scripts.python import env_manager as navigator
+    from machineconfig.scripts.python.helpers import helper_env as navigator
     from pathlib import Path
 
     match which:
@@ -18,7 +17,7 @@ def tui_env(which: Annotated[Literal["PATH", "p", "ENV", "e"], typer.Argument(he
     uv_with = ["textual"]
     uv_project_dir = None
     if not Path.home().joinpath("code/machineconfig").exists():
-        uv_with.append("machineconfig>=8.14")
+        uv_with.append("machineconfig>=8.45")
     else:
         uv_project_dir = str(Path.home().joinpath("code/machineconfig"))
     run_shell_script(
@@ -37,7 +36,7 @@ def init_project(
     ] = None,
     group: Annotated[
         Optional[str], typer.Option("--group", "-g", help="group of packages names (no separation) p:plot, t:types, l:linting, i:interactive, d:data")
-    ] = "ptlid",
+    ] = "p,t,l,i,d",
 ) -> None:
     if libraries is not None:
         packages_add_line = f"uv add {libraries}"
@@ -51,7 +50,9 @@ def init_project(
             typer.echo(f"❌ Error: pyproject.toml not found in {repo_root}", err=True)
             raise typer.Exit(code=1)
         starting_code = ""
+        agents_line = ""
     else:
+        agents_line = """agents make-config"""
         if name is not None:
             from machineconfig.utils.accessories import randstr
 
@@ -68,36 +69,49 @@ uv init --python {python}
 uv venv
 """
     print(f"Adding group `{group}` with common data science and plotting packages...")
-    total_packages: list[str] = []
+    total_packages: dict[str, list[str]] = {}
     if group is not None:
-        if "t" in group:
-            total_packages.append(
-                "types-python-dateutil types-pyyaml types-requests types-tqdm types-mysqlclient types-paramiko types-pytz types-sqlalchemy types-toml types-urllib3"
-            )
-        if "l" in group:
-            total_packages.append("mypy pyright ruff pylint pyrefly cleanpy ipdb pudb")
-        if "i" in group:
-            total_packages.append("ipython ipykernel jupyterlab nbformat marimo")
-        if "p" in group:
-            total_packages.append("python-magic matplotlib plotly kaleido")
-        if "d" in group:
-            total_packages.append("numpy pandas polars duckdb-engine sqlalchemy  psycopg2-binary pyarrow tqdm openpyxl")
+        packages = group.split(",")
+        if "t" in packages or "types" in packages:
+            total_packages["types"] = [
+                "types-python-dateutil",
+                "types-pyyaml",
+                "types-requests",
+                "types-tqdm",
+                "types-mysqlclient",
+                "types-paramiko",
+                "types-pytz",
+                "types-sqlalchemy",
+                "types-toml",
+                "types-urllib3",
+            ]
+        if "l" in packages:
+            total_packages["linting"] = ["mypy", "pyright", "ruff", "pylint", "pyrefly", "cleanpy", "ipdb", "pudb"]
+        if "i" in packages:
+            total_packages["interactive"] = ["ipython", "ipykernel", "jupyterlab", "nbformat", "marimo"]
+        if "p" in packages:
+            total_packages["plot"] = ["python-magic", "matplotlib", "plotly", "kaleido"]
+        if "d" in packages:
+            total_packages["data"] = ["numpy", "pandas", "polars", "duckdb-engine", "sqlalchemy", "psycopg2-binary", "pyarrow", "tqdm", "openpyxl"]
     from machineconfig.utils.ve import get_ve_activate_line
-
+    groups_packages_lines = "\n".join(
+        [f"uv add --group {group_name} {' '.join(packages)}" for group_name, packages in total_packages.items()]
+    )   
     script = f"""
 {starting_code}
 {packages_add_line}
-uv add --group {group} {" ".join(total_packages)}
+{groups_packages_lines}
 {get_ve_activate_line(ve_root=str(repo_root.joinpath(".venv")))}
+{agents_line}
 ls
 """
     from machineconfig.utils.code import exit_then_run_shell_script, run_shell_script
-    # exit_then_run_shell_script(script)
-    _ = exit_then_run_shell_script
-    run_shell_script(script)
-    if tempdir:
-        from machineconfig.scripts.python.ai.initai import add_ai_configs
-        add_ai_configs(repo_root=repo_root)
+    exit_then_run_shell_script(script)
+    _ = exit_then_run_shell_script, run_shell_script
+    # run_shell_script(script)
+    # if tempdir:
+    #     from machineconfig.scripts.python.ai.initai import add_ai_configs
+    #     add_ai_configs(repo_root=repo_root)
 
 
 def edit_file_with_hx(
@@ -144,8 +158,14 @@ class MachineSpecs(TypedDict):
     user: str
 
 
-def get_machine_specs() -> MachineSpecs:
+def get_machine_specs(hardware: Annotated[bool, typer.Option(..., "--hardware", "-h", help="Show compute capability")] = False) -> MachineSpecs:
     """Write print and return the local machine specs."""
+    if hardware:
+        from machineconfig.scripts.python.helpers.helpers_utils.specs import main
+        main()
+        import sys
+        sys.exit()
+
     import platform
     from machineconfig.utils.code import get_uv_command
 

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()