@agentuity/cli 0.0.69 → 0.0.70

package/src/cmd/build/route-registry.ts

@@ -0,0 +1,198 @@
+import { writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Route information extracted from route files
+ */
+export interface RouteInfo {
+	/** HTTP method (GET, POST, etc.) */
+	method: string;
+	/** Route path */
+	path: string;
+	/** Relative file path */
+	filename: string;
+	/** Variable name of the route handler */
+	handlerVariable?: string;
+	/** Whether this route uses validator */
+	hasValidator: boolean;
+	/** Route type: 'api' | 'websocket' | 'sse' | 'stream' */
+	routeType?: string;
+	/** Agent variable name if using agent.validator() */
+	agentVariable?: string;
+	/** Agent import path (e.g., '@agent/hello', '../shared/agents') */
+	agentImportPath?: string;
+	/** Input schema variable name if using validator({ input }) */
+	inputSchemaVariable?: string;
+	/** Output schema variable name if using validator({ output }) */
+	outputSchemaVariable?: string;
+}
+
+/**
+ * Generate RouteRegistry type definitions from discovered routes.
+ *
+ * Creates a module augmentation for @agentuity/react that provides
+ * strongly-typed route keys with input/output schema information.
+ *
+ * @param srcDir - Source directory path
+ * @param routes - Array of route information
+ */
+export function generateRouteRegistry(srcDir: string, routes: RouteInfo[]): void {
+	// Filter routes by type and validator presence
+	const apiRoutes = routes.filter((r) => r.hasValidator && r.routeType === 'api');
+	const websocketRoutes = routes.filter((r) => r.hasValidator && r.routeType === 'websocket');
+	const sseRoutes = routes.filter((r) => r.hasValidator && r.routeType === 'sse');
+
+	if (apiRoutes.length === 0 && websocketRoutes.length === 0 && sseRoutes.length === 0) {
+		// No typed routes, skip generation
+		return;
+	}
+
+	// Generate imports for agents and schemas
+	const imports: string[] = [];
+	const agentImports = new Map<string, string>(); // Maps agent variable to unique import name
+	const schemaImports = new Set<string>(); // Track which schema variables we've seen
+
+	// Combine all typed routes for import collection
+	const allTypedRoutes = [...apiRoutes, ...websocketRoutes, ...sseRoutes];
+
+	// First pass: collect all unique agents and schema variables
+	allTypedRoutes.forEach((route) => {
+		// If this route uses an agent, import it directly
+		if (route.agentVariable && route.agentImportPath && !agentImports.has(route.agentVariable)) {
+			// Resolve the import path (could be @agent/hello, ../shared, etc.)
+			let resolvedPath = route.agentImportPath;
+
+			// If it's a path alias like @agent/hello, convert to relative path
+			if (resolvedPath.startsWith('@agent/')) {
+				resolvedPath = `../src/agent/${resolvedPath.substring('@agent/'.length)}`;
+			} else if (resolvedPath.startsWith('@api/')) {
+				resolvedPath = `../src/web/${resolvedPath.substring('@api/'.length)}`;
+			} else if (resolvedPath.startsWith('./') || resolvedPath.startsWith('../')) {
+				// Relative path - need to resolve relative to route file location
+				const routeDir = route.filename.substring(0, route.filename.lastIndexOf('/'));
+				resolvedPath = `../${routeDir}/${resolvedPath}`;
+			}
+
+			// Generate unique import name: agent_hello, agent_user, etc.
+			const uniqueImportName = `agent_${route.agentVariable}`;
+			imports.push(`import type ${uniqueImportName} from '${resolvedPath}';`);
+			agentImports.set(route.agentVariable, uniqueImportName);
+		}
+
+		// Track schema variables for potential import from route file
+		if (route.inputSchemaVariable) {
+			schemaImports.add(route.inputSchemaVariable);
+		}
+		if (route.outputSchemaVariable) {
+			schemaImports.add(route.outputSchemaVariable);
+		}
+	});
+
+	// Import schema variables from route files
+	const routeFileImports = new Map<string, Set<string>>(); // Maps route file to schema variables
+	allTypedRoutes.forEach((route) => {
+		if (route.inputSchemaVariable || route.outputSchemaVariable) {
+			const filename = route.filename.replace(/\\/g, '/');
+			const importPath = `../${filename.replace(/\.ts$/, '')}`;
+
+			if (!routeFileImports.has(importPath)) {
+				routeFileImports.set(importPath, new Set());
+			}
+
+			if (route.inputSchemaVariable) {
+				routeFileImports.get(importPath)!.add(route.inputSchemaVariable);
+			}
+			if (route.outputSchemaVariable) {
+				routeFileImports.get(importPath)!.add(route.outputSchemaVariable);
+			}
+		}
+	});
+
+	// Generate imports for schema variables
+	routeFileImports.forEach((schemas, importPath) => {
+		const schemaList = Array.from(schemas).join(', ');
+		imports.push(`import type { ${schemaList} } from '${importPath}';`);
+	});
+
+	const importsStr = imports.join('\n');
+
+	// Helper function to generate route entry
+	const generateRouteEntry = (route: RouteInfo): string => {
+		const routeKey = route.path; // Use path only for websocket/sse, or METHOD path for API
+
+		// If we have an agent variable, we can infer types from it
+		if (route.agentVariable) {
+			const importName = agentImports.get(route.agentVariable)!;
+			return `  '${routeKey}': {
+    inputSchema: typeof ${importName} extends { inputSchema?: infer I } ? I : never;
+    outputSchema: typeof ${importName} extends { outputSchema?: infer O } ? O : never;
+  };`;
+		}
+
+		// If we have standalone validator with schema variables
+		if (route.inputSchemaVariable || route.outputSchemaVariable) {
+			const inputType = route.inputSchemaVariable
+				? `typeof ${route.inputSchemaVariable}`
+				: 'never';
+			const outputType = route.outputSchemaVariable
+				? `typeof ${route.outputSchemaVariable}`
+				: 'never';
+			return `  '${routeKey}': {
+    inputSchema: ${inputType};
+    outputSchema: ${outputType};
+  };`;
+		}
+
+		// Fall back to any if we can't determine the schema source
+		return `  '${routeKey}': {
+    // Unable to extract schema types - validator might use inline schemas
+    inputSchema: any;
+    outputSchema: any;
+  };`;
+	};
+
+	// Generate RouteRegistry interface (API routes use METHOD path format)
+	const apiRouteEntries = apiRoutes
+		.map((route) => {
+			const routeKey = `${route.method.toUpperCase()} ${route.path}`;
+			return generateRouteEntry({ ...route, path: routeKey });
+		})
+		.join('\n');
+
+	// Generate WebSocketRouteRegistry (path only, no method)
+	const websocketRouteEntries = websocketRoutes.map(generateRouteEntry).join('\n');
+
+	// Generate SSERouteRegistry (path only, no method)
+	const sseRouteEntries = sseRoutes.map(generateRouteEntry).join('\n');
+
+	const generatedContent = `// Auto-generated by Agentuity - do not edit manually
+${importsStr}
+
+// Augment @agentuity/react types with project-specific routes
+declare module '@agentuity/react' {
+  export interface RouteRegistry {
+${apiRouteEntries}
+  }
+  
+  export interface WebSocketRouteRegistry {
+${websocketRouteEntries}
+  }
+  
+  export interface SSERouteRegistry {
+${sseRouteEntries}
+  }
+}
+`;
+
+	// Get the project root (parent of srcDir)
+	const projectRoot = join(srcDir, '..');
+	const agentuityDir = join(projectRoot, '.agentuity');
+	const registryPath = join(agentuityDir, 'routes.generated.ts');
+
+	// Ensure .agentuity directory exists
+	if (!existsSync(agentuityDir)) {
+		mkdirSync(agentuityDir, { recursive: true });
+	}
+
+	writeFileSync(registryPath, generatedContent, 'utf-8');
+}

package/src/cmd/cloud/deploy.ts

@@ -186,6 +186,7 @@ export const deploySubcommand = createSubcommand({
 									provider: opts?.provider,
 									trigger: opts?.trigger,
 									tag: opts?.tag,
+									region: project.region,
 								});
 								build = await loadBuildMetadata(join(projectDir, '.agentuity'));
 								instructions = await projectDeploymentUpdate(

package/src/cmd/cloud/index.ts

@@ -9,7 +9,6 @@ import { scpSubcommand } from './scp';
 import { deploymentCommand } from './deployment';
 import keyvalueCommand from './keyvalue';
 import { agentCommand } from './agent';
-import objectstoreCommand from './objectstore';
 import envCommand from './env';
 import secretCommand from './secret';
 import apikeyCommand from './apikey';
@@ -29,7 +28,6 @@ export const command = createCommand({
 		apikeyCommand,
 		keyvalueCommand,
 		agentCommand,
-		objectstoreCommand,
 		streamCommand,
 		vectorCommand,
 		envCommand,

package/src/cmd/dev/index.ts

@@ -121,7 +121,7 @@ export const command = createCommand({
 			config = _config;
 			devmode = endpoint;
 			gravityURL = getGravityDevModeURL(project.region, config);
-			logger.error('gravity url: %s', gravityURL);
+			logger.trace('gravity url: %s', gravityURL);
 		}
 
 		logger.debug(
@@ -201,7 +201,6 @@ export const command = createCommand({
 			env.AGENTUITY_TRANSPORT_URL = serviceUrls.catalyst;
 			env.AGENTUITY_CATALYST_URL = serviceUrls.catalyst;
 			env.AGENTUITY_VECTOR_URL = serviceUrls.vector;
-			env.AGENTUITY_OBJECTSTORE_URL = serviceUrls.objectstore;
 			env.AGENTUITY_KEYVALUE_URL = serviceUrls.keyvalue;
 			env.AGENTUITY_STREAM_URL = serviceUrls.stream;
 			env.AGENTUITY_CLOUD_ORG_ID = project.orgId;
@@ -499,6 +498,7 @@ export const command = createCommand({
 								projectId: project?.projectId,
 								deploymentId,
 								port: opts.port,
+								region: project?.region ?? 'local',
 							});
 							building = false;
 							buildCompletedAt = Date.now();
@@ -1005,7 +1005,7 @@ export const command = createCommand({
 						if (changedFile?.startsWith('src/agent/')) {
 							logger.debug('agent directory created: %s', changedFile);
 							createAgentTemplates(absPath);
-						} else if (changedFile?.startsWith('src/web/')) {
+						} else if (changedFile?.startsWith('src/api/')) {
 							logger.debug('api directory created: %s', changedFile);
 							createAPITemplates(absPath);
 						}

package/src/cmd/dev/sync.ts

@@ -5,28 +5,16 @@ import type { APIClient } from '../../api';
 interface AgentSyncPayload {
 	id: string;
 	name: string;
-	identifier: string;
 	agentId: string;
 	description?: string;
 	version: string;
 	filename: string;
 	projectId: string;
-	subagents?: Array<{
-		id: string;
-		name: string;
-		identifier: string;
-		agentId: string;
-		description?: string;
-		version: string;
-		filename: string;
-		projectId: string;
-	}>;
 }
 
 interface EvalSyncPayload {
 	id: string;
 	name: string;
-	identifier: string;
 	evalId: string;
 	description?: string;
 	version: string;
@@ -64,30 +52,14 @@ function getAgentsToSync(
 				agent.name
 			);
 
-			// Add projectId to subagents if they exist
-			const subagents = agent.subagents?.map((subagent) => {
-				return {
-					id: subagent.id,
-					name: subagent.name,
-					identifier: subagent.identifier,
-					agentId: subagent.agentId,
-					description: subagent.description,
-					version: subagent.version,
-					filename: subagent.filename,
-					projectId,
-				};
-			});
-
 			agentsToCreate.push({
 				id: agent.id,
 				name: agent.name,
-				identifier: agent.identifier,
 				agentId: agent.agentId,
 				description: agent.description,
 				version: agent.version,
 				filename: agent.filename,
 				projectId,
-				...(subagents && { subagents }),
 			});
 		}
 	}

package/src/cmd/dev/templates.ts

@@ -1,16 +1,13 @@
 /* eslint-disable no-control-regex */
 import { writeFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
-import { toCamelCase } from '../../utils/string';
+import { toPascalCase } from '../../utils/string';
 
 const newAgentTemplate = (name: string) => `import { createAgent } from '@agentuity/runtime';
 import { s } from '@agentuity/schema';
 
-const agent = createAgent({
-	metadata: {
-        name: '${name}',
-        description: 'Add your agent description here',
-    },
+export const ${name} = createAgent('${name}', {
+    description: 'Add your agent description here',
 	schema: {
 		input: s.string(),
 		output: s.string(),
@@ -20,47 +17,25 @@ const agent = createAgent({
 		return input;
 	},
 });
+`;
 
-export default agent;
+const newAgentIndexTemplate = (name: string) => `export { ${name} } from './agent';
 `;
 
-const newAgentRouteTemplate = (name: string) => {
-	const camelName = toCamelCase(name);
+const newRouteTemplate = () => {
 	return `import { createRouter } from '@agentuity/runtime';
-import agent from './agent';
 
 const router = createRouter();
 
 router.get('/', async (c) => {
-	// TODO: add your code here
-	const output = await c.agent.${camelName}.run('hello world');
+	// TODO: add your code here - for now we just echo back what you sent
 	return c.text(output);
 });
 
-router.post('/', agent.validator(), async (c) => {
-	const data = c.req.valid('json');
-	const output = await c.agent.${camelName}.run(data);
-	return c.json(output);
-});
-
 export default router;
-
 `;
 };
 
-const newAPIRouteTemplate = (_name: string) => `import { createRouter } from '@agentuity/runtime';
-
-const router = createRouter();
-
-router.get('/', async (c) => {
-	// TODO: add your code here
-	return c.text('Hello');
-});
-
-export default router;
-
-`;
-
 const invalidDirRegex = /[<>:"/\\|?*]/;
 
 // biome-ignore lint/suspicious/noControlCharactersInRegex: checking for invalid control characters in directory names
@@ -82,8 +57,9 @@ export function createAgentTemplates(dir: string) {
 	if (!isValidDirectoryName(name)) {
 		return;
 	}
-	writeFileSync(join(dir, 'agent.ts'), newAgentTemplate(name));
-	writeFileSync(join(dir, 'route.ts'), newAgentRouteTemplate(name));
+	const agentName = toPascalCase(name);
+	writeFileSync(join(dir, 'agent.ts'), newAgentTemplate(agentName));
+	writeFileSync(join(dir, 'index.ts'), newAgentIndexTemplate(agentName));
 }
 
 export function createAPITemplates(dir: string) {
@@ -91,5 +67,5 @@ export function createAPITemplates(dir: string) {
 	if (!isValidDirectoryName(name)) {
 		return;
 	}
-	writeFileSync(join(dir, 'route.ts'), newAPIRouteTemplate(name));
+	writeFileSync(join(dir, 'index.ts'), newRouteTemplate());
 }

package/src/cmd/profile/create.ts

@@ -79,7 +79,6 @@ export const createCommand = createSubcommand({
 					transport_url: 'https://catalyst.agentuity.io',
 					stream_url: 'https://streams.agentuity.io',
 					kv_url: 'https://catalyst.agentuity.io',
-					object_url: 'https://catalyst.agentuity.io',
 					vector_url: 'https://catalyst.agentuity.io',
 					catalyst_url: 'https://catalyst.agentuity.io',
 					ion_url: 'https://ion.agentuity.io',

package/src/cmd/project/template-flow.ts

@@ -3,7 +3,6 @@ import { z } from 'zod';
 import { existsSync, readdirSync, rmSync, statSync } from 'node:fs';
 import { cwd } from 'node:process';
 import { homedir } from 'node:os';
-import enquirer from 'enquirer';
 import {
 	projectCreate,
 	projectExists,
@@ -16,6 +15,7 @@ import {
 } from '@agentuity/server';
 import type { Logger } from '@agentuity/core';
 import * as tui from '../../tui';
+import { createPrompt, note } from '../../tui';
 import { playSound } from '../../sound';
 import { fetchTemplates, type TemplateInfo } from './templates';
 import { downloadTemplate, setupProject } from './download';
@@ -95,10 +95,15 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 		catalystClient = new ServerAPIClient(catalystUrl, logger, auth.apiKey);
 	}
 
+	// Create prompt flow
+	const prompt = createPrompt();
+
+	if (!skipPrompts) {
+		prompt.intro('Create Agentuity Project');
+	}
+
 	if (!projectName && !skipPrompts) {
-		const response = await enquirer.prompt<{ name: string }>({
-			type: 'input',
-			name: 'name',
+		projectName = await prompt.text({
 			message: 'What is the name of your project?',
 			initial: 'My First Agent',
 			validate: async (value: string) => {
@@ -117,7 +122,6 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 				return true;
 			},
 		});
-		projectName = response.name;
 	}
 	projectName = projectName || 'My First Agent';
 
@@ -140,14 +144,13 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 		// In TTY mode, ask if they want to overwrite
 		if (process.stdin.isTTY && !skipPrompts) {
 			tui.warning(`Directory ${dest} already exists and is not empty.`, true);
-			const response = await enquirer.prompt<{ overwrite: boolean }>({
-				type: 'confirm',
-				name: 'overwrite',
+			console.log(tui.tuiColors.secondary('│'));
+			const overwrite = await prompt.confirm({
 				message: 'Delete and overwrite the directory?',
 				initial: false,
 			});
 
-			if (!response.overwrite) {
+			if (!overwrite) {
 				tui.info('Operation cancelled');
 				process.exit(0);
 			}
@@ -160,6 +163,7 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 			}
 			rmSync(dest, { recursive: true, force: true });
 			tui.success(`Deleted ${dest}`);
+			console.log(tui.tuiColors.secondary('│'));
 		} else {
 			logger.fatal(
 				`Directory ${dest} already exists and is not empty.`,
@@ -180,16 +184,15 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 	} else if (skipPrompts) {
 		selectedTemplate = templates[0];
 	} else {
-		const response = await enquirer.prompt<{ template: string }>({
-			type: 'select',
-			name: 'template',
+		const templateId = await prompt.select({
 			message: 'Select a template:',
-			choices: templates.map((t) => ({
-				name: t.id,
-				message: `${t.name.padEnd(15, ' ')} ${tui.muted(t.description)}`,
+			options: templates.map((t) => ({
+				value: t.id,
+				label: t.name,
+				hint: t.description,
 			})),
 		});
-		const found = templates.find((t) => t.id === response.template);
+		const found = templates.find((t) => t.id === templateId);
 		if (!found) {
 			logger.fatal('Template selection failed', ErrorCode.USER_CANCELLED);
 			return;
@@ -197,8 +200,6 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 		selectedTemplate = found;
 	}
 
-	tui.info(`✨ Using template: ${tui.bold(selectedTemplate.name)}`);
-
 	// Download template
 	await downloadTemplate({
 		dest,
@@ -218,6 +219,17 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 		logger,
 	});
 
+	// Re-display template selection after spinners clear it
+	if (!skipPrompts) {
+		const { symbols, tuiColors } = tui;
+		console.log(`${tuiColors.completed(symbols.completed)}  Select a template:`);
+		console.log(`${tuiColors.secondary(symbols.bar)}  ${tuiColors.muted(selectedTemplate.name)}`);
+		// Only add bar if we're going to show resource prompts
+		if (auth && apiClient && catalystClient && orgId && region) {
+			console.log(tuiColors.secondary(symbols.bar));
+		}
+	}
+
 	const resourceConfig: ResourcesTypes = Resources.parse({});
 
 	if (auth && apiClient && catalystClient && orgId && region) {
@@ -232,37 +244,31 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 
 		logger.debug(`Resources for org ${orgId} in region ${region}:`, resources);
 
-		const choices = await enquirer.prompt<{
-			db_action: string;
-			s3_action: string;
-		}>([
-			{
-				type: 'select',
-				name: 'db_action',
-				message: 'Create SQL Database?',
-				choices: [
-					{ name: 'Create New', message: 'Create a new (free)' },
-					{ name: 'Skip', message: 'Skip or Setup later' },
-					...resources.db.map((db) => ({
-						name: db.name,
-						message: `Use database: ${db.name}`,
-					})),
-				],
-			},
-			{
-				type: 'select',
-				name: 's3_action',
-				message: 'Create Storage Bucket?',
-				choices: [
-					{ name: 'Create New', message: 'Create a new (free)' },
-					{ name: 'Skip', message: 'Skip or Setup later' },
-					...resources.s3.map((db) => ({
-						name: db.bucket_name,
-						message: `Use bucket: ${db.bucket_name}`,
-					})),
-				],
-			},
-		]);
+		const db_action = await prompt.select({
+			message: 'Create SQL Database?',
+			options: [
+				{ value: 'Create New', label: 'Create a new (free)' },
+				{ value: 'Skip', label: 'Skip or Setup later' },
+				...resources.db.map((db) => ({
+					value: db.name,
+					label: `Use database: ${tui.tuiColors.primary(db.name)}`,
+				})),
+			],
+		});
+
+		const s3_action = await prompt.select({
+			message: 'Create Storage Bucket?',
+			options: [
+				{ value: 'Create New', label: 'Create a new (free)' },
+				{ value: 'Skip', label: 'Skip or Setup later' },
+				...resources.s3.map((bucket) => ({
+					value: bucket.bucket_name,
+					label: `Use bucket: ${tui.tuiColors.primary(bucket.bucket_name)}`,
+				})),
+			],
+		});
+
+		const choices = { db_action, s3_action };
 		switch (choices.s3_action) {
 			case 'Create New': {
 				const created = await tui.spinner({
@@ -364,16 +370,30 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 	}
 
 	// Show completion message
-	tui.success('✨ Project created successfully!\n');
-	tui.info('Next steps:');
-	if (dirName !== '.') {
-		const dirDisplay = cwd() === targetDir ? basename(dirName) : dest;
-		tui.newline();
-		console.log(`  1. ${tui.bold(`cd ${dirDisplay}`)}`);
-		console.log(`  2. ${tui.bold('bun run dev')}`);
+	if (!skipPrompts) {
+		tui.success('✨ Project created successfully!\n');
+
+		// Show next steps in a box with primary color for commands
+		if (dirName !== '.') {
+			// Use relative path if dest is under cwd, otherwise show full path
+			const currentDir = cwd();
+			const dirDisplay = dest.startsWith(currentDir) ? basename(dest) : dest;
+			note(
+				`${tui.tuiColors.primary(`cd ${dirDisplay}`)}\n${tui.tuiColors.primary('bun run dev')}`,
+				'Next steps'
+			);
+		} else {
+			note(tui.tuiColors.primary('bun run dev'), 'Next steps');
+		}
+
+		prompt.outro(
+			`${tui.tuiColors.muted('🛟 Need help?')} ${tui.link('https://discord.gg/agentuity')}`,
+			`${tui.tuiColors.muted('⭐️ Follow us:')} ${tui.link('https://github.com/agentuity/sdk')}`
+		);
 	} else {
-		console.log(`  ${tui.bold('bun run dev')}`);
+		tui.success('✨ Project created successfully!');
 	}
+
 	playSound();
 }
 

package/src/config.ts

@@ -170,9 +170,6 @@ export async function loadConfig(customPath?: string): Promise<Config | null> {
 			if (process.env.AGENTUITY_KEYVALUE_URL) {
 				overrides.kv_url = process.env.AGENTUITY_KEYVALUE_URL;
 			}
-			if (process.env.AGENTUITY_OBJECTSTORE_URL) {
-				overrides.object_url = process.env.AGENTUITY_OBJECTSTORE_URL;
-			}
 			if (process.env.AGENTUITY_VECTOR_URL) {
 				overrides.vector_url = process.env.AGENTUITY_VECTOR_URL;
 			}