Enhance development mode support by adding devPlugins loading and updating CLI commands for improved configuration handling

Author: hotlong

PROTOCOL-QUICK-REFERENCE.md

@@ -11,6 +11,43 @@
 
 ---
 
+## 🏗️ Project & Plugin Definition
+
+Use `objectstack.config.ts` to define your stack.
+
+```typescript
+import { defineStack } from '@objectstack/spec';
+
+export default defineStack({
+  manifest: {
+    id: 'com.example.app',
+    version: '1.0.0',
+    type: 'app',
+  },
+
+  // 1. Objects & Logic
+  objects: [ ... ],
+  flows: [ ... ],
+
+  // 2. Production Dependencies
+  plugins: [
+    '@objectstack/driver-postgres',
+  ],
+
+  // 3. Development Dependencies (like package.json devDependencies)
+  // These are ONLY loaded when running `objectstack dev`
+  devPlugins: [
+    '@objectstack/plugin-bi', // Debug integration with BI
+    {
+      manifest: { id: 'dev-db' },
+      datasources: [{ type: 'sqlite', url: 'file:dev.db' }]
+    }
+  ]
+});
+```
+
+---
+
 ## 🔌 Client SDK
 
 Access ObjectStack from your applications using the official client libraries:

packages/cli/src/commands/dev.ts

@@ -1,6 +1,6 @@
 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';
@@ -14,6 +14,28 @@ export const devCommand = new Command('dev')
     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}`;

packages/cli/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);
@@ -90,14 +91,35 @@ export const serveCommand = new Command('serve')
       });
 
       // 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];
+      }
 
       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) {