ixt-cli 0.8.0__py3-none-any.whl

ixt/core/install_local.py

@@ -0,0 +1,229 @@
+"""Install tools from a local directory via ``ixt tool install --from <path>``."""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+from ixt.config.models import ToolRecord
+from ixt.config.settings import Settings, get_settings
+from ixt.config.setup_toml import _loads as _toml_loads
+from ixt.core.backend import BackendType, get_backend
+from ixt.core.expose import expose_tool, unexpose_tool
+from ixt.core.identity import apply_slot, validate_slot
+from ixt.core.install import ToolAlreadyInstalledError, _remove_env_dir, _validate_env_dir
+from ixt.libs.constants import EXPOSE_MAIN
+from ixt.libs.shell import shell_run
+
+_LOCAL_VERSION = "local"
+
+
+@dataclass(slots=True)
+class LocalInstallPlan:
+    """What ``install_from_local`` would do, without mutating disk."""
+
+    source_path: Path
+    backend: BackendType
+    tool_name: str
+    pkg_name: str
+    env_dir: Path
+    expose_rules: list[str]
+    already_installed: bool
+
+
+def detect_backend_from_dir(path: Path) -> BackendType:
+    """Pick the backend that fits the directory contents.
+
+    Cascade:
+        1. ``pyproject.toml`` or ``setup.py`` → PYTHON
+        2. ``package.json``                   → NODE
+        3. otherwise                          → BINARY (copy + auto-expose)
+    """
+    if (path / "pyproject.toml").exists() or (path / "setup.py").exists():
+        return BackendType.PYTHON
+    if (path / "package.json").exists():
+        return BackendType.NODE
+    return BackendType.BINARY
+
+
+def _read_python_pkg_name(source_path: Path, fallback: str) -> str:
+    """Read [project].name from pyproject.toml; fall back when missing."""
+    pyproject = source_path / "pyproject.toml"
+    if pyproject.exists():
+        try:
+            data = _toml_loads(pyproject.read_text(encoding="utf-8"))
+            name = data.get("project", {}).get("name")
+            if isinstance(name, str) and name:
+                return name
+        except (OSError, ValueError):
+            pass
+    return fallback
+
+
+def _read_node_pkg_name(source_path: Path, fallback: str) -> str:
+    """Read .name from package.json; fall back when missing."""
+    pkg_json = source_path / "package.json"
+    if pkg_json.exists():
+        try:
+            with pkg_json.open(encoding="utf-8") as f:
+                data = json.load(f)
+            name = data.get("name")
+            if isinstance(name, str) and name:
+                return name
+        except (OSError, json.JSONDecodeError):
+            pass
+    return fallback
+
+
+def plan_install_from_local(
+    source_path: Path,
+    *,
+    slot: str | None = None,
+    settings: Settings | None = None,
+) -> LocalInstallPlan:
+    """Resolve a local install plan without copying or installing anything."""
+    settings = settings or get_settings()
+    validate_slot(slot)
+    source_path = source_path.expanduser().resolve()
+    if not source_path.exists():
+        raise ValueError(f"--from path does not exist: {source_path}")
+    if not source_path.is_dir():
+        raise ValueError(f"--from path is not a directory: {source_path}")
+
+    bt = detect_backend_from_dir(source_path)
+    base_name = source_path.name
+    tool_name = apply_slot(base_name, slot)
+    if bt == BackendType.PYTHON:
+        pkg_name = _read_python_pkg_name(source_path, fallback=base_name)
+    elif bt == BackendType.NODE:
+        pkg_name = _read_node_pkg_name(source_path, fallback=base_name)
+    else:
+        pkg_name = base_name
+    env_dir = settings.get_tool_env_dir(tool_name)
+    env_dir = _validate_env_dir(env_dir, settings.envs_dir)
+
+    return LocalInstallPlan(
+        source_path=source_path,
+        backend=bt,
+        tool_name=tool_name,
+        pkg_name=pkg_name,
+        env_dir=env_dir,
+        expose_rules=[EXPOSE_MAIN],
+        already_installed=env_dir.exists(),
+    )
+
+
+def _copy_local_tree(source_path: Path, env_dir: Path, settings: Settings) -> None:
+    """Copy a local binary tree into an env without following symlinks."""
+    source_root = source_path.expanduser().resolve()
+    safe_env_dir = _validate_env_dir(env_dir, settings.envs_dir)
+    for root, dirs, files in os.walk(source_root, followlinks=False):
+        root_path = Path(root)
+        rel = root_path.relative_to(source_root)
+        dest_root = _validate_env_dir(safe_env_dir / rel, settings.envs_dir)
+        dest_root.mkdir(parents=True, exist_ok=True)
+
+        # Do not traverse or copy symlinked directories: a local install should
+        # not silently pull content from outside the declared source tree.
+        dirs[:] = [name for name in dirs if not (root_path / name).is_symlink()]
+
+        for filename in files:
+            src = root_path / filename
+            if src.is_symlink() or not src.is_file():
+                continue
+            dest = _validate_env_dir(dest_root / filename, settings.envs_dir)
+            with src.open("rb") as source, dest.open("wb") as out:
+                shutil.copyfileobj(source, out)
+            shutil.copymode(src, dest)
+
+
+def install_from_local(
+    source_path: Path,
+    *,
+    slot: str | None = None,
+    force: bool = False,
+    settings: Settings | None = None,
+) -> ToolRecord:
+    """Install a tool from a local directory.
+
+    Backend is auto-detected from directory contents. The install is a copy
+    (not editable): the env_dir is autonomous and the source path can be
+    moved or deleted afterwards without breaking the install.
+    """
+    settings = settings or get_settings()
+    plan = plan_install_from_local(source_path, slot=slot, settings=settings)
+    source_path = plan.source_path
+    bt = plan.backend
+    tool_name = plan.tool_name
+    env_dir = plan.env_dir
+
+    if env_dir.exists():
+        if not force:
+            raise ToolAlreadyInstalledError(tool_name, env_dir)
+        meta_file = settings.get_tool_metadata_file(tool_name)
+        if meta_file.exists():
+            old = ToolRecord.load_json(meta_file)
+            unexpose_tool(old.exposed_bins, settings.bin_dir)
+        _remove_env_dir(env_dir, settings)
+
+    backend = get_backend(bt, settings=settings)
+    created = False
+    try:
+        if bt == BackendType.PYTHON:
+            created = backend.create_env(env_dir)
+            backend.install_packages(env_dir, [str(source_path)])
+            pkg_name = _read_python_pkg_name(source_path, fallback=tool_name)
+            version = backend.installed_version(env_dir, pkg_name) or _LOCAL_VERSION
+        elif bt == BackendType.NODE:
+            from ixt.backends.node import NodeBackend
+
+            if not isinstance(backend, NodeBackend):
+                raise RuntimeError(f"Expected NodeBackend, got {type(backend).__name__}")
+            created = backend.create_env(env_dir)
+            pkg_name = _read_node_pkg_name(source_path, fallback=tool_name)
+            shell_run(
+                [backend._bun(), "add", str(source_path)],
+                cwd=env_dir,
+                check=True,
+                capture_output=True,
+            )
+            version = backend.installed_version(env_dir, pkg_name) or _LOCAL_VERSION
+        else:  # BINARY
+            env_dir = _validate_env_dir(env_dir, settings.envs_dir)
+            env_dir.mkdir(parents=True, exist_ok=True)
+            created = True
+            _copy_local_tree(source_path, env_dir, settings)
+            pkg_name = plan.pkg_name
+            version = _LOCAL_VERSION
+
+        rules = [EXPOSE_MAIN]
+        result = expose_tool(
+            pkg_name,
+            backend,
+            env_dir,
+            settings.bin_dir,
+            rules,
+            overwrite=force,
+        )
+        linked_bins = result.linked
+
+        record = ToolRecord(
+            name=tool_name,
+            pkg_name=pkg_name,
+            backend=bt.value,
+            spec=str(source_path),
+            env_dir=str(env_dir),
+            version=version,
+            expose_rules=rules,
+            exposed_bins=linked_bins,
+            source="local",
+        )
+        record.save_json(settings.get_tool_metadata_file(tool_name))
+        return record
+    except Exception:
+        if created:
+            _remove_env_dir(env_dir, settings, ignore_errors=True)
+        raise

