kubeagent 0.1.0

package/dist/orchestrator.js

@@ -0,0 +1,222 @@
+import chalk from "chalk";
+import { diagnose } from "./diagnoser/index.js";
+import { verify } from "./verifier.js";
+import { sendNotification } from "./notify/index.js";
+import { writeIncident, writeUnresolved } from "./kb/writer.js";
+import { join } from "node:path";
+import { configDir } from "./config.js";
+import { loadAuth } from "./auth.js";
+import { reportIncident } from "./proxy-client.js";
+import { renderMarkdown, sectionHeader, commandBox } from "./render.js";
+import { broadcastQuestion } from "./notify/index.js";
+import readline from "node:readline";
+const MAX_ATTEMPTS = 3;
+const issueHistory = new Map();
+function issueKey(issue) {
+    return `${issue.kind}:${issue.namespace ?? ""}:${issue.resource ?? ""}`;
+}
+function getOrCreate(key) {
+    if (!issueHistory.has(key)) {
+        issueHistory.set(key, { attempts: 0, gaveUp: false, reason: "" });
+    }
+    return issueHistory.get(key);
+}
+function extractReason(analysis) {
+    const lines = analysis.split("\n").map((l) => l.trim()).filter(Boolean);
+    const rcIdx = lines.findIndex((l) => /root cause/i.test(l));
+    const candidate = rcIdx >= 0 ? lines[rcIdx + 1] ?? lines[0] : lines[0];
+    return candidate?.replace(/^[#*>\-]+\s*/, "").slice(0, 120) ?? "Unknown";
+}
+function severityIcon(severity) {
+    switch (severity) {
+        case "critical": return chalk.red("✖");
+        case "warning": return chalk.yellow("▲");
+        default: return chalk.blue("ℹ");
+    }
+}
+function severityLabel(severity) {
+    switch (severity) {
+        case "critical": return chalk.bgRed.white(" CRITICAL ");
+        case "warning": return chalk.bgYellow.black(" WARNING  ");
+        default: return chalk.bgBlue.white("   INFO   ");
+    }
+}
+function printIssue(issue, prefix = "  ") {
+    const icon = severityIcon(issue.severity);
+    const label = severityLabel(issue.severity);
+    const ns = issue.namespace ? chalk.dim(`[${issue.namespace}]`) : "";
+    console.log(`${prefix}${icon}  ${issue.message}  ${ns}  ${label}`);
+}
+function formatApprovalCommand(action, params) {
+    const p = params;
+    switch (action) {
+        case "set_resources": {
+            const parts = ["kubectl set resources", `deployment/${p.deployment}`, "-n", p.namespace];
+            const req = [];
+            const lim = [];
+            if (p.memory_request)
+                req.push(`memory=${p.memory_request}`);
+            if (p.cpu_request)
+                req.push(`cpu=${p.cpu_request}`);
+            if (p.memory_limit)
+                lim.push(`memory=${p.memory_limit}`);
+            if (p.cpu_limit)
+                lim.push(`cpu=${p.cpu_limit}`);
+            if (p.container)
+                parts.push("-c", String(p.container));
+            if (req.length)
+                parts.push(`--requests=${req.join(",")}`);
+            if (lim.length)
+                parts.push(`--limits=${lim.join(",")}`);
+            return parts.join(" ");
+        }
+        case "scale_deployment":
+            return `kubectl scale deployment/${p.deployment} -n ${p.namespace} --replicas=${p.replicas}`;
+        case "rollout_restart":
+            return `kubectl rollout restart deployment/${p.deployment} -n ${p.namespace}`;
+        case "restart_pod":
+            return `kubectl delete pod ${p.pod} -n ${p.namespace}`;
+        default:
+            return `${action} ${JSON.stringify(params)}`;
+    }
+}
+async function askApproval(action, params) {
+    const cmd = formatApprovalCommand(action, params);
+    console.log("\n" + chalk.yellow("  Action requires approval:"));
+    commandBox(cmd);
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(chalk.yellow("  Run this? [y/N] "), (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "y");
+        });
+    });
+}
+export async function handleIssues(issues, config, clusterContext, noInteractive = false) {
+    const kbDir = join(configDir(), "clusters", clusterContext ?? "default");
+    const dateStr = new Date().toISOString().slice(0, 10);
+    // ── Issues detected ──────────────────────────────────────
+    const critCount = issues.filter((i) => i.severity === "critical").length;
+    const warnCount = issues.filter((i) => i.severity === "warning").length;
+    const parts = [
+        critCount ? chalk.red(`${critCount} critical`) : "",
+        warnCount ? chalk.yellow(`${warnCount} warning`) : "",
+    ].filter(Boolean).join(chalk.dim(", "));
+    sectionHeader(`${issues.length} issue${issues.length !== 1 ? "s" : ""} detected  ${parts}`, chalk.red.bold);
+    const gaveUpIssues = issues.filter((i) => getOrCreate(issueKey(i)).gaveUp);
+    const actionableIssues = issues.filter((i) => !getOrCreate(issueKey(i)).gaveUp);
+    for (const issue of actionableIssues) {
+        printIssue(issue);
+    }
+    for (const issue of gaveUpIssues) {
+        const record = issueHistory.get(issueKey(issue));
+        printIssue(issue);
+        console.log(chalk.dim(`     ↳ Skipped — gave up after ${MAX_ATTEMPTS} attempts: ${record.reason}`));
+    }
+    if (actionableIssues.length === 0)
+        return;
+    await sendNotification(actionableIssues, config, clusterContext);
+    // ── Diagnosing ────────────────────────────────────────────
+    sectionHeader("Diagnosing", chalk.blue.bold);
+    const result = await diagnose(actionableIssues, kbDir, clusterContext, {
+        autoFix: config.remediation.auto_fix,
+        safeActions: config.remediation.safe_actions,
+        noInteractive,
+        onApproval: noInteractive ? undefined : askApproval,
+        onQuestion: (question, choices) => broadcastQuestion(question, choices, config, clusterContext),
+    });
+    // ── Analysis ──────────────────────────────────────────────
+    sectionHeader("Analysis", chalk.green.bold);
+    console.log(renderMarkdown(result.analysis));
+    // Attempt tracking / gave-up logic
+    const reason = extractReason(result.analysis);
+    for (const issue of actionableIssues) {
+        const record = getOrCreate(issueKey(issue));
+        record.attempts += 1;
+        record.reason = reason;
+        if (record.attempts >= MAX_ATTEMPTS) {
+            record.gaveUp = true;
+            console.log("\n  " + chalk.red("✖ Gave up") + chalk.dim(` on "${issue.message}" after ${MAX_ATTEMPTS} attempts`));
+            console.log(chalk.dim(`    Reason:   ${reason}`));
+            console.log(chalk.dim(`    Logged:   ${kbDir}/unresolved/`));
+            console.log(chalk.dim("    Restart the CLI or fix manually to retry."));
+            const key = issueKey(issue);
+            const content = [
+                `# Unresolved: ${issue.message}`,
+                "",
+                `**Issue key:** \`${key}\``,
+                `**First seen:** ${new Date().toISOString()}`,
+                `**Attempts:** ${MAX_ATTEMPTS}`,
+                `**Severity:** ${issue.severity}`,
+                "",
+                "## Why the agent gave up",
+                reason,
+                "",
+                "## Last full analysis",
+                result.analysis,
+                "",
+                "## TODO",
+                "- [ ] Investigate root cause manually",
+                "- [ ] Add a runbook to `runbooks/` with the fix steps",
+                "- [ ] Once fixed, delete this file so the agent re-diagnoses if it reappears",
+            ].join("\n");
+            writeUnresolved(kbDir, key, content);
+        }
+    }
+    // ── Verifying ─────────────────────────────────────────────
+    let verified = false;
+    if (result.action) {
+        sectionHeader("Verifying fix", chalk.blue.bold);
+        const originalKinds = actionableIssues.map((i) => i.kind);
+        for (let attempt = 0; attempt < config.remediation.max_retries; attempt++) {
+            const verification = await verify(originalKinds, { context: clusterContext }, config.remediation.cooldown * 1000);
+            if (verification.passed) {
+                console.log("  " + chalk.green("✔ Fix verified successfully"));
+                for (const issue of actionableIssues) {
+                    issueHistory.delete(issueKey(issue));
+                }
+                verified = true;
+                break;
+            }
+            console.log("  " + chalk.yellow(`▲ Attempt ${attempt + 1} failed: ${verification.message}`));
+        }
+        if (!verified) {
+            console.log("  " + chalk.red("✖ Fix could not be verified — manual intervention may be needed"));
+        }
+    }
+    // Log incident
+    const incidentName = actionableIssues[0].kind;
+    const incidentContent = [
+        `# Incident: ${actionableIssues.map((i) => i.kind).join(", ")}`,
+        "",
+        `**Date:** ${new Date().toISOString()}`,
+        `**Severity:** ${actionableIssues[0].severity}`,
+        "",
+        "## Issues",
+        ...actionableIssues.map((i) => `- ${i.message}`),
+        "",
+        "## Analysis",
+        result.analysis,
+    ].join("\n");
+    writeIncident(kbDir, dateStr, incidentName, incidentContent);
+    // Report to SaaS if authenticated
+    const auth = loadAuth();
+    if (auth?.apiKey) {
+        try {
+            await reportIncident(auth, {
+                clusterContext: clusterContext ?? "default",
+                issues: JSON.stringify(actionableIssues.map((i) => ({
+                    kind: i.kind,
+                    severity: i.severity,
+                    message: i.message,
+                }))),
+                analysis: result.analysis,
+                actionTaken: result.action?.name,
+                verified: result.action ? verified : undefined,
+            });
+        }
+        catch {
+            // Silent — don't break local flow if server is unreachable
+        }
+    }
+}

