@geekmidas/cli 0.0.15 → 0.0.17

package/dist/build-DqTE4qtW.mjs

@@ -0,0 +1,160 @@
+import { loadConfig } from "./config-BciAdY6_.mjs";
+import { loadEndpoints } from "./loadEndpoints-DAZ53Og2.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 providers: ${options.providers.join(", ")}`);
+	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 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._path,
+			method: endpoint.method,
+			handler: ""
+		};
+		logger.log(`Found endpoint: ${name} - ${routeInfo.method} ${routeInfo.path}`);
+		return {
+			file: relative(process.cwd(), file),
+			exportName: name,
+			endpoint,
+			routeInfo
+		};
+	});
+	for (const provider of options.providers) {
+		const routes = [];
+		const outputDir = join(process.cwd(), ".gkm", provider);
+		await mkdir(outputDir, { recursive: true });
+		logger.log(`\nGenerating handlers for provider: ${provider}`);
+		if (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, 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 { Endpoint } from '@geekmidas/api/server';
+import { ServiceDiscovery } 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: Endpoint<any, any, any, any, any, any>[] = [
+    ${allExportNames.join(",\n    ")}
+  ];
+
+  const serviceDiscovery = ServiceDiscovery.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-CTKUZTHx.cjs → build-HWB991oI.cjs}

@@ -1,6 +1,6 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_config = require('./config-D8AyiwBU.cjs');
-const require_loadEndpoints = require('./loadEndpoints-Dh-dSqZX.cjs');
+const require_config = require('./config-BNqUMsvc.cjs');
+const require_loadEndpoints = require('./loadEndpoints-BBIavB9h.cjs');
 const node_fs_promises = require_chunk.__toESM(require("node:fs/promises"));
 const path = require_chunk.__toESM(require("path"));
 

package/dist/build.cjs

@@ -1,5 +1,5 @@
-require('./config-D8AyiwBU.cjs');
-require('./loadEndpoints-Dh-dSqZX.cjs');
-const require_build = require('./build-CTKUZTHx.cjs');
+require('./config-BNqUMsvc.cjs');
+require('./loadEndpoints-BBIavB9h.cjs');
+const require_build = require('./build-HWB991oI.cjs');
 
 exports.buildCommand = require_build.buildCommand;

package/dist/build.mjs

@@ -0,0 +1,5 @@
+import "./config-BciAdY6_.mjs";
+import "./loadEndpoints-DAZ53Og2.mjs";
+import { buildCommand } from "./build-DqTE4qtW.mjs";
+
+export { buildCommand };

package/dist/{config-D8AyiwBU.cjs → config-BNqUMsvc.cjs}

@@ -1,16 +1,17 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
 const path = require_chunk.__toESM(require("path"));
 const fs = require_chunk.__toESM(require("fs"));
+const fs_promises = require_chunk.__toESM(require("fs/promises"));
 
 //#region src/config.ts
 async function loadConfig() {
 	const configPath = (0, path.join)(process.cwd(), "gkm.config.json");
 	if (!(0, fs.existsSync)(configPath)) throw new Error("gkm.config.json not found. Please create a configuration file.");
 	try {
-		const config = await import(configPath);
-		return config.default || config;
+		const config = await (0, fs_promises.readFile)(configPath, "utf-8");
+		return JSON.parse(config);
 	} catch (error) {
-		throw new Error(`Failed to load gkm.config.ts: ${error.message}`);
+		throw new Error(`Failed to load gkm.config.json: ${error.message}`);
 	}
 }
 

package/dist/config-BciAdY6_.mjs

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

package/dist/config.cjs

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

package/dist/config.mjs

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

package/dist/{cli.cjs → index.cjs}

@@ -1,18 +1,18 @@
 #!/usr/bin/env -S npx tsx
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-require('./config-D8AyiwBU.cjs');
-require('./loadEndpoints-Dh-dSqZX.cjs');
-const require_build = require('./build-CTKUZTHx.cjs');
+require('./config-BNqUMsvc.cjs');
+require('./loadEndpoints-BBIavB9h.cjs');
+const require_build = require('./build-HWB991oI.cjs');
 const require_openapi_react_query = require('./openapi-react-query-C1JLYUOs.cjs');
-const require_openapi = require('./openapi-DrPYAlJ_.cjs');
+const require_openapi = require('./openapi-D4QQJUPY.cjs');
 const commander = require_chunk.__toESM(require("commander"));
 
 //#region package.json
 var name = "@geekmidas/cli";
-var version = "0.0.14";
+var version = "0.0.17";
 var private$1 = false;
-var type = "commonjs";
-var bin = { "gkm": "./dist/cli.cjs" };
+var type = "module";
+var bin = { "gkm": "./dist/index.cjs" };
 var publishConfig = {
 	"registry": "https://registry.npmjs.org/",
 	"access": "public"
@@ -41,7 +41,7 @@ var package_default = {
 };
 
 //#endregion
-//#region src/cli.ts
+//#region src/index.ts
 const program = new commander.Command();
 program.name("gkm").description("GeekMidas backend framework CLI").version(package_default.version).option("--cwd <path>", "Change working directory");
 program.command("build").description("Build API handlers from endpoints").option("--providers <providers>", "Target providers for generated handlers (comma-separated)", "aws-apigatewayv1").action(async (options) => {

package/dist/index.mjs

@@ -0,0 +1,94 @@
+#!/usr/bin/env -S npx tsx
+import "./config-BciAdY6_.mjs";
+import "./loadEndpoints-DAZ53Og2.mjs";
+import { buildCommand } from "./build-DqTE4qtW.mjs";
+import { generateReactQueryCommand } from "./openapi-react-query-DpT3XHFC.mjs";
+import { openapiCommand } from "./openapi-CksVdkh2.mjs";
+import { Command } from "commander";
+
+//#region package.json
+var name = "@geekmidas/cli";
+var version = "0.0.17";
+var private$1 = false;
+var type = "module";
+var bin = { "gkm": "./dist/index.cjs" };
+var publishConfig = {
+	"registry": "https://registry.npmjs.org/",
+	"access": "public"
+};
+var 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": "workspace:*"
+};
+var devDependencies = {
+	"@types/lodash.get": "~4.4.9",
+	"@types/lodash.set": "~4.3.9"
+};
+var package_default = {
+	name,
+	version,
+	private: private$1,
+	type,
+	bin,
+	publishConfig,
+	dependencies,
+	devDependencies
+};
+
+//#endregion
+//#region src/index.ts
+const program = new Command();
+program.name("gkm").description("GeekMidas backend framework CLI").version(package_default.version).option("--cwd <path>", "Change working directory");
+program.command("build").description("Build API handlers from endpoints").option("--providers <providers>", "Target providers for generated handlers (comma-separated)", "aws-apigatewayv1").action(async (options) => {
+	try {
+		const globalOptions = program.opts();
+		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+		const providerList = [...new Set(options.providers.split(",").map((p) => p.trim()))];
+		await buildCommand({ providers: providerList });
+	} catch (error) {
+		console.error("Build failed:", error.message);
+		process.exit(1);
+	}
+});
+program.command("cron").description("Manage cron jobs").action(() => {
+	const globalOptions = program.opts();
+	if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+	process.stdout.write("Cron management - coming soon\n");
+});
+program.command("function").description("Manage serverless functions").action(() => {
+	const globalOptions = program.opts();
+	if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+	process.stdout.write("Serverless function management - coming soon\n");
+});
+program.command("api").description("Manage REST API endpoints").action(() => {
+	const globalOptions = program.opts();
+	if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+	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 {
+		const globalOptions = program.opts();
+		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+		await openapiCommand(options);
+	} catch (error) {
+		console.error("OpenAPI generation failed:", error.message);
+		process.exit(1);
+	}
+});
+program.command("generate:react-query").description("Generate React Query hooks from OpenAPI specification").option("--input <path>", "Input OpenAPI spec file path", "openapi.json").option("--output <path>", "Output file path for generated hooks", "src/api/hooks.ts").option("--name <name>", "API name prefix for generated code", "API").action(async (options) => {
+	try {
+		const globalOptions = program.opts();
+		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+		await generateReactQueryCommand(options);
+	} catch (error) {
+		console.error("React Query generation failed:", error.message);
+		process.exit(1);
+	}
+});
+program.parse();
+
+//#endregion

package/dist/{loadEndpoints-Dh-dSqZX.cjs → loadEndpoints-BBIavB9h.cjs}

@@ -23,6 +23,7 @@ async function loadEndpoints(routes) {
 		}
 	} catch (error) {
 		logger.warn(`Failed to load ${f}:`, error.message);
+		throw new Error("Failed to load endpoints. Please check the logs for details.");
 	}
 	return endpoints;
 }

package/dist/loadEndpoints-DAZ53Og2.mjs

@@ -0,0 +1,31 @@
+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)) {
+			exportValue.operationId = exportName;
+			endpoints.push({
+				name: exportName,
+				endpoint: exportValue,
+				file
+			});
+		}
+	} catch (error) {
+		logger.warn(`Failed to load ${f}:`, error.message);
+		throw new Error("Failed to load endpoints. Please check the logs for details.");
+	}
+	return endpoints;
+}
+
+//#endregion
+export { loadEndpoints };

