install_evcxr_cwd_kernel.py

from __future__ import annotations

import argparse
import json
import os
import re
import shutil
import sys
from pathlib import Path


def _slugify_kernel_name(text: str) -> str:
    # Jupyter kernelspec names are directory names; keep it conservative.
    text = text.strip().lower()
    text = re.sub(r"\s+", "-", text)
    text = re.sub(r"[^a-z0-9._-]", "-", text)
    text = re.sub(r"-+", "-", text).strip("-.")
    return text or "kernel"


def _load_json(path: Path) -> dict:
    with path.open("r", encoding="utf-8") as f:
        return json.load(f)


def _find_source_kernelspec_name(preferred: str | None) -> tuple[str, Path, dict]:
    """Return (kernelspec_name, kernel_json_path, kernel_json_data)."""
    try:
        from jupyter_client.kernelspec import KernelSpecManager  # type: ignore
    except Exception as exc:  # pragma: no cover
        raise SystemExit(
            "Brak pakietu 'jupyter_client'. Zainstaluj Jupyter (np. pip install jupyter) i spróbuj ponownie.\n"
            f"Szczegóły: {exc}"
        )

    ksm = KernelSpecManager()
    kernels = ksm.find_kernel_specs()  # name -> resource_dir

    if not kernels:
        raise SystemExit("Nie znaleziono żadnych kernelspeców Jupytera.")

    def matches_evcxr(resource_dir: str) -> bool:
        kernel_json = Path(resource_dir) / "kernel.json"
        if not kernel_json.exists():
            return False
        try:
            data = _load_json(kernel_json)
        except Exception:
            return False
        argv0 = ""
        argv = data.get("argv")
        if isinstance(argv, list) and argv:
            argv0 = str(argv[0]).lower()
        display = str(data.get("display_name", "")).lower()
        # Heuristics: evcxr_jupyter executable OR Rust kernel with evcxr.
        return ("evcxr_jupyter" in argv0) or ("rust" in display and "evcxr" in argv0)

    if preferred:
        if preferred not in kernels:
            raise SystemExit(
                f"Nie ma kernelspeca o nazwie {preferred!r}. Dostępne: {', '.join(sorted(kernels))}"
            )
        resource_dir = Path(kernels[preferred])
        kernel_json = resource_dir / "kernel.json"
        if not kernel_json.exists():
            raise SystemExit(f"Wybrany kernelspec nie ma pliku kernel.json: {kernel_json}")
        return preferred, kernel_json, _load_json(kernel_json)

    # Auto-detect.
    for name, resource_dir in kernels.items():
        if matches_evcxr(resource_dir):
            kernel_json = Path(resource_dir) / "kernel.json"
            return name, kernel_json, _load_json(kernel_json)

    # Fallback: try name 'rust'
    if "rust" in kernels:
        kernel_json = Path(kernels["rust"]) / "kernel.json"
        return "rust", kernel_json, _load_json(kernel_json)

    raise SystemExit(
        "Nie umiem znaleźć kernelspeca opartego o evcxr_jupyter. "
        "Podaj go ręcznie przez --source-kernel (np. --source-kernel rust)."
    )


WRAPPER_FILENAME = "evcxr_env_wrapper.py"


def _write_wrapper(wrapper_path: Path) -> None:
    wrapper_path.write_text(
        """from __future__ import annotations

import os
import subprocess
import sys


def main(argv: list[str]) -> int:
    # Everything after "--" is the original kernel argv.
    if "--" in argv:
        idx = argv.index("--")
        cmd = argv[idx + 1 :]
    else:
        cmd = argv

    if not cmd:
        print("Brak docelowego polecenia kernela (argv)", file=sys.stderr)
        return 2

    env = os.environ.copy()
    env["EVCXR_TMPDIR"] = os.getcwd()

    try:
        completed = subprocess.run(cmd, env=env, check=False)
    except FileNotFoundError:
        print(f"Nie znaleziono programu: {cmd[0]!r}", file=sys.stderr)
        return 127

    return int(completed.returncode)


if __name__ == "__main__":
    raise SystemExit(main(sys.argv[1:]))
""",
        encoding="utf-8",
    )


