kx-cli 0.0.1__py3-none-any.whl

kx/events.py

@@ -0,0 +1,43 @@
+from kubernetes import client
+from kx.k8s import load_k8s
+
+_KIND_MAP = {
+    "pod": "Pod", "pods": "Pod",
+    "deployment": "Deployment", "deployments": "Deployment", "deploy": "Deployment",
+    "replicaset": "ReplicaSet", "replicasets": "ReplicaSet", "rs": "ReplicaSet",
+    "statefulset": "StatefulSet", "statefulsets": "StatefulSet", "sts": "StatefulSet",
+    "daemonset": "DaemonSet", "daemonsets": "DaemonSet", "ds": "DaemonSet",
+    "hpa": "HorizontalPodAutoscaler",
+    "horizontalpodautoscaler": "HorizontalPodAutoscaler",
+    "horizontalpodautoscalers": "HorizontalPodAutoscaler",
+    "service": "Service", "services": "Service", "svc": "Service",
+    "ingress": "Ingress", "ingresses": "Ingress",
+    "configmap": "ConfigMap", "configmaps": "ConfigMap", "cm": "ConfigMap",
+    "secret": "Secret", "secrets": "Secret",
+    "job": "Job", "jobs": "Job",
+    "cronjob": "CronJob", "cronjobs": "CronJob",
+    "pvc": "PersistentVolumeClaim",
+    "persistentvolumeclaim": "PersistentVolumeClaim",
+    "persistentvolumeclaims": "PersistentVolumeClaim",
+    "node": "Node", "nodes": "Node",
+    "namespace": "Namespace", "namespaces": "Namespace",
+}
+
+
+def normalize_kind(resource_type: str) -> str:
+    return _KIND_MAP.get(resource_type.lower(), resource_type)
+
+
+def get_events(namespace: str):
+    load_k8s()
+    v1 = client.CoreV1Api()
+
+    return v1.list_namespaced_event(namespace=namespace).items
+
+def filter_events(events, name: str, kind: str):
+    normalized = normalize_kind(kind)
+    return [
+        e for e in events
+        if e.involved_object.name == name
+        and e.involved_object.kind == normalized
+    ]

kx/graph.py

@@ -0,0 +1,89 @@
+from kubernetes import client
+from rich.tree import Tree
+
+from kx.k8s import load_k8s
+
+
+def build_tree(kind: str, name: str, namespace: str) -> Tree:
+    load_k8s()
+    root = Tree(f"[bold]{kind}/{name}[/bold]")
+
+    apps = client.AppsV1Api()
+    core = client.CoreV1Api()
+    batch = client.BatchV1Api()
+
+    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]")
+
+    return root
+
+
+def _tree_deployment(name, namespace, node, apps, pods):
+    deploy = apps.read_namespaced_deployment(name, namespace)
+    uid = deploy.metadata.uid
+    replica_sets = [
+        rs for rs in apps.list_namespaced_replica_set(namespace).items
+        if _owned_by(rs, uid)
+    ]
+    for rs in replica_sets:
+        rs_node = node.add(f"[green]rs/{rs.metadata.name}[/green]")
+        _add_pods_for_owner(rs.metadata.uid, pods, rs_node)
+
+
+def _tree_replica_set(name, namespace, node, apps, pods):
+    rs = apps.read_namespaced_replica_set(name, namespace)
+    _add_pods_for_owner(rs.metadata.uid, pods, node)
+
+
+def _tree_stateful_set(name, namespace, node, apps, pods):
+    sts = apps.read_namespaced_stateful_set(name, namespace)
+    _add_pods_for_owner(sts.metadata.uid, pods, node)
+
+
+def _tree_daemon_set(name, namespace, node, apps, pods):
+    ds = apps.read_namespaced_daemon_set(name, namespace)
+    _add_pods_for_owner(ds.metadata.uid, pods, node)
+
+
+def _tree_cron_job(name, namespace, node, batch, pods):
+    cj = batch.read_namespaced_cron_job(name, namespace)
+    uid = cj.metadata.uid
+    jobs = [
+        j for j in batch.list_namespaced_job(namespace).items
+        if _owned_by(j, uid)
+    ]
+    for job in jobs:
+        job_node = node.add(f"[green]job/{job.metadata.name}[/green]")
+        _add_pods_for_owner(job.metadata.uid, pods, job_node)
+
+
+def _add_pods_for_owner(owner_uid, pods, parent_node):
+    owned = [p for p in pods if _owned_by(p, owner_uid)]
+    for pod in owned:
+        pod_node = parent_node.add(f"[blue]pod/{pod.metadata.name}[/blue]")
+        _add_containers(pod, pod_node)
+
+
+def _add_containers(pod, parent_node):
+    for container in pod.spec.containers:
+        parent_node.add(f"[cyan]container: {container.name}[/cyan]")
+
+
+def _owned_by(resource, uid: str) -> bool:
+    refs = resource.metadata.owner_references or []
+    return any(ref.uid == uid for ref in refs)