package/dist/proxy-client.d.ts

@@ -0,0 +1,15 @@
+import type { AuthState } from "./auth.js";
+export declare function proxyRequest(auth: AuthState, body: Record<string, unknown>): Promise<Record<string, unknown>>;
+export declare function fetchSlackWebhook(auth: AuthState): Promise<{
+    connected: boolean;
+    webhookUrl?: string;
+    channelName?: string;
+    teamName?: string;
+}>;
+export declare function reportIncident(auth: AuthState, incident: {
+    clusterContext: string;
+    issues: string;
+    analysis: string;
+    actionTaken?: string;
+    verified?: boolean;
+}): Promise<void>;

package/dist/proxy-client.js

@@ -0,0 +1,72 @@
+import { dbg } from "./debug.js";
+const MAX_RETRIES = 3;
+export async function proxyRequest(auth, body) {
+    const apiKey = auth.apiKey ?? auth.token;
+    const url = `${auth.serverUrl}/v1/messages`;
+    const keyPreview = apiKey ? `${apiKey.slice(0, 12)}...` : "(none)";
+    dbg("proxy", `POST ${url}`, {
+        keyPrefix: keyPreview,
+        model: body.model,
+        maxTokens: body.max_tokens,
+    });
+    let res;
+    let lastErr;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        if (attempt > 0) {
+            const delay = 2 ** (attempt - 1) * 1000; // 1s, 2s, 4s
+            dbg("proxy", `retry ${attempt}/${MAX_RETRIES} after ${delay}ms`);
+            await new Promise((r) => setTimeout(r, delay));
+        }
+        res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `ApiKey ${apiKey}`,
+            },
+            body: JSON.stringify(body),
+        });
+        dbg("proxy", `response ${res.status} from ${url}`);
+        if (res.status !== 429 && res.status !== 503)
+            break;
+        dbg("proxy", `transient error ${res.status}, will retry`);
+        lastErr = res;
+    }
+    res = res;
+    if (!res.ok) {
+        const errBody = await res.json().catch(() => ({}));
+        const message = errBody.error ?? `HTTP ${res.status}`;
+        // Distinguish backend 401 from other errors for easier debugging
+        const hint = res.status === 401
+            ? " — your API key may be expired or invalid. Run: kubeagent login --server <url>"
+            : "";
+        throw Object.assign(new Error(`KubeAgent proxy: ${message}${hint}`), {
+            status: res.status,
+        });
+    }
+    return (await res.json());
+}
+export async function fetchSlackWebhook(auth) {
+    const apiKey = auth.apiKey ?? auth.token;
+    try {
+        const res = await fetch(`${auth.serverUrl}/slack/api/webhook`, {
+            headers: { Authorization: `ApiKey ${apiKey}` },
+        });
+        if (!res.ok)
+            return { connected: false };
+        return (await res.json());
+    }
+    catch {
+        return { connected: false };
+    }
+}
+export async function reportIncident(auth, incident) {
+    const apiKey = auth.apiKey ?? auth.token;
+    await fetch(`${auth.serverUrl}/incidents`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `ApiKey ${apiKey}`,
+        },
+        body: JSON.stringify(incident),
+    });
+}

