auq-mcp-server 2.4.0 → 2.5.0

package/dist/src/tui/components/Footer.js

@@ -8,7 +8,7 @@ const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧",
  * Footer component - displays context-aware keybindings
  * Shows different shortcuts based on current focus context and question type
  */
-export const Footer = ({ focusContext, multiSelect, isReviewScreen = false, showSessionSwitching = false, customInputValue = "", hasRecommendedOptions = false, hasAnyRecommendedInSession = false, isSubmitting = false, }) => {
+export const Footer = ({ focusContext, multiSelect, isReviewScreen = false, showSessionSwitching = false, customInputValue = "", hasRecommendedOptions = false, hasAnyRecommendedInSession = false, isSubmitting = false, hasUpdate = false, }) => {
     const { theme } = useTheme();
     const [spinnerFrame, setSpinnerFrame] = useState(0);
     // Animate spinner when submitting
@@ -75,6 +75,9 @@ export const Footer = ({ focusContext, multiSelect, isReviewScreen = false, show
                 bindings.push({ key: KEY_LABELS.SESSION_LIST, action: t("footer.list") });
             }
             bindings.push({ key: KEY_LABELS.THEME, action: t("footer.theme") });
+            if (hasUpdate) {
+                bindings.push({ key: KEY_LABELS.UPDATE, action: "Update" });
+            }
             bindings.push({ key: KEY_LABELS.REJECT, action: t("footer.reject") });
             return bindings;
         }

package/dist/src/tui/components/Header.js

@@ -3,11 +3,12 @@ import React, { useEffect, useState } from "react";
 import { t } from "../../i18n/index.js";
 import { useTheme } from "../ThemeContext.js";
 import packageJson from "../../../package.json" with { type: "json" };
+import { UpdateBadge } from "./UpdateBadge.js";
 /**
  * Header component - displays app logo and status
  * Shows at the top of the TUI with gradient branding and live-updating pending queue count
  */
-export const Header = ({ pendingCount }) => {
+export const Header = ({ pendingCount, updateInfo, onUpdateBadgeActivate }) => {
     const { theme } = useTheme();
     const [flash, setFlash] = useState(false);
     const [prevCount, setPrevCount] = useState(pendingCount);
@@ -35,6 +36,7 @@ export const Header = ({ pendingCount }) => {
             React.createElement(Text, { dimColor: true },
                 "v",
                 version),
+            updateInfo && (React.createElement(UpdateBadge, { updateType: updateInfo.updateType, latestVersion: updateInfo.latestVersion })),
             React.createElement(Text, { dimColor: true }, " "),
             React.createElement(Text, { backgroundColor: theme.components.header.pillBg, bold: flash, color: flash
                     ? theme.components.header.queueFlash

package/dist/src/tui/components/UpdateBadge.js

@@ -0,0 +1,29 @@
+import { Box, Text } from "ink";
+import React from "react";
+import { useTheme } from "../ThemeContext.js";
+/**
+ * UpdateBadge — compact header indicator shown when a new version is available.
+ *
+ * Color-coding by severity:
+ *   patch  → success (green)  — minor fix, can auto-install
+ *   minor  → warning (yellow) — new features
+ *   major  → error  (red)     — possible breaking changes
+ *
+ * Rendered inside Header next to the version text.
+ */
+export const UpdateBadge = ({ updateType, latestVersion, }) => {
+    const { theme } = useTheme();
+    // Map update severity to theme colors
+    const colorMap = {
+        patch: theme.colors.success,
+        minor: theme.colors.warning,
+        major: theme.colors.error,
+    };
+    const color = colorMap[updateType] ?? theme.colors.info;
+    // Patch updates are concise (they auto-install); minor/major show the target version
+    const label = updateType === "patch"
+        ? "↑ Update"
+        : `↑ v${latestVersion}`;
+    return (React.createElement(Box, { marginLeft: 1 },
+        React.createElement(Text, { backgroundColor: color, bold: true, color: "#000000" }, ` ${label} `)));
+};

package/dist/src/tui/components/UpdateOverlay.js

@@ -0,0 +1,199 @@
+import { Box, Text, useInput, useStdout } from "ink";
+import React, { useState } from "react";
+import Markdown from "ink-markdown-es";
+import { lexer } from "marked";
+import { useTheme } from "../ThemeContext.js";
+import { detectPackageManager } from "../../update/package-manager.js";
+import { getManualCommand } from "../../update/installer.js";
+/**
+ * UpdateOverlay — fullscreen modal for minor/major update prompts.
+ *
+ * Displays version information, changelog (rendered as Markdown), and
+ * action buttons. Major updates show a breaking-change warning badge.
+ *
+ * Navigation:
+ *   Tab / →  : next button
+ *   Shift+Tab / ← : previous button
+ *   Enter    : trigger focused action
+ *   Esc      : same as "Remind me later"
+ */
+export const UpdateOverlay = ({ isOpen, currentVersion, latestVersion, updateType, changelog, changelogUrl, isInstalling, installError, onInstall, onSkipVersion, onRemindLater, }) => {
+    const { theme } = useTheme();
+    const { stdout } = useStdout();
+    const termWidth = stdout?.columns ?? 80;
+    const [focusedButton, setFocusedButton] = useState(0);
+    // ── Actions bound to button indices ──────────────────────────────
+    const actions = [onInstall, onSkipVersion, onRemindLater];
+    const buttonLabels = ["Yes, update", "Skip this version", "Remind me later"];
+    const buttonCount = buttonLabels.length;
+    // ── Keyboard handling (only active when overlay is open) ────────
+    useInput((input, key) => {
+        // Installing or error state — only Esc closes
+        if (isInstalling)
+            return;
+        if (installError) {
+            if (key.return || key.escape) {
+                onRemindLater();
+            }
+            return;
+        }
+        // Tab / Right arrow: next button
+        if (key.tab && !key.shift) {
+            setFocusedButton((prev) => (prev + 1) % buttonCount);
+            return;
+        }
+        if (key.rightArrow) {
+            setFocusedButton((prev) => (prev + 1) % buttonCount);
+            return;
+        }
+        // Shift+Tab / Left arrow: previous button
+        if (key.tab && key.shift) {
+            setFocusedButton((prev) => (prev - 1 + buttonCount) % buttonCount);
+            return;
+        }
+        if (key.leftArrow) {
+            setFocusedButton((prev) => (prev - 1 + buttonCount) % buttonCount);
+            return;
+        }
+        // Enter: trigger focused button
+        if (key.return) {
+            actions[focusedButton]();
+            return;
+        }
+        // Escape: remind me later
+        if (key.escape) {
+            onRemindLater();
+            return;
+        }
+    }, { isActive: isOpen });
+    // ── Render nothing when closed ──────────────────────────────────
+    if (!isOpen)
+        return null;
+    // ── Color mapping for update type badges ────────────────────────
+    const typeColorMap = {
+        patch: theme.colors.success,
+        minor: theme.colors.warning,
+        major: theme.colors.error,
+    };
+    const typeColor = typeColorMap[updateType] ?? theme.colors.info;
+    const overlayWidth = Math.min(64, termWidth - 4);
+    const innerWidth = overlayWidth - 6; // account for border + paddingX
+    // ── Package manager info for error display ──────────────────────
+    const packageManager = detectPackageManager();
+    const manualCommand = getManualCommand(packageManager);
+    // ── Markdown styles matching MarkdownPrompt ─────────────────────
+    const markdownStyles = {
+        code: {
+            backgroundColor: theme.components.markdown.codeBlockBg,
+            color: theme.components.markdown.codeBlockText,
+            borderColor: theme.components.markdown.codeBlockBorder,
+            borderStyle: "round",
+            paddingX: 1,
+        },
+        codespan: {
+            backgroundColor: theme.components.markdown.codeBlockBg,
+            color: theme.components.markdown.codeBlockText,
+        },
+    };
+    // ── Render changelog section ────────────────────────────────────
+    const renderChangelog = () => {
+        if (changelog) {
+            // Determine if changelog has block elements (like MarkdownPrompt)
+            let hasBlockElements = false;
+            try {
+                const tokens = lexer(changelog);
+                hasBlockElements = tokens.some((token) => ["code", "list", "blockquote", "heading", "hr", "table"].includes(token.type));
+            }
+            catch {
+                // fall through, treat as inline
+            }
+            const renderers = {
+                link: (linkText, href) => (React.createElement(Text, null,
+                    linkText,
+                    " (",
+                    href,
+                    ")")),
+                ...(!hasBlockElements
+                    ? {
+                        paragraph: (content) => (React.createElement(Text, null, content)),
+                    }
+                    : {}),
+            };
+            return (React.createElement(Box, { borderStyle: "round", borderColor: theme.borders.neutral, flexDirection: "column", paddingX: 1, paddingY: 1, width: innerWidth },
+                React.createElement(Markdown, { styles: markdownStyles, renderers: renderers, highlight: true }, changelog)));
+        }
+        // No changelog — show fallback link
+        return (React.createElement(Box, { borderStyle: "round", borderColor: theme.borders.neutral, paddingX: 1, paddingY: 1, width: innerWidth },
+            React.createElement(Text, { dimColor: true },
+                "View changelog: ",
+                changelogUrl)));
+    };
+    // ── Installing state ────────────────────────────────────────────
+    if (isInstalling) {
+        return (React.createElement(Box, { flexDirection: "column", alignItems: "center", justifyContent: "center" },
+            React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.borders.primary, paddingX: 2, paddingY: 1, width: overlayWidth, alignItems: "center" },
+                React.createElement(Box, { marginBottom: 1 },
+                    React.createElement(Text, { bold: true, color: theme.colors.primary }, "Installing Update")),
+                React.createElement(Box, { marginBottom: 1 },
+                    React.createElement(Text, null,
+                        React.createElement(Text, { color: theme.colors.info }, "\u280B "),
+                        "Installing v",
+                        latestVersion,
+                        "\u2026")),
+                React.createElement(Box, null,
+                    React.createElement(Text, { dimColor: true },
+                        "Running: ",
+                        manualCommand)))));
+    }
+    // ── Error state ─────────────────────────────────────────────────
+    if (installError) {
+        return (React.createElement(Box, { flexDirection: "column", alignItems: "center", justifyContent: "center" },
+            React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.borders.error, paddingX: 2, paddingY: 1, width: overlayWidth },
+                React.createElement(Box, { marginBottom: 1 },
+                    React.createElement(Text, { bold: true, color: theme.colors.error }, "Update Failed")),
+                React.createElement(Box, { marginBottom: 1 },
+                    React.createElement(Text, { color: theme.colors.error }, installError)),
+                React.createElement(Box, { marginBottom: 1, flexDirection: "column" },
+                    React.createElement(Text, { dimColor: true }, "Try running manually:"),
+                    React.createElement(Box, { marginTop: 0 },
+                        React.createElement(Text, { bold: true, color: theme.colors.info },
+                            "  ",
+                            manualCommand))),
+                React.createElement(Box, { justifyContent: "center", marginTop: 1 },
+                    React.createElement(Text, { bold: true, backgroundColor: theme.components.options.focusedBg, color: theme.colors.focused }, " Close ")),
+                React.createElement(Box, { justifyContent: "center", marginTop: 1 },
+                    React.createElement(Text, { dimColor: true }, "Enter or Esc to close")))));
+    }
+    // ── Default state: update prompt with buttons ───────────────────
+    return (React.createElement(Box, { flexDirection: "column", alignItems: "center", justifyContent: "center" },
+        React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.borders.primary, paddingX: 2, paddingY: 1, width: overlayWidth },
+            React.createElement(Box, { justifyContent: "center", marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: theme.colors.primary }, "Update Available")),
+            React.createElement(Box, { justifyContent: "center", marginBottom: 1 },
+                React.createElement(Text, null,
+                    React.createElement(Text, { dimColor: true }, "Current: "),
+                    React.createElement(Text, null, currentVersion),
+                    React.createElement(Text, { dimColor: true }, " \u2192 "),
+                    React.createElement(Text, { dimColor: true }, "Latest: "),
+                    React.createElement(Text, { bold: true, color: typeColor }, latestVersion),
+                    React.createElement(Text, null, " "),
+                    React.createElement(Text, { backgroundColor: typeColor, color: "#000000", bold: true },
+                        " ",
+                        updateType.toUpperCase(),
+                        " "))),
+            updateType === "major" && (React.createElement(Box, { borderStyle: "round", borderColor: theme.borders.warning, paddingX: 1, marginBottom: 1, width: innerWidth },
+                React.createElement(Text, { color: theme.colors.warning, bold: true }, "\u26A0 Breaking changes may be included"))),
+            React.createElement(Box, { marginBottom: 1 }, renderChangelog()),
+            React.createElement(Box, { justifyContent: "center", gap: 1 }, buttonLabels.map((label, index) => {
+                const isFocused = index === focusedButton;
+                return (React.createElement(Box, { key: label },
+                    React.createElement(Text, { bold: isFocused, backgroundColor: isFocused
+                            ? theme.components.options.focusedBg
+                            : undefined, color: isFocused ? theme.colors.focused : theme.colors.text },
+                        isFocused ? " ▸ " : " ",
+                        label,
+                        isFocused ? " " : " ")));
+            })),
+            React.createElement(Box, { justifyContent: "center", marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "\u2190\u2192/Tab navigate \u00B7 Enter select \u00B7 Esc dismiss")))));
+};

