@objectstack/cli 3.0.5 → 3.0.7

package/src/commands/generate.ts

@@ -1,6 +1,6 @@
 // Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
 
-import { Command } from 'commander';
+import { Args, Command, Flags } from '@oclif/core';
 import chalk from 'chalk';
 import fs from 'fs';
 import path from 'path';
@@ -305,14 +305,7 @@ function generateTypesFromConfig(config: Record<string, unknown>): string {
 
 // ─── Command ────────────────────────────────────────────────────────
 
-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)')
-  .option('--dry-run', 'Show what would be created without writing files')
-  .action(async (type: string, name: string, options) => {
+async function runMetadataGeneration(type: string, name: string, flags: { dir?: string; dryRun?: boolean }): Promise<void> {
     printHeader('Generate');
 
     const generator = GENERATORS[type];
@@ -330,7 +323,7 @@ const generateMetadataCommand = new Command('metadata')
       process.exit(1);
     }
 
-    const dir = options.dir || generator.defaultDir;
+    const dir = flags.dir || generator.defaultDir;
     const fileName = `${toSnakeCase(name)}.ts`;
     const filePath = path.join(process.cwd(), dir, fileName);
 
@@ -339,7 +332,7 @@ const generateMetadataCommand = new Command('metadata')
     console.log(`  ${chalk.dim('File:')}  ${chalk.white(path.join(dir, fileName))}`);
     console.log('');
 
-    if (options.dryRun) {
+    if (flags.dryRun) {
       printInfo('Dry run — no files written');
       console.log('');
       console.log(chalk.dim('  Content:'));
@@ -395,14 +388,9 @@ const generateMetadataCommand = new Command('metadata')
       printError(error.message || String(error));
       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) => {
+}
+
+async function runTypesGeneration(configPath: string | undefined, flags: { output: string; dryRun?: boolean }): Promise<void> {
     printHeader('Generate Types');
 
     try {
@@ -411,12 +399,12 @@ const generateTypesCommand = new Command('types')
       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(`  ${chalk.dim('Output:')} ${chalk.white(flags.output)}`);
       console.log('');
 
       const content = generateTypesFromConfig(config as Record<string, unknown>);
 
-      if (options.dryRun) {
+      if (flags.dryRun) {
         printInfo('Dry run — no files written');
         console.log('');
         for (const line of content.split('\n')) {
@@ -426,20 +414,20 @@ const generateTypesCommand = new Command('types')
         return;
       }
 
-      const outPath = path.resolve(process.cwd(), options.output);
+      const outPath = path.resolve(process.cwd(), flags.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}`);
+      printSuccess(`Generated types at ${flags.output}`);
       console.log('');
 
     } catch (error: any) {
       printError(error.message || String(error));
       process.exit(1);
     }
-  });
+}
 
 // ─── Client SDK Generator ───────────────────────────────────────────
 
@@ -541,12 +529,7 @@ function generateClientFromConfig(config: Record<string, unknown>): string {
   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) => {
+async function runClientGeneration(configPath: string | undefined, flags: { output: string; dryRun?: boolean }): Promise<void> {
     printHeader('Generate Client SDK');
 
     try {
@@ -556,13 +539,13 @@ const generateClientCommand = new Command('client')
       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(`  ${chalk.dim('Output:')} ${chalk.white(flags.output)}`);
       console.log('');
 
       printStep('Generating client SDK...');
       const content = generateClientFromConfig(config as Record<string, unknown>);
 
-      if (options.dryRun) {
+      if (flags.dryRun) {
         printInfo('Dry run — no files written');
         console.log('');
         for (const line of content.split('\n')) {
@@ -572,20 +555,20 @@ const generateClientCommand = new Command('client')
         return;
       }
 
-      const outPath = path.resolve(process.cwd(), options.output);
+      const outPath = path.resolve(process.cwd(), flags.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()})`);
+      printSuccess(`Generated client SDK at ${flags.output} (${timer.display()})`);
       console.log('');
 
     } catch (error: any) {
       printError(error.message || String(error));
       process.exit(1);
     }
-  });
+}
 
 // ─── Migration Generator ────────────────────────────────────────────
 
@@ -777,13 +760,7 @@ function generateMigrationTs(config: Record<string, unknown>): string {
   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) => {
+async function runMigrationGeneration(configPath: string | undefined, flags: { output?: string; format: string; dryRun?: boolean }): Promise<void> {
     printHeader('Generate Migration');
 
     try {
@@ -792,23 +769,23 @@ const generateMigrationCommand = new Command('migration')
       printInfo('Loading configuration...');
       const { config, absolutePath } = await loadConfig(configPath);
 
-      const ext = options.format === 'sql' ? 'sql' : 'ts';
+      const ext = flags.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;
+      const output = flags.output || defaultOutput;
 
       console.log(`  ${chalk.dim('Config:')} ${chalk.white(absolutePath)}`);
-      console.log(`  ${chalk.dim('Format:')} ${chalk.white(options.format)}`);
+      console.log(`  ${chalk.dim('Format:')} ${chalk.white(flags.format)}`);
       console.log(`  ${chalk.dim('Output:')} ${chalk.white(output)}`);
       console.log('');
 
       printStep('Generating migration...');
-      const content = options.format === 'sql'
+      const content = flags.format === 'sql'
         ? generateMigrationSql(config as Record<string, unknown>)
         : generateMigrationTs(config as Record<string, unknown>);
 
-      if (options.dryRun) {
+      if (flags.dryRun) {
         printInfo('Dry run — no files written');
         console.log('');
         for (const line of content.split('\n')) {
@@ -831,15 +808,11 @@ const generateMigrationCommand = new Command('migration')
       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) => {
+async function runSchemaGeneration(flags: { output: string; dryRun?: boolean }): Promise<void> {
     printHeader('Generate Schema');
 
     try {
@@ -864,20 +837,20 @@ const generateSchemaCommand = new Command('schema')
 
       const content = JSON.stringify(schema, null, 2) + '\n';
 
-      if (options.dryRun) {
+      if (flags.dryRun) {
         printInfo('Dry run — no files written');
         console.log('');
         console.log(content);
         return;
       }
 
-      const outPath = path.resolve(process.cwd(), options.output);
+      const outPath = path.resolve(process.cwd(), flags.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()})`);
+      printSuccess(`Generated JSON Schema at ${flags.output} (${timer.display()})`);
       console.log('');
       console.log(chalk.dim('  Usage: Reference in your IDE or editor for autocomplete'));
       console.log(chalk.dim(`  Path:  ${outPath}`));
@@ -887,47 +860,65 @@ const generateSchemaCommand = new Command('schema')
       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;
+export default class Generate extends Command {
+  static override description = 'Generate metadata files or TypeScript types';
+
+  static override aliases = ['g'];
+
+  static override args = {
+    type: Args.string({ description: 'Metadata type to generate (object, view, action, flow, agent, dashboard, app)', required: true }),
+    name: Args.string({ description: 'Name for the metadata (use kebab-case)', required: false }),
+  };
+
+  static override flags = {
+    dir: Flags.string({ char: 'd', description: 'Target directory (overrides default)' }),
+    'dry-run': Flags.boolean({ description: 'Show what would be created without writing files' }),
+    output: Flags.string({ char: 'o', description: 'Output file path' }),
+    format: Flags.string({ description: 'Output format: sql or typescript', default: 'typescript' }),
+  };
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Generate);
+
+    // Route to sub-commands by type name
+    switch (args.type) {
+      case 'types':
+        return runTypesGeneration(args.name, {
+          output: flags.output ?? 'src/types/objectstack.d.ts',
+          dryRun: flags['dry-run'],
+        });
+      case 'client':
+        return runClientGeneration(args.name, {
+          output: flags.output ?? 'src/client/objectstack-client.ts',
+          dryRun: flags['dry-run'],
+        });
+      case 'migration':
+        return runMigrationGeneration(args.name, {
+          output: flags.output,
+          format: flags.format ?? 'typescript',
+          dryRun: flags['dry-run'],
+        });
+      case 'schema':
+        return runSchemaGeneration({
+          output: flags.output ?? 'objectstack.schema.json',
+          dryRun: flags['dry-run'],
+        });
     }
 
-    // Delegate to metadata command action
-    if (!name) {
+    // Metadata generation
+    if (!args.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' });
-  });
+    await runMetadataGeneration(args.type, args.name, {
+      dir: flags.dir,
+      dryRun: flags['dry-run'],
+    });
+  }
+}

package/src/commands/info.ts

@@ -1,7 +1,8 @@
 // Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
 
-import { Command } from 'commander';
+import { Args, Command, Flags } from '@oclif/core';
 import chalk from 'chalk';
+import { normalizeStackInput } from '@objectstack/spec';
 import { loadConfig } from '../utils/config.js';
 import {
   printHeader,
@@ -14,22 +15,31 @@ import {
   printMetadataStats,
 } from '../utils/format.js';
 
-export const infoCommand = new Command('info')
-  .description('Display metadata summary of an ObjectStack configuration')
-  .argument('[config]', 'Configuration file path')
-  .option('--json', 'Output as JSON')
-  .action(async (configPath, options) => {
+export default class Info extends Command {
+  static override description = 'Display metadata summary of an ObjectStack configuration';
+
+  static override args = {
+    config: Args.string({ description: 'Configuration file path', required: false }),
+  };
+
+  static override flags = {
+    json: Flags.boolean({ description: 'Output as JSON' }),
+  };
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Info);
     const timer = createTimer();
 
-    if (!options.json) {
+    if (!flags.json) {
       printHeader('Info');
     }
 
     try {
-      const { config, absolutePath, duration } = await loadConfig(configPath);
+      const { config: rawConfig, absolutePath, duration } = await loadConfig(args.config);
+      const config: any = normalizeStackInput(rawConfig as Record<string, unknown>);
       const stats = collectMetadataStats(config);
 
-      if (options.json) {
+      if (flags.json) {
         console.log(JSON.stringify({
           config: absolutePath,
           manifest: config.manifest || null,
@@ -102,7 +112,7 @@ export const infoCommand = new Command('info')
       console.log('');
 
     } catch (error: any) {
-      if (options.json) {
+      if (flags.json) {
         console.log(JSON.stringify({ error: error.message }));
         process.exit(1);
       }
@@ -110,4 +120,5 @@ export const infoCommand = new Command('info')
       printError(error.message || String(error));
       process.exit(1);
     }
-  });
+  }
+}

package/src/commands/init.ts

@@ -1,12 +1,12 @@
 // Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
 
-import { Command } from 'commander';
+import { Args, Command, Flags } from '@oclif/core';
 import chalk from 'chalk';
 import fs from 'fs';
 import path from 'path';
 import { printHeader, printSuccess, printError, printStep, printKV, printInfo } from '../utils/format.js';
 
-const TEMPLATES: Record<string, {
+export const TEMPLATES: Record<string, {
   description: string;
   dependencies: Record<string, string>;
   devDependencies: Record<string, string>;
@@ -179,33 +179,48 @@ function toTitleCase(str: string): string {
   return str.replace(/[-_]/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
 }
 
-export const initCommand = new Command('init')
-  .description('Initialize a new ObjectStack project in the current directory')
-  .argument('[name]', 'Project name (defaults to directory name)')
-  .option('-t, --template <template>', 'Template: app, plugin, empty', 'app')
-  .option('--no-install', 'Skip dependency installation')
-  .action(async (name, options) => {
+function printWarning(msg: string) {
+  console.log(chalk.yellow(`  ⚠ ${msg}`));
+}
+
+export default class Init extends Command {
+  static override id = 'init';
+
+  static override description = 'Initialize a new ObjectStack project in the current directory';
+
+  static override args = {
+    name: Args.string({ description: 'Project name (defaults to directory name)', required: false }),
+  };
+
+  static override flags = {
+    template: Flags.string({ char: 't', description: 'Template: app, plugin, empty', default: 'app' }),
+    install: Flags.boolean({ description: 'Install dependencies', default: true, allowNo: true }),
+  };
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Init);
+
     printHeader('Init');
 
     const cwd = process.cwd();
-    const projectName = name || path.basename(cwd);
-    const template = TEMPLATES[options.template];
+    const projectName = args.name || path.basename(cwd);
+    const template = TEMPLATES[flags.template];
 
     if (!template) {
-      printError(`Unknown template: ${options.template}`);
+      printError(`Unknown template: ${flags.template}`);
       console.log(chalk.dim(`  Available: ${Object.keys(TEMPLATES).join(', ')}`));
-      process.exit(1);
+      this.error(`Unknown template: ${flags.template}`);
     }
 
     // Check for existing config
     if (fs.existsSync(path.join(cwd, 'objectstack.config.ts'))) {
       printError('objectstack.config.ts already exists in this directory');
       console.log(chalk.dim('  Use `objectstack generate` to add metadata to an existing project'));
-      process.exit(1);
+      this.error('objectstack.config.ts already exists in this directory');
     }
 
     printKV('Project', projectName);
-    printKV('Template', `${options.template} — ${template.description}`);
+    printKV('Template', `${flags.template} — ${template.description}`);
     printKV('Directory', cwd);
     console.log('');
 
@@ -286,7 +301,7 @@ export const initCommand = new Command('init')
       console.log('');
 
       // Install dependencies
-      if (options.install !== false) {
+      if (flags.install) {
         printStep('Installing dependencies...');
         const { execSync } = await import('child_process');
         try {
@@ -306,10 +321,7 @@ export const initCommand = new Command('init')
 
     } catch (error: any) {
       printError(error.message || String(error));
-      process.exit(1);
+      this.error(error.message || String(error));
     }
-  });
-
-function printWarning(msg: string) {
-  console.log(chalk.yellow(`  ⚠ ${msg}`));
+  }
 }

package/src/commands/lint.ts

@@ -1,7 +1,8 @@
 // Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
 
-import { Command } from 'commander';
+import { Args, Command, Flags } from '@oclif/core';
 import chalk from 'chalk';
+import { normalizeStackInput } from '@objectstack/spec';
 import { loadConfig } from '../utils/config.js';
 import {
   printHeader,
@@ -187,15 +188,24 @@ function lintConfig(config: any): LintIssue[] {
 
 // ─── Command ────────────────────────────────────────────────────────
 
-export const lintCommand = new Command('lint')
-  .description('Check ObjectStack configuration for style and convention issues')
-  .argument('[config]', 'Configuration file path')
-  .option('--json', 'Output as JSON')
-  .option('--fix', 'Show what would be fixed (dry-run)')
-  .action(async (configPath, options) => {
+export default class Lint extends Command {
+  static override description = 'Check ObjectStack configuration for style and convention issues';
+
+  static override args = {
+    config: Args.string({ description: 'Configuration file path', required: false }),
+  };
+
+  static override flags = {
+    json: Flags.boolean({ description: 'Output as JSON' }),
+    fix: Flags.boolean({ description: 'Show what would be fixed (dry-run)' }),
+  };
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Lint);
+    const configPath = args.config;
     const timer = createTimer();
 
-    if (!options.json) {
+    if (!flags.json) {
       printHeader('Lint');
       printStep('Loading configuration...');
     }
@@ -203,14 +213,15 @@ export const lintCommand = new Command('lint')
     try {
       const { config, absolutePath } = await loadConfig(configPath);
 
-      if (!options.json) {
+      if (!flags.json) {
         printInfo(`Config: ${chalk.white(absolutePath)}`);
       }
 
-      const issues = lintConfig(config);
+      const normalized = normalizeStackInput(config as Record<string, unknown>);
+      const issues = lintConfig(normalized);
 
       // ── JSON output ──
-      if (options.json) {
+      if (flags.json) {
         const errors = issues.filter((i) => i.severity === 'error');
         const warnings = issues.filter((i) => i.severity === 'warning');
         const suggestions = issues.filter((i) => i.severity === 'suggestion');
@@ -252,7 +263,7 @@ export const lintCommand = new Command('lint')
 
         console.log(`  ${color(icon)} ${color(issue.message)}`);
         console.log(chalk.dim(`    ${issue.rule}  at ${issue.path}`));
-        if (options.fix && issue.fix) {
+        if (flags.fix && issue.fix) {
           console.log(chalk.green(`    → fix: ${issue.fix}`));
         }
       };
@@ -282,7 +293,7 @@ export const lintCommand = new Command('lint')
       if (suggestions.length > 0) parts.push(chalk.blue(`${suggestions.length} suggestion(s)`));
       console.log(`  ${parts.join(', ')} ${chalk.dim(`(${timer.display()})`)}`);
 
-      if (options.fix) {
+      if (flags.fix) {
         console.log('');
         printInfo('Dry-run mode: no files were modified.');
       }
@@ -292,7 +303,7 @@ export const lintCommand = new Command('lint')
       if (errors.length > 0) process.exit(1);
 
     } catch (error: any) {
-      if (options.json) {
+      if (flags.json) {
         console.log(JSON.stringify({ error: error.message }));
         process.exit(1);
       }
@@ -300,4 +311,5 @@ export const lintCommand = new Command('lint')
       printError(error.message || String(error));
       process.exit(1);
     }
-  });
+  }
+}