@objectstack/cli 0.8.2 → 0.9.1

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @objectstack/cli
 
+## 0.9.1
+
+### Patch Changes
+
+- Patch release for maintenance and stability improvements. All packages updated with unified versioning.
+- Updated dependencies
+  - @objectstack/spec@0.9.1
+  - @objectstack/core@0.9.1
+  - @objectstack/objectql@0.9.1
+  - @objectstack/runtime@0.9.1
+  - @objectstack/driver-memory@0.9.1
+  - @objectstack/plugin-hono-server@0.9.1
+
 ## 0.8.2
 
 ### Patch Changes

package/README.md

@@ -0,0 +1,487 @@
+# @objectstack/cli
+
+Command Line Interface for ObjectStack Protocol - Development tools for building, serving, and managing ObjectStack applications.
+
+## Features
+
+- 🚀 **Development Server** - Hot-reload development server with auto-discovery
+- 🔨 **Build & Compile** - Validate and compile ObjectStack configurations to JSON
+- 🏥 **Environment Check** - Health check for development environment
+- 📦 **Project Scaffolding** - Generate plugins and examples from templates
+- 🧪 **Test Runner** - Execute Quality Protocol test scenarios
+- ⚡ **Auto-Configuration** - Smart defaults with minimal configuration
+
+## Installation
+
+### Global Installation (Recommended)
+
+```bash
+npm install -g @objectstack/cli
+# or
+pnpm add -g @objectstack/cli
+```
+
+### Local Development
+
+```bash
+pnpm add -D @objectstack/cli
+```
+
+## Commands
+
+### `objectstack serve`
+
+Start an ObjectStack server with automatic plugin loading and configuration.
+
+```bash
+# Start server with default config (objectstack.config.ts)
+objectstack serve
+
+# Specify custom config file
+objectstack serve my-config.ts
+
+# Custom port
+objectstack serve --port 8080
+
+# Development mode (loads devPlugins)
+objectstack serve --dev
+
+# Skip HTTP server plugin
+objectstack serve --no-server
+```
+
+**Features:**
+- Auto-detects and loads `objectstack.config.ts`
+- Auto-injects ObjectQL Engine if objects are defined
+- Auto-injects Memory Driver in development mode
+- Auto-registers AppPlugin for app configurations
+- Finds available port if requested port is in use
+- Pretty logging in development mode
+- Graceful shutdown on SIGINT (Ctrl+C)
+
+**Example:**
+
+```typescript
+// objectstack.config.ts
+import { defineStack } from '@objectstack/spec';
+
+export default defineStack({
+  manifest: {
+    name: 'my-app',
+    version: '1.0.0'
+  },
+  objects: [
+    {
+      name: 'todo_task',
+      fields: {
+        subject: { type: 'text', label: 'Subject' },
+        completed: { type: 'boolean', default: false }
+      }
+    }
+  ]
+});
+```
+
+```bash
+$ objectstack serve --dev
+
+🚀 ObjectStack Server
+------------------------
+📂 Config: objectstack.config.ts
+🌐 Port: 3000
+
+📦 Loading configuration...
+✓ Configuration loaded
+🔧 Initializing ObjectStack kernel...
+  Auto-injecting ObjectQL Engine...
+  ✓ Registered ObjectQL Plugin (auto-detected)
+  Auto-injecting Memory Driver (Dev Mode)...
+  ✓ Registered Memory Driver (auto-detected)
+  ✓ Registered App Plugin (auto-detected)
+  ✓ Registered HTTP server plugin (port: 3000)
+
+🚀 Starting ObjectStack...
+
+✅ ObjectStack server is running!
+   Press Ctrl+C to stop
+```
+
+### `objectstack dev`
+
+Start development mode with watch and hot-reload capabilities.
+
+```bash
+# Single package mode (if objectstack.config.ts exists in CWD)
+objectstack dev
+
+# Monorepo mode - run dev for all packages
+objectstack dev
+
+# Monorepo mode - filter specific package
+objectstack dev @objectstack/core
+```
+
+**Behavior:**
+- **Single Package Mode**: If `objectstack.config.ts` exists in current directory, delegates to `objectstack serve --dev` to start a development server with hot reload
+- **Monorepo Mode**: If `pnpm-workspace.yaml` exists in current directory (workspace root), executes `pnpm dev` with optional package filter to run development builds across multiple packages in the workspace. The command uses pnpm's workspace filtering to target specific packages or all packages.
+
+### `objectstack compile`
+
+Compile and validate ObjectStack configuration files.
+
+```bash
+# Compile default config
+objectstack compile
+
+# Custom source and output
+objectstack compile src/config.ts build/app.json
+```
+
+**Features:**
+- Bundles TypeScript configuration files
+- Validates against ObjectStack Protocol using Zod schemas
+- Outputs optimized JSON artifact
+- Shows validation errors with exact field paths
+- Build time and artifact size reporting
+
+**Example:**
+
+```bash
+$ objectstack compile
+
+🔹 ObjectStack Compiler v0.1
+------------------------------
+📂 Source: objectstack.config.ts
+📦 Bundling Configuration...
+🔍 Validating Protocol Compliance...
+
+✅ Build Success (234ms)
+📦 Artifact: dist/objectstack.json (12.45 KB)
+✨ Ready for Deployment
+```
+
+### `objectstack doctor`
+
+Check development environment health and dependencies.
+
+```bash
+# Quick health check
+objectstack doctor
+
+# Detailed information with fix suggestions
+objectstack doctor --verbose
+```
+
+**Checks:**
+- ✓ Node.js version (>= 18.0.0 required)
+- ✓ pnpm package manager
+- ✓ TypeScript compiler
+- ✓ Dependencies installation status
+- ✓ @objectstack/spec build status
+- ✓ Git installation
+
+**Example Output:**
+
+```bash
+$ objectstack doctor
+
+🏥 ObjectStack Environment Health Check
+-----------------------------------------
+
+✓ Node.js             Version v20.10.0
+✓ pnpm                Version 10.28.1
+✓ TypeScript          Version 5.3.3
+✓ Dependencies        Installed
+✓ @objectstack/spec   Built
+✓ Git                 git version 2.39.0
+
+✅ Environment is healthy and ready for development!
+```
+
+### `objectstack create`
+
+Create new plugins or examples from templates.
+
+```bash
+# Create a plugin
+objectstack create plugin my-feature
+
+# Create an example
+objectstack create example todo-app
+
+# Custom directory
+objectstack create plugin auth --dir custom/path
+```
+
+**Templates:**
+
+#### Plugin Template
+Creates a fully-configured ObjectStack plugin with:
+- `package.json` with dependencies
+- TypeScript configuration
+- Plugin implementation boilerplate
+- README with usage examples
+- Test setup with Vitest
+
+#### Example Template
+Creates an ObjectStack example application with:
+- `objectstack.config.ts` configuration
+- Build and dev scripts
+- TypeScript configuration
+- Example README
+
+**Example:**
+
+```bash
+$ objectstack create plugin authentication
+
+📦 ObjectStack Project Creator
+-------------------------------
+📁 Creating plugin: authentication
+📂 Location: packages/plugins/plugin-authentication
+
+✓ Created package.json
+✓ Created tsconfig.json
+✓ Created src/index.ts
+✓ Created README.md
+
+✅ Project created successfully!
+
+Next steps:
+  cd packages/plugins/plugin-authentication
+  pnpm install
+  pnpm build
+```
+
+### `objectstack test:run`
+
+Run Quality Protocol test scenarios against your ObjectStack server.
+
+```bash
+# Run all tests in qa/ directory
+objectstack test:run
+
+# Specific test file or pattern
+objectstack test:run qa/api-tests.json
+
+# Custom target URL
+objectstack test:run --url http://staging.example.com
+
+# With authentication
+objectstack test:run --token "Bearer xyz..."
+```
+
+**Features:**
+- Executes test scenarios from JSON files
+- HTTP-based test adapter
+- Detailed step-by-step output
+- Pass/fail reporting with timing
+- Authentication support
+
+## Configuration File
+
+The CLI expects an `objectstack.config.ts` file in your project root:
+
+```typescript
+import { defineStack } from '@objectstack/spec';
+import type { ObjectStackDefinition } from '@objectstack/spec';
+
+export default defineStack({
+  // App metadata
+  manifest: {
+    name: 'my-app',
+    version: '1.0.0',
+    description: 'My ObjectStack Application'
+  },
+
+  // Data objects
+  objects: [
+    {
+      name: 'customer',
+      label: 'Customer',
+      fields: {
+        name: { type: 'text', label: 'Name', required: true },
+        email: { type: 'email', label: 'Email' },
+        phone: { type: 'phone', label: 'Phone' }
+      }
+    }
+  ],
+
+  // UI applications
+  apps: [
+    {
+      id: 'crm',
+      name: 'CRM',
+      objects: ['customer', 'opportunity']
+    }
+  ],
+
+  // Runtime plugins
+  plugins: [
+    // Your production plugins
+  ],
+
+  // Development-only plugins
+  devPlugins: [
+    // Loaded only with --dev flag
+  ]
+});
+```
+
+## Usage in Monorepo
+
+The CLI is monorepo-aware and works seamlessly in pnpm workspaces:
+
+```bash
+# From workspace root
+pnpm --filter @objectstack/spec build
+pnpm --filter my-app dev
+
+# Or use the CLI shorthand
+objectstack dev @objectstack/spec
+```
+
+## Environment Variables
+
+```bash
+# Server port (overridden by --port flag)
+PORT=3000
+
+# Node environment
+NODE_ENV=development|production
+```
+
+## Aliases
+
+The CLI binary is available as both `objectstack` and `os`:
+
+```bash
+objectstack serve
+# or
+os serve
+```
+
+## Development Workflow
+
+### New Project Setup
+
+```bash
+# 1. Create a new example
+objectstack create example my-project
+
+# 2. Navigate to project
+cd examples/my-project
+
+# 3. Install dependencies
+pnpm install
+
+# 4. Start development server
+objectstack dev
+```
+
+### Plugin Development
+
+```bash
+# 1. Create plugin
+objectstack create plugin my-feature
+
+# 2. Implement plugin logic
+# Edit packages/plugins/plugin-my-feature/src/index.ts
+
+# 3. Build and test
+cd packages/plugins/plugin-my-feature
+pnpm build
+pnpm test
+```
+
+### Production Build
+
+```bash
+# 1. Compile configuration
+objectstack compile
+
+# 2. Run production server
+NODE_ENV=production objectstack serve --port 8080
+```
+
+## Integration with Package Scripts
+
+Add CLI commands to your `package.json`:
+
+```json
+{
+  "scripts": {
+    "build": "objectstack compile",
+    "dev": "objectstack dev",
+    "serve": "objectstack serve",
+    "test": "objectstack test:run",
+    "doctor": "objectstack doctor"
+  }
+}
+```
+
+## Troubleshooting
+
+### Port Already in Use
+
+The CLI automatically finds an available port if the requested port is in use:
+
+```bash
+🌐 Port: 3001 (requested: 3000 in use)
+```
+
+### Configuration Not Found
+
+Ensure your config file exists and is properly named:
+
+```bash
+❌ Configuration file not found: /path/to/objectstack.config.ts
+```
+
+Default file name: `objectstack.config.ts`
+
+### Validation Errors
+
+The compiler will show detailed validation errors:
+
+```bash
+❌ Validation Failed!
+   - [objects.0.name] Expected snake_case, received "MyObject"
+   - [objects.0.fields.name.type] Invalid enum value. Expected 'text' | 'number' | ...
+```
+
+### Environment Issues
+
+Run the doctor command to diagnose:
+
+```bash
+objectstack doctor --verbose
+```
+
+## API Reference
+
+### Command Options
+
+All commands support `--help` for detailed usage:
+
+```bash
+objectstack --help
+objectstack serve --help
+objectstack compile --help
+```
+
+### Exit Codes
+
+- `0` - Success
+- `1` - Error (validation failed, file not found, etc.)
+
+## Related Packages
+
+- [@objectstack/spec](../spec) - Protocol definitions and schemas
+- [@objectstack/core](../core) - Microkernel runtime
+- [@objectstack/objectql](../objectql) - Data query engine
+- [@objectstack/runtime](../runtime) - Runtime utilities and plugins
+
+## License
+
+MIT

