@agentuity/cli 2.0.11 → 3.0.0-alpha.1

package/src/cmd/build/format-schema.ts

@@ -1,66 +0,0 @@
-/**
- * Simple formatter for schema code strings.
- * Adds basic indentation and line breaks for readability.
- */
-export function formatSchemaCode(code: string): string {
-	if (!code) return code;
-
-	let indentLevel = 0;
-	const indentSize = 2;
-	const lines: string[] = [];
-	let currentLine = '';
-
-	for (let i = 0; i < code.length; i++) {
-		const char = code[i];
-		const nextChar = code[i + 1];
-		const prevChar = i > 0 ? code[i - 1] : '';
-
-		// Skip existing whitespace/newlines
-		if (char === '\n' || char === '\r' || (char === ' ' && prevChar === ' ')) {
-			continue;
-		}
-
-		// Handle opening braces
-		if (char === '{') {
-			currentLine += char;
-			lines.push(' '.repeat(indentLevel * indentSize) + currentLine.trim());
-			indentLevel++;
-			currentLine = '';
-			continue;
-		}
-
-		// Handle closing braces
-		if (char === '}') {
-			if (currentLine.trim()) {
-				lines.push(' '.repeat(indentLevel * indentSize) + currentLine.trim());
-				currentLine = '';
-			}
-			indentLevel--;
-			// Check if next char is closing paren - if so, put on same line
-			if (nextChar === ')') {
-				currentLine = '}';
-			} else {
-				lines.push(' '.repeat(indentLevel * indentSize) + char);
-			}
-			continue;
-		}
-
-		// Handle commas - add line break after
-		if (char === ',') {
-			currentLine += char;
-			lines.push(' '.repeat(indentLevel * indentSize) + currentLine.trim());
-			currentLine = '';
-			continue;
-		}
-
-		// Accumulate characters
-		currentLine += char;
-	}
-
-	// Add any remaining content
-	if (currentLine.trim()) {
-		lines.push(' '.repeat(indentLevel * indentSize) + currentLine.trim());
-	}
-
-	return lines.join('\n');
-}

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

