@geekmidas/cli 0.0.1

package/dist/build-BgAllbWO.mjs

@@ -0,0 +1,156 @@
+import { loadConfig } from "./config-Bzzc89wR.mjs";
+import { loadEndpoints } from "./loadEndpoints-BL8q2rTO.mjs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join, relative } from "path";
+
+//#region src/build.ts
+const logger = console;
+async function buildCommand(options) {
+	logger.log(`Building with provider: ${options.provider}`);
+	const config = await loadConfig();
+	logger.log(`Loading routes from: ${config.routes}`);
+	logger.log(`Using envParser: ${config.envParser}`);
+	const [envParserPath, envParserName] = config.envParser.split("#");
+	const envParserImportPattern = !envParserName ? "envParser" : envParserName === "envParser" ? "{ envParser }" : `{ ${envParserName} as envParser }`;
+	const [loggerPath, loggerName] = config.logger.split("#");
+	const loggerImportPattern = !loggerName ? "logger" : loggerName === "logger" ? "{ logger }" : `{ ${loggerName} as logger }`;
+	const routes = [];
+	const outputDir = join(process.cwd(), ".gkm", options.provider);
+	await mkdir(outputDir, { recursive: true });
+	const loadedEndpoints = await loadEndpoints(config.routes);
+	if (loadedEndpoints.length === 0) {
+		logger.log("No endpoints found to process");
+		return;
+	}
+	const allEndpoints = loadedEndpoints.map(({ name, endpoint, file }) => {
+		const routeInfo = {
+			path: endpoint.route,
+			method: endpoint.method,
+			handler: ""
+		};
+		logger.log(`Found endpoint: ${name} - ${routeInfo.method} ${routeInfo.path}`);
+		return {
+			file: relative(process.cwd(), file),
+			exportName: name,
+			endpoint,
+			routeInfo
+		};
+	});
+	if (options.provider === "server") {
+		const serverFile = await generateServerFile(outputDir, allEndpoints, envParserPath, envParserImportPattern, loggerPath, loggerImportPattern);
+		routes.push({
+			path: "*",
+			method: "ALL",
+			handler: relative(process.cwd(), serverFile)
+		});
+		logger.log(`Generated server app with ${allEndpoints.length} endpoints`);
+	} else for (const { file, exportName, routeInfo } of allEndpoints) {
+		const handlerFile = await generateHandlerFile(outputDir, file, exportName, options.provider, routeInfo, envParserPath, envParserImportPattern);
+		routes.push({
+			...routeInfo,
+			handler: relative(process.cwd(), handlerFile).replace(/\.ts$/, ".handler")
+		});
+		logger.log(`Generated handler for ${routeInfo.method} ${routeInfo.path}`);
+	}
+	const manifest = { routes };
+	const manifestPath = join(outputDir, "routes.json");
+	await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+	logger.log(`Generated ${routes.length} handlers in ${relative(process.cwd(), outputDir)}`);
+	logger.log(`Routes manifest: ${relative(process.cwd(), manifestPath)}`);
+}
+async function generateServerFile(outputDir, endpoints, envParserPath, envParserImportPattern, loggerPath, loggerImportPattern) {
+	const serverFileName = "app.ts";
+	const serverPath = join(outputDir, serverFileName);
+	const importsByFile = /* @__PURE__ */ new Map();
+	for (const { file, exportName } of endpoints) {
+		const relativePath = relative(dirname(serverPath), file);
+		const importPath = relativePath.replace(/\.ts$/, ".js");
+		if (!importsByFile.has(importPath)) importsByFile.set(importPath, []);
+		importsByFile.get(importPath).push(exportName);
+	}
+	const relativeEnvParserPath = relative(dirname(serverPath), envParserPath);
+	const relativeLoggerPath = relative(dirname(serverPath), loggerPath);
+	const imports = Array.from(importsByFile.entries()).map(([importPath, exports]) => `import { ${exports.join(", ")} } from '${importPath}';`).join("\n");
+	const allExportNames = endpoints.map(({ exportName }) => exportName);
+	const content = `import { HonoEndpoint } from '@geekmidas/api/hono';
+import { HermodServiceDiscovery } from '@geekmidas/api/services';
+import { Hono } from 'hono';
+import ${envParserImportPattern} from '${relativeEnvParserPath}';
+import ${loggerImportPattern} from '${relativeLoggerPath}';
+${imports}
+
+export function createApp(app?: Hono): Hono {
+  const honoApp = app || new Hono();
+  
+  const endpoints = [
+    ${allExportNames.join(",\n    ")}
+  ];
+
+  const serviceDiscovery = HermodServiceDiscovery.getInstance(
+    logger,
+    envParser
+  );
+
+  HonoEndpoint.addRoutes(endpoints, serviceDiscovery, honoApp);
+
+  return honoApp;
+}
+
+// Default export for convenience
+export default createApp;
+`;
+	await writeFile(serverPath, content);
+	return serverPath;
+}
+async function generateHandlerFile(outputDir, sourceFile, exportName, provider, routeInfo, envParserPath, envParserImportPattern) {
+	const handlerFileName = `${exportName}.ts`;
+	const handlerPath = join(outputDir, handlerFileName);
+	const relativePath = relative(dirname(handlerPath), sourceFile);
+	const importPath = relativePath.replace(/\.ts$/, ".js");
+	const relativeEnvParserPath = relative(dirname(handlerPath), envParserPath);
+	let content;
+	switch (provider) {
+		case "aws-apigatewayv1":
+			content = generateAWSApiGatewayV1Handler(importPath, exportName, relativeEnvParserPath, envParserImportPattern);
+			break;
+		case "aws-apigatewayv2":
+			content = generateAWSApiGatewayV2Handler(importPath, exportName, relativeEnvParserPath, envParserImportPattern);
+			break;
+		case "server":
+			content = generateServerHandler(importPath, exportName);
+			break;
+		default: throw new Error(`Unsupported provider: ${provider}`);
+	}
+	await writeFile(handlerPath, content);
+	return handlerPath;
+}
+function generateAWSApiGatewayV1Handler(importPath, exportName, envParserPath, envParserImportPattern) {
+	return `import { AmazonApiGatewayV1Endpoint } from '@geekmidas/api/aws-apigateway';
+import { ${exportName} } from '${importPath}';
+import ${envParserImportPattern} from '${envParserPath}';
+
+const adapter = new AmazonApiGatewayV1Endpoint(envParser, ${exportName});
+
+export const handler = adapter.handler;
+`;
+}
+function generateAWSApiGatewayV2Handler(importPath, exportName, envParserPath, envParserImportPattern) {
+	return `import { AmazonApiGatewayV2Endpoint } from '@geekmidas/api/aws-apigateway';
+import { ${exportName} } from '${importPath}';
+import ${envParserImportPattern} from '${envParserPath}';
+
+const adapter = new AmazonApiGatewayV2Endpoint(envParser, ${exportName});
+
+export const handler = adapter.handler;
+`;
+}
+function generateServerHandler(importPath, exportName) {
+	return `import { ${exportName} } from '${importPath}';
+
+// Server handler - implement based on your server framework
+export const handler = ${exportName};
+`;
+}
+
+//#endregion
+export { buildCommand };

