@agentuity/cli 0.0.60 → 0.0.61

package/src/cmd/build/bundler.ts

@@ -1,6 +1,6 @@
 import { $ } from 'bun';
 import { z } from 'zod';
-import { join, relative, resolve, dirname } from 'node:path';
+import { join, relative, resolve, dirname, basename } from 'node:path';
 import { cpSync, existsSync, mkdirSync, rmSync } from 'node:fs';
 import gitParseUrl from 'git-url-parse';
 import AgentuityBundler, { getBuildMetadata } from './plugin';
@@ -12,7 +12,7 @@ import { createLogger } from '@agentuity/server';
 import type { LogLevel } from '../../types';
 import { generateWorkbenchMainTsx, generateWorkbenchIndexHtml } from './workbench-templates';
 import { analyzeWorkbench } from './ast';
-import { encodeWorkbenchConfig } from '@agentuity/core';
+import { encodeWorkbenchConfig, StructuredError } from '@agentuity/core';
 
 export const DeployOptionsSchema = z.object({
 	tag: z
@@ -27,6 +27,7 @@ export const DeployOptionsSchema = z.object({
 		.optional()
 		.describe('The trigger that caused the build'),
 	commitUrl: z.url().optional().describe('The url to the CI commit'),
+	message: z.string().optional().describe('The message to associate with this deployment'),
 	provider: z.string().optional().describe('The CI provider name (attempts to autodetect)'),
 	event: z
 		.enum(['pull_request', 'push', 'manual', 'workflow'])
@@ -49,8 +50,33 @@ export interface BundleOptions extends DeployOptions {
 	deploymentId?: string;
 	project?: Project;
 	port?: number;
+	outDir?: string;
 }
 
+type BuildResult = Awaited<ReturnType<typeof Bun.build>>;
+type BuildLogs = BuildResult['logs'];
+
+const AppFileNotFoundError = StructuredError('AppFileNotFoundError');
+const AgentsDirNotFoundError = StructuredError('AgentsDirNotFoundError');
+const BuildFailedError = StructuredError('BuildFailedError')<{ logs?: BuildLogs }>();
+
+const handleBuildFailure = (buildResult: BuildResult) => {
+	// Collect all build errors with full details
+	const errorMessages = buildResult.logs
+		.map((log) => {
+			const parts = [log.message];
+			if (log.position) {
+				parts.push(`  at ${log.position.file}:${log.position.line}:${log.position.column}`);
+			}
+			return parts.join('\n');
+		})
+		.join('\n');
+	throw new BuildFailedError({
+		message: errorMessages || 'Build failed with no error messages',
+		logs: buildResult.logs,
+	});
+};
+
 export async function bundle({
 	orgId,
 	projectId,
@@ -59,6 +85,7 @@ export async function bundle({
 	rootDir,
 	project,
 	port,
+	outDir: customOutDir,
 	tag,
 	logsUrl,
 	commitUrl,
@@ -68,12 +95,16 @@ export async function bundle({
 	pullRequestNumber,
 	pullRequestCommentId,
 	pullRequestURL,
+	message,
+	env,
 }: BundleOptions) {
 	const appFile = join(rootDir, 'app.ts');
 	if (!existsSync(appFile)) {
-		throw new Error(`App file not found at expected location: ${appFile}`);
+		throw new AppFileNotFoundError({
+			message: `App file not found at expected location: ${appFile}`,
+		});
 	}
-	const outDir = join(rootDir, '.agentuity');
+	const outDir = customOutDir ?? join(rootDir, '.agentuity');
 	const srcDir = join(rootDir, 'src');
 
 	const appEntrypoints: string[] = [];
@@ -82,13 +113,17 @@ export async function bundle({
 		const dir = join(srcDir, folder);
 		if (!existsSync(dir)) {
 			if (folder === 'agents') {
-				throw new Error(`Expected directory not found: ${dir}`);
+				throw new AgentsDirNotFoundError({ message: `Expected directory not found: ${dir}` });
 			}
 			continue;
 		}
 		const files = await getFilesRecursively(dir);
 		for (const filename of files) {
-			if (/\.[jt]s?$/.test(filename) && !filename.includes('.generated.')) {
+			if (
+				/\.[jt]s?$/.test(filename) &&
+				!filename.includes('.generated.') &&
+				basename(filename) !== 'AGENTS.md'
+			) {
 				appEntrypoints.push(filename);
 			}
 		}
@@ -122,6 +157,12 @@ export async function bundle({
 		define['process.env.AGENTUITY_CLOUD_DEPLOYMENT_ID'] = JSON.stringify(deploymentId);
 	}
 
+	if (env) {
+		for (const [key, value] of env) {
+			define[`process.env.${key}`] = JSON.stringify(value);
+		}
+	}
+
 	await (async () => {
 		const config: Bun.BuildConfig = {
 			entrypoints: appEntrypoints,
@@ -148,9 +189,7 @@ export async function bundle({
 		};
 		const buildResult = await Bun.build(config);
 		if (!buildResult.success) {
-			// Collect all build errors
-			const errorMessages = buildResult.logs.map((log) => log.message).join('\n');
-			throw new Error(errorMessages || 'Build failed');
+			handleBuildFailure(buildResult);
 		}
 		// Fix duplicate exports caused by Bun splitting bug
 		// See: https://github.com/oven-sh/bun/issues/5344
@@ -257,35 +296,29 @@ export async function bundle({
 						asset: 'web/asset/[name]-[hash].[ext]',
 					},
 				};
-				try {
-					const result = await Bun.build(config);
-					if (result.success) {
-						// Fix duplicate exports caused by Bun splitting bug
-						// See: https://github.com/oven-sh/bun/issues/5344
-						await fixDuplicateExportsInDirectory(join(outDir, 'web'), false);
-
-						if (!dev && buildmetadata?.assets) {
-							const assets = buildmetadata.assets;
-							result.outputs
-								// Filter for deployable assets: sourcemaps (hash '00000000') and content-addressed files
-								.filter((x) => x.hash === '00000000' || (x.hash && x.path.includes(x.hash)))
-								.forEach((artifact) => {
-									const r = relative(join(outDir, 'web'), artifact.path);
-									assets.push({
-										filename: r,
-										kind: artifact.kind,
-										contentType: artifact.type,
-										size: artifact.size,
-									});
+				const result = await Bun.build(config);
+				if (result.success) {
+					// Fix duplicate exports caused by Bun splitting bug
+					// See: https://github.com/oven-sh/bun/issues/5344
+					await fixDuplicateExportsInDirectory(join(outDir, 'web'), false);
+
+					if (!dev && buildmetadata?.assets) {
+						const assets = buildmetadata.assets;
+						result.outputs
+							// Filter for deployable assets: sourcemaps (hash '00000000') and content-addressed files
+							.filter((x) => x.hash === '00000000' || (x.hash && x.path.includes(x.hash)))
+							.forEach((artifact) => {
+								const r = relative(join(outDir, 'web'), artifact.path);
+								assets.push({
+									filename: r,
+									kind: artifact.kind,
+									contentType: artifact.type,
+									size: artifact.size,
 								});
-						}
-					} else {
-						console.error(result.logs.join('\n'));
-						process.exit(1);
+							});
 					}
-				} catch (ex) {
-					console.error(ex);
-					process.exit(1);
+				} else {
+					handleBuildFailure(result);
 				}
 			}
 		})();
@@ -318,9 +351,10 @@ 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
 				const workbenchBuildConfig: Bun.BuildConfig = {
 					entrypoints: [workbenchIndexFile],
-					root: tempWorkbenchDir,
 					outdir: join(outDir, 'workbench'),
 					define: workbenchDefine,
 					sourcemap: dev ? 'inline' : 'linked',
@@ -360,6 +394,42 @@ export async function bundle({
 				}
 			} catch (error) {
 				logger.error('Failed to bundle workbench:', error);
+				// Collect all error messages
+				const errorMessages: string[] = [];
+				if (error instanceof AggregateError && Array.isArray(error.errors)) {
+					for (const err of error.errors) {
+						// Extract useful info from Bun's ResolveMessage errors
+						if (err && typeof err === 'object') {
+							const errObj = err as Record<string, unknown>;
+							if (typeof errObj.message === 'string') {
+								errorMessages.push(`  ${errObj.message}`);
+							}
+							const position = errObj.position as Record<string, unknown> | undefined;
+							if (position?.file && position?.line && position?.column) {
+								errorMessages.push(
+									`  at ${position.file}:${position.line}:${position.column}`
+								);
+							}
+						}
+					}
+				}
+
+				// Show different tips based on whether we're in a monorepo or published package
+				const isMonorepo = await Bun.file(join(rootDir, '../../packages')).exists();
+				if (isMonorepo) {
+					errorMessages.push(
+						'\nTip: Make sure all @agentuity/* packages are built by',
+						'running "bun run build" from the monorepo root.'
+					);
+				} else {
+					errorMessages.push(
+						'\nTip: If you see module resolution errors, try running',
+						'"bun install" to ensure all dependencies are installed.'
+					);
+				}
+
+				// Don't continue if workbench bundling fails
+				logger.fatal(errorMessages.join('\n'));
 			}
 		}
 	}
@@ -506,6 +576,9 @@ export async function bundle({
 				commentId: pullRequestCommentId,
 			};
 		}
+		if (message) {
+			buildmetadata.deployment.git.message = message;
+		}
 	}
 
 	await Bun.write(

package/src/cmd/build/file.ts

@@ -3,7 +3,7 @@ import { resolve } from 'node:path';
 export async function getFilesRecursively(dir: string): Promise<string[]> {
 	const glob = new Bun.Glob('**/*');
 	const files: string[] = [];
-	for await (const file of glob.scan({ cwd: dir, onlyFiles: true, absolute: false })) {
+	for await (const file of glob.scan({ cwd: dir, onlyFiles: true, absolute: false, dot: true })) {
 		files.push(resolve(dir, file));
 	}
 	return files;

package/src/cmd/build/fix-duplicate-exports.ts

@@ -8,6 +8,9 @@ export async function fixDuplicateExportsInDirectory(dir: string, verbose = fals
 	const jsFiles = await getAllJsFiles(dir);
 	if (verbose) {
 		console.log(`Found ${jsFiles.length} .js files`);
+		for (const js of jsFiles) {
+			console.log(` + Processing ${js}`);
+		}
 	}
 
 	if (jsFiles.length === 0) {
@@ -179,7 +182,7 @@ async function fixDuplicateExportsInFile(filePath: string, verbose = false): Pro
 
 async function getAllJsFiles(dir: string): Promise<string[]> {
 	const glob = new Bun.Glob('**/*.js');
-	const files = await Array.fromAsync(glob.scan({ cwd: dir }));
+	const files = await Array.fromAsync(glob.scan({ cwd: dir, dot: true }));
 	return files.map((file) => path.join(dir, file));
 }
 

package/src/cmd/build/index.ts

@@ -1,8 +1,10 @@
-import { createCommand } from '../../types';
 import { z } from 'zod';
+import { resolve, join } from 'node:path';
+import { createCommand } from '../../types';
 import { bundle } from './bundler';
 import * as tui from '../../tui';
 import { getCommand } from '../../command-prefix';
+import { ErrorCode } from '../../errors';
 
 const BuildResponseSchema = z.object({
 	success: z.boolean().describe('Whether the build succeeded'),
@@ -19,35 +21,74 @@ export const command = createCommand({
 	aliases: ['bundle'],
 	optional: { project: true },
 	idempotent: false,
-	examples: [getCommand('build'), getCommand('build --dev'), getCommand('bundle')],
+	examples: [
+		{ command: getCommand('build'), description: 'Build the project' },
+		{ command: getCommand('build --dev'), description: 'Run in development mode' },
+		{ command: getCommand('bundle'), description: 'Bundle the project' },
+	],
 	schema: {
 		options: z.object({
 			dev: z.boolean().optional().describe('Enable development mode'),
+			outdir: z.string().optional().describe('Output directory for build artifacts'),
+			skipTypeCheck: z
+				.boolean()
+				.default(false)
+				.optional()
+				.describe('Skip typecheck after build'),
 		}),
 		response: BuildResponseSchema,
 	},
 
 	async handler(ctx) {
-		const { opts, projectDir, project } = ctx;
+		const { opts, projectDir, project, config } = ctx;
+
+		const absoluteProjectDir = resolve(projectDir);
+		const outDir = opts.outdir ? resolve(opts.outdir) : join(absoluteProjectDir, '.agentuity');
 
 		try {
-			tui.info(`Bundling project at: ${projectDir}`);
+			tui.info(`Bundling project at ${absoluteProjectDir} to ${outDir}`);
+
+			const env: Map<string, string> = new Map();
+
+			if (opts.dev) {
+				if (config?.overrides?.transport_url) {
+					env.set('AGENTUITY_TRANSPORT_URL', config.overrides.transport_url);
+				}
+				if (config?.overrides?.catalyst_url) {
+					env.set('AGENTUITY_CATALYST_URL', config.overrides.catalyst_url);
+				}
+				if (config?.overrides?.vector_url) {
+					env.set('AGENTUITY_VECTOR_URL', config.overrides.vector_url);
+				}
+				if (config?.overrides?.object_url) {
+					env.set('AGENTUITY_OBJECTSTORE_URL', config.overrides.object_url);
+				}
+				if (config?.overrides?.kv_url) {
+					env.set('AGENTUITY_KEYVALUE_URL', config.overrides.kv_url);
+				}
+				if (config?.overrides?.stream_url) {
+					env.set('AGENTUITY_STREAM_URL', config.overrides.stream_url);
+				}
+				if (project) {
+					env.set('AGENTUITY_CLOUD_ORG_ID', project.orgId);
+					env.set('AGENTUITY_CLOUD_PROJECT_ID', project.projectId);
+				}
+			}
 
-			// Generate agent registry FIRST (so types exist for typecheck)
-			tui.info('Generating agent registry...');
 			await bundle({
-				rootDir: projectDir,
+				rootDir: absoluteProjectDir,
 				dev: opts.dev || false,
+				outDir,
 				project,
 				orgId: project?.orgId,
 				projectId: project?.projectId,
+				env,
 			});
 
 			// Run TypeScript type checking after registry generation (skip in dev mode)
-			if (!opts.dev) {
+			if (!opts.dev && !opts.skipTypeCheck) {
 				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)
@@ -72,15 +113,19 @@ export const command = createCommand({
 
 			return {
 				success: true,
-				bundlePath: `${projectDir}/.agentuity`,
+				bundlePath: outDir,
 				projectName: project?.projectId || 'unknown',
 				dev: opts.dev || false,
 			};
 		} catch (error) {
-			if (error instanceof Error) {
-				tui.fatal(`Bundle failed: ${error.message}`);
+			if (error instanceof AggregateError) {
+				const ae = error as AggregateError;
+				for (const e of ae.errors) {
+					tui.error(e.message);
+				}
+				tui.fatal('Build failed', ErrorCode.BUILD_FAILED);
 			} else {
-				tui.fatal('Bundle failed');
+				tui.fatal(`Build failed: ${error}`, ErrorCode.BUILD_FAILED);
 			}
 		}
 	},