@@ -1,380 +0,0 @@
-/**
- * Agent Discovery — import-based
- *
- * Discovers agents by scanning src/agent/**\/*.ts files and importing them
- * at build time. The agent instance already knows its own metadata, schemas,
- * and evals — no AST parsing needed.
- */
-
-import { dirname, join, relative } from 'node:path';
-import type { Logger } from '../../../types';
-import { StructuredError } from '@agentuity/core';
-import { toForwardSlash } from '../../../utils/normalize-path';
-
-const DuplicateEvalNameError = StructuredError('DuplicateEvalNameError')<{
-	agent: string;
-	filename: string;
-}>();
-
-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;
-	identifier: 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');
-	for (const v of val) hasher.update(v);
-	return hasher.digest().toHex();
-}
-
-function hashSHA1(...val: string[]): string {
-	const hasher = new Bun.CryptoHasher('sha1');
-	for (const v of val) 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);
-}
-
-/**
- * Convert a StandardSchemaV1-compatible schema to a JSON Schema string.
- * Dynamically imports toJSONSchema from @agentuity/schema (available in user's project).
- */
-async function schemaToJsonString(
-	schema: unknown,
-	rootDir: string,
-	logger: Logger
-): Promise<string | undefined> {
-	if (!schema) return undefined;
-
-	try {
-		// Resolve @agentuity/schema from the user's project and import its public entry point.
-		// The CLI doesn't declare @agentuity/schema as its own dependency — it lives in the
-		// user's node_modules, so we resolve the path dynamically.
-		const schemaPackageDir = join(rootDir, 'node_modules', '@agentuity', 'schema');
-		if (!(await Bun.file(join(schemaPackageDir, 'package.json')).exists())) {
-			logger.debug('[agent-discovery] @agentuity/schema not found in user project');
-			return undefined;
-		}
-
-		const { toJSONSchema } = await import(schemaPackageDir);
-		const jsonSchema = toJSONSchema(schema);
-		return JSON.stringify(jsonSchema);
-	} catch (error) {
-		logger.debug(
-			'[agent-discovery] Failed to convert schema to JSON Schema: %s',
-			error instanceof Error ? error.message : String(error)
-		);
-		return undefined;
-	}
-}
-
-/**
- * Import an agent file and extract metadata from the agent instance.
- */
-async function importAgentMetadata(
-	filePath: string,
-	relativeFilename: string,
-	rootDir: string,
-	projectId: string,
-	deploymentId: string,
-	logger: Logger
-): Promise<AgentMetadata | null> {
-	try {
-		const source = await Bun.file(filePath).text();
-		const version = hash(source);
-
-		// Import the agent file — Bun handles TS natively
-		// No source-level gate: files may re-export agents created elsewhere
-		const mod = await import(filePath);
-		const agent = mod.default;
-
-		if (!agent?.metadata?.name) {
-			logger.debug('[agent-discovery] No valid agent found in %s', relativeFilename);
-			return null;
-		}
-
-		const name = agent.metadata.name;
-		const description = agent.metadata.description;
-		const id = getAgentId(projectId, deploymentId, relativeFilename, version);
-		const agentId = generateStableAgentId(projectId, name);
-
-		// Extract schemas as JSON Schema strings
-		const inputSchemaCode = await schemaToJsonString(agent.inputSchema, rootDir, logger);
-		const outputSchemaCode = await schemaToJsonString(agent.outputSchema, rootDir, logger);
-
-		// Extract evals from agent.evals array (self-registered by createEval())
-		const evals: EvalMetadata[] = [];
-		if (agent.evals && Array.isArray(agent.evals) && agent.evals.length > 0) {
-			for (const evalItem of agent.evals) {
-				const evalName = evalItem.metadata?.name ?? evalItem.name;
-				if (!evalName) continue;
-
-				const evalDescription = evalItem.metadata?.description ?? evalItem.description;
-				const evalVersion = version; // same file version
-				const evalId = getEvalId(
-					projectId,
-					deploymentId,
-					relativeFilename,
-					evalName,
-					evalVersion
-				);
-				const evalIdentifier = generateStableEvalId(projectId, agentId, evalName);
-
-				logger.trace(
-					'Found eval "%s" in %s (identifier: %s)',
-					evalName,
-					relativeFilename,
-					evalIdentifier
-				);
-
-				evals.push({
-					id: evalId,
-					identifier: evalIdentifier,
-					name: evalName,
-					filename: relativeFilename,
-					version: evalVersion,
-					description: evalDescription,
-					agentIdentifier: agentId,
-					projectId,
-				});
-			}
-		}
-
-		// Also check for evals in separate eval.ts file in same directory
-		const agentDir = dirname(filePath);
-		const evalsPath = join(agentDir, 'eval.ts');
-		if (await Bun.file(evalsPath).exists()) {
-			const evalsSource = await Bun.file(evalsPath).text();
-			if (evalsSource.includes('createEval')) {
-				try {
-					await import(evalsPath);
-					// After importing, the evals self-register on the agent via agent.createEval()
-					// Re-check agent.evals for any newly registered evals
-					if (agent.evals && Array.isArray(agent.evals)) {
-						const relativeEvalsPath = toForwardSlash(relative(join(rootDir), evalsPath));
-						const evalVersion = hash(evalsSource);
-
-						for (const evalItem of agent.evals) {
-							const evalName = evalItem.metadata?.name ?? evalItem.name;
-							if (!evalName) continue;
-
-							// Skip if already collected from agent file
-							if (evals.some((e) => e.name === evalName)) continue;
-
-							const evalDescription = evalItem.metadata?.description ?? evalItem.description;
-							const evalId = getEvalId(
-								projectId,
-								deploymentId,
-								relativeEvalsPath,
-								evalName,
-								evalVersion
-							);
-							const evalIdentifier = generateStableEvalId(projectId, agentId, evalName);
-
-							logger.trace(
-								'Found eval "%s" in eval.ts for agent %s (identifier: %s)',
-								evalName,
-								name,
-								evalIdentifier
-							);
-
-							evals.push({
-								id: evalId,
-								identifier: evalIdentifier,
-								name: evalName,
-								filename: relativeEvalsPath,
-								version: evalVersion,
-								description: evalDescription,
-								agentIdentifier: agentId,
-								projectId,
-							});
-						}
-					}
-				} catch (error) {
-					logger.warn(
-						'[agent-discovery] Failed to import evals from %s: %s',
-						evalsPath,
-						error instanceof Error ? error.message : String(error)
-					);
-				}
-			}
-		}
-
-		// Check for duplicate eval names across sources (agent file + eval.ts).
-		// Same name + same agent = same stable identifier → duplicate key error
-		// on the backend database.
-		if (evals.length > 1) {
-			const seen = new Map<string, string>();
-			for (const evalItem of evals) {
-				const prev = seen.get(evalItem.name);
-				if (prev && prev !== evalItem.filename) {
-					throw new DuplicateEvalNameError({
-						message:
-							`Duplicate eval name '${evalItem.name}' for agent '${name}': ` +
-							`defined in both '${prev}' and '${evalItem.filename}'. ` +
-							'Eval names must be unique per agent.',
-						agent: name,
-						filename: evalItem.filename,
-					});
-				}
-				seen.set(evalItem.name, evalItem.filename);
-			}
-		}
-
-		return {
-			filename: relativeFilename,
-			name,
-			id,
-			agentId,
-			version,
-			description,
-			inputSchemaCode,
-			outputSchemaCode,
-			evals: evals.length > 0 ? evals : undefined,
-		};
-	} catch (error) {
-		const errorMsg = error instanceof Error ? error.message : String(error);
-		throw new Error(
-			`Failed to import agent at ${relativeFilename}:\n` +
-				`  ${errorMsg}\n\n` +
-				`Agent files are imported at build time to extract metadata. Code that ` +
-				`runs at module scope (outside of setup() or handler()) will execute ` +
-				`during the build — including SDK client constructors that require API ` +
-				`keys or environment variables.\n\n` +
-				`To fix this, move initialization code into setup() or handler():\n\n` +
-				`  // ❌ Don't do this — runs at import time:\n` +
-				`  const client = new OpenAI();\n` +
-				`  export default createAgent('my-agent', { handler: async (ctx) => { ... } });\n\n` +
-				`  // ✅ Do this instead — runs at startup:\n` +
-				`  export default createAgent('my-agent', {\n` +
-				`    setup: async () => ({ client: new OpenAI() }),\n` +
-				`    handler: async (ctx) => { const { client } = ctx.config; ... },\n` +
-				`  });\n\n` +
-				`See https://agentuity.dev/agents/creating-agents for more information.`
-		);
-	}
-}
-
-/**
- * Discover all agents in src/agent directory.
- *
- * Imports each agent file at build time — the agent instance already knows
- * its own metadata, schemas, and evals. No AST parsing needed.
- */
-export async function discoverAgents(
-	srcDir: string,
-	projectId: string,
-	deploymentId: string,
-	logger: Logger
-): Promise<AgentMetadata[]> {
-	const agentsDir = join(srcDir, 'agent');
-	const agents: AgentMetadata[] = [];
-	const rootDir = join(srcDir, '..');
-
-	// Scan all .ts files in agent directory
-	const glob = new Bun.Glob('**/*.ts');
-	let files: string[];
-	try {
-		files = await Array.fromAsync(glob.scan(agentsDir));
-	} catch {
-		logger.trace('No agent directory found at %s', agentsDir);
-		return agents;
-	}
-
-	// Track seen agent names to deduplicate — e.g., index.ts re-exporting agent.ts
-	const seenAgentNames = new Set<string>();
-
-	for (const file of files) {
-		const filePath = join(agentsDir, file);
-
-		// Skip eval.ts files (processed as part of agent discovery)
-		if (file.endsWith('/eval.ts') || file === 'eval.ts') {
-			continue;
-		}
-
-		// Skip test files (*.test.ts, *.spec.ts) and test directories
-		if (
-			file.startsWith('test/') ||
-			file.includes('/test/') ||
-			file.startsWith('__tests__/') ||
-			file.includes('/__tests__/') ||
-			file.endsWith('.test.ts') ||
-			file.endsWith('.spec.ts')
-		) {
-			continue;
-		}
-
-		const relativeFilename = toForwardSlash(relative(rootDir, filePath));
-		const agentMetadata = await importAgentMetadata(
-			filePath,
-			relativeFilename,
-			rootDir,
-			projectId,
-			deploymentId,
-			logger
-		);
-
-		if (agentMetadata) {
-			if (seenAgentNames.has(agentMetadata.name)) {
-				logger.trace(
-					'Skipping duplicate agent %s from %s (already discovered)',
-					agentMetadata.name,
-					relativeFilename
-				);
-				continue;
-			}
-			seenAgentNames.add(agentMetadata.name);
-			logger.trace('Discovered agent: %s at %s', agentMetadata.name, relativeFilename);
-			agents.push(agentMetadata);
-		}
-	}
-
-	logger.debug('Discovered %d agent(s)', agents.length);
-	return agents;
-}

