@agentuity/cli 0.0.95 → 0.0.96

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

@@ -1,202 +0,0 @@
-import { existsSync, readdirSync, lstatSync } from 'node:fs';
-import { join, relative } from 'node:path';
-import { toCamelCase } from '../../utils/string';
-
-/**
- * Information about a discovered route file
- */
-export interface DiscoveredRouteFile {
-	/** Full path to the route file */
-	filepath: string;
-	/** Relative path from apiDir (e.g., 'auth/route.ts', 'v1/users/route.ts') */
-	relativePath: string;
-	/** Mount path for the route (e.g., '/api/auth', '/api/v1/users') */
-	mountPath: string;
-	/** Safe variable name for importing (e.g., 'authRoute', 'v1UsersRoute') */
-	variableName: string;
-	/** Import path relative to build output (e.g., './src/api/auth/route') */
-	importPath: string;
-}
-
-/**
- * Recursively discover all TypeScript files in an API directory.
- * Any .ts file CAN be a route if it exports a router, but not all files MUST be routes.
- * Files without router exports (utility files, types, helpers) are discovered but gracefully skipped during processing.
- *
- * Supports nested structures like:
- * - src/api/index.ts (root API router - handled separately)
- * - src/api/auth/route.ts -> mounted at /api/auth
- * - src/api/auth/login.ts -> mounted at /api/auth
- * - src/api/v1/users/route.ts -> mounted at /api/v1/users
- * - src/api/auth/helpers.ts -> discovered but skipped if no router export
- *
- * @param apiDir - Absolute path to the src/api directory
- * @param currentDir - Current directory being scanned (used for recursion)
- * @param results - Accumulated results (used for recursion)
- * @returns Array of discovered TypeScript files with mount information
- */
-export function discoverRouteFiles(
-	apiDir: string,
-	currentDir: string = apiDir,
-	results: DiscoveredRouteFile[] = []
-): DiscoveredRouteFile[] {
-	if (!existsSync(currentDir)) {
-		return results;
-	}
-
-	const entries = readdirSync(currentDir);
-
-	for (const entry of entries) {
-		const entryPath = join(currentDir, entry);
-		const stat = lstatSync(entryPath);
-
-		// Skip symlinks to prevent infinite recursion
-		if (stat.isSymbolicLink()) {
-			continue;
-		}
-
-		if (stat.isFile() && entry.endsWith('.ts') && !entry.endsWith('.generated.ts')) {
-			// Found a TypeScript file
-			const relativePath = relative(apiDir, entryPath);
-			const isRootIndex = relativePath === 'index.ts';
-
-			// Skip root index.ts - it's handled separately
-			if (isRootIndex) {
-				continue;
-			}
-
-			// For subdirectory files, determine mount path
-			// src/api/auth/route.ts -> /api/auth
-			// src/api/auth/login.ts -> /api/auth
-			// src/api/v1/users/route.ts -> /api/v1/users
-			// src/api/admin/helpers.ts -> /api/admin (discovered but may be skipped during processing)
-			const pathParts = relativePath.split('/');
-			pathParts.pop(); // Remove filename
-
-			// Skip files directly in src/api/ to avoid mount path conflicts with root index.ts
-			if (pathParts.length === 0) {
-				continue;
-			}
-
-			const mountPath = `/api/${pathParts.join('/')}`;
-
-			// Generate safe variable name
-			// auth/route.ts -> authRoute
-			// v1/users/route.ts -> v1UsersRoute
-			// admin/login.ts -> adminLoginRoute
-			const variableParts = pathParts.map((p, idx) => {
-				const camel = toCamelCase(p);
-				// Capitalize first letter of all parts except the first
-				return idx === 0 ? camel : camel.charAt(0).toUpperCase() + camel.slice(1);
-			});
-			const baseName = entry.replace('.ts', '');
-			if (baseName !== 'route' && baseName !== 'index') {
-				const camelBase = toCamelCase(baseName);
-				// Always capitalize the base name since it's not the first part
-				variableParts.push(camelBase.charAt(0).toUpperCase() + camelBase.slice(1));
-			}
-			const variableName = variableParts.join('') + 'Route';
-
-			// Generate import path relative to build output
-			// src/api/auth/route.ts -> ./src/api/auth/route
-			const importPath = './src/api/' + relativePath.replace('.ts', '');
-
-			results.push({
-				filepath: entryPath,
-				relativePath,
-				mountPath,
-				variableName,
-				importPath,
-			});
-		} else if (stat.isDirectory()) {
-			// Recursively scan subdirectories
-			discoverRouteFiles(apiDir, entryPath, results);
-		}
-	}
-
-	return results;
-}
-
-/**
- * Detect potential route path conflicts
- *
- * @param routes - Array of route metadata with method and path
- * @returns Array of conflict descriptions
- */
-export interface RouteConflict {
-	type: 'duplicate' | 'ambiguous-param' | 'wildcard-overlap';
-	routes: Array<{ method: string; path: string; filename: string }>;
-	message: string;
-}
-
-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) {
-		const key = `${route.method.toUpperCase()} ${route.path}`;
-		if (!methodPathMap.has(key)) {
-			methodPathMap.set(key, []);
-		}
-		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] = methodPath.split(' ', 2);
-			conflicts.push({
-				type: 'duplicate',
-				routes: routeList.map((r) => ({ method, path: r.path, filename: r.filename })),
-				message: `Duplicate route: ${methodPath} defined in ${routeList.length} files`,
-			});
-		}
-	}
-
-	// Check for ambiguous parameter routes (same method, different param names)
-	// e.g., GET /users/:id and GET /users/:userId
-	const methodGroups = new Map<string, Array<{ path: string; filename: string }>>();
-	for (const route of routes) {
-		const method = route.method.toUpperCase();
-		if (!methodGroups.has(method)) {
-			methodGroups.set(method, []);
-		}
-		methodGroups.get(method)!.push({ path: route.path, filename: route.filename });
-	}
-
-	for (const [method, routeList] of methodGroups.entries()) {
-		// Normalize params to check for conflicts
-		const normalized = routeList.map((r) => ({
-			...r,
-			normalizedPath: r.path.replace(/:[^/]+/g, ':param'),
-		}));
-
-		const pathMap = new Map<string, Array<{ path: string; filename: string }>>();
-		for (const route of normalized) {
-			if (!pathMap.has(route.normalizedPath)) {
-				pathMap.set(route.normalizedPath, []);
-			}
-			pathMap.get(route.normalizedPath)!.push({ path: route.path, filename: route.filename });
-		}
-
-		for (const [normalizedPath, paths] of pathMap.entries()) {
-			if (paths.length > 1 && normalizedPath.includes(':param')) {
-				// Check if the actual param names differ
-				const uniquePaths = new Set(paths.map((p) => p.path));
-				if (uniquePaths.size > 1) {
-					conflicts.push({
-						type: 'ambiguous-param',
-						routes: paths.map(({ path, filename }) => ({ method, path, filename })),
-						message: `Ambiguous param routes: ${method} ${Array.from(uniquePaths).join(', ')}`,
-					});
-				}
-			}
-		}
-	}
-
-	return conflicts;
-}

