@agentuity/cli 0.0.78 → 0.0.80

package/src/cmd/build/ast.ts

@@ -1,5 +1,5 @@
 import * as acornLoose from 'acorn-loose';
-import { dirname, relative } from 'node:path';
+import { dirname, relative, join, basename } from 'node:path';
 import { parse as parseCronExpression } from '@datasert/cronjs-parser';
 import { generate } from 'astring';
 import type { BuildMetadata } from '../../types';
@@ -7,7 +7,7 @@ import { createLogger } from '@agentuity/server';
 import * as ts from 'typescript';
 import { StructuredError, type WorkbenchConfig } from '@agentuity/core';
 import type { LogLevel } from '../../types';
-import { join } from 'node:path';
+
 import { existsSync, mkdirSync } from 'node:fs';
 import JSON5 from 'json5';
 import { formatSchemaCode } from './format-schema';
@@ -152,7 +152,7 @@ function getEvalId(
 	name: string,
 	version: string
 ): string {
-	return `eval_${hashSHA1(projectId, deploymentId, filename, name, version)}`;
+	return `evalid_${hashSHA1(projectId, deploymentId, filename, name, version)}`;
 }
 
 function generateRouteId(
@@ -172,7 +172,7 @@ function generateStableAgentId(projectId: string, name: string): string {
 }
 
 function generateStableEvalId(projectId: string, agentId: string, name: string): string {
-	return `evalid_${hashSHA1(projectId, agentId, name)}`.substring(0, 64);
+	return `eval_${hashSHA1(projectId, agentId, name)}`.substring(0, 64);
 }
 
 /**
@@ -328,24 +328,135 @@ function createAgentMetadataNode(
 
 const DuplicateNameError = StructuredError('DuplicateNameError')<{ filename: string }>();
 
-export function parseEvalMetadata(
+function injectEvalMetadata(
+	configObj: ASTObjectExpression,
+	evalId: string,
+	stableEvalId: string,
+	version: string,
+	filename: string,
+	agentId?: string
+): void {
+	// Create metadata object with eval IDs and version
+	const properties = [
+		createObjectPropertyNode('id', evalId),
+		createObjectPropertyNode('evalId', stableEvalId),
+		createObjectPropertyNode('version', version),
+		createObjectPropertyNode('filename', filename),
+	];
+
+	// Add agentId if available
+	if (agentId) {
+		properties.push(createObjectPropertyNode('agentId', agentId));
+	}
+
+	const metadataObj: ASTPropertyNode = {
+		type: 'Property',
+		kind: 'init',
+		key: {
+			type: 'Identifier',
+			name: 'metadata',
+		},
+		value: {
+			type: 'ObjectExpression',
+			properties,
+		} as ASTObjectExpression,
+	};
+
+	// Add metadata to the config object
+	configObj.properties.push(metadataObj);
+}
+
+function findAgentVariableAndImport(
+	ast: ASTProgram
+): { varName: string; importPath: string } | undefined {
+	// First, find what variable is being used in agent.createEval() calls
+	let agentVarName: string | undefined;
+
+	for (const node of ast.body) {
+		if (node.type === 'ExportNamedDeclaration') {
+			const exportDecl = node as {
+				declaration?: { type: string; declarations?: Array<ASTVariableDeclarator> };
+			};
+			if (exportDecl.declaration?.type === 'VariableDeclaration') {
+				const variableDeclaration = exportDecl.declaration as {
+					declarations: Array<ASTVariableDeclarator>;
+				};
+
+				for (const vardecl of variableDeclaration.declarations) {
+					if (
+						vardecl.type === 'VariableDeclarator' &&
+						vardecl.init?.type === 'CallExpression'
+					) {
+						const call = vardecl.init as ASTCallExpression;
+						if (call.callee.type === 'MemberExpression') {
+							const memberExpr = call.callee as ASTMemberExpression;
+							const object = memberExpr.object as ASTNodeIdentifier;
+							const property = memberExpr.property as ASTNodeIdentifier;
+							if (
+								object.type === 'Identifier' &&
+								property.type === 'Identifier' &&
+								property.name === 'createEval'
+							) {
+								agentVarName = object.name;
+								break;
+							}
+						}
+					}
+				}
+				if (agentVarName) break;
+			}
+		}
+	}
+
+	if (!agentVarName) return undefined;
+
+	// Now find the import for this variable
+	for (const node of ast.body) {
+		if (node.type === 'ImportDeclaration') {
+			const importDecl = node as unknown as {
+				source: ASTLiteral;
+				specifiers: Array<{
+					type: string;
+					local: ASTNodeIdentifier;
+				}>;
+			};
+
+			// Find default import specifier that matches our variable
+			for (const spec of importDecl.specifiers) {
+				if (spec.type === 'ImportDefaultSpecifier' && spec.local.name === agentVarName) {
+					const importPath = importDecl.source.value;
+					if (typeof importPath === 'string') {
+						return { varName: agentVarName, importPath };
+					}
+				}
+			}
+		}
+	}
+
+	return undefined;
+}
+
+export async function parseEvalMetadata(
 	rootDir: string,
 	filename: string,
 	contents: string,
 	projectId: string,
 	deploymentId: string,
-	agentId?: string
-): [
-	string,
-	Array<{
-		filename: string;
-		id: string;
-		version: string;
-		name: string;
-		evalId: string;
-		description?: string;
-	}>,
-] {
+	agentId?: string,
+	agentMetadata?: Map<string, Map<string, string>>
+): Promise<
+	[
+		string,
+		Array<{
+			filename: string;
+			id: string;
+			version: string;
+			name: string;
+			evalId: string;
+			description?: string;
+		}>,
+	]
+> {
 	const logLevel = (process.env.AGENTUITY_LOG_LEVEL || 'info') as
 		| 'trace'
 		| 'debug'
@@ -370,6 +481,47 @@ export function parseEvalMetadata(
 		description?: string;
 	}> = [];
 
+	// Try to find the corresponding agent to get the agentId
+	let resolvedAgentId = agentId;
+	if (!resolvedAgentId && agentMetadata) {
+		const agentInfo = findAgentVariableAndImport(ast);
+		if (agentInfo) {
+			logger.trace(
+				`[EVAL METADATA] Found agent variable '${agentInfo.varName}' imported from '${agentInfo.importPath}'`
+			);
+
+			// Resolve the import path to actual file path
+			let resolvedPath = agentInfo.importPath;
+			if (resolvedPath.startsWith('./') || resolvedPath.startsWith('../')) {
+				// Convert relative path to match the format in agentMetadata
+				const baseDir = dirname(filename);
+				resolvedPath = join(baseDir, resolvedPath);
+				// Normalize and ensure .ts extension
+				if (!resolvedPath.endsWith('.ts')) {
+					resolvedPath += '.ts';
+				}
+			}
+
+			// Find the agent metadata from the passed agentMetadata map
+			for (const [agentFile, metadata] of agentMetadata) {
+				// Check if this agent file matches the resolved import path
+				if (agentFile.includes(basename(resolvedPath)) && metadata.has('agentId')) {
+					resolvedAgentId = metadata.get('agentId');
+					logger.trace(
+						`[EVAL METADATA] Resolved agentId from agent metadata: ${resolvedAgentId} (file: ${agentFile})`
+					);
+					break;
+				}
+			}
+
+			if (!resolvedAgentId) {
+				logger.warn(
+					`[EVAL METADATA] Could not find agent metadata for import path: ${resolvedPath}`
+				);
+			}
+		}
+	}
+
 	// Find all exported agent.createEval() calls
 	for (const body of ast.body) {
 		let variableDeclaration: { declarations: Array<ASTVariableDeclarator> } | undefined;
@@ -451,16 +603,25 @@ export function parseEvalMetadata(
 								);
 								const evalId = getEvalId(projectId, deploymentId, rel, finalName, version);
 
-								// Generate stable evalId
-								const effectiveAgentId = agentId || '';
+								// Generate stable evalId using resolved agentId
+								const effectiveAgentId = resolvedAgentId || '';
 								const stableEvalId = generateStableEvalId(
 									projectId,
 									effectiveAgentId,
 									finalName
 								);
 
-								// Note: We no longer inject metadata into the AST since there's no metadata object
-								// The runtime will generate IDs from the name parameter
+								// Inject eval metadata into the AST (same pattern as agents)
+								if (configObj) {
+									injectEvalMetadata(
+										configObj,
+										evalId,
+										stableEvalId,
+										version,
+										rel,
+										resolvedAgentId
+									);
+								}
 
 								evals.push({
 									filename: rel,
@@ -740,13 +901,14 @@ export async function parseAgentMetadata(
 		const transpiler = new Bun.Transpiler({ loader: 'ts', target: 'bun' });
 		const evalsContents = transpiler.transformSync(evalsSource);
 		const agentId = result[1].get('agentId') || '';
-		const [, evals] = parseEvalMetadata(
+		const [, evals] = await parseEvalMetadata(
 			rootDir,
 			evalsPath,
 			evalsContents,
 			projectId,
 			deploymentId,
-			agentId
+			agentId,
+			new Map() // Empty map since we already have agentId
 		);
 		if (evals.length > 0) {
 			logger.trace(`Adding ${evals.length} eval(s) to agent metadata for ${name}`);
@@ -1777,11 +1939,17 @@ export * from '${runtimeImportPath}/src/index';
  */
 export function analyzeWorkbench(content: string): WorkbenchAnalysis {
 	try {
+		if (!content.includes('@agentuity/workbench')) {
+			return {
+				hasWorkbench: false,
+				config: null,
+			};
+		}
 		const sourceFile = ts.createSourceFile('app.ts', content, ts.ScriptTarget.Latest, true);
 
 		let hasImport = false;
-		let hasUsage = false;
-		let config: WorkbenchConfig | null = null;
+		const workbenchVariables = new Map<string, WorkbenchConfig>();
+		let usedInServices = false;
 
 		function visitNode(node: ts.Node): void {
 			// Check for import declarations with createWorkbench
@@ -1795,18 +1963,55 @@ export function analyzeWorkbench(content: string): WorkbenchAnalysis {
 				}
 			}
 
-			// Check for createWorkbench function calls and extract config
-			if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
-				if (node.expression.text === 'createWorkbench') {
-					hasUsage = true;
-
+			// Track variables assigned from createWorkbench() calls
+			if (
+				ts.isVariableDeclaration(node) &&
+				node.initializer &&
+				ts.isCallExpression(node.initializer) &&
+				ts.isIdentifier(node.initializer.expression) &&
+				node.initializer.expression.text === 'createWorkbench'
+			) {
+				// Extract variable name
+				if (ts.isIdentifier(node.name)) {
 					// Extract configuration from the first argument (if any)
-					if (node.arguments.length > 0) {
-						const configArg = node.arguments[0];
-						config = parseConfigObject(configArg);
+					let varConfig: WorkbenchConfig;
+					if (node.initializer.arguments.length > 0) {
+						const configArg = node.initializer.arguments[0];
+						varConfig = parseConfigObject(configArg) || { route: '/workbench' };
 					} else {
 						// Default config if no arguments provided
-						config = { route: '/workbench' };
+						varConfig = { route: '/workbench' };
+					}
+					workbenchVariables.set(node.name.text, varConfig);
+				}
+			}
+
+			// Check if workbench variable is used in createApp's services config
+			if (
+				ts.isCallExpression(node) &&
+				ts.isIdentifier(node.expression) &&
+				node.expression.text === 'createApp' &&
+				node.arguments.length > 0
+			) {
+				const configArg = node.arguments[0];
+				if (ts.isObjectLiteralExpression(configArg)) {
+					// Find the services property
+					for (const prop of configArg.properties) {
+						if (
+							ts.isPropertyAssignment(prop) &&
+							ts.isIdentifier(prop.name) &&
+							prop.name.text === 'services'
+						) {
+							// Check if any workbench variable is referenced in services
+							const foundVariableName = checkForWorkbenchUsage(
+								prop.initializer,
+								workbenchVariables
+							);
+							if (foundVariableName) {
+								usedInServices = true;
+							}
+							break;
+						}
 					}
 				}
 			}
@@ -1815,15 +2020,94 @@ export function analyzeWorkbench(content: string): WorkbenchAnalysis {
 			ts.forEachChild(node, visitNode);
 		}
 
+		// Helper function to check if workbench variable is used in services config
+		// Returns the variable name if found, otherwise null
+		function checkForWorkbenchUsage(
+			node: ts.Node,
+			variables: Map<string, WorkbenchConfig>
+		): string | null {
+			let foundVar: string | null = null;
+
+			function visit(n: ts.Node): void {
+				if (foundVar) return; // Already found
+
+				// Check for identifier references
+				if (ts.isIdentifier(n) && variables.has(n.text)) {
+					foundVar = n.text;
+					return;
+				}
+
+				// Check for property shorthand: { workbench } in services
+				if (ts.isShorthandPropertyAssignment(n) && variables.has(n.name.text)) {
+					foundVar = n.name.text;
+					return;
+				}
+
+				// Check for property value: { workbench: workbench } in services
+				if (
+					ts.isPropertyAssignment(n) &&
+					n.initializer &&
+					ts.isIdentifier(n.initializer) &&
+					variables.has(n.initializer.text)
+				) {
+					foundVar = n.initializer.text;
+					return;
+				}
+
+				ts.forEachChild(n, visit);
+			}
+
+			visit(node);
+			return foundVar;
+		}
+
 		visitNode(sourceFile);
 
-		// Set default config if workbench is used but no config was parsed
-		if (hasImport && hasUsage && !config) {
-			config = { route: '/workbench', headers: {}, port: 3500 };
+		// Get the config from the first used workbench variable
+		let config: WorkbenchConfig | null = null;
+		if (hasImport && usedInServices) {
+			// Re-check which variable was used
+			const ast = sourceFile;
+			for (const [varName, varConfig] of workbenchVariables.entries()) {
+				// Simple check: walk through and find if this variable is used in services
+				let used = false;
+				function checkUsage(node: ts.Node): void {
+					if (
+						ts.isCallExpression(node) &&
+						ts.isIdentifier(node.expression) &&
+						node.expression.text === 'createApp' &&
+						node.arguments.length > 0
+					) {
+						const configArg = node.arguments[0];
+						if (ts.isObjectLiteralExpression(configArg)) {
+							for (const prop of configArg.properties) {
+								if (
+									ts.isPropertyAssignment(prop) &&
+									ts.isIdentifier(prop.name) &&
+									prop.name.text === 'services'
+								) {
+									const foundVar = checkForWorkbenchUsage(
+										prop.initializer,
+										workbenchVariables
+									);
+									if (foundVar === varName) {
+										used = true;
+										config = varConfig;
+									}
+									break;
+								}
+							}
+						}
+					}
+					ts.forEachChild(node, checkUsage);
+				}
+				checkUsage(ast);
+				if (used) break;
+			}
 		}
 
 		return {
-			hasWorkbench: hasImport && hasUsage,
+			hasWorkbench: hasImport && usedInServices,
 			config: config,
 		};
 	} catch (error) {

package/src/cmd/build/bundler.ts

@@ -11,8 +11,8 @@ import { getVersion } from '../../version';
 import type { Project } from '../../types';
 import { fixDuplicateExportsInDirectory } from './fix-duplicate-exports';
 import type { Logger } from '../../types';
-import { generateWorkbenchMainTsx, generateWorkbenchIndexHtml } from './workbench-templates';
-import { analyzeWorkbench } from './ast';
+import { generateWorkbenchMainTsx, generateWorkbenchIndexHtml } from './workbench';
+import { analyzeWorkbench, type WorkbenchAnalysis } from './ast';
 import { type DeployOptions } from '../../schemas/deploy';
 
 const minBunVersion = '>=1.3.3';
@@ -64,6 +64,7 @@ export interface BundleOptions extends DeployOptions {
 	outDir?: string;
 	region: string;
 	logger: Logger;
+	workbench?: WorkbenchAnalysis;
 }
 
 type BuildResult = Awaited<ReturnType<typeof Bun.build>>;
@@ -116,6 +117,7 @@ export async function bundle({
 	env,
 	region,
 	logger,
+	workbench,
 }: BundleOptions): Promise<{ output: string[] }> {
 	const output: string[] = [];
 
@@ -305,10 +307,12 @@ export async function bundle({
 			format: 'esm',
 			banner: `// Generated file. DO NOT EDIT`,
 			// Disable minify for server bundle (keep code readable for debugging)
-			// Enable splitting to reduce bundle size by extracting common code
-			minify: false,
+			minify: !dev,
 			drop: isProd ? ['debugger'] : undefined,
-			splitting: true,
+			// Disable splitting - causes module initialization issues with externalized packages
+			// The chunk helper functions (__commonJS, __esm, etc.) don't properly handle
+			// CommonJS packages in node_modules that require() other modules
+			splitting: false,
 			conditions: [isProd ? 'production' : 'development', 'bun'],
 			external,
 			naming: {
@@ -322,9 +326,6 @@ export async function bundle({
 		if (!buildResult.success) {
 			handleBuildFailure(buildResult);
 		}
-		// Fix duplicate exports caused by Bun splitting bug
-		// See: https://github.com/oven-sh/bun/issues/5344
-		await fixDuplicateExportsInDirectory(outDir, false);
 	})();
 
 	const buildmetadata = getBuildMetadata();
@@ -468,13 +469,15 @@ export async function bundle({
 
 	// Bundle workbench app if detected via setupWorkbench
 	if (existsSync(appFile)) {
-		const appContent = await Bun.file(appFile).text();
-		const analysis = analyzeWorkbench(appContent);
+		if (!workbench) {
+			const appContent = await Bun.file(appFile).text();
+			workbench = analyzeWorkbench(appContent);
+		}
 
-		if (analysis.hasWorkbench) {
+		if (workbench.hasWorkbench) {
 			// Create workbench config with proper defaults
 			const defaultConfig = { route: '/workbench', headers: {}, port: port || 3500 };
-			const config = { ...defaultConfig, ...analysis.config };
+			const config = { ...defaultConfig, ...workbench.config };
 			try {
 				// Generate workbench files on the fly instead of using files from package
 				const tempWorkbenchDir = join(outDir, 'temp-workbench');
@@ -486,19 +489,19 @@ export async function bundle({
 				await Bun.write(workbenchIndexFile, generateWorkbenchIndexHtml());
 
 				// Bundle workbench using generated files
-				// NOTE: Don't set 'root' to tempWorkbenchDir because it breaks module resolution
-				// Bun needs to resolve @agentuity/* packages from the project's node_modules
+				// Disable splitting to avoid CommonJS/ESM module resolution conflicts
 				const workbenchBuildConfig: Bun.BuildConfig = {
 					entrypoints: [workbenchIndexFile],
 					outdir: join(outDir, 'workbench'),
 					sourcemap: dev ? 'inline' : 'linked',
-					plugins: [AgentuityBundler], // i dont think we need this plugin here
 					target: 'browser',
 					format: 'esm',
 					banner: `// Generated file. DO NOT EDIT`,
-					minify: !dev, // Disable minification in dev to avoid module resolution issues
-					splitting: !dev, // Disable code splitting in dev to avoid relative import resolution issues
+					minify: !dev,
+					drop: isProd ? ['debugger'] : undefined,
+					splitting: false,
 					packages: 'bundle',
+					conditions: ['browser', 'import', 'default'],
 					naming: {
 						entry: '[dir]/[name].[ext]',
 						chunk: 'workbench/chunk/[name]-[hash].[ext]',

package/src/cmd/build/index.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { resolve, join } from 'node:path';
+import { resolve, join, relative } from 'node:path';
 import { getServiceUrls } from '@agentuity/server';
 import { createCommand } from '../../types';
 import { bundle } from './bundler';
@@ -47,7 +47,10 @@ export const command = createCommand({
 		const outDir = opts.outdir ? resolve(opts.outdir) : join(absoluteProjectDir, '.agentuity');
 
 		try {
-			tui.info(`Bundling project at ${absoluteProjectDir} to ${outDir}`);
+			const rel = outDir.startsWith(absoluteProjectDir)
+				? relative(absoluteProjectDir, outDir)
+				: outDir;
+			tui.info(`Bundling project at ${absoluteProjectDir} to ${rel}`);
 
 			const env: Map<string, string> = new Map();
 

package/src/cmd/build/plugin.ts

@@ -236,38 +236,55 @@ const AgentuityBundler: BunPlugin = {
 			let newsource = await Bun.file(args.path).text();
 			if (args.path.startsWith(srcDir)) {
 				const contents = transpiler.transformSync(newsource);
-				const result = await parseAgentMetadata(
-					rootDir,
-					args.path,
-					contents,
-					projectId,
-					deploymentId
-				);
 
-				// Skip files that don't have a createAgent export
-				if (result === undefined) {
-					return {
-						contents: newsource,
-						loader: 'ts',
-					};
-				}
+				// Check if this is an eval file (eval.ts)
+				if (args.path.endsWith('/eval.ts')) {
+					// parseEvalMetadata will find the agent from the import statement
+					const [ns] = await parseEvalMetadata(
+						rootDir,
+						args.path,
+						contents,
+						projectId,
+						deploymentId,
+						undefined, // No agentId - will be resolved from import
+						agentMetadata
+					);
+					newsource = ns;
+				} else {
+					// Handle regular agent files
+					const result = await parseAgentMetadata(
+						rootDir,
+						args.path,
+						contents,
+						projectId,
+						deploymentId
+					);
+
+					// Skip files that don't have a createAgent export
+					if (result === undefined) {
+						return {
+							contents: newsource,
+							loader: 'ts',
+						};
+					}
 
-				const [ns, md] = result;
-				newsource = ns;
-
-				// Only process files that actually export an agent
-				if (md.has('name')) {
-					const newAgentName = md.get('name');
-					for (const [, kv] of agentMetadata) {
-						const found = kv.get('name');
-						if (newAgentName === found) {
-							throw new AgentNameDuplicateError({
-								message: `The agent in ${kv.get('filename')} and the agent in ${md.get('filename')} have the same name (${found}). Agent Names must be unique within a project.`,
-							});
+					const [ns, md] = result;
+					newsource = ns;
+
+					// Only process files that actually export an agent
+					if (md.has('name')) {
+						const newAgentName = md.get('name');
+						for (const [, kv] of agentMetadata) {
+							const found = kv.get('name');
+							if (newAgentName === found) {
+								throw new AgentNameDuplicateError({
+									message: `The agent in ${kv.get('filename')} and the agent in ${md.get('filename')} have the same name (${found}). Agent Names must be unique within a project.`,
+								});
+							}
 						}
-					}
 
-					agentMetadata.set(md.get('name')!, md);
+						agentMetadata.set(md.get('name')!, md);
+					}
 				}
 			}
 			return {
@@ -276,19 +293,6 @@ const AgentuityBundler: BunPlugin = {
 			};
 		});
 
-		build.onLoad({ filter: /\/eval\.ts$/, namespace: 'file' }, async (args) => {
-			let newsource = await Bun.file(args.path).text();
-			if (args.path.startsWith(srcDir)) {
-				const contents = transpiler.transformSync(newsource);
-				const [ns] = parseEvalMetadata(rootDir, args.path, contents, projectId, deploymentId);
-				newsource = ns;
-			}
-			return {
-				contents: newsource,
-				loader: 'ts',
-			};
-		});
-
 		const patches = generatePatches();
 		for (const [, patch] of patches) {
 			let modulePath = join('node_modules', patch.module, '.*');