@geekmidas/cli 0.23.0 → 0.24.0

package/dist/openapi.cjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env -S npx tsx
 require('./workspace-iWgBlX6h.cjs');
-require('./config-CxrLu8ia.cjs');
-const require_openapi = require('./openapi-DfpxS0xv.cjs');
+require('./config-CTftATBX.cjs');
+const require_openapi = require('./openapi-BrhkPKM7.cjs');
 
 exports.OPENAPI_OUTPUT_PATH = require_openapi.OPENAPI_OUTPUT_PATH;
 exports.generateOpenApi = require_openapi.generateOpenApi;

package/dist/openapi.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env -S npx tsx
 import "./workspace-CPLEZDZf.mjs";
-import "./config-BaYqrF3n.mjs";
-import { OPENAPI_OUTPUT_PATH, generateOpenApi, openapiCommand, resolveOpenApiConfig } from "./openapi-CgqR6Jkw.mjs";
+import "./config-BogU0_oQ.mjs";
+import { OPENAPI_OUTPUT_PATH, generateOpenApi, openapiCommand, resolveOpenApiConfig } from "./openapi-DNbXfhXE.mjs";
 
 export { OPENAPI_OUTPUT_PATH, generateOpenApi, openapiCommand, resolveOpenApiConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "description": "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs",
   "private": false,
   "type": "module",
@@ -48,11 +48,11 @@
     "lodash.kebabcase": "^4.1.1",
     "openapi-typescript": "^7.4.2",
     "prompts": "~2.4.2",
-    "@geekmidas/errors": "~0.1.0",
     "@geekmidas/constructs": "~0.6.0",
-    "@geekmidas/envkit": "~0.4.0",
+    "@geekmidas/errors": "~0.1.0",
     "@geekmidas/logger": "~0.4.0",
-    "@geekmidas/schema": "~0.1.0"
+    "@geekmidas/schema": "~0.1.0",
+    "@geekmidas/envkit": "~0.4.0"
   },
   "devDependencies": {
     "@types/lodash.kebabcase": "^4.1.9",

package/src/__tests__/config.spec.ts

@@ -1,7 +1,8 @@
-import { writeFile } from 'node:fs/promises';
+import { realpathSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { loadConfig } from '../config';
+import { getAppNameFromCwd, loadAppConfig, loadConfig } from '../config';
 import { cleanupDir, createTempDir } from './test-helpers';
 
 describe('loadConfig', () => {
@@ -108,3 +109,314 @@ export default {
 		expect(config.routes).toBe('./ts-routes/**/*.ts');
 	});
 });
+
+describe('getAppNameFromCwd', () => {
+	let tempDir: string;
+
+	beforeEach(async () => {
+		tempDir = await createTempDir();
+	});
+
+	afterEach(async () => {
+		await cleanupDir(tempDir);
+	});
+
+	it('should return app name from package.json', async () => {
+		const packageJson = { name: 'my-app', version: '1.0.0' };
+		await writeFile(join(tempDir, 'package.json'), JSON.stringify(packageJson));
+
+		const appName = getAppNameFromCwd(tempDir);
+
+		expect(appName).toBe('my-app');
+	});
+
+	it('should extract name from scoped package', async () => {
+		const packageJson = { name: '@myorg/api', version: '1.0.0' };
+		await writeFile(join(tempDir, 'package.json'), JSON.stringify(packageJson));
+
+		const appName = getAppNameFromCwd(tempDir);
+
+		expect(appName).toBe('api');
+	});
+
+	it('should handle scoped package with nested scope', async () => {
+		const packageJson = { name: '@my-company/auth-service', version: '1.0.0' };
+		await writeFile(join(tempDir, 'package.json'), JSON.stringify(packageJson));
+
+		const appName = getAppNameFromCwd(tempDir);
+
+		expect(appName).toBe('auth-service');
+	});
+
+	it('should return null if package.json does not exist', async () => {
+		const appName = getAppNameFromCwd(tempDir);
+
+		expect(appName).toBeNull();
+	});
+
+	it('should return null if package.json has no name field', async () => {
+		const packageJson = { version: '1.0.0' };
+		await writeFile(join(tempDir, 'package.json'), JSON.stringify(packageJson));
+
+		const appName = getAppNameFromCwd(tempDir);
+
+		expect(appName).toBeNull();
+	});
+
+	it('should return null if package.json is invalid JSON', async () => {
+		await writeFile(join(tempDir, 'package.json'), 'not valid json');
+
+		const appName = getAppNameFromCwd(tempDir);
+
+		expect(appName).toBeNull();
+	});
+});
+
+describe('loadAppConfig', () => {
+	let tempDir: string;
+	let originalCwd: string;
+
+	beforeEach(async () => {
+		tempDir = await createTempDir();
+		originalCwd = process.cwd();
+	});
+
+	afterEach(async () => {
+		process.chdir(originalCwd);
+		// Clean up GKM_CONFIG_PATH env var
+		delete process.env.GKM_CONFIG_PATH;
+		await cleanupDir(tempDir);
+	});
+
+	it('should load app config from workspace when in app directory', async () => {
+		// Create workspace structure
+		const workspaceRoot = tempDir;
+		const appDir = join(workspaceRoot, 'apps', 'api');
+		await mkdir(appDir, { recursive: true });
+
+		// Create workspace config (plain JS object with __isWorkspace marker)
+		const workspaceConfig = `
+export default {
+  __isWorkspace: true,
+  name: 'test-workspace',
+  apps: {
+    api: {
+      type: 'backend',
+      path: 'apps/api',
+      port: 3000,
+      routes: './src/endpoints/**/*.ts',
+      envParser: './src/config/env',
+      logger: './src/config/logger',
+    },
+  },
+};
+`;
+		await writeFile(join(workspaceRoot, 'gkm.config.ts'), workspaceConfig);
+
+		// Create app package.json
+		const packageJson = { name: '@test-workspace/api', version: '1.0.0' };
+		await writeFile(join(appDir, 'package.json'), JSON.stringify(packageJson));
+
+		// Change to app directory
+		process.chdir(appDir);
+
+		const result = await loadAppConfig();
+
+		expect(result.appName).toBe('api');
+		expect(result.gkmConfig.routes).toBe('./src/endpoints/**/*.ts');
+		// Use realpathSync to handle macOS /var -> /private/var symlink
+		expect(realpathSync(result.appRoot)).toBe(realpathSync(appDir));
+		expect(realpathSync(result.workspaceRoot)).toBe(
+			realpathSync(workspaceRoot),
+		);
+	});
+
+	it('should throw error if app not found in workspace', async () => {
+		// Create workspace structure
+		const workspaceRoot = tempDir;
+		const appDir = join(workspaceRoot, 'apps', 'unknown');
+		await mkdir(appDir, { recursive: true });
+
+		// Create workspace config without 'unknown' app
+		const workspaceConfig = `
+export default {
+  __isWorkspace: true,
+  name: 'test-workspace',
+  apps: {
+    api: {
+      type: 'backend',
+      path: 'apps/api',
+      port: 3000,
+      routes: './src/endpoints/**/*.ts',
+      envParser: './src/config/env',
+      logger: './src/config/logger',
+    },
+  },
+};
+`;
+		await writeFile(join(workspaceRoot, 'gkm.config.ts'), workspaceConfig);
+
+		// Create app package.json with different name
+		const packageJson = { name: '@test-workspace/unknown', version: '1.0.0' };
+		await writeFile(join(appDir, 'package.json'), JSON.stringify(packageJson));
+
+		// Change to app directory
+		process.chdir(appDir);
+
+		await expect(loadAppConfig()).rejects.toThrow(
+			'App "unknown" not found in workspace config',
+		);
+	});
+
+	it('should throw error if no package.json exists', async () => {
+		// Create workspace structure without package.json in app
+		const workspaceRoot = tempDir;
+		const appDir = join(workspaceRoot, 'apps', 'api');
+		await mkdir(appDir, { recursive: true });
+
+		const workspaceConfig = `
+export default {
+  routes: './src/endpoints/**/*.ts',
+  envParser: './src/config/env',
+  logger: './src/config/logger',
+};
+`;
+		await writeFile(join(workspaceRoot, 'gkm.config.ts'), workspaceConfig);
+
+		// Change to app directory (no package.json)
+		process.chdir(appDir);
+
+		await expect(loadAppConfig()).rejects.toThrow(
+			'Could not determine app name',
+		);
+	});
+
+	it('should use GKM_CONFIG_PATH env var when set', async () => {
+		// Create workspace at a different location
+		const workspaceRoot = await createTempDir('workspace-');
+		const configPath = join(workspaceRoot, 'gkm.config.ts');
+
+		// Create workspace config
+		const workspaceConfig = `
+export default {
+  __isWorkspace: true,
+  name: 'env-test',
+  apps: {
+    api: {
+      type: 'backend',
+      path: 'apps/api',
+      port: 3000,
+      routes: './src/endpoints/**/*.ts',
+      envParser: './src/config/env',
+      logger: './src/config/logger',
+    },
+  },
+};
+`;
+		await writeFile(configPath, workspaceConfig);
+
+		// Create app directory in temp dir (separate from workspace)
+		const appDir = join(tempDir, 'apps', 'api');
+		await mkdir(appDir, { recursive: true });
+
+		// Create app package.json
+		const packageJson = { name: '@env-test/api', version: '1.0.0' };
+		await writeFile(join(appDir, 'package.json'), JSON.stringify(packageJson));
+
+		// Set GKM_CONFIG_PATH
+		process.env.GKM_CONFIG_PATH = configPath;
+
+		// Change to app directory
+		process.chdir(appDir);
+
+		const result = await loadAppConfig();
+
+		expect(result.appName).toBe('api');
+		// Use realpathSync to handle macOS /var -> /private/var symlink
+		expect(realpathSync(result.workspaceRoot)).toBe(
+			realpathSync(workspaceRoot),
+		);
+
+		// Cleanup the extra temp dir
+		await cleanupDir(workspaceRoot);
+	});
+});
+
+describe('config discovery', () => {
+	let tempDir: string;
+	let originalCwd: string;
+
+	beforeEach(async () => {
+		tempDir = await createTempDir();
+		originalCwd = process.cwd();
+	});
+
+	afterEach(async () => {
+		process.chdir(originalCwd);
+		delete process.env.GKM_CONFIG_PATH;
+		await cleanupDir(tempDir);
+	});
+
+	it('should find config by walking up directories', async () => {
+		// Create nested directory structure
+		const nestedDir = join(tempDir, 'apps', 'api', 'src', 'endpoints');
+		await mkdir(nestedDir, { recursive: true });
+
+		// Create config at root
+		const configContent = `
+export default {
+  routes: './src/endpoints/**/*.ts',
+  envParser: './src/config/env',
+  logger: './src/config/logger',
+};
+`;
+		await writeFile(join(tempDir, 'gkm.config.ts'), configContent);
+
+		// Change to deeply nested directory
+		process.chdir(nestedDir);
+
+		const config = await loadConfig();
+
+		expect(config.routes).toBe('./src/endpoints/**/*.ts');
+	});
+
+	it('should prefer GKM_CONFIG_PATH over walking up directories', async () => {
+		// Create two configs at different levels
+		const nestedDir = join(tempDir, 'apps', 'api');
+		await mkdir(nestedDir, { recursive: true });
+
+		// Config at root
+		const rootConfig = `
+export default {
+  routes: './root-routes/**/*.ts',
+  envParser: './src/config/env',
+  logger: './src/config/logger',
+};
+`;
+		await writeFile(join(tempDir, 'gkm.config.ts'), rootConfig);
+
+		// Config in a different location pointed to by env var
+		const envConfigDir = await createTempDir('env-config-');
+		const envConfig = `
+export default {
+  routes: './env-routes/**/*.ts',
+  envParser: './src/config/env',
+  logger: './src/config/logger',
+};
+`;
+		await writeFile(join(envConfigDir, 'gkm.config.ts'), envConfig);
+
+		// Set GKM_CONFIG_PATH to the env config
+		process.env.GKM_CONFIG_PATH = join(envConfigDir, 'gkm.config.ts');
+
+		// Change to nested directory
+		process.chdir(nestedDir);
+
+		const config = await loadConfig();
+
+		expect(config.routes).toBe('./env-routes/**/*.ts');
+
+		// Cleanup
+		await cleanupDir(envConfigDir);
+	});
+});

package/src/config.ts

@@ -1,9 +1,12 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, parse } from 'node:path';
 import type { GkmConfig } from './types.js';
 import {
+	getAppGkmConfig,
 	isWorkspaceConfig,
 	type LoadedConfig,
+	type NormalizedAppConfig,
+	type NormalizedWorkspace,
 	processConfig,
 	type WorkspaceConfig,
 } from './workspace/index.js';
