inup 1.4.10 → 1.5.0

package/README.md

@@ -14,12 +14,6 @@ Upgrade your dependencies interactively. Works with npm, yarn, pnpm, and bun.
 npx inup
 ```
 
-Scan deeper package layouts:
-
-```bash
-npx inup --max-depth 15
-```
-
 Or install globally:
 
 ```bash
@@ -66,7 +60,7 @@ inup [options]
 
 We don't track anything. Ever.
 
-The only network requests made are to the npm registry and jsDelivr CDN to fetch package version data. That's it.
+Version checks and package metadata are fetched from the npm registry. When needed for immutable exact-version manifests, inup may also fetch a pinned `package.json` from jsDelivr. Weekly download counts come from the npm downloads API.
 
 ## 📄 License
 

package/dist/cli.js

@@ -25,7 +25,6 @@ program
     .option('--package-manager <name>', 'manually specify package manager (npm, yarn, pnpm, bun)')
     .option('--debug', 'write verbose debug log to /tmp/inup-debug-YYYY-MM-DD.log')
     .action(async (options) => {
-    console.log(chalk_1.default.bold.blue(`🚀 `) + chalk_1.default.bold.red(`i`) + chalk_1.default.bold.yellow(`n`) + chalk_1.default.bold.blue(`u`) + chalk_1.default.bold.magenta(`p`) + `\n`);
     const cwd = (0, path_1.resolve)(options.dir);
     if (options.debug || process.env.INUP_DEBUG === '1') {
         (0, utils_1.enableDebugLogging)();
@@ -73,6 +72,8 @@ program
         maxDepth,
         ignorePackages,
         packageManager,
+        showPeerDependencyVulnerabilities: projectConfig.showPeerDependencyVulnerabilities ?? false,
+        showOptionalDependencyVulnerabilities: projectConfig.showOptionalDependencyVulnerabilities ?? false,
         debug: options.debug || process.env.INUP_DEBUG === '1',
     });
     await upgrader.run();

package/dist/config/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_REGISTRY = exports.JSDELIVR_POOL_TIMEOUT = exports.JSDELIVR_RETRY_DELAYS = exports.JSDELIVR_RETRY_TIMEOUTS = exports.REQUEST_TIMEOUT = exports.CACHE_TTL = exports.MAX_CONCURRENT_REQUESTS = exports.JSDELIVR_CDN_URL = exports.NPM_REGISTRY_URL = exports.PACKAGE_NAME = void 0;
+exports.JSDELIVR_POOL_TIMEOUT = exports.JSDELIVR_RETRY_DELAYS = exports.JSDELIVR_RETRY_TIMEOUTS = exports.REQUEST_TIMEOUT = exports.CACHE_TTL = exports.MAX_CONCURRENT_REQUESTS = exports.JSDELIVR_CDN_URL = exports.NPM_REGISTRY_URL = exports.PACKAGE_NAME = void 0;
 exports.PACKAGE_NAME = 'inup';
 exports.NPM_REGISTRY_URL = 'https://registry.npmjs.org';
 exports.JSDELIVR_CDN_URL = 'https://cdn.jsdelivr.net/npm';
@@ -10,5 +10,4 @@ exports.REQUEST_TIMEOUT = 60000; // 60 seconds in milliseconds
 exports.JSDELIVR_RETRY_TIMEOUTS = [2000, 3500]; // short retry budget to keep fallback fast
 exports.JSDELIVR_RETRY_DELAYS = [150]; // tiny backoff between jsDelivr retries in ms
 exports.JSDELIVR_POOL_TIMEOUT = 60000; // keep-alive/connect lifecycle should be looser than per-request timeouts
-exports.DEFAULT_REGISTRY = 'jsdelivr';
 //# sourceMappingURL=constants.js.map

package/dist/config/project-config.js

@@ -49,6 +49,12 @@ function normalizeConfig(config) {
             normalized.exclude = config.exclude.filter((item) => typeof item === 'string');
         }
     }
