@agentuity/cli 0.0.95 → 0.0.96

package/src/cmd/build/vite/agent-discovery.ts

@@ -0,0 +1,467 @@
+/**
+ * Agent Discovery - READ-ONLY AST analysis
+ *
+ * Discovers agents by scanning src/agent/**\/*.ts files
+ * Extracts metadata WITHOUT mutating source files
+ */
+
+import * as acornLoose from 'acorn-loose';
+import { generate } from 'astring';
+import { dirname, join, relative } from 'node:path';
+import { existsSync } from 'node:fs';
+import type { Logger } from '../../../types';
+import { formatSchemaCode } from '../format-schema';
+
+interface ASTNode {
+	type: string;
+	start?: number;
+	end?: number;
+}
+
+interface ASTNodeIdentifier extends ASTNode {
+	name: string;
+}
+
+interface ASTPropertyNode {
+	type: string;
+	kind: string;
+	key: ASTNodeIdentifier;
+	value: ASTNode;
+	shorthand?: boolean;
+	method?: boolean;
+	computed?: boolean;
+}
+
+interface ASTObjectExpression extends ASTNode {
+	properties: ASTPropertyNode[];
+}
+
+interface ASTLiteral extends ASTNode {
+	value: string | number | boolean | null;
+	raw?: string;
+}
+
+interface ASTCallExpression extends ASTNode {
+	arguments: unknown[];
+	callee: ASTNode;
+}
+
+interface ASTVariableDeclarator extends ASTNode {
+	id: ASTNode;
+	init?: ASTNode;
+}
+
+export interface AgentMetadata {
+	filename: string;
+	name: string;
+	id: string;
+	agentId: string;
+	version: string;
+	description?: string;
+	inputSchemaCode?: string;
+	outputSchemaCode?: string;
+	evals?: EvalMetadata[];
+}
+
+export interface EvalMetadata {
+	id: string;
+	evalId: string;
+	name: string;
+	filename: string;
+	version: string;
+	description?: string;
+	agentIdentifier: string;
+	projectId: string;
+}
+
+/**
+ * Hash function for generating stable IDs
+ */
+function hash(...val: string[]): string {
+	const hasher = new Bun.CryptoHasher('sha256');
+	val.forEach((v) => hasher.update(v));
+	return hasher.digest().toHex();
+}
+
+function hashSHA1(...val: string[]): string {
+	const hasher = new Bun.CryptoHasher('sha1');
+	val.forEach((v) => hasher.update(v));
+	return hasher.digest().toHex();
+}
+
+function getAgentId(
+	projectId: string,
+	deploymentId: string,
+	filename: string,
+	version: string
+): string {
+	return `agentid_${hashSHA1(projectId, deploymentId, filename, version)}`;
+}
+
+function generateStableAgentId(projectId: string, name: string): string {
+	return `agent_${hashSHA1(projectId, name)}`.substring(0, 64);
+}
+
+function getEvalId(
+	projectId: string,
+	deploymentId: string,
+	filename: string,
+	name: string,
+	version: string
+): string {
+	return `evalid_${hashSHA1(projectId, deploymentId, filename, name, version)}`;
+}
+
+function generateStableEvalId(projectId: string, agentId: string, name: string): string {
+	return `eval_${hashSHA1(projectId, agentId, name)}`.substring(0, 64);
+}
+
+/**
+ * Extract schema code from createAgent call arguments
+ */
+function extractSchemaCode(callargexp: ASTObjectExpression): {
+	inputSchemaCode?: string;
+	outputSchemaCode?: string;
+} {
+	let schemaObj: ASTObjectExpression | undefined;
+
+	// Find the schema property
+	for (const prop of callargexp.properties) {
+		if (prop.key.type === 'Identifier' && prop.key.name === 'schema') {
+			if (prop.value.type === 'ObjectExpression') {
+				schemaObj = prop.value as ASTObjectExpression;
+				break;
+			}
+		}
+	}
+
+	if (!schemaObj) {
+		return {};
+	}
+
+	let inputSchemaCode: string | undefined;
+	let outputSchemaCode: string | undefined;
+
+	// Extract input and output schema code
+	for (const prop of schemaObj.properties) {
+		if (prop.key.type === 'Identifier') {
+			if (prop.key.name === 'input' && prop.value) {
+				inputSchemaCode = formatSchemaCode(generate(prop.value));
+			} else if (prop.key.name === 'output' && prop.value) {
+				outputSchemaCode = formatSchemaCode(generate(prop.value));
+			}
+		}
+	}
+
+	return { inputSchemaCode, outputSchemaCode };
+}
+
+/**
+ * Parse object expression to extract metadata
+ */
+function parseObjectExpressionToMap(expr: ASTObjectExpression): Map<string, string> {
+	const result = new Map<string, string>();
+	for (const prop of expr.properties) {
+		if (prop.value.type === 'Literal') {
+			const value = prop.value as ASTLiteral;
+			result.set(prop.key.name, String(value.value));
+		}
+	}
+	return result;
+}
+
+/**
+ * Extract metadata from createAgent call (READ-ONLY)
+ */
+function extractAgentMetadata(
+	code: string,
+	filename: string,
+	projectId: string,
+	deploymentId: string
+): AgentMetadata | null {
+	const ast = acornLoose.parse(code, { ecmaVersion: 'latest', sourceType: 'module' });
+
+	// Calculate file version (hash of contents)
+	const version = hash(code);
+
+	// Find createAgent calls
+	for (const node of (ast as { body: ASTNode[] }).body) {
+		if (node.type === 'ExportDefaultDeclaration') {
+			const declaration = (node as unknown as { declaration: ASTNode }).declaration;
+
+			if (declaration.type === 'CallExpression') {
+				const callExpr = declaration as ASTCallExpression;
+
+				if (
+					callExpr.callee.type === 'Identifier' &&
+					(callExpr.callee as ASTNodeIdentifier).name === 'createAgent' &&
+					callExpr.arguments.length >= 2
+				) {
+					// First arg is agent name
+					const nameArg = callExpr.arguments[0] as ASTLiteral;
+					const name = String(nameArg.value);
+
+					// Second arg is config object
+					const callargexp = callExpr.arguments[1] as ASTObjectExpression;
+
+					// Extract schemas
+					const { inputSchemaCode, outputSchemaCode } = extractSchemaCode(callargexp);
+
+					// Extract description from either direct property or metadata object
+					let description: string | undefined;
+					for (const prop of callargexp.properties) {
+						// Check for direct description property
+						if (prop.key.name === 'description' && prop.value.type === 'Literal') {
+							description = String((prop.value as ASTLiteral).value);
+							break; // Direct description takes precedence
+						}
+						// Also check metadata.description for backwards compat
+						if (prop.key.name === 'metadata' && prop.value.type === 'ObjectExpression') {
+							const metadataMap = parseObjectExpressionToMap(
+								prop.value as ASTObjectExpression
+							);
+							if (!description) {
+								description = metadataMap.get('description');
+							}
+							break;
+						}
+					}
+
+					// Generate IDs
+					const id = getAgentId(projectId, deploymentId, filename, version);
+					const agentId = generateStableAgentId(projectId, name);
+
+					return {
+						filename,
+						name,
+						id,
+						agentId,
+						version,
+						description,
+						inputSchemaCode,
+						outputSchemaCode,
+					};
+				}
+			}
+		}
+
+		// Also check variable declarations (e.g., const agent = createAgent(...))
+		if (node.type === 'VariableDeclaration') {
+			const declarations = (node as unknown as { declarations: ASTVariableDeclarator[] })
+				.declarations;
+			for (const decl of declarations) {
+				if (decl.init && decl.init.type === 'CallExpression') {
+					const callExpr = decl.init as ASTCallExpression;
+
+					if (
+						callExpr.callee.type === 'Identifier' &&
+						(callExpr.callee as ASTNodeIdentifier).name === 'createAgent' &&
+						callExpr.arguments.length >= 2
+					) {
+						const nameArg = callExpr.arguments[0] as ASTLiteral;
+						const name = String(nameArg.value);
+
+						const callargexp = callExpr.arguments[1] as ASTObjectExpression;
+						const { inputSchemaCode, outputSchemaCode } = extractSchemaCode(callargexp);
+
+						let description: string | undefined;
+						for (const prop of callargexp.properties) {
+							// Check for direct description property
+							if (prop.key.name === 'description' && prop.value.type === 'Literal') {
+								description = String((prop.value as ASTLiteral).value);
+								break; // Direct description takes precedence
+							}
+							// Also check metadata.description for backwards compat
+							if (prop.key.name === 'metadata' && prop.value.type === 'ObjectExpression') {
+								const metadataMap = parseObjectExpressionToMap(
+									prop.value as ASTObjectExpression
+								);
+								if (!description) {
+									description = metadataMap.get('description');
+								}
+								break;
+							}
+						}
+
+						const id = getAgentId(projectId, deploymentId, filename, version);
+						const agentId = generateStableAgentId(projectId, name);
+
+						return {
+							filename,
+							name,
+							id,
+							agentId,
+							version,
+							description,
+							inputSchemaCode,
+							outputSchemaCode,
+						};
+					}
+				}
+			}
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Extract evals from eval.ts file (READ-ONLY)
+ */
+async function extractEvalMetadata(
+	evalsPath: string,
+	agentId: string,
+	projectId: string,
+	deploymentId: string,
+	logger: Logger
+): Promise<EvalMetadata[]> {
+	const evalsFile = Bun.file(evalsPath);
+	if (!(await evalsFile.exists())) {
+		return [];
+	}
+
+	try {
+		const evalsSource = await evalsFile.text();
+		const transpiler = new Bun.Transpiler({ loader: 'ts', target: 'bun' });
+		const evalsContents = transpiler.transformSync(evalsSource);
+		const version = hash(evalsContents);
+
+		const ast = acornLoose.parse(evalsContents, { ecmaVersion: 'latest', sourceType: 'module' });
+		const evals: EvalMetadata[] = [];
+
+		// Find createEval calls
+		for (const node of (ast as { body: ASTNode[] }).body) {
+			if (node.type === 'ExportNamedDeclaration') {
+				const declaration = (
+					node as unknown as { declaration: { declarations?: ASTVariableDeclarator[] } }
+				).declaration;
+
+				if (declaration?.declarations) {
+					for (const decl of declaration.declarations) {
+						if (decl.init && decl.init.type === 'CallExpression') {
+							const callExpr = decl.init as ASTCallExpression;
+
+							if (
+								callExpr.callee.type === 'Identifier' &&
+								(callExpr.callee as ASTNodeIdentifier).name === 'createEval' &&
+								callExpr.arguments.length >= 2
+							) {
+								const nameArg = callExpr.arguments[0] as ASTLiteral;
+								const evalName = String(nameArg.value);
+
+								const callargexp = callExpr.arguments[1] as ASTObjectExpression;
+								let description: string | undefined;
+
+								for (const prop of callargexp.properties) {
+									if (
+										prop.key.name === 'metadata' &&
+										prop.value.type === 'ObjectExpression'
+									) {
+										const metadataMap = parseObjectExpressionToMap(
+											prop.value as ASTObjectExpression
+										);
+										description = metadataMap.get('description');
+										break;
+									}
+								}
+
+								const id = getEvalId(projectId, deploymentId, evalsPath, evalName, version);
+								const evalId = generateStableEvalId(projectId, agentId, evalName);
+
+								evals.push({
+									id,
+									evalId,
+									name: evalName,
+									filename: evalsPath,
+									version,
+									description,
+									agentIdentifier: agentId,
+									projectId,
+								});
+							}
+						}
+					}
+				}
+			}
+		}
+
+		return evals;
+	} catch (error) {
+		logger.warn(`Failed to parse evals from ${evalsPath}: ${error}`);
+		return [];
+	}
+}
+
+/**
+ * Discover all agents in src/agent directory (READ-ONLY)
+ */
+export async function discoverAgents(
+	srcDir: string,
+	projectId: string,
+	deploymentId: string,
+	logger: Logger
+): Promise<AgentMetadata[]> {
+	const agentsDir = join(srcDir, 'agent');
+	const agents: AgentMetadata[] = [];
+
+	// Check if agent directory exists
+	if (!existsSync(agentsDir)) {
+		logger.trace('No agent directory found at %s', agentsDir);
+		return agents;
+	}
+
+	const transpiler = new Bun.Transpiler({ loader: 'ts', target: 'bun' });
+
+	// Scan all .ts files in agent directory
+	const glob = new Bun.Glob('**/*.ts');
+	for await (const file of glob.scan(agentsDir)) {
+		const filePath = join(agentsDir, file);
+
+		// Skip eval.ts files (processed separately)
+		if (file.endsWith('/eval.ts') || file === 'eval.ts') {
+			continue;
+		}
+
+		try {
+			const source = await Bun.file(filePath).text();
+			const contents = transpiler.transformSync(source);
+
+			// Use 'src/' prefix for consistency with bun bundler and registry imports
+			const rootDir = join(srcDir, '..');
+			const relativeFilename = relative(rootDir, filePath);
+			const agentMetadata = extractAgentMetadata(
+				contents,
+				relativeFilename,
+				projectId,
+				deploymentId
+			);
+
+			if (agentMetadata) {
+				logger.trace('Discovered agent: %s at %s', agentMetadata.name, relativeFilename);
+
+				// Check for evals in same directory
+				const agentDir = dirname(filePath);
+				const evalsPath = join(agentDir, 'eval.ts');
+				const evals = await extractEvalMetadata(
+					evalsPath,
+					agentMetadata.agentId,
+					projectId,
+					deploymentId,
+					logger
+				);
+
+				if (evals.length > 0) {
+					agentMetadata.evals = evals;
+					logger.trace('Found %d eval(s) for agent %s', evals.length, agentMetadata.name);
+				}
+
+				agents.push(agentMetadata);
+			}
+		} catch (error) {
+			logger.warn(`Failed to parse agent file ${filePath}: ${error}`);
+		}
+	}
+
+	logger.debug('Discovered %d agent(s)', agents.length);
+	return agents;
+}

package/src/cmd/build/vite/browser-env-plugin.ts

@@ -0,0 +1,34 @@
+/**
+ * Vite plugin to shim process.env for browser code only
+ *
+ * Replaces process.env with import.meta.env ONLY in files under src/web
+ * to avoid breaking server-side code that needs real process.env
+ */
+
+import type { Plugin } from 'vite';
+
+export function browserEnvPlugin(): Plugin {
+	return {
+		name: 'agentuity:browser-env',
+		enforce: 'pre',
+
+		transform(code, id) {
+			// Only transform files in src/web (browser code)
+			if (!id.includes('/src/web/') && !id.includes('\\src\\web\\')) {
+				return null;
+			}
+
+			// Replace process.env with import.meta.env for browser compatibility
+			const transformed = code.replace(/process\.env/g, 'import.meta.env');
+
+			if (transformed !== code) {
+				return {
+					code: transformed,
+					map: null,
+				};
+			}
+
+			return null;
+		},
+	};
+}

package/src/cmd/build/vite/bun-dev-server.ts

@@ -0,0 +1,78 @@
+/**
+ * Bun Dev Server
+ *
+ * Runs Bun server that handles ALL app logic (HTTP + WebSocket) and proxies
+ * frontend asset requests to Vite asset server for HMR support.
+ */
+
+import type { Logger } from '../../../types';
+import { startViteAssetServer } from './vite-asset-server';
+
+export interface BunDevServerOptions {
+	rootDir: string;
+	port?: number;
+	projectId?: string;
+	orgId?: string;
+	deploymentId?: string;
+	logger: Logger;
+}
+
+export interface BunDevServerResult {
+	viteAssetServer: { server: { close: () => void | Promise<void> }; port: number };
+	bunServerPort: number;
+}
+
+/**
+ * Start Bun dev server with Vite asset server for HMR
+ */
+export async function startBunDevServer(options: BunDevServerOptions): Promise<BunDevServerResult> {
+	const { rootDir, port = 3500, projectId = '', deploymentId = '', logger } = options;
+
+	logger.debug('Starting Bun dev server with Vite asset server for HMR...');
+
+	// Generate workbench source files if enabled (dev mode)
+	const { loadAgentuityConfig, getWorkbenchConfig } = await import('./config-loader');
+	const config = await loadAgentuityConfig(rootDir, logger);
+	const workbenchConfig = getWorkbenchConfig(config, true); // dev mode
+
+	if (workbenchConfig.enabled) {
+		logger.debug('Workbench enabled (dev mode), generating source files...');
+		const { generateWorkbenchFiles } = await import('./workbench-generator');
+		await generateWorkbenchFiles(rootDir, projectId, workbenchConfig, logger);
+	}
+
+	// Step 1: Start Vite asset server FIRST and get its dynamic port
+	logger.info('🎨 Starting Vite asset server for HMR...');
+	const viteAssetServer = await startViteAssetServer({
+		rootDir,
+		logger,
+		workbenchPath: workbenchConfig.enabled ? workbenchConfig.route : undefined,
+	});
+	const vitePort = viteAssetServer.port;
+
+	// Step 2: Generate entry file with Vite port for asset proxying
+	logger.info('📝 Generating entry file with asset proxy configuration...');
+	const { generateEntryFile } = await import('../entry-generator');
+	await generateEntryFile({
+		rootDir,
+		projectId: projectId || '',
+		deploymentId: deploymentId || '',
+		logger,
+		mode: 'dev',
+		workbench: workbenchConfig.enabled ? workbenchConfig : undefined,
+		vitePort, // Pass Vite port for proxy routes
+	});
+
+	// Step 3: Load the generated app - this will start Bun.serve() internally
+	logger.info('📦 Loading generated app (Bun server will start)...');
+	const appPath = `${rootDir}/.agentuity/app.generated.ts`;
+	await import(appPath);
+
+	logger.info(`✅ Bun dev server started on http://127.0.0.1:${port}`);
+	logger.debug(`Asset requests (/@vite/*, /src/web/*, etc.) proxied to Vite:${vitePort}`);
+
+	return {
+		viteAssetServer,
+		bunServerPort: port,
+	};
+}

package/src/cmd/build/vite/config-loader.ts

@@ -0,0 +1,70 @@
+/**
+ * Config loader for agentuity.config.ts
+ */
+
+import { join } from 'node:path';
+import type { Logger } from '../../../types';
+import type { AgentuityConfig } from '../../../types';
+
+/**
+ * Load agentuity.config.ts from the project root
+ * Returns null if the file doesn't exist or fails to load
+ */
+export async function loadAgentuityConfig(
+	rootDir: string,
+	logger: Logger
+): Promise<AgentuityConfig | null> {
+	const configPath = join(rootDir, 'agentuity.config.ts');
+
+	if (!(await Bun.file(configPath).exists())) {
+		logger.trace('No agentuity.config.ts found');
+		return null;
+	}
+
+	try {
+		const config = await import(configPath);
+		const userConfig = config.default as AgentuityConfig | undefined;
+
+		if (!userConfig) {
+			logger.warn('agentuity.config.ts does not export a default configuration');
+			return null;
+		}
+
+		logger.trace('Loaded agentuity.config.ts');
+		return userConfig;
+	} catch (error) {
+		logger.warn('Failed to load agentuity.config.ts:', error);
+		return null;
+	}
+}
+
+/**
+ * Get workbench configuration with defaults
+ * NOTE: Workbench is only available in dev mode
+ *
+ * Presence of workbench config implicitly enables it (no explicit 'enabled' flag needed)
+ * Missing workbench config implicitly disables it
+ */
+export function getWorkbenchConfig(
+	config: AgentuityConfig | null,
+	dev: boolean
+): {
+	enabled: boolean;
+	route: string;
+	headers: Record<string, string>;
+} {
+	const hasWorkbenchConfig = config?.workbench !== undefined;
+
+	// Workbench is enabled if:
+	// 1. In dev mode (never in production)
+	// 2. Config has a workbench object (presence implies enablement)
+	const enabled = dev && hasWorkbenchConfig;
+
+	const workbench = config?.workbench || {};
+
+	return {
+		enabled,
+		route: workbench.route ?? '/workbench',
+		headers: workbench.headers ?? {},
+	};
+}