ixt-cli 0.8.0__py3-none-any.whl

ixt/config/toml.py

@@ -0,0 +1,416 @@
+"""TOML configuration parsing for ixt.toml files.
+
+Uses stdlib tomllib (Python 3.11+) with a minimal fallback parser
+for Python 3.10 that handles the subset of TOML used by ixt.toml.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from ixt.libs.constants import EXPOSE_MAIN
+
+# -- TOML loading ------------------------------------------------------------
+
+if sys.version_info >= (3, 11):
+    import tomllib
+
+    def _load_toml(path: Path) -> dict[str, Any]:
+        with path.open("rb") as f:
+            return tomllib.load(f)
+
+else:
+
+    def _load_toml(path: Path) -> dict[str, Any]:
+        """Minimal TOML parser for ixt.toml (Python 3.10 fallback).
+
+        Handles the subset we use: tables, dotted keys, strings,
+        inline arrays, inline tables, booleans, and integers.
+        """
+        return _mini_toml_parse(path.read_text(encoding="utf-8"))
+
+
+def _mini_toml_parse(text: str) -> dict[str, Any]:
+    """Parse a minimal TOML subset sufficient for ixt.toml."""
+    root: dict[str, Any] = {}
+    current = root
+    current_path: list[str] = []
+
+    for line in text.splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+
+        # Table header: [section] or [section.subsection]
+        m = re.match(r"^\[([^\]]+)\]$", stripped)
+        if m:
+            current_path = [k.strip().strip('"') for k in m.group(1).split(".")]
+            current = root
+            for key in current_path:
+                current = current.setdefault(key, {})
+            continue
+
+        # Key = value
+        eq_pos = stripped.find("=")
+        if eq_pos < 0:
+            continue
+        key = stripped[:eq_pos].strip().strip('"')
+        val_str = stripped[eq_pos + 1 :].strip()
+        # Strip inline comment (not inside strings)
+        val_str = _strip_inline_comment(val_str)
+        current[key] = _parse_value(val_str)
+
+    return root
+
+
+def _strip_inline_comment(val: str) -> str:
+    """Remove trailing # comment, respecting quoted strings."""
+    in_str = False
+    quote_char = ""
+    i = 0
+    while i < len(val):
+        c = val[i]
+        if in_str:
+            if c == "\\" and i + 1 < len(val):
+                i += 2
+                continue
+            if c == quote_char:
+                in_str = False
+        else:
+            if c in ('"', "'"):
+                in_str = True
+                quote_char = c
+            elif c == "#":
+                return val[:i].rstrip()
+        i += 1
+    return val
+
+
+def _parse_value(val: str) -> Any:
+    """Parse a TOML value (string, bool, int, array, inline table)."""
+    if not val:
+        return ""
+
+    # Boolean
+    if val == "true":
+        return True
+    if val == "false":
+        return False
+
+    # Integer
+    if re.match(r"^-?\d+$", val):
+        return int(val)
+
+    # Quoted string
+    if (val.startswith('"') and val.endswith('"')) or (val.startswith("'") and val.endswith("'")):
+        return val[1:-1]
+
+    # Inline array: [...]
+    if val.startswith("[") and val.endswith("]"):
+        inner = val[1:-1].strip()
+        if not inner:
+            return []
+        return [_parse_value(item.strip()) for item in _split_top_level(inner, ",")]
+
+    # Inline table: {...}
+    if val.startswith("{") and val.endswith("}"):
+        inner = val[1:-1].strip()
+        if not inner:
+            return {}
+        result = {}
+        for item in _split_top_level(inner, ","):
+            eq = item.find("=")
+            if eq < 0:
+                continue
+            k = item[:eq].strip().strip('"')
+            v = item[eq + 1 :].strip()
+            result[k] = _parse_value(v)
+        return result
+
+    # Bare string (shouldn't happen in valid TOML, but handle gracefully)
+    return val
+
+
+def _split_top_level(text: str, sep: str) -> list[str]:
+    """Split *text* by *sep* respecting brackets and quotes."""
+    parts: list[str] = []
+    depth = 0
+    in_str = False
+    quote_char = ""
+    start = 0
+    for i, c in enumerate(text):
+        if in_str:
+            if c == "\\" and i + 1 < len(text):
+                continue
+            if c == quote_char:
+                in_str = False
+        else:
+            if c in ('"', "'"):
+                in_str = True
+                quote_char = c
+            elif c in ("[", "{"):
+                depth += 1
+            elif c in ("]", "}"):
+                depth -= 1
+            elif c == sep and depth == 0:
+                parts.append(text[start:i])
+                start = i + 1
+    parts.append(text[start:])
+    return [p for p in parts if p.strip()]
+
+
+# -- ixt.toml data model -----------------------------------------------------
+
+
+@dataclass(slots=True)
+class ToolSpec:
+    """Parsed tool specification from ixt.toml [tools] section."""
+
+    name: str  # [tools] key: install spec by default, slot when ``install`` is set
+    install: str | None = None  # underlying install spec for slotted entries
+    version: str | None = None
+    expose: list[str] = field(default_factory=lambda: [EXPOSE_MAIN])
+    inject: list[str] = field(default_factory=list)
+    node_shim: bool | None = None  # None = auto (default), False = opt-out of #!node → bun rewrite
+    runtime: str | None = None  # npm only — None/bun default, "node" = install via npm
+    asset_pattern: str | None = None  # binary backend only — forced pattern for asset selection
+    env_base: str = "all"
+    env_allow: list[str] = field(default_factory=list)
+    env_deny: dict[str, dict[str, list[str]]] = field(default_factory=dict)
+    fs_base: str = "all"
+    fs_ro: list[str] = field(default_factory=list)
+    fs_rw: list[str] = field(default_factory=list)
+    fs_scratch: list[str] = field(default_factory=list)
+
+
+@dataclass(slots=True)
+class IxtConfig:
+    """Parsed ixt.toml configuration."""
+
+    tools: dict[str, ToolSpec] = field(default_factory=dict)
+    settings: dict[str, str] = field(default_factory=dict)
+    source_path: Path | None = None
+
+
+# -- Parsing ixt.toml → IxtConfig -------------------------------------------
+
+
+def parse_tool_entry(name: str, raw: dict[str, Any] | Any) -> ToolSpec:
+    """Parse a single tool entry from the [tools] table."""
+    if not isinstance(raw, dict):
+        raw = {}
+
+    legacy_fields = [field for field in ("pkg", "source") if field in raw]
+    if legacy_fields:
+        fields = ", ".join(legacy_fields)
+        raise ValueError(
+            f"Unsupported ixt.toml field(s) for tool '{name}': {fields}. "
+            'Use install = "..." for slotted entries or @pypi:/@npm:/@gh:/@gl: prefixes.'
+        )
+
+    expose_raw = raw.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 = [EXPOSE_MAIN]
+
+    inject_raw = raw.get("inject")
+    if isinstance(inject_raw, str):
+        inject = [inject_raw]
+    elif isinstance(inject_raw, list):
+        inject = [str(e) for e in inject_raw]
+    else:
+        inject = []
+
+    node_shim_raw = raw.get("node_shim")
+    node_shim = bool(node_shim_raw) if isinstance(node_shim_raw, bool) else None
+
+    runtime_raw = raw.get("runtime")
+    runtime = str(runtime_raw) if isinstance(runtime_raw, str) and runtime_raw else None
+
+    install_raw = raw.get("install")
+    install = str(install_raw) if isinstance(install_raw, str) and install_raw else None
+
+    asset_pattern_raw = raw.get("asset_pattern")
+    asset_pattern = (
+        str(asset_pattern_raw) if isinstance(asset_pattern_raw, str) and asset_pattern_raw else None
+    )
+
+    def _strlist(key: str) -> list[str]:
+        v = raw.get(key, [])
+        return [str(x) for x in v] if isinstance(v, list) else []
+
+    def _parse_deny(raw_deny: object) -> dict[str, dict[str, list[str]]]:
+        if not isinstance(raw_deny, dict):
+            return {}
+        result = {}
+        for pat, rule in raw_deny.items():
+            if isinstance(rule, dict):
+                excs = rule.get("except", [])
+                excs_list = [str(e) for e in excs] if isinstance(excs, list) else []
+                result[str(pat)] = {"except": excs_list}
+            else:
+                result[str(pat)] = {"except": []}
+        return result
+
+    return ToolSpec(
+        name=name,
+        install=install,
+        version=raw.get("version"),
+        expose=expose,
+        inject=inject,
+        node_shim=node_shim,
+        runtime=runtime,
+        asset_pattern=asset_pattern,
+        env_base=str(raw.get("env_base", "all")),
+        env_allow=_strlist("env_allow"),
+        env_deny=_parse_deny(raw.get("env_deny", {})),
+        fs_base="all" if (_raw_fs := raw.get("fs_base", "all")) == "none" else str(_raw_fs),
+        fs_ro=_strlist("fs_ro"),
+        fs_rw=_strlist("fs_rw"),
+        fs_scratch=_strlist("fs_scratch"),
+    )
+
+
+def parse_config(data: dict[str, Any], source_path: Path | None = None) -> IxtConfig:
+    """Parse raw TOML dict into an IxtConfig."""
+    tools: dict[str, ToolSpec] = {}
+    for name, raw in data.get("tools", {}).items():
+        tools[name] = parse_tool_entry(name, raw)
+
+    settings = {}
+    for k, v in data.get("settings", {}).items():
+        settings[k] = str(v)
+
+    return IxtConfig(tools=tools, settings=settings, source_path=source_path)
+
+
+def load_config(path: Path) -> IxtConfig:
+    """Load and parse an ixt.toml file."""
+    data = _load_toml(path)
+    return parse_config(data, source_path=path)
+
+
+# -- File resolution ----------------------------------------------------------
+
+
+def find_config_file(start: Path | None = None) -> Path | None:
+    """Find the nearest ixt.toml, searching upward then falling back to global.
+
+    Resolution order:
+    1. ./ixt.toml (then parent dirs up to root)
+    2. $IXT_HOME/config/ixt.toml
+    """
+    from ixt.config.settings import get_ixt_config_dir
+
+    cwd = (start or Path.cwd()).resolve()
+
+    # Walk up from cwd looking for ixt.toml
+    current = cwd
+    while True:
+        candidate = current / "ixt.toml"
+        if candidate.is_file():
+            return candidate
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+
+    # Fall back to global config
+    global_config = get_ixt_config_dir() / "ixt.toml"
+    if global_config.is_file():
+        return global_config
+
+    return None
+
+
+# -- TOML serialization (for export/save) ------------------------------------
+
+
+def _quote_key(key: str) -> str:
+    """Quote a TOML key if it contains special characters."""
+    if re.match(r"^[A-Za-z0-9_-]+$", key):
+        return key
+    return f'"{key}"'
+
+
+def _format_value(val: Any) -> str:
+    """Format a Python value as a TOML value string."""
+    if isinstance(val, bool):
+        return "true" if val else "false"
+    if isinstance(val, int):
+        return str(val)
+    if isinstance(val, str):
+        return f'"{val}"'
+    if isinstance(val, list):
+        items = ", ".join(_format_value(v) for v in val)
+        return f"[{items}]"
+    if isinstance(val, dict):
+        pairs = ", ".join(f"{_quote_key(k)} = {_format_value(v)}" for k, v in val.items())
+        return f"{{{pairs}}}"
+    return f'"{val}"'
+
+
+def tool_spec_to_dict(spec: ToolSpec) -> dict[str, Any]:
+    """Convert a ToolSpec to its TOML-serializable dict form."""
+    d: dict[str, Any] = {}
+    if spec.install:
+        d["install"] = spec.install
+    if spec.version:
+        d["version"] = spec.version
+    if spec.expose != [EXPOSE_MAIN]:
+        d["expose"] = spec.expose
+    if spec.inject:
+        d["inject"] = spec.inject
+    if spec.node_shim is False:
+        d["node_shim"] = False
+    if spec.runtime:
+        d["runtime"] = spec.runtime
+    if spec.asset_pattern:
+        d["asset_pattern"] = spec.asset_pattern
+    if spec.env_base != "all":
+        d["env_base"] = spec.env_base
+    if spec.env_allow:
+        d["env_allow"] = spec.env_allow
+    if spec.env_deny:
+        d["env_deny"] = spec.env_deny
+    if spec.fs_base != "all":
+        d["fs_base"] = spec.fs_base
+    if spec.fs_ro:
+        d["fs_ro"] = spec.fs_ro
+    if spec.fs_rw:
+        d["fs_rw"] = spec.fs_rw
+    if spec.fs_scratch:
+        d["fs_scratch"] = spec.fs_scratch
+    return d
+
+
+def serialize_config(config: IxtConfig) -> str:
+    """Serialize an IxtConfig to TOML string."""
+    lines: list[str] = []
+
+    if config.settings:
+        lines.append("[settings]")
+        for key, val in sorted(config.settings.items()):
+            lines.append(f'{_quote_key(key)} = "{val}"')
+        lines.append("")
+
+    if config.tools:
+        lines.append("[tools]")
+        for name in sorted(config.tools):
+            spec = config.tools[name]
+            d = tool_spec_to_dict(spec)
+            key = _quote_key(name)
+            if d:
+                lines.append(f"{key} = {_format_value(d)}")
+            else:
+                lines.append(f"{key} = {{}}")
+        lines.append("")
+
+    return "\n".join(lines) + "\n" if lines else ""

ixt/core/__init__.py

@@ -0,0 +1,16 @@
+"""Core primitives for isolated tool environments."""
+
+from ixt.core.backend import Backend, BackendType, detect_backend, get_backend
+from ixt.core.install import install_tool, uninstall_tool
+from ixt.core.pathlink import PathLink, create_path_link
+
+__all__ = [
+    "Backend",
+    "BackendType",
+    "PathLink",
+    "create_path_link",
+    "detect_backend",
+    "get_backend",
+    "install_tool",
+    "uninstall_tool",
+]