@geekmidas/cli 0.3.0 → 0.5.0

package/src/init/generators/package.ts

@@ -0,0 +1,81 @@
+import type {
+  GeneratedFile,
+  TemplateConfig,
+  TemplateOptions,
+} from '../templates/index.js';
+
+/**
+ * Generate package.json with dependencies based on template and options
+ */
+export function generatePackageJson(
+  options: TemplateOptions,
+  template: TemplateConfig,
+): GeneratedFile[] {
+  const { name, telescope, database, monorepo } = options;
+
+  // Start with template dependencies
+  const dependencies = { ...template.dependencies };
+  const devDependencies = { ...template.devDependencies };
+  const scripts = { ...template.scripts };
+
+  // Add optional dependencies based on user choices
+  if (telescope) {
+    dependencies['@geekmidas/telescope'] = 'workspace:*';
+  }
+
+  if (database) {
+    dependencies['@geekmidas/db'] = 'workspace:*';
+    dependencies['kysely'] = '~0.28.2';
+    dependencies['pg'] = '~8.16.0';
+    devDependencies['@types/pg'] = '~8.15.0';
+  }
+
+  // Add zod for schema validation (commonly used)
+  dependencies['zod'] = '~4.1.0';
+
+  // For monorepo apps, remove biome/turbo (they're at root) and lint/fmt scripts
+  if (monorepo) {
+    delete devDependencies['@biomejs/biome'];
+    delete devDependencies['turbo'];
+    delete scripts['lint'];
+    delete scripts['fmt'];
+    delete scripts['fmt:check'];
+
+    // Add models package as dependency
+    dependencies[`@${name}/models`] = 'workspace:*';
+
+    // Remove zod from api package (it's in models)
+    delete dependencies['zod'];
+  }
+
+  // Sort dependencies alphabetically
+  const sortObject = (obj: Record<string, string>) =>
+    Object.fromEntries(
+      Object.entries(obj).sort(([a], [b]) => a.localeCompare(b)),
+    );
+
+  // For monorepo, derive package name from apiPath (e.g., apps/api -> @name/api)
+  let packageName = name;
+  if (monorepo && options.apiPath) {
+    const pathParts = options.apiPath.split('/');
+    const appName = pathParts[pathParts.length - 1] || 'api';
+    packageName = `@${name}/${appName}`;
+  }
+
+  const packageJson = {
+    name: packageName,
+    version: '0.0.1',
+    private: true,
+    type: 'module',
+    scripts,
+    dependencies: sortObject(dependencies),
+    devDependencies: sortObject(devDependencies),
+  };
+
+  return [
+    {
+      path: 'package.json',
+      content: JSON.stringify(packageJson, null, 2) + '\n',
+    },
+  ];
+}

package/src/init/generators/source.ts

@@ -0,0 +1,15 @@
+import type {
+  GeneratedFile,
+  TemplateConfig,
+  TemplateOptions,
+} from '../templates/index.js';
+
+/**
+ * Generate source files from template
+ */
+export function generateSourceFiles(
+  options: TemplateOptions,
+  template: TemplateConfig,
+): GeneratedFile[] {
+  return template.files(options);
+}

package/src/init/index.ts

