kubeagent 0.1.0

package/dist/diagnoser/index.js

@@ -0,0 +1,251 @@
+import chalk from "chalk";
+import readline from "node:readline";
+import { buildSystemPrompt } from "../kb/loader.js";
+import { loadAuth } from "../auth.js";
+import { proxyRequest } from "../proxy-client.js";
+import { dbg } from "../debug.js";
+import { getLogs, describeResource, restartPod, rolloutRestart, scaleDeployment, getEvents, setResources, kubectlGetLogsSchema, kubectlDescribeSchema, restartPodSchema, rolloutRestartSchema, scaleDeploymentSchema, getEventsSchema, setResourcesSchema, } from "./tools.js";
+import { zodToJsonSchema } from "zod-to-json-schema";
+const MAX_TOOL_OUTPUT_CHARS = 8000;
+const HAIKU = "claude-haiku-4-5-20251001";
+const SONNET = "claude-sonnet-4-6";
+function selectModel(issues) {
+    if (issues.some((i) => i.kind === "node_not_ready" || i.kind === "node_pressure"))
+        return SONNET;
+    if (issues.length >= 3)
+        return SONNET;
+    const maxRestarts = Math.max(0, ...issues.map((i) => i.details.restartCount ?? 0));
+    if (maxRestarts > 20)
+        return SONNET;
+    if (issues.filter((i) => i.kind === "pod_oom").length >= 2)
+        return SONNET;
+    return HAIKU;
+}
+async function createMessage(params) {
+    const auth = loadAuth();
+    if (!auth?.apiKey) {
+        throw new Error("Not logged in. Run 'kubeagent login' to get started.");
+    }
+    const result = await proxyRequest(auth, params);
+    return result;
+}
+function truncateOutput(output) {
+    if (output.length <= MAX_TOOL_OUTPUT_CHARS)
+        return output;
+    const half = Math.floor(MAX_TOOL_OUTPUT_CHARS / 2);
+    return output.slice(0, half) + "\n\n... [truncated] ...\n\n" + output.slice(-half);
+}
+async function askUserQuestion(question, choices) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        let prompt = `\n${chalk.cyan("?")} ${chalk.bold(question)}\n`;
+        if (choices && choices.length > 0) {
+            choices.forEach((c, i) => {
+                prompt += `  ${chalk.dim(`${i + 1}.`)} ${c}\n`;
+            });
+            prompt += chalk.dim(`Enter number (1-${choices.length}) or type your own answer: `);
+        }
+        else {
+            prompt += chalk.dim("> ");
+        }
+        rl.question(prompt, (answer) => {
+            rl.close();
+            const trimmed = answer.trim();
+            if (choices && choices.length > 0) {
+                const idx = parseInt(trimmed, 10) - 1;
+                if (idx >= 0 && idx < choices.length) {
+                    resolve(choices[idx]);
+                    return;
+                }
+            }
+            resolve(trimmed || "(no answer provided)");
+        });
+    });
+}
+function makeToolDefs() {
+    return [
+        {
+            name: "ask_user_question",
+            description: "Ask the user a clarifying question. Use when context is needed before diagnosing — e.g., a resource doesn't match any known deployment, or you need to know if an issue is intentional. Provide `choices` for multiple-choice questions, or omit for open-ended input.",
+            input_schema: {
+                type: "object",
+                properties: {
+                    question: { type: "string", description: "The question to ask the user" },
+                    choices: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Optional list of choices. If provided, the user picks by number or types a free-form answer.",
+                    },
+                },
+                required: ["question"],
+            },
+        },
+        {
+            name: "get_logs",
+            description: "Get logs from a pod. Use to investigate errors, crashes, OOM kills.",
+            input_schema: zodToJsonSchema(kubectlGetLogsSchema),
+        },
+        {
+            name: "describe_resource",
+            description: "Describe a Kubernetes resource (pod, deployment, service, node). Shows events, conditions, configuration.",
+            input_schema: zodToJsonSchema(kubectlDescribeSchema),
+        },
+        {
+            name: "restart_pod",
+            description: "Delete a pod. If the pod is owned by a Deployment or DaemonSet it will be recreated; orphan pods are permanently deleted. Requires user approval.",
+            input_schema: zodToJsonSchema(restartPodSchema),
+        },
+        {
+            name: "rollout_restart",
+            description: "Rollout restart a deployment. Requires user approval.",
+            input_schema: zodToJsonSchema(rolloutRestartSchema),
+        },
+        {
+            name: "scale_deployment",
+            description: "Scale a deployment to a specific number of replicas. Scaling to 0 requires approval.",
+            input_schema: zodToJsonSchema(scaleDeploymentSchema),
+        },
+        {
+            name: "get_events",
+            description: "Get recent events in a namespace. Useful for understanding what happened.",
+            input_schema: zodToJsonSchema(getEventsSchema),
+        },
+        {
+            name: "set_resources",
+            description: "Change CPU/memory requests and limits on a deployment. Triggers a rolling restart. Requires user approval.",
+            input_schema: zodToJsonSchema(setResourcesSchema),
+        },
+    ];
+}
+function makeToolExecutors(noInteractive, onQuestion) {
+    return {
+        ask_user_question: async (input) => {
+            const { question, choices } = input;
+            // Always broadcast to notification channels so remote users see the question
+            await onQuestion?.(question, choices);
+            if (noInteractive) {
+                return `[non-interactive mode] Unable to ask: "${question}" — proceed with best judgement using available data only.`;
+            }
+            return askUserQuestion(question, choices);
+        },
+        get_logs: (input, ctx) => getLogs(input, ctx),
+        describe_resource: (input, ctx) => describeResource(input, ctx),
+        restart_pod: (input, ctx) => restartPod(input, ctx),
+        rollout_restart: (input, ctx) => rolloutRestart(input, ctx),
+        scale_deployment: (input, ctx) => scaleDeployment(input, ctx),
+        get_events: (input, ctx) => getEvents(input, ctx),
+        set_resources: (input, ctx) => setResources(input, ctx),
+    };
+}
+export async function diagnose(issues, kbDir, clusterContext, options) {
+    const systemPrompt = buildSystemPrompt(kbDir);
+    const tools = makeToolDefs();
+    const issuesSummary = issues
+        .map((i) => `[${i.severity}] ${i.kind}: ${i.message}`)
+        .join("\n");
+    const userMessage = `The following issues were detected in the cluster:
+
+${issuesSummary}
+
+Please:
+1. Investigate using the available tools (get logs, describe resources, check events)
+2. Determine the root cause
+3. Propose a fix
+4. Define a verification contract — what should be true after the fix is applied
+
+If the fix is a safe action (restart, scale up), apply it directly.
+If it requires a risky action (rollback, delete, scale to zero), propose it but do not apply.`;
+    const messages = [
+        { role: "user", content: userMessage },
+    ];
+    const toolExecutors = makeToolExecutors(options?.noInteractive ?? false, options?.onQuestion);
+    const mutatingTools = new Set(["restart_pod", "rollout_restart", "scale_deployment", "set_resources"]);
+    // Merge hardcoded read-only safe tools with user-configured safe actions
+    const effectiveSafeActions = new Set([
+        ...["get_logs", "get_events", "describe_resource", "ask_user_question"],
+        ...(options?.safeActions ?? []),
+    ]);
+    let appliedAction;
+    const model = selectModel(issues);
+    dbg("model", `selected ${model} for ${issues.length} issue(s): ${issues.map(i => i.kind).join(", ")}`);
+    // Agentic loop
+    let lastResponse;
+    for (let turn = 0; turn < 10; turn++) {
+        const params = {
+            model,
+            max_tokens: 16000,
+            system: systemPrompt,
+            tools,
+            messages,
+        };
+        // adaptive thinking only supported on Sonnet+, not Haiku
+        if (model === SONNET) {
+            params.thinking = { type: "adaptive" };
+        }
+        const response = await createMessage(params);
+        lastResponse = response;
+        if (response.stop_reason === "end_turn")
+            break;
+        if (response.stop_reason === "tool_use") {
+            messages.push({ role: "assistant", content: response.content });
+            const toolResults = [];
+            for (const block of response.content) {
+                if (block.type === "tool_use") {
+                    const executor = toolExecutors[block.name];
+                    if (!executor) {
+                        toolResults.push({
+                            type: "tool_result",
+                            tool_use_id: block.id,
+                            content: `Unknown tool: ${block.name}`,
+                            is_error: true,
+                        });
+                        continue;
+                    }
+                    // Check if action requires approval
+                    if (!effectiveSafeActions.has(block.name) && options?.onApproval) {
+                        const approved = await options.onApproval(block.name, block.input);
+                        if (!approved) {
+                            toolResults.push({
+                                type: "tool_result",
+                                tool_use_id: block.id,
+                                content: "Action denied by user. Propose an alternative.",
+                            });
+                            continue;
+                        }
+                    }
+                    try {
+                        const result = await executor(block.input, { context: clusterContext });
+                        // Track mutating actions for the verifier
+                        if (mutatingTools.has(block.name)) {
+                            appliedAction = {
+                                name: block.name,
+                                safe: effectiveSafeActions.has(block.name),
+                                params: block.input,
+                            };
+                        }
+                        toolResults.push({
+                            type: "tool_result",
+                            tool_use_id: block.id,
+                            content: truncateOutput(result),
+                        });
+                    }
+                    catch (err) {
+                        toolResults.push({
+                            type: "tool_result",
+                            tool_use_id: block.id,
+                            content: `Error: ${err.message}`,
+                            is_error: true,
+                        });
+                    }
+                }
+            }
+            messages.push({ role: "user", content: toolResults });
+        }
+    }
+    // Extract final text
+    const analysis = lastResponse?.content
+        .filter((b) => b.type === "text")
+        .map((b) => b.text)
+        .join("\n") ?? "No analysis produced.";
+    return { analysis, action: appliedAction };
+}

