@geekmidas/cli 0.0.13 → 0.0.15

package/dist/cli.cjs

@@ -1,7 +1,95 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S npx tsx
+const require_chunk = require('./chunk-CUT6urMc.cjs');
 require('./config-D8AyiwBU.cjs');
 require('./loadEndpoints-Dh-dSqZX.cjs');
-require('./build-CTKUZTHx.cjs');
-require('./cli-CNAOwWIn.cjs');
-require('./openapi-DrPYAlJ_.cjs');
-require('./openapi-react-query-BWpdwBix.cjs');
+const require_build = require('./build-CTKUZTHx.cjs');
+const require_openapi_react_query = require('./openapi-react-query-C1JLYUOs.cjs');
+const require_openapi = require('./openapi-DrPYAlJ_.cjs');
+const commander = require_chunk.__toESM(require("commander"));
+
+//#region package.json
+var name = "@geekmidas/cli";
+var version = "0.0.14";
+var private$1 = false;
+var type = "commonjs";
+var bin = { "gkm": "./dist/cli.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/cli.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) => {
+	try {
+		const globalOptions = program.opts();
+		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+		const providerList = [...new Set(options.providers.split(",").map((p) => p.trim()))];
+		await require_build.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 require_openapi.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 require_openapi_react_query.generateReactQueryCommand(options);
+	} catch (error) {
+		console.error("React Query generation failed:", error.message);
+		process.exit(1);
+	}
+});
+program.parse();
+
+//#endregion

package/dist/{openapi-react-query-BWpdwBix.cjs → openapi-react-query-C1JLYUOs.cjs}

@@ -1,8 +1,8 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
 const node_fs_promises = require_chunk.__toESM(require("node:fs/promises"));
-const node_path = require_chunk.__toESM(require("node:path"));
-const node_fs = require_chunk.__toESM(require("node:fs"));
 const node_child_process = require_chunk.__toESM(require("node:child_process"));
+const node_fs = require_chunk.__toESM(require("node:fs"));
+const node_path = require_chunk.__toESM(require("node:path"));
 const node_util = require_chunk.__toESM(require("node:util"));
 
 //#region src/openapi-react-query.ts

package/dist/openapi-react-query.cjs

@@ -1,4 +1,4 @@
 #!/usr/bin/env -S npx tsx
-const require_openapi_react_query = require('./openapi-react-query-BWpdwBix.cjs');
+const require_openapi_react_query = require('./openapi-react-query-C1JLYUOs.cjs');
 
 exports.generateReactQueryCommand = require_openapi_react_query.generateReactQueryCommand;

package/package.json

