@agentuity/cli 1.0.48 → 2.0.0-beta.0

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

@@ -1,15 +1,15 @@
 /**
- * Route Discovery - READ-ONLY AST analysis
+ * Route Discovery — Explicit Routing Only
  *
- * Discovers routes by scanning src/api/**\/*.ts files or by following
- * explicit router mounts from createApp({ router }).
- * Extracts route definitions WITHOUT mutating source files.
+ * Discovers routes from `createApp({ router })` by importing the router
+ * module at build time and reading `router.routes` from the Hono instance.
+ *
+ * File-based routing (scanning src/api/**) is no longer supported.
  */
 
 import { join, relative } from 'node:path';
-import { existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import type { Logger } from '../../../types';
-import { parseRoute } from '../ast';
 import { toForwardSlash } from '../../../utils/normalize-path';
 import { detectExplicitRouter, type AppRouterDetection } from '../app-router-detector';
 
@@ -28,34 +28,6 @@ export interface RouteMetadata {
 	};
 }
 
-export interface RouteInfo {
-	method: string;
-	path: string;
-	filename: string;
-	hasValidator: boolean;
-	routeType: 'api' | 'sms' | 'email' | 'cron' | 'websocket' | 'sse' | 'stream';
-	agentVariable?: string;
-	agentImportPath?: string;
-	agentName?: string;
-	agentDescription?: string;
-	inputSchemaVariable?: string;
-	outputSchemaVariable?: string;
-	inputSchemaImportPath?: string;
-	inputSchemaImportedName?: string;
-	outputSchemaImportPath?: string;
-	outputSchemaImportedName?: string;
-	inputSchemaCode?: string;
-	outputSchemaCode?: string;
-	stream?: boolean;
-	pathParams?: string[];
-	/**
-	 * When a route is mounted via .route(), its filename is set to the parent file
-	 * (for dedup filtering). schemaSourceFile preserves the actual file where the
-	 * route's schema variables are defined/exported, so registry imports resolve correctly.
-	 */
-	schemaSourceFile?: string;
-}
-
 /**
  * Extract path parameters from a route path.
  * Matches patterns like :id, :userId, :id?, *path, etc.
@@ -74,283 +46,154 @@ export function extractPathParams(path: string): string[] {
 }
 
 /**
- * Discover all routes — tries explicit router detection first, falls back to file-based.
- *
- * When `createApp({ router })` is detected in app.ts, routes are discovered by
- * following the router imports with code-derived mount paths. Otherwise, falls back
- * to scanning src/api/**\/*.ts with filesystem-derived paths.
+ * Generate a deterministic route ID from project/deployment/path/method.
  */