package/dist/diagnoser/tools.d.ts

@@ -0,0 +1,119 @@
+import { z } from "zod";
+export declare const safeActions: Set<string>;
+export declare const riskyActions: Set<string>;
+export declare function isActionSafe(action: string): boolean;
+export declare const kubectlGetLogsSchema: z.ZodObject<{
+    namespace: z.ZodString;
+    pod: z.ZodString;
+    container: z.ZodOptional<z.ZodString>;
+    tail: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    namespace: string;
+    pod: string;
+    tail: number;
+    container?: string | undefined;
+}, {
+    namespace: string;
+    pod: string;
+    container?: string | undefined;
+    tail?: number | undefined;
+}>;
+export declare const kubectlDescribeSchema: z.ZodObject<{
+    namespace: z.ZodString;
+    resource_type: z.ZodEnum<["pod", "deployment", "service", "statefulset", "daemonset", "replicaset", "job", "cronjob", "ingress", "node", "persistentvolumeclaim", "configmap", "endpoints"]>;
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    namespace: string;
+    resource_type: "pod" | "deployment" | "service" | "statefulset" | "daemonset" | "replicaset" | "job" | "cronjob" | "ingress" | "node" | "persistentvolumeclaim" | "configmap" | "endpoints";
+}, {
+    name: string;
+    namespace: string;
+    resource_type: "pod" | "deployment" | "service" | "statefulset" | "daemonset" | "replicaset" | "job" | "cronjob" | "ingress" | "node" | "persistentvolumeclaim" | "configmap" | "endpoints";
+}>;
+export declare const restartPodSchema: z.ZodObject<{
+    namespace: z.ZodString;
+    pod: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    namespace: string;
+    pod: string;
+}, {
+    namespace: string;
+    pod: string;
+}>;
+export declare const rolloutRestartSchema: z.ZodObject<{
+    namespace: z.ZodString;
+    deployment: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    namespace: string;
+    deployment: string;
+}, {
+    namespace: string;
+    deployment: string;
+}>;
+export declare const scaleDeploymentSchema: z.ZodObject<{
+    namespace: z.ZodString;
+    deployment: z.ZodString;
+    replicas: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    namespace: string;
+    deployment: string;
+    replicas: number;
+}, {
+    namespace: string;
+    deployment: string;
+    replicas: number;
+}>;
+export declare const getEventsSchema: z.ZodObject<{
+    namespace: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    namespace: string;
+}, {
+    namespace: string;
+}>;
+export declare const setResourcesSchema: z.ZodObject<{
+    namespace: z.ZodString;
+    deployment: z.ZodString;
+    container: z.ZodOptional<z.ZodString>;
+    memory_request: z.ZodOptional<z.ZodString>;
+    memory_limit: z.ZodOptional<z.ZodString>;
+    cpu_request: z.ZodOptional<z.ZodString>;
+    cpu_limit: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    namespace: string;
+    deployment: string;
+    container?: string | undefined;
+    memory_request?: string | undefined;
+    memory_limit?: string | undefined;
+    cpu_request?: string | undefined;
+    cpu_limit?: string | undefined;
+}, {
+    namespace: string;
+    deployment: string;
+    container?: string | undefined;
+    memory_request?: string | undefined;
+    memory_limit?: string | undefined;
+    cpu_request?: string | undefined;
+    cpu_limit?: string | undefined;
+}>;
+export declare function getLogs(input: z.infer<typeof kubectlGetLogsSchema>, context?: {
+    context?: string;
+}): Promise<string>;
+export declare function describeResource(input: z.infer<typeof kubectlDescribeSchema>, context?: {
+    context?: string;
+}): Promise<string>;
+export declare function restartPod(input: z.infer<typeof restartPodSchema>, context?: {
+    context?: string;
+}): Promise<string>;
+export declare function rolloutRestart(input: z.infer<typeof rolloutRestartSchema>, context?: {
+    context?: string;
+}): Promise<string>;
+export declare function scaleDeployment(input: z.infer<typeof scaleDeploymentSchema>, context?: {
+    context?: string;
+}): Promise<string>;
+export declare function getEvents(input: z.infer<typeof getEventsSchema>, context?: {
+    context?: string;
+}): Promise<string>;
+export declare function setResources(input: z.infer<typeof setResourcesSchema>, context?: {
+    context?: string;
+}): Promise<string>;

