kubeagent 0.1.43 → 0.1.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kubeagent",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "description": "AI-powered Kubernetes management CLI",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

package/dist/auth.d.ts

@@ -1,29 +0,0 @@
-export interface AuthState {
-    serverUrl: string;
-    appUrl: string;
-    token: string;
-    email?: string;
-    name?: string;
-    apiKey?: string;
-}
-export declare function loadAuth(): AuthState | null;
-export declare function saveAuth(auth: AuthState): void;
-export declare function clearAuth(): void;
-export declare function loginBrowser(serverUrl: string, appUrl: string): Promise<AuthState>;
-export declare function loginDevice(serverUrl: string, appUrl: string): Promise<AuthState>;
-export declare function createApiKey(auth: AuthState, name: string): Promise<{
-    key: string;
-    prefix: string;
-}>;
-export interface BalanceInfo {
-    monthlyRemaining: number;
-    extraRemaining: number;
-    totalRemaining: number;
-    resetsAt: string;
-    plan: string | null;
-    planName: string | null;
-    monthlyTotal: number;
-}
-export declare function showAccount(auth: AuthState): Promise<{
-    balance: BalanceInfo;
-}>;

package/dist/check/index.d.ts

@@ -1,34 +0,0 @@
-import type { Issue, Severity } from "../monitor/types.js";
-export declare const SEVERITY_RANK: Record<Severity, number>;
-export declare function isValidSeverity(s: string): s is Severity;
-export interface CheckReportSummary {
-    critical: number;
-    warning: number;
-    info: number;
-    podCount: number;
-    nodeCount: number;
-}
-export interface CheckReport {
-    version: 1;
-    context: string;
-    namespaces: string[] | "all";
-    scannedAt: string;
-    durationMs: number;
-    summary: CheckReportSummary;
-    issues: Issue[];
-    diagnosis: {
-        analysis: string;
-    } | null;
-    exit: {
-        code: 0 | 1;
-        reason: string;
-    };
-}
-export declare function filterIssuesByNamespace(issues: Issue[], namespaces: string[] | "all"): Issue[];
-export declare function summarizeIssues(issues: Issue[], podCount: number, nodeCount: number): CheckReportSummary;
-export declare function computeExitCode(summary: CheckReportSummary, failOn: Severity): {
-    code: 0 | 1;
-    reason: string;
-};
-export declare function renderJson(report: CheckReport): string;
-export declare function renderHuman(report: CheckReport): string;

package/dist/check/index.test.d.ts

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

package/dist/check/index.test.js

