ixt-cli 0.8.0__py3-none-any.whl

ixt/config/registry.py

@@ -0,0 +1,145 @@
+"""Registry for short name -> spec resolution.
+
+`ixt tool install ripgrep` -> lookup registry -> `@gh:BurntSushi/ripgrep` -> binary backend.
+
+Loads embedded registry.toml + optional user overrides from
+$IXT_HOME/config/registry.toml + optional high-priority files from
+IXT_REGISTRY.
+
+Format:
+
+    [tools]
+    ripgrep = "@gh:BurntSushi/ripgrep"
+"""
+
+from __future__ import annotations
+
+import functools
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from ixt.config.toml import _load_toml
+from ixt.data import get_data_path
+
+REGISTRY_ENV = "IXT_REGISTRY"
+
+# ---------------------------------------------------------------------------
+# Data model
+# ---------------------------------------------------------------------------
+
+
+@dataclass(slots=True)
+class RegistryEntry:
+    """A single tool entry in the registry."""
+
+    spec: str
+
+
+# ---------------------------------------------------------------------------
+# Loading
+# ---------------------------------------------------------------------------
+
+
+def _parse_registry(data: dict[str, Any]) -> dict[str, RegistryEntry]:
+    """Build a name -> RegistryEntry mapping from parsed TOML dict."""
+    tools = data.get("tools", {})
+    result: dict[str, RegistryEntry] = {}
+    for name, value in tools.items():
+        if isinstance(value, str):
+            result[name] = RegistryEntry(spec=value)
+    return result
+
+
+@functools.lru_cache(maxsize=1)
+def load_registry(user_path: Path | None = None) -> dict[str, RegistryEntry]:
+    """Load registry sources in priority order.
+
+    Lower-priority sources are loaded first. Later files override earlier
+    entries, so env-supplied registries have the highest priority.
+
+    Args:
+        user_path: Explicit path to user override file.
+                   If None, checks $IXT_HOME/config/registry.toml.
+
+    Returns:
+        Dict mapping short name to RegistryEntry.
+    """
+    registry: dict[str, RegistryEntry] = {}
+    _merge_registry_file(registry, get_data_path("registry.toml"))
+
+    # User overrides
+    if user_path is None:
+        from ixt.config.settings import get_ixt_config_dir
+
+        user_path = get_ixt_config_dir() / "registry.toml"
+
+    _merge_registry_file(registry, user_path)
+
+    for raw in _split_env_paths(os.environ.get(REGISTRY_ENV, "")):
+        if raw.startswith(("http://", "https://")):
+            continue
+        _merge_registry_file(registry, Path(raw).expanduser())
+
+    return registry
+
+
+def _merge_registry_file(registry: dict[str, RegistryEntry], path: Path) -> None:
+    if not path.is_file():
+        return
+    registry.update(_parse_registry(_load_toml(path)))
+
+
+def _split_env_paths(value: str) -> list[str]:
+    return [part for part in (item.strip() for item in value.split(";")) if part]
+
+
+# ---------------------------------------------------------------------------
+# Lookup
+# ---------------------------------------------------------------------------
+
+
+def lookup(name: str, registry: dict[str, RegistryEntry] | None = None) -> RegistryEntry | None:
+    """Resolve a short name to a RegistryEntry.
+
+    Lookup strategy:
+        1. Exact match on registry key (e.g. "ripgrep" -> RegistryEntry)
+        2. Match on repo part of owner/repo (e.g. "nushell" matches "nushell/nushell")
+
+    Args:
+        name: Short tool name to look up.
+        registry: Registry dict. Loads defaults if None.
+
+    Returns:
+        RegistryEntry, or None if not found.
+    """
+    if registry is None:
+        registry = load_registry()
+
+    lower = name.lower()
+
+    # 1. Exact key match (case-insensitive)
+    for key, entry in registry.items():
+        if key.lower() == lower:
+            return entry
+
+    # 2. Match on repo name part (last segment after /)
+    for entry in registry.values():
+        # Strip @prefix: if present to get the raw spec
+        raw = entry.spec.partition(":")[2] if ":" in entry.spec else entry.spec
+        if "/" in raw:
+            repo_name = raw.rsplit("/", 1)[1]
+            if repo_name.lower() == lower:
+                return entry
+
+    return None
+
+
+def lookup_spec(name: str, registry: dict[str, RegistryEntry] | None = None) -> str | None:
+    """Resolve a short name to a spec string (e.g. ``@gh:BurntSushi/ripgrep``).
+
+    Convenience wrapper around :func:`lookup` that returns just the spec.
+    """
+    entry = lookup(name, registry)
+    return entry.spec if entry else None

