kx-cli 0.0.1__tar.gz → 0.0.2__tar.gz

kx_cli-0.0.2/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: kx-cli
+Version: 0.0.2
+Summary: kubectl wrapper with index-based resource selection
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: typer
+Requires-Dist: kubernetes
+Requires-Dist: rich
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+
+# kx
+
+`kx` is a kubectl wrapper that adds index-based resource selection. Run `kx get <resource>` once, then reference any result by number instead of typing full resource names.
+
+## Install
+
+```bash
+pip install kx-cli
+```
+
+## Usage
+
+### List resources
+
+```
+kx get <resource> [-n <namespace>]
+```
+
+Fetches resources and assigns index numbers. Omitting `-n` uses the current context namespace.
+
+```
+$ kx get pods
+X  NAME                          READY  STATUS   RESTARTS  AGE
+1  api-7d9f4b8c6-xkp2q           1/1    Running  0         2d
+2  worker-6c8b5f7d9-mnt4r        1/1    Running  3         5h
+3  postgres-0                    1/1    Running  0         12d
+```
+
+All subsequent commands reference resources by their `X` index from the last `kx get`.
+
+### Commands
+
+| Command | Description |
+|---|---|
+| `kx get <resource> [-n ns]` | List resources with index numbers |
+| `kx describe <index>` | Show `kubectl describe` output for an indexed resource |
+| `kx events <index>` | Show Kubernetes events for the resource |
+| `kx logs <index>` | Stream logs for a pod |
+| `kx yaml <index>` | Print the raw YAML manifest |
+| `kx exec <index> [cmd]` | Open an interactive shell in a pod (bash → sh fallback); pass a custom command with `cmd` |
+| `kx edit <index>` | Open the resource in your editor via `kubectl edit` |
+| `kx delete <index> [-y]` | Delete the resource (prompts for confirmation; `-y` skips it) |
+| `kx tree <index>` | Show the ownership graph for a resource |
+| `kx port-forward <index> <port>` | Forward a local port to a resource (supports Pod, Deployment, ReplicaSet, StatefulSet, DaemonSet, Service) |
+| `kx state` | Show the current state (last `kx get` result) as JSON |
+
+### Example workflow
+
+```bash
+# list deployments, pick index 2
+kx get deployments
+kx describe 2
+
+# check events on that deployment
+kx events 2
+
+# drill into a pod
+kx get pods
+kx logs 1
+kx exec 1            # opens bash/sh
+kx exec 1 -- env     # run a specific command
+
+# forward local port 8080 to port 80 on a service
+kx get services
+kx port-forward 2 8080:80
+
+# clean up
+kx delete 3
+```
+
+## State
+
+`kx` saves the last `get` result to `~/.kx_state.json`. Index-based commands read from this file, so switching namespaces or resource types requires a new `kx get`.
+
+## Development
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+```
+
+Run the CLI directly:
+
+```bash
+python -m kx.main --help
+```

kx_cli-0.0.2/README.md

@@ -0,0 +1,87 @@
+# kx
+
+`kx` is a kubectl wrapper that adds index-based resource selection. Run `kx get <resource>` once, then reference any result by number instead of typing full resource names.
+
+## Install
+
+```bash
+pip install kx-cli
+```
+
+## Usage
+
+### List resources
+
+```
+kx get <resource> [-n <namespace>]
+```
+
+Fetches resources and assigns index numbers. Omitting `-n` uses the current context namespace.
+
+```
+$ kx get pods
+X  NAME                          READY  STATUS   RESTARTS  AGE
+1  api-7d9f4b8c6-xkp2q           1/1    Running  0         2d
+2  worker-6c8b5f7d9-mnt4r        1/1    Running  3         5h
+3  postgres-0                    1/1    Running  0         12d
+```
+
+All subsequent commands reference resources by their `X` index from the last `kx get`.
+
+### Commands
+
+| Command | Description |
+|---|---|
+| `kx get <resource> [-n ns]` | List resources with index numbers |
+| `kx describe <index>` | Show `kubectl describe` output for an indexed resource |
+| `kx events <index>` | Show Kubernetes events for the resource |
+| `kx logs <index>` | Stream logs for a pod |
+| `kx yaml <index>` | Print the raw YAML manifest |
+| `kx exec <index> [cmd]` | Open an interactive shell in a pod (bash → sh fallback); pass a custom command with `cmd` |
+| `kx edit <index>` | Open the resource in your editor via `kubectl edit` |
+| `kx delete <index> [-y]` | Delete the resource (prompts for confirmation; `-y` skips it) |
+| `kx tree <index>` | Show the ownership graph for a resource |
+| `kx port-forward <index> <port>` | Forward a local port to a resource (supports Pod, Deployment, ReplicaSet, StatefulSet, DaemonSet, Service) |
+| `kx state` | Show the current state (last `kx get` result) as JSON |
+
+### Example workflow
+
+```bash
+# list deployments, pick index 2
+kx get deployments
+kx describe 2
+
+# check events on that deployment
+kx events 2
+
+# drill into a pod
+kx get pods
+kx logs 1
+kx exec 1            # opens bash/sh
+kx exec 1 -- env     # run a specific command
+
+# forward local port 8080 to port 80 on a service
+kx get services
+kx port-forward 2 8080:80
+
+# clean up
+kx delete 3
+```
+
+## State
+
+`kx` saves the last `get` result to `~/.kx_state.json`. Index-based commands read from this file, so switching namespaces or resource types requires a new `kx get`.
+
+## Development
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+```
+
+Run the CLI directly:
+
+```bash
+python -m kx.main --help
+```