@@ -1,202 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { computeExitCode, filterIssuesByNamespace, isValidSeverity, renderHuman, renderJson, summarizeIssues, } from "./index.js";
-function makeIssue(overrides = {}) {
-    return {
-        kind: "pod_crashloop",
-        severity: "critical",
-        namespace: "default",
-        resource: "test-pod",
-        message: "CrashLoopBackOff",
-        details: {},
-        timestamp: new Date("2026-05-28T10:00:00Z"),
-        ...overrides,
-    };
-}
-describe("isValidSeverity", () => {
-    it("accepts the three valid severities", () => {
-        expect(isValidSeverity("info")).toBe(true);
-        expect(isValidSeverity("warning")).toBe(true);
-        expect(isValidSeverity("critical")).toBe(true);
-    });
-    it("rejects anything else", () => {
-        expect(isValidSeverity("bogus")).toBe(false);
-        expect(isValidSeverity("")).toBe(false);
-        expect(isValidSeverity("CRITICAL")).toBe(false);
-    });
-});
-describe("filterIssuesByNamespace", () => {
-    const issues = [
-        makeIssue({ namespace: "foo" }),
-        makeIssue({ namespace: "bar" }),
-        makeIssue({ namespace: "baz" }),
-    ];
-    it("returns all issues when scope is 'all'", () => {
-        expect(filterIssuesByNamespace(issues, "all")).toHaveLength(3);
-    });
-    it("returns all issues when namespace list is empty", () => {
-        expect(filterIssuesByNamespace(issues, [])).toHaveLength(3);
-    });
-    it("filters to the specified namespaces", () => {
-        const result = filterIssuesByNamespace(issues, ["foo", "baz"]);
-        expect(result.map((i) => i.namespace)).toEqual(["foo", "baz"]);
-    });
-    it("returns empty when no namespaces match", () => {
-        expect(filterIssuesByNamespace(issues, ["nope"])).toHaveLength(0);
-    });
-});
-describe("summarizeIssues", () => {
-    it("counts each severity", () => {
-        const issues = [
-            makeIssue({ severity: "critical" }),
-            makeIssue({ severity: "critical" }),
-            makeIssue({ severity: "warning" }),
-            makeIssue({ severity: "info" }),
-        ];
-        const s = summarizeIssues(issues, 10, 3);
-        expect(s).toEqual({ critical: 2, warning: 1, info: 1, podCount: 10, nodeCount: 3 });
-    });
-    it("zeros when no issues", () => {
-        expect(summarizeIssues([], 5, 2)).toEqual({
-            critical: 0,
-            warning: 0,
-            info: 0,
-            podCount: 5,
-            nodeCount: 2,
-        });
-    });
-});
-describe("computeExitCode", () => {
-    const empty = { critical: 0, warning: 0, info: 0, podCount: 0, nodeCount: 0 };
-    it("exits 0 when no issues at any threshold", () => {
-        expect(computeExitCode(empty, "critical").code).toBe(0);
-        expect(computeExitCode(empty, "warning").code).toBe(0);
-        expect(computeExitCode(empty, "info").code).toBe(0);
-    });
-    it("fail-on=critical only fails on critical", () => {
-        expect(computeExitCode({ ...empty, critical: 1 }, "critical").code).toBe(1);
-        expect(computeExitCode({ ...empty, warning: 5 }, "critical").code).toBe(0);
-        expect(computeExitCode({ ...empty, info: 10 }, "critical").code).toBe(0);
-    });
-    it("fail-on=warning fails on warning or critical", () => {
-        expect(computeExitCode({ ...empty, critical: 1 }, "warning").code).toBe(1);
-        expect(computeExitCode({ ...empty, warning: 1 }, "warning").code).toBe(1);
-        expect(computeExitCode({ ...empty, info: 1 }, "warning").code).toBe(0);
-    });
-    it("fail-on=info fails on anything", () => {
-        expect(computeExitCode({ ...empty, info: 1 }, "info").code).toBe(1);
-        expect(computeExitCode({ ...empty, warning: 1 }, "info").code).toBe(1);
-        expect(computeExitCode({ ...empty, critical: 1 }, "info").code).toBe(1);
-    });
-    it("reason mentions all triggered severities", () => {
-        const result = computeExitCode({ ...empty, critical: 1, warning: 1 }, "warning");
-        expect(result.code).toBe(1);
-        expect(result.reason).toContain("critical");
-        expect(result.reason).toContain("warning");
-    });
-});
-describe("renderJson", () => {
-    function makeReport(overrides = {}) {
-        return {
-            version: 1,
-            context: "hetzner-prod",
-            namespaces: ["kubeagent"],
-            scannedAt: "2026-05-28T10:00:00.000Z",
-            durationMs: 1200,
-            summary: { critical: 1, warning: 0, info: 0, podCount: 14, nodeCount: 3 },
-            issues: [
-                makeIssue({
-                    namespace: "kubeagent",
-                    resource: "kubeagent-server-7d9-xj2",
-                    message: "CrashLoopBackOff (5 restarts)",
-                    details: { restartCount: 5 },
-                }),
-            ],
-            diagnosis: null,
-            exit: { code: 1, reason: "fail-on=critical threshold met (critical)" },
-            ...overrides,
-        };
-    }
-    it("emits versioned schema", () => {
-        const parsed = JSON.parse(renderJson(makeReport()));
-        expect(parsed.version).toBe(1);
-    });
-    it("strips timestamp from issues (not part of v1 schema)", () => {
-        const parsed = JSON.parse(renderJson(makeReport()));
-        expect(parsed.issues[0]).not.toHaveProperty("timestamp");
-        expect(parsed.issues[0].kind).toBe("pod_crashloop");
-        expect(parsed.issues[0].details.restartCount).toBe(5);
-    });
-    it("emits diagnosis: null when not run", () => {
-        const parsed = JSON.parse(renderJson(makeReport()));
-        expect(parsed.diagnosis).toBeNull();
-    });
-    it("includes diagnosis when present", () => {
-        const parsed = JSON.parse(renderJson(makeReport({ diagnosis: { analysis: "Root cause: DB unreachable" } })));
-        expect(parsed.diagnosis.analysis).toContain("DB unreachable");
-    });
-    it("handles empty issues", () => {
-        const parsed = JSON.parse(renderJson(makeReport({
-            issues: [],
-            summary: { critical: 0, warning: 0, info: 0, podCount: 14, nodeCount: 3 },
-            exit: { code: 0, reason: "no issues at or above fail-on=critical" },
-        })));
-        expect(parsed.issues).toEqual([]);
-        expect(parsed.exit.code).toBe(0);
-    });
-});
-describe("renderHuman", () => {
-    const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
-    function makeReport(overrides = {}) {
-        return {
-            version: 1,
-            context: "hetzner-prod",
-            namespaces: "all",
-            scannedAt: "2026-05-28T10:00:00.000Z",
-            durationMs: 1200,
-            summary: { critical: 0, warning: 0, info: 0, podCount: 14, nodeCount: 3 },
-            issues: [],
-            diagnosis: null,
-            exit: { code: 0, reason: "no issues at or above fail-on=critical" },
-            ...overrides,
-        };
-    }
-    it("shows 'all clear' when no issues", () => {
-        const out = stripAnsi(renderHuman(makeReport()));
-        expect(out).toContain("all clear");
-        expect(out).toContain("Exit: 0");
-    });
-    it("renders critical issues with severity column", () => {
-        const out = stripAnsi(renderHuman(makeReport({
-            summary: { critical: 1, warning: 0, info: 0, podCount: 14, nodeCount: 3 },
-            issues: [
-                {
-                    kind: "pod_crashloop",
-                    severity: "critical",
-                    namespace: "kubeagent",
-                    resource: "server-xj2",
-                    message: "CrashLoopBackOff",
-                    details: {},
-                    timestamp: new Date(),
-                },
-            ],
-            exit: { code: 1, reason: "fail-on=critical threshold met (critical)" },
-        })));
-        expect(out).toContain("1 critical");
-        expect(out).toContain("server-xj2");
-        expect(out).toContain("CrashLoopBackOff");
-        expect(out).toContain("Exit: 1");
-    });
-    it("shows diagnosis block when present", () => {
-        const out = stripAnsi(renderHuman(makeReport({ diagnosis: { analysis: "Root cause analysis here" } })));
-        expect(out).toContain("Diagnosis");
-        expect(out).toContain("Root cause analysis here");
-    });
-    it("shows 'all' for cluster-wide scope", () => {
-        const out = stripAnsi(renderHuman(makeReport({ namespaces: "all" })));
-        expect(out).toContain("namespace: all");
-    });
-    it("shows namespace list for scoped runs", () => {
-        const out = stripAnsi(renderHuman(makeReport({ namespaces: ["foo", "bar"] })));
-        expect(out).toContain("foo, bar");
-    });
-});