package/dist/render.d.ts

@@ -0,0 +1,5 @@
+export declare function renderMarkdown(text: string): string;
+/** Print a labelled section divider: ── Label ──────────── */
+export declare function sectionHeader(label: string, color?: import("chalk").ChalkInstance): void;
+/** Print a two-line command approval box. */
+export declare function commandBox(cmd: string): void;

package/dist/render.js

@@ -0,0 +1,143 @@
+import chalk from "chalk";
+function renderInline(text) {
+    return text
+        .replace(/\*\*(.*?)\*\*/g, (_, t) => chalk.bold(t))
+        .replace(/__(.*?)__/g, (_, t) => chalk.bold(t))
+        .replace(/`([^`]+)`/g, (_, t) => chalk.cyan(t))
+        .replace(/\*(.*?)\*/g, (_, t) => chalk.italic ? chalk.italic(t) : t);
+}
+function renderTable(tableLines) {
+    const dataLines = tableLines.filter((l) => !/^\s*\|[\s\-:|]+\|\s*$/.test(l));
+    if (dataLines.length === 0)
+        return "";
+    const rows = dataLines.map((l) => l.trim().replace(/^\||\|$/g, "").split("|").map((c) => c.trim()));
+    const cols = Math.max(...rows.map((r) => r.length));
+    const widths = Array.from({ length: cols }, () => 0);
+    for (const row of rows) {
+        for (let c = 0; c < row.length; c++) {
+            widths[c] = Math.max(widths[c], row[c].length);
+        }
+    }
+    const result = [];
+    let isHeader = true;
+    for (const row of rows) {
+        const cells = row.map((cell, c) => {
+            const rendered = renderInline(cell);
+            const pad = widths[c] - cell.length;
+            const padded = rendered + " ".repeat(Math.max(0, pad));
+            return isHeader ? chalk.bold(padded) : padded;
+        });
+        result.push("  " + cells.join("  │  "));
+        if (isHeader) {
+            result.push("  " + widths.map((w) => "─".repeat(w + 2)).join("┼"));
+            isHeader = false;
+        }
+    }
+    return result.join("\n");
+}
+export function renderMarkdown(text) {
+    const lines = text.split("\n");
+    const output = [];
+    let i = 0;
+    let inCodeBlock = false;
+    const codeLines = [];
+    while (i < lines.length) {
+        const line = lines[i];
+        // Code blocks
+        if (line.trim().startsWith("```")) {
+            if (!inCodeBlock) {
+                inCodeBlock = true;
+                codeLines.length = 0;
+            }
+            else {
+                inCodeBlock = false;
+                output.push(codeLines.map((l) => "    " + chalk.dim(l)).join("\n"));
+            }
+            i++;
+            continue;
+        }
+        if (inCodeBlock) {
+            codeLines.push(line);
+            i++;
+            continue;
+        }
+        // Tables
+        if (line.trim().startsWith("|")) {
+            const tableLines = [];
+            while (i < lines.length && lines[i].trim().startsWith("|")) {
+                tableLines.push(lines[i]);
+                i++;
+            }
+            output.push(renderTable(tableLines));
+            continue;
+        }
+        // Headings
+        if (line.startsWith("### ")) {
+            output.push("\n" + chalk.bold(line.slice(4)));
+        }
+        else if (line.startsWith("## ")) {
+            output.push("\n" + chalk.bold.underline(line.slice(3)));
+        }
+        else if (line.startsWith("# ")) {
+            output.push("\n" + chalk.bold.underline(line.slice(2)));
+            // Horizontal rule
+        }
+        else if (/^[-*]{3,}$/.test(line.trim())) {
+            output.push(chalk.dim("─".repeat(60)));
+            // Blockquote
+        }
+        else if (line.startsWith("> ")) {
+            output.push(chalk.dim("│ ") + chalk.italic(renderInline(line.slice(2))));
+            // Checkboxes
+        }
+        else if (/^(\s*)- \[x\] /i.test(line)) {
+            const indent = line.match(/^(\s*)/)?.[1] ?? "";
+            const content = line.replace(/^\s*- \[x\] /i, "");
+            output.push(indent + chalk.green("✔ ") + chalk.dim(renderInline(content)));
+        }
+        else if (/^(\s*)- \[ \] /.test(line)) {
+            const indent = line.match(/^(\s*)/)?.[1] ?? "";
+            const content = line.replace(/^\s*- \[ \] /, "");
+            output.push(indent + chalk.dim("○ ") + renderInline(content));
+            // Bullet lists
+        }
+        else if (/^(\s*)[-*] /.test(line)) {
+            const indent = line.match(/^(\s*)/)?.[1] ?? "";
+            const depth = Math.floor(indent.length / 2);
+            const bullet = depth === 0 ? chalk.dim("•") : chalk.dim("◦");
+            const content = line.replace(/^\s*[-*] /, "");
+            output.push("  " + "  ".repeat(depth) + bullet + " " + renderInline(content));
+            // Numbered lists
+        }
+        else if (/^(\s*)\d+\. /.test(line)) {
+            const indent = line.match(/^(\s*)/)?.[1] ?? "";
+            const depth = Math.floor(indent.length / 2);
+            const num = line.match(/^\s*(\d+)\./)?.[1] ?? "";
+            const content = line.replace(/^\s*\d+\. /, "");
+            output.push("  " + "  ".repeat(depth) + chalk.dim(`${num}.`) + " " + renderInline(content));
+            // Everything else
+        }
+        else {
+            output.push(renderInline(line));
+        }
+        i++;
+    }
+    return output.join("\n");
+}
+/** Print a labelled section divider: ── Label ──────────── */
+export function sectionHeader(label, color = chalk.bold) {
+    const width = 56;
+    const inner = ` ${label} `;
+    const dashes = "─".repeat(Math.max(0, width - inner.length));
+    console.log("\n" + color("──" + inner + dashes));
+}
+/** Print a two-line command approval box. */
+export function commandBox(cmd) {
+    const maxWidth = Math.max(cmd.length + 4, 40);
+    const top = "  ╭" + "─".repeat(maxWidth) + "╮";
+    const middle = "  │  " + chalk.cyan(cmd) + " ".repeat(Math.max(0, maxWidth - cmd.length - 3)) + "│";
+    const bottom = "  ╰" + "─".repeat(maxWidth) + "╯";
+    console.log(chalk.dim(top));
+    console.log(middle);
+    console.log(chalk.dim(bottom));
+}

