inup 1.4.0

package/dist/services/changelog-fetcher.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changelogFetcher = exports.ChangelogFetcher = void 0;
+/**
+ * Fetches package metadata from npm registry
+ * Includes description, repository info, and basic metadata
+ */
+class ChangelogFetcher {
+    constructor() {
+        this.cache = new Map();
+        this.failureCache = new Set(); // Track packages that failed to fetch
+    }
+    /**
+     * Fetch package metadata from npm registry
+     * Uses a cached approach to avoid repeated requests
+     */
+    async fetchPackageMetadata(packageName) {
+        // Check if we already have this in cache
+        if (this.cache.has(packageName)) {
+            return this.cache.get(packageName);
+        }
+        // Check if we already failed to fetch this
+        if (this.failureCache.has(packageName)) {
+            return null;
+        }
+        try {
+            // Fetch from npm registry
+            const response = await this.fetchFromRegistry(packageName);
+            if (!response) {
+                this.failureCache.add(packageName);
+                return null;
+            }
+            const repositoryUrl = this.extractRepositoryUrl(response.repository?.url || '');
+            const npmUrl = `https://www.npmjs.com/package/${encodeURIComponent(packageName)}`;
+            const issuesUrl = repositoryUrl ? `${repositoryUrl}/issues` : undefined;
+            const metadata = {
+                description: response.description || 'No description available',
+                homepage: response.homepage,
+                repository: response.repository,
+                bugs: response.bugs,
+                keywords: response.keywords || [],
+                author: response.author?.name || response.author,
+                license: response.license,
+                repositoryUrl,
+                npmUrl,
+                issuesUrl,
+            };
+            // Try to extract release notes/changelog info
+            if (repositoryUrl) {
+                metadata.releaseNotes = `${repositoryUrl}/releases`;
+            }
+            // Try to get weekly download count
+            try {
+                const downloadsData = await this.fetchDownloadStats(packageName);
+                if (downloadsData) {
+                    metadata.weeklyDownloads = downloadsData.downloads;
+                }
+            }
+            catch {
+                // Ignore download stats errors - optional data
+            }
+            this.cache.set(packageName, metadata);
+            return metadata;
+        }
+        catch (error) {
+            // Cache the failure to avoid retrying
+            this.failureCache.add(packageName);
+            return null;
+        }
+    }
+    /**
+     * Fetch data from npm registry
+     * Returns the package data from the registry
+     */
+    async fetchFromRegistry(packageName) {
+        try {
+            const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}`, {
+                method: 'GET',
+                headers: {
+                    accept: 'application/json',
+                },
+            });
+            if (!response.ok) {
+                return null;
+            }
+            const data = (await response.json());
+            // Get the latest version data
+            const distTags = data['dist-tags'];
+            const latestVersion = distTags?.latest;
+            const versions = data.versions;
+            const latestPackageData = latestVersion ? versions?.[latestVersion] : undefined;
+            return {
+                description: data.description,
+                homepage: (data.homepage || latestPackageData?.homepage),
+                repository: (data.repository || latestPackageData?.repository),
+                bugs: (data.bugs || latestPackageData?.bugs),
+                keywords: (data.keywords || []),
+                author: (data.author || latestPackageData?.author),
+                license: (data.license || latestPackageData?.license),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Extract GitHub URL from repository URL for easier access to releases
+     */
+    extractRepositoryUrl(repoUrl) {
+        if (!repoUrl)
+            return '';
+        // Handle various repository URL formats
+        // git+https://github.com/user/repo.git -> https://github.com/user/repo/releases
+        // https://github.com/user/repo.git -> https://github.com/user/repo/releases
+        // github:user/repo -> https://github.com/user/repo/releases
+        let cleanUrl = repoUrl
+            .replace(/^git\+/, '') // Remove git+ prefix
+            .replace(/\.git$/, '') // Remove .git suffix
+            .replace(/^github:/, 'https://github.com/'); // Convert github: format
+        // Ensure it's a proper URL
+        if (!cleanUrl.startsWith('http')) {
+            cleanUrl = 'https://github.com/' + cleanUrl;
+        }
+        return cleanUrl;
+    }
+    /**
+     * Fetch weekly download statistics from npm
+     */
+    async fetchDownloadStats(packageName) {
+        try {
+            const response = await fetch(`https://api.npmjs.org/downloads/point/last-week/${encodeURIComponent(packageName)}`, {
+                method: 'GET',
+                headers: {
+                    accept: 'application/json',
+                },
+            });
+            if (!response.ok) {
+                return null;
+            }
+            const data = (await response.json());
+            return {
+                downloads: data.downloads || 0,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get repository release URL for a package
+     */
+    getRepositoryReleaseUrl(packageName, version) {
+        const metadata = this.cache.get(packageName);
+        if (!metadata || !metadata.releaseNotes) {
+            return null;
+        }
+        return `${metadata.releaseNotes}/releases/tag/v${version}`;
+    }
+    /**
+     * Cache package metadata directly (used by utils to avoid duplicate fetches)
+     */
+    cacheMetadata(packageName, rawData) {
+        const repositoryUrl = this.extractRepositoryUrl(rawData.repository?.url || '');
+        const npmUrl = `https://www.npmjs.com/package/${encodeURIComponent(packageName)}`;
+        const issuesUrl = repositoryUrl ? `${repositoryUrl}/issues` : undefined;
+        const metadata = {
+            description: rawData.description || 'No description available',
+            homepage: rawData.homepage,
+            repository: rawData.repository,
+            bugs: rawData.bugs,
+            keywords: rawData.keywords || [],
+            author: rawData.author?.name || rawData.author,
+            license: rawData.license,
+            repositoryUrl,
+            npmUrl,
+            issuesUrl,
+        };
+        if (repositoryUrl) {
+            metadata.releaseNotes = `${repositoryUrl}/releases`;
+        }
+        this.cache.set(packageName, metadata);
+    }
+    /**
+     * Clear the cache (useful for testing)
+     */
+    clearCache() {
+        this.cache.clear();
+        this.failureCache.clear();
+    }
+}
+exports.ChangelogFetcher = ChangelogFetcher;
+exports.changelogFetcher = new ChangelogFetcher();
+//# sourceMappingURL=changelog-fetcher.js.map