kx_cli-0.0.2/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "kx-cli"
+version = "0.0.2"
+description = "kubectl wrapper with index-based resource selection"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "typer",
+    "kubernetes",
+    "rich",
+]
+
+[project.optional-dependencies]
+dev = [
+    "ruff",
+    "pytest",
+]
+
+[project.scripts]
+kx = "kx.main:app"
+
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

kx_cli-0.0.2/src/kx/commands/delete.py

@@ -0,0 +1,17 @@
+from kx.kubectl import KubectlServiceProtocol
+from kx.state import StateServiceProtocol
+from kx.types import Confirm
+
+
+class DeleteCommand:
+    def __init__(self, state: StateServiceProtocol, kubectl: KubectlServiceProtocol, confirm: Confirm):
+        self.state = state
+        self.kubectl = kubectl
+        self.confirm = confirm
+
+    def execute(self, index: int, yes: bool) -> str:
+        name, namespace, kind = self.state.fields(index)
+        if not yes:
+            self.confirm(f"Delete {kind}/{name} in {namespace}?")
+        self.kubectl.run(["delete", kind, name, "-n", namespace])
+        return f"Deleted {kind}/{name}"

kx_cli-0.0.2/src/kx/commands/describe.py

@@ -0,0 +1,16 @@
+from kx.kubectl import KubectlServiceProtocol
+from kx.state import StateServiceProtocol
+
+
+class DescribeCommand:
+    def __init__(
+        self,
+        state: StateServiceProtocol,
+        kubectl: KubectlServiceProtocol,
+    ):
+        self.state = state
+        self.kubectl = kubectl
+
+    def execute(self, index: int, extra_args: list[str] = []) -> None:
+        name, namespace, kind = self.state.fields(index)
+        self.kubectl.run_interactive(["describe", kind, name, "-n", namespace, *extra_args])

kx_cli-0.0.2/src/kx/commands/edit.py

@@ -0,0 +1,12 @@
+from kx.kubectl import KubectlServiceProtocol
+from kx.state import StateServiceProtocol
+
+
+class EditCommand:
+    def __init__(self, state: StateServiceProtocol, kubectl: KubectlServiceProtocol):
+        self.state = state
+        self.kubectl = kubectl
+
+    def execute(self, index: int, extra_args: list[str] = []) -> None:
+        name, namespace, kind = self.state.fields(index)
+        self.kubectl.run_interactive(["edit", kind, name, "-n", namespace, *extra_args])

