@agentuity/cli 0.0.6

package/src/legacy-check.ts

@@ -0,0 +1,127 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import * as tui from './tui';
+
+interface LegacyInstall {
+	path: string;
+	method: 'homebrew' | 'manual' | 'install-script';
+}
+
+/**
+ * Check if the legacy (Go-based) Agentuity CLI is installed
+ * and block execution with migration instructions
+ */
+export async function checkLegacyCLI(): Promise<void> {
+	const homeDir = homedir();
+
+	const legacyLocations = [
+		'/opt/homebrew/bin/agentuity', // Homebrew ARM64 (M1/M2/M3 Macs)
+		'/usr/local/bin/agentuity', // Homebrew Intel Macs / Linux
+		'/usr/bin/agentuity', // System install
+		join(homeDir, '.bin/agentuity'), // User bin from install script
+		join(homeDir, 'bin/agentuity'), // User bin alternate
+		join(homeDir, '.local/bin/agentuity'), // XDG user bin
+	];
+
+	const foundInstalls: LegacyInstall[] = [];
+
+	// Check if Homebrew manages the agentuity package
+	let isBrewManaged = false;
+	try {
+		const brewCheck = Bun.spawn(['brew', 'list', '--versions', 'agentuity'], {
+			stdout: 'ignore',
+			stderr: 'ignore',
+		});
+		const exitCode = await brewCheck.exited;
+		isBrewManaged = exitCode === 0;
+	} catch {
+		// Homebrew not installed or command failed
+	}
+
+	// Check file system locations
+	for (const location of legacyLocations) {
+		const file = Bun.file(location);
+		if (await file.exists()) {
+			try {
+				// Check if it's a compiled binary (not TypeScript)
+				const proc = Bun.spawn(['file', location], { stdout: 'pipe' });
+				const output = await new Response(proc.stdout).text();
+				await proc.exited;
+
+				if (output.includes('Mach-O') || output.includes('ELF')) {
+					// Determine method: if brew manages the package, mark all installs as homebrew
+					// otherwise check if it's in user home (install-script) or system (manual)
+					const method = isBrewManaged
+						? 'homebrew'
+						: location.includes(homeDir)
+							? 'install-script'
+							: 'manual';
+					foundInstalls.push({ path: location, method });
+				}
+			} catch {
+				// Ignore errors
+			}
+		}
+	}
+
+	if (foundInstalls.length === 0 && !isBrewManaged) {
+		return; // No legacy CLI found
+	}
+
+	// Block execution and show removal instructions
+	tui.newline();
+	tui.error('Legacy CLI Conflict Detected');
+	tui.newline();
+
+	console.log('  The legacy (Go-based) Agentuity CLI is installed and conflicts with the new');
+	console.log('  TypeScript-based CLI. Please remove it before continuing.');
+	tui.newline();
+
+	// Filter installs into brew-managed and manual
+	const brewInstalls = foundInstalls.filter(
+		(install) => isBrewManaged || install.method === 'homebrew'
+	);
+	const manualInstalls = foundInstalls.filter(
+		(install) => !isBrewManaged && install.method !== 'homebrew'
+	);
+
+	// Show Homebrew removal section if any brew-managed installs
+	if (brewInstalls.length > 0) {
+		console.log('  ' + tui.bold('Remove via Homebrew:'));
+		tui.bullet('brew uninstall agentuity');
+		tui.newline();
+
+		// Show which files will be removed by brew
+		console.log('  ' + tui.muted('This will remove:'));
+		for (const install of brewInstalls) {
+			console.log(`    "${install.path}"`);
+		}
+		tui.newline();
+	}
+
+	// Show manual removal section if any manual installs
+	if (manualInstalls.length > 0) {
+		console.log('  ' + tui.bold('Remove the following legacy CLI installations:'));
+		tui.newline();
+
+		for (const install of manualInstalls) {
+			console.log(`  ${tui.muted('"' + install.path + '"')}`);
+
+			if (install.method === 'install-script') {
+				tui.bullet(`rm "${install.path}"`);
+			} else {
+				tui.bullet(`sudo rm "${install.path}"`);
+			}
+		}
+		tui.newline();
+	}
+
+	console.log('  ' + tui.bold('After removal, install the new CLI:'));
+	tui.bullet('bun install -g @agentuity/cli');
+	tui.newline();
+
+	console.log(`  Learn more: ${tui.link('https://docs.agentuity.dev/cli/migration')}`);
+	tui.newline();
+
+	process.exit(1);
+}