package/dist/bin.js

@@ -4,20 +4,44 @@ import {
 } from "./chunk-2YXVEYO7.js";
 
 // src/bin.ts
-import { Command as Command5 } from "commander";
+import { createRequire } from "module";
+import { Command as Command6 } from "commander";
 
 // src/commands/dev.ts
 import { Command } from "commander";
 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) => {
+import { execSync, spawn } from "child_process";
+import fs from "fs";
+import path from "path";
+var devCommand = new Command("dev").description("Start development mode for a package").argument("[package]", "Package name or filter pattern", "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(`-------------------------------`));
+  const configPath = path.resolve(process.cwd(), "objectstack.config.ts");
+  if (packageName === "all" && fs.existsSync(configPath)) {
+    console.log(chalk.blue(`\u{1F4C2} Detected package config: ${configPath}`));
+    console.log(chalk.green(`\u26A1 Starting Dev Server...`));
+    console.log("");
+    const binPath = process.argv[1];
+    const child = spawn(process.execPath, [binPath, "serve", "--dev", ...options.verbose ? ["--verbose"] : []], {
+      stdio: "inherit",
+      env: { ...process.env, NODE_ENV: "development" }
+    });
+    return;
+  }
   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}`)}`);
+    const workspaceConfigPath = path.resolve(cwd, "pnpm-workspace.yaml");
+    const isWorkspaceRoot = fs.existsSync(workspaceConfigPath);
+    if (packageName === "all" && !isWorkspaceRoot) {
+      console.error(chalk.red(`
+\u274C 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.`));
+      process.exit(1);
+    }
+    const filter = packageName === "all" ? "" : `--filter ${packageName}`;
+    console.log(`\u{1F4E6} Package: ${chalk.blue(packageName === "all" ? "All packages" : packageName)}`);
     console.log(`\u{1F504} Watch mode: ${chalk.green("enabled")}`);
     console.log("");
     const command = `pnpm ${filter} dev`.trim();
