@agentuity/cli 0.0.86 → 0.0.87

package/src/types.ts

@@ -89,6 +89,7 @@ export interface GlobalOptions {
 	explain?: boolean;
 	dryRun?: boolean;
 	validate?: boolean;
+	skipVersionCheck?: boolean;
 }
 
 export interface PaginationInfo {
@@ -282,6 +283,8 @@ export function createCommand<
 	banner?: true;
 	aliases?: string[];
 	hidden?: boolean;
+	executable?: boolean;
+	skipUpgradeCheck?: boolean;
 	requires?: R;
 	optional?: O;
 	examples?: CommandExample[];
@@ -318,6 +321,8 @@ type CommandDefBase =
 			description: string;
 			aliases?: string[];
 			banner?: boolean;
+			executable?: boolean;
+			skipUpgradeCheck?: boolean;
 			examples?: CommandExample[];
 			idempotent?: boolean;
 			prerequisites?: string[];
@@ -332,6 +337,8 @@ type CommandDefBase =
 			description: string;
 			aliases?: string[];
 			banner?: boolean;
+			executable?: boolean;
+			skipUpgradeCheck?: boolean;
 			examples?: CommandExample[];
 			idempotent?: boolean;
 			prerequisites?: string[];

package/src/utils/dependency-checker.ts

@@ -0,0 +1,207 @@
+import { $ } from 'bun';
+import { join } from 'node:path';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { getVersion } from '../version';
+import type { Logger } from '../types';
+
+interface PackageJson {
+	dependencies?: Record<string, string>;
+	devDependencies?: Record<string, string>;
+}
+
+export interface UpgradeResult {
+	upgraded: string[];
+	skipped: string[];
+	failed: string[];
+}
+
+/**
+ * Checks if a version specifier should be upgraded
+ * @param specifier - The version specifier from package.json (e.g., "latest", "^1.0.0", "1.2.3")
+ * @returns true if the package should be upgraded
+ */
+export function shouldUpgradeVersion(specifier: string): boolean {
+	// Always upgrade "latest" and "*"
+	if (specifier === 'latest' || specifier === '*') {
+		return true;
+	}
+
+	// Skip pinned versions (exact semver like "1.2.3")
+	if (/^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/.test(specifier)) {
+		return false;
+	}
+
+	// Upgrade ranges (^1.0.0, ~1.0.0, >=1.0.0, etc.)
+	// Check if the specifier is a range pattern
+	if (/^[~^>=<]/.test(specifier)) {
+		return true;
+	}
+
+	// Default to not upgrading if we can't determine
+	return false;
+}
+
+/**
+ * Check and upgrade @agentuity/* dependencies to match CLI version
+ * @param projectDir - Root directory of the user's project
+ * @param logger - Logger instance
+ * @returns Result of the upgrade operation
+ */
+export async function checkAndUpgradeDependencies(
+	projectDir: string,
+	logger: Logger
+): Promise<UpgradeResult> {
+	const result: UpgradeResult = {
+		upgraded: [],
+		skipped: [],
+		failed: [],
+	};
+
+	// Skip in CI/non-interactive environments
+	if (!process.stdin.isTTY) {
+		logger.debug('Skipping dependency check in non-interactive environment');
+		return result;
+	}
+
+	const packageJsonPath = join(projectDir, 'package.json');
+	const cliVersion = getVersion();
+
+	logger.debug('CLI version: %s', cliVersion);
+
+	// Read package.json
+	let packageJson: PackageJson;
+	try {
+		packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+	} catch (error) {
+		logger.debug('Failed to read package.json: %s', error);
+		return result;
+	}
+
+	// Collect all @agentuity/* packages and their original specifiers
+	const allDeps = {
+		...packageJson.dependencies,
+		...packageJson.devDependencies,
+	};
+
+	const agentuitPackages = Object.entries(allDeps)
+		.filter(([name]) => name.startsWith('@agentuity/'))
+		.map(([name, specifier]) => ({ name, specifier }));
+
+	if (agentuitPackages.length === 0) {
+		logger.debug('No @agentuity/* packages found in package.json');
+		return result;
+	}
+
+	// Check which packages need upgrading
+	const packagesToUpgrade = agentuitPackages.filter(({ specifier }) =>
+		shouldUpgradeVersion(specifier)
+	);
+
+	if (packagesToUpgrade.length === 0) {
+		logger.debug('All @agentuity/* packages are pinned, skipping upgrade');
+		for (const pkg of agentuitPackages) {
+			result.skipped.push(pkg.name);
+		}
+		return result;
+	}
+
+	// Check if CLI version is different from installed packages
+	let needsUpgrade = false;
+	for (const { name } of packagesToUpgrade) {
+		try {
+			const installedPackageJson = JSON.parse(
+				readFileSync(join(projectDir, 'node_modules', name, 'package.json'), 'utf-8')
+			);
+			const installedVersion: string = installedPackageJson.version;
+			if (installedVersion !== cliVersion) {
+				logger.debug(
+					'%s: installed=%s, cli=%s (needs upgrade)',
+					name,
+					installedVersion,
+					cliVersion
+				);
+				needsUpgrade = true;
+			} else {
+				logger.debug('%s: already at correct version %s', name, installedVersion);
+			}
+		} catch {
+			// Package not installed or can't read version - needs upgrade
+			logger.debug('%s: not installed or unreadable, needs upgrade', name);
+			needsUpgrade = true;
+		}
+	}
+
+	if (!needsUpgrade) {
+		logger.debug('All @agentuity/* packages are already at CLI version');
+		for (const pkg of packagesToUpgrade) {
+			result.skipped.push(pkg.name);
+		}
+		return result;
+	}
+
+	// Upgrade packages
+	logger.debug('Upgrading %d @agentuity/* package(s) to %s', packagesToUpgrade.length, cliVersion);
+
+	for (const { name } of packagesToUpgrade) {
+		try {
+			logger.debug('Installing %s@%s', name, cliVersion);
+			const installResult = await $`bun add ${name}@${cliVersion}`
+				.cwd(projectDir)
+				.quiet()
+				.nothrow();
+
+			if (installResult.exitCode !== 0) {
+				logger.error(
+					'Failed to install %s@%s: %s',
+					name,
+					cliVersion,
+					installResult.stderr.toString()
+				);
+				result.failed.push(name);
+			} else {
+				logger.debug('Successfully installed %s@%s', name, cliVersion);
+				result.upgraded.push(name);
+			}
+		} catch (_error) {
+			logger.error('Error installing %s: %s', name, _error);
+			result.failed.push(name);
+		}
+	}
+
+	// Restore original version specifiers in package.json
+	// (bun add replaces them with specific versions)
+	if (result.upgraded.length > 0) {
+		try {
+			const updatedPackageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+			let modified = false;
+
+			for (const { name, specifier } of packagesToUpgrade) {
+				// Only restore if we successfully upgraded
+				if (!result.upgraded.includes(name)) {
+					continue;
+				}
+
+				// Check both dependencies and devDependencies
+				if (updatedPackageJson.dependencies?.[name]) {
+					updatedPackageJson.dependencies[name] = specifier;
+					modified = true;
+					logger.debug('Restored %s to "%s" in dependencies', name, specifier);
+				}
+				if (updatedPackageJson.devDependencies?.[name]) {
+					updatedPackageJson.devDependencies[name] = specifier;
+					modified = true;
+					logger.debug('Restored %s to "%s" in devDependencies', name, specifier);
+				}
+			}
+
+			if (modified) {
+				writeFileSync(packageJsonPath, JSON.stringify(updatedPackageJson, null, 2) + '\n');
+				logger.debug('Restored original version specifiers in package.json');
+			}
+		} catch (_error) {
+			logger.warn('Failed to restore version specifiers in package.json: %s', _error);
+		}
+	}
+
+	return result;
+}

package/src/version-check.ts

@@ -0,0 +1,234 @@
+import type { Config, Logger, CommandDefinition } from './types';
+import { isRunningFromExecutable, fetchLatestVersion } from './cmd/upgrade';
+import { getVersion } from './version';
+import * as tui from './tui';
+import { saveConfig } from './config';
+import { $ } from 'bun';
+
+const ONE_HOUR_MS = 60 * 60 * 1000;
+
+/**
+ * Check if we should skip the version check based on environment and config
+ */
+function shouldSkipCheck(
+	config: Config | null,
+	options: {
+		json?: boolean;
+		quiet?: boolean;
+		validate?: boolean;
+		dryRun?: boolean;
+		skipVersionCheck?: boolean;
+	},
+	commandDef: CommandDefinition | undefined,
+	args: string[]
+): boolean {
+	// Skip if running via bun/bunx (not installed executable)
+	if (!isRunningFromExecutable()) {
+		return true;
+	}
+
+	// Skip if no TTY (CI, redirected output, etc.)
+	if (!process.stdin.isTTY || !process.stdout.isTTY) {
+		return true;
+	}
+
+	// Skip if any of these flags are set
+	if (options.json || options.quiet || options.validate || options.dryRun) {
+		return true;
+	}
+
+	// Skip if explicitly disabled via flag
+	if (options.skipVersionCheck) {
+		return true;
+	}
+
+	// Skip if explicitly disabled via environment variable
+	if (process.env.AGENTUITY_SKIP_VERSION_CHECK === '1') {
+		return true;
+	}
+
+	// Skip if explicitly disabled via config
+	if (config?.overrides?.skip_version_check) {
+		return true;
+	}
+
+	// Skip if development version (0.0.x or 'dev')
+	const currentVersion = getVersion();
+	if (currentVersion.startsWith('0.0.') || currentVersion === 'dev') {
+		return true;
+	}
+
+	// Skip if command explicitly opts out of upgrade check
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	if (commandDef && (commandDef as any).skipUpgradeCheck === true) {
+		return true;
+	}
+
+	// Skip for help commands
+	const helpFlags = ['--help', '-h', 'help'];
+	if (args.some((arg) => helpFlags.includes(arg))) {
+		return true;
+	}
+
+	return false;
+}
+
+/**
+ * Check if enough time has passed since last check (at least 1 hour)
+ */
+function shouldCheckNow(config: Config | null): boolean {
+	const lastCheck = config?.preferences?.last_update_check;
+	if (!lastCheck) {
+		return true;
+	}
+
+	const now = Date.now();
+	const elapsed = now - lastCheck;
+	return elapsed >= ONE_HOUR_MS;
+}
+
+/**
+ * Prompt user to upgrade to a new version
+ * Returns true if user wants to upgrade, false otherwise
+ */
+async function promptUpgrade(currentVersion: string, latestVersion: string): Promise<boolean> {
+	tui.newline();
+	tui.info(`${tui.bold('A new version of the CLI is available!')}`);
+	tui.info(`Current version: ${tui.muted(currentVersion)}`);
+	tui.info(`Latest version:  ${tui.bold(latestVersion)}`);
+	tui.newline();
+
+	return await tui.confirm('Would you like to upgrade now?', true);
+}
+
+/**
+ * Update the last check timestamp in config
+ */
+async function updateCheckTimestamp(config: Config | null, logger: Logger): Promise<void> {
+	if (!config) {
+		return;
+	}
+
+	const updatedConfig: Config = {
+		...config,
+		preferences: {
+			...config.preferences,
+			last_update_check: Date.now(),
+		},
+	};
+
+	try {
+		await saveConfig(updatedConfig);
+	} catch (error) {
+		// Non-fatal - log but continue
+		logger.debug('Failed to save config after version check: %s', error);
+	}
+}
+
+/**
+ * Perform the upgrade and re-run the command
+ */
+async function performUpgrade(logger: Logger): Promise<void> {
+	try {
+		// Run upgrade command (it will validate, download, install, etc.)
+		// Use process.execPath to get the actual binary path (not Bun.main which is virtual)
+		logger.info('Starting upgrade...');
+		await $`${process.execPath} upgrade`.quiet();
+
+		// If we got here, the upgrade succeeded
+		// Re-run the original command with the new binary
+		const args = process.argv.slice(2);
+		const newBinaryPath = process.execPath;
+
+		logger.info('Upgrade successful! Restarting with new version...');
+		tui.info('');
+
+		// Spawn new process with same arguments
+		const proc = Bun.spawn([newBinaryPath, ...args], {
+			stdin: 'inherit',
+			stdout: 'inherit',
+			stderr: 'inherit',
+		});
+
+		// Wait for the new process to complete
+		await proc.exited;
+
+		// Exit with the same exit code as the new process
+		process.exit(proc.exitCode ?? 0);
+	} catch (error) {
+		// Upgrade failed - log and continue with original command
+		logger.error('Upgrade failed: %s', error instanceof Error ? error.message : 'Unknown error');
+		tui.warning('Continuing with current version...');
+		tui.info('');
+	}
+}
+
+/**
+ * Check for updates and optionally prompt to upgrade
+ * Should be called early in the CLI initialization, before commands execute
+ */
+export async function checkForUpdates(
+	config: Config | null,
+	logger: Logger,
+	options: {
+		json?: boolean;
+		quiet?: boolean;
+		validate?: boolean;
+		dryRun?: boolean;
+		skipVersionCheck?: boolean;
+	},
+	commandDef: CommandDefinition | undefined,
+	args: string[]
+): Promise<void> {
+	// Determine if we should skip the check
+	if (shouldSkipCheck(config, options, commandDef, args)) {
+		logger.trace('Skipping version check (disabled or not applicable)');
+		return;
+	}
+
+	// Check if enough time has passed
+	if (!shouldCheckNow(config)) {
+		logger.trace('Skipping version check (checked recently)');
+		return;
+	}
+
+	// Perform the actual version check
+	logger.trace('Checking for updates...');
+
+	try {
+		const currentVersion = getVersion();
+		const latestVersion = await fetchLatestVersion();
+
+		// Update the timestamp since we successfully checked
+		await updateCheckTimestamp(config, logger);
+
+		// Compare versions
+		const normalizedCurrent = currentVersion.replace(/^v/, '');
+		const normalizedLatest = latestVersion.replace(/^v/, '');
+
+		if (normalizedCurrent === normalizedLatest) {
+			logger.trace('Already on latest version: %s', currentVersion);
+			return;
+		}
+
+		// New version available - prompt user
+		const shouldUpgrade = await promptUpgrade(currentVersion, latestVersion);
+
+		if (!shouldUpgrade) {
+			// User declined - just continue
+			tui.info('You can upgrade later by running: agentuity upgrade');
+			tui.newline();
+			return;
+		}
+
+		// User wants to upgrade - perform it
+		await performUpgrade(logger);
+	} catch (error) {
+		// Non-fatal - if we can't fetch the latest version (network error, timeout, etc.),
+		// just log at debug level and continue without interrupting the user's command
+		logger.debug(
+			'Version check failed: %s',
+			error instanceof Error ? error.message : 'Unknown error'
+		);
+	}
+}