@geekmidas/cli 0.6.2 → 0.8.0

package/dist/index.mjs

@@ -1,37 +1,25 @@
 #!/usr/bin/env -S npx tsx
-import "./config-Bq72aj8e.mjs";
-import "./providerResolver-DEVKngbC.mjs";
-import "./Generator-CDt4pB3W.mjs";
-import "./CronGenerator-CCRYptuT.mjs";
-import "./EndpointGenerator-DGivkPLT.mjs";
-import "./FunctionGenerator-CVk0h8tO.mjs";
-import "./SubscriberGenerator-DABaJXML.mjs";
-import "./generators-FNpdfN6J.mjs";
-import "./OpenApiTsGenerator-BVS4pOH7.mjs";
-import { openapiCommand } from "./openapi-DA9RkPJl.mjs";
-import { devCommand } from "./dev-BBPWSllq.mjs";
-import "./manifests-BNKG6AXf.mjs";
-import { buildCommand } from "./build-Cu6Mi0Lf.mjs";
-import "./config-UCK12Lrr.mjs";
-import "./docker-31GNwU3F.mjs";
-import "./env-DEeVOvVu.mjs";
-import "./models-BWlDfviw.mjs";
-import "./monorepo-BBOWhkcd.mjs";
-import "./api-Bp5TIl1R.mjs";
-import "./minimal-BkyASH_C.mjs";
-import "./serverless-D5HjJByU.mjs";
-import "./worker-CiP420As.mjs";
-import "./templates-C0EMmhwb.mjs";
-import "./package-C3If80n1.mjs";
-import "./source-CkQHBpwu.mjs";
-import "./utils-CKEzCxc1.mjs";
-import { initCommand } from "./init-BMA7xi8r.mjs";
-import { generateReactQueryCommand } from "./openapi-react-query-_-B3s8v_.mjs";
+import { loadConfig, parseModuleConfig } from "./config-Bq72aj8e.mjs";
+import { ConstructGenerator, EndpointGenerator, OPENAPI_OUTPUT_PATH, generateOpenApi, openapiCommand, resolveOpenApiConfig } from "./openapi--vOy9mo4.mjs";
+import { generateReactQueryCommand } from "./openapi-react-query-CcciaVu5.mjs";
+import { join, relative } from "path";
 import { Command } from "commander";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join as join$1, relative as relative$1, resolve } from "node:path";
+import { execSync, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createServer } from "node:net";
+import chokidar from "chokidar";
+import { config } from "dotenv";
+import fg from "fast-glob";
+import { Cron } from "@geekmidas/constructs/crons";
+import { Function } from "@geekmidas/constructs/functions";
+import { Subscriber } from "@geekmidas/constructs/subscribers";
+import prompts from "prompts";
 
 //#region package.json
 var name = "@geekmidas/cli";
-var version = "0.6.2";
+var version = "0.8.0";
 var description = "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs";
 var private$1 = false;
 var type = "module";
@@ -111,6 +99,2567 @@ var package_default = {
 	peerDependenciesMeta
 };
 