package/dist/src/tui/constants/keybindings.js

@@ -11,6 +11,8 @@ export const KEYS = {
     QUICK_SUBMIT: "r", // used with key.ctrl
     // Theme
     THEME_CYCLE: "t", // used with key.ctrl
+    // Update overlay
+    UPDATE: "u",
     // Confirmation shortcuts
     CONFIRM_YES: /^[yY]$/,
     CONFIRM_NO: /^[nN]$/,
@@ -37,4 +39,5 @@ export const KEY_LABELS = {
     REJECT: "Esc",
     BACK: "n",
     SUBMIT: "Enter",
+    UPDATE: "U",
 };

package/dist/src/update/__tests__/cache.test.js

@@ -0,0 +1,136 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+// Mock node:fs/promises and node:os before importing the module under test
+vi.mock("node:fs/promises", () => ({
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    mkdir: vi.fn(),
+    unlink: vi.fn(),
+}));
+vi.mock("node:os", () => ({
+    homedir: vi.fn(() => "/home/testuser"),
+}));
+import { readFile, writeFile, mkdir, unlink } from "node:fs/promises";
+import { getCachePath, readCache, writeCache, isCacheFresh, shouldSkipVersion, clearUpdateCache, CACHE_TTL, } from "../cache.js";
+describe("cache management", () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.env = { ...originalEnv };
+        delete process.env.XDG_CONFIG_HOME;
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+        vi.restoreAllMocks();
+    });
+    describe("CACHE_TTL", () => {
+        it("should be 1 hour in milliseconds", () => {
+            expect(CACHE_TTL).toBe(3600000);
+        });
+    });
+    describe("getCachePath", () => {
+        it("should use homedir/.config when XDG_CONFIG_HOME is not set", () => {
+            const path = getCachePath();
+            expect(path).toContain("/home/testuser/.config/auq/update-check.json");
+        });
+        it("should use XDG_CONFIG_HOME when set", () => {
+            process.env.XDG_CONFIG_HOME = "/custom/config";
+            const path = getCachePath();
+            expect(path).toContain("/custom/config/auq/update-check.json");
+        });
+    });
+    describe("readCache", () => {
+        it("should return parsed cache when file contains valid JSON", async () => {
+            const cache = {
+                lastCheck: Date.now(),
+                latestVersion: "2.5.0",
+            };
+            vi.mocked(readFile).mockResolvedValue(JSON.stringify(cache));
+            const result = await readCache();
+            expect(result).toEqual(cache);
+        });
+        it("should return null when file is missing", async () => {
+            vi.mocked(readFile).mockRejectedValue(new Error("ENOENT"));
+            const result = await readCache();
+            expect(result).toBeNull();
+        });
+        it("should return null when file contains invalid JSON", async () => {
+            vi.mocked(readFile).mockResolvedValue("not valid json{{{");
+            const result = await readCache();
+            expect(result).toBeNull();
+        });
+    });
+    describe("writeCache", () => {
+        it("should create directory and write JSON", async () => {
+            vi.mocked(mkdir).mockResolvedValue(undefined);
+            vi.mocked(writeFile).mockResolvedValue(undefined);
+            const cache = {
+                lastCheck: Date.now(),
+                latestVersion: "2.5.0",
+            };
+            await writeCache(cache);
+            expect(mkdir).toHaveBeenCalledWith(expect.stringContaining("auq"), { recursive: true });
+            expect(writeFile).toHaveBeenCalledWith(expect.stringContaining("update-check.json"), JSON.stringify(cache, null, 2), "utf-8");
+        });
+        it("should silently handle write errors", async () => {
+            vi.mocked(mkdir).mockRejectedValue(new Error("EACCES"));
+            const cache = {
+                lastCheck: Date.now(),
+                latestVersion: "2.5.0",
+            };
+            // Should not throw
+            await expect(writeCache(cache)).resolves.toBeUndefined();
+        });
+    });
+    describe("isCacheFresh", () => {
+        it("should return true for a recent cache (30 min ago)", () => {
+            const cache = {
+                lastCheck: Date.now() - 30 * 60 * 1000, // 30 minutes ago
+                latestVersion: "2.5.0",
+            };
+            expect(isCacheFresh(cache)).toBe(true);
+        });
+        it("should return false for an old cache (2 hours ago)", () => {
+            const cache = {
+                lastCheck: Date.now() - 2 * 60 * 60 * 1000, // 2 hours ago
+                latestVersion: "2.5.0",
+            };
+            expect(isCacheFresh(cache)).toBe(false);
+        });
+    });
+    describe("shouldSkipVersion", () => {
+        it("should return true when skippedVersion matches", () => {
+            const cache = {
+                lastCheck: Date.now(),
+                latestVersion: "2.5.0",
+                skippedVersion: "2.5.0",
+            };
+            expect(shouldSkipVersion(cache, "2.5.0")).toBe(true);
+        });
+        it("should return false when skippedVersion does not match", () => {
+            const cache = {
+                lastCheck: Date.now(),
+                latestVersion: "2.5.0",
+                skippedVersion: "2.4.0",
+            };
+            expect(shouldSkipVersion(cache, "2.5.0")).toBe(false);
+        });
+        it("should return false when skippedVersion is undefined", () => {
+            const cache = {
+                lastCheck: Date.now(),
+                latestVersion: "2.5.0",
+            };
+            expect(shouldSkipVersion(cache, "2.5.0")).toBe(false);
+        });
+    });
+    describe("clearUpdateCache", () => {
+        it("should call unlink on the cache file", async () => {
+            vi.mocked(unlink).mockResolvedValue(undefined);
+            await clearUpdateCache();
+            expect(unlink).toHaveBeenCalledWith(expect.stringContaining("update-check.json"));
+        });
+        it("should silently handle errors when file does not exist", async () => {
+            vi.mocked(unlink).mockRejectedValue(new Error("ENOENT"));
+            await expect(clearUpdateCache()).resolves.toBeUndefined();
+        });
+    });
+});

