ixt-cli 0.8.0__py3-none-any.whl

ixt/data/registry.toml

@@ -0,0 +1,71 @@
+# registry.toml — Short name -> spec resolution
+#
+# The registry serves ONE purpose: `ixt tool install ripgrep` (short name)
+# -> find the corresponding spec (e.g. @gh:BurntSushi/ripgrep).
+#
+# It does NOT:
+# - Detect the right asset (scoring does that)
+# - Find the binary (auto-expose does that)
+# - Declare the format (bare binary auto-detected)
+#
+# When the user types `ixt tool install BurntSushi/ripgrep` (full path),
+# no registry entry is needed.
+#
+# Format:
+#   ripgrep = "@gh:BurntSushi/ripgrep"
+#
+# User can add/override entries in $IXT_HOME/config/registry.toml.
+
+[tools]
+ast-grep = "@gh:ast-grep/ast-grep"
+atuin = "@gh:atuinsh/atuin"
+bat = "@gh:sharkdp/bat"
+bottom = "@gh:ClementTsang/bottom"
+btop = "@gh:aristocratos/btop"
+chezmoi = "@gh:twpayne/chezmoi"
+delta = "@gh:dandavison/delta"
+difftastic = "@gh:Wilfred/difftastic"
+dive = "@gh:wagoodman/dive"
+duf = "@gh:muesli/duf"
+dust = "@gh:bootandy/dust"
+eza = "@gh:eza-community/eza"
+fd = "@gh:sharkdp/fd"
+fimod = "@gh:pytgaen/fimod"
+fzf = "@gh:junegunn/fzf"
+gh = "@gh:cli/cli"
+git-cliff = "@gh:orhun/git-cliff"
+gitleaks = "@gh:gitleaks/gitleaks"
+gitui = "@gh:extrawurst/gitui"
+glow = "@gh:charmbracelet/glow"
+gum = "@gh:charmbracelet/gum"
+helix = "@gh:helix-editor/helix"
+hexyl = "@gh:sharkdp/hexyl"
+hyperfine = "@gh:sharkdp/hyperfine"
+jj = "@gh:jj-vcs/jj"
+jq = "@gh:jqlang/jq"
+just = "@gh:casey/just"
+k9s = "@gh:derailed/k9s"
+lazydocker = "@gh:jesseduffield/lazydocker"
+lazygit = "@gh:jesseduffield/lazygit"
+lazyssh = "@gh:Adembc/lazyssh"
+lnav = "@gh:tstack/lnav"
+lsd = "@gh:lsd-rs/lsd"
+mise = "@gh:jdx/mise"
+nushell = "@gh:nushell/nushell"
+procs = "@gh:dalance/procs"
+rclone = "@gh:rclone/rclone"
+ripgrep = "@gh:BurntSushi/ripgrep"
+sd = "@gh:chmln/sd"
+shellcheck = "@gh:koalaman/shellcheck"
+starship = "@gh:starship/starship"
+task = "@gh:go-task/task"
+tealdeer = "@gh:tealdeer-rs/tealdeer"
+television = "@gh:alexpasmantier/television"
+trivy = "@gh:aquasecurity/trivy"
+typos = "@gh:crate-ci/typos"
+watchexec = "@gh:watchexec/watchexec"
+xh = "@gh:ducaale/xh"
+yazi = "@gh:sxyazi/yazi"
+yq = "@gh:mikefarah/yq"
+zellij = "@gh:zellij-org/zellij"
+zoxide = "@gh:ajeetdsouza/zoxide"

ixt/libs/__init__.py

@@ -0,0 +1,3 @@
+"""lib module"""
+
+__all__ = []

ixt/libs/constants.py

@@ -0,0 +1,4 @@
+"""Shared constants — no internal imports to avoid circular dependencies."""
+
+# Default exposure rule — expose only the main binary.
+EXPOSE_MAIN = "__main__"

ixt/libs/fmt.py