package/src/logger.ts

@@ -0,0 +1,235 @@
+import type { LogLevel } from './types';
+import type { ColorScheme } from './terminal';
+
+const LOG_LEVELS: Record<LogLevel, number> = {
+	debug: 0,
+	trace: 1,
+	info: 2,
+	warn: 3,
+	error: 4,
+};
+
+const BOLD = '\x1b[1m';
+const RESET = '\x1b[0m';
+
+// Helper to convert hex color to ANSI 24-bit color code
+function hexToAnsi(hex: string): string {
+	const r = parseInt(hex.slice(1, 3), 16);
+	const g = parseInt(hex.slice(3, 5), 16);
+	const b = parseInt(hex.slice(5, 7), 16);
+	return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+function shouldUseColors(): boolean {
+	// Check for NO_COLOR environment variable (any non-empty value disables colors)
+	if (process.env.NO_COLOR) {
+		return false;
+	}
+
+	// Check for TERM=dumb
+	if (process.env.TERM === 'dumb') {
+		return false;
+	}
+
+	// Check if stdout is a TTY
+	if (!process.stdout.isTTY) {
+		return false;
+	}
+
+	return true;
+}
+
+const USE_COLORS = shouldUseColors();
+
+interface LogColors {
+	level: string;
+	message: string;
+	timestamp: string;
+}
+
+function getLogColors(scheme: ColorScheme): Record<LogLevel, LogColors> {
+	if (scheme === 'light') {
+		// Darker, high-contrast colors for light backgrounds
+		return {
+			trace: {
+				level: hexToAnsi('#008B8B') + BOLD, // Dark cyan
+				message: hexToAnsi('#4B4B4B'), // Dark gray
+				timestamp: hexToAnsi('#808080'), // Gray
+			},
+			debug: {
+				level: hexToAnsi('#0000CD') + BOLD, // Medium blue
+				message: hexToAnsi('#006400'), // Dark green
+				timestamp: hexToAnsi('#808080'),
+			},
+			info: {
+				level: hexToAnsi('#FF8C00') + BOLD, // Dark orange
+				message: hexToAnsi('#0066CC') + BOLD, // Strong blue
+				timestamp: hexToAnsi('#808080'),
+			},
+			warn: {
+				level: hexToAnsi('#9400D3') + BOLD, // Dark violet
+				message: hexToAnsi('#8B008B'), // Dark magenta
+				timestamp: hexToAnsi('#808080'),
+			},
+			error: {
+				level: hexToAnsi('#DC143C') + BOLD, // Crimson
+				message: hexToAnsi('#8B0000') + BOLD, // Dark red
+				timestamp: hexToAnsi('#808080'),
+			},
+		};
+	}
+
+	// Dark mode colors (brighter for dark backgrounds)
+	return {
+		trace: {
+			level: (Bun.color('cyan', 'ansi') ?? '') + BOLD,
+			message: Bun.color('gray', 'ansi') ?? '',
+			timestamp: hexToAnsi('#666666'),
+		},
+		debug: {
+			level: (Bun.color('blue', 'ansi') ?? '') + BOLD,
+			message: Bun.color('green', 'ansi') ?? '',
+			timestamp: hexToAnsi('#666666'),
+		},
+		info: {
+			level: (Bun.color('yellow', 'ansi') ?? '') + BOLD,
+			message: (Bun.color('white', 'ansi') ?? '') + BOLD,
+			timestamp: hexToAnsi('#666666'),
+		},
+		warn: {
+			level: (Bun.color('magenta', 'ansi') ?? '') + BOLD,
+			message: Bun.color('magenta', 'ansi') ?? '',
+			timestamp: hexToAnsi('#666666'),
+		},
+		error: {
+			level: (Bun.color('red', 'ansi') ?? '') + BOLD,
+			message: Bun.color('red', 'ansi') ?? '',
+			timestamp: hexToAnsi('#666666'),
+		},
+	};
+}
+
+export class Logger {
+	private level: LogLevel;
+	private showTimestamp: boolean;
+	private colorScheme: ColorScheme;
+	private colors: Record<LogLevel, LogColors>;
+	private showPrefix = true;
+
+	constructor(
+		level: LogLevel = 'info',
+		showTimestamp: boolean = false,
+		colorScheme: ColorScheme = 'dark'
+	) {
+		this.level = level;
+		this.showTimestamp = showTimestamp;
+		this.colorScheme = colorScheme;
+		this.colors = getLogColors(this.colorScheme);
+	}
+
+	setLevel(level: LogLevel): void {
+		this.level = level;
+	}
+
+	setTimestamp(enabled: boolean): void {
+		this.showTimestamp = enabled;
+	}
+
+	setColorScheme(scheme: ColorScheme): void {
+		this.colorScheme = scheme;
+		this.colors = getLogColors(this.colorScheme);
+	}
+
+	setShowPrefix(show: boolean): void {
+		this.showPrefix = show;
+	}
+
+	private shouldLog(level: LogLevel): boolean {
+		return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+	}
+
+	private log(level: LogLevel, message: string, ...args: unknown[]): void {
+		if (!this.shouldLog(level) || !message) {
+			return;
+		}
+
+		const colors = this.colors[level];
+		const levelText = `[${level.toUpperCase()}]`;
+
+		let output = '';
+
+		if (USE_COLORS) {
+			if (this.showPrefix) {
+				if (this.showTimestamp) {
+					const timestamp = new Date().toISOString();
+					output = `${colors.timestamp}[${timestamp}]${RESET} ${colors.level}${levelText}${RESET} ${colors.message}${message}${RESET}`;
+				} else {
+					output = `${colors.level}${levelText}${RESET} ${colors.message}${message}${RESET}`;
+				}
+			} else {
+				// No prefix - just the message with color
+				output = `${colors.message}${message}${RESET}`;
+			}
+		} else {
+			// No colors - plain text output
+			if (this.showPrefix) {
+				if (this.showTimestamp) {
+					const timestamp = new Date().toISOString();
+					output = `[${timestamp}] ${levelText} ${message}`;
+				} else {
+					output = `${levelText} ${message}`;
+				}
+			} else {
+				// No prefix, no colors - just message
+				output = message;
+			}
+		}
+
+		if (level === 'error') {
+			if (args.length > 0) {
+				console.error(output, ...args);
+			} else {
+				console.error(output);
+			}
+		} else if (level === 'warn') {
+			if (args.length > 0) {
+				console.warn(output, ...args);
+			} else {
+				console.warn(output);
+			}
+		} else {
+			if (args.length > 0) {
+				console.log(output, ...args);
+			} else {
+				console.log(output);
+			}
+		}
+	}
+
+	debug(message: string, ...args: unknown[]): void {
+		this.log('debug', message, ...args);
+	}
+
+	trace(message: string, ...args: unknown[]): void {
+		this.log('trace', message, ...args);
+	}
+
+	info(message: string, ...args: unknown[]): void {
+		this.log('info', message, ...args);
+	}
+
+	warn(message: string, ...args: unknown[]): void {
+		this.log('warn', message, ...args);
+	}
+
+	error(message: string, ...args: unknown[]): void {
+		this.log('error', message, ...args);
+	}
+
+	fatal(message: string, ...args: unknown[]): never {
+		this.log('error', message, ...args);
+		process.exit(1);
+	}
+}
+
+export const logger = new Logger('info');

package/src/runtime.ts

@@ -0,0 +1,22 @@
+import { semver } from 'bun';
+
+const MIN_BUN_VERSION = '1.3.0';
+
+export function isBun(): boolean {
+	return typeof Bun !== 'undefined';
+}
+
+export function validateRuntime(): void {
+	if (!isBun()) {
+		console.error('Error: This CLI requires Bun runtime');
+		console.error('Please install Bun: https://bun.sh');
+		process.exit(1);
+	}
+
+	const bunVersion = Bun.version;
+	if (semver.satisfies(bunVersion, `>=${MIN_BUN_VERSION}`) === false) {
+		console.error(`Error: This CLI requires Bun ${MIN_BUN_VERSION} or higher`);
+		console.error(`Current Bun version: ${bunVersion}`);
+		process.exit(1);
+	}
+}

package/src/schema-parser.ts

@@ -0,0 +1,213 @@
+import type { ZodType } from 'zod';
+import type { CommandSchemas } from './types';
+
+export interface ParsedArgs {
+	names: string[];
+	metadata: Array<{
+		name: string;
+		optional: boolean;
+		variadic: boolean;
+	}>;
+}
+
+export interface ParsedOption {
+	name: string;
+	description?: string;
+	type: 'string' | 'number' | 'boolean';
+	hasDefault?: boolean;
+	defaultValue?: unknown;
+}
+
+interface ZodTypeDef {
+	typeName?: string;
+	type?: string;
+	innerType?: unknown;
+	schema?: unknown;
+	shape?: (() => Record<string, unknown>) | Record<string, unknown>;
+	description?: string;
+}
+
+interface ZodTypeInternal {
+	_def: ZodTypeDef;
+}
+
+function unwrapSchema(schema: unknown): unknown {
+	let current = schema as ZodTypeInternal | undefined;
+
+	while (current?._def) {
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		const typeId = current._def.typeName || current._def.type || (current as any).type;
+
+		if ((typeId === 'ZodEffects' || typeId === 'effects') && current._def.schema) {
+			current = current._def.schema as ZodTypeInternal;
+		} else if ((typeId === 'ZodOptional' || typeId === 'optional') && current._def.innerType) {
+			current = current._def.innerType as ZodTypeInternal;
+		} else if ((typeId === 'ZodNullable' || typeId === 'nullable') && current._def.innerType) {
+			current = current._def.innerType as ZodTypeInternal;
+		} else if ((typeId === 'ZodDefault' || typeId === 'default') && current._def.innerType) {
+			current = current._def.innerType as ZodTypeInternal;
+		} else if ((typeId === 'ZodReadonly' || typeId === 'readonly') && current._def.innerType) {
+			current = current._def.innerType as ZodTypeInternal;
+		} else {
+			break;
+		}
+	}
+
+	return current;
+}
+
+function getShape(schema: ZodType): Record<string, unknown> {
+	const unwrapped = unwrapSchema(schema) as ZodTypeInternal;
+	const typeId = unwrapped?._def?.typeName || unwrapped?._def?.type;
+
+	if (typeId === 'ZodObject' || typeId === 'object') {
+		const shape = unwrapped._def.shape;
+		return typeof shape === 'function' ? shape() : (shape as Record<string, unknown>) || {};
+	}
+
+	return {};
+}
+
+export function parseArgsSchema(schema: ZodType): ParsedArgs {
+	const shape = getShape(schema);
+	const names: string[] = [];
+	const metadata: Array<{ name: string; optional: boolean; variadic: boolean }> = [];
+
+	for (const [key, value] of Object.entries(shape)) {
+		names.push(key);
+
+		/* eslint-disable @typescript-eslint/no-explicit-any */
+		const typeId =
+			(value as ZodTypeInternal)?._def?.typeName ||
+			(value as any)._def?.type ||
+			(value as any).type;
+		const unwrapped = unwrapSchema(value) as ZodTypeInternal;
+		const unwrappedTypeId =
+			unwrapped?._def?.typeName || (unwrapped as any)?._def?.type || (unwrapped as any)?.type;
+		/* eslint-enable @typescript-eslint/no-explicit-any */
+
+		const isOptional = typeId === 'ZodOptional' || typeId === 'optional';
+		const isVariadic = unwrappedTypeId === 'ZodArray' || unwrappedTypeId === 'array';
+
+		metadata.push({ name: key, optional: isOptional, variadic: isVariadic });
+	}
+
+	return { names, metadata };
+}
+
+/**
+ * Extract default value information from a Zod schema by walking the wrapper chain
+ */
+function extractDefaultInfo(schema: unknown): {
+	hasDefault: boolean;
+	defaultValue?: unknown;
+	defaultIsFunction: boolean;
+} {
+	let current = schema as ZodTypeInternal | undefined;
+
+	while (current?._def) {
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		const typeId = current._def.typeName || (current as any)._def?.type;
+
+		if (typeId === 'ZodDefault' || typeId === 'default') {
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			const rawDefaultValue = (current as any)._def?.defaultValue;
+			const defaultIsFunction = typeof rawDefaultValue === 'function';
+
+			return {
+				hasDefault: true,
+				defaultValue: rawDefaultValue,
+				defaultIsFunction,
+			};
+		}
+
+		// Continue through wrapper chain
+		if (
+			(typeId === 'ZodOptional' ||
+				typeId === 'optional' ||
+				typeId === 'ZodNullable' ||
+				typeId === 'nullable' ||
+				typeId === 'ZodEffects' ||
+				typeId === 'effects' ||
+				typeId === 'ZodReadonly' ||
+				typeId === 'readonly') &&
+			current._def.innerType
+		) {
+			current = current._def.innerType as ZodTypeInternal;
+		} else if ((typeId === 'ZodEffects' || typeId === 'effects') && current._def.schema) {
+			current = current._def.schema as ZodTypeInternal;
+		} else {
+			break;
+		}
+	}
+
+	return { hasDefault: false, defaultIsFunction: false };
+}
+
+export function parseOptionsSchema(schema: ZodType): ParsedOption[] {
+	const shape = getShape(schema);
+	const options: ParsedOption[] = [];
+
+	for (const [key, value] of Object.entries(shape)) {
+		const unwrapped = unwrapSchema(value) as ZodTypeInternal;
+		const description =
+			(unwrapped as ZodTypeInternal)?._def?.description ??
+			(value as unknown as { description?: string })?.description ??
+			(value as ZodTypeInternal)?._def?.description;
+		/* eslint-disable @typescript-eslint/no-explicit-any */
+		const typeId =
+			unwrapped?._def?.typeName || (unwrapped as any)?._def?.type || (unwrapped as any)?.type;
+		/* eslint-enable @typescript-eslint/no-explicit-any */
+
+		// Extract default info using helper that walks the wrapper chain
+		const defaultInfo = extractDefaultInfo(value);
+
+		// Evaluate function defaults at parse-time for actual default value
+		const defaultValue = defaultInfo.defaultIsFunction
+			? (defaultInfo.defaultValue as () => unknown)()
+			: defaultInfo.defaultValue;
+
+		let type: 'string' | 'number' | 'boolean' = 'string';
+		if (typeId === 'ZodNumber' || typeId === 'number') {
+			type = 'number';
+		} else if (typeId === 'ZodBoolean' || typeId === 'boolean') {
+			type = 'boolean';
+		}
+
+		options.push({
+			name: key,
+			type,
+			description,
+			hasDefault: defaultInfo.hasDefault,
+			defaultValue,
+		});
+	}
+
+	return options;
+}
+
+export function buildValidationInput(
+	schemas: CommandSchemas,
+	rawArgs: unknown[],
+	rawOptions: Record<string, unknown>
+): { args: Record<string, unknown>; options: Record<string, unknown> } {
+	const result = { args: {} as Record<string, unknown>, options: {} as Record<string, unknown> };
+
+	if (schemas.args) {
+		const parsed = parseArgsSchema(schemas.args);
+		for (let i = 0; i < parsed.names.length; i++) {
+			result.args[parsed.names[i]] = rawArgs[i];
+		}
+	}
+
+	if (schemas.options) {
+		const parsed = parseOptionsSchema(schemas.options);
+		for (const opt of parsed) {
+			if (rawOptions[opt.name] !== undefined) {
+				result.options[opt.name] = rawOptions[opt.name];
+			}
+		}
+	}
+
+	return result;
+}

package/src/sound.ts

@@ -0,0 +1,25 @@
+import { $ } from 'bun';
+
+export async function playSound(): Promise<void> {
+	const platform = process.platform;
+
+	let result;
+	switch (platform) {
+		case 'darwin':
+			result = await $`afplay /System/Library/Sounds/Glass.aiff`.quiet().nothrow();
+			break;
+		case 'linux':
+			result = await $`paplay /usr/share/sounds/freedesktop/stereo/complete.oga`
+				.quiet()
+				.nothrow();
+			break;
+		case 'win32':
+			result = await $`rundll32 user32.dll,MessageBeep 0x00000040`.quiet().nothrow();
+			break;
+	}
+
+	// Fallback to terminal bell if command failed or platform unsupported
+	if (!result || result.exitCode !== 0) {
+		process.stdout.write('\u0007');
+	}
+}