package/dist/build-DN7u1ccT.cjs

@@ -0,0 +1,162 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_config = require('./config-B-D8cs7V.cjs');
+const require_loadEndpoints = require('./loadEndpoints-CYFwuPZr.cjs');
+const node_fs_promises = require_chunk.__toESM(require("node:fs/promises"));
+const path = require_chunk.__toESM(require("path"));
+
+//#region src/build.ts
+const logger = console;
+async function buildCommand(options) {
+	logger.log(`Building with provider: ${options.provider}`);
+	const config = await require_config.loadConfig();
+	logger.log(`Loading routes from: ${config.routes}`);
+	logger.log(`Using envParser: ${config.envParser}`);
+	const [envParserPath, envParserName] = config.envParser.split("#");
+	const envParserImportPattern = !envParserName ? "envParser" : envParserName === "envParser" ? "{ envParser }" : `{ ${envParserName} as envParser }`;
+	const [loggerPath, loggerName] = config.logger.split("#");
+	const loggerImportPattern = !loggerName ? "logger" : loggerName === "logger" ? "{ logger }" : `{ ${loggerName} as logger }`;
+	const routes = [];
+	const outputDir = (0, path.join)(process.cwd(), ".gkm", options.provider);
+	await (0, node_fs_promises.mkdir)(outputDir, { recursive: true });
+	const loadedEndpoints = await require_loadEndpoints.loadEndpoints(config.routes);
+	if (loadedEndpoints.length === 0) {
+		logger.log("No endpoints found to process");
+		return;
+	}
+	const allEndpoints = loadedEndpoints.map(({ name, endpoint, file }) => {
+		const routeInfo = {
+			path: endpoint.route,
+			method: endpoint.method,
+			handler: ""
+		};
+		logger.log(`Found endpoint: ${name} - ${routeInfo.method} ${routeInfo.path}`);
+		return {
+			file: (0, path.relative)(process.cwd(), file),
+			exportName: name,
+			endpoint,
+			routeInfo
+		};
+	});
+	if (options.provider === "server") {
+		const serverFile = await generateServerFile(outputDir, allEndpoints, envParserPath, envParserImportPattern, loggerPath, loggerImportPattern);
+		routes.push({
+			path: "*",
+			method: "ALL",
+			handler: (0, path.relative)(process.cwd(), serverFile)
+		});
+		logger.log(`Generated server app with ${allEndpoints.length} endpoints`);
+	} else for (const { file, exportName, routeInfo } of allEndpoints) {
+		const handlerFile = await generateHandlerFile(outputDir, file, exportName, options.provider, routeInfo, envParserPath, envParserImportPattern);
+		routes.push({
+			...routeInfo,
+			handler: (0, path.relative)(process.cwd(), handlerFile).replace(/\.ts$/, ".handler")
+		});
+		logger.log(`Generated handler for ${routeInfo.method} ${routeInfo.path}`);
+	}
+	const manifest = { routes };
+	const manifestPath = (0, path.join)(outputDir, "routes.json");
+	await (0, node_fs_promises.writeFile)(manifestPath, JSON.stringify(manifest, null, 2));
+	logger.log(`Generated ${routes.length} handlers in ${(0, path.relative)(process.cwd(), outputDir)}`);
+	logger.log(`Routes manifest: ${(0, path.relative)(process.cwd(), manifestPath)}`);
+}
+async function generateServerFile(outputDir, endpoints, envParserPath, envParserImportPattern, loggerPath, loggerImportPattern) {
+	const serverFileName = "app.ts";
+	const serverPath = (0, path.join)(outputDir, serverFileName);
+	const importsByFile = /* @__PURE__ */ new Map();
+	for (const { file, exportName } of endpoints) {
+		const relativePath = (0, path.relative)((0, path.dirname)(serverPath), file);
+		const importPath = relativePath.replace(/\.ts$/, ".js");
+		if (!importsByFile.has(importPath)) importsByFile.set(importPath, []);
+		importsByFile.get(importPath).push(exportName);
+	}
+	const relativeEnvParserPath = (0, path.relative)((0, path.dirname)(serverPath), envParserPath);
+	const relativeLoggerPath = (0, path.relative)((0, path.dirname)(serverPath), loggerPath);
+	const imports = Array.from(importsByFile.entries()).map(([importPath, exports$1]) => `import { ${exports$1.join(", ")} } from '${importPath}';`).join("\n");
+	const allExportNames = endpoints.map(({ exportName }) => exportName);
+	const content = `import { HonoEndpoint } from '@geekmidas/api/hono';
+import { HermodServiceDiscovery } from '@geekmidas/api/services';
+import { Hono } from 'hono';
+import ${envParserImportPattern} from '${relativeEnvParserPath}';
+import ${loggerImportPattern} from '${relativeLoggerPath}';
+${imports}
+
+export function createApp(app?: Hono): Hono {
+  const honoApp = app || new Hono();
+  
+  const endpoints = [
+    ${allExportNames.join(",\n    ")}
+  ];
+
+  const serviceDiscovery = HermodServiceDiscovery.getInstance(
+    logger,
+    envParser
+  );
+
+  HonoEndpoint.addRoutes(endpoints, serviceDiscovery, honoApp);
+
+  return honoApp;
+}
+
+// Default export for convenience
+export default createApp;
+`;
+	await (0, node_fs_promises.writeFile)(serverPath, content);
+	return serverPath;
+}
+async function generateHandlerFile(outputDir, sourceFile, exportName, provider, routeInfo, envParserPath, envParserImportPattern) {
+	const handlerFileName = `${exportName}.ts`;
+	const handlerPath = (0, path.join)(outputDir, handlerFileName);
+	const relativePath = (0, path.relative)((0, path.dirname)(handlerPath), sourceFile);
+	const importPath = relativePath.replace(/\.ts$/, ".js");
+	const relativeEnvParserPath = (0, path.relative)((0, path.dirname)(handlerPath), envParserPath);
+	let content;
+	switch (provider) {
+		case "aws-apigatewayv1":
+			content = generateAWSApiGatewayV1Handler(importPath, exportName, relativeEnvParserPath, envParserImportPattern);
+			break;
+		case "aws-apigatewayv2":
+			content = generateAWSApiGatewayV2Handler(importPath, exportName, relativeEnvParserPath, envParserImportPattern);
+			break;
+		case "server":
+			content = generateServerHandler(importPath, exportName);
+			break;
+		default: throw new Error(`Unsupported provider: ${provider}`);
+	}
+	await (0, node_fs_promises.writeFile)(handlerPath, content);
+	return handlerPath;
+}
+function generateAWSApiGatewayV1Handler(importPath, exportName, envParserPath, envParserImportPattern) {
+	return `import { AmazonApiGatewayV1Endpoint } from '@geekmidas/api/aws-apigateway';
+import { ${exportName} } from '${importPath}';
+import ${envParserImportPattern} from '${envParserPath}';
+
+const adapter = new AmazonApiGatewayV1Endpoint(envParser, ${exportName});
+
+export const handler = adapter.handler;
+`;
+}
+function generateAWSApiGatewayV2Handler(importPath, exportName, envParserPath, envParserImportPattern) {
+	return `import { AmazonApiGatewayV2Endpoint } from '@geekmidas/api/aws-apigateway';
+import { ${exportName} } from '${importPath}';
+import ${envParserImportPattern} from '${envParserPath}';
+
+const adapter = new AmazonApiGatewayV2Endpoint(envParser, ${exportName});
+
+export const handler = adapter.handler;
+`;
+}
+function generateServerHandler(importPath, exportName) {
+	return `import { ${exportName} } from '${importPath}';
+
+// Server handler - implement based on your server framework
+export const handler = ${exportName};
+`;
+}
+
+//#endregion
+Object.defineProperty(exports, 'buildCommand', {
+  enumerable: true,
+  get: function () {
+    return buildCommand;
+  }
+});

