@objectstack/cli 1.0.10 → 1.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/cli",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "Command Line Interface for ObjectStack Protocol",
   "main": "dist/index.js",
   "bin": {
@@ -21,16 +21,16 @@
     "chalk": "^5.3.0",
     "commander": "^14.0.3",
     "tsx": "^4.7.1",
-    "zod": "^4.3.6",
-    "@objectstack/core": "1.0.10",
-    "@objectstack/driver-memory": "^1.0.10",
-    "@objectstack/objectql": "^1.0.10",
-    "@objectstack/plugin-hono-server": "1.0.10",
-    "@objectstack/runtime": "^1.0.10",
-    "@objectstack/spec": "1.0.10"
+    "zod": "^3.24.1",
+    "@objectstack/core": "1.0.12",
+    "@objectstack/driver-memory": "^1.0.12",
+    "@objectstack/objectql": "^1.0.12",
+    "@objectstack/plugin-hono-server": "1.0.12",
+    "@objectstack/runtime": "^1.0.12",
+    "@objectstack/spec": "1.0.12"
   },
   "peerDependencies": {
-    "@objectstack/core": "^1.0.10"
+    "@objectstack/core": "^1.0.12"
   },
   "devDependencies": {
     "@types/node": "^25.1.0",

package/src/bin.ts

@@ -1,28 +1,75 @@
 import { createRequire } from 'module';
 import { Command } from 'commander';
+import chalk from 'chalk';
+
+// Commands
 import { compileCommand } from './commands/compile.js';
 import { devCommand } from './commands/dev.js';
 import { doctorCommand } from './commands/doctor.js';
 import { createCommand } from './commands/create.js';
 import { serveCommand } from './commands/serve.js';
+import { studioCommand } from './commands/studio.js';
 import { testCommand } from './commands/test.js';
+import { validateCommand } from './commands/validate.js';
+import { initCommand } from './commands/init.js';
+import { infoCommand } from './commands/info.js';
+import { generateCommand } from './commands/generate.js';
 
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 
+// ─── Global Error Handling ──────────────────────────────────────────
+process.on('unhandledRejection', (err: any) => {
+  console.error(chalk.red(`\n  ✗ Unhandled error: ${err?.message || err}`));
+  if (err?.stack && process.env.DEBUG) {
+    console.error(chalk.dim(err.stack));
+  }
+  process.exit(1);
+});
+
+// ─── Program Definition ─────────────────────────────────────────────
 const program = new Command();
 
 program
   .name('objectstack')
-  .description('CLI for ObjectStack Protocol - Development Tools for Microkernel Architecture')
-  .version(pkg.version);
+  .description('ObjectStack CLI — Build metadata-driven apps with the ObjectStack Protocol')
+  .version(pkg.version, '-v, --version')
+  .configureHelp({
+    sortSubcommands: false,
+  })
+  .addHelpText('before', `
+${chalk.bold.cyan('◆ ObjectStack CLI')} ${chalk.dim(`v${pkg.version}`)}
+`)
+  .addHelpText('after', `
+${chalk.bold('Workflow:')}
+  ${chalk.dim('$')} os init                      ${chalk.dim('# Create a new project')}
+  ${chalk.dim('$')} os generate object task       ${chalk.dim('# Add metadata')}
+  ${chalk.dim('$')} os validate                   ${chalk.dim('# Check configuration')}
+  ${chalk.dim('$')} os dev                        ${chalk.dim('# Start dev server')}
+  ${chalk.dim('$')} os studio                     ${chalk.dim('# Dev server + Console UI')}
+  ${chalk.dim('$')} os compile                    ${chalk.dim('# Build for production')}
 
-// Add all commands
-program.addCommand(compileCommand);
-program.addCommand(serveCommand);
+${chalk.dim('Aliases: objectstack | os')}
+${chalk.dim('Docs: https://objectstack.dev')}
+`);
+
+// ── Development ──
+program.addCommand(initCommand);
 program.addCommand(devCommand);
-program.addCommand(doctorCommand);
+program.addCommand(serveCommand);
+program.addCommand(studioCommand);
+
+// ── Build & Validate ──
+program.addCommand(compileCommand);
+program.addCommand(validateCommand);
+program.addCommand(infoCommand);
+
+// ── Scaffolding ──
+program.addCommand(generateCommand);
 program.addCommand(createCommand);
+
+// ── Quality ──
 program.addCommand(testCommand);
+program.addCommand(doctorCommand);
 
 program.parse(process.argv);

package/src/commands/compile.ts

@@ -1,75 +1,102 @@
 import { Command } from 'commander';
 import path from 'path';
 import fs from 'fs';
-import { pathToFileURL } from 'url';
 import chalk from 'chalk';
-import { bundleRequire } from 'bundle-require';
 import { ZodError } from 'zod';
 import { ObjectStackDefinitionSchema } from '@objectstack/spec';
+import { loadConfig } from '../utils/config.js';
+import {
+  printHeader,
+  printKV,
+  printSuccess,
+  printError,
+  printStep,
+  createTimer,
+  formatZodErrors,
+  collectMetadataStats,
+  printMetadataStats,
+} from '../utils/format.js';
 
 export const compileCommand = new Command('compile')
-  .description('Compile ObjectStack configuration to JSON definition')
-  .argument('[source]', 'Source configuration file', 'objectstack.config.ts')
-  .argument('[output]', 'Output JSON file', 'dist/objectstack.json')
-  .action(async (source, output) => {
-    const start = Date.now();
-    console.log(chalk.bold(`\n🔹 ObjectStack Compiler v0.1`));
-    console.log(chalk.dim(`------------------------------`));
-    console.log(`📂 Source: ${chalk.blue(source)}`);
-    
-    const absolutePath = path.resolve(process.cwd(), source);
-    if (!fs.existsSync(absolutePath)) {
-      console.error(chalk.red(`\n❌ Config file not found: ${absolutePath}`));
-      process.exit(1);
+  .description('Compile ObjectStack configuration to JSON artifact')
+  .argument('[config]', 'Source configuration file')
+  .option('-o, --output <path>', 'Output JSON file', 'dist/objectstack.json')
+  .option('--json', 'Output compile result as JSON (for CI)')
+  .action(async (configPath, options) => {
+    const timer = createTimer();
+
+    if (!options.json) {
+      printHeader('Compile');
     }
 
     try {
       // 1. Load Configuration
-      console.log(chalk.yellow(`📦 Bundling Configuration...`));
-      const { mod } = await bundleRequire({
-        filepath: absolutePath,
-      });
-
-      const config = mod.default || mod;
+      if (!options.json) printStep('Loading configuration...');
+      const { config, absolutePath, duration } = await loadConfig(configPath);
 
-      if (!config) {
-        throw new Error(`Default export not found in ${source}`);
+      if (!options.json) {
+        printKV('Config', path.relative(process.cwd(), absolutePath));
+        printKV('Load time', `${duration}ms`);
       }
 
       // 2. Validate against Protocol
-      console.log(chalk.yellow(`🔍 Validating Protocol Compliance...`));
+      if (!options.json) printStep('Validating protocol compliance...');
       const result = ObjectStackDefinitionSchema.safeParse(config);
 
       if (!result.success) {
-        console.error(chalk.red(`\n❌ Validation Failed!`));
-        
-        const error = result.error as unknown as ZodError;
-        error.issues.forEach((e: any) => {
-          console.error(chalk.red(`   - [${e.path.join('.')}] ${e.message}`));
-        });
-        
+        if (options.json) {
+          console.log(JSON.stringify({ success: false, errors: (result.error as unknown as ZodError).issues }));
+          process.exit(1);
+        }
+        console.log('');
+        printError('Validation failed');
+        formatZodErrors(result.error as unknown as ZodError);
         process.exit(1);
       }
 
       // 3. Generate Artifact
+      if (!options.json) printStep('Writing artifact...');
+      const output = options.output;
       const artifactPath = path.resolve(process.cwd(), output);
       const artifactDir = path.dirname(artifactPath);
-      
+
       if (!fs.existsSync(artifactDir)) {
         fs.mkdirSync(artifactDir, { recursive: true });
       }
-      
+
       const jsonContent = JSON.stringify(result.data, null, 2);
       fs.writeFileSync(artifactPath, jsonContent);
 
-      const size = (jsonContent.length / 1024).toFixed(2);
-      console.log(chalk.green(`\n✅ Build Success (${Date.now() - start}ms)`));
-      console.log(`📦 Artifact: ${chalk.blue(output)} (${size} KB)`);
-      console.log(chalk.magenta(`✨ Ready for Deployment`));
+      const sizeKB = (jsonContent.length / 1024).toFixed(1);
+      const stats = collectMetadataStats(config);
+
+      if (options.json) {
+        console.log(JSON.stringify({
+          success: true,
+          output: artifactPath,
+          size: jsonContent.length,
+          stats,
+          duration: timer.elapsed(),
+        }));
+        return;
+      }
+
+      // 4. Summary
+      console.log('');
+      printSuccess(`Build complete ${chalk.dim(`(${timer.display()})`)}`);
+      console.log('');
+      printMetadataStats(stats);
+      console.log('');
+      printKV('Artifact', `${output} ${chalk.dim(`(${sizeKB} KB`)})`);
+      console.log('');
 
     } catch (error: any) {
-      console.error(chalk.red(`\n❌ Compilation Error:`));
-      console.error(error.message || error);
+      if (options.json) {
+        console.log(JSON.stringify({ success: false, error: error.message }));
+        process.exit(1);
+      }
+      console.log('');
+      printError(error.message || String(error));
       process.exit(1);
     }
   });

package/src/commands/create.ts

@@ -24,12 +24,12 @@ export const templates = {
         license: 'MIT',
         dependencies: {
           '@objectstack/spec': 'workspace:*',
-          zod: '^3.22.4',
+          zod: '^4.3.6',
         },
         devDependencies: {
-          '@types/node': '^20.10.0',
-          typescript: '^5.3.0',
-          vitest: '^2.1.8',
+          '@types/node': '^22.0.0',
+          typescript: '^5.8.0',
+          vitest: '^4.0.0',
         },
       }),
       'tsconfig.json': () => ({
@@ -108,17 +108,22 @@ MIT
         dependencies: {
           '@objectstack/spec': 'workspace:*',
           '@objectstack/cli': 'workspace:*',
-          zod: '^3.22.4',
+          zod: '^4.3.6',
         },
         devDependencies: {
-          '@types/node': '^20.10.0',
+          '@types/node': '^22.0.0',
           tsx: '^4.21.0',
-          typescript: '^5.3.0',
-          vitest: '^2.1.8',
+          typescript: '^5.8.0',
+          vitest: '^4.0.0',
         },
       }),
       'objectstack.config.ts': (name: string) => `import { defineStack } from '@objectstack/spec';
 
+// Barrel imports — add more as you create new type folders
+// import * as objects from './src/objects';
+// import * as actions from './src/actions';
+// import * as apps from './src/apps';
+
 export default defineStack({
   manifest: {
     name: '${name}',
@@ -127,12 +132,11 @@ export default defineStack({
   },
   
   objects: [
-    // Define your data objects here
-    // { name: 'my_object', fields: { ... } }
+    // Object.values(objects),  // Uncomment after creating src/objects/index.ts
   ],
   
   apps: [
-    // Define your apps here
+    // Object.values(apps),     // Uncomment after creating src/apps/index.ts
   ],
 });
 `,

package/src/commands/dev.ts

@@ -1,33 +1,32 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { execSync, spawn } from 'child_process';
-import os from 'os';
 import fs from 'fs';
 import path from 'path';
+import { printHeader, printKV, printStep, printError } from '../utils/format.js';
 
 export const devCommand = new Command('dev')
-  .description('Start development mode for a package')
+  .description('Start development mode with hot-reload')
   .argument('[package]', 'Package name or filter pattern', 'all')
   .option('-w, --watch', 'Enable watch mode (default)', true)
+  .option('--ui', 'Enable Console UI at /_studio/')
   .option('-v, --verbose', 'Verbose output')
   .action(async (packageName, options) => {
-    console.log(chalk.bold(`\n🚀 ObjectStack Development Mode`));
-    console.log(chalk.dim(`-------------------------------`));
+    printHeader('Development Mode');
     
     // Check if we are running inside a package (Single Package Mode)
     // If "package" argument is 'all' (default) AND objectstack.config.ts exists in CWD
     const configPath = path.resolve(process.cwd(), 'objectstack.config.ts');
     if (packageName === 'all' && fs.existsSync(configPath)) {
-       console.log(chalk.blue(`📂 Detected package config: ${configPath}`));
-       console.log(chalk.green(`⚡ Starting Dev Server...`));
-       console.log('');
+       printKV('Config', configPath, '📂');
+       printStep('Starting dev server...');
 
        // Delegate to 'serve --dev'
        // We spawn a new process to ensure clean environment and watch capabilities (plugin-loader etc)
        // usage: objectstack serve --dev
        const binPath = process.argv[1]; // path to objectstack bin
        
-       const child = spawn(process.execPath, [binPath, 'serve', '--dev', ...(options.verbose ? ['--verbose'] : [])], {
+       const child = spawn(process.execPath, [binPath, 'serve', '--dev', ...(options.ui ? ['--ui'] : []), ...(options.verbose ? ['--verbose'] : [])], {
          stdio: 'inherit',
          env: { ...process.env, NODE_ENV: 'development' }
        });
@@ -44,17 +43,15 @@ export const devCommand = new Command('dev')
       const isWorkspaceRoot = fs.existsSync(workspaceConfigPath);
 
       if (packageName === 'all' && !isWorkspaceRoot) {
-          console.error(chalk.red(`\n❌ Configuration file (objectstack.config.ts) not found in ${cwd}`));
-          console.error(chalk.yellow(`   To start development mode, run this command in a directory with objectstack.config.ts`));
-          console.error(chalk.yellow(`   OR run from the monorepo root to start all packages.`));
+          printError(`Config file not found in ${cwd}`);
+          console.error(chalk.yellow('  Run in a directory with objectstack.config.ts, or from the monorepo root.'));
           process.exit(1);
       }
 
       const filter = packageName === 'all' ? '' : `--filter ${packageName}`;
       
-      console.log(`📦 Package: ${chalk.blue(packageName === 'all' ? 'All packages' : packageName)}`);
-      console.log(`🔄 Watch mode: ${chalk.green('enabled')}`);
-      console.log('');
+      printKV('Package', packageName === 'all' ? 'All packages' : packageName, '📦');
+      printKV('Watch', 'enabled', '🔄');
       
       // Start dev mode
       const command = `pnpm ${filter} dev`.trim();
@@ -67,8 +64,7 @@ export const devCommand = new Command('dev')
       });
       
     } catch (error: any) {
-      console.error(chalk.red(`\n❌ Development mode failed:`));
-      console.error(error.message || error);
+      printError(`Development mode failed: ${error.message || error}`);
       process.exit(1);
     }
   });

package/src/commands/doctor.ts

@@ -3,6 +3,7 @@ import chalk from 'chalk';
 import { execSync } from 'child_process';
 import fs from 'fs';
 import path from 'path';
+import { printHeader, printSuccess, printWarning, printError } from '../utils/format.js';
 
 interface HealthCheckResult {
   name: string;
@@ -15,9 +16,7 @@ export const doctorCommand = new Command('doctor')
   .description('Check development environment health')
   .option('-v, --verbose', 'Show detailed information')
   .action(async (options) => {
-    console.log(chalk.bold(`\n🏥 ObjectStack Environment Health Check`));
-    console.log(chalk.dim(`-----------------------------------------`));
-    console.log('');
+    printHeader('Environment Health Check');
     
     const results: HealthCheckResult[] = [];
     
@@ -141,14 +140,19 @@ export const doctorCommand = new Command('doctor')
     let hasErrors = false;
     let hasWarnings = false;
     
+    console.log('');
     results.forEach((result) => {
-      const icon = result.status === 'ok' ? '✓' : result.status === 'warning' ? '⚠' : '✗';
-      const color = result.status === 'ok' ? chalk.green : result.status === 'warning' ? chalk.yellow : chalk.red;
-      
-      console.log(color(`${icon} ${result.name.padEnd(20)} ${result.message}`));
+      const padded = result.name.padEnd(20);
+      if (result.status === 'ok') {
+        printSuccess(`${padded} ${result.message}`);
+      } else if (result.status === 'warning') {
+        printWarning(`${padded} ${result.message}`);
+      } else {
+        printError(`${padded} ${result.message}`);
+      }
       
-      if (result.fix && options.verbose) {
-        console.log(chalk.dim(`  → ${result.fix}`));
+      if (result.fix && (options.verbose || result.status === 'error')) {
+        console.log(chalk.dim(`      → ${result.fix}`));
       }
       
       if (result.status === 'error') hasErrors = true;