openk8s 1.0.1 → 1.0.3

package/src/lib/k8s/__tests__/resource-parser.test.ts

@@ -0,0 +1,455 @@
+import { describe, expect, test } from "bun:test";
+import {
+  asRecord,
+  asString,
+  asNumber,
+  asBoolean,
+  asArray,
+  asPort,
+  suggestedLocalPort,
+  summarizeLabels,
+  summarizeIngressHosts,
+  isPodKind,
+  normalizeKind,
+  supportsDirectPortForward,
+  flattenSections,
+  extractContainerPorts,
+  extractContainerNames,
+  formatContainerState,
+  formatValueFrom,
+  buildEnvLine,
+  formatEnvFromSource,
+  formatProbe,
+  formatVolumeSource,
+} from "../resource-parser";
+
+// ── Type guards ──────────────────────────────────────────────────────────────
+
+describe("asRecord", () => {
+  test("returns record for plain object", () => {
+    expect(asRecord({ a: 1 })).toEqual({ a: 1 });
+  });
+
+  test("returns undefined for null", () => {
+    expect(asRecord(null)).toBeUndefined();
+  });
+
+  test("returns undefined for array", () => {
+    expect(asRecord([1, 2])).toBeUndefined();
+  });
+
+  test("returns undefined for string", () => {
+    expect(asRecord("hello")).toBeUndefined();
+  });
+
+  test("returns undefined for number", () => {
+    expect(asRecord(42)).toBeUndefined();
+  });
+
+  test("returns undefined for undefined", () => {
+    expect(asRecord(undefined)).toBeUndefined();
+  });
+});
+
+describe("asString", () => {
+  test("returns string for non-empty string", () => {
+    expect(asString("hello")).toBe("hello");
+  });
+
+  test("returns undefined for empty string", () => {
+    expect(asString("")).toBeUndefined();
+  });
+
+  test("returns undefined for non-string", () => {
+    expect(asString(42)).toBeUndefined();
+  });
+});
+
+describe("asNumber", () => {
+  test("returns number for number", () => {
+    expect(asNumber(42)).toBe(42);
+  });
+
+  test("returns undefined for non-number", () => {
+    expect(asNumber("42")).toBeUndefined();
+  });
+
+  test("returns zero for zero", () => {
+    expect(asNumber(0)).toBe(0);
+  });
+});
+
+describe("asBoolean", () => {
+  test("returns true", () => {
+    expect(asBoolean(true)).toBe(true);
+  });
+
+  test("returns false", () => {
+    expect(asBoolean(false)).toBe(false);
+  });
+
+  test("returns undefined for non-boolean", () => {
+    expect(asBoolean("true")).toBeUndefined();
+  });
+});
+
+describe("asArray", () => {
+  test("returns array for array", () => {
+    expect(asArray([1, 2, 3])).toEqual([1, 2, 3]);
+  });
+
+  test("returns empty array for non-array", () => {
+    expect(asArray(null)).toEqual([]);
+    expect(asArray(undefined)).toEqual([]);
+    expect(asArray("hello")).toEqual([]);
+  });
+});
+
+// ── Port utilities ───────────────────────────────────────────────────────────
+
+describe("asPort", () => {
+  test("valid number port", () => {
+    expect(asPort(8080)).toBe(8080);
+  });
+
+  test("valid string port", () => {
+    expect(asPort("8080")).toBe(8080);
+  });
+
+  test("invalid port 0", () => {
+    expect(asPort(0)).toBeUndefined();
+  });
+
+  test("out of range port", () => {
+    expect(asPort(70000)).toBeUndefined();
+  });
+
+  test("non-numeric string", () => {
+    expect(asPort("abc")).toBeUndefined();
+  });
+});
+
+describe("suggestedLocalPort", () => {
+  test("maps 80 to 8080", () => {
+    expect(suggestedLocalPort(80)).toBe(8080);
+  });
+
+  test("maps 443 to 8443", () => {
+    expect(suggestedLocalPort(443)).toBe(8443);
+  });
+
+  test("keeps other ports unchanged", () => {
+    expect(suggestedLocalPort(3000)).toBe(3000);
+    expect(suggestedLocalPort(9090)).toBe(9090);
+    expect(suggestedLocalPort(22)).toBe(22);
+  });
+});
+
+// ── Label utilities ──────────────────────────────────────────────────────────
+
+describe("summarizeLabels", () => {
+  test("returns 'none' for empty labels", () => {
+    expect(summarizeLabels({})).toBe("none");
+  });
+
+  test("returns 'none' for undefined", () => {
+    expect(summarizeLabels(undefined)).toBe("none");
+  });
+
+  test("formats single label", () => {
+    expect(summarizeLabels({ app: "nginx" })).toBe("app=nginx");
+  });
+
+  test("formats multiple labels", () => {
+    expect(summarizeLabels({ app: "nginx", env: "prod", version: "1.0" })).toBe("app=nginx, env=prod, version=1.0");
+  });
+
+  test("limits to 6 labels", () => {
+    const labels = { a: "1", b: "2", c: "3", d: "4", e: "5", f: "6", g: "7" };
+    const result = summarizeLabels(labels);
+    expect(result).toBe("a=1, b=2, c=3, d=4, e=5, f=6");
+  });
+});
+
+describe("summarizeIngressHosts", () => {
+  test("returns undefined when no rules", () => {
+    expect(summarizeIngressHosts({})).toBeUndefined();
+  });
+
+  test("returns undefined when rules have no host", () => {
+    expect(summarizeIngressHosts({ rules: [{ http: { paths: [] } }] })).toBeUndefined();
+  });
+
+  test("formats single host", () => {
+    expect(summarizeIngressHosts({ rules: [{ host: "example.com" }] })).toBe("example.com");
+  });
+
+  test("formats multiple hosts", () => {
+    expect(summarizeIngressHosts({ rules: [{ host: "a.com" }, { host: "b.com" }] })).toBe("a.com, b.com");
+  });
+});
+
+// ── Kind helpers ─────────────────────────────────────────────────────────────
+
+describe("isPodKind", () => {
+  test("pod matches", () => expect(isPodKind("pod")).toBe(true));
+  test("pods matches", () => expect(isPodKind("pods")).toBe(true));
+  test("Pod matches", () => expect(isPodKind("Pod")).toBe(true));
+  test("POD matches", () => expect(isPodKind("POD")).toBe(true));
+  test("deployment does not match", () => expect(isPodKind("deployment")).toBe(false));
+  test("service does not match", () => expect(isPodKind("service")).toBe(false));
+});
+
+describe("normalizeKind", () => {
+  test("lowercases", () => expect(normalizeKind("Deployment")).toBe("deployment"));
+  test("trims whitespace", () => expect(normalizeKind("  Pod  ")).toBe("pod"));
+});
+
+describe("supportsDirectPortForward", () => {
+  const supported = ["pod", "pods", "service", "services", "deployment", "deployments",
+    "replicaset", "replicasets", "statefulset", "statefulsets"];
+
+  for (const kind of supported) {
+    test(`${kind} is supported`, () => expect(supportsDirectPortForward(kind)).toBe(true));
+  }
+
+  test("ingress is not supported", () => expect(supportsDirectPortForward("ingress")).toBe(false));
+  test("configmap is not supported", () => expect(supportsDirectPortForward("configmap")).toBe(false));
+});
+
+// ── Flatten sections ─────────────────────────────────────────────────────────
+
+describe("flattenSections", () => {
+  test("flattens sections with string lines", () => {
+    const sections = [
+      { title: "Overview", lines: ["kind: Pod", "name: test"] },
+      { title: "Containers", lines: ["nginx image nginx"] },
+    ];
+    const result = flattenSections(sections);
+    expect(result).toEqual([
+      "Overview",
+      "  kind: Pod",
+      "  name: test",
+      "Containers",
+      "  nginx image nginx",
+    ]);
+  });
+
+  test("handles structured lines", () => {
+    const sections = [
+      {
+        title: "Environment",
+        lines: [{ id: "e1", text: "KEY=value" }],
+      },
+    ];
+    const result = flattenSections(sections);
+    expect(result).toEqual(["Environment", "  KEY=value"]);
+  });
+});
+
+// ── Container parsing ────────────────────────────────────────────────────────
+
+describe("extractContainerPorts", () => {
+  test("extracts ports from containers", () => {
+    const spec = {
+      containers: [
+        { ports: [{ containerPort: 80 }, { containerPort: 443 }] },
+        { ports: [{ containerPort: 8080 }] },
+      ],
+    };
+    const ports = extractContainerPorts(spec);
+    expect(ports).toEqual(expect.arrayContaining([80, 443, 8080]));
+    expect(ports).toHaveLength(3);
+  });
+
+  test("deduplicates ports", () => {
+    const spec = {
+      containers: [
+        { ports: [{ containerPort: 80 }] },
+        { ports: [{ containerPort: 80 }] },
+      ],
+    };
+    const ports = extractContainerPorts(spec);
+    expect(ports).toEqual([80]);
+  });
+
+  test("returns empty for no containers", () => {
+    expect(extractContainerPorts({})).toEqual([]);
+    expect(extractContainerPorts(null)).toEqual([]);
+  });
+});
+
+describe("extractContainerNames", () => {
+  test("extracts container names", () => {
+    const spec = {
+      containers: [{ name: "nginx" }, { name: "sidecar" }],
+    };
+    expect(extractContainerNames(spec)).toEqual(["nginx", "sidecar"]);
+  });
+
+  test("returns empty for no containers", () => {
+    expect(extractContainerNames({})).toEqual([]);
+    expect(extractContainerNames(null)).toEqual([]);
+  });
+});
+
+// ── Formatting functions ─────────────────────────────────────────────────────
+
+describe("formatContainerState", () => {
+  test("running state", () => {
+    expect(formatContainerState({ running: {} })).toBe("running");
+  });
+
+  test("waiting state with reason", () => {
+    expect(formatContainerState({ waiting: { reason: "CrashLoopBackOff" } })).toBe("waiting (CrashLoopBackOff)");
+  });
+
+  test("waiting state without reason", () => {
+    expect(formatContainerState({ waiting: {} })).toBe("waiting (unknown)");
+  });
+
+  test("terminated state with reason", () => {
+    expect(formatContainerState({ terminated: { reason: "Completed" } })).toBe("terminated (Completed)");
+  });
+
+  test("undefined state", () => {
+    expect(formatContainerState(undefined)).toBe("waiting");
+  });
+
+  test("null state", () => {
+    expect(formatContainerState(null)).toBe("waiting");
+  });
+});
+
+describe("formatValueFrom", () => {
+  test("fieldRef", () => {
+    expect(formatValueFrom({ fieldRef: { fieldPath: "metadata.name" } })).toBe("field:metadata.name");
+  });
+
+  test("resourceFieldRef", () => {
+    expect(formatValueFrom({ resourceFieldRef: { resource: "limits.cpu" } })).toBe("resource:limits.cpu");
+  });
+
+  test("configMapKeyRef", () => {
+    expect(formatValueFrom({ configMapKeyRef: { name: "myconfig", key: "mykey" } })).toBe("configmap:myconfig/mykey");
+  });
+
+  test("secretKeyRef", () => {
+    expect(formatValueFrom({ secretKeyRef: { name: "mysecret", key: "password" } })).toBe("secret:mysecret/password");
+  });
+
+  test("undefined valueFrom", () => {
+    expect(formatValueFrom(undefined)).toBe("-");
+  });
+});
+
+describe("buildEnvLine", () => {
+  test("builds non-revealable line", () => {
+    const line = buildEnvLine("env:1", "KEY=value");
+    expect(line).toEqual({ id: "env:1", text: "KEY=value" });
+  });
+
+  test("builds revealable line with secret ref", () => {
+    const line = buildEnvLine("env:2", "KEY=*****", "secret:mysecret/password", { name: "mysecret", key: "password" });
+    expect(line).toEqual({
+      id: "env:2",
+      text: "KEY=*****",
+      revealedText: "secret:mysecret/password",
+      revealable: true,
+      secretRef: { name: "mysecret", key: "password" },
+    });
+  });
+
+  test("builds revealable line without key in secret ref", () => {
+    const line = buildEnvLine("env:3", "envFrom: secret/s", "envFrom: secret/s (all keys imported)", { name: "s" });
+    expect(line).toEqual({
+      id: "env:3",
+      text: "envFrom: secret/s",
+      revealedText: "envFrom: secret/s (all keys imported)",
+      revealable: true,
+      secretRef: { name: "s" },
+    });
+  });
+});
+
+describe("formatEnvFromSource", () => {
+  test("configMapRef", () => {
+    expect(formatEnvFromSource({ configMapRef: { name: "myconfig" } })).toBe("configmap:myconfig");
+  });
+
+  test("configMapRef with prefix", () => {
+    expect(formatEnvFromSource({ prefix: "PREFIX_", configMapRef: { name: "myconfig" } })).toBe("PREFIX_ <= configmap:myconfig");
+  });
+
+  test("secretRef", () => {
+    expect(formatEnvFromSource({ secretRef: { name: "mysecret" } })).toBe("secret:mysecret");
+  });
+
+  test("unknown source", () => {
+    expect(formatEnvFromSource({})).toBe("-");
+  });
+
+  test("undefined", () => {
+    expect(formatEnvFromSource(undefined)).toBe("-");
+  });
+});
+
+describe("formatProbe", () => {
+  test("disabled when no probe", () => {
+    expect(formatProbe(undefined)).toBe("disabled");
+  });
+
+  test("httpGet probe", () => {
+    expect(formatProbe({ httpGet: { path: "/healthz", port: 8080 } })).toBe("http /healthz port 8080");
+  });
+
+  test("tcp socket probe", () => {
+    expect(formatProbe({ tcpSocket: { port: 3306 } })).toBe("tcp port 3306");
+  });
+
+  test("exec probe", () => {
+    expect(formatProbe({ exec: { command: ["cat", "/tmp/healthy"] } })).toBe("exec cat /tmp/healthy");
+  });
+
+  test("grpc probe", () => {
+    expect(formatProbe({ grpc: { port: 50051 } })).toBe("grpc port 50051");
+  });
+
+  test("configured fallback", () => {
+    expect(formatProbe({})).toBe("configured");
+  });
+});
+
+describe("formatVolumeSource", () => {
+  test("configMap", () => {
+    expect(formatVolumeSource({ configMap: { name: "myconfig" } })).toBe("configmap:myconfig");
+  });
+
+  test("secret", () => {
+    expect(formatVolumeSource({ secret: { secretName: "mysecret" } })).toBe("secret:mysecret");
+  });
+
+  test("persistentVolumeClaim", () => {
+    expect(formatVolumeSource({ persistentVolumeClaim: { claimName: "mypvc" } })).toBe("pvc:mypvc");
+  });
+
+  test("projected", () => {
+    expect(formatVolumeSource({ projected: {} })).toBe("projected");
+  });
+
+  test("emptyDir", () => {
+    expect(formatVolumeSource({ emptyDir: {} })).toBe("emptyDir");
+  });
+
+  test("downwardAPI", () => {
+    expect(formatVolumeSource({ downwardAPI: {} })).toBe("downwardAPI");
+  });
+
+  test("unknown", () => {
+    expect(formatVolumeSource({})).toBe("other");
+  });
+
+  test("undefined", () => {
+    expect(formatVolumeSource(undefined)).toBe("unknown");
+  });
+});