+    if (typeof config.showPeerDependencyVulnerabilities === 'boolean') {
+        normalized.showPeerDependencyVulnerabilities = config.showPeerDependencyVulnerabilities;
+    }
+    if (typeof config.showOptionalDependencyVulnerabilities === 'boolean') {
+        normalized.showOptionalDependencyVulnerabilities = config.showOptionalDependencyVulnerabilities;
+    }
     return normalized;
 }
 /**

package/dist/core/package-detector.js

@@ -44,6 +44,8 @@ class PackageDetector {
     constructor(options) {
         this.packageJsonPath = null;
         this.packageJson = null;
+        this.batchSize = 25;
+        this.batchConcurrency = 5;
         this.cwd = options?.cwd || process.cwd();
         this.excludePatterns = options?.excludePatterns || [];
         this.ignorePackages = options?.ignorePackages || [];
@@ -57,21 +59,87 @@ class PackageDetector {
         return this.packageJsonPath !== null && this.packageJson !== null;
     }
     async getOutdatedPackages() {
+        const packages = [];
+        await this.streamOutdatedPackages((event) => {
+            if (event.type === 'batch') {
+                event.payload.batch.forEach((item) => {
+                    packages.push(...item.packageInfo);
+                });
+            }
+            else if (event.type === 'complete') {
+                packages.splice(0, packages.length, ...event.payload.packages);
+            }
+        });
+        return packages;
+    }
+    async streamOutdatedPackages(onEvent) {
         if (!this.packageJson) {
             throw new Error('No package.json found in current directory');
         }
-        const packages = [];
         const t0 = Date.now();
         utils_3.debugLog.info('PackageDetector', `Starting scan in ${this.cwd}`);
-        // Always check all package.json files recursively with timeout protection
+        const prepared = await this.prepareDependencies();
+        const initialPayload = {
+            allDependencies: prepared.allDependencies,
+            uniquePackages: prepared.uniquePackages,
+            currentVersions: prepared.currentVersions,
+            progress: this.createProgressSnapshot(prepared.uniquePackages.length, 0, 0, true),
+        };
+        onEvent({ type: 'initial', payload: initialPayload });
+        const packageLookup = new Map();
+        let resolved = 0;
+        let failed = 0;
+        const tFetch = Date.now();
+        utils_3.debugLog.info('PackageDetector', 'fetching version data via npm registry in batches');
+        await (0, services_1.getAllPackageDataBatched)(prepared.uniquePackages, (batch) => {
+            const batchItems = batch.map((batchItem) => {
+                const packageInfo = this.resolvePackageGroup(batchItem.packageName, prepared.allDependencies, batchItem.data);
+                packageLookup.set(batchItem.packageName, packageInfo);
+                resolved++;
+                const isFailed = batchItem.data.latestVersion === 'unknown';
+                if (isFailed) {
+                    failed++;
+                }
+                return {
+                    packageName: batchItem.packageName,
+                    packageInfo,
+                    failed: isFailed,
+                };
+            });
+            const progress = this.createProgressSnapshot(prepared.uniquePackages.length, resolved, failed, resolved < prepared.uniquePackages.length);
+            onEvent({
+                type: 'batch',
+                payload: {
+                    batch: batchItems,
+                    progress,
+                },
+            });
+        }, prepared.currentVersions, {
+            batchSize: this.batchSize,
+            concurrency: this.batchConcurrency,
+        });
+        utils_3.debugLog.perf('PackageDetector', `registry fetch (${resolved}/${prepared.uniquePackages.length} resolved)`, tFetch);
+        const finalPackages = prepared.uniquePackages.flatMap((packageName) => packageLookup.get(packageName) ?? []);
+        const progress = this.createProgressSnapshot(prepared.uniquePackages.length, resolved, failed, false);
+        utils_3.debugLog.perf('PackageDetector', `total scan complete (${finalPackages.filter((p) => p.isOutdated).length} outdated of ${finalPackages.length} deps)`, t0);
+        onEvent({
+            type: 'complete',
+            payload: {
+                packages: finalPackages,
+                progress,
+            },
+        });
+        utils_2.ConsoleUtils.clearProgress();
+        return finalPackages;
+    }
+    async prepareDependencies() {
         this.showProgress('🔍 Scanning repository for package.json files...');
         const tScan = Date.now();
-        const allPackageJsonFiles = await this.findPackageJsonFilesWithTimeout(30000); // 30 second timeout
+        const allPackageJsonFiles = await this.findPackageJsonFilesWithTimeout(30000);
         utils_3.debugLog.perf('PackageDetector', `file scan (${allPackageJsonFiles.length} files)`, tScan, {
             files: allPackageJsonFiles,
         });
         this.showProgress(`🔍 Found ${allPackageJsonFiles.length} package.json file${allPackageJsonFiles.length === 1 ? '' : 's'}`);
-        // Step 2: Collect all dependencies from package.json files (parallelized)
         this.showProgress('🔍 Reading dependencies from package.json files...');
         const tDeps = Date.now();
         const allDepsRaw = await (0, utils_1.collectAllDependenciesAsync)(allPackageJsonFiles, {
@@ -79,10 +147,9 @@ class PackageDetector {
             includeOptionalDeps: true,
         });
         utils_3.debugLog.perf('PackageDetector', `dependency collection (${allDepsRaw.length} raw deps)`, tDeps);
-        // Step 3: Get unique package names while filtering out workspace references and ignored packages
         this.showProgress('🔍 Identifying unique packages...');
         const uniquePackageNames = new Set();
-        const allDeps = [];
+        const allDependencies = [];
         let ignoredCount = 0;
         const seenWorkspaceRefs = new Set();
         const seenIgnored = new Set();
@@ -103,102 +170,111 @@ class PackageDetector {
                 }
                 continue;
             }
-            allDeps.push(dep);
+            allDependencies.push({
+                name: dep.name,
+                version: dep.version,
+                type: dep.type,
+                packageJsonPath: dep.packageJsonPath,
+            });
             uniquePackageNames.add(dep.name);
         }
         if (ignoredCount > 0) {
             this.showProgress(`🔍 Skipped ${ignoredCount} ignored package(s)`);
         }
-        const packageNames = Array.from(uniquePackageNames);
-        utils_3.debugLog.info('PackageDetector', `${packageNames.length} unique packages to check, ${ignoredCount} ignored`);
-        // Step 4: Fetch all package data in one call per package
-        // Create a map of package names to their current versions for major version optimization
+        const uniquePackages = Array.from(uniquePackageNames).sort((a, b) => {
+            const aIsScoped = a.startsWith('@');
+            const bIsScoped = b.startsWith('@');
+            if (aIsScoped && !bIsScoped)
+                return -1;
+            if (!aIsScoped && bIsScoped)
+                return 1;
+            return a.localeCompare(b);
+        });
+        utils_3.debugLog.info('PackageDetector', `${uniquePackages.length} unique packages to check, ${ignoredCount} ignored`);
         const currentVersions = new Map();
-        for (const dep of allDeps) {
-            // Use the first occurrence of each package's version
+        for (const dep of allDependencies) {
             if (!currentVersions.has(dep.name)) {
                 currentVersions.set(dep.name, dep.version);
             }
         }
-        const tFetch = Date.now();
-        utils_3.debugLog.info('PackageDetector', `fetching version data via ${config_1.DEFAULT_REGISTRY}`);
-        const allPackageData = config_1.DEFAULT_REGISTRY === 'jsdelivr'
-            ? await (0, services_1.getAllPackageDataFromJsdelivr)(packageNames, currentVersions, (_currentPackage, completed, total) => {
-                this.showProgress(`🌐 Checking versions... (${completed}/${total} packages)`);
-            })
-            : await (0, services_1.getAllPackageData)(packageNames, (_currentPackage, completed, total) => {
-                this.showProgress(`🌐 Checking versions... (${completed}/${total} packages)`);
-            });
-        utils_3.debugLog.perf('PackageDetector', `registry fetch (${allPackageData.size}/${packageNames.length} resolved)`, tFetch);
-        const loggedOutdated = new Set();
+        return {
+            allDependencies,
+            uniquePackages,
+            currentVersions,
+        };
+    }
+    resolvePackageGroup(packageName, allDependencies, packageData) {
+        const dependencies = allDependencies.filter((dep) => dep.name === packageName);
         const loggedNoData = new Set();
-        try {
-            for (const dep of allDeps) {
-                try {
-                    const packageData = allPackageData.get(dep.name);
-                    if (!packageData) {
-                        if (!loggedNoData.has(dep.name)) {
-                            loggedNoData.add(dep.name);
-                            utils_3.debugLog.warn('PackageDetector', `no data returned for ${dep.name} — skipping`);
-                        }
-                        continue;
-                    }
-                    const { latestVersion, allVersions } = packageData;
-                    // Find closest minor version (same major, higher minor) that satisfies the current range
-                    // Falls back to patch updates if no minor updates are available
-                    const closestMinorVersion = (0, utils_1.findClosestMinorVersion)(dep.version, allVersions);
-                    const installedClean = semver.coerce(dep.version)?.version || dep.version;
-                    const minorClean = closestMinorVersion
-                        ? semver.coerce(closestMinorVersion)?.version || closestMinorVersion
-                        : null;
-                    const latestClean = semver.coerce(latestVersion)?.version || latestVersion;
-                    const hasRangeUpdate = minorClean !== null && minorClean !== installedClean;
-                    const hasMajorUpdate = semver.major(latestClean) > semver.major(installedClean);
-                    const isOutdated = hasRangeUpdate || hasMajorUpdate;
-                    if (isOutdated) {
-                        const outdatedKey = `${dep.name}@${dep.version}`;
-                        if (!loggedOutdated.has(outdatedKey)) {
-                            loggedOutdated.add(outdatedKey);
-                            utils_3.debugLog.info('PackageDetector', `outdated: ${dep.name} ${dep.version} → range:${closestMinorVersion ?? '-'} latest:${latestVersion}`);
-                        }
+        const loggedOutdated = new Set();
+        return dependencies.map((dep) => {
+            try {
+                if (!packageData || packageData.latestVersion === 'unknown') {
+                    if (!loggedNoData.has(dep.name)) {
+                        loggedNoData.add(dep.name);
+                        utils_3.debugLog.warn('PackageDetector', `no data returned for ${dep.name} — marking unavailable`);
                     }
-                    packages.push({
-                        name: dep.name,
-                        currentVersion: dep.version, // Keep original version specifier with prefix
-                        rangeVersion: closestMinorVersion || dep.version,
-                        latestVersion,
-                        type: dep.type,
-                        packageJsonPath: dep.packageJsonPath,
-                        isOutdated,
-                        hasRangeUpdate,
-                        hasMajorUpdate,
-                    });
+                    return this.createFailedPackageInfo(dep);
                 }
-                catch (error) {
-                    utils_3.debugLog.error('PackageDetector', `error processing ${dep.name}`, error);
-                    // Skip packages that can't be checked (private packages, etc.)
-                    packages.push({
-                        name: dep.name,
-                        currentVersion: dep.version,
-                        rangeVersion: 'unknown',
-                        latestVersion: 'unknown',
-                        type: dep.type,
-                        packageJsonPath: dep.packageJsonPath,
-                        isOutdated: false,
-                        hasRangeUpdate: false,
-                        hasMajorUpdate: false,
-                    });
+                const { latestVersion, allVersions } = packageData;
+                const closestMinorVersion = (0, utils_1.findClosestMinorVersion)(dep.version, allVersions);
+                const installedClean = semver.coerce(dep.version)?.version || dep.version;
+                const minorClean = closestMinorVersion
+                    ? semver.coerce(closestMinorVersion)?.version || closestMinorVersion
+                    : null;
+                const latestClean = semver.coerce(latestVersion)?.version || latestVersion;
+                const hasRangeUpdate = minorClean !== null && minorClean !== installedClean;
+                const hasMajorUpdate = semver.valid(latestClean) !== null &&
+                    semver.valid(installedClean) !== null &&
+                    semver.major(latestClean) > semver.major(installedClean);
+                const isOutdated = hasRangeUpdate || hasMajorUpdate;
+                if (isOutdated) {
+                    const outdatedKey = `${dep.name}@${dep.version}`;
+                    if (!loggedOutdated.has(outdatedKey)) {
+                        loggedOutdated.add(outdatedKey);
+                        utils_3.debugLog.info('PackageDetector', `outdated: ${dep.name} ${dep.version} → range:${closestMinorVersion ?? '-'} latest:${latestVersion}`);
+                    }
                 }
+                return {
+                    name: dep.name,
+                    currentVersion: dep.version,
+                    rangeVersion: closestMinorVersion || dep.version,
+                    latestVersion,
+                    type: dep.type,
+                    packageJsonPath: dep.packageJsonPath,
+                    isOutdated,
+                    hasRangeUpdate,
+                    hasMajorUpdate,
+                    allVersions,
+                };
             }
-            const outdatedCount = packages.filter((p) => p.isOutdated).length;
-            utils_3.debugLog.perf('PackageDetector', `total scan complete (${outdatedCount} outdated of ${packages.length} deps)`, t0);
-            return packages;
-        }
-        catch (error) {
-            this.showProgress('❌ Failed to check packages\n');
-            utils_3.debugLog.error('PackageDetector', 'fatal error during package check', error);
-            throw error;
-        }
+            catch (error) {
+                utils_3.debugLog.error('PackageDetector', `error processing ${dep.name}`, error);
+                return this.createFailedPackageInfo(dep);
+            }
+        });
+    }
+    createFailedPackageInfo(dep) {
+        return {
+            name: dep.name,
+            currentVersion: dep.version,
+            rangeVersion: 'unknown',
+            latestVersion: 'unknown',
+            type: dep.type,
+            packageJsonPath: dep.packageJsonPath,
+            isOutdated: false,
+            hasRangeUpdate: false,
+            hasMajorUpdate: false,
+        };
+    }
+    createProgressSnapshot(total, resolved, failed, isLoading) {
+        return {
+            discovered: total,
+            resolved,
+            total,
+            failed,
+            isLoading,
+        };
     }
     async findPackageJsonFilesWithTimeout(timeoutMs) {
         try {
@@ -206,7 +282,6 @@ class PackageDetector {
             try {
                 return await Promise.race([
                     (0, utils_1.findAllPackageJsonFilesAsync)(this.cwd, this.excludePatterns, this.maxDepth, (currentDir, foundCount) => {
-                        // Show scanning progress with current directory and count
                         const truncatedDir = currentDir.length > 50 ? '...' + currentDir.slice(-47) : currentDir;
                         this.showProgress(`🔍 Scanning ${truncatedDir} (found ${foundCount})`);
                     }),
@@ -229,7 +304,6 @@ class PackageDetector {
         }
     }
     isWorkspaceReference(version) {
-        // Check for common workspace reference patterns
         return (version.includes('workspace:') ||
             version === '*' ||
             version.startsWith('file:') ||

package/dist/core/upgrade-runner.js

@@ -9,6 +9,7 @@ const package_detector_1 = require("./package-detector");
 const interactive_ui_1 = require("../interactive-ui");
 const upgrader_1 = require("./upgrader");
 const package_manager_detector_1 = require("../services/package-manager-detector");
+const utils_1 = require("../ui/utils");
 /**
  * Main orchestrator for the inup upgrade process
  */