@@ -70,17 +73,45 @@ export function parseModuleConfig(
 	return { path, importPattern };
 }
 
+export interface ConfigDiscoveryResult {
+	configPath: string;
+	workspaceRoot: string;
+}
+
 /**
  * Find and return the path to the config file.
+ *
+ * Resolution order:
+ * 1. GKM_CONFIG_PATH env var (set by workspace dev command)
+ * 2. Walk up directory tree from cwd
  */
-function findConfigPath(cwd: string): string {
+function findConfigPath(cwd: string): ConfigDiscoveryResult {
 	const files = ['gkm.config.json', 'gkm.config.ts', 'gkm.config.js'];
 
-	for (const file of files) {
-		const path = join(cwd, file);
-		if (existsSync(path)) {
-			return path;
+	// Check GKM_CONFIG_PATH env var first (set by workspace dev command)
+	const envConfigPath = process.env.GKM_CONFIG_PATH;
+	if (envConfigPath && existsSync(envConfigPath)) {
+		return {
+			configPath: envConfigPath,
+			workspaceRoot: dirname(envConfigPath),
+		};
+	}
+
+	// Walk up directory tree to find config
+	let currentDir = cwd;
+	const { root } = parse(currentDir);
+
+	while (currentDir !== root) {
+		for (const file of files) {
+			const configPath = join(currentDir, file);
+			if (existsSync(configPath)) {
+				return {
+					configPath,
+					workspaceRoot: currentDir,
+				};
+			}
 		}
+		currentDir = dirname(currentDir);
 	}
 
 	throw new Error(
@@ -88,17 +119,58 @@ function findConfigPath(cwd: string): string {
 	);
 }
 
+/**
+ * Get app name from package.json in the given directory.
+ * Handles scoped packages by extracting the name after the scope.
+ *
+ * @example
+ * getAppNameFromCwd('/path/to/apps/api')
+ * // package.json: { "name": "@myorg/api" }
+ * // Returns: 'api'
+ */
+export function getAppNameFromCwd(cwd: string = process.cwd()): string | null {
+	const packageJsonPath = join(cwd, 'package.json');
+
+	if (!existsSync(packageJsonPath)) {
+		return null;
+	}
+
+	try {
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+		const name = packageJson.name as string | undefined;
+
+		if (!name) {
+			return null;
+		}
+
+		// Handle scoped packages: @scope/name -> name
+		if (name.startsWith('@') && name.includes('/')) {
+			return name.split('/')[1] ?? null;
+		}
+
+		return name;
+	} catch {
+		return null;
+	}
+}
+
+interface RawConfigResult {
+	config: GkmConfig | WorkspaceConfig;
+	workspaceRoot: string;
+}
+
 /**
  * Load raw configuration from file.
  */
-async function loadRawConfig(
-	cwd: string,
-): Promise<GkmConfig | WorkspaceConfig> {
-	const configPath = findConfigPath(cwd);
+async function loadRawConfig(cwd: string): Promise<RawConfigResult> {
+	const { configPath, workspaceRoot } = findConfigPath(cwd);
 
 	try {
 		const config = await import(configPath);
-		return config.default;
+		return {
+			config: config.default,
+			workspaceRoot,
+		};
 	} catch (error) {
 		throw new Error(`Failed to load config: ${(error as Error).message}`);
 	}
@@ -113,7 +185,7 @@ async function loadRawConfig(
 export async function loadConfig(
 	cwd: string = process.cwd(),
 ): Promise<GkmConfig> {
-	const config = await loadRawConfig(cwd);
+	const { config } = await loadRawConfig(cwd);
 
 	// If it's a workspace config, throw an error
 	if (isWorkspaceConfig(config)) {
@@ -145,6 +217,70 @@ export async function loadConfig(
 export async function loadWorkspaceConfig(
 	cwd: string = process.cwd(),
 ): Promise<LoadedConfig> {
-	const config = await loadRawConfig(cwd);
-	return processConfig(config, cwd);
+	const { config, workspaceRoot } = await loadRawConfig(cwd);
+	return processConfig(config, workspaceRoot);
+}
+
+export interface AppConfigResult {
+	appName: string;
+	app: NormalizedAppConfig;
+	gkmConfig: GkmConfig;
+	workspace: NormalizedWorkspace;
+	workspaceRoot: string;
+	appRoot: string;
+}
+
+/**
+ * Load app-specific configuration from workspace.
+ * Uses the app name from package.json to find the correct app config.
+ *
+ * @example
+ * ```ts
+ * // From apps/api directory with package.json: { "name": "@myorg/api" }
+ * const { app, workspace, workspaceRoot } = await loadAppConfig();
+ * console.log(app.routes); // './src/endpoints/**\/*.ts'
+ * ```
+ */
+export async function loadAppConfig(
+	cwd: string = process.cwd(),
+): Promise<AppConfigResult> {
+	const appName = getAppNameFromCwd(cwd);
+
+	if (!appName) {
+		throw new Error(
+			'Could not determine app name. Ensure package.json exists with a "name" field.',
+		);
+	}
+
+	const { config, workspaceRoot } = await loadRawConfig(cwd);
+	const loadedConfig = processConfig(config, workspaceRoot);
+
+	// Find the app in workspace (apps is a Record<string, NormalizedAppConfig>)
+	const app = loadedConfig.workspace.apps[appName];
+
+	if (!app) {
+		const availableApps = Object.keys(loadedConfig.workspace.apps).join(', ');
+		throw new Error(
+			`App "${appName}" not found in workspace config. Available apps: ${availableApps}. ` +
+				`Ensure the package.json name matches the app key in gkm.config.ts.`,
+		);
+	}
+
+	// Get the app's GKM config using the helper
+	const gkmConfig = getAppGkmConfig(loadedConfig.workspace, appName);
+
+	if (!gkmConfig) {
+		throw new Error(
+			`App "${appName}" is not a backend app and cannot be run with gkm dev.`,
+		);
+	}
+
+	return {
+		appName,
+		app,
+		gkmConfig,
+		workspace: loadedConfig.workspace,
+		workspaceRoot,
+		appRoot: join(workspaceRoot, app.path),
+	};
 }