package/src/lib/k8s/detail-builders/event-builder.ts

@@ -0,0 +1,21 @@
+import type { ResourceDetailSection } from "../types";
+import type { KubernetesResource } from "../resource-parser";
+
+export function buildEventSections(resource: KubernetesResource): ResourceDetailSection[] {
+  const raw = resource as unknown as Record<string, unknown>;
+  const involvedObject = (raw.involvedObject ?? {}) as Record<string, unknown>;
+  const source = (raw.source ?? {}) as Record<string, unknown>;
+
+  const lines = [
+    `type: ${String(raw.type ?? "-")}`,
+    `reason: ${String(raw.reason ?? "-")}`,
+    `message: ${String(raw.message ?? "-")}`,
+    `count: ${String(raw.count ?? "-")}`,
+    `firstTimestamp: ${String(raw.firstTimestamp ?? "-")}`,
+    `lastTimestamp: ${String(raw.lastTimestamp ?? "-")}`,
+    `source: ${String(source.component ?? raw.reportingComponent ?? "-")}`,
+    `involvedObject: ${String(involvedObject.kind ?? "-")}/${String(involvedObject.name ?? "-")}  ns: ${String(involvedObject.namespace ?? "-")}`,
+  ];
+
+  return [{ title: "Event", lines }];
+}

