kubeagent 0.1.36 → 0.1.44

package/dist/detector/index.test.js

@@ -1,210 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-vi.mock("./sources.js", () => ({
-    fetchWorkloadCandidates: vi.fn(),
-    fetchHelmCandidates: vi.fn(),
-    fetchIngressHostMap: vi.fn(),
-    workloadKey: (ref) => `${ref.kind}/${ref.namespace}/${ref.name}`,
-}));
-vi.mock("./osv.js", () => ({
-    queryOsv: vi.fn(),
-}));
-vi.mock("./eol.js", () => ({
-    queryEol: vi.fn(),
-}));
-import { fetchWorkloadCandidates, fetchHelmCandidates, fetchIngressHostMap } from "./sources.js";
-import { queryOsv } from "./osv.js";
-import { queryEol } from "./eol.js";
-import { detectApplications, formatApplicationsMarkdown } from "./index.js";
-const fetchWorkloads = vi.mocked(fetchWorkloadCandidates);
-const fetchHelm = vi.mocked(fetchHelmCandidates);
-const fetchIngress = vi.mocked(fetchIngressHostMap);
-const osv = vi.mocked(queryOsv);
-const eol = vi.mocked(queryEol);
-describe("detectApplications", () => {
-    beforeEach(() => {
-        fetchWorkloads.mockReset();
-        fetchHelm.mockReset();
-        fetchIngress.mockReset();
-        osv.mockReset();
-        eol.mockReset();
-        fetchIngress.mockResolvedValue(new Map());
-        osv.mockResolvedValue([]);
-        eol.mockResolvedValue(null);
-    });
-    it("merges image and label candidates pointing at the same app/version", async () => {
-        fetchWorkloads.mockResolvedValue([
-            {
-                source: "image",
-                image: "postgres:15.2",
-                container: "db",
-                workload: { kind: "StatefulSet", namespace: "prod", name: "db" },
-            },
-            {
-                source: "label",
-                appName: "postgres",
-                appVersion: "15.2",
-                workload: { kind: "StatefulSet", namespace: "prod", name: "db" },
-            },
-        ]);
-        fetchHelm.mockResolvedValue([]);
-        const result = await detectApplications({ noCache: true });
-        expect(result.apps).toHaveLength(1);
-        expect(result.apps[0].canonical).toBe("postgres");
-        expect(result.apps[0].version).toBe("15.2");
-        expect(result.apps[0].sources.sort()).toEqual(["image", "label"]);
-        expect(result.apps[0].workloads).toHaveLength(1);
-    });
-    it("tracks images not in the catalog as unknowns", async () => {
-        fetchWorkloads.mockResolvedValue([
-            {
-                source: "image",
-                image: "acme/internal-app:1.2.3",
-                container: "app",
-                workload: { kind: "Deployment", namespace: "team-x", name: "foo" },
-            },
-        ]);
-        fetchHelm.mockResolvedValue([]);
-        const result = await detectApplications({ noCache: true });
-        expect(result.apps).toHaveLength(0);
-        expect(result.unknowns).toHaveLength(1);
-        expect(result.unknowns[0]).toMatchObject({ name: "internal-app", version: "1.2.3" });
-    });
-    it("flags EOL apps via the eol lookup", async () => {
-        fetchWorkloads.mockResolvedValue([
-            {
-                source: "image",
-                image: "postgres:11.18",
-                container: "db",
-                workload: { kind: "StatefulSet", namespace: "prod", name: "db" },
-            },
-        ]);
-        fetchHelm.mockResolvedValue([]);
-        eol.mockResolvedValue({
-            product: "postgres",
-            cycle: "11",
-            eol: true,
-            eolDate: "2023-11-09",
-            latest: "11.22",
-            lts: false,
-        });
-        const result = await detectApplications({ noCache: true });
-        expect(result.apps[0].eol?.eol).toBe(true);
-        expect(result.apps[0].eol?.eolDate).toBe("2023-11-09");
-    });
-    it("attaches CVE findings from OSV", async () => {
-        fetchWorkloads.mockResolvedValue([
-            {
-                source: "image",
-                image: "redis:7.0.5",
-                container: "cache",
-                workload: { kind: "Deployment", namespace: "infra", name: "redis" },
-            },
-        ]);
-        fetchHelm.mockResolvedValue([]);
-        osv.mockResolvedValue([
-            { id: "CVE-2023-9999", summary: "Boom.", severity: "high", fixed: "7.0.12" },
-        ]);
-        const result = await detectApplications({ noCache: true });
-        expect(result.apps[0].cves).toHaveLength(1);
-        expect(result.apps[0].cves[0].id).toBe("CVE-2023-9999");
-    });
-    it("orders apps by severity (EOL → CVEs → healthy)", async () => {
-        fetchWorkloads.mockResolvedValue([
-            {
-                source: "image",
-                image: "nginx:1.25.3",
-                container: "web",
-                workload: { kind: "Deployment", namespace: "edge", name: "nginx" },
-            },
-            {
-                source: "image",
-                image: "postgres:11.18",
-                container: "db",
-                workload: { kind: "StatefulSet", namespace: "prod", name: "db" },
-            },
-            {
-                source: "image",
-                image: "redis:7.0.5",
-                container: "cache",
-                workload: { kind: "Deployment", namespace: "infra", name: "redis" },
-            },
-        ]);
-        fetchHelm.mockResolvedValue([]);
-        eol.mockImplementation(async (product) => product === "postgres"
-            ? { product: "postgres", cycle: "11", eol: true, eolDate: "2023-11-09", lts: false }
-            : null);
-        osv.mockImplementation(async (lookup) => lookup.name === "redis"
-            ? [{ id: "CVE-2023-1", summary: "x", severity: "medium" }]
-            : []);
-        const result = await detectApplications({ noCache: true });
-        expect(result.apps.map((a) => a.canonical)).toEqual(["postgres", "redis", "nginx"]);
-    });
-    it("uses Helm chart appVersion when available", async () => {
-        fetchWorkloads.mockResolvedValue([]);
-        fetchHelm.mockResolvedValue([
-            {
-                source: "helm",
-                chart: "postgresql",
-                chartVersion: "12.0.0",
-                appVersion: "15.2.0",
-                namespace: "data",
-                releaseName: "primary",
-            },
-        ]);
-        const result = await detectApplications({ noCache: true });
-        expect(result.apps).toHaveLength(1);
-        expect(result.apps[0].canonical).toBe("postgres");
-        expect(result.apps[0].version).toBe("15.2.0");
-        expect(result.apps[0].sources).toContain("helm");
-    });
-});
-describe("formatApplicationsMarkdown", () => {
-    it("produces sections for EOL, CVEs, healthy, and unknowns", () => {
-        const md = formatApplicationsMarkdown({
-            apps: [
-                {
-                    canonical: "postgres",
-                    display: "PostgreSQL",
-                    version: "11.18",
-                    sources: ["image"],
-                    workloads: [{ kind: "StatefulSet", namespace: "prod", name: "db" }],
-                    cves: [],
-                    eol: { product: "postgres", cycle: "11", eol: true, eolDate: "2023-11-09", latest: "11.22", lts: false },
-                    catalogMatch: true,
-                },
-                {
-                    canonical: "redis",
-                    display: "Redis",
-                    version: "7.0.5",
-                    sources: ["image"],
-                    workloads: [{ kind: "Deployment", namespace: "infra", name: "redis" }],
-                    cves: [{ id: "CVE-2023-1", summary: "boom", severity: "high", fixed: "7.0.12" }],
-                    eol: null,
-                    catalogMatch: true,
-                },
-                {
-                    canonical: "nginx",
-                    display: "nginx",
-                    version: "1.25.3",
-                    sources: ["image"],
-                    workloads: [{ kind: "Deployment", namespace: "edge", name: "nginx" }],
-                    cves: [],
-                    eol: null,
-                    catalogMatch: true,
-                },
-            ],
-            unknowns: [
-                { name: "internal-app", version: "1.2.3", workloads: [{ kind: "Deployment", namespace: "team-x", name: "foo" }] },
-            ],
-            scanned: { workloads: 4, helmReleases: 0 },
-        });
-        expect(md).toContain("## End-of-Life");
-        expect(md).toContain("PostgreSQL");
-        expect(md).toContain("## Known Vulnerabilities");
-        expect(md).toContain("CVE-2023-1");
-        expect(md).toContain("## Up-to-date");
-        expect(md).toContain("nginx");
-        expect(md).toContain("## Other / not in catalog");
-        expect(md).toContain("internal-app");
-    });
-});