package/dist/check/run.d.ts

@@ -1,10 +0,0 @@
-export interface CheckCliOptions {
-    context?: string;
-    namespace?: string[];
-    allNamespaces?: boolean;
-    failOn: string;
-    format: string;
-    diagnose?: boolean;
-    timeout: string;
-}
-export declare function runCheck(opts: CheckCliOptions): Promise<void>;

package/dist/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/config.d.ts

@@ -1,75 +0,0 @@
-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 interface WebhookChannel {
-    type: "webhook";
-    url: string;
-    secret?: string;
-    severity: NotificationSeverity;
-    label?: string;
-}
-export interface PagerDutyChannel {
-    type: "pagerduty";
-    routing_key: string;
-    severity: NotificationSeverity;
-    label?: string;
-}
-export interface DiscordChannel {
-    type: "discord";
-    webhook_url: string;
-    severity: NotificationSeverity;
-    label?: string;
-}
-export interface TeamsChannel {
-    type: "teams";
-    webhook_url: string;
-    severity: NotificationSeverity;
-    label?: string;
-}
-export type NotificationChannel = SlackChannel | TelegramChannel | WebhookChannel | PagerDutyChannel | DiscordChannel | TeamsChannel;
-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/debug.d.ts

@@ -1,10 +0,0 @@
-/**
- * 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/detector/cache.d.ts

@@ -1,6 +0,0 @@
-export declare function readCache<T>(kind: string, key: string): T | null;
-export declare function readStaleCache<T>(kind: string, key: string): {
-    data: T;
-    fetchedAt: number;
-} | null;
-export declare function writeCache<T>(kind: string, key: string, data: T): void;

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

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

package/dist/detector/cache.test.js

@@ -1,54 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, rmSync, existsSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-let tmpHome;
-let originalHome;
-beforeEach(() => {
-    originalHome = process.env.HOME;
-    tmpHome = mkdtempSync(join(tmpdir(), "kubeagent-cache-test-"));
-    process.env.HOME = tmpHome;
-});
-afterEach(() => {
-    if (originalHome !== undefined)
-        process.env.HOME = originalHome;
-    else
-        delete process.env.HOME;
-    rmSync(tmpHome, { recursive: true, force: true });
-});
-describe("cache", () => {
-    it("round-trips data within the TTL", async () => {
-        const { readCache, writeCache } = await import("./cache.js");
-        writeCache("osv", "redis@7.0.5", [{ id: "CVE-1" }]);
-        const got = readCache("osv", "redis@7.0.5");
-        expect(got).toEqual([{ id: "CVE-1" }]);
-    });
-    it("returns null for a missing entry", async () => {
-        const { readCache } = await import("./cache.js");
-        expect(readCache("osv", "nope")).toBeNull();
-    });
-    it("creates the cache directory on write", async () => {
-        const { writeCache } = await import("./cache.js");
-        writeCache("eol", "postgres", [{ cycle: "15" }]);
-        expect(existsSync(join(tmpHome, ".kubeagent", "cache", "eol", "postgres.json"))).toBe(true);
-    });
-    it("sanitizes unsafe characters in cache keys", async () => {
-        const { writeCache } = await import("./cache.js");
-        writeCache("osv", "foo/../bar@1.0", { x: 1 });
-        expect(existsSync(join(tmpHome, ".kubeagent", "cache", "osv", "foo_.._bar@1.0.json"))).toBe(true);
-    });
-    it("readStaleCache returns data and a fetchedAt timestamp", async () => {
-        const { writeCache, readStaleCache } = await import("./cache.js");
-        writeCache("osv", "k", "v");
-        const stale = readStaleCache("osv", "k");
-        expect(stale?.data).toBe("v");
-        expect(typeof stale?.fetchedAt).toBe("number");
-    });
-    it("treats a malformed cache file as a miss", async () => {
-        const { writeCache, readCache } = await import("./cache.js");
-        writeCache("osv", "k", "v");
-        const path = join(tmpHome, ".kubeagent", "cache", "osv", "k.json");
-        writeFileSync(path, "not json");
-        expect(readCache("osv", "k")).toBeNull();
-    });
-});

package/dist/detector/catalog.d.ts

@@ -1,17 +0,0 @@
-export interface OsvLookup {
-    name: string;
-    ecosystem?: string;
-}
-export interface ProductEntry {
-    display: string;
-    eolProduct?: string;
-    osv?: OsvLookup;
-}
-export declare const PRODUCTS: Record<string, ProductEntry>;
-export declare const ALIASES: Record<string, string>;
-export interface CatalogMatch {
-    canonical: string;
-    entry: ProductEntry;
-}
-export declare function lookupCatalog(repository: string, name: string): CatalogMatch | null;
-export declare function lookupChart(chartName: string): CatalogMatch | null;

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

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

package/dist/detector/catalog.test.js

@@ -1,33 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { lookupCatalog, lookupChart } from "./catalog.js";
-describe("lookupCatalog", () => {
-    it("matches bare image names from the products map", () => {
-        const m = lookupCatalog("library/postgres", "postgres");
-        expect(m?.canonical).toBe("postgres");
-        expect(m?.entry.display).toBe("PostgreSQL");
-    });
-    it("resolves aliases for bitnami charts", () => {
-        const m = lookupCatalog("bitnami/postgresql", "postgresql");
-        expect(m?.canonical).toBe("postgres");
-    });
-    it("resolves quay.io prometheus", () => {
-        const m = lookupCatalog("prometheus/prometheus", "prometheus");
-        expect(m?.canonical).toBe("prometheus");
-    });
-    it("handles case-insensitive lookups", () => {
-        const m = lookupCatalog("Library/PostgreSQL", "PostgreSQL");
-        expect(m?.canonical).toBe("postgres");
-    });
-    it("returns null for unknown repositories", () => {
-        expect(lookupCatalog("acme/internal-app", "internal-app")).toBeNull();
-    });
-});
-describe("lookupChart", () => {
-    it("matches chart names to canonical products", () => {
-        expect(lookupChart("postgresql")?.canonical).toBe("postgres");
-        expect(lookupChart("redis")?.canonical).toBe("redis");
-    });
-    it("returns null for unknown charts", () => {
-        expect(lookupChart("unknown-chart")).toBeNull();
-    });
-});

package/dist/detector/eol.d.ts

@@ -1,13 +0,0 @@
-export interface EolStatus {
-    product: string;
-    cycle: string;
-    eol: boolean;
-    eolDate?: string;
-    latest?: string;
-    releaseDate?: string;
-    lts: boolean;
-}
-export declare function queryEol(product: string, version: string, opts?: {
-    noCache?: boolean;
-    timeoutMs?: number;
-}): Promise<EolStatus | null>;

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

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

package/dist/detector/eol.test.js

@@ -1,78 +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 { queryEol } from "./eol.js";
-const mockFetch = vi.fn();
-vi.stubGlobal("fetch", mockFetch);
-const cacheRead = vi.mocked(readCache);
-const cacheStale = vi.mocked(readStaleCache);
-const cacheWrite = vi.mocked(writeCache);
-const POSTGRES_FIXTURE = [
-    { cycle: "16", releaseDate: "2023-09-14", eol: "2028-11-09", latest: "16.2", lts: false },
-    { cycle: "15", releaseDate: "2022-10-13", eol: "2027-11-11", latest: "15.6", lts: false },
-    { cycle: "11", releaseDate: "2018-10-18", eol: "2023-11-09", latest: "11.22", lts: false },
-];
-describe("queryEol", () => {
-    beforeEach(() => {
-        mockFetch.mockReset();
-        cacheRead.mockReset();
-        cacheStale.mockReset();
-        cacheWrite.mockReset();
-        cacheRead.mockReturnValue(null);
-        cacheStale.mockReturnValue(null);
-    });
-    it("hits endoflife.date and picks the matching cycle by major version", async () => {
-        mockFetch.mockResolvedValue({ ok: true, json: async () => POSTGRES_FIXTURE });
-        const status = await queryEol("postgres", "15.2", { noCache: true });
-        expect(mockFetch.mock.calls[0][0]).toBe("https://endoflife.date/api/postgres.json");
-        expect(status).toMatchObject({
-            product: "postgres",
-            cycle: "15",
-            eol: false,
-            eolDate: "2027-11-11",
-            latest: "15.6",
-        });
-        expect(cacheWrite).toHaveBeenCalledOnce();
-    });
-    it("flags a cycle as EOL when its date is in the past", async () => {
-        mockFetch.mockResolvedValue({ ok: true, json: async () => POSTGRES_FIXTURE });
-        const status = await queryEol("postgres", "11.18", { noCache: true });
-        expect(status?.cycle).toBe("11");
-        expect(status?.eol).toBe(true);
-        expect(status?.eolDate).toBe("2023-11-09");
-    });
-    it("returns null when no cycle matches", async () => {
-        mockFetch.mockResolvedValue({ ok: true, json: async () => POSTGRES_FIXTURE });
-        const status = await queryEol("postgres", "99.0", { noCache: true });
-        expect(status).toBeNull();
-    });
-    it("returns null on network error with no cache", async () => {
-        mockFetch.mockRejectedValue(new Error("network down"));
-        const status = await queryEol("postgres", "15.2", { noCache: true });
-        expect(status).toBeNull();
-    });
-    it("serves a fresh cached entry without hitting the network", async () => {
-        cacheRead.mockReturnValue(POSTGRES_FIXTURE);
-        const status = await queryEol("postgres", "15.2");
-        expect(mockFetch).not.toHaveBeenCalled();
-        expect(status?.cycle).toBe("15");
-    });
-    it("falls back to stale cache on network error", async () => {
-        cacheStale.mockReturnValue({ data: POSTGRES_FIXTURE, fetchedAt: 1 });
-        mockFetch.mockRejectedValue(new Error("offline"));
-        const status = await queryEol("postgres", "11.18", { noCache: true });
-        expect(status?.eol).toBe(true);
-    });
-    it("treats eol: true as EOL regardless of date", async () => {
-        mockFetch.mockResolvedValue({
-            ok: true,
-            json: async () => [{ cycle: "1.0", eol: true, latest: "1.0.5" }],
-        });
-        const status = await queryEol("oldthing", "1.0", { noCache: true });
-        expect(status?.eol).toBe(true);
-    });
-});

package/dist/detector/image-parser.d.ts

@@ -1,11 +0,0 @@
-export interface ParsedImage {
-    registry: string;
-    repository: string;
-    name: string;
-    tag: string;
-    digest?: string;
-}
-export declare function parseImage(image: string): ParsedImage;
-export declare function normalizeVersion(tag: string): string;
-export declare function majorMinor(version: string): string;
-export declare function major(version: string): string;

package/dist/detector/image-parser.test.d.ts

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