package/dist/build.cjs

@@ -0,0 +1,5 @@
+require('./config-B-D8cs7V.cjs');
+require('./loadEndpoints-CYFwuPZr.cjs');
+const require_build = require('./build-DN7u1ccT.cjs');
+
+exports.buildCommand = require_build.buildCommand;

package/dist/build.mjs

@@ -0,0 +1,5 @@
+import "./config-Bzzc89wR.mjs";
+import "./loadEndpoints-BL8q2rTO.mjs";
+import { buildCommand } from "./build-BgAllbWO.mjs";
+
+export { buildCommand };

package/dist/chunk-CUT6urMc.cjs

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/cli-D6VgkVGJ.mjs

@@ -0,0 +1,35 @@
+import { buildCommand } from "./build-BgAllbWO.mjs";
+import { openapiCommand } from "./openapi-DLix_iqn.mjs";
+import { Command } from "commander";
+
+//#region src/cli.ts
+const program = new Command();
+program.name("gkm").description("GeekMidas backend framework CLI").version("0.0.2");
+program.command("build").description("Build API handlers from endpoints").option("--provider <provider>", "Target provider for generated handlers", "aws-apigatewayv1").action(async (options) => {
+	try {
+		await buildCommand(options);
+	} catch (error) {
+		console.error("Build failed:", error.message);
+		process.exit(1);
+	}
+});
+program.command("cron").description("Manage cron jobs").action(() => {
+	process.stdout.write("Cron management - coming soon\n");
+});
+program.command("function").description("Manage serverless functions").action(() => {
+	process.stdout.write("Serverless function management - coming soon\n");
+});
+program.command("api").description("Manage REST API endpoints").action(() => {
+	process.stdout.write("REST API management - coming soon\n");
+});
+program.command("openapi").description("Generate OpenAPI 3.0 specification from endpoints").option("--output <path>", "Output file path for the OpenAPI spec", "openapi.json").action(async (options) => {
+	try {
+		await openapiCommand(options);
+	} catch (error) {
+		console.error("OpenAPI generation failed:", error.message);
+		process.exit(1);
+	}
+});
+program.parse();
+
+//#endregion

