@agentuity/cli 2.0.10 → 3.0.0-alpha.0

package/src/cmd/build/vite/prompt-generator.ts

@@ -1,169 +0,0 @@
-/**
- * Prompt Generator
- *
- * Generates AGENTS.md prompt files in .agents/agentuity/sdk/[type]/ directories.
- * Also creates reference files in src/[type]/AGENTS.md (write-once, only if missing).
- *
- * Uses hash tracking to detect template changes in .agents/ folder.
- * Reference files in src/ are never overwritten once created.
- *
- * Only runs in dev mode.
- */
-
-import { join, dirname } from 'node:path';
-import { mkdir } from 'node:fs/promises';
-import type { Logger } from '../../../types';
-import { needsUpdate } from '../../ai/prompt/version';
-import {
-	generateLLMPrompt as generateAgentPrompt,
-	getPromptContent as getAgentContent,
-} from '../../ai/prompt/agent';
-import {
-	generateLLMPrompt as generateApiPrompt,
-	getPromptContent as getApiContent,
-} from '../../ai/prompt/api';
-import {
-	generateLLMPrompt as generateWebPrompt,
-	getPromptContent as getWebContent,
-} from '../../ai/prompt/web';
-
-interface PromptConfig {
-	name: string;
-	srcFolder: string;
-	generate: () => string;
-	getContent: () => string;
-}
-
-const PROMPTS: PromptConfig[] = [
-	{
-		name: 'agent',
-		srcFolder: 'agent',
-		generate: generateAgentPrompt,
-		getContent: getAgentContent,
-	},
-	{
-		name: 'api',
-		srcFolder: 'api',
-		generate: generateApiPrompt,
-		getContent: getApiContent,
-	},
-	{
-		name: 'web',
-		srcFolder: 'web',
-		generate: generateWebPrompt,
-		getContent: getWebContent,
-	},
-];
-
-/**
- * Generate the reference file content that points to .agents/
- */
-function generateReferenceContent(name: string): string {
-	return `See [.agents/agentuity/sdk/${name}/AGENTS.md](../../.agents/agentuity/sdk/${name}/AGENTS.md) for Agentuity ${name} development guidelines.
-`;
-}
-
-/**
- * Generate or update prompt files.
- *
- * - .agents/agentuity/sdk/[type]/AGENTS.md: Full content, updated when hash differs
- * - src/[type]/AGENTS.md: Reference file, only created if missing
- *
- * @param srcDir - The src/ directory path
- * @param logger - Logger for output
- */
-export async function generatePromptFiles(srcDir: string, logger: Logger): Promise<void> {
-	const projectRoot = dirname(srcDir);
-
-	for (const prompt of PROMPTS) {
-		await generatePromptFile(projectRoot, srcDir, prompt, logger);
-	}
-}
-
-async function generatePromptFile(
-	projectRoot: string,
-	srcDir: string,
-	config: PromptConfig,
-	logger: Logger
-): Promise<void> {
-	const srcFolderPath = join(srcDir, config.srcFolder);
-
-	// Check if the src folder exists (e.g., src/agent/)
-	try {
-		const stat = await Bun.$`test -d ${srcFolderPath}`.nothrow();
-		if (stat.exitCode !== 0) {
-			logger.trace(`Skipping ${config.name} prompt - src/${config.srcFolder}/ does not exist`);
-			return;
-		}
-	} catch {
-		logger.trace(`Skipping ${config.name} prompt - src/${config.srcFolder}/ does not exist`);
-		return;
-	}
-
-	// Generate files
-	await generateAgentsFile(projectRoot, config, logger);
-	await generateReferenceFile(srcFolderPath, config, logger);
-}
-
-/**
- * Generate/update the .agents/agentuity/sdk/[type]/AGENTS.md file.
- * Overwrites if hash differs from source template.
- */
-async function generateAgentsFile(
-	projectRoot: string,
-	config: PromptConfig,
-	logger: Logger
-): Promise<void> {
-	const agentsDir = join(projectRoot, '.agents', 'agentuity', 'sdk', config.name);
-	const filePath = join(agentsDir, 'AGENTS.md');
-
-	const file = Bun.file(filePath);
-	const fileExists = await file.exists();
-
-	if (!fileExists) {
-		// File doesn't exist - create it
-		await mkdir(agentsDir, { recursive: true });
-		const content = config.generate();
-		await Bun.write(filePath, content);
-		logger.debug(`Generated .agents/agentuity/sdk/${config.name}/AGENTS.md`);
-		return;
-	}
-
-	// File exists - check if it needs to be updated
-	const existingContent = await file.text();
-	const sourceContent = config.getContent();
-
-	if (needsUpdate(existingContent, sourceContent)) {
-		const content = config.generate();
-		await Bun.write(filePath, content);
-		logger.debug(`Updated .agents/agentuity/sdk/${config.name}/AGENTS.md`);
-		return;
-	}
-
-	logger.trace(`Skipping ${config.name} prompt - already up to date`);
-}
-
-/**
- * Generate the src/[type]/AGENTS.md reference file.
- * Only creates if missing (write-once).
- */
-async function generateReferenceFile(
-	srcFolderPath: string,
-	config: PromptConfig,
-	logger: Logger
-): Promise<void> {
-	const filePath = join(srcFolderPath, 'AGENTS.md');
-
-	const file = Bun.file(filePath);
-	const fileExists = await file.exists();
-
-	if (fileExists) {
-		logger.trace(`Skipping src/${config.srcFolder}/AGENTS.md - already exists`);
-		return;
-	}
-
-	// Create the reference file
-	const content = generateReferenceContent(config.name);
-	await Bun.write(filePath, content);
-	logger.debug(`Generated src/${config.srcFolder}/AGENTS.md (reference)`);
-}

