@objectstack/cli 3.0.0 → 3.0.2

package/dist/bin.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import {
   collectMetadataStats,
+  configExists,
   createTimer,
   formatZodErrors,
   loadConfig,
@@ -18,8 +19,8 @@ import {
 
 // src/bin.ts
 import { createRequire as createRequire2 } from "module";
-import { Command as Command13 } from "commander";
-import chalk13 from "chalk";
+import { Command as Command17 } from "commander";
+import chalk17 from "chalk";
 
 // src/commands/compile.ts
 import { Command } from "commander";
@@ -140,7 +141,237 @@ import chalk3 from "chalk";
 import { execSync as execSync2 } from "child_process";
 import fs3 from "fs";
 import path3 from "path";
-var doctorCommand = new Command3("doctor").description("Check development environment health").option("-v, --verbose", "Show detailed information").action(async (options) => {
+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, path12) {
+    if (stack.has(node)) {
+      const cycleStart = path12.indexOf(node);
+      const cycle = path12.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, [...path12, 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 (!fs3.existsSync(dir)) return results;
+  const entries = fs3.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "node_modules") continue;
+    const fullPath = path3.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 = path3.join(cwd, "packages/spec/src");
+  if (!fs3.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 (!fs3.existsSync(testFile)) {
+      const relZod = path3.relative(specSrcDir, zodFile);
+      const relTest = path3.relative(specSrcDir, testFile);
+      missing.push(`Missing test: ${relTest} (for ${relZod})`);
+    }
+  }
+  return missing;
+}
+function findDeprecatedUsages(cwd) {
+  const specSrcDir = path3.join(cwd, "packages/spec/src");
+  if (!fs3.existsSync(specSrcDir)) return [];
+  const deprecated = [];
+  const tsFiles = walkDir(specSrcDir, ".ts").filter((f) => !f.endsWith(".test.ts"));
+  for (const tsFile of tsFiles) {
+    try {
+      const content = fs3.readFileSync(tsFile, "utf-8");
+      const lines = content.split("\n");
+      const relPath = path3.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 (!fs3.existsSync(dir)) return results;
+  const tsFiles = walkDir(dir, ".ts").filter((f) => !f.endsWith(".test.ts"));
+  for (const tsFile of tsFiles) {
+    try {
+      const content = fs3.readFileSync(tsFile, "utf-8");
+      const lines = content.split("\n");
+      const relPath = path3.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 Command3("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 {
@@ -262,6 +493,87 @@ var doctorCommand = new Command3("doctor").description("Check development enviro
     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 = path3.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(chalk3.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(chalk3.red("\u274C Some critical issues found. Please fix them before continuing."));
@@ -1775,79 +2087,451 @@ var generateTypesCommand = new Command11("types").description("Generate TypeScri
     process.exit(1);
   }
 });
-var generateCommand = new Command11("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).action(async (type, name, options) => {
-  if (!type) {
-    printHeader("Generate");
-    console.log(chalk10.bold("  Sub-commands:"));
-    console.log(`    ${chalk10.cyan("types".padEnd(12))} Generate TypeScript type definitions from config`);
+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 Command11("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-A7BN6UIT.js");
+    const timer = createTimer();
+    printInfo("Loading configuration...");
+    const { config, absolutePath } = await loadConfig2(configPath);
+    console.log(`  ${chalk10.dim("Config:")} ${chalk10.white(absolutePath)}`);
+    console.log(`  ${chalk10.dim("Output:")} ${chalk10.white(options.output)}`);
     console.log("");
-    console.log(chalk10.bold("  Metadata types:"));
-    for (const [key, gen] of Object.entries(GENERATORS)) {
-      console.log(`    ${chalk10.cyan(key.padEnd(12))} ${chalk10.dim(gen.description)}`);
+    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(chalk10.dim(`  ${line}`));
+      }
+      console.log("");
+      return;
+    }
+    const outPath = path9.resolve(process.cwd(), options.output);
+    const outDir = path9.dirname(outPath);
+    if (!fs9.existsSync(outDir)) {
+      fs9.mkdirSync(outDir, { recursive: true });
     }
+    fs9.writeFileSync(outPath, content);
+    printSuccess(`Generated client SDK at ${options.output} (${timer.display()})`);
     console.log("");
-    console.log(chalk10.dim("  Usage: objectstack generate <type> <name>"));
-    console.log(chalk10.dim("  Usage: objectstack generate types [config]"));
-    return;
-  }
-  if (!name) {
-    printError("Missing required argument: <name>");
-    console.log(chalk10.dim("  Usage: objectstack generate <type> <name>"));
+  } catch (error) {
+    printError(error.message || String(error));
     process.exit(1);
   }
-  await generateMetadataCommand.parseAsync([type, name, ...process.argv.slice(4)], { from: "user" });
 });
-
-// src/commands/plugin.ts
-import { Command as Command12 } from "commander";
-import chalk11 from "chalk";
-import fs10 from "fs";
-import path10 from "path";
-function resolvePluginName(plugin) {
-  if (typeof plugin === "string") return plugin;
-  if (plugin && typeof plugin === "object") {
-    const p = plugin;
-    if (typeof p.name === "string") return p.name;
-    if (p.constructor && p.constructor.name !== "Object") return p.constructor.name;
-  }
-  return "unknown";
+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 resolvePluginVersion(plugin) {
-  if (plugin && typeof plugin === "object") {
-    const p = plugin;
-    if (typeof p.version === "string") return p.version;
+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);
+    }
   }
-  return "-";
-}
-function resolvePluginType(plugin) {
-  if (plugin && typeof plugin === "object") {
-    const p = plugin;
-    if (typeof p.type === "string") return p.type;
+  if (objects.length === 0) {
+    lines.push("-- No objects found in configuration");
+    return lines.join("\n") + "\n";
   }
-  return "standard";
-}
-function readConfigText(configPath) {
-  return fs10.readFileSync(configPath, "utf-8");
-}
-function addPluginToConfig(configPath, packageName) {
-  let content = readConfigText(configPath);
-  const shortName = packageName.replace(/^@[^/]+\//, "").replace(/^plugin-/, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
-  const varName = shortName.replace(/-([a-z])/g, (_, c) => c.toUpperCase()) + "Plugin";
-  const importLine = `import ${varName} from '${packageName}';
-`;
-  if (content.includes(packageName)) {
-    throw new Error(`Plugin '${packageName}' is already referenced in the config`);
+  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("");
   }
-  const importRegex = /^import .+$/gm;
-  let lastImportEnd = 0;
-  let match;
-  while ((match = importRegex.exec(content)) !== null) {
-    lastImportEnd = match.index + match[0].length;
+  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 (lastImportEnd > 0) {
-    content = content.slice(0, lastImportEnd) + "\n" + importLine + content.slice(lastImportEnd);
-  } else {
-    content = importLine + "\n" + content;
+  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 Command11("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-A7BN6UIT.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(`  ${chalk10.dim("Config:")} ${chalk10.white(absolutePath)}`);
+    console.log(`  ${chalk10.dim("Format:")} ${chalk10.white(options.format)}`);
+    console.log(`  ${chalk10.dim("Output:")} ${chalk10.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(chalk10.dim(`  ${line}`));
+      }
+      console.log("");
+      return;
+    }
+    const outPath = path9.resolve(process.cwd(), output);
+    const outDir = path9.dirname(outPath);
+    if (!fs9.existsSync(outDir)) {
+      fs9.mkdirSync(outDir, { recursive: true });
+    }
+    fs9.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 Command11("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 = path9.resolve(process.cwd(), options.output);
+    const outDir = path9.dirname(outPath);
+    if (!fs9.existsSync(outDir)) {
+      fs9.mkdirSync(outDir, { recursive: true });
+    }
+    fs9.writeFileSync(outPath, content);
+    printSuccess(`Generated JSON Schema at ${options.output} (${timer.display()})`);
+    console.log("");
+    console.log(chalk10.dim("  Usage: Reference in your IDE or editor for autocomplete"));
+    console.log(chalk10.dim(`  Path:  ${outPath}`));
+    console.log("");
+  } catch (error) {
+    printError(error.message || String(error));
+    process.exit(1);
+  }
+});
+var generateCommand = new Command11("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(chalk10.bold("  Sub-commands:"));
+    console.log(`    ${chalk10.cyan("types".padEnd(12))} Generate TypeScript type definitions from config`);
+    console.log(`    ${chalk10.cyan("client".padEnd(12))} Generate a type-safe client SDK from config`);
+    console.log(`    ${chalk10.cyan("migration".padEnd(12))} Generate database migration from schema`);
+    console.log(`    ${chalk10.cyan("schema".padEnd(12))} Generate JSON Schema for objectstack.config.ts (IDE autocomplete)`);
+    console.log("");
+    console.log(chalk10.bold("  Metadata types:"));
+    for (const [key, gen] of Object.entries(GENERATORS)) {
+      console.log(`    ${chalk10.cyan(key.padEnd(12))} ${chalk10.dim(gen.description)}`);
+    }
+    console.log("");
+    console.log(chalk10.dim("  Usage: objectstack generate <type> <name>"));
+    console.log(chalk10.dim("  Usage: objectstack generate types [config]"));
+    return;
+  }
+  if (!name) {
+    printError("Missing required argument: <name>");
+    console.log(chalk10.dim("  Usage: objectstack generate <type> <name>"));
+    process.exit(1);
+  }
+  await generateMetadataCommand.parseAsync([type, name, ...process.argv.slice(4)], { from: "user" });
+});
+
+// src/commands/plugin.ts
+import { Command as Command12 } from "commander";
+import chalk11 from "chalk";
+import fs10 from "fs";
+import path10 from "path";
+function resolvePluginName(plugin) {
+  if (typeof plugin === "string") return plugin;
+  if (plugin && typeof plugin === "object") {
+    const p = plugin;
+    if (typeof p.name === "string") return p.name;
+    if (p.constructor && p.constructor.name !== "Object") return p.constructor.name;
+  }
+  return "unknown";
+}
+function resolvePluginVersion(plugin) {
+  if (plugin && typeof plugin === "object") {
+    const p = plugin;
+    if (typeof p.version === "string") return p.version;
+  }
+  return "-";
+}
+function resolvePluginType(plugin) {
+  if (plugin && typeof plugin === "object") {
+    const p = plugin;
+    if (typeof p.type === "string") return p.type;
+  }
+  return "standard";
+}
+function readConfigText(configPath) {
+  return fs10.readFileSync(configPath, "utf-8");
+}
+function addPluginToConfig(configPath, packageName) {
+  let content = readConfigText(configPath);
+  const shortName = packageName.replace(/^@[^/]+\//, "").replace(/^plugin-/, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const varName = shortName.replace(/-([a-z])/g, (_, c) => c.toUpperCase()) + "Plugin";
+  const importLine = `import ${varName} from '${packageName}';
+`;
+  if (content.includes(packageName)) {
+    throw new Error(`Plugin '${packageName}' is already referenced in the config`);
+  }
+  const importRegex = /^import .+$/gm;
+  let lastImportEnd = 0;
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    lastImportEnd = match.index + match[0].length;
+  }
+  if (lastImportEnd > 0) {
+    content = content.slice(0, lastImportEnd) + "\n" + importLine + content.slice(lastImportEnd);
+  } else {
+    content = importLine + "\n" + content;
   }
   if (/plugins\s*:\s*\[/.test(content)) {
     let replaced = false;
@@ -2043,8 +2727,897 @@ var removeCommand = new Command12("remove").alias("rm").description("Remove a pl
 });
 var pluginCommand = new Command12("plugin").description("Manage plugins (list, info, add, remove)").addCommand(listCommand).addCommand(infoSubCommand).addCommand(addCommand).addCommand(removeCommand);
 
-// src/utils/plugin-commands.ts
+// src/commands/diff.ts
+import { Command as Command13 } from "commander";
 import chalk12 from "chalk";
+function getNames(items) {
+  const map = /* @__PURE__ */ new Map();
+  if (!Array.isArray(items)) return map;
+  for (const item of items) {
+    if (item?.name) map.set(item.name, item);
+  }
+  return map;
+}
+function getFieldNames(obj) {
+  if (!obj?.fields || typeof obj.fields !== "object") return [];
+  return Object.keys(obj.fields);
+}
+function getFieldType(obj, fieldName) {
+  return obj?.fields?.[fieldName]?.type;
+}
+function isFieldRequired(obj, fieldName) {
+  return obj?.fields?.[fieldName]?.required === true;
+}
+function diffNamedArrays(beforeItems, afterItems, category, detectFieldChanges) {
+  const entries = [];
+  const beforeMap = getNames(beforeItems);
+  const afterMap = getNames(afterItems);
+  for (const [name] of beforeMap) {
+    if (!afterMap.has(name)) {
+      entries.push({
+        type: "removed",
+        category,
+        name,
+        breaking: true
+      });
+    }
+  }
+  for (const [name] of afterMap) {
+    if (!beforeMap.has(name)) {
+      entries.push({
+        type: "added",
+        category,
+        name,
+        breaking: false
+      });
+    }
+  }
+  if (detectFieldChanges) {
+    for (const [name, beforeObj] of beforeMap) {
+      const afterObj = afterMap.get(name);
+      if (!afterObj) continue;
+      const beforeFields = getFieldNames(beforeObj);
+      const afterFields = getFieldNames(afterObj);
+      const beforeSet = new Set(beforeFields);
+      const afterSet = new Set(afterFields);
+      for (const f of beforeFields) {
+        if (!afterSet.has(f)) {
+          entries.push({
+            type: "removed",
+            category: `${category}.${name}.fields`,
+            name: f,
+            breaking: true,
+            detail: "field removed"
+          });
+        }
+      }
+      for (const f of afterFields) {
+        if (!beforeSet.has(f)) {
+          const breaking = isFieldRequired(afterObj, f);
+          entries.push({
+            type: "added",
+            category: `${category}.${name}.fields`,
+            name: f,
+            breaking,
+            detail: breaking ? "required field added" : "optional field added"
+          });
+        }
+      }
+      for (const f of beforeFields) {
+        if (!afterSet.has(f)) continue;
+        const oldType = getFieldType(beforeObj, f);
+        const newType = getFieldType(afterObj, f);
+        if (oldType && newType && oldType !== newType) {
+          entries.push({
+            type: "modified",
+            category: `${category}.${name}.fields`,
+            name: f,
+            breaking: true,
+            detail: `type changed: ${oldType} \u2192 ${newType}`
+          });
+        }
+      }
+      if (beforeObj.label !== afterObj.label) {
+        entries.push({
+          type: "modified",
+          category,
+          name,
+          breaking: false,
+          detail: `label changed: "${beforeObj.label ?? "(none)"}" \u2192 "${afterObj.label ?? "(none)"}"`
+        });
+      }
+    }
+  }
+  return entries;
+}
+var diffCommand = new Command13("diff").description("Compare two ObjectStack configurations and detect breaking changes").argument("[before]", 'Path to the "before" config file').argument("[after]", 'Path to the "after" config file').option("--before <path>", 'Path to the "before" config (alternative)').option("--after <path>", 'Path to the "after" config (alternative)').option("--json", "Output as JSON").option("--breaking-only", "Show only breaking changes").action(async (beforeArg, afterArg, options) => {
+  const timer = createTimer();
+  const beforePath = beforeArg || options.before;
+  const afterPath = afterArg || options.after;
+  if (!beforePath || !afterPath) {
+    printError("Two config file paths are required.");
+    console.log("");
+    console.log(chalk12.dim("  Usage: objectstack diff <before> <after>"));
+    console.log(chalk12.dim("     or: objectstack diff --before path1 --after path2"));
+    process.exit(1);
+  }
+  if (!options.json) {
+    printHeader("Diff");
+    printStep("Loading configurations...");
+  }
+  try {
+    const { config: beforeConfig } = await loadConfig(beforePath);
+    const { config: afterConfig } = await loadConfig(afterPath);
+    if (!options.json) {
+      printInfo(`Before: ${chalk12.white(beforePath)}`);
+      printInfo(`After:  ${chalk12.white(afterPath)}`);
+    }
+    const allDiffs = [];
+    allDiffs.push(...diffNamedArrays(beforeConfig.objects, afterConfig.objects, "objects", true));
+    const simpleCats = [
+      { key: "views", label: "views" },
+      { key: "flows", label: "flows" },
+      { key: "agents", label: "agents" },
+      { key: "apps", label: "apps" },
+      { key: "dashboards", label: "dashboards" },
+      { key: "actions", label: "actions" },
+      { key: "workflows", label: "workflows" },
+      { key: "apis", label: "apis" },
+      { key: "roles", label: "roles" }
+    ];
+    for (const cat of simpleCats) {
+      allDiffs.push(
+        ...diffNamedArrays(beforeConfig[cat.key], afterConfig[cat.key], cat.label, false)
+      );
+    }
+    const diffs = options.breakingOnly ? allDiffs.filter((d) => d.breaking) : allDiffs;
+    const breakingCount = allDiffs.filter((d) => d.breaking).length;
+    if (options.json) {
+      console.log(JSON.stringify({
+        before: beforePath,
+        after: afterPath,
+        total: diffs.length,
+        breaking: breakingCount,
+        changes: diffs,
+        duration: timer.elapsed()
+      }, null, 2));
+      return;
+    }
+    console.log("");
+    if (diffs.length === 0) {
+      printSuccess(options.breakingOnly ? "No breaking changes detected." : "No changes detected.");
+      console.log("");
+      return;
+    }
+    const grouped = /* @__PURE__ */ new Map();
+    for (const d of diffs) {
+      const key = d.category;
+      if (!grouped.has(key)) grouped.set(key, []);
+      grouped.get(key).push(d);
+    }
+    for (const [category, items] of grouped) {
+      console.log(`  ${chalk12.bold(category)}`);
+      for (const item of items) {
+        const icon = item.type === "added" ? "+" : item.type === "removed" ? "-" : "~";
+        const color = item.type === "added" ? chalk12.green : item.type === "removed" ? chalk12.red : chalk12.yellow;
+        const breakingTag = item.breaking ? chalk12.bgRed.white(" BREAKING ") + " " : "";
+        const detail = item.detail ? chalk12.dim(` (${item.detail})`) : "";
+        console.log(`    ${color(icon)} ${breakingTag}${color(item.name)}${detail}`);
+      }
+      console.log("");
+    }
+    if (breakingCount > 0) {
+      printError(`${breakingCount} breaking change(s) detected`);
+    } else {
+      printSuccess("No breaking changes");
+    }
+    console.log(chalk12.dim(`  ${diffs.length} total change(s) in ${timer.display()}`));
+    console.log("");
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: error.message }));
+      process.exit(1);
+    }
+    console.log("");
+    printError(error.message || String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/lint.ts
+import { Command as Command14 } from "commander";
+import chalk13 from "chalk";
+var SNAKE_CASE_RE = /^[a-z][a-z0-9_]*$/;
+function checkSnakeCase(value, path12, label) {
+  if (!SNAKE_CASE_RE.test(value)) {
+    return {
+      severity: "error",
+      rule: "naming/snake-case",
+      message: `${label} "${value}" must be snake_case`,
+      path: path12,
+      fix: value.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").toLowerCase().replace(/^_/, "").replace(/-/g, "_")
+    };
+  }
+  return null;
+}
+function checkLabelExists(item, path12, kind) {
+  if (!item.label) {
+    return {
+      severity: "error",
+      rule: "required/label",
+      message: `${kind} "${item.name || "?"}" is missing a label`,
+      path: path12
+    };
+  }
+  return null;
+}
+function checkLabelCase(label, path12) {
+  if (label && label[0] !== label[0].toUpperCase()) {
+    return {
+      severity: "warning",
+      rule: "convention/label-case",
+      message: `Label "${label}" should start with an uppercase letter`,
+      path: path12,
+      fix: label.charAt(0).toUpperCase() + label.slice(1)
+    };
+  }
+  return null;
+}
+function lintConfig(config) {
+  const issues = [];
+  const push = (issue) => {
+    if (issue) issues.push(issue);
+  };
+  const objects = Array.isArray(config.objects) ? config.objects : [];
+  for (let i = 0; i < objects.length; i++) {
+    const obj = objects[i];
+    const objPath = `objects[${i}]`;
+    if (obj.name) {
+      push(checkSnakeCase(obj.name, `${objPath}.name`, "Object name"));
+    }
+    push(checkLabelExists(obj, `${objPath}.label`, "Object"));
+    if (obj.label) {
+      push(checkLabelCase(obj.label, `${objPath}.label`));
+    }
+    if (obj.fields && typeof obj.fields === "object") {
+      const fieldNames = Object.keys(obj.fields);
+      if (fieldNames.length === 0) {
+        issues.push({
+          severity: "warning",
+          rule: "structure/empty-fields",
+          message: `Object "${obj.name || "?"}" has an empty fields map`,
+          path: `${objPath}.fields`
+        });
+      }
+      for (const fieldName of fieldNames) {
+        const field = obj.fields[fieldName];
+        const fieldPath = `${objPath}.fields.${fieldName}`;
+        push(checkSnakeCase(fieldName, fieldPath, "Field name"));
+        if (field && typeof field === "object") {
+          push(checkLabelExists({ ...field, name: fieldName }, `${fieldPath}.label`, "Field"));
+          if (field.label) {
+            push(checkLabelCase(field.label, `${fieldPath}.label`));
+          }
+        }
+      }
+    } else if (!obj.fields) {
+      issues.push({
+        severity: "error",
+        rule: "structure/no-fields",
+        message: `Object "${obj.name || "?"}" has no fields defined`,
+        path: `${objPath}.fields`
+      });
+    }
+  }
+  const views = Array.isArray(config.views) ? config.views : [];
+  for (let i = 0; i < views.length; i++) {
+    const view = views[i];
+    const viewPath = `views[${i}]`;
+    if (view.name) {
+      push(checkSnakeCase(view.name, `${viewPath}.name`, "View name"));
+    }
+    push(checkLabelExists(view, `${viewPath}.label`, "View"));
+    if (view.label) {
+      push(checkLabelCase(view.label, `${viewPath}.label`));
+    }
+  }
+  const apps = Array.isArray(config.apps) ? config.apps : [];
+  for (let i = 0; i < apps.length; i++) {
+    const app = apps[i];
+    const appPath = `apps[${i}]`;
+    if (app.name) {
+      push(checkSnakeCase(app.name, `${appPath}.name`, "App name"));
+    }
+    push(checkLabelExists(app, `${appPath}.label`, "App"));
+    if (app.label) {
+      push(checkLabelCase(app.label, `${appPath}.label`));
+    }
+  }
+  const flows = Array.isArray(config.flows) ? config.flows : [];
+  for (let i = 0; i < flows.length; i++) {
+    const flow = flows[i];
+    const flowPath = `flows[${i}]`;
+    if (flow.name) {
+      push(checkSnakeCase(flow.name, `${flowPath}.name`, "Flow name"));
+    }
+  }
+  const agents = Array.isArray(config.agents) ? config.agents : [];
+  for (let i = 0; i < agents.length; i++) {
+    const agent = agents[i];
+    const agentPath = `agents[${i}]`;
+    if (agent.name) {
+      push(checkSnakeCase(agent.name, `${agentPath}.name`, "Agent name"));
+    }
+  }
+  return issues;
+}
+var lintCommand = new Command14("lint").description("Check ObjectStack configuration for style and convention issues").argument("[config]", "Configuration file path").option("--json", "Output as JSON").option("--fix", "Show what would be fixed (dry-run)").action(async (configPath, options) => {
+  const timer = createTimer();
+  if (!options.json) {
+    printHeader("Lint");
+    printStep("Loading configuration...");
+  }
+  try {
+    const { config, absolutePath } = await loadConfig(configPath);
+    if (!options.json) {
+      printInfo(`Config: ${chalk13.white(absolutePath)}`);
+    }
+    const issues = lintConfig(config);
+    if (options.json) {
+      const errors2 = issues.filter((i) => i.severity === "error");
+      const warnings2 = issues.filter((i) => i.severity === "warning");
+      const suggestions2 = issues.filter((i) => i.severity === "suggestion");
+      console.log(JSON.stringify({
+        passed: errors2.length === 0,
+        total: issues.length,
+        errors: errors2.length,
+        warnings: warnings2.length,
+        suggestions: suggestions2.length,
+        issues,
+        duration: timer.elapsed()
+      }, null, 2));
+      if (errors2.length > 0) process.exit(1);
+      return;
+    }
+    console.log("");
+    if (issues.length === 0) {
+      printSuccess(`All checks passed ${chalk13.dim(`(${timer.display()})`)}`);
+      console.log("");
+      return;
+    }
+    const errors = issues.filter((i) => i.severity === "error");
+    const warnings = issues.filter((i) => i.severity === "warning");
+    const suggestions = issues.filter((i) => i.severity === "suggestion");
+    const printIssue = (issue) => {
+      const color = issue.severity === "error" ? chalk13.red : issue.severity === "warning" ? chalk13.yellow : chalk13.blue;
+      const icon = issue.severity === "error" ? "\u2717" : issue.severity === "warning" ? "\u26A0" : "\u2139";
+      console.log(`  ${color(icon)} ${color(issue.message)}`);
+      console.log(chalk13.dim(`    ${issue.rule}  at ${issue.path}`));
+      if (options.fix && issue.fix) {
+        console.log(chalk13.green(`    \u2192 fix: ${issue.fix}`));
+      }
+    };
+    if (errors.length > 0) {
+      console.log(chalk13.bold.red(`  Errors (${errors.length})`));
+      errors.forEach(printIssue);
+      console.log("");
+    }
+    if (warnings.length > 0) {
+      console.log(chalk13.bold.yellow(`  Warnings (${warnings.length})`));
+      warnings.forEach(printIssue);
+      console.log("");
+    }
+    if (suggestions.length > 0) {
+      console.log(chalk13.bold.blue(`  Suggestions (${suggestions.length})`));
+      suggestions.forEach(printIssue);
+      console.log("");
+    }
+    const parts = [];
+    if (errors.length > 0) parts.push(chalk13.red(`${errors.length} error(s)`));
+    if (warnings.length > 0) parts.push(chalk13.yellow(`${warnings.length} warning(s)`));
+    if (suggestions.length > 0) parts.push(chalk13.blue(`${suggestions.length} suggestion(s)`));
+    console.log(`  ${parts.join(", ")} ${chalk13.dim(`(${timer.display()})`)}`);
+    if (options.fix) {
+      console.log("");
+      printInfo("Dry-run mode: no files were modified.");
+    }
+    console.log("");
+    if (errors.length > 0) process.exit(1);
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: error.message }));
+      process.exit(1);
+    }
+    console.log("");
+    printError(error.message || String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/explain.ts
+import { Command as Command15 } from "commander";
+import chalk14 from "chalk";
+var SCHEMAS = {
+  object: {
+    name: "Object",
+    description: "Defines a data entity in the ObjectStack data model. Objects contain fields, enable capabilities, and form the foundation of the metadata-driven platform.",
+    required: [
+      { name: "name", type: "string (snake_case)", description: "Machine name identifier" },
+      { name: "fields", type: "Record<string, Field>", description: "Map of field definitions" }
+    ],
+    optional: [
+      { name: "label", type: "string", description: "Human-readable display name" },
+      { name: "pluralLabel", type: "string", description: "Plural display name" },
+      { name: "description", type: "string", description: "Documentation for the object" },
+      { name: "ownership", type: '"own" | "extend"', description: "Whether this object is owned or extended" },
+      { name: "enable", type: "ObjectCapabilities", description: "Feature flags (trackHistory, apiEnabled, etc.)" },
+      { name: "icon", type: "string", description: "Icon identifier for UI display" }
+    ],
+    example: `{
+  name: 'project_task',
+  label: 'Project Task',
+  fields: {
+    title: { type: 'text', label: 'Title', required: true },
+    status: { type: 'select', label: 'Status', options: ['open', 'closed'] },
+    assigned_to: { type: 'lookup', label: 'Assigned To', reference: 'user' },
+  },
+  enable: { trackHistory: true, apiEnabled: true },
+}`,
+    related: ["field", "view", "flow", "query"],
+    docsPath: "data/object"
+  },
+  field: {
+    name: "Field",
+    description: "Defines a property on an Object. Fields have types that control validation, storage, and UI rendering.",
+    required: [
+      { name: "type", type: "FieldType", description: "Field data type (text, number, boolean, select, lookup, etc.)" }
+    ],
+    optional: [
+      { name: "label", type: "string", description: "Human-readable display name" },
+      { name: "required", type: "boolean", description: "Whether the field is mandatory" },
+      { name: "multiple", type: "boolean", description: "Whether the field holds an array of values" },
+      { name: "defaultValue", type: "any", description: "Default value for new records" },
+      { name: "maxLength", type: "number", description: "Maximum character length (text fields)" },
+      { name: "reference", type: "string", description: "Target object name (lookup fields)" },
+      { name: "options", type: "string[]", description: "Available choices (select fields)" }
+    ],
+    example: `{
+  type: 'text',
+  label: 'Email Address',
+  required: true,
+  maxLength: 255,
+}`,
+    related: ["object", "view", "query"],
+    docsPath: "data/field"
+  },
+  view: {
+    name: "View",
+    description: "Defines how data is displayed and interacted with. Views can be list views (grid, kanban, calendar) or form views (simple, tabbed, wizard).",
+    required: [
+      { name: "name", type: "string (snake_case)", description: "Machine name identifier" },
+      { name: "object", type: "string", description: "Target object to display" },
+      { name: "type", type: '"list" | "form"', description: "View category" }
+    ],
+    optional: [
+      { name: "label", type: "string", description: "Display name" },
+      { name: "layout", type: '"grid" | "kanban" | "calendar" | "gantt" | "simple" | "tabbed" | "wizard"', description: "Layout style" },
+      { name: "columns", type: "string[]", description: "Visible fields for list views" },
+      { name: "filters", type: "Filter[]", description: "Default query filters" },
+      { name: "sort", type: "SortConfig", description: "Default sort configuration" }
+    ],
+    example: `{
+  name: 'task_board',
+  object: 'project_task',
+  type: 'list',
+  label: 'Task Board',
+  layout: 'kanban',
+  columns: ['title', 'status', 'assigned_to'],
+}`,
+    related: ["object", "app", "action", "dashboard"],
+    docsPath: "ui/view"
+  },
+  flow: {
+    name: "Flow",
+    description: "Visual logic orchestration for business processes. Flows can be auto-launched, screen-based, or scheduled.",
+    required: [
+      { name: "name", type: "string (snake_case)", description: "Machine name identifier" },
+      { name: "type", type: '"autolaunched" | "screen" | "schedule"', description: "Trigger type" }
+    ],
+    optional: [
+      { name: "label", type: "string", description: "Display name" },
+      { name: "description", type: "string", description: "Documentation for the flow" },
+      { name: "trigger", type: "TriggerConfig", description: "Event that starts the flow" },
+      { name: "steps", type: "FlowStep[]", description: "Sequence of actions" },
+      { name: "variables", type: "Variable[]", description: "Flow-scoped variables" }
+    ],
+    example: `{
+  name: 'assign_on_create',
+  type: 'autolaunched',
+  label: 'Auto-Assign on Create',
+  trigger: { object: 'project_task', event: 'afterInsert' },
+  steps: [
+    { type: 'assignment', field: 'assigned_to', value: '$currentUser' },
+  ],
+}`,
+    related: ["object", "trigger", "workflow", "agent"],
+    docsPath: "automation/flow"
+  },
+  agent: {
+    name: "Agent",
+    description: "Autonomous AI actor that can perform tasks using tools, instructions, and context from the ObjectStack data model.",
+    required: [
+      { name: "name", type: "string (snake_case)", description: "Machine name identifier" },
+      { name: "role", type: "string", description: "Agent purpose description" }
+    ],
+    optional: [
+      { name: "instructions", type: "string", description: "System prompt / behavioral instructions" },
+      { name: "tools", type: "ToolReference[]", description: "Tools the agent can invoke" },
+      { name: "model", type: "string", description: "LLM model to use" },
+      { name: "objects", type: "string[]", description: "Objects the agent can access" },
+      { name: "temperature", type: "number", description: "Creativity parameter (0-1)" }
+    ],
+    example: `{
+  name: 'support_agent',
+  role: 'Customer Support Assistant',
+  instructions: 'Help users resolve issues by searching the knowledge base.',
+  tools: [{ name: 'query', object: 'knowledge_article' }],
+  model: 'gpt-4o',
+}`,
+    related: ["object", "flow", "query"],
+    docsPath: "ai/agent"
+  },
+  app: {
+    name: "App",
+    description: "Application shell that groups navigation, branding, and views into a cohesive user experience.",
+    required: [
+      { name: "name", type: "string (snake_case)", description: "Machine name identifier" }
+    ],
+    optional: [
+      { name: "label", type: "string", description: "Display name" },
+      { name: "description", type: "string", description: "App description" },
+      { name: "navigation", type: "NavItem[]", description: "Menu tree structure" },
+      { name: "logo", type: "string", description: "Logo URL or asset path" },
+      { name: "theme", type: "string", description: "Theme reference" },
+      { name: "defaultRoute", type: "string", description: "Landing page route" }
+    ],
+    example: `{
+  name: 'project_manager',
+  label: 'Project Manager',
+  navigation: [
+    { type: 'object', object: 'project_task', label: 'Tasks' },
+    { type: 'dashboard', dashboard: 'project_overview', label: 'Overview' },
+  ],
+}`,
+    related: ["view", "dashboard", "action", "object"],
+    docsPath: "ui/app"
+  },
+  query: {
+    name: "Query",
+    description: "Declarative data retrieval definition used for fetching and filtering records from objects.",
+    required: [
+      { name: "object", type: "string", description: "Target object to query" }
+    ],
+    optional: [
+      { name: "fields", type: "string[]", description: "Fields to select" },
+      { name: "filters", type: "Filter[]", description: "Where conditions" },
+      { name: "sort", type: "SortConfig[]", description: "Order by configuration" },
+      { name: "limit", type: "number", description: "Maximum records to return" },
+      { name: "offset", type: "number", description: "Pagination offset" }
+    ],
+    example: `{
+  object: 'project_task',
+  fields: ['title', 'status', 'assigned_to'],
+  filters: [{ field: 'status', operator: 'eq', value: 'open' }],
+  sort: [{ field: 'created_at', direction: 'desc' }],
+  limit: 50,
+}`,
+    related: ["object", "field", "view"],
+    docsPath: "data/query"
+  },
+  dashboard: {
+    name: "Dashboard",
+    description: "Grid-layout container for widgets that display aggregated data, charts, and key metrics.",
+    required: [
+      { name: "name", type: "string (snake_case)", description: "Machine name identifier" }
+    ],
+    optional: [
+      { name: "label", type: "string", description: "Display name" },
+      { name: "widgets", type: "Widget[]", description: "Dashboard widget definitions" },
+      { name: "layout", type: "GridLayout", description: "Widget positioning" },
+      { name: "refreshInterval", type: "number", description: "Auto-refresh interval in seconds" }
+    ],
+    example: `{
+  name: 'project_overview',
+  label: 'Project Overview',
+  widgets: [
+    { type: 'chart', object: 'project_task', groupBy: 'status' },
+    { type: 'metric', object: 'project_task', aggregate: 'count' },
+  ],
+}`,
+    related: ["app", "view", "object"],
+    docsPath: "ui/dashboard"
+  },
+  action: {
+    name: "Action",
+    description: "User-triggered operation such as a button click, URL redirect, or screen flow launch.",
+    required: [
+      { name: "name", type: "string (snake_case)", description: "Machine name identifier" },
+      { name: "type", type: '"button" | "url" | "flow" | "api"', description: "Action type" }
+    ],
+    optional: [
+      { name: "label", type: "string", description: "Display text" },
+      { name: "icon", type: "string", description: "Button icon" },
+      { name: "object", type: "string", description: "Target object context" },
+      { name: "flow", type: "string", description: "Flow to launch (for flow actions)" },
+      { name: "url", type: "string", description: "Target URL (for url actions)" },
+      { name: "confirmation", type: "string", description: "Confirmation dialog message" }
+    ],
+    example: `{
+  name: 'close_task',
+  type: 'flow',
+  label: 'Close Task',
+  object: 'project_task',
+  flow: 'close_task_flow',
+  confirmation: 'Are you sure you want to close this task?',
+}`,
+    related: ["flow", "view", "app"],
+    docsPath: "ui/action"
+  },
+  workflow: {
+    name: "Workflow",
+    description: "State machine and approval process that governs record lifecycle transitions.",
+    required: [
+      { name: "name", type: "string (snake_case)", description: "Machine name identifier" },
+      { name: "object", type: "string", description: "Target object" }
+    ],
+    optional: [
+      { name: "label", type: "string", description: "Display name" },
+      { name: "states", type: "State[]", description: "Defined workflow states" },
+      { name: "transitions", type: "Transition[]", description: "Allowed state transitions" },
+      { name: "approvers", type: "ApproverConfig", description: "Approval chain configuration" }
+    ],
+    example: `{
+  name: 'task_approval',
+  object: 'project_task',
+  label: 'Task Approval',
+  states: ['draft', 'pending', 'approved', 'rejected'],
+  transitions: [
+    { from: 'draft', to: 'pending', action: 'submit' },
+    { from: 'pending', to: 'approved', action: 'approve' },
+    { from: 'pending', to: 'rejected', action: 'reject' },
+  ],
+}`,
+    related: ["object", "flow", "action"],
+    docsPath: "automation/workflow"
+  },
+  trigger: {
+    name: "Trigger",
+    description: "Event-driven automation hook that fires when specific data events occur on an object.",
+    required: [
+      { name: "name", type: "string (snake_case)", description: "Machine name identifier" },
+      { name: "object", type: "string", description: "Target object to monitor" },
+      { name: "event", type: '"beforeInsert" | "afterInsert" | "beforeUpdate" | "afterUpdate" | "beforeDelete" | "afterDelete"', description: "Event type" }
+    ],
+    optional: [
+      { name: "label", type: "string", description: "Display name" },
+      { name: "condition", type: "FilterExpression", description: "Conditional guard" },
+      { name: "flow", type: "string", description: "Flow to execute" },
+      { name: "async", type: "boolean", description: "Whether to execute asynchronously" }
+    ],
+    example: `{
+  name: 'task_created_notify',
+  object: 'project_task',
+  event: 'afterInsert',
+  label: 'Notify on Task Creation',
+  flow: 'send_task_notification',
+  async: true,
+}`,
+    related: ["object", "flow", "workflow"],
+    docsPath: "automation/trigger"
+  }
+};
+var explainCommand = new Command15("explain").description("Display human-readable explanation of an ObjectStack schema").argument("[schema]", "Schema name (e.g., object, field, view, flow, agent, app)").option("--json", "Output as JSON").action(async (schemaName, options) => {
+  if (!schemaName) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        schemas: Object.entries(SCHEMAS).map(([key, s]) => ({
+          name: key,
+          description: s.description
+        }))
+      }, null, 2));
+      return;
+    }
+    printHeader("Available Schemas");
+    console.log("");
+    for (const [key, schema2] of Object.entries(SCHEMAS)) {
+      const desc = schema2.description;
+      console.log(`  ${chalk14.bold.cyan(key.padEnd(12))} ${chalk14.dim(desc.length > 70 ? desc.slice(0, 70) + "..." : desc)}`);
+    }
+    console.log("");
+    printInfo(`Run ${chalk14.white("objectstack explain <schema>")} for details.`);
+    console.log("");
+    return;
+  }
+  const schema = SCHEMAS[schemaName.toLowerCase()];
+  if (!schema) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: `Unknown schema: ${schemaName}` }));
+      process.exit(1);
+    }
+    printError(`Unknown schema: "${schemaName}"`);
+    console.log("");
+    printInfo(`Available schemas: ${Object.keys(SCHEMAS).join(", ")}`);
+    console.log("");
+    process.exit(1);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(schema, null, 2));
+    return;
+  }
+  printHeader(`Schema: ${schema.name}`);
+  console.log("");
+  console.log(`  ${schema.description}`);
+  console.log("");
+  console.log(chalk14.bold("  Required Properties:"));
+  for (const prop of schema.required) {
+    console.log(`    ${chalk14.green(prop.name.padEnd(18))} ${chalk14.dim(prop.type.padEnd(30))} ${prop.description}`);
+  }
+  if (schema.optional.length > 0) {
+    console.log("");
+    console.log(chalk14.bold("  Optional Properties:"));
+    for (const prop of schema.optional) {
+      console.log(`    ${chalk14.yellow(prop.name.padEnd(18))} ${chalk14.dim(prop.type.padEnd(30))} ${prop.description}`);
+    }
+  }
+  console.log("");
+  console.log(chalk14.bold("  Example:"));
+  for (const line of schema.example.split("\n")) {
+    console.log(chalk14.dim(`    ${line}`));
+  }
+  console.log("");
+  printKV("  Related", schema.related.map((r) => chalk14.cyan(r)).join(", "));
+  printKV("  Docs", `https://objectstack.dev/docs/${schema.docsPath}`);
+  console.log("");
+});
+
+// src/commands/codemod.ts
+import { Command as Command16 } from "commander";
+import chalk15 from "chalk";
+import fs11 from "fs";
+import path11 from "path";
+var V2_TO_V3_TRANSFORMS = [
+  {
+    pattern: /\bEnhancedObjectKernel\b/g,
+    replacement: "ObjectKernel",
+    description: "EnhancedObjectKernel \u2192 ObjectKernel"
+  },
+  {
+    pattern: /\bmax_length\b/g,
+    replacement: "maxLength",
+    description: "max_length \u2192 maxLength"
+  },
+  {
+    pattern: /\breference_filters\b/g,
+    replacement: "referenceFilters",
+    description: "reference_filters \u2192 referenceFilters"
+  },
+  {
+    pattern: /\bdefault_value\b/g,
+    replacement: "defaultValue",
+    description: "default_value \u2192 defaultValue"
+  },
+  {
+    pattern: /\bmin_length\b/g,
+    replacement: "minLength",
+    description: "min_length \u2192 minLength"
+  },
+  {
+    pattern: /\bunique_name\b/g,
+    replacement: "uniqueName",
+    description: "unique_name \u2192 uniqueName"
+  },
+  {
+    pattern: /from\s+['"]@objectstack\/core\/enhanced['"]/g,
+    replacement: "from '@objectstack/core'",
+    description: "Update import from @objectstack/core/enhanced"
+  },
+  {
+    pattern: /from\s+['"]@objectstack\/spec\/dist\/[^'"]+['"]/g,
+    replacement: "from '@objectstack/spec'",
+    description: "Update deep import from @objectstack/spec/dist/"
+  }
+];
+function walkDir2(dir, ext) {
+  const results = [];
+  if (!fs11.existsSync(dir)) return results;
+  const entries = fs11.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "node_modules") continue;
+    const fullPath = path11.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walkDir2(fullPath, ext));
+    } else if (entry.name.endsWith(ext)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+var v2ToV3Command = new Command16("v2-to-v3").description("Migrate ObjectStack v2 code patterns to v3").option("--dir <directory>", "Directory to scan", "src/").option("--dry-run", "Show changes without writing files").action(async (options) => {
+  printHeader("Codemod: v2 \u2192 v3");
+  const timer = createTimer();
+  const dir = path11.resolve(process.cwd(), options.dir);
+  if (!fs11.existsSync(dir)) {
+    printError(`Directory not found: ${dir}`);
+    process.exit(1);
+  }
+  console.log(`  ${chalk15.dim("Directory:")} ${chalk15.white(options.dir)}`);
+  console.log(`  ${chalk15.dim("Dry run:")}   ${chalk15.white(options.dryRun ? "yes" : "no")}`);
+  console.log("");
+  printStep("Scanning TypeScript files...");
+  const files = walkDir2(dir, ".ts");
+  if (files.length === 0) {
+    printInfo("No .ts files found in directory");
+    return;
+  }
+  printInfo(`Found ${files.length} TypeScript file(s)`);
+  console.log("");
+  let totalTransforms = 0;
+  let filesModified = 0;
+  const transformCounts = {};
+  for (const file of files) {
+    const original = fs11.readFileSync(file, "utf-8");
+    let content = original;
+    let fileTransforms = 0;
+    for (const transform of V2_TO_V3_TRANSFORMS) {
+      const matches = content.match(transform.pattern);
+      if (matches) {
+        const count = matches.length;
+        content = content.replace(transform.pattern, transform.replacement);
+        fileTransforms += count;
+        transformCounts[transform.description] = (transformCounts[transform.description] || 0) + count;
+      }
+    }
+    if (fileTransforms > 0) {
+      const relPath = path11.relative(process.cwd(), file);
+      filesModified++;
+      totalTransforms += fileTransforms;
+      if (options.dryRun) {
+        printInfo(`${relPath} \u2014 ${fileTransforms} change(s)`);
+      } else {
+        fs11.writeFileSync(file, content);
+        printSuccess(`${relPath} \u2014 ${fileTransforms} change(s)`);
+      }
+    }
+  }
+  console.log("");
+  if (totalTransforms === 0) {
+    printSuccess("No v2 patterns found \u2014 code is already v3 compatible");
+  } else {
+    console.log(chalk15.bold("  Summary:"));
+    for (const [desc, count] of Object.entries(transformCounts)) {
+      console.log(`    ${chalk15.dim(desc)}: ${chalk15.white(count)}`);
+    }
+    console.log("");
+    if (options.dryRun) {
+      printInfo(`Would modify ${filesModified} file(s) with ${totalTransforms} total change(s)`);
+      console.log(chalk15.dim("  Run without --dry-run to apply changes"));
+    } else {
+      printSuccess(`Modified ${filesModified} file(s) with ${totalTransforms} total change(s) (${timer.display()})`);
+    }
+  }
+  console.log("");
+});
+var codemodCommand = new Command16("codemod").description("Run automated code transformations").addCommand(v2ToV3Command).action(() => {
+  printHeader("Codemod");
+  console.log(chalk15.bold("  Available codemods:"));
+  console.log(`    ${chalk15.cyan("v2-to-v3".padEnd(16))} Migrate ObjectStack v2 code patterns to v3`);
+  console.log("");
+  console.log(chalk15.dim("  Usage: objectstack codemod v2-to-v3 [--dir src/] [--dry-run]"));
+  console.log("");
+});
+
+// src/utils/plugin-commands.ts
+import chalk16 from "chalk";
 async function loadPluginCommands(program2) {
   let config;
   try {
@@ -2088,7 +3661,7 @@ async function loadPluginCommands(program2) {
       if (process.env.DEBUG) {
         const message = error instanceof Error ? error.message : String(error);
         console.error(
-          chalk12.yellow(`  \u26A0 Failed to load CLI command '${contribution.name}' from plugin '${contribution.pluginName}': ${message}`)
+          chalk16.yellow(`  \u26A0 Failed to load CLI command '${contribution.name}' from plugin '${contribution.pluginName}': ${message}`)
         );
       }
     }
@@ -2134,30 +3707,30 @@ function resolvePluginName2(plugin) {
 var require2 = createRequire2(import.meta.url);
 var pkg = require2("../package.json");
 process.on("unhandledRejection", (err) => {
-  console.error(chalk13.red(`
+  console.error(chalk17.red(`
   \u2717 Unhandled error: ${err?.message || err}`));
   if (err?.stack && process.env.DEBUG) {
-    console.error(chalk13.dim(err.stack));
+    console.error(chalk17.dim(err.stack));
   }
   process.exit(1);
 });
-var program = new Command13();
+var program = new Command17();
 program.name("objectstack").description("ObjectStack CLI \u2014 Build metadata-driven apps with the ObjectStack Protocol").version(pkg.version, "-v, --version").configureHelp({
   sortSubcommands: false
 }).addHelpText("before", `
-${chalk13.bold.cyan("\u25C6 ObjectStack CLI")} ${chalk13.dim(`v${pkg.version}`)}
+${chalk17.bold.cyan("\u25C6 ObjectStack CLI")} ${chalk17.dim(`v${pkg.version}`)}
 `).addHelpText("after", `
-${chalk13.bold("Workflow:")}
-  ${chalk13.dim("$")} os init                      ${chalk13.dim("# Create a new project")}
-  ${chalk13.dim("$")} os generate object task       ${chalk13.dim("# Add metadata")}
-  ${chalk13.dim("$")} os plugin add <package>       ${chalk13.dim("# Add a plugin")}
-  ${chalk13.dim("$")} os validate                   ${chalk13.dim("# Check configuration")}
-  ${chalk13.dim("$")} os dev                        ${chalk13.dim("# Start dev server")}
-  ${chalk13.dim("$")} os studio                     ${chalk13.dim("# Dev server + Studio UI")}
-  ${chalk13.dim("$")} os compile                    ${chalk13.dim("# Build for production")}
-
-${chalk13.dim("Aliases: objectstack | os")}
-${chalk13.dim("Docs: https://objectstack.dev")}
+${chalk17.bold("Workflow:")}
+  ${chalk17.dim("$")} os init                      ${chalk17.dim("# Create a new project")}
+  ${chalk17.dim("$")} os generate object task       ${chalk17.dim("# Add metadata")}
+  ${chalk17.dim("$")} os plugin add <package>       ${chalk17.dim("# Add a plugin")}
+  ${chalk17.dim("$")} os validate                   ${chalk17.dim("# Check configuration")}
+  ${chalk17.dim("$")} os dev                        ${chalk17.dim("# Start dev server")}
+  ${chalk17.dim("$")} os studio                     ${chalk17.dim("# Dev server + Studio UI")}
+  ${chalk17.dim("$")} os compile                    ${chalk17.dim("# Build for production")}
+
+${chalk17.dim("Aliases: objectstack | os")}
+${chalk17.dim("Docs: https://objectstack.dev")}
 `);
 program.addCommand(initCommand);
 program.addCommand(devCommand);
@@ -2171,11 +3744,15 @@ program.addCommand(createCommand);
 program.addCommand(pluginCommand);
 program.addCommand(testCommand);
 program.addCommand(doctorCommand);
+program.addCommand(lintCommand);
+program.addCommand(diffCommand);
+program.addCommand(explainCommand);
+program.addCommand(codemodCommand);
 loadPluginCommands(program).then(() => {
   program.parse(process.argv);
 }).catch((err) => {
   if (process.env.DEBUG) {
-    console.error(chalk13.yellow(`
+    console.error(chalk17.yellow(`
   \u26A0 Plugin command loading failed: ${err?.message || err}`));
   }
   program.parse(process.argv);