package/dist/cli-eVdV1MSk.cjs

@@ -0,0 +1,36 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_build = require('./build-DN7u1ccT.cjs');
+const require_openapi = require('./openapi-BKjcm03Q.cjs');
+const commander = require_chunk.__toESM(require("commander"));
+
+//#region src/cli.ts
+const program = new commander.Command();
+program.name("gkm").description("GeekMidas backend framework CLI").version("0.0.2");
+program.command("build").description("Build API handlers from endpoints").option("--provider <provider>", "Target provider for generated handlers", "aws-apigatewayv1").action(async (options) => {
+	try {
+		await require_build.buildCommand(options);
+	} catch (error) {
+		console.error("Build failed:", error.message);
+		process.exit(1);
+	}
+});
+program.command("cron").description("Manage cron jobs").action(() => {
+	process.stdout.write("Cron management - coming soon\n");
+});
+program.command("function").description("Manage serverless functions").action(() => {
+	process.stdout.write("Serverless function management - coming soon\n");
+});
+program.command("api").description("Manage REST API endpoints").action(() => {
+	process.stdout.write("REST API management - coming soon\n");
+});
+program.command("openapi").description("Generate OpenAPI 3.0 specification from endpoints").option("--output <path>", "Output file path for the OpenAPI spec", "openapi.json").action(async (options) => {
+	try {
+		await require_openapi.openapiCommand(options);
+	} catch (error) {
+		console.error("OpenAPI generation failed:", error.message);
+		process.exit(1);
+	}
+});
+program.parse();
+
+//#endregion

package/dist/cli.cjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+require('./config-B-D8cs7V.cjs');
+require('./loadEndpoints-CYFwuPZr.cjs');
+require('./build-DN7u1ccT.cjs');
+require('./openapi-BKjcm03Q.cjs');
+require('./cli-eVdV1MSk.cjs');

package/dist/cli.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import "./config-Bzzc89wR.mjs";
+import "./loadEndpoints-BL8q2rTO.mjs";
+import "./build-BgAllbWO.mjs";
+import "./openapi-DLix_iqn.mjs";
+import "./cli-D6VgkVGJ.mjs";

package/dist/config-B-D8cs7V.cjs

@@ -0,0 +1,23 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const path = require_chunk.__toESM(require("path"));
+const fs = require_chunk.__toESM(require("fs"));
+
+//#region src/config.ts
+async function loadConfig() {
+	const configPath = (0, path.join)(process.cwd(), "gkm.config.ts");
+	if (!(0, fs.existsSync)(configPath)) throw new Error("gkm.config.ts not found. Please create a configuration file.");
+	try {
+		const config = await import(configPath);
+		return config.default || config;
+	} catch (error) {
+		throw new Error(`Failed to load gkm.config.ts: ${error.message}`);
+	}
+}
+
+//#endregion
+Object.defineProperty(exports, 'loadConfig', {
+  enumerable: true,
+  get: function () {
+    return loadConfig;
+  }
+});

package/dist/config-Bzzc89wR.mjs

@@ -0,0 +1,17 @@
+import { join } from "path";
+import { existsSync } from "fs";
+
+//#region src/config.ts
+async function loadConfig() {
+	const configPath = join(process.cwd(), "gkm.config.ts");
+	if (!existsSync(configPath)) throw new Error("gkm.config.ts not found. Please create a configuration file.");
+	try {
+		const config = await import(configPath);
+		return config.default || config;
+	} catch (error) {
+		throw new Error(`Failed to load gkm.config.ts: ${error.message}`);
+	}
+}
+
+//#endregion
+export { loadConfig };

package/dist/config.cjs

@@ -0,0 +1,3 @@
+const require_config = require('./config-B-D8cs7V.cjs');
+
+exports.loadConfig = require_config.loadConfig;

package/dist/config.mjs

@@ -0,0 +1,3 @@
+import { loadConfig } from "./config-Bzzc89wR.mjs";
+
+export { loadConfig };

package/dist/index.cjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env -S npx tsx
+require('./config-B-D8cs7V.cjs');
+require('./loadEndpoints-CYFwuPZr.cjs');
+require('./build-DN7u1ccT.cjs');
+require('./openapi-BKjcm03Q.cjs');
+require('./cli-eVdV1MSk.cjs');

package/dist/index.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env -S npx tsx
+import "./config-Bzzc89wR.mjs";
+import "./loadEndpoints-BL8q2rTO.mjs";
+import "./build-BgAllbWO.mjs";
+import "./openapi-DLix_iqn.mjs";
+import "./cli-D6VgkVGJ.mjs";

package/dist/loadEndpoints-BL8q2rTO.mjs

@@ -0,0 +1,27 @@
+import { Endpoint } from "@geekmidas/api/server";
+import fg from "fast-glob";
+
+//#region src/loadEndpoints.ts
+async function loadEndpoints(routes) {
+	const logger = console;
+	const files = await fg.stream(routes, {
+		cwd: process.cwd(),
+		absolute: true
+	});
+	const endpoints = [];
+	for await (const f of files) try {
+		const file = f.toString();
+		const module = await import(file);
+		for (const [exportName, exportValue] of Object.entries(module)) if (Endpoint.isEndpoint(exportValue)) endpoints.push({
+			name: exportName,
+			endpoint: exportValue,
+			file
+		});
+	} catch (error) {
+		logger.warn(`Failed to load ${f}:`, error.message);
+	}
+	return endpoints;
+}
+
+//#endregion
+export { loadEndpoints };