kx_cli-0.0.2/src/kx/commands/events.py

@@ -0,0 +1,26 @@
+from kx.events import EventsServiceProtocol
+from kx.state import StateServiceProtocol
+
+
+class EventsCommand:
+    def __init__(self, state: StateServiceProtocol, events: EventsServiceProtocol):
+        self.state = state
+        self.events = events
+
+    def execute(self, index: int) -> str:
+        name, namespace, kind = self.state.fields(index)
+        all_events = self.events.get(namespace)
+        filtered = self.events.filter(all_events, name, kind)
+
+        if not filtered:
+            return "No events found"
+
+        output = []
+        for e in filtered:
+            obj = e.involved_object
+            output.append(
+                f"{e.type:8} {e.reason:30} "
+                f"{obj.kind:10} {e.metadata.creation_timestamp} "
+                f"{e.message}"
+            )
+        return "\n".join(output)

kx_cli-0.0.2/src/kx/commands/exec.py

@@ -0,0 +1,20 @@
+from kx.kinds import Kind
+from kx.kubectl import KubectlServiceProtocol
+from kx.state import StateServiceProtocol
+
+
+class ExecCommand:
+    def __init__(self, state: StateServiceProtocol, kubectl: KubectlServiceProtocol):
+        self.state = state
+        self.kubectl = kubectl
+
+    def execute(self, index: int, cmd: list[str] | None, extra_args: list[str] = []) -> None:
+        name, namespace, kind = self.state.fields(index)
+        if kind != Kind.Pod:
+            raise ValueError("exec is only supported for pods.")
+        if cmd:
+            self.kubectl.run_interactive(["exec", "-it", name, "-n", namespace, *extra_args, "--", *cmd])
+        else:
+            rc = self.kubectl.run_interactive(["exec", "-it", name, "-n", namespace, *extra_args, "--", "bash"])
+            if rc != 0:
+                self.kubectl.run_interactive(["exec", "-it", name, "-n", namespace, *extra_args, "--", "sh"])

kx_cli-0.0.2/src/kx/commands/get.py

@@ -0,0 +1,28 @@
+from kx.index import IndexServiceProtocol
+from kx.kinds import normalize_kind
+from kx.kubectl import KubectlServiceProtocol
+from kx.state import State, StateServiceProtocol
+
+
+class GetCommand:
+    def __init__(
+        self,
+        kubectl: KubectlServiceProtocol,
+        state: StateServiceProtocol,
+        index: IndexServiceProtocol,
+    ):
+        self.kubectl = kubectl
+        self.state = state
+        self.index = index
+
+    def execute(self, resource: str, namespace: str, filter_term: str | None = None, extra_args: list[str] = []) -> str:
+        if namespace is None:
+            namespace = self.kubectl.current_namespace()
+
+        output = self.kubectl.run(["get", resource, "-n", namespace, *extra_args])
+        if filter_term:
+            output = self.index.filter(output, filter_term)
+        indexed_output, names = self.index.add(output)
+        if names:
+            self.state.save(State(kind=str(normalize_kind(resource)), names=names, namespace=namespace))
+        return indexed_output

kx_cli-0.0.2/src/kx/commands/logs.py

@@ -0,0 +1,15 @@
+from kx.kinds import Kind
+from kx.kubectl import KubectlServiceProtocol
+from kx.state import StateServiceProtocol
+
+
+class LogsCommand:
+    def __init__(self, state: StateServiceProtocol, kubectl: KubectlServiceProtocol):
+        self.state = state
+        self.kubectl = kubectl
+
+    def execute(self, index: int, extra_args: list[str] = []) -> None:
+        name, namespace, kind = self.state.fields(index)
+        if kind != Kind.Pod:
+            raise ValueError("Logs are only supported on pods.")
+        self.kubectl.run_interactive(["logs", name, "-n", namespace, *extra_args])