kx/index.py

@@ -0,0 +1,56 @@
+import typer
+
+
+def resolve_index(state, index: int) -> str:
+    try:
+        return state.names[index - 1]
+    except IndexError:
+        typer.echo("Invalid index")
+        raise typer.Exit(1)
+
+def add_indexes(output: str) -> tuple[str, list[str]]:
+    import re
+
+    lines = output.splitlines()
+    if not lines:
+        return output, []
+
+    header = lines[0]
+    rows = lines[1:]
+
+    # compute column boundaries from header
+    spans = [(m.start(), m.end()) for m in re.finditer(r"\S+\s*", header)]
+
+    headers = [header[s:e].strip() for s, e in spans]
+    name_idx = headers.index("NAME")
+
+    names = []
+
+    parsed_rows = []
+    for r in rows:
+        if not r.strip():
+            continue
+
+        cols = [r[s:e].strip() for s, e in spans]
+
+        if len(cols) <= name_idx:
+            continue
+
+        names.append(cols[name_idx])
+        parsed_rows.append(cols)
+
+    # add index column (X)
+    headers = ["X"] + headers
+    parsed_rows = [[str(i + 1)] + r for i, r in enumerate(parsed_rows)]
+
+    # compute widths
+    cols = list(zip(headers, *parsed_rows))
+    widths = [max(len(str(cell)) for cell in col) for col in cols]
+
+    def fmt(row):
+        return "  ".join(str(cell).ljust(widths[i]) for i, cell in enumerate(row))
+
+    out = [fmt(headers)]
+    out += [fmt(r) for r in parsed_rows]
+
+    return "\n".join(out), names

kx/k8s.py

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

kx/kubectl.py

