@agentuity/cli 1.0.59 → 2.0.0-beta.1

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

@@ -1,108 +1,76 @@
 /**
- * Config loader for agentuity.config.ts
+ * Config loader for v2
+ *
+ * In v2, all runtime config (analytics, workbench) goes in createApp().
+ * Vite-specific config (plugins, define, render, bundle) goes in vite.config.ts.
+ *
+ * Runtime config values are extracted from app.ts via app-config-extractor.
  */
 
-import { join } from 'node:path';
 import type { Logger } from '../../../types';
-import type { AgentuityConfig } from '../../../types';
+import { extractAppConfig, type ExtractedAppConfig } from '../app-config-extractor';
 
 /**
- * Load agentuity.config.ts from the project root
- * Returns null if the file doesn't exist or fails to load
+ * Load runtime config from createApp() in app.ts (v2 approach).
+ *
+ * This is the only way to get analytics/workbench config in v2.
+ * The CLI reads these values directly from the user's createApp() call.
  */
-export async function loadAgentuityConfig(
+export async function loadRuntimeConfig(
 	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;
-	}
+): Promise<ExtractedAppConfig> {
+	return extractAppConfig(rootDir, logger);
 }
 
 /**
- * Get workbench configuration with defaults
- * NOTE: Workbench is only enabled at runtime in dev mode, but we need to know
- * if it's configured at build time so we can generate the correct code.
+ * Get workbench configuration with defaults.
  *
- * Presence of workbench config implicitly enables it (no explicit 'enabled' flag needed)
- * Missing workbench config implicitly disables it
+ * In v2, workbench config is extracted from createApp() in app.ts.
  */
 export function getWorkbenchConfig(
-	config: AgentuityConfig | null,
-	dev: boolean
+	dev: boolean,
+	runtimeConfig?: ExtractedAppConfig
 ): {
 	configured: boolean;
 	enabled: boolean;
 	route: string;
 	headers: Record<string, string>;
 } {
-	const configured = config?.workbench !== undefined;
+	const workbenchFromRuntime = runtimeConfig?.workbench;
 
 	// Workbench is enabled if:
 	// 1. In dev mode (never in production)
-	// 2. Config has a workbench object (presence implies enablement)
-	const enabled = dev && configured;
+	// 2. Workbench is configured in createApp()
+	const hasWorkbench = workbenchFromRuntime !== undefined;
+	const configured = hasWorkbench;
+	const enabled = dev && hasWorkbench;
 
-	const workbench = config?.workbench || {};
+	// Extract values from createApp()
+	let route = '/workbench';
+	let headers: Record<string, string> = {};
+
+	if (workbenchFromRuntime !== undefined) {
+		if (typeof workbenchFromRuntime === 'string') {
+			route = workbenchFromRuntime;
+		} else if (typeof workbenchFromRuntime === 'object' && workbenchFromRuntime !== null) {
+			if ('route' in workbenchFromRuntime && typeof workbenchFromRuntime.route === 'string') {
+				route = workbenchFromRuntime.route;
+			}
+			if (
+				'headers' in workbenchFromRuntime &&
+				typeof workbenchFromRuntime.headers === 'object'
+			) {
+				headers = workbenchFromRuntime.headers as Record<string, string>;
+			}
+		}
+		// boolean true uses defaults
+	}
 
 	return {
 		configured,
 		enabled,
-		route: workbench.route ?? '/workbench',
-		headers: workbench.headers ?? {},
+		route,
+		headers,
 	};
 }