package/dist/services/index.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * External service integrations
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./npm-registry"), exports);
+__exportStar(require("./jsdelivr-registry"), exports);
+__exportStar(require("./changelog-fetcher"), exports);
+__exportStar(require("./version-checker"), exports);
+//# sourceMappingURL=index.js.map

package/dist/services/jsdelivr-registry.js

@@ -0,0 +1,232 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllPackageDataFromJsdelivr = getAllPackageDataFromJsdelivr;
+exports.clearJsdelivrPackageCache = clearJsdelivrPackageCache;
+exports.closeJsdelivrPool = closeJsdelivrPool;
+const undici_1 = require("undici");
+const semver = __importStar(require("semver"));
+const constants_1 = require("../constants");
+const npm_registry_1 = require("./npm-registry");
+// Create a persistent connection pool for jsDelivr CDN with optimal settings
+// This enables connection reuse and HTTP/1.1 keep-alive for blazing fast requests
+const jsdelivrPool = new undici_1.Pool('https://cdn.jsdelivr.net', {
+    connections: constants_1.MAX_CONCURRENT_REQUESTS, // Maximum concurrent connections
+    pipelining: 10, // Enable request pipelining for even better performance
+    keepAliveTimeout: 60000, // Keep connections alive for 60 seconds
+    keepAliveMaxTimeout: 600000, // Maximum keep-alive timeout
+});
+const packageCache = new Map();
+/**
+ * Fetches package.json from jsdelivr CDN for a specific version tag using undici pool.
+ * Uses connection pooling and keep-alive for maximum performance.
+ * @param packageName - The npm package name
+ * @param versionTag - The version tag (e.g., '14', 'latest')
+ * @returns The package.json content or null if not found
+ */
+async function fetchPackageJsonFromJsdelivr(packageName, versionTag) {
+    try {
+        const url = `${constants_1.JSDELIVR_CDN_URL}/${encodeURIComponent(packageName)}@${versionTag}/package.json`;
+        const { statusCode, body } = await (0, undici_1.request)(url, {
+            dispatcher: jsdelivrPool,
+            method: 'GET',
+            headers: {
+                accept: 'application/json',
+            },
+            headersTimeout: constants_1.REQUEST_TIMEOUT,
+            bodyTimeout: constants_1.REQUEST_TIMEOUT,
+        });
+        if (statusCode !== 200) {
+            // Consume body to prevent memory leaks
+            await body.text();
+            return null;
+        }
+        const text = await body.text();
+        const data = JSON.parse(text);
+        return data.version ? { version: data.version } : null;
+    }
+    catch (error) {
+        console.error(`Error fetching from jsdelivr for package: ${packageName}@${versionTag}`, error);
+        return null;
+    }
+}
+/**
+ * Fetches package data from jsdelivr CDN with fallback to npm registry.
+ * Makes simultaneous requests for @latest and @major version.
+ * @param packageName - The npm package name
+ * @param currentVersion - The current version to extract major from (optional)
+ * @returns Package data with latest version and all versions
+ */
+async function fetchPackageFromJsdelivr(packageName, currentVersion) {
+    // Check cache first
+    const cached = packageCache.get(packageName);
+    if (cached && Date.now() - cached.timestamp < constants_1.CACHE_TTL) {
+        return cached.data;
+    }
+    try {
+        // Determine major version from current version if provided
+        // Need to coerce the version first in case it's a range like ^1.1.5
+        const majorVersion = currentVersion
+            ? semver.major(semver.coerce(currentVersion) || '0.0.0').toString()
+            : null;
+        // Prepare requests: always fetch @latest, and @major if we have a current version
+        const requests = [
+            fetchPackageJsonFromJsdelivr(packageName, 'latest'),
+        ];
+        if (majorVersion) {
+            requests.push(fetchPackageJsonFromJsdelivr(packageName, majorVersion));
+        }
+        // Execute all requests simultaneously
+        const results = await Promise.all(requests);
+        const latestResult = results[0];
+        const majorResult = results[1];
+        if (!latestResult) {
+            // jsdelivr doesn't have this package, fallback to npm registry
+            const npmData = await (0, npm_registry_1.getAllPackageData)([packageName]);
+            const data = npmData.get(packageName) || { latestVersion: 'unknown', allVersions: [] };
+            // Cache the result
+            packageCache.set(packageName, {
+                data,
+                timestamp: Date.now(),
+            });
+            return data;
+        }
+        const latestVersion = latestResult.version;
+        // If we have a major version result, we can build a minimal version list
+        // This is much faster than fetching all versions from npm
+        if (majorResult) {
+            const allVersions = [latestVersion];
+            // Add the major version result if different from latest
+            if (majorResult.version !== latestVersion) {
+                allVersions.push(majorResult.version);
+            }
+            // Add the current version if it's valid and not already in the list
+            if (currentVersion && semver.valid(currentVersion)) {
+                const coerced = semver.coerce(currentVersion);
+                if (coerced && !allVersions.includes(coerced.version)) {
+                    allVersions.push(coerced.version);
+                }
+            }
+            const result = {
+                latestVersion,
+                allVersions: allVersions.sort(semver.rcompare),
+            };
+            // Cache the result
+            packageCache.set(packageName, {
+                data: result,
+                timestamp: Date.now(),
+            });
+            return result;
+        }
+        // No major version provided, just return latest with minimal version list
+        const allVersions = [latestVersion];
+        // Add the current version if it's valid and not already in the list
+        if (currentVersion && semver.valid(currentVersion)) {
+            const coerced = semver.coerce(currentVersion);
+            if (coerced && !allVersions.includes(coerced.version)) {
+                allVersions.push(coerced.version);
+            }
+        }
+        const result = {
+            latestVersion,
+            allVersions: allVersions.sort(semver.rcompare),
+        };
+        // Cache the result
+        packageCache.set(packageName, {
+            data: result,
+            timestamp: Date.now(),
+        });
+        return result;
+    }
+    catch (error) {
+        // Fallback to npm registry on any error
+        const npmData = await (0, npm_registry_1.getAllPackageData)([packageName]);
+        const data = npmData.get(packageName) || { latestVersion: 'unknown', allVersions: [] };
+        // Cache the result
+        packageCache.set(packageName, {
+            data,
+            timestamp: Date.now(),
+        });
+        return data;
+    }
+}
+/**
+ * Fetches package version data from jsdelivr CDN for multiple packages.
+ * Uses undici connection pool for blazing fast performance with connection reuse.
+ * Falls back to npm registry if jsdelivr doesn't have the package.
+ * @param packageNames - Array of package names to fetch
+ * @param currentVersions - Optional map of package names to their current versions
+ * @param onProgress - Optional progress callback
+ * @returns Map of package names to their version data
+ */
+async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onProgress) {
+    const packageData = new Map();
+    if (packageNames.length === 0) {
+        return packageData;
+    }
+    const total = packageNames.length;
+    let completedCount = 0;
+    // Fire all requests simultaneously - undici pool handles concurrency internally
+    // No need for p-limit - the pool's connection limit controls concurrency
+    const allPromises = packageNames.map(async (packageName) => {
+        const currentVersion = currentVersions?.get(packageName);
+        const data = await fetchPackageFromJsdelivr(packageName, currentVersion);
+        packageData.set(packageName, data);
+        completedCount++;
+        if (onProgress) {
+            onProgress(packageName, completedCount, total);
+        }
+    });
+    // Wait for all requests to complete
+    await Promise.all(allPromises);
+    // Clear the progress line and show completion time if no custom progress handler
+    if (!onProgress) {
+        process.stdout.write('\r' + ' '.repeat(80) + '\r');
+    }
+    return packageData;
+}
+/**
+ * Clear the package cache (useful for testing)
+ */
+function clearJsdelivrPackageCache() {
+    packageCache.clear();
+}
+/**
+ * Close the jsDelivr connection pool (useful for graceful shutdown)
+ */
+async function closeJsdelivrPool() {
+    await jsdelivrPool.close();
+}
+//# sourceMappingURL=jsdelivr-registry.js.map