package/dist/diagnoser/tools.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { kubectl } from "../kubectl.js";
+export const safeActions = new Set([
+    "get_logs",
+    "get_events",
+    "describe_resource",
+    "ask_user_question",
+]);
+export const riskyActions = new Set([
+    "scale_deployment",
+    "set_resources",
+    "rollback_deployment",
+    "scale_to_zero",
+    "delete_resource",
+    "edit_configmap",
+    "apply_manifest",
+]);
+export function isActionSafe(action) {
+    return safeActions.has(action);
+}
+// Tool input schemas for Claude API
+export const kubectlGetLogsSchema = z.object({
+    namespace: z.string().describe("Kubernetes namespace"),
+    pod: z.string().describe("Pod name"),
+    container: z.string().optional().describe("Container name (if multi-container pod)"),
+    tail: z.number().default(50).describe("Number of log lines to return"),
+});
+const ALLOWED_RESOURCE_TYPES = [
+    "pod", "deployment", "service", "statefulset", "daemonset",
+    "replicaset", "job", "cronjob", "ingress", "node",
+    "persistentvolumeclaim", "configmap", "endpoints",
+];
+export const kubectlDescribeSchema = z.object({
+    namespace: z.string().describe("Kubernetes namespace"),
+    resource_type: z.enum(ALLOWED_RESOURCE_TYPES).describe("Resource type to describe"),
+    name: z.string().describe("Resource name"),
+});
+export const restartPodSchema = z.object({
+    namespace: z.string().describe("Kubernetes namespace"),
+    pod: z.string().describe("Pod name to delete (deployment will recreate it)"),
+});
+export const rolloutRestartSchema = z.object({
+    namespace: z.string().describe("Kubernetes namespace"),
+    deployment: z.string().describe("Deployment name to rollout restart"),
+});
+export const scaleDeploymentSchema = z.object({
+    namespace: z.string().describe("Kubernetes namespace"),
+    deployment: z.string().describe("Deployment name"),
+    replicas: z.number().min(0).max(20).describe("Target replica count"),
+});
+export const getEventsSchema = z.object({
+    namespace: z.string().describe("Kubernetes namespace"),
+});
+export const setResourcesSchema = z.object({
+    namespace: z.string().describe("Kubernetes namespace"),
+    deployment: z.string().describe("Deployment name"),
+    container: z.string().optional().describe("Container name (omit for single-container pods)"),
+    memory_request: z.string().optional().describe("Memory request e.g. '128Mi'"),
+    memory_limit: z.string().optional().describe("Memory limit e.g. '512Mi'"),
+    cpu_request: z.string().optional().describe("CPU request e.g. '100m'"),
+    cpu_limit: z.string().optional().describe("CPU limit e.g. '500m'"),
+});
+// Tool implementations
+export async function getLogs(input, context) {
+    const args = ["logs", input.pod, "-n", input.namespace, "--tail", String(input.tail)];
+    if (input.container)
+        args.push("-c", input.container);
+    return kubectl(args, { context: context?.context });
+}
+export async function describeResource(input, context) {
+    return kubectl(["describe", input.resource_type, input.name, "-n", input.namespace], { context: context?.context });
+}
+export async function restartPod(input, context) {
+    await kubectl(["delete", "pod", input.pod, "-n", input.namespace], { context: context?.context });
+    return `Pod ${input.pod} deleted. Deployment will recreate it.`;
+}
+export async function rolloutRestart(input, context) {
+    await kubectl(["rollout", "restart", `deployment/${input.deployment}`, "-n", input.namespace], { context: context?.context });
+    return `Rollout restart initiated for deployment/${input.deployment}`;
+}
+export async function scaleDeployment(input, context) {
+    await kubectl(["scale", `deployment/${input.deployment}`, "--replicas", String(input.replicas), "-n", input.namespace], { context: context?.context });
+    return `Scaled deployment/${input.deployment} to ${input.replicas} replicas`;
+}
+export async function getEvents(input, context) {
+    return kubectl(["get", "events", "-n", input.namespace, "--sort-by=.lastTimestamp"], { context: context?.context });
+}
+export async function setResources(input, context) {
+    const args = ["set", "resources", `deployment/${input.deployment}`, "-n", input.namespace];
+    if (input.container)
+        args.push("-c", input.container);
+    const requests = [];
+    if (input.memory_request)
+        requests.push(`memory=${input.memory_request}`);
+    if (input.cpu_request)
+        requests.push(`cpu=${input.cpu_request}`);
+    if (requests.length)
+        args.push(`--requests=${requests.join(",")}`);
+    const limits = [];
+    if (input.memory_limit)
+        limits.push(`memory=${input.memory_limit}`);
+    if (input.cpu_limit)
+        limits.push(`cpu=${input.cpu_limit}`);
+    if (limits.length)
+        args.push(`--limits=${limits.join(",")}`);
+    await kubectl(args, { context: context?.context });
+    return `Resources updated on deployment/${input.deployment}. Rolling restart triggered automatically.`;
+}

