kx-cli 0.0.9__tar.gz → 0.0.10__tar.gz

{kx_cli-0.0.9/src/kx_cli.egg-info → kx_cli-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kx-cli
-Version: 0.0.9
+Version: 0.0.10
 Summary: kubectl wrapper with index-based resource selection
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
@@ -70,7 +70,7 @@ With pip:
 pip install kx-cli
 ```
 
-As a kubectl plugin via [krew](https://krew.sigs.k8s.io/), where kx is published as `idx` (no Python required; krew-index submission in progress):
+As a kubectl plugin via [krew](https://krew.sigs.k8s.io/), where kx is published as `idx` (no Python required):
 
 ```bash
 kubectl krew install idx

{kx_cli-0.0.9 → kx_cli-0.0.10}/README.md

@@ -47,7 +47,7 @@ With pip:
 pip install kx-cli
 ```
 
-As a kubectl plugin via [krew](https://krew.sigs.k8s.io/), where kx is published as `idx` (no Python required; krew-index submission in progress):
+As a kubectl plugin via [krew](https://krew.sigs.k8s.io/), where kx is published as `idx` (no Python required):
 
 ```bash
 kubectl krew install idx

{kx_cli-0.0.9 → kx_cli-0.0.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kx-cli"
-version = "0.0.9"
+version = "0.0.10"
 description = "kubectl wrapper with index-based resource selection"
 readme = "README.md"
 requires-python = ">=3.11"

{kx_cli-0.0.9 → kx_cli-0.0.10}/src/kx/commands/events.py

@@ -1,4 +1,4 @@
-from kx.events import EventsServiceProtocol
+from kx.events import EventRow, EventsServiceProtocol
 from kx.kubectl import KubectlServiceProtocol
 from kx.refresh import ensure_exists
 from kx.state import StateServiceProtocol
@@ -15,7 +15,7 @@ class EventsCommand:
         self.events = events
         self.kubectl = kubectl
 
-    def execute(self, index: int) -> str:
+    def execute(self, index: int) -> list[EventRow]:
         name, namespace, kind = self.state.fields(index)
         all_events = self.events.get(namespace)
         filtered = self.events.filter(all_events, name, kind)
@@ -24,14 +24,21 @@ class EventsCommand:
             # Deleted resources keep their events ~1h; only an empty result
             # warrants checking whether the target itself is gone.
             ensure_exists(self.kubectl, kind, name, namespace)
-            return "No events found"
+            return []
 
-        output = []
+        rows = []
         for event in filtered:
             obj = event.involved_object
-            output.append(
-                f"{event.type:8} {event.reason:30} "
-                f"{obj.kind:10} {event.metadata.creation_timestamp} "
-                f"{event.message}"
+            timestamp = getattr(event, "last_timestamp", None) or getattr(
+                event.metadata, "creation_timestamp", None
             )
-        return "\n".join(output)
+            rows.append(
+                EventRow(
+                    type=event.type or "",
+                    reason=event.reason or "",
+                    kind=obj.kind,
+                    message=event.message or "",
+                    timestamp=timestamp,
+                )
+            )
+        return rows

kx_cli-0.0.10/src/kx/commands/yaml.py

@@ -0,0 +1,43 @@
+import yaml
+
+from kx.kubectl import KubectlServiceProtocol
+from kx.state import StateServiceProtocol
+
+
+def _find_keys(data: dict | list, keys: set[str]) -> dict:
+    """Collect the value of each requested key from anywhere in the manifest,
+    preferring the shallowest occurrence when a key appears at multiple depths.
+
+    A breadth-first walk guarantees shallowest-wins: a workload's own top-level
+    `metadata` is returned rather than its pod template's nested `metadata`,
+    while genuinely nested-only keys (e.g. `containerStatuses` under `status`)
+    are still found. A matched key's own subtree is not descended into."""
+    result: dict = {}
+    frontier: list = [data]
+    while frontier:
+        deeper: list = []
+        for node in frontier:
+            if isinstance(node, dict):
+                for k, v in node.items():
+                    if k in keys:
+                        result.setdefault(k, v)
+                    else:
+                        deeper.append(v)
+            elif isinstance(node, list):
+                deeper.extend(node)
+        frontier = deeper
+    return result
+
+
+class YamlCommand:
+    def __init__(self, state: StateServiceProtocol, kubectl: KubectlServiceProtocol):
+        self.state = state
+        self.kubectl = kubectl
+
+    def execute(self, index: int, show: list[str] | None = None) -> str:
+        name, namespace, kind = self.state.fields(index)
+        raw = self.kubectl.run(["get", kind, name, "-n", namespace, "-o", "yaml"])
+        if not show:
+            return raw
+        data = yaml.safe_load(raw)
+        return yaml.dump(_find_keys(data, set(show)), default_flow_style=False)

{kx_cli-0.0.9 → kx_cli-0.0.10}/src/kx/config.py

@@ -52,6 +52,13 @@ def load_config() -> Config:
     if "KX_THEME" in os.environ:
         kwargs["theme"] = os.environ["KX_THEME"]
 
+    if "max_history" in kwargs:
+        mh = kwargs["max_history"]
+        # bool is an int subclass; reject it and any non-int/non-positive value
+        # (a string from TOML, 0, or a negative) with a clear message.
+        if isinstance(mh, bool) or not isinstance(mh, int) or mh < 1:
+            raise SystemExit("kx: max_history must be a positive integer")
+
     if "theme" in kwargs and kwargs["theme"] not in THEMES:
         raise SystemExit(
             f"kx: unknown theme '{kwargs['theme']}' (run kx theme to list themes)"

{kx_cli-0.0.9 → kx_cli-0.0.10}/src/kx/console.py

@@ -14,6 +14,8 @@ from rich.table import Table
 from rich.text import Text
 
 from kx.diagnostics import SEVERITY_PATTERN, Severity
+from kx.events import EventRow
+from kx.index import _parse_output
 from kx.kinds import plural_display
 from kx.scanner import SEVERITIES, ImageScan
 from kx.state import StateHistory
@@ -245,28 +247,20 @@ def _print_get_caption(resource_type: str, namespace: str, count: int) -> None:
 def render_indexed_table(
     text: str, resource_type: str, namespace: str, note: str | None = None
 ) -> None:
-    lines = [line for line in text.splitlines() if line.strip()]
-    if not lines:
-        # kubectl exits 0 with empty stdout when nothing matches ("No
-        # resources found" goes to stderr) — show the caption, not silence.
-        _print_get_caption(resource_type, namespace, 0)
-        return
-
-    header_line = lines[0]
-    first_col = header_line.split()[0] if header_line.split() else ""
-    if first_col != "X" and note is None:
-        _console.print(text, markup=False, highlight=False)
+    # Share index._parse_output (the single table parser) rather than a private
+    # copy: it extends the last column to end-of-line, so a value wider than its
+    # header (kubectl doesn't pad the last column) is never sliced off.
+    headers, rows, _ = _parse_output(text)
+    if not headers:
+        # Non-tabular output (JSON/YAML, or a table with no NAME column) prints
+        # as-is; genuinely empty stdout (kubectl sends "No resources found" to
+        # stderr) shows the zero-count caption instead of silence.
+        if text.strip():
+            _console.print(text, markup=False, highlight=False)
+        else:
+            _print_get_caption(resource_type, namespace, 0)
         return
 
-    spans = [(m.start(), m.end()) for m in re.finditer(r"\S+\s*", header_line)]
-    headers = [header_line[start:end].strip() for start, end in spans]
-
-    rows = []
-    for line in lines[1:]:
-        cols = [line[start:end].strip() for start, end in spans]
-        if cols:
-            rows.append(cols)
-
     if not rows:
         _print_get_caption(resource_type, namespace, 0)
         return
@@ -329,8 +323,8 @@ def render_indexed_table(
         _console.print(f"[muted]{note}[/muted]")
 
 
-def render_events_table(text: str) -> None:
-    if text.strip() == "No events found":
+def render_events_table(rows: list[EventRow]) -> None:
+    if not rows:
         _console.print("[muted]No events found[/muted]")
         return
 
@@ -343,31 +337,17 @@ def render_events_table(text: str) -> None:
     for col in ("TYPE", "REASON", "KIND", "AGE", "MESSAGE"):
         table.add_column(col)
 
-    for line in text.splitlines():
-        if not line.strip():
-            continue
-        event_type = line[0:8].strip()
-        reason = line[9:39].strip()
-        kind = line[40:50].strip()
-        rest = line[51:]
-        parts = rest.split(" ", 2)
-        timestamp = (
-            f"{parts[0]} {parts[1]}" if len(parts) >= 2 else (parts[0] if parts else "")
-        )
-        message = parts[2] if len(parts) >= 3 else ""
-
-        try:
-            age = _format_age(datetime.fromisoformat(timestamp))
-        except ValueError:
-            age = timestamp
-
-        type_color = "muted" if event_type == "Normal" else "warn"
+    for row in rows:
+        age = _format_age(row.timestamp)
+        type_color = "muted" if row.type == "Normal" else "warn"
         table.add_row(
-            f"[{type_color}]{event_type}[/]",
-            reason,
-            kind,
+            f"[{type_color}]{row.type}[/]",
+            row.reason,
+            row.kind,
             f"[muted]{age}[/]",
-            message,
+            # Text (not markup) so bracketed characters in a message are shown
+            # literally, matching the WARNING EVENTS section.
+            Text(row.message),
         )
 
     _console.print(table)

{kx_cli-0.0.9 → kx_cli-0.0.10}/src/kx/events.py

@@ -1,9 +1,24 @@
-from kubernetes import client
+from dataclasses import dataclass
+from datetime import datetime
 from typing import Protocol
 
+from kubernetes import client
+
 from kx.k8s import load_config
 
 
+@dataclass
+class EventRow:
+    """One event, flattened for rendering. `timestamp` is the event's last-seen
+    time (falling back to creation) as a datetime, or None if unavailable."""
+
+    type: str
+    reason: str
+    kind: str
+    message: str
+    timestamp: datetime | None = None
+
+
 class EventsServiceProtocol(Protocol):
     def get(self, namespace: str) -> list: ...
     def filter(self, events: list, name: str, kind: str) -> list: ...

{kx_cli-0.0.9 → kx_cli-0.0.10}/src/kx/index.py

@@ -63,6 +63,19 @@ class IndexService:
         if not headers:
             return output, []
 
+        # Index numbers must map 1:1 to saved state, which is keyed by name.
+        # Collapse any repeated NAME (first-seen wins) so the displayed indexes
+        # and the state entries can never desync.
+        seen: set[str] = set()
+        unique_rows = []
+        for row in rows:
+            name = row[name_idx]
+            if name in seen:
+                continue
+            seen.add(name)
+            unique_rows.append(row)
+        rows = unique_rows
+
         names = [row[name_idx] for row in rows]
 
         headers = ["X"] + headers

kx_cli-0.0.10/src/kx/kubectl.py

@@ -0,0 +1,64 @@
+import subprocess
+from typing import Protocol
+
+_MISSING_KUBECTL = (
+    "kubectl not found on PATH — install kubectl "
+    "(https://kubernetes.io/docs/tasks/tools/) and ensure it is on your PATH."
+)
+
+
+class KubectlServiceProtocol(Protocol):
+    def run(self, args: list[str]) -> str: ...
+    def run_interactive(self, args: list[str], stderr: int | None = None) -> int: ...
+    def probe(self, args: list[str]) -> int: ...
+    def current_namespace(self) -> str: ...
+    def current_context(self) -> str: ...
+
+
+class KubectlService:
+    def _run(self, args: list[str], **kwargs) -> subprocess.CompletedProcess:
+        # Central chokepoint: a missing kubectl raises FileNotFoundError, which
+        # handle_errors doesn't catch (traceback). Translate it into a handled
+        # RuntimeError with an actionable message.
+        try:
+            return subprocess.run(["kubectl", *args], **kwargs)
+        except FileNotFoundError as e:
+            raise RuntimeError(_MISSING_KUBECTL) from e
+
+    def run(self, args: list[str]) -> str:
+        result = self._run(args, capture_output=True, text=True)
+        if result.returncode != 0:
+            raise RuntimeError(result.stderr.strip())
+        return result.stdout
+
+    def run_interactive(self, args: list[str], stderr: int | None = None) -> int:
+        return self._run(args, stderr=stderr).returncode
+
+    def probe(self, args: list[str]) -> int:
+        return self._run(args, capture_output=True).returncode
+
+    def current_namespace(self) -> str:
+        # Best-effort: no kubeconfig / no current context exits non-zero, and
+        # `check=True` would surface that as an unhandled CalledProcessError.
+        # The namespace is only a label here, so fall back to "default".
+        result = self._run(
+            ["config", "view", "--minify", "-o", "jsonpath={..namespace}"],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            return "default"
+        ns = result.stdout.strip()
+        return ns if ns else "default"
+
+    def current_context(self) -> str:
+        # `kubectl config current-context` exits non-zero when none is set;
+        # return empty so context listing still works instead of crashing.
+        result = self._run(
+            ["config", "current-context"],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            return ""
+        return result.stdout.strip()

{kx_cli-0.0.9 → kx_cli-0.0.10}/src/kx/main.py

@@ -293,16 +293,13 @@ def events(indexes: list[int]):
     for position, index in enumerate(indexes):
         name, ns, kind = _state.fields(index)
         with console.status("fetching events"):
-            result = command.execute(index)
-        if result.strip() == "No events found":
-            count = 0
-        else:
-            count = len([line for line in result.splitlines() if line.strip()])
+            rows = command.execute(index)
+        count = len(rows)
         extra = f"{count} {'item' if count == 1 else 'items'}" if count else ""
         if position > 0:
             console.print_raw("")
         console.print_banner(kind, name, namespace=ns, extra=extra)
-        console.render_events_table(result)
+        console.render_events_table(rows)
 
 
 @app.command(
@@ -468,7 +465,7 @@ def yaml(
     show: Optional[str] = typer.Option(
         None,
         "--show",
-        help="Comma-separated top-level YAML fields to display (e.g. metadata,spec)",
+        help="Comma-separated YAML fields to display (e.g. metadata,spec)",
     ),
 ):
     """Print the raw YAML manifest for one or more indexed resources; --show filters to specific top-level fields."""

{kx_cli-0.0.9 → kx_cli-0.0.10}/src/kx/scanner.py

@@ -24,15 +24,25 @@ class ScannerServiceProtocol(Protocol):
     def capture(self, argv: list[str]) -> subprocess.CompletedProcess: ...
 
 
+def _missing_binary(argv: list[str]) -> str:
+    return f"{argv[0]} not found on PATH — install it to run this scan."
+
+
 class ScannerService:
     def scan(self, argv: list[str]) -> int:
         # Inherit stdio so the scanner streams its own output straight to the
         # terminal (native passthrough); return the exit code without raising.
-        return subprocess.run(argv).returncode
+        try:
+            return subprocess.run(argv).returncode
+        except FileNotFoundError as e:
+            raise RuntimeError(_missing_binary(argv)) from e
 
     def capture(self, argv: list[str]) -> subprocess.CompletedProcess:
         # Capture stdout for structured (SARIF) parsing into a summary table.
-        return subprocess.run(argv, capture_output=True, text=True)
+        try:
+            return subprocess.run(argv, capture_output=True, text=True)
+        except FileNotFoundError as e:
+            raise RuntimeError(_missing_binary(argv)) from e
 
 
 class Engine:

{kx_cli-0.0.9 → kx_cli-0.0.10}/src/kx/state.py

@@ -1,5 +1,7 @@
 from dataclasses import dataclass, asdict
 import json
+import os
+import tempfile
 from pathlib import Path
 from typing import Protocol
 
@@ -55,16 +57,26 @@ _STATE_FILE = Path.home() / ".kx" / "state.json"
 
 class StateService:
     def __init__(self, max_history: int = 10) -> None:
-        self.max_history = max_history
+        # Always keep at least one entry: max_history < 1 would otherwise make
+        # the history slice below a no-op (list[-0:] is the whole list).
+        self.max_history = max(1, max_history)
 
     def _load_history(self) -> StateHistory:
         if not _STATE_FILE.exists():
             raise RuntimeError("No state found. Run `kx get <resource>` first.")
-        data = json.loads(_STATE_FILE.read_text())
-        if "states" not in data:
-            return StateHistory(states=[_state_from_dict(data)], cursor=0)
-        states = [_state_from_dict(state_data) for state_data in data["states"]]
-        return StateHistory(states=states, cursor=data["cursor"])
+        try:
+            data = json.loads(_STATE_FILE.read_text())
+            if "states" not in data:
+                return StateHistory(states=[_state_from_dict(data)], cursor=0)
+            states = [_state_from_dict(state_data) for state_data in data["states"]]
+            return StateHistory(states=states, cursor=data["cursor"])
+        except (json.JSONDecodeError, KeyError, TypeError) as e:
+            # Corrupt or foreign JSON (partial write, hand-edit, old schema).
+            # A `kx get` rebuilds state, so this is recoverable, not fatal.
+            raise RuntimeError(
+                f"State file at {_STATE_FILE} is unreadable ({e}). "
+                f"Run `kx get <resource>` to rebuild it."
+            ) from e
 
     def _save_history(self, history: StateHistory) -> None:
         _STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
@@ -72,7 +84,18 @@ class StateService:
             "states": [asdict(state) for state in history.states],
             "cursor": history.cursor,
         }
-        _STATE_FILE.write_text(json.dumps(data))
+        # Write to a sibling temp file and atomically replace it in, so an
+        # interrupted write can never leave a truncated/corrupt state.json.
+        fd, tmp = tempfile.mkstemp(
+            dir=_STATE_FILE.parent, prefix=".state-", suffix=".tmp"
+        )
+        try:
+            with os.fdopen(fd, "w") as f:
+                f.write(json.dumps(data))
+            os.replace(tmp, _STATE_FILE)
+        except BaseException:
+            Path(tmp).unlink(missing_ok=True)
+            raise
 
     def save(self, state: State) -> None:
         try:

{kx_cli-0.0.9 → kx_cli-0.0.10/src/kx_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kx-cli
-Version: 0.0.9
+Version: 0.0.10
 Summary: kubectl wrapper with index-based resource selection
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
@@ -70,7 +70,7 @@ With pip:
 pip install kx-cli
 ```
 
-As a kubectl plugin via [krew](https://krew.sigs.k8s.io/), where kx is published as `idx` (no Python required; krew-index submission in progress):
+As a kubectl plugin via [krew](https://krew.sigs.k8s.io/), where kx is published as `idx` (no Python required):
 
 ```bash
 kubectl krew install idx

{kx_cli-0.0.9 → kx_cli-0.0.10}/src/kx_cli.egg-info/SOURCES.txt

@@ -78,6 +78,7 @@ tests/test_get.py
 tests/test_graph.py
 tests/test_index.py
 tests/test_kinds.py
+tests/test_kubectl.py
 tests/test_labels.py
 tests/test_logs.py
 tests/test_metadata_helper.py

{kx_cli-0.0.9 → kx_cli-0.0.10}/tests/test_config.py

@@ -90,6 +90,40 @@ class TestEnvOverrides:
             with pytest.raises(SystemExit, match="KX_MAX_HISTORY must be an integer"):
                 load_config()
 
+    def test_zero_max_history_from_env_raises_system_exit(self, tmp_path, monkeypatch):
+        _clear_env(monkeypatch)
+        monkeypatch.setenv("KX_MAX_HISTORY", "0")
+        with _patch_config_file(tmp_path / "config.toml"):
+            with pytest.raises(SystemExit, match="positive integer"):
+                load_config()
+
+    def test_negative_max_history_from_env_raises_system_exit(
+        self, tmp_path, monkeypatch
+    ):
+        _clear_env(monkeypatch)
+        monkeypatch.setenv("KX_MAX_HISTORY", "-3")
+        with _patch_config_file(tmp_path / "config.toml"):
+            with pytest.raises(SystemExit, match="positive integer"):
+                load_config()
+
+    def test_zero_max_history_from_file_raises_system_exit(self, tmp_path, monkeypatch):
+        _clear_env(monkeypatch)
+        config_file = tmp_path / "config.toml"
+        config_file.write_text("max_history = 0\n")
+        with _patch_config_file(config_file):
+            with pytest.raises(SystemExit, match="positive integer"):
+                load_config()
+
+    def test_non_integer_max_history_from_file_raises_system_exit(
+        self, tmp_path, monkeypatch
+    ):
+        _clear_env(monkeypatch)
+        config_file = tmp_path / "config.toml"
+        config_file.write_text('max_history = "ten"\n')
+        with _patch_config_file(config_file):
+            with pytest.raises(SystemExit, match="positive integer"):
+                load_config()
+
 
 class TestNoColor:
     def test_no_color_from_file(self, tmp_path, monkeypatch):