@objectstack/cli 2.0.7 → 3.0.1

package/dist/index.js

@@ -1,237 +1,27 @@
+import {
+  collectMetadataStats,
+  configExists,
+  createTimer,
+  formatZodErrors,
+  loadConfig,
+  printError,
+  printHeader,
+  printInfo,
+  printKV,
+  printMetadataStats,
+  printServerReady,
+  printStep,
+  printSuccess,
+  printWarning,
+  resolveConfigPath
+} from "./chunk-CSHQEILI.js";
+
 // src/commands/compile.ts
 import { Command } from "commander";
-import path2 from "path";
-import fs2 from "fs";
-import chalk3 from "chalk";
-import { ObjectStackDefinitionSchema } from "@objectstack/spec";
-
-// src/utils/config.ts
 import path from "path";
 import fs from "fs";
-import chalk2 from "chalk";
-import { bundleRequire } from "bundle-require";
-
-// src/utils/format.ts
 import chalk from "chalk";
-function printHeader(title) {
-  console.log(chalk.bold(`
-\u25C6 ${title}`));
-  console.log(chalk.dim("\u2500".repeat(40)));
-}
-function printKV(key, value, icon) {
-  const prefix = icon ? `${icon} ` : "  ";
-  console.log(`${prefix}${chalk.dim(key + ":")} ${chalk.white(String(value))}`);
-}
-function printSuccess(msg) {
-  console.log(chalk.green(`  \u2713 ${msg}`));
-}
-function printWarning(msg) {
-  console.log(chalk.yellow(`  \u26A0 ${msg}`));
-}
-function printError(msg) {
-  console.log(chalk.red(`  \u2717 ${msg}`));
-}
-function printInfo(msg) {
-  console.log(chalk.blue(`  \u2139 ${msg}`));
-}
-function printStep(msg) {
-  console.log(chalk.yellow(`  \u2192 ${msg}`));
-}
-function createTimer() {
-  const start = Date.now();
-  return {
-    elapsed: () => Date.now() - start,
-    display: () => `${Date.now() - start}ms`
-  };
-}
-function formatZodErrors(error) {
-  const issues = error.issues || error.errors || [];
-  if (issues.length === 0) {
-    console.log(chalk.red("  Unknown validation error"));
-    return;
-  }
-  const grouped = /* @__PURE__ */ new Map();
-  for (const issue of issues) {
-    const topPath = issue.path?.[0] || "_root";
-    if (!grouped.has(String(topPath))) {
-      grouped.set(String(topPath), []);
-    }
-    grouped.get(String(topPath)).push(issue);
-  }
-  for (const [section, sectionIssues] of grouped) {
-    console.log(chalk.bold.red(`
-  ${section}:`));
-    for (const issue of sectionIssues) {
-      const path12 = issue.path?.join(".") || "";
-      const code = issue.code || "";
-      const msg = issue.message || "";
-      console.log(chalk.red(`    \u2717 ${path12}`));
-      console.log(chalk.dim(`      ${code}: ${msg}`));
-      if (issue.expected) {
-        console.log(chalk.dim(`      expected: ${chalk.green(issue.expected)}`));
-      }
-      if (issue.received) {
-        console.log(chalk.dim(`      received: ${chalk.red(issue.received)}`));
-      }
-    }
-  }
-  console.log("");
-  console.log(chalk.dim(`  ${issues.length} validation error(s) total`));
-}
-function collectMetadataStats(config) {
-  const count = (arr) => Array.isArray(arr) ? arr.length : 0;
-  let fields = 0;
-  if (Array.isArray(config.objects)) {
-    for (const obj of config.objects) {
-      if (obj.fields && typeof obj.fields === "object") {
-        fields += Object.keys(obj.fields).length;
-      }
-    }
-  }
-  return {
-    objects: count(config.objects),
-    objectExtensions: count(config.objectExtensions),
-    fields,
-    views: count(config.views),
-    pages: count(config.pages),
-    apps: count(config.apps),
-    dashboards: count(config.dashboards),
-    reports: count(config.reports),
-    actions: count(config.actions),
-    flows: count(config.flows),
-    workflows: count(config.workflows),
-    approvals: count(config.approvals),
-    agents: count(config.agents),
-    apis: count(config.apis),
-    roles: count(config.roles),
-    permissions: count(config.permissions),
-    themes: count(config.themes),
-    datasources: count(config.datasources),
-    translations: count(config.translations),
-    plugins: count(config.plugins),
-    devPlugins: count(config.devPlugins)
-  };
-}
-function printServerReady(opts) {
-  const base = `http://localhost:${opts.port}`;
-  console.log("");
-  console.log(chalk.bold.green("  \u2713 Server is ready"));
-  console.log("");
-  console.log(chalk.cyan("  \u279C") + chalk.bold("  API:     ") + chalk.cyan(base + "/"));
-  if (opts.uiEnabled && opts.studioPath) {
-    console.log(chalk.cyan("  \u279C") + chalk.bold("  Studio:  ") + chalk.cyan(base + opts.studioPath + "/"));
-  }
-  console.log("");
-  console.log(chalk.dim(`  Config:  ${opts.configFile}`));
-  console.log(chalk.dim(`  Mode:    ${opts.isDev ? "development" : "production"}`));
-  console.log(chalk.dim(`  Plugins: ${opts.pluginCount} loaded`));
-  if (opts.pluginNames && opts.pluginNames.length > 0) {
-    console.log(chalk.dim(`           ${opts.pluginNames.join(", ")}`));
-  }
-  console.log("");
-  console.log(chalk.dim("  Press Ctrl+C to stop"));
-  console.log("");
-}
-function printMetadataStats(stats) {
-  const sections = [
-    {
-      label: "Data",
-      items: [
-        ["Objects", stats.objects],
-        ["Fields", stats.fields],
-        ["Extensions", stats.objectExtensions],
-        ["Datasources", stats.datasources]
-      ]
-    },
-    {
-      label: "UI",
-      items: [
-        ["Apps", stats.apps],
-        ["Views", stats.views],
-        ["Pages", stats.pages],
-        ["Dashboards", stats.dashboards],
-        ["Reports", stats.reports],
-        ["Actions", stats.actions],
-        ["Themes", stats.themes]
-      ]
-    },
-    {
-      label: "Logic",
-      items: [
-        ["Flows", stats.flows],
-        ["Workflows", stats.workflows],
-        ["Approvals", stats.approvals],
-        ["Agents", stats.agents],
-        ["APIs", stats.apis]
-      ]
-    },
-    {
-      label: "Security",
-      items: [
-        ["Roles", stats.roles],
-        ["Permissions", stats.permissions]
-      ]
-    }
-  ];
-  for (const section of sections) {
-    const nonZero = section.items.filter(([, v]) => v > 0);
-    if (nonZero.length === 0) continue;
-    const line = nonZero.map(([k, v]) => `${chalk.white(v)} ${chalk.dim(k)}`).join("  ");
-    console.log(`  ${chalk.bold(section.label + ":")} ${line}`);
-  }
-  if (stats.plugins > 0 || stats.devPlugins > 0) {
-    const parts = [];
-    if (stats.plugins > 0) parts.push(`${stats.plugins} plugins`);
-    if (stats.devPlugins > 0) parts.push(`${stats.devPlugins} devPlugins`);
-    console.log(`  ${chalk.bold("Runtime:")} ${chalk.dim(parts.join(", "))}`);
-  }
-}
-
-// src/utils/config.ts
-function resolveConfigPath(source) {
-  if (source) {
-    const abs = path.resolve(process.cwd(), source);
-    if (!fs.existsSync(abs)) {
-      printError(`Config file not found: ${chalk2.white(abs)}`);
-      console.log("");
-      console.log(chalk2.dim("  Hint: Run this command from a directory with objectstack.config.ts"));
-      console.log(chalk2.dim("  Or specify the path: objectstack <command> path/to/config.ts"));
-      process.exit(1);
-    }
-    return abs;
-  }
-  const candidates = [
-    "objectstack.config.ts",
-    "objectstack.config.js",
-    "objectstack.config.mjs"
-  ];
-  for (const candidate of candidates) {
-    const abs = path.resolve(process.cwd(), candidate);
-    if (fs.existsSync(abs)) return abs;
-  }
-  printError("No objectstack.config.{ts,js,mjs} found in current directory");
-  console.log("");
-  console.log(chalk2.dim("  Hint: Run `objectstack init` to create a new project"));
-  process.exit(1);
-}
-async function loadConfig(source) {
-  const absolutePath = resolveConfigPath(source);
-  const start = Date.now();
-  const { mod } = await bundleRequire({
-    filepath: absolutePath
-  });
-  const config = mod.default || mod;
-  if (!config) {
-    throw new Error(`No default export found in ${path.basename(absolutePath)}`);
-  }
-  return {
-    config,
-    absolutePath,
-    duration: Date.now() - start
-  };
-}
-
-// src/commands/compile.ts
+import { ObjectStackDefinitionSchema } from "@objectstack/spec";
 var compileCommand = new Command("compile").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) {
@@ -241,7 +31,7 @@ var compileCommand = new Command("compile").description("Compile ObjectStack con
     if (!options.json) printStep("Loading configuration...");
     const { config, absolutePath, duration } = await loadConfig(configPath);
     if (!options.json) {
-      printKV("Config", path2.relative(process.cwd(), absolutePath));
+      printKV("Config", path.relative(process.cwd(), absolutePath));
       printKV("Load time", `${duration}ms`);
     }
     if (!options.json) printStep("Validating protocol compliance...");
@@ -258,13 +48,13 @@ var compileCommand = new Command("compile").description("Compile ObjectStack con
     }
     if (!options.json) printStep("Writing artifact...");
     const output = options.output;
-    const artifactPath = path2.resolve(process.cwd(), output);
-    const artifactDir = path2.dirname(artifactPath);
-    if (!fs2.existsSync(artifactDir)) {
-      fs2.mkdirSync(artifactDir, { recursive: true });
+    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);
-    fs2.writeFileSync(artifactPath, jsonContent);
+    fs.writeFileSync(artifactPath, jsonContent);
     const sizeKB = (jsonContent.length / 1024).toFixed(1);
     const stats = collectMetadataStats(config);
     if (options.json) {
@@ -278,11 +68,11 @@ var compileCommand = new Command("compile").description("Compile ObjectStack con
       return;
     }
     console.log("");
-    printSuccess(`Build complete ${chalk3.dim(`(${timer.display()})`)}`);
+    printSuccess(`Build complete ${chalk.dim(`(${timer.display()})`)}`);
     console.log("");
     printMetadataStats(stats);
     console.log("");
-    printKV("Artifact", `${output} ${chalk3.dim(`(${sizeKB} KB`)})`);
+    printKV("Artifact", `${output} ${chalk.dim(`(${sizeKB} KB`)})`);
     console.log("");
   } catch (error) {
     if (options.json) {
@@ -297,7 +87,7 @@ var compileCommand = new Command("compile").description("Compile ObjectStack con
 
 // src/commands/validate.ts
 import { Command as Command2 } from "commander";
-import chalk4 from "chalk";
+import chalk2 from "chalk";
 import { ObjectStackDefinitionSchema as ObjectStackDefinitionSchema2 } from "@objectstack/spec";
 var validateCommand = new Command2("validate").description("Validate ObjectStack configuration against the protocol schema").argument("[config]", "Configuration file path").option("--strict", "Treat warnings as errors").option("--json", "Output results as JSON").action(async (configPath, options) => {
   const timer = createTimer();
@@ -351,12 +141,12 @@ var validateCommand = new Command2("validate").description("Validate ObjectStack
       warnings.push("Missing manifest.namespace \u2014 required for multi-app hosting");
     }
     console.log("");
-    printSuccess(`Validation passed ${chalk4.dim(`(${timer.display()})`)}`);
+    printSuccess(`Validation passed ${chalk2.dim(`(${timer.display()})`)}`);
     console.log("");
     if (config.manifest) {
-      console.log(`  ${chalk4.bold(config.manifest.name || config.manifest.id || "Unnamed")} ${chalk4.dim(`v${config.manifest.version || "0.0.0"}`)}`);
+      console.log(`  ${chalk2.bold(config.manifest.name || config.manifest.id || "Unnamed")} ${chalk2.dim(`v${config.manifest.version || "0.0.0"}`)}`);
       if (config.manifest.description) {
-        console.log(chalk4.dim(`  ${config.manifest.description}`));
+        console.log(chalk2.dim(`  ${config.manifest.description}`));
       }
       console.log("");
     }
@@ -364,7 +154,7 @@ var validateCommand = new Command2("validate").description("Validate ObjectStack
     if (warnings.length > 0) {
       console.log("");
       for (const w of warnings) {
-        console.log(chalk4.yellow(`  \u26A0 ${w}`));
+        console.log(chalk2.yellow(`  \u26A0 ${w}`));
       }
       if (options.strict) {
         console.log("");
@@ -390,7 +180,7 @@ var validateCommand = new Command2("validate").description("Validate ObjectStack
 
 // src/commands/info.ts
 import { Command as Command3 } from "commander";
-import chalk5 from "chalk";
+import chalk3 from "chalk";
 var infoCommand = new Command3("info").description("Display metadata summary of an ObjectStack configuration").argument("[config]", "Configuration file path").option("--json", "Output as JSON").action(async (configPath, options) => {
   const timer = createTimer();
   if (!options.json) {
@@ -416,9 +206,9 @@ var infoCommand = new Command3("info").description("Display metadata summary of
     if (config.manifest) {
       const m = config.manifest;
       console.log("");
-      console.log(`  ${chalk5.bold(m.name || m.id || "Unnamed")} ${chalk5.dim(`v${m.version || "0.0.0"}`)}`);
-      if (m.id) console.log(chalk5.dim(`  ${m.id}`));
-      if (m.description) console.log(chalk5.dim(`  ${m.description}`));
+      console.log(`  ${chalk3.bold(m.name || m.id || "Unnamed")} ${chalk3.dim(`v${m.version || "0.0.0"}`)}`);
+      if (m.id) console.log(chalk3.dim(`  ${m.id}`));
+      if (m.description) console.log(chalk3.dim(`  ${m.description}`));
       if (m.namespace) printKV("  Namespace", m.namespace);
       if (m.type) printKV("  Type", m.type);
     }
@@ -426,35 +216,35 @@ var infoCommand = new Command3("info").description("Display metadata summary of
     printMetadataStats(stats);
     if (config.objects && config.objects.length > 0) {
       console.log("");
-      console.log(chalk5.bold("  Objects:"));
+      console.log(chalk3.bold("  Objects:"));
       for (const obj of config.objects) {
         const fieldCount = obj.fields ? Object.keys(obj.fields).length : 0;
         const ownership = obj.ownership || "own";
         console.log(
-          `    ${chalk5.cyan(obj.name || "?")}` + chalk5.dim(` (${fieldCount} fields, ${ownership})`) + (obj.label ? chalk5.dim(` \u2014 ${obj.label}`) : "")
+          `    ${chalk3.cyan(obj.name || "?")}` + chalk3.dim(` (${fieldCount} fields, ${ownership})`) + (obj.label ? chalk3.dim(` \u2014 ${obj.label}`) : "")
         );
       }
     }
     if (config.agents && config.agents.length > 0) {
       console.log("");
-      console.log(chalk5.bold("  Agents:"));
+      console.log(chalk3.bold("  Agents:"));
       for (const agent of config.agents) {
         console.log(
-          `    ${chalk5.magenta(agent.name || "?")}` + (agent.role ? chalk5.dim(` \u2014 ${agent.role}`) : "")
+          `    ${chalk3.magenta(agent.name || "?")}` + (agent.role ? chalk3.dim(` \u2014 ${agent.role}`) : "")
         );
       }
     }
     if (config.apps && config.apps.length > 0) {
       console.log("");
-      console.log(chalk5.bold("  Apps:"));
+      console.log(chalk3.bold("  Apps:"));
       for (const app of config.apps) {
         console.log(
-          `    ${chalk5.green(app.name || "?")}` + (app.label ? chalk5.dim(` \u2014 ${app.label}`) : "")
+          `    ${chalk3.green(app.name || "?")}` + (app.label ? chalk3.dim(` \u2014 ${app.label}`) : "")
         );
       }
     }
     console.log("");
-    console.log(chalk5.dim(`  Loaded in ${duration}ms`));
+    console.log(chalk3.dim(`  Loaded in ${duration}ms`));
     console.log("");
   } catch (error) {
     if (options.json) {
@@ -469,9 +259,9 @@ var infoCommand = new Command3("info").description("Display metadata summary of
 
 // src/commands/init.ts
 import { Command as Command4 } from "commander";
-import chalk6 from "chalk";
-import fs3 from "fs";
-import path3 from "path";
+import chalk4 from "chalk";
+import fs2 from "fs";
+import path2 from "path";
 var TEMPLATES = {
   app: {
     description: "Full application with objects, views, and actions",
@@ -636,16 +426,16 @@ function toTitleCase(str) {
 var initCommand = new Command4("init").description("Initialize a new ObjectStack project in the current directory").argument("[name]", "Project name (defaults to directory name)").option("-t, --template <template>", "Template: app, plugin, empty", "app").option("--no-install", "Skip dependency installation").action(async (name, options) => {
   printHeader("Init");
   const cwd = process.cwd();
-  const projectName = name || path3.basename(cwd);
+  const projectName = name || path2.basename(cwd);
   const template = TEMPLATES[options.template];
   if (!template) {
     printError(`Unknown template: ${options.template}`);
-    console.log(chalk6.dim(`  Available: ${Object.keys(TEMPLATES).join(", ")}`));
+    console.log(chalk4.dim(`  Available: ${Object.keys(TEMPLATES).join(", ")}`));
     process.exit(1);
   }
-  if (fs3.existsSync(path3.join(cwd, "objectstack.config.ts"))) {
+  if (fs2.existsSync(path2.join(cwd, "objectstack.config.ts"))) {
     printError("objectstack.config.ts already exists in this directory");
-    console.log(chalk6.dim("  Use `objectstack generate` to add metadata to an existing project"));
+    console.log(chalk4.dim("  Use `objectstack generate` to add metadata to an existing project"));
     process.exit(1);
   }
   printKV("Project", projectName);
@@ -654,8 +444,8 @@ var initCommand = new Command4("init").description("Initialize a new ObjectStack
   console.log("");
   const createdFiles = [];
   try {
-    const pkgPath = path3.join(cwd, "package.json");
-    if (!fs3.existsSync(pkgPath)) {
+    const pkgPath = path2.join(cwd, "package.json");
+    if (!fs2.existsSync(pkgPath)) {
       const pkg = {
         name: projectName,
         version: "0.1.0",
@@ -665,16 +455,16 @@ var initCommand = new Command4("init").description("Initialize a new ObjectStack
         dependencies: template.dependencies,
         devDependencies: template.devDependencies
       };
-      fs3.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+      fs2.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
       createdFiles.push("package.json");
     } else {
       printInfo("package.json already exists, skipping");
     }
     const configContent = template.configContent(projectName);
-    fs3.writeFileSync(path3.join(cwd, "objectstack.config.ts"), configContent);
+    fs2.writeFileSync(path2.join(cwd, "objectstack.config.ts"), configContent);
     createdFiles.push("objectstack.config.ts");
-    const tsconfigPath = path3.join(cwd, "tsconfig.json");
-    if (!fs3.existsSync(tsconfigPath)) {
+    const tsconfigPath = path2.join(cwd, "tsconfig.json");
+    if (!fs2.existsSync(tsconfigPath)) {
       const tsconfig = {
         compilerOptions: {
           target: "ES2022",
@@ -690,30 +480,30 @@ var initCommand = new Command4("init").description("Initialize a new ObjectStack
         include: ["*.ts", "src/**/*"],
         exclude: ["dist", "node_modules"]
       };
-      fs3.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
+      fs2.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
       createdFiles.push("tsconfig.json");
     }
     for (const [filePath, contentFn] of Object.entries(template.srcFiles)) {
       const resolvedPath = filePath.replace("__name__", projectName);
-      const fullPath = path3.join(cwd, resolvedPath);
-      const dir = path3.dirname(fullPath);
-      if (!fs3.existsSync(dir)) {
-        fs3.mkdirSync(dir, { recursive: true });
+      const fullPath = path2.join(cwd, resolvedPath);
+      const dir = path2.dirname(fullPath);
+      if (!fs2.existsSync(dir)) {
+        fs2.mkdirSync(dir, { recursive: true });
       }
-      fs3.writeFileSync(fullPath, contentFn(projectName));
+      fs2.writeFileSync(fullPath, contentFn(projectName));
       createdFiles.push(resolvedPath);
     }
-    const gitignorePath = path3.join(cwd, ".gitignore");
-    if (!fs3.existsSync(gitignorePath)) {
-      fs3.writeFileSync(gitignorePath, `node_modules/
+    const gitignorePath = path2.join(cwd, ".gitignore");
+    if (!fs2.existsSync(gitignorePath)) {
+      fs2.writeFileSync(gitignorePath, `node_modules/
 dist/
 *.tsbuildinfo
 `);
       createdFiles.push(".gitignore");
     }
-    console.log(chalk6.bold("  Created files:"));
+    console.log(chalk4.bold("  Created files:"));
     for (const f of createdFiles) {
-      console.log(chalk6.green(`    + ${f}`));
+      console.log(chalk4.green(`    + ${f}`));
     }
     console.log("");
     if (options.install !== false) {
@@ -727,10 +517,10 @@ dist/
     }
     printSuccess("Project initialized!");
     console.log("");
-    console.log(chalk6.bold("  Next steps:"));
-    console.log(chalk6.dim("    objectstack validate   # Check configuration"));
-    console.log(chalk6.dim("    objectstack dev        # Start development server"));
-    console.log(chalk6.dim("    objectstack generate   # Add objects, views, etc."));
+    console.log(chalk4.bold("  Next steps:"));
+    console.log(chalk4.dim("    objectstack validate   # Check configuration"));
+    console.log(chalk4.dim("    objectstack dev        # Start development server"));
+    console.log(chalk4.dim("    objectstack generate   # Add objects, views, etc."));
     console.log("");
   } catch (error) {
     printError(error.message || String(error));
@@ -738,14 +528,14 @@ dist/
   }
 });
 function printWarning2(msg) {
-  console.log(chalk6.yellow(`  \u26A0 ${msg}`));
+  console.log(chalk4.yellow(`  \u26A0 ${msg}`));
 }
 
 // src/commands/generate.ts
 import { Command as Command5 } from "commander";
-import chalk7 from "chalk";
-import fs4 from "fs";
-import path4 from "path";
+import chalk5 from "chalk";
+import fs3 from "fs";
+import path3 from "path";
 var GENERATORS = {
   object: {
     description: "Business data object",
@@ -926,81 +716,589 @@ function toTitleCase2(str) {
 function toSnakeCase(str) {
   return str.replace(/[-]/g, "_").replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`).replace(/^_/, "");
 }
-var generateCommand = new Command5("generate").alias("g").description("Generate metadata files (object, view, action, flow, agent, dashboard, app)").argument("<type>", "Metadata type to generate").argument("<name>", "Name for the metadata (use kebab-case)").option("-d, --dir <directory>", "Target directory (overrides default)").option("--dry-run", "Show what would be created without writing files").action(async (type, name, options) => {
+var FIELD_TYPE_MAP = {
+  text: "string",
+  textarea: "string",
+  richtext: "string",
+  html: "string",
+  markdown: "string",
+  number: "number",
+  integer: "number",
+  currency: "number",
+  percent: "number",
+  boolean: "boolean",
+  date: "string",
+  datetime: "string",
+  time: "string",
+  email: "string",
+  phone: "string",
+  url: "string",
+  select: "string",
+  multiselect: "string[]",
+  lookup: "string",
+  master_detail: "string",
+  formula: "unknown",
+  autonumber: "string",
+  json: "Record<string, unknown>",
+  file: "string",
+  image: "string",
+  password: "string",
+  slug: "string",
+  uuid: "string",
+  ip_address: "string",
+  color: "string",
+  rating: "number",
+  geo_point: "{ lat: number; lng: number }",
+  vector: "number[]",
+  encrypted: "string"
+};
+function fieldTypeToTs(fieldType, multiple) {
+  const base = FIELD_TYPE_MAP[fieldType] || "unknown";
+  return multiple ? `${base}[]` : base;
+}
+function generateTypesFromConfig(config) {
+  const lines = [
+    "// Auto-generated by ObjectStack CLI \u2014 do not edit manually",
+    `// Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "import type { Data } from '@objectstack/spec';",
+    ""
+  ];
+  const objects = [];
+  const rawObjects = config.objects ?? config.data?.objects ?? {};
+  if (Array.isArray(rawObjects)) {
+    objects.push(...rawObjects);
+  } else if (typeof rawObjects === "object") {
+    for (const val of Object.values(rawObjects)) {
+      if (val && typeof val === "object") objects.push(val);
+    }
+  }
+  if (objects.length === 0) {
+    lines.push("// No objects found in configuration");
+    return lines.join("\n") + "\n";
+  }
+  for (const obj of objects) {
+    const name = String(obj.name || "unknown");
+    const typeName = name.split("_").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+    const fields = obj.fields ?? {};
+    lines.push(`/** ${String(obj.label || typeName)} record type */`);
+    lines.push(`export interface ${typeName}Record {`);
+    lines.push("  id: string;");
+    for (const [fieldName, fieldDef] of Object.entries(fields)) {
+      const fType = String(fieldDef.type || "text");
+      const tsType = fieldTypeToTs(fType, !!fieldDef.multiple);
+      const required = fieldDef.required ? "" : "?";
+      if (fieldDef.label) {
+        lines.push(`  /** ${fieldDef.label} */`);
+      }
+      lines.push(`  ${fieldName}${required}: ${tsType};`);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  return lines.join("\n") + "\n";
+}
+var generateMetadataCommand = new Command5("metadata").alias("m").description("Generate metadata scaffold (object, view, action, flow, agent, dashboard, app)").argument("<type>", "Metadata type to generate").argument("<name>", "Name for the metadata (use kebab-case)").option("-d, --dir <directory>", "Target directory (overrides default)").option("--dry-run", "Show what would be created without writing files").action(async (type, name, options) => {
   printHeader("Generate");
   const generator = GENERATORS[type];
   if (!generator) {
     printError(`Unknown type: ${type}`);
     console.log("");
-    console.log(chalk7.bold("  Available types:"));
+    console.log(chalk5.bold("  Available types:"));
     for (const [key, gen] of Object.entries(GENERATORS)) {
-      console.log(`    ${chalk7.cyan(key.padEnd(12))} ${chalk7.dim(gen.description)}`);
+      console.log(`    ${chalk5.cyan(key.padEnd(12))} ${chalk5.dim(gen.description)}`);
     }
     console.log("");
-    console.log(chalk7.dim("  Usage: objectstack generate <type> <name>"));
-    console.log(chalk7.dim("  Example: objectstack generate object project"));
-    console.log(chalk7.dim("  Alias: os g object project"));
+    console.log(chalk5.dim("  Usage: objectstack generate <type> <name>"));
+    console.log(chalk5.dim("  Example: objectstack generate object project"));
+    console.log(chalk5.dim("  Alias: os g object project"));
     process.exit(1);
   }
   const dir = options.dir || generator.defaultDir;
   const fileName = `${toSnakeCase(name)}.ts`;
-  const filePath = path4.join(process.cwd(), dir, fileName);
-  console.log(`  ${chalk7.dim("Type:")}  ${chalk7.cyan(type)} \u2014 ${generator.description}`);
-  console.log(`  ${chalk7.dim("Name:")}  ${chalk7.white(name)}`);
-  console.log(`  ${chalk7.dim("File:")}  ${chalk7.white(path4.join(dir, fileName))}`);
+  const filePath = path3.join(process.cwd(), dir, fileName);
+  console.log(`  ${chalk5.dim("Type:")}  ${chalk5.cyan(type)} \u2014 ${generator.description}`);
+  console.log(`  ${chalk5.dim("Name:")}  ${chalk5.white(name)}`);
+  console.log(`  ${chalk5.dim("File:")}  ${chalk5.white(path3.join(dir, fileName))}`);
   console.log("");
   if (options.dryRun) {
     printInfo("Dry run \u2014 no files written");
     console.log("");
-    console.log(chalk7.dim("  Content:"));
-    console.log(chalk7.dim("  " + "-".repeat(38)));
+    console.log(chalk5.dim("  Content:"));
+    console.log(chalk5.dim("  " + "-".repeat(38)));
     const content = generator.generate(name);
     for (const line of content.split("\n")) {
-      console.log(chalk7.dim(`  ${line}`));
+      console.log(chalk5.dim(`  ${line}`));
     }
     console.log("");
     return;
   }
-  if (fs4.existsSync(filePath)) {
+  if (fs3.existsSync(filePath)) {
     printError(`File already exists: ${filePath}`);
     process.exit(1);
   }
   try {
-    const fullDir = path4.dirname(filePath);
-    if (!fs4.existsSync(fullDir)) {
-      fs4.mkdirSync(fullDir, { recursive: true });
+    const fullDir = path3.dirname(filePath);
+    if (!fs3.existsSync(fullDir)) {
+      fs3.mkdirSync(fullDir, { recursive: true });
     }
     const content = generator.generate(name);
-    fs4.writeFileSync(filePath, content);
-    printSuccess(`Created ${path4.join(dir, fileName)}`);
-    const indexPath = path4.join(process.cwd(), dir, "index.ts");
-    if (fs4.existsSync(indexPath)) {
-      const indexContent = fs4.readFileSync(indexPath, "utf-8");
+    fs3.writeFileSync(filePath, content);
+    printSuccess(`Created ${path3.join(dir, fileName)}`);
+    const indexPath = path3.join(process.cwd(), dir, "index.ts");
+    if (fs3.existsSync(indexPath)) {
+      const indexContent = fs3.readFileSync(indexPath, "utf-8");
       const exportLine = `export { default as ${toCamelCase2(name)} } from './${toSnakeCase(name)}';`;
       if (!indexContent.includes(toCamelCase2(name))) {
-        fs4.appendFileSync(indexPath, exportLine + "\n");
+        fs3.appendFileSync(indexPath, exportLine + "\n");
         printSuccess(`Updated ${dir}/index.ts with export`);
       }
     } else {
       const exportLine = `export { default as ${toCamelCase2(name)} } from './${toSnakeCase(name)}';
 `;
-      fs4.writeFileSync(indexPath, exportLine);
+      fs3.writeFileSync(indexPath, exportLine);
       printSuccess(`Created ${dir}/index.ts`);
     }
     console.log("");
-    console.log(chalk7.dim(`  Tip: Run \`objectstack validate\` to check your config`));
+    console.log(chalk5.dim(`  Tip: Run \`objectstack validate\` to check your config`));
     console.log("");
   } catch (error) {
     printError(error.message || String(error));
     process.exit(1);
   }
 });
+var generateTypesCommand = new Command5("types").description("Generate TypeScript type definitions from ObjectStack configuration").argument("[config]", "Configuration file path").option("-o, --output <file>", "Output file path", "src/types/objectstack.d.ts").option("--dry-run", "Show what would be generated without writing files").action(async (configPath, options) => {
+  printHeader("Generate Types");
+  try {
+    const { loadConfig: loadConfig2 } = await import("./config-UN34WBHT.js");
+    printInfo("Loading configuration...");
+    const { config, absolutePath } = await loadConfig2(configPath);
+    console.log(`  ${chalk5.dim("Config:")} ${chalk5.white(absolutePath)}`);
+    console.log(`  ${chalk5.dim("Output:")} ${chalk5.white(options.output)}`);
+    console.log("");
+    const content = generateTypesFromConfig(config);
+    if (options.dryRun) {
+      printInfo("Dry run \u2014 no files written");
+      console.log("");
+      for (const line of content.split("\n")) {
+        console.log(chalk5.dim(`  ${line}`));
+      }
+      console.log("");
+      return;
+    }
+    const outPath = path3.resolve(process.cwd(), options.output);
+    const outDir = path3.dirname(outPath);
+    if (!fs3.existsSync(outDir)) {
+      fs3.mkdirSync(outDir, { recursive: true });
+    }
+    fs3.writeFileSync(outPath, content);
+    printSuccess(`Generated types at ${options.output}`);
+    console.log("");
+  } catch (error) {
+    printError(error.message || String(error));
+    process.exit(1);
+  }
+});
+function generateClientFromConfig(config) {
+  const lines = [
+    "// Auto-generated by ObjectStack CLI \u2014 do not edit manually",
+    `// Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "import type { Data } from '@objectstack/spec';",
+    ""
+  ];
+  const objects = [];
+  const rawObjects = config.objects ?? config.data?.objects ?? {};
+  if (Array.isArray(rawObjects)) {
+    objects.push(...rawObjects);
+  } else if (typeof rawObjects === "object") {
+    for (const val of Object.values(rawObjects)) {
+      if (val && typeof val === "object") objects.push(val);
+    }
+  }
+  if (objects.length === 0) {
+    lines.push("// No objects found in configuration");
+    return lines.join("\n") + "\n";
+  }
+  for (const obj of objects) {
+    const name = String(obj.name || "unknown");
+    const typeName = name.split("_").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+    const fields = obj.fields ?? {};
+    lines.push(`export interface ${typeName}Record {`);
+    lines.push("  id: string;");
+    for (const [fieldName, fieldDef] of Object.entries(fields)) {
+      const fType = String(fieldDef.type || "text");
+      const tsType = fieldTypeToTs(fType, !!fieldDef.multiple);
+      const required = fieldDef.required ? "" : "?";
+      lines.push(`  ${fieldName}${required}: ${tsType};`);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  lines.push("export class ObjectStackClient {");
+  lines.push("  constructor(private baseUrl: string, private headers: Record<string, string> = {}) {}");
+  lines.push("");
+  lines.push("  private async request<T>(method: string, path: string, body?: unknown): Promise<T> {");
+  lines.push("    const res = await fetch(`${this.baseUrl}${path}`, {");
+  lines.push("      method,");
+  lines.push("      headers: { 'Content-Type': 'application/json', ...this.headers },");
+  lines.push("      body: body ? JSON.stringify(body) : undefined,");
+  lines.push("    });");
+  lines.push("    if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);");
+  lines.push("    return res.json() as Promise<T>;");
+  lines.push("  }");
+  for (const obj of objects) {
+    const name = String(obj.name || "unknown");
+    const typeName = name.split("_").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+    const endpoint = `/api/${name}`;
+    lines.push("");
+    lines.push(`  async list${typeName}(): Promise<${typeName}Record[]> {`);
+    lines.push(`    return this.request<${typeName}Record[]>('GET', '${endpoint}');`);
+    lines.push("  }");
+    lines.push("");
+    lines.push(`  async get${typeName}(id: string): Promise<${typeName}Record> {`);
+    lines.push(`    return this.request<${typeName}Record>('GET', '${endpoint}/\${id}');`);
+    lines.push("  }");
+    lines.push("");
+    lines.push(`  async create${typeName}(data: Omit<${typeName}Record, 'id'>): Promise<${typeName}Record> {`);
+    lines.push(`    return this.request<${typeName}Record>('POST', '${endpoint}', data);`);
+    lines.push("  }");
+    lines.push("");
+    lines.push(`  async update${typeName}(id: string, data: Partial<${typeName}Record>): Promise<${typeName}Record> {`);
+    lines.push(`    return this.request<${typeName}Record>('PATCH', '${endpoint}/\${id}', data);`);
+    lines.push("  }");
+    lines.push("");
+    lines.push(`  async delete${typeName}(id: string): Promise<void> {`);
+    lines.push(`    return this.request<void>('DELETE', '${endpoint}/\${id}');`);
+    lines.push("  }");
+  }
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n") + "\n";
+}
+var generateClientCommand = new Command5("client").description("Generate a type-safe client SDK from ObjectStack configuration").argument("[config]", "Configuration file path").option("-o, --output <file>", "Output file path", "src/client/objectstack-client.ts").option("--dry-run", "Show output without writing").action(async (configPath, options) => {
+  printHeader("Generate Client SDK");
+  try {
+    const { loadConfig: loadConfig2 } = await import("./config-UN34WBHT.js");
+    const timer = createTimer();
+    printInfo("Loading configuration...");
+    const { config, absolutePath } = await loadConfig2(configPath);
+    console.log(`  ${chalk5.dim("Config:")} ${chalk5.white(absolutePath)}`);
+    console.log(`  ${chalk5.dim("Output:")} ${chalk5.white(options.output)}`);
+    console.log("");
+    printStep("Generating client SDK...");
+    const content = generateClientFromConfig(config);
+    if (options.dryRun) {
+      printInfo("Dry run \u2014 no files written");
+      console.log("");
+      for (const line of content.split("\n")) {
+        console.log(chalk5.dim(`  ${line}`));
+      }
+      console.log("");
+      return;
+    }
+    const outPath = path3.resolve(process.cwd(), options.output);
+    const outDir = path3.dirname(outPath);
+    if (!fs3.existsSync(outDir)) {
+      fs3.mkdirSync(outDir, { recursive: true });
+    }
+    fs3.writeFileSync(outPath, content);
+    printSuccess(`Generated client SDK at ${options.output} (${timer.display()})`);
+    console.log("");
+  } catch (error) {
+    printError(error.message || String(error));
+    process.exit(1);
+  }
+});
+var FIELD_TYPE_SQL_MAP = {
+  text: "VARCHAR(255)",
+  textarea: "TEXT",
+  richtext: "TEXT",
+  html: "TEXT",
+  markdown: "TEXT",
+  number: "DECIMAL(18,2)",
+  integer: "INTEGER",
+  currency: "DECIMAL(18,2)",
+  percent: "DECIMAL(5,2)",
+  boolean: "BOOLEAN",
+  date: "DATE",
+  datetime: "TIMESTAMP",
+  time: "TIME",
+  email: "VARCHAR(255)",
+  phone: "VARCHAR(50)",
+  url: "VARCHAR(2048)",
+  select: "VARCHAR(255)",
+  multiselect: "TEXT",
+  lookup: "VARCHAR(36)",
+  master_detail: "VARCHAR(36)",
+  formula: "TEXT",
+  autonumber: "SERIAL",
+  json: "JSONB",
+  file: "VARCHAR(2048)",
+  image: "VARCHAR(2048)",
+  password: "VARCHAR(255)",
+  slug: "VARCHAR(255)",
+  uuid: "UUID",
+  ip_address: "VARCHAR(45)",
+  color: "VARCHAR(7)",
+  rating: "INTEGER",
+  geo_point: "POINT",
+  vector: "VECTOR",
+  encrypted: "TEXT"
+};
+function fieldTypeToSql(fieldType) {
+  return FIELD_TYPE_SQL_MAP[fieldType] || "TEXT";
+}
+function generateMigrationSql(config) {
+  const lines = [
+    "-- Auto-generated by ObjectStack CLI \u2014 do not edit manually",
+    `-- Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    ""
+  ];
+  const objects = [];
+  const rawObjects = config.objects ?? config.data?.objects ?? {};
+  if (Array.isArray(rawObjects)) {
+    objects.push(...rawObjects);
+  } else if (typeof rawObjects === "object") {
+    for (const val of Object.values(rawObjects)) {
+      if (val && typeof val === "object") objects.push(val);
+    }
+  }
+  if (objects.length === 0) {
+    lines.push("-- No objects found in configuration");
+    return lines.join("\n") + "\n";
+  }
+  for (const obj of objects) {
+    const tableName = String(obj.name || "unknown");
+    const fields = obj.fields ?? {};
+    lines.push(`CREATE TABLE IF NOT EXISTS "${tableName}" (`);
+    lines.push('  "id" UUID PRIMARY KEY DEFAULT gen_random_uuid(),');
+    const fieldLines = [];
+    for (const [fieldName, fieldDef] of Object.entries(fields)) {
+      const sqlType = fieldTypeToSql(String(fieldDef.type || "text"));
+      const notNull = fieldDef.required ? " NOT NULL" : "";
+      fieldLines.push(`  "${fieldName}" ${sqlType}${notNull}`);
+    }
+    fieldLines.push('  "created_at" TIMESTAMP NOT NULL DEFAULT now()');
+    fieldLines.push('  "updated_at" TIMESTAMP NOT NULL DEFAULT now()');
+    lines.push(fieldLines.join(",\n"));
+    lines.push(");");
+    lines.push("");
+  }
+  return lines.join("\n") + "\n";
+}
+function generateMigrationTs(config) {
+  const lines = [
+    "// Auto-generated by ObjectStack CLI \u2014 do not edit manually",
+    `// Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "export async function up(db: any): Promise<void> {"
+  ];
+  const objects = [];
+  const rawObjects = config.objects ?? config.data?.objects ?? {};
+  if (Array.isArray(rawObjects)) {
+    objects.push(...rawObjects);
+  } else if (typeof rawObjects === "object") {
+    for (const val of Object.values(rawObjects)) {
+      if (val && typeof val === "object") objects.push(val);
+    }
+  }
+  if (objects.length === 0) {
+    lines.push("  // No objects found in configuration");
+    lines.push("}");
+    lines.push("");
+    lines.push("export async function down(db: any): Promise<void> {");
+    lines.push("  // No objects found in configuration");
+    lines.push("}");
+    return lines.join("\n") + "\n";
+  }
+  for (const obj of objects) {
+    const tableName = String(obj.name || "unknown");
+    const fields = obj.fields ?? {};
+    lines.push(`  await db.schema.createTable('${tableName}', (table: any) => {`);
+    lines.push("    table.uuid('id').primary().defaultTo(db.fn.uuid());");
+    for (const [fieldName, fieldDef] of Object.entries(fields)) {
+      const fType = String(fieldDef.type || "text");
+      const required = fieldDef.required ? ".notNullable()" : ".nullable()";
+      let colMethod;
+      switch (fType) {
+        case "text":
+        case "email":
+        case "phone":
+        case "url":
+        case "select":
+        case "slug":
+        case "password":
+        case "color":
+        case "ip_address":
+          colMethod = `table.string('${fieldName}')`;
+          break;
+        case "textarea":
+        case "richtext":
+        case "html":
+        case "markdown":
+        case "formula":
+        case "encrypted":
+          colMethod = `table.text('${fieldName}')`;
+          break;
+        case "number":
+        case "currency":
+        case "percent":
+          colMethod = `table.decimal('${fieldName}')`;
+          break;
+        case "integer":
+        case "rating":
+          colMethod = `table.integer('${fieldName}')`;
+          break;
+        case "boolean":
+          colMethod = `table.boolean('${fieldName}')`;
+          break;
+        case "date":
+          colMethod = `table.date('${fieldName}')`;
+          break;
+        case "datetime":
+          colMethod = `table.timestamp('${fieldName}')`;
+          break;
+        case "time":
+          colMethod = `table.time('${fieldName}')`;
+          break;
+        case "json":
+        case "multiselect":
+          colMethod = `table.jsonb('${fieldName}')`;
+          break;
+        case "uuid":
+        case "lookup":
+        case "master_detail":
+          colMethod = `table.uuid('${fieldName}')`;
+          break;
+        default:
+          colMethod = `table.text('${fieldName}')`;
+      }
+      lines.push(`    ${colMethod}${required};`);
+    }
+    lines.push("    table.timestamps(true, true);");
+    lines.push("  });");
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("export async function down(db: any): Promise<void> {");
+  const tableNames = objects.map((o) => String(o.name || "unknown")).reverse();
+  for (const tableName of tableNames) {
+    lines.push(`  await db.schema.dropTableIfExists('${tableName}');`);
+  }
+  lines.push("}");
+  return lines.join("\n") + "\n";
+}
+var generateMigrationCommand = new Command5("migration").description("Generate database migration from ObjectStack schema").argument("[config]", "Configuration file path").option("-o, --output <file>", "Output file path").option("--format <format>", "Output format: sql or typescript", "typescript").option("--dry-run", "Show output without writing").action(async (configPath, options) => {
+  printHeader("Generate Migration");
+  try {
+    const { loadConfig: loadConfig2 } = await import("./config-UN34WBHT.js");
+    const timer = createTimer();
+    printInfo("Loading configuration...");
+    const { config, absolutePath } = await loadConfig2(configPath);
+    const ext = options.format === "sql" ? "sql" : "ts";
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T]/g, "").slice(0, 14);
+    const defaultOutput = `migrations/${timestamp}_migration.${ext}`;
+    const output = options.output || defaultOutput;
+    console.log(`  ${chalk5.dim("Config:")} ${chalk5.white(absolutePath)}`);
+    console.log(`  ${chalk5.dim("Format:")} ${chalk5.white(options.format)}`);
+    console.log(`  ${chalk5.dim("Output:")} ${chalk5.white(output)}`);
+    console.log("");
+    printStep("Generating migration...");
+    const content = options.format === "sql" ? generateMigrationSql(config) : generateMigrationTs(config);
+    if (options.dryRun) {
+      printInfo("Dry run \u2014 no files written");
+      console.log("");
+      for (const line of content.split("\n")) {
+        console.log(chalk5.dim(`  ${line}`));
+      }
+      console.log("");
+      return;
+    }
+    const outPath = path3.resolve(process.cwd(), output);
+    const outDir = path3.dirname(outPath);
+    if (!fs3.existsSync(outDir)) {
+      fs3.mkdirSync(outDir, { recursive: true });
+    }
+    fs3.writeFileSync(outPath, content);
+    printSuccess(`Generated migration at ${output} (${timer.display()})`);
+    console.log("");
+  } catch (error) {
+    printError(error.message || String(error));
+    process.exit(1);
+  }
+});
+var generateSchemaCommand = new Command5("schema").description("Generate JSON Schema for objectstack.config.ts (for IDE autocomplete)").option("-o, --output <file>", "Output file path", "objectstack.schema.json").option("--dry-run", "Show output without writing").action(async (options) => {
+  printHeader("Generate Schema");
+  try {
+    const timer = createTimer();
+    printStep("Loading ObjectStackDefinitionSchema...");
+    const { z } = await import("zod");
+    const { ObjectStackDefinitionSchema: ObjectStackDefinitionSchema3 } = await import("@objectstack/spec");
+    printStep("Converting to JSON Schema...");
+    const jsonSchema = z.toJSONSchema(ObjectStackDefinitionSchema3, {
+      target: "draft-2020-12"
+    });
+    const schema = {
+      ...jsonSchema,
+      $id: "https://schema.objectstack.io/objectstack.config.json",
+      title: "ObjectStack Configuration",
+      description: "JSON Schema for objectstack.config.ts \u2014 generated from ObjectStackDefinitionSchema"
+    };
+    const content = JSON.stringify(schema, null, 2) + "\n";
+    if (options.dryRun) {
+      printInfo("Dry run \u2014 no files written");
+      console.log("");
+      console.log(content);
+      return;
+    }
+    const outPath = path3.resolve(process.cwd(), options.output);
+    const outDir = path3.dirname(outPath);
+    if (!fs3.existsSync(outDir)) {
+      fs3.mkdirSync(outDir, { recursive: true });
+    }
+    fs3.writeFileSync(outPath, content);
+    printSuccess(`Generated JSON Schema at ${options.output} (${timer.display()})`);
+    console.log("");
+    console.log(chalk5.dim("  Usage: Reference in your IDE or editor for autocomplete"));
+    console.log(chalk5.dim(`  Path:  ${outPath}`));
+    console.log("");
+  } catch (error) {
+    printError(error.message || String(error));
+    process.exit(1);
+  }
+});
+var generateCommand = new Command5("generate").alias("g").description("Generate metadata files or TypeScript types").argument("[type]", "Metadata type to generate (object, view, action, flow, agent, dashboard, app)").argument("[name]", "Name for the metadata (use kebab-case)").option("-d, --dir <directory>", "Target directory (overrides default)").option("--dry-run", "Show what would be created without writing files").addCommand(generateTypesCommand).addCommand(generateClientCommand).addCommand(generateMigrationCommand).addCommand(generateSchemaCommand).action(async (type, name, options) => {
+  if (!type) {
+    printHeader("Generate");
+    console.log(chalk5.bold("  Sub-commands:"));
+    console.log(`    ${chalk5.cyan("types".padEnd(12))} Generate TypeScript type definitions from config`);
+    console.log(`    ${chalk5.cyan("client".padEnd(12))} Generate a type-safe client SDK from config`);
+    console.log(`    ${chalk5.cyan("migration".padEnd(12))} Generate database migration from schema`);
+    console.log(`    ${chalk5.cyan("schema".padEnd(12))} Generate JSON Schema for objectstack.config.ts (IDE autocomplete)`);
+    console.log("");
+    console.log(chalk5.bold("  Metadata types:"));
+    for (const [key, gen] of Object.entries(GENERATORS)) {
+      console.log(`    ${chalk5.cyan(key.padEnd(12))} ${chalk5.dim(gen.description)}`);
+    }
+    console.log("");
+    console.log(chalk5.dim("  Usage: objectstack generate <type> <name>"));
+    console.log(chalk5.dim("  Usage: objectstack generate types [config]"));
+    return;
+  }
+  if (!name) {
+    printError("Missing required argument: <name>");
+    console.log(chalk5.dim("  Usage: objectstack generate <type> <name>"));
+    process.exit(1);
+  }
+  await generateMetadataCommand.parseAsync([type, name, ...process.argv.slice(4)], { from: "user" });
+});
 
 // src/commands/create.ts
 import { Command as Command6 } from "commander";
-import chalk8 from "chalk";
-import fs5 from "fs";
-import path5 from "path";
+import chalk6 from "chalk";
+import fs4 from "fs";
+import path4 from "path";
 var templates = {
   plugin: {
     description: "Create a new ObjectStack plugin",
@@ -1175,64 +1473,64 @@ function toCamelCase3(str) {
   return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
 }
 var createCommand = new Command6("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(chalk8.bold(`
+  console.log(chalk6.bold(`
 \u{1F4E6} ObjectStack Project Creator`));
-  console.log(chalk8.dim(`-------------------------------`));
+  console.log(chalk6.dim(`-------------------------------`));
   if (!templates[type]) {
-    console.error(chalk8.red(`
+    console.error(chalk6.red(`
 \u274C Unknown type: ${type}`));
-    console.log(chalk8.dim("Available types: plugin, example"));
+    console.log(chalk6.dim("Available types: plugin, example"));
     process.exit(1);
   }
   if (!name) {
-    console.error(chalk8.red("\n\u274C Project name is required"));
-    console.log(chalk8.dim(`Usage: objectstack create ${type} <name>`));
+    console.error(chalk6.red("\n\u274C Project name is required"));
+    console.log(chalk6.dim(`Usage: objectstack create ${type} <name>`));
     process.exit(1);
   }
   const template = templates[type];
   const cwd = process.cwd();
   let targetDir;
   if (options?.dir) {
-    targetDir = path5.resolve(cwd, options.dir);
+    targetDir = path4.resolve(cwd, options.dir);
   } else {
     const baseDir = type === "plugin" ? "packages/plugins" : "examples";
     const projectName = type === "plugin" ? `plugin-${name}` : name;
-    targetDir = path5.join(cwd, baseDir, projectName);
+    targetDir = path4.join(cwd, baseDir, projectName);
   }
-  if (fs5.existsSync(targetDir)) {
-    console.error(chalk8.red(`
+  if (fs4.existsSync(targetDir)) {
+    console.error(chalk6.red(`
 \u274C Directory already exists: ${targetDir}`));
     process.exit(1);
   }
-  console.log(`\u{1F4C1} Creating ${type}: ${chalk8.blue(name)}`);
-  console.log(`\u{1F4C2} Location: ${chalk8.dim(targetDir)}`);
+  console.log(`\u{1F4C1} Creating ${type}: ${chalk6.blue(name)}`);
+  console.log(`\u{1F4C2} Location: ${chalk6.dim(targetDir)}`);
   console.log("");
   try {
-    fs5.mkdirSync(targetDir, { recursive: true });
+    fs4.mkdirSync(targetDir, { recursive: true });
     for (const [filePath, contentFn] of Object.entries(template.files)) {
-      const fullPath = path5.join(targetDir, filePath);
-      const dir = path5.dirname(fullPath);
-      if (!fs5.existsSync(dir)) {
-        fs5.mkdirSync(dir, { recursive: true });
+      const fullPath = path4.join(targetDir, filePath);
+      const dir = path4.dirname(fullPath);
+      if (!fs4.existsSync(dir)) {
+        fs4.mkdirSync(dir, { recursive: true });
       }
       const content = contentFn(name);
       const fileContent = typeof content === "string" ? content : JSON.stringify(content, null, 2);
-      fs5.writeFileSync(fullPath, fileContent);
-      console.log(chalk8.green(`\u2713 Created ${filePath}`));
+      fs4.writeFileSync(fullPath, fileContent);
+      console.log(chalk6.green(`\u2713 Created ${filePath}`));
     }
     console.log("");
-    console.log(chalk8.green("\u2705 Project created successfully!"));
+    console.log(chalk6.green("\u2705 Project created successfully!"));
     console.log("");
-    console.log(chalk8.bold("Next steps:"));
-    console.log(chalk8.dim(`  cd ${path5.relative(cwd, targetDir)}`));
-    console.log(chalk8.dim("  pnpm install"));
-    console.log(chalk8.dim("  pnpm build"));
+    console.log(chalk6.bold("Next steps:"));
+    console.log(chalk6.dim(`  cd ${path4.relative(cwd, targetDir)}`));
+    console.log(chalk6.dim("  pnpm install"));
+    console.log(chalk6.dim("  pnpm build"));
     console.log("");
   } catch (error) {
-    console.error(chalk8.red("\n\u274C Failed to create project:"));
+    console.error(chalk6.red("\n\u274C Failed to create project:"));
     console.error(error.message || error);
-    if (fs5.existsSync(targetDir)) {
-      fs5.rmSync(targetDir, { recursive: true });
+    if (fs4.existsSync(targetDir)) {
+      fs4.rmSync(targetDir, { recursive: true });
     }
     process.exit(1);
   }
@@ -1240,9 +1538,9 @@ var createCommand = new Command6("create").description("Create a new package, pl
 
 // src/commands/plugin.ts
 import { Command as Command7 } from "commander";
-import chalk9 from "chalk";
-import fs6 from "fs";
-import path6 from "path";
+import chalk7 from "chalk";
+import fs5 from "fs";
+import path5 from "path";
 function resolvePluginName(plugin) {
   if (typeof plugin === "string") return plugin;
   if (plugin && typeof plugin === "object") {
@@ -1267,7 +1565,7 @@ function resolvePluginType(plugin) {
   return "standard";
 }
 function readConfigText(configPath) {
-  return fs6.readFileSync(configPath, "utf-8");
+  return fs5.readFileSync(configPath, "utf-8");
 }
 function addPluginToConfig(configPath, packageName) {
   let content = readConfigText(configPath);
@@ -1309,7 +1607,7 @@ function addPluginToConfig(configPath, packageName) {
 $2`
     );
   }
-  fs6.writeFileSync(configPath, content);
+  fs5.writeFileSync(configPath, content);
 }
 function removePluginFromConfig(configPath, pluginName) {
   let content = readConfigText(configPath);
@@ -1331,7 +1629,7 @@ function removePluginFromConfig(configPath, pluginName) {
     content = content.replace(pattern, "\n");
   }
   content = content.replace(/plugins\s*:\s*\[\s*\],?\n?/g, "");
-  fs6.writeFileSync(configPath, content);
+  fs5.writeFileSync(configPath, content);
 }
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -1363,31 +1661,31 @@ var listCommand = new Command7("list").alias("ls").description("List plugins def
     if (plugins.length === 0 && devPlugins.length === 0) {
       printInfo("No plugins configured");
       console.log("");
-      console.log(chalk9.dim("  Hint: Add plugins to your objectstack.config.ts"));
-      console.log(chalk9.dim("  Or run: os plugin add <package-name>"));
+      console.log(chalk7.dim("  Hint: Add plugins to your objectstack.config.ts"));
+      console.log(chalk7.dim("  Or run: os plugin add <package-name>"));
       console.log("");
       return;
     }
     if (plugins.length > 0) {
-      console.log(chalk9.bold(`
+      console.log(chalk7.bold(`
   Plugins (${plugins.length}):`));
       for (const plugin of plugins) {
         const name = resolvePluginName(plugin);
         const version = resolvePluginVersion(plugin);
         const type = resolvePluginType(plugin);
         console.log(
-          `    ${chalk9.cyan("\u25CF")} ${chalk9.white(name)}` + (version !== "-" ? chalk9.dim(` v${version}`) : "") + (type !== "standard" ? chalk9.dim(` [${type}]`) : "")
+          `    ${chalk7.cyan("\u25CF")} ${chalk7.white(name)}` + (version !== "-" ? chalk7.dim(` v${version}`) : "") + (type !== "standard" ? chalk7.dim(` [${type}]`) : "")
         );
       }
     }
     if (devPlugins.length > 0) {
-      console.log(chalk9.bold(`
+      console.log(chalk7.bold(`
   Dev Plugins (${devPlugins.length}):`));
       for (const plugin of devPlugins) {
         const name = resolvePluginName(plugin);
         const version = resolvePluginVersion(plugin);
         console.log(
-          `    ${chalk9.yellow("\u25CF")} ${chalk9.white(name)}` + (version !== "-" ? chalk9.dim(` v${version}`) : "") + chalk9.dim(" [dev]")
+          `    ${chalk7.yellow("\u25CF")} ${chalk7.white(name)}` + (version !== "-" ? chalk7.dim(` v${version}`) : "") + chalk7.dim(" [dev]")
         );
       }
     }
@@ -1411,9 +1709,9 @@ var infoSubCommand = new Command7("info").description("Show detailed information
     if (!found) {
       printError(`Plugin '${name}' not found in configuration`);
       console.log("");
-      console.log(chalk9.dim("  Available plugins:"));
+      console.log(chalk7.dim("  Available plugins:"));
       for (const p of allPlugins) {
-        console.log(chalk9.dim(`    - ${resolvePluginName(p)}`));
+        console.log(chalk7.dim(`    - ${resolvePluginName(p)}`));
       }
       console.log("");
       process.exit(1);
@@ -1449,15 +1747,15 @@ var addCommand = new Command7("add").description("Add a plugin to objectstack.co
   try {
     const configPath = resolveConfigPath(options?.config);
     printHeader("Add Plugin");
-    console.log(`  ${chalk9.dim("Package:")} ${chalk9.white(packageName)}`);
-    console.log(`  ${chalk9.dim("Config:")}  ${chalk9.white(path6.relative(process.cwd(), configPath))}`);
+    console.log(`  ${chalk7.dim("Package:")} ${chalk7.white(packageName)}`);
+    console.log(`  ${chalk7.dim("Config:")}  ${chalk7.white(path5.relative(process.cwd(), configPath))}`);
     console.log("");
     addPluginToConfig(configPath, packageName);
-    printSuccess(`Added ${chalk9.cyan(packageName)} to config`);
+    printSuccess(`Added ${chalk7.cyan(packageName)} to config`);
     console.log("");
-    console.log(chalk9.dim("  Next steps:"));
-    console.log(chalk9.dim(`  1. Install the package: pnpm add ${packageName}`));
-    console.log(chalk9.dim("  2. Run: os validate"));
+    console.log(chalk7.dim("  Next steps:"));
+    console.log(chalk7.dim(`  1. Install the package: pnpm add ${packageName}`));
+    console.log(chalk7.dim("  2. Run: os validate"));
     console.log("");
   } catch (error) {
     printError(error.message || String(error));
@@ -1468,13 +1766,13 @@ var removeCommand = new Command7("remove").alias("rm").description("Remove a plu
   try {
     const configPath = resolveConfigPath(options?.config);
     printHeader("Remove Plugin");
-    console.log(`  ${chalk9.dim("Plugin:")} ${chalk9.white(pluginName)}`);
-    console.log(`  ${chalk9.dim("Config:")} ${chalk9.white(path6.relative(process.cwd(), configPath))}`);
+    console.log(`  ${chalk7.dim("Plugin:")} ${chalk7.white(pluginName)}`);
+    console.log(`  ${chalk7.dim("Config:")} ${chalk7.white(path5.relative(process.cwd(), configPath))}`);
     console.log("");
     removePluginFromConfig(configPath, pluginName);
-    printSuccess(`Removed ${chalk9.cyan(pluginName)} from config`);
+    printSuccess(`Removed ${chalk7.cyan(pluginName)} from config`);
     console.log("");
-    console.log(chalk9.dim("  Tip: Run `pnpm remove " + pluginName + "` to uninstall the package"));
+    console.log(chalk7.dim("  Tip: Run `pnpm remove " + pluginName + "` to uninstall the package"));
     console.log("");
   } catch (error) {
     printError(error.message || String(error));
@@ -1485,14 +1783,14 @@ var pluginCommand = new Command7("plugin").description("Manage plugins (list, in
 
 // src/commands/dev.ts
 import { Command as Command8 } from "commander";
-import chalk10 from "chalk";
+import chalk8 from "chalk";
 import { execSync, spawn } from "child_process";
-import fs7 from "fs";
-import path7 from "path";
+import fs6 from "fs";
+import path6 from "path";
 var devCommand = new Command8("dev").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 Studio UI at /_studio/").option("-v, --verbose", "Verbose output").action(async (packageName, options) => {
   printHeader("Development Mode");
-  const configPath = path7.resolve(process.cwd(), "objectstack.config.ts");
-  if (packageName === "all" && fs7.existsSync(configPath)) {
+  const configPath = path6.resolve(process.cwd(), "objectstack.config.ts");
+  if (packageName === "all" && fs6.existsSync(configPath)) {
     printKV("Config", configPath, "\u{1F4C2}");
     printStep("Starting dev server...");
     const binPath = process.argv[1];
@@ -1504,18 +1802,18 @@ var devCommand = new Command8("dev").description("Start development mode with ho
   }
   try {
     const cwd = process.cwd();
-    const workspaceConfigPath = path7.resolve(cwd, "pnpm-workspace.yaml");
-    const isWorkspaceRoot = fs7.existsSync(workspaceConfigPath);
+    const workspaceConfigPath = path6.resolve(cwd, "pnpm-workspace.yaml");
+    const isWorkspaceRoot = fs6.existsSync(workspaceConfigPath);
     if (packageName === "all" && !isWorkspaceRoot) {
       printError(`Config file not found in ${cwd}`);
-      console.error(chalk10.yellow("  Run in a directory with objectstack.config.ts, or from the monorepo root."));
+      console.error(chalk8.yellow("  Run in a directory with objectstack.config.ts, or from the monorepo root."));
       process.exit(1);
     }
     const filter = packageName === "all" ? "" : `--filter ${packageName}`;
     printKV("Package", packageName === "all" ? "All packages" : packageName, "\u{1F4E6}");
     printKV("Watch", "enabled", "\u{1F504}");
     const command = `pnpm ${filter} dev`.trim();
-    console.log(chalk10.dim(`$ ${command}`));
+    console.log(chalk8.dim(`$ ${command}`));
     console.log("");
     execSync(command, {
       stdio: "inherit",
@@ -1529,37 +1827,37 @@ var devCommand = new Command8("dev").description("Start development mode with ho
 
 // src/commands/serve.ts
 import { Command as Command9 } from "commander";
-import path9 from "path";
-import fs9 from "fs";
+import path8 from "path";
+import fs8 from "fs";
 import net from "net";
-import chalk11 from "chalk";
-import { bundleRequire as bundleRequire2 } from "bundle-require";
+import chalk9 from "chalk";
+import { bundleRequire } from "bundle-require";
 
 // src/utils/studio.ts
-import path8 from "path";
-import fs8 from "fs";
+import path7 from "path";
+import fs7 from "fs";
 import { createRequire } from "module";
 import { pathToFileURL } from "url";
 var STUDIO_PATH = "/_studio";
 function resolveStudioPath() {
   const cwd = process.cwd();
   const candidates = [
-    path8.resolve(cwd, "apps/studio"),
-    path8.resolve(cwd, "../../apps/studio"),
-    path8.resolve(cwd, "../apps/studio")
+    path7.resolve(cwd, "apps/studio"),
+    path7.resolve(cwd, "../../apps/studio"),
+    path7.resolve(cwd, "../apps/studio")
   ];
   for (const candidate of candidates) {
-    const pkgPath = path8.join(candidate, "package.json");
-    if (fs8.existsSync(pkgPath)) {
+    const pkgPath = path7.join(candidate, "package.json");
+    if (fs7.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
+        const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
         if (pkg.name === "@objectstack/studio") return candidate;
       } catch {
       }
     }
   }
   const resolutionBases = [
-    pathToFileURL(path8.join(cwd, "package.json")).href,
+    pathToFileURL(path7.join(cwd, "package.json")).href,
     // consumer workspace
     import.meta.url
     // CLI package itself
@@ -1568,18 +1866,18 @@ function resolveStudioPath() {
     try {
       const req = createRequire(base);
       const resolved = req.resolve("@objectstack/studio/package.json");
-      return path8.dirname(resolved);
+      return path7.dirname(resolved);
     } catch {
     }
   }
-  const directPath = path8.join(cwd, "node_modules", "@objectstack", "studio");
-  if (fs8.existsSync(path8.join(directPath, "package.json"))) {
+  const directPath = path7.join(cwd, "node_modules", "@objectstack", "studio");
+  if (fs7.existsSync(path7.join(directPath, "package.json"))) {
     return directPath;
   }
   return null;
 }
 function hasStudioDist(studioPath) {
-  return fs8.existsSync(path8.join(studioPath, "dist", "index.html"));
+  return fs7.existsSync(path7.join(studioPath, "dist", "index.html"));
 }
 function createStudioStaticPlugin(distPath, options) {
   return {
@@ -1593,13 +1891,13 @@ function createStudioStaticPlugin(distPath, options) {
         return;
       }
       const app = httpServer.getRawApp();
-      const absoluteDist = path8.resolve(distPath);
-      const indexPath = path8.join(absoluteDist, "index.html");
-      if (!fs8.existsSync(indexPath)) {
+      const absoluteDist = path7.resolve(distPath);
+      const indexPath = path7.join(absoluteDist, "index.html");
+      if (!fs7.existsSync(indexPath)) {
         ctx.logger?.warn?.(`Studio static: dist not found at ${absoluteDist}`);
         return;
       }
-      const rawHtml = fs8.readFileSync(indexPath, "utf-8");
+      const rawHtml = fs7.readFileSync(indexPath, "utf-8");
       const rewrittenHtml = rawHtml.replace(
         /(\s(?:href|src))="\/(?!\/)/g,
         `$1="${STUDIO_PATH}/`
@@ -1610,12 +1908,12 @@ function createStudioStaticPlugin(distPath, options) {
       app.get(STUDIO_PATH, (c) => c.redirect(`${STUDIO_PATH}/`));
       app.get(`${STUDIO_PATH}/*`, async (c) => {
         const reqPath = c.req.path.substring(STUDIO_PATH.length) || "/";
-        const filePath = path8.join(absoluteDist, reqPath);
+        const filePath = path7.join(absoluteDist, reqPath);
         if (!filePath.startsWith(absoluteDist)) {
           return c.text("Forbidden", 403);
         }
-        if (fs8.existsSync(filePath) && fs8.statSync(filePath).isFile()) {
-          const content = fs8.readFileSync(filePath);
+        if (fs7.existsSync(filePath) && fs7.statSync(filePath).isFile()) {
+          const content = fs7.readFileSync(filePath);
           return new Response(content, {
             headers: { "content-type": mimeType(filePath) }
           });
@@ -1645,7 +1943,7 @@ var MIME_TYPES = {
   ".map": "application/json"
 };
 function mimeType(filePath) {
-  const ext = path8.extname(filePath).toLowerCase();
+  const ext = path7.extname(filePath).toLowerCase();
   return MIME_TYPES[ext] || "application/octet-stream";
 }
 
@@ -1682,15 +1980,15 @@ var serveCommand = new Command9("serve").description("Start ObjectStack server w
   } catch (e) {
   }
   const isDev = options.dev || process.env.NODE_ENV === "development";
-  const absolutePath = path9.resolve(process.cwd(), configPath);
-  const relativeConfig = path9.relative(process.cwd(), absolutePath);
-  if (!fs9.existsSync(absolutePath)) {
+  const absolutePath = path8.resolve(process.cwd(), configPath);
+  const relativeConfig = path8.relative(process.cwd(), absolutePath);
+  if (!fs8.existsSync(absolutePath)) {
     printError(`Configuration file not found: ${absolutePath}`);
-    console.log(chalk11.dim("  Hint: Run `objectstack init` to create a new project"));
+    console.log(chalk9.dim("  Hint: Run `objectstack init` to create a new project"));
     process.exit(1);
   }
   console.log("");
-  console.log(chalk11.dim(`  Loading ${relativeConfig}...`));
+  console.log(chalk9.dim(`  Loading ${relativeConfig}...`));
   const loadedPlugins = [];
   const shortPluginName = (raw) => {
     if (raw.includes("objectql")) return "ObjectQL";
@@ -1725,7 +2023,7 @@ var serveCommand = new Command9("serve").description("Start ObjectStack server w
     console.debug = (...args) => {
       if (!bootQuiet) originalConsoleDebug(...args);
     };
-    const { mod } = await bundleRequire2({
+    const { mod } = await bundleRequire({
       filepath: absolutePath
     });
     const config = mod.default || mod;
@@ -1794,7 +2092,7 @@ var serveCommand = new Command9("serve").description("Start ObjectStack server w
           const pluginName = plugin.name || plugin.constructor?.name || "unnamed";
           trackPlugin(pluginName);
         } catch (e) {
-          console.error(chalk11.red(`  \u2717 Failed to load plugin: ${e.message}`));
+          console.error(chalk9.red(`  \u2717 Failed to load plugin: ${e.message}`));
         }
       }
     }
@@ -1805,7 +2103,7 @@ var serveCommand = new Command9("serve").description("Start ObjectStack server w
         await kernel.use(serverPlugin);
         trackPlugin("HonoServer");
       } catch (e) {
-        console.warn(chalk11.yellow(`  \u26A0 HTTP server plugin not available: ${e.message}`));
+        console.warn(chalk9.yellow(`  \u26A0 HTTP server plugin not available: ${e.message}`));
       }
       try {
         const { createRestApiPlugin } = await import("@objectstack/rest");
@@ -1824,13 +2122,13 @@ var serveCommand = new Command9("serve").description("Start ObjectStack server w
     if (enableUI) {
       const studioPath = resolveStudioPath();
       if (!studioPath) {
-        console.warn(chalk11.yellow(`  \u26A0 @objectstack/studio not found \u2014 skipping UI`));
+        console.warn(chalk9.yellow(`  \u26A0 @objectstack/studio not found \u2014 skipping UI`));
       } else if (hasStudioDist(studioPath)) {
-        const distPath = path9.join(studioPath, "dist");
+        const distPath = path8.join(studioPath, "dist");
         await kernel.use(createStudioStaticPlugin(distPath, { isDev }));
         trackPlugin("StudioUI");
       } else {
-        console.warn(chalk11.yellow(`  \u26A0 Studio dist not found \u2014 run "pnpm --filter @objectstack/studio build" first`));
+        console.warn(chalk9.yellow(`  \u26A0 Studio dist not found \u2014 run "pnpm --filter @objectstack/studio build" first`));
       }
     }
     await runtime.start();
@@ -1846,33 +2144,33 @@ var serveCommand = new Command9("serve").description("Start ObjectStack server w
       studioPath: STUDIO_PATH
     });
     process.on("SIGINT", async () => {
-      console.warn(chalk11.yellow(`
+      console.warn(chalk9.yellow(`
 
 \u23F9  Stopping server...`));
       await runtime.getKernel().shutdown();
-      console.log(chalk11.green(`\u2705 Server stopped`));
+      console.log(chalk9.green(`\u2705 Server stopped`));
       process.exit(0);
     });
   } catch (error) {
     restoreOutput();
     console.log("");
     printError(error.message || String(error));
-    if (process.env.DEBUG) console.error(chalk11.dim(error.stack));
+    if (process.env.DEBUG) console.error(chalk9.dim(error.stack));
     process.exit(1);
   }
 });
 
 // src/commands/test.ts
 import { Command as Command10 } from "commander";
-import chalk12 from "chalk";
-import path10 from "path";
-import fs10 from "fs";
+import chalk10 from "chalk";
+import path9 from "path";
+import fs9 from "fs";
 import { QA as CoreQA } from "@objectstack/core";
 function resolveGlob(pattern) {
   if (!pattern.includes("*")) {
-    return fs10.existsSync(pattern) ? [pattern] : [];
+    return fs9.existsSync(pattern) ? [pattern] : [];
   }
-  const parts = pattern.split(path10.sep.replace("\\", "/"));
+  const parts = pattern.split(path9.sep.replace("\\", "/"));
   const segments = pattern.includes("/") ? pattern.split("/") : parts;
   let baseDir = ".";
   let globStart = 0;
@@ -1881,25 +2179,25 @@ function resolveGlob(pattern) {
       globStart = i;
       break;
     }
-    baseDir = i === 0 ? segments[i] : path10.join(baseDir, segments[i]);
+    baseDir = i === 0 ? segments[i] : path9.join(baseDir, segments[i]);
   }
-  if (!fs10.existsSync(baseDir)) return [];
+  if (!fs9.existsSync(baseDir)) return [];
   const globPortion = segments.slice(globStart).join("/");
   const regexStr = globPortion.replace(/\./g, "\\.").replace(/\*\*\//g, "(.+/)?").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
   const regex = new RegExp(`^${regexStr}$`);
-  const entries = fs10.readdirSync(baseDir, { recursive: true, encoding: "utf-8" });
-  return entries.filter((entry) => regex.test(entry.replace(/\\/g, "/"))).map((entry) => path10.join(baseDir, entry)).filter((fullPath) => fs10.statSync(fullPath).isFile());
+  const entries = fs9.readdirSync(baseDir, { recursive: true, encoding: "utf-8" });
+  return entries.filter((entry) => regex.test(entry.replace(/\\/g, "/"))).map((entry) => path9.join(baseDir, entry)).filter((fullPath) => fs9.statSync(fullPath).isFile());
 }
 var testCommand = new Command10("test").description("Run Quality Protocol test scenarios against a running server").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(chalk12.bold(`
+  console.log(chalk10.bold(`
 \u{1F9EA} ObjectStack Quality Protocol Runner`));
-  console.log(chalk12.dim(`-------------------------------------`));
-  console.log(`Target: ${chalk12.blue(options.url)}`);
+  console.log(chalk10.dim(`-------------------------------------`));
+  console.log(`Target: ${chalk10.blue(options.url)}`);
   const adapter = new CoreQA.HttpTestAdapter(options.url, options.token);
   const runner = new CoreQA.TestRunner(adapter);
   const testFiles = resolveGlob(filesPattern);
   if (testFiles.length === 0) {
-    console.warn(chalk12.yellow(`No test files found matching: ${filesPattern}`));
+    console.warn(chalk10.yellow(`No test files found matching: ${filesPattern}`));
     return;
   }
   console.log(`Found ${testFiles.length} test suites.`);
@@ -1907,19 +2205,19 @@ var testCommand = new Command10("test").description("Run Quality Protocol test s
   let totalFailed = 0;
   for (const file of testFiles) {
     console.log(`
-\u{1F4C4} Running suite: ${chalk12.bold(path10.basename(file))}`);
+\u{1F4C4} Running suite: ${chalk10.bold(path9.basename(file))}`);
     try {
-      const content = fs10.readFileSync(file, "utf-8");
+      const content = fs9.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(chalk12.red(`     Error: ${result.error}`));
+          console.error(chalk10.red(`     Error: ${result.error}`));
           result.steps.forEach((step) => {
             if (!step.passed) {
-              console.error(chalk12.red(`     Step Failed: ${step.stepName}`));
+              console.error(chalk10.red(`     Step Failed: ${step.stepName}`));
               if (step.output) console.error(`     Output:`, step.output);
               if (step.error) console.error(`     Error:`, step.error);
             }
@@ -1930,28 +2228,258 @@ var testCommand = new Command10("test").description("Run Quality Protocol test s
         }
       }
     } catch (e) {
-      console.error(chalk12.red(`Failed to load or run suite ${file}: ${e}`));
+      console.error(chalk10.red(`Failed to load or run suite ${file}: ${e}`));
       totalFailed++;
     }
   }
-  console.log(chalk12.dim(`
+  console.log(chalk10.dim(`
 -------------------------------------`));
   if (totalFailed > 0) {
-    console.log(chalk12.red(`FAILED: ${totalFailed} scenarios failed. ${totalPassed} passed.`));
+    console.log(chalk10.red(`FAILED: ${totalFailed} scenarios failed. ${totalPassed} passed.`));
     process.exit(1);
   } else {
-    console.log(chalk12.green(`SUCCESS: All ${totalPassed} scenarios passed.`));
+    console.log(chalk10.green(`SUCCESS: All ${totalPassed} scenarios passed.`));
     process.exit(0);
   }
 });
 
 // src/commands/doctor.ts
 import { Command as Command11 } from "commander";
-import chalk13 from "chalk";
+import chalk11 from "chalk";
 import { execSync as execSync2 } from "child_process";
-import fs11 from "fs";
-import path11 from "path";
-var doctorCommand = new Command11("doctor").description("Check development environment health").option("-v, --verbose", "Show detailed information").action(async (options) => {
+import fs10 from "fs";
+import path10 from "path";
+function detectCircularDependencies(objects) {
+  const issues = [];
+  const graph = /* @__PURE__ */ new Map();
+  for (const obj of objects) {
+    const deps = [];
+    if (obj.fields && typeof obj.fields === "object") {
+      for (const field of Object.values(obj.fields)) {
+        if (field?.type === "lookup" && field?.reference) {
+          deps.push(field.reference);
+        }
+      }
+    }
+    graph.set(obj.name, deps);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  function dfs(node, path11) {
+    if (stack.has(node)) {
+      const cycleStart = path11.indexOf(node);
+      const cycle = path11.slice(cycleStart).concat(node);
+      issues.push(`Circular dependency: ${cycle.join(" \u2192 ")}`);
+      return true;
+    }
+    if (visited.has(node)) return false;
+    visited.add(node);
+    stack.add(node);
+    for (const dep of graph.get(node) || []) {
+      if (graph.has(dep)) {
+        dfs(dep, [...path11, node]);
+      }
+    }
+    stack.delete(node);
+    return false;
+  }
+  for (const name of graph.keys()) {
+    if (!visited.has(name)) {
+      dfs(name, []);
+    }
+  }
+  return issues;
+}
+function findOrphanViews(config) {
+  const objectNames = /* @__PURE__ */ new Set();
+  if (Array.isArray(config.objects)) {
+    for (const obj of config.objects) {
+      if (obj.name) objectNames.add(obj.name);
+    }
+  }
+  const orphans = [];
+  if (Array.isArray(config.views)) {
+    for (const view of config.views) {
+      if (view.object && !objectNames.has(view.object)) {
+        orphans.push(`View "${view.name || "?"}" references non-existent object "${view.object}"`);
+      }
+    }
+  }
+  return orphans;
+}
+function findUnusedObjects(config) {
+  const objectNames = /* @__PURE__ */ new Set();
+  if (Array.isArray(config.objects)) {
+    for (const obj of config.objects) {
+      if (obj.name) objectNames.add(obj.name);
+    }
+  }
+  const referencedObjects = /* @__PURE__ */ new Set();
+  if (Array.isArray(config.views)) {
+    for (const view of config.views) {
+      if (view.object) referencedObjects.add(view.object);
+    }
+  }
+  if (Array.isArray(config.flows)) {
+    for (const flow of config.flows) {
+      if (flow.trigger?.object) referencedObjects.add(flow.trigger.object);
+      if (flow.object) referencedObjects.add(flow.object);
+    }
+  }
+  if (Array.isArray(config.apps)) {
+    for (const app of config.apps) {
+      if (Array.isArray(app.navigation)) {
+        for (const nav of app.navigation) {
+          if (nav.object) referencedObjects.add(nav.object);
+        }
+      }
+    }
+  }
+  if (Array.isArray(config.agents)) {
+    for (const agent of config.agents) {
+      if (Array.isArray(agent.objects)) {
+        for (const o of agent.objects) referencedObjects.add(o);
+      }
+    }
+  }
+  if (Array.isArray(config.objects)) {
+    for (const obj of config.objects) {
+      if (obj.fields && typeof obj.fields === "object") {
+        for (const field of Object.values(obj.fields)) {
+          if (field?.type === "lookup" && field?.reference) {
+            referencedObjects.add(field.reference);
+          }
+        }
+      }
+    }
+  }
+  const unused = [];
+  for (const name of objectNames) {
+    if (!referencedObjects.has(name)) {
+      unused.push(`Object "${name}" is defined but not referenced by any view, flow, app, or agent`);
+    }
+  }
+  return unused;
+}
+function walkDir(dir, ext) {
+  const results = [];
+  if (!fs10.existsSync(dir)) return results;
+  const entries = fs10.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "node_modules") continue;
+    const fullPath = path10.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walkDir(fullPath, ext));
+    } else if (entry.name.endsWith(ext)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+function findMissingTests(cwd) {
+  const specSrcDir = path10.join(cwd, "packages/spec/src");
+  if (!fs10.existsSync(specSrcDir)) return [];
+  const missing = [];
+  const zodFiles = walkDir(specSrcDir, ".zod.ts");
+  for (const zodFile of zodFiles) {
+    const testFile = zodFile.replace(".zod.ts", ".test.ts");
+    if (!fs10.existsSync(testFile)) {
+      const relZod = path10.relative(specSrcDir, zodFile);
+      const relTest = path10.relative(specSrcDir, testFile);
+      missing.push(`Missing test: ${relTest} (for ${relZod})`);
+    }
+  }
+  return missing;
+}
+function findDeprecatedUsages(cwd) {
+  const specSrcDir = path10.join(cwd, "packages/spec/src");
+  if (!fs10.existsSync(specSrcDir)) return [];
+  const deprecated = [];
+  const tsFiles = walkDir(specSrcDir, ".ts").filter((f) => !f.endsWith(".test.ts"));
+  for (const tsFile of tsFiles) {
+    try {
+      const content = fs10.readFileSync(tsFile, "utf-8");
+      const lines = content.split("\n");
+      const relPath = path10.relative(specSrcDir, tsFile);
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].includes("@deprecated")) {
+          deprecated.push(`${relPath}:${i + 1} \u2014 @deprecated tag found`);
+        }
+      }
+    } catch {
+    }
+  }
+  return deprecated;
+}
+var DEPRECATED_PATTERNS = [
+  {
+    pattern: /\bEnhancedObjectKernel\b/,
+    description: "EnhancedObjectKernel is deprecated in v3",
+    replacement: "Use ObjectKernel instead"
+  },
+  {
+    pattern: /\bmax_length\b/,
+    description: "snake_case config key: max_length",
+    replacement: "Use maxLength (camelCase)"
+  },
+  {
+    pattern: /\bdefault_value\b/,
+    description: "snake_case config key: default_value",
+    replacement: "Use defaultValue (camelCase)"
+  },
+  {
+    pattern: /\bmin_length\b/,
+    description: "snake_case config key: min_length",
+    replacement: "Use minLength (camelCase)"
+  },
+  {
+    pattern: /\breference_filters\b/,
+    description: "snake_case config key: reference_filters",
+    replacement: "Use referenceFilters (camelCase)"
+  },
+  {
+    pattern: /\bunique_name\b/,
+    description: "snake_case config key: unique_name",
+    replacement: "Use uniqueName (camelCase)"
+  },
+  {
+    pattern: /from\s+['"]@objectstack\/core\/enhanced['"]/,
+    description: "Import from deprecated @objectstack/core/enhanced path",
+    replacement: "Use import from '@objectstack/core'"
+  },
+  {
+    pattern: /from\s+['"]@objectstack\/spec\/dist\/[^'"]+['"]/,
+    description: "Import from deprecated @objectstack/spec/dist/ deep path",
+    replacement: "Use import from '@objectstack/spec'"
+  }
+];
+function scanDeprecatedPatterns(dir) {
+  const results = [];
+  if (!fs10.existsSync(dir)) return results;
+  const tsFiles = walkDir(dir, ".ts").filter((f) => !f.endsWith(".test.ts"));
+  for (const tsFile of tsFiles) {
+    try {
+      const content = fs10.readFileSync(tsFile, "utf-8");
+      const lines = content.split("\n");
+      const relPath = path10.relative(process.cwd(), tsFile);
+      for (let i = 0; i < lines.length; i++) {
+        for (const dp of DEPRECATED_PATTERNS) {
+          if (dp.pattern.test(lines[i])) {
+            results.push({
+              file: relPath,
+              line: i + 1,
+              description: dp.description,
+              replacement: dp.replacement
+            });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+var doctorCommand = new Command11("doctor").description("Check development environment and configuration health").option("-v, --verbose", "Show detailed information").option("--scan-deprecations", "Scan for deprecated ObjectStack patterns").action(async (options) => {
   printHeader("Environment Health Check");
   const results = [];
   try {
@@ -2010,8 +2538,8 @@ var doctorCommand = new Command11("doctor").description("Check development envir
     });
   }
   const cwd = process.cwd();
-  const nodeModulesPath = path11.join(cwd, "node_modules");
-  if (fs11.existsSync(nodeModulesPath)) {
+  const nodeModulesPath = path10.join(cwd, "node_modules");
+  if (fs10.existsSync(nodeModulesPath)) {
     results.push({
       name: "Dependencies",
       status: "ok",
@@ -2025,8 +2553,8 @@ var doctorCommand = new Command11("doctor").description("Check development envir
       fix: "Run: pnpm install"
     });
   }
-  const specDistPath = path11.join(cwd, "packages/spec/dist");
-  if (fs11.existsSync(specDistPath)) {
+  const specDistPath = path10.join(cwd, "packages/spec/dist");
+  if (fs10.existsSync(specDistPath)) {
     results.push({
       name: "@objectstack/spec",
       status: "ok",
@@ -2068,27 +2596,108 @@ var doctorCommand = new Command11("doctor").description("Check development envir
       printError(`${padded} ${result.message}`);
     }
     if (result.fix && (options.verbose || result.status === "error")) {
-      console.log(chalk13.dim(`      \u2192 ${result.fix}`));
+      console.log(chalk11.dim(`      \u2192 ${result.fix}`));
     }
     if (result.status === "error") hasErrors = true;
     if (result.status === "warning") hasWarnings = true;
   });
+  printStep("Checking for missing test files...");
+  const missingTests = findMissingTests(cwd);
+  if (missingTests.length > 0) {
+    hasWarnings = true;
+    for (const msg of missingTests) {
+      printWarning(msg);
+    }
+  } else {
+    printSuccess("Test coverage         All *.zod.ts files have matching tests");
+  }
+  printStep("Scanning for @deprecated usage...");
+  const deprecatedUsages = findDeprecatedUsages(cwd);
+  if (deprecatedUsages.length > 0) {
+    hasWarnings = true;
+    for (const msg of deprecatedUsages) {
+      printWarning(`Deprecated: ${msg}`);
+    }
+  } else {
+    printSuccess("Deprecations          No @deprecated tags found");
+  }
+  if (configExists()) {
+    printStep("Loading configuration for analysis...");
+    try {
+      const { config } = await loadConfig();
+      if (Array.isArray(config.objects) && config.objects.length > 0) {
+        printStep("Checking for circular dependencies...");
+        const cycles = detectCircularDependencies(config.objects);
+        if (cycles.length > 0) {
+          hasWarnings = true;
+          for (const msg of cycles) {
+            printWarning(msg);
+          }
+        } else {
+          printSuccess("Dependencies          No circular references detected");
+        }
+        printStep("Checking for unused objects...");
+        const unused = findUnusedObjects(config);
+        if (unused.length > 0) {
+          hasWarnings = true;
+          for (const msg of unused) {
+            printWarning(msg);
+          }
+        } else {
+          printSuccess("Object usage          All objects are referenced");
+        }
+      }
+      if (Array.isArray(config.views) && config.views.length > 0) {
+        printStep("Checking for orphan views...");
+        const orphans = findOrphanViews(config);
+        if (orphans.length > 0) {
+          hasWarnings = true;
+          for (const msg of orphans) {
+            printWarning(msg);
+          }
+        } else {
+          printSuccess("View integrity        All views reference valid objects");
+        }
+      }
+    } catch {
+      printWarning("Could not load config for analysis (config checks skipped)");
+      hasWarnings = true;
+    }
+  }
+  if (options.scanDeprecations) {
+    printStep("Scanning for deprecated ObjectStack patterns...");
+    const scanDir = path10.join(cwd, "src");
+    const deprecations = scanDeprecatedPatterns(scanDir);
+    if (deprecations.length > 0) {
+      hasWarnings = true;
+      for (const dep of deprecations) {
+        printWarning(`${dep.file}:${dep.line} \u2014 ${dep.description}`);
+        if (options.verbose) {
+          console.log(chalk11.dim(`      \u2192 ${dep.replacement}`));
+        }
+      }
+      console.log("");
+      printInfo(`Found ${deprecations.length} deprecated pattern(s). Run \`objectstack codemod v2-to-v3\` to auto-fix.`);
+    } else {
+      printSuccess("Deprecation scan      No deprecated patterns found");
+    }
+  }
   console.log("");
   if (hasErrors) {
-    console.log(chalk13.red("\u274C Some critical issues found. Please fix them before continuing."));
-    results.filter((r) => r.status === "error" && r.fix).forEach((r) => console.log(chalk13.dim(`   ${r.fix}`)));
+    console.log(chalk11.red("\u274C Some critical issues found. Please fix them before continuing."));
+    results.filter((r) => r.status === "error" && r.fix).forEach((r) => console.log(chalk11.dim(`   ${r.fix}`)));
     process.exit(1);
   } else if (hasWarnings) {
-    console.log(chalk13.yellow("\u26A0\uFE0F  Environment is functional but has some warnings."));
-    console.log(chalk13.dim("   Run with --verbose to see fix suggestions."));
+    console.log(chalk11.yellow("\u26A0\uFE0F  Environment is functional but has some warnings."));
+    console.log(chalk11.dim("   Run with --verbose to see fix suggestions."));
   } else {
-    console.log(chalk13.green("\u2705 Environment is healthy and ready for development!"));
+    console.log(chalk11.green("\u2705 Environment is healthy and ready for development!"));
   }
   console.log("");
 });
 
 // src/utils/plugin-commands.ts
-import chalk14 from "chalk";
+import chalk12 from "chalk";
 async function loadPluginCommands(program) {
   let config;
   try {
@@ -2132,7 +2741,7 @@ async function loadPluginCommands(program) {
       if (process.env.DEBUG) {
         const message = error instanceof Error ? error.message : String(error);
         console.error(
-          chalk14.yellow(`  \u26A0 Failed to load CLI command '${contribution.name}' from plugin '${contribution.pluginName}': ${message}`)
+          chalk12.yellow(`  \u26A0 Failed to load CLI command '${contribution.name}' from plugin '${contribution.pluginName}': ${message}`)
         );
       }
     }