@@ -0,0 +1,108 @@
+"""Text formatting utilities.
+
+Includes table formatting with word-wrap support ported from uvpipx's
+text_formatter.py.
+"""
+
+from __future__ import annotations
+
+import textwrap
+
+from ixt.libs.style import visible_len
+
+
+def format_table(rows: list[list[str]], headers: list[str] | None = None) -> str:
+    """Format data as a simple ASCII table."""
+    if not rows:
+        return ""
+
+    all_rows: list[list[str]] = [headers] if headers else []
+    all_rows.extend(rows)
+
+    col_widths = max_col_widths(all_rows)
+
+    def _format_row(row: list[str]) -> str:
+        cells = []
+        for cell, width in zip(row, col_widths, strict=False):
+            s = str(cell)
+            pad = width - visible_len(s)
+            cells.append(s + " " * max(pad, 0))
+        return "  ".join(cells)
+
+    lines: list[str] = []
+    if headers:
+        lines.append(_format_row(headers))
+        lines.append("-" * (sum(col_widths) + 2 * (len(col_widths) - 1)))
+
+    for row in rows:
+        lines.append(_format_row(row))
+
+    return "\n".join(lines)
+
+
+def indent(text: str, spaces: int = 2) -> str:
+    """Indent each line of *text* by *spaces* spaces."""
+    prefix = " " * spaces
+    return prefix + ("\n" + prefix).join(text.split("\n"))
+
+
+def truncate(text: str, max_width: int, suffix: str = "...") -> str:
+    """Truncate *text* to *max_width*, adding *suffix* if truncated."""
+    if len(text) <= max_width:
+        return text
+    return text[: max_width - len(suffix)] + suffix
+
+
+# -- Column width helpers ----------------------------------------------------
+
+
+def max_col_widths(table: list[list[str]]) -> list[int]:
+    """Return the maximum visible width for each column, ignoring ANSI codes."""
+    if not table:
+        return []
+    num_cols = len(table[0])
+    return [max(visible_len(row[i]) for row in table) for i in range(num_cols)]
+
+
+# -- Word-wrap aware table --------------------------------------------------
+
+
+class _NewLinePreservingWrapper(textwrap.TextWrapper):
+    """TextWrapper that preserves explicit newlines in the source text."""
+
+    def wrap(self, text: str) -> list[str]:
+        lines: list[str] = []
+        for part in text.split("\n"):
+            lines.extend(super().wrap(part))
+        return lines
+
+
+def wrap_text_in_table(
+    table: list[list[str]],
+    column_widths: list[int],
+) -> list[list[list[str]]]:
+    """Wrap cell text to *column_widths* and pad lines for vertical alignment.
+
+    Returns a 3-D structure: ``rows → cells → lines``.
+    Each line is left-justified to its column width so that columns align when
+    printed side by side.
+    """
+    wrappers = [_NewLinePreservingWrapper(width=w) for w in column_widths]
+
+    wrapped_table: list[list[list[str]]] = []
+    for row in table:
+        wrapped_row: list[list[str]] = []
+        max_lines = 0
+
+        for content, wrapper in zip(row, wrappers, strict=False):
+            cell_lines = [line.ljust(wrapper.width) for line in wrapper.wrap(content)]
+            max_lines = max(max_lines, len(cell_lines))
+            wrapped_row.append(cell_lines)
+
+        # Pad all cells in the row to the same number of lines.
+        for i, cell in enumerate(wrapped_row):
+            cell.extend(["".ljust(column_widths[i])] * (max_lines - len(cell)))
+
+        wrapped_table.append(wrapped_row)
+
+    return wrapped_table

ixt/libs/logger.py

