machineconfig 6.82__py3-none-any.whl → 8.51__py3-none-any.whl

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

@@ -1,7 +1,6 @@
 
 
 from typing import Optional, Annotated
-from pathlib import Path
 import typer
 
 
@@ -10,23 +9,23 @@ def create_from_function(
         path: Annotated[str, typer.Option(..., "--path", "-p", help="Path to a Python or Shell script file or a directory containing such files")] = ".",
         function: Annotated[Optional[str], typer.Option(..., "--function", "-f", help="Function to run from the Python file. If not provided, you will be prompted to choose.")] = None,
 ):
-    from machineconfig.utils.ve import get_ve_activate_line, get_ve_path_and_ipython_profile
+    from machineconfig.utils.ve import get_ve_path_and_ipython_profile
     from machineconfig.utils.options import choose_from_options
     from machineconfig.utils.path_helper import match_file_name, sanitize_path
-    from machineconfig.utils.path_extended import PathExtended
     from machineconfig.utils.accessories import get_repo_root
+    from pathlib import Path
 
     path_obj = sanitize_path(path)
     if not path_obj.exists():
         suffixes = {".py"}
-        choice_file = match_file_name(sub_string=path, search_root=PathExtended.cwd(), suffixes=suffixes)
+        choice_file = match_file_name(sub_string=path, search_root=Path.cwd(), suffixes=suffixes)
     elif path_obj.is_dir():
-        from machineconfig.scripts.python.helpers_fire.helpers4 import search_for_files_of_interest
+        from machineconfig.utils.path_helper import search_for_files_of_interest
         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)
     else:
         choice_file = path_obj
 