kx_cli-0.0.2/src/kx/commands/port_forward.py

@@ -0,0 +1,17 @@
+from kx.kinds import Kind
+from kx.kubectl import KubectlServiceProtocol
+from kx.state import StateServiceProtocol
+
+_SUPPORTED_KINDS = {Kind.Pod, Kind.Deployment, Kind.ReplicaSet, Kind.StatefulSet, Kind.DaemonSet, Kind.Service}
+
+
+class PortForwardCommand:
+    def __init__(self, kubectl: KubectlServiceProtocol, state: StateServiceProtocol):
+        self.kubectl = kubectl
+        self.state = state
+
+    def execute(self, index: int, port: str, extra_args: list[str] = []) -> None:
+        name, namespace, kind = self.state.fields(index)
+        if kind not in _SUPPORTED_KINDS:
+            raise ValueError(f"port-forward is not supported for '{kind}'.")
+        self.kubectl.run_interactive(["port-forward", f"{kind}/{name}", port, "-n", namespace, *extra_args])

kx_cli-0.0.2/src/kx/commands/state.py

@@ -0,0 +1,13 @@
+from dataclasses import asdict
+import json
+
+from kx.state import State, StateServiceProtocol
+
+
+class StateCommand:
+    def __init__(self, state: StateServiceProtocol):
+        self.state = state
+
+    def execute(self) -> State:
+        state = self.state.load()
+        return json.dumps(asdict(state), indent=2)

kx_cli-0.0.2/src/kx/commands/tree.py

@@ -0,0 +1,16 @@
+from rich.tree import Tree
+
+from kx.kubectl import KubectlServiceProtocol
+from kx.state import StateServiceProtocol
+from kx.types import BuildTree
+
+
+class TreeCommand:
+    def __init__(self, state: StateServiceProtocol, kubectl: KubectlServiceProtocol, build_tree: BuildTree):
+        self.state = state
+        self.kubectl = kubectl
+        self.build_tree = build_tree
+
+    def execute(self, index: int) -> Tree:
+        name, namespace, kind = self.state.fields(index)
+        return self.build_tree(kind, name, namespace)

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

@@ -0,0 +1,12 @@
+from kx.kubectl import KubectlServiceProtocol
+from kx.state import StateServiceProtocol
+
+
+class YamlCommand:
+    def __init__(self, state: StateServiceProtocol, kubectl: KubectlServiceProtocol):
+        self.state = state
+        self.kubectl = kubectl
+
+    def execute(self, index: int) -> str:
+        name, namespace, kind = self.state.fields(index)
+        return self.kubectl.run(["get", kind, name, "-n", namespace, "-o", "yaml"])

kx_cli-0.0.2/src/kx/events.py

@@ -0,0 +1,22 @@
+from kubernetes import client
+from typing import Protocol
+
+from kx.k8s import load_config
+
+class EventsServiceProtocol(Protocol):
+    def get(self, namespace: str) -> list: ...
+    def filter(self, events: list, name: str, kind: str) -> list: ...
+
+
+class EventsService:
+    def get(self, namespace: str) -> list:
+        load_config()
+        v1 = client.CoreV1Api()
+        return v1.list_namespaced_event(namespace=namespace).items
+
+    def filter(self, events: list, name: str, kind: str) -> list:
+        return [
+            e for e in events
+            if e.involved_object.name == name
+            and e.involved_object.kind == kind
+        ]

{kx_cli-0.0.1 → kx_cli-0.0.2}/src/kx/graph.py

@@ -1,11 +1,12 @@
 from kubernetes import client
 from rich.tree import Tree
 
-from kx.k8s import load_k8s
+from kx.k8s import load_config
+from kx.kinds import Kind
 
 
 def build_tree(kind: str, name: str, namespace: str) -> Tree:
-    load_k8s()
+    load_config()
     root = Tree(f"[bold]{kind}/{name}[/bold]")
 
     apps = client.AppsV1Api()