def main(argv: list[str]) -> int:
    parser = argparse.ArgumentParser(
        description=(
            "Instaluje nowy kernelspec Jupytera, który uruchamia evcxr_jupyter z EVCXR_TMPDIR="
            "ustawionym dynamicznie na bieżący katalog procesu (os.getcwd()).\n\n"
            "Nazwa i display_name nowego kernela bazują na nazwie folderu, w którym uruchomisz ten skrypt."
        )
    )
    parser.add_argument(
        "--folder",
        default=".",
        help=(
            "Folder, z którego nazwy ma powstać nazwa/display_name kernela. "
            "Domyślnie: bieżący katalog. To wpływa tylko na nazewnictwo kernelspeca (nie na EVCXR_TMPDIR w runtime)."
        ),
    )
    parser.add_argument(
        "--source-kernel",
        help="Nazwa istniejącego kernelspeca do sklonowania (np. rust). Jeśli pominięte, spróbuje wykryć evcxr_jupyter.",
    )
    parser.add_argument(
        "--prefix",
        default="rust-",
        help="Prefiks nazwy nowego kernela (domyślnie: rust-).",
    )
    parser.add_argument(
        "--uninstall",
        action="store_true",
        help=(
            "Usuń kernelspec wyliczony z --folder (prefix + nazwa folderu) i zakończ. "
            "Nie instaluje nic nowego."
        ),
    )
    parser.add_argument(
        "--force",
        action="store_true",
        help="Nadpisz, jeśli kernelspec o tej nazwie już istnieje.",
    )
    parser.add_argument(
        "--dry-run",
        action="store_true",
        help="Nic nie zapisuj, tylko pokaż co by zostało zrobione.",
    )

    args = parser.parse_args(argv)

    folder_path = Path(args.folder).resolve()
    folder_name = folder_path.name
    slug = _slugify_kernel_name(folder_name)
    new_kernel_name = _slugify_kernel_name(f"{args.prefix}{slug}")
    new_display_name = f"Rust ({folder_name})"

    try:
        from jupyter_client.kernelspec import KernelSpecManager  # type: ignore
    except Exception as exc:  # pragma: no cover
        raise SystemExit(
            "Brak pakietu 'jupyter_client'. Zainstaluj Jupyter (np. pip install jupyter) i spróbuj ponownie.\n"
            f"Szczegóły: {exc}"
        )

    ksm = KernelSpecManager()
    user_dir = Path(ksm.user_kernel_dir)
    target_dir = user_dir / new_kernel_name
    kernel_json_out = target_dir / "kernel.json"
    wrapper_path = target_dir / WRAPPER_FILENAME

    if args.uninstall:
        if args.dry_run:
            print(f"DRY RUN: usunąłbym kernelspec {new_kernel_name!r} z {target_dir}")
            return 0

        if not target_dir.exists():
            print(f"Kernelspec {new_kernel_name!r} nie istnieje (nic do usunięcia): {target_dir}")
            return 0

        shutil.rmtree(target_dir)
        print(f"Usunięto kernelspec {new_kernel_name!r}.")
        print("Sprawdź listę: python -m jupyter kernelspec list")
        return 0

    source_name, source_kernel_json_path, source_data = _find_source_kernelspec_name(args.source_kernel)

    source_argv = source_data.get("argv")
    if not isinstance(source_argv, list) or not source_argv:
        raise SystemExit(f"Kernelspec {source_name!r} ma niepoprawne argv w {source_kernel_json_path}.")

    new_data = dict(source_data)
    new_data["display_name"] = new_display_name

    # Build wrapped argv: python wrapper -- <original argv...>
    new_data["argv"] = [sys.executable, "-u", str(wrapper_path), "--", *map(str, source_argv)]

    plan_lines = [
        f"Source kernelspec: {source_name} ({source_kernel_json_path.parent})",
        f"Target kernelspec name: {new_kernel_name}",
        f"Target dir: {target_dir}",
        f"Display name: {new_display_name}",
        f"Wrapper: {wrapper_path}",
    ]
    print("\n".join(plan_lines))

    if args.dry_run:
        print("DRY RUN: nic nie zapisano.")
        return 0

    if target_dir.exists():
        if not args.force:
            raise SystemExit(
                f"Kernelspec {new_kernel_name!r} już istnieje w {target_dir}. "
                "Użyj --force żeby nadpisać albo uruchom w innym folderze."
            )
        shutil.rmtree(target_dir)

    target_dir.mkdir(parents=True, exist_ok=True)

    _write_wrapper(wrapper_path)
    kernel_json_out.write_text(json.dumps(new_data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")

    print("Zainstalowano kernelspec.")
    print("Sprawdź listę: python -m jupyter kernelspec list")
    print("W VS Code wybierz kernel o nazwie display_name pokazanej powyżej.")
    return 0


if __name__ == "__main__":
    raise SystemExit(main(sys.argv[1:]))