@agentuity/cli 0.0.55 → 0.0.56

package/src/cmd/build/ast.ts

@@ -790,111 +790,137 @@ export async function parseRoute(
 	const routes: RouteDefinition = [];
 	const routePrefix = filename.includes('src/agents') ? '/agent' : '/api';
 
-	for (const body of ast.body) {
-		if (body.type === 'ExpressionStatement') {
-			const statement = body as ASTExpressionStatement;
-			const callee = statement.expression.callee;
-			if (callee.object.type === 'Identifier') {
-				const identifier = callee.object as ASTNodeIdentifier;
-				if (identifier.name === variableName) {
-					let method = (callee.property as ASTNodeIdentifier).name;
-					let type = 'api';
-					const action = statement.expression.arguments[0];
-					let suffix = '';
-					let config: Record<string, unknown> | undefined;
-					switch (method) {
-						case 'get':
-						case 'put':
-						case 'post':
-						case 'patch':
-						case 'delete': {
-							const theaction = action as ASTLiteral;
-							if (theaction.type === 'Literal') {
-								suffix = theaction.value;
+	try {
+		for (const body of ast.body) {
+			if (body.type === 'ExpressionStatement') {
+				const statement = body as ASTExpressionStatement;
+
+				// Validate that the expression is a call expression (e.g. function call)
+				if (statement.expression.type !== 'CallExpression') {
+					continue;
+				}
+
+				const callee = statement.expression.callee;
+
+				// Validate that the callee is a member expression (e.g. object.method())
+				// This handles cases like 'console.log()' or 'router.get()'
+				// direct function calls like 'myFunc()' have type 'Identifier' and will be skipped
+				if (callee.type !== 'MemberExpression') {
+					continue;
+				}
+
+				if (callee.object.type === 'Identifier' && statement.expression.arguments?.length > 0) {
+					const identifier = callee.object as ASTNodeIdentifier;
+					if (identifier.name === variableName) {
+						let method = (callee.property as ASTNodeIdentifier).name;
+						let type = 'api';
+						const action = statement.expression.arguments[0];
+						let suffix = '';
+						let config: Record<string, unknown> | undefined;
+						switch (method) {
+							case 'get':
+							case 'put':
+							case 'post':
+							case 'patch':
+							case 'delete': {
+								if (action && (action as ASTLiteral).type === 'Literal') {
+									suffix = (action as ASTLiteral).value;
+								} else {
+									throw new Error(
+										`unsupported HTTP method ${method} in ${filename} at line ${body.start}`
+									);
+								}
 								break;
 							}
-							break;
-						}
-						case 'stream':
-						case 'sse':
-						case 'websocket': {
-							type = method;
-							method = 'post';
-							const theaction = action as ASTLiteral;
-							if (theaction.type === 'Literal') {
-								suffix = theaction.value;
+							case 'stream':
+							case 'sse':
+							case 'websocket': {
+								type = method;
+								method = 'post';
+								const theaction = action as ASTLiteral;
+								if (theaction.type === 'Literal') {
+									suffix = theaction.value;
+									break;
+								}
 								break;
 							}
-							break;
-						}
-						case 'sms': {
-							type = method;
-							method = 'post';
-							const theaction = action as ASTObjectExpression;
-							if (theaction.type === 'ObjectExpression') {
-								config = {};
-								theaction.properties.forEach((p) => {
-									if (p.value.type === 'Literal') {
-										const literal = p.value as ASTLiteral;
-										config![p.key.name] = literal.value;
+							case 'sms': {
+								type = method;
+								method = 'post';
+								const theaction = action as ASTObjectExpression;
+								if (theaction.type === 'ObjectExpression') {
+									config = {};
+									theaction.properties.forEach((p) => {
+										if (p.value.type === 'Literal') {
+											const literal = p.value as ASTLiteral;
+											config![p.key.name] = literal.value;
+										}
+									});
+									const number = theaction.properties.find((p) => p.key.name === 'number');
+									if (number && number.value.type === 'Literal') {
+										const phoneNumber = number.value as ASTLiteral;
+										suffix = hash(phoneNumber.value);
+										break;
 									}
-								});
-								const number = theaction.properties.find((p) => p.key.name === 'number');
-								if (number && number.value.type === 'Literal') {
-									const phoneNumber = number.value as ASTLiteral;
-									suffix = hash(phoneNumber.value);
-									break;
 								}
+								break;
 							}
-							break;
-						}
-						case 'email': {
-							type = method;
-							method = 'post';
-							const theaction = action as ASTLiteral;
-							if (theaction.type === 'Literal') {
-								const email = theaction.value;
-								suffix = hash(email);
+							case 'email': {
+								type = method;
+								method = 'post';
+								const theaction = action as ASTLiteral;
+								if (theaction.type === 'Literal') {
+									const email = theaction.value;
+									suffix = hash(email);
+									break;
+								}
 								break;
 							}
-							break;
-						}
-						case 'cron': {
-							type = method;
-							method = 'post';
-							const theaction = action as ASTLiteral;
-							if (theaction.type === 'Literal') {
-								const number = theaction.value;
-								suffix = hash(number);
+							case 'cron': {
+								type = method;
+								method = 'post';
+								const theaction = action as ASTLiteral;
+								if (theaction.type === 'Literal') {
+									const number = theaction.value;
+									suffix = hash(number);
+									break;
+								}
 								break;
 							}
-							break;
+							default: {
+								throw new Error(
+									`unsupported router method ${method} in ${filename} at line ${body.start}`
+								);
+							}
 						}
+						const thepath = `${routePrefix}/${routeName}/${suffix}`
+							.replaceAll(/\/{2,}/g, '/')
+							.replaceAll(/\/$/g, '');
+						const id = generateRouteId(
+							projectId,
+							deploymentId,
+							type,
+							method,
+							rel,
+							thepath,
+							version
+						);
+						routes.push({
+							id,
+							method: method as 'get' | 'post' | 'put' | 'delete' | 'patch',
+							type: type as 'api' | 'sms' | 'email' | 'cron',
+							filename: rel,
+							path: thepath,
+							version,
+							config,
+						});
 					}
-					const thepath = `${routePrefix}/${routeName}/${suffix}`
-						.replaceAll(/\/{2,}/g, '/')
-						.replaceAll(/\/$/g, '');
-					const id = generateRouteId(
-						projectId,
-						deploymentId,
-						type,
-						method,
-						rel,
-						thepath,
-						version
-					);
-					routes.push({
-						id,
-						method: method as 'get' | 'post' | 'put' | 'delete' | 'patch',
-						type: type as 'api' | 'sms' | 'email' | 'cron',
-						filename: rel,
-						path: thepath,
-						version,
-						config,
-					});
 				}
 			}
 		}
+	} catch (error) {
+		const err = error instanceof Error ? error : new Error(String(error));
+		throw new Error(`Failed to parse route file ${filename}: ${err.message}`);
 	}
 	return routes;
 }

package/src/cmd/build/bundler.ts

@@ -358,13 +358,16 @@ export async function bundle({
 						.map((s) => s.trim())
 						.filter(Boolean);
 				}
-				const branch = $`git branch --show-current`.nothrow().quiet();
-				if (branch) {
-					const _branch = await branch.text();
-					if (_branch) {
-						buildmetadata.deployment.git.branch = _branch.trim();
+				let branch = process.env.GITHUB_HEAD_REF;
+				if (!branch) {
+					const branchText = $`git branch --show-current`.nothrow().quiet();
+					if (branchText) {
+						branch = await branchText.text();
 					}
 				}
+				if (branch) {
+					buildmetadata.deployment.git.branch = branch.trim();
+				}
 				const commit = $`git rev-parse HEAD`.nothrow().quiet();
 				if (commit) {
 					const sha = await commit.text();

package/src/cmd/build/plugin.ts

@@ -493,7 +493,6 @@ const AgentuityBundler: BunPlugin = {
 						projectId,
 						deploymentId
 					);
-					routeDefinitions = [...routeDefinitions, ...definitions];
 
 					let agentDetail: Record<string, string> = {};
 
@@ -504,6 +503,7 @@ const AgentuityBundler: BunPlugin = {
 						}
 						agentDetail = {
 							name,
+							id: md.get('id')!,
 							path: `.${agent}`,
 							filename: md.get('filename')!,
 							identifier: md.get('identifier')!,
@@ -514,8 +514,14 @@ const AgentuityBundler: BunPlugin = {
 							agentDetail.parent = parentName;
 						}
 						agentInfo.push(agentDetail);
+						for (const def of definitions) {
+							def.agentIds = [agentDetail.agentId, agentDetail.id];
+						}
 					}
 
+					// do this after handling the agent association (if any)
+					routeDefinitions = [...routeDefinitions, ...definitions];
+
 					let buffer = `await (async() => {
     const { createAgentMiddleware, getRouter, registerAgent } = await import('@agentuity/runtime');
     const router = getRouter()!;
@@ -657,6 +663,9 @@ if (route !== '/workbench') {
 					if (!v.has('name')) {
 						throw new Error('agent metadata is missing expected name property');
 					}
+					if (!v.has('agentId')) {
+						throw new Error('agent metadata is missing expected agentId property');
+					}
 
 					const parentName = v.get('parent');
 					if (parentName) {

package/src/cmd/cloud/session/get.ts

@@ -1,11 +1,29 @@
 import { z } from 'zod';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
-import { sessionGet } from '@agentuity/server';
+import { sessionGet, type SpanNode } from '@agentuity/server';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
 import { getCatalystAPIClient } from '../../../config';
 
+const SpanNodeSchema: z.ZodType<SpanNode> = z.lazy(() =>
+	z.object({
+		id: z.string().describe('Span ID'),
+		duration: z.number().describe('Duration in milliseconds'),
+		operation: z.string().describe('Operation name'),
+		attributes: z.record(z.string(), z.unknown()).describe('Span attributes'),
+		children: z.array(SpanNodeSchema).optional().describe('Child spans'),
+	})
+);
+
+const RouteInfoSchema = z
+	.object({
+		id: z.string().describe('Route ID'),
+		method: z.string().describe('HTTP method'),
+		path: z.string().describe('Route path'),
+	})
+	.nullable();
+
 const SessionGetResponseSchema = z.object({
 	id: z.string().describe('Session ID'),
 	created_at: z.string().describe('Creation timestamp'),
@@ -26,8 +44,15 @@ const SessionGetResponseSchema = z.object({
 	url: z.string().describe('Request URL'),
 	route_id: z.string().describe('Route ID'),
 	thread_id: z.string().describe('Thread ID'),
-	agentNames: z.array(z.string()).describe('Agent names'),
-	evalRuns: z
+	agents: z
+		.array(
+			z.object({
+				name: z.string(),
+				identifier: z.string(),
+			})
+		)
+		.describe('Agents'),
+	eval_runs: z
 		.array(
 			z.object({
 				id: z.string(),
@@ -40,8 +65,41 @@ const SessionGetResponseSchema = z.object({
 			})
 		)
 		.describe('Eval runs'),
+	timeline: SpanNodeSchema.nullable().optional().describe('Session timeline'),
+	route: RouteInfoSchema.optional().describe('Route information'),
 });
 
+function formatDuration(ms: number): string {
+	if (ms < 1) {
+		return `${(ms * 1000).toFixed(0)}µs`;
+	}
+	if (ms < 1000) {
+		return `${ms.toFixed(1)}ms`;
+	}
+	return `${(ms / 1000).toFixed(2)}s`;
+}
+
+function printTimeline(node: SpanNode, prefix: string, isLast = true): void {
+	const connector = isLast ? '└── ' : '├── ';
+	const duration = tui.muted(`(${formatDuration(node.duration)})`);
+	let extra = '';
+	if (node.operation.startsWith('agentuity.')) {
+		if ('name' in node.attributes && 'key' in node.attributes) {
+			extra = tui.colorSuccess(`${node.attributes.name} ${node.attributes.key}`) + ' ';
+		}
+	}
+	if (node.operation.startsWith('HTTP ') && 'http.url' in node.attributes) {
+		extra = `${tui.colorSuccess(node.attributes['http.url'] as string)} `;
+	}
+	console.log(`${prefix}${connector}${node.operation} ${extra}${duration}`);
+
+	const childPrefix = prefix + (isLast ? '    ' : '│   ');
+	const children = node.children ?? [];
+	children.forEach((child, index) => {
+		printTimeline(child, childPrefix, index === children.length - 1);
+	});
+}
+
 export const getSubcommand = createSubcommand({
 	name: 'get',
 	description: 'Get details about a specific session',
@@ -83,8 +141,8 @@ export const getSubcommand = createSubcommand({
 				url: session.url,
 				route_id: session.route_id,
 				thread_id: session.thread_id,
-				agentNames: enriched.agentNames,
-				evalRuns: enriched.evalRuns.map((run) => ({
+				agents: enriched.agents,
+				eval_runs: enriched.evalRuns.map((run) => ({
 					id: run.id,
 					eval_id: run.eval_id,
 					created_at: run.created_at,
@@ -93,6 +151,8 @@ export const getSubcommand = createSubcommand({
 					error: run.error,
 					result: run.result,
 				})),
+				timeline: enriched.timeline,
+				route: enriched.route,
 			};
 
 			if (options.json) {
@@ -100,17 +160,14 @@ export const getSubcommand = createSubcommand({
 				return result;
 			}
 
-			tui.banner(`Session ${session.id}`, `Status: ${session.success ? 'Success' : 'Failed'}`);
-
 			console.log(tui.bold('ID:          ') + session.id);
 			console.log(tui.bold('Project:     ') + session.project_id);
 			console.log(tui.bold('Deployment:  ') + (session.deployment_id || '-'));
-			console.log(tui.bold('Created:     ') + new Date(session.created_at).toLocaleString());
 			console.log(tui.bold('Start:       ') + new Date(session.start_time).toLocaleString());
 			if (session.end_time) {
 				console.log(tui.bold('End:         ') + new Date(session.end_time).toLocaleString());
 			}
-			if (session.duration) {
+			if (session.duration && session.end_time) {
 				console.log(
 					tui.bold('Duration:    ') + `${(session.duration / 1_000_000).toFixed(0)}ms`
 				);
@@ -118,23 +175,32 @@ export const getSubcommand = createSubcommand({
 			console.log(tui.bold('Method:      ') + session.method);
 			console.log(tui.bold('URL:         ') + tui.link(session.url, session.url));
 			console.log(tui.bold('Trigger:     ') + session.trigger);
-			console.log(tui.bold('Environment: ') + session.env);
+			if (session.env !== 'production') {
+				console.log(tui.bold('Environment: ') + session.env);
+			}
 			console.log(tui.bold('Dev Mode:    ') + (session.devmode ? 'Yes' : 'No'));
-			console.log(tui.bold('Success:     ') + (session.success ? '✓' : '✗'));
+			console.log(
+				tui.bold('Success:     ') +
+					(session.success ? tui.colorSuccess('✓') : tui.colorError('✗'))
+			);
 			console.log(tui.bold('Pending:     ') + (session.pending ? 'Yes' : 'No'));
 			if (session.error) {
 				console.log(tui.bold('Error:       ') + tui.error(session.error));
 			}
-			if (enriched.agentNames.length > 0) {
-				const agentDisplay = enriched.agentNames
-					.map((name, idx) => {
-						const agentId = session.agent_ids[idx];
-						return `${name} ${tui.muted(`(${agentId})`)}`;
-					})
+			if (enriched.agents.length > 0) {
+				const agentDisplay = enriched.agents
+					.map((agent) => `${agent.name} ${tui.muted(`(${agent.identifier})`)}`)
 					.join(', ');
 				console.log(tui.bold('Agents:      ') + agentDisplay);
 			}
-			console.log(tui.bold('Route ID:    ') + session.route_id);
+			if (enriched.route) {
+				console.log(
+					tui.bold('Route:       ') +
+						`${enriched.route.method.toUpperCase()} ${enriched.route.path} ${tui.muted(`(${enriched.route.id})`)}`
+				);
+			} else {
+				console.log(tui.bold('Route ID:    ') + session.route_id);
+			}
 			console.log(tui.bold('Thread ID:   ') + session.thread_id);
 
 			if (enriched.evalRuns.length > 0) {
@@ -143,7 +209,7 @@ export const getSubcommand = createSubcommand({
 				const evalTableData = enriched.evalRuns.map((run) => ({
 					ID: run.id,
 					'Eval ID': run.eval_id,
-					Success: run.success ? '✓' : '✗',
+					Success: run.success ? tui.colorSuccess('✓') : tui.colorError('✗'),
 					Pending: run.pending ? '⏳' : '✓',
 					Error: run.error || 'No',
 					Created: new Date(run.created_at).toLocaleString(),
@@ -159,6 +225,12 @@ export const getSubcommand = createSubcommand({
 				]);
 			}
 
+			if (result.timeline) {
+				console.log('');
+				console.log(tui.bold('Timeline:'));
+				printTimeline(result.timeline, '');
+			}
+
 			return result;
 		} catch (ex) {
 			tui.fatal(

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

@@ -325,6 +325,7 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 					deployment: {
 						resources: resourceConfig,
 					},
+					region: region ?? 'usc',
 				});
 			},
 		});

package/src/config.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { existsSync } from 'node:fs';
+import { existsSync, mkdirSync } from 'node:fs';
 import type { Logger } from '@agentuity/core';
 import {
 	BuildMetadataSchema,
@@ -486,6 +486,7 @@ class ProjectConfigNotFoundExpection extends Error {
 type ProjectConfig = z.infer<typeof ProjectSchema>;
 
 function generateJSON5WithComments(
+	jsonSchema: string,
 	schema: z.ZodObject<z.ZodRawShape>,
 	data: Record<string, unknown>
 ): string {
@@ -493,6 +494,8 @@ function generateJSON5WithComments(
 	const shape = schema.shape;
 	const keys = Object.keys(shape);
 
+	lines.push(`  "$schema": "${jsonSchema}",`);
+
 	for (let i = 0; i < keys.length; i++) {
 		const key = keys[i];
 		const fieldSchema = shape[key] as z.ZodTypeAny;
@@ -551,23 +554,59 @@ export async function loadProjectConfig(
 	return result.data;
 }
 
-type InitialProjectConfig = ProjectConfig & {
-	sdkKey: string;
-};
+export const InitialProjectConfigSchema = z.intersection(
+	ProjectSchema,
+	z.object({
+		sdkKey: z.string().describe('the project specific SDK key'),
+		$schema: z.string().optional(),
+	})
+);
+
+type InitialProjectConfig = z.infer<typeof InitialProjectConfigSchema>;
 
 export async function createProjectConfig(dir: string, config: InitialProjectConfig) {
 	const { sdkKey, ...sanitizedConfig } = config;
 
+	// generate the project config
 	const configPath = join(dir, 'agentuity.json');
-	const json5Content = generateJSON5WithComments(ProjectSchema, sanitizedConfig);
+	const json5Content = generateJSON5WithComments(
+		'https://agentuity.dev/schema/cli/v1/agentuity.json',
+		ProjectSchema,
+		sanitizedConfig
+	);
 	await Bun.write(configPath, json5Content + '\n');
 
+	// generate the .env file with initial secret
 	const envPath = join(dir, '.env');
 	const comment =
 		'# AGENTUITY_SDK_KEY is a sensitive value and should not be committed to version control.';
 	const content = `${comment}\nAGENTUITY_SDK_KEY=${sdkKey}\n`;
 	await Bun.write(envPath, content);
 	await chmod(envPath, 0o600);
+
+	// generate the vscode settings
+	const vscodeDir = join(dir, '.vscode');
+	mkdirSync(vscodeDir);
+
+	const settings = {
+		'files.associations': {
+			'agentuity.json': 'jsonc',
+		},
+		'search.exclude': {
+			'**/.git/**': true,
+			'**/node_modules/**': true,
+			'**/bun.lock': true,
+			'**/.agentuity/**': true,
+		},
+		'json.schemas': [
+			{
+				fileMatch: ['agentuity.json'],
+				url: 'https://agentuity.dev/schema/cli/v1/agentuity.json',
+			},
+		],
+	};
+
+	await Bun.write(join(vscodeDir, 'settings.json'), JSON.stringify(settings, null, 2));
 }
 
 export async function loadBuildMetadata(dir: string): Promise<BuildMetadata> {