@@ -24,34 +25,82 @@ class UpgradeRunner {
             this.packageManager = package_manager_detector_1.PackageManagerDetector.detect(cwd);
         }
         this.detector = new package_detector_1.PackageDetector(options);
-        this.ui = new interactive_ui_1.InteractiveUI(this.packageManager);
+        this.ui = new interactive_ui_1.InteractiveUI(this.packageManager, {
+            showPeerDependencyVulnerabilities: options?.showPeerDependencyVulnerabilities ?? false,
+            showOptionalDependencyVulnerabilities: options?.showOptionalDependencyVulnerabilities ?? false,
+        });
         this.upgrader = new upgrader_1.PackageUpgrader(this.packageManager);
     }
     async run() {
         try {
             // Check prerequisites
             this.checkPrerequisites();
-            // Detect packages
-            const packages = await this.detector.getOutdatedPackages();
-            // Display packages table
-            await this.ui.displayPackagesTable(packages);
-            const outdatedPackages = this.detector.getOutdatedPackagesOnly(packages);
-            if (outdatedPackages.length === 0) {
+            const progress = {
+                discovered: 0,
+                resolved: 0,
+                total: 0,
+                failed: 0,
+                isLoading: true,
+            };
+            let selectionStates = [];
+            let refreshUI;
+            let latestPackages = [];
+            let previousSelections;
+            const selectionPromise = new Promise((resolve, reject) => {
+                const streamPromise = this.detector.streamOutdatedPackages((event) => {
+                    if (event.type === 'initial') {
+                        progress.discovered = event.payload.progress.discovered;
+                        progress.resolved = event.payload.progress.resolved;
+                        progress.total = event.payload.progress.total;
+                        progress.failed = event.payload.progress.failed;
+                        progress.isLoading = event.payload.progress.isLoading;
+                        selectionStates = [];
+                        this.ui
+                            .selectPackagesToUpgradeProgressive(selectionStates, progress, (refresh) => {
+                            refreshUI = refresh;
+                        })
+                            .then(resolve)
+                            .catch(reject);
+                    }
+                    if (event.type === 'batch') {
+                        latestPackages = latestPackages
+                            .filter((pkg) => !event.payload.batch.some((item) => item.packageName === pkg.name))
+                            .concat(event.payload.batch.flatMap((item) => item.packageInfo));
+                        progress.discovered = event.payload.progress.discovered;
+                        progress.resolved = event.payload.progress.resolved;
+                        progress.total = event.payload.progress.total;
+                        progress.failed = event.payload.progress.failed;
+                        progress.isLoading = event.payload.progress.isLoading;
+                        this.ui.appendOutdatedBatchToSelectionStates(selectionStates, event.payload.batch, previousSelections);
+                        refreshUI?.();
+                    }
+                    if (event.type === 'complete') {
+                        latestPackages = event.payload.packages;
+                        progress.discovered = event.payload.progress.discovered;
+                        progress.resolved = event.payload.progress.resolved;
+                        progress.total = event.payload.progress.total;
+                        progress.failed = event.payload.progress.failed;
+                        progress.isLoading = event.payload.progress.isLoading;
+                        refreshUI?.();
+                    }
+                });
+                streamPromise.catch(reject);
+            });
+            let selectedChoices = await selectionPromise;
+            const outdatedPackages = this.detector.getOutdatedPackagesOnly(latestPackages);
+            if (outdatedPackages.length === 0 && selectedChoices.length === 0) {
+                console.log(chalk_1.default.green('✅ All packages are up to date!'));
                 return;
             }
             // Interactive selection and confirmation loop
-            let selectedChoices = [];
             let shouldProceed = false;
-            let previousSelections;
             while (true) {
-                // Interactive selection
-                selectedChoices = await this.ui.selectPackagesToUpgrade(packages, previousSelections);
                 if (selectedChoices.length === 0) {
                     console.log(chalk_1.default.yellow('No packages selected. Exiting...'));
                     return;
                 }
                 // Validate selected choices before confirmation
-                this.validateSelectedChoices(selectedChoices, packages);
+                this.validateSelectedChoices(selectedChoices, latestPackages);
                 // Store current selections for potential return to selection
                 previousSelections = new Map();
                 // Convert selectedChoices back to selection state format
@@ -69,9 +118,12 @@ class UpgradeRunner {
                 shouldProceed = await this.ui.confirmUpgrade(selectedChoices);
                 if (shouldProceed === null) {
                     // User pressed N or ESC - go back to selection with current selections preserved
-                    console.clear();
-                    console.log(chalk_1.default.bold.blue('🚀 inup\n'));
-                    // previousSelections is already set from above
+                    utils_1.ConsoleUtils.clearProgress();
+                    selectedChoices = progress.isLoading
+                        ? await this.ui.selectPackagesToUpgradeProgressive(selectionStates, progress, (refresh) => {
+                            refreshUI = refresh;
+                        })
+                        : await this.ui.selectPackagesToUpgrade(latestPackages, previousSelections);
                     continue;
                 }
                 if (!shouldProceed) {
@@ -82,7 +134,7 @@ class UpgradeRunner {
                 break;
             }
             // Perform upgrade
-            await this.upgrader.upgradePackages(selectedChoices, packages);
+            await this.upgrader.upgradePackages(selectedChoices, latestPackages);
         }
         catch (error) {
             console.error(chalk_1.default.red(`Error: ${error}`));

package/dist/features/changelog/clients/github-client.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHubClient = void 0;
+const repository_ref_1 = require("../parsers/repository-ref");
+const GITHUB_RELEASES_PAGE_LIMIT = 3;
+class GitHubClient {
+    constructor() {
+        this.releasesCache = new Map();
+        this.rawChangelogCache = new Map();
+    }
+    clearCache() {
+        this.releasesCache.clear();
+        this.rawChangelogCache.clear();
+    }
+    async fetchReleaseByTag(repoUrl, tag, signal) {
+        const repo = (0, repository_ref_1.parseGitHubRepo)(repoUrl);
+        if (!repo)
+            return null;
+        try {
+            const response = await fetch(`https://api.github.com/repos/${repo.owner}/${repo.repo}/releases/tags/${tag}`, {
+                method: 'GET',
+                headers: {
+                    accept: 'application/vnd.github.v3+json',
+                    'user-agent': 'inup-cli',
+                },
+                signal,
+            });
+            if (!response.ok)
+                return null;
+            const data = (await response.json());
+            return data.body?.trim() ? data.body.trim() : null;
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === 'AbortError') {
+                throw error;
+            }
+            return null;
+        }
+    }
+    async fetchReleasePageHtml(repoUrl, tag, signal) {
+        const repo = (0, repository_ref_1.parseGitHubRepo)(repoUrl);
+        if (!repo)
+            return null;
+        try {
+            const response = await fetch(`https://github.com/${repo.owner}/${repo.repo}/releases/tag/${tag}`, {
+                method: 'GET',
+                signal,
+            });
+            if (!response.ok)
+                return null;
+            return await response.text();
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === 'AbortError') {
+                throw error;
+            }
+            return null;
+        }
+    }
+    async fetchReleases(repoUrl, signal) {
+        const repo = (0, repository_ref_1.parseGitHubRepo)(repoUrl);
+        if (!repo)
+            return null;
+        const cacheKey = `${repo.owner}/${repo.repo}`;
+        if (this.releasesCache.has(cacheKey)) {
+            return this.releasesCache.get(cacheKey);
+        }
+        const releases = [];
+        for (let page = 1; page <= GITHUB_RELEASES_PAGE_LIMIT; page += 1) {
+            try {
+                const response = await fetch(`https://api.github.com/repos/${repo.owner}/${repo.repo}/releases?per_page=100&page=${page}`, {
+                    method: 'GET',
+                    headers: {
+                        accept: 'application/vnd.github.v3+json',
+                        'user-agent': 'inup-cli',
+                    },
+                    signal,
+                });
+                if (!response.ok)
+                    break;
+                const pageReleases = (await response.json());
+                if (!Array.isArray(pageReleases) || pageReleases.length === 0)
+                    break;
+                releases.push(...pageReleases);
+                if (pageReleases.length < 100)
+                    break;
+            }
+            catch (error) {
+                if (error instanceof DOMException && error.name === 'AbortError') {
+                    throw error;
+                }
+                break;
+            }
+        }
+        const result = releases.length > 0 ? releases : null;
+        this.releasesCache.set(cacheKey, result);
+        return result;
+    }
+    async fetchRawChangelog(repoUrl, signal) {
+        const repo = (0, repository_ref_1.parseGitHubRepo)(repoUrl);
+        if (!repo)
+            return null;
+        const cacheKey = `${repo.owner}/${repo.repo}`;
+        if (this.rawChangelogCache.has(cacheKey)) {
+            return this.rawChangelogCache.get(cacheKey);
+        }
+        const branches = ['main', 'master'];
+        const filenames = ['CHANGELOG.md', 'CHANGES.md', 'HISTORY.md'];
+        for (const branch of branches) {
+            for (const filename of filenames) {
+                try {
+                    const response = await fetch(`https://raw.githubusercontent.com/${repo.owner}/${repo.repo}/${branch}/${filename}`, {
+                        method: 'GET',
+                        signal,
+                    });
+                    if (response.ok) {
+                        const text = await response.text();
+                        this.rawChangelogCache.set(cacheKey, text);
+                        return text;
+                    }
+                }
+                catch (error) {
+                    if (error instanceof DOMException && error.name === 'AbortError') {
+                        throw error;
+                    }
+                }
+            }
+        }
+        this.rawChangelogCache.set(cacheKey, null);
+        return null;
+    }
+}
+exports.GitHubClient = GitHubClient;
+//# sourceMappingURL=github-client.js.map