@@ -0,0 +1,206 @@
+import { execSync } from 'node:child_process';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import prompts from 'prompts';
+import { generateConfigFiles } from './generators/config.js';
+import { generateDockerFiles } from './generators/docker.js';
+import { generateEnvFiles } from './generators/env.js';
+import { generateModelsPackage } from './generators/models.js';
+import { generateMonorepoFiles } from './generators/monorepo.js';
+import { generatePackageJson } from './generators/package.js';
+import { generateSourceFiles } from './generators/source.js';
+import {
+  type TemplateName,
+  type TemplateOptions,
+  getTemplate,
+  routeStyleChoices,
+  templateChoices,
+} from './templates/index.js';
+import {
+  checkDirectoryExists,
+  detectPackageManager,
+  getInstallCommand,
+  getRunCommand,
+  validateProjectName,
+} from './utils.js';
+
+export interface InitOptions {
+  template?: TemplateName;
+  skipInstall?: boolean;
+  yes?: boolean;
+  monorepo?: boolean;
+  apiPath?: string;
+}
+
+/**
+ * Main init command - scaffolds a new project
+ */
+export async function initCommand(
+  projectName?: string,
+  options: InitOptions = {},
+): Promise<void> {
+  const cwd = process.cwd();
+  const pkgManager = detectPackageManager(cwd);
+
+  // Handle Ctrl+C gracefully
+  prompts.override({});
+  const onCancel = () => {
+    process.exit(0);
+  };
+
+  // Gather answers via prompts
+  const answers = await prompts(
+    [
+      {
+        type: projectName ? null : 'text',
+        name: 'name',
+        message: 'Project name:',
+        initial: 'my-api',
+        validate: (value: string) => {
+          const nameValid = validateProjectName(value);
+          if (nameValid !== true) return nameValid;
+          const dirValid = checkDirectoryExists(value, cwd);
+          if (dirValid !== true) return dirValid;
+          return true;
+        },
+      },
+      {
+        type: options.template || options.yes ? null : 'select',
+        name: 'template',
+        message: 'Template:',
+        choices: templateChoices,
+        initial: 0,
+      },
+      {
+        type: options.yes ? null : 'confirm',
+        name: 'telescope',
+        message: 'Include Telescope (debugging dashboard)?',
+        initial: true,
+      },
+      {
+        type: options.yes ? null : 'confirm',
+        name: 'database',
+        message: 'Include database support (Kysely)?',
+        initial: true,
+      },
+      {
+        type: options.yes ? null : 'select',
+        name: 'routeStyle',
+        message: 'Route organization:',
+        choices: routeStyleChoices,
+        initial: 0,
+      },
+      {
+        type: options.yes || options.monorepo !== undefined ? null : 'confirm',
+        name: 'monorepo',
+        message: 'Setup as monorepo?',
+        initial: false,
+      },
+      {
+        type: (prev) =>
+          (prev === true || options.monorepo) && !options.apiPath
+            ? 'text'
+            : null,
+        name: 'apiPath',
+        message: 'API app path:',
+        initial: 'apps/api',
+      },
+    ],
+    { onCancel },
+  );
+
+  // Build final options
+  const name = projectName || answers.name;
+  if (!name) {
+    console.error('  Error: Project name is required\n');
+    process.exit(1);
+  }
+
+  // Validate name if provided via argument
+  if (projectName) {
+    const nameValid = validateProjectName(projectName);
+    if (nameValid !== true) {
+      console.error(`  Error: ${nameValid}\n`);
+      process.exit(1);
+    }
+    const dirValid = checkDirectoryExists(projectName, cwd);
+    if (dirValid !== true) {
+      console.error(`  Error: ${dirValid}\n`);
+      process.exit(1);
+    }
+  }
+
+  const monorepo =
+    options.monorepo ?? (options.yes ? false : (answers.monorepo ?? false));
+  const templateOptions: TemplateOptions = {
+    name,
+    template: options.template || answers.template || 'minimal',
+    telescope: options.yes ? true : (answers.telescope ?? true),
+    database: options.yes ? true : (answers.database ?? true),
+    routeStyle: options.yes
+      ? 'file-based'
+      : (answers.routeStyle ?? 'file-based'),
+    monorepo,
+    apiPath: monorepo ? (options.apiPath ?? answers.apiPath ?? 'apps/api') : '',
+  };
+
+  const targetDir = join(cwd, name);
+  const template = getTemplate(templateOptions.template);
+
+  const isMonorepo = templateOptions.monorepo;
+  const apiPath = templateOptions.apiPath;
+
+  // Create project directory
+  await mkdir(targetDir, { recursive: true });
+
+  // For monorepo, app files go in the specified apiPath (e.g., apps/api)
+  const appDir = isMonorepo ? join(targetDir, apiPath) : targetDir;
+  if (isMonorepo) {
+    await mkdir(appDir, { recursive: true });
+  }
+
+  // Collect app files
+  const appFiles = [
+    ...generatePackageJson(templateOptions, template),
+    ...generateConfigFiles(templateOptions, template),
+    ...generateEnvFiles(templateOptions, template),
+    ...generateSourceFiles(templateOptions, template),
+    ...generateDockerFiles(templateOptions, template),
+  ];
+
+  // Collect root monorepo files (includes packages/models)
+  const rootFiles = [
+    ...generateMonorepoFiles(templateOptions, template),
+    ...generateModelsPackage(templateOptions),
+  ];
+
+  // Write root files (for monorepo)
+  for (const { path, content } of rootFiles) {
+    const fullPath = join(targetDir, path);
+    await mkdir(dirname(fullPath), { recursive: true });
+    await writeFile(fullPath, content);
+  }
+
+  // Write app files
+  for (const { path, content } of appFiles) {
+    const fullPath = join(appDir, path);
+    const displayPath = isMonorepo ? `${apiPath}/${path}` : path;
+    await mkdir(dirname(fullPath), { recursive: true });
+    await writeFile(fullPath, content);
+  }
+
+  // Install dependencies
+  if (!options.skipInstall) {
+    try {
+      execSync(getInstallCommand(pkgManager), {
+        cwd: targetDir,
+        stdio: 'inherit',
+      });
+    } catch {
+      console.error('\n  Warning: Failed to install dependencies.');
+    }
+  }
+
+  // Print next steps
+  const devCommand = getRunCommand(pkgManager, 'dev');
+}