@@ -1,17 +1,10 @@
 {
   "name": "@geekmidas/cli",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "private": false,
-  "type": "module",
+  "type": "commonjs",
   "bin": {
-    "gkm": "./src/index.ts"
-  },
-  "exports": {
-    ".": {
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs",
-      "types": "./src/index.ts"
-    }
+    "gkm": "./dist/cli.cjs"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
@@ -23,7 +16,7 @@
     "lodash.set": "~4.3.2",
     "zod": "~3.25.67",
     "fast-glob": "~3.3.3",
-    "@geekmidas/api": "0.0.26"
+    "@geekmidas/api": "0.0.31"
   },
   "devDependencies": {
     "@types/lodash.get": "~4.4.9",

package/src/cli.ts

@@ -1,11 +1,11 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S npx tsx
 
 import { Command } from 'commander';
 import pkg from '../package.json' assert { type: 'json' };
-import { buildCommand } from './build.js';
-import { openapiCommand } from './openapi.js';
-import { generateReactQueryCommand } from './openapi-react-query.js';
-import type { Provider } from './types.js';
+import { buildCommand } from './build.ts';
+import { generateReactQueryCommand } from './openapi-react-query.ts';
+import { openapiCommand } from './openapi.ts';
+import type { Provider } from './types.ts';
 
 const program = new Command();
 
@@ -96,32 +96,29 @@ program
 program
   .command('generate:react-query')
   .description('Generate React Query hooks from OpenAPI specification')
-  .option(
-    '--input <path>',
-    'Input OpenAPI spec file path',
-    'openapi.json',
-  )
+  .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: { input?: string; output?: string; name?: string }) => {
-    try {
-      const globalOptions = program.opts();
-      if (globalOptions.cwd) {
-        process.chdir(globalOptions.cwd);
+  .option('--name <name>', 'API name prefix for generated code', 'API')
+  .action(
+    async (options: { input?: string; output?: string; name?: string }) => {
+      try {
+        const globalOptions = program.opts();
+        if (globalOptions.cwd) {
+          process.chdir(globalOptions.cwd);
+        }
+        await generateReactQueryCommand(options);
+      } catch (error) {
+        console.error(
+          'React Query generation failed:',
+          (error as Error).message,
+        );
+        process.exit(1);
       }
-      await generateReactQueryCommand(options);
-    } catch (error) {
-      console.error('React Query generation failed:', (error as Error).message);
-      process.exit(1);
-    }
-  });
+    },
+  );
 
 program.parse();

package/src/openapi-react-query.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env -S npx tsx
 
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { join, dirname } from 'node:path';
-import { existsSync } from 'node:fs';
 import { exec } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
 import { promisify } from 'node:util';
 
 const execAsync = promisify(exec);
@@ -31,33 +31,41 @@ export async function generateReactQueryCommand(
   try {
     // Read OpenAPI spec
     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.`);
+      throw new Error(
+        `OpenAPI spec not found at ${inputPath}. Run 'npx @geekmidas/cli openapi' first.`,
+      );
     }
 
     const specContent = await readFile(inputPath, 'utf-8');
     const spec: OpenAPISpec = JSON.parse(specContent);
 
     // Generate TypeScript types from OpenAPI spec
-    const outputDir = dirname(options.output || join(process.cwd(), 'src', 'api', 'hooks.ts'));
+    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 {
       // Use npx to run openapi-typescript
       await execAsync(
         `npx openapi-typescript "${inputPath}" -o "${typesPath}"`,
-        { cwd: process.cwd() }
+        { 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(
+        'Could not generate types with openapi-typescript. Install it for better type inference.',
+      );
       logger.warn('Run: npm install -D openapi-typescript');
-      
+
       // Generate basic types file
-      await writeFile(typesPath, `// Auto-generated placeholder types
+      await writeFile(
+        typesPath,
+        `// Auto-generated placeholder types
 export interface paths {
   [path: string]: {
     [method: string]: {
@@ -68,24 +76,32 @@ export interface paths {
     };
   };
 }
-`);
+`,
+      );
     }
 
     // Extract operation info
     const operations = extractOperations(spec);
-    
+
     // Generate TypeScript code
-    const code = generateReactQueryCode(spec, operations, options.name || 'API');
+    const code = generateReactQueryCode(
+      spec,
+      operations,
+      options.name || 'API',
+    );
 
     // Write output
-    const outputPath = options.output || join(process.cwd(), 'src', 'api', 'hooks.ts');
+    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 as Error).message}`);
+    throw new Error(
+      `React Query generation failed: ${(error as Error).message}`,
+    );
   }
 }
 