@@ -0,0 +1,109 @@
+"""Structured logger for ixt with colored level prefixes.
+
+Ported from uvpipx's Logger.py — simplified, integrated with style.py.
+Output goes to stderr so it never pollutes piped stdout.
+"""
+
+from __future__ import annotations
+
+import sys
+from enum import IntEnum
+
+from ixt.libs.style import Color, Painter, no_color_stderr, strip_ansi
+
+
+class Level(IntEnum):
+    """Log levels (higher value = more severe)."""
+
+    DEBUG = 0
+    INFO = 50
+    WARN = 200
+    ERROR = 300
+
+
+_LEVEL_STYLE: dict[Level, tuple[str, tuple[Color, ...]]] = {
+    Level.DEBUG: ("DEBG", (Color.BLUE,)),
+    Level.INFO: ("INFO", (Color.BRIGHT_CYAN, Color.ST_BOLD)),
+    Level.WARN: ("WARN", (Color.BRIGHT_YELLOW, Color.ST_BOLD)),
+    Level.ERROR: ("ERR ", (Color.BRIGHT_RED, Color.ST_BOLD)),
+}
+
+
+class Logger:
+    """Logger that writes to stderr with optional colored level prefixes."""
+
+    def __init__(
+        self,
+        name: str,
+        level: Level = Level.INFO,
+        *,
+        show_prefix: bool = True,
+    ):
+        self.name = name
+        self.level = level
+        self.show_prefix = show_prefix
+
+    def _format_prefix(self, level: Level) -> str:
+        if not self.show_prefix:
+            return ""
+        label, styles = _LEVEL_STYLE[level]
+        return f"[{Painter.color_str(label, *styles)}] "
+
+    def _emit(self, level: Level, message: str) -> None:
+        if level < self.level:
+            return
+        prefix = self._format_prefix(level)
+        strip = no_color_stderr()
+        for line in message.split("\n"):
+            out = f"{prefix}{line}\n"
+            if strip:
+                out = strip_ansi(out)
+            sys.stderr.write(out)
+        sys.stderr.flush()
+
+    def debug(self, message: str) -> None:
+        self._emit(Level.DEBUG, message)
+
+    def info(self, message: str) -> None:
+        self._emit(Level.INFO, message)
+
+    def warn(self, message: str) -> None:
+        self._emit(Level.WARN, message)
+
+    def error(self, message: str) -> None:
+        self._emit(Level.ERROR, message)
+
+
+# -- Singleton registry ------------------------------------------------------
+
+_LOGGERS: dict[str, Logger] = {}
+_GLOBAL_LEVEL: Level | None = None
+_VERBOSITY: int = 0
+
+
+def set_global_level(level: Level, *, verbosity: int = 1) -> None:
+    """Override the level of all existing and future loggers."""
+    global _GLOBAL_LEVEL, _VERBOSITY
+    _GLOBAL_LEVEL = level
+    _VERBOSITY = verbosity
+    for lg in _LOGGERS.values():
+        lg.level = level
+
+
+def get_verbosity() -> int:
+    """Return the CLI verbosity count (0=normal, 1=-v, 2=-vv, …)."""
+    return _VERBOSITY
+
+
+def get_logger(name: str = "ixt", level: Level = Level.INFO) -> Logger:
+    """Get or create a named logger instance.
+
+    If the logger already exists, its level is updated to *level*.
+    A global level override (via *set_global_level*) takes precedence.
+    """
+    effective = _GLOBAL_LEVEL if _GLOBAL_LEVEL is not None else level
+    if name not in _LOGGERS:
+        _LOGGERS[name] = Logger(name, effective)
+    else:
+        _LOGGERS[name].level = effective
+    return _LOGGERS[name]

ixt/libs/output.py

@@ -0,0 +1,25 @@
+"""Data output to stdout — pipeable, color-aware.
+
+Use for the *result* of a command (list, info, export, config get) so that
+``ixt <cmd> > file`` and ``ixt <cmd> | other`` work as users expect.
+
+Operational messages (progress, hints, errors) stay on the logger (stderr).
+"""
+
+from __future__ import annotations
+
+import sys
+
+from ixt.libs.style import no_color_stdout, strip_ansi
+
+
+def data(line: str) -> None:
+    """Write *line* to stdout, followed by a newline.
+
+    ANSI sequences are stripped when stdout is not a TTY or ``NO_COLOR`` is set,
+    so callers can freely use ``dim()`` / ``bold()`` without worrying about
+    garbage escape codes landing in files or pipes.
+    """
+    if no_color_stdout():
+        line = strip_ansi(line)
+    sys.stdout.write(line + "\n")

ixt/libs/req_spec.py