package/dist/kb/loader.d.ts

@@ -0,0 +1 @@
+export declare function buildSystemPrompt(kbDir: string): string;

package/dist/kb/loader.js

@@ -0,0 +1,41 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+export function buildSystemPrompt(kbDir) {
+    if (!existsSync(kbDir)) {
+        return "No knowledge base found. Run `kubeagent onboard` to create one.";
+    }
+    const sections = [];
+    sections.push("You are KubeAgent, an AI-powered Kubernetes management assistant.", "You have access to the following knowledge about this cluster and its projects.", "Use this context to diagnose issues and propose fixes.", "");
+    // Load cluster.md
+    const clusterPath = join(kbDir, "cluster.md");
+    if (existsSync(clusterPath)) {
+        sections.push("## Cluster Information\n");
+        sections.push(readFileSync(clusterPath, "utf-8"));
+        sections.push("");
+    }
+    // Load project files
+    const projectsDir = join(kbDir, "projects");
+    if (existsSync(projectsDir)) {
+        const files = readdirSync(projectsDir).filter((f) => f.endsWith(".md"));
+        if (files.length > 0) {
+            sections.push("## Projects\n");
+            for (const file of files) {
+                sections.push(readFileSync(join(projectsDir, file), "utf-8"));
+                sections.push("");
+            }
+        }
+    }
+    // Load runbooks
+    const runbooksDir = join(kbDir, "runbooks");
+    if (existsSync(runbooksDir)) {
+        const files = readdirSync(runbooksDir).filter((f) => f.endsWith(".md"));
+        if (files.length > 0) {
+            sections.push("## Runbooks (learned remediation patterns)\n");
+            for (const file of files) {
+                sections.push(readFileSync(join(runbooksDir, file), "utf-8"));
+                sections.push("");
+            }
+        }
+    }
+    return sections.join("\n");
+}

