@agentuity/cli 1.0.8 → 1.0.9

package/src/cmd/ai/claude-code/uninstall.ts

@@ -0,0 +1,122 @@
+import { readFileSync, writeFileSync, rmSync } from 'node:fs';
+import { createSubcommand, type CommandContext } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import {
+	type ClaudeSettings,
+	CLAUDE_SETTINGS_FILE,
+	PLUGIN_INSTALL_DIR,
+	AGENTUITY_ALLOW_PERMISSIONS,
+	AGENTUITY_DENY_PERMISSIONS,
+} from './constants';
+
+export const uninstallSubcommand = createSubcommand({
+	name: 'uninstall',
+	description: 'Uninstall Agentuity Coder plugin for Claude Code',
+	tags: ['fast'],
+	examples: [
+		{
+			command: getCommand('ai claude-code uninstall'),
+			description: 'Uninstall Agentuity Coder plugin for Claude Code',
+		},
+	],
+	async handler(ctx: CommandContext) {
+		const { options } = ctx;
+		const jsonMode = !!options?.json;
+
+		if (!jsonMode) {
+			tui.newline();
+			tui.output(tui.bold('Uninstalling Agentuity Coder plugin for Claude Code'));
+			tui.newline();
+		}
+
+		let removedPlugin = false;
+		let removedPermissions = false;
+
+		if (await Bun.file(`${PLUGIN_INSTALL_DIR}/package.json`).exists()) {
+			try {
+				rmSync(PLUGIN_INSTALL_DIR, { recursive: true, force: true });
+				removedPlugin = true;
+				if (!jsonMode) {
+					tui.success('Removed plugin installation directory');
+				}
+			} catch (error) {
+				if (!jsonMode) {
+					tui.warning(`Failed to remove plugin directory: ${error}`);
+				}
+			}
+		} else {
+			if (!jsonMode) {
+				tui.info('Plugin installation directory not found - nothing to remove');
+			}
+		}
+
+		if (await Bun.file(CLAUDE_SETTINGS_FILE).exists()) {
+			try {
+				const content = readFileSync(CLAUDE_SETTINGS_FILE, 'utf-8');
+				const settings: ClaudeSettings = JSON.parse(content);
+
+				if (settings.permissions) {
+					const allPerms = [...AGENTUITY_ALLOW_PERMISSIONS, ...AGENTUITY_DENY_PERMISSIONS];
+
+					if (settings.permissions.allow) {
+						const originalAllowLen = settings.permissions.allow.length;
+						settings.permissions.allow = settings.permissions.allow.filter(
+							(p) => !allPerms.includes(p)
+						);
+						if (settings.permissions.allow.length < originalAllowLen) {
+							removedPermissions = true;
+						}
+					}
+
+					if (settings.permissions.deny) {
+						const originalDenyLen = settings.permissions.deny.length;
+						settings.permissions.deny = settings.permissions.deny.filter(
+							(p) => !allPerms.includes(p)
+						);
+						if (settings.permissions.deny.length < originalDenyLen) {
+							removedPermissions = true;
+						}
+					}
+
+					if (removedPermissions) {
+						writeFileSync(CLAUDE_SETTINGS_FILE, JSON.stringify(settings, null, 2) + '\n');
+						if (!jsonMode) {
+							tui.success('Removed Agentuity permissions from Claude Code settings');
+						}
+					} else {
+						if (!jsonMode) {
+							tui.info('No Agentuity permissions found in Claude Code settings');
+						}
+					}
+				}
+			} catch (error) {
+				if (!jsonMode) {
+					tui.warning(`Failed to update Claude Code settings: ${error}`);
+				}
+			}
+		} else {
+			if (!jsonMode) {
+				tui.info('Claude Code settings file not found');
+			}
+		}
+
+		if (!jsonMode) {
+			tui.newline();
+
+			if (removedPlugin || removedPermissions) {
+				tui.output(tui.bold('Agentuity Coder plugin uninstalled successfully'));
+			} else {
+				tui.output(tui.bold('Agentuity Coder plugin was not installed'));
+			}
+
+			tui.newline();
+			tui.info(`To reinstall, run: ${tui.bold(getCommand('ai claude-code install'))}`);
+			tui.newline();
+		}
+
+		return { success: true, removedPlugin, removedPermissions };
+	},
+});
+
+export default uninstallSubcommand;

package/src/cmd/ai/index.ts

@@ -3,6 +3,7 @@ import capabilitiesCommand from './capabilities';
 import promptCommand from './prompt';
 import schemaCommand from './schema';
 import opencodeCommand from './opencode';