package/dist/loadEndpoints-CYFwuPZr.cjs

@@ -0,0 +1,33 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const __geekmidas_api_server = require_chunk.__toESM(require("@geekmidas/api/server"));
+const fast_glob = require_chunk.__toESM(require("fast-glob"));
+
+//#region src/loadEndpoints.ts
+async function loadEndpoints(routes) {
+	const logger = console;
+	const files = await fast_glob.default.stream(routes, {
+		cwd: process.cwd(),
+		absolute: true
+	});
+	const endpoints = [];
+	for await (const f of files) try {
+		const file = f.toString();
+		const module$1 = await import(file);
+		for (const [exportName, exportValue] of Object.entries(module$1)) if (__geekmidas_api_server.Endpoint.isEndpoint(exportValue)) endpoints.push({
+			name: exportName,
+			endpoint: exportValue,
+			file
+		});
+	} catch (error) {
+		logger.warn(`Failed to load ${f}:`, error.message);
+	}
+	return endpoints;
+}
+
+//#endregion
+Object.defineProperty(exports, 'loadEndpoints', {
+  enumerable: true,
+  get: function () {
+    return loadEndpoints;
+  }
+});

package/dist/loadEndpoints.cjs

@@ -0,0 +1,3 @@
+const require_loadEndpoints = require('./loadEndpoints-CYFwuPZr.cjs');
+
+exports.loadEndpoints = require_loadEndpoints.loadEndpoints;

package/dist/loadEndpoints.mjs

@@ -0,0 +1,3 @@
+import { loadEndpoints } from "./loadEndpoints-BL8q2rTO.mjs";
+
+export { loadEndpoints };

package/dist/openapi-BKjcm03Q.cjs

@@ -0,0 +1,40 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_config = require('./config-B-D8cs7V.cjs');
+const require_loadEndpoints = require('./loadEndpoints-CYFwuPZr.cjs');
+const node_fs_promises = require_chunk.__toESM(require("node:fs/promises"));
+const __geekmidas_api_server = require_chunk.__toESM(require("@geekmidas/api/server"));
+const node_path = require_chunk.__toESM(require("node:path"));
+
+//#region src/openapi.ts
+async function openapiCommand(options = {}) {
+	const logger = console;
+	try {
+		const config = await require_config.loadConfig();
+		const loadedEndpoints = await require_loadEndpoints.loadEndpoints(config.routes);
+		if (loadedEndpoints.length === 0) {
+			logger.log("No valid endpoints found");
+			return;
+		}
+		const endpoints = loadedEndpoints.map(({ endpoint }) => endpoint);
+		const spec = await __geekmidas_api_server.Endpoint.buildOpenApiSchema(endpoints, {
+			title: "API Documentation",
+			version: "1.0.0",
+			description: "Auto-generated API documentation from endpoints"
+		});
+		const outputPath = options.output || (0, node_path.join)(process.cwd(), "openapi.json");
+		await (0, node_fs_promises.mkdir)((0, node_path.join)(outputPath, ".."), { recursive: true });
+		await (0, node_fs_promises.writeFile)(outputPath, JSON.stringify(spec, null, 2));
+		logger.log(`OpenAPI spec generated: ${outputPath}`);
+		logger.log(`Found ${endpoints.length} endpoints`);
+	} catch (error) {
+		throw new Error(`OpenAPI generation failed: ${error.message}`);
+	}
+}
+
+//#endregion
+Object.defineProperty(exports, 'openapiCommand', {
+  enumerable: true,
+  get: function () {
+    return openapiCommand;
+  }
+});

package/dist/openapi-DLix_iqn.mjs

@@ -0,0 +1,34 @@
+import { loadConfig } from "./config-Bzzc89wR.mjs";
+import { loadEndpoints } from "./loadEndpoints-BL8q2rTO.mjs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { Endpoint } from "@geekmidas/api/server";
+import { join } from "node:path";
+
+//#region src/openapi.ts
+async function openapiCommand(options = {}) {
+	const logger = console;
+	try {
+		const config = await loadConfig();
+		const loadedEndpoints = await loadEndpoints(config.routes);
+		if (loadedEndpoints.length === 0) {
+			logger.log("No valid endpoints found");
+			return;
+		}
+		const endpoints = loadedEndpoints.map(({ endpoint }) => endpoint);
+		const spec = await Endpoint.buildOpenApiSchema(endpoints, {
+			title: "API Documentation",
+			version: "1.0.0",
+			description: "Auto-generated API documentation from endpoints"
+		});
+		const outputPath = options.output || join(process.cwd(), "openapi.json");
+		await mkdir(join(outputPath, ".."), { recursive: true });
+		await writeFile(outputPath, JSON.stringify(spec, null, 2));
+		logger.log(`OpenAPI spec generated: ${outputPath}`);
+		logger.log(`Found ${endpoints.length} endpoints`);
+	} catch (error) {
+		throw new Error(`OpenAPI generation failed: ${error.message}`);
+	}
+}
+
+//#endregion
+export { openapiCommand };

package/dist/openapi.cjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env -S npx tsx
+require('./config-B-D8cs7V.cjs');
+require('./loadEndpoints-CYFwuPZr.cjs');
+const require_openapi = require('./openapi-BKjcm03Q.cjs');
+
+exports.openapiCommand = require_openapi.openapiCommand;

package/dist/openapi.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env -S npx tsx
+import "./config-Bzzc89wR.mjs";
+import "./loadEndpoints-BL8q2rTO.mjs";
+import { openapiCommand } from "./openapi-DLix_iqn.mjs";
+
+export { openapiCommand };

package/examples/env.ts

