@agentuity/cli 0.0.6

package/src/cmd/project/create.ts

@@ -0,0 +1,247 @@
+import { createSubcommand } from '@/types';
+import { z } from 'zod';
+import enquirer from 'enquirer';
+import { existsSync, readdirSync } from 'node:fs';
+import { resolve, basename, join } from 'node:path';
+
+export const createProjectSubcommand = createSubcommand({
+	name: 'create',
+	description: 'Create a new project',
+	aliases: ['new'],
+	toplevel: true,
+	requiresAuth: false,
+	schema: {
+		options: z.object({
+			name: z.string().optional().describe('Project name'),
+			dir: z.string().optional().describe('Directory to create the project in'),
+			install: z
+				.boolean()
+				.optional()
+				.default(true)
+				.describe('Run bun install after creating the project (use --no-install to skip)'),
+			confirm: z.boolean().optional().describe('Skip confirmation prompts'),
+			fromBunCreate: z
+				.boolean()
+				.optional()
+				.describe('Internal: called from bun create postinstall'),
+			dev: z.boolean().optional().describe('Internal: use local template for testing'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { logger, opts } = ctx;
+
+		// Case 2: Called from bun create postinstall
+		if (opts.fromBunCreate) {
+			const projectDir = process.cwd();
+			const packageJsonPath = join(projectDir, 'package.json');
+
+			if (!existsSync(packageJsonPath)) {
+				logger.error('package.json not found in current directory');
+				return;
+			}
+
+			// Disable log prefixes for cleaner postinstall output
+			logger.setShowPrefix(false);
+
+			const packageJsonFile = Bun.file(packageJsonPath);
+			const packageJson = await packageJsonFile.json();
+			const projectName = packageJson.name || basename(projectDir);
+
+			logger.info(`\n🔧 Setting up ${projectName}...\n`);
+
+			// Update package.json - remove bun-create metadata
+			packageJson.name = projectName;
+			delete packageJson['bun-create'];
+			delete packageJson.bin;
+			packageJson.private = true;
+			delete packageJson.files;
+			delete packageJson.keywords;
+			delete packageJson.author;
+			delete packageJson.license;
+			delete packageJson.publishConfig;
+			delete packageJson.description;
+
+			// Remove enquirer from dependencies (only needed for setup)
+			if (packageJson.dependencies) {
+				delete packageJson.dependencies.enquirer;
+			}
+
+			await Bun.write(packageJsonPath, JSON.stringify(packageJson, null, '\t'));
+			logger.info('✓ Updated package.json');
+
+			// Update README.md
+			const readmePath = join(projectDir, 'README.md');
+			if (existsSync(readmePath)) {
+				const readmeFile = Bun.file(readmePath);
+				let readme = await readmeFile.text();
+				readme = readme.replace(/\{\{PROJECT_NAME\}\}/g, projectName);
+				await Bun.write(readmePath, readme);
+				logger.info('✓ Updated README.md');
+			}
+
+			// Update AGENTS.md
+			const agentsMdPath = join(projectDir, 'AGENTS.md');
+			if (existsSync(agentsMdPath)) {
+				const agentsMdFile = Bun.file(agentsMdPath);
+				let agentsMd = await agentsMdFile.text();
+				agentsMd = agentsMd.replace(/\{\{PROJECT_NAME\}\}/g, projectName);
+				await Bun.write(agentsMdPath, agentsMd);
+				logger.info('✓ Updated AGENTS.md');
+			}
+
+			// Remove setup files
+			const filesToRemove = ['setup.ts'];
+			for (const file of filesToRemove) {
+				const filePath = join(projectDir, file);
+				if (existsSync(filePath)) {
+					await Bun.$`rm ${filePath}`;
+					logger.info('✓ Removed ${file}');
+				}
+			}
+
+			logger.info('\n✨ Setup complete!\n');
+			return;
+		}
+
+		// Case 1: Normal CLI flow
+		// Relaxed validation: any reasonable name between 2-64 characters
+		const isValidProjectName = (name: string): boolean => {
+			return name.trim().length >= 2 && name.trim().length <= 64;
+		};
+
+		// Transform name to URL and disk-friendly format
+		const transformToDirectoryName = (name: string): string => {
+			const result = name
+				.trim()
+				.toLowerCase()
+				.replace(/[^a-z0-9]+/g, '-') // Replace non-alphanumeric with hyphens
+				.replace(/^-+|-+$/g, '') // Remove leading/trailing hyphens
+				.replace(/-+/g, '-') // Replace consecutive hyphens with single hyphen
+				.substring(0, 64); // Ensure max length
+
+			// Validate result is non-empty (happens when name contains only special chars)
+			if (!result) {
+				throw new Error(
+					`Invalid project name "${name}": must contain at least one alphanumeric character`
+				);
+			}
+
+			return result;
+		};
+
+		// Get project name
+		let projectName = opts.name;
+		while (!projectName || !isValidProjectName(projectName)) {
+			const result = await enquirer.prompt<{ name: string }>({
+				type: 'input',
+				name: 'name',
+				message: 'Project name:',
+				initial: projectName,
+				validate: (value: string) => {
+					if (!value) return 'Project name is required';
+					if (!isValidProjectName(value)) {
+						return 'Project name must be between 2 and 64 characters';
+					}
+					return true;
+				},
+			});
+			projectName = result.name;
+		}
+
+		projectName = projectName.trim();
+		const projectDirName = transformToDirectoryName(projectName);
+
+		// Get directory - if specified, create the project there, otherwise create in current dir
+		const baseDir = opts.dir ? resolve(opts.dir) : process.cwd();
+		const targetDir = resolve(baseDir, projectDirName);
+
+		// Check if directory exists and validate
+		let shouldProceed = true;
+		if (existsSync(targetDir)) {
+			const files = readdirSync(targetDir);
+			const hasFiles = files.length > 0;
+
+			if (hasFiles) {
+				if (opts.confirm === false) {
+					logger.error(`Directory ${targetDir} is not empty and --no-confirm was specified`);
+					return;
+				}
+
+				// Require explicit confirmation in non-TTY environments
+				if (opts.confirm !== true && !process.stdin.isTTY) {
+					logger.error(
+						`Directory "${targetDir}" is not empty. Use --confirm flag in non-interactive environments.`
+					);
+					return;
+				}
+
+				// Interactive prompt in TTY environments
+				if (opts.confirm !== true && process.stdin.isTTY) {
+					const result = await enquirer.prompt<{ proceed: boolean }>({
+						type: 'confirm',
+						name: 'proceed',
+						message: `Directory "${targetDir}" is not empty. Files may be overwritten. Continue?`,
+						initial: false,
+					});
+					shouldProceed = result.proceed;
+				}
+
+				if (!shouldProceed) {
+					logger.info('Operation cancelled');
+					return;
+				}
+			}
+		}
+
+		// Print collected values
+		logger.info('\n=== Project Configuration ===');
+		logger.info(`Name: ${projectName}`);
+		logger.info(`Directory Name: ${projectDirName}`);
+		logger.info(`Target Directory: ${targetDir}`);
+		logger.info('=============================\n');
+
+		// Run bun create to scaffold the project
+		logger.info('Creating project from template...');
+
+		try {
+			// Determine template name based on dev mode
+			const templateName = opts.dev ? 'agentuity-dev' : 'agentuity';
+
+			if (opts.dev) {
+				logger.info('🔧 Dev mode: Using local template');
+			}
+
+			// Build bun create command args
+			// Note: bun create supports --no-install to skip dependency installation
+			const bunCreateArgs = ['bun', 'create'];
+			if (opts.install === false) {
+				bunCreateArgs.push('--no-install');
+			}
+			bunCreateArgs.push(templateName, projectDirName);
+
+			logger.info(`Running: ${bunCreateArgs.join(' ')}`);
+
+			const result = Bun.spawn(bunCreateArgs, {
+				cwd: baseDir,
+				stdout: 'inherit',
+				stderr: 'inherit',
+				stdin: 'inherit',
+			});
+
+			const exitCode = await result.exited;
+
+			if (exitCode !== 0) {
+				throw new Error(`bun create exited with code ${exitCode}`);
+			}
+
+			logger.info('\n✨ Project created successfully!');
+			logger.info(`\nNext steps:`);
+			logger.info(`  cd ${projectDirName}`);
+			logger.info(`  bun run dev`);
+		} catch (error) {
+			logger.error('Failed to create project:', error);
+			throw error;
+		}
+	},
+});

package/src/cmd/project/delete.ts

@@ -0,0 +1,13 @@
+import { createSubcommand } from '@/types';
+
+export const deleteSubcommand = createSubcommand({
+	name: 'delete',
+	description: 'Delete a project',
+	aliases: ['rm', 'del'],
+	requiresAuth: true,
+
+	async handler(ctx) {
+		const { logger } = ctx;
+		logger.info('TODO: Implement project delete functionality');
+	},
+});

package/src/cmd/project/index.ts

@@ -0,0 +1,11 @@
+import { createCommand } from '@/types';
+import { createProjectSubcommand } from './create';
+import { listSubcommand } from './list';
+import { deleteSubcommand } from './delete';
+import { showSubcommand } from './show';
+
+export const command = createCommand({
+	name: 'project',
+	description: 'Manage Agentuity projects',
+	subcommands: [createProjectSubcommand, listSubcommand, deleteSubcommand, showSubcommand],
+});

package/src/cmd/project/list.ts

@@ -0,0 +1,13 @@
+import { createSubcommand } from '@/types';
+
+export const listSubcommand = createSubcommand({
+	name: 'list',
+	description: 'List all projects',
+	aliases: ['ls'],
+	requiresAuth: true,
+
+	async handler(ctx) {
+		const { logger } = ctx;
+		logger.info('TODO: Implement project list functionality');
+	},
+});

package/src/cmd/project/show.ts

@@ -0,0 +1,12 @@
+import { createSubcommand } from '@/types';
+
+export const showSubcommand = createSubcommand({
+	name: 'show',
+	description: 'Show project details',
+	requiresAuth: true,
+
+	async handler(ctx) {
+		const { logger } = ctx;
+		logger.info('TODO: Implement project show functionality');
+	},
+});

package/src/cmd/version/index.ts

@@ -0,0 +1,16 @@
+import { createCommand } from '@/types';
+import { getVersion } from '@/version';
+import { logger } from '@/logger';
+
+export const command = createCommand({
+	name: 'version',
+	description: 'Display version information',
+
+	async handler() {
+		try {
+			console.log(getVersion());
+		} catch (error) {
+			logger.fatal('Failed to retrieve version: %s', error);
+		}
+	},
+});

package/src/command-prefix.ts

@@ -0,0 +1,43 @@
+import path from 'node:path';
+import { getPackageName } from './version';
+
+let cachedPrefix: string | null = null;
+
+/**
+ * Detects how the CLI is being invoked and returns the appropriate command prefix.
+ * Returns "agentuity" if installed globally, or "bunx @agentuity/cli" if running via bunx.
+ */
+export function getCommandPrefix(): string {
+	if (cachedPrefix) {
+		return cachedPrefix;
+	}
+
+	// Check if running from a globally installed package
+	// When installed globally, the process.argv[1] will be in a bin directory
+	const scriptPath = process.argv[1] || '';
+	const normalized = path.normalize(scriptPath);
+
+	// If the script is in node_modules/.bin or a global bin directory, it's likely global
+	const isGlobal =
+		normalized.includes(`${path.sep}bin${path.sep}`) &&
+		!normalized.includes(`${path.sep}node_modules${path.sep}`) &&
+		!normalized.includes(path.join('packages', 'cli', 'bin'));
+
+	if (isGlobal) {
+		cachedPrefix = 'agentuity';
+	} else {
+		// Running locally via bunx or from source
+		const pkgName = getPackageName();
+		cachedPrefix = `bunx ${pkgName}`;
+	}
+
+	return cachedPrefix;
+}
+
+/**
+ * Gets a formatted command string with the appropriate prefix.
+ * Example: getCommand('auth login') => 'agentuity auth login' or 'bunx @agentuity/cli auth login'
+ */
+export function getCommand(command: string): string {
+	return `${getCommandPrefix()} ${command}`;
+}

package/src/config.ts

@@ -0,0 +1,304 @@
+import { YAML } from 'bun';
+import { join, extname } from 'node:path';
+import { homedir } from 'node:os';
+import { mkdir, readdir, readFile, writeFile, chmod } from 'node:fs/promises';
+import type { Config, Profile, AuthData } from './types';
+import { ConfigSchema } from './types';
+import * as tui from '@/tui';
+import { z } from 'zod';
+
+export function getDefaultConfigDir(): string {
+	return join(homedir(), '.config', 'agentuity');
+}
+
+export function getDefaultConfigPath(): string {
+	return join(getDefaultConfigDir(), 'config.yaml');
+}
+
+export function getProfilePath(): string {
+	return join(getDefaultConfigDir(), 'profile');
+}
+
+export async function ensureConfigDir(): Promise<void> {
+	const dir = getDefaultConfigDir();
+	try {
+		await mkdir(dir, { recursive: true, mode: 0o700 });
+	} catch {
+		// Ignore if already exists
+	}
+}
+
+export async function saveProfile(path: string): Promise<void> {
+	await ensureConfigDir();
+	await writeFile(getProfilePath(), path, { mode: 0o644 });
+}
+
+export async function getProfile(): Promise<string> {
+	const profilePath = getProfilePath();
+	const defaultConfigPath = getDefaultConfigPath();
+
+	try {
+		const file = Bun.file(profilePath);
+		if (await file.exists()) {
+			const content = await file.text();
+			const savedPath = content.trim();
+			const savedFile = Bun.file(savedPath);
+			if (await savedFile.exists()) {
+				return savedPath;
+			}
+		}
+	} catch {
+		// Fall back to default
+	}
+
+	return defaultConfigPath;
+}
+
+export async function fetchProfiles(): Promise<Profile[]> {
+	const configDir = getDefaultConfigDir();
+	const currentConfigPath = await getProfile();
+	const profiles: Profile[] = [];
+	const nameRegex = /\bname:\s+["']?([\w-_]+)["']?/;
+
+	try {
+		const entries = await readdir(configDir);
+
+		for (const entry of entries) {
+			if (extname(entry) === '.yaml' && !entry.includes('templates/')) {
+				const filePath = join(configDir, entry);
+
+				try {
+					const content = await readFile(filePath, 'utf-8');
+					const match = nameRegex.exec(content);
+
+					if (match && match[1]) {
+						profiles.push({
+							name: match[1],
+							filename: filePath,
+							selected: filePath === currentConfigPath,
+						});
+					}
+				} catch {
+					// Skip files we can't read
+				}
+			}
+		}
+	} catch {
+		// Directory doesn't exist or can't be read
+	}
+
+	return profiles;
+}
+
+export async function loadConfig(customPath?: string): Promise<Config | null> {
+	const configPath = customPath || (await getProfile());
+
+	try {
+		const file = Bun.file(configPath);
+		const exists = await file.exists();
+
+		if (!exists) {
+			return null;
+		}
+
+		const content = await file.text();
+		const config = YAML.parse(content);
+
+		const result = ConfigSchema.safeParse(config);
+		if (!result.success) {
+			tui.error(`Invalid config in ${configPath}:`);
+			for (const issue of result.error.issues) {
+				const path = issue.path.length > 0 ? issue.path.join('.') : 'root';
+				tui.bullet(`${path}: ${issue.message}`);
+			}
+			process.exit(1);
+		}
+
+		return result.data;
+	} catch (error) {
+		if (error instanceof Error) {
+			console.error(`Error loading config from ${configPath}:`, error.message);
+		}
+		return null;
+	}
+}
+
+function formatYAML(obj: unknown, indent = 0): string {
+	const spaces = '    '.repeat(indent);
+	const lines: string[] = [];
+
+	if (typeof obj !== 'object' || obj === null) {
+		return String(obj);
+	}
+
+	for (const [key, value] of Object.entries(obj)) {
+		if (value === null || value === undefined) {
+			continue;
+		}
+
+		if (typeof value === 'object' && !Array.isArray(value)) {
+			lines.push(`${spaces}${key}:`);
+			lines.push(formatYAML(value, indent + 1));
+		} else if (Array.isArray(value)) {
+			lines.push(`${spaces}${key}:`);
+			for (const item of value) {
+				if (typeof item === 'object') {
+					lines.push(`${spaces}    -`);
+					lines.push(formatYAML(item, indent + 2));
+				} else {
+					lines.push(`${spaces}    - ${item}`);
+				}
+			}
+		} else if (typeof value === 'string') {
+			if (value === '') {
+				lines.push(`${spaces}${key}: ""`);
+			} else if (value.includes(':') || value.includes('#') || value.includes(' ')) {
+				lines.push(`${spaces}${key}: "${value}"`);
+			} else {
+				lines.push(`${spaces}${key}: ${value}`);
+			}
+		} else {
+			lines.push(`${spaces}${key}: ${value}`);
+		}
+	}
+
+	return lines.join('\n');
+}
+
+export async function saveConfig(config: Config, customPath?: string): Promise<void> {
+	const configPath = customPath || (await getProfile());
+	await ensureConfigDir();
+
+	const content = formatYAML(config);
+	await writeFile(configPath, content + '\n', { mode: 0o600 });
+	// Ensure existing files get correct permissions on upgrade
+	await chmod(configPath, 0o600);
+}
+
+export async function saveAuth(auth: AuthData): Promise<void> {
+	const config = (await loadConfig()) || { name: 'default' };
+	config.auth = {
+		api_key: auth.apiKey,
+		user_id: auth.userId,
+		expires: auth.expires.getTime(),
+	};
+	config.preferences = config.preferences || {};
+	(config.preferences as Record<string, unknown>).orgId = '';
+	await saveConfig(config);
+}
+
+export async function clearAuth(): Promise<void> {
+	const config = (await loadConfig()) || { name: 'default' };
+	config.auth = {
+		api_key: '',
+		user_id: '',
+		expires: Date.now(),
+	};
+	config.preferences = config.preferences || {};
+	(config.preferences as Record<string, unknown>).orgId = '';
+	await saveConfig(config);
+}
+
+export async function getAuth(): Promise<AuthData | null> {
+	const config = await loadConfig();
+	if (!config) return null;
+	const auth = config.auth as { api_key?: string; user_id?: string; expires?: number } | undefined;
+
+	if (!auth || !auth.api_key || !auth.user_id) {
+		return null;
+	}
+
+	return {
+		apiKey: auth.api_key,
+		userId: auth.user_id,
+		expires: new Date(auth.expires || 0),
+	};
+}
+
+function getSchemaDescription(schema: z.ZodTypeAny): string | undefined {
+	return (schema as unknown as { description?: string }).description;
+}
+
+function getPlaceholderValue(schema: z.ZodTypeAny): string {
+	// Unwrap optional to get to the inner type
+	let unwrapped = schema;
+	if (schema instanceof z.ZodOptional) {
+		unwrapped = (schema._def as unknown as { innerType: z.ZodTypeAny }).innerType;
+	}
+
+	// Check the type using constructor name
+	const typeName = unwrapped.constructor.name;
+
+	switch (typeName) {
+		case 'ZodString':
+			return '""';
+		case 'ZodNumber':
+			return '0';
+		case 'ZodBoolean':
+			return 'false';
+		default:
+			return '""';
+	}
+}
+
+function generateYAMLTemplate(name: string): string {
+	const lines: string[] = [];
+
+	// Add name (required)
+	lines.push(`name: "${name}"`);
+	lines.push('');
+
+	// Get schema shape
+	const shape = ConfigSchema.shape;
+
+	// Only include user-configurable sections
+	// Skip: auth (managed by login), devmode (internal), preferences (managed by CLI)
+	const userConfigurableSections = ['overrides'];
+
+	// Process each top-level field
+	for (const [key, value] of Object.entries(shape)) {
+		if (key === 'name') continue;
+		if (!userConfigurableSections.includes(key)) continue;
+
+		const schema = value as z.ZodTypeAny;
+
+		// Unwrap optional to get to the inner schema
+		let innerSchema = schema;
+		if (schema instanceof z.ZodOptional) {
+			innerSchema = (schema._def as unknown as { innerType: z.ZodTypeAny }).innerType;
+		}
+
+		const description = getSchemaDescription(schema);
+
+		// Add section comment
+		if (description) {
+			lines.push(`# ${description}`);
+		}
+
+		// For object schemas, expand their properties
+		if (innerSchema instanceof z.ZodObject) {
+			const innerShape = innerSchema.shape;
+			lines.push(`# ${key}:`);
+
+			for (const [subKey, subValue] of Object.entries(innerShape)) {
+				const subSchema = subValue as z.ZodTypeAny;
+				const subDesc = getSchemaDescription(subSchema);
+				const placeholder = getPlaceholderValue(subSchema);
+
+				if (subDesc) {
+					lines.push(`#     ${subKey}: ${placeholder}  # ${subDesc}`);
+				} else {
+					lines.push(`#     ${subKey}: ${placeholder}`);
+				}
+			}
+		} else {
+			const placeholder = getPlaceholderValue(schema);
+			lines.push(`# ${key}: ${placeholder}`);
+		}
+		lines.push('');
+	}
+
+	return lines.join('\n');
+}
+
+export { generateYAMLTemplate };

package/src/index.ts

@@ -0,0 +1,40 @@
+export { createCLI, registerCommands } from './cli';
+export { validateRuntime, isBun } from './runtime';
+export { getVersion, getRevision, getPackageName, getPackage } from './version';
+export {
+	loadConfig,
+	saveConfig,
+	getDefaultConfigPath,
+	getDefaultConfigDir,
+	getProfilePath,
+	ensureConfigDir,
+	saveProfile,
+	getProfile,
+	fetchProfiles,
+	saveAuth,
+	clearAuth,
+	getAuth,
+} from './config';
+export { APIClient, getAPIBaseURL, getAppBaseURL, UpgradeRequiredError } from './api';
+export { Logger, logger } from './logger';
+export { showBanner } from './banner';
+export { discoverCommands } from './cmd';
+export { detectColorScheme } from './terminal';
+export { getCommandPrefix, getCommand } from './command-prefix';
+export * as tui from './tui';
+export { runSteps, setStepsColorScheme, stepSuccess, stepSkipped, stepError } from './steps';
+export { playSound } from './sound';
+export type {
+	Config,
+	LogLevel,
+	GlobalOptions,
+	CommandContext,
+	SubcommandDefinition,
+	CommandDefinition,
+	Profile,
+	AuthData,
+	CommandSchemas,
+} from './types';
+export { createSubcommand, createCommand } from './types';
+export type { ColorScheme } from './terminal';
+export type { Step, SimpleStep, ProgressStep, StepOutcome, ProgressCallback } from './steps';