package/dist/verifier.d.ts

@@ -0,0 +1,9 @@
+import type { Issue, IssueKind } from "./monitor/types.js";
+import type { KubectlOptions } from "./kubectl.js";
+export interface VerificationResult {
+    passed: boolean;
+    remainingIssues: Issue[];
+    message: string;
+}
+export declare function evaluateResult(currentIssues: Issue[], originalIssueKinds: IssueKind[]): VerificationResult;
+export declare function verify(originalIssueKinds: IssueKind[], kubectlOptions: KubectlOptions, cooldownMs?: number): Promise<VerificationResult>;

package/dist/verifier.js

@@ -0,0 +1,17 @@
+import { runChecks } from "./monitor/index.js";
+export function evaluateResult(currentIssues, originalIssueKinds) {
+    const remaining = currentIssues.filter((issue) => originalIssueKinds.includes(issue.kind));
+    return {
+        passed: remaining.length === 0,
+        remainingIssues: remaining,
+        message: remaining.length === 0
+            ? "All original issues resolved."
+            : `${remaining.length} issue(s) still present: ${remaining.map((i) => i.message).join("; ")}`,
+    };
+}
+export async function verify(originalIssueKinds, kubectlOptions, cooldownMs = 30_000) {
+    // Wait for cooldown before checking
+    await new Promise((resolve) => setTimeout(resolve, cooldownMs));
+    const currentIssues = await runChecks(kubectlOptions);
+    return evaluateResult(currentIssues, originalIssueKinds);
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "kubeagent",
+  "version": "0.1.0",
+  "description": "AI-powered Kubernetes management CLI",
+  "type": "module",
+  "bin": {
+    "kubeagent": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli.ts",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.80.0",
+    "chalk": "^5.4.0",
+    "commander": "^13.0.0",
+    "js-yaml": "^4.1.0",
+    "ora": "^8.0.0",
+    "zod": "^3.24.0",
+    "zod-to-json-schema": "^3.25.2"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}