package/src/cmd/build/vite/public-asset-path-plugin.ts

@@ -1,209 +0,0 @@
-/**
- * Vite plugin to fix incorrect public asset paths
- *
- * Developers should use /public/ paths for static assets from src/web/public/.
- * In production, these paths are transformed to CDN URLs.
- *
- * This plugin:
- * 1. During build: Rewrites /public/* paths to CDN URLs
- * 2. During dev: Warns only about incorrect source paths (src/web/public/)
- *
- * Supported patterns (work in dev, rewritten to CDN in production):
- * - '/public/foo.svg'          → CDN URL (recommended)
- * - './public/foo.svg'         → CDN URL
- * - 'url(/public/foo.svg)'    → CDN URL (CSS unquoted)
- * - 'url(./public/foo.svg)'   → CDN URL (CSS unquoted)
- *
- * Incorrect patterns (warned in dev, rewritten in production):
- * - '/src/web/public/foo.svg'  → CDN URL
- * - './src/web/public/foo.svg' → CDN URL
- * - 'src/web/public/foo.svg'   → CDN URL
- */
-
-import type { Plugin } from 'vite';
-
-export interface PublicAssetPathPluginOptions {
-	/** Whether to show warnings in dev mode (default: true) */
-	warnInDev?: boolean;
-	/** CDN base URL for production builds (e.g., 'https://cdn.agentuity.com/{deploymentId}/client/') */
-	cdnBaseUrl?: string;
-}
-
-interface PathPattern {
-	regex: RegExp;
-	description: string;
-	/** Replacement template - use {base} for the target base URL */
-	replacement: string;
-}
-
-/**
- * Patterns that are incorrect - reference source paths directly
- */
-function createIncorrectPatterns(): PathPattern[] {
-	return [
-		// '/src/web/public/...' or './src/web/public/...' or 'src/web/public/...'
-		{
-			regex: /(['"`])(?:\.?\/)?src\/web\/public\//g,
-			description: 'src/web/public/',
-			replacement: '$1{base}',
-		},
-	];
-}
-
-/**
- * Patterns that need rewriting for production CDN
- * Both patterns simply replace the prefix while preserving the rest of the path naturally.
- */
-function createPublicPatterns(): PathPattern[] {
-	return [
-		// './public/...' (relative public path) - replace prefix, keep rest
-		{
-			regex: /(['"`])\.\/public\//g,
-			description: './public/',
-			replacement: '$1{base}',
-		},
-		// '/public/...' (absolute public path) - replace prefix, keep rest
-		{
-			regex: /(['"`])\/public\//g,
-			description: '/public/',
-			replacement: '$1{base}',
-		},
-		// CSS url(/public/...) — unquoted path inside url()
-		{
-			regex: /url\(\/public\//g,
-			description: 'url(/public/)',
-			replacement: 'url({base}',
-		},
-		// CSS url(./public/...) — unquoted relative path inside url()
-		{
-			regex: /url\(\.\/public\//g,
-			description: 'url(./public/)',
-			replacement: 'url({base}',
-		},
-	];
-}
-
-/**
- * Vite plugin that fixes public asset paths and rewrites to CDN URLs
- *
- * Rewrites all public asset paths to CDN URLs in production.
- *
- * @example
- * // In vite config:
- * plugins: [publicAssetPathPlugin({ cdnBaseUrl: 'https://cdn.example.com/deploy/client/' })]
- *
- * // In code, use /public/ paths:
- * <img src="/public/logo.svg" />
- *
- * // Transforms in production:
- * // '/public/logo.svg' → 'https://cdn.example.com/deploy/client/logo.svg'
- */
-export function publicAssetPathPlugin(options: PublicAssetPathPluginOptions = {}): Plugin {
-	const { warnInDev = true, cdnBaseUrl } = options;
-
-	let isDev = false;
-	const warnedFiles = new Map<string, Set<string>>(); // file -> set of patterns warned
-
-	return {
-		name: 'agentuity:public-asset-path',
-
-		configResolved(config) {
-			isDev = config.command === 'serve';
-		},
-
-		transform(code, id) {
-			// Only transform files in src/web (browser code)
-			if (!id.includes('/src/web/') && !id.includes('\\src\\web\\')) {
-				return null;
-			}
-
-			// Quick check: does the code contain any patterns we care about?
-			const hasIncorrectSourcePaths = code.includes('src/web/public/');
-			const hasPublicPaths = code.includes('/public/') || code.includes('./public/');
-
-			if (!hasIncorrectSourcePaths && !hasPublicPaths) {
-				return null;
-			}
-
-			// In dev mode, only warn about incorrect source paths (src/web/public/)
-			// /public/ and ./public/ paths work correctly in dev mode
-			if (isDev) {
-				if (warnInDev && hasIncorrectSourcePaths) {
-					const patterns = createIncorrectPatterns();
-					const foundPatterns: string[] = [];
-
-					for (const { regex, description } of patterns) {
-						if (regex.test(code)) {
-							foundPatterns.push(description);
-						}
-					}
-
-					if (foundPatterns.length > 0) {
-						const fileWarnings = warnedFiles.get(id) || new Set();
-						const newWarnings = foundPatterns.filter((p) => !fileWarnings.has(p));
-
-						if (newWarnings.length > 0) {
-							for (const p of newWarnings) {
-								fileWarnings.add(p);
-							}
-							warnedFiles.set(id, fileWarnings);
-
-							this.warn(
-								`Found incorrect asset path(s) in ${id}:\n` +
-									newWarnings.map((p) => `  - '${p}' should be '/public/'`).join('\n') +
-									`\nUse '/public/...' paths for static assets.`
-							);
-						}
-					}
-				}
-				// In dev mode, never transform - Vite serves from source paths
-				// and the Bun server proxies /public/* to Vite
-				return null;
-			}
-
-			// Build mode: transform paths to CDN URLs
-			let transformed = code;
-
-			// Determine target URL: CDN base if provided, otherwise /public/
-			const targetBase = cdnBaseUrl
-				? cdnBaseUrl.endsWith('/')
-					? cdnBaseUrl
-					: `${cdnBaseUrl}/`
-				: '/public/';
-
-			// Transform incorrect source paths (src/web/public/) → CDN
-			if (hasIncorrectSourcePaths) {
-				const patterns = createIncorrectPatterns();
-				for (const { regex, replacement } of patterns) {
-					const replaceRegex = new RegExp(regex.source, regex.flags);
-					transformed = transformed.replace(
-						replaceRegex,
-						replacement.replace('{base}', targetBase)
-					);
-				}
-			}
-
-			// Transform public paths → CDN
-			if (hasPublicPaths) {
-				const publicPatterns = createPublicPatterns();
-				for (const { regex, replacement } of publicPatterns) {
-					const replaceRegex = new RegExp(regex.source, regex.flags);
-					transformed = transformed.replace(
-						replaceRegex,
-						replacement.replace('{base}', targetBase)
-					);
-				}
-			}
-
-			// Return transformed code if changed
-			if (transformed !== code) {
-				return {
-					code: transformed,
-					map: null,
-				};
-			}
-
-			return null;
-		},
-	};
-}

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

@@ -1,271 +0,0 @@
-/**
- * Route Discovery — Explicit Routing Only
- *
- * 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 { createHash } from 'node:crypto';
-import type { Logger } from '../../../types';
-import { toForwardSlash } from '../../../utils/normalize-path';
-import { detectExplicitRouter, type AppRouterDetection } from '../app-router-detector';
-
-export interface RouteMetadata {
-	id: string;
-	filename: string;
-	path: string;
-	method: string;
-	version: string;
-	type: 'api' | 'sms' | 'email' | 'cron' | 'websocket' | 'sse' | 'stream';
-	agentIds?: string[];
-	config?: Record<string, unknown>;
-	schema?: {
-		input?: string;
-		output?: string;
-	};
-}
-
-/**
- * Extract path parameters from a route path.
- * Matches patterns like :id, :userId, :id?, *path, etc.
- */
-export function extractPathParams(path: string): string[] {
-	const params: string[] = [];
-	const parts = path.split('/');
-	for (const part of parts) {
-		if (part.startsWith(':')) {
-			params.push(part.replace(/^:|[?+*]$/g, ''));
-		} else if (part.startsWith('*') && part.length > 1) {
-			params.push(part.substring(1).replace(/[?+*]$/g, ''));
-		}
-	}
-	return params;
-}
-
-/**
- * Generate a deterministic route ID from project/deployment/type/method/filename/path/version.
- * Must match the format used by the platform (prefix: route_, SHA1 hash of all components).
- */
-export function generateRouteId(
-	projectId: string,
-	deploymentId: string,
-	type: string,
-	method: string,
-	filename: string,
-	path: string,
-	version: string
-): string {
-	const hasher = new Bun.CryptoHasher('sha1');
-	for (const val of [projectId, deploymentId, type, method, filename, path, version]) {
-		hasher.update(val);
-	}
-	return `route_${hasher.digest().toHex()}`;
-}
-
-/**
- * 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';
-	}
-}
-
-/**
- * Detect route type from handler metadata or method.
- * Checks for route-meta symbol stamped by handler wrappers (websocket, sse, stream, cron).
- */
-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;
-		}
-	}
-
-	// Heuristic: upgradeWebSocket handler has a specific name
-	if (typeof handler === 'function' && handler.name === 'upgradeWebSocket') {
-		return 'websocket';
-	}
-
-	return 'api';
-}
-
-/**
- * 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
- */
-export async function discoverRoutes(
-	srcDir: string,
-	projectId: string,
-	deploymentId: string,
-	logger: Logger
-): Promise<{
-	routes: RouteMetadata[];
-	explicitRouter?: AppRouterDetection;
-}> {
-	const rootDir = join(srcDir, '..');
-
-	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: [] };
-	}
-
-	logger.debug(
-		'Using explicit router detection (%d mount(s) from createApp)',
-		detection.mounts.length
-	);
-
-	const routes: RouteMetadata[] = [];
-
-	const seenRoutes = new Set<string>();
-
-	for (const mount of detection.mounts) {
-		try {
-			// 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 relFile = './' + toForwardSlash(relative(srcDir, mount.routerFile));
-			const version = await generateFileVersion(mount.routerFile);
-
-			// Filter to actual route handlers (not middleware — middleware uses '*' or ALL method)
-			const routeEntries = router.routes.filter(
-				(r: any) => r.method !== 'ALL' && r.path !== '*'
-			);
-
-			for (const route of routeEntries) {
-				const method = String(route.method).toLowerCase();
-				// 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.toUpperCase()} ${fullPath}`;
-				if (seenRoutes.has(routeKey)) continue;
-				seenRoutes.add(routeKey);
-
-				const routeType = detectRouteType(route.handler);
-				const rel = toForwardSlash(relative(rootDir, mount.routerFile));
-				const id = generateRouteId(
-					projectId,
-					deploymentId,
-					routeType,
-					method,
-					rel,
-					fullPath,
-					version
-				);
-
-				// Extract type-specific config from route metadata
-				const meta =
-					typeof route.handler === 'function'
-						? (route.handler as any)[Symbol.for('agentuity:route-meta')]
-						: undefined;
-				const config = meta?.schedule ? { expression: meta.schedule } : undefined;
-
-				routes.push({
-					id,
-					filename: toForwardSlash(relative(rootDir, mount.routerFile)),
-					path: fullPath,
-					method,
-					version,
-					type: routeType,
-					config,
-				});
-			}
-
-			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)
-			);
-		}
-	}
-
-	// Check for route conflicts
-	const conflicts = detectRouteConflicts(routes);
-	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.`
-		);
-	}
-
-	logger.debug('Discovered %d route(s) via explicit router detection', routes.length);
-	return { routes, explicitRouter: detection };
-}
-
-export interface RouteConflict {
-	type: 'duplicate';
-	routes: Array<{ method: string; path: string; filename: string }>;
-	message: string;
-}
-
-/**
- * Detect conflicts between routes.
- */
-export function detectRouteConflicts(
-	routes: Array<{ method: string; path: string; filename: string }>
-): RouteConflict[] {
-	const conflicts: RouteConflict[] = [];
-
-	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 });
-	}
-
-	for (const [methodPath, routeList] of methodPathMap.entries()) {
-		if (routeList.length > 1) {
-			const [method = 'UNKNOWN'] = 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`,
-			});
-		}
-	}
-
-	return conflicts;
-}