package/dist/loadEndpoints.cjs

@@ -1,3 +1,3 @@
-const require_loadEndpoints = require('./loadEndpoints-Dh-dSqZX.cjs');
+const require_loadEndpoints = require('./loadEndpoints-BBIavB9h.cjs');
 
 exports.loadEndpoints = require_loadEndpoints.loadEndpoints;

package/dist/loadEndpoints.mjs

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

package/dist/openapi-CksVdkh2.mjs

@@ -0,0 +1,34 @@
+import { loadConfig } from "./config-BciAdY6_.mjs";
+import { loadEndpoints } from "./loadEndpoints-DAZ53Og2.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-DrPYAlJ_.cjs → openapi-D4QQJUPY.cjs}

@@ -1,6 +1,6 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_config = require('./config-D8AyiwBU.cjs');
-const require_loadEndpoints = require('./loadEndpoints-Dh-dSqZX.cjs');
+const require_config = require('./config-BNqUMsvc.cjs');
+const require_loadEndpoints = require('./loadEndpoints-BBIavB9h.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"));

package/dist/openapi-react-query-DpT3XHFC.mjs

@@ -0,0 +1,165 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { exec } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { promisify } from "node:util";
+
+//#region src/openapi-react-query.ts
+const execAsync = promisify(exec);
+async function generateReactQueryCommand(options = {}) {
+	const logger = console;
+	try {
+		const inputPath = options.input || join(process.cwd(), "openapi.json");
+		if (!existsSync(inputPath)) throw new Error(`OpenAPI spec not found at ${inputPath}. Run 'npx @geekmidas/cli openapi' first.`);
+		const specContent = await readFile(inputPath, "utf-8");
+		const spec = JSON.parse(specContent);
+		const outputDir = dirname(options.output || join(process.cwd(), "src", "api", "hooks.ts"));
+		const typesPath = join(outputDir, "openapi-types.d.ts");
+		logger.log("Generating TypeScript types from OpenAPI spec...");
+		try {
+			await execAsync(`npx openapi-typescript "${inputPath}" -o "${typesPath}"`, { cwd: process.cwd() });
+			logger.log(`TypeScript types generated: ${typesPath}`);
+		} catch (error) {
+			logger.warn("Could not generate types with openapi-typescript. Install it for better type inference.");
+			logger.warn("Run: npm install -D openapi-typescript");
+			await writeFile(typesPath, `// Auto-generated placeholder types
+export interface paths {
+  [path: string]: {
+    [method: string]: {
+      operationId?: string;
+      parameters?: any;
+      requestBody?: any;
+      responses?: any;
+    };
+  };
+}
+`);
+		}
+		const operations = extractOperations(spec);
+		const code = generateReactQueryCode(spec, operations, options.name || "API");
+		const outputPath = options.output || join(process.cwd(), "src", "api", "hooks.ts");
+		await mkdir(dirname(outputPath), { recursive: true });
+		await writeFile(outputPath, code);
+		logger.log(`React Query hooks generated: ${outputPath}`);
+		logger.log(`Generated ${operations.length} hooks`);
+	} catch (error) {
+		throw new Error(`React Query generation failed: ${error.message}`);
+	}
+}
+function extractOperations(spec) {
+	const operations = [];
+	Object.entries(spec.paths).forEach(([path, methods]) => {
+		Object.entries(methods).forEach(([method, operation]) => {
+			if (operation.operationId) operations.push({
+				operationId: operation.operationId,
+				path,
+				method: method.toUpperCase(),
+				endpoint: `${method.toUpperCase()} ${path}`,
+				parameters: operation.parameters,
+				requestBody: !!operation.requestBody,
+				responseType: extractResponseType(operation)
+			});
+		});
+	});
+	return operations;
+}
+function extractResponseType(operation) {
+	const responses = operation.responses;
+	if (!responses) return "unknown";
+	const successResponse = responses["200"] || responses["201"];
+	if (!successResponse?.content?.["application/json"]?.schema) return "unknown";
+	const schema = successResponse.content["application/json"].schema;
+	return schemaToTypeString(schema);
+}
+function schemaToTypeString(schema) {
+	if (!schema) return "unknown";
+	switch (schema.type) {
+		case "string": return "string";
+		case "number":
+		case "integer": return "number";
+		case "boolean": return "boolean";
+		case "array": return `Array<${schemaToTypeString(schema.items)}>`;
+		case "object":
+			if (schema.properties) {
+				const props = Object.entries(schema.properties).map(([key, value]) => `${key}: ${schemaToTypeString(value)}`).join("; ");
+				return `{ ${props} }`;
+			}
+			return "Record<string, unknown>";
+		default: return "unknown";
+	}
+}
+function generateReactQueryCode(spec, operations, apiName) {
+	const imports = `import { createTypedQueryClient } from '@geekmidas/api/client';
+import type { paths } from './openapi-types';
+
+// Create typed query client
+export const ${apiName.toLowerCase()} = createTypedQueryClient<paths>({
+  baseURL: process.env.NEXT_PUBLIC_API_URL || '/api',
+});
+
+// Export individual hooks for better DX
+`;
+	const queryHooks = operations.filter((op) => op.method === "GET").map((op) => generateQueryHook(op, apiName)).join("\n\n");
+	const mutationHooks = operations.filter((op) => op.method !== "GET").map((op) => generateMutationHook(op, apiName)).join("\n\n");
+	const typeExports = generateTypeExports(operations);
+	return `${imports}
+// Query Hooks
+${queryHooks}
+
+// Mutation Hooks
+${mutationHooks}
+
+// Type exports for convenience
+${typeExports}
+
+// Re-export the api for advanced usage
+export { ${apiName.toLowerCase()} };
+`;
+}
+function generateQueryHook(op, apiName) {
+	const hookName = `use${capitalize(op.operationId)}`;
+	const endpoint = op.endpoint;
+	const hasParams = op.parameters?.some((p) => p.in === "path");
+	const hasQuery = op.parameters?.some((p) => p.in === "query");
+	let params = "";
+	let args = "";
+	if (hasParams || hasQuery) {
+		const paramParts = [];
+		if (hasParams) {
+			const pathParams = op.parameters?.filter((p) => p.in === "path").map((p) => p.name) || [];
+			paramParts.push(`params: { ${pathParams.map((p) => `${p}: string`).join("; ")} }`);
+		}
+		if (hasQuery) paramParts.push(`query?: Record<string, any>`);
+		params = `config: { ${paramParts.join("; ")} }, `;
+		args = ", config";
+	}
+	return `export const ${hookName} = (
+  ${params}options?: Parameters<typeof ${apiName.toLowerCase()}.useQuery>[2]
+) => {
+  return ${apiName.toLowerCase()}.useQuery('${endpoint}' as any${args}, options);
+};`;
+}
+function generateMutationHook(op, apiName) {
+	const hookName = `use${capitalize(op.operationId)}`;
+	const endpoint = op.endpoint;
+	return `export const ${hookName} = (
+  options?: Parameters<typeof ${apiName.toLowerCase()}.useMutation>[1]
+) => {
+  return ${apiName.toLowerCase()}.useMutation('${endpoint}' as any, options);
+};`;
+}
+function generateTypeExports(operations) {
+	const exports = operations.map((op) => {
+		const typeName = capitalize(op.operationId);
+		const isQuery = op.method === "GET";
+		if (isQuery) return `export type ${typeName}Response = Awaited<ReturnType<ReturnType<typeof use${typeName}>['data']>>;`;
+		else return `export type ${typeName}Response = Awaited<ReturnType<ReturnType<typeof use${typeName}>['mutateAsync']>>;`;
+	});
+	return exports.join("\n");
+}
+function capitalize(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+//#endregion
+export { generateReactQueryCommand };

package/dist/openapi-react-query.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env -S npx tsx
+import { generateReactQueryCommand } from "./openapi-react-query-DpT3XHFC.mjs";
+
+export { generateReactQueryCommand };

package/dist/openapi.cjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env -S npx tsx
-require('./config-D8AyiwBU.cjs');
-require('./loadEndpoints-Dh-dSqZX.cjs');
-const require_openapi = require('./openapi-DrPYAlJ_.cjs');
+require('./config-BNqUMsvc.cjs');
+require('./loadEndpoints-BBIavB9h.cjs');
+const require_openapi = require('./openapi-D4QQJUPY.cjs');
 
 exports.openapiCommand = require_openapi.openapiCommand;

package/dist/openapi.mjs

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

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@geekmidas/cli",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "private": false,
-  "type": "commonjs",
+  "type": "module",
   "bin": {
-    "gkm": "./dist/cli.cjs"
+    "gkm": "./dist/index.cjs"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",

package/src/config.ts

@@ -1,6 +1,7 @@
 import { existsSync } from 'fs';
 import { join } from 'path';
-import type { GkmConfig } from './types.js';
+import { readFile } from 'fs/promises';
+import type { GkmConfig } from './types.ts';
 
 export async function loadConfig(): Promise<GkmConfig> {
   const configPath = join(process.cwd(), 'gkm.config.json');
@@ -12,11 +13,11 @@ export async function loadConfig(): Promise<GkmConfig> {
   }
 
   try {
-    const config = await import(configPath);
-    return config.default || config;
+    const config = await readFile(configPath, 'utf-8');
+    return JSON.parse(config);
   } catch (error) {
     throw new Error(
-      `Failed to load gkm.config.ts: ${(error as Error).message}`,
+      `Failed to load gkm.config.json: ${(error as Error).message}`,
     );
   }
 }

package/src/loadEndpoints.ts

@@ -38,6 +38,9 @@ export async function loadEndpoints(routes: Routes): Promise<LoadedEndpoint[]> {
       }
     } catch (error) {
       logger.warn(`Failed to load ${f}:`, (error as Error).message);
+      throw new Error(
+        'Failed to load endpoints. Please check the logs for details.',
+      );
     }
   }
 

package/tsdown.config.ts

@@ -2,5 +2,5 @@ import { defineConfig } from 'tsdown';
 
 export default defineConfig({
   dts: false,
-  format: 'cjs',
+  format: ['cjs', 'esm'],
 });