@@ -137,7 +153,7 @@ function extractResponseType(operation: any): string {
 
 function schemaToTypeString(schema: any): string {
   if (!schema) return 'unknown';
-  
+
   switch (schema.type) {
     case 'string':
       return 'string';
@@ -151,7 +167,10 @@ function schemaToTypeString(schema: any): string {
     case 'object':
       if (schema.properties) {
         const props = Object.entries(schema.properties)
-          .map(([key, value]: [string, any]) => `${key}: ${schemaToTypeString(value)}`)
+          .map(
+            ([key, value]: [string, any]) =>
+              `${key}: ${schemaToTypeString(value)}`,
+          )
           .join('; ');
         return `{ ${props} }`;
       }
@@ -178,13 +197,13 @@ export const ${apiName.toLowerCase()} = createTypedQueryClient<paths>({
 `;
 
   const queryHooks = operations
-    .filter(op => op.method === 'GET')
-    .map(op => generateQueryHook(op, apiName))
+    .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))
+    .filter((op) => op.method !== 'GET')
+    .map((op) => generateMutationHook(op, apiName))
     .join('\n\n');
 
   const typeExports = generateTypeExports(operations);
@@ -207,18 +226,21 @@ export { ${apiName.toLowerCase()} };
 function generateQueryHook(op: OperationInfo, apiName: string): string {
   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');
-  
+  const hasParams = op.parameters?.some((p) => p.in === 'path');
+  const hasQuery = op.parameters?.some((p) => p.in === 'query');
+
   // Generate properly typed hook
   let params = '';
   let args = '';
-  
+
   if (hasParams || hasQuery) {
     const paramParts: string[] = [];
     if (hasParams) {
-      const pathParams = op.parameters?.filter(p => p.in === 'path').map(p => p.name) || [];
-      paramParts.push(`params: { ${pathParams.map(p => `${p}: string`).join('; ')} }`);
+      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>`);
@@ -226,7 +248,7 @@ function generateQueryHook(op: OperationInfo, apiName: string): string {
     params = `config: { ${paramParts.join('; ')} }, `;
     args = ', config';
   }
-  
+
   return `export const ${hookName} = (
   ${params}options?: Parameters<typeof ${apiName.toLowerCase()}.useQuery>[2]
 ) => {
@@ -237,7 +259,7 @@ function generateQueryHook(op: OperationInfo, apiName: string): string {
 function generateMutationHook(op: OperationInfo, apiName: string): string {
   const hookName = `use${capitalize(op.operationId)}`;
   const endpoint = op.endpoint;
-  
+
   return `export const ${hookName} = (
   options?: Parameters<typeof ${apiName.toLowerCase()}.useMutation>[1]
 ) => {
@@ -246,10 +268,10 @@ function generateMutationHook(op: OperationInfo, apiName: string): string {
 }
 
 function generateTypeExports(operations: OperationInfo[]): string {
-  const exports = operations.map(op => {
+  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 {
@@ -262,4 +284,4 @@ function generateTypeExports(operations: OperationInfo[]): string {
 
 function capitalize(str: string): string {
   return str.charAt(0).toUpperCase() + str.slice(1);
-}
+}

package/tsdown.config.ts

@@ -1,3 +1,6 @@
 import { defineConfig } from 'tsdown';
 
-export default defineConfig({});
+export default defineConfig({
+  dts: false,
+  format: 'cjs',
+});

package/dist/build-DgeiXkH-.mjs

@@ -1,160 +0,0 @@
-import { loadConfig } from "./config-DV1Lwdkx.mjs";
-import { loadEndpoints } from "./loadEndpoints-DKaw6Eqm.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.mjs

@@ -1,5 +0,0 @@
-import "./config-DV1Lwdkx.mjs";
-import "./loadEndpoints-DKaw6Eqm.mjs";
-import { buildCommand } from "./build-DgeiXkH-.mjs";
-
-export { buildCommand };

package/dist/cli-CNAOwWIn.cjs

@@ -1,98 +0,0 @@
-const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_build = require('./build-CTKUZTHx.cjs');
-const require_openapi = require('./openapi-DrPYAlJ_.cjs');
-const require_openapi_react_query = require('./openapi-react-query-BWpdwBix.cjs');
-const commander = require_chunk.__toESM(require("commander"));
-
-//#region package.json
-var name = "@geekmidas/cli";
-var version = "0.0.13";
-var private$1 = false;
-var type = "module";
-var bin = { "gkm": "./src/index.ts" };
-var exports$1 = { ".": {
-	"import": "./dist/index.mjs",
-	"require": "./dist/index.cjs",
-	"types": "./src/index.ts"
-} };
-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,
-	exports: exports$1,
-	publishConfig,
-	dependencies,
-	devDependencies
-};
-
-//#endregion
-//#region src/cli.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) => {
-	try {
-		const globalOptions = program.opts();
-		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
-		const providerList = [...new Set(options.providers.split(",").map((p) => p.trim()))];
-		await require_build.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 require_openapi.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 require_openapi_react_query.generateReactQueryCommand(options);
-	} catch (error) {
-		console.error("React Query generation failed:", error.message);
-		process.exit(1);
-	}
-});
-program.parse();
-
-//#endregion

package/dist/cli-jxBvJiFq.mjs

@@ -1,97 +0,0 @@
-import { buildCommand } from "./build-DgeiXkH-.mjs";
-import { openapiCommand } from "./openapi-DgLItZw-.mjs";
-import { generateReactQueryCommand } from "./openapi-react-query-DuNQ8DwF.mjs";
-import { Command } from "commander";
-
-//#region package.json
-var name = "@geekmidas/cli";
-var version = "0.0.13";
-var private$1 = false;
-var type = "module";
-var bin = { "gkm": "./src/index.ts" };
-var exports = { ".": {
-	"import": "./dist/index.mjs",
-	"require": "./dist/index.cjs",
-	"types": "./src/index.ts"
-} };
-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,
-	exports,
-	publishConfig,
-	dependencies,
-	devDependencies
-};
-
-//#endregion
-//#region src/cli.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/cli.mjs

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-import "./config-DV1Lwdkx.mjs";
-import "./loadEndpoints-DKaw6Eqm.mjs";
-import "./build-DgeiXkH-.mjs";
-import "./cli-jxBvJiFq.mjs";
-import "./openapi-DgLItZw-.mjs";
-import "./openapi-react-query-DuNQ8DwF.mjs";

package/dist/config-DV1Lwdkx.mjs

@@ -1,17 +0,0 @@
-import { join } from "path";
-import { existsSync } from "fs";
-
-//#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 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.mjs

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

package/dist/index.cjs

@@ -1,7 +0,0 @@
-#!/usr/bin/env -S npx tsx
-require('./config-D8AyiwBU.cjs');
-require('./loadEndpoints-Dh-dSqZX.cjs');
-require('./build-CTKUZTHx.cjs');
-require('./cli-CNAOwWIn.cjs');
-require('./openapi-DrPYAlJ_.cjs');
-require('./openapi-react-query-BWpdwBix.cjs');

package/dist/index.mjs

@@ -1,7 +0,0 @@
-#!/usr/bin/env -S npx tsx
-import "./config-DV1Lwdkx.mjs";
-import "./loadEndpoints-DKaw6Eqm.mjs";
-import "./build-DgeiXkH-.mjs";
-import "./cli-jxBvJiFq.mjs";
-import "./openapi-DgLItZw-.mjs";
-import "./openapi-react-query-DuNQ8DwF.mjs";

package/dist/loadEndpoints-DKaw6Eqm.mjs

@@ -1,30 +0,0 @@
-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);
-	}
-	return endpoints;
-}
-
-//#endregion
-export { loadEndpoints };

package/dist/loadEndpoints.mjs

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

package/dist/openapi-DgLItZw-.mjs

@@ -1,34 +0,0 @@
-import { loadConfig } from "./config-DV1Lwdkx.mjs";
-import { loadEndpoints } from "./loadEndpoints-DKaw6Eqm.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-react-query-DuNQ8DwF.mjs

@@ -1,165 +0,0 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { existsSync } from "node:fs";
-import { exec } from "node:child_process";
-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

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

package/dist/openapi.mjs

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

package/src/index.ts

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