ixt/config/settings.py

@@ -0,0 +1,173 @@
+"""Path management and global configuration for ixt."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from ixt.platform import get_binary_extension
+
+
+def get_ixt_home() -> Path:
+    """Get the ixt home directory.
+
+    Resolution order:
+
+    1. ``$IXT_HOME`` if set — explicit user override.
+    2. ``$XDG_DATA_HOME/ixt`` if ``XDG_DATA_HOME`` is set.
+    3. ``~/.local/share/ixt`` otherwise (XDG default).
+
+    The home directory stores user-visible ixt state: ``config/`` and
+    ``installed/``. Regenerable cache content lives under
+    :func:`get_ixt_cache_home`.
+    """
+    if env_home := os.environ.get("IXT_HOME"):
+        return Path(env_home).expanduser()
+    if xdg_data := os.environ.get("XDG_DATA_HOME"):
+        return Path(xdg_data).expanduser() / "ixt"
+    return Path.home() / ".local" / "share" / "ixt"
+
+
+def get_ixt_installed_dir() -> Path:
+    """Get the active installation root (``$IXT_HOME/installed``)."""
+    return get_ixt_home() / "installed"
+
+
+def get_ixt_bin_dir() -> Path:
+    """Get the directory for exposed tool shims."""
+    if env_bin := os.environ.get("IXT_BIN_DIR"):
+        return Path(env_bin).expanduser()
+    return get_ixt_installed_dir() / "bin"
+
+
+def get_ixt_envs_dir() -> Path:
+    """Get the directory containing isolated environments per tool."""
+    return get_ixt_installed_dir() / "envs"
+
+
+def get_ixt_runtimes_dir() -> Path:
+    """Get the directory for bootstrapped runtimes (uv, bun, python)."""
+    return get_ixt_installed_dir() / "runtimes"
+
+
+def get_ixt_config_dir() -> Path:
+    """Get the directory for user-editable ixt tool config files."""
+    return get_ixt_home() / "config"
+
+
+def get_ixt_cache_home() -> Path:
+    """Get the ixt cache root.
+
+    Resolution order:
+
+    1. ``$IXT_CACHE_HOME`` if set — explicit ixt override.
+    2. ``$XDG_CACHE_HOME/ixt`` if ``XDG_CACHE_HOME`` is set.
+    3. ``~/.cache/ixt`` otherwise (XDG default).
+    """
+    if env_cache := os.environ.get("IXT_CACHE_HOME"):
+        return Path(env_cache).expanduser()
+    if xdg_cache := os.environ.get("XDG_CACHE_HOME"):
+        return Path(xdg_cache).expanduser() / "ixt"
+    return Path.home() / ".cache" / "ixt"
+
+
+def get_ixt_downloads_dir() -> Path:
+    """Get the cache directory for network artifacts."""
+    return get_ixt_cache_home() / "downloads"
+
+
+def get_ixt_metadata_dir() -> Path:
+    """Get the cache directory for metadata and resolution state."""
+    return get_ixt_cache_home() / "metadata"
+
+
+def get_ixt_tmp_dir() -> Path:
+    """Get the cache directory for ixt-owned temporary files."""
+    return get_ixt_cache_home() / "tmp"
+
+
+def get_ixt_cache_dir() -> Path:
+    """Get the network-artifact cache directory.
+
+    Kept as the historical helper name for backend code that stores
+    downloaded release assets and fetched ``ixt.setup.toml`` files.
+    """
+    return get_ixt_downloads_dir()
+
+
+class Settings:
+    """Central, backend-agnostic configuration for ixt."""
+
+    def __init__(self):
+        self.home = get_ixt_home()
+        self.installed_dir = get_ixt_installed_dir()
+        self.bin_dir = get_ixt_bin_dir()
+        self.envs_dir = get_ixt_envs_dir()
+        self.runtimes_dir = get_ixt_runtimes_dir()
+        self.config_dir = get_ixt_config_dir()
+        self.cache_home = get_ixt_cache_home()
+        self.downloads_dir = get_ixt_downloads_dir()
+        self.metadata_dir = get_ixt_metadata_dir()
+        self.tmp_dir = get_ixt_tmp_dir()
+        self.cache_dir = get_ixt_cache_dir()
+
+    def ensure_directories(self):
+        """Create all necessary ixt state and cache directories."""
+        for d in [
+            self.home,
+            self.config_dir,
+            self.installed_dir,
+            self.bin_dir,
+            self.envs_dir,
+            self.runtimes_dir,
+            self.cache_home,
+            self.downloads_dir,
+            self.metadata_dir,
+            self.tmp_dir,
+            self.cache_dir,
+        ]:
+            d.mkdir(parents=True, exist_ok=True)
+
+    @property
+    def uv_runtime(self) -> Path:
+        """Path to the bootstrapped uv binary."""
+        return self.runtimes_dir / f"uv{get_binary_extension()}"
+
+    @property
+    def bun_runtime(self) -> Path:
+        """Path to the bootstrapped bun binary."""
+        return self.runtimes_dir / f"bun{get_binary_extension()}"
+
+    def get_tool_env_dir(self, tool_name: str) -> Path:
+        """Get the isolated environment directory for a specific tool."""
+        safe = tool_name.replace("@", "").replace("/", "-")
+        return self.envs_dir / safe
+
+    def get_tool_metadata_file(self, tool_name: str) -> Path:
+        """Get the ixt.json metadata file for a tool."""
+        return self.get_tool_env_dir(tool_name) / "ixt.json"
+
+    def iter_installed_metadata(self) -> list[Path]:
+        """Return sorted list of ixt.json paths for all installed tools."""
+        if not self.envs_dir.exists():
+            return []
+        results = []
+        for entry in sorted(self.envs_dir.iterdir()):
+            if entry.name.startswith(".") or not entry.is_dir():
+                continue
+            meta = entry / "ixt.json"
+            if meta.exists():
+                results.append(meta)
+        return results
+
+
+# Global settings singleton
+_settings: Settings | None = None
+
+
+def get_settings() -> Settings:
+    """Get or create the global Settings instance."""
+    global _settings
+    if _settings is None:
+        _settings = Settings()
+    return _settings

ixt/config/setup_toml.py

@@ -0,0 +1,179 @@
+"""Parser for ``ixt.setup.toml`` — metadata defined by tool authors.
+
+A repo can contain an ``ixt.setup.toml`` at its root, which ixt reads
+during installation to discover how the tool should be installed and
+exposed. This avoids relying solely on heuristics or the built-in registry.
+
+Priority: ixt.setup.toml > heuristic auto-detection.
+"""
+
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from ixt.net.source import ReleaseSource
+
+if sys.version_info >= (3, 11):
+    import tomllib
+
+    _loads = tomllib.loads
+else:
+    from ixt.config.toml import _mini_toml_parse
+
+    _loads = _mini_toml_parse
+
+
+# ---------------------------------------------------------------------------
+# Data model
+# ---------------------------------------------------------------------------
+
+
+@dataclass(slots=True)
+class HookConfig:
+    """A lifecycle hook (post_install or pre_uninstall)."""
+
+    run: str | None = None
+    check: str | None = None
+
+
+@dataclass(slots=True)
+class SetupConfig:
+    """Parsed ``ixt.setup.toml`` from a tool repo."""
+
+    name: str | None = None
+    expose: list[str] = field(default_factory=list)
+    description: str | None = None
+    asset_pattern: str | None = None
+
+    completions: dict[str, str] = field(default_factory=dict)
+    man: dict[str, str] = field(default_factory=dict)
+    meta: dict[str, Any] = field(default_factory=dict)
+
+    post_install: HookConfig = field(default_factory=HookConfig)
+    pre_uninstall: HookConfig = field(default_factory=HookConfig)
+
+
+# ---------------------------------------------------------------------------
+# Parsing
+# ---------------------------------------------------------------------------
+
+
+def _parse_toml_string(text: str) -> dict[str, Any]:
+    """Parse a TOML string using stdlib (3.11+) or fallback parser."""
+    return _loads(text)
+
+
+def parse_setup_toml(text: str) -> SetupConfig:
+    """Parse the text content of an ``ixt.setup.toml`` file.
+
+    The file is expected to have an ``[ixt]`` top-level table.
+    Returns a SetupConfig with all recognized fields, or an empty
+    SetupConfig if the ``[ixt]`` section is absent.
+    """
+    data = _parse_toml_string(text)
+    ixt = data.get("ixt", {})
+    if not isinstance(ixt, dict):
+        return SetupConfig()
+
+    expose_raw = ixt.get("expose")
+    if isinstance(expose_raw, str):
+        expose = [expose_raw]
+    elif isinstance(expose_raw, list):
+        expose = [str(e) for e in expose_raw]
+    else:
+        expose = []
+
+    completions = ixt.get("completions", {})
+    if not isinstance(completions, dict):
+        completions = {}
+
+    man = ixt.get("man", {})
+    if not isinstance(man, dict):
+        man = {}
+
+    meta = ixt.get("meta", {})
+    if not isinstance(meta, dict):
+        meta = {}
+
+    post_install = _parse_hook(ixt.get("post_install"))
+    pre_uninstall = _parse_hook(ixt.get("pre_uninstall"))
+
+    return SetupConfig(
+        name=ixt.get("name"),
+        expose=expose,
+        description=ixt.get("description"),
+        asset_pattern=ixt.get("asset_pattern"),
+        completions=completions,
+        man=man,
+        meta=meta,
+        post_install=post_install,
+        pre_uninstall=pre_uninstall,
+    )
+
+
+def _parse_hook(raw: Any) -> HookConfig:
+    """Parse a hook section (dict with optional run/check keys)."""
+    if not isinstance(raw, dict):
+        return HookConfig()
+    return HookConfig(
+        run=raw.get("run"),
+        check=raw.get("check"),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Fetch and cache
+# ---------------------------------------------------------------------------
+
+
+def load_local_setup_toml(path: Path) -> SetupConfig:
+    """Load an ``ixt.setup.toml`` from a local file path.
+
+    Raises FileNotFoundError if *path* does not exist.
+    """
+    text = path.read_text(encoding="utf-8")
+    return parse_setup_toml(text)
+
+
+def fetch_setup_toml(
+    source: ReleaseSource,
+    owner: str,
+    repo: str,
+    *,
+    cache_dir: Path | None = None,
+    ref: str | None = None,
+) -> SetupConfig | None:
+    """Fetch ``ixt.setup.toml`` from the repo and parse it.
+
+    Uses the ReleaseSource's ``get_file_content()`` method. When *ref* is
+    given, the file is fetched at that specific revision (tag) so the
+    config stays coherent with the installed release.
+    Caches the result to disk if *cache_dir* is given.
+    Returns None if the file doesn't exist (404).
+    """
+    # Check cache first
+    if cache_dir is not None:
+        cached = cache_dir / "setup.toml"
+        try:
+            text = cached.read_text(encoding="utf-8")
+            if text:
+                return parse_setup_toml(text)
+        except FileNotFoundError:
+            pass
+
+    # Fetch from repo
+    text = source.get_file_content(owner, repo, "ixt.setup.toml", ref=ref)
+    if text is None:
+        return None
+
+    # Cache for later
+    if cache_dir is not None:
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        cached = cache_dir / "setup.toml"
+        cached.write_text(text, encoding="utf-8")
+
+    return parse_setup_toml(text)