@@ -0,0 +1,115 @@
+"""Simple PEP 508 requirement specifier parsing
+
+Handles basic parsing of package specifications like:
+  - ruff
+  - ruff>=1.0.0
+  - ruff>=1.0.0,<2.0.0
+  - ruff[dev]
+  - ruff[dev]>=1.0.0
+"""
+
+import re
+from dataclasses import dataclass
+
+NAME_PATTERN = r"(?:@[A-Za-z0-9._-]+/[A-Za-z0-9._-]+|[A-Za-z0-9._-]+)"
+VERSION_OPERATOR_PATTERN = r"(>=|<=|==|!=|~=|>|<)"
+
+
+@dataclass
+class VersionSpec:
+    """Version specification for a package"""
+
+    operator: str  # >=, <=, ==, !=, ~=, etc.
+    version: str
+
+    def __str__(self) -> str:
+        return f"{self.operator}{self.version}"
+
+
+@dataclass
+class RequirementSpec:
+    """Parsed PEP 508 requirement specification"""
+
+    name: str  # Package name
+    extras: list[str]  # Optional extras [dev, test, ...]
+    specs: list[VersionSpec]  # Version specifiers
+
+    @property
+    def version_constraint(self) -> str | None:
+        """Get the version constraint as a string, or None if not specified"""
+        if not self.specs:
+            return None
+        return ",".join(str(spec) for spec in self.specs)
+
+    def __str__(self) -> str:
+        s = self.name
+        if self.extras:
+            s += f"[{','.join(self.extras)}]"
+        if self.specs:
+            s += ",".join(str(spec) for spec in self.specs)
+        return s
+
+
+def parse_requirement(req_str: str) -> RequirementSpec:
+    """Parse a PEP 508 requirement string
+
+    Args:
+        req_str: Requirement string (e.g., "ruff>=1.0.0,<2.0.0[dev]")
+
+    Returns:
+        Parsed RequirementSpec
+
+    Raises:
+        ValueError: If the requirement string is invalid
+    """
+    req_str = req_str.strip()
+
+    # Extract extras [...]
+    extras = []
+    extras_match = re.search(r"\[([^\]]+)\]", req_str)
+    if extras_match:
+        extras = [e.strip() for e in extras_match.group(1).split(",")]
+        req_str = req_str[: extras_match.start()] + req_str[extras_match.end() :]
+
+    # Split name and version specs.
+    # Allow classic package names and npm-style scoped names.
+    match = re.match(rf"^(?P<name>{NAME_PATTERN})(?P<rest>.*)$", req_str.strip())
+
+    if not match:
+        raise ValueError(f"Invalid requirement: {req_str}")
+
+    name = match.group("name").strip()
+    version_part = match.group("rest").strip()
+
+    specs = []
+    if version_part:
+        # Parse version specifiers (comma-separated)
+        for part in version_part.split(","):
+            part = part.strip()
+            if not part:
+                continue
+
+            # Extract operator and version
+            spec_match = re.match(rf"^{VERSION_OPERATOR_PATTERN}\s*(.+)$", part)
+            if not spec_match:
+                raise ValueError(f"Invalid version spec: {part}")
+
+            operator = spec_match.group(1)
+            version = spec_match.group(2).strip()
+            if not version or re.match(rf"^{VERSION_OPERATOR_PATTERN}", version):
+                raise ValueError(f"Invalid version spec: {part}")
+            specs.append(VersionSpec(operator, version))
+
+    return RequirementSpec(name, extras, specs)
+
+
+def parse_requirements(req_strings: list[str]) -> list[RequirementSpec]:
+    """Parse a list of requirement strings
+
+    Args:
+        req_strings: List of requirement strings
+
+    Returns:
+        List of parsed RequirementSpec objects
+    """
+    return [parse_requirement(req) for req in req_strings]

ixt/libs/semver.py