package/src/init/templates/api.ts

@@ -0,0 +1,218 @@
+import type {
+  GeneratedFile,
+  TemplateConfig,
+  TemplateOptions,
+} from './index.js';
+
+export const apiTemplate: TemplateConfig = {
+  name: 'api',
+  description: 'Full API with auth, database, services',
+
+  dependencies: {
+    '@geekmidas/constructs': 'workspace:*',
+    '@geekmidas/envkit': 'workspace:*',
+    '@geekmidas/logger': 'workspace:*',
+    '@geekmidas/services': 'workspace:*',
+    '@geekmidas/errors': 'workspace:*',
+    '@geekmidas/auth': 'workspace:*',
+    hono: '~4.8.2',
+    pino: '~9.6.0',
+  },
+
+  devDependencies: {
+    '@biomejs/biome': '~1.9.4',
+    '@geekmidas/cli': 'workspace:*',
+    '@types/node': '~22.0.0',
+    tsx: '~4.20.0',
+    turbo: '~2.3.0',
+    typescript: '~5.8.2',
+    vitest: '~4.0.0',
+  },
+
+  scripts: {
+    dev: 'gkm dev',
+    build: 'gkm build',
+    test: 'vitest',
+    'test:once': 'vitest run',
+    typecheck: 'tsc --noEmit',
+    lint: 'biome lint .',
+    fmt: 'biome format . --write',
+    'fmt:check': 'biome format .',
+  },
+
+  files: (options: TemplateOptions): GeneratedFile[] => {
+    const files: GeneratedFile[] = [
+      // src/config/env.ts
+      {
+        path: 'src/config/env.ts',
+        content: `import { EnvironmentParser } from '@geekmidas/envkit';
+
+export const envParser = new EnvironmentParser(process.env);
+
+export const config = envParser
+  .create((get) => ({
+    port: get('PORT').string().transform(Number).default(3000),
+    nodeEnv: get('NODE_ENV').string().default('development'),
+    jwtSecret: get('JWT_SECRET').string().default('change-me-in-production'),${
+      options.database
+        ? `
+    database: {
+      url: get('DATABASE_URL').string().default('postgresql://localhost:5432/mydb'),
+    },`
+        : ''
+    }
+  }))
+  .parse();
+`,
+      },
+
+      // src/config/logger.ts - using pino
+      {
+        path: 'src/config/logger.ts',
+        content: `import { PinoLogger } from '@geekmidas/logger/pino';
+
+export const logger = new PinoLogger({
+  app: '${options.name}',
+  level: process.env.LOG_LEVEL || 'info',
+});
+`,
+      },
+
+      // src/endpoints/health.ts
+      {
+        path: 'src/endpoints/health.ts',
+        content: `import { e } from '@geekmidas/constructs/endpoints';
+
+export default e
+  .get('/health')
+  .handle(async () => ({
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+  }));
+`,
+      },
+    ];
+
+    // Add user endpoints based on route style
+    if (options.routeStyle === 'flat') {
+      files.push(
+        {
+          path: 'src/endpoints/users-list.ts',
+          content: `import { e } from '@geekmidas/constructs/endpoints';
+
+export default e
+  .get('/users')
+  .handle(async () => ({
+    users: [
+      { id: '1', name: 'Alice' },
+      { id: '2', name: 'Bob' },
+    ],
+  }));
+`,
+        },
+        {
+          path: 'src/endpoints/users-get.ts',
+          content: `import { e } from '@geekmidas/constructs/endpoints';
+import { z } from 'zod';
+
+export default e
+  .get('/users/:id')
+  .params(z.object({ id: z.string() }))
+  .handle(async ({ params }) => ({
+    id: params.id,
+    name: 'Alice',
+    email: 'alice@example.com',
+  }));
+`,
+        },
+      );
+    } else {
+      files.push(
+        {
+          path: 'src/endpoints/users/list.ts',
+          content: `import { e } from '@geekmidas/constructs/endpoints';
+
+export default e
+  .get('/users')
+  .handle(async () => ({
+    users: [
+      { id: '1', name: 'Alice' },
+      { id: '2', name: 'Bob' },
+    ],
+  }));
+`,
+        },
+        {
+          path: 'src/endpoints/users/get.ts',
+          content: `import { e } from '@geekmidas/constructs/endpoints';
+import { z } from 'zod';
+
+export default e
+  .get('/users/:id')
+  .params(z.object({ id: z.string() }))
+  .handle(async ({ params }) => ({
+    id: params.id,
+    name: 'Alice',
+    email: 'alice@example.com',
+  }));
+`,
+        },
+      );
+    }
+
+    // Add database service if enabled
+    if (options.database) {
+      files.push({
+        path: 'src/services/database.ts',
+        content: `import type { Service } from '@geekmidas/services';
+import { Kysely, PostgresDialect } from 'kysely';
+import pg from 'pg';
+
+// Define your database schema
+export interface Database {
+  users: {
+    id: string;
+    name: string;
+    email: string;
+    created_at: Date;
+  };
+}
+
+export const databaseService = {
+  serviceName: 'database' as const,
+  async register(envParser) {
+    const config = envParser
+      .create((get) => ({
+        url: get('DATABASE_URL').string(),
+      }))
+      .parse();
+
+    return new Kysely<Database>({
+      dialect: new PostgresDialect({
+        pool: new pg.Pool({ connectionString: config.url }),
+      }),
+    });
+  },
+} satisfies Service<'database', Kysely<Database>>;
+`,
+      });
+    }
+
+    // Add Telescope config if enabled
+    if (options.telescope) {
+      files.push({
+        path: 'src/config/telescope.ts',
+        content: `import { Telescope } from '@geekmidas/telescope';
+import { InMemoryStorage } from '@geekmidas/telescope/storage/memory';
+
+export const telescope = new Telescope({
+  storage: new InMemoryStorage({ maxEntries: 100 }),
+  enabled: process.env.NODE_ENV === 'development',
+});
+`,
+      });
+    }
+
+    return files;
+  },
+};