@@ -0,0 +1,16 @@
+import subprocess
+
+
+def run_kubectl(args: list[str]) -> str:
+    result = subprocess.run(
+        ["kubectl", *args],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return result.stdout
+
+
+def run_kubectl_interactive(args: list[str]) -> int:
+    result = subprocess.run(["kubectl", *args])
+    return result.returncode

kx/main.py

@@ -0,0 +1,166 @@
+import subprocess
+
+import typer
+
+from kx.kubectl import run_kubectl, run_kubectl_interactive
+from kx.index import add_indexes, resolve_index
+from kx.state import KxState, save_state, load_state
+
+app = typer.Typer(help="kx - kubectl extended with indexing")
+
+
+def _get_current_namespace() -> str:
+    result = subprocess.run(
+        ["kubectl", "config", "view", "--minify", "-o", "jsonpath={..namespace}"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    ns = result.stdout.strip()
+    return ns if ns else "default"
+
+
+def _state_fields(index: int) -> tuple[str, str, str]:
+    state = load_state()
+    name = resolve_index(state, index)
+    return name, state.namespace, state.resource_type
+
+
+@app.command()
+def get(
+    resource: str,
+    namespace: str = typer.Option(None, "-n", help="Kubernetes namespace"),
+):
+    """List resources and assign index numbers for use with other commands."""
+    if namespace is None:
+        namespace = _get_current_namespace()
+
+    output = run_kubectl(["get", resource, "-n", namespace])
+    indexed_output, names = add_indexes(output)
+    typer.echo(indexed_output)
+    save_state(KxState(resource_type=resource, names=names, namespace=namespace))
+
+
+@app.command()
+def describe(
+    index: int,
+    view: str = typer.Option("full", help="Output view: full or events"),
+):
+    """Show full kubectl describe output for an indexed resource."""
+    name, namespace, kind = _state_fields(index)
+
+    if view == "events":
+        from kx.events import get_events, filter_events
+
+        all_events = get_events(namespace)
+        events = filter_events(all_events, name, kind)
+
+        if not events:
+            typer.echo("No events found")
+            return
+
+        for e in events:
+            obj = e.involved_object
+            typer.echo(
+                f"{e.type:8} {e.reason:30} "
+                f"{obj.kind:10} {e.metadata.creation_timestamp} "
+                f"{e.message}"
+            )
+        return
+
+    subprocess.run(["kubectl", "describe", kind, name, "-n", namespace])
+
+
+@app.command()
+def events(index: int):
+    """Show Kubernetes events for an indexed resource."""
+    from kx.events import get_events, filter_events
+
+    name, namespace, kind = _state_fields(index)
+    all_events = get_events(namespace)
+    filtered = filter_events(all_events, name, kind)
+
+    if not filtered:
+        typer.echo("No events found")
+        return
+
+    for e in filtered:
+        obj = e.involved_object
+        typer.echo(
+            f"{e.type:8} {e.reason:30} "
+            f"{obj.kind:10} {e.metadata.creation_timestamp} "
+            f"{e.message}"
+        )
+
+
+@app.command()
+def logs(index: int):
+    """Stream logs for an indexed pod."""
+    name, namespace, kind = _state_fields(index)
+
+    if kind != "pod":
+        typer.echo("Logs are only supported on pods.")
+        raise typer.Exit(1)
+
+    args = ["logs", name, "-n", namespace]
+    typer.echo(run_kubectl(args))
+
+
+@app.command()
+def yaml(index: int):
+    """Print the raw YAML manifest for an indexed resource."""
+    name, namespace, kind = _state_fields(index)
+    typer.echo(run_kubectl(["get", kind, name, "-n", namespace, "-o", "yaml"]))
+
+
+@app.command()
+def delete(
+    index: int,
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+):
+    """Delete an indexed resource (prompts for confirmation unless --yes)."""
+    name, namespace, kind = _state_fields(index)
+    if not yes:
+        typer.confirm(f"Delete {kind}/{name} in {namespace}?", abort=True)
+    run_kubectl(["delete", kind, name, "-n", namespace])
+    typer.echo(f"Deleted {kind}/{name}")
+
+
+@app.command()
+def edit(index: int):
+    """Open an indexed resource in your editor via kubectl edit."""
+    name, namespace, kind = _state_fields(index)
+    run_kubectl_interactive(["edit", kind, name, "-n", namespace])
+
+
+@app.command(name="exec")
+def exec_cmd(
+    index: int,
+    cmd: list[str] = typer.Argument(default=None, help="Command to run (default: bash with sh fallback)"),
+):
+    """Open an interactive shell in an indexed pod (bash, falling back to sh)."""
+    name, namespace, kind = _state_fields(index)
+    if kind.lower() not in ("pod", "pods"):
+        typer.echo("exec is only supported for pods.")
+        raise typer.Exit(1)
+    if cmd:
+        run_kubectl_interactive(["exec", "-it", name, "-n", namespace, "--", *cmd])
+    else:
+        rc = run_kubectl_interactive(["exec", "-it", name, "-n", namespace, "--", "bash"])
+        if rc != 0:
+            run_kubectl_interactive(["exec", "-it", name, "-n", namespace, "--", "sh"])
+
+
+@app.command()
+def tree(index: int):
+    """Show the ownership graph for an indexed resource (deployments, statefulsets, etc.)."""
+    from kx.events import normalize_kind
+    from kx.graph import build_tree
+    from rich.console import Console
+
+    name, namespace, kind = _state_fields(index)
+    Console().print(build_tree(normalize_kind(kind), name, namespace))
+
+
+if __name__ == "__main__":
+    app()

kx/state.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass, asdict
+import json
+from pathlib import Path
+
+STATE_FILE = Path.home() / ".kx_state.json"
+
+
+@dataclass
+class KxState:
+    resource_type: str
+    names: list[str]
+    namespace: str = "default"
+
+
+def save_state(state: KxState) -> None:
+    STATE_FILE.write_text(json.dumps(asdict(state)))
+
+
+def load_state() -> KxState:
+    if not STATE_FILE.exists():
+        raise RuntimeError("No state found. Run `kx get <resource>` first.")
+    data = json.loads(STATE_FILE.read_text())
+    return KxState(**data)

kx_cli-0.0.1.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: kx-cli
+Version: 0.0.1
+Requires-Python: >=3.11
+Requires-Dist: typer
+Requires-Dist: kubernetes
+Requires-Dist: rich

kx_cli-0.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+kx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kx/events.py,sha256=yUBgELf7NhMTlLK86sRwN3QBPmAhEiumRnqmP0GV-Ag,1627
+kx/graph.py,sha256=jJy84CUY-x5r-1Lrz10I1w7DYRA2L54ycgaeJPo0bW0,2923
+kx/index.py,sha256=OofJB2sW53QmV5VZTSaVZ3p2-WWWj3EddDiOWF16LsU,1344
+kx/k8s.py,sha256=Q1dlnlFk-xRE7ZoViZdtZZEI76UUVHXoT9eARxbJqe0,158
+kx/kubectl.py,sha256=mq09eQgOPNiyqO564byiSAeNiVY0CLTDageqa47taNk,348
+kx/main.py,sha256=rIxN1uqs8fJYX_D4vp6c7vRwQ4vyz0VL9l1DPotXLNM,4998
+kx/state.py,sha256=W9puXcyiQCHSWp5JRhqB3puc6ktqjwTaegJRG-YBOT4,535
+kx_cli-0.0.1.dist-info/METADATA,sha256=g6KwISxwWno01JtEXyQ1khmWlqoIJi7ZaxIUaY6buBU,141
+kx_cli-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+kx_cli-0.0.1.dist-info/entry_points.txt,sha256=7FKIfh_28wCHnIO0TFsW70g2JqsoRsSTjIK161QYQwQ,35
+kx_cli-0.0.1.dist-info/top_level.txt,sha256=HMijR3s083ws0pe6Fso-IU3si7RWxFUEY7BCKg15G5E,3
+kx_cli-0.0.1.dist-info/RECORD,,

kx_cli-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

kx_cli-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kx = kx.main:app

kx_cli-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+kx