package/src/cmd/build/vite/beacon-plugin.ts

@@ -1,164 +0,0 @@
-/**
- * Vite plugin to emit the analytics beacon as a hashed CDN asset
- *
- * This plugin:
- * 1. Reads the pre-built beacon from @agentuity/frontend
- * 2. Emits it as a Rollup asset with content-based hashing
- * 3. Injects a <script data-agentuity-beacon> tag into the HTML
- */
-
-import type { Plugin, ResolvedConfig } from 'vite';
-import { join } from 'node:path';
-import { createRequire } from 'node:module';
-
-export interface BeaconPluginOptions {
-	/** Whether analytics is enabled */
-	enabled: boolean;
-}
-
-/**
- * Read the pre-built beacon script from @agentuity/frontend package
- * @param projectRoot - The root directory of the project (for resolving node_modules)
- */
-async function readBeaconScript(projectRoot: string): Promise<string> {
-	let frontendPath: string | null = null;
-
-	// Strategy 1: Use Bun.resolve (works with workspaces and symlinks)
-	try {
-		frontendPath = await Bun.resolve('@agentuity/frontend', projectRoot);
-	} catch {
-		// Not found from project root
-	}
-
-	// Strategy 2: Try from this file's directory (for installed CLI case)
-	if (!frontendPath) {
-		try {
-			const thisDir = new URL('.', import.meta.url).pathname;
-			frontendPath = await Bun.resolve('@agentuity/frontend', thisDir);
-		} catch {
-			// Not found from CLI directory
-		}
-	}
-
-	// Strategy 3: Fallback to createRequire for Node.js compatibility
-	if (!frontendPath) {
-		try {
-			const projectRequire = createRequire(join(projectRoot, 'package.json'));
-			frontendPath = projectRequire.resolve('@agentuity/frontend');
-		} catch {
-			// Not found via createRequire
-		}
-	}
-
-	if (!frontendPath) {
-		throw new Error(
-			'Could not resolve @agentuity/frontend. Ensure the package is installed and built.'
-		);
-	}
-
-	// The beacon.js file is in the dist folder of @agentuity/frontend
-	// frontendPath points to dist/index.js, so we go up one level
-	const packageDir = join(frontendPath, '..');
-	const beaconPath = join(packageDir, 'beacon.js');
-
-	const beaconFile = Bun.file(beaconPath);
-	if (!(await beaconFile.exists())) {
-		throw new Error(
-			`Beacon script not found at ${beaconPath}. Run "bun run build" in @agentuity/frontend first.`
-		);
-	}
-
-	return beaconFile.text();
-}
-
-/**
- * Vite plugin that emits the analytics beacon as a hashed asset
- * and injects a script tag into the HTML
- */
-export function beaconPlugin(options: BeaconPluginOptions): Plugin {
-	const { enabled } = options;
-
-	let resolvedConfig: ResolvedConfig | null = null;
-	let beaconReferenceId: string | null = null;
-
-	return {
-		name: 'agentuity:beacon',
-		apply: 'build',
-
-		configResolved(config) {
-			resolvedConfig = config;
-		},
-
-		async buildStart() {
-			if (!enabled) return;
-
-			try {
-				// Get project root from Vite config
-				const projectRoot = resolvedConfig?.root || process.cwd();
-				const beaconCode = await readBeaconScript(projectRoot);
-
-				// Emit the beacon as an asset - Rollup will hash it
-				beaconReferenceId = this.emitFile({
-					type: 'asset',
-					name: 'agentuity-beacon.js',
-					source: beaconCode,
-				});
-			} catch (error) {
-				this.error(
-					`Failed to read beacon script: ${error instanceof Error ? error.message : String(error)}`
-				);
-			}
-		},
-
-		// Use transformIndexHtml hook to modify the HTML
-		// This is called during the HTML transformation phase and works with Vite's HTML pipeline
-		transformIndexHtml: {
-			order: 'post',
-			handler(html, ctx) {
-				if (!enabled || !beaconReferenceId) return html;
-
-				// Get the final hashed filename using the bundle from the context
-				// We need to use ctx.bundle to access the emitted file
-				const bundle = ctx.bundle;
-				if (!bundle) return html;
-
-				// Find our beacon asset in the bundle
-				let beaconFileName: string | null = null;
-				for (const fileName of Object.keys(bundle)) {
-					if (fileName.includes('agentuity-beacon') && fileName.endsWith('.js')) {
-						beaconFileName = fileName;
-						break;
-					}
-				}
-
-				if (!beaconFileName) return html;
-
-				// Build the beacon URL using Vite's configured base (respects CDN URL)
-				// resolvedConfig.base is e.g., "https://cdn.agentuity.com/{deploymentId}/client/" or "/"
-				const base = resolvedConfig?.base || '/';
-				// Normalize: ensure base ends with / and beaconFileName doesn't start with /
-				const normalizedBase = base.endsWith('/') ? base : `${base}/`;
-				const normalizedFileName = beaconFileName.startsWith('/')
-					? beaconFileName.slice(1)
-					: beaconFileName;
-				const beaconUrl = `${normalizedBase}${normalizedFileName}`;
-
-				// Inject a marker script tag
-				// The script must be sync (no async/defer) to patch history API before router loads
-				// Use data-agentuity-beacon attribute as a marker for config/session injection
-				const beaconScript = `<script data-agentuity-beacon src="${beaconUrl}"></script>`;
-
-				// Inject before </head>
-				if (html.includes('</head>')) {
-					return html.replace('</head>', `${beaconScript}</head>`);
-				}
-				// Fallback: inject at start of body
-				if (html.includes('<body')) {
-					return html.replace(/<body([^>]*)>/, `<body$1>${beaconScript}`);
-				}
-
-				return beaconScript + html;
-			},
-		},
-	};
-}

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

@@ -1,34 +0,0 @@
-/**
- * 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;
-		},
-	};
-}