ixt/core/locks.py

@@ -0,0 +1,54 @@
+"""Small file locks for mutating installed tool state."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+from pathlib import Path
+from typing import BinaryIO
+
+from ixt.config.settings import Settings, get_settings
+
+
+@contextmanager
+def tool_lock(tool_name: str, *, settings: Settings | None = None) -> Iterator[Path]:
+    """Hold an exclusive lock for operations mutating one installed tool."""
+    settings = settings or get_settings()
+    lock_dir = settings.envs_dir / ".locks"
+    lock_dir.mkdir(parents=True, exist_ok=True)
+    lock_path = lock_dir / f"{settings.get_tool_env_dir(tool_name).name}.lock"
+    with lock_path.open("a+b") as handle:
+        _lock_file(handle)
+        try:
+            yield lock_path
+        finally:
+            _unlock_file(handle)
+
+
+def _lock_file(handle: BinaryIO) -> None:
+    try:
+        import fcntl
+    except ImportError:
+        import msvcrt
+
+        handle.seek(0)
+        handle.write(b"\0")
+        handle.flush()
+        handle.seek(0)
+        msvcrt.locking(handle.fileno(), msvcrt.LK_LOCK, 1)  # pyright: ignore[reportAttributeAccessIssue]
+        return
+
+    fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+
+
+def _unlock_file(handle: BinaryIO) -> None:
+    try:
+        import fcntl
+    except ImportError:
+        import msvcrt
+
+        handle.seek(0)
+        msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)  # pyright: ignore[reportAttributeAccessIssue]
+        return
+
+    fcntl.flock(handle.fileno(), fcntl.LOCK_UN)

ixt/core/pathlink.py

@@ -0,0 +1,86 @@
+"""Cross-platform linking helpers for exposed binaries."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+from ixt.platform import is_windows
+
+
+def _file_hash(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(8192), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+@dataclass(slots=True)
+class PathLink:
+    """Represents one exposed binary link or copy."""
+
+    source_path: Path
+    target_path: Path
+
+    def source_exists(self) -> bool:
+        return self.source_path.exists()
+
+    def target_exists(self) -> bool:
+        return self.target_path.exists() or self.target_path.is_symlink()
+
+    def is_valid(self) -> bool:
+        if not self.target_exists():
+            return False
+
+        if is_windows():
+            return (
+                self.source_exists()
+                and self.target_path.exists()
+                and _file_hash(self.source_path) == _file_hash(self.target_path)
+            )
+
+        return (
+            self.target_path.is_symlink()
+            and self.target_path.resolve() == self.source_path.resolve()
+        )
+
+    def create(self, overwrite: bool = False) -> None:
+        if not self.source_exists():
+            raise FileNotFoundError(self.source_path)
+
+        if self.target_exists():
+            if not overwrite:
+                raise FileExistsError(self.target_path)
+            self.remove(force=True)
+
+        self.target_path.parent.mkdir(parents=True, exist_ok=True)
+        if is_windows():
+            shutil.copy2(self.source_path, self.target_path)
+            return
+
+        link_source = os.path.relpath(self.source_path, self.target_path.parent)
+        os.symlink(link_source, self.target_path)
+
+    def remove(self, force: bool = False) -> bool:
+        if not self.target_exists():
+            return False
+
+        if not force and not self.is_valid():
+            return False
+
+        self.target_path.unlink()
+        return True
+
+    def display_name(self) -> str:
+        if self.target_path.name == self.source_path.name:
+            return self.target_path.name
+        return f"{self.source_path.name} -> {self.target_path.name}"
+
+
+def create_path_link(app_bin: Path, bin_dir: Path, rename_to: str | None = None) -> PathLink:
+    """Create a PathLink object for one exposed binary."""
+    return PathLink(source_path=app_bin, target_path=bin_dir / (rename_to or app_bin.name))

ixt/core/resolution_stats.py

@@ -0,0 +1,191 @@
+"""Runtime counters for version-resolution diagnostics.
+
+The collector is intentionally process-local: the CLI enables it around one
+command, resolver worker threads record into it, then the CLI renders a compact
+summary. Outside that command scope every record call is a no-op.
+"""
+
+from __future__ import annotations
+
+import threading
+from collections.abc import Iterator
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+
+_CURRENT_LOCK = threading.Lock()
+_CURRENT: ResolutionStats | None = None
+_LOCAL = threading.local()
+
+
+@dataclass(slots=True)
+class VersionResolutionStats:
+    github_latest_redirect_attempts: int = 0
+    github_latest_redirect_hits: int = 0
+    github_api_calls: int = 0
+    gitlab_api_calls: int = 0
+    pypi_registry_calls: int = 0
+    npm_registry_calls: int = 0
+
+    def has_activity(self) -> bool:
+        return any(
+            (
+                self.github_latest_redirect_attempts,
+                self.github_api_calls,
+                self.gitlab_api_calls,
+                self.pypi_registry_calls,
+                self.npm_registry_calls,
+            )
+        )
+
+
+@dataclass(slots=True)
+class ResolutionStats:
+    version: VersionResolutionStats = field(default_factory=VersionResolutionStats)
+    _lock: threading.Lock = field(default_factory=threading.Lock, repr=False)
+
+    def has_activity(self) -> bool:
+        return self.version.has_activity()
+
+    def record_github_latest_redirect(self, owner: str, repo: str, *, hit: bool) -> None:
+        if _current_phase() != "version":
+            return
+        with self._lock:
+            self.version.github_latest_redirect_attempts += 1
+            if hit:
+                self.version.github_latest_redirect_hits += 1
+        _debug_trace(f"{owner}/{repo}: GitHub latest redirect {'hit' if hit else 'miss'}")
+
+    def record_github_api(self, owner: str, repo: str, endpoint: str) -> None:
+        if _current_phase() != "version":
+            return
+        with self._lock:
+            self.version.github_api_calls += 1
+        _debug_trace(f"{owner}/{repo}: GitHub API {endpoint}")
+
+    def record_gitlab_api(self, owner: str, repo: str, endpoint: str) -> None:
+        if _current_phase() != "version":
+            return
+        with self._lock:
+            self.version.gitlab_api_calls += 1
+        _debug_trace(f"{owner}/{repo}: GitLab API {endpoint}")
+
+    def record_pypi_registry(self, name: str) -> None:
+        if _current_phase() != "version":
+            return
+        with self._lock:
+            self.version.pypi_registry_calls += 1
+        _debug_trace(f"{name}: PyPI registry")
+
+    def record_npm_registry(self, name: str) -> None:
+        if _current_phase() != "version":
+            return
+        with self._lock:
+            self.version.npm_registry_calls += 1
+        _debug_trace(f"{name}: npm registry")
+
+    def format_summary(self) -> str:
+        parts = _version_parts(self.version)
+        return f"version: {', '.join(parts)}" if parts else ""
+
+
+@contextmanager
+def collect_resolution_stats() -> Iterator[ResolutionStats]:
+    """Collect resolver counters inside the context."""
+    global _CURRENT
+    stats = ResolutionStats()
+    with _CURRENT_LOCK:
+        previous = _CURRENT
+        _CURRENT = stats
+    try:
+        yield stats
+    finally:
+        with _CURRENT_LOCK:
+            _CURRENT = previous
+
+
+@contextmanager
+def resolution_phase(name: str) -> Iterator[None]:
+    """Mark the kind of resolution currently running in this thread."""
+    previous = getattr(_LOCAL, "phase", None)
+    _LOCAL.phase = name
+    try:
+        yield
+    finally:
+        if previous is None:
+            try:
+                delattr(_LOCAL, "phase")
+            except AttributeError:
+                pass
+        else:
+            _LOCAL.phase = previous
+
+
+def record_github_latest_redirect(owner: str, repo: str, *, hit: bool) -> None:
+    stats = _current()
+    if stats is not None:
+        stats.record_github_latest_redirect(owner, repo, hit=hit)
+
+
+def record_github_api(owner: str, repo: str, endpoint: str) -> None:
+    stats = _current()
+    if stats is not None:
+        stats.record_github_api(owner, repo, endpoint)
+
+
+def record_gitlab_api(owner: str, repo: str, endpoint: str) -> None:
+    stats = _current()
+    if stats is not None:
+        stats.record_gitlab_api(owner, repo, endpoint)
+
+
+def record_pypi_registry(name: str) -> None:
+    stats = _current()
+    if stats is not None:
+        stats.record_pypi_registry(name)
+
+
+def record_npm_registry(name: str) -> None:
+    stats = _current()
+    if stats is not None:
+        stats.record_npm_registry(name)
+
+
+def _current() -> ResolutionStats | None:
+    with _CURRENT_LOCK:
+        return _CURRENT
+
+
+def _current_phase() -> str | None:
+    value = getattr(_LOCAL, "phase", None)
+    return value if isinstance(value, str) else None
+
+
+def _debug_trace(message: str) -> None:
+    from ixt.libs.logger import get_logger, get_verbosity
+
+    if get_verbosity() >= 2:
+        get_logger("resolution").debug(f"resolution: version: {message}")
+
+
+def _version_parts(stats: VersionResolutionStats) -> list[str]:
+    parts: list[str] = []
+    if stats.github_latest_redirect_attempts:
+        parts.append(
+            "GitHub latest redirect "
+            f"{stats.github_latest_redirect_hits}/{stats.github_latest_redirect_attempts} hit"
+        )
+        parts.append(_count_phrase(stats.github_api_calls, "GitHub API call"))
+    elif stats.github_api_calls:
+        parts.append(_count_phrase(stats.github_api_calls, "GitHub API call"))
+    if stats.gitlab_api_calls:
+        parts.append(_count_phrase(stats.gitlab_api_calls, "GitLab API call"))
+    if stats.pypi_registry_calls:
+        parts.append(_count_phrase(stats.pypi_registry_calls, "PyPI registry call"))
+    if stats.npm_registry_calls:
+        parts.append(_count_phrase(stats.npm_registry_calls, "npm registry call"))
+    return parts
+
+
+def _count_phrase(count: int, singular: str) -> str:
+    suffix = "" if count == 1 else "s"
+    return f"{count} {singular}{suffix}"