@@ -14,21 +15,22 @@ def build_tree(kind: str, name: str, namespace: str) -> Tree:
 
     pods = core.list_namespaced_pod(namespace).items
 
-    if kind == "Deployment":
-        _tree_deployment(name, namespace, root, apps, pods)
-    elif kind == "ReplicaSet":
-        _tree_replica_set(name, namespace, root, apps, pods)
-    elif kind == "StatefulSet":
-        _tree_stateful_set(name, namespace, root, apps, pods)
-    elif kind == "DaemonSet":
-        _tree_daemon_set(name, namespace, root, apps, pods)
-    elif kind == "CronJob":
-        _tree_cron_job(name, namespace, root, batch, pods)
-    elif kind == "Pod":
-        pod = core.read_namespaced_pod(name, namespace)
-        _add_containers(pod, root)
-    else:
-        root.add(f"[dim](no ownership graph for {kind})[/dim]")
+    match kind:
+        case Kind.Deployment:
+            _tree_deployment(name, namespace, root, apps, pods)
+        case Kind.ReplicaSet:
+            _tree_replica_set(name, namespace, root, apps, pods)
+        case Kind.StatefulSet:
+            _tree_stateful_set(name, namespace, root, apps, pods)
+        case Kind.DaemonSet:
+            _tree_daemon_set(name, namespace, root, apps, pods)
+        case Kind.CronJob:
+            _tree_cron_job(name, namespace, root, batch, pods)
+        case Kind.Pod:
+            pod = core.read_namespaced_pod(name, namespace)
+            _add_containers(pod, root)
+        case _:
+            root.add(f"[dim](no ownership graph for {kind})[/dim]")
 
     return root
 

kx_cli-0.0.2/src/kx/index.py

@@ -0,0 +1,91 @@
+import re
+from typing import TYPE_CHECKING, Protocol
+
+import typer
+
+if TYPE_CHECKING:
+    from kx.state import State
+
+
+def resolve_index(state, index: int) -> str:
+    if index < 1:
+        typer.echo("Invalid index")
+        raise typer.Exit(1)
+    try:
+        return state.names[index - 1]
+    except IndexError:
+        typer.echo("Invalid index")
+        raise typer.Exit(1)
+
+
+def _parse_output(output: str) -> tuple[list[str], list[list[str]], int]:
+    lines = output.splitlines()
+    if not lines:
+        return [], [], 0
+
+    header = lines[0]
+    spans = [(m.start(), m.end()) for m in re.finditer(r"\S+\s*", header)]
+    headers = [header[s:e].strip() for s, e in spans]
+    if "NAME" not in headers:
+        return [], [], 0
+    name_idx = headers.index("NAME")
+
+    rows = []
+    for r in lines[1:]:
+        if not r.strip():
+            continue
+        cols = [r[s:e].strip() for s, e in spans]
+        if len(cols) <= name_idx:
+            continue
+        rows.append(cols)
+
+    return headers, rows, name_idx
+
+
+class IndexServiceProtocol(Protocol):
+    def add(self, output: str) -> tuple[str, list[str]]: ...
+    def filter(self, output: str, term: str) -> str: ...
+    def resolve(self, state: "State", index: int) -> str: ...
+
+
+class IndexService:
+    def add(self, output: str) -> tuple[str, list[str]]:
+        headers, rows, name_idx = _parse_output(output)
+        if not headers:
+            return output, []
+
+        names = [r[name_idx] for r in rows]
+
+        headers = ["X"] + headers
+        rows = [[str(i + 1)] + r for i, r in enumerate(rows)]
+
+        all_rows = [headers] + rows
+        cols = list(zip(*all_rows))
+        widths = [max(len(cell) for cell in col) for col in cols]
+
+        def fmt(row: list[str]) -> str:
+            return "  ".join(cell.ljust(widths[i]) for i, cell in enumerate(row))
+
+        return "\n".join(fmt(r) for r in all_rows), names
+
+    def filter(self, output: str, term: str) -> str:
+        headers, rows, name_idx = _parse_output(output)
+        if not headers:
+            return output
+
+        filtered = [r for r in rows if term.lower() in r[name_idx].lower()]
+
+        all_rows = [headers] + filtered
+        if len(all_rows) == 1:
+            return output.splitlines()[0]
+
+        cols = list(zip(*all_rows))
+        widths = [max(len(cell) for cell in col) for col in cols]
+
+        def fmt(row: list[str]) -> str:
+            return "  ".join(cell.ljust(widths[i]) for i, cell in enumerate(row))
+
+        return "\n".join(fmt(r) for r in all_rows)
+
+    def resolve(self, state: "State", index: int) -> str:
+        return resolve_index(state, index)

