@agentuity/cli 0.0.6

package/src/cmd/example/sound.ts

@@ -0,0 +1,14 @@
+import type { SubcommandDefinition } from '../../types';
+import * as tui from '@/tui';
+import { playSound } from '@/sound';
+
+export const soundSubcommand: SubcommandDefinition = {
+	name: 'sound',
+	description: 'Test completion sound',
+
+	async handler() {
+		tui.info('Playing completion sound...');
+		await playSound();
+		tui.success('Sound played!');
+	},
+};

package/src/cmd/example/spinner.ts

@@ -0,0 +1,44 @@
+import { createSubcommand } from '@/types';
+import * as tui from '@/tui';
+
+export const spinnerSubcommand = createSubcommand({
+	name: 'spinner',
+	description: 'Demo of spinner TUI component',
+
+	async handler() {
+		await tui.spinner('Loading configuration...', async () => {
+			await Bun.sleep(2000);
+			return { loaded: true };
+		});
+
+		await tui.spinner('Fetching data...', Bun.sleep(1500));
+
+		const result = await tui.spinner('Processing...', async () => {
+			await Bun.sleep(1000);
+			return 42;
+		});
+
+		tui.info(`Result: ${result}`);
+
+		// Spinner with progress tracking
+		await tui.spinner({
+			type: 'progress',
+			message: 'Downloading file...',
+			callback: async (progress) => {
+				for (let i = 0; i <= 100; i += 5) {
+					progress(i);
+					await Bun.sleep(100);
+				}
+			},
+		});
+
+		try {
+			await tui.spinner('This will fail...', async () => {
+				await Bun.sleep(1000);
+				throw new Error('Something went wrong!');
+			});
+		} catch (err) {
+			tui.error(`Caught error: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	},
+});

package/src/cmd/example/steps.ts

@@ -0,0 +1,66 @@
+import { createSubcommand } from '@/types';
+import { runSteps, stepSuccess, stepSkipped, stepError } from '@/steps';
+
+export const stepsSubcommand = createSubcommand({
+	name: 'steps',
+	description: 'Demo of step progress UI component',
+
+	async handler() {
+		await runSteps([
+			{
+				label: 'Launching application...',
+				run: async () => {
+					await Bun.sleep(1500);
+					return stepSuccess();
+				},
+			},
+			{
+				label: 'Installing dependencies...',
+				run: async () => {
+					await Bun.sleep(2000);
+					return stepSuccess();
+				},
+			},
+			{
+				label: 'Checking for updates...',
+				run: async () => {
+					await Bun.sleep(800);
+					return stepSkipped('already up to date');
+				},
+			},
+			{
+				label: 'Registering service...',
+				run: async () => {
+					await Bun.sleep(1200);
+					return stepSuccess();
+				},
+			},
+			{
+				label: 'Building project...',
+				run: async () => {
+					await Bun.sleep(1800);
+					return stepSuccess();
+				},
+			},
+			{
+				type: 'progress',
+				label: 'Downloading packages...',
+				run: async (progress) => {
+					// Simulate download with progress updates
+					for (let i = 0; i <= 100; i += 10) {
+						progress(i);
+						await Bun.sleep(200);
+					}
+					return stepSuccess();
+				},
+			},
+			{
+				label: 'Deploying the app ...',
+				run: async () => {
+					await Bun.sleep(1200);
+					return stepError('something bad happened');
+				},
+			},
+		]);
+	},
+});

package/src/cmd/example/version.ts

@@ -0,0 +1,13 @@
+import { createSubcommand } from '@/types';
+
+export const versionSubcommand = createSubcommand({
+	name: 'version',
+	description: 'Example: Display version information (no auth required)',
+
+	async handler(ctx) {
+		const { logger } = ctx;
+
+		logger.info('Version 1.0.0');
+		logger.info('This command does not require authentication');
+	},
+});

package/src/cmd/index.ts

@@ -0,0 +1,46 @@
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { CommandDefinition } from '../types';
+
+export async function discoverCommands(): Promise<CommandDefinition[]> {
+	const cmdDir = join(import.meta.dir);
+	const entries = await readdir(cmdDir, { withFileTypes: true });
+
+	const commands: CommandDefinition[] = [];
+
+	for (const entry of entries) {
+		if (entry.isDirectory()) {
+			try {
+				const modulePath = join(cmdDir, entry.name, 'index.ts');
+				const module = await import(modulePath);
+
+				if (module.default || module.command) {
+					const cmd = module.default || module.command;
+					commands.push(cmd);
+
+					// Auto-create hidden top-level aliases for subcommands with toplevel: true
+					if (cmd.subcommands) {
+						for (const subcommand of cmd.subcommands) {
+							if (subcommand.toplevel) {
+								const alias: CommandDefinition = {
+									name: subcommand.name,
+									description: subcommand.description,
+									aliases: subcommand.aliases,
+									hidden: true,
+									requiresAuth: subcommand.requiresAuth,
+									schema: subcommand.schema,
+									handler: subcommand.handler,
+								};
+								commands.push(alias);
+							}
+						}
+					}
+				}
+			} catch (error) {
+				console.warn(`Warning: Failed to load command from ${entry.name}:`, error);
+			}
+		}
+	}
+
+	return commands;
+}

package/src/cmd/profile/README.md

@@ -0,0 +1,80 @@
+# Profile Management
+
+The profile command allows you to manage multiple configuration profiles for different environments (production, staging, local development, etc.).
+
+## How It Works
+
+Profiles are YAML files stored in `~/.config/agentuity/` that contain a `name` field. The CLI maintains a `profile` file in the same directory that stores the path to the currently selected profile.
+
+When you run the CLI, it automatically loads the active profile's configuration.
+
+## Commands
+
+### `profile show` (alias: `current`)
+
+Show the configuration of the currently active profile.
+
+```bash
+agentuity profile show
+agentuity profile current
+```
+
+Example output:
+
+```
+[INFO] Profile: /Users/username/.config/agentuity/production.yaml
+
+name: production
+auth:
+    api_key: ck_...
+    user_id: user_...
+overrides:
+    api_url: "https://api.agentuity.com"
+```
+
+### `profile list` (alias: `ls`)
+
+Lists all available profiles. The currently active profile is marked with a bullet (`•`).
+
+```bash
+agentuity profile list
+```
+
+Example output:
+
+```
+[INFO] Available profiles:
+[INFO] • production      agentuity/production.yaml
+[INFO]   local           agentuity/local.yaml
+```
+
+### `profile use [name]` (alias: `select`)
+
+Switch to a different profile by name. If no name is provided, shows the current profile and available options.
+
+```bash
+# Switch to a specific profile
+agentuity profile use local
+
+# Show current profile
+agentuity profile use
+```
+
+## Profile File Format
+
+Each profile is a YAML file with at minimum a `name` field:
+
+```yaml
+name: 'production'
+# other configuration...
+```
+
+The `name` field is extracted using the regex: `/\bname:\s+["']?([\w-_]+)["']?/`
+
+## Implementation Details
+
+- Profile selection is stored in `~/.config/agentuity/profile`
+- Profile files must have `.yaml` extension
+- Profile names must match: `^[\w-_]{3,}$` (3+ chars, alphanumeric, dashes, underscores)
+- The config loader (`loadConfig()`) automatically uses the active profile
+- If no profile is selected or the file doesn't exist, falls back to `config.yaml`

package/src/cmd/profile/create.ts

@@ -0,0 +1,57 @@
+import { createSubcommand } from '@/types';
+import { z } from 'zod';
+import {
+	fetchProfiles,
+	getDefaultConfigDir,
+	ensureConfigDir,
+	generateYAMLTemplate,
+} from '@/config';
+import { join } from 'node:path';
+import { writeFile } from 'node:fs/promises';
+import * as tui from '@/tui';
+
+const PROFILE_NAME_REGEX = /^[\w_-]{3,}$/;
+
+export const createCommand = createSubcommand({
+	name: 'create',
+	description: 'Create a new configuration profile',
+	aliases: ['new'],
+	schema: {
+		args: z
+			.object({
+				name: z
+					.string()
+					.min(3)
+					.regex(PROFILE_NAME_REGEX)
+					.describe('The name of the profile to create'),
+			})
+			.describe('Profile creation arguments'),
+	},
+
+	async handler(ctx) {
+		const { logger, args } = ctx;
+		const { name } = args;
+
+		const profiles = await fetchProfiles();
+		const existing = profiles.find((p) => p.name === name);
+
+		if (existing) {
+			return logger.fatal(`Profile "${name}" already exists at ${existing.filename}`);
+		}
+
+		await ensureConfigDir();
+		const configDir = getDefaultConfigDir();
+		const filename = join(configDir, `${name}.yaml`);
+
+		const template = generateYAMLTemplate(name);
+
+		try {
+			await writeFile(filename, template, { flag: 'wx', mode: 0o600 });
+			tui.success(`Created profile "${name}" at ${filename}`);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			const stack = error instanceof Error ? error.stack : undefined;
+			logger.fatal(`Failed to create profile: ${message}${stack ? `\n${stack}` : ''}`);
+		}
+	},
+});

package/src/cmd/profile/delete.ts

@@ -0,0 +1,52 @@
+import { createSubcommand } from '@/types';
+import { z } from 'zod';
+import { fetchProfiles } from '@/config';
+import { unlink } from 'node:fs/promises';
+import * as tui from '@/tui';
+
+export const deleteCommand = createSubcommand({
+	name: 'delete',
+	description: 'Delete a configuration profile',
+	aliases: ['remove', 'rm'],
+	schema: {
+		args: z.object({
+			name: z.string().describe('The name of the profile to delete'),
+		}),
+		options: z.object({
+			confirm: z.boolean().optional().describe('Skip confirmation prompt'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { logger, args, opts } = ctx;
+		const { name } = args;
+
+		const profiles = await fetchProfiles();
+		const profile = profiles.find((p) => p.name === name);
+
+		if (!profile) {
+			return logger.fatal(`Profile "${name}" not found`);
+		}
+
+		// Ask for confirmation unless --confirm flag is passed
+		if (!opts?.confirm) {
+			const confirmed = await tui.confirm(`Delete profile "${name}"?`, false);
+			if (!confirmed) {
+				logger.info('Cancelled');
+				return;
+			}
+		}
+
+		try {
+			await unlink(profile.filename);
+			tui.success(`Deleted profile "${name}"`);
+			if (profile.selected) {
+				tui.warning(
+					'The active profile was deleted. Use "profile use <name>" to select a new default.'
+				);
+			}
+		} catch (error) {
+			logger.fatal(`Failed to delete profile: ${error}`);
+		}
+	},
+});

package/src/cmd/profile/index.ts

@@ -0,0 +1,12 @@
+import { createCommand } from '@/types';
+import { createCommand as createProfileCmd } from './create';
+import { useCommand } from './use';
+import { listCommand } from './list';
+import { showCommand } from './show';
+import { deleteCommand } from './delete';
+
+export const command = createCommand({
+	name: 'profile',
+	description: 'Manage configuration profiles',
+	subcommands: [createProfileCmd, useCommand, listCommand, showCommand, deleteCommand],
+});

package/src/cmd/profile/list.ts

@@ -0,0 +1,27 @@
+import type { SubcommandDefinition } from '@/types';
+import { fetchProfiles } from '@/config';
+import { basename, dirname } from 'node:path';
+import * as tui from '@/tui';
+
+export const listCommand: SubcommandDefinition = {
+	name: 'list',
+	description: 'List all available profiles',
+	aliases: ['ls'],
+
+	async handler() {
+		const profiles = await fetchProfiles();
+
+		if (profiles.length === 0) {
+			tui.info('No profiles found');
+			return;
+		}
+
+		console.log('Available profiles:');
+		for (const profile of profiles) {
+			const marker = profile.selected ? '•' : ' ';
+			const name = tui.padRight(profile.name, 15, ' ');
+			const path = `${basename(dirname(profile.filename))}/${basename(profile.filename)}`;
+			console.log(`${marker} ${name} ${tui.muted(path)}`);
+		}
+	},
+};

package/src/cmd/profile/show.ts

@@ -0,0 +1,54 @@
+import { createSubcommand } from '@/types';
+import { z } from 'zod';
+import { getProfile, fetchProfiles } from '@/config';
+import { readFile } from 'node:fs/promises';
+import * as tui from '@/tui';
+
+export const showCommand = createSubcommand({
+	name: 'show',
+	description: 'Show the configuration of a profile (defaults to current)',
+	aliases: ['current'],
+	schema: {
+		args: z
+			.object({
+				name: z.string().optional().describe('Profile name to show (optional)'),
+			})
+			.describe('Profile show arguments'),
+	},
+
+	async handler(ctx) {
+		const { logger, args } = ctx;
+
+		try {
+			let profilePath: string;
+
+			if (args.name) {
+				// Find profile by name
+				const profiles = await fetchProfiles();
+				const profile = profiles.find((p) => p.name === args.name);
+
+				if (!profile) {
+					return logger.fatal(`Profile "${args.name}" not found`);
+				}
+
+				profilePath = profile.filename;
+			} else {
+				// Use current profile
+				profilePath = await getProfile();
+			}
+
+			const content = await readFile(profilePath, 'utf-8');
+
+			tui.info(`Profile: ${profilePath}`);
+			tui.newline();
+
+			console.log(content);
+		} catch (error) {
+			if (error instanceof Error) {
+				logger.fatal(`Failed to show profile: ${error.message}`);
+			} else {
+				logger.fatal('Failed to show profile');
+			}
+		}
+	},
+});

package/src/cmd/profile/use.ts

@@ -0,0 +1,30 @@
+import { createSubcommand } from '@/types';
+import { z } from 'zod';
+import { fetchProfiles, saveProfile } from '@/config';
+import * as tui from '@/tui';
+
+export const useCommand = createSubcommand({
+	name: 'use',
+	description: 'Switch to a different configuration profile',
+	aliases: ['switch'],
+	schema: {
+		args: z.object({
+			name: z.string().describe('The name of the profile to use'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { logger, args } = ctx;
+		const { name } = args;
+
+		const profiles = await fetchProfiles();
+		const profile = profiles.find((p) => p.name === name);
+
+		if (!profile) {
+			logger.fatal(`Profile "${name}" not found`);
+		}
+
+		await saveProfile(profile!.filename);
+		tui.success(`Switched to profile "${name}"`);
+	},
+});