package/dist/src/update/__tests__/changelog.test.js

@@ -0,0 +1,86 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+// Mock the cache module before importing changelog
+vi.mock("../cache.js", () => ({
+    readCache: vi.fn(),
+    writeCache: vi.fn(),
+}));
+import { readCache, writeCache } from "../cache.js";
+import { fetchChangelog } from "../changelog.js";
+describe("changelog fetcher", () => {
+    const originalFetch = globalThis.fetch;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Default mock: no cache
+        vi.mocked(readCache).mockResolvedValue(null);
+        vi.mocked(writeCache).mockResolvedValue(undefined);
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+        vi.restoreAllMocks();
+    });
+    it("should return content and fallbackUrl on successful fetch", async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({ body: "## Changes\n- Fix bug" }),
+        });
+        const result = await fetchChangelog("2.5.0");
+        expect(result.content).toBe("## Changes\n- Fix bug");
+        expect(result.fallbackUrl).toBe("https://github.com/AlpacaLOS/auq/releases/tag/v2.5.0");
+    });
+    it("should return cached changelog without fetching", async () => {
+        vi.mocked(readCache).mockResolvedValue({
+            lastCheck: Date.now(),
+            latestVersion: "2.5.0",
+            changelog: "## Cached changelog",
+            changelogFetchedAt: Date.now(),
+        });
+        globalThis.fetch = vi.fn();
+        const result = await fetchChangelog("2.5.0");
+        expect(result.content).toBe("## Cached changelog");
+        expect(result.fallbackUrl).toBe("https://github.com/AlpacaLOS/auq/releases/tag/v2.5.0");
+        expect(globalThis.fetch).not.toHaveBeenCalled();
+    });
+    it("should return null content on 403 rate limit", async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue({
+            ok: false,
+            status: 403,
+        });
+        const result = await fetchChangelog("2.5.0");
+        expect(result.content).toBeNull();
+        expect(result.fallbackUrl).toBe("https://github.com/AlpacaLOS/auq/releases/tag/v2.5.0");
+    });
+    it("should return null content on 429 rate limit", async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue({
+            ok: false,
+            status: 429,
+        });
+        const result = await fetchChangelog("2.5.0");
+        expect(result.content).toBeNull();
+        expect(result.fallbackUrl).toBe("https://github.com/AlpacaLOS/auq/releases/tag/v2.5.0");
+    });
+    it("should return null content on network error", async () => {
+        globalThis.fetch = vi.fn().mockRejectedValue(new Error("network error"));
+        const result = await fetchChangelog("2.5.0");
+        expect(result.content).toBeNull();
+        expect(result.fallbackUrl).toBe("https://github.com/AlpacaLOS/auq/releases/tag/v2.5.0");
+    });
+    it("should return null content on non-OK response", async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue({
+            ok: false,
+            status: 500,
+        });
+        const result = await fetchChangelog("2.5.0");
+        expect(result.content).toBeNull();
+        expect(result.fallbackUrl).toBe("https://github.com/AlpacaLOS/auq/releases/tag/v2.5.0");
+    });
+    it("should always have correct fallbackUrl format", async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({ body: "content" }),
+        });
+        const result = await fetchChangelog("3.1.0");
+        expect(result.fallbackUrl).toBe("https://github.com/AlpacaLOS/auq/releases/tag/v3.1.0");
+    });
+});