kx_cli-0.0.2/src/kx/k8s.py

@@ -0,0 +1,7 @@
+from kubernetes import config
+
+def load_config():
+    try:
+        config.load_kube_config()
+    except Exception:
+        config.load_incluster_config()

kx_cli-0.0.2/src/kx/kinds.py

@@ -0,0 +1,66 @@
+from enum import StrEnum
+
+
+class Kind(StrEnum):
+    Pod = "Pod"
+    Deployment = "Deployment"
+    ReplicaSet = "ReplicaSet"
+    StatefulSet = "StatefulSet"
+    DaemonSet = "DaemonSet"
+    CronJob = "CronJob"
+    Service = "Service"
+    HorizontalPodAutoscaler = "HorizontalPodAutoscaler"
+    Ingress = "Ingress"
+    ConfigMap = "ConfigMap"
+    Secret = "Secret"
+    Job = "Job"
+    PersistentVolumeClaim = "PersistentVolumeClaim"
+    Node = "Node"
+    Namespace = "Namespace"
+
+
+_KIND_MAP: dict[str, Kind] = {
+    "po":                       Kind.Pod,
+    "pod":                      Kind.Pod,
+    "pods":                     Kind.Pod,
+    "deployment":               Kind.Deployment,
+    "deployments":              Kind.Deployment,
+    "deploy":                   Kind.Deployment,
+    "replicaset":               Kind.ReplicaSet,
+    "replicasets":              Kind.ReplicaSet,
+    "rs":                       Kind.ReplicaSet,
+    "statefulset":              Kind.StatefulSet,
+    "statefulsets":             Kind.StatefulSet,
+    "sts":                      Kind.StatefulSet,
+    "daemonset":                Kind.DaemonSet,
+    "daemonsets":               Kind.DaemonSet,
+    "ds":                       Kind.DaemonSet,
+    "hpa":                      Kind.HorizontalPodAutoscaler,
+    "horizontalpodautoscaler":  Kind.HorizontalPodAutoscaler,
+    "horizontalpodautoscalers": Kind.HorizontalPodAutoscaler,
+    "service":                  Kind.Service,
+    "services":                 Kind.Service,
+    "svc":                      Kind.Service,
+    "ingress":                  Kind.Ingress,
+    "ingresses":                Kind.Ingress,
+    "configmap":                Kind.ConfigMap,
+    "configmaps":               Kind.ConfigMap,
+    "cm":                       Kind.ConfigMap,
+    "secret":                   Kind.Secret,
+    "secrets":                  Kind.Secret,
+    "job":                      Kind.Job,
+    "jobs":                     Kind.Job,
+    "cronjob":                  Kind.CronJob,
+    "cronjobs":                 Kind.CronJob,
+    "pvc":                      Kind.PersistentVolumeClaim,
+    "persistentvolumeclaim":    Kind.PersistentVolumeClaim,
+    "persistentvolumeclaims":   Kind.PersistentVolumeClaim,
+    "node":                     Kind.Node,
+    "nodes":                    Kind.Node,
+    "namespace":                Kind.Namespace,
+    "namespaces":               Kind.Namespace,
+}
+
+
+def normalize_kind(resource_type: str) -> Kind | str:
+    return _KIND_MAP.get(resource_type.lower(), resource_type)