package/src/lib/k8s/detail-builders/hpa-cronjob-builder.ts

@@ -0,0 +1,63 @@
+import { asArray, asBoolean, asNumber, asRecord, asString } from "../resource-parser";
+import type { ResourceDetailSection } from "../types";
+import type { KubernetesResource } from "../resource-parser";
+
+export function buildHpaSections(resource: KubernetesResource): ResourceDetailSection[] {
+  const spec = resource.spec ?? {};
+  const status = resource.status ?? {};
+
+  const scaleTargetRef = (spec.scaleTargetRef ?? {}) as Record<string, unknown>;
+  const lines = [
+    `scaleTargetRef: ${String(scaleTargetRef.kind ?? "-")}/${String(scaleTargetRef.name ?? "-")}`,
+    `minReplicas: ${String(spec.minReplicas ?? "-")}`,
+    `maxReplicas: ${String(spec.maxReplicas ?? "-")}`,
+    `currentReplicas: ${String(status.currentReplicas ?? "-")}`,
+    `desiredReplicas: ${String(status.desiredReplicas ?? "-")}`,
+  ];
+
+  const conditions = asArray(status.conditions)
+    .map((c) => asRecord(c))
+    .filter((c): c is Record<string, unknown> => c !== undefined)
+    .map((c) => `${asString(c.type) ?? "Condition"}: ${asString(c.status) ?? "-"} — ${asString(c.message) ?? ""}`);
+
+  const metrics = asArray(status.currentMetrics)
+    .map((m) => asRecord(m))
+    .filter((m): m is Record<string, unknown> => m !== undefined)
+    .map((m) => {
+      const type = asString(m.type) ?? "metric";
+      const resource = asRecord(m.resource);
+      if (resource) {
+        const current = asRecord(resource.current);
+        return `${type}/${String(resource.name ?? "-")}: ${String(current?.averageUtilization ?? current?.averageValue ?? "-")}`;
+      }
+      return type;
+    });
+
+  return [
+    { title: "HPA", lines },
+    ...(conditions.length > 0 ? [{ title: "Conditions", lines: conditions }] : []),
+    ...(metrics.length > 0 ? [{ title: "Current Metrics", lines: metrics }] : []),
+  ];
+}
+
+export function buildCronJobSections(resource: KubernetesResource): ResourceDetailSection[] {
+  const spec = resource.spec ?? {};
+  const status = resource.status ?? {};
+
+  const activeJobs = asArray(status.active).map((j) => {
+    const ref = asRecord(j);
+    return ref ? `${String(ref.kind ?? "Job")}/${String(ref.name ?? "-")}` : "-";
+  });
+
+  const lines = [
+    `schedule: ${asString(spec.schedule) ?? "-"}`,
+    `suspend: ${String(asBoolean(spec.suspend) ?? false)}`,
+    `lastScheduleTime: ${asString(status.lastScheduleTime as unknown) ?? "-"}`,
+    `concurrencyPolicy: ${asString(spec.concurrencyPolicy) ?? "-"}`,
+    `successfulJobsHistoryLimit: ${String(asNumber(spec.successfulJobsHistoryLimit) ?? "-")}`,
+    `failedJobsHistoryLimit: ${String(asNumber(spec.failedJobsHistoryLimit) ?? "-")}`,
+    ...(activeJobs.length > 0 ? [`active: ${activeJobs.join(", ")}`] : []),
+  ];
+
+  return [{ title: "CronJob", lines }];
+}