+import claudeCodeCommand from './claude-code';
 import introSubcommand from './intro';
 import detectSubcommand from './detect';
 import { getCommand } from '../../command-prefix';
@@ -25,6 +26,10 @@ export const command = createCommand({
 			command: getCommand('ai opencode install'),
 			description: 'Install Agentuity Open Code plugin',
 		},
+		{
+			command: getCommand('ai claude-code install'),
+			description: 'Install Agentuity Coder plugin for Claude Code',
+		},
 		{
 			command: getCommand('ai capabilities show'),
 			description: 'Show CLI capabilities for AI agents',
@@ -38,6 +43,7 @@ export const command = createCommand({
 		detectSubcommand,
 		introSubcommand,
 		opencodeCommand,
+		claudeCodeCommand,
 		capabilitiesCommand,
 		promptCommand,
 		schemaCommand,

package/src/cmd/build/vite/server-bundler.ts

@@ -316,10 +316,28 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 		},
 	};
 
+	// Detect files belonging to @agentuity/postgres or @agentuity/drizzle.
+	// Matches both published paths (node_modules/@agentuity/postgres/) and
+	// symlinked/monorepo paths (packages/postgres/dist/, packages/postgres/src/).
+	const isAgentuityPostgres = (filePath: string) =>
+		filePath.includes('/@agentuity/postgres/') ||
+		filePath.includes('\\@agentuity\\postgres\\') ||
+		filePath.includes('/packages/postgres/');
+
+	const isAgentuityDrizzle = (filePath: string) =>
+		filePath.includes('/@agentuity/drizzle/') ||
+		filePath.includes('\\@agentuity\\drizzle\\') ||
+		filePath.includes('/packages/drizzle/');
+
 	const dbRewritePlugin: BunPlugin = {
 		name: 'agentuity:db-rewrite',
 		setup(build) {
 			build.onResolve({ filter: /^drizzle-orm\/bun-sql$/ }, (args) => {
+				// Don't redirect if the importer is @agentuity/drizzle itself — that would create a cycle.
+				// Matches both published packages in node_modules and symlinked monorepo paths.
+				if (args.importer && isAgentuityDrizzle(args.importer)) {
+					return; // Let default resolution handle it
+				}
 				// Resolve to @agentuity/drizzle — the bundler will find it in node_modules
 				// and bundle it into .agentuity/app.js (NOT kept external).
 				const resolved = import.meta.resolveSync('@agentuity/drizzle', args.importer);
@@ -333,7 +351,16 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 					namespace: 'file',
 				},
 				async (args) => {
-					if (args.path.includes('/node_modules/')) {
+					// Skip node_modules and the rewrite-target packages themselves.
+					// The symlink check is needed because symlinked packages (e.g. via
+					// workspace links) resolve to paths outside node_modules/ (like
+					// ../../sdk/packages/postgres/dist/) and would otherwise be rewritten,
+					// creating circular imports (postgres importing from itself).
+					if (
+						args.path.includes('/node_modules/') ||
+						isAgentuityPostgres(args.path) ||
+						isAgentuityDrizzle(args.path)
+					) {
 						return;
 					}
 					const contents = await Bun.file(args.path).text();

package/src/cmd/upgrade/index.ts

@@ -71,19 +71,35 @@ export async function fetchLatestVersion(): Promise<string> {
 }
 
 /**
- * Upgrade the CLI using bun global install
+ * Upgrade the CLI using bun global install.
+ * Retries on transient resolution errors caused by npm CDN propagation delays.
  */
-async function performBunUpgrade(version: string): Promise<void> {
+async function performBunUpgrade(
+	version: string,
+	onRetry?: (attempt: number, delayMs: number) => void
+): Promise<void> {
 	// Remove 'v' prefix for npm version
 	const npmVersion = version.replace(/^v/, '');
 
-	// Use bun to install the specific version globally
-	// Run from tmpdir to avoid interference from any local package.json/node_modules
-	const result = await $`bun add -g @agentuity/cli@${npmVersion}`.cwd(tmpdir()).quiet().nothrow();
-
-	if (result.exitCode !== 0) {
-		const stderr = result.stderr.toString();
-		throw new Error(`Failed to install @agentuity/cli@${npmVersion}: ${stderr}`);
+	const { installWithRetry } = await import('./npm-availability');
+
+	try {
+		await installWithRetry(
+			async () => {
+				// Use bun to install the specific version globally
+				// Run from tmpdir to avoid interference from any local package.json/node_modules
+				const result = await $`bun add -g @agentuity/cli@${npmVersion}`
+					.cwd(tmpdir())
+					.quiet()
+					.nothrow();
+				return { exitCode: result.exitCode, stderr: result.stderr };
+			},
+			{ onRetry }
+		);
+	} catch (error) {
+		throw new Error(
+			`Failed to install @agentuity/cli@${npmVersion}: ${error instanceof Error ? error.message : String(error)}`
+		);
 	}
 }
 
@@ -194,8 +210,9 @@ export const command = createCommand({
 				callback: async () => {
 					const { waitForNpmAvailability } = await import('./npm-availability');
 					return await waitForNpmAvailability(latestVersion, {
-						maxAttempts: 6,
-						initialDelayMs: 2000,
+						maxAttempts: 10,
+						initialDelayMs: 5000,
+						maxDelayMs: 15000,
 					});
 				},
 			});
@@ -244,8 +261,14 @@ export const command = createCommand({
 
 			// Perform the upgrade using bun
 			await tui.spinner({
+				type: 'logger',
 				message: `Installing @agentuity/cli@${normalizedLatest}...`,
-				callback: async () => await performBunUpgrade(latestVersion),
+				callback: async (log) =>
+					await performBunUpgrade(latestVersion, (attempt, delayMs) => {
+						log(
+							`Package not yet available on CDN, retrying in ${Math.round(delayMs / 1000)}s (attempt ${attempt})...`
+						);
+					}),
 			});
 
 			// Verify the upgrade

package/src/cmd/upgrade/npm-availability.ts

@@ -1,62 +1,51 @@
 /**
  * npm registry availability checking utilities.
- * Used to verify a version is available on npm before attempting upgrade.
+ * Used to verify a version is available via bun's resolver before attempting upgrade.
  */
 
-const NPM_REGISTRY_URL = 'https://registry.npmjs.org';
-const PACKAGE_NAME = '@agentuity/cli';
+import { $ } from 'bun';
+import { tmpdir } from 'node:os';
 
-/** Default timeout for quick checks (implicit version check) */
-const QUICK_CHECK_TIMEOUT_MS = 1000;
-
-/** Default timeout for explicit upgrade command */
-const EXPLICIT_CHECK_TIMEOUT_MS = 5000;
-
-export interface CheckNpmOptions {
-	/** Timeout in milliseconds (default: 5000 for explicit, 1000 for quick) */
-	timeoutMs?: number;
-}
+const PACKAGE_SPEC = '@agentuity/cli';
 
 /**
- * Check if a specific version of @agentuity/cli is available on npm registry.
- * Uses the npm registry API directly for faster response than `npm view`.
+ * Check if a specific version of @agentuity/cli is resolvable by bun.
+ * Uses `bun info` to verify bun's own resolver/CDN can see the version,
+ * which avoids the race where npm registry returns 200 but bun's CDN
+ * has not yet propagated the version.
  *
  * @param version - Version to check (with or without 'v' prefix)
- * @param options - Optional configuration
  * @returns true if version is available, false otherwise
  */
-export async function isVersionAvailableOnNpm(
-	version: string,
-	options: CheckNpmOptions = {}
-): Promise<boolean> {
-	const { timeoutMs = EXPLICIT_CHECK_TIMEOUT_MS } = options;
+export async function isVersionAvailableOnNpm(version: string): Promise<boolean> {
 	const normalizedVersion = version.replace(/^v/, '');
-	const url = `${NPM_REGISTRY_URL}/${encodeURIComponent(PACKAGE_NAME)}/${normalizedVersion}`;
-
 	try {
-		const response = await fetch(url, {
-			method: 'HEAD', // Only need to check existence, not full metadata
-			signal: AbortSignal.timeout(timeoutMs),
-			headers: {
-				Accept: 'application/json',
-			},
-		});
-		return response.ok;
+		const result = await $`bun info ${PACKAGE_SPEC}@${normalizedVersion} --json`
+			.cwd(tmpdir())
+			.quiet()
+			.nothrow();
+		if (result.exitCode !== 0) {
+			return false;
+		}
+		const info = JSON.parse(result.stdout.toString());
+		if (info.error) {
+			return false;
+		}
+		return info.version === normalizedVersion;
 	} catch {
-		// Network error or timeout - assume not available
 		return false;
 	}
 }
 
 /**
- * Quick check if a version is available on npm with a short timeout.
- * Used for implicit version checks (auto-upgrade flow) to avoid blocking the user's command.
+ * Quick check if a version is available via bun's resolver.
+ * Used for implicit version checks (auto-upgrade flow).
  *
  * @param version - Version to check (with or without 'v' prefix)
- * @returns true if version is available, false if unavailable or timeout
+ * @returns true if version is available, false if unavailable or error
  */
 export async function isVersionAvailableOnNpmQuick(version: string): Promise<boolean> {
-	return isVersionAvailableOnNpm(version, { timeoutMs: QUICK_CHECK_TIMEOUT_MS });
+	return isVersionAvailableOnNpm(version);
 }
 
 export interface WaitForNpmOptions {
@@ -103,3 +92,84 @@ export async function waitForNpmAvailability(
 
 	return false;
 }
+
+/**
+ * Patterns in bun's stderr that indicate a resolution/CDN propagation failure
+ * (as opposed to a permanent install error like permissions or disk space).
+ */
+const RESOLUTION_ERROR_PATTERNS = [/failed to resolve/i, /no version matching/i];
+
+/**
+ * Check whether a bun install failure is a transient resolution error
+ * caused by npm CDN propagation delays.
+ */
+export function isResolutionError(stderr: string): boolean {
+	return RESOLUTION_ERROR_PATTERNS.some((pattern) => pattern.test(stderr));
+}
+
+export interface InstallWithRetryOptions {
+	/** Maximum number of attempts including the first (default: 7 → 1 initial + 6 retries) */
+	maxAttempts?: number;
+	/** Initial delay in ms before the first retry (default: 5000) */
+	initialDelayMs?: number;
+	/** Maximum delay cap in ms (default: 30000) */
+	maxDelayMs?: number;
+	/** Multiplier applied to the delay after each retry (default: 2) */
+	multiplier?: number;
+	/** Callback invoked before each retry with the attempt number and upcoming delay */
+	onRetry?: (attempt: number, delayMs: number) => void;
+}
+
+/**
+ * Run an install function and retry on transient resolution errors with
+ * exponential backoff. This covers the window (~2 min) where npm CDN nodes
+ * have not yet propagated a newly-published version.
+ *
+ * Total wait with defaults: 5 + 10 + 20 + 30 + 30 + 30 = 125 s ≈ 2 min
+ *
+ * @param installFn - Async function that performs the install and returns exitCode + stderr
+ * @param options - Retry configuration
+ * @returns The successful result (exitCode 0)
+ * @throws Error if all retries are exhausted or a non-resolution error occurs
+ */
+export async function installWithRetry(
+	installFn: () => Promise<{ exitCode: number; stderr: Buffer }>,
+	options: InstallWithRetryOptions = {}
+): Promise<{ exitCode: number; stderr: Buffer }> {
+	const {
+		maxAttempts = 7,
+		initialDelayMs = 5000,
+		maxDelayMs = 30000,
+		multiplier = 2,
+		onRetry,
+	} = options;
+
+	let delay = initialDelayMs;
+
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+		const result = await installFn();
+
+		if (result.exitCode === 0) {
+			return result;
+		}
+
+		const stderr = result.stderr.toString();
+
+		// Only retry on resolution/propagation errors — bail immediately for anything else
+		if (!isResolutionError(stderr)) {
+			throw new Error(stderr);
+		}
+
+		// Last attempt exhausted — throw
+		if (attempt === maxAttempts) {
+			throw new Error(stderr);
+		}
+
+		onRetry?.(attempt, delay);
+		await new Promise((resolve) => setTimeout(resolve, delay));
+		delay = Math.min(Math.round(delay * multiplier), maxDelayMs);
+	}
+
+	// Unreachable, but satisfies TypeScript
+	throw new Error('Install failed after retries');
+}

package/src/version-check.ts

@@ -172,9 +172,27 @@ async function performUpgrade(logger: Logger, targetVersion: string): Promise<vo
 
 		logger.info('Upgrading to version %s...', npmVersion);
 
-		// Use bun to install the specific version globally
+		// Use bun to install the specific version globally with retry for CDN propagation delays
 		// Run from tmpdir to avoid interference from any local package.json/node_modules
-		await $`bun add -g @agentuity/cli@${npmVersion}`.cwd(tmpdir()).quiet();
+		const { installWithRetry } = await import('./cmd/upgrade/npm-availability');
+		await installWithRetry(
+			async () => {
+				const result = await $`bun add -g @agentuity/cli@${npmVersion}`
+					.cwd(tmpdir())
+					.quiet()
+					.nothrow();
+				return { exitCode: result.exitCode, stderr: result.stderr };
+			},
+			{
+				onRetry: (attempt, delayMs) => {
+					logger.info(
+						'Package not yet available on CDN, retrying in %ds (attempt %d)...',
+						Math.round(delayMs / 1000),
+						attempt
+					);
+				},
+			}
+		);
 
 		// If we got here, the upgrade succeeded
 		// Re-run the original command with the new binary