package/dist/detector/osv.d.ts

@@ -1,12 +0,0 @@
-import type { OsvLookup } from "./catalog.js";
-export interface CveFinding {
-    id: string;
-    summary: string;
-    severity?: string;
-    fixed?: string;
-    reference?: string;
-}
-export declare function queryOsv(lookup: OsvLookup, version: string, opts?: {
-    noCache?: boolean;
-    timeoutMs?: number;
-}): Promise<CveFinding[]>;

package/dist/detector/osv.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/detector/osv.test.js

@@ -1,86 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-vi.mock("./cache.js", () => ({
-    readCache: vi.fn(),
-    readStaleCache: vi.fn(),
-    writeCache: vi.fn(),
-}));
-import { readCache, readStaleCache, writeCache } from "./cache.js";
-import { queryOsv } from "./osv.js";
-const mockFetch = vi.fn();
-vi.stubGlobal("fetch", mockFetch);
-const cacheRead = vi.mocked(readCache);
-const cacheStale = vi.mocked(readStaleCache);
-const cacheWrite = vi.mocked(writeCache);
-describe("queryOsv", () => {
-    beforeEach(() => {
-        mockFetch.mockReset();
-        cacheRead.mockReset();
-        cacheStale.mockReset();
-        cacheWrite.mockReset();
-        cacheRead.mockReturnValue(null);
-        cacheStale.mockReturnValue(null);
-    });
-    it("posts the package + version to api.osv.dev and returns mapped findings", async () => {
-        mockFetch.mockResolvedValue({
-            ok: true,
-            json: async () => ({
-                vulns: [
-                    {
-                        id: "CVE-2024-1",
-                        summary: "Test vuln",
-                        database_specific: { severity: "high" },
-                        affected: [{ ranges: [{ events: [{ introduced: "0" }, { fixed: "7.0.12" }] }] }],
-                        references: [{ type: "ADVISORY", url: "https://example.com/advisory" }],
-                    },
-                ],
-            }),
-        });
-        const findings = await queryOsv({ name: "redis" }, "7.0.5", { noCache: true });
-        expect(mockFetch).toHaveBeenCalledOnce();
-        expect(mockFetch.mock.calls[0][0]).toBe("https://api.osv.dev/v1/query");
-        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-        expect(body).toEqual({ package: { name: "redis" }, version: "7.0.5" });
-        expect(findings).toHaveLength(1);
-        expect(findings[0]).toMatchObject({
-            id: "CVE-2024-1",
-            severity: "high",
-            fixed: "7.0.12",
-            reference: "https://example.com/advisory",
-        });
-        expect(cacheWrite).toHaveBeenCalledOnce();
-    });
-    it("includes ecosystem in the OSV body when provided", async () => {
-        mockFetch.mockResolvedValue({ ok: true, json: async () => ({}) });
-        await queryOsv({ name: "postgresql", ecosystem: "Debian" }, "15.2", { noCache: true });
-        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-        expect(body.package).toEqual({ name: "postgresql", ecosystem: "Debian" });
-    });
-    it("returns empty when version is empty", async () => {
-        const findings = await queryOsv({ name: "redis" }, "", { noCache: true });
-        expect(findings).toEqual([]);
-        expect(mockFetch).not.toHaveBeenCalled();
-    });
-    it("returns [] on network error when no stale cache is present", async () => {
-        mockFetch.mockRejectedValue(new Error("network down"));
-        const findings = await queryOsv({ name: "redis" }, "7.0.99", { noCache: true });
-        expect(findings).toEqual([]);
-    });
-    it("serves a fresh cached entry without hitting the network", async () => {
-        cacheRead.mockReturnValue([{ id: "CVE-cached", summary: "from cache" }]);
-        const findings = await queryOsv({ name: "redis" }, "7.0.5");
-        expect(mockFetch).not.toHaveBeenCalled();
-        expect(findings[0].id).toBe("CVE-cached");
-    });
-    it("falls back to stale cache on network error", async () => {
-        cacheStale.mockReturnValue({ data: [{ id: "CVE-stale", summary: "from cache" }], fetchedAt: 1 });
-        mockFetch.mockRejectedValue(new Error("offline"));
-        const findings = await queryOsv({ name: "redis" }, "7.0.5", { noCache: true });
-        expect(findings[0].id).toBe("CVE-stale");
-    });
-    it("falls back to stale cache on non-2xx response", async () => {
-        cacheStale.mockReturnValue({ data: [{ id: "CVE-stale", summary: "x" }], fetchedAt: 1 });
-        mockFetch.mockResolvedValue({ ok: false, status: 500 });
-        const findings = await queryOsv({ name: "redis" }, "7.0.5", { noCache: true });
-        expect(findings[0].id).toBe("CVE-stale");
-    });
-});