-export async function discoverRoutes(
-	srcDir: string,
+function generateRouteId(
 	projectId: string,
 	deploymentId: string,
-	logger: Logger
-): Promise<{
-	routes: RouteMetadata[];
-	routeInfoList: RouteInfo[];
-	/** Whether explicit router was detected (vs file-based fallback) */
-	explicitRouter?: AppRouterDetection;
-}> {
-	const rootDir = join(srcDir, '..');
+	path: string,
+	method: string
+): string {
+	const hash = createHash('sha256')
+		.update(`${projectId}:${deploymentId}:${path}:${method}`)
+		.digest('hex')
+		.substring(0, 16);
+	return `routeid_${hash}`;
+}
 
-	// Try explicit router detection first
-	const detection = await detectExplicitRouter(rootDir, logger);
-	if (detection.detected && detection.mounts.length > 0) {
-		logger.debug(
-			'Using explicit router detection (%d mount(s) from createApp)',
-			detection.mounts.length
-		);
-		const result = await discoverExplicitRoutes(
-			rootDir,
-			srcDir,
-			projectId,
-			deploymentId,
-			detection,
-			logger
-		);
-		return { ...result, explicitRouter: detection };
+/**
+ * Generate a version hash from file contents.
+ */
+async function generateFileVersion(filePath: string): Promise<string> {
+	try {
+		const content = await Bun.file(filePath).text();
+		return createHash('sha256').update(content).digest('hex').substring(0, 16);
+	} catch {
+		return 'unknown';
 	}
-
-	// Fall back to file-based discovery
-	return discoverFileBasedRoutes(srcDir, projectId, deploymentId, logger);
 }
 
 /**
- * Discover routes from explicit router mounts detected in app.ts.
- * Parses each router file with its code-derived mount prefix.
+ * Detect route type from handler metadata or method.
+ * Checks for route-meta symbol stamped by handler wrappers (websocket, sse, stream, cron).
  */
-async function discoverExplicitRoutes(
-	rootDir: string,
-	srcDir: string,
-	projectId: string,
-	deploymentId: string,
-	detection: AppRouterDetection,
-	logger: Logger
-): Promise<{ routes: RouteMetadata[]; routeInfoList: RouteInfo[] }> {
-	const routes: RouteMetadata[] = [];
-	const routeInfoList: RouteInfo[] = [];
-	const visited = new Set<string>();
-	const mountedSubrouters = new Set<string>();
-
-	for (const mount of detection.mounts) {
-		try {
-			const parsedRoutes = await parseRoute(rootDir, mount.routerFile, projectId, deploymentId, {
-				visitedFiles: visited,
-				mountedSubrouters,
-				mountPrefix: mount.path,
-			});
-
-			if (parsedRoutes.length > 0) {
-				const relFile = './' + toForwardSlash(relative(srcDir, mount.routerFile));
-				logger.trace(
-					'Discovered %d route(s) from explicit mount at %s (%s)',
-					parsedRoutes.length,
-					mount.path,
-					relFile
-				);
-				routes.push(...parsedRoutes);
-
-				for (const route of parsedRoutes) {
-					const pathParams = extractPathParams(route.path);
-					routeInfoList.push({
-						method: route.method.toUpperCase(),
-						path: route.path,
-						filename: route.filename,
-						hasValidator: route.config?.hasValidator === true,
-						routeType: route.type || 'api',
-						agentVariable: route.config?.agentVariable as string | undefined,
-						agentImportPath: route.config?.agentImportPath as string | undefined,
-						inputSchemaVariable: route.config?.inputSchemaVariable as string | undefined,
-						outputSchemaVariable: route.config?.outputSchemaVariable as string | undefined,
-						inputSchemaImportPath: route.config?.inputSchemaImportPath as string | undefined,
-						inputSchemaImportedName: route.config?.inputSchemaImportedName as
-							| string
-							| undefined,
-						outputSchemaImportPath: route.config?.outputSchemaImportPath as
-							| string
-							| undefined,
-						outputSchemaImportedName: route.config?.outputSchemaImportedName as
-							| string
-							| undefined,
-						stream:
-							route.config?.stream !== undefined && route.config.stream !== null
-								? Boolean(route.config.stream)
-								: route.type === 'stream'
-									? true
-									: undefined,
-						pathParams: pathParams.length > 0 ? pathParams : undefined,
-						schemaSourceFile: route.config?.schemaSourceFile as string | undefined,
-					});
-				}
-			}
-		} catch (error) {
-			logger.warn(
-				'Failed to parse explicit router at %s: %s',
-				mount.routerFile,
-				error instanceof Error ? error.message : String(error)
-			);
+function detectRouteType(handler: unknown): 'api' | 'websocket' | 'sse' | 'stream' | 'cron' {
+	// Check for route-meta symbol (future: handler wrappers will tag this)
+	if (typeof handler === 'function') {
+		const meta = (handler as any)[Symbol.for('agentuity:route-meta')];
+		if (meta?.type) {
+			return meta.type;
 		}
 	}
 
-	logger.debug('Discovered %d route(s) via explicit router detection', routes.length);
-
-	// Check for route conflicts
-	const conflicts = detectRouteConflicts(routeInfoList);
-	if (conflicts.length > 0) {
-		logger.error('Route conflicts detected:');
-		for (const conflict of conflicts) {
-			logger.error('  %s', conflict.message);
-			for (const route of conflict.routes) {
-				logger.error('    - %s %s in %s', route.method, route.path, route.filename);
-			}
-		}
-		throw new Error(
-			`Found ${conflicts.length} route conflict(s). Fix the conflicts and try again.`
-		);
+	// Heuristic: upgradeWebSocket handler has a specific name
+	if (typeof handler === 'function' && handler.name === 'upgradeWebSocket') {
+		return 'websocket';
 	}
 
-	return { routes, routeInfoList };
+	return 'api';
 }
 
 /**
- * Discover routes by scanning src/api directory (original file-based approach).
+ * Discover all routes from explicit router mounts in createApp({ router }).
+ *
+ * Imports each router module at build time and reads `router.routes` from
+ * the Hono instance to extract method, path, and route type.
+ *
+ * @throws If no explicit router is detected in app.ts
  */
-async function discoverFileBasedRoutes(
+export async function discoverRoutes(
 	srcDir: string,
 	projectId: string,
 	deploymentId: string,
 	logger: Logger
-): Promise<{ routes: RouteMetadata[]; routeInfoList: RouteInfo[] }> {
-	const apiDir = join(srcDir, 'api');
-	const routes: RouteMetadata[] = [];
-	const routeInfoList: RouteInfo[] = [];
+): Promise<{
+	routes: RouteMetadata[];
+	explicitRouter?: AppRouterDetection;
+}> {
+	const rootDir = join(srcDir, '..');
 
-	// Check if API directory exists
-	if (!existsSync(apiDir)) {
-		logger.trace('No api directory found at %s', apiDir);
-		return { routes, routeInfoList };
+	const detection = await detectExplicitRouter(rootDir, logger);
+	if (!detection.detected || detection.mounts.length === 0) {
+		logger.debug('No explicit router detected in createApp() — no routes to discover');
+		return { routes: [] };
 	}
 
-	const transpiler = new Bun.Transpiler({ loader: 'ts', target: 'bun' });
+	logger.debug(
+		'Using explicit router detection (%d mount(s) from createApp)',
+		detection.mounts.length
+	);
 
-	// Track files that are mounted as sub-routers via .route()
-	// These files will be parsed standalone AND via .route() — we need to deduplicate
-	const mountedSubrouters = new Set<string>();
+	const routes: RouteMetadata[] = [];
 
-	// Scan all .ts files in api directory
-	const glob = new Bun.Glob('**/*.ts');
-	for await (const file of glob.scan(apiDir)) {
-		const filePath = join(apiDir, file);
+	const seenRoutes = new Set<string>();
 
+	for (const mount of detection.mounts) {
 		try {
-			const source = await Bun.file(filePath).text();
-			const contents = transpiler.transformSync(source);
-
-			// Check if file has createRouter or Hono
-			if (!contents.includes('createRouter') && !contents.includes('new Hono')) {
-				logger.trace('Skipping %s (no router)', file);
+			// Import the router module at build time
+			const routerModule = await import(mount.routerFile);
+			const router = routerModule.default ?? routerModule;
+
+			// Validate it's a Hono instance with routes
+			if (!router || !Array.isArray(router.routes)) {
+				logger.warn(
+					'Router module at %s does not export a Hono instance with routes',
+					mount.routerFile
+				);
 				continue;
 			}
 
-			const rootDir = join(srcDir, '..');
-			const relativeFilename = './' + toForwardSlash(relative(srcDir, filePath));
+			const relFile = './' + toForwardSlash(relative(srcDir, mount.routerFile));
+			const version = await generateFileVersion(mount.routerFile);
 
-			try {
-				const parsedRoutes = await parseRoute(
-					rootDir,
-					filePath,
-					projectId,
-					deploymentId,
-					undefined,
-					mountedSubrouters
-				);
-
-				if (parsedRoutes.length > 0) {
-					logger.trace('Discovered %d route(s) in %s', parsedRoutes.length, relativeFilename);
-					routes.push(...parsedRoutes);
+			// Filter to actual route handlers (not middleware — middleware uses '*' or ALL method)
+			const routeEntries = router.routes.filter(
+				(r: any) => r.method !== 'ALL' && r.path !== '*'
+			);
 
-					// Convert to RouteInfo for registry
-					for (const route of parsedRoutes) {
-						const pathParams = extractPathParams(route.path);
-						routeInfoList.push({
-							method: route.method.toUpperCase(),
-							path: route.path,
-							filename: route.filename,
-							hasValidator: route.config?.hasValidator === true,
-							routeType: route.type || 'api',
-							agentVariable: route.config?.agentVariable as string | undefined,
-							agentImportPath: route.config?.agentImportPath as string | undefined,
-							inputSchemaVariable: route.config?.inputSchemaVariable as string | undefined,
-							outputSchemaVariable: route.config?.outputSchemaVariable as string | undefined,
-							inputSchemaImportPath: route.config?.inputSchemaImportPath as
-								| string
-								| undefined,
-							inputSchemaImportedName: route.config?.inputSchemaImportedName as
-								| string
-								| undefined,
-							outputSchemaImportPath: route.config?.outputSchemaImportPath as
-								| string
-								| undefined,
-							outputSchemaImportedName: route.config?.outputSchemaImportedName as
-								| string
-								| undefined,
-							stream:
-								route.config?.stream !== undefined && route.config.stream !== null
-									? Boolean(route.config.stream)
-									: route.type === 'stream'
-										? true
-										: undefined,
-							pathParams: pathParams.length > 0 ? pathParams : undefined,
-							schemaSourceFile: route.config?.schemaSourceFile as string | undefined,
-						});
-					}
-				}
-			} catch (error) {
-				// Skip files that don't have proper router setup
-				if (error instanceof Error) {
-					if (
-						error.message.includes('could not find default export') ||
-						error.message.includes('could not find an proper createRouter')
-					) {
-						logger.trace('Skipping %s: %s', file, error.message);
-					} else {
-						throw error;
-					}
-				} else {
-					throw error;
+			for (const route of routeEntries) {
+				const method = String(route.method).toUpperCase();
+				// Combine mount path with route path
+				let fullPath = route.path;
+				if (mount.path !== '/' && !fullPath.startsWith(mount.path)) {
+					fullPath = mount.path + (fullPath.startsWith('/') ? fullPath : '/' + fullPath);
 				}
+
+				// Deduplicate (Hono may register same route multiple times for middleware)
+				const routeKey = `${method} ${fullPath}`;
+				if (seenRoutes.has(routeKey)) continue;
+				seenRoutes.add(routeKey);
+
+				const routeType = detectRouteType(route.handler);
+				const id = generateRouteId(projectId, deploymentId, fullPath, method);
+
+				routes.push({
+					id,
+					filename: toForwardSlash(relative(rootDir, mount.routerFile)),
+					path: fullPath,
+					method: method.toLowerCase(),
+					version,
+					type: routeType,
+				});
 			}
-		} catch (error) {
-			logger.warn(`Failed to parse route file ${filePath}: ${error}`);
-		}
-	}
 
-	// Filter out routes from standalone-parsed sub-router files
-	// When a file is mounted via .route(), its standalone routes have wrong prefixes
-	// Only the .route()-prefixed routes (attached to the parent file) are correct
-	if (mountedSubrouters.size > 0) {
-		const rootDir = join(srcDir, '..');
-		const subrouterRelPaths = new Set<string>();
-		for (const absPath of mountedSubrouters) {
-			subrouterRelPaths.add(toForwardSlash(relative(rootDir, absPath)));
+			logger.trace(
+				'Discovered %d route(s) from explicit mount at %s (%s)',
+				routeEntries.length,
+				mount.path,
+				relFile
+			);
+		} catch (error) {
+			logger.warn(
+				'Failed to import router at %s: %s',
+				mount.routerFile,
+				error instanceof Error ? error.message : String(error)
+			);
 		}
-
-		// Remove routes whose filename matches a sub-router file
-		// (these are the incorrectly-prefixed standalone routes)
-		const filteredRoutes = routes.filter((r) => !subrouterRelPaths.has(r.filename));
-		const filteredRouteInfoList = routeInfoList.filter((r) => !subrouterRelPaths.has(r.filename));
-
-		// Replace arrays in-place
-		routes.length = 0;
-		routes.push(...filteredRoutes);
-		routeInfoList.length = 0;
-		routeInfoList.push(...filteredRouteInfoList);
 	}
 
-	logger.debug('Discovered %d route(s)', routes.length);
-
 	// Check for route conflicts
-	const conflicts = detectRouteConflicts(routeInfoList);
+	const conflicts = detectRouteConflicts(routes);
 	if (conflicts.length > 0) {
 		logger.error('Route conflicts detected:');
 		for (const conflict of conflicts) {
@@ -364,7 +207,8 @@ async function discoverFileBasedRoutes(
 		);
 	}
 
-	return { routes, routeInfoList };
+	logger.debug('Discovered %d route(s) via explicit router detection', routes.length);
+	return { routes, explicitRouter: detection };
 }
 
 export interface RouteConflict {
@@ -374,14 +218,13 @@ export interface RouteConflict {
 }
 
 /**
- * Detect conflicts between routes
+ * Detect conflicts between routes.
  */
 export function detectRouteConflicts(
 	routes: Array<{ method: string; path: string; filename: string }>
 ): RouteConflict[] {
 	const conflicts: RouteConflict[] = [];
 
-	// Group routes by method+path
 	const methodPathMap = new Map<string, Array<{ path: string; filename: string }>>();
 
 	for (const route of routes) {
@@ -392,7 +235,6 @@ export function detectRouteConflicts(
 		methodPathMap.get(key)!.push({ path: route.path, filename: route.filename });
 	}
 
-	// Check for exact duplicates
 	for (const [methodPath, routeList] of methodPathMap.entries()) {
 		if (routeList.length > 1) {
 			const [method = 'UNKNOWN'] = methodPath.split(' ', 2);

package/src/cmd/build/vite/server-bundler.ts

@@ -56,7 +56,7 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 
 	logger.debug('[server-bundler] Starting server bundle process');
 
-	const entryPath = join(rootDir, 'src/generated/app.ts');
+	const entryPath = join(rootDir, 'app.ts');
 	const outDir = join(rootDir, '.agentuity');
 
 	logger.debug(`[server-bundler] Entry: ${entryPath}, OutDir: ${outDir}`);

package/src/cmd/build/vite/static-renderer.ts

@@ -109,16 +109,6 @@ export async function runStaticRender(options: StaticRenderOptions): Promise<Sta
 		);
 	}
 
-	const isViteDebug =
-		process.env.AGENTUITY_VITE_DEBUG === '1' || process.env.AGENTUITY_VITE_DEBUG === 'true';
-	if (isViteDebug) {
-		logger.debug('Vite debug logging enabled via AGENTUITY_VITE_DEBUG');
-		const existing = process.env.DEBUG || '';
-		if (!existing.includes('vite:')) {
-			process.env.DEBUG = existing ? `${existing},vite:*` : 'vite:*';
-		}
-	}
-
 	// Step 1: Vite SSR build
 	// This resolves import.meta.glob, MDX imports, and other Vite-specific APIs
 	logger.debug('Running Vite SSR build for static rendering...');
@@ -160,7 +150,7 @@ export async function runStaticRender(options: StaticRenderOptions): Promise<Sta
 			// resolved at build time. Node built-ins are still externalized.
 			noExternal: true,
 		},
-		logLevel: isViteDebug ? 'info' : 'warn',
+		logLevel: 'warn',
 	});
 
 	// Steps 2–4: wrapped in try-finally so SSR artifacts are always cleaned up,