@@ -0,0 +1,33 @@
+import { EnvironmentParser } from '@geekmidas/envkit';
+
+export const envParser = new EnvironmentParser(process.env)
+  .create((get) => ({
+    // Database configuration
+    database: {
+      url: get('DATABASE_URL').string().url(),
+      maxConnections: get('DB_MAX_CONNECTIONS')
+        .string()
+        .transform(Number)
+        .default('10'),
+    },
+
+    // API configuration
+    api: {
+      port: get('PORT').string().transform(Number).default('3000'),
+      cors: {
+        origin: get('CORS_ORIGIN').string().default('*'),
+      },
+    },
+
+    // AWS configuration (for Lambda deployments)
+    aws: {
+      region: get('AWS_REGION').string().default('us-east-1'),
+    },
+
+    // Application settings
+    app: {
+      environment: get('NODE_ENV').string().default('development'),
+      logLevel: get('LOG_LEVEL').string().default('info'),
+    },
+  }))
+  .parse();

package/examples/gkm.config.ts

@@ -0,0 +1,16 @@
+import type { GkmConfig } from '@geekmidas/cli';
+
+const config: GkmConfig = {
+  // Glob pattern to find endpoint files
+  routes: 'src/routes/**/*.ts',
+
+  // Environment parser configuration
+  // Format: path#exportName (if no #exportName, treats as default import)
+  envParser: './src/env.ts#envParser',
+
+  // Logger configuration
+  // Format: path#exportName (if no #exportName, treats as default import)
+  logger: './src/logger.ts#logger',
+};
+
+export default config;

package/examples/logger.ts

@@ -0,0 +1,10 @@
+import { ConsoleLogger } from '@geekmidas/api/logger';
+
+// Create a console logger instance
+export const logger = new ConsoleLogger({
+  level: process.env.LOG_LEVEL || 'info',
+  pretty: process.env.NODE_ENV !== 'production',
+});
+
+// You can also export a default logger
+export default logger;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@geekmidas/cli",
+  "version": "0.0.1",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "gkm": "./dist/index.mjs"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "types": "./src/index.ts"
+    }
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "dependencies": {
+    "commander": "~14.0.0",
+    "lodash.get": "~4.4.2",
+    "lodash.set": "~4.3.2",
+    "zod": "~3.25.67",
+    "fast-glob": "~3.3.3",
+    "@geekmidas/api": "0.0.3"
+  },
+  "devDependencies": {
+    "@types/lodash.get": "~4.4.9",
+    "@types/lodash.set": "~4.3.9"
+  }
+}

package/src/build.ts

