@compass-ai/nova 1.0.74 → 1.0.76

package/dist/services/update-service.js

@@ -1,749 +0,0 @@
-/**
- * Auto-update service for the Compass CLI.
- *
- * This module provides functionality to check for updates, notify users,
- * and manage the update lifecycle. It uses update-notifier for npm registry
- * checks and provides a comprehensive update management system.
- *
- * Key features:
- * - Automatic update checking on startup (configurable)
- * - Manual update checking via /update command
- * - Update notification banners with customizable styles
- * - Update history tracking
- * - Configurable check intervals and notification preferences
- */
-import updateNotifier from 'update-notifier';
-import boxen from 'boxen';
-import chalk from 'chalk';
-import semver from 'semver';
-import { readFile } from 'fs/promises';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { execa } from 'execa';
-import { getGlobalCompassDir } from '../utils/path.js';
-import { ensureDir, pathExists, safeReadJson, safeWriteJson } from '../utils/file-system.js';
-import { logger } from '../utils/logger.js';
-/**
- * Package metadata - uses build-time constants if available, otherwise fallback values
- */
-const PACKAGE_NAME = typeof __PKG_NAME__ !== 'undefined' ? __PKG_NAME__ : '@compass-ai/nova';
-const CURRENT_VERSION = typeof __PKG_VERSION__ !== 'undefined' ? __PKG_VERSION__ : '0.0.0';
-const CACHE_VERSION = '1.0.0';
-/**
- * Resolve the path to this package's package.json
- */
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const PACKAGE_JSON_PATH = path.resolve(__dirname, '../../package.json');
-/**
- * Cache file name for storing update data
- */
-const UPDATE_CACHE_FILE = 'update-cache.json';
-/**
- * Default update configuration
- */
-const defaultConfig = {
-    checkOnStartup: true,
-    checkInterval: 4, // hours
-    showNotifications: true,
-    notificationStyle: 'banner',
-    includePrerelease: false,
-};
-/**
- * UpdateService class manages all update-related functionality.
- */
-export class UpdateService {
-    config;
-    cache;
-    cacheFilePath;
-    packageJson;
-    constructor(config, packageJson) {
-        this.config = config;
-        this.packageJson = packageJson;
-        this.cacheFilePath = path.join(getGlobalCompassDir(), UPDATE_CACHE_FILE);
-        this.cache = {
-            history: [],
-            cacheVersion: CACHE_VERSION,
-        };
-    }
-    /**
-     * Creates and initializes an UpdateService instance.
-     */
-    static async create(config) {
-        const mergedConfig = { ...defaultConfig, ...config };
-        // Read package.json from the installed CLI location for accurate version info
-        let packageJson = { name: PACKAGE_NAME, version: CURRENT_VERSION };
-        try {
-            logger.debug('Update service: resolving package.json', { path: PACKAGE_JSON_PATH });
-            if (await pathExists(PACKAGE_JSON_PATH)) {
-                const pkgContent = await readFile(PACKAGE_JSON_PATH, 'utf-8');
-                const pkg = JSON.parse(pkgContent);
-                packageJson = { name: pkg.name || PACKAGE_NAME, version: pkg.version || CURRENT_VERSION };
-                logger.debug('Update service: loaded package.json', {
-                    name: packageJson.name,
-                    version: packageJson.version,
-                    source: 'package.json',
-                });
-            }
-            else {
-                logger.debug('Update service: package.json not found, using fallback', {
-                    name: packageJson.name,
-                    version: packageJson.version,
-                    source: 'fallback',
-                });
-            }
-        }
-        catch (error) {
-            // Use defaults if package.json can't be read
-            logger.debug('Update service: failed to read package.json, using fallback', {
-                error: error instanceof Error ? error.message : 'unknown error',
-                name: packageJson.name,
-                version: packageJson.version,
-            });
-        }
-        const service = new UpdateService(mergedConfig, packageJson);
-        await service.loadCache();
-        return service;
-    }
-    /**
-     * Loads the update cache from disk.
-     */
-    async loadCache() {
-        try {
-            await ensureDir(getGlobalCompassDir());
-            if (await pathExists(this.cacheFilePath)) {
-                const data = await safeReadJson(this.cacheFilePath);
-                if (data && data.cacheVersion === CACHE_VERSION) {
-                    this.cache = data;
-                }
-            }
-        }
-        catch (error) {
-            logger.debug('Failed to load update cache', error);
-        }
-    }
-    /**
-     * Saves the update cache to disk.
-     */
-    async saveCache() {
-        try {
-            await ensureDir(getGlobalCompassDir());
-            await safeWriteJson(this.cacheFilePath, this.cache);
-        }
-        catch (error) {
-            logger.debug('Failed to save update cache', error);
-        }
-    }
-    /**
-     * Checks for available updates.
-     */
-    async checkForUpdates(force = false) {
-        const result = {
-            updateAvailable: false,
-            currentVersion: this.packageJson.version,
-            checkedAt: new Date().toISOString(),
-        };
-        try {
-            // Check if we should skip based on interval (unless forced)
-            if (!force && this.cache.lastCheck) {
-                // Invalidate cache if the installed version has changed (e.g., user manually updated)
-                if (this.cache.lastCheck.currentVersion !== this.packageJson.version) {
-                    logger.debug('Cache invalidated - installed version changed', {
-                        cachedVersion: this.cache.lastCheck.currentVersion,
-                        installedVersion: this.packageJson.version,
-                    });
-                }
-                else {
-                    const lastCheckTime = new Date(this.cache.lastCheck.checkedAt).getTime();
-                    const intervalMs = this.config.checkInterval * 60 * 60 * 1000;
-                    if (Date.now() - lastCheckTime < intervalMs) {
-                        logger.debug('Skipping update check - within interval');
-                        return this.cache.lastCheck;
-                    }
-                }
-            }
-            logger.debug('Checking for updates...');
-            // Use update-notifier to check npm registry
-            const notifier = updateNotifier({
-                pkg: this.packageJson,
-                updateCheckInterval: 0, // We manage our own interval
-            });
-            // Fetch update info (this can take a moment)
-            const updateInfo = await notifier.fetchInfo();
-            // Only mark as update available if latest version is actually NEWER than current
-            if (updateInfo && updateInfo.latest && semver.gt(updateInfo.latest, this.packageJson.version)) {
-                result.updateAvailable = true;
-                result.latestVersion = updateInfo.latest;
-                result.updateType = this.mapUpdateType(updateInfo.type || 'patch');
-                result.releaseNotesUrl = `https://dev.azure.com/oakpeak-devops/Kore/_git/Kore-CLI?version=GTv${updateInfo.latest}`;
-                // Filter out prerelease if not wanted
-                if (!this.config.includePrerelease && semver.prerelease(updateInfo.latest)) {
-                    result.updateAvailable = false;
-                    result.latestVersion = undefined;
-                    result.updateType = undefined;
-                }
-            }
-            else if (updateInfo && updateInfo.latest && semver.lt(updateInfo.latest, this.packageJson.version)) {
-                logger.debug('Current version is newer than npm registry', {
-                    currentVersion: this.packageJson.version,
-                    registryVersion: updateInfo.latest,
-                });
-            }
-            // Update cache
-            this.cache.lastCheck = result;
-            await this.saveCache();
-            return result;
-        }
-        catch (error) {
-            result.error = error instanceof Error ? error.message : 'Failed to check for updates';
-            logger.debug('Update check failed', error);
-            return result;
-        }
-    }
-    /**
-     * Maps update-notifier type to our UpdateType.
-     */
-    mapUpdateType(type) {
-        switch (type) {
-            case 'major':
-                return 'major';
-            case 'minor':
-                return 'minor';
-            case 'patch':
-                return 'patch';
-            case 'prerelease':
-                return 'prerelease';
-            default:
-                return 'patch';
-        }
-    }
-    /**
-     * Displays an update notification to the user.
-     */
-    displayUpdateNotification(result) {
-        if (!result.updateAvailable || !result.latestVersion || !this.config.showNotifications) {
-            return;
-        }
-        if (this.config.notificationStyle === 'silent') {
-            return;
-        }
-        const notification = this.formatNotification(result);
-        console.log(notification);
-        // Update notification state
-        this.updateNotificationState(result.latestVersion);
-    }
-    /**
-     * Formats the update notification based on style preference.
-     */
-    formatNotification(result) {
-        const { currentVersion, latestVersion, updateType } = result;
-        switch (this.config.notificationStyle) {
-            case 'minimal':
-                return this.formatMinimalNotification(currentVersion, latestVersion, updateType);
-            case 'detailed':
-                return this.formatDetailedNotification(currentVersion, latestVersion, updateType, result.releaseNotesUrl);
-            case 'banner':
-            default:
-                return this.formatBannerNotification(currentVersion, latestVersion, updateType);
-        }
-    }
-    /**
-     * Formats a minimal one-line notification.
-     */
-    formatMinimalNotification(current, latest, type) {
-        const typeColor = this.getUpdateTypeColor(type);
-        return chalk.gray(`Update available: ${current} -> `) + typeColor(latest) + chalk.gray(` (npm i -g ${this.packageJson.name})`);
-    }
-    /**
-     * Formats a banner-style notification using boxen.
-     */
-    formatBannerNotification(current, latest, type) {
-        const typeColor = this.getUpdateTypeColor(type);
-        const typeLabel = type ? ` (${type})` : '';
-        const message = [
-            `Update available! ${chalk.dim(current)} ${chalk.reset('→')} ${typeColor(latest)}${chalk.dim(typeLabel)}`,
-            '',
-            `Run ${chalk.cyan(`npm i -g ${this.packageJson.name}`)} to update`,
-        ].join('\n');
-        return boxen(message, {
-            padding: 1,
-            margin: 1,
-            borderStyle: 'round',
-            borderColor: this.getUpdateTypeBorderColor(type),
-            title: 'Compass CLI Update',
-            titleAlignment: 'center',
-        });
-    }
-    /**
-     * Formats a detailed notification with release notes link.
-     */
-    formatDetailedNotification(current, latest, type, releaseNotesUrl) {
-        const typeColor = this.getUpdateTypeColor(type);
-        const typeLabel = type ? type.charAt(0).toUpperCase() + type.slice(1) : 'New';
-        const lines = [
-            '',
-            chalk.bold.cyan(`  ${typeLabel} Update Available!`),
-            '',
-            `  ${chalk.gray('Current version:')} ${current}`,
-            `  ${chalk.gray('Latest version:')}  ${typeColor(latest)}`,
-            '',
-        ];
-        if (releaseNotesUrl) {
-            lines.push(`  ${chalk.gray('Release notes:')} ${chalk.underline.blue(releaseNotesUrl)}`);
-            lines.push('');
-        }
-        lines.push(`  ${chalk.gray('To update, run:')} ${chalk.cyan(`npm i -g ${this.packageJson.name}`)}`);
-        lines.push('');
-        const message = lines.join('\n');
-        return boxen(message, {
-            padding: 0,
-            margin: 1,
-            borderStyle: 'double',
-            borderColor: this.getUpdateTypeBorderColor(type),
-        });
-    }
-    /**
-     * Gets the chalk color function for an update type.
-     */
-    getUpdateTypeColor(type) {
-        switch (type) {
-            case 'major':
-                return chalk.red;
-            case 'minor':
-                return chalk.yellow;
-            case 'patch':
-                return chalk.green;
-            case 'prerelease':
-                return chalk.magenta;
-            default:
-                return chalk.cyan;
-        }
-    }
-    /**
-     * Gets the border color for boxen based on update type.
-     */
-    getUpdateTypeBorderColor(type) {
-        switch (type) {
-            case 'major':
-                return 'red';
-            case 'minor':
-                return 'yellow';
-            case 'patch':
-                return 'green';
-            case 'prerelease':
-                return 'magenta';
-            default:
-                return 'cyan';
-        }
-    }
-    /**
-     * Updates the notification state in cache.
-     */
-    async updateNotificationState(version) {
-        const existing = this.cache.notificationState;
-        if (existing && existing.version === version) {
-            existing.showCount++;
-        }
-        else {
-            this.cache.notificationState = {
-                version,
-                notifiedAt: new Date().toISOString(),
-                dismissed: false,
-                showCount: 1,
-            };
-        }
-        await this.saveCache();
-    }
-    /**
-     * Dismisses the current update notification.
-     */
-    async dismissNotification() {
-        if (this.cache.notificationState) {
-            this.cache.notificationState.dismissed = true;
-            this.cache.notificationState.dismissedAt = new Date().toISOString();
-            await this.saveCache();
-        }
-    }
-    /**
-     * Performs the update using the specified package manager.
-     */
-    async performUpdate(method = 'npm') {
-        const result = await this.checkForUpdates(true);
-        if (!result.updateAvailable || !result.latestVersion) {
-            logger.output(chalk.green('You are already on the latest version!'));
-            return true;
-        }
-        const fromVersion = this.packageJson.version;
-        const toVersion = result.latestVersion;
-        logger.output('');
-        logger.output(chalk.cyan(`Updating Compass CLI from ${fromVersion} to ${toVersion}...`));
-        logger.output('');
-        try {
-            const command = this.getUpdateCommand(method);
-            logger.output(chalk.gray(`Running: ${command}`));
-            logger.output('');
-            const { stdout } = await execa(command, { shell: true });
-            if (stdout) {
-                logger.output(stdout);
-            }
-            // Record successful update
-            await this.recordUpdateHistory(fromVersion, toVersion, true, method);
-            logger.output('');
-            logger.output(chalk.green(`Successfully updated to version ${toVersion}!`));
-            logger.output(chalk.gray('Please restart Compass CLI to use the new version.'));
-            logger.output('');
-            return true;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Update failed';
-            // Record failed update
-            await this.recordUpdateHistory(fromVersion, toVersion, false, method, errorMessage);
-            logger.output('');
-            logger.output(chalk.red(`Update failed: ${errorMessage}`));
-            logger.output('');
-            logger.output(chalk.gray('You can try updating manually:'));
-            logger.output(chalk.cyan(`  ${this.getUpdateCommand(method)}`));
-            logger.output('');
-            return false;
-        }
-    }
-    /**
-     * Gets the update command for the specified package manager.
-     */
-    getUpdateCommand(method) {
-        const pkgName = this.packageJson.name;
-        switch (method) {
-            case 'yarn':
-                return `yarn global add ${pkgName}`;
-            case 'pnpm':
-                return `pnpm add -g ${pkgName}`;
-            case 'npm':
-            default:
-                return `npm install -g ${pkgName}`;
-        }
-    }
-    /**
-     * Records an update attempt in the history.
-     */
-    async recordUpdateHistory(fromVersion, toVersion, success, method, error) {
-        const entry = {
-            fromVersion,
-            toVersion,
-            updatedAt: new Date().toISOString(),
-            success,
-            method,
-            error,
-        };
-        this.cache.history.push(entry);
-        // Keep only last 10 entries
-        if (this.cache.history.length > 10) {
-            this.cache.history = this.cache.history.slice(-10);
-        }
-        // Clear notification state after update attempt
-        if (success) {
-            this.cache.notificationState = undefined;
-        }
-        await this.saveCache();
-    }
-    /**
-     * Gets the update history.
-     */
-    getUpdateHistory() {
-        return [...this.cache.history];
-    }
-    /**
-     * Gets the last update check result.
-     */
-    getLastCheckResult() {
-        return this.cache.lastCheck;
-    }
-    /**
-     * Gets the current configuration.
-     */
-    getConfig() {
-        return { ...this.config };
-    }
-    /**
-     * Updates the configuration.
-     */
-    async updateConfig(updates) {
-        this.config = { ...this.config, ...updates };
-    }
-    /**
-     * Gets information about the current version and update status.
-     */
-    getVersionInfo() {
-        return {
-            currentVersion: this.packageJson.version,
-            packageName: this.packageJson.name,
-            lastCheck: this.cache.lastCheck,
-            updateAvailable: this.cache.lastCheck?.updateAvailable ?? false,
-            latestVersion: this.cache.lastCheck?.latestVersion,
-        };
-    }
-    /**
-     * Detects the package manager used to install the CLI.
-     */
-    async detectPackageManager() {
-        try {
-            // Check if installed via yarn
-            const { stdout: yarnGlobal } = await execa('yarn', ['global', 'list', '--depth=0'], {
-                shell: true,
-                reject: false,
-            });
-            if (yarnGlobal && yarnGlobal.includes(this.packageJson.name)) {
-                return 'yarn';
-            }
-        }
-        catch {
-            // yarn not available or failed
-        }
-        try {
-            // Check if installed via pnpm
-            const { stdout: pnpmGlobal } = await execa('pnpm', ['list', '-g', '--depth=0'], {
-                shell: true,
-                reject: false,
-            });
-            if (pnpmGlobal && pnpmGlobal.includes(this.packageJson.name)) {
-                return 'pnpm';
-            }
-        }
-        catch {
-            // pnpm not available or failed
-        }
-        // Default to npm
-        return 'npm';
-    }
-}
-// Singleton instance
-let updateServiceInstance = null;
-/**
- * Gets the singleton UpdateService instance.
- */
-export async function getUpdateService(config) {
-    if (!updateServiceInstance) {
-        updateServiceInstance = await UpdateService.create(config);
-    }
-    return updateServiceInstance;
-}
-/**
- * Checks for updates and displays notification if available.
- * This is the main entry point for startup update checks.
- */
-export async function checkAndNotifyUpdates(config) {
-    const service = await getUpdateService(config);
-    const result = await service.checkForUpdates();
-    if (result.updateAvailable) {
-        service.displayUpdateNotification(result);
-    }
-    return result;
-}
-/**
- * Performs a manual update check with full output.
- */
-export async function manualUpdateCheck() {
-    const service = await getUpdateService();
-    logger.output('');
-    logger.output(chalk.cyan('Checking for updates...'));
-    const result = await service.checkForUpdates(true);
-    if (result.error) {
-        logger.output(chalk.red(`Failed to check for updates: ${result.error}`));
-    }
-    else if (result.updateAvailable) {
-        service.displayUpdateNotification(result);
-    }
-    else {
-        logger.output('');
-        logger.output(chalk.green(`You are on the latest version (${result.currentVersion})`));
-        logger.output('');
-    }
-    return result;
-}
-/**
- * Formats an update type color indicator for the terminal.
- */
-function getUpdateTypeIndicator(type) {
-    switch (type) {
-        case 'major':
-            return chalk.red('●');
-        case 'minor':
-            return chalk.yellow('●');
-        case 'patch':
-            return chalk.green('●');
-        case 'prerelease':
-            return chalk.magenta('●');
-        default:
-            return chalk.cyan('●');
-    }
-}
-/**
- * Checks for updates and returns a discrete status for startup display.
- * This provides a smart, single-line status message instead of verbose notifications.
- *
- * @example
- * ```typescript
- * const status = await checkUpdateStatus();
- * if (status.type === 'available') {
- *   console.log(status.message); // "● Update available: 1.0.8 → 1.1.0 (npm i -g @compass-ai/nova)"
- * }
- * ```
- */
-export async function checkUpdateStatus(config) {
-    const service = await getUpdateService(config);
-    const versionInfo = service.getVersionInfo();
-    const pkgName = versionInfo.packageName;
-    const currentVersion = versionInfo.currentVersion;
-    logger.debug('Update check: querying npm registry', {
-        packageName: pkgName,
-        currentVersion,
-    });
-    try {
-        const result = await service.checkForUpdates();
-        logger.debug('Update check: npm registry response', {
-            updateAvailable: result.updateAvailable,
-            latestVersion: result.latestVersion,
-            updateType: result.updateType,
-            error: result.error,
-        });
-        if (result.error) {
-            const manualCmd = `npm i -g ${pkgName}`;
-            return {
-                type: 'error',
-                message: chalk.red('✗') + chalk.dim(` Update check failed. Manual upgrade: `) + chalk.cyan(manualCmd),
-                currentVersion,
-                packageName: pkgName,
-                manualCommand: manualCmd,
-            };
-        }
-        if (result.updateAvailable && result.latestVersion) {
-            const indicator = getUpdateTypeIndicator(result.updateType);
-            const manualCmd = `npm i -g ${pkgName}@${result.latestVersion}`;
-            return {
-                type: 'available',
-                message: indicator +
-                    chalk.dim(' Update available: ') +
-                    chalk.dim(currentVersion) +
-                    chalk.dim(' → ') +
-                    chalk.bold(result.latestVersion) +
-                    chalk.dim(` (${manualCmd})`),
-                currentVersion,
-                latestVersion: result.latestVersion,
-                packageName: pkgName,
-                manualCommand: manualCmd,
-            };
-        }
-        return {
-            type: 'up-to-date',
-            message: '', // No message needed when up-to-date
-            currentVersion,
-            packageName: pkgName,
-        };
-    }
-    catch (error) {
-        const manualCmd = `npm i -g ${pkgName}`;
-        return {
-            type: 'error',
-            message: chalk.red('✗') + chalk.dim(` Update check failed. Manual upgrade: `) + chalk.cyan(manualCmd),
-            currentVersion,
-            packageName: pkgName,
-            manualCommand: manualCmd,
-        };
-    }
-}
-/**
- * Displays the discrete update status line if relevant.
- * Only outputs a message if there's something to report (available update or error).
- * Debug logging is always emitted to help diagnose update issues.
- */
-export async function displayDiscreteUpdateStatus(config) {
-    logger.debug('Update check: starting discrete update status check');
-    const status = await checkUpdateStatus(config);
-    // Log detailed debug info about the update status
-    logger.debug('Update check: completed', {
-        type: status.type,
-        currentVersion: status.currentVersion,
-        latestVersion: status.latestVersion,
-        packageName: status.packageName,
-    });
-    // Only display if there's an update available or an error occurred
-    if (status.type === 'available') {
-        logger.debug(`Update check: new version available (${status.latestVersion})`);
-        console.log(status.message);
-    }
-    else if (status.type === 'error') {
-        logger.debug('Update check: error occurred, showing manual upgrade command');
-        console.log(status.message);
-    }
-    else if (status.type === 'up-to-date') {
-        logger.debug('Update check: already on latest version, no notification shown');
-    }
-    return status;
-}
-/**
- * Performs auto-update on startup if an update is available.
- * This function checks for updates and automatically installs if available.
- * Returns true if an update was performed (CLI should exit for restart).
- *
- * @example
- * ```typescript
- * const result = await performAutoUpdateOnStartup();
- * if (result.updated) {
- *   // CLI will exit, user should restart
- *   process.exit(0);
- * }
- * ```
- */
-export async function performAutoUpdateOnStartup(config, force = false) {
-    logger.debug('Auto-update: starting startup update check', { force });
-    const service = await getUpdateService(config);
-    const versionInfo = service.getVersionInfo();
-    try {
-        // Check for updates (force bypasses cache interval)
-        const result = await service.checkForUpdates(force);
-        logger.debug('Auto-update: check completed', {
-            updateAvailable: result.updateAvailable,
-            currentVersion: result.currentVersion,
-            latestVersion: result.latestVersion,
-        });
-        if (!result.updateAvailable || !result.latestVersion) {
-            logger.debug('Auto-update: no update available');
-            return { updated: false };
-        }
-        // Update is available - perform auto-update
-        const fromVersion = versionInfo.currentVersion;
-        const toVersion = result.latestVersion;
-        // Detect package manager and perform update
-        const packageManager = await service.detectPackageManager();
-        logger.debug('Auto-update: detected package manager', { packageManager });
-        const success = await service.performUpdate(packageManager);
-        if (success) {
-            return {
-                updated: true,
-                fromVersion,
-                toVersion,
-            };
-        }
-        else {
-            // Update failed - return error but don't exit, let user continue with current version
-            logger.debug('Auto-update: update failed');
-            return {
-                updated: false,
-                error: 'Update failed, continuing with current version',
-            };
-        }
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        logger.debug('Auto-update: error during update', { error: errorMessage });
-        // Don't block startup on update errors
-        console.log(chalk.yellow(`⚠ Auto-update check failed: ${errorMessage}`));
-        console.log(chalk.dim(`  You can manually update with: npm i -g ${versionInfo.packageName}`));
-        console.log('');
-        return {
-            updated: false,
-            error: errorMessage,
-        };
-    }
-}
-export default UpdateService;
-//# sourceMappingURL=update-service.js.map