+//#endregion
+//#region src/build/providerResolver.ts
+/**
+* Resolves provider configuration from the new simplified system
+* to the internal legacy format for backward compatibility
+*/
+function resolveProviders(config$1, options) {
+	const providers = [];
+	let enableOpenApi = options.enableOpenApi || false;
+	if (options.providers) return {
+		providers: options.providers,
+		enableOpenApi
+	};
+	if (options.provider) {
+		const resolvedProviders = resolveMainProvider(options.provider, config$1.providers);
+		providers.push(...resolvedProviders.providers);
+		enableOpenApi = resolvedProviders.enableOpenApi || enableOpenApi;
+	} else if (config$1.providers) {
+		const resolvedProviders = resolveAllConfiguredProviders(config$1.providers);
+		providers.push(...resolvedProviders.providers);
+		enableOpenApi = resolvedProviders.enableOpenApi || enableOpenApi;
+	} else providers.push("aws-apigatewayv2", "aws-lambda");
+	return {
+		providers: [...new Set(providers)],
+		enableOpenApi
+	};
+}
+function resolveMainProvider(mainProvider, providersConfig) {
+	const providers = [];
+	let enableOpenApi = false;
+	if (mainProvider === "aws") {
+		const awsConfig = providersConfig?.aws;
+		if (awsConfig?.apiGateway) {
+			if (isEnabled(awsConfig.apiGateway.v1)) providers.push("aws-apigatewayv1");
+			if (isEnabled(awsConfig.apiGateway.v2)) providers.push("aws-apigatewayv2");
+		} else providers.push("aws-apigatewayv2");
+		if (awsConfig?.lambda) {
+			if (isEnabled(awsConfig.lambda.functions) || isEnabled(awsConfig.lambda.crons)) providers.push("aws-lambda");
+		} else providers.push("aws-lambda");
+	} else if (mainProvider === "server") {
+		providers.push("server");
+		const serverConfig = providersConfig?.server;
+		if (typeof serverConfig === "object" && serverConfig?.enableOpenApi) enableOpenApi = true;
+	}
+	return {
+		providers,
+		enableOpenApi
+	};
+}
+function resolveAllConfiguredProviders(providersConfig) {
+	const providers = [];
+	let enableOpenApi = false;
+	if (providersConfig.aws) {
+		const awsProviders = resolveMainProvider("aws", providersConfig);
+		providers.push(...awsProviders.providers);
+	}
+	if (providersConfig.server && isEnabled(providersConfig.server)) {
+		providers.push("server");
+		if (typeof providersConfig.server === "object" && providersConfig.server.enableOpenApi) enableOpenApi = true;
+	}
+	return {
+		providers,
+		enableOpenApi
+	};
+}
+function isEnabled(config$1) {
+	if (config$1 === void 0) return false;
+	if (typeof config$1 === "boolean") return config$1;
+	return config$1.enabled !== false;
+}
+
+//#endregion
+//#region src/generators/CronGenerator.ts
+var CronGenerator = class extends ConstructGenerator {
+	async build(context, constructs, outputDir, options) {
+		const provider = options?.provider || "aws-lambda";
+		const logger$3 = console;
+		const cronInfos = [];
+		if (constructs.length === 0 || provider !== "aws-lambda") return cronInfos;
+		const cronsDir = join$1(outputDir, "crons");
+		await mkdir(cronsDir, { recursive: true });
+		for (const { key, construct, path } of constructs) {
+			const handlerFile = await this.generateCronHandler(cronsDir, path.relative, key, context);
+			cronInfos.push({
+				name: key,
+				handler: relative$1(process.cwd(), handlerFile).replace(/\.ts$/, ".handler"),
+				schedule: construct.schedule || "rate(1 hour)",
+				timeout: construct.timeout,
+				memorySize: construct.memorySize,
+				environment: await construct.getEnvironment()
+			});
+			logger$3.log(`Generated cron handler: ${key}`);
+		}
+		return cronInfos;
+	}
+	isConstruct(value) {
+		return Cron.isCron(value);
+	}
+	async generateCronHandler(outputDir, sourceFile, exportName, context) {
+		const handlerFileName = `${exportName}.ts`;
+		const handlerPath = join$1(outputDir, handlerFileName);
+		const relativePath = relative$1(dirname(handlerPath), sourceFile);
+		const importPath = relativePath.replace(/\.ts$/, ".js");
+		const relativeEnvParserPath = relative$1(dirname(handlerPath), context.envParserPath);
+		const relativeLoggerPath = relative$1(dirname(handlerPath), context.loggerPath);
+		const content = `import { AWSScheduledFunction } from '@geekmidas/constructs/crons';
+import { ${exportName} } from '${importPath}';
+import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
+import ${context.loggerImportPattern} from '${relativeLoggerPath}';
+
+const adapter = new AWSScheduledFunction(envParser, ${exportName});
+
+export const handler = adapter.handler;
+`;
+		await writeFile(handlerPath, content);
+		return handlerPath;
+	}
+};
+
+//#endregion
+//#region src/generators/FunctionGenerator.ts
+var FunctionGenerator = class extends ConstructGenerator {
+	isConstruct(value) {
+		return Function.isFunction(value);
+	}
+	async build(context, constructs, outputDir, options) {
+		const provider = options?.provider || "aws-lambda";
+		const logger$3 = console;
+		const functionInfos = [];
+		if (constructs.length === 0 || provider !== "aws-lambda") return functionInfos;
+		const functionsDir = join$1(outputDir, "functions");
+		await mkdir(functionsDir, { recursive: true });
+		for (const { key, construct, path } of constructs) {
+			const handlerFile = await this.generateFunctionHandler(functionsDir, path.relative, key, context);
+			functionInfos.push({
+				name: key,
+				handler: relative$1(process.cwd(), handlerFile).replace(/\.ts$/, ".handler"),
+				timeout: construct.timeout,
+				memorySize: construct.memorySize,
+				environment: await construct.getEnvironment()
+			});
+			logger$3.log(`Generated function handler: ${key}`);
+		}
+		return functionInfos;
+	}
+	async generateFunctionHandler(outputDir, sourceFile, exportName, context) {
+		const handlerFileName = `${exportName}.ts`;
+		const handlerPath = join$1(outputDir, handlerFileName);
+		const relativePath = relative$1(dirname(handlerPath), sourceFile);
+		const importPath = relativePath.replace(/\.ts$/, ".js");
+		const relativeEnvParserPath = relative$1(dirname(handlerPath), context.envParserPath);
+		const relativeLoggerPath = relative$1(dirname(handlerPath), context.loggerPath);
+		const content = `import { AWSLambdaFunction } from '@geekmidas/constructs/functions';
+import { ${exportName} } from '${importPath}';
+import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
+import ${context.loggerImportPattern} from '${relativeLoggerPath}';
+
+const adapter = new AWSLambdaFunction(envParser, ${exportName});
+
+export const handler = adapter.handler;
+`;
+		await writeFile(handlerPath, content);
+		return handlerPath;
+	}
+};
+
+//#endregion
+//#region src/generators/SubscriberGenerator.ts
+var SubscriberGenerator = class extends ConstructGenerator {
+	isConstruct(value) {
+		return Subscriber.isSubscriber(value);
+	}
+	async build(context, constructs, outputDir, options) {
+		const provider = options?.provider || "aws-lambda";
+		const logger$3 = console;
+		const subscriberInfos = [];
+		if (provider === "server") {
+			await this.generateServerSubscribersFile(outputDir, constructs);
+			logger$3.log(`Generated server subscribers file with ${constructs.length} subscribers (polling mode)`);
+			return subscriberInfos;
+		}
+		if (constructs.length === 0) return subscriberInfos;
+		if (provider !== "aws-lambda") return subscriberInfos;
+		const subscribersDir = join$1(outputDir, "subscribers");
+		await mkdir(subscribersDir, { recursive: true });
+		for (const { key, construct, path } of constructs) {
+			const handlerFile = await this.generateSubscriberHandler(subscribersDir, path.relative, key, construct, context);
+			subscriberInfos.push({
+				name: key,
+				handler: relative$1(process.cwd(), handlerFile).replace(/\.ts$/, ".handler"),
+				subscribedEvents: construct.subscribedEvents || [],
+				timeout: construct.timeout,
+				memorySize: construct.memorySize,
+				environment: await construct.getEnvironment()
+			});
+			logger$3.log(`Generated subscriber handler: ${key}`);
+		}
+		return subscriberInfos;
+	}
+	async generateSubscriberHandler(outputDir, sourceFile, exportName, _subscriber, context) {
+		const handlerFileName = `${exportName}.ts`;
+		const handlerPath = join$1(outputDir, handlerFileName);
+		const relativePath = relative$1(dirname(handlerPath), sourceFile);
+		const importPath = relativePath.replace(/\.ts$/, ".js");
+		const relativeEnvParserPath = relative$1(dirname(handlerPath), context.envParserPath);
+		const content = `import { AWSLambdaSubscriber } from '@geekmidas/constructs/aws';
+import { ${exportName} } from '${importPath}';
+import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
+
+const adapter = new AWSLambdaSubscriber(envParser, ${exportName});
+
+export const handler = adapter.handler;
+`;
+		await writeFile(handlerPath, content);
+		return handlerPath;
+	}
+	async generateServerSubscribersFile(outputDir, subscribers) {
+		await mkdir(outputDir, { recursive: true });
+		const subscribersFileName = "subscribers.ts";
+		const subscribersPath = join$1(outputDir, subscribersFileName);
+		const importsByFile = /* @__PURE__ */ new Map();
+		for (const { path, key } of subscribers) {
+			const relativePath = relative$1(dirname(subscribersPath), path.relative);
+			const importPath = relativePath.replace(/\.ts$/, ".js");
+			if (!importsByFile.has(importPath)) importsByFile.set(importPath, []);
+			importsByFile.get(importPath).push(key);
+		}
+		const imports = Array.from(importsByFile.entries()).map(([importPath, exports$1]) => `import { ${exports$1.join(", ")} } from '${importPath}';`).join("\n");
+		const allExportNames = subscribers.map(({ key }) => key);
+		const content = `/**
+ * Generated subscribers setup
+ *
+ * ⚠️  WARNING: This is for LOCAL DEVELOPMENT ONLY
+ * This uses event polling which is not suitable for production.
+ *
+ * For production, use AWS Lambda with SQS/SNS event source mappings.
+ * Lambda automatically:
+ * - Scales based on queue depth
+ * - Handles batch processing and retries
+ * - Manages dead letter queues
+ * - Provides better cost optimization
+ *
+ * This polling implementation is useful for:
+ * - Local development and testing
+ * - Understanding event flow without Lambda deployment
+ *
+ * Supported connection strings:
+ * - sqs://region/account-id/queue-name (SQS queue)
+ * - sns://region/account-id/topic-name (SNS topic)
+ * - rabbitmq://host:port/queue-name (RabbitMQ)
+ * - basic://in-memory (In-memory for testing)
+ */
+import type { EnvironmentParser } from '@geekmidas/envkit';
+import type { Logger } from '@geekmidas/logger';
+import { EventConnectionFactory, Subscriber } from '@geekmidas/events';
+import type { EventConnection, EventSubscriber } from '@geekmidas/events';
+import { ServiceDiscovery } from '@geekmidas/services';
+${imports}
+
+const subscribers = [
+  ${allExportNames.join(",\n  ")}
+];
+
+const activeSubscribers: EventSubscriber<any>[] = [];
+
+export async function setupSubscribers(
+  envParser: EnvironmentParser<any>,
+  logger: Logger,
+): Promise<void> {
+  logger.info('Setting up subscribers in polling mode (local development)');
+
+  const config = envParser.create((get) => ({
+    connectionString: get('EVENT_SUBSCRIBER_CONNECTION_STRING').string().optional(),
+  })).parse();
+
+  if (!config.connectionString) {
+    logger.warn('EVENT_SUBSCRIBER_CONNECTION_STRING not configured, skipping subscriber setup');
+    return;
+  }
+
+  const serviceDiscovery = ServiceDiscovery.getInstance(logger, envParser);
+
+  // Create connection once, outside the loop (more efficient)
+  // EventConnectionFactory automatically determines the right connection type
+  let connection: EventConnection;
+  try {
+    connection = await EventConnectionFactory.fromConnectionString(config.connectionString);
+
+    const connectionType = new URL(config.connectionString).protocol.replace(':', '');
+    logger.info({ connectionType }, 'Created shared event connection');
+  } catch (error) {
+    logger.error({ error }, 'Failed to create event connection');
+    return;
+  }
+
+  for (const subscriber of subscribers) {
+    try {
+      // Create subscriber from shared connection
+      const eventSubscriber = await Subscriber.fromConnection(connection);
+
+      // Register services
+      const services = subscriber.services.length > 0
+        ? await serviceDiscovery.register(subscriber.services)
+        : {};
+
+      // Subscribe to events
+      const subscribedEvents = subscriber.subscribedEvents || [];
+
+      if (subscribedEvents.length === 0) {
+        logger.warn({ subscriber: subscriber.constructor.name }, 'Subscriber has no subscribed events, skipping');
+        continue;
+      }
+
+      await eventSubscriber.subscribe(subscribedEvents, async (event) => {
+        try {
+          // Process single event (batch of 1)
+          await subscriber.handler({
+            events: [event],
+            services: services as any,
+            logger: subscriber.logger,
+          });
+
+          logger.debug({ eventType: event.type }, 'Successfully processed event');
+        } catch (error) {
+          logger.error({ error, event }, 'Failed to process event');
+          // Event will become visible again for retry
+        }
+      });
+
+      activeSubscribers.push(eventSubscriber);
+
+      logger.info(
+        {
+          events: subscribedEvents,
+        },
+        'Subscriber started polling'
+      );
+    } catch (error) {
+      logger.error({ error, subscriber: subscriber.constructor.name }, 'Failed to setup subscriber');
+    }
+  }
+
+  // Setup graceful shutdown
+  const shutdown = () => {
+    logger.info('Stopping all subscribers');
+    for (const eventSubscriber of activeSubscribers) {
+      connection.stop();
+    }
+  };
+
+  process.on('SIGTERM', shutdown);
+  process.on('SIGINT', shutdown);
+}
+`;
+		await writeFile(subscribersPath, content);
+		return subscribersPath;
+	}
+};
+
+//#endregion
+//#region src/dev/index.ts
+const logger$2 = console;
+/**
+* Load environment files
+* @internal Exported for testing
+*/
+function loadEnvFiles(envConfig, cwd = process.cwd()) {
+	const loaded = [];
+	const missing = [];
+	const envFiles = envConfig ? Array.isArray(envConfig) ? envConfig : [envConfig] : [".env"];
+	for (const envFile of envFiles) {
+		const envPath = resolve(cwd, envFile);
+		if (existsSync(envPath)) {
+			config({
+				path: envPath,
+				override: true,
+				quiet: true
+			});
+			loaded.push(envFile);
+		} else if (envConfig) missing.push(envFile);
+	}
+	return {
+		loaded,
+		missing
+	};
+}
+/**
+* Check if a port is available
+* @internal Exported for testing
+*/
+async function isPortAvailable(port) {
+	return new Promise((resolve$1) => {
+		const server = createServer();
+		server.once("error", (err) => {
+			if (err.code === "EADDRINUSE") resolve$1(false);
+			else resolve$1(false);
+		});
+		server.once("listening", () => {
+			server.close();
+			resolve$1(true);
+		});
+		server.listen(port);
+	});
+}
+/**
+* Find an available port starting from the preferred port
+* @internal Exported for testing
+*/
+async function findAvailablePort(preferredPort, maxAttempts = 10) {
+	for (let i = 0; i < maxAttempts; i++) {
+		const port = preferredPort + i;
+		if (await isPortAvailable(port)) return port;
+		logger$2.log(`⚠️  Port ${port} is in use, trying ${port + 1}...`);
+	}
+	throw new Error(`Could not find an available port after trying ${maxAttempts} ports starting from ${preferredPort}`);
+}
+/**
+* Normalize telescope configuration
+* @internal Exported for testing
+*/
+function normalizeTelescopeConfig(config$1) {
+	if (config$1 === false) return void 0;
+	if (typeof config$1 === "string") {
+		const { path: telescopePath, importPattern: telescopeImportPattern } = parseModuleConfig(config$1, "telescope");
+		return {
+			enabled: true,
+			telescopePath,
+			telescopeImportPattern,
+			path: "/__telescope",
+			ignore: [],
+			recordBody: true,
+			maxEntries: 1e3,
+			websocket: true
+		};
+	}
+	const isEnabled$1 = config$1 === true || config$1 === void 0 || config$1.enabled !== false;
+	if (!isEnabled$1) return void 0;
+	const telescopeConfig = typeof config$1 === "object" ? config$1 : {};
+	return {
+		enabled: true,
+		path: telescopeConfig.path ?? "/__telescope",
+		ignore: telescopeConfig.ignore ?? [],
+		recordBody: telescopeConfig.recordBody ?? true,
+		maxEntries: telescopeConfig.maxEntries ?? 1e3,
+		websocket: telescopeConfig.websocket ?? true
+	};
+}
+/**
+* Normalize studio configuration
+* @internal Exported for testing
+*/
+function normalizeStudioConfig(config$1) {
+	if (config$1 === false) return void 0;
+	if (typeof config$1 === "string") {
+		const { path: studioPath, importPattern: studioImportPattern } = parseModuleConfig(config$1, "studio");
+		return {
+			enabled: true,
+			studioPath,
+			studioImportPattern,
+			path: "/__studio",
+			schema: "public"
+		};
+	}
+	const isEnabled$1 = config$1 === true || config$1 === void 0 || config$1.enabled !== false;
+	if (!isEnabled$1) return void 0;
+	const studioConfig = typeof config$1 === "object" ? config$1 : {};
+	return {
+		enabled: true,
+		path: studioConfig.path ?? "/__studio",
+		schema: studioConfig.schema ?? "public"
+	};
+}
+/**
+* Normalize hooks configuration
+* @internal Exported for testing
+*/
+function normalizeHooksConfig(config$1) {
+	if (!config$1?.server) return void 0;
+	const serverPath = config$1.server.endsWith(".ts") ? config$1.server : `${config$1.server}.ts`;
+	const resolvedPath = resolve(process.cwd(), serverPath);
+	return { serverHooksPath: resolvedPath };
+}
+async function devCommand(options) {
+	const defaultEnv = loadEnvFiles(".env");
+	if (defaultEnv.loaded.length > 0) logger$2.log(`📦 Loaded env: ${defaultEnv.loaded.join(", ")}`);
+	const config$1 = await loadConfig();
+	if (config$1.env) {
+		const { loaded, missing } = loadEnvFiles(config$1.env);
+		if (loaded.length > 0) logger$2.log(`📦 Loaded env: ${loaded.join(", ")}`);
+		if (missing.length > 0) logger$2.warn(`⚠️  Missing env files: ${missing.join(", ")}`);
+	}
+	const resolved = resolveProviders(config$1, { provider: "server" });
+	logger$2.log("🚀 Starting development server...");
+	logger$2.log(`Loading routes from: ${config$1.routes}`);
+	if (config$1.functions) logger$2.log(`Loading functions from: ${config$1.functions}`);
+	if (config$1.crons) logger$2.log(`Loading crons from: ${config$1.crons}`);
+	if (config$1.subscribers) logger$2.log(`Loading subscribers from: ${config$1.subscribers}`);
+	logger$2.log(`Using envParser: ${config$1.envParser}`);
+	const { path: envParserPath, importPattern: envParserImportPattern } = parseModuleConfig(config$1.envParser, "envParser");
+	const { path: loggerPath, importPattern: loggerImportPattern } = parseModuleConfig(config$1.logger, "logger");
+	const telescope = normalizeTelescopeConfig(config$1.telescope);
+	if (telescope) logger$2.log(`🔭 Telescope enabled at ${telescope.path}`);
+	const studio = normalizeStudioConfig(config$1.studio);
+	if (studio) logger$2.log(`🗄️  Studio enabled at ${studio.path}`);
+	const hooks = normalizeHooksConfig(config$1.hooks);
+	if (hooks) logger$2.log(`🪝 Server hooks enabled from ${config$1.hooks?.server}`);
+	const openApiConfig = resolveOpenApiConfig(config$1);
+	const enableOpenApi = openApiConfig.enabled || resolved.enableOpenApi;
+	if (enableOpenApi) logger$2.log(`📄 OpenAPI output: ${OPENAPI_OUTPUT_PATH}`);
+	const buildContext = {
+		envParserPath,
+		envParserImportPattern,
+		loggerPath,
+		loggerImportPattern,
+		telescope,
+		studio,
+		hooks
+	};
+	await buildServer(config$1, buildContext, resolved.providers[0], enableOpenApi);
+	if (enableOpenApi) await generateOpenApi(config$1);
+	const runtime = config$1.runtime ?? "node";
+	const devServer = new DevServer(resolved.providers[0], options.port || 3e3, enableOpenApi, telescope, studio, runtime);
+	await devServer.start();
+	const envParserFile = config$1.envParser.split("#")[0];
+	const loggerFile = config$1.logger.split("#")[0];
+	const hooksFile = config$1.hooks?.server?.split("#")[0];
+	const watchPatterns = [
+		config$1.routes,
+		...config$1.functions ? [config$1.functions] : [],
+		...config$1.crons ? [config$1.crons] : [],
+		...config$1.subscribers ? [config$1.subscribers] : [],
+		envParserFile.endsWith(".ts") ? envParserFile : `${envParserFile}.ts`,
+		loggerFile.endsWith(".ts") ? loggerFile : `${loggerFile}.ts`,
+		...hooksFile ? [hooksFile.endsWith(".ts") ? hooksFile : `${hooksFile}.ts`] : []
+	].flat();
+	const normalizedPatterns = watchPatterns.map((p) => p.startsWith("./") ? p.slice(2) : p);
+	logger$2.log(`👀 Watching for changes in: ${normalizedPatterns.join(", ")}`);
+	const resolvedFiles = await fg(normalizedPatterns, {
+		cwd: process.cwd(),
+		absolute: false,
+		onlyFiles: true
+	});
+	const dirsToWatch = [...new Set(resolvedFiles.map((f) => f.split("/").slice(0, -1).join("/")))];
+	logger$2.log(`📁 Found ${resolvedFiles.length} files in ${dirsToWatch.length} directories`);
+	const watcher = chokidar.watch([...resolvedFiles, ...dirsToWatch], {
+		ignored: /(^|[\/\\])\../,
+		persistent: true,
+		ignoreInitial: true,
+		cwd: process.cwd()
+	});
+	watcher.on("ready", () => {
+		logger$2.log("🔍 File watcher ready");
+	});
+	watcher.on("error", (error) => {
+		logger$2.error("❌ Watcher error:", error);
+	});
+	let rebuildTimeout = null;
+	watcher.on("change", async (path) => {
+		logger$2.log(`📝 File changed: ${path}`);
+		if (rebuildTimeout) clearTimeout(rebuildTimeout);
+		rebuildTimeout = setTimeout(async () => {
+			try {
+				logger$2.log("🔄 Rebuilding...");
+				await buildServer(config$1, buildContext, resolved.providers[0], enableOpenApi);
+				if (enableOpenApi) await generateOpenApi(config$1, { silent: true });
+				logger$2.log("✅ Rebuild complete, restarting server...");
+				await devServer.restart();
+			} catch (error) {
+				logger$2.error("❌ Rebuild failed:", error.message);
+			}
+		}, 300);
+	});
+	let isShuttingDown = false;
+	const shutdown = () => {
+		if (isShuttingDown) return;
+		isShuttingDown = true;
+		logger$2.log("\n🛑 Shutting down...");
+		Promise.all([watcher.close(), devServer.stop()]).catch((err) => {
+			logger$2.error("Error during shutdown:", err);
+		}).finally(() => {
+			process.exit(0);
+		});
+	};
+	process.on("SIGINT", shutdown);
+	process.on("SIGTERM", shutdown);
+}
+async function buildServer(config$1, context, provider, enableOpenApi) {
+	const endpointGenerator = new EndpointGenerator();
+	const functionGenerator = new FunctionGenerator();
+	const cronGenerator = new CronGenerator();
+	const subscriberGenerator = new SubscriberGenerator();
+	const [allEndpoints, allFunctions, allCrons, allSubscribers] = await Promise.all([
+		endpointGenerator.load(config$1.routes),
+		config$1.functions ? functionGenerator.load(config$1.functions) : [],
+		config$1.crons ? cronGenerator.load(config$1.crons) : [],
+		config$1.subscribers ? subscriberGenerator.load(config$1.subscribers) : []
+	]);
+	const outputDir = join$1(process.cwd(), ".gkm", provider);
+	await mkdir(outputDir, { recursive: true });
+	await Promise.all([
+		endpointGenerator.build(context, allEndpoints, outputDir, {
+			provider,
+			enableOpenApi
+		}),
+		functionGenerator.build(context, allFunctions, outputDir, { provider }),
+		cronGenerator.build(context, allCrons, outputDir, { provider }),
+		subscriberGenerator.build(context, allSubscribers, outputDir, { provider })
+	]);
+}
+var DevServer = class {
+	serverProcess = null;
+	isRunning = false;
+	actualPort;
+	constructor(provider, requestedPort, enableOpenApi, telescope, studio, runtime = "node") {
+		this.provider = provider;
+		this.requestedPort = requestedPort;
+		this.enableOpenApi = enableOpenApi;
+		this.telescope = telescope;
+		this.studio = studio;
+		this.runtime = runtime;
+		this.actualPort = requestedPort;
+	}
+	async start() {
+		if (this.isRunning) await this.stop();
+		this.actualPort = await findAvailablePort(this.requestedPort);
+		if (this.actualPort !== this.requestedPort) logger$2.log(`ℹ️  Port ${this.requestedPort} was in use, using port ${this.actualPort} instead`);
+		const serverEntryPath = join$1(process.cwd(), ".gkm", this.provider, "server.ts");
+		await this.createServerEntry();
+		logger$2.log(`\n✨ Starting server on port ${this.actualPort}...`);
+		this.serverProcess = spawn("npx", [
+			"tsx",
+			serverEntryPath,
+			"--port",
+			this.actualPort.toString()
+		], {
+			stdio: "inherit",
+			env: {
+				...process.env,
+				NODE_ENV: "development"
+			},
+			detached: true
+		});
+		this.isRunning = true;
+		this.serverProcess.on("error", (error) => {
+			logger$2.error("❌ Server error:", error);
+		});
+		this.serverProcess.on("exit", (code, signal) => {
+			if (code !== null && code !== 0 && signal !== "SIGTERM") logger$2.error(`❌ Server exited with code ${code}`);
+			this.isRunning = false;
+		});
+		await new Promise((resolve$1) => setTimeout(resolve$1, 1e3));
+		if (this.isRunning) {
+			logger$2.log(`\n🎉 Server running at http://localhost:${this.actualPort}`);
+			if (this.enableOpenApi) logger$2.log(`📚 API Docs available at http://localhost:${this.actualPort}/__docs`);
+			if (this.telescope) logger$2.log(`🔭 Telescope available at http://localhost:${this.actualPort}${this.telescope.path}`);
+			if (this.studio) logger$2.log(`🗄️  Studio available at http://localhost:${this.actualPort}${this.studio.path}`);
+		}
+	}
+	async stop() {
+		const port = this.actualPort;
+		if (this.serverProcess && this.isRunning) {
+			const pid = this.serverProcess.pid;
+			if (pid) try {
+				process.kill(-pid, "SIGKILL");
+			} catch {
+				try {
+					process.kill(pid, "SIGKILL");
+				} catch {}
+			}
+			this.serverProcess = null;
+			this.isRunning = false;
+		}
+		this.killProcessesOnPort(port);
+	}
+	killProcessesOnPort(port) {
+		try {
+			execSync(`lsof -ti tcp:${port} | xargs kill -9 2>/dev/null || true`, { stdio: "ignore" });
+		} catch {}
+	}
+	async restart() {
+		const portToReuse = this.actualPort;
+		await this.stop();
+		let attempts = 0;
+		while (attempts < 30) {
+			if (await isPortAvailable(portToReuse)) break;
+			await new Promise((resolve$1) => setTimeout(resolve$1, 100));
+			attempts++;
+		}
+		this.requestedPort = portToReuse;
+		await this.start();
+	}
+	async createServerEntry() {
+		const { writeFile: writeFile$1 } = await import("node:fs/promises");
+		const { relative: relative$2, dirname: dirname$1 } = await import("node:path");
+		const serverPath = join$1(process.cwd(), ".gkm", this.provider, "server.ts");
+		const relativeAppPath = relative$2(dirname$1(serverPath), join$1(dirname$1(serverPath), "app.js"));
+		const serveCode = this.runtime === "bun" ? `Bun.serve({
+      port,
+      fetch: app.fetch,
+    });` : `const { serve } = await import('@hono/node-server');
+    const server = serve({
+      fetch: app.fetch,
+      port,
+    });
+    // Inject WebSocket support if available
+    const injectWs = (app as any).__injectWebSocket;
+    if (injectWs) {
+      injectWs(server);
+      console.log('🔌 Telescope real-time updates enabled');
+    }`;
+		const content = `#!/usr/bin/env node
+/**
+ * Development server entry point
+ * This file is auto-generated by 'gkm dev'
+ */
+import { createApp } from './${relativeAppPath.startsWith(".") ? relativeAppPath : "./" + relativeAppPath}';
+
+const port = process.argv.includes('--port')
+  ? Number.parseInt(process.argv[process.argv.indexOf('--port') + 1])
+  : 3000;
+
+// createApp is async to support optional WebSocket setup
+const { app, start } = await createApp(undefined, ${this.enableOpenApi});
+
+// Start the server
+start({
+  port,
+  serve: async (app, port) => {
+    ${serveCode}
+  },
+}).catch((error) => {
+  console.error('Failed to start server:', error);
+  process.exit(1);
+});
+`;
+		await writeFile$1(serverPath, content);
+	}
+};
+
+//#endregion
+//#region src/build/manifests.ts
+const logger$1 = console;
+async function generateAwsManifest(outputDir, routes, functions, crons, subscribers) {
+	const manifestDir = join(outputDir, "manifest");
+	await mkdir(manifestDir, { recursive: true });
+	const awsRoutes = routes.filter((r) => r.method !== "ALL");
+	const content = `export const manifest = {
+  routes: ${JSON.stringify(awsRoutes, null, 2)},
+  functions: ${JSON.stringify(functions, null, 2)},
+  crons: ${JSON.stringify(crons, null, 2)},
+  subscribers: ${JSON.stringify(subscribers, null, 2)},
+} as const;
+
+// Derived types
+export type Route = (typeof manifest.routes)[number];
+export type Function = (typeof manifest.functions)[number];
+export type Cron = (typeof manifest.crons)[number];
+export type Subscriber = (typeof manifest.subscribers)[number];
+
+// Useful union types
+export type Authorizer = Route['authorizer'];
+export type HttpMethod = Route['method'];
+export type RoutePath = Route['path'];
+`;
+	const manifestPath = join(manifestDir, "aws.ts");
+	await writeFile(manifestPath, content);
+	logger$1.log(`Generated AWS manifest with ${awsRoutes.length} routes, ${functions.length} functions, ${crons.length} crons, ${subscribers.length} subscribers`);
+	logger$1.log(`Manifest: ${relative(process.cwd(), manifestPath)}`);
+}
+async function generateServerManifest(outputDir, appInfo, routes, subscribers) {
+	const manifestDir = join(outputDir, "manifest");
+	await mkdir(manifestDir, { recursive: true });
+	const serverRoutes = routes.filter((r) => r.method !== "ALL").map((r) => ({
+		path: r.path,
+		method: r.method,
+		authorizer: r.authorizer
+	}));
+	const serverSubscribers = subscribers.map((s) => ({
+		name: s.name,
+		subscribedEvents: s.subscribedEvents
+	}));
+	const content = `export const manifest = {
+  app: ${JSON.stringify(appInfo, null, 2)},
+  routes: ${JSON.stringify(serverRoutes, null, 2)},
+  subscribers: ${JSON.stringify(serverSubscribers, null, 2)},
+} as const;
+
+// Derived types
+export type Route = (typeof manifest.routes)[number];
+export type Subscriber = (typeof manifest.subscribers)[number];
+
+// Useful union types
+export type Authorizer = Route['authorizer'];
+export type HttpMethod = Route['method'];
+export type RoutePath = Route['path'];
+`;
+	const manifestPath = join(manifestDir, "server.ts");
+	await writeFile(manifestPath, content);
+	logger$1.log(`Generated server manifest with ${serverRoutes.length} routes, ${serverSubscribers.length} subscribers`);
+	logger$1.log(`Manifest: ${relative(process.cwd(), manifestPath)}`);
+}
+
+//#endregion
+//#region src/build/index.ts
+const logger = console;
+async function buildCommand(options) {
+	const config$1 = await loadConfig();
+	const resolved = resolveProviders(config$1, options);
+	logger.log(`Building with providers: ${resolved.providers.join(", ")}`);
+	logger.log(`Loading routes from: ${config$1.routes}`);
+	if (config$1.functions) logger.log(`Loading functions from: ${config$1.functions}`);
+	if (config$1.crons) logger.log(`Loading crons from: ${config$1.crons}`);
+	if (config$1.subscribers) logger.log(`Loading subscribers from: ${config$1.subscribers}`);
+	logger.log(`Using envParser: ${config$1.envParser}`);
+	const { path: envParserPath, importPattern: envParserImportPattern } = parseModuleConfig(config$1.envParser, "envParser");
+	const { path: loggerPath, importPattern: loggerImportPattern } = parseModuleConfig(config$1.logger, "logger");
+	const telescope = normalizeTelescopeConfig(config$1.telescope);
+	if (telescope) logger.log(`🔭 Telescope enabled at ${telescope.path}`);
+	const hooks = normalizeHooksConfig(config$1.hooks);
+	if (hooks) logger.log(`🪝 Server hooks enabled`);
+	const buildContext = {
+		envParserPath,
+		envParserImportPattern,
+		loggerPath,
+		loggerImportPattern,
+		telescope,
+		hooks
+	};
+	const endpointGenerator = new EndpointGenerator();
+	const functionGenerator = new FunctionGenerator();
+	const cronGenerator = new CronGenerator();
+	const subscriberGenerator = new SubscriberGenerator();
+	const [allEndpoints, allFunctions, allCrons, allSubscribers] = await Promise.all([
+		endpointGenerator.load(config$1.routes),
+		config$1.functions ? functionGenerator.load(config$1.functions) : [],
+		config$1.crons ? cronGenerator.load(config$1.crons) : [],
+		config$1.subscribers ? subscriberGenerator.load(config$1.subscribers) : []
+	]);
+	logger.log(`Found ${allEndpoints.length} endpoints`);
+	logger.log(`Found ${allFunctions.length} functions`);
+	logger.log(`Found ${allCrons.length} crons`);
+	logger.log(`Found ${allSubscribers.length} subscribers`);
+	if (allEndpoints.length === 0 && allFunctions.length === 0 && allCrons.length === 0 && allSubscribers.length === 0) {
+		logger.log("No endpoints, functions, crons, or subscribers found to process");
+		return;
+	}
+	const rootOutputDir = join$1(process.cwd(), ".gkm");
+	await mkdir(rootOutputDir, { recursive: true });
+	for (const provider of resolved.providers) await buildForProvider(provider, buildContext, rootOutputDir, endpointGenerator, functionGenerator, cronGenerator, subscriberGenerator, allEndpoints, allFunctions, allCrons, allSubscribers, resolved.enableOpenApi);
+}
+async function buildForProvider(provider, context, rootOutputDir, endpointGenerator, functionGenerator, cronGenerator, subscriberGenerator, endpoints, functions, crons, subscribers, enableOpenApi) {
+	const outputDir = join$1(process.cwd(), ".gkm", provider);
+	await mkdir(outputDir, { recursive: true });
+	logger.log(`\nGenerating handlers for provider: ${provider}`);
+	const [routes, functionInfos, cronInfos, subscriberInfos] = await Promise.all([
+		endpointGenerator.build(context, endpoints, outputDir, {
+			provider,
+			enableOpenApi
+		}),
+		functionGenerator.build(context, functions, outputDir, { provider }),
+		cronGenerator.build(context, crons, outputDir, { provider }),
+		subscriberGenerator.build(context, subscribers, outputDir, { provider })
+	]);
+	logger.log(`Generated ${routes.length} routes, ${functionInfos.length} functions, ${cronInfos.length} crons, ${subscriberInfos.length} subscribers for ${provider}`);
+	if (provider === "server") {
+		const routeMetadata = await Promise.all(endpoints.map(async ({ construct }) => ({
+			path: construct._path,
+			method: construct.method,
+			handler: "",
+			authorizer: construct.authorizer?.name ?? "none"
+		})));
+		const appInfo = {
+			handler: relative$1(process.cwd(), join$1(outputDir, "app.ts")),
+			endpoints: relative$1(process.cwd(), join$1(outputDir, "endpoints.ts"))
+		};
+		await generateServerManifest(rootOutputDir, appInfo, routeMetadata, subscriberInfos);
+	} else await generateAwsManifest(rootOutputDir, routes, functionInfos, cronInfos, subscriberInfos);
+}
+
+//#endregion
+//#region src/init/generators/config.ts
+/**
+* Generate configuration files (gkm.config.ts, tsconfig.json, biome.json, turbo.json)
+*/
+function generateConfigFiles(options, template) {
+	const { telescope, studio, routesStructure } = options;
+	const isServerless = template.name === "serverless";
+	const hasWorker = template.name === "worker";
+	const getRoutesGlob = () => {
+		switch (routesStructure) {
+			case "centralized-endpoints": return "./src/endpoints/**/*.ts";
+			case "centralized-routes": return "./src/routes/**/*.ts";
+			case "domain-based": return "./src/**/routes/*.ts";
+		}
+	};
+	let gkmConfig = `import { defineConfig } from '@geekmidas/cli/config';
+
+export default defineConfig({
+  routes: '${getRoutesGlob()}',
+  envParser: './src/config/env#envParser',
+  logger: './src/config/logger#logger',`;
+	if (isServerless || hasWorker) gkmConfig += `
+  functions: './src/functions/**/*.ts',`;
+	if (hasWorker) gkmConfig += `
+  crons: './src/crons/**/*.ts',
+  subscribers: './src/subscribers/**/*.ts',`;
+	if (telescope) gkmConfig += `
+  telescope: {
+    enabled: true,
+    path: '/__telescope',
+  },`;
+	if (studio) gkmConfig += `
+  studio: './src/config/studio#studio',`;
+	gkmConfig += `
+  openapi: {
+    enabled: true,
+  },`;
+	gkmConfig += `
+});
+`;
+	const tsConfig = options.monorepo ? {
+		extends: "../../tsconfig.json",
+		compilerOptions: {
+			outDir: "./dist",
+			rootDir: "./src",
+			baseUrl: ".",
+			paths: { [`@${options.name}/*`]: ["../../packages/*/src"] }
+		},
+		include: ["src/**/*.ts"],
+		exclude: ["node_modules", "dist"]
+	} : {
+		compilerOptions: {
+			target: "ES2022",
+			module: "NodeNext",
+			moduleResolution: "NodeNext",
+			lib: ["ES2022"],
+			strict: true,
+			esModuleInterop: true,
+			skipLibCheck: true,
+			forceConsistentCasingInFileNames: true,
+			resolveJsonModule: true,
+			declaration: true,
+			declarationMap: true,
+			outDir: "./dist",
+			rootDir: "./src"
+		},
+		include: ["src/**/*.ts"],
+		exclude: ["node_modules", "dist"]
+	};
+	if (options.monorepo) return [{
+		path: "gkm.config.ts",
+		content: gkmConfig
+	}, {
+		path: "tsconfig.json",
+		content: JSON.stringify(tsConfig, null, 2) + "\n"
+	}];
+	const biomeConfig = {
+		$schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
+		vcs: {
+			enabled: true,
+			clientKind: "git",
+			useIgnoreFile: true
+		},
+		organizeImports: { enabled: true },
+		formatter: {
+			enabled: true,
+			indentStyle: "space",
+			indentWidth: 2,
+			lineWidth: 80
+		},
+		javascript: { formatter: {
+			quoteStyle: "single",
+			trailingCommas: "all",
+			semicolons: "always",
+			arrowParentheses: "always"
+		} },
+		linter: {
+			enabled: true,
+			rules: {
+				recommended: true,
+				correctness: {
+					noUnusedImports: "error",
+					noUnusedVariables: "error"
+				},
+				style: { noNonNullAssertion: "off" }
+			}
+		},
+		files: { ignore: [
+			"node_modules",
+			"dist",
+			".gkm",
+			"coverage"
+		] }
+	};
+	const turboConfig = {
+		$schema: "https://turbo.build/schema.json",
+		tasks: {
+			build: {
+				dependsOn: ["^build"],
+				outputs: ["dist/**"]
+			},
+			dev: {
+				cache: false,
+				persistent: true
+			},
+			test: {
+				dependsOn: ["^build"],
+				cache: false
+			},
+			"test:once": {
+				dependsOn: ["^build"],
+				outputs: ["coverage/**"]
+			},
+			typecheck: {
+				dependsOn: ["^build"],
+				outputs: []
+			},
+			lint: { outputs: [] },
+			fmt: { outputs: [] }
+		}
+	};
+	return [
+		{
+			path: "gkm.config.ts",
+			content: gkmConfig
+		},
+		{
+			path: "tsconfig.json",
+			content: JSON.stringify(tsConfig, null, 2) + "\n"
+		},
+		{
+			path: "biome.json",
+			content: JSON.stringify(biomeConfig, null, 2) + "\n"
+		},
+		{
+			path: "turbo.json",
+			content: JSON.stringify(turboConfig, null, 2) + "\n"
+		}
+	];
+}
+
+//#endregion
+//#region src/init/generators/docker.ts
+/**
+* Generate docker-compose.yml based on template and options
+*/
+function generateDockerFiles(options, template) {
+	const { database } = options;
+	const isServerless = template.name === "serverless";
+	const hasWorker = template.name === "worker";
+	const services = [];
+	const volumes = [];
+	if (database) {
+		services.push(`  postgres:
+    image: postgres:16-alpine
+    container_name: ${options.name}-postgres
+    restart: unless-stopped
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: ${options.name.replace(/-/g, "_")}_dev
+    ports:
+      - '5432:5432'
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ['CMD-SHELL', 'pg_isready -U postgres']
+      interval: 5s
+      timeout: 5s
+      retries: 5`);
+		volumes.push("  postgres_data:");
+	}
+	if (isServerless) {
+		services.push(`  redis:
+    image: redis:7-alpine
+    container_name: ${options.name}-redis
+    restart: unless-stopped
+    ports:
+      - '6379:6379'
+    volumes:
+      - redis_data:/data
+    healthcheck:
+      test: ['CMD', 'redis-cli', 'ping']
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+  serverless-redis:
+    image: hiett/serverless-redis-http:latest
+    container_name: ${options.name}-serverless-redis
+    restart: unless-stopped
+    ports:
+      - '8079:80'
+    environment:
+      SRH_MODE: env
+      SRH_TOKEN: local_dev_token
+      SRH_CONNECTION_STRING: redis://redis:6379
+    depends_on:
+      redis:
+        condition: service_healthy`);
+		volumes.push("  redis_data:");
+	} else {
+		services.push(`  redis:
+    image: redis:7-alpine
+    container_name: ${options.name}-redis
+    restart: unless-stopped
+    ports:
+      - '6379:6379'
+    volumes:
+      - redis_data:/data
+    healthcheck:
+      test: ['CMD', 'redis-cli', 'ping']
+      interval: 5s
+      timeout: 5s
+      retries: 5`);
+		volumes.push("  redis_data:");
+	}
+	if (hasWorker) {
+		services.push(`  rabbitmq:
+    image: rabbitmq:3-management-alpine
+    container_name: ${options.name}-rabbitmq
+    restart: unless-stopped
+    ports:
+      - '5672:5672'
+      - '15672:15672'
+    environment:
+      RABBITMQ_DEFAULT_USER: guest
+      RABBITMQ_DEFAULT_PASS: guest
+    volumes:
+      - rabbitmq_data:/var/lib/rabbitmq
+    healthcheck:
+      test: ['CMD', 'rabbitmq-diagnostics', 'check_running']
+      interval: 10s
+      timeout: 5s
+      retries: 5`);
+		volumes.push("  rabbitmq_data:");
+	}
+	let dockerCompose = `version: '3.8'
+
+services:
+${services.join("\n\n")}
+`;
+	if (volumes.length > 0) dockerCompose += `
+volumes:
+${volumes.join("\n")}
+`;
+	return [{
+		path: "docker-compose.yml",
+		content: dockerCompose
+	}];
+}
+
+//#endregion
+//#region src/init/generators/env.ts
+/**
+* Generate environment files (.env, .env.example, .env.development, .env.test, .gitignore)
+*/
+function generateEnvFiles(options, template) {
+	const { database } = options;
+	const isServerless = template.name === "serverless";
+	const hasWorker = template.name === "worker";
+	let baseEnv = `# Application
+NODE_ENV=development
+PORT=3000
+LOG_LEVEL=info
+`;
+	if (isServerless) baseEnv = `# AWS
+STAGE=dev
+AWS_REGION=us-east-1
+LOG_LEVEL=info
+`;
+	if (database) baseEnv += `
+# Database
+DATABASE_URL=postgresql://user:password@localhost:5432/mydb
+`;
+	if (hasWorker) baseEnv += `
+# Message Queue
+RABBITMQ_URL=amqp://localhost:5672
+`;
+	baseEnv += `
+# Authentication
+JWT_SECRET=your-secret-key-change-in-production
+`;
+	let devEnv = `# Development Environment
+NODE_ENV=development
+PORT=3000
+LOG_LEVEL=debug
+`;
+	if (isServerless) devEnv = `# Development Environment
+STAGE=dev
+AWS_REGION=us-east-1
+LOG_LEVEL=debug
+`;
+	if (database) devEnv += `
+# Database
+DATABASE_URL=postgresql://postgres:postgres@localhost:5432/mydb_dev
+`;
+	if (hasWorker) devEnv += `
+# Message Queue
+RABBITMQ_URL=amqp://localhost:5672
+`;
+	devEnv += `
+# Authentication
+JWT_SECRET=dev-secret-not-for-production
+`;
+	let testEnv = `# Test Environment
+NODE_ENV=test
+PORT=3001
+LOG_LEVEL=error
+`;
+	if (isServerless) testEnv = `# Test Environment
+STAGE=test
+AWS_REGION=us-east-1
+LOG_LEVEL=error
+`;
+	if (database) testEnv += `
+# Database
+DATABASE_URL=postgresql://postgres:postgres@localhost:5432/mydb_test
+`;
+	if (hasWorker) testEnv += `
+# Message Queue
+RABBITMQ_URL=amqp://localhost:5672
+`;
+	testEnv += `
+# Authentication
+JWT_SECRET=test-secret-not-for-production
+`;
+	const files = [
+		{
+			path: ".env.example",
+			content: baseEnv
+		},
+		{
+			path: ".env",
+			content: baseEnv
+		},
+		{
+			path: ".env.development",
+			content: devEnv
+		},
+		{
+			path: ".env.test",
+			content: testEnv
+		}
+	];
+	if (!options.monorepo) {
+		const gitignore = `# Dependencies
+node_modules/
+
+# Build output
+dist/
+.gkm/
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+pnpm-debug.log*
+
+# Test coverage
+coverage/
+
+# TypeScript cache
+*.tsbuildinfo
+`;
+		files.push({
+			path: ".gitignore",
+			content: gitignore
+		});
+	}
+	return files;
+}
+
+//#endregion
+//#region src/init/generators/models.ts
+/**
+* Generate packages/models for shared Zod schemas (monorepo only)
+*/
+function generateModelsPackage(options) {
+	if (!options.monorepo) return [];
+	const packageName = `@${options.name}/models`;
+	const packageJson = {
+		name: packageName,
+		version: "0.0.1",
+		private: true,
+		type: "module",
+		exports: {
+			".": {
+				types: "./dist/index.d.ts",
+				import: "./dist/index.js"
+			},
+			"./*": {
+				types: "./dist/*.d.ts",
+				import: "./dist/*.js"
+			}
+		},
+		scripts: {
+			build: "tsc",
+			"build:watch": "tsc --watch",
+			typecheck: "tsc --noEmit"
+		},
+		dependencies: { zod: "~4.1.0" },
+		devDependencies: { typescript: "~5.8.2" }
+	};
+	const tsConfig = {
+		extends: "../../tsconfig.json",
+		compilerOptions: {
+			outDir: "./dist",
+			rootDir: "./src"
+		},
+		include: ["src/**/*.ts"],
+		exclude: ["node_modules", "dist"]
+	};
+	const indexTs = `import { z } from 'zod';
+
+// ============================================
+// Common Schemas
+// ============================================
+
+export const idSchema = z.string().uuid();
+
+export const timestampsSchema = z.object({
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+});
+
+export const paginationSchema = z.object({
+  page: z.coerce.number().int().positive().default(1),
+  limit: z.coerce.number().int().positive().max(100).default(20),
+});
+
+export const paginatedResponseSchema = <T extends z.ZodTypeAny>(itemSchema: T) =>
+  z.object({
+    items: z.array(itemSchema),
+    total: z.number(),
+    page: z.number(),
+    limit: z.number(),
+    totalPages: z.number(),
+  });
+
+// ============================================
+// User Schemas
+// ============================================
+
+export const userSchema = z.object({
+  id: idSchema,
+  email: z.string().email(),
+  name: z.string().min(1).max(100),
+  ...timestampsSchema.shape,
+});
+
+export const createUserSchema = userSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+});
+
+export const updateUserSchema = createUserSchema.partial();
+
+// ============================================
+// Type Exports
+// ============================================
+
+export type Id = z.infer<typeof idSchema>;
+export type Timestamps = z.infer<typeof timestampsSchema>;
+export type Pagination = z.infer<typeof paginationSchema>;
+export type User = z.infer<typeof userSchema>;
+export type CreateUser = z.infer<typeof createUserSchema>;
+export type UpdateUser = z.infer<typeof updateUserSchema>;
+`;
+	return [
+		{
+			path: "packages/models/package.json",
+			content: JSON.stringify(packageJson, null, 2) + "\n"
+		},
+		{
+			path: "packages/models/tsconfig.json",
+			content: JSON.stringify(tsConfig, null, 2) + "\n"
+		},
+		{
+			path: "packages/models/src/index.ts",
+			content: indexTs
+		}
+	];
+}
+
+//#endregion
+//#region src/init/generators/monorepo.ts
+/**
+* Generate monorepo root files (pnpm-workspace.yaml, root package.json, etc.)
+*/
+function generateMonorepoFiles(options, _template) {
+	if (!options.monorepo) return [];
+	const rootPackageJson = {
+		name: options.name,
+		version: "0.0.1",
+		private: true,
+		type: "module",
+		scripts: {
+			dev: "turbo dev",
+			build: "turbo build",
+			test: "turbo test",
+			"test:once": "turbo test:once",
+			typecheck: "turbo typecheck",
+			lint: "biome lint .",
+			fmt: "biome format . --write",
+			"fmt:check": "biome format ."
+		},
+		devDependencies: {
+			"@biomejs/biome": "~1.9.4",
+			turbo: "~2.3.0",
+			typescript: "~5.8.2",
+			vitest: "~4.0.0"
+		}
+	};
+	const apiPathParts = options.apiPath.split("/");
+	const appsFolder = apiPathParts[0] || "apps";
+	const pnpmWorkspace = `packages:
+  - '${appsFolder}/*'
+  - 'packages/*'
+`;
+	const biomeConfig = {
+		$schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
+		vcs: {
+			enabled: true,
+			clientKind: "git",
+			useIgnoreFile: true
+		},
+		organizeImports: { enabled: true },
+		formatter: {
+			enabled: true,
+			indentStyle: "space",
+			indentWidth: 2,
+			lineWidth: 80
+		},
+		javascript: { formatter: {
+			quoteStyle: "single",
+			trailingCommas: "all",
+			semicolons: "always",
+			arrowParentheses: "always"
+		} },
+		linter: {
+			enabled: true,
+			rules: {
+				recommended: true,
+				correctness: {
+					noUnusedImports: "error",
+					noUnusedVariables: "error"
+				},
+				style: { noNonNullAssertion: "off" }
+			}
+		},
+		files: { ignore: [
+			"node_modules",
+			"dist",
+			".gkm",
+			"coverage"
+		] }
+	};
+	const turboConfig = {
+		$schema: "https://turbo.build/schema.json",
+		tasks: {
+			build: {
+				dependsOn: ["^build"],
+				outputs: ["dist/**"]
+			},
+			dev: {
+				cache: false,
+				persistent: true
+			},
+			test: {
+				dependsOn: ["^build"],
+				cache: false
+			},
+			"test:once": {
+				dependsOn: ["^build"],
+				outputs: ["coverage/**"]
+			},
+			typecheck: {
+				dependsOn: ["^build"],
+				outputs: []
+			},
+			lint: { outputs: [] },
+			fmt: { outputs: [] }
+		}
+	};
+	const gitignore = `# Dependencies
+node_modules/
+
+# Build output
+dist/
+.gkm/
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+pnpm-debug.log*
+
+# Test coverage
+coverage/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Turbo
+.turbo/
+`;
+	const tsConfig = {
+		compilerOptions: {
+			target: "ES2022",
+			module: "NodeNext",
+			moduleResolution: "NodeNext",
+			lib: ["ES2022"],
+			strict: true,
+			esModuleInterop: true,
+			skipLibCheck: true,
+			forceConsistentCasingInFileNames: true,
+			resolveJsonModule: true,
+			declaration: true,
+			declarationMap: true,
+			composite: true
+		},
+		exclude: ["node_modules", "dist"]
+	};
+	return [
+		{
+			path: "package.json",
+			content: JSON.stringify(rootPackageJson, null, 2) + "\n"
+		},
+		{
+			path: "pnpm-workspace.yaml",
+			content: pnpmWorkspace
+		},
+		{
+			path: "tsconfig.json",
+			content: JSON.stringify(tsConfig, null, 2) + "\n"
+		},
+		{
+			path: "biome.json",
+			content: JSON.stringify(biomeConfig, null, 2) + "\n"
+		},
+		{
+			path: "turbo.json",
+			content: JSON.stringify(turboConfig, null, 2) + "\n"
+		},
+		{
+			path: ".gitignore",
+			content: gitignore
+		}
+	];
+}
+
+//#endregion
+//#region src/init/templates/api.ts
+const apiTemplate = {
+	name: "api",
+	description: "Full API with auth, database, services",
+	dependencies: {
+		"@geekmidas/constructs": "workspace:*",
+		"@geekmidas/envkit": "workspace:*",
+		"@geekmidas/logger": "workspace:*",
+		"@geekmidas/services": "workspace:*",
+		"@geekmidas/errors": "workspace:*",
+		"@geekmidas/auth": "workspace:*",
+		hono: "~4.8.2",
+		pino: "~9.6.0"
+	},
+	devDependencies: {
+		"@biomejs/biome": "~1.9.4",
+		"@geekmidas/cli": "workspace:*",
+		"@types/node": "~22.0.0",
+		tsx: "~4.20.0",
+		turbo: "~2.3.0",
+		typescript: "~5.8.2",
+		vitest: "~4.0.0"
+	},
+	scripts: {
+		dev: "gkm dev",
+		build: "gkm build",
+		test: "vitest",
+		"test:once": "vitest run",
+		typecheck: "tsc --noEmit",
+		lint: "biome lint .",
+		fmt: "biome format . --write",
+		"fmt:check": "biome format ."
+	},
+	files: (options) => {
+		const { loggerType, routesStructure } = options;
+		const loggerContent = `import { createLogger } from '@geekmidas/logger/${loggerType}';
+
+export const logger = createLogger();
+`;
+		const getRoutePath = (file) => {
+			switch (routesStructure) {
+				case "centralized-endpoints": return `src/endpoints/${file}`;
+				case "centralized-routes": return `src/routes/${file}`;
+				case "domain-based": {
+					const parts = file.split("/");
+					if (parts.length === 1) return `src/${file.replace(".ts", "")}/routes/index.ts`;
+					return `src/${parts[0]}/routes/${parts.slice(1).join("/")}`;
+				}
+			}
+		};
+		const files = [
+			{
+				path: "src/config/env.ts",
+				content: `import { EnvironmentParser } from '@geekmidas/envkit';
+
+export const envParser = new EnvironmentParser(process.env);
+
+export const config = envParser
+  .create((get) => ({
+    port: get('PORT').string().transform(Number).default(3000),
+    nodeEnv: get('NODE_ENV').string().default('development'),
+    jwtSecret: get('JWT_SECRET').string().default('change-me-in-production'),${options.database ? `
+    database: {
+      url: get('DATABASE_URL').string().default('postgresql://localhost:5432/mydb'),
+    },` : ""}
+  }))
+  .parse();
+`
+			},
+			{
+				path: "src/config/logger.ts",
+				content: loggerContent
+			},
+			{
+				path: getRoutePath("health.ts"),
+				content: `import { e } from '@geekmidas/constructs/endpoints';
+
+export default e
+  .get('/health')
+  .handle(async () => ({
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+  }));
+`
+			},
+			{
+				path: getRoutePath("users/list.ts"),
+				content: `import { e } from '@geekmidas/constructs/endpoints';
+
+export default e
+  .get('/users')
+  .handle(async () => ({
+    users: [
+      { id: '1', name: 'Alice' },
+      { id: '2', name: 'Bob' },
+    ],
+  }));
+`
+			},
+			{
+				path: getRoutePath("users/get.ts"),
+				content: `import { e } from '@geekmidas/constructs/endpoints';
+import { z } from 'zod';
+
+export default e
+  .get('/users/:id')
+  .params(z.object({ id: z.string() }))
+  .handle(async ({ params }) => ({
+    id: params.id,
+    name: 'Alice',
+    email: 'alice@example.com',
+  }));
+`
+			}
+		];
+		if (options.database) files.push({
+			path: "src/services/database.ts",
+			content: `import type { Service } from '@geekmidas/services';
+import { Kysely, PostgresDialect } from 'kysely';
+import pg from 'pg';
+
+// Define your database schema
+export interface Database {
+  users: {
+    id: string;
+    name: string;
+    email: string;
+    created_at: Date;
+  };
+}
+
+export const databaseService = {
+  serviceName: 'database' as const,
+  async register(envParser) {
+    const config = envParser
+      .create((get) => ({
+        url: get('DATABASE_URL').string(),
+      }))
+      .parse();
+
+    return new Kysely<Database>({
+      dialect: new PostgresDialect({
+        pool: new pg.Pool({ connectionString: config.url }),
+      }),
+    });
+  },
+} satisfies Service<'database', Kysely<Database>>;
+`
+		});
+		if (options.telescope) files.push({
+			path: "src/config/telescope.ts",
+			content: `import { Telescope } from '@geekmidas/telescope';
+import { InMemoryStorage } from '@geekmidas/telescope/storage/memory';
+
+export const telescope = new Telescope({
+  storage: new InMemoryStorage({ maxEntries: 100 }),
+  enabled: process.env.NODE_ENV === 'development',
+});
+`
+		});
+		if (options.studio && options.database) files.push({
+			path: "src/config/studio.ts",
+			content: `import { Direction, InMemoryMonitoringStorage, Studio } from '@geekmidas/studio';
+import { Kysely, PostgresDialect } from 'kysely';
+import pg from 'pg';
+import type { Database } from '../services/database';
+import { config } from './env';
+
+// Create a Kysely instance for Studio
+const db = new Kysely<Database>({
+  dialect: new PostgresDialect({
+    pool: new pg.Pool({ connectionString: config.database.url }),
+  }),
+});
+
+export const studio = new Studio<Database>({
+  monitoring: {
+    storage: new InMemoryMonitoringStorage({ maxEntries: 100 }),
+  },
+  data: {
+    db,
+    cursor: { field: 'id', direction: Direction.Desc },
+  },
+  enabled: process.env.NODE_ENV === 'development',
+});
+`
+		});
+		return files;
+	}
+};
+
+//#endregion
+//#region src/init/templates/minimal.ts
+const minimalTemplate = {
+	name: "minimal",
+	description: "Basic health endpoint",
+	dependencies: {
+		"@geekmidas/constructs": "workspace:*",
+		"@geekmidas/envkit": "workspace:*",
+		"@geekmidas/logger": "workspace:*",
+		hono: "~4.8.2",
+		pino: "~9.6.0"
+	},
+	devDependencies: {
+		"@biomejs/biome": "~1.9.4",
+		"@geekmidas/cli": "workspace:*",
+		"@types/node": "~22.0.0",
+		tsx: "~4.20.0",
+		turbo: "~2.3.0",
+		typescript: "~5.8.2",
+		vitest: "~4.0.0"
+	},
+	scripts: {
+		dev: "gkm dev",
+		build: "gkm build",
+		test: "vitest",
+		"test:once": "vitest run",
+		typecheck: "tsc --noEmit",
+		lint: "biome lint .",
+		fmt: "biome format . --write",
+		"fmt:check": "biome format ."
+	},
+	files: (options) => {
+		const { loggerType, routesStructure } = options;
+		const loggerContent = `import { createLogger } from '@geekmidas/logger/${loggerType}';
+
+export const logger = createLogger();
+`;
+		const getRoutePath = (file) => {
+			switch (routesStructure) {
+				case "centralized-endpoints": return `src/endpoints/${file}`;
+				case "centralized-routes": return `src/routes/${file}`;
+				case "domain-based": return `src/${file.replace(".ts", "")}/routes/index.ts`;
+			}
+		};
+		const files = [
+			{
+				path: "src/config/env.ts",
+				content: `import { EnvironmentParser } from '@geekmidas/envkit';
+
+export const envParser = new EnvironmentParser(process.env);
+
+export const config = envParser
+  .create((get) => ({
+    port: get('PORT').string().transform(Number).default(3000),
+    nodeEnv: get('NODE_ENV').string().default('development'),
+  }))
+  .parse();
+`
+			},
+			{
+				path: "src/config/logger.ts",
+				content: loggerContent
+			},
+			{
+				path: getRoutePath("health.ts"),
+				content: `import { e } from '@geekmidas/constructs/endpoints';
+
+export default e
+  .get('/health')
+  .handle(async () => ({
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+  }));
+`
+			}
+		];
+		if (options.database) {
+			files[0] = {
+				path: "src/config/env.ts",
+				content: `import { EnvironmentParser } from '@geekmidas/envkit';
+
+export const envParser = new EnvironmentParser(process.env);
+
+export const config = envParser
+  .create((get) => ({
+    port: get('PORT').string().transform(Number).default(3000),
+    nodeEnv: get('NODE_ENV').string().default('development'),
+    database: {
+      url: get('DATABASE_URL').string().default('postgresql://localhost:5432/mydb'),
+    },
+  }))
+  .parse();
+`
+			};
+			files.push({
+				path: "src/services/database.ts",
+				content: `import type { Service } from '@geekmidas/services';
+import { Kysely, PostgresDialect } from 'kysely';
+import pg from 'pg';
+
+// Define your database schema
+export interface Database {
+  // Add your tables here
+}
+
+export const databaseService = {
+  serviceName: 'database' as const,
+  async register(envParser) {
+    const config = envParser
+      .create((get) => ({
+        url: get('DATABASE_URL').string(),
+      }))
+      .parse();
+
+    return new Kysely<Database>({
+      dialect: new PostgresDialect({
+        pool: new pg.Pool({ connectionString: config.url }),
+      }),
+    });
+  },
+} satisfies Service<'database', Kysely<Database>>;
+`
+			});
+		}
+		if (options.telescope) files.push({
+			path: "src/config/telescope.ts",
+			content: `import { Telescope } from '@geekmidas/telescope';
+import { InMemoryStorage } from '@geekmidas/telescope/storage/memory';
+
+export const telescope = new Telescope({
+  storage: new InMemoryStorage({ maxEntries: 100 }),
+  enabled: process.env.NODE_ENV === 'development',
+});
+`
+		});
+		if (options.studio && options.database) files.push({
+			path: "src/config/studio.ts",
+			content: `import { Direction, InMemoryMonitoringStorage, Studio } from '@geekmidas/studio';
+import { Kysely, PostgresDialect } from 'kysely';
+import pg from 'pg';
+import type { Database } from '../services/database';
+import { config } from './env';
+
+// Create a Kysely instance for Studio
+const db = new Kysely<Database>({
+  dialect: new PostgresDialect({
+    pool: new pg.Pool({ connectionString: config.database.url }),
+  }),
+});
+
+export const studio = new Studio<Database>({
+  monitoring: {
+    storage: new InMemoryMonitoringStorage({ maxEntries: 100 }),
+  },
+  data: {
+    db,
+    cursor: { field: 'id', direction: Direction.Desc },
+  },
+  enabled: process.env.NODE_ENV === 'development',
+});
+`
+		});
+		return files;
+	}
+};
+
+//#endregion
+//#region src/init/templates/serverless.ts
+const serverlessTemplate = {
+	name: "serverless",
+	description: "AWS Lambda handlers",
+	dependencies: {
+		"@geekmidas/constructs": "workspace:*",
+		"@geekmidas/envkit": "workspace:*",
+		"@geekmidas/logger": "workspace:*",
+		"@geekmidas/cloud": "workspace:*",
+		hono: "~4.8.2",
+		pino: "~9.6.0"
+	},
+	devDependencies: {
+		"@biomejs/biome": "~1.9.4",
+		"@geekmidas/cli": "workspace:*",
+		"@types/aws-lambda": "~8.10.92",
+		"@types/node": "~22.0.0",
+		tsx: "~4.20.0",
+		turbo: "~2.3.0",
+		typescript: "~5.8.2",
+		vitest: "~4.0.0"
+	},
+	scripts: {
+		dev: "gkm dev",
+		build: "gkm build --provider aws-apigatewayv2",
+		test: "vitest",
+		"test:once": "vitest run",
+		typecheck: "tsc --noEmit",
+		lint: "biome lint .",
+		fmt: "biome format . --write",
+		"fmt:check": "biome format ."
+	},
+	files: (options) => {
+		const { loggerType, routesStructure } = options;
+		const loggerContent = `import { createLogger } from '@geekmidas/logger/${loggerType}';
+
+export const logger = createLogger();
+`;
+		const getRoutePath = (file) => {
+			switch (routesStructure) {
+				case "centralized-endpoints": return `src/endpoints/${file}`;
+				case "centralized-routes": return `src/routes/${file}`;
+				case "domain-based": return `src/${file.replace(".ts", "")}/routes/index.ts`;
+			}
+		};
+		const files = [
+			{
+				path: "src/config/env.ts",
+				content: `import { EnvironmentParser } from '@geekmidas/envkit';
+
+export const envParser = new EnvironmentParser(process.env);
+
+export const config = envParser
+  .create((get) => ({
+    stage: get('STAGE').string().default('dev'),
+    region: get('AWS_REGION').string().default('us-east-1'),${options.database ? `
+    database: {
+      url: get('DATABASE_URL').string(),
+    },` : ""}
+  }))
+  .parse();
+`
+			},
+			{
+				path: "src/config/logger.ts",
+				content: loggerContent
+			},
+			{
+				path: getRoutePath("health.ts"),
+				content: `import { e } from '@geekmidas/constructs/endpoints';
+
+export default e
+  .get('/health')
+  .handle(async () => ({
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+    region: process.env.AWS_REGION || 'local',
+  }));
+`
+			},
+			{
+				path: "src/functions/hello.ts",
+				content: `import { f } from '@geekmidas/constructs/functions';
+import { z } from 'zod';
+
+export default f
+  .input(z.object({ name: z.string() }))
+  .output(z.object({ message: z.string() }))
+  .handle(async ({ input }) => ({
+    message: \`Hello, \${input.name}!\`,
+  }));
+`
+			}
+		];
+		if (options.telescope) files.push({
+			path: "src/config/telescope.ts",
+			content: `import { Telescope } from '@geekmidas/telescope';
+import { InMemoryStorage } from '@geekmidas/telescope/storage/memory';
+
+// Note: For production Lambda, consider using a persistent storage
+export const telescope = new Telescope({
+  storage: new InMemoryStorage({ maxEntries: 50 }),
+  enabled: process.env.STAGE === 'dev',
+});
+`
+		});
+		return files;
+	}
+};
+
+//#endregion
+//#region src/init/templates/worker.ts
+const workerTemplate = {
+	name: "worker",
+	description: "Background job processing",
+	dependencies: {
+		"@geekmidas/constructs": "workspace:*",
+		"@geekmidas/envkit": "workspace:*",
+		"@geekmidas/logger": "workspace:*",
+		"@geekmidas/events": "workspace:*",
+		hono: "~4.8.2",
+		pino: "~9.6.0"
+	},
+	devDependencies: {
+		"@biomejs/biome": "~1.9.4",
+		"@geekmidas/cli": "workspace:*",
+		"@types/node": "~22.0.0",
+		tsx: "~4.20.0",
+		turbo: "~2.3.0",
+		typescript: "~5.8.2",
+		vitest: "~4.0.0"
+	},
+	scripts: {
+		dev: "gkm dev",
+		build: "gkm build",
+		test: "vitest",
+		"test:once": "vitest run",
+		typecheck: "tsc --noEmit",
+		lint: "biome lint .",
+		fmt: "biome format . --write",
+		"fmt:check": "biome format ."
+	},
+	files: (options) => {
+		const { loggerType, routesStructure } = options;
+		const loggerContent = `import { createLogger } from '@geekmidas/logger/${loggerType}';
+
+export const logger = createLogger();
+`;
+		const getRoutePath = (file) => {
+			switch (routesStructure) {
+				case "centralized-endpoints": return `src/endpoints/${file}`;
+				case "centralized-routes": return `src/routes/${file}`;
+				case "domain-based": return `src/${file.replace(".ts", "")}/routes/index.ts`;
+			}
+		};
+		const files = [
+			{
+				path: "src/config/env.ts",
+				content: `import { EnvironmentParser } from '@geekmidas/envkit';
+
+export const envParser = new EnvironmentParser(process.env);
+
+export const config = envParser
+  .create((get) => ({
+    port: get('PORT').string().transform(Number).default(3000),
+    nodeEnv: get('NODE_ENV').string().default('development'),
+    rabbitmq: {
+      url: get('RABBITMQ_URL').string().default('amqp://localhost:5672'),
+    },${options.database ? `
+    database: {
+      url: get('DATABASE_URL').string().default('postgresql://localhost:5432/mydb'),
+    },` : ""}
+  }))
+  .parse();
+`
+			},
+			{
+				path: "src/config/logger.ts",
+				content: loggerContent
+			},
+			{
+				path: getRoutePath("health.ts"),
+				content: `import { e } from '@geekmidas/constructs/endpoints';
+
+export default e
+  .get('/health')
+  .handle(async () => ({
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+  }));
+`
+			},
+			{
+				path: "src/events/types.ts",
+				content: `import type { PublishableMessage } from '@geekmidas/events';
+
+// Define your event types here
+export type AppEvents =
+  | PublishableMessage<'user.created', { userId: string; email: string }>
+  | PublishableMessage<'user.updated', { userId: string; changes: Record<string, unknown> }>
+  | PublishableMessage<'order.placed', { orderId: string; userId: string; total: number }>;
+`
+			},
+			{
+				path: "src/subscribers/user-events.ts",
+				content: `import { s } from '@geekmidas/constructs/subscribers';
+import type { AppEvents } from '../events/types.js';
+
+export default s<AppEvents>()
+  .events(['user.created', 'user.updated'])
+  .handle(async ({ event, logger }) => {
+    logger.info({ type: event.type, payload: event.payload }, 'Processing user event');
+
+    switch (event.type) {
+      case 'user.created':
+        // Handle user creation
+        logger.info({ userId: event.payload.userId }, 'New user created');
+        break;
+      case 'user.updated':
+        // Handle user update
+        logger.info({ userId: event.payload.userId }, 'User updated');
+        break;
+    }
+  });
+`
+			},
+			{
+				path: "src/crons/cleanup.ts",
+				content: `import { cron } from '@geekmidas/constructs/crons';
+
+// Run every day at midnight
+export default cron('0 0 * * *')
+  .handle(async ({ logger }) => {
+    logger.info('Running cleanup job');
+
+    // Add your cleanup logic here
+    // e.g., delete old sessions, clean up temp files, etc.
+
+    logger.info('Cleanup job completed');
+  });
+`
+			}
+		];
+		if (options.telescope) files.push({
+			path: "src/config/telescope.ts",
+			content: `import { Telescope } from '@geekmidas/telescope';
+import { InMemoryStorage } from '@geekmidas/telescope/storage/memory';
+
+export const telescope = new Telescope({
+  storage: new InMemoryStorage({ maxEntries: 100 }),
+  enabled: process.env.NODE_ENV === 'development',
+});
+`
+		});
+		return files;
+	}
+};
+
+//#endregion
+//#region src/init/templates/index.ts
+/**
+* OpenAPI output path (fixed, not configurable)
+*/
+const OPENAPI_OUTPUT_PATH$1 = "./.gkm/openapi.ts";
+/**
+* All available templates
+*/
+const templates = {
+	minimal: minimalTemplate,
+	api: apiTemplate,
+	serverless: serverlessTemplate,
+	worker: workerTemplate
+};
+/**
+* Template choices for prompts
+*/
+const templateChoices = [
+	{
+		title: "Minimal",
+		value: "minimal",
+		description: "Basic health endpoint"
+	},
+	{
+		title: "API",
+		value: "api",
+		description: "Full API with auth, database, services"
+	},
+	{
+		title: "Serverless",
+		value: "serverless",
+		description: "AWS Lambda handlers"
+	},
+	{
+		title: "Worker",
+		value: "worker",
+		description: "Background job processing"
+	}
+];
+/**
+* Logger type choices for prompts
+*/
+const loggerTypeChoices = [{
+	title: "Pino",
+	value: "pino",
+	description: "Fast JSON logger for production (recommended)"
+}, {
+	title: "Console",
+	value: "console",
+	description: "Simple console logger for development"
+}];
+/**
+* Routes structure choices for prompts
+*/
+const routesStructureChoices = [
+	{
+		title: "Centralized (endpoints)",
+		value: "centralized-endpoints",
+		description: "src/endpoints/**/*.ts"
+	},
+	{
+		title: "Centralized (routes)",
+		value: "centralized-routes",
+		description: "src/routes/**/*.ts"
+	},
+	{
+		title: "Domain-based",
+		value: "domain-based",
+		description: "src/**/routes/*.ts (e.g., src/users/routes/list.ts)"
+	}
+];
+/**
+* Get a template by name
+*/
+function getTemplate(name$1) {
+	const template = templates[name$1];
+	if (!template) throw new Error(`Unknown template: ${name$1}`);
+	return template;
+}
+
+//#endregion
+//#region src/init/generators/package.ts
+/**
+* Generate package.json with dependencies based on template and options
+*/
+function generatePackageJson(options, template) {
+	const { name: name$1, telescope, database, studio, monorepo } = options;
+	const dependencies$1 = { ...template.dependencies };
+	const devDependencies$1 = { ...template.devDependencies };
+	const scripts$1 = { ...template.scripts };
+	if (telescope) dependencies$1["@geekmidas/telescope"] = "workspace:*";
+	if (studio) dependencies$1["@geekmidas/studio"] = "workspace:*";
+	if (database) {
+		dependencies$1["@geekmidas/db"] = "workspace:*";
+		dependencies$1["kysely"] = "~0.28.2";
+		dependencies$1["pg"] = "~8.16.0";
+		devDependencies$1["@types/pg"] = "~8.15.0";
+	}
+	dependencies$1["zod"] = "~4.1.0";
+	if (monorepo) {
+		delete devDependencies$1["@biomejs/biome"];
+		delete devDependencies$1["turbo"];
+		delete scripts$1["lint"];
+		delete scripts$1["fmt"];
+		delete scripts$1["fmt:check"];
+		dependencies$1[`@${name$1}/models`] = "workspace:*";
+		delete dependencies$1["zod"];
+	}
+	const sortObject = (obj) => Object.fromEntries(Object.entries(obj).sort(([a], [b]) => a.localeCompare(b)));
+	let packageName = name$1;
+	if (monorepo && options.apiPath) {
+		const pathParts = options.apiPath.split("/");
+		const appName = pathParts[pathParts.length - 1] || "api";
+		packageName = `@${name$1}/${appName}`;
+	}
+	const packageJson = {
+		name: packageName,
+		version: "0.0.1",
+		private: true,
+		type: "module",
+		exports: { "./client": {
+			types: OPENAPI_OUTPUT_PATH$1,
+			import: OPENAPI_OUTPUT_PATH$1
+		} },
+		scripts: scripts$1,
+		dependencies: sortObject(dependencies$1),
+		devDependencies: sortObject(devDependencies$1)
+	};
+	return [{
+		path: "package.json",
+		content: JSON.stringify(packageJson, null, 2) + "\n"
+	}];
+}
+
+//#endregion
+//#region src/init/generators/source.ts
+/**
+* Generate source files from template
+*/
+function generateSourceFiles(options, template) {
+	return template.files(options);
+}
+
+//#endregion
+//#region src/init/utils.ts
+/**
+* Detect the package manager being used based on lockfiles or npm_config_user_agent
+*/
+function detectPackageManager(cwd = process.cwd()) {
+	if (existsSync(join$1(cwd, "pnpm-lock.yaml"))) return "pnpm";
+	if (existsSync(join$1(cwd, "yarn.lock"))) return "yarn";
+	if (existsSync(join$1(cwd, "bun.lockb"))) return "bun";
+	if (existsSync(join$1(cwd, "package-lock.json"))) return "npm";
+	const userAgent = process.env.npm_config_user_agent || "";
+	if (userAgent.includes("pnpm")) return "pnpm";
+	if (userAgent.includes("yarn")) return "yarn";
+	if (userAgent.includes("bun")) return "bun";
+	return "npm";
+}
+/**
+* Validate project name for npm package naming conventions
+*/
+function validateProjectName(name$1) {
+	if (!name$1) return "Project name is required";
+	if (!/^[a-z0-9-_@/.]+$/i.test(name$1)) return "Project name can only contain letters, numbers, hyphens, underscores, @, /, and .";
+	const reserved = [
+		"node_modules",
+		".git",
+		"package.json",
+		"src"
+	];
+	if (reserved.includes(name$1.toLowerCase())) return `"${name$1}" is a reserved name`;
+	return true;
+}
+/**
+* Check if a directory already exists at the target path
+*/
+function checkDirectoryExists(name$1, cwd = process.cwd()) {
+	const targetPath = join$1(cwd, name$1);
+	if (existsSync(targetPath)) return `Directory "${name$1}" already exists`;
+	return true;
+}
+/**
+* Get the install command for a package manager
+*/
+function getInstallCommand(pkgManager) {
+	switch (pkgManager) {
+		case "pnpm": return "pnpm install";
+		case "yarn": return "yarn";
+		case "bun": return "bun install";
+		case "npm":
+		default: return "npm install";
+	}
+}
+/**
+* Get the dev command for a package manager
+*/
+function getRunCommand(pkgManager, script) {
+	switch (pkgManager) {
+		case "pnpm": return `pnpm ${script}`;
+		case "yarn": return `yarn ${script}`;
+		case "bun": return `bun run ${script}`;
+		case "npm":
+		default: return `npm run ${script}`;
+	}
+}
+
+//#endregion
+//#region src/init/index.ts
+/**
+* Main init command - scaffolds a new project
+*/
+async function initCommand(projectName, options = {}) {
+	const cwd = process.cwd();
+	const pkgManager = detectPackageManager(cwd);
+	prompts.override({});
+	const onCancel = () => {
+		process.exit(0);
+	};
+	const answers = await prompts([
+		{
+			type: projectName ? null : "text",
+			name: "name",
+			message: "Project name:",
+			initial: "my-api",
+			validate: (value) => {
+				const nameValid = validateProjectName(value);
+				if (nameValid !== true) return nameValid;
+				const dirValid = checkDirectoryExists(value, cwd);
+				if (dirValid !== true) return dirValid;
+				return true;
+			}
+		},
+		{
+			type: options.template || options.yes ? null : "select",
+			name: "template",
+			message: "Template:",
+			choices: templateChoices,
+			initial: 0
+		},
+		{
+			type: options.yes ? null : "confirm",
+			name: "telescope",
+			message: "Include Telescope (debugging dashboard)?",
+			initial: true
+		},
+		{
+			type: options.yes ? null : "confirm",
+			name: "database",
+			message: "Include database support (Kysely)?",
+			initial: true
+		},
+		{
+			type: (prev) => options.yes ? null : prev ? "confirm" : null,
+			name: "studio",
+			message: "Include Studio (database browser)?",
+			initial: true
+		},
+		{
+			type: options.yes ? null : "select",
+			name: "loggerType",
+			message: "Logger:",
+			choices: loggerTypeChoices,
+			initial: 0
+		},
+		{
+			type: options.yes ? null : "select",
+			name: "routesStructure",
+			message: "Routes structure:",
+			choices: routesStructureChoices,
+			initial: 0
+		},
+		{
+			type: options.yes || options.monorepo !== void 0 ? null : "confirm",
+			name: "monorepo",
+			message: "Setup as monorepo?",
+			initial: false
+		},
+		{
+			type: (prev) => (prev === true || options.monorepo) && !options.apiPath ? "text" : null,
+			name: "apiPath",
+			message: "API app path:",
+			initial: "apps/api"
+		}
+	], { onCancel });
+	const name$1 = projectName || answers.name;
+	if (!name$1) {
+		console.error("  Error: Project name is required\n");
+		process.exit(1);
+	}
+	if (projectName) {
+		const nameValid = validateProjectName(projectName);
+		if (nameValid !== true) {
+			console.error(`  Error: ${nameValid}\n`);
+			process.exit(1);
+		}
+		const dirValid = checkDirectoryExists(projectName, cwd);
+		if (dirValid !== true) {
+			console.error(`  Error: ${dirValid}\n`);
+			process.exit(1);
+		}
+	}
+	const monorepo = options.monorepo ?? (options.yes ? false : answers.monorepo ?? false);
+	const database = options.yes ? true : answers.database ?? true;
+	const templateOptions = {
+		name: name$1,
+		template: options.template || answers.template || "minimal",
+		telescope: options.yes ? true : answers.telescope ?? true,
+		database,
+		studio: database && (options.yes ? true : answers.studio ?? true),
+		loggerType: options.yes ? "pino" : answers.loggerType ?? "pino",
+		routesStructure: options.yes ? "centralized-endpoints" : answers.routesStructure ?? "centralized-endpoints",
+		monorepo,
+		apiPath: monorepo ? options.apiPath ?? answers.apiPath ?? "apps/api" : ""
+	};
+	const targetDir = join$1(cwd, name$1);
+	const template = getTemplate(templateOptions.template);
+	const isMonorepo = templateOptions.monorepo;
+	const apiPath = templateOptions.apiPath;
+	await mkdir(targetDir, { recursive: true });
+	const appDir = isMonorepo ? join$1(targetDir, apiPath) : targetDir;
+	if (isMonorepo) await mkdir(appDir, { recursive: true });
+	const appFiles = [
+		...generatePackageJson(templateOptions, template),
+		...generateConfigFiles(templateOptions, template),
+		...generateEnvFiles(templateOptions, template),
+		...generateSourceFiles(templateOptions, template),
+		...generateDockerFiles(templateOptions, template)
+	];
+	const rootFiles = [...generateMonorepoFiles(templateOptions, template), ...generateModelsPackage(templateOptions)];
+	for (const { path, content } of rootFiles) {
+		const fullPath = join$1(targetDir, path);
+		await mkdir(dirname(fullPath), { recursive: true });
+		await writeFile(fullPath, content);
+	}
+	for (const { path, content } of appFiles) {
+		const fullPath = join$1(appDir, path);
+		const displayPath = isMonorepo ? `${apiPath}/${path}` : path;
+		await mkdir(dirname(fullPath), { recursive: true });
+		await writeFile(fullPath, content);
+	}
+	if (!options.skipInstall) {
+		try {
+			execSync(getInstallCommand(pkgManager), {
+				cwd: targetDir,
+				stdio: "inherit"
+			});
+		} catch {
+			console.error("\n  Warning: Failed to install dependencies.");
+		}
+		try {
+			execSync("npx @biomejs/biome format --write --unsafe .", {
+				cwd: targetDir,
+				stdio: "inherit"
+			});
+		} catch {}
+	}
+	const devCommand$1 = getRunCommand(pkgManager, "dev");
+}
+
 //#endregion
 //#region src/index.ts
 const program = new Command();