@@ -0,0 +1,283 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join, relative } from 'path';
+import { loadConfig } from './config.js';
+import { loadEndpoints } from './loadEndpoints.js';
+import type {
+  BuildOptions,
+  Provider,
+  RouteInfo,
+  RoutesManifest,
+} from './types.js';
+
+const logger = console;
+export async function buildCommand(options: BuildOptions): Promise<void> {
+  logger.log(`Building with provider: ${options.provider}`);
+
+  const config = await loadConfig();
+  logger.log(`Loading routes from: ${config.routes}`);
+  logger.log(`Using envParser: ${config.envParser}`);
+
+  // Parse envParser configuration
+  const [envParserPath, envParserName] = config.envParser.split('#');
+  const envParserImportPattern = !envParserName
+    ? 'envParser'
+    : envParserName === 'envParser'
+      ? '{ envParser }'
+      : `{ ${envParserName} as envParser }`;
+
+  // Parse logger configuration
+  const [loggerPath, loggerName] = config.logger.split('#');
+  const loggerImportPattern = !loggerName
+    ? 'logger'
+    : loggerName === 'logger'
+      ? '{ logger }'
+      : `{ ${loggerName} as logger }`;
+
+  const routes: RouteInfo[] = [];
+  const outputDir = join(process.cwd(), '.gkm', options.provider);
+
+  // Ensure output directory exists
+  await mkdir(outputDir, { recursive: true });
+
+  // Load all endpoints using the refactored function
+  const loadedEndpoints = await loadEndpoints(config.routes);
+
+  if (loadedEndpoints.length === 0) {
+    logger.log('No endpoints found to process');
+    return;
+  }
+
+  const allEndpoints = loadedEndpoints.map(({ name, endpoint, file }) => {
+    const routeInfo: RouteInfo = {
+      path: endpoint.route,
+      method: endpoint.method,
+      handler: '', // Will be filled in later
+    };
+
+    logger.log(
+      `Found endpoint: ${name} - ${routeInfo.method} ${routeInfo.path}`,
+    );
+
+    return {
+      file: relative(process.cwd(), file),
+      exportName: name,
+      endpoint,
+      routeInfo,
+    };
+  });
+
+  // Generate handlers based on provider
+  if (options.provider === 'server') {
+    // Generate single server file with all endpoints
+    const serverFile = await generateServerFile(
+      outputDir,
+      allEndpoints,
+      envParserPath,
+      envParserImportPattern,
+      loggerPath,
+      loggerImportPattern,
+    );
+
+    routes.push({
+      path: '*',
+      method: 'ALL',
+      handler: relative(process.cwd(), serverFile),
+    });
+
+    logger.log(`Generated server app with ${allEndpoints.length} endpoints`);
+  } else {
+    // Generate individual handler files for AWS providers
+    for (const { file, exportName, routeInfo } of allEndpoints) {
+      const handlerFile = await generateHandlerFile(
+        outputDir,
+        file,
+        exportName,
+        options.provider,
+        routeInfo,
+        envParserPath,
+        envParserImportPattern,
+      );
+
+      routes.push({
+        ...routeInfo,
+        handler: relative(process.cwd(), handlerFile).replace(
+          /\.ts$/,
+          '.handler',
+        ),
+      });
+
+      logger.log(`Generated handler for ${routeInfo.method} ${routeInfo.path}`);
+    }
+  }
+
+  // Generate routes.json
+  const manifest: RoutesManifest = { routes };
+  const manifestPath = join(outputDir, 'routes.json');
+  await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+
+  logger.log(
+    `Generated ${routes.length} handlers in ${relative(process.cwd(), outputDir)}`,
+  );
+  logger.log(`Routes manifest: ${relative(process.cwd(), manifestPath)}`);
+}
+
+async function generateServerFile(
+  outputDir: string,
+  endpoints: Array<{
+    file: string;
+    exportName: string;
+    endpoint: any;
+    routeInfo: RouteInfo;
+  }>,
+  envParserPath: string,
+  envParserImportPattern: string,
+  loggerPath: string,
+  loggerImportPattern: string,
+): Promise<string> {
+  const serverFileName = 'app.ts';
+  const serverPath = join(outputDir, serverFileName);
+
+  // Group imports by file
+  const importsByFile = new Map<string, string[]>();
+
+  for (const { file, exportName } of endpoints) {
+    const relativePath = relative(dirname(serverPath), file);
+    const importPath = relativePath.replace(/\.ts$/, '.js');
+
+    if (!importsByFile.has(importPath)) {
+      importsByFile.set(importPath, []);
+    }
+    importsByFile.get(importPath)!.push(exportName);
+  }
+
+  const relativeEnvParserPath = relative(dirname(serverPath), envParserPath);
+  const relativeLoggerPath = relative(dirname(serverPath), loggerPath);
+
+  // Generate import statements
+  const imports = Array.from(importsByFile.entries())
+    .map(
+      ([importPath, exports]) =>
+        `import { ${exports.join(', ')} } from '${importPath}';`,
+    )
+    .join('\n');
+
+  const allExportNames = endpoints.map(({ exportName }) => exportName);
+
+  const content = `import { HonoEndpoint } from '@geekmidas/api/hono';
+import { HermodServiceDiscovery } from '@geekmidas/api/services';
+import { Hono } from 'hono';
+import ${envParserImportPattern} from '${relativeEnvParserPath}';
+import ${loggerImportPattern} from '${relativeLoggerPath}';
+${imports}
+
+export function createApp(app?: Hono): Hono {
+  const honoApp = app || new Hono();
+  
+  const endpoints = [
+    ${allExportNames.join(',\n    ')}
+  ];
+
+  const serviceDiscovery = HermodServiceDiscovery.getInstance(
+    logger,
+    envParser
+  );
+
+  HonoEndpoint.addRoutes(endpoints, serviceDiscovery, honoApp);
+
+  return honoApp;
+}
+
+// Default export for convenience
+export default createApp;
+`;
+
+  await writeFile(serverPath, content);
+  return serverPath;
+}
+
+async function generateHandlerFile(
+  outputDir: string,
+  sourceFile: string,
+  exportName: string,
+  provider: Provider,
+  routeInfo: RouteInfo,
+  envParserPath: string,
+  envParserImportPattern: string,
+): Promise<string> {
+  const handlerFileName = `${exportName}.ts`;
+  const handlerPath = join(outputDir, handlerFileName);
+
+  const relativePath = relative(dirname(handlerPath), sourceFile);
+  const importPath = relativePath.replace(/\.ts$/, '.js');
+
+  const relativeEnvParserPath = relative(dirname(handlerPath), envParserPath);
+
+  let content: string;
+
+  switch (provider) {
+    case 'aws-apigatewayv1':
+      content = generateAWSApiGatewayV1Handler(
+        importPath,
+        exportName,
+        relativeEnvParserPath,
+        envParserImportPattern,
+      );
+      break;
+    case 'aws-apigatewayv2':
+      content = generateAWSApiGatewayV2Handler(
+        importPath,
+        exportName,
+        relativeEnvParserPath,
+        envParserImportPattern,
+      );
+      break;
+    case 'server':
+      content = generateServerHandler(importPath, exportName);
+      break;
+    default:
+      throw new Error(`Unsupported provider: ${provider}`);
+  }
+
+  await writeFile(handlerPath, content);
+  return handlerPath;
+}
+
+function generateAWSApiGatewayV1Handler(
+  importPath: string,
+  exportName: string,
+  envParserPath: string,
+  envParserImportPattern: string,
+): string {
+  return `import { AmazonApiGatewayV1Endpoint } from '@geekmidas/api/aws-apigateway';
+import { ${exportName} } from '${importPath}';
+import ${envParserImportPattern} from '${envParserPath}';
+
+const adapter = new AmazonApiGatewayV1Endpoint(envParser, ${exportName});
+
+export const handler = adapter.handler;
+`;
+}
+
+function generateAWSApiGatewayV2Handler(
+  importPath: string,
+  exportName: string,
+  envParserPath: string,
+  envParserImportPattern: string,
+): string {
+  return `import { AmazonApiGatewayV2Endpoint } from '@geekmidas/api/aws-apigateway';
+import { ${exportName} } from '${importPath}';
+import ${envParserImportPattern} from '${envParserPath}';
+
+const adapter = new AmazonApiGatewayV2Endpoint(envParser, ${exportName});
+
+export const handler = adapter.handler;
+`;
+}
+
+function generateServerHandler(importPath: string, exportName: string): string {
+  return `import { ${exportName} } from '${importPath}';
+
+// Server handler - implement based on your server framework
+export const handler = ${exportName};
+`;
+}