-
-/**
- * Known Vite framework plugin name prefixes.
- * Each framework's Vite plugin registers one or more plugins whose names
- * start with these prefixes. We match against these to detect whether the
- * user has already configured a framework plugin in their agentuity.config.ts.
- */
-const FRAMEWORK_PLUGIN_PREFIXES = [
-	'vite:react', // @vitejs/plugin-react  (vite:react-babel, vite:react-refresh, …)
-	'vite:preact', // @preact/preset-vite
-	'vite-plugin-svelte', // @sveltejs/vite-plugin-svelte
-	'vite:vue', // @vitejs/plugin-vue      (vite:vue, vite:vue-jsx)
-	'vite-plugin-solid', // vite-plugin-solid
-	'solid', // vite-plugin-solid also uses plain "solid"
-];
-
-/**
- * Check if the user's plugins include any known UI-framework Vite plugin
- * (React, Svelte, Vue, Solid, Preact, …).
- *
- * Detection is name-based: Vite plugins expose a `name` property and every
- * major framework plugin uses a predictable prefix. This avoids dynamically
- * importing every possible framework just to compare names.
- */
-export function hasFrameworkPlugin(userPlugins: import('vite').PluginOption[]): boolean {
-	const flat = (userPlugins as unknown[]).flat(Infinity).filter(Boolean);
-	return flat.some(
-		(p: unknown) =>
-			p &&
-			typeof p === 'object' &&
-			'name' in p &&
-			typeof (p as { name: unknown }).name === 'string' &&
-			FRAMEWORK_PLUGIN_PREFIXES.some((prefix) => (p as { name: string }).name.startsWith(prefix))
-	);
-}

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