package/dist/detector/report.d.ts

@@ -1,6 +0,0 @@
-import type { AuthState } from "../auth.js";
-import type { DetectionResult } from "./index.js";
-export interface ReportOptions {
-    onProgress?: (step: string) => void;
-}
-export declare function generateReport(result: DetectionResult, auth: AuthState, opts?: ReportOptions): Promise<string>;

package/dist/detector/sources.d.ts

@@ -1,42 +0,0 @@
-import { type KubectlOptions } from "../kubectl.js";
-export type WorkloadKind = "Deployment" | "StatefulSet" | "DaemonSet";
-export interface WorkloadRef {
-    kind: WorkloadKind;
-    namespace: string;
-    name: string;
-    hosts?: string[];
-}
-export declare function workloadKey(ref: {
-    kind: string;
-    namespace: string;
-    name: string;
-}): string;
-export interface ImageCandidate {
-    source: "image";
-    image: string;
-    workload: WorkloadRef;
-    container: string;
-}
-export interface LabelCandidate {
-    source: "label";
-    appName: string;
-    appVersion: string;
-    workload: WorkloadRef;
-}
-export interface HelmCandidate {
-    source: "helm";
-    chart: string;
-    chartVersion: string;
-    appVersion?: string;
-    namespace: string;
-    releaseName: string;
-}
-export type Candidate = ImageCandidate | LabelCandidate | HelmCandidate;
-export declare function fetchWorkloadCandidates(options: KubectlOptions): Promise<Candidate[]>;
-export declare function fetchHelmCandidates(options: KubectlOptions): Promise<HelmCandidate[]>;
-/**
- * Build a map of workload key (Kind/namespace/name) → ingress hostnames.
- * Joins Ingresses → Services → workload pod-template labels best-effort.
- * Returns an empty map on failure (ingress visibility is non-essential).
- */
-export declare function fetchIngressHostMap(options: KubectlOptions): Promise<Map<string, string[]>>;