package/src/lib/k8s/detail-builders/node-builder.ts

@@ -0,0 +1,41 @@
+import { asArray, asRecord, asString } from "../resource-parser";
+import type { ResourceDetailSection } from "../types";
+import type { KubernetesResource } from "../resource-parser";
+
+export function buildNodeSections(resource: KubernetesResource): ResourceDetailSection[] {
+  const status = resource.status ?? {};
+  const raw = resource as unknown as Record<string, unknown>;
+
+  const nodeInfo = (status.nodeInfo ?? {}) as Record<string, unknown>;
+  const capacity = (status.capacity ?? {}) as Record<string, unknown>;
+  const allocatable = (status.allocatable ?? {}) as Record<string, unknown>;
+
+  const infoLines = [
+    `kubeletVersion: ${String(nodeInfo.kubeletVersion ?? "-")}`,
+    `containerRuntime: ${String(nodeInfo.containerRuntimeVersion ?? "-")}`,
+    `osImage: ${String(nodeInfo.osImage ?? "-")}`,
+    `architecture: ${String(nodeInfo.architecture ?? "-")}`,
+  ];
+
+  const capacityLines = Object.entries(capacity).map(([k, v]) => {
+    const alloc = allocatable[k];
+    return alloc !== undefined ? `${k}: ${String(v)} (allocatable: ${String(alloc)})` : `${k}: ${String(v)}`;
+  });
+
+  const conditions = asArray(status.conditions)
+    .map((c) => asRecord(c))
+    .filter((c): c is Record<string, unknown> => c !== undefined)
+    .map((c) => `${asString(c.type) ?? "Condition"}: ${asString(c.status) ?? "-"}  ${asString(c.reason) ?? ""}`);
+
+  const taints = asArray((raw.spec as Record<string, unknown> | undefined)?.taints)
+    .map((t) => asRecord(t))
+    .filter((t): t is Record<string, unknown> => t !== undefined)
+    .map((t) => `${asString(t.key) ?? "key"}:${asString(t.effect) ?? "NoSchedule"}${t.value ? `=${String(t.value)}` : ""}`);
+
+  return [
+    { title: "Node Info", lines: infoLines },
+    ...(capacityLines.length > 0 ? [{ title: "Capacity / Allocatable", lines: capacityLines }] : []),
+    ...(conditions.length > 0 ? [{ title: "Conditions", lines: conditions }] : []),
+    ...(taints.length > 0 ? [{ title: "Taints", lines: taints }] : []),
+  ];
+}

