kubeagent 0.1.0

package/dist/cli.js

@@ -0,0 +1,447 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { homedir } from "node:os";
+function expandPath(p) {
+    return p.startsWith("~/") ? homedir() + p.slice(1) : p;
+}
+import { loadConfig, saveConfig, configDir } from "./config.js";
+import { onboard } from "./onboard/index.js";
+import { runChecks } from "./monitor/index.js";
+import { startMonitor } from "./monitor/index.js";
+import { handleIssues } from "./orchestrator.js";
+import { diagnose } from "./diagnoser/index.js";
+import { buildSystemPrompt } from "./kb/loader.js";
+import { join } from "node:path";
+import { loadAuth, loginBrowser, createApiKey, showAccount, clearAuth } from "./auth.js";
+import { fetchSlackWebhook } from "./proxy-client.js";
+import { createInterface } from "node:readline";
+import { scanProjectDirectory, matchProjectsToWorkloads, bestMatches } from "./onboard/project-matcher.js";
+import { scanCluster } from "./onboard/cluster-scan.js";
+import { formatProjectMarkdown } from "./onboard/code-scan.js";
+import { writeProjectKb, ensureKbDir } from "./kb/writer.js";
+const program = new Command();
+program
+    .name("kubeagent")
+    .description("AI-powered Kubernetes management CLI")
+    .version("0.1.0");
+program
+    .command("status")
+    .description("Quick cluster health summary (no LLM)")
+    .option("-c, --context <context>", "Kubernetes context")
+    .action(async (opts) => {
+    try {
+        const issues = await runChecks({ context: opts.context });
+        if (issues.length === 0) {
+            console.log(chalk.green("All clear. No issues detected."));
+        }
+        else {
+            for (const issue of issues) {
+                const color = issue.severity === "critical" ? chalk.red : chalk.yellow;
+                console.log(color(`[${issue.severity}] ${issue.message}`));
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+    }
+});
+program
+    .command("onboard")
+    .description("Scan cluster + codebases, interview user, generate knowledge base")
+    .action(async () => {
+    await onboard();
+});
+program
+    .command("watch")
+    .description("Continuous monitoring with auto-remediation")
+    .option("-c, --context <context>", "Kubernetes context (skips prompt)")
+    .option("-i, --interval <seconds>", "Override check interval in seconds")
+    .option("--no-interactive", "Auto-deny all approvals and skip questions (safe for background use)")
+    .action(async (opts) => {
+    const config = loadConfig();
+    const { pickContext } = await import("./kubectl-config.js");
+    // Resolve context: flag skips prompt, otherwise always ask
+    const context = opts.context ?? await pickContext();
+    // Validate the context is onboarded
+    const clusterCfg = config.clusters.find((c) => c.context === context);
+    if (!clusterCfg) {
+        console.log("\n  " + chalk.red("✖ ") + chalk.bold(`"${context}"`) + " has not been onboarded yet.");
+        console.log(chalk.dim("  Run: ") + chalk.cyan("kubeagent onboard") + chalk.dim(" to set it up first."));
+        process.exit(1);
+    }
+    // Interval: CLI flag > saved cluster interval > 300s default
+    const intervalSec = opts.interval
+        ? parseInt(opts.interval, 10)
+        : (clusterCfg.interval ?? 300);
+    const interval = intervalSec * 1000;
+    // Pre-flight: verify cluster connectivity before entering the watch loop
+    const preflight = ora("Connecting to cluster...").start();
+    try {
+        await import("./kubectl.js").then(({ kubectl }) => kubectl(["cluster-info", "--request-timeout=5s"], { context }));
+        preflight.succeed(`Connected to ${context}`);
+    }
+    catch (err) {
+        preflight.fail(`Cannot reach cluster: ${err.message}`);
+        process.exit(1);
+    }
+    const intervalLabel = intervalSec >= 60
+        ? `${Math.floor(intervalSec / 60)}m`
+        : `${intervalSec}s`;
+    const bannerWidth = 44;
+    const bannerInner = `  KubeAgent  ${chalk.cyan(context)}  ${chalk.dim(intervalLabel)}  `;
+    const pad = Math.max(0, bannerWidth - context.length - intervalLabel.length - 18);
+    console.log("\n" + chalk.dim("  ┌" + "─".repeat(bannerWidth) + "┐"));
+    console.log(chalk.dim("  │") + bannerInner + " ".repeat(pad) + chalk.dim("│"));
+    console.log(chalk.dim("  └" + "─".repeat(bannerWidth) + "┘"));
+    console.log(chalk.dim("  Ctrl+C to stop\n"));
+    const noInteractive = opts.noInteractive === true;
+    if (noInteractive) {
+        console.log(chalk.dim("  Non-interactive mode — approvals auto-denied, questions skipped\n"));
+    }
+    // Merge server-stored Slack webhook (from dashboard "Add to Slack") into local config channels
+    const auth = loadAuth();
+    if (auth?.apiKey) {
+        const serverSlack = await fetchSlackWebhook(auth);
+        if (serverSlack.connected && serverSlack.webhookUrl) {
+            const alreadyConfigured = config.notifications.channels.some((ch) => ch.type === "slack" && ch.webhook_url === serverSlack.webhookUrl);
+            if (!alreadyConfigured) {
+                config.notifications.channels.unshift({
+                    type: "slack",
+                    webhook_url: serverSlack.webhookUrl,
+                    label: serverSlack.teamName ?? serverSlack.channelName ?? "KubeAgent",
+                    severity: "warning",
+                });
+                console.log(chalk.dim(`  Slack: ${serverSlack.teamName ?? ""}${serverSlack.channelName ? ` ${serverSlack.channelName}` : ""} (from dashboard)\n`));
+            }
+        }
+    }
+    const { stop } = startMonitor({ context }, interval, async (issues) => {
+        await handleIssues(issues, config, context, noInteractive);
+    });
+    // Handle graceful shutdown
+    process.on("SIGINT", () => {
+        console.log("\n" + chalk.dim("  Stopping monitor..."));
+        stop();
+        process.exit(0);
+    });
+    // Keep process alive
+    await new Promise(() => { });
+});
+program
+    .command("diagnose <resource>")
+    .description("One-shot diagnosis of a specific pod/deployment/service")
+    .option("-c, --context <context>", "Kubernetes context")
+    .option("-n, --namespace <namespace>", "Kubernetes namespace", "default")
+    .action(async (resource, opts) => {
+    const kbDir = join(configDir(), "clusters", opts.context ?? "default");
+    const config = loadConfig();
+    // Create a synthetic issue for the resource
+    const issues = [
+        {
+            kind: "pod_error",
+            severity: "warning",
+            namespace: opts.namespace,
+            resource,
+            message: `User requested diagnosis of ${resource} in ${opts.namespace}`,
+            details: {},
+            timestamp: new Date(),
+        },
+    ];
+    const result = await diagnose(issues, kbDir, opts.context, {
+        autoFix: false,
+        onApproval: async () => false,
+    });
+    console.log(result.analysis);
+});
+program
+    .command("scan <directory>")
+    .description("Scan a directory and suggest which subdirectory maps to which cluster deployment")
+    .option("-c, --context <context>", "Kubernetes context")
+    .option("--write-kb", "Save high-confidence matches to knowledge base and config")
+    .action(async (directory, opts) => {
+    const HIGH_CONFIDENCE = 60;
+    const resolvedDir = expandPath(directory.startsWith("/") || directory.startsWith("~") ? directory : join(process.cwd(), directory));
+    const contextName = opts.context ?? "default";
+    // Load existing saved mappings for this context
+    const config = loadConfig();
+    const clusterCfg = config.clusters.find((c) => c.context === contextName);
+    const existingMappings = new Map((clusterCfg?.projects ?? []).map((p) => [p.dir, p]));
+    if (existingMappings.size > 0) {
+        console.log(chalk.dim(`\nLoaded ${existingMappings.size} saved mapping(s) for context "${contextName}"`));
+    }
+    // Scan local projects
+    const spinner = ora("Scanning project directories...").start();
+    const projects = scanProjectDirectory(resolvedDir);
+    spinner.succeed(`Found ${projects.length} project(s) in ${resolvedDir}`);
+    if (projects.length === 0) {
+        console.log(chalk.yellow("No projects found. Make sure subdirectories contain package.json, go.mod, Dockerfile, etc."));
+        return;
+    }
+    // Scan cluster
+    const kubectlOpts = opts.context ? { context: opts.context } : {};
+    const clusterSpinner = ora("Scanning cluster deployments...").start();
+    let clusterInfo;
+    try {
+        clusterInfo = await scanCluster(kubectlOpts);
+        clusterSpinner.succeed(`Found ${clusterInfo.deployments.length} deployments, ${clusterInfo.statefulsets.length} statefulsets`);
+    }
+    catch (err) {
+        clusterSpinner.fail(`Cluster scan failed: ${err.message}`);
+        return;
+    }
+    // Match
+    const allSuggestions = matchProjectsToWorkloads(projects, clusterInfo.deployments, clusterInfo.statefulsets);
+    const topMatches = bestMatches(allSuggestions, 30);
+    // Group by project for display
+    const grouped = new Map();
+    for (const m of topMatches) {
+        if (!grouped.has(m.project.dir))
+            grouped.set(m.project.dir, []);
+        grouped.get(m.project.dir).push(m);
+    }
+    // Show saved mappings first
+    const alreadySaved = projects.filter((p) => existingMappings.has(p.dir));
+    if (alreadySaved.length > 0) {
+        console.log(chalk.bold("\nAlready mapped (saved in config):\n"));
+        for (const p of alreadySaved) {
+            const saved = existingMappings.get(p.dir);
+            console.log(`  ${chalk.green("✓")} ${p.name}/ → ${saved.kind}/${saved.namespace}/${saved.deployment}`);
+        }
+    }
+    // New suggestions
+    const newMatches = [...grouped.entries()].filter(([dir]) => !existingMappings.has(dir));
+    if (newMatches.length === 0 && alreadySaved.length > 0) {
+        console.log(chalk.dim("\nAll projects are already mapped."));
+    }
+    else if (newMatches.length > 0) {
+        console.log(chalk.bold("\nNew suggestions:\n"));
+        const toSave = [];
+        const skipped = [];
+        for (const [, matches] of newMatches) {
+            const best = matches[0];
+            const isHigh = best.score >= HIGH_CONFIDENCE;
+            const confidence = isHigh ? chalk.green("high") : best.score >= 40 ? chalk.yellow("medium") : chalk.red("low");
+            console.log(chalk.bold(`  ${best.project.name}/`));
+            console.log(`    → ${best.workload.kind}/${best.workload.namespace}/${best.workload.name}`);
+            console.log(`    Confidence: ${confidence} (${best.score}/100)  ${best.reasons[0]}`);
+            if (matches.length > 1) {
+                console.log(chalk.dim(`    Alternatives: ${matches.slice(1, 3).map((m) => m.workload.name).join(", ")}`));
+            }
+            if (opts.writeKb) {
+                if (isHigh) {
+                    toSave.push(best);
+                    console.log(chalk.dim("    → auto-saved (high confidence)"));
+                }
+                else {
+                    skipped.push(best);
+                    console.log(chalk.dim(`    → skipped (below ${HIGH_CONFIDENCE} threshold)`));
+                }
+            }
+            console.log();
+        }
+        // Show unmatched
+        const matchedDirs = new Set(topMatches.map((m) => m.project.dir));
+        const unmatched = projects.filter((p) => !matchedDirs.has(p.dir) && !existingMappings.has(p.dir));
+        if (unmatched.length > 0) {
+            console.log(chalk.dim("No match found for:"));
+            for (const p of unmatched) {
+                console.log(chalk.dim(`  ${p.name}/ (${p.stack.language}/${p.stack.framework})`));
+            }
+            console.log();
+        }
+        // Save high-confidence matches
+        if (opts.writeKb && toSave.length > 0) {
+            const kbDir = join(configDir(), "clusters", contextName);
+            ensureKbDir(kbDir);
+            // Update config
+            const newMappings = toSave.map((m) => ({
+                name: m.project.name,
+                dir: m.project.dir,
+                deployment: m.workload.name,
+                namespace: m.workload.namespace,
+                kind: m.workload.kind,
+            }));
+            const existingClusterIdx = config.clusters.findIndex((c) => c.context === contextName);
+            if (existingClusterIdx >= 0) {
+                const existing = config.clusters[existingClusterIdx].projects ?? [];
+                config.clusters[existingClusterIdx].projects = [...existing, ...newMappings];
+            }
+            else {
+                config.clusters.push({ context: contextName, interval: 60, codepaths: [], projects: newMappings });
+            }
+            saveConfig(config);
+            // Write KB
+            for (const m of toSave) {
+                const md = formatProjectMarkdown(m.project.name, m.project.dir, m.project.stack, `**Deployment:** ${m.workload.name} (${m.workload.namespace})\n**Image:** \`${m.workload.image}\``);
+                writeProjectKb(kbDir, m.project.name, md);
+                console.log(chalk.green(`Saved: ${m.project.name} → ${m.workload.name}`));
+            }
+            if (skipped.length > 0) {
+                console.log(chalk.yellow(`\nSkipped ${skipped.length} low-confidence match(es). Review manually if needed.`));
+            }
+        }
+        else if (!opts.writeKb) {
+            console.log(chalk.dim(`Run with --write-kb to save high-confidence matches (score ≥ ${HIGH_CONFIDENCE}).`));
+        }
+    }
+});
+// Notify commands
+const notifyCmd = program.command("notify").description("Manage notification channels");
+notifyCmd
+    .command("list")
+    .description("List configured notification channels")
+    .action(() => {
+    const config = loadConfig();
+    const { describeChannel } = require("./notify/index.js");
+    const channels = config.notifications.channels;
+    if (channels.length === 0) {
+        console.log(chalk.dim("No notification channels configured."));
+        console.log(chalk.dim("Run: kubeagent notify add"));
+        return;
+    }
+    console.log(chalk.bold(`\n${channels.length} channel(s):\n`));
+    channels.forEach((ch, i) => {
+        console.log(`  ${chalk.cyan(String(i + 1))}. ${describeChannel(ch)}`);
+    });
+    console.log();
+});
+notifyCmd
+    .command("add")
+    .description("Add a Slack or Telegram notification channel")
+    .action(async () => {
+    const { interactiveAddChannel } = await import("./notify/setup.js");
+    const channel = await interactiveAddChannel();
+    if (!channel)
+        return;
+    const config = loadConfig();
+    config.notifications.channels.push(channel);
+    saveConfig(config);
+    console.log(chalk.green("\n  ✔ Channel saved."));
+});
+notifyCmd
+    .command("remove <index>")
+    .description("Remove a channel by number (from: kubeagent notify list)")
+    .action((indexStr) => {
+    const config = loadConfig();
+    const idx = parseInt(indexStr, 10) - 1;
+    if (isNaN(idx) || idx < 0 || idx >= config.notifications.channels.length) {
+        console.error(chalk.red(`Invalid index. Run: kubeagent notify list`));
+        process.exit(1);
+    }
+    const removed = config.notifications.channels.splice(idx, 1)[0];
+    saveConfig(config);
+    const type = removed.type.charAt(0).toUpperCase() + removed.type.slice(1);
+    console.log(chalk.green(`  ✔ Removed ${type} channel.`));
+});
+notifyCmd
+    .command("test")
+    .description("Send a test alert to all configured channels")
+    .option("-c, --context <context>", "Cluster context label to include in test message", "test-cluster")
+    .action(async (opts) => {
+    const config = loadConfig();
+    if (config.notifications.channels.length === 0) {
+        console.log(chalk.yellow("No channels configured. Run: kubeagent notify add"));
+        return;
+    }
+    const { sendNotification } = await import("./notify/index.js");
+    const testIssues = [
+        { kind: "pod_crashloop", severity: "critical", namespace: "prod", resource: "my-app-abc123", message: "Test alert: Container my-app in my-app-abc123 is CrashLoopBackOff (5 restarts)", details: {}, timestamp: new Date() },
+        { kind: "pod_pending", severity: "warning", namespace: "staging", resource: "worker-xyz", message: "Test alert: Pod worker-xyz is Pending", details: {}, timestamp: new Date() },
+    ];
+    console.log(chalk.dim(`\nSending test to ${config.notifications.channels.length} channel(s)...`));
+    await sendNotification(testIssues, config, opts.context);
+    console.log(chalk.green("  ✔ Done. Check your channels."));
+});
+// Auth commands
+function prompt(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+const DEFAULT_SERVER = "https://api.kubeagent.net";
+const DEFAULT_APP_URL = "https://app.kubeagent.net";
+program
+    .command("login")
+    .description("Log in to KubeAgent (opens browser)")
+    .option("-s, --server <url>", "API server URL", DEFAULT_SERVER)
+    .option("--app-url <url>", "Dashboard URL (for browser login)", DEFAULT_APP_URL)
+    .action(async (opts) => {
+    try {
+        const auth = await loginBrowser(opts.server, opts.appUrl);
+        console.log(chalk.green(`Logged in as ${auth.email ?? auth.name ?? "unknown"}`));
+        const { prefix } = await createApiKey(auth, "cli-default");
+        console.log(chalk.dim(`API key created: ${prefix}...`));
+        console.log(chalk.dim("Credentials saved to ~/.kubeagent/auth.json"));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+program
+    .command("account")
+    .description("Show account info and token balance")
+    .action(async () => {
+    const auth = loadAuth();
+    if (!auth) {
+        console.log(chalk.yellow("Not logged in. Run: kubeagent login"));
+        return;
+    }
+    try {
+        const { balance } = await showAccount(auth);
+        console.log(chalk.bold("Token Balance"));
+        console.log(`  Monthly remaining: ${balance.monthlyRemaining.toLocaleString()}`);
+        console.log(`  Extra credits:     ${balance.extraRemaining.toLocaleString()}`);
+        console.log(`  Total:             ${balance.totalRemaining.toLocaleString()}`);
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+    }
+});
+program
+    .command("logout")
+    .description("Clear saved credentials")
+    .action(() => {
+    clearAuth();
+    console.log(chalk.dim("Credentials removed."));
+});
+// Default: interactive mode
+program
+    .argument("[prompt...]", "Ask a question about your cluster")
+    .option("-c, --context <context>", "Kubernetes context")
+    .action(async (prompt, opts) => {
+    if (prompt.length === 0) {
+        program.help();
+        return;
+    }
+    const context = opts.context;
+    const kbDir = join(configDir(), "clusters", context ?? "default");
+    const systemPrompt = buildSystemPrompt(kbDir);
+    const auth = loadAuth();
+    if (!auth?.apiKey) {
+        console.error(chalk.red("Not logged in. Run 'kubeagent login' to get started."));
+        process.exit(1);
+    }
+    const { proxyRequest } = await import("./proxy-client.js");
+    const result = await proxyRequest(auth, {
+        model: "claude-sonnet-4-6",
+        max_tokens: 16000,
+        system: systemPrompt,
+        thinking: { type: "adaptive" },
+        messages: [{ role: "user", content: prompt.join(" ") }],
+    });
+    const response = result;
+    for (const block of response.content) {
+        if (block.type === "text") {
+            console.log(block.text);
+        }
+    }
+});
+program.parse();

package/dist/config.d.ts

@@ -0,0 +1,50 @@
+export interface ProjectMapping {
+    name: string;
+    dir: string;
+    deployment: string;
+    namespace: string;
+    kind: "Deployment" | "StatefulSet";
+}
+export interface ClusterConfig {
+    context: string;
+    interval: number;
+    codepaths: string[];
+    projects?: ProjectMapping[];
+}
+export type NotificationSeverity = "info" | "warning" | "critical";
+export interface SlackChannel {
+    type: "slack";
+    webhook_url: string;
+    severity: NotificationSeverity;
+    label?: string;
+}
+export interface TelegramChannel {
+    type: "telegram";
+    bot_token: string;
+    chat_id: string;
+    severity: NotificationSeverity;
+    label?: string;
+}
+export type NotificationChannel = SlackChannel | TelegramChannel;
+export declare const ALL_ACTIONS: readonly ["restart_pod", "rollout_restart", "scale_deployment", "set_resources"];
+export type RemediationAction = (typeof ALL_ACTIONS)[number];
+export interface KubeAgentConfig {
+    clusters: ClusterConfig[];
+    notifications: {
+        terminal: boolean;
+        channels: NotificationChannel[];
+    };
+    remediation: {
+        auto_fix: boolean;
+        max_retries: number;
+        cooldown: number;
+        safe_actions: RemediationAction[];
+    };
+}
+export declare const DEFAULT_SAFE_ACTIONS: RemediationAction[];
+export declare function defaultConfig(): KubeAgentConfig;
+export declare function parseConfig(raw: Record<string, unknown>): KubeAgentConfig;
+export declare function configDir(): string;
+export declare function configPath(): string;
+export declare function loadConfig(): KubeAgentConfig;
+export declare function saveConfig(config: KubeAgentConfig): void;

package/dist/config.js

@@ -0,0 +1,79 @@
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import yaml from "js-yaml";
+// Actions that are auto-approved without user confirmation.
+// Valid values: restart_pod, rollout_restart, scale_deployment, set_resources
+export const ALL_ACTIONS = [
+    "restart_pod",
+    "rollout_restart",
+    "scale_deployment",
+    "set_resources",
+];
+export const DEFAULT_SAFE_ACTIONS = ["restart_pod", "rollout_restart"];
+export function defaultConfig() {
+    return {
+        clusters: [],
+        notifications: { terminal: true, channels: [] },
+        remediation: {
+            auto_fix: true,
+            max_retries: 2,
+            cooldown: 30,
+            safe_actions: DEFAULT_SAFE_ACTIONS,
+        },
+    };
+}
+export function parseConfig(raw) {
+    const defaults = defaultConfig();
+    const notifications = (raw.notifications ?? {});
+    const remediation = (raw.remediation ?? {});
+    const clusters = (raw.clusters ?? []);
+    // Migrate legacy webhook field → channels array
+    const channels = [];
+    if (Array.isArray(notifications.channels)) {
+        channels.push(...notifications.channels);
+    }
+    else if (notifications.webhook) {
+        // One-time migration from old single-webhook format
+        const w = notifications.webhook;
+        if (w.url && (w.type === "slack" || w.type === "mattermost")) {
+            channels.push({ type: "slack", webhook_url: w.url, severity: w.severity ?? "warning", label: "migrated" });
+        }
+    }
+    return {
+        clusters,
+        notifications: {
+            terminal: notifications.terminal ?? defaults.notifications.terminal,
+            channels,
+        },
+        remediation: {
+            auto_fix: remediation.auto_fix ?? defaults.remediation.auto_fix,
+            max_retries: remediation.max_retries ?? defaults.remediation.max_retries,
+            cooldown: remediation.cooldown ?? defaults.remediation.cooldown,
+            safe_actions: (remediation.safe_actions
+                ?.filter((a) => ALL_ACTIONS.includes(a))
+                ?? defaults.remediation.safe_actions),
+        },
+    };
+}
+export function configDir() {
+    return join(homedir(), ".kubeagent");
+}
+export function configPath() {
+    return join(configDir(), "config.yaml");
+}
+export function loadConfig() {
+    const path = configPath();
+    if (!existsSync(path)) {
+        return defaultConfig();
+    }
+    const raw = yaml.load(readFileSync(path, "utf-8"));
+    return parseConfig(raw ?? {});
+}
+export function saveConfig(config) {
+    const dir = configDir();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(configPath(), yaml.dump(config, { lineWidth: 120 }));
+}

package/dist/debug.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Debug logging — enabled with KUBEAGENT_DEBUG=1 (or any truthy value).
+ *
+ * Usage:
+ *   KUBEAGENT_DEBUG=1 kubeagent watch
+ *
+ * Logs to stderr so it doesn't interfere with piped output.
+ */
+export declare const DEBUG: boolean;
+export declare function dbg(tag: string, message: string, data?: unknown): void;

package/dist/debug.js

@@ -0,0 +1,18 @@
+/**
+ * Debug logging — enabled with KUBEAGENT_DEBUG=1 (or any truthy value).
+ *
+ * Usage:
+ *   KUBEAGENT_DEBUG=1 kubeagent watch
+ *
+ * Logs to stderr so it doesn't interfere with piped output.
+ */
+export const DEBUG = Boolean(process.env.KUBEAGENT_DEBUG || process.env.DEBUG);
+function ts() {
+    return new Date().toISOString().slice(11, 23); // HH:MM:SS.mmm
+}
+export function dbg(tag, message, data) {
+    if (!DEBUG)
+        return;
+    const extra = data !== undefined ? ` ${JSON.stringify(data, null, 2)}` : "";
+    process.stderr.write(`\x1b[2m[${ts()}] [${tag}] ${message}${extra}\x1b[0m\n`);
+}

package/dist/diagnoser/index.d.ts

@@ -0,0 +1,17 @@
+import type { Issue } from "../monitor/types.js";
+export interface DiagnosisResult {
+    analysis: string;
+    action?: {
+        name: string;
+        safe: boolean;
+        params: Record<string, unknown>;
+    };
+    verificationContract?: string;
+}
+export declare function diagnose(issues: Issue[], kbDir: string, clusterContext?: string, options?: {
+    autoFix?: boolean;
+    safeActions?: string[];
+    noInteractive?: boolean;
+    onApproval?: (action: string, params: Record<string, unknown>) => Promise<boolean>;
+    onQuestion?: (question: string, choices: string[] | undefined) => Promise<void>;
+}): Promise<DiagnosisResult>;