package/dist/src/update/__tests__/checker.test.js

@@ -0,0 +1,148 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+// Mock dependencies before importing the module under test
+vi.mock("../cache.js", () => ({
+    readCache: vi.fn(),
+    writeCache: vi.fn(),
+    isCacheFresh: vi.fn(),
+    shouldSkipVersion: vi.fn(),
+    clearUpdateCache: vi.fn(),
+}));
+vi.mock("../version.js", () => ({
+    isNewer: vi.fn(),
+    getUpdateType: vi.fn(),
+    getCurrentVersion: vi.fn(() => "1.0.0"),
+}));
+import { readCache, writeCache, isCacheFresh, shouldSkipVersion, clearUpdateCache, } from "../cache.js";
+import { isNewer, getUpdateType, getCurrentVersion } from "../version.js";
+import { UpdateChecker } from "../checker.js";
+describe("UpdateChecker", () => {
+    const originalEnv = { ...process.env };
+    const originalFetch = globalThis.fetch;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Clear env vars that trigger shouldSkipCheck
+        delete process.env.CI;
+        delete process.env.NO_UPDATE_NOTIFIER;
+        delete process.env.NODE_ENV;
+        // Default mocks
+        vi.mocked(readCache).mockResolvedValue(null);
+        vi.mocked(writeCache).mockResolvedValue(undefined);
+        vi.mocked(clearUpdateCache).mockResolvedValue(undefined);
+        vi.mocked(isCacheFresh).mockReturnValue(false);
+        vi.mocked(shouldSkipVersion).mockReturnValue(false);
+        vi.mocked(isNewer).mockReturnValue(false);
+        vi.mocked(getUpdateType).mockReturnValue("patch");
+        vi.mocked(getCurrentVersion).mockReturnValue("1.0.0");
+    });
+    afterEach(() => {
+        process.env = { ...originalEnv };
+        globalThis.fetch = originalFetch;
+        vi.restoreAllMocks();
+    });
+    describe("shouldSkipCheck", () => {
+        it("should return true when CI=true", () => {
+            process.env.CI = "true";
+            const checker = new UpdateChecker("1.0.0");
+            expect(checker.shouldSkipCheck()).toBe(true);
+        });
+        it("should return true when NO_UPDATE_NOTIFIER=1", () => {
+            process.env.NO_UPDATE_NOTIFIER = "1";
+            const checker = new UpdateChecker("1.0.0");
+            expect(checker.shouldSkipCheck()).toBe(true);
+        });
+        it("should return true when NODE_ENV=test", () => {
+            process.env.NODE_ENV = "test";
+            const checker = new UpdateChecker("1.0.0");
+            expect(checker.shouldSkipCheck()).toBe(true);
+        });
+        it("should return false when none of the skip conditions are set", () => {
+            const checker = new UpdateChecker("1.0.0");
+            expect(checker.shouldSkipCheck()).toBe(false);
+        });
+    });
+    describe("check", () => {
+        it("should return null when shouldSkipCheck is true", async () => {
+            process.env.CI = "true";
+            const checker = new UpdateChecker("1.0.0");
+            const result = await checker.check();
+            expect(result).toBeNull();
+        });
+        it("should return UpdateInfo when a newer version is available", async () => {
+            // Ensure shouldSkipCheck returns false
+            process.env.NODE_ENV = "development";
+            vi.mocked(isNewer).mockReturnValue(true);
+            vi.mocked(getUpdateType).mockReturnValue("minor");
+            globalThis.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ "dist-tags": { latest: "1.1.0" } }),
+            });
+            const checker = new UpdateChecker("1.0.0");
+            const result = await checker.check();
+            expect(result).not.toBeNull();
+            expect(result?.currentVersion).toBe("1.0.0");
+            expect(result?.latestVersion).toBe("1.1.0");
+            expect(result?.updateType).toBe("minor");
+            expect(result?.changelogUrl).toContain("v1.1.0");
+        });
+        it("should return null when versions are the same", async () => {
+            // Ensure shouldSkipCheck returns false
+            process.env.NODE_ENV = "development";
+            vi.mocked(isNewer).mockReturnValue(false);
+            globalThis.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ "dist-tags": { latest: "1.0.0" } }),
+            });
+            const checker = new UpdateChecker("1.0.0");
+            const result = await checker.check();
+            expect(result).toBeNull();
+        });
+        it("should return null on fetch error", async () => {
+            // Ensure shouldSkipCheck returns false
+            process.env.NODE_ENV = "development";
+            globalThis.fetch = vi.fn().mockRejectedValue(new Error("network error"));
+            const checker = new UpdateChecker("1.0.0");
+            const result = await checker.check();
+            expect(result).toBeNull();
+        });
+        it("should memoize: two check() calls only fetch once", async () => {
+            // Ensure shouldSkipCheck returns false
+            process.env.NODE_ENV = "development";
+            vi.mocked(isNewer).mockReturnValue(true);
+            vi.mocked(getUpdateType).mockReturnValue("patch");
+            globalThis.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ "dist-tags": { latest: "1.0.1" } }),
+            });
+            const checker = new UpdateChecker("1.0.0");
+            const [result1, result2] = await Promise.all([
+                checker.check(),
+                checker.check(),
+            ]);
+            // Both should resolve to the same value
+            expect(result1).toStrictEqual(result2);
+            // Fetch should have been called only once (memoized)
+            expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe("clearCache", () => {
+        it("should reset the memoized promise", async () => {
+            // Ensure shouldSkipCheck returns false
+            process.env.NODE_ENV = "development";
+            vi.mocked(isNewer).mockReturnValue(true);
+            vi.mocked(getUpdateType).mockReturnValue("patch");
+            globalThis.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ "dist-tags": { latest: "1.0.1" } }),
+            });
+            const checker = new UpdateChecker("1.0.0");
+            // First check
+            const result1 = await checker.check();
+            expect(result1).not.toBeNull();
+            // Clear cache
+            checker.clearCache();
+            // Second check should create a new promise (calls fetch again)
+            const result2 = await checker.check();
+            expect(globalThis.fetch).toHaveBeenCalledTimes(2);
+        });
+    });
+});