auq-mcp-server 2.4.0 → 2.6.0

package/dist/src/update/package-manager.js

@@ -0,0 +1,49 @@
+/**
+ * Package manager detection for the auto-update system.
+ *
+ * Detects which package manager was used to install AUQ by inspecting
+ * environment variables and process paths, following a priority-based
+ * detection strategy.
+ */
+/** The npm package name used for global install/update commands. */
+export const PACKAGE_NAME = "auq-mcp-server";
+/**
+ * Detects which package manager was used to install AUQ.
+ *
+ * Detection priority:
+ *   1. `process.env.npm_config_user_agent` — most reliable for npm/yarn/pnpm
+ *   2. `process.env.npm_execpath` — fallback for npm-based managers
+ *   3. `process.execPath` — check if executable path contains package manager names
+ *   4. Default to npm as universal fallback
+ *
+ * @returns Package manager info with name and global install command prefix.
+ *          The install command does NOT include the package name — the caller appends it.
+ */
+export function detectPackageManager() {
+    // Priority 1: npm_config_user_agent (most reliable)
+    // Format is typically: "npm/10.2.0 node/v20.9.0 darwin arm64"
+    const userAgent = process.env.npm_config_user_agent || "";
+    if (userAgent.includes("bun"))
+        return { name: "bun", installCommand: "bun add -g" };
+    if (userAgent.includes("yarn"))
+        return { name: "yarn", installCommand: "yarn global add" };
+    if (userAgent.includes("pnpm"))
+        return { name: "pnpm", installCommand: "pnpm add -g" };
+    if (userAgent.includes("npm"))
+        return { name: "npm", installCommand: "npm install -g" };
+    // Priority 2: npm_execpath (path to the package manager executable)
+    const execpath = (process.env.npm_execpath || "").toLowerCase();
+    if (execpath.includes("bun"))
+        return { name: "bun", installCommand: "bun add -g" };
+    if (execpath.includes("yarn"))
+        return { name: "yarn", installCommand: "yarn global add" };
+    if (execpath.includes("pnpm"))
+        return { name: "pnpm", installCommand: "pnpm add -g" };
+    // Priority 3: process.execPath (runtime executable path)
+    // Useful for detecting bun when run outside a package manager context
+    const execPath = process.execPath.toLowerCase();
+    if (execPath.includes("bun"))
+        return { name: "bun", installCommand: "bun add -g" };
+    // Priority 4: Default fallback — npm is universally available
+    return { name: "npm", installCommand: "npm install -g" };
+}

package/dist/src/update/types.js

@@ -0,0 +1,7 @@
+/**
+ * TypeScript type definitions for the auto-update system.
+ *
+ * These interfaces define the data structures used throughout the update module
+ * for version checking, caching, package manager detection, and changelog fetching.
+ */
+export {};

package/dist/src/update/version.js