package/src/cmd/build/route-registry.ts

@@ -1,222 +0,0 @@
-import { writeFileSync, mkdirSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-
-/**
- * Route information extracted from route files
- */
-export interface RouteInfo {
-	/** HTTP method (GET, POST, etc.) */
-	method: string;
-	/** Route path */
-	path: string;
-	/** Relative file path */
-	filename: string;
-	/** Variable name of the route handler */
-	handlerVariable?: string;
-	/** Whether this route uses validator */
-	hasValidator: boolean;
-	/** Route type: 'api' | 'websocket' | 'sse' | 'stream' */
-	routeType?: string;
-	/** Agent variable name if using agent.validator() */
-	agentVariable?: string;
-	/** Agent import path (e.g., '@agent/hello', '../shared/agents') */
-	agentImportPath?: string;
-	/** Input schema variable name if using validator({ input }) */
-	inputSchemaVariable?: string;
-	/** Output schema variable name if using validator({ output }) */
-	outputSchemaVariable?: string;
-	/** Whether this route is a streaming route (from validator({ stream: true })) */
-	stream?: boolean;
-}
-
-/**
- * Generate RouteRegistry type definitions from discovered routes.
- *
- * Creates a module augmentation for @agentuity/react that provides
- * strongly-typed route keys with input/output schema information.
- *
- * @param srcDir - Source directory path
- * @param routes - Array of route information
- */
-export function generateRouteRegistry(srcDir: string, routes: RouteInfo[]): void {
-	// Filter routes by type (include ALL routes, not just those with validators)
-	// Note: 'stream' routes are HTTP routes that return ReadableStream, so include them with API routes
-	const apiRoutes = routes.filter((r) => r.routeType === 'api' || r.routeType === 'stream');
-	const websocketRoutes = routes.filter((r) => r.routeType === 'websocket');
-	const sseRoutes = routes.filter((r) => r.routeType === 'sse');
-
-	if (apiRoutes.length === 0 && websocketRoutes.length === 0 && sseRoutes.length === 0) {
-		// No routes, skip generation
-		return;
-	}
-
-	// Generate imports for agents and schemas
-	const imports: string[] = [];
-	const agentImports = new Map<string, string>(); // Maps agent variable to unique import name
-	const schemaImports = new Set<string>(); // Track which schema variables we've seen
-
-	// Combine all routes for import collection
-	const allRoutes = [...apiRoutes, ...websocketRoutes, ...sseRoutes];
-
-	// First pass: collect all unique agents and schema variables (only for routes with validators)
-	allRoutes.forEach((route) => {
-		// Skip routes without validators - they won't need imports
-		if (!route.hasValidator) {
-			return;
-		}
-		// If this route uses an agent, import it directly
-		if (route.agentVariable && route.agentImportPath && !agentImports.has(route.agentVariable)) {
-			// Resolve the import path (could be @agent/hello, ../shared, etc.)
-			let resolvedPath = route.agentImportPath;
-
-			// If it's a path alias like @agent/hello, convert to relative path
-			if (resolvedPath.startsWith('@agent/')) {
-				resolvedPath = `../src/agent/${resolvedPath.substring('@agent/'.length)}`;
-			} else if (resolvedPath.startsWith('@api/')) {
-				resolvedPath = `../src/web/${resolvedPath.substring('@api/'.length)}`;
-			} else if (resolvedPath.startsWith('./') || resolvedPath.startsWith('../')) {
-				// Relative path - need to resolve relative to route file location
-				const routeDir = route.filename.substring(0, route.filename.lastIndexOf('/'));
-				resolvedPath = `../${routeDir}/${resolvedPath}`;
-			}
-
-			// Generate unique import name: agent_hello, agent_user, etc.
-			const uniqueImportName = `agent_${route.agentVariable}`;
-			imports.push(`import type ${uniqueImportName} from '${resolvedPath}';`);
-			agentImports.set(route.agentVariable, uniqueImportName);
-		}
-
-		// Track schema variables for potential import from route file
-		if (route.inputSchemaVariable) {
-			schemaImports.add(route.inputSchemaVariable);
-		}
-		if (route.outputSchemaVariable) {
-			schemaImports.add(route.outputSchemaVariable);
-		}
-	});
-
-	// Import schema variables from route files
-	const routeFileImports = new Map<string, Set<string>>(); // Maps route file to schema variables
-	allRoutes.forEach((route) => {
-		// Only import schemas for routes with validators
-		if (!route.hasValidator) {
-			return;
-		}
-		if (route.inputSchemaVariable || route.outputSchemaVariable) {
-			const filename = route.filename.replace(/\\/g, '/');
-			const importPath = `../${filename.replace(/\.ts$/, '')}`;
-
-			if (!routeFileImports.has(importPath)) {
-				routeFileImports.set(importPath, new Set());
-			}
-
-			if (route.inputSchemaVariable) {
-				routeFileImports.get(importPath)!.add(route.inputSchemaVariable);
-			}
-			if (route.outputSchemaVariable) {
-				routeFileImports.get(importPath)!.add(route.outputSchemaVariable);
-			}
-		}
-	});
-
-	// Generate imports for schema variables
-	routeFileImports.forEach((schemas, importPath) => {
-		const schemaList = Array.from(schemas).join(', ');
-		imports.push(`import type { ${schemaList} } from '${importPath}';`);
-	});
-
-	const importsStr = imports.join('\n');
-
-	// Helper function to generate route entry
-	const generateRouteEntry = (route: RouteInfo): string => {
-		const routeKey = route.path; // Use path only for websocket/sse, or METHOD path for API
-
-		// If route doesn't have a validator, use never for schemas
-		if (!route.hasValidator) {
-			const streamValue = route.stream === true ? 'true' : 'false';
-			return `  '${routeKey}': {
-    inputSchema: never;
-    outputSchema: never;
-    stream: ${streamValue};
-  };`;
-		}
-
-		// If we have an agent variable, we can infer types from it
-		if (route.agentVariable) {
-			const importName = agentImports.get(route.agentVariable)!;
-			return `  '${routeKey}': {
-    inputSchema: typeof ${importName} extends { inputSchema?: infer I } ? I : never;
-    outputSchema: typeof ${importName} extends { outputSchema?: infer O } ? O : never;
-    stream: typeof ${importName} extends { stream?: infer S } ? S : false;
-  };`;
-		}
-
-		// If we have standalone validator with schema variables
-		if (route.inputSchemaVariable || route.outputSchemaVariable) {
-			const inputType = route.inputSchemaVariable
-				? `typeof ${route.inputSchemaVariable}`
-				: 'never';
-			const outputType = route.outputSchemaVariable
-				? `typeof ${route.outputSchemaVariable}`
-				: 'never';
-			const streamValue = route.stream === true ? 'true' : 'false';
-			return `  '${routeKey}': {
-    inputSchema: ${inputType};
-    outputSchema: ${outputType};
-    stream: ${streamValue};
-  };`;
-		}
-
-		// Fall back to any if we can't determine the schema source
-		return `  '${routeKey}': {
-    // Unable to extract schema types - validator might use inline schemas
-    inputSchema: any;
-    outputSchema: any;
-  };`;
-	};
-
-	// Generate RouteRegistry interface (API routes use METHOD path format)
-	const apiRouteEntries = apiRoutes
-		.map((route) => {
-			const routeKey = `${route.method.toUpperCase()} ${route.path}`;
-			return generateRouteEntry({ ...route, path: routeKey });
-		})
-		.join('\n');
-
-	// Generate WebSocketRouteRegistry (path only, no method)
-	const websocketRouteEntries = websocketRoutes.map(generateRouteEntry).join('\n');
-
-	// Generate SSERouteRegistry (path only, no method)
-	const sseRouteEntries = sseRoutes.map(generateRouteEntry).join('\n');
-
-	const generatedContent = `// Auto-generated by Agentuity - do not edit manually
-${importsStr}
-
-// Augment @agentuity/react types with project-specific routes
-declare module '@agentuity/react' {
-  export interface RouteRegistry {
-${apiRouteEntries}
-  }
-  
-  export interface WebSocketRouteRegistry {
-${websocketRouteEntries}
-  }
-  
-  export interface SSERouteRegistry {
-${sseRouteEntries}
-  }
-}
-`;
-
-	// Get the project root (parent of srcDir)
-	const projectRoot = join(srcDir, '..');
-	const agentuityDir = join(projectRoot, '.agentuity');
-	const registryPath = join(agentuityDir, 'routes.generated.ts');
-
-	// Ensure .agentuity directory exists
-	if (!existsSync(agentuityDir)) {
-		mkdirSync(agentuityDir, { recursive: true });
-	}
-
-	writeFileSync(registryPath, generatedContent, 'utf-8');
-}