@@ -0,0 +1,149 @@
+"""Minimal semver utilities for version parsing, comparison, and partial matching."""
+
+from __future__ import annotations
+
+import re
+
+_VERSION_RE = re.compile(r"v?(\d+(?:\.\d+)*)")
+
+
+def parse_version(tag: str) -> tuple[int, ...] | None:
+    """Parse a version string into a tuple of ints.
+
+    Strips leading 'v' and any suffix after the numeric part.
+    Returns None if the string contains no version.
+
+    >>> parse_version("v14.1.0")
+    (14, 1, 0)
+    >>> parse_version("14.1")
+    (14, 1)
+    >>> parse_version("not-a-version")
+    """
+    m = _VERSION_RE.match(tag.strip())
+    if m is None:
+        return None
+    return tuple(int(x) for x in m.group(1).split("."))
+
+
+def compare_versions(a: str, b: str) -> int:
+    """Compare two version strings.
+
+    Returns -1 if a < b, 0 if a == b, 1 if a > b.
+    Missing components are treated as 0: "14.1" == "14.1.0".
+    Returns 0 if either version is unparsable.
+    """
+    va = parse_version(a)
+    vb = parse_version(b)
+    if va is None or vb is None:
+        return 0
+    # Pad to same length
+    length = max(len(va), len(vb))
+    va = va + (0,) * (length - len(va))
+    vb = vb + (0,) * (length - len(vb))
+    if va < vb:
+        return -1
+    if va > vb:
+        return 1
+    return 0
+
+
+def matches_partial(version: str, partial: str) -> bool:
+    """Check whether *version* matches a partial version prefix.
+
+    >>> matches_partial("14.1.0", "14")
+    True
+    >>> matches_partial("14.1.0", "14.1")
+    True
+    >>> matches_partial("14.1.0", "15")
+    False
+    """
+    vt = parse_version(version)
+    pt = parse_version(partial)
+    if vt is None or pt is None:
+        return False
+    return vt[: len(pt)] == pt
+
+
+def is_partial_version(version: str) -> bool:
+    """Return True if *version* looks like a partial semver (1 or 2 components).
+
+    >>> is_partial_version("14")
+    True
+    >>> is_partial_version("14.1")
+    True
+    >>> is_partial_version("14.1.0")
+    False
+    """
+    vt = parse_version(version)
+    if vt is None:
+        return False
+    return len(vt) <= 2
+
+
+_OPERATOR_RE = re.compile(r"^\s*(==|!=|>=|<=|~=|>|<)\s*(.+?)\s*$")
+
+
+def _compatible_release_upper(version: str) -> str:
+    """Compute the upper bound for a ``~=`` compatible release.
+
+    ``~=X.Y``    → ``<X+1.0``
+    ``~=X.Y.Z``  → ``<X.Y+1.0``
+    """
+    parts = version.split(".")
+    if len(parts) < 2:
+        return version  # ill-formed; caller will treat as non-matching
+    prefix = parts[:-2]
+    try:
+        bumped = int(parts[-2]) + 1
+    except ValueError:
+        return version
+    return ".".join([*prefix, str(bumped), "0"])
+
+
+def _matches_single(version: str, operator: str, target: str) -> bool:
+    """Check *version* against one operator+target."""
+    if operator == "==":
+        return compare_versions(version, target) == 0
+    if operator == "!=":
+        return compare_versions(version, target) != 0
+    if operator == ">":
+        return compare_versions(version, target) > 0
+    if operator == ">=":
+        return compare_versions(version, target) >= 0
+    if operator == "<":
+        return compare_versions(version, target) < 0
+    if operator == "<=":
+        return compare_versions(version, target) <= 0
+    if operator == "~=":
+        upper = _compatible_release_upper(target)
+        return compare_versions(version, target) >= 0 and compare_versions(version, upper) < 0
+    return False
+
+
+def version_satisfies(version: str, constraint: str) -> bool:
+    """Return True if *version* satisfies *constraint* (PEP-440-ish).
+
+    Constraint may be a single specifier (``>=1.0``) or a comma-separated
+    conjunction (``>=1.0,<2.0``). Unknown/unparsable pieces are treated as
+    non-matching — callers should decide upstream whether to trust the
+    constraint string.
+
+    >>> version_satisfies("1.5", ">=1.0,<2.0")
+    True
+    >>> version_satisfies("2.0", ">=1.0,<2.0")
+    False
+    >>> version_satisfies("1.2.3", "~=1.2")
+    True
+    """
+    if not constraint.strip():
+        return True
+    for part in constraint.split(","):
+        part = part.strip()
+        if not part:
+            continue
+        m = _OPERATOR_RE.match(part)
+        if not m:
+            return False
+        if not _matches_single(version, m.group(1), m.group(2)):
+            return False
+    return True