@@ -36,14 +35,17 @@ def create_from_function(
     ve_root_from_file, ipy_profile = get_ve_path_and_ipython_profile(choice_file)
     if ipy_profile is None:
         ipy_profile = "default"
-    if ve_root_from_file is None:
-        raise ValueError(f"Could not determine virtual environment for file {choice_file}. Please ensure it is within a recognized project structure.")
-
-    _activate_ve_line = get_ve_activate_line(ve_root=ve_root_from_file)
+    # if ve_root_from_file is None:
+    #     raise ValueError(f"Could not determine virtual environment for file {choice_file}. Please ensure it is within a recognized project structure.")
+    # _activate_ve_line = get_ve_activate_line(ve_root=ve_root_from_file)
+    if ve_root_from_file is not None:
+        start_dir = Path(ve_root_from_file).parent
+    else:
+        start_dir = Path.cwd()
 
     # =========================  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
@@ -52,7 +54,11 @@ def create_from_function(
     from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
     layout: LayoutConfig = {"layoutName": "fireNprocess", "layoutTabs": []}
     for an_arg in range(num_process):
-        layout["layoutTabs"].append({"tabName": f"tab{an_arg}", "startDir": str(PathExtended.cwd()), "command": f"uv run -m fire {choice_file} {choice_function} --idx={an_arg} --idx_max={num_process}"})
+        layout["layoutTabs"].append({
+            "tabName": f"tab{an_arg}",
+            "startDir": str(start_dir),
+            "command": f"uv run python -m fire {choice_file} {choice_function} --idx={an_arg} --idx_max={num_process}"
+            })
     print(layout)
     run_zellij_layout(layout_config=layout)
 

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/helpers_utils/download.py

@@ -0,0 +1,150 @@
+
+
+from typing import Annotated, Optional
+import typer
+from pathlib import Path
+
+
+def download(
+    url: Annotated[Optional[str], typer.Argument(..., help="The URL to download the file from.")] = None,
+    decompress: Annotated[bool, typer.Option(..., "--decompress", "-d", help="Decompress the file if it's an archive.")] = False,
+    output: Annotated[Optional[str], typer.Option("--output", "-o", help="The output file path.")] = None,
+    output_dir: Annotated[Optional[str], typer.Option("--output-dir", help="Directory to place the downloaded file in.")] = None,
+) -> Optional["Path"]:
+    import subprocess
+    from urllib.parse import parse_qs, unquote, urlparse
+    from requests import Response
+    import requests
+    from pathlib import Path
+    if url is None:
+        typer.echo("❌ Error: URL is required.", err=True)
+        return None
+    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"    {url}")
+
+    def _sanitize_candidate_filename(name: str) -> Optional[str]:
+        candidate = Path(name).name.strip()
+        if not candidate or candidate in {".", ".."}:
+            return None
+        return candidate
+
+    def _filename_from_content_disposition(header_value: Optional[str]) -> Optional[str]:
+        if header_value is None:
+            return None
+        parts = [segment.strip() for segment in header_value.split(";")]
+        for part in parts:
+            lower = part.lower()
+            if lower.startswith("filename*="):
+                value = part.split("=", 1)[1]
+                value = value.strip().strip('"')
+                if "''" in value:
+                    value = value.split("''", 1)[1]
+                decoded = unquote(value)
+                sanitized = _sanitize_candidate_filename(decoded)
+                if sanitized is not None:
+                    return sanitized
+            if lower.startswith("filename="):
+                value = part.split("=", 1)[1].strip().strip('"')
+                decoded = unquote(value)
+                sanitized = _sanitize_candidate_filename(decoded)
+                if sanitized is not None:
+                    return sanitized
+        return None
+
+    def _filename_from_url(source_url: str) -> Optional[str]:
+        parsed = urlparse(source_url)
+        url_candidate = _sanitize_candidate_filename(unquote(Path(parsed.path).name))
+        if url_candidate is not None:
+            return url_candidate
+        query_params = parse_qs(parsed.query, keep_blank_values=True)
+        for key, values in query_params.items():
+            lower_key = key.lower()
+            if "name" in lower_key or "file" in lower_key:
+                for value in values:
+                    sanitized = _sanitize_candidate_filename(unquote(value))
+                    if sanitized is not None:
+                        return sanitized
+        return None
+
+    def _resolve_download_path(request_url: str, response: Response, requested_output: Optional[str], requested_output_dir: Optional[str]) -> Path:
+        if requested_output is not None:
+            return Path(requested_output)
+        header_candidate = _filename_from_content_disposition(response.headers.get("content-disposition"))
+        if header_candidate is None:
+            header_candidate = _filename_from_url(response.url)
+        if header_candidate is None:
+            header_candidate = _filename_from_url(request_url)
+        if header_candidate is None:
+            header_candidate = "downloaded_file"
+        if requested_output_dir is not None:
+            return Path(requested_output_dir) / header_candidate
+        return Path(header_candidate)
+
+    try:
+        with requests.get(url, allow_redirects=True, stream=True, timeout=60) as response:
+            response.raise_for_status()
+            download_path = _resolve_download_path(url, response, output, output_dir)
+            download_path.parent.mkdir(parents=True, exist_ok=True)
+            total_size_header = response.headers.get("content-length", "0")
+            try:
+                total_size = int(total_size_header)
+            except (TypeError, ValueError):
+                total_size = 0
+            if total_size <= 0:
+                with open(download_path, "wb") as file_handle:
+                    file_handle.write(response.content)
+            else:
+                downloaded = 0
+                chunk_size = 8192 * 40
+                with open(download_path, "wb") as file_handle:
+                    for chunk in response.iter_content(chunk_size=chunk_size):
+                        if not chunk:
+                            continue
+                        file_handle.write(chunk)
+                        downloaded += len(chunk)
+                        progress = (downloaded / total_size) * 100
+                        typer.echo(f"\r⏬ Progress: {progress:.1f}% ({downloaded}/{total_size} bytes)", nl=False)
+                typer.echo()
+    except requests.exceptions.RequestException as exception:
+        typer.echo(f"❌ Download failed: {exception}", err=True)
+        return None
+    except OSError as exception:
+        typer.echo(f"❌ File write error: {exception}", err=True)
+        return None
+
+    typer.echo(f"✅ Downloaded to: {download_path}")
+    result_path: Path = download_path
+    if decompress:
+        typer.echo(f"📦 Decompressing: {download_path}")
+        base_name = download_path.name.split(".", maxsplit=1)[0]  # ouch decompresses all (e.g. .tar.gz) in one go.
+        if base_name in {"", ".", ".."}:
+            base_name = "extracted"
+        extract_dir = download_path.parent / base_name
+        extract_dir.mkdir(parents=True, exist_ok=True)
+        try:
+            subprocess.run(
+                ["ouch", "decompress", str(download_path), "--dir", str(extract_dir)],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            typer.echo(f"✅ Decompressed to: {extract_dir}")
+            if download_path.exists():
+                download_path.unlink()
+                typer.echo(f"🗑️  Removed archive: {download_path}")
+            result_path = extract_dir
+        except subprocess.CalledProcessError as exception:
+            typer.echo(f"❌ Decompression failed: {exception.stderr}", err=True)
+            return None
+        except FileNotFoundError:
+            typer.echo("❌ Error: ouch command not found. Please install ouch.", err=True)
+            typer.echo("💡 Install with: cargo install ouch", err=True)
+            return None
+
+    return result_path.resolve()
+
+
+if __name__ == "__main__":
+    pass

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

@@ -0,0 +1,96 @@
+
+
+import typer
+from typing import Annotated, Optional
+
+
+def merge_pdfs(
+        pdfs: Annotated[list[str], typer.Argument(..., help="Paths to the PDF files to merge.")],
+        output: Annotated[Optional[str], typer.Option("--output", "-o", help="Output merged PDF file path.")] = None,
+        compress: Annotated[bool, typer.Option("--compress", "-c", help="Compress the output PDF.")] = False,
+    ) -> None:
+    def merge_pdfs_internal(pdfs: list[str], output: str | None, compress: bool) -> None:
+        from pypdf import PdfReader, PdfWriter
+        writer = PdfWriter()
+        for pdf_path in pdfs:
+            reader = PdfReader(pdf_path)
+            for page in reader.pages:
+                writer.add_page(page)
+        output_path = output if output else "merged.pdf"
+        if compress:
+            try:
+                for p in writer.pages:
+                    try:
+                        # PageObject.compress_content_streams exists in pypdf
+                        p.compress_content_streams()
+                    except Exception:
+                        # best-effort: ignore per-page compression failures
+                        continue
+            except Exception:
+                pass
+            try:
+                writer.compress_identical_objects()
+            except Exception:
+                # non-fatal if this fails
+                pass
+        writer.write(output_path)
+        print(f"✅ Merged PDF saved to: {output_path}")
+    from machineconfig.utils.meta import lambda_to_python_script
+    code = lambda_to_python_script(lambda : merge_pdfs_internal(pdfs=pdfs, output=output, compress=compress),
+                                   in_global=True, import_module=False)
+    from machineconfig.utils.code import run_shell_script, get_uv_command_executing_python_script
+    uv_command, _py_file = get_uv_command_executing_python_script(python_script=code, uv_with=["pypdf"], uv_project_dir=None)
+    run_shell_script(uv_command, display_script=True, clean_env=False)
+
+
+def compress_pdf(
+        pdf_input: Annotated[str, typer.Argument(..., help="Path to the input PDF file to compress.")],
+        output: Annotated[Optional[str], typer.Option("--output", "-o", help="Output compressed PDF file path.")] = None,
+        quality: Annotated[int, typer.Option("--quality", "-q", help="JPEG quality for image compression (0-100, 0=no change, 100=best).")] = 85,
+        image_dpi: Annotated[int, typer.Option("--image-dpi", "-d", help="Target DPI for image resampling. If set, images above this DPI will be downsampled.")] = 0,
+        # remove_images: Annotated[bool, typer.Option("--remove-images", "-r", help="Remove all images from the PDF.")] = False,
+        compress_streams: Annotated[bool, typer.Option("--compress-streams", "-c", help="Compress uncompressed streams.")] = True,
+        use_objstms: Annotated[bool, typer.Option("--object-streams", "-s", help="Use object streams for additional compression.")] = True,
+    ) -> None:
+    def compress_pdf_internal(pdf_input: str, output: str | None, quality: int, image_dpi: int, compress_streams: bool, use_objstms: bool) -> None:
+        import pymupdf
+        from pathlib import Path
+        output_path = output if output else pdf_input.replace(".pdf", "_compressed.pdf")
+        doc = pymupdf.open(pdf_input)
+        try:
+            # if remove_images:
+            #     for page in doc:
+            #         page.remove_images()
+            if quality > 0 or image_dpi > 0:
+                doc.rewrite_images(
+                    dpi_threshold=image_dpi if image_dpi > 0 else None,
+                    dpi_target=max(72, image_dpi - 10) if image_dpi > 72 else 72,
+                    quality=quality,
+                    lossy=True,
+                    lossless=True,
+                )
+            doc.save(
+                output_path,
+                deflate=compress_streams,
+                garbage=3,
+                use_objstms=1 if use_objstms else 0,
+            )
+            input_size = Path(pdf_input).stat().st_size
+            output_size = Path(output_path).stat().st_size
+            ratio = (1 - output_size / input_size) * 100
+            print(f"✅ Compressed PDF saved to: {output_path}")
+            print(f"   Original: {input_size / 1024 / 1024:.2f} MB")
+            print(f"   Compressed: {output_size / 1024 / 1024:.2f} MB")
+            print(f"   Reduction: {ratio:.1f}%")
+        finally:
+            doc.close()
+    from machineconfig.utils.meta import lambda_to_python_script
+    code = lambda_to_python_script(
+        lambda: compress_pdf_internal(pdf_input=pdf_input, output=output, quality=quality, image_dpi=image_dpi, compress_streams=compress_streams, use_objstms=use_objstms),
+        in_global=True,
+        import_module=False,
+    )
+    from machineconfig.utils.code import run_shell_script, get_uv_command_executing_python_script
+    uv_command, _py_file = get_uv_command_executing_python_script(python_script=code, uv_with=["pymupdf"], uv_project_dir=None)
+    run_shell_script(uv_command, display_script=True, clean_env=False)
+

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

@@ -0,0 +1,210 @@
+import typer
+from typing import Optional, Annotated, Literal, TypedDict, cast
+from machineconfig.utils.ssh_utils.abc import MACHINECONFIG_VERSION
+
+
+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.helpers import helper_env as navigator
+    from pathlib import Path
+
+    match which:
+        case "PATH" | "p":
+            path = Path(navigator.__file__).resolve().parent.joinpath("path_manager_tui.py")
+        case "ENV" | "e":
+            path = Path(navigator.__file__).resolve().parent.joinpath("env_manager_tui.py")
+    from machineconfig.utils.code import run_shell_script, get_uv_command_executing_python_script
+
+    uv_with = ["textual"]
+    uv_project_dir = None
+    if not Path.home().joinpath("code/machineconfig").exists():
+        uv_with.append(MACHINECONFIG_VERSION)
+    else:
+        uv_project_dir = str(Path.home().joinpath("code/machineconfig"))
+    run_shell_script(
+        get_uv_command_executing_python_script(python_script=path.read_text(encoding="utf-8"), uv_with=uv_with, uv_project_dir=uv_project_dir)[0],
+        display_script=True,
+        clean_env=False,
+    )
+
+
+def init_project(
+    name: Annotated[Optional[str], typer.Option("--name", "-n", help="Name of the project.")] = None,
+    tmp_dir: Annotated[bool, typer.Option("--tmp-dir", "-t", help="Use a temporary directory for the project initialization.")] = False,
+    python: Annotated[
+        Literal["3.11", "3.12", "3.13", "3.14"], typer.Option("--python", "-p", help="Python sub version for the uv virtual environment.")
+    ] = "3.13",
+    libraries: Annotated[
+        Optional[str], typer.Option("--libraries", "-l", help="Additional packages to include in the uv virtual environment (space separated).")
+    ] = 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")
+    ] = "p,t,l,i,d",
+) -> None:
+    if libraries is not None:
+        packages_add_line = f"uv add {libraries}"
+    else:
+        packages_add_line = ""
+    from pathlib import Path
+
+    if not tmp_dir:
+        repo_root = Path.cwd()
+        if not (repo_root / "pyproject.toml").exists():
+            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
+
+            repo_root = Path.home().joinpath(f"tmp_results/tmp_projects/{name}")
+        else:
+            from machineconfig.utils.accessories import randstr
+
+            repo_root = Path.home().joinpath(f"tmp_results/tmp_projects/{randstr(6)}")
+        repo_root.mkdir(parents=True, exist_ok=True)
+        print(f"Using temporary directory for project initialization: {repo_root}")
+        starting_code = f"""
+cd {repo_root}
+uv init --python {python}
+uv venv
+"""
+    print(f"Adding group `{group}` with common data science and plotting packages...")
+    total_packages: dict[str, list[str]] = {}
+    if group is not None:
+        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}
+{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
+    # 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(
+    path: Annotated[Optional[str], typer.Argument(..., help="The root directory of the project to edit, or a file path.")] = None,
+) -> None:
+    from pathlib import Path
+
+    if path is None:
+        root_path = Path.cwd()
+        print(f"No path provided. Using current working directory: {root_path}")
+    else:
+        root_path = Path(path).expanduser().resolve()
+        print(f"Using provided path: {root_path}")
+    from machineconfig.utils.accessories import get_repo_root
+
+    repo_root = get_repo_root(root_path)
+    if repo_root is not None and repo_root.joinpath("pyproject.toml").exists():
+        code = f"""
+cd {repo_root}
+uv add --dev pylsp-mypy python-lsp-server[all] pyright ruff-lsp  # for helix editor.
+source ./.venv/bin/activate
+"""
+    else:
+        code = ""
+    if root_path.is_file():
+        code += f"hx {root_path}"
+    else:
+        code += "hx"
+    from machineconfig.utils.code import exit_then_run_shell_script
+
+    exit_then_run_shell_script(code)
+
+
+class MachineSpecs(TypedDict):
+    system: Literal["Windows", "Linux", "Darwin"]
+    distro: str
+    home_dir: str
+    hostname: str
+    release: str
+    version: str
+    machine: str
+    processor: str
+    python_version: str
+    user: str
+
+
+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
+
+    uv_cmd = get_uv_command(platform=platform.system())  # type: ignore
+    command = f"""{uv_cmd} run --with distro python -c "import distro; print(distro.name(pretty=True))" """
+    import subprocess
+    from pathlib import Path
+    import socket
+    import os
+
+    distro = subprocess.run(command, shell=True, capture_output=True, text=True).stdout.strip()
+    system = platform.system()
+    if system not in {"Windows", "Linux", "Darwin"}:
+        system = "Linux"
+    specs: MachineSpecs = {
+        "system": cast(Literal["Windows", "Linux", "Darwin"], system),
+        "distro": distro,
+        "home_dir": str(Path.home()),
+        "hostname": socket.gethostname(),
+        "release": platform.release(),
+        "version": platform.version(),
+        "machine": platform.machine(),
+        "processor": platform.processor() or "Unknown",
+        "python_version": platform.python_version(),
+        "user": os.getenv("USER") or os.getenv("USERNAME") or "Unknown",
+    }
+    print(specs)
+    from machineconfig.utils.source_of_truth import CONFIG_ROOT
+
+    path = CONFIG_ROOT.joinpath("machine_specs.json")
+    CONFIG_ROOT.mkdir(parents=True, exist_ok=True)
+    import json
+
+    path.write_text(json.dumps(specs, indent=4), encoding="utf-8")
+    return specs
+
+
+if __name__ == "__main__":
+    get_machine_specs()