package/src/lib/k8s/detail-builders/overview-builder.ts

@@ -0,0 +1,103 @@
+import {
+  asArray, asNumber, asPort, asRecord, asString,
+  extractContainerNames, isPodKind, normalizeKind,
+  suggestedLocalPort, summarizeIngressHosts, summarizeLabels,
+} from "../resource-parser";
+import type { ResourceDetailSection, ResourceKind, ResourcePortForward } from "../types";
+import type { KubernetesResource } from "../resource-parser";
+
+export function buildPortForward(
+  resourceKind: ResourceKind | undefined,
+  resource: KubernetesResource,
+): ResourcePortForward[] {
+  const kindName = resource.kind ?? resourceKind?.name ?? "unknown";
+
+  if (!supportsDirectPortForward(kindName)) {
+    return [];
+  }
+
+  const spec = resource.spec ?? {};
+  let remotePorts: number[];
+
+  if (["service", "services"].includes(normalizeKind(kindName))) {
+    remotePorts = asArray(spec.ports)
+      .map((port) => asPort(asRecord(port)?.port))
+      .filter((port): port is number => port !== undefined);
+  } else if (isPodKind(kindName)) {
+    remotePorts = extractContainerPortsFromSpec(spec);
+  } else {
+    remotePorts = extractContainerPortsFromSpec(asRecord(spec.template)?.spec);
+  }
+
+  return remotePorts.map((remotePort) => ({
+    localPort: suggestedLocalPort(remotePort),
+    remotePort,
+  }));
+}
+
+function extractContainerPortsFromSpec(specValue: unknown): number[] {
+  const spec = asRecord(specValue);
+  if (!spec) return [];
+  return asArray(spec.containers)
+    .map((container) => asRecord(container))
+    .filter((c): c is Record<string, unknown> => c !== undefined)
+    .flatMap((c) => asArray(c.ports).map((p) => asPort(asRecord(p)?.containerPort)).filter((p): p is number => p !== undefined));
+}
+
+function supportsDirectPortForward(kind: string): boolean {
+  const normalized = normalizeKind(kind);
+  return ["pod", "pods", "service", "services", "deployment", "deployments", "replicaset", "replicasets", "statefulset", "statefulsets"].includes(normalized);
+}
+
+export function buildOverviewSection(
+  resourceKind: ResourceKind | undefined,
+  resource: KubernetesResource,
+): { section: ResourceDetailSection; replicas?: number | undefined } {
+  const metadata = resource.metadata ?? {};
+  const status = resource.status ?? {};
+  const spec = resource.spec ?? {};
+
+  const lines = [
+    `kind: ${resource.kind ?? resourceKind?.name ?? "unknown"}`,
+    `apiVersion: ${resource.apiVersion ?? "unknown"}`,
+    `name: ${metadata.name ?? "unknown"}`,
+    `namespace: ${metadata.namespace ?? (resourceKind?.namespaced ? "default" : "cluster")}`,
+    `created: ${metadata.creationTimestamp ?? "unknown"}`,
+    `labels: ${summarizeLabels(metadata.labels)}`,
+  ];
+
+  const replicas = asNumber(spec.replicas);
+  if (replicas !== undefined) lines.push(`replicas: ${replicas}`);
+
+  const readyReplicas = asNumber(status.readyReplicas);
+  if (readyReplicas !== undefined) lines.push(`readyReplicas: ${readyReplicas}`);
+
+  const phase = asString(status.phase);
+  if (phase) lines.push(`phase: ${phase}`);
+
+  const qosClass = asString(status.qosClass);
+  if (qosClass) lines.push(`qos: ${qosClass}`);
+
+  const clusterIP = asString(spec.clusterIP);
+  if (clusterIP) lines.push(`clusterIP: ${clusterIP}`);
+
+  const nodeName = asString(spec.nodeName);
+  if (nodeName) lines.push(`node: ${nodeName}`);
+
+  const podIP = asString(status.podIP);
+  if (podIP) lines.push(`podIP: ${podIP}`);
+
+  const hostIP = asString(status.hostIP);
+  if (hostIP) lines.push(`hostIP: ${hostIP}`);
+
+  const serviceAccount = asString(spec.serviceAccountName);
+  if (serviceAccount) lines.push(`serviceAccount: ${serviceAccount}`);
+
+  const completions = asNumber(status.succeeded);
+  if (completions !== undefined) lines.push(`succeeded: ${completions}`);
+
+  const ingressHosts = summarizeIngressHosts(spec);
+  if (ingressHosts) lines.push(`hosts: ${ingressHosts}`);
+
+  return { section: { title: "Overview", lines }, replicas };
+}