@@ -18,7 +18,6 @@ This directory contains auto-generated TypeScript files created by the Agentuity
 ## Generated Files
 
 - \`registry.ts\` - Agent registry from \`src/agent/**\`
-- \`routes.ts\` - Route registry from \`src/api/**\`
 - \`app.ts\` - Application entry point
 - \`analytics-config.ts\` - Web analytics configuration from \`agentuity.json\`
 - \`webanalytics.ts\` - Web analytics injection and route registration
@@ -63,7 +62,6 @@ const AGENTS_MD_CONTENT = `# AI Agent Instructions
 ## What Gets Generated
 
 - \`registry.ts\` - Built from agent discovery in \`src/agent/\`
-- \`routes.ts\` - Built from route discovery in \`src/api/\`
 - \`app.ts\` - Entry point assembled from project configuration
 - \`analytics-config.ts\` - Web analytics configuration from \`agentuity.json\`
 - \`webanalytics.ts\` - Web analytics injection and route registration

package/src/cmd/build/vite/index.ts

@@ -3,13 +3,10 @@ import { join } from 'node:path';
 import { createLogger } from '@agentuity/server';
 import type { LogLevel, DeployOptions } from '../../../types';
 import { discoverAgents, type AgentMetadata } from './agent-discovery';
-import { discoverRoutes, type RouteMetadata, type RouteInfo } from './route-discovery';
-import { generateAgentRegistry, generateRouteRegistry } from './registry-generator';
+import { discoverRoutes, type RouteMetadata } from './route-discovery';
 import { generateLifecycleTypes } from './lifecycle-generator';
 import { generateEnvTypes } from './env-types-generator';
 import { generateMetadata, writeMetadataFile, generateRouteMapping } from './metadata-generator';
-import { generateEntryFile } from '../entry-generator';
-import { loadAgentuityConfig, getWorkbenchConfig } from './config-loader';
 
 // Re-export plugins
 export { browserEnvPlugin } from './browser-env-plugin';
@@ -59,7 +56,6 @@ export function agentuityPlugin(options: AgentuityPluginOptions): Plugin {
 	// Store discovered metadata
 	let agents: AgentMetadata[] = [];
 	let routes: RouteMetadata[] = [];
-	let routeInfoList: RouteInfo[] = [];
 
 	logger.trace('Initializing Agentuity Vite plugin', { dev, rootDir, projectId, deploymentId });
 
@@ -73,31 +69,12 @@ export function agentuityPlugin(options: AgentuityPluginOptions): Plugin {
 		async buildStart() {
 			logger.trace('buildStart: Discovering agents and routes');
 
-			// Load agentuity.config.ts for entry file generation
-			const config = await loadAgentuityConfig(rootDir, logger);
-			const workbenchConfig = getWorkbenchConfig(config, dev);
-
-			// Note: Workbench files are generated in runAllBuilds() BEFORE builds start (dev mode only)
-			// We just need the config here for entry file generation
-
 			// Discover agents (read-only)
 			agents = await discoverAgents(srcDir, projectId, deploymentId, logger);
 
 			// Discover routes (read-only)
 			const routeDiscovery = await discoverRoutes(srcDir, projectId, deploymentId, logger);
 			routes = routeDiscovery.routes;
-			routeInfoList = routeDiscovery.routeInfoList;
-
-			// Generate registries
-			if (agents.length > 0) {
-				generateAgentRegistry(srcDir, agents);
-				logger.trace('Generated agent registry with %d agent(s)', agents.length);
-			}
-
-			if (routeInfoList.length > 0) {
-				await generateRouteRegistry(srcDir, routeInfoList, agents);
-				logger.trace('Generated route registry with %d route(s)', routeInfoList.length);
-			}
 
 			// Generate lifecycle types
 			logger.debug('[vite-plugin] About to call generateLifecycleTypes');
@@ -115,17 +92,6 @@ export function agentuityPlugin(options: AgentuityPluginOptions): Plugin {
 			});
 			logger.debug(`[vite-plugin] generateEnvTypes returned: ${envTypesResult}`);
 
-			// Generate entry file (pass workbench and analytics config)
-			await generateEntryFile({
-				rootDir,
-				projectId,
-				deploymentId,
-				logger,
-				mode: dev ? 'dev' : 'prod',
-				workbench: workbenchConfig.configured ? workbenchConfig : undefined,
-				analytics: config?.analytics,
-			});
-
 			logger.trace('buildStart: Discovery complete');
 		},
 
@@ -137,9 +103,6 @@ export function agentuityPlugin(options: AgentuityPluginOptions): Plugin {
 			if (id === 'virtual:agentuity/agents') {
 				return '\0virtual:agentuity/agents';
 			}
-			if (id === 'virtual:agentuity/routes') {
-				return '\0virtual:agentuity/routes';
-			}
 			return null;
 		},
 
@@ -152,10 +115,6 @@ export function agentuityPlugin(options: AgentuityPluginOptions): Plugin {
 				// Re-export from generated registry
 				return `export { agentRegistry } from '../src/generated/registry.js';`;
 			}
-			if (id === '\0virtual:agentuity/routes') {
-				// Re-export from generated route registry
-				return `export { routeRegistry } from '../src/generated/routes.js';`;
-			}
 			return null;
 		},
 

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

@@ -1,15 +1,331 @@
 /**
  * Lifecycle Types Generator
  *
- * Generates src/generated/lifecycle.d.ts by analyzing app.ts for setup() function
+ * Generates src/generated/state.ts and src/generated/router.ts by analyzing
+ * app.ts for a setup() function.
+ *
+ * Uses TypeScript's type checker to extract the real return type of setup —
+ * no AST literal guessing needed.
  */
 
-import { join } from 'node:path';
-import { generateLifecycleTypes as generateLifecycleTypesFromAST } from '../ast';
+import ts from 'typescript';
+import { join, relative, dirname } from 'node:path';
+import { mkdirSync } from 'node:fs';
+import { StructuredError } from '@agentuity/core';
 import type { Logger } from '../../../types';
+import { toForwardSlash } from '../../../utils/normalize-path';
+
+const RuntimePackageNotFound = StructuredError('RuntimePackageNotFound');
+
+/**
+ * Use the TypeScript type checker to extract the return type of the setup
+ * function passed to createApp(). Works with inline setup, exported setup,
+ * variable references, async functions — anything TS can resolve.
+ */
+function extractSetupReturnType(appFilePath: string, logger: Logger): string | null {
+	const compilerOptions: ts.CompilerOptions = {
+		target: ts.ScriptTarget.ESNext,
+		module: ts.ModuleKind.ESNext,
+		moduleResolution: ts.ModuleResolutionKind.Bundler,
+		strict: true,
+		skipLibCheck: true,
+		noEmit: true,
+		allowJs: true,
+		esModuleInterop: true,
+	};
+
+	const program = ts.createProgram([appFilePath], compilerOptions);
+	const checker = program.getTypeChecker();
+	const sourceFile = program.getSourceFile(appFilePath);
+
+	if (!sourceFile) {
+		logger.debug('[lifecycle] Could not load source file');
+		return null;
+	}
+
+	let setupType: ts.Type | null = null;
+
+	function unwrapPromise(type: ts.Type): ts.Type {
+		// Check for Promise by looking at typeArguments on TypeReference
+		const typeRef = type as ts.TypeReference;
+		if (typeRef.typeArguments && typeRef.typeArguments.length > 0) {
+			const symbol = type.getSymbol() ?? type.aliasSymbol;
+			if (symbol?.name === 'Promise') {
+				return typeRef.typeArguments[0]!;
+			}
+		}
+		return type;
+	}
+
+	function extractFromProperty(prop: ts.ObjectLiteralElementLike): void {
+		if (setupType) return;
+
+		// Handle: setup: () => { ... }  or  setup: myFunc
+		if (
+			ts.isPropertyAssignment(prop) &&
+			ts.isIdentifier(prop.name) &&
+			prop.name.text === 'setup'
+		) {
+			const type = checker.getTypeAtLocation(prop.initializer);
+			const callSigs = type.getCallSignatures();
+			if (callSigs.length > 0) {
+				setupType = unwrapPromise(checker.getReturnTypeOfSignature(callSigs[0]!));
+			}
+			return;
+		}
+
+		// Handle shorthand: createApp({ setup })
+		if (ts.isShorthandPropertyAssignment(prop) && prop.name.text === 'setup') {
+			const type = checker.getTypeAtLocation(prop.name);
+			const callSigs = type.getCallSignatures();
+			if (callSigs.length > 0) {
+				setupType = unwrapPromise(checker.getReturnTypeOfSignature(callSigs[0]!));
+			}
+		}
+	}
+
+	function visit(node: ts.Node): void {
+		if (setupType) return;
+
+		// Find createApp(...) call — with or without await
+		let callExpr: ts.CallExpression | undefined;
+
+		if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+			if (node.expression.text === 'createApp') callExpr = node;
+		} else if (ts.isAwaitExpression(node) && ts.isCallExpression(node.expression)) {
+			const call = node.expression;
+			if (ts.isIdentifier(call.expression) && call.expression.text === 'createApp') {
+				callExpr = call;
+			}
+		}
+
+		if (callExpr && callExpr.arguments.length > 0) {
+			const configArg = callExpr.arguments[0];
+			if (configArg && ts.isObjectLiteralExpression(configArg)) {
+				for (const prop of configArg.properties) {
+					extractFromProperty(prop);
+					if (setupType) return;
+				}
+			}
+		}
+
+		ts.forEachChild(node, visit);
+	}
+
+	visit(sourceFile);
+
+	// Fallback: look for an exported function named `setup` in the file
+	// (user may define `export function setup()` without passing it to createApp)
+	if (!setupType) {
+		for (const stmt of sourceFile.statements) {
+			if (
+				ts.isFunctionDeclaration(stmt) &&
+				stmt.name?.text === 'setup' &&
+				stmt.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)
+			) {
+				const type = checker.getTypeAtLocation(stmt);
+				const callSigs = type.getCallSignatures();
+				if (callSigs.length > 0) {
+					setupType = unwrapPromise(checker.getReturnTypeOfSignature(callSigs[0]!));
+				}
+				break;
+			}
+
+			// Handle: export const setup = () => { ... }
+			if (
+				ts.isVariableStatement(stmt) &&
+				stmt.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)
+			) {
+				for (const decl of stmt.declarationList.declarations) {
+					if (ts.isIdentifier(decl.name) && decl.name.text === 'setup' && decl.initializer) {
+						const type = checker.getTypeAtLocation(decl.initializer);
+						const callSigs = type.getCallSignatures();
+						if (callSigs.length > 0) {
+							setupType = unwrapPromise(checker.getReturnTypeOfSignature(callSigs[0]!));
+						}
+						break;
+					}
+				}
+				if (setupType) break;
+			}
+		}
+	}
+
+	if (!setupType) {
+		return null;
+	}
+
+	// Print the type as a string — TS gives us the real resolved type
+	const typeString = checker.typeToString(
+		setupType,
+		undefined,
+		ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.MultilineObjectLiterals
+	);
+
+	return typeString;
+}
+
+/**
+ * Find the @agentuity/runtime package by walking up the directory tree.
+ */
+async function findRuntimePackage(rootDir: string, logger: Logger): Promise<string> {
+	let currentDir = rootDir;
+	const searchedPaths: string[] = [];
+
+	while (currentDir && currentDir !== '/' && currentDir !== '.') {
+		const candidatePath = join(currentDir, 'node_modules', '@agentuity', 'runtime');
+		searchedPaths.push(candidatePath);
+		if (await Bun.file(join(candidatePath, 'package.json')).exists()) {
+			logger.debug(`Found runtime package at: ${candidatePath}`);
+			return candidatePath;
+		}
+
+		const packagesPath = join(currentDir, 'packages', 'runtime');
+		searchedPaths.push(packagesPath);
+		if (await Bun.file(join(packagesPath, 'package.json')).exists()) {
+			logger.debug(`Found runtime package (source) at: ${packagesPath}`);
+			return packagesPath;
+		}
+
+		const parent = dirname(currentDir);
+		if (parent === currentDir) break;
+		currentDir = parent;
+	}
+
+	throw new RuntimePackageNotFound({
+		message:
+			`@agentuity/runtime package not found.\n` +
+			`Searched paths:\n${searchedPaths.map((p) => `  - ${p}`).join('\n')}\n` +
+			`Make sure dependencies are installed by running 'bun install' or 'npm install'`,
+	});
+}
+
+function generateStateContent(appStateType: string): string {
+	return `// @generated
+// AUTO-GENERATED from app.ts setup() return type
+// This file is auto-generated by the build tool - do not edit manually
 
 /**
- * Setup lifecycle types by analyzing app.ts for setup() function
+ * Application state type inferred from your createApp setup function.
+ * This type is automatically generated and available throughout your app via ctx.app.
+ *
+ * @example
+ * \`\`\`typescript
+ * // In your agents:
+ * const agent = createAgent({
+ *   handler: async (ctx, input) => {
+ *     // ctx.app is strongly typed as GeneratedAppState
+ *     const value = ctx.app; // All properties from your setup return value
+ *     return 'result';
+ *   }
+ * });
+ * \`\`\`
+ */
+export type GeneratedAppState = ${appStateType};
+
+// Augment the @agentuity/runtime module with AppState
+declare module '@agentuity/runtime' {
+	interface AppState extends GeneratedAppState {}
+}
+
+// FOUND AN ERROR IN THIS FILE?
+// Please file an issue at https://github.com/agentuity/sdk/issues
+// or if you know the fix please submit a PR!
+`;
+}
+
+function generateRouterWrapper(runtimeImportPath: string): string {
+	return `// @generated
+// AUTO-GENERATED runtime wrapper
+// This file is auto-generated by the build tool - do not edit manually
+
+// Import augmentations file (NOT type-only) to trigger module augmentation
+import type { GeneratedAppState } from './state';
+import './state';
+
+// Import from actual package location
+import { createRouter as baseCreateRouter, type Env } from '${runtimeImportPath}/src/index';
+import type { Hono } from 'hono';
+
+// Type aliases to avoid repeating the generic parameter
+type AppEnv = Env<GeneratedAppState>;
+type AppRouter = Hono<AppEnv>;
+
+/**
+ * Creates a Hono router with extended methods for Agentuity-specific routing patterns.
+ *
+ * @returns Extended Hono router with custom methods and app state typing
+ *
+ * @example
+ * \`\`\`typescript
+ * const router = createRouter();
+ * router.get('/hello', (c) => c.text('Hello!'));
+ * router.get('/db', (c) => {
+ *   const db = c.var.app; // Your app state from createApp setup
+ *   return c.json({ connected: true });
+ * });
+ * \`\`\`
+ */
+export function createRouter(): AppRouter {
+	return baseCreateRouter() as unknown as AppRouter;
+}
+
+// Re-export everything else
+export * from '${runtimeImportPath}/src/index';
+
+// FOUND AN ERROR IN THIS FILE?
+// Please file an issue at https://github.com/agentuity/sdk/issues
+// or if you know the fix please submit a PR!
+`;
+}
+
+async function updateTsconfigPathMapping(
+	rootDir: string,
+	shouldAdd: boolean,
+	logger: Logger
+): Promise<void> {
+	const tsconfigPath = join(rootDir, 'tsconfig.json');
+	if (!(await Bun.file(tsconfigPath).exists())) {
+		logger.debug('No tsconfig.json found, skipping path mapping update');
+		return;
+	}
+
+	try {
+		const tsconfigContent = await Bun.file(tsconfigPath).text();
+		const { parseJSONC } = await import('../../../utils/jsonc');
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		const tsconfig = parseJSONC(tsconfigContent) as any;
+		const before = JSON.stringify(tsconfig);
+
+		if (!tsconfig.compilerOptions) tsconfig.compilerOptions = {};
+		if (!tsconfig.compilerOptions.paths) tsconfig.compilerOptions.paths = {};
+
+		if (shouldAdd) {
+			tsconfig.compilerOptions.paths['@agentuity/runtime'] = ['./src/generated/router.ts'];
+			logger.debug('Added @agentuity/runtime path mapping to tsconfig.json');
+		} else {
+			if (tsconfig.compilerOptions.paths['@agentuity/runtime']) {
+				delete tsconfig.compilerOptions.paths['@agentuity/runtime'];
+				logger.debug('Removed @agentuity/runtime path mapping from tsconfig.json');
+			}
+			if (Object.keys(tsconfig.compilerOptions.paths).length === 0) {
+				delete tsconfig.compilerOptions.paths;
+			}
+		}
+
+		if (JSON.stringify(tsconfig) === before) return;
+		await Bun.write(tsconfigPath, JSON.stringify(tsconfig, null, '\t') + '\n');
+	} catch (error) {
+		logger.warn('Failed to update tsconfig.json:', error);
+	}
+}
+
+/**
+ * Setup lifecycle types by analyzing app.ts for setup() function.
+ *
+ * Uses TypeScript's type checker to extract the real return type — handles
+ * inline setup, exported setup, variable references, async functions, and
+ * any other pattern TS can resolve.
  */
 export async function generateLifecycleTypes(
 	rootDir: string,
@@ -17,11 +333,8 @@ export async function generateLifecycleTypes(
 	logger: Logger
 ): Promise<boolean> {
 	logger.debug('[lifecycle] Starting lifecycle type generation...');
-	logger.debug(`[lifecycle] rootDir: ${rootDir}`);
-	logger.debug(`[lifecycle] srcDir: ${srcDir}`);
 
 	const outDir = join(srcDir, 'generated');
-	logger.debug(`[lifecycle] outDir: ${outDir}`);
 
 	// Look for app.ts in both root and src directories
 	const rootAppFile = join(rootDir, 'app.ts');
@@ -30,28 +343,39 @@ export async function generateLifecycleTypes(
 	let appFile = '';
 	if (await Bun.file(rootAppFile).exists()) {
 		appFile = rootAppFile;
-		logger.debug(`[lifecycle] Found app.ts at root: ${rootAppFile}`);
 	} else if (await Bun.file(srcAppFile).exists()) {
 		appFile = srcAppFile;
-		logger.debug(`[lifecycle] Found app.ts in src: ${srcAppFile}`);
 	}
 
 	if (!appFile || !(await Bun.file(appFile).exists())) {
-		logger.debug('[lifecycle] No app.ts found for lifecycle types generation');
+		logger.debug('[lifecycle] No app.ts found');
 		return false;
 	}
 
-	try {
-		logger.debug(`[lifecycle] Calling generateLifecycleTypesFromAST...`);
-		const result = await generateLifecycleTypesFromAST(rootDir, outDir, appFile);
-		if (result) {
-			logger.debug(`[lifecycle] Lifecycle types generated successfully in ${outDir}`);
-		} else {
-			logger.debug('[lifecycle] generateLifecycleTypesFromAST returned false (no setup found)');
-		}
-		return result;
-	} catch (error) {
-		logger.error('[lifecycle] Failed to generate lifecycle types:', error);
+	// Use TypeScript type checker to extract the setup return type
+	const appStateType = extractSetupReturnType(appFile, logger);
+
+	if (!appStateType) {
+		logger.debug('[lifecycle] No setup() function found in createApp');
+		await updateTsconfigPathMapping(rootDir, false, logger);
 		return false;
 	}
+
+	logger.debug(`[lifecycle] Extracted setup return type: ${appStateType}`);
+
+	// Generate files
+	mkdirSync(outDir, { recursive: true });
+
+	const runtimePkgPath = await findRuntimePackage(rootDir, logger);
+	const runtimeImportPath = toForwardSlash(relative(outDir, runtimePkgPath));
+
+	await Bun.write(join(outDir, 'state.ts'), generateStateContent(appStateType));
+	logger.debug(`Generated lifecycle types: ${join(outDir, 'state.ts')}`);
+
+	await Bun.write(join(outDir, 'router.ts'), generateRouterWrapper(runtimeImportPath));
+	logger.debug(`Generated lifecycle wrapper: ${join(outDir, 'router.ts')}`);
+
+	await updateTsconfigPathMapping(rootDir, true, logger);
+
+	return true;
 }