package/dist/kb/writer.d.ts

@@ -0,0 +1,11 @@
+export declare function ensureKbDir(kbDir: string): void;
+export declare function writeClusterKb(kbDir: string, content: string): void;
+export declare function writeProjectKb(kbDir: string, projectName: string, content: string): void;
+export declare function writeRunbook(kbDir: string, name: string, content: string): void;
+/**
+ * Write a gave-up issue to the unresolved/ directory.
+ * Files are named by issue key so repeated give-ups overwrite rather than accumulate.
+ * The agent reads these as KB context on future runs.
+ */
+export declare function writeUnresolved(kbDir: string, issueKey: string, content: string): void;
+export declare function writeIncident(kbDir: string, date: string, name: string, content: string): void;

package/dist/kb/writer.js

@@ -0,0 +1,36 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+export function ensureKbDir(kbDir) {
+    for (const sub of ["", "projects", "runbooks", "incidents", "unresolved"]) {
+        const dir = join(kbDir, sub);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+    }
+}
+export function writeClusterKb(kbDir, content) {
+    ensureKbDir(kbDir);
+    writeFileSync(join(kbDir, "cluster.md"), content);
+}
+export function writeProjectKb(kbDir, projectName, content) {
+    ensureKbDir(kbDir);
+    writeFileSync(join(kbDir, "projects", `${projectName}.md`), content);
+}
+export function writeRunbook(kbDir, name, content) {
+    ensureKbDir(kbDir);
+    writeFileSync(join(kbDir, "runbooks", `${name}.md`), content);
+}
+/**
+ * Write a gave-up issue to the unresolved/ directory.
+ * Files are named by issue key so repeated give-ups overwrite rather than accumulate.
+ * The agent reads these as KB context on future runs.
+ */
+export function writeUnresolved(kbDir, issueKey, content) {
+    ensureKbDir(kbDir);
+    const safeName = issueKey.replace(/[^a-z0-9_-]/gi, "_");
+    writeFileSync(join(kbDir, "unresolved", `${safeName}.md`), content);
+}
+export function writeIncident(kbDir, date, name, content) {
+    ensureKbDir(kbDir);
+    writeFileSync(join(kbDir, "incidents", `${date}-${name}.md`), content);
+}

