@objectstack/cli 2.0.7 → 3.0.1

package/src/commands/generate.ts

@@ -4,7 +4,7 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import fs from 'fs';
 import path from 'path';
-import { printHeader, printSuccess, printError, printInfo } from '../utils/format.js';
+import { printHeader, printSuccess, printError, printInfo, printStep, createTimer } from '../utils/format.js';
 
 // ─── Metadata Type Templates ────────────────────────────────────────
 
@@ -204,11 +204,110 @@ function toSnakeCase(str: string): string {
   return str.replace(/[-]/g, '_').replace(/[A-Z]/g, c => `_${c.toLowerCase()}`).replace(/^_/, '');
 }
 
+// ─── Field Type Mapping ─────────────────────────────────────────────
+
+const FIELD_TYPE_MAP: Record<string, string> = {
+  text: 'string',
+  textarea: 'string',
+  richtext: 'string',
+  html: 'string',
+  markdown: 'string',
+  number: 'number',
+  integer: 'number',
+  currency: 'number',
+  percent: 'number',
+  boolean: 'boolean',
+  date: 'string',
+  datetime: 'string',
+  time: 'string',
+  email: 'string',
+  phone: 'string',
+  url: 'string',
+  select: 'string',
+  multiselect: 'string[]',
+  lookup: 'string',
+  master_detail: 'string',
+  formula: 'unknown',
+  autonumber: 'string',
+  json: 'Record<string, unknown>',
+  file: 'string',
+  image: 'string',
+  password: 'string',
+  slug: 'string',
+  uuid: 'string',
+  ip_address: 'string',
+  color: 'string',
+  rating: 'number',
+  geo_point: '{ lat: number; lng: number }',
+  vector: 'number[]',
+  encrypted: 'string',
+};
+
+function fieldTypeToTs(fieldType: string, multiple?: boolean): string {
+  const base = FIELD_TYPE_MAP[fieldType] || 'unknown';
+  return multiple ? `${base}[]` : base;
+}
+
+function generateTypesFromConfig(config: Record<string, unknown>): string {
+  const lines: string[] = [
+    '// Auto-generated by ObjectStack CLI — do not edit manually',
+    `// Generated at ${new Date().toISOString()}`,
+    '',
+    "import type { Data } from '@objectstack/spec';",
+    '',
+  ];
+
+  // Extract objects from config (supports both top-level and nested)
+  const objects: Record<string, unknown>[] = [];
+  const rawObjects = (config as any).objects ?? (config as any).data?.objects ?? {};
+
+  if (Array.isArray(rawObjects)) {
+    objects.push(...rawObjects);
+  } else if (typeof rawObjects === 'object') {
+    for (const val of Object.values(rawObjects)) {
+      if (val && typeof val === 'object') objects.push(val as Record<string, unknown>);
+    }
+  }
+
+  if (objects.length === 0) {
+    lines.push('// No objects found in configuration');
+    return lines.join('\n') + '\n';
+  }
+
+  for (const obj of objects) {
+    const name = String(obj.name || 'unknown');
+    const typeName = name
+      .split('_')
+      .map((w: string) => w.charAt(0).toUpperCase() + w.slice(1))
+      .join('');
+    const fields = (obj.fields ?? {}) as Record<string, Record<string, unknown>>;
+
+    lines.push(`/** ${String(obj.label || typeName)} record type */`);
+    lines.push(`export interface ${typeName}Record {`);
+    lines.push('  id: string;');
+
+    for (const [fieldName, fieldDef] of Object.entries(fields)) {
+      const fType = String(fieldDef.type || 'text');
+      const tsType = fieldTypeToTs(fType, !!fieldDef.multiple);
+      const required = fieldDef.required ? '' : '?';
+      if (fieldDef.label) {
+        lines.push(`  /** ${fieldDef.label} */`);
+      }
+      lines.push(`  ${fieldName}${required}: ${tsType};`);
+    }
+
+    lines.push('}');
+    lines.push('');
+  }
+
+  return lines.join('\n') + '\n';
+}
+
 // ─── Command ────────────────────────────────────────────────────────
 
-export const generateCommand = new Command('generate')
-  .alias('g')
-  .description('Generate metadata files (object, view, action, flow, agent, dashboard, app)')
+const generateMetadataCommand = new Command('metadata')
+  .alias('m')
+  .description('Generate metadata scaffold (object, view, action, flow, agent, dashboard, app)')
   .argument('<type>', 'Metadata type to generate')
   .argument('<name>', 'Name for the metadata (use kebab-case)')
   .option('-d, --dir <directory>', 'Target directory (overrides default)')
