@agentuity/cli 0.0.57 → 0.0.59

package/src/cmd/cloud/vector/search.ts

@@ -0,0 +1,156 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+
+const VectorSearchResultSchema = z.object({
+	id: z.string().describe('Vector ID'),
+	key: z.string().describe('Vector key'),
+	similarity: z.number().describe('Similarity score (0-1)'),
+	metadata: z.record(z.string(), z.unknown()).optional().describe('Vector metadata'),
+});
+
+const VectorSearchResponseSchema = z.object({
+	namespace: z.string().describe('Namespace name'),
+	query: z.string().describe('Search query used'),
+	results: z.array(VectorSearchResultSchema).describe('Search results'),
+	count: z.number().describe('Number of results found'),
+});
+
+export const searchSubcommand = createCommand({
+	name: 'search',
+	aliases: ['list', 'ls'],
+	description: 'Search for vectors using semantic similarity',
+	tags: ['read-only', 'slow', 'requires-auth'],
+	requires: { auth: true, project: true },
+	idempotent: true,
+	examples: [
+		`${getCommand('vector search products "comfortable office chair"')} - Search for similar products`,
+		`${getCommand('vector list knowledge-base "machine learning"')} - Search knowledge base`,
+		`${getCommand('vector search docs "API documentation" --limit 5')} - Limit results`,
+		`${getCommand('vector search products "ergonomic" --similarity 0.8')} - Set minimum similarity`,
+		`${getCommand('vector ls embeddings "neural networks" --metadata category=ai')} - Filter by metadata`,
+	],
+	schema: {
+		args: z.object({
+			namespace: z.string().min(1).describe('the vector storage namespace'),
+			query: z.string().min(1).describe('the search query text'),
+		}),
+		options: z.object({
+			limit: z.number().optional().describe('maximum number of results to return (default: 10)'),
+			similarity: z
+				.number()
+				.min(0)
+				.max(1)
+				.optional()
+				.describe('minimum similarity threshold (0.0-1.0)'),
+			metadata: z
+				.string()
+				.optional()
+				.describe('filter by metadata (format: key=value or key1=value1,key2=value2)'),
+		}),
+		response: VectorSearchResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const storage = await createStorageAdapter(ctx);
+		const started = Date.now();
+
+		// Parse metadata filter if provided
+		let metadataFilter: Record<string, unknown> | undefined;
+		if (opts.metadata) {
+			const validPairs: Record<string, unknown> = {};
+			const malformed: string[] = [];
+			const pairs = opts.metadata.split(',');
+
+			for (const pair of pairs) {
+				const trimmedPair = pair.trim();
+				if (!trimmedPair) continue;
+
+				const firstEqualIdx = trimmedPair.indexOf('=');
+				if (firstEqualIdx === -1) {
+					malformed.push(trimmedPair);
+					continue;
+				}
+
+				const key = trimmedPair.substring(0, firstEqualIdx).trim();
+				const value = trimmedPair.substring(firstEqualIdx + 1).trim();
+
+				if (!key || !value) {
+					malformed.push(trimmedPair);
+					continue;
+				}
+
+				// Try to parse as JSON for complex values, otherwise use as string
+				try {
+					validPairs[key] = JSON.parse(value);
+				} catch {
+					validPairs[key] = value;
+				}
+			}
+
+			if (malformed.length > 0) {
+				ctx.logger.warn(`Skipping malformed metadata pairs: ${malformed.join(', ')}`);
+			}
+
+			if (Object.keys(validPairs).length > 0) {
+				metadataFilter = validPairs;
+			}
+		}
+
+		const results = await storage.search(args.namespace, {
+			query: args.query,
+			limit: opts.limit,
+			similarity: opts.similarity,
+			metadata: metadataFilter,
+		});
+
+		const durationMs = Date.now() - started;
+
+		if (!options.json) {
+			if (results.length === 0) {
+				tui.info(
+					`No vectors found matching "${tui.bold(args.query)}" in ${tui.bold(args.namespace)}`
+				);
+			} else {
+				tui.info(
+					`Found ${results.length} result(s) in ${tui.bold(args.namespace)} (${durationMs}ms):`
+				);
+
+				const tableData = results.map((result) => {
+					const metadataStr = result.metadata ? JSON.stringify(result.metadata) : '-';
+					return {
+						Key: result.key,
+						ID: result.id,
+						Similarity: `${(result.similarity * 100).toFixed(1)}%`,
+						Metadata:
+							metadataStr.length > 50 ? metadataStr.substring(0, 47) + '...' : metadataStr,
+					};
+				});
+
+				tui.table(tableData, [
+					{ name: 'Key', alignment: 'left' },
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'Similarity', alignment: 'right' },
+					{ name: 'Metadata', alignment: 'left' },
+				]);
+			}
+		}
+
+		return {
+			namespace: args.namespace,
+			query: args.query,
+			results: results.map((r) => ({
+				id: r.id,
+				key: r.key,
+				similarity: r.similarity,
+				metadata: r.metadata,
+			})),
+			count: results.length,
+		};
+	},
+});
+
+export default searchSubcommand;