package/dist/services/npm-registry.js

@@ -0,0 +1,145 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllPackageData = getAllPackageData;
+exports.clearPackageCache = clearPackageCache;
+exports.closeNpmPool = closeNpmPool;
+const undici_1 = require("undici");
+const semver = __importStar(require("semver"));
+const constants_1 = require("../constants");
+// Create a persistent connection pool for npm registry with optimal settings
+// This enables connection reuse and HTTP/1.1 keep-alive for blazing fast requests
+const npmPool = new undici_1.Pool('https://registry.npmjs.org', {
+    connections: constants_1.MAX_CONCURRENT_REQUESTS, // Maximum concurrent connections
+    pipelining: 10, // Enable request pipelining for even better performance
+    keepAliveTimeout: 60000, // Keep connections alive for 60 seconds
+    keepAliveMaxTimeout: 600000, // Maximum keep-alive timeout
+});
+const packageCache = new Map();
+/**
+ * Fetches package data from npm registry with caching using undici pool.
+ * Uses connection pooling and keep-alive for maximum performance.
+ */
+async function fetchPackageFromRegistry(packageName) {
+    // Check cache first
+    const cached = packageCache.get(packageName);
+    if (cached && Date.now() - cached.timestamp < constants_1.CACHE_TTL) {
+        return cached.data;
+    }
+    try {
+        const url = `${constants_1.NPM_REGISTRY_URL}/${encodeURIComponent(packageName)}`;
+        const { statusCode, body } = await (0, undici_1.request)(url, {
+            dispatcher: npmPool,
+            method: 'GET',
+            headers: {
+                accept: 'application/vnd.npm.install-v1+json',
+            },
+            headersTimeout: constants_1.REQUEST_TIMEOUT,
+            bodyTimeout: constants_1.REQUEST_TIMEOUT,
+        });
+        if (statusCode !== 200) {
+            // Consume body to prevent memory leaks
+            await body.text();
+            throw new Error(`HTTP ${statusCode}`);
+        }
+        const text = await body.text();
+        const data = JSON.parse(text);
+        // Extract versions and filter to valid semver (X.Y.Z format, no pre-releases)
+        const allVersions = Object.keys(data.versions || {}).filter((version) => {
+            // Match only X.Y.Z format (no pre-release, no build metadata)
+            return /^[0-9]+\.[0-9]+\.[0-9]+$/.test(version);
+        });
+        // Sort versions to find the latest
+        const sortedVersions = allVersions.sort(semver.rcompare);
+        const latestVersion = sortedVersions.length > 0 ? sortedVersions[0] : 'unknown';
+        const result = {
+            latestVersion,
+            allVersions,
+        };
+        // Cache the result
+        packageCache.set(packageName, {
+            data: result,
+            timestamp: Date.now(),
+        });
+        return result;
+    }
+    catch (error) {
+        // Return fallback data for failed packages
+        return { latestVersion: 'unknown', allVersions: [] };
+    }
+}
+/**
+ * Fetches package version data from npm registry for multiple packages.
+ * Uses undici connection pool for blazing fast performance with connection reuse.
+ * Only returns valid semantic versions (X.Y.Z format, excluding pre-releases).
+ */
+async function getAllPackageData(packageNames, onProgress) {
+    const packageData = new Map();
+    if (packageNames.length === 0) {
+        return packageData;
+    }
+    const total = packageNames.length;
+    let completedCount = 0;
+    // Fire all requests simultaneously - undici pool handles concurrency internally
+    // No need for p-limit - the pool's connection limit controls concurrency
+    const allPromises = packageNames.map(async (packageName) => {
+        const data = await fetchPackageFromRegistry(packageName);
+        packageData.set(packageName, data);
+        completedCount++;
+        if (onProgress) {
+            onProgress(packageName, completedCount, total);
+        }
+    });
+    // Wait for all requests to complete
+    await Promise.all(allPromises);
+    // Clear the progress line and show completion time if no custom progress handler
+    if (!onProgress) {
+        process.stdout.write('\r' + ' '.repeat(80) + '\r');
+    }
+    return packageData;
+}
+/**
+ * Clear the package cache (useful for testing)
+ */
+function clearPackageCache() {
+    packageCache.clear();
+}
+/**
+ * Close the npm registry connection pool (useful for graceful shutdown)
+ */
+async function closeNpmPool() {
+    await npmPool.close();
+}
+//# sourceMappingURL=npm-registry.js.map