package/dist/kubectl-config.d.ts

@@ -0,0 +1,7 @@
+export interface KubeContext {
+    name: string;
+    cluster: string;
+    current: boolean;
+}
+export declare function listContexts(): Promise<KubeContext[]>;
+export declare function pickContext(): Promise<string>;

package/dist/kubectl-config.js

@@ -0,0 +1,47 @@
+import readline from "node:readline";
+import chalk from "chalk";
+import { kubectl } from "./kubectl.js";
+export async function listContexts() {
+    const raw = await kubectl(["config", "get-contexts", "--no-headers", "-o", "name"]);
+    const names = raw.trim().split("\n").filter(Boolean);
+    const currentRaw = await kubectl(["config", "current-context"]).catch(() => "");
+    const current = currentRaw.trim();
+    return names.map((name) => ({ name, cluster: name, current: name === current }));
+}
+async function ask(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(chalk.cyan(`${question} `), (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export async function pickContext() {
+    let contexts;
+    try {
+        contexts = await listContexts();
+    }
+    catch {
+        return ask("Kubernetes context to use:");
+    }
+    if (contexts.length === 0) {
+        return ask("Kubernetes context to use:");
+    }
+    console.log(chalk.bold("\nAvailable Kubernetes contexts:\n"));
+    contexts.forEach((ctx, i) => {
+        const marker = ctx.current ? chalk.green(" (current)") : "";
+        console.log(`  ${chalk.cyan(String(i + 1))}. ${ctx.name}${marker}`);
+    });
+    console.log();
+    const defaultIdx = contexts.findIndex((c) => c.current);
+    const defaultLabel = defaultIdx >= 0 ? ` [${defaultIdx + 1}]` : "";
+    const answer = await ask(`Select context${defaultLabel}:`);
+    if (!answer && defaultIdx >= 0)
+        return contexts[defaultIdx].name;
+    const num = parseInt(answer, 10);
+    if (!isNaN(num) && num >= 1 && num <= contexts.length) {
+        return contexts[num - 1].name;
+    }
+    return answer || contexts[defaultIdx]?.name || "default";
+}

package/dist/kubectl.d.ts

@@ -0,0 +1,13 @@
+export declare class KubectlError extends Error {
+    readonly stderr?: string | undefined;
+    readonly exitCode?: number | undefined;
+    constructor(message: string, stderr?: string | undefined, exitCode?: number | undefined);
+}
+export declare function parseKubectlJson(raw: string): unknown;
+export interface KubectlOptions {
+    context?: string;
+    namespace?: string;
+    timeout?: number;
+}
+export declare function kubectl(args: string[], options?: KubectlOptions): Promise<string>;
+export declare function kubectlJson(args: string[], options?: KubectlOptions): Promise<unknown>;