package/src/init/templates/index.ts

@@ -0,0 +1,108 @@
+import { apiTemplate } from './api.js';
+import { minimalTemplate } from './minimal.js';
+import { serverlessTemplate } from './serverless.js';
+import { workerTemplate } from './worker.js';
+
+/**
+ * Route organization style
+ */
+export type RouteStyle = 'file-based' | 'flat';
+
+/**
+ * Options collected from user prompts
+ */
+export interface TemplateOptions {
+  name: string;
+  template: TemplateName;
+  telescope: boolean;
+  database: boolean;
+  routeStyle: RouteStyle;
+  monorepo: boolean;
+  /** Path for the API app in monorepo (e.g., 'apps/api') */
+  apiPath: string;
+}
+
+/**
+ * A file to be generated
+ */
+export interface GeneratedFile {
+  path: string;
+  content: string;
+}
+
+/**
+ * Template configuration
+ */
+export interface TemplateConfig {
+  name: TemplateName;
+  description: string;
+  dependencies: Record<string, string>;
+  devDependencies: Record<string, string>;
+  scripts: Record<string, string>;
+  files: (options: TemplateOptions) => GeneratedFile[];
+}
+
+export type TemplateName = 'minimal' | 'api' | 'serverless' | 'worker';
+
+/**
+ * All available templates
+ */
+export const templates: Record<TemplateName, TemplateConfig> = {
+  minimal: minimalTemplate,
+  api: apiTemplate,
+  serverless: serverlessTemplate,
+  worker: workerTemplate,
+};
+
+/**
+ * Template choices for prompts
+ */
+export const templateChoices = [
+  {
+    title: 'Minimal',
+    value: 'minimal' as TemplateName,
+    description: 'Basic health endpoint',
+  },
+  {
+    title: 'API',
+    value: 'api' as TemplateName,
+    description: 'Full API with auth, database, services',
+  },
+  {
+    title: 'Serverless',
+    value: 'serverless' as TemplateName,
+    description: 'AWS Lambda handlers',
+  },
+  {
+    title: 'Worker',
+    value: 'worker' as TemplateName,
+    description: 'Background job processing',
+  },
+];
+
+/**
+ * Route style choices for prompts
+ */
+export const routeStyleChoices = [
+  {
+    title: 'File-based',
+    value: 'file-based' as RouteStyle,
+    description: 'Folder structure matches URL paths (users/list.ts → /users)',
+  },
+  {
+    title: 'Flat',
+    value: 'flat' as RouteStyle,
+    description: 'All endpoints in one folder (users-list.ts → /users)',
+  },
+];
+
+/**
+ * Get a template by name
+ */
+export function getTemplate(name: TemplateName): TemplateConfig {
+  const template = templates[name];
+  if (!template) {
+    throw new Error(`Unknown template: ${name}`);
+  }
+  return template;
+}