@@ -297,3 +396,538 @@ export const generateCommand = new Command('generate')
       process.exit(1);
     }
   });
+
+const generateTypesCommand = new Command('types')
+  .description('Generate TypeScript type definitions from ObjectStack configuration')
+  .argument('[config]', 'Configuration file path')
+  .option('-o, --output <file>', 'Output file path', 'src/types/objectstack.d.ts')
+  .option('--dry-run', 'Show what would be generated without writing files')
+  .action(async (configPath, options) => {
+    printHeader('Generate Types');
+
+    try {
+      const { loadConfig } = await import('../utils/config.js');
+      printInfo('Loading configuration...');
+      const { config, absolutePath } = await loadConfig(configPath);
+
+      console.log(`  ${chalk.dim('Config:')} ${chalk.white(absolutePath)}`);
+      console.log(`  ${chalk.dim('Output:')} ${chalk.white(options.output)}`);
+      console.log('');
+
+      const content = generateTypesFromConfig(config as Record<string, unknown>);
+
+      if (options.dryRun) {
+        printInfo('Dry run — no files written');
+        console.log('');
+        for (const line of content.split('\n')) {
+          console.log(chalk.dim(`  ${line}`));
+        }
+        console.log('');
+        return;
+      }
+
+      const outPath = path.resolve(process.cwd(), options.output);
+      const outDir = path.dirname(outPath);
+      if (!fs.existsSync(outDir)) {
+        fs.mkdirSync(outDir, { recursive: true });
+      }
+      fs.writeFileSync(outPath, content);
+      printSuccess(`Generated types at ${options.output}`);
+      console.log('');
+
+    } catch (error: any) {
+      printError(error.message || String(error));
+      process.exit(1);
+    }
+  });
+
+// ─── Client SDK Generator ───────────────────────────────────────────
+
+function generateClientFromConfig(config: Record<string, unknown>): string {
+  const lines: string[] = [
+    '// Auto-generated by ObjectStack CLI — do not edit manually',
+    `// Generated at ${new Date().toISOString()}`,
+    '',
+    "import type { Data } from '@objectstack/spec';",
+    '',
+  ];
+
+  const objects: Record<string, unknown>[] = [];
+  const rawObjects = (config as any).objects ?? (config as any).data?.objects ?? {};
+
+  if (Array.isArray(rawObjects)) {
+    objects.push(...rawObjects);
+  } else if (typeof rawObjects === 'object') {
+    for (const val of Object.values(rawObjects)) {
+      if (val && typeof val === 'object') objects.push(val as Record<string, unknown>);
+    }
+  }
+
+  if (objects.length === 0) {
+    lines.push('// No objects found in configuration');
+    return lines.join('\n') + '\n';
+  }
+
+  // Generate type interfaces
+  for (const obj of objects) {
+    const name = String(obj.name || 'unknown');
+    const typeName = name
+      .split('_')
+      .map((w: string) => w.charAt(0).toUpperCase() + w.slice(1))
+      .join('');
+    const fields = (obj.fields ?? {}) as Record<string, Record<string, unknown>>;
+
+    lines.push(`export interface ${typeName}Record {`);
+    lines.push('  id: string;');
+
+    for (const [fieldName, fieldDef] of Object.entries(fields)) {
+      const fType = String(fieldDef.type || 'text');
+      const tsType = fieldTypeToTs(fType, !!fieldDef.multiple);
+      const required = fieldDef.required ? '' : '?';
+      lines.push(`  ${fieldName}${required}: ${tsType};`);
+    }
+
+    lines.push('}');
+    lines.push('');
+  }
+
+  // Generate client class
+  lines.push('export class ObjectStackClient {');
+  lines.push('  constructor(private baseUrl: string, private headers: Record<string, string> = {}) {}');
+  lines.push('');
+  lines.push('  private async request<T>(method: string, path: string, body?: unknown): Promise<T> {');
+  lines.push('    const res = await fetch(`${this.baseUrl}${path}`, {');
+  lines.push('      method,');
+  lines.push("      headers: { 'Content-Type': 'application/json', ...this.headers },");
+  lines.push('      body: body ? JSON.stringify(body) : undefined,');
+  lines.push('    });');
+  lines.push('    if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);');
+  lines.push('    return res.json() as Promise<T>;');
+  lines.push('  }');
+
+  for (const obj of objects) {
+    const name = String(obj.name || 'unknown');
+    const typeName = name
+      .split('_')
+      .map((w: string) => w.charAt(0).toUpperCase() + w.slice(1))
+      .join('');
+    const endpoint = `/api/${name}`;
+
+    lines.push('');
+    lines.push(`  async list${typeName}(): Promise<${typeName}Record[]> {`);
+    lines.push(`    return this.request<${typeName}Record[]>('GET', '${endpoint}');`);
+    lines.push('  }');
+    lines.push('');
+    lines.push(`  async get${typeName}(id: string): Promise<${typeName}Record> {`);
+    lines.push(`    return this.request<${typeName}Record>('GET', '${endpoint}/\${id}');`);
+    lines.push('  }');
+    lines.push('');
+    lines.push(`  async create${typeName}(data: Omit<${typeName}Record, 'id'>): Promise<${typeName}Record> {`);
+    lines.push(`    return this.request<${typeName}Record>('POST', '${endpoint}', data);`);
+    lines.push('  }');
+    lines.push('');
+    lines.push(`  async update${typeName}(id: string, data: Partial<${typeName}Record>): Promise<${typeName}Record> {`);
+    lines.push(`    return this.request<${typeName}Record>('PATCH', '${endpoint}/\${id}', data);`);
+    lines.push('  }');
+    lines.push('');
+    lines.push(`  async delete${typeName}(id: string): Promise<void> {`);
+    lines.push(`    return this.request<void>('DELETE', '${endpoint}/\${id}');`);
+    lines.push('  }');
+  }
+
+  lines.push('}');
+  lines.push('');
+
+  return lines.join('\n') + '\n';
+}
+
+const generateClientCommand = new Command('client')
+  .description('Generate a type-safe client SDK from ObjectStack configuration')
+  .argument('[config]', 'Configuration file path')
+  .option('-o, --output <file>', 'Output file path', 'src/client/objectstack-client.ts')
+  .option('--dry-run', 'Show output without writing')
+  .action(async (configPath, options) => {
+    printHeader('Generate Client SDK');
+
+    try {
+      const { loadConfig } = await import('../utils/config.js');
+      const timer = createTimer();
+      printInfo('Loading configuration...');
+      const { config, absolutePath } = await loadConfig(configPath);
+
+      console.log(`  ${chalk.dim('Config:')} ${chalk.white(absolutePath)}`);
+      console.log(`  ${chalk.dim('Output:')} ${chalk.white(options.output)}`);
+      console.log('');
+
+      printStep('Generating client SDK...');
+      const content = generateClientFromConfig(config as Record<string, unknown>);
+
+      if (options.dryRun) {
+        printInfo('Dry run — no files written');
+        console.log('');
+        for (const line of content.split('\n')) {
+          console.log(chalk.dim(`  ${line}`));
+        }
+        console.log('');
+        return;
+      }
+
+      const outPath = path.resolve(process.cwd(), options.output);
+      const outDir = path.dirname(outPath);
+      if (!fs.existsSync(outDir)) {
+        fs.mkdirSync(outDir, { recursive: true });
+      }
+      fs.writeFileSync(outPath, content);
+      printSuccess(`Generated client SDK at ${options.output} (${timer.display()})`);
+      console.log('');
+
+    } catch (error: any) {
+      printError(error.message || String(error));
+      process.exit(1);
+    }
+  });
+
+// ─── Migration Generator ────────────────────────────────────────────
+
+const FIELD_TYPE_SQL_MAP: Record<string, string> = {
+  text: 'VARCHAR(255)',
+  textarea: 'TEXT',
+  richtext: 'TEXT',
+  html: 'TEXT',
+  markdown: 'TEXT',
+  number: 'DECIMAL(18,2)',
+  integer: 'INTEGER',
+  currency: 'DECIMAL(18,2)',
+  percent: 'DECIMAL(5,2)',
+  boolean: 'BOOLEAN',
+  date: 'DATE',
+  datetime: 'TIMESTAMP',
+  time: 'TIME',
+  email: 'VARCHAR(255)',
+  phone: 'VARCHAR(50)',
+  url: 'VARCHAR(2048)',
+  select: 'VARCHAR(255)',
+  multiselect: 'TEXT',
+  lookup: 'VARCHAR(36)',
+  master_detail: 'VARCHAR(36)',
+  formula: 'TEXT',
+  autonumber: 'SERIAL',
+  json: 'JSONB',
+  file: 'VARCHAR(2048)',
+  image: 'VARCHAR(2048)',
+  password: 'VARCHAR(255)',
+  slug: 'VARCHAR(255)',
+  uuid: 'UUID',
+  ip_address: 'VARCHAR(45)',
+  color: 'VARCHAR(7)',
+  rating: 'INTEGER',
+  geo_point: 'POINT',
+  vector: 'VECTOR',
+  encrypted: 'TEXT',
+};
+
+function fieldTypeToSql(fieldType: string): string {
+  return FIELD_TYPE_SQL_MAP[fieldType] || 'TEXT';
+}
+
+function generateMigrationSql(config: Record<string, unknown>): string {
+  const lines: string[] = [
+    '-- Auto-generated by ObjectStack CLI — do not edit manually',
+    `-- Generated at ${new Date().toISOString()}`,
+    '',
+  ];
+
+  const objects: Record<string, unknown>[] = [];
+  const rawObjects = (config as any).objects ?? (config as any).data?.objects ?? {};
+
+  if (Array.isArray(rawObjects)) {
+    objects.push(...rawObjects);
+  } else if (typeof rawObjects === 'object') {
+    for (const val of Object.values(rawObjects)) {
+      if (val && typeof val === 'object') objects.push(val as Record<string, unknown>);
+    }
+  }
+
+  if (objects.length === 0) {
+    lines.push('-- No objects found in configuration');
+    return lines.join('\n') + '\n';
+  }
+
+  for (const obj of objects) {
+    const tableName = String(obj.name || 'unknown');
+    const fields = (obj.fields ?? {}) as Record<string, Record<string, unknown>>;
+
+    lines.push(`CREATE TABLE IF NOT EXISTS "${tableName}" (`);
+    lines.push('  "id" UUID PRIMARY KEY DEFAULT gen_random_uuid(),');
+
+    const fieldLines: string[] = [];
+    for (const [fieldName, fieldDef] of Object.entries(fields)) {
+      const sqlType = fieldTypeToSql(String(fieldDef.type || 'text'));
+      const notNull = fieldDef.required ? ' NOT NULL' : '';
+      fieldLines.push(`  "${fieldName}" ${sqlType}${notNull}`);
+    }
+
+    fieldLines.push('  "created_at" TIMESTAMP NOT NULL DEFAULT now()');
+    fieldLines.push('  "updated_at" TIMESTAMP NOT NULL DEFAULT now()');
+    lines.push(fieldLines.join(',\n'));
+    lines.push(');');
+    lines.push('');
+  }
+
+  return lines.join('\n') + '\n';
+}
+
+function generateMigrationTs(config: Record<string, unknown>): string {
+  const lines: string[] = [
+    '// Auto-generated by ObjectStack CLI — do not edit manually',
+    `// Generated at ${new Date().toISOString()}`,
+    '',
+    'export async function up(db: any): Promise<void> {',
+  ];
+
+  const objects: Record<string, unknown>[] = [];
+  const rawObjects = (config as any).objects ?? (config as any).data?.objects ?? {};
+
+  if (Array.isArray(rawObjects)) {
+    objects.push(...rawObjects);
+  } else if (typeof rawObjects === 'object') {
+    for (const val of Object.values(rawObjects)) {
+      if (val && typeof val === 'object') objects.push(val as Record<string, unknown>);
+    }
+  }
+
+  if (objects.length === 0) {
+    lines.push('  // No objects found in configuration');
+    lines.push('}');
+    lines.push('');
+    lines.push('export async function down(db: any): Promise<void> {');
+    lines.push('  // No objects found in configuration');
+    lines.push('}');
+    return lines.join('\n') + '\n';
+  }
+
+  for (const obj of objects) {
+    const tableName = String(obj.name || 'unknown');
+    const fields = (obj.fields ?? {}) as Record<string, Record<string, unknown>>;
+
+    lines.push(`  await db.schema.createTable('${tableName}', (table: any) => {`);
+    lines.push("    table.uuid('id').primary().defaultTo(db.fn.uuid());");
+
+    for (const [fieldName, fieldDef] of Object.entries(fields)) {
+      const fType = String(fieldDef.type || 'text');
+      const required = fieldDef.required ? '.notNullable()' : '.nullable()';
+      let colMethod: string;
+
+      switch (fType) {
+        case 'text': case 'email': case 'phone': case 'url': case 'select':
+        case 'slug': case 'password': case 'color': case 'ip_address':
+          colMethod = `table.string('${fieldName}')`;
+          break;
+        case 'textarea': case 'richtext': case 'html': case 'markdown':
+        case 'formula': case 'encrypted':
+          colMethod = `table.text('${fieldName}')`;
+          break;
+        case 'number': case 'currency': case 'percent':
+          colMethod = `table.decimal('${fieldName}')`;
+          break;
+        case 'integer': case 'rating':
+          colMethod = `table.integer('${fieldName}')`;
+          break;
+        case 'boolean':
+          colMethod = `table.boolean('${fieldName}')`;
+          break;
+        case 'date':
+          colMethod = `table.date('${fieldName}')`;
+          break;
+        case 'datetime':
+          colMethod = `table.timestamp('${fieldName}')`;
+          break;
+        case 'time':
+          colMethod = `table.time('${fieldName}')`;
+          break;
+        case 'json': case 'multiselect':
+          colMethod = `table.jsonb('${fieldName}')`;
+          break;
+        case 'uuid': case 'lookup': case 'master_detail':
+          colMethod = `table.uuid('${fieldName}')`;
+          break;
+        default:
+          colMethod = `table.text('${fieldName}')`;
+      }
+
+      lines.push(`    ${colMethod}${required};`);
+    }
+
+    lines.push("    table.timestamps(true, true);");
+    lines.push('  });');
+  }
+
+  lines.push('}');
+  lines.push('');
+  lines.push('export async function down(db: any): Promise<void> {');
+
+  // Drop tables in reverse order
+  const tableNames = objects.map(o => String(o.name || 'unknown')).reverse();
+  for (const tableName of tableNames) {
+    lines.push(`  await db.schema.dropTableIfExists('${tableName}');`);
+  }
+
+  lines.push('}');
+
+  return lines.join('\n') + '\n';
+}
+
+const generateMigrationCommand = new Command('migration')
+  .description('Generate database migration from ObjectStack schema')
+  .argument('[config]', 'Configuration file path')
+  .option('-o, --output <file>', 'Output file path')
+  .option('--format <format>', 'Output format: sql or typescript', 'typescript')
+  .option('--dry-run', 'Show output without writing')
+  .action(async (configPath, options) => {
+    printHeader('Generate Migration');
+
+    try {
+      const { loadConfig } = await import('../utils/config.js');
+      const timer = createTimer();
+      printInfo('Loading configuration...');
+      const { config, absolutePath } = await loadConfig(configPath);
+
+      const ext = options.format === 'sql' ? 'sql' : 'ts';
+      // Format: YYYYMMDDHHmmss (e.g. 20250101120000)
+      const timestamp = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14);
+      const defaultOutput = `migrations/${timestamp}_migration.${ext}`;
+      const output = options.output || defaultOutput;
+
+      console.log(`  ${chalk.dim('Config:')} ${chalk.white(absolutePath)}`);
+      console.log(`  ${chalk.dim('Format:')} ${chalk.white(options.format)}`);
+      console.log(`  ${chalk.dim('Output:')} ${chalk.white(output)}`);
+      console.log('');
+
+      printStep('Generating migration...');
+      const content = options.format === 'sql'
+        ? generateMigrationSql(config as Record<string, unknown>)
+        : generateMigrationTs(config as Record<string, unknown>);
+
+      if (options.dryRun) {
+        printInfo('Dry run — no files written');
+        console.log('');
+        for (const line of content.split('\n')) {
+          console.log(chalk.dim(`  ${line}`));
+        }
+        console.log('');
+        return;
+      }
+
+      const outPath = path.resolve(process.cwd(), output);
+      const outDir = path.dirname(outPath);
+      if (!fs.existsSync(outDir)) {
+        fs.mkdirSync(outDir, { recursive: true });
+      }
+      fs.writeFileSync(outPath, content);
+      printSuccess(`Generated migration at ${output} (${timer.display()})`);
+      console.log('');
+
+    } catch (error: any) {
+      printError(error.message || String(error));
+      process.exit(1);
+    }
+  });
+
+// ─── JSON Schema Generator ──────────────────────────────────────────
+
+const generateSchemaCommand = new Command('schema')
+  .description('Generate JSON Schema for objectstack.config.ts (for IDE autocomplete)')
+  .option('-o, --output <file>', 'Output file path', 'objectstack.schema.json')
+  .option('--dry-run', 'Show output without writing')
+  .action(async (options) => {
+    printHeader('Generate Schema');
+
+    try {
+      const timer = createTimer();
+      printStep('Loading ObjectStackDefinitionSchema...');
+
+      const { z } = await import('zod');
+      const { ObjectStackDefinitionSchema } = await import('@objectstack/spec');
+
+      printStep('Converting to JSON Schema...');
+      const jsonSchema = z.toJSONSchema(ObjectStackDefinitionSchema, {
+        target: 'draft-2020-12',
+      });
+
+      // Add metadata
+      const schema = {
+        ...jsonSchema,
+        $id: 'https://schema.objectstack.io/objectstack.config.json',
+        title: 'ObjectStack Configuration',
+        description: 'JSON Schema for objectstack.config.ts — generated from ObjectStackDefinitionSchema',
+      };
+
+      const content = JSON.stringify(schema, null, 2) + '\n';
+
+      if (options.dryRun) {
+        printInfo('Dry run — no files written');
+        console.log('');
+        console.log(content);
+        return;
+      }
+
+      const outPath = path.resolve(process.cwd(), options.output);
+      const outDir = path.dirname(outPath);
+      if (!fs.existsSync(outDir)) {
+        fs.mkdirSync(outDir, { recursive: true });
+      }
+      fs.writeFileSync(outPath, content);
+      printSuccess(`Generated JSON Schema at ${options.output} (${timer.display()})`);
+      console.log('');
+      console.log(chalk.dim('  Usage: Reference in your IDE or editor for autocomplete'));
+      console.log(chalk.dim(`  Path:  ${outPath}`));
+      console.log('');
+
+    } catch (error: any) {
+      printError(error.message || String(error));
+      process.exit(1);
+    }
+  });
+
+// ─── Main Generate Command ──────────────────────────────────────────
+
+export const generateCommand = new Command('generate')
+  .alias('g')
+  .description('Generate metadata files or TypeScript types')
+  .argument('[type]', 'Metadata type to generate (object, view, action, flow, agent, dashboard, app)')
+  .argument('[name]', 'Name for the metadata (use kebab-case)')
+  .option('-d, --dir <directory>', 'Target directory (overrides default)')
+  .option('--dry-run', 'Show what would be created without writing files')
+  .addCommand(generateTypesCommand)
+  .addCommand(generateClientCommand)
+  .addCommand(generateMigrationCommand)
+  .addCommand(generateSchemaCommand)
+  .action(async (type: string | undefined, name: string | undefined, options) => {
+    if (!type) {
+      printHeader('Generate');
+      console.log(chalk.bold('  Sub-commands:'));
+      console.log(`    ${chalk.cyan('types'.padEnd(12))} Generate TypeScript type definitions from config`);
+      console.log(`    ${chalk.cyan('client'.padEnd(12))} Generate a type-safe client SDK from config`);
+      console.log(`    ${chalk.cyan('migration'.padEnd(12))} Generate database migration from schema`);
+      console.log(`    ${chalk.cyan('schema'.padEnd(12))} Generate JSON Schema for objectstack.config.ts (IDE autocomplete)`);
+      console.log('');
+      console.log(chalk.bold('  Metadata types:'));
+      for (const [key, gen] of Object.entries(GENERATORS)) {
+        console.log(`    ${chalk.cyan(key.padEnd(12))} ${chalk.dim(gen.description)}`);
+      }
+      console.log('');
+      console.log(chalk.dim('  Usage: objectstack generate <type> <name>'));
+      console.log(chalk.dim('  Usage: objectstack generate types [config]'));
+      return;
+    }
+
+    // Delegate to metadata command action
+    if (!name) {
+      printError('Missing required argument: <name>');
+      console.log(chalk.dim('  Usage: objectstack generate <type> <name>'));
+      process.exit(1);
+    }
+
+    // Execute metadata generation inline
+    await generateMetadataCommand.parseAsync([type, name, ...process.argv.slice(4)], { from: 'user' });
+  });