package/dist/diagnoser/index.d.ts

@@ -1,17 +0,0 @@
-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>;

package/dist/diagnoser/tools.d.ts

@@ -1,119 +0,0 @@
-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: "service" | "node" | "pod" | "deployment" | "statefulset" | "daemonset" | "replicaset" | "job" | "cronjob" | "ingress" | "persistentvolumeclaim" | "configmap" | "endpoints";
-}, {
-    name: string;
-    namespace: string;
-    resource_type: "service" | "node" | "pod" | "deployment" | "statefulset" | "daemonset" | "replicaset" | "job" | "cronjob" | "ingress" | "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/kb/loader.d.ts

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

package/dist/kb/writer.d.ts

@@ -1,12 +0,0 @@
-export declare function ensureKbDir(kbDir: string): void;
-export declare function writeClusterKb(kbDir: string, content: string): void;
-export declare function writeApplicationsKb(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/kubectl-config.d.ts

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

package/dist/kubectl.d.ts

@@ -1,13 +0,0 @@
-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>;

package/dist/monitor/checks.d.ts

@@ -1,71 +0,0 @@
-import type { Issue } from "./types.js";
-interface PodStatus {
-    metadata: {
-        name: string;
-        namespace: string;
-    };
-    status: {
-        phase: string;
-        reason?: string;
-        containerStatuses?: Array<{
-            name: string;
-            state: {
-                waiting?: {
-                    reason?: string;
-                };
-                terminated?: {
-                    reason?: string;
-                };
-                running?: Record<string, unknown>;
-            };
-            lastState?: {
-                terminated?: {
-                    reason?: string;
-                };
-            };
-            restartCount: number;
-        }>;
-    };
-}
-interface NodeStatus {
-    metadata: {
-        name: string;
-    };
-    status: {
-        conditions: Array<{
-            type: string;
-            status: string;
-            reason?: string;
-        }>;
-    };
-}
-export declare function findPodIssues(podList: {
-    items: PodStatus[];
-}): Issue[];
-interface JobStatus {
-    metadata: {
-        name: string;
-        namespace: string;
-    };
-    status: {
-        failed?: number;
-        succeeded?: number;
-        active?: number;
-        conditions?: Array<{
-            type: string;
-            status: string;
-            reason?: string;
-            message?: string;
-        }>;
-    };
-    spec?: {
-        backoffLimit?: number;
-    };
-}
-export declare function findJobIssues(jobList: {
-    items: JobStatus[];
-}): Issue[];
-export declare function findNodeIssues(nodeList: {
-    items: NodeStatus[];
-}): Issue[];
-export {};

package/dist/monitor/index.d.ts

@@ -1,17 +0,0 @@
-import { type KubectlOptions } from "../kubectl.js";
-import type { Issue } from "./types.js";
-export type IssueCallback = (issues: Issue[]) => void | Promise<void>;
-export type ResolveCallback = (resolvedKeys: string[]) => void | Promise<void>;
-export interface CheckSummary {
-    issues: Issue[];
-    podCount: number;
-    nodeCount: number;
-    namespaceCount: number;
-}
-export declare function runChecks(options: KubectlOptions): Promise<Issue[]>;
-export declare function runChecks(options: KubectlOptions, withSummary: true): Promise<CheckSummary>;
-export declare function computeResolvedKeys(activeKeys: Set<string>, currentKeys: Set<string>): string[];
-export declare function updateActiveKeys(activeKeys: Set<string>, resolvedKeys: string[], currentKeys: Set<string>): void;
-export declare function startMonitor(options: KubectlOptions, intervalMs: number, onIssues: IssueCallback, onResolved?: ResolveCallback, onFirstCycle?: () => void): {
-    stop: () => void;
-};

package/dist/monitor/resolve.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/monitor/resolve.test.js

@@ -1,21 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { computeResolvedKeys, updateActiveKeys } from "./index.js";
-describe("resolve tracking", () => {
-    it("returns keys that disappeared since last tick", () => {
-        const active = new Set(["pod_crashloop:prod:web", "pod_oom:prod:worker"]);
-        const current = new Set(["pod_oom:prod:worker"]);
-        expect(computeResolvedKeys(active, current)).toEqual(["pod_crashloop:prod:web"]);
-    });
-    it("returns empty array when nothing cleared", () => {
-        const active = new Set(["pod_crashloop:prod:web"]);
-        const current = new Set(["pod_crashloop:prod:web"]);
-        expect(computeResolvedKeys(active, current)).toEqual([]);
-    });
-    it("updates active set correctly after resolve", () => {
-        const active = new Set(["pod_crashloop:prod:web", "pod_oom:prod:worker"]);
-        const current = new Set(["pod_oom:prod:worker", "node_not_ready::node1"]);
-        const resolved = computeResolvedKeys(active, current);
-        updateActiveKeys(active, resolved, current);
-        expect([...active].sort()).toEqual(["node_not_ready::node1", "pod_oom:prod:worker"]);
-    });
-});

package/dist/monitor/types.d.ts

@@ -1,11 +0,0 @@
-export type Severity = "info" | "warning" | "critical";
-export type IssueKind = "pod_crashloop" | "pod_oom" | "pod_image_pull" | "pod_pending" | "pod_failed" | "pod_evicted" | "pod_error" | "node_not_ready" | "node_pressure" | "cert_expiring" | "resource_high" | "job_failed" | "rollout_stuck";
-export interface Issue {
-    kind: IssueKind;
-    severity: Severity;
-    namespace: string;
-    resource: string;
-    message: string;
-    details: Record<string, unknown>;
-    timestamp: Date;
-}