@agentuity/cli 0.0.49 → 0.0.51

package/src/cmd/{bundle → build}/ast.ts

@@ -116,6 +116,10 @@ function hashSHA1(...val: string[]): string {
 	return hasher.digest().toHex();
 }
 
+export function getDevmodeDeploymentId(projectId: string, endpointId: string): string {
+	return `devmode_${hashSHA1(projectId, endpointId)}`;
+}
+
 function getAgentId(
 	projectId: string,
 	deploymentId: string,
@@ -151,6 +155,10 @@ function generateStableAgentId(projectId: string, name: string): string {
 	return `agentid_${hashSHA1(projectId, name)}`.substring(0, 64);
 }
 
+function generateStableEvalId(projectId: string, agentId: string, name: string): string {
+	return `evalid_${hashSHA1(projectId, agentId, name)}`.substring(0, 64);
+}
+
 type AcornParseResultType = ReturnType<typeof acornLoose.parse>;
 
 function augmentAgentMetadataNode(
@@ -242,14 +250,29 @@ function setLiteralValue(literal: ASTLiteral, value: string) {
 }
 
 function augmentEvalMetadataNode(
+	projectId: string,
+	agentId: string,
 	id: string,
 	name: string,
 	rel: string,
 	version: string,
-	identifier: string,
-	metadataObj: ASTObjectExpression
+	_ast: AcornParseResultType,
+	metadataObj: ASTObjectExpression,
+	_filename: string
 ): void {
-	// Check if id, version, identifier, filename already exist
+	const metadata = parseObjectExpressionToMap(metadataObj);
+	// Name can come from metadata.name or variable name (already resolved in caller)
+	// If metadata doesn't have name, we'll add it from the resolved name
+	if (!metadata.has('name')) {
+		metadataObj.properties.push(createObjectPropertyNode('name', name));
+	}
+	const descriptionNode = metadataObj.properties.find((x) => x.key.name === 'description')?.value;
+	const description = descriptionNode ? (descriptionNode as ASTLiteral).value : '';
+	const effectiveAgentId = agentId || '';
+	const _evalId = getEvalId(projectId, effectiveAgentId, rel, name, version); // Deployment-specific ID (not used, kept for potential future use)
+	const stableEvalId = generateStableEvalId(projectId, effectiveAgentId, name);
+
+	// Check if id, version, identifier, filename, evalId already exist
 	const existingKeys = new Set<string>();
 	for (const prop of metadataObj.properties) {
 		if (prop.key.type === 'Identifier') {
@@ -286,12 +309,12 @@ function augmentEvalMetadataNode(
 	}
 
 	if (!existingKeys.has('identifier')) {
-		metadataObj.properties.push(createObjectPropertyNode('identifier', identifier));
+		metadataObj.properties.push(createObjectPropertyNode('identifier', name));
 	} else {
 		for (const prop of metadataObj.properties) {
 			if (prop.key.type === 'Identifier' && prop.key.name === 'identifier') {
 				if (prop.value.type === 'Literal') {
-					setLiteralValue(prop.value as ASTLiteral, identifier);
+					setLiteralValue(prop.value as ASTLiteral, name);
 				}
 				break;
 			}
@@ -310,6 +333,32 @@ function augmentEvalMetadataNode(
 			}
 		}
 	}
+
+	if (!existingKeys.has('evalId')) {
+		metadataObj.properties.push(createObjectPropertyNode('evalId', stableEvalId));
+	} else {
+		for (const prop of metadataObj.properties) {
+			if (prop.key.type === 'Identifier' && prop.key.name === 'evalId') {
+				if (prop.value.type === 'Literal') {
+					setLiteralValue(prop.value as ASTLiteral, stableEvalId);
+				}
+				break;
+			}
+		}
+	}
+
+	if (!existingKeys.has('description')) {
+		metadataObj.properties.push(createObjectPropertyNode('description', description));
+	} else {
+		for (const prop of metadataObj.properties) {
+			if (prop.key.type === 'Identifier' && prop.key.name === 'description') {
+				if (prop.value.type === 'Literal') {
+					setLiteralValue(prop.value as ASTLiteral, description);
+				}
+				break;
+			}
+		}
+	}
 }
 
 export function parseEvalMetadata(
@@ -317,7 +366,8 @@ export function parseEvalMetadata(
 	filename: string,
 	contents: string,
 	projectId: string,
-	deploymentId: string
+	deploymentId: string,
+	agentId?: string
 ): [
 	string,
 	Array<{
@@ -326,6 +376,7 @@ export function parseEvalMetadata(
 		version: string;
 		identifier: string;
 		name: string;
+		evalId: string;
 		description?: string;
 	}>,
 ] {
@@ -339,8 +390,6 @@ export function parseEvalMetadata(
 	logger.trace(`Parsing evals from ${filename}`);
 	const ast = acornLoose.parse(contents, { ecmaVersion: 'latest', sourceType: 'module' });
 	const rel = relative(rootDir, filename);
-	const dir = dirname(filename);
-	const identifier = basename(dir);
 	const version = hash(contents);
 	const evals: Array<{
 		filename: string;
@@ -348,17 +397,16 @@ export function parseEvalMetadata(
 		version: string;
 		identifier: string;
 		name: string;
+		evalId: string;
 		description?: string;
 	}> = [];
 
-	// Find all agent.createEval() calls
+	// Find all exported agent.createEval() calls
 	for (const body of ast.body) {
 		let variableDeclaration: { declarations: Array<ASTVariableDeclarator> } | undefined;
 
-		// Handle both direct VariableDeclaration and ExportNamedDeclaration
-		if (body.type === 'VariableDeclaration') {
-			variableDeclaration = body as { declarations: Array<ASTVariableDeclarator> };
-		} else if (body.type === 'ExportNamedDeclaration') {
+		// Only process exported VariableDeclarations
+		if (body.type === 'ExportNamedDeclaration') {
 			const exportDecl = body as {
 				declaration?: { type: string; declarations?: Array<ASTVariableDeclarator> };
 			};
@@ -447,14 +495,31 @@ export function parseEvalMetadata(
 									);
 
 									// Inject metadata into AST if metadata object exists
+									let stableEvalId: string;
+									const effectiveAgentId = agentId || '';
 									if (metadataObj) {
 										augmentEvalMetadataNode(
+											projectId,
+											effectiveAgentId,
 											evalId,
 											finalName,
 											rel,
 											version,
-											identifier,
-											metadataObj
+											ast,
+											metadataObj,
+											filename
+										);
+										// Extract evalId from metadata after augmentation
+										const metadata = parseObjectExpressionToMap(metadataObj);
+										stableEvalId =
+											metadata.get('evalId') ||
+											generateStableEvalId(projectId, effectiveAgentId, finalName);
+									} else {
+										// If no metadata object, generate stable evalId
+										stableEvalId = generateStableEvalId(
+											projectId,
+											effectiveAgentId,
+											finalName
 										);
 									}
 
@@ -462,8 +527,9 @@ export function parseEvalMetadata(
 										filename: rel,
 										id: evalId,
 										version,
-										identifier,
+										identifier: finalName,
 										name: finalName,
+										evalId: stableEvalId,
 										description: evalDescription,
 									});
 								}
@@ -639,12 +705,14 @@ export async function parseAgentMetadata(
 		const evalsSource = await evalsFile.text();
 		const transpiler = new Bun.Transpiler({ loader: 'ts', target: 'bun' });
 		const evalsContents = transpiler.transformSync(evalsSource);
+		const agentId = result[1].get('agentId') || '';
 		const [, evals] = parseEvalMetadata(
 			rootDir,
 			evalsPath,
 			evalsContents,
 			projectId,
-			deploymentId
+			deploymentId,
+			agentId
 		);
 		if (evals.length > 0) {
 			logger.trace(`Adding ${evals.length} eval(s) to agent metadata for ${name}`);

package/src/cmd/build/index.ts

@@ -0,0 +1,89 @@
+import { createCommand } from '../../types';
+import { z } from 'zod';
+import { bundle } from './bundler';
+import * as tui from '../../tui';
+import { getCommand } from '../../command-prefix';
+
+const BuildResponseSchema = z.object({
+	success: z.boolean().describe('Whether the build succeeded'),
+	bundlePath: z.string().describe('Path to the build directory'),
+	projectName: z.string().describe('Project name'),
+	dev: z.boolean().describe('Whether dev mode was enabled'),
+	size: z.number().optional().describe('Build size in bytes'),
+});
+
+export const command = createCommand({
+	name: 'build',
+	description: 'Build Agentuity application for deployment',
+	tags: ['read-only', 'slow', 'requires-project'],
+	aliases: ['bundle'],
+	optional: { project: true },
+	idempotent: false,
+	examples: [getCommand('build'), getCommand('build --dev'), getCommand('bundle')],
+	schema: {
+		options: z.object({
+			dev: z.boolean().optional().describe('Enable development mode'),
+		}),
+		response: BuildResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { opts, projectDir, project } = ctx;
+
+		try {
+			tui.info(`Bundling project at: ${projectDir}`);
+
+			// Run TypeScript type checking before bundling (skip in dev mode)
+			if (!opts.dev) {
+				try {
+					tui.info('Running type check...');
+					const { resolve } = await import('node:path');
+					const absoluteProjectDir = resolve(projectDir);
+					const result = await Bun.$`bunx tsc --noEmit --skipLibCheck`.cwd(absoluteProjectDir).nothrow();
+					if (result.exitCode !== 0) {
+						const errorOutput = result.stderr.toString();
+						// Filter out errors from node_modules - only show user code errors
+						const lines = errorOutput.split('\n');
+						const userErrorLines = lines.filter((line) => !line.includes('node_modules/'));
+						
+						if (userErrorLines.length > 0 && userErrorLines.some(line => line.trim())) {
+							tui.error('Type check failed:\n');
+							console.error(userErrorLines.join('\n'));
+							tui.fatal('Fix type errors before building');
+						}
+						// If only node_modules errors, pass with info
+						tui.info('Type check passed (ignoring dependency type errors)');
+					} else {
+						tui.success('Type check passed');
+					}
+				} catch (error) {
+					// If tsc fails to run, show error and fail
+					const errorMsg = error instanceof Error ? error.message : String(error);
+					tui.error(`Type check failed to run: ${errorMsg}`);
+					tui.fatal('Unable to run TypeScript type checking. Ensure TypeScript is installed.');
+				}
+			}
+
+			await bundle({
+				rootDir: projectDir,
+				dev: opts.dev || false,
+				project,
+			});
+
+			tui.success('Bundle complete');
+
+			return {
+				success: true,
+				bundlePath: `${projectDir}/.agentuity`,
+				projectName: project?.projectId || 'unknown',
+				dev: opts.dev || false,
+			};
+		} catch (error) {
+			if (error instanceof Error) {
+				tui.fatal(`Bundle failed: ${error.message}`);
+			} else {
+				tui.fatal('Bundle failed');
+			}
+		}
+	},
+});

package/src/cmd/{bundle → build}/plugin.ts

@@ -578,6 +578,7 @@ const AgentuityBundler: BunPlugin = {
 						version: v.get('version')!,
 						name: v.get('name')!,
 						description: v.get('description') ?? '<no description provided>',
+						projectId,
 					};
 
 					const evalsStr = v.get('evals');
@@ -586,7 +587,17 @@ const AgentuityBundler: BunPlugin = {
 							`[plugin] Found evals string for agent ${agentData.name}, parsing...`
 						);
 						try {
-							agentData.evals = JSON.parse(evalsStr);
+							const parsedEvals = JSON.parse(evalsStr) as Array<
+								Omit<
+									NonNullable<BuildMetadata['agents'][number]['evals']>[number],
+									'agentIdentifier' | 'projectId'
+								>
+							>;
+							agentData.evals = parsedEvals.map((evalItem) => ({
+								...evalItem,
+								agentIdentifier: agentData.agentId,
+								projectId,
+							}));
 							logger.trace(
 								`[plugin] Successfully parsed ${agentData.evals?.length ?? 0} eval(s) for agent ${agentData.name}`
 							);
@@ -614,6 +625,7 @@ const AgentuityBundler: BunPlugin = {
 								version: sub.get('version')!,
 								name: sub.get('name')!,
 								description: sub.get('description') ?? '<no description provided>',
+								projectId,
 							};
 
 							// Add evals for subagents if any
@@ -623,7 +635,17 @@ const AgentuityBundler: BunPlugin = {
 									`[plugin] Found evals string for subagent ${subagentData.name}, parsing...`
 								);
 								try {
-									subagentData.evals = JSON.parse(subEvalsStr);
+									const parsedSubEvals = JSON.parse(subEvalsStr) as Array<
+										Omit<
+											NonNullable<BuildMetadata['agents'][number]['evals']>[number],
+											'agentIdentifier' | 'projectId'
+										>
+									>;
+									subagentData.evals = parsedSubEvals.map((evalItem) => ({
+										...evalItem,
+										agentIdentifier: subagentData.agentId,
+										projectId,
+									}));
 									logger.trace(
 										`[plugin] Successfully parsed ${subagentData.evals?.length ?? 0} eval(s) for subagent ${subagentData.name}`
 									);

package/src/cmd/cloud/agents/index.ts

@@ -0,0 +1,148 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { APIResponseSchema } from '@agentuity/server';
+import { Table } from 'console-table-printer';
+import { abbreviate, abbreviateDescription } from '../../../utils/format';
+
+const AgentSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string().nullable(),
+	identifier: z.string(),
+	version: z.string().nullable(),
+	deploymentId: z.string().nullable(),
+	devmode: z.boolean(),
+	metadata: z.record(z.string(), z.unknown()).nullable(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	evals: z.array(
+		z.object({
+			id: z.string(),
+			name: z.string(),
+			description: z.string().nullable(),
+			identifier: z.string().nullable(),
+			deploymentId: z.string().nullable(),
+			version: z.string().nullable(),
+			devmode: z.boolean(),
+			createdAt: z.string(),
+			updatedAt: z.string(),
+		})
+	),
+});
+
+const AgentsResponseSchema = APIResponseSchema(z.array(AgentSchema));
+
+export const command = createCommand({
+	name: 'agents',
+	description: 'Show devmode agent results',
+	requires: { auth: true, apiClient: true, project: true },
+	schema: {
+		options: z.object({
+			deploymentId: z.string().optional().describe('Filter by deployment ID'),
+			format: z
+				.enum(['json', 'table'])
+				.optional()
+				.default('table')
+				.describe('Output format: json or table'),
+			verbose: z.boolean().optional().default(false).describe('Show full IDs and descriptions'),
+		}),
+	},
+	async handler(ctx) {
+		const { opts, apiClient, project } = ctx;
+		const projectId = project.projectId;
+		const format = opts?.format ?? 'table';
+		const verbose = opts?.verbose ?? false;
+
+		const deploymentId = opts?.deploymentId;
+		const queryParams = deploymentId ? `?deploymentId=${deploymentId}` : '';
+		const response = await tui.spinner('Fetching agents', async () => {
+			return apiClient.request(
+				'GET',
+				`/cli/agent/${projectId}${queryParams}`,
+				AgentsResponseSchema
+			);
+		});
+
+		if (!response.success) {
+			tui.fatal(`Failed to fetch agents: ${response.message ?? 'Unknown error'}`);
+		}
+
+		const agents = response.data;
+
+		if (format === 'json') {
+			console.log(JSON.stringify(agents, null, 2));
+			return;
+		}
+
+		tui.info(`Agents (${agents.length})`);
+		if (agents.length === 0) {
+			tui.muted('No agents found');
+		} else {
+			const table = new Table({
+				columns: [
+					{ name: 'Name', alignment: 'left' },
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'Identifier', alignment: 'left' },
+					{ name: 'Deployment', alignment: 'left' },
+					{ name: 'Version', alignment: 'left' },
+					{ name: 'Evals', alignment: 'center' },
+					{ name: 'Created', alignment: 'left' },
+				],
+			});
+
+			for (const agent of agents) {
+				table.addRow({
+					Name: agent.name,
+					ID: verbose ? agent.id : abbreviate(agent.id, 20),
+					Identifier: verbose ? agent.identifier : abbreviate(agent.identifier, 20),
+					Deployment: abbreviate(agent.deploymentId, 20),
+					Version: verbose
+						? (agent.version ?? 'N/A')
+						: (abbreviate(agent.version, 20) ?? 'N/A'),
+					Evals: agent.evals.length,
+					Created: new Date(agent.createdAt).toLocaleString(),
+				});
+			}
+			table.printTable();
+
+			// Show evals for each agent
+			for (const agent of agents) {
+				if (agent.evals.length > 0) {
+					console.log(`\n  Evals for ${agent.name}:`);
+					const evalTable = new Table({
+						columns: [
+							{ name: 'Name', alignment: 'left' },
+							{ name: 'ID', alignment: 'left' },
+							{ name: 'Identifier', alignment: 'left' },
+							{ name: 'Deployment', alignment: 'left' },
+							{ name: 'Version', alignment: 'left' },
+							{ name: 'Description', alignment: 'left' },
+							{ name: 'Created', alignment: 'left' },
+						],
+					});
+
+					for (const evalItem of agent.evals) {
+						evalTable.addRow({
+							Name: evalItem.name,
+							ID: verbose ? evalItem.id : abbreviate(evalItem.id, 20),
+							Identifier: verbose
+								? (evalItem.identifier ?? 'N/A')
+								: (abbreviate(evalItem.identifier, 20) ?? 'N/A'),
+							Deployment: abbreviate(evalItem.deploymentId, 20),
+							Version: verbose
+								? (evalItem.version ?? 'N/A')
+								: (abbreviate(evalItem.version, 20) ?? 'N/A'),
+							Description: verbose
+								? (evalItem.description ?? 'N/A')
+								: abbreviateDescription(evalItem.description),
+							Created: new Date(evalItem.createdAt).toLocaleString(),
+						});
+					}
+					evalTable.printTable();
+				}
+			}
+		}
+	},
+});
+export default command;

package/src/cmd/cloud/deploy.ts

@@ -6,7 +6,7 @@ import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
 import { saveProjectDir } from '../../config';
 import { runSteps, stepSuccess, stepSkipped, stepError, Step, ProgressCallback } from '../../steps';
-import { bundle } from '../bundle/bundler';
+import { bundle } from '../build/bundler';
 import { loadBuildMetadata } from '../../config';
 import {
 	projectEnvUpdate,

package/src/cmd/cloud/deployment/list.ts

@@ -3,7 +3,6 @@ import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { projectDeploymentList } from '@agentuity/server';
 import { resolveProjectId } from './utils';
-import { Table } from 'console-table-printer';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
 
@@ -64,28 +63,23 @@ export const listSubcommand = createSubcommand({
 				return [];
 			}
 
-			const table = new Table({
-				columns: [
-					{ name: 'ID', alignment: 'left' },
-					{ name: 'State', alignment: 'left' },
-					{ name: 'Active', alignment: 'center' },
-					{ name: 'Created', alignment: 'left' },
-					{ name: 'Message', alignment: 'left' },
-					{ name: 'Tags', alignment: 'left' },
-				],
-			});
+			const tableData = deployments.map((d) => ({
+				ID: d.id,
+				State: d.state || 'unknown',
+				Active: d.active ? 'Yes' : '',
+				Created: new Date(d.createdAt).toLocaleString(),
+				Message: d.message || '',
+				Tags: d.tags.join(', '),
+			}));
 
-			for (const d of deployments) {
-				table.addRow({
-					ID: d.id,
-					State: d.state || 'unknown',
-					Active: d.active ? 'Yes' : '',
-					Created: new Date(d.createdAt).toLocaleString(),
-					Message: d.message || '',
-					Tags: d.tags.join(', '),
-				});
-			}
-			table.printTable();
+			tui.table(tableData, [
+				{ name: 'ID', alignment: 'left' },
+				{ name: 'State', alignment: 'left' },
+				{ name: 'Active', alignment: 'center' },
+				{ name: 'Created', alignment: 'left' },
+				{ name: 'Message', alignment: 'left' },
+				{ name: 'Tags', alignment: 'left' },
+			]);
 
 			return deployments.map((d) => ({
 				id: d.id,

package/src/cmd/{env → cloud/env}/delete.ts

@@ -1,14 +1,14 @@
 import { z } from 'zod';
-import { createSubcommand } from '../../types';
-import * as tui from '../../tui';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
 import { projectEnvDelete } from '@agentuity/server';
 import {
 	findExistingEnvFile,
 	readEnvFile,
 	writeEnvFile,
 	filterAgentuitySdkKeys,
-} from '../../env-util';
-import { getCommand } from '../../command-prefix';
+} from '../../../env-util';
+import { getCommand } from '../../../command-prefix';
 
 const EnvDeleteResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),

package/src/cmd/{env → cloud/env}/get.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
-import { createSubcommand } from '../../types';
-import * as tui from '../../tui';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
 import { projectGet } from '@agentuity/server';
-import { maskSecret } from '../../env-util';
-import { getCommand } from '../../command-prefix';
-import { ErrorCode } from '../../errors';
+import { maskSecret } from '../../../env-util';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
 
 const EnvGetResponseSchema = z.object({
 	key: z.string().describe('Environment variable key name'),

package/src/cmd/{env → cloud/env}/import.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { createSubcommand } from '../../types';
-import * as tui from '../../tui';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
 import { projectEnvUpdate } from '@agentuity/server';
 import {
 	findEnvFile,
@@ -10,8 +10,8 @@ import {
 	mergeEnvVars,
 	splitEnvAndSecrets,
 	looksLikeSecret,
-} from '../../env-util';
-import { getCommand } from '../../command-prefix';
+} from '../../../env-util';
+import { getCommand } from '../../../command-prefix';
 
 const EnvImportResponseSchema = z.object({
 	success: z.boolean().describe('Whether import succeeded'),

package/src/cmd/{env → cloud/env}/index.ts

@@ -1,4 +1,4 @@
-import { createCommand } from '../../types';
+import { createCommand } from '../../../types';
 import { pullSubcommand } from './pull';
 import { pushSubcommand } from './push';
 import { setSubcommand } from './set';
@@ -21,3 +21,4 @@ export const command = createCommand({
 		importSubcommand,
 	],
 });
+export default command;

package/src/cmd/{env → cloud/env}/list.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
-import { createSubcommand } from '../../types';
-import * as tui from '../../tui';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
 import { projectGet } from '@agentuity/server';
-import { maskSecret } from '../../env-util';
-import { getCommand } from '../../command-prefix';
+import { maskSecret } from '../../../env-util';
+import { getCommand } from '../../../command-prefix';
 
 const EnvListResponseSchema = z.record(
 	z.string(),

package/src/cmd/{env → cloud/env}/pull.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { join } from 'node:path';
-import { createSubcommand } from '../../types';
-import * as tui from '../../tui';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
 import { projectGet } from '@agentuity/server';
 import {
 	findEnvFile,
@@ -9,8 +9,8 @@ import {
 	readEnvFile,
 	writeEnvFile,
 	mergeEnvVars,
-} from '../../env-util';
-import { getCommand } from '../../command-prefix';
+} from '../../../env-util';
+import { getCommand } from '../../../command-prefix';
 
 const EnvPullResponseSchema = z.object({
 	success: z.boolean().describe('Whether pull succeeded'),