package/src/cli.ts

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { buildCommand } from './build.js';
+import { openapiCommand } from './openapi.js';
+import type { Provider } from './types.js';
+
+const program = new Command();
+
+program
+  .name('gkm')
+  .description('GeekMidas backend framework CLI')
+  .version('0.0.2');
+
+program
+  .command('build')
+  .description('Build API handlers from endpoints')
+  .option(
+    '--provider <provider>',
+    'Target provider for generated handlers',
+    'aws-apigatewayv1',
+  )
+  .action(async (options: { provider: Provider }) => {
+    try {
+      await buildCommand(options);
+    } catch (error) {
+      console.error('Build failed:', (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('cron')
+  .description('Manage cron jobs')
+  .action(() => {
+    process.stdout.write('Cron management - coming soon\n');
+  });
+
+program
+  .command('function')
+  .description('Manage serverless functions')
+  .action(() => {
+    process.stdout.write('Serverless function management - coming soon\n');
+  });
+
+program
+  .command('api')
+  .description('Manage REST API endpoints')
+  .action(() => {
+    process.stdout.write('REST API management - coming soon\n');
+  });
+
+program
+  .command('openapi')
+  .description('Generate OpenAPI 3.0 specification from endpoints')
+  .option(
+    '--output <path>',
+    'Output file path for the OpenAPI spec',
+    'openapi.json',
+  )
+  .action(async (options: { output?: string }) => {
+    try {
+      await openapiCommand(options);
+    } catch (error) {
+      console.error('OpenAPI generation failed:', (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/src/config.ts

@@ -0,0 +1,22 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import type { GkmConfig } from './types.js';
+
+export async function loadConfig(): Promise<GkmConfig> {
+  const configPath = join(process.cwd(), 'gkm.config.ts');
+
+  if (!existsSync(configPath)) {
+    throw new Error(
+      'gkm.config.ts not found. Please create a configuration file.',
+    );
+  }
+
+  try {
+    const config = await import(configPath);
+    return config.default || config;
+  } catch (error) {
+    throw new Error(
+      `Failed to load gkm.config.ts: ${(error as Error).message}`,
+    );
+  }
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env -S npx tsx
+
+import './cli.js';
+
+// Export types for user configuration
+export type { GkmConfig, Provider, BuildOptions } from './types.js';

package/src/loadEndpoints.ts

@@ -0,0 +1,43 @@
+import { Endpoint } from '@geekmidas/api/server';
+import fg from 'fast-glob';
+
+export interface LoadedEndpoint {
+  name: string;
+  endpoint: Endpoint<any, any, any, any, any, any>;
+  file: string;
+}
+
+export async function loadEndpoints(routes: string): Promise<LoadedEndpoint[]> {
+  const logger = console;
+
+  // Find all endpoint files
+  const files = await fg.stream(routes, {
+    cwd: process.cwd(),
+    absolute: true,
+  });
+
+  // Load endpoints
+  const endpoints: LoadedEndpoint[] = [];
+
+  for await (const f of files) {
+    try {
+      const file = f.toString();
+      const module = await import(file);
+
+      // Check all exports for endpoints
+      for (const [exportName, exportValue] of Object.entries(module)) {
+        if (Endpoint.isEndpoint(exportValue as any)) {
+          endpoints.push({
+            name: exportName,
+            endpoint: exportValue as Endpoint<any, any, any, any, any, any>,
+            file,
+          });
+        }
+      }
+    } catch (error) {
+      logger.warn(`Failed to load ${f}:`, (error as Error).message);
+    }
+  }
+
+  return endpoints;
+}

package/src/openapi.ts

@@ -0,0 +1,50 @@
+#!/usr/bin/env -S npx tsx
+
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { Endpoint } from '@geekmidas/api/server';
+import { loadConfig } from './config.js';
+import { loadEndpoints } from './loadEndpoints.js';
+
+interface OpenAPIOptions {
+  output?: string;
+}
+
+export async function openapiCommand(
+  options: OpenAPIOptions = {},
+): Promise<void> {
+  const logger = console;
+
+  try {
+    // Load config using existing function
+    const config = await loadConfig();
+
+    // Load all endpoints using the refactored function
+    const loadedEndpoints = await loadEndpoints(config.routes);
+
+    if (loadedEndpoints.length === 0) {
+      logger.log('No valid endpoints found');
+      return;
+    }
+
+    // Extract just the endpoint instances for OpenAPI generation
+    const endpoints = loadedEndpoints.map(({ endpoint }) => endpoint);
+
+    // Generate OpenAPI spec using built-in method
+    const spec = await Endpoint.buildOpenApiSchema(endpoints, {
+      title: 'API Documentation',
+      version: '1.0.0',
+      description: 'Auto-generated API documentation from endpoints',
+    });
+
+    // Write output
+    const outputPath = options.output || join(process.cwd(), 'openapi.json');
+    await mkdir(join(outputPath, '..'), { recursive: true });
+    await writeFile(outputPath, JSON.stringify(spec, null, 2));
+
+    logger.log(`OpenAPI spec generated: ${outputPath}`);
+    logger.log(`Found ${endpoints.length} endpoints`);
+  } catch (error) {
+    throw new Error(`OpenAPI generation failed: ${(error as Error).message}`);
+  }
+}

package/src/types.ts

@@ -0,0 +1,21 @@
+export type Provider = 'server' | 'aws-apigatewayv1' | 'aws-apigatewayv2';
+
+export interface GkmConfig {
+  routes: string;
+  envParser: string;
+  logger: string;
+}
+
+export interface BuildOptions {
+  provider: Provider;
+}
+
+export interface RouteInfo {
+  path: string;
+  method: string;
+  handler: string;
+}
+
+export interface RoutesManifest {
+  routes: RouteInfo[];
+}

package/tsdown.config.ts

@@ -0,0 +1,3 @@
+import { defineConfig } from 'tsdown';
+
+export default defineConfig({});