@@ -0,0 +1,114 @@
+/**
+ * Semver comparison utilities for the auto-update system.
+ *
+ * Provides version parsing, comparison, and update type detection
+ * without requiring external dependencies like the `semver` package.
+ */
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+/**
+ * Parse a version string into its numeric components.
+ *
+ * Strips a leading `v` prefix if present. Splits prerelease
+ * identifiers on `-`. Handles two-part versions like "2.5"
+ * by treating the missing patch as 0.
+ *
+ * @param version - Semver string, e.g., "2.5.0", "v1.2.3-beta.1"
+ * @returns Parsed version object
+ * @throws Error if any numeric component is NaN
+ */
+export function parseVersion(version) {
+    // Strip leading 'v' prefix
+    const cleaned = version.startsWith("v") ? version.slice(1) : version;
+    // Separate prerelease from numeric parts
+    const [numericPart, ...prereleaseParts] = cleaned.split("-");
+    const prerelease = prereleaseParts.length > 0 ? prereleaseParts.join("-") : undefined;
+    const parts = numericPart.split(".");
+    const major = Number(parts[0]);
+    const minor = Number(parts[1] ?? "0");
+    const patch = Number(parts[2] ?? "0");
+    if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch)) {
+        throw new Error(`Invalid version string: "${version}"`);
+    }
+    return { major, minor, patch, prerelease };
+}
+/**
+ * Determine if `latest` is newer than `current`.
+ *
+ * Compares major, minor, and patch components numerically.
+ * For prerelease handling: a version WITH a prerelease tag is
+ * considered OLDER than the same version WITHOUT one
+ * (e.g., `2.5.0-beta.1 < 2.5.0`).
+ *
+ * @param current - Currently installed version
+ * @param latest - Latest available version
+ * @returns true if `latest` is strictly newer than `current`
+ */
+export function isNewer(current, latest) {
+    const c = parseVersion(current);
+    const l = parseVersion(latest);
+    // Compare major.minor.patch numerically
+    if (l.major !== c.major)
+        return l.major > c.major;
+    if (l.minor !== c.minor)
+        return l.minor > c.minor;
+    if (l.patch !== c.patch)
+        return l.patch > c.patch;
+    // Same numeric version — check prerelease
+    // A version with prerelease is older than the same version without
+    if (c.prerelease && !l.prerelease)
+        return true;
+    if (!c.prerelease && l.prerelease)
+        return false;
+    // Both have prerelease or both don't — considered equal
+    return false;
+}
+/**
+ * Determine the type of update between two versions.
+ *
+ * @param current - Currently installed version
+ * @param latest - Latest available version
+ * @returns "major" | "minor" | "patch"
+ */
+export function getUpdateType(current, latest) {
+    const c = parseVersion(current);
+    const l = parseVersion(latest);
+    if (l.major > c.major)
+        return "major";
+    if (l.minor > c.minor)
+        return "minor";
+    return "patch";
+}
+/**
+ * Read the current installed version from the package's package.json.
+ *
+ * Resolves the path relative to this module's location, trying
+ * multiple paths to handle both local dev and global install layouts.
+ *
+ * @returns The current version string
+ * @throws Error if package.json cannot be found or parsed
+ */
+export function getCurrentVersion() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    // Try different possible paths for package.json
+    // - ../../package.json: from src/update/ in local dev (src/update -> src -> root)
+    // - ../../../package.json: from dist/update/ in global install (dist/update -> dist -> root)
+    const possiblePaths = [
+        join(__dirname, "..", "..", "package.json"),
+        join(__dirname, "..", "..", "..", "package.json"),
+    ];
+    for (const path of possiblePaths) {
+        try {
+            const packageJson = JSON.parse(readFileSync(path, "utf-8"));
+            if (packageJson.version) {
+                return packageJson.version;
+            }
+        }
+        catch {
+            // Try next path
+        }
+    }
+    throw new Error("Could not determine current version from package.json");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auq-mcp-server",
-  "version": "2.4.0",
+  "version": "2.6.0",
   "main": "dist/index.js",
   "bin": {
     "auq": "dist/bin/auq.js"

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

@@ -1,19 +0,0 @@
-import { Text } from "ink";
-import React, { useEffect, useState } from "react";
-import { useTheme } from "../ThemeContext.js";
-const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-/**
- * Spinner displays an animated loading indicator
- * Uses braille pattern characters for smooth animation
- */
-export const Spinner = ({ color }) => {
-    const { theme } = useTheme();
-    const [frame, setFrame] = useState(0);
-    useEffect(() => {
-        const timer = setInterval(() => {
-            setFrame((prev) => (prev + 1) % SPINNER_FRAMES.length);
-        }, 80);
-        return () => clearInterval(timer);
-    }, []);
-    return (React.createElement(Text, { color: color ?? theme.colors.primary }, SPINNER_FRAMES[frame]));
-};

package/dist/src/tui/utils/__tests__/detectTheme.test.js

@@ -1,78 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { detectSystemTheme, clearThemeCache } from "../detectTheme.js";
-describe("detectSystemTheme", () => {
-    const originalEnv = process.env;
-    beforeEach(() => {
-        // Reset environment and clear cache before each test
-        process.env = { ...originalEnv };
-        clearThemeCache();
-    });
-    afterEach(() => {
-        process.env = originalEnv;
-        clearThemeCache();
-    });
-    describe("COLORFGBG detection", () => {
-        it("should detect dark theme when background is 0 (black)", () => {
-            process.env.COLORFGBG = "15;0";
-            expect(detectSystemTheme()).toBe("dark");
-        });
-        it("should detect dark theme when background is 6", () => {
-            process.env.COLORFGBG = "7;6";
-            expect(detectSystemTheme()).toBe("dark");
-        });
-        it("should detect light theme when background is 7 (white/light gray)", () => {
-            process.env.COLORFGBG = "0;7";
-            expect(detectSystemTheme()).toBe("light");
-        });
-        it("should detect light theme when background is 15 (bright white)", () => {
-            process.env.COLORFGBG = "0;15";
-            expect(detectSystemTheme()).toBe("light");
-        });
-        it("should handle three-part COLORFGBG format", () => {
-            // Some terminals use foreground;middle;background format
-            process.env.COLORFGBG = "15;default;0";
-            expect(detectSystemTheme()).toBe("dark");
-        });
-        it("should handle three-part COLORFGBG with light background", () => {
-            process.env.COLORFGBG = "0;default;15";
-            expect(detectSystemTheme()).toBe("light");
-        });
-    });
-    describe("fallback behavior", () => {
-        it("should fallback to dark when COLORFGBG is not set", () => {
-            delete process.env.COLORFGBG;
-            expect(detectSystemTheme()).toBe("dark");
-        });
-        it("should fallback to dark when COLORFGBG is invalid", () => {
-            process.env.COLORFGBG = "invalid";
-            expect(detectSystemTheme()).toBe("dark");
-        });
-        it("should fallback to dark when COLORFGBG has invalid number", () => {
-            process.env.COLORFGBG = "15;abc";
-            expect(detectSystemTheme()).toBe("dark");
-        });
-        it("should fallback to dark when COLORFGBG is empty", () => {
-            process.env.COLORFGBG = "";
-            expect(detectSystemTheme()).toBe("dark");
-        });
-    });
-    describe("caching", () => {
-        it("should cache the result", () => {
-            process.env.COLORFGBG = "15;0";
-            expect(detectSystemTheme()).toBe("dark");
-            // Change the environment variable
-            process.env.COLORFGBG = "0;15";
-            // Should still return cached result
-            expect(detectSystemTheme()).toBe("dark");
-        });
-        it("should return fresh result after cache is cleared", () => {
-            process.env.COLORFGBG = "15;0";
-            expect(detectSystemTheme()).toBe("dark");
-            // Clear cache and change environment
-            clearThemeCache();
-            process.env.COLORFGBG = "0;15";
-            // Should return new result
-            expect(detectSystemTheme()).toBe("light");
-        });
-    });
-});