@@ -39,8 +63,8 @@ var devCommand = new Command("dev").description("Start development mode for a pa
 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";
+import fs2 from "fs";
+import path2 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`));
@@ -103,8 +127,8 @@ var doctorCommand = new Command2("doctor").description("Check development enviro
     });
   }
   const cwd = process.cwd();
-  const nodeModulesPath = path.join(cwd, "node_modules");
-  if (fs.existsSync(nodeModulesPath)) {
+  const nodeModulesPath = path2.join(cwd, "node_modules");
+  if (fs2.existsSync(nodeModulesPath)) {
     results.push({
       name: "Dependencies",
       status: "ok",
@@ -118,8 +142,8 @@ var doctorCommand = new Command2("doctor").description("Check development enviro
       fix: "Run: pnpm install"
     });
   }
-  const specDistPath = path.join(cwd, "packages/spec/dist");
-  if (fs.existsSync(specDistPath)) {
+  const specDistPath = path2.join(cwd, "packages/spec/dist");
+  if (fs2.existsSync(specDistPath)) {
     results.push({
       name: "@objectstack/spec",
       status: "ok",
@@ -177,8 +201,8 @@ var doctorCommand = new Command2("doctor").description("Check development enviro
 // src/commands/create.ts
 import { Command as Command3 } from "commander";
 import chalk3 from "chalk";
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 var templates = {
   plugin: {
     description: "Create a new ObjectStack plugin",
@@ -270,13 +294,13 @@ MIT
     description: "Create a new ObjectStack example application",
     files: {
       "package.json": (name) => ({
-        name: `@objectstack/example-${name}`,
+        name: `@example/${name}`,
         version: "0.1.0",
         private: true,
         description: `ObjectStack Example: ${name}`,
         scripts: {
           build: "objectstack compile",
-          dev: "tsx watch objectstack.config.ts",
+          dev: "objectstack dev",
           test: "vitest"
         },
         dependencies: {
@@ -294,20 +318,20 @@ MIT
       "objectstack.config.ts": (name) => `import { defineStack } from '@objectstack/spec';
 
 export default defineStack({
-  metadata: {
+  manifest: {
     name: '${name}',
     version: '0.1.0',
     description: '${name} example application',
   },
   
-  objects: {
+  objects: [
     // Define your data objects here
-  },
+    // { name: 'my_object', fields: { ... } }
+  ],
   
-  ui: {
-    apps: [],
-    views: [],
-  },
+  apps: [
+    // Define your apps here
+  ],
 });
 `,
       "README.md": (name) => `# ${name} Example
@@ -367,13 +391,13 @@ var createCommand = new Command3("create").description("Create a new package, pl
   const cwd = process.cwd();
   let targetDir;
   if (options?.dir) {
-    targetDir = path2.resolve(cwd, options.dir);
+    targetDir = path3.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);
+    targetDir = path3.join(cwd, baseDir, projectName);
   }
-  if (fs2.existsSync(targetDir)) {
+  if (fs3.existsSync(targetDir)) {
     console.error(chalk3.red(`
 \u274C Directory already exists: ${targetDir}`));
     process.exit(1);
@@ -382,31 +406,31 @@ var createCommand = new Command3("create").description("Create a new package, pl
   console.log(`\u{1F4C2} Location: ${chalk3.dim(targetDir)}`);
   console.log("");
   try {
-    fs2.mkdirSync(targetDir, { recursive: true });
+    fs3.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 fullPath = path3.join(targetDir, filePath);
+      const dir = path3.dirname(fullPath);
+      if (!fs3.existsSync(dir)) {
+        fs3.mkdirSync(dir, { recursive: true });
       }
       const content = contentFn(name);
       const fileContent = typeof content === "string" ? content : JSON.stringify(content, null, 2);
-      fs2.writeFileSync(fullPath, fileContent);
+      fs3.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(`  cd ${path3.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 });
+    if (fs3.existsSync(targetDir)) {
+      fs3.rmSync(targetDir, { recursive: true });
     }
     process.exit(1);
   }
@@ -414,8 +438,8 @@ var createCommand = new Command3("create").description("Create a new package, pl
 
 // src/commands/serve.ts
 import { Command as Command4 } from "commander";
-import path3 from "path";
-import fs3 from "fs";
+import path4 from "path";
+import fs4 from "fs";
 import net from "net";
 import chalk4 from "chalk";
 import { bundleRequire } from "bundle-require";
@@ -441,7 +465,7 @@ var getAvailablePort = async (startPort) => {
   }
   return port;
 };
-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) => {
+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("--dev", "Run in development mode (load devPlugins)").option("--no-server", "Skip starting HTTP server plugin").action(async (configPath, options) => {
   let port = parseInt(options.port);
   try {
     const availablePort = await getAvailablePort(port);
@@ -460,8 +484,8 @@ var serveCommand = new Command4("serve").description("Start ObjectStack server w
     console.log(`\u{1F310} Port: ${chalk4.blue(port)}`);
   }
   console.log("");
-  const absolutePath = path3.resolve(process.cwd(), configPath);
-  if (!fs3.existsSync(absolutePath)) {
+  const absolutePath = path4.resolve(process.cwd(), configPath);
+  if (!fs4.existsSync(absolutePath)) {
     console.error(chalk4.red(`
 \u274C Configuration file not found: ${absolutePath}`));
     process.exit(1);
@@ -478,16 +502,65 @@ var serveCommand = new Command4("serve").description("Start ObjectStack server w
     console.log(chalk4.green(`\u2713 Configuration loaded`));
     const { ObjectKernel } = await import("@objectstack/core");
     console.log(chalk4.yellow(`\u{1F527} Initializing ObjectStack kernel...`));
+    const isDev = options.dev || process.env.NODE_ENV === "development";
+    const loggerConfig = isDev ? { format: "pretty" } : void 0;
     const kernel = new ObjectKernel({
       metadata: config.metadata || {},
-      objects: config.objects || {}
+      objects: config.objects || {},
+      logger: loggerConfig
     });
-    const plugins = config.plugins || [];
+    let plugins = config.plugins || [];
+    if (options.dev && config.devPlugins) {
+      console.log(chalk4.blue(`\u{1F4E6} Loading development plugins...`));
+      plugins = [...plugins, ...config.devPlugins];
+    }
+    const hasObjectQL = plugins.some((p) => p.name?.includes("objectql") || p.constructor?.name?.includes("ObjectQL"));
+    if (config.objects && !hasObjectQL) {
+      try {
+        console.log(chalk4.dim(`  Auto-injecting ObjectQL Engine...`));
+        const { ObjectQLPlugin } = await import("@objectstack/objectql");
+        kernel.use(new ObjectQLPlugin());
+        console.log(chalk4.green(`  \u2713 Registered ObjectQL Plugin (auto-detected)`));
+      } catch (e) {
+        console.warn(chalk4.yellow(`  \u26A0 Could not auto-load ObjectQL: ${e.message}`));
+      }
+    }
+    const hasDriver = plugins.some((p) => p.name?.includes("driver") || p.constructor?.name?.includes("Driver"));
+    if (isDev && !hasDriver && config.objects) {
+      try {
+        console.log(chalk4.dim(`  Auto-injecting Memory Driver (Dev Mode)...`));
+        const { DriverPlugin } = await import("@objectstack/runtime");
+        const { InMemoryDriver } = await import("@objectstack/driver-memory");
+        kernel.use(new DriverPlugin(new InMemoryDriver()));
+        console.log(chalk4.green(`  \u2713 Registered Memory Driver (auto-detected)`));
+      } catch (e) {
+        console.log(chalk4.dim(`  \u2139 No default driver loaded: ${e.message}`));
+      }
+    }
+    if (config.objects || config.manifest || config.apps) {
+      try {
+        const { AppPlugin } = await import("@objectstack/runtime");
+        kernel.use(new AppPlugin(config));
+        console.log(chalk4.green(`  \u2713 Registered App Plugin (auto-detected)`));
+      } catch (e) {
+        console.warn(chalk4.yellow(`  \u26A0 Could not auto-load AppPlugin: ${e.message}`));
+      }
+    }
     if (plugins.length > 0) {
       console.log(chalk4.yellow(`\u{1F4E6} Loading ${plugins.length} plugin(s)...`));
       for (const plugin of plugins) {
         try {
-          kernel.use(plugin);
+          let pluginToLoad = plugin;
+          if (typeof plugin === "string") {
+            console.log(chalk4.dim(`  Trying to resolve plugin: ${plugin}`));
+            try {
+              const imported = await import(plugin);
+              pluginToLoad = imported.default || imported;
+            } catch (importError) {
+              throw new Error(`Failed to import plugin '${plugin}': ${importError.message}`);
+            }
+          }
+          kernel.use(pluginToLoad);
           const pluginName = plugin.name || plugin.constructor?.name || "unnamed";
           console.log(chalk4.green(`  \u2713 Registered plugin: ${pluginName}`));
         } catch (e) {
@@ -529,12 +602,87 @@ var serveCommand = new Command4("serve").description("Start ObjectStack server w
   }
 });
 
+// src/commands/test.ts
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+import path5 from "path";
+import fs5 from "fs";
+import { QA as CoreQA } from "@objectstack/core";
+var testCommand = new Command5("test:run").description("Run Quality Protocol test scenarios").argument("[files]", 'Glob pattern for test files (e.g. "qa/*.test.json")', "qa/*.test.json").option("--url <url>", "Target base URL", "http://localhost:3000").option("--token <token>", "Authentication token").action(async (filesPattern, options) => {
+  console.log(chalk5.bold(`
+\u{1F9EA} ObjectStack Quality Protocol Runner`));
+  console.log(chalk5.dim(`-------------------------------------`));
+  console.log(`Target: ${chalk5.blue(options.url)}`);
+  const adapter = new CoreQA.HttpTestAdapter(options.url, options.token);
+  const runner = new CoreQA.TestRunner(adapter);
+  const cwd = process.cwd();
+  const testFiles = [];
+  if (fs5.existsSync(filesPattern)) {
+    testFiles.push(filesPattern);
+  } else {
+    const dir = path5.dirname(filesPattern);
+    const ext = path5.extname(filesPattern);
+    if (fs5.existsSync(dir)) {
+      const files = fs5.readdirSync(dir).filter((f) => f.endsWith(ext) || f.endsWith(".json"));
+      files.forEach((f) => testFiles.push(path5.join(dir, f)));
+    }
+  }
+  if (testFiles.length === 0) {
+    console.warn(chalk5.yellow(`No test files found matching: ${filesPattern}`));
+    return;
+  }
+  console.log(`Found ${testFiles.length} test suites.`);
+  let totalPassed = 0;
+  let totalFailed = 0;
+  for (const file of testFiles) {
+    console.log(`
+\u{1F4C4} Running suite: ${chalk5.bold(path5.basename(file))}`);
+    try {
+      const content = fs5.readFileSync(file, "utf-8");
+      const suite = JSON.parse(content);
+      const results = await runner.runSuite(suite);
+      for (const result of results) {
+        const icon = result.passed ? "\u2705" : "\u274C";
+        console.log(`  ${icon} Scenario: ${result.scenarioId} (${result.duration}ms)`);
+        if (!result.passed) {
+          console.error(chalk5.red(`     Error: ${result.error}`));
+          result.steps.forEach((step) => {
+            if (!step.passed) {
+              console.error(chalk5.red(`     Step Failed: ${step.stepName}`));
+              if (step.output) console.error(`     Output:`, step.output);
+              if (step.error) console.error(`     Error:`, step.error);
+            }
+          });
+          totalFailed++;
+        } else {
+          totalPassed++;
+        }
+      }
+    } catch (e) {
+      console.error(chalk5.red(`Failed to load or run suite ${file}: ${e}`));
+      totalFailed++;
+    }
+  }
+  console.log(chalk5.dim(`
+-------------------------------------`));
+  if (totalFailed > 0) {
+    console.log(chalk5.red(`FAILED: ${totalFailed} scenarios failed. ${totalPassed} passed.`));
+    process.exit(1);
+  } else {
+    console.log(chalk5.green(`SUCCESS: All ${totalPassed} scenarios passed.`));
+    process.exit(0);
+  }
+});
+
 // src/bin.ts
-var program = new Command5();
-program.name("objectstack").description("CLI for ObjectStack Protocol - Development Tools for Microkernel Architecture").version("0.8.0");
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var program = new Command6();
+program.name("objectstack").description("CLI for ObjectStack Protocol - Development Tools for Microkernel Architecture").version(pkg.version);
 program.addCommand(compileCommand);
 program.addCommand(serveCommand);
 program.addCommand(devCommand);
 program.addCommand(doctorCommand);
 program.addCommand(createCommand);
+program.addCommand(testCommand);
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/cli",
-  "version": "0.8.2",
+  "version": "0.9.1",
   "description": "Command Line Interface for ObjectStack Protocol",
   "main": "dist/index.js",
   "bin": {
@@ -22,21 +22,26 @@
     "commander": "^11.1.0",
     "tsx": "^4.7.1",
     "zod": "^4.3.6",
-    "@objectstack/spec": "0.8.2",
-    "@objectstack/core": "0.8.2",
-    "@objectstack/plugin-hono-server": "0.8.2"
+    "@objectstack/core": "0.9.1",
+    "@objectstack/driver-memory": "^0.9.1",
+    "@objectstack/objectql": "^0.9.1",
+    "@objectstack/plugin-hono-server": "0.9.1",
+    "@objectstack/runtime": "^0.9.1",
+    "@objectstack/spec": "0.9.1"
   },
   "peerDependencies": {
-    "@objectstack/core": "^0.8.2"
+    "@objectstack/core": "^0.9.1"
   },
   "devDependencies": {
     "@types/node": "^25.1.0",
     "tsup": "^8.0.2",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "vitest": "^4.0.18"
   },
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",
+    "test": "vitest run",
     "lint": "eslint src"
   }
 }

package/src/bin.ts

@@ -1,16 +1,21 @@
+import { createRequire } from 'module';
 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';
+import { testCommand } from './commands/test.js';
+
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
 
 const program = new Command();
 
 program
   .name('objectstack')
   .description('CLI for ObjectStack Protocol - Development Tools for Microkernel Architecture')
-  .version('0.8.0');
+  .version(pkg.version);
 
 // Add all commands
 program.addCommand(compileCommand);
@@ -18,5 +23,6 @@ program.addCommand(serveCommand);
 program.addCommand(devCommand);
 program.addCommand(doctorCommand);
 program.addCommand(createCommand);
+program.addCommand(testCommand);
 
 program.parse(process.argv);

package/src/commands/create.ts

@@ -4,7 +4,7 @@ import fs from 'fs';
 import path from 'path';
 import { execSync } from 'child_process';
 
-const templates = {
+export const templates = {
   plugin: {
     description: 'Create a new ObjectStack plugin',
     files: {
@@ -96,13 +96,13 @@ MIT
     description: 'Create a new ObjectStack example application',
     files: {
       'package.json': (name: string) => ({
-        name: `@objectstack/example-${name}`,
+        name: `@example/${name}`,
         version: '0.1.0',
         private: true,
         description: `ObjectStack Example: ${name}`,
         scripts: {
           build: 'objectstack compile',
-          dev: 'tsx watch objectstack.config.ts',
+          dev: 'objectstack dev',
           test: 'vitest',
         },
         dependencies: {
@@ -120,20 +120,20 @@ MIT
       'objectstack.config.ts': (name: string) => `import { defineStack } from '@objectstack/spec';
 
 export default defineStack({
-  metadata: {
+  manifest: {
     name: '${name}',
     version: '0.1.0',
     description: '${name} example application',
   },
   
-  objects: {
+  objects: [
     // Define your data objects here
-  },
+    // { name: 'my_object', fields: { ... } }
+  ],
   
-  ui: {
-    apps: [],
-    views: [],
-  },
+  apps: [
+    // Define your apps here
+  ],
 });
 `,
       'README.md': (name: string) => `# ${name} Example

package/src/commands/dev.ts

@@ -1,24 +1,58 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { execSync } from 'child_process';
+import { execSync, spawn } 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')
+  .argument('[package]', 'Package name or filter pattern', '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(`-------------------------------`));
     
+    // 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('');
+
+       // 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'] : [])], {
+         stdio: 'inherit',
+         env: { ...process.env, NODE_ENV: 'development' }
+       });
+
+       return;
+    }
+
+    // Monorepo Orchestration Mode
     try {
       const cwd = process.cwd();
-      const filter = packageName === 'all' ? '' : `--filter @objectstack/${packageName}`;
       
-      console.log(`📦 Package: ${chalk.blue(packageName === 'all' ? 'All packages' : `@objectstack/${packageName}`)}`);
+      // Only attempt monorepo orchestration if we are in a workspace root
+      const workspaceConfigPath = path.resolve(cwd, 'pnpm-workspace.yaml');
+      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.`));
+          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('');
       

package/src/commands/serve.ts

@@ -34,6 +34,7 @@ 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('--dev', 'Run in development mode (load devPlugins)')
   .option('--no-server', 'Skip starting HTTP server plugin')
   .action(async (configPath, options) => {
     let port = parseInt(options.port);
@@ -84,20 +85,87 @@ export const serveCommand = new Command('serve')
       
       // Create kernel instance
       console.log(chalk.yellow(`🔧 Initializing ObjectStack kernel...`));
+      
+      // Auto-configure pretty logging in development mode
+      const isDev = options.dev || process.env.NODE_ENV === 'development';
+      const loggerConfig = isDev ? { format: 'pretty' } : undefined;
+
       const kernel = new ObjectKernel({
         metadata: config.metadata || {},
         objects: config.objects || {},
+        logger: loggerConfig
       });
 
       // Load plugins from configuration
-      const plugins = config.plugins || [];
+      let plugins = config.plugins || [];
+
+      // Merge devPlugins if in dev mode
+      if (options.dev && config.devPlugins) {
+        console.log(chalk.blue(`📦 Loading development plugins...`));
+        plugins = [...plugins, ...config.devPlugins];
+      }
+
+      // 1. Auto-register ObjectQL Plugin if objects define but plugins missing
+      const hasObjectQL = plugins.some((p: any) => p.name?.includes('objectql') || p.constructor?.name?.includes('ObjectQL'));
+      if (config.objects && !hasObjectQL) {
+         try {
+           console.log(chalk.dim(`  Auto-injecting ObjectQL Engine...`));
+           const { ObjectQLPlugin } = await import('@objectstack/objectql');
+           kernel.use(new ObjectQLPlugin());
+           console.log(chalk.green(`  ✓ Registered ObjectQL Plugin (auto-detected)`));
+         } catch (e: any) {
+           console.warn(chalk.yellow(`  ⚠ Could not auto-load ObjectQL: ${e.message}`));
+         }
+      }
+
+      // 2. Auto-register Memory Driver if in Dev and no driver configured
+      const hasDriver = plugins.some((p: any) => p.name?.includes('driver') || p.constructor?.name?.includes('Driver'));
+      if (isDev && !hasDriver && config.objects) {
+         try {
+           console.log(chalk.dim(`  Auto-injecting Memory Driver (Dev Mode)...`));
+           const { DriverPlugin } = await import('@objectstack/runtime');
+           const { InMemoryDriver } = await import('@objectstack/driver-memory');
+           kernel.use(new DriverPlugin(new InMemoryDriver()));
+           console.log(chalk.green(`  ✓ Registered Memory Driver (auto-detected)`));
+         } catch (e: any) {
+           // Silent fail - maybe they don't want a driver or don't have the package
+           console.log(chalk.dim(`  ℹ No default driver loaded: ${e.message}`));
+         }
+      }
+
+      // 3. Auto-register AppPlugin if config contains app definitions
+      if (config.objects || config.manifest || config.apps) {
+        try {
+           const { AppPlugin } = await import('@objectstack/runtime');
+           kernel.use(new AppPlugin(config));
+           console.log(chalk.green(`  ✓ Registered App Plugin (auto-detected)`));
+        } catch (e: any) {
+           console.warn(chalk.yellow(`  ⚠ Could not auto-load AppPlugin: ${e.message}`));
+        }
+      }
+
       
       if (plugins.length > 0) {
         console.log(chalk.yellow(`📦 Loading ${plugins.length} plugin(s)...`));
         
         for (const plugin of plugins) {
           try {
-            kernel.use(plugin);
+            let pluginToLoad = plugin;
+
+            // Resolve string references (package names)
+            if (typeof plugin === 'string') {
+              console.log(chalk.dim(`  Trying to resolve plugin: ${plugin}`));
+              try {
+                // Try dynamic import for packages
+                 const imported = await import(plugin);
+                 pluginToLoad = imported.default || imported;
+              } catch (importError: any) {
+                 // Fallback: try bundleRequire for local paths if needed, otherwise throw
+                 throw new Error(`Failed to import plugin '${plugin}': ${importError.message}`);
+              }
+            }
+
+            kernel.use(pluginToLoad);
             const pluginName = plugin.name || plugin.constructor?.name || 'unnamed';
             console.log(chalk.green(`  ✓ Registered plugin: ${pluginName}`));
           } catch (e: any) {

package/src/commands/test.ts

@@ -0,0 +1,92 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs';
+import { QA as CoreQA } from '@objectstack/core';
+import { QA } from '@objectstack/spec';
+
+export const testCommand = new Command('test:run')
+  .description('Run Quality Protocol test scenarios')
+  .argument('[files]', 'Glob pattern for test files (e.g. "qa/*.test.json")', 'qa/*.test.json')
+  .option('--url <url>', 'Target base URL', 'http://localhost:3000')
+  .option('--token <token>', 'Authentication token')
+  .action(async (filesPattern, options) => {
+    console.log(chalk.bold(`\n🧪 ObjectStack Quality Protocol Runner`));
+    console.log(chalk.dim(`-------------------------------------`));
+    console.log(`Target: ${chalk.blue(options.url)}`);
+    
+    // 1. Setup Runner
+    const adapter = new CoreQA.HttpTestAdapter(options.url, options.token);
+    const runner = new CoreQA.TestRunner(adapter);
+
+    // 2. Find Files (Simple implementation for now)
+    // TODO: Use glob
+    const cwd = process.cwd();
+    const testFiles: string[] = [];
+    
+    // Very basic file finding for demo - assume explicit path or check local dir
+    if (fs.existsSync(filesPattern)) {
+        testFiles.push(filesPattern);
+    } else {
+        // Simple directory scan
+        const dir = path.dirname(filesPattern);
+        const ext = path.extname(filesPattern);
+        if (fs.existsSync(dir)) {
+            const files = fs.readdirSync(dir).filter(f => f.endsWith(ext) || f.endsWith('.json'));
+            files.forEach(f => testFiles.push(path.join(dir, f)));
+        }
+    }
+
+    if (testFiles.length === 0) {
+        console.warn(chalk.yellow(`No test files found matching: ${filesPattern}`));
+        // Create a demo test file if none exist?
+        return;
+    }
+
+    console.log(`Found ${testFiles.length} test suites.`);
+
+    // 3. Run Tests
+    let totalPassed = 0;
+    let totalFailed = 0;
+
+    for (const file of testFiles) {
+        console.log(`\n📄 Running suite: ${chalk.bold(path.basename(file))}`);
+        try {
+            const content = fs.readFileSync(file, 'utf-8');
+            const suite = JSON.parse(content) as QA.TestSuite; // Should validate with Zod
+            
+            const results = await runner.runSuite(suite);
+            
+            for (const result of results) {
+                const icon = result.passed ? '✅' : '❌';
+                console.log(`  ${icon} Scenario: ${result.scenarioId} (${result.duration}ms)`);
+                if (!result.passed) {
+                   console.error(chalk.red(`     Error: ${result.error}`));
+                   result.steps.forEach(step => {
+                       if (!step.passed) {
+                           console.error(chalk.red(`     Step Failed: ${step.stepName}`));
+                           if (step.output) console.error(`     Output:`, step.output);
+                           if (step.error) console.error(`     Error:`, step.error);
+                       }
+                   });
+                   totalFailed++;
+                } else {
+                    totalPassed++;
+                }
+            }
+        } catch (e) {
+            console.error(chalk.red(`Failed to load or run suite ${file}: ${e}`));
+            totalFailed++; // Count suite failure
+        }
+    }
+
+    // 4. Summary
+    console.log(chalk.dim(`\n-------------------------------------`));
+    if (totalFailed > 0) {
+        console.log(chalk.red(`FAILED: ${totalFailed} scenarios failed. ${totalPassed} passed.`));
+        process.exit(1);
+    } else {
+        console.log(chalk.green(`SUCCESS: All ${totalPassed} scenarios passed.`));
+        process.exit(0);
+    }
+  });

package/test/commands.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from 'vitest';
+import { compileCommand } from '../src/commands/compile';
+import { serveCommand } from '../src/commands/serve';
+import { devCommand } from '../src/commands/dev';
+import { doctorCommand } from '../src/commands/doctor';
+import { createCommand } from '../src/commands/create';
+import { testCommand } from '../src/commands/test';
+
+describe('CLI Commands', () => {
+  it('should have compile command', () => {
+    expect(compileCommand.name()).toBe('compile');
+    expect(compileCommand.description()).toContain('Compile');
+  });
+
+  it('should have serve command', () => {
+    expect(serveCommand.name()).toBe('serve');
+    expect(serveCommand.description()).toContain('server');
+  });
+
+  it('should have dev command', () => {
+    expect(devCommand.name()).toBe('dev');
+    expect(devCommand.description()).toContain('development mode');
+  });
+
+  it('should have doctor command', () => {
+    expect(doctorCommand.name()).toBe('doctor');
+    expect(doctorCommand.description()).toContain('health');
+  });
+
+  it('should have create command', () => {
+    expect(createCommand.name()).toBe('create');
+    expect(createCommand.description()).toContain('Create');
+  });
+
+  it('should have test command', () => {
+    expect(testCommand.name()).toBe('test:run');
+    expect(testCommand.description()).toContain('Quality Protocol');
+  });
+});

package/test/create.test.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect } from 'vitest';
+import { templates } from '../src/commands/create';
+
+describe('Create Command Templates', () => {
+  describe('Example Template', () => {
+    it('should generate correct package.json scripts', () => {
+      const packageJsonFn = templates.example.files['package.json'];
+      const packageJson = packageJsonFn('test-app');
+      
+      expect(packageJson.scripts.dev).toBe('objectstack dev');
+      expect(packageJson.scripts.build).toBe('objectstack compile');
+      expect(packageJson.dependencies['@objectstack/cli']).toBe('workspace:*');
+    });
+  });
+
+  describe('Plugin Template', () => {
+    it('should generate correct dependencies', () => {
+        const packageJsonFn = templates.plugin.files['package.json'];
+        const packageJson = packageJsonFn('test-plugin');
+        
+        expect(packageJson.dependencies).toHaveProperty('@objectstack/spec');
+        expect(packageJson.keywords).toContain('test-plugin');
+    });
+  });
+});