package/src/cmd/cloud/vector/util.ts

@@ -0,0 +1,28 @@
+import { Logger, VectorStorageService } from '@agentuity/core';
+import { createServerFetchAdapter } from '@agentuity/server';
+import { loadProjectSDKKey } from '../../../config';
+import type { Config } from '../../../types';
+import * as tui from '../../../tui';
+
+export async function createStorageAdapter(ctx: {
+	logger: Logger;
+	projectDir: string;
+	config: Config | null;
+}) {
+	const sdkKey = await loadProjectSDKKey(ctx.projectDir);
+	if (!sdkKey) {
+		tui.fatal(`Couldn't find the AGENTUITY_SDK_KEY in ${ctx.projectDir} .env file`);
+	}
+
+	const adapter = createServerFetchAdapter(
+		{
+			headers: {
+				Authorization: `Bearer ${sdkKey}`,
+			},
+		},
+		ctx.logger
+	);
+
+	const baseUrl = ctx.config?.overrides?.catalyst_url ?? 'https://catalyst.agentuity.cloud';
+	return new VectorStorageService(baseUrl, adapter);
+}

package/src/cmd/dev/agents.ts

@@ -8,7 +8,7 @@ const AgentSchema = z.object({
 	id: z.string(),
 	name: z.string(),
 	description: z.string().nullable(),
-	identifier: z.string(),
+	identifier: z.string().nullable(), // nullable for legacy records
 	version: z.string().nullable(),
 	deploymentId: z.string().nullable(),
 	devmode: z.boolean(),
@@ -75,7 +75,8 @@ export const agentsSubcommand = createSubcommand({
 			tui.fatal(`Failed to fetch agents: ${response.message ?? 'Unknown error'}`);
 		}
 
-		const agents = response.data;
+		// Filter out legacy agents without identifiers
+		const agents = response.data.filter((agent) => agent.identifier !== null);
 
 		if (format === 'json' && !options.json) {
 			console.log(JSON.stringify(agents, null, 2));
@@ -91,7 +92,7 @@ export const agentsSubcommand = createSubcommand({
 					agents.map((agent) => ({
 						name: agent.name,
 						id: verbose ? agent.id : abbreviate(agent.id, 20),
-						identifier: verbose ? agent.identifier : abbreviate(agent.identifier, 20),
+						identifier: verbose ? agent.identifier! : abbreviate(agent.identifier!, 20),
 						deployment: abbreviate(agent.deploymentId, 20),
 						version: verbose
 							? (agent.version ?? 'N/A')

package/src/cmd/dev/index.ts

@@ -110,7 +110,7 @@ export const command = createCommand({
 		);
 		const deploymentId = getDevmodeDeploymentId(project?.projectId ?? '', devmode?.id ?? '');
 
-		if (devmode) {
+		if (devmode && opts.public) {
 			const configDir = getDefaultConfigDir();
 			const gravityDir = join(configDir, 'gravity');
 			let mustCheck = true;
@@ -238,48 +238,52 @@ export const command = createCommand({
 		let gravityClient: Bun.Subprocess | undefined;
 		let initialStartupComplete = false;
 
-		if (gravityBin && devmode && project) {
-			const sdkKey = await loadProjectSDKKey(rootDir);
-			if (!sdkKey) {
-				tui.warning(`Couldn't find the AGENTUITY_SDK_KEY in ${rootDir} .env file`);
-			} else {
-				const gravityBinExists = await Bun.file(gravityBin).exists();
-				if (!gravityBinExists) {
-					logger.error(
-						`Gravity binary not found at ${gravityBin}, skipping gravity client startup`
-					);
-				} else {
-					try {
-						gravityClient = Bun.spawn(
-							[
-								gravityBin,
-								'--endpoint-id',
-								devmode.id,
-								'--port',
-								env.PORT,
-								'--url',
-								config?.overrides?.gravity_url ?? 'grpc://devmode.agentuity.com',
-								'--log-level',
-								process.env.AGENTUITY_GRAVITY_LOG_LEVEL ?? 'error',
-							],
-							{
-								cwd: rootDir,
-								stdout: 'inherit',
-								stderr: 'inherit',
-								stdin: 'ignore',
-								env: { ...env, AGENTUITY_SDK_KEY: sdkKey },
-							}
-						);
-						gravityClient.exited.then(() => {
-							logger.debug('gravity client exited');
-						});
-					} catch (err) {
-						logger.error(
-							'Failed to spawn gravity client: %s',
-							err instanceof Error ? err.message : String(err)
-						);
+		const sdkKey = await loadProjectSDKKey(rootDir);
+		if (!sdkKey) {
+			tui.warning(`Couldn't find the AGENTUITY_SDK_KEY in ${rootDir} .env file`);
+		}
+		const gravityBinExists = gravityBin ? await Bun.file(gravityBin).exists() : true;
+		if (!gravityBinExists) {
+			logger.error(`Gravity binary not found at ${gravityBin}, skipping gravity client startup`);
+		}
+
+		async function restartGravityClient() {
+			if (gravityClient) {
+				gravityClient.kill('SIGINT');
+				gravityClient.kill();
+			}
+			if (!devmode || !opts.public) {
+				return;
+			}
+			try {
+				gravityClient = Bun.spawn(
+					[
+						gravityBin!,
+						'--endpoint-id',
+						devmode.id,
+						'--port',
+						env.PORT!,
+						'--url',
+						config?.overrides?.gravity_url ?? 'grpc://devmode.agentuity.com',
+						'--log-level',
+						process.env.AGENTUITY_GRAVITY_LOG_LEVEL ?? 'error',
+					],
+					{
+						cwd: rootDir,
+						stdout: 'inherit',
+						stderr: 'inherit',
+						stdin: 'ignore',
+						env: { ...env, AGENTUITY_SDK_KEY: sdkKey },
 					}
-				}
+				);
+				gravityClient.exited.then(() => {
+					logger.debug('gravity client exited');
+				});
+			} catch (err) {
+				logger.error(
+					'Failed to spawn gravity client: %s',
+					err instanceof Error ? err.message : String(err)
+				);
 			}
 		}
 
@@ -307,14 +311,42 @@ export const command = createCommand({
 			}
 		}
 
+		let lastErrorLineCount = 0;
+		let showedRestartMessage = false;
+
+		function clearRestartMessage() {
+			if (showedRestartMessage) {
+				process.stdout.write('\x1b[1A\x1b[2K');
+				showedRestartMessage = false;
+			}
+		}
+
 		function failure(msg: string) {
 			failed = true;
 			failures++;
+			// Exit immediately on initial startup failure
+			if (!initialStartupComplete) {
+				tui.fatal(msg);
+			}
+			// During hot reload, show error but don't exit unless too many failures
 			if (failures >= 5) {
 				tui.error(msg);
 				tui.fatal('too many failures, exiting');
 			} else {
-				setImmediate(() => tui.error(msg));
+				// Ensure we're on a new line before printing error
+				tui.error(msg);
+				// Track lines: 1 for "✗ Building..." + 1 for error message
+				lastErrorLineCount = 2;
+			}
+		}
+
+		function clearLastError() {
+			if (lastErrorLineCount > 0) {
+				// Move cursor up and clear each line
+				for (let i = 0; i < lastErrorLineCount; i++) {
+					process.stdout.write('\x1b[1A\x1b[2K');
+				}
+				lastErrorLineCount = 0;
 			}
 		}
 
@@ -406,6 +438,7 @@ export const command = createCommand({
 					logger.trace('Server is running, killing before restart');
 					checkRestartThrottle();
 					tui.info('Restarting on file change');
+					showedRestartMessage = true;
 					await kill();
 					logger.trace('Server killed, continuing with restart');
 					// Continue with restart after kill completes
@@ -413,11 +446,16 @@ export const command = createCommand({
 					logger.trace('Initial server start');
 				}
 				logger.trace('Starting typecheck and build...');
-				await tui.spinner({
-					message: 'Building project',
-					clearOnSuccess: true,
-					callback: async () => {
-						try {
+
+				// Clear any previous error before starting new build
+				clearLastError();
+				clearRestartMessage();
+
+				try {
+					await tui.spinner({
+						message: 'Building...',
+						clearOnSuccess: true,
+						callback: async () => {
 							logger.trace('Bundle starting...');
 							building = true;
 							await bundle({
@@ -431,7 +469,7 @@ export const command = createCommand({
 							buildCompletedAt = Date.now();
 							logger.trace('Bundle completed successfully');
 							logger.trace('tsc starting...');
-							await tui.runCommand({
+							const tscExitCode = await tui.runCommand({
 								command: 'tsc',
 								cmd: ['bunx', 'tsc', '--noEmit'],
 								cwd: rootDir,
@@ -440,15 +478,32 @@ export const command = createCommand({
 								maxLinesOutput: 2,
 								maxLinesOnFailure: 15,
 							});
+							if (tscExitCode !== 0) {
+								logger.trace('tsc failed with exit code %d', tscExitCode);
+								failure('Type check failed');
+								return;
+							}
 							logger.trace('tsc completed successfully');
-						} catch (error) {
-							building = false;
-							logger.trace('Bundle failed: %s', error);
-							failure('Build failed');
-							return;
+							await restartGravityClient();
+						},
+					});
+				} catch (error) {
+					building = false;
+					const e = error as Error;
+					if (e.constructor.name === 'AggregateError') {
+						const ex = e as AggregateError;
+						for (const err of ex.errors) {
+							if (err) {
+								failure(err);
+								return;
+							}
 						}
-					},
-				});
+						return;
+					}
+					const errorMsg = error instanceof Error ? error.message : String(error);
+					failure(errorMsg);
+					return;
+				}
 
 				logger.trace('Typecheck and build completed');
 
@@ -457,6 +512,9 @@ export const command = createCommand({
 					return;
 				}
 
+				// Reset failure counter on successful build
+				failures = 0;
+
 				logger.trace('Checking if app file exists: %s', appPath);
 				if (!existsSync(appPath)) {
 					logger.trace('App file not found: %s', appPath);
@@ -548,9 +606,6 @@ export const command = createCommand({
 
 				if (showInitialReadyMessage) {
 					showInitialReadyMessage = false;
-					// Clear any lingering spinner/command output - clear everything below cursor
-					process.stderr.write('\x1B[J'); // Clear from cursor to end of screen
-					process.stdout.write('\x1B[J'); // Clear from cursor to end of screen
 					logger.info('DevMode ready 🚀');
 					logger.trace('Initial ready message logged');
 					// Mark initial startup complete immediately to prevent watcher restarts

package/src/cmd/index.ts

@@ -1,53 +1,49 @@
-import { readdir } from 'node:fs/promises';
-import { join } from 'node:path';
 import type { CommandDefinition } from '../types';
 
+// Use dynamic imports for bundler compatibility while maintaining lazy loading
 export async function discoverCommands(): Promise<CommandDefinition[]> {
-	const cmdDir = join(import.meta.dir);
-	const entries = await readdir(cmdDir, { withFileTypes: true });
+	const commandModules = await Promise.all([
+		import('./ai').then((m) => m.command),
+		import('./auth').then((m) => m.command),
+		import('./build').then((m) => m.command),
+		import('./cloud').then((m) => m.command),
+		import('./dev').then((m) => m.command),
+		import('./profile').then((m) => m.command),
+		import('./project').then((m) => m.command),
+		import('./repl').then((m) => m.command),
+		import('./version').then((m) => m.command),
+	]);
 
 	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);
+	for (const cmd of commandModules) {
+		commands.push(cmd);
 
-				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) {
-								// eslint-disable-next-line @typescript-eslint/no-explicit-any
-								const alias: any = {
-									name: subcommand.name,
-									description: subcommand.description,
-									aliases: subcommand.aliases,
-									hidden: true,
-									requires: subcommand.requires,
-									optional: subcommand.optional,
-									schema: subcommand.schema,
-									handler: subcommand.handler,
-									// eslint-disable-next-line @typescript-eslint/no-explicit-any
-									idempotent: (subcommand as any).idempotent,
-									// eslint-disable-next-line @typescript-eslint/no-explicit-any
-									prerequisites: (subcommand as any).prerequisites,
-									// eslint-disable-next-line @typescript-eslint/no-explicit-any
-									tags: (subcommand as any).tags,
-									// eslint-disable-next-line @typescript-eslint/no-explicit-any
-									examples: (subcommand as any).examples,
-								};
-								commands.push(alias as CommandDefinition);
-							}
-						}
-					}
+		// Auto-create hidden top-level aliases for subcommands with toplevel: true
+		if (cmd.subcommands) {
+			for (const subcommand of cmd.subcommands) {
+				if (subcommand.toplevel) {
+					// eslint-disable-next-line @typescript-eslint/no-explicit-any
+					const alias: any = {
+						name: subcommand.name,
+						description: subcommand.description,
+						aliases: subcommand.aliases,
+						hidden: true,
+						requires: subcommand.requires,
+						optional: subcommand.optional,
+						schema: subcommand.schema,
+						handler: subcommand.handler,
+						// eslint-disable-next-line @typescript-eslint/no-explicit-any
+						idempotent: (subcommand as any).idempotent,
+						// eslint-disable-next-line @typescript-eslint/no-explicit-any
+						prerequisites: (subcommand as any).prerequisites,
+						// eslint-disable-next-line @typescript-eslint/no-explicit-any
+						tags: (subcommand as any).tags,
+						// eslint-disable-next-line @typescript-eslint/no-explicit-any
+						examples: (subcommand as any).examples,
+					};
+					commands.push(alias as CommandDefinition);
 				}
-			} catch (error) {
-				console.warn(`Warning: Failed to load command from ${entry.name}:`, error);
 			}
 		}
 	}

package/src/schema-parser.ts

@@ -216,7 +216,9 @@ export function buildValidationInput(
 		const parsed = parseOptionsSchema(schemas.options);
 		for (const opt of parsed) {
 			// Only include the option if it has a value - omitting undefined allows Zod to apply defaults
-			const value = rawOptions[opt.name];
+			// Commander.js converts kebab-case to camelCase, so we need to check both
+			const camelCaseName = opt.name.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+			const value = rawOptions[opt.name] ?? rawOptions[camelCaseName];
 			if (value !== undefined) {
 				result.options[opt.name] = value;
 			}