@objectstack/cli 0.7.1 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @objectstack/cli
 
+## 1.0.0
+
+### Minor Changes
+
+- # Upgrade to Zod v4 and Protocol Improvements
+
+  This release includes a major upgrade to the core validation engine (Zod v4) and aligns all protocol definitions with stricter type safety.
+
+### Patch Changes
+
+- Updated dependencies
+  - @objectstack/spec@1.0.0
+  - @objectstack/core@1.0.0
+  - @objectstack/plugin-hono-server@1.0.0
+
+## 0.7.2
+
+### Patch Changes
+
+- fb41cc0: Patch release: Updated documentation and JSON schemas
+- Updated dependencies [fb41cc0]
+  - @objectstack/spec@0.7.2
+  - @objectstack/core@0.7.2
+  - @objectstack/plugin-hono-server@0.7.2
+
 ## 0.7.1
 
 ### Patch Changes

package/dist/bin.js

@@ -1,11 +1,505 @@
 #!/usr/bin/env node
 import {
   compileCommand
-} from "./chunk-RQRAZ23Z.js";
+} from "./chunk-2YXVEYO7.js";
 
 // src/bin.ts
+import { Command as Command5 } from "commander";
+
+// src/commands/dev.ts
 import { Command } from "commander";
-var program = new Command();
-program.name("objectstack").description("CLI for ObjectStack Protocol").version("0.1.0");
+import chalk from "chalk";
+import { execSync } from "child_process";
+var devCommand = new Command("dev").description("Start development mode for a package").argument("[package]", "Package name (without @objectstack/ prefix)", "all").option("-w, --watch", "Enable watch mode (default)", true).option("-v, --verbose", "Verbose output").action(async (packageName, options) => {
+  console.log(chalk.bold(`
+\u{1F680} ObjectStack Development Mode`));
+  console.log(chalk.dim(`-------------------------------`));
+  try {
+    const cwd = process.cwd();
+    const filter = packageName === "all" ? "" : `--filter @objectstack/${packageName}`;
+    console.log(`\u{1F4E6} Package: ${chalk.blue(packageName === "all" ? "All packages" : `@objectstack/${packageName}`)}`);
+    console.log(`\u{1F504} Watch mode: ${chalk.green("enabled")}`);
+    console.log("");
+    const command = `pnpm ${filter} dev`.trim();
+    console.log(chalk.dim(`$ ${command}`));
+    console.log("");
+    execSync(command, {
+      stdio: "inherit",
+      cwd
+    });
+  } catch (error) {
+    console.error(chalk.red(`
+\u274C Development mode failed:`));
+    console.error(error.message || error);
+    process.exit(1);
+  }
+});
+
+// src/commands/doctor.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+import { execSync as execSync2 } from "child_process";
+import fs from "fs";
+import path from "path";
+var doctorCommand = new Command2("doctor").description("Check development environment health").option("-v, --verbose", "Show detailed information").action(async (options) => {
+  console.log(chalk2.bold(`
+\u{1F3E5} ObjectStack Environment Health Check`));
+  console.log(chalk2.dim(`-----------------------------------------`));
+  console.log("");
+  const results = [];
+  try {
+    const nodeVersion = process.version;
+    const majorVersion = parseInt(nodeVersion.slice(1).split(".")[0]);
+    if (majorVersion >= 18) {
+      results.push({
+        name: "Node.js",
+        status: "ok",
+        message: `Version ${nodeVersion}`
+      });
+    } else {
+      results.push({
+        name: "Node.js",
+        status: "error",
+        message: `Version ${nodeVersion} (requires >= 18.0.0)`,
+        fix: "Upgrade Node.js: https://nodejs.org"
+      });
+    }
+  } catch (error) {
+    results.push({
+      name: "Node.js",
+      status: "error",
+      message: "Not found",
+      fix: "Install Node.js: https://nodejs.org"
+    });
+  }
+  try {
+    const pnpmVersion = execSync2("pnpm -v", { encoding: "utf-8" }).trim();
+    results.push({
+      name: "pnpm",
+      status: "ok",
+      message: `Version ${pnpmVersion}`
+    });
+  } catch (error) {
+    results.push({
+      name: "pnpm",
+      status: "error",
+      message: "Not found",
+      fix: "Install pnpm: npm install -g pnpm@10.28.1"
+    });
+  }
+  try {
+    const tscVersion = execSync2("tsc -v", { encoding: "utf-8" }).trim();
+    results.push({
+      name: "TypeScript",
+      status: "ok",
+      message: tscVersion
+    });
+  } catch (error) {
+    results.push({
+      name: "TypeScript",
+      status: "warning",
+      message: "Not found in PATH",
+      fix: "Installed locally via pnpm"
+    });
+  }
+  const cwd = process.cwd();
+  const nodeModulesPath = path.join(cwd, "node_modules");
+  if (fs.existsSync(nodeModulesPath)) {
+    results.push({
+      name: "Dependencies",
+      status: "ok",
+      message: "Installed"
+    });
+  } else {
+    results.push({
+      name: "Dependencies",
+      status: "error",
+      message: "Not installed",
+      fix: "Run: pnpm install"
+    });
+  }
+  const specDistPath = path.join(cwd, "packages/spec/dist");
+  if (fs.existsSync(specDistPath)) {
+    results.push({
+      name: "@objectstack/spec",
+      status: "ok",
+      message: "Built"
+    });
+  } else {
+    results.push({
+      name: "@objectstack/spec",
+      status: "warning",
+      message: "Not built",
+      fix: "Run: pnpm --filter @objectstack/spec build"
+    });
+  }
+  try {
+    const gitVersion = execSync2("git --version", { encoding: "utf-8" }).trim();
+    results.push({
+      name: "Git",
+      status: "ok",
+      message: gitVersion
+    });
+  } catch (error) {
+    results.push({
+      name: "Git",
+      status: "warning",
+      message: "Not found",
+      fix: "Install Git for version control"
+    });
+  }
+  let hasErrors = false;
+  let hasWarnings = false;
+  results.forEach((result) => {
+    const icon = result.status === "ok" ? "\u2713" : result.status === "warning" ? "\u26A0" : "\u2717";
+    const color = result.status === "ok" ? chalk2.green : result.status === "warning" ? chalk2.yellow : chalk2.red;
+    console.log(color(`${icon} ${result.name.padEnd(20)} ${result.message}`));
+    if (result.fix && options.verbose) {
+      console.log(chalk2.dim(`  \u2192 ${result.fix}`));
+    }
+    if (result.status === "error") hasErrors = true;
+    if (result.status === "warning") hasWarnings = true;
+  });
+  console.log("");
+  if (hasErrors) {
+    console.log(chalk2.red("\u274C Some critical issues found. Please fix them before continuing."));
+    results.filter((r) => r.status === "error" && r.fix).forEach((r) => console.log(chalk2.dim(`   ${r.fix}`)));
+    process.exit(1);
+  } else if (hasWarnings) {
+    console.log(chalk2.yellow("\u26A0\uFE0F  Environment is functional but has some warnings."));
+    console.log(chalk2.dim("   Run with --verbose to see fix suggestions."));
+  } else {
+    console.log(chalk2.green("\u2705 Environment is healthy and ready for development!"));
+  }
+  console.log("");
+});
+
+// src/commands/create.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import fs2 from "fs";
+import path2 from "path";
+var templates = {
+  plugin: {
+    description: "Create a new ObjectStack plugin",
+    files: {
+      "package.json": (name) => ({
+        name: `@objectstack/plugin-${name}`,
+        version: "0.1.0",
+        description: `ObjectStack Plugin: ${name}`,
+        main: "dist/index.js",
+        types: "dist/index.d.ts",
+        scripts: {
+          build: "tsc",
+          dev: "tsc --watch",
+          test: "vitest"
+        },
+        keywords: ["objectstack", "plugin", name],
+        author: "",
+        license: "MIT",
+        dependencies: {
+          "@objectstack/spec": "workspace:*",
+          zod: "^3.22.4"
+        },
+        devDependencies: {
+          "@types/node": "^20.10.0",
+          typescript: "^5.3.0",
+          vitest: "^2.1.8"
+        }
+      }),
+      "tsconfig.json": () => ({
+        extends: "../../tsconfig.json",
+        compilerOptions: {
+          outDir: "dist",
+          rootDir: "src"
+        },
+        include: ["src/**/*"]
+      }),
+      "src/index.ts": (name) => `import type { Plugin } from '@objectstack/spec';
+
+/**
+ * ${name} Plugin for ObjectStack
+ */
+export const ${toCamelCase(name)}Plugin: Plugin = {
+  name: '${name}',
+  version: '0.1.0',
+  
+  async initialize(context) {
+    console.log('Initializing ${name} plugin...');
+    // Plugin initialization logic
+  },
+  
+  async destroy() {
+    console.log('Destroying ${name} plugin...');
+    // Plugin cleanup logic
+  },
+};
+
+export default ${toCamelCase(name)}Plugin;
+`,
+      "README.md": (name) => `# @objectstack/plugin-${name}
+
+ObjectStack Plugin: ${name}
+
+## Installation
+
+\`\`\`bash
+pnpm add @objectstack/plugin-${name}
+\`\`\`
+
+## Usage
+
+\`\`\`typescript
+import { ${toCamelCase(name)}Plugin } from '@objectstack/plugin-${name}';
+
+// Use the plugin in your ObjectStack configuration
+export default {
+  plugins: [
+    ${toCamelCase(name)}Plugin,
+  ],
+};
+\`\`\`
+
+## License
+
+MIT
+`
+    }
+  },
+  example: {
+    description: "Create a new ObjectStack example application",
+    files: {
+      "package.json": (name) => ({
+        name: `@objectstack/example-${name}`,
+        version: "0.1.0",
+        private: true,
+        description: `ObjectStack Example: ${name}`,
+        scripts: {
+          build: "objectstack compile",
+          dev: "tsx watch objectstack.config.ts",
+          test: "vitest"
+        },
+        dependencies: {
+          "@objectstack/spec": "workspace:*",
+          "@objectstack/cli": "workspace:*",
+          zod: "^3.22.4"
+        },
+        devDependencies: {
+          "@types/node": "^20.10.0",
+          tsx: "^4.21.0",
+          typescript: "^5.3.0",
+          vitest: "^2.1.8"
+        }
+      }),
+      "objectstack.config.ts": (name) => `import { defineStack } from '@objectstack/spec';
+
+export default defineStack({
+  metadata: {
+    name: '${name}',
+    version: '0.1.0',
+    description: '${name} example application',
+  },
+  
+  objects: {
+    // Define your data objects here
+  },
+  
+  ui: {
+    apps: [],
+    views: [],
+  },
+});
+`,
+      "README.md": (name) => `# ${name} Example
+
+ObjectStack example application: ${name}
+
+## Quick Start
+
+\`\`\`bash
+# Build the configuration
+pnpm build
+
+# Run in development mode
+pnpm dev
+\`\`\`
+
+## Structure
+
+- \`objectstack.config.ts\` - Main configuration file
+- \`dist/objectstack.json\` - Compiled artifact
+
+## Learn More
+
+- [ObjectStack Documentation](../../content/docs)
+- [Examples](../)
+`,
+      "tsconfig.json": () => ({
+        extends: "../../tsconfig.json",
+        compilerOptions: {
+          outDir: "dist",
+          rootDir: "."
+        },
+        include: ["*.ts", "src/**/*"]
+      })
+    }
+  }
+};
+function toCamelCase(str) {
+  return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+}
+var createCommand = new Command3("create").description("Create a new package, plugin, or example from template").argument("<type>", "Type of project to create (plugin, example)").argument("[name]", "Name of the project").option("-d, --dir <directory>", "Target directory").action(async (type, name, options) => {
+  console.log(chalk3.bold(`
+\u{1F4E6} ObjectStack Project Creator`));
+  console.log(chalk3.dim(`-------------------------------`));
+  if (!templates[type]) {
+    console.error(chalk3.red(`
+\u274C Unknown type: ${type}`));
+    console.log(chalk3.dim("Available types: plugin, example"));
+    process.exit(1);
+  }
+  if (!name) {
+    console.error(chalk3.red("\n\u274C Project name is required"));
+    console.log(chalk3.dim(`Usage: objectstack create ${type} <name>`));
+    process.exit(1);
+  }
+  const template = templates[type];
+  const cwd = process.cwd();
+  let targetDir;
+  if (options?.dir) {
+    targetDir = path2.resolve(cwd, options.dir);
+  } else {
+    const baseDir = type === "plugin" ? "packages/plugins" : "examples";
+    const projectName = type === "plugin" ? `plugin-${name}` : name;
+    targetDir = path2.join(cwd, baseDir, projectName);
+  }
+  if (fs2.existsSync(targetDir)) {
+    console.error(chalk3.red(`
+\u274C Directory already exists: ${targetDir}`));
+    process.exit(1);
+  }
+  console.log(`\u{1F4C1} Creating ${type}: ${chalk3.blue(name)}`);
+  console.log(`\u{1F4C2} Location: ${chalk3.dim(targetDir)}`);
+  console.log("");
+  try {
+    fs2.mkdirSync(targetDir, { recursive: true });
+    for (const [filePath, contentFn] of Object.entries(template.files)) {
+      const fullPath = path2.join(targetDir, filePath);
+      const dir = path2.dirname(fullPath);
+      if (!fs2.existsSync(dir)) {
+        fs2.mkdirSync(dir, { recursive: true });
+      }
+      const content = contentFn(name);
+      const fileContent = typeof content === "string" ? content : JSON.stringify(content, null, 2);
+      fs2.writeFileSync(fullPath, fileContent);
+      console.log(chalk3.green(`\u2713 Created ${filePath}`));
+    }
+    console.log("");
+    console.log(chalk3.green("\u2705 Project created successfully!"));
+    console.log("");
+    console.log(chalk3.bold("Next steps:"));
+    console.log(chalk3.dim(`  cd ${path2.relative(cwd, targetDir)}`));
+    console.log(chalk3.dim("  pnpm install"));
+    console.log(chalk3.dim("  pnpm build"));
+    console.log("");
+  } catch (error) {
+    console.error(chalk3.red("\n\u274C Failed to create project:"));
+    console.error(error.message || error);
+    if (fs2.existsSync(targetDir)) {
+      fs2.rmSync(targetDir, { recursive: true });
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/serve.ts
+import { Command as Command4 } from "commander";
+import path3 from "path";
+import fs3 from "fs";
+import chalk4 from "chalk";
+import { bundleRequire } from "bundle-require";
+var serveCommand = new Command4("serve").description("Start ObjectStack server with plugins from configuration").argument("[config]", "Configuration file path", "objectstack.config.ts").option("-p, --port <port>", "Server port", "3000").option("--no-server", "Skip starting HTTP server plugin").action(async (configPath, options) => {
+  console.log(chalk4.bold(`
+\u{1F680} ObjectStack Server`));
+  console.log(chalk4.dim(`------------------------`));
+  console.log(`\u{1F4C2} Config: ${chalk4.blue(configPath)}`);
+  console.log(`\u{1F310} Port: ${chalk4.blue(options.port)}`);
+  console.log("");
+  const absolutePath = path3.resolve(process.cwd(), configPath);
+  if (!fs3.existsSync(absolutePath)) {
+    console.error(chalk4.red(`
+\u274C Configuration file not found: ${absolutePath}`));
+    process.exit(1);
+  }
+  try {
+    console.log(chalk4.yellow(`\u{1F4E6} Loading configuration...`));
+    const { mod } = await bundleRequire({
+      filepath: absolutePath
+    });
+    const config = mod.default || mod;
+    if (!config) {
+      throw new Error(`Default export not found in ${configPath}`);
+    }
+    console.log(chalk4.green(`\u2713 Configuration loaded`));
+    const { ObjectKernel } = await import("@objectstack/core");
+    console.log(chalk4.yellow(`\u{1F527} Initializing ObjectStack kernel...`));
+    const kernel = new ObjectKernel({
+      metadata: config.metadata || {},
+      objects: config.objects || {}
+    });
+    const plugins = config.plugins || [];
+    if (plugins.length > 0) {
+      console.log(chalk4.yellow(`\u{1F4E6} Loading ${plugins.length} plugin(s)...`));
+      for (const plugin of plugins) {
+        try {
+          kernel.registerPlugin(plugin);
+          const pluginName = plugin.name || plugin.constructor?.name || "unnamed";
+          console.log(chalk4.green(`  \u2713 Registered plugin: ${pluginName}`));
+        } catch (e) {
+          console.error(chalk4.red(`  \u2717 Failed to register plugin: ${e.message}`));
+        }
+      }
+    }
+    if (options.server !== false) {
+      try {
+        const { HonoServerPlugin } = await import("@objectstack/plugin-hono-server");
+        const serverPlugin = new HonoServerPlugin({ port: parseInt(options.port) });
+        kernel.registerPlugin(serverPlugin);
+        console.log(chalk4.green(`  \u2713 Registered HTTP server plugin (port: ${options.port})`));
+      } catch (e) {
+        console.warn(chalk4.yellow(`  \u26A0 HTTP server plugin not available: ${e.message}`));
+      }
+    }
+    console.log(chalk4.yellow(`
+\u{1F680} Starting ObjectStack...`));
+    await kernel.boot();
+    console.log(chalk4.green(`
+\u2705 ObjectStack server is running!`));
+    console.log(chalk4.dim(`   Press Ctrl+C to stop
+`));
+    process.on("SIGINT", async () => {
+      console.log(chalk4.yellow(`
+
+\u23F9  Stopping server...`));
+      await kernel.shutdown();
+      console.log(chalk4.green(`\u2705 Server stopped`));
+      process.exit(0);
+    });
+  } catch (error) {
+    console.error(chalk4.red(`
+\u274C Server Error:`));
+    console.error(error.message || error);
+    console.error(error.stack);
+    process.exit(1);
+  }
+});
+
+// src/bin.ts
+var program = new Command5();
+program.name("objectstack").description("CLI for ObjectStack Protocol - Development Tools for Microkernel Architecture").version("0.7.1");
 program.addCommand(compileCommand);
+program.addCommand(serveCommand);
+program.addCommand(devCommand);
+program.addCommand(doctorCommand);
+program.addCommand(createCommand);
 program.parse(process.argv);

package/dist/{chunk-RQRAZ23Z.js → chunk-2YXVEYO7.js}

@@ -33,7 +33,8 @@ var compileCommand = new Command("compile").description("Compile ObjectStack con
     if (!result.success) {
       console.error(chalk.red(`
 \u274C Validation Failed!`));
-      result.error.errors.forEach((e) => {
+      const error = result.error;
+      error.issues.forEach((e) => {
         console.error(chalk.red(`   - [${e.path.join(".")}] ${e.message}`));
       });
       process.exit(1);

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   compileCommand
-} from "./chunk-RQRAZ23Z.js";
+} from "./chunk-2YXVEYO7.js";
 export {
   compileCommand
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/cli",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "Command Line Interface for ObjectStack Protocol",
   "main": "dist/index.js",
   "bin": {
@@ -21,11 +21,13 @@
     "chalk": "^5.3.0",
     "commander": "^11.1.0",
     "tsx": "^4.7.1",
-    "zod": "^3.22.4",
-    "@objectstack/spec": "0.7.1"
+    "zod": "^4.3.6",
+    "@objectstack/spec": "0.8.0",
+    "@objectstack/core": "0.8.0",
+    "@objectstack/plugin-hono-server": "0.8.0"
   },
   "devDependencies": {
-    "@types/node": "^20.11.19",
+    "@types/node": "^25.1.0",
     "tsup": "^8.0.2",
     "typescript": "^5.3.3"
   },

package/src/bin.ts

@@ -1,13 +1,22 @@
 import { Command } from 'commander';
 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';
 
 const program = new Command();
 
 program
   .name('objectstack')
-  .description('CLI for ObjectStack Protocol')
-  .version('0.1.0');
+  .description('CLI for ObjectStack Protocol - Development Tools for Microkernel Architecture')
+  .version('0.7.1');
 
+// Add all commands
 program.addCommand(compileCommand);
+program.addCommand(serveCommand);
+program.addCommand(devCommand);
+program.addCommand(doctorCommand);
+program.addCommand(createCommand);
 
 program.parse(process.argv);

package/src/commands/compile.ts

@@ -4,6 +4,7 @@ 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';
 
 export const compileCommand = new Command('compile')
@@ -42,7 +43,8 @@ export const compileCommand = new Command('compile')
       if (!result.success) {
         console.error(chalk.red(`\n❌ Validation Failed!`));
         
-        result.error.errors.forEach(e => {
+        const error = result.error as ZodError;
+        error.issues.forEach((e: any) => {
           console.error(chalk.red(`   - [${e.path.join('.')}] ${e.message}`));
         });
         

package/src/commands/create.ts

@@ -0,0 +1,265 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+
+const templates = {
+  plugin: {
+    description: 'Create a new ObjectStack plugin',
+    files: {
+      'package.json': (name: string) => ({
+        name: `@objectstack/plugin-${name}`,
+        version: '0.1.0',
+        description: `ObjectStack Plugin: ${name}`,
+        main: 'dist/index.js',
+        types: 'dist/index.d.ts',
+        scripts: {
+          build: 'tsc',
+          dev: 'tsc --watch',
+          test: 'vitest',
+        },
+        keywords: ['objectstack', 'plugin', name],
+        author: '',
+        license: 'MIT',
+        dependencies: {
+          '@objectstack/spec': 'workspace:*',
+          zod: '^3.22.4',
+        },
+        devDependencies: {
+          '@types/node': '^20.10.0',
+          typescript: '^5.3.0',
+          vitest: '^2.1.8',
+        },
+      }),
+      'tsconfig.json': () => ({
+        extends: '../../tsconfig.json',
+        compilerOptions: {
+          outDir: 'dist',
+          rootDir: 'src',
+        },
+        include: ['src/**/*'],
+      }),
+      'src/index.ts': (name: string) => `import type { Plugin } from '@objectstack/spec';
+
+/**
+ * ${name} Plugin for ObjectStack
+ */
+export const ${toCamelCase(name)}Plugin: Plugin = {
+  name: '${name}',
+  version: '0.1.0',
+  
+  async initialize(context) {
+    console.log('Initializing ${name} plugin...');
+    // Plugin initialization logic
+  },
+  
+  async destroy() {
+    console.log('Destroying ${name} plugin...');
+    // Plugin cleanup logic
+  },
+};
+
+export default ${toCamelCase(name)}Plugin;
+`,
+      'README.md': (name: string) => `# @objectstack/plugin-${name}
+
+ObjectStack Plugin: ${name}
+
+## Installation
+
+\`\`\`bash
+pnpm add @objectstack/plugin-${name}
+\`\`\`
+
+## Usage
+
+\`\`\`typescript
+import { ${toCamelCase(name)}Plugin } from '@objectstack/plugin-${name}';
+
+// Use the plugin in your ObjectStack configuration
+export default {
+  plugins: [
+    ${toCamelCase(name)}Plugin,
+  ],
+};
+\`\`\`
+
+## License
+
+MIT
+`,
+    },
+  },
+  
+  example: {
+    description: 'Create a new ObjectStack example application',
+    files: {
+      'package.json': (name: string) => ({
+        name: `@objectstack/example-${name}`,
+        version: '0.1.0',
+        private: true,
+        description: `ObjectStack Example: ${name}`,
+        scripts: {
+          build: 'objectstack compile',
+          dev: 'tsx watch objectstack.config.ts',
+          test: 'vitest',
+        },
+        dependencies: {
+          '@objectstack/spec': 'workspace:*',
+          '@objectstack/cli': 'workspace:*',
+          zod: '^3.22.4',
+        },
+        devDependencies: {
+          '@types/node': '^20.10.0',
+          tsx: '^4.21.0',
+          typescript: '^5.3.0',
+          vitest: '^2.1.8',
+        },
+      }),
+      'objectstack.config.ts': (name: string) => `import { defineStack } from '@objectstack/spec';
+
+export default defineStack({
+  metadata: {
+    name: '${name}',
+    version: '0.1.0',
+    description: '${name} example application',
+  },
+  
+  objects: {
+    // Define your data objects here
+  },
+  
+  ui: {
+    apps: [],
+    views: [],
+  },
+});
+`,
+      'README.md': (name: string) => `# ${name} Example
+
+ObjectStack example application: ${name}
+
+## Quick Start
+
+\`\`\`bash
+# Build the configuration
+pnpm build
+
+# Run in development mode
+pnpm dev
+\`\`\`
+
+## Structure
+
+- \`objectstack.config.ts\` - Main configuration file
+- \`dist/objectstack.json\` - Compiled artifact
+
+## Learn More
+
+- [ObjectStack Documentation](../../content/docs)
+- [Examples](../)
+`,
+      'tsconfig.json': () => ({
+        extends: '../../tsconfig.json',
+        compilerOptions: {
+          outDir: 'dist',
+          rootDir: '.',
+        },
+        include: ['*.ts', 'src/**/*'],
+      }),
+    },
+  },
+};
+
+function toCamelCase(str: string): string {
+  return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+}
+
+export const createCommand = new Command('create')
+  .description('Create a new package, plugin, or example from template')
+  .argument('<type>', 'Type of project to create (plugin, example)')
+  .argument('[name]', 'Name of the project')
+  .option('-d, --dir <directory>', 'Target directory')
+  .action(async (type: string, name?: string, options?: { dir?: string }) => {
+    console.log(chalk.bold(`\n📦 ObjectStack Project Creator`));
+    console.log(chalk.dim(`-------------------------------`));
+    
+    if (!templates[type as keyof typeof templates]) {
+      console.error(chalk.red(`\n❌ Unknown type: ${type}`));
+      console.log(chalk.dim('Available types: plugin, example'));
+      process.exit(1);
+    }
+    
+    if (!name) {
+      console.error(chalk.red('\n❌ Project name is required'));
+      console.log(chalk.dim(`Usage: objectstack create ${type} <name>`));
+      process.exit(1);
+    }
+    
+    const template = templates[type as keyof typeof templates];
+    const cwd = process.cwd();
+    
+    // Determine target directory
+    let targetDir: string;
+    if (options?.dir) {
+      targetDir = path.resolve(cwd, options.dir);
+    } else {
+      const baseDir = type === 'plugin' ? 'packages/plugins' : 'examples';
+      const projectName = type === 'plugin' ? `plugin-${name}` : name;
+      targetDir = path.join(cwd, baseDir, projectName);
+    }
+    
+    // Check if directory already exists
+    if (fs.existsSync(targetDir)) {
+      console.error(chalk.red(`\n❌ Directory already exists: ${targetDir}`));
+      process.exit(1);
+    }
+    
+    console.log(`📁 Creating ${type}: ${chalk.blue(name)}`);
+    console.log(`📂 Location: ${chalk.dim(targetDir)}`);
+    console.log('');
+    
+    try {
+      // Create directory
+      fs.mkdirSync(targetDir, { recursive: true });
+      
+      // Create files from template
+      for (const [filePath, contentFn] of Object.entries(template.files)) {
+        const fullPath = path.join(targetDir, filePath);
+        const dir = path.dirname(fullPath);
+        
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+        
+        const content = contentFn(name);
+        const fileContent = typeof content === 'string' 
+          ? content 
+          : JSON.stringify(content, null, 2);
+        
+        fs.writeFileSync(fullPath, fileContent);
+        console.log(chalk.green(`✓ Created ${filePath}`));
+      }
+      
+      console.log('');
+      console.log(chalk.green('✅ Project created successfully!'));
+      console.log('');
+      console.log(chalk.bold('Next steps:'));
+      console.log(chalk.dim(`  cd ${path.relative(cwd, targetDir)}`));
+      console.log(chalk.dim('  pnpm install'));
+      console.log(chalk.dim('  pnpm build'));
+      console.log('');
+      
+    } catch (error: any) {
+      console.error(chalk.red('\n❌ Failed to create project:'));
+      console.error(error.message || error);
+      
+      // Clean up on error
+      if (fs.existsSync(targetDir)) {
+        fs.rmSync(targetDir, { recursive: true });
+      }
+      
+      process.exit(1);
+    }
+  });

package/src/commands/dev.ts

@@ -0,0 +1,40 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+
+export const devCommand = new Command('dev')
+  .description('Start development mode for a package')
+  .argument('[package]', 'Package name (without @objectstack/ prefix)', 'all')
+  .option('-w, --watch', 'Enable watch mode (default)', true)
+  .option('-v, --verbose', 'Verbose output')
+  .action(async (packageName, options) => {
+    console.log(chalk.bold(`\n🚀 ObjectStack Development Mode`));
+    console.log(chalk.dim(`-------------------------------`));
+    
+    try {
+      const cwd = process.cwd();
+      const filter = packageName === 'all' ? '' : `--filter @objectstack/${packageName}`;
+      
+      console.log(`📦 Package: ${chalk.blue(packageName === 'all' ? 'All packages' : `@objectstack/${packageName}`)}`);
+      console.log(`🔄 Watch mode: ${chalk.green('enabled')}`);
+      console.log('');
+      
+      // Start dev mode
+      const command = `pnpm ${filter} dev`.trim();
+      console.log(chalk.dim(`$ ${command}`));
+      console.log('');
+      
+      execSync(command, { 
+        stdio: 'inherit',
+        cwd 
+      });
+      
+    } catch (error: any) {
+      console.error(chalk.red(`\n❌ Development mode failed:`));
+      console.error(error.message || error);
+      process.exit(1);
+    }
+  });

package/src/commands/doctor.ts

@@ -0,0 +1,175 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+interface HealthCheckResult {
+  name: string;
+  status: 'ok' | 'warning' | 'error';
+  message: string;
+  fix?: string;
+}
+
+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('');
+    
+    const results: HealthCheckResult[] = [];
+    
+    // Check Node.js version
+    try {
+      const nodeVersion = process.version;
+      const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0]);
+      
+      if (majorVersion >= 18) {
+        results.push({
+          name: 'Node.js',
+          status: 'ok',
+          message: `Version ${nodeVersion}`,
+        });
+      } else {
+        results.push({
+          name: 'Node.js',
+          status: 'error',
+          message: `Version ${nodeVersion} (requires >= 18.0.0)`,
+          fix: 'Upgrade Node.js: https://nodejs.org',
+        });
+      }
+    } catch (error) {
+      results.push({
+        name: 'Node.js',
+        status: 'error',
+        message: 'Not found',
+        fix: 'Install Node.js: https://nodejs.org',
+      });
+    }
+    
+    // Check pnpm
+    try {
+      const pnpmVersion = execSync('pnpm -v', { encoding: 'utf-8' }).trim();
+      results.push({
+        name: 'pnpm',
+        status: 'ok',
+        message: `Version ${pnpmVersion}`,
+      });
+    } catch (error) {
+      results.push({
+        name: 'pnpm',
+        status: 'error',
+        message: 'Not found',
+        fix: 'Install pnpm: npm install -g pnpm@10.28.1',
+      });
+    }
+    
+    // Check TypeScript
+    try {
+      const tscVersion = execSync('tsc -v', { encoding: 'utf-8' }).trim();
+      results.push({
+        name: 'TypeScript',
+        status: 'ok',
+        message: tscVersion,
+      });
+    } catch (error) {
+      results.push({
+        name: 'TypeScript',
+        status: 'warning',
+        message: 'Not found in PATH',
+        fix: 'Installed locally via pnpm',
+      });
+    }
+    
+    // Check if dependencies are installed
+    const cwd = process.cwd();
+    const nodeModulesPath = path.join(cwd, 'node_modules');
+    
+    if (fs.existsSync(nodeModulesPath)) {
+      results.push({
+        name: 'Dependencies',
+        status: 'ok',
+        message: 'Installed',
+      });
+    } else {
+      results.push({
+        name: 'Dependencies',
+        status: 'error',
+        message: 'Not installed',
+        fix: 'Run: pnpm install',
+      });
+    }
+    
+    // Check if spec package is built
+    const specDistPath = path.join(cwd, 'packages/spec/dist');
+    
+    if (fs.existsSync(specDistPath)) {
+      results.push({
+        name: '@objectstack/spec',
+        status: 'ok',
+        message: 'Built',
+      });
+    } else {
+      results.push({
+        name: '@objectstack/spec',
+        status: 'warning',
+        message: 'Not built',
+        fix: 'Run: pnpm --filter @objectstack/spec build',
+      });
+    }
+    
+    // Check Git
+    try {
+      const gitVersion = execSync('git --version', { encoding: 'utf-8' }).trim();
+      results.push({
+        name: 'Git',
+        status: 'ok',
+        message: gitVersion,
+      });
+    } catch (error) {
+      results.push({
+        name: 'Git',
+        status: 'warning',
+        message: 'Not found',
+        fix: 'Install Git for version control',
+      });
+    }
+    
+    // Display results
+    let hasErrors = false;
+    let hasWarnings = false;
+    
+    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}`));
+      
+      if (result.fix && options.verbose) {
+        console.log(chalk.dim(`  → ${result.fix}`));
+      }
+      
+      if (result.status === 'error') hasErrors = true;
+      if (result.status === 'warning') hasWarnings = true;
+    });
+    
+    console.log('');
+    
+    // Summary
+    if (hasErrors) {
+      console.log(chalk.red('❌ Some critical issues found. Please fix them before continuing.'));
+      results
+        .filter(r => r.status === 'error' && r.fix)
+        .forEach(r => console.log(chalk.dim(`   ${r.fix}`)));
+      process.exit(1);
+    } else if (hasWarnings) {
+      console.log(chalk.yellow('⚠️  Environment is functional but has some warnings.'));
+      console.log(chalk.dim('   Run with --verbose to see fix suggestions.'));
+    } else {
+      console.log(chalk.green('✅ Environment is healthy and ready for development!'));
+    }
+    
+    console.log('');
+  });

package/src/commands/serve.ts

@@ -0,0 +1,101 @@
+import { Command } from 'commander';
+import path from 'path';
+import fs from 'fs';
+import chalk from 'chalk';
+import { bundleRequire } from 'bundle-require';
+
+export const serveCommand = new Command('serve')
+  .description('Start ObjectStack server with plugins from configuration')
+  .argument('[config]', 'Configuration file path', 'objectstack.config.ts')
+  .option('-p, --port <port>', 'Server port', '3000')
+  .option('--no-server', 'Skip starting HTTP server plugin')
+  .action(async (configPath, options) => {
+    console.log(chalk.bold(`\n🚀 ObjectStack Server`));
+    console.log(chalk.dim(`------------------------`));
+    console.log(`📂 Config: ${chalk.blue(configPath)}`);
+    console.log(`🌐 Port: ${chalk.blue(options.port)}`);
+    console.log('');
+
+    const absolutePath = path.resolve(process.cwd(), configPath);
+    
+    if (!fs.existsSync(absolutePath)) {
+      console.error(chalk.red(`\n❌ Configuration file not found: ${absolutePath}`));
+      process.exit(1);
+    }
+
+    try {
+      // Load configuration
+      console.log(chalk.yellow(`📦 Loading configuration...`));
+      const { mod } = await bundleRequire({
+        filepath: absolutePath,
+      });
+
+      const config = mod.default || mod;
+
+      if (!config) {
+        throw new Error(`Default export not found in ${configPath}`);
+      }
+
+      console.log(chalk.green(`✓ Configuration loaded`));
+
+      // Import ObjectStack runtime
+      const { ObjectKernel } = await import('@objectstack/core');
+      
+      // Create kernel instance
+      console.log(chalk.yellow(`🔧 Initializing ObjectStack kernel...`));
+      const kernel = new ObjectKernel({
+        metadata: config.metadata || {},
+        objects: config.objects || {},
+      });
+
+      // Load plugins from configuration
+      const plugins = config.plugins || [];
+      
+      if (plugins.length > 0) {
+        console.log(chalk.yellow(`📦 Loading ${plugins.length} plugin(s)...`));
+        
+        for (const plugin of plugins) {
+          try {
+            kernel.registerPlugin(plugin);
+            const pluginName = plugin.name || plugin.constructor?.name || 'unnamed';
+            console.log(chalk.green(`  ✓ Registered plugin: ${pluginName}`));
+          } catch (e: any) {
+            console.error(chalk.red(`  ✗ Failed to register plugin: ${e.message}`));
+          }
+        }
+      }
+
+      // Add HTTP server plugin if not disabled
+      if (options.server !== false) {
+        try {
+          const { HonoServerPlugin } = await import('@objectstack/plugin-hono-server');
+          const serverPlugin = new HonoServerPlugin({ port: parseInt(options.port) });
+          kernel.registerPlugin(serverPlugin);
+          console.log(chalk.green(`  ✓ Registered HTTP server plugin (port: ${options.port})`));
+        } catch (e: any) {
+          console.warn(chalk.yellow(`  ⚠ HTTP server plugin not available: ${e.message}`));
+        }
+      }
+
+      // Boot the kernel
+      console.log(chalk.yellow(`\n🚀 Starting ObjectStack...`));
+      await kernel.boot();
+
+      console.log(chalk.green(`\n✅ ObjectStack server is running!`));
+      console.log(chalk.dim(`   Press Ctrl+C to stop\n`));
+
+      // Keep process alive
+      process.on('SIGINT', async () => {
+        console.log(chalk.yellow(`\n\n⏹  Stopping server...`));
+        await kernel.shutdown();
+        console.log(chalk.green(`✅ Server stopped`));
+        process.exit(0);
+      });
+
+    } catch (error: any) {
+      console.error(chalk.red(`\n❌ Server Error:`));
+      console.error(error.message || error);
+      console.error(error.stack);
+      process.exit(1);
+    }
+  });