@happyvertical/smrt-cli 0.30.0

package/dist/index.js

@@ -0,0 +1,1809 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+import { ObjectRegistry } from "@happyvertical/smrt-core";
+import { loadLocalTestManifestSync } from "@happyvertical/smrt-core/manifest";
+import { parseCliArgs } from "@happyvertical/utils";
+const __dirname$1 = dirname(fileURLToPath(import.meta.url));
+const packageJson = JSON.parse(
+  readFileSync(join(__dirname$1, "../package.json"), "utf-8")
+);
+const CLI_VERSION = packageJson.version;
+function countRequiredArgs(args) {
+  if (!args) return 0;
+  return args.filter((arg) => !arg.startsWith("[") || !arg.endsWith("]")).length;
+}
+let _gnodeCommands = null;
+let _generateCommands = null;
+let _gitCommands = null;
+let _initCommands = null;
+let _utilityCommands = null;
+let _dispatchCommands = null;
+let _docsCommands = null;
+let _playgroundCommands = null;
+async function getGnodeCommands() {
+  if (!_gnodeCommands) {
+    const { gnodeCommands } = await import("./index-psX--9zT.js");
+    _gnodeCommands = gnodeCommands;
+  }
+  return _gnodeCommands;
+}
+async function getGitCommands() {
+  if (!_gitCommands) {
+    const { gitCommands } = await import("./index-psX--9zT.js");
+    _gitCommands = gitCommands;
+  }
+  return _gitCommands;
+}
+async function getGenerateCommands() {
+  if (!_generateCommands) {
+    const { generateCommands } = await import("./index-psX--9zT.js");
+    _generateCommands = generateCommands;
+  }
+  return _generateCommands;
+}
+async function getInitCommands() {
+  if (!_initCommands) {
+    const { initCommands } = await import("./index-psX--9zT.js");
+    _initCommands = initCommands;
+  }
+  return _initCommands;
+}
+async function getUtilityCommands() {
+  if (!_utilityCommands) {
+    const { utilityCommands } = await import("./index-psX--9zT.js");
+    _utilityCommands = utilityCommands;
+  }
+  return _utilityCommands;
+}
+async function getDispatchCommands() {
+  if (!_dispatchCommands) {
+    const { dispatchCommands } = await import("./index-psX--9zT.js");
+    _dispatchCommands = dispatchCommands;
+  }
+  return _dispatchCommands;
+}
+async function getDocsCommands() {
+  if (!_docsCommands) {
+    const { docsCommands } = await import("./index-psX--9zT.js");
+    _docsCommands = docsCommands;
+  }
+  return _docsCommands;
+}
+async function getPlaygroundCommands() {
+  if (!_playgroundCommands) {
+    const { playgroundCommands } = await import("./index-psX--9zT.js");
+    _playgroundCommands = playgroundCommands;
+  }
+  return _playgroundCommands;
+}
+class CLIGenerator {
+  config;
+  context;
+  collections = /* @__PURE__ */ new Map();
+  commandCache = null;
+  /** Lazy-loaded cache for object commands (key: objectName lowercase) */
+  objectCommandsCache = /* @__PURE__ */ new Map();
+  /** Set of registered object names (lowercase) for quick lookup */
+  registeredObjectNames = null;
+  /** Whether manifest/classes have been loaded */
+  manifestLoaded = false;
+  constructor(config = {}, context = {}) {
+    this.config = {
+      name: "smrt",
+      version: CLI_VERSION,
+      description: "Admin CLI for smrt objects",
+      prompt: true,
+      colors: true,
+      ...config
+    };
+    this.context = context;
+  }
+  /**
+   * Check if running in test environment
+   */
+  isTestMode() {
+    return process.env.NODE_ENV === "test" || process.env.VITEST === "true" || typeof global.it === "function" || typeof global.describe === "function";
+  }
+  /**
+   * Check if a type string represents an inline object type parameter
+   * e.g., "{ meetingId?: string; limit?: number }"
+   *
+   * Note: Only supports single-level nested braces. Deeply nested types
+   * like "{ config: { nested: { deep: string } } }" are not fully supported.
+   */
+  isObjectTypeParameter(typeStr) {
+    return typeStr.includes("{") && typeStr.includes("}") && typeStr.includes(":");
+  }
+  /**
+   * Try to load user's compiled classes for runtime execution
+   *
+   * Loads both local classes (from project entry point) and external classes
+   * (from packages in .smrt/manifest.json) to enable full CLI functionality.
+   */
+  async tryLoadUserClasses() {
+    const verbose = process.env.SMRT_VERBOSE === "true" || process.env.DEBUG?.includes("smrt");
+    if (verbose) {
+      console.log("[CLI] tryLoadUserClasses() called");
+    }
+    try {
+      if (verbose) {
+        console.log("[CLI] Loading local classes...");
+      }
+      await this.loadLocalClasses();
+    } catch (localError) {
+      if (verbose) {
+        console.log(
+          "[CLI] Local class loading failed (this is OK if using external packages only):",
+          localError instanceof Error ? localError.message : "Unknown error"
+        );
+      }
+    }
+    if (verbose) {
+      console.log("[CLI] Loading external classes...");
+    }
+    await this.loadExternalClasses();
+    const { getPackageConfig } = await import("@happyvertical/smrt-config");
+    const { DEFAULT_CLI_CONFIG } = await import("./config-C8pQD-tk.js");
+    const config = getPackageConfig("cli", DEFAULT_CLI_CONFIG);
+    const registeredCount = ObjectRegistry.getAllClasses().size;
+    if (verbose || config.verbose) {
+      console.log(`[CLI] Successfully loaded ${registeredCount} SMRT objects`);
+    }
+  }
+  /**
+   * Load classes from local project entry point
+   *
+   * Entry point discovery order:
+   * 1. smrt.config.js: packages.cli.entryPoint (explicit override)
+   * 2. package.json: exports['.'] or main field
+   * 3. Fallback: ./dist/index.js
+   */
+  async loadLocalClasses() {
+    const { getPackageConfig } = await import("@happyvertical/smrt-config");
+    const { DEFAULT_CLI_CONFIG } = await import("./config-C8pQD-tk.js");
+    const fs = await import("node:fs");
+    const path = await import("node:path");
+    const config = getPackageConfig("cli", DEFAULT_CLI_CONFIG);
+    let entryPoint = config.entryPoint;
+    if (!entryPoint) {
+      try {
+        const packageJsonPath = path.resolve(process.cwd(), "package.json");
+        if (fs.existsSync(packageJsonPath)) {
+          const packageJson2 = JSON.parse(
+            fs.readFileSync(packageJsonPath, "utf-8")
+          );
+          entryPoint = packageJson2.exports?.["."]?.import || packageJson2.exports?.["."] || packageJson2.main || "./dist/index.js";
+          if (config.verbose) {
+            console.log(
+              `[CLI] Detected entry point from package.json: ${entryPoint}`
+            );
+          }
+        }
+      } catch {
+        entryPoint = "./dist/index.js";
+      }
+    }
+    if (!entryPoint) {
+      entryPoint = "./dist/index.js";
+    }
+    const fullPath = path.resolve(process.cwd(), entryPoint);
+    if (!fs.existsSync(fullPath)) {
+      if (config.verbose) {
+        console.log(`[CLI] Entry point not found: ${fullPath}`);
+      }
+      return;
+    }
+    if (config.verbose) {
+      console.log(`[CLI] Loading local SMRT classes from ${entryPoint}...`);
+    }
+    const fileUrl = `file://${fullPath}`;
+    const importedModule = await import(fileUrl);
+    for (const [exportName, exportValue] of Object.entries(importedModule)) {
+      if (exportValue && typeof exportValue === "function") {
+        const itemClass = exportValue._itemClass;
+        if (itemClass) {
+          const tableName = itemClass.SMRT_TABLE_NAME || itemClass.name.toLowerCase();
+          const existing = ObjectRegistry.getClass(tableName);
+          if (existing && !existing.collectionConstructor) {
+            ObjectRegistry.registerCollection(tableName, exportValue);
+            if (config.verbose) {
+              console.log(`[CLI] Registered local collection ${exportName}`);
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Load classes from external packages
+   *
+   * Imports the auto-generated .smrt/register.js file which contains
+   * static imports and registrations for all external SMRT objects.
+   *
+   * This file is generated by the consumer plugin during build.
+   */
+  async loadExternalClasses() {
+    const { getPackageConfig } = await import("@happyvertical/smrt-config");
+    const { DEFAULT_CLI_CONFIG } = await import("./config-C8pQD-tk.js");
+    const { loadLocalTestManifestSync: loadLocalTestManifestSync2 } = await import("@happyvertical/smrt-core/manifest");
+    const fs = await import("node:fs");
+    const path = await import("node:path");
+    const config = getPackageConfig("cli", DEFAULT_CLI_CONFIG);
+    loadLocalTestManifestSync2();
+    const registerPath = path.join(process.cwd(), ".smrt", "register.js");
+    if (!fs.existsSync(registerPath)) {
+      console.log(
+        "[CLI] No .smrt/register.js found - custom commands may not work"
+      );
+      console.log('      Run "npm run build" to generate class registrations');
+      return;
+    }
+    try {
+      const fileUrl = `file://${registerPath}`;
+      await import(fileUrl);
+      if (config.verbose) {
+        const count = ObjectRegistry.getAllClasses().size;
+        console.log(`[CLI] Loaded ${count} objects from .smrt/register.js`);
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : "Unknown error";
+      console.error(`
+❌ Failed to load .smrt/register.js: ${msg}`);
+      console.error(
+        "\nThis usually means an installed package has non-Node.js exports (e.g., .svelte files)."
+      );
+      console.error("Fix the offending package, then re-run.\n");
+      throw error;
+    }
+  }
+  /**
+   * Handle exits safely in test mode
+   */
+  exitWithError(message, code = 1) {
+    if (this.isTestMode()) {
+      throw new Error(message);
+    }
+    console.error(message);
+    process.exit(code);
+  }
+  /**
+   * Generate CLI handler function
+   */
+  generateHandler() {
+    return async (argv) => {
+      const commands = await this.generateCommands();
+      const processedArgv = this.preprocessObjectCommands(argv, commands);
+      const parsed = parseCliArgs(processedArgv, commands, {});
+      await this.executeCommand(parsed, commands, processedArgv);
+    };
+  }
+  /**
+   * Preprocess argv to support space-separated object commands
+   *
+   * Converts: ['council', 'list'] → ['council:list']
+   * Converts: ['council', 'get', 'abc-123'] → ['council:get', 'abc-123']
+   *
+   * This enables users to type:
+   *   smrt council list
+   *   smrt council get abc-123
+   *   smrt council analyze abc-123 --depth 3
+   *
+   * Instead of:
+   *   smrt council:list
+   *   smrt council:get abc-123
+   */
+  preprocessObjectCommands(argv, commands) {
+    if (argv.length < 2) return argv;
+    const firstArg = argv[0];
+    const secondArg = argv[1];
+    if (firstArg.includes(":")) return argv;
+    if (firstArg.startsWith("-")) return argv;
+    if (secondArg.startsWith("-")) return argv;
+    const combinedCommand = `${firstArg}:${secondArg}`;
+    const matchesCommand = commands.some(
+      (cmd) => cmd.name === combinedCommand || cmd.aliases?.includes(combinedCommand)
+    );
+    if (matchesCommand) {
+      return [combinedCommand, ...argv.slice(2)];
+    }
+    const knownBuiltInNamespaces = /* @__PURE__ */ new Set([
+      "dispatch",
+      "docs",
+      "git",
+      "playground"
+    ]);
+    if (knownBuiltInNamespaces.has(firstArg)) {
+      return [combinedCommand, ...argv.slice(2)];
+    }
+    const registeredClasses = ObjectRegistry.getAllClasses();
+    const isKnownObject = Array.from(registeredClasses.values()).some(
+      (info) => (info.name || "").toLowerCase() === firstArg.toLowerCase()
+    );
+    if (isKnownObject) {
+      return [combinedCommand, ...argv.slice(2)];
+    }
+    return argv;
+  }
+  /**
+   * Ensure manifest and user classes are loaded.
+   * This is the minimum required work before any command can be executed.
+   * Separated from command generation to enable lazy command loading.
+   */
+  async ensureManifestLoaded() {
+    if (this.manifestLoaded) {
+      return;
+    }
+    const timing = this.context.timing;
+    const verbose = process.env.SMRT_VERBOSE === "true" || process.env.DEBUG?.includes("smrt");
+    const manifest = loadLocalTestManifestSync();
+    if (verbose) {
+      console.log(
+        "[CLI] Manifest loaded:",
+        manifest ? `${Object.keys(manifest.objects || {}).length} objects` : "null"
+      );
+    }
+    if (manifest?.objects) {
+      for (const [name, objectDef] of Object.entries(manifest.objects)) {
+        ObjectRegistry.registerFromManifest(
+          name,
+          objectDef,
+          manifest.packageName
+        );
+      }
+    }
+    const classLoadStart = timing ? performance.now() : 0;
+    await this.tryLoadUserClasses();
+    if (timing) {
+      timing.classLoading = performance.now() - classLoadStart;
+    }
+    const registeredClasses = ObjectRegistry.getAllClasses();
+    this.registeredObjectNames = new Set(
+      Array.from(registeredClasses.values()).map(
+        (info) => (info.name || "").toLowerCase()
+      )
+    );
+    this.manifestLoaded = true;
+  }
+  /**
+   * Get commands for a specific object (lazy generation with caching)
+   */
+  async getObjectCommandsLazy(objectName) {
+    const lowerName = objectName.toLowerCase();
+    const cachedCommands = this.objectCommandsCache.get(lowerName);
+    if (cachedCommands) {
+      return cachedCommands;
+    }
+    const registeredClasses = ObjectRegistry.getAllClasses();
+    let actualName;
+    let matchedKey;
+    for (const [key, info] of registeredClasses) {
+      if ((info.name || key).toLowerCase() === lowerName) {
+        actualName = info.name || key;
+        matchedKey = key;
+        break;
+      }
+    }
+    if (!actualName || !matchedKey) {
+      return [];
+    }
+    const classInfo = registeredClasses.get(matchedKey);
+    const commands = await this.generateObjectCommands(actualName, classInfo);
+    this.objectCommandsCache.set(lowerName, commands);
+    return commands;
+  }
+  /**
+   * Find an object command by name (lazy lookup)
+   */
+  async findObjectCommand(commandName) {
+    const colonIndex = commandName.indexOf(":");
+    if (colonIndex === -1) {
+      return void 0;
+    }
+    const objectName = commandName.slice(0, colonIndex);
+    await this.ensureManifestLoaded();
+    if (!this.registeredObjectNames?.has(objectName.toLowerCase())) {
+      return void 0;
+    }
+    const objectCommands = await this.getObjectCommandsLazy(objectName);
+    return objectCommands.find(
+      (cmd) => cmd.name === commandName || cmd.aliases?.includes(commandName)
+    );
+  }
+  /**
+   * Generate all CLI commands
+   *
+   * NOTE: Object commands are now loaded LAZILY for better startup performance.
+   * This method only generates utility commands upfront. Object commands are
+   * generated on-demand when executeCommand() looks for them.
+   *
+   * For full command list (e.g., help display), use generateAllCommands().
+   */
+  async generateCommands() {
+    const timing = this.context.timing;
+    const verbose = process.env.SMRT_VERBOSE === "true" || process.env.DEBUG?.includes("smrt");
+    if (this.commandCache) {
+      if (verbose) {
+        console.log("[CLI] generateCommands() returning cached commands");
+      }
+      return this.commandCache;
+    }
+    if (verbose) {
+      console.log("[CLI] generateCommands() starting (lazy mode)");
+    }
+    await this.ensureManifestLoaded();
+    const commandGenStart = timing ? performance.now() : 0;
+    const commands = [];
+    const commandNames = /* @__PURE__ */ new Set();
+    for (const cmd of this.generateUtilityCommands()) {
+      if (commandNames.has(cmd.name)) {
+        if (verbose) {
+          console.warn(`[CLI] Skipping duplicate utility command: ${cmd.name}`);
+        }
+        continue;
+      }
+      commandNames.add(cmd.name);
+      commands.push(cmd);
+    }
+    if (timing) {
+      timing.commandGen = performance.now() - commandGenStart;
+    }
+    this.commandCache = commands;
+    return commands;
+  }
+  /**
+   * Generate ALL commands including lazy-loaded object commands.
+   * Used for help display where we need the complete list.
+   */
+  async generateAllCommands() {
+    const verbose = process.env.SMRT_VERBOSE === "true" || process.env.DEBUG?.includes("smrt");
+    if (verbose) {
+      console.log("[CLI] generateAllCommands() - loading all object commands");
+    }
+    await this.ensureManifestLoaded();
+    const allCommands = [];
+    const commandNames = /* @__PURE__ */ new Set();
+    for (const cmd of this.generateUtilityCommands()) {
+      if (!commandNames.has(cmd.name)) {
+        commandNames.add(cmd.name);
+        allCommands.push(cmd);
+      }
+    }
+    const registeredClasses = ObjectRegistry.getAllClasses();
+    for (const [_key, classInfo] of registeredClasses) {
+      const objectCommands = await this.getObjectCommandsLazy(
+        classInfo.name || _key
+      );
+      for (const cmd of objectCommands) {
+        if (!commandNames.has(cmd.name)) {
+          commandNames.add(cmd.name);
+          allCommands.push(cmd);
+        }
+      }
+    }
+    return allCommands;
+  }
+  /**
+   * Generate CRUD commands for a specific object
+   */
+  async generateObjectCommands(objectName, _classInfo) {
+    const commands = [];
+    const lowerName = objectName.toLowerCase();
+    const config = ObjectRegistry.getConfig(objectName);
+    const cliConfig = config.cli;
+    if (cliConfig === false) return commands;
+    const excluded = (typeof cliConfig === "object" ? cliConfig.exclude : []) || [];
+    const included = typeof cliConfig === "object" ? cliConfig.include : null;
+    const shouldInclude = (command) => {
+      if (included && !included.includes(command)) return false;
+      if (excluded.includes(command)) return false;
+      return true;
+    };
+    if (shouldInclude("list")) {
+      commands.push({
+        name: `${lowerName}:list`,
+        description: `List ${objectName} objects`,
+        aliases: [`${lowerName}:ls`],
+        options: {
+          limit: {
+            type: "string",
+            description: "limit number of results",
+            default: "50",
+            short: "l"
+          },
+          offset: {
+            type: "string",
+            description: "offset for pagination",
+            default: "0",
+            short: "o"
+          },
+          "order-by": { type: "string", description: "field to order by" },
+          where: { type: "string", description: "filter conditions as JSON" },
+          format: {
+            type: "string",
+            description: "output format (table|json)",
+            default: "table"
+          }
+        },
+        handler: async (_args, options) => {
+          await this.handleList(objectName, options);
+        }
+      });
+    }
+    if (shouldInclude("get")) {
+      commands.push({
+        name: `${lowerName}:get`,
+        description: `Get ${objectName} by ID or slug`,
+        aliases: [`${lowerName}:show`],
+        args: ["id"],
+        options: {
+          format: {
+            type: "string",
+            description: "output format (json|yaml)",
+            default: "json"
+          }
+        },
+        handler: async (args, options) => {
+          await this.handleGet(objectName, args[0], options);
+        }
+      });
+    }
+    if (shouldInclude("create")) {
+      const options = {
+        interactive: {
+          type: "boolean",
+          description: "interactive mode with prompts"
+        },
+        "from-file": { type: "string", description: "create from JSON file" }
+      };
+      const fields = ObjectRegistry.getFields(objectName);
+      for (const [fieldName, field] of fields) {
+        const optionName = fieldName.replace(/_/g, "-");
+        const description = field.options?.description || `${objectName} ${fieldName}`;
+        options[optionName] = { type: "string", description };
+      }
+      commands.push({
+        name: `${lowerName}:create`,
+        description: `Create new ${objectName}`,
+        aliases: [`${lowerName}:new`],
+        options,
+        handler: async (_args, options2) => {
+          await this.handleCreate(objectName, options2);
+        }
+      });
+    }
+    if (shouldInclude("update")) {
+      const options = {
+        interactive: {
+          type: "boolean",
+          description: "interactive mode with prompts"
+        },
+        "from-file": { type: "string", description: "update from JSON file" }
+      };
+      const fields = ObjectRegistry.getFields(objectName);
+      for (const [fieldName, field] of fields) {
+        const optionName = fieldName.replace(/_/g, "-");
+        const description = field.options?.description || `${objectName} ${fieldName}`;
+        options[optionName] = { type: "string", description };
+      }
+      commands.push({
+        name: `${lowerName}:update`,
+        description: `Update ${objectName}`,
+        aliases: [`${lowerName}:edit`],
+        args: ["id"],
+        options,
+        handler: async (args, options2) => {
+          await this.handleUpdate(objectName, args[0], options2);
+        }
+      });
+    }
+    if (shouldInclude("delete")) {
+      commands.push({
+        name: `${lowerName}:delete`,
+        description: `Delete ${objectName}`,
+        aliases: [`${lowerName}:rm`],
+        args: ["id"],
+        options: {
+          force: { type: "boolean", description: "skip confirmation prompt" }
+        },
+        handler: async (args, options) => {
+          await this.handleDelete(objectName, args[0], options);
+        }
+      });
+    }
+    const methods = await ObjectRegistry.getAllMethods(objectName);
+    const crudOperations = ["list", "get", "create", "update", "delete"];
+    const hasCustomMethodsInInclude = included?.some(
+      (item) => !crudOperations.includes(item)
+    );
+    for (const [methodName, methodDef] of methods) {
+      const shouldIncludeMethod = () => {
+        if (!methodDef.isPublic) return false;
+        if (excluded.includes(methodName)) return false;
+        if (hasCustomMethodsInInclude && included && !included.includes(methodName)) {
+          return false;
+        }
+        return true;
+      };
+      if (!shouldIncludeMethod()) continue;
+      const methodOptions = {
+        json: {
+          type: "boolean",
+          description: "Output as JSON only (suppress other output)"
+        }
+      };
+      for (const param of methodDef.parameters || []) {
+        const typeStr = param.type || "";
+        const isObjectType = this.isObjectTypeParameter(typeStr);
+        if (isObjectType) {
+          const match = typeStr.match(/\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}/);
+          if (match) {
+            const propsStr = match[1];
+            const propMatches = propsStr.matchAll(/(\w+)(\?)?:\s*([^;]+)/g);
+            for (const propMatch of propMatches) {
+              const [, propName, isOptional, propType] = propMatch;
+              const optionName = propName.replace(/([A-Z])/g, "-$1").toLowerCase();
+              if (propType.includes("import(")) {
+                methodOptions[optionName] = {
+                  type: "string",
+                  description: `JSON object${isOptional ? " (optional)" : ""}`
+                };
+              } else {
+                const trimmedType = propType.trim();
+                methodOptions[optionName] = {
+                  type: trimmedType === "boolean" ? "boolean" : "string",
+                  description: `${trimmedType}${isOptional ? " (optional)" : ""}`
+                };
+              }
+            }
+          }
+        } else {
+          const optionName = param.name.replace(/([A-Z])/g, "-$1").toLowerCase();
+          const paramType = (param.type || "").trim();
+          methodOptions[optionName] = {
+            type: paramType === "boolean" ? "boolean" : "string",
+            description: `${param.type}${param.optional ? " (optional)" : ""}`,
+            ...param.default !== void 0 && {
+              default: String(param.default)
+            }
+          };
+        }
+      }
+      const firstParam = (methodDef.parameters || [])[0];
+      const needsInstance = firstParam?.name === "id";
+      commands.push({
+        name: `${lowerName}:${methodName}`,
+        description: methodDef.description || `Execute ${methodName} on ${objectName}`,
+        args: needsInstance ? ["id"] : [],
+        // Only require ID if method has required parameters
+        options: methodOptions,
+        handler: async (args, options) => {
+          if (needsInstance) {
+            await this.handleCustomMethod(
+              objectName,
+              args[0],
+              methodName,
+              options
+            );
+          } else {
+            await this.handleSingletonMethod(
+              objectName,
+              methodName,
+              options,
+              methodDef
+            );
+          }
+        }
+      });
+    }
+    return commands;
+  }
+  /**
+   * Execute a parsed command
+   */
+  async executeCommand(parsed, commands, processedArgv = process.argv.slice(2)) {
+    if (!parsed.command) {
+      const allCommands = await this.generateAllCommands();
+      await this.showHelp(allCommands);
+      return;
+    }
+    let command = commands.find(
+      (cmd) => cmd.name === parsed.command || parsed.command && cmd.aliases && cmd.aliases.includes(parsed.command)
+    );
+    if (!command && parsed.command) {
+      command = await this.findObjectCommand(parsed.command);
+    }
+    if (command) {
+      const requiredArgCount = countRequiredArgs(command.args);
+      if (parsed.args.length < requiredArgCount) {
+        const missingArgs = command.args?.slice(parsed.args.length).filter((arg) => !arg.startsWith("[") || !arg.endsWith("]"));
+        this.exitWithError(
+          `Missing required arguments: ${missingArgs?.join(", ") || ""}`
+        );
+        return;
+      }
+      if (!command.handler) {
+        this.exitWithError(
+          `Command '${parsed.command}' has no handler defined`
+        );
+        return;
+      }
+      try {
+        await command.handler(parsed.args, parsed.options);
+        return;
+      } catch (error) {
+        this.exitWithError(
+          `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+        return;
+      }
+    }
+    const [
+      gnodeCommands,
+      generateCommands,
+      gitCommands,
+      initCommands,
+      utilityCommands,
+      dispatchCommands,
+      docsCommands,
+      playgroundCommands
+    ] = await Promise.all([
+      getGnodeCommands(),
+      getGenerateCommands(),
+      getGitCommands(),
+      getInitCommands(),
+      getUtilityCommands(),
+      getDispatchCommands(),
+      getDocsCommands(),
+      getPlaygroundCommands()
+    ]);
+    const builtInCommands = {
+      ...gnodeCommands,
+      ...generateCommands,
+      ...gitCommands,
+      ...initCommands,
+      ...utilityCommands,
+      ...dispatchCommands,
+      ...docsCommands,
+      ...playgroundCommands
+    };
+    const builtInCommand = builtInCommands[parsed.command] ?? Object.values(builtInCommands).find(
+      (cmd) => cmd.name === parsed.command || cmd.aliases?.includes(parsed.command ?? "")
+    );
+    if (builtInCommand) {
+      const requiredArgCount = countRequiredArgs(builtInCommand.args);
+      if (parsed.args.length < requiredArgCount) {
+        const missingArgs = builtInCommand.args?.slice(parsed.args.length).filter((arg) => !arg.startsWith("[") || !arg.endsWith("]"));
+        this.exitWithError(
+          `Missing required arguments: ${missingArgs?.join(", ") || ""}`
+        );
+        return;
+      }
+      if (!builtInCommand.handler) {
+        this.exitWithError(
+          `Command '${parsed.command}' has no handler defined`
+        );
+        return;
+      }
+      const reParsed = parseCliArgs(processedArgv, [builtInCommand], {});
+      try {
+        await builtInCommand.handler(reParsed.args, reParsed.options);
+        return;
+      } catch (error) {
+        this.exitWithError(
+          `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+        return;
+      }
+    }
+    await this.ensureManifestLoaded();
+    const registeredClasses = ObjectRegistry.getAllClasses();
+    let matchingObject;
+    for (const [_key, info] of registeredClasses) {
+      if ((info.name || _key).toLowerCase() === parsed.command?.toLowerCase()) {
+        matchingObject = info.name || _key;
+        break;
+      }
+    }
+    if (matchingObject) {
+      const objectCommands = await this.getObjectCommandsLazy(matchingObject);
+      await this.showObjectHelp(matchingObject, objectCommands);
+      return;
+    }
+    this.exitWithError(`Unknown command '${parsed.command}'`);
+  }
+  /**
+   * Show help for a specific object and its available commands
+   */
+  async showObjectHelp(objectName, objectCommands) {
+    const classInfo = ObjectRegistry.getClass(objectName);
+    const lowerName = objectName.toLowerCase();
+    console.log(`
+${objectName}`);
+    console.log("=".repeat(objectName.length));
+    if (classInfo?.packageName) {
+      console.log(`Package: ${classInfo.packageName}`);
+    }
+    if (objectCommands.length === 0) {
+      console.log("\nNo CLI commands available for this object.");
+      console.log(
+        "Check that cli: true or cli: { include: [...] } is set in @smrt() decorator."
+      );
+      return;
+    }
+    console.log("\nAvailable commands:");
+    for (const cmd of objectCommands) {
+      const cmdName = cmd.name.replace(`${lowerName}:`, "");
+      const args = cmd.args ? ` ${cmd.args.map((arg) => `<${arg}>`).join(" ")}` : "";
+      console.log(`  smrt ${lowerName} ${cmdName}${args}`);
+      console.log(`    ${cmd.description}`);
+      if (cmd.options && Object.keys(cmd.options).length > 0) {
+        for (const [optName, opt] of Object.entries(cmd.options)) {
+          const short = opt.short ? `-${opt.short}, ` : "";
+          const def = opt.default ? ` (default: ${opt.default})` : "";
+          console.log(`      ${short}--${optName}${def}`);
+        }
+      }
+      console.log();
+    }
+    const fields = ObjectRegistry.getFields(objectName);
+    if (fields.size > 0) {
+      console.log("Fields:");
+      for (const [fieldName, field] of fields) {
+        const required = field.options?.required ? " (required)" : "";
+        console.log(`  ${fieldName}: ${field.type}${required}`);
+      }
+    }
+  }
+  /**
+   * Generate utility commands
+   */
+  generateUtilityCommands() {
+    const commands = [];
+    commands.push({
+      name: "objects",
+      description: "List all registered smrt objects",
+      aliases: ["ls"],
+      options: {
+        verbose: {
+          type: "boolean",
+          description: "Show detailed output including methods",
+          short: "v"
+        },
+        json: {
+          type: "boolean",
+          description: "Output as JSON"
+        }
+      },
+      handler: async (_args, options) => {
+        const registeredClasses = ObjectRegistry.getAllClasses();
+        if (registeredClasses.size === 0) {
+          console.log("No SMRT objects found.");
+          console.log("\nTo discover objects:");
+          console.log("  • Build your project: npm run build");
+          console.log("  • Ensure .smrt/register.js exists");
+          console.log("  • Run: smrt introspect for details");
+          return;
+        }
+        if (options.json) {
+          const output = {};
+          for (const [key, classInfo] of registeredClasses) {
+            const displayName = classInfo.name || key;
+            const config = ObjectRegistry.getConfig(key);
+            const fields = ObjectRegistry.getFields(key);
+            const methods = await ObjectRegistry.getAllMethods(key);
+            output[classInfo.qualifiedName || displayName] = {
+              name: displayName,
+              package: classInfo.packageName || "project",
+              hasConstructor: !!classInfo.constructor,
+              hasCollection: !!classInfo.collectionConstructor,
+              config,
+              fields: Object.fromEntries(fields),
+              methods: Object.fromEntries(methods)
+            };
+          }
+          console.log(JSON.stringify(output, null, 2));
+          return;
+        }
+        console.log("Registered SMRT objects:\n");
+        const byPackage = /* @__PURE__ */ new Map();
+        for (const [key, classInfo] of registeredClasses) {
+          const pkg = classInfo.packageName || "project";
+          if (!byPackage.has(pkg)) {
+            byPackage.set(pkg, []);
+          }
+          byPackage.get(pkg)?.push({ display: classInfo.name || key, key });
+        }
+        for (const [pkg, entries] of byPackage) {
+          console.log(`  ${pkg}:`);
+          for (const { display: objName, key: objKey } of entries) {
+            const config = ObjectRegistry.getConfig(objKey);
+            const cliConfig = config.cli;
+            let cliMethods = [];
+            if (cliConfig) {
+              const methods = await ObjectRegistry.getAllMethods(objKey);
+              const methodNames = Array.from(methods.keys());
+              if (typeof cliConfig === "object" && cliConfig.include) {
+                cliMethods = methodNames.filter(
+                  (m) => cliConfig.include?.includes(m) && methods.get(m)?.isPublic
+                );
+              } else if (cliConfig === true) {
+                cliMethods = methodNames.filter(
+                  (m) => methods.get(m)?.isPublic
+                );
+              }
+            }
+            if (options.verbose) {
+              console.log(`    • ${objName}`);
+              if (cliMethods.length > 0) {
+                console.log(`      CLI: ${cliMethods.join(", ")}`);
+              }
+              const fields = ObjectRegistry.getFields(objKey);
+              const fieldNames = Array.from(fields.keys()).slice(0, 5);
+              if (fieldNames.length > 0) {
+                console.log(
+                  `      Fields: ${fieldNames.join(", ")}${fields.size > 5 ? "..." : ""}`
+                );
+              }
+            } else {
+              const methodStr = cliMethods.length > 0 ? ` → ${cliMethods.join(", ")}` : "";
+              console.log(`    • ${objName}${methodStr}`);
+            }
+          }
+          console.log();
+        }
+        console.log(
+          `Total: ${registeredClasses.size} objects from ${byPackage.size} source(s)`
+        );
+      }
+    });
+    commands.push({
+      name: "schema",
+      description: "Show schema for an object",
+      args: ["object"],
+      handler: this.createSchemaHandler()
+    });
+    commands.push({
+      name: "help",
+      description: "Show help information",
+      aliases: ["h"],
+      handler: async (_args, _options) => {
+        await this.showHelp(commands);
+      }
+    });
+    commands.push({
+      name: "version",
+      description: "Show version information",
+      aliases: ["v"],
+      handler: async (_args, _options) => {
+        console.log(`${this.config.name} v${this.config.version}`);
+      }
+    });
+    commands.push({
+      name: "status",
+      description: "Show system status",
+      handler: async (_args, _options) => {
+        console.log("System Status:");
+        console.log(`- CLI: ${this.config.name} v${this.config.version}`);
+        console.log(
+          `- Database: ${this.context.db ? "Connected" : "Not connected"}`
+        );
+        console.log(`- AI: ${this.context.ai ? "Available" : "Not available"}`);
+        console.log(`- User: ${this.context.user?.id || "Not authenticated"}`);
+      }
+    });
+    return commands;
+  }
+  /**
+   * Create schema command handler
+   */
+  createSchemaHandler() {
+    return async (args, _options) => {
+      const objectName = args[0];
+      const fields = ObjectRegistry.getFields(objectName);
+      if (fields.size === 0) {
+        this.exitWithError(`Object ${objectName} not found`);
+        return;
+      }
+      console.log(`Schema for ${objectName}:`);
+      for (const [fieldName, field] of fields) {
+        console.log(
+          `  ${fieldName}: ${field.type}${field.options?.required ? " (required)" : ""}`
+        );
+        if (field.options?.description) {
+          console.log(`    ${field.options.description}`);
+        }
+      }
+    };
+  }
+  /**
+   * Show help information
+   */
+  async showHelp(commands) {
+    console.log(`${this.config.name} v${this.config.version}`);
+    console.log(this.config.description);
+    console.log();
+    const [
+      gnodeCommands,
+      generateCommands,
+      gitCommands,
+      initCommands,
+      utilityCommands,
+      dispatchCommands,
+      docsCommands,
+      playgroundCommands
+    ] = await Promise.all([
+      getGnodeCommands(),
+      getGenerateCommands(),
+      getGitCommands(),
+      getInitCommands(),
+      getUtilityCommands(),
+      getDispatchCommands(),
+      getDocsCommands(),
+      getPlaygroundCommands()
+    ]);
+    console.log("Project Setup:");
+    for (const command of Object.values(initCommands)) {
+      this.showCommandHelp(command);
+    }
+    console.log();
+    console.log("Playground:");
+    for (const command of Object.values(playgroundCommands)) {
+      this.showCommandHelp(command);
+    }
+    console.log();
+    console.log("Utility Commands:");
+    for (const command of Object.values(utilityCommands)) {
+      this.showCommandHelp(command);
+    }
+    console.log();
+    console.log("Dispatch (Inter-Agent Communication):");
+    for (const command of Object.values(dispatchCommands)) {
+      this.showCommandHelp(command);
+    }
+    console.log();
+    console.log("Git Integration:");
+    for (const command of Object.values(gitCommands)) {
+      this.showCommandHelp(command);
+    }
+    console.log();
+    console.log("Gnode Commands:");
+    for (const command of Object.values(gnodeCommands)) {
+      this.showCommandHelp(command);
+    }
+    console.log("Code Generation:");
+    for (const command of Object.values(generateCommands)) {
+      this.showCommandHelp(command);
+    }
+    console.log("Documentation:");
+    for (const command of Object.values(docsCommands)) {
+      this.showCommandHelp(command);
+    }
+    console.log();
+    const builtInUtilityCommands = commands.filter(
+      (cmd) => cmd.name === "objects" || cmd.name === "schema" || cmd.name === "help" || cmd.name === "version" || cmd.name === "status"
+    );
+    if (builtInUtilityCommands.length > 0) {
+      console.log("Object Utilities:");
+      for (const command of builtInUtilityCommands) {
+        this.showCommandHelp(command);
+      }
+    }
+    const objectCommands = commands.filter(
+      (cmd) => !builtInUtilityCommands.includes(cmd)
+    );
+    if (objectCommands.length > 0) {
+      console.log("Object Commands (auto-generated):");
+      for (const command of objectCommands) {
+        this.showCommandHelp(command);
+      }
+    }
+  }
+  /**
+   * Show help for a single command
+   */
+  showCommandHelp(command) {
+    const aliases = command.aliases ? ` (${command.aliases.join(", ")})` : "";
+    const args = command.args ? ` ${command.args.map((arg) => `<${arg}>`).join(" ")}` : "";
+    console.log(`  ${command.name}${args}${aliases}`);
+    console.log(`    ${command.description}`);
+    if (command.options) {
+      for (const [name, option] of Object.entries(command.options)) {
+        const short = option.short ? `-${option.short}, ` : "";
+        console.log(`    ${short}--${name}: ${option.description}`);
+      }
+    }
+    console.log();
+  }
+  /**
+   * Create a simple spinner
+   */
+  createSpinner(text) {
+    const isTTY = process.stdout.isTTY && typeof process.stdout.clearLine === "function" && typeof process.stdout.cursorTo === "function";
+    if (this.config.colors && isTTY) {
+      process.stdout.write(`⠋ ${text}`);
+      return {
+        succeed: (successText) => {
+          process.stdout.clearLine(0);
+          process.stdout.cursorTo(0);
+          console.log(`✅ ${successText || text}`);
+        },
+        fail: (errorText) => {
+          process.stdout.clearLine(0);
+          process.stdout.cursorTo(0);
+          console.log(`❌ ${errorText || text}`);
+        }
+      };
+    }
+    console.log(text);
+    return {
+      succeed: (successText) => console.log(successText || "Done"),
+      fail: (errorText) => console.log(errorText || "Failed")
+    };
+  }
+  /**
+   * Prompt for input
+   */
+  async prompt(message) {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    return new Promise((resolve) => {
+      rl.question(`${message} `, (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    });
+  }
+  /**
+   * Confirm prompt
+   */
+  async confirm(message) {
+    const answer = await this.prompt(`${message} (y/n)`);
+    return answer.toLowerCase().startsWith("y");
+  }
+  /**
+   * Handle LIST command
+   */
+  async handleList(objectName, options) {
+    const spinner = this.createSpinner(`Listing ${objectName} objects...`);
+    try {
+      const collection = await this.getCollection(objectName);
+      const listOptions = {
+        limit: Number.parseInt(options.limit, 10),
+        offset: Number.parseInt(options.offset, 10)
+      };
+      const orderBy = options["order-by"] ?? options.orderBy;
+      if (orderBy) {
+        listOptions.orderBy = orderBy;
+      }
+      if (options.where) {
+        listOptions.where = JSON.parse(options.where);
+      }
+      const results = await collection.list(listOptions);
+      spinner.succeed(`Found ${results.length} ${objectName} objects`);
+      if (options.format === "json") {
+        console.log(JSON.stringify(results, null, 2));
+      } else {
+        this.displayTable(results, objectName);
+      }
+    } catch (error) {
+      spinner.fail(`Failed to list ${objectName} objects`);
+      this.exitWithError(
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+  /**
+   * Handle GET command
+   */
+  async handleGet(objectName, id, options) {
+    const spinner = this.createSpinner(`Getting ${objectName}...`);
+    try {
+      const collection = await this.getCollection(objectName);
+      const result = await collection.get(id);
+      if (!result) {
+        spinner.fail(`${objectName} not found`);
+        this.exitWithError(`${objectName} not found`);
+        return;
+      }
+      spinner.succeed(`Found ${objectName}`);
+      if (options.format === "yaml") {
+        console.log(this.toYamlString(result));
+      } else {
+        console.log(JSON.stringify(result, null, 2));
+      }
+    } catch (error) {
+      spinner.fail(`Failed to get ${objectName}`);
+      this.exitWithError(
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+  /**
+   * Handle CREATE command
+   */
+  async handleCreate(objectName, options) {
+    try {
+      let data = {};
+      const fromFile = options["from-file"] ?? options.fromFile;
+      if (fromFile) {
+        const fs = await import("node:fs/promises");
+        const content = await fs.readFile(fromFile, "utf-8");
+        data = JSON.parse(content);
+      } else if (options.interactive && this.config.prompt) {
+        data = await this.promptForFields(objectName, {});
+      } else {
+        const fields = ObjectRegistry.getFields(objectName);
+        for (const [fieldName] of fields) {
+          const optionName = fieldName.replace(/_/g, "-");
+          if (options[optionName] !== void 0) {
+            data[fieldName] = this.parseFieldValue(options[optionName]);
+          }
+        }
+      }
+      const spinner = this.createSpinner(`Creating ${objectName}...`);
+      const collection = await this.getCollection(objectName);
+      const result = await collection.create(data);
+      await result.save();
+      spinner.succeed(`Created ${objectName} with ID: ${result.id}`);
+      if (!options.quiet) {
+        console.log(JSON.stringify(result, null, 2));
+      }
+    } catch (error) {
+      this.exitWithError(
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+  /**
+   * Handle UPDATE command
+   */
+  async handleUpdate(objectName, id, options) {
+    try {
+      const collection = await this.getCollection(objectName);
+      const existing = await collection.get(id);
+      if (!existing) {
+        this.exitWithError(`${objectName} not found`);
+        return;
+      }
+      let data = {};
+      const fromFile = options["from-file"] ?? options.fromFile;
+      if (fromFile) {
+        const fs = await import("node:fs/promises");
+        const content = await fs.readFile(fromFile, "utf-8");
+        data = JSON.parse(content);
+      } else if (options.interactive && this.config.prompt) {
+        data = await this.promptForFields(objectName, existing);
+      } else {
+        const fields = ObjectRegistry.getFields(objectName);
+        for (const [fieldName] of fields) {
+          const optionName = fieldName.replace(/_/g, "-");
+          if (options[optionName] !== void 0) {
+            data[fieldName] = this.parseFieldValue(options[optionName]);
+          }
+        }
+      }
+      const spinner = this.createSpinner(`Updating ${objectName}...`);
+      Object.assign(existing, data);
+      await existing.save();
+      spinner.succeed(`Updated ${objectName}`);
+      if (!options.quiet) {
+        console.log(JSON.stringify(existing, null, 2));
+      }
+    } catch (error) {
+      this.exitWithError(
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+  /**
+   * Handle DELETE command
+   */
+  async handleDelete(objectName, id, options) {
+    try {
+      const collection = await this.getCollection(objectName);
+      const existing = await collection.get(id);
+      if (!existing) {
+        this.exitWithError(`${objectName} not found`);
+        return;
+      }
+      if (!options.force && this.config.prompt) {
+        const confirmed = await this.confirm(
+          `Are you sure you want to delete ${objectName} "${existing.name || existing.slug || existing.id}"?`
+        );
+        if (!confirmed) {
+          console.log("Cancelled");
+          return;
+        }
+      }
+      const spinner = this.createSpinner(`Deleting ${objectName}...`);
+      await existing.delete();
+      spinner.succeed(`Deleted ${objectName}`);
+    } catch (error) {
+      this.exitWithError(
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+  /**
+   * Handle custom method execution
+   */
+  async handleCustomMethod(objectName, id, methodName, options) {
+    try {
+      const collection = await this.getCollection(objectName);
+      const obj = await collection.get(id);
+      if (!obj) {
+        this.exitWithError(`${objectName} not found`);
+        return;
+      }
+      const methods = await ObjectRegistry.getAllMethods(objectName);
+      const methodDef = methods.get(methodName);
+      if (!methodDef) {
+        this.exitWithError(`Method ${methodName} not found on ${objectName}`);
+        return;
+      }
+      const jsonMode = options.json === true;
+      const spinner = jsonMode ? {
+        succeed: (_text) => {
+        },
+        fail: (msg) => {
+          if (msg) {
+            console.error(msg);
+          }
+        }
+      } : this.createSpinner(`Executing ${methodName} on ${objectName}...`);
+      const methodParams = methodDef.parameters || [];
+      const methodCallArgs = [];
+      for (const param of methodParams) {
+        const typeStr = param.type || "";
+        const isObjectType = this.isObjectTypeParameter(typeStr);
+        if (isObjectType) {
+          const objArg = {};
+          const match = typeStr.match(/\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}/);
+          if (match) {
+            const propsStr = match[1];
+            const propMatches = propsStr.matchAll(/(\w+)(\?)?:\s*([^;]+)/g);
+            for (const propMatch of propMatches) {
+              const [, propName] = propMatch;
+              const optionName = propName.replace(/([A-Z])/g, "-$1").toLowerCase();
+              if (options[optionName] !== void 0) {
+                let value = options[optionName];
+                if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+                  try {
+                    value = JSON.parse(value);
+                  } catch {
+                  }
+                }
+                objArg[propName] = value;
+              }
+            }
+          }
+          if (Object.keys(objArg).length > 0) {
+            methodCallArgs.push(objArg);
+          } else if (!param.optional) {
+            methodCallArgs.push({});
+          } else {
+            methodCallArgs.push(void 0);
+          }
+        } else {
+          const optionName = param.name.replace(/([A-Z])/g, "-$1").toLowerCase();
+          if (options[optionName] !== void 0) {
+            methodCallArgs.push(options[optionName]);
+          } else if (param.default !== void 0) {
+            methodCallArgs.push(param.default);
+          } else {
+            methodCallArgs.push(void 0);
+          }
+        }
+      }
+      const method = obj[methodName];
+      if (typeof method !== "function") {
+        spinner.fail(`Method ${methodName} is not a function`);
+        this.exitWithError(`Method ${methodName} is not callable`);
+        return;
+      }
+      const result = await method.call(obj, ...methodCallArgs);
+      spinner.succeed(`Executed ${methodName}`);
+      console.log(JSON.stringify(result, null, 2));
+    } catch (error) {
+      this.exitWithError(
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+  /**
+   * Handle singleton method (no parameters, no database lookup)
+   * Creates a new instance with proper config and calls the method
+   */
+  async handleSingletonMethod(objectName, methodName, options, methodDef) {
+    try {
+      const classInfo = ObjectRegistry.getClass(objectName);
+      if (!classInfo || !classInfo.constructor) {
+        const availableObjects = Array.from(
+          ObjectRegistry.getAllClasses().values()
+        ).map((info) => info.name);
+        const availableList = availableObjects.length > 0 ? `Available objects:
+  ${availableObjects.join("\n  ")}` : 'No objects registered. Run "npm run build" to generate registrations.';
+        this.exitWithError(
+          `Object class '${objectName}' not found.
+
+${availableList}
+
+Troubleshooting:
+1. Run "npm run build" to generate .smrt/register.js
+2. Ensure package exports classes correctly
+3. Run "smrt doctor" for diagnostics`
+        );
+        return;
+      }
+      const jsonMode = options.json === true;
+      const spinner = jsonMode ? {
+        succeed: (_text) => {
+        },
+        fail: (msg) => {
+          if (msg) {
+            console.error(msg);
+          }
+        }
+      } : this.createSpinner(`Executing ${methodName} on ${objectName}...`);
+      const { getConfig, getPackageConfig, getModuleConfig } = await import("@happyvertical/smrt-config");
+      const smrtConfig = getConfig() || {};
+      const moduleConfig = getModuleConfig(objectName.toLowerCase(), {});
+      const { DEFAULT_CLI_CONFIG } = await import("./config-C8pQD-tk.js");
+      const cliConfig = getPackageConfig("cli", DEFAULT_CLI_CONFIG);
+      let db = this.context.db;
+      if (!db && cliConfig?.database?.url) {
+        const { getDatabase } = await import("@happyvertical/sql");
+        db = await getDatabase({
+          type: cliConfig.database.type || "sqlite",
+          url: cliConfig.database.url
+        });
+      }
+      const isManifestStub = classInfo.constructor?._isManifestStub === true;
+      if (process.env.DEBUG) {
+        console.log(`[DEBUG] ${objectName} constructor info:`);
+        console.log(`  - isManifestStub: ${isManifestStub}`);
+        console.log(
+          `  - constructor name: ${classInfo.constructor?.name || "undefined"}`
+        );
+        console.log(`  - packageName: ${classInfo.packageName || "local"}`);
+      }
+      if (isManifestStub) {
+        this.exitWithError(
+          `${objectName} is registered from manifest but the real class wasn't loaded.
+
+This usually means:
+1. The .smrt/register.js file doesn't import the class
+2. The package doesn't export the class properly
+3. The class name in the package doesn't match the manifest
+
+Try:
+- Run 'npm run build' to regenerate .smrt/register.js
+- Check that the package exports the ${objectName} class
+- Check .smrt/register.js imports match the package exports`
+        );
+        return;
+      }
+      if (typeof classInfo.constructor !== "function") {
+        this.exitWithError(
+          `${objectName} constructor is not available.
+This usually means the class wasn't properly exported or registered.
+Check that the package exports the class and .smrt/register.js imports it.`
+        );
+        return;
+      }
+      const useCliDb = db && !moduleConfig?.db;
+      const instanceConfig = {
+        ...smrtConfig,
+        ...moduleConfig,
+        ...useCliDb && { db },
+        ...this.context.ai && { ai: this.context.ai },
+        // In JSON mode, silence all log output to ensure clean JSON
+        ...jsonMode && { silent: true }
+      };
+      const obj = new classInfo.constructor(instanceConfig);
+      if (typeof obj.initialize === "function") {
+        await obj.initialize();
+      }
+      const method = obj[methodName];
+      if (typeof method !== "function") {
+        spinner.fail(`Method ${methodName} is not a function`);
+        this.exitWithError(`Method ${methodName} is not callable`);
+        return;
+      }
+      const methodParams = methodDef?.parameters || [];
+      const methodCallArgs = [];
+      for (const param of methodParams) {
+        const typeStr = param.type || "";
+        const isObjectType = this.isObjectTypeParameter(typeStr);
+        if (isObjectType) {
+          const objArg = {};
+          const match = typeStr.match(/\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}/);
+          if (match) {
+            const propsStr = match[1];
+            const propMatches = propsStr.matchAll(/(\w+)(\?)?:\s*([^;]+)/g);
+            for (const propMatch of propMatches) {
+              const [, propName] = propMatch;
+              const optionName = propName.replace(/([A-Z])/g, "-$1").toLowerCase();
+              if (options[optionName] !== void 0) {
+                let value = options[optionName];
+                if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+                  try {
+                    value = JSON.parse(value);
+                  } catch {
+                  }
+                }
+                objArg[propName] = value;
+              }
+            }
+          }
+          if (Object.keys(objArg).length > 0) {
+            methodCallArgs.push(objArg);
+          } else if (!param.optional) {
+            methodCallArgs.push({});
+          } else {
+            methodCallArgs.push(void 0);
+          }
+        } else {
+          const optionName = param.name.replace(/([A-Z])/g, "-$1").toLowerCase();
+          if (options[optionName] !== void 0) {
+            methodCallArgs.push(options[optionName]);
+          } else if (param.default !== void 0) {
+            methodCallArgs.push(param.default);
+          } else {
+            methodCallArgs.push(void 0);
+          }
+        }
+      }
+      const result = await method.call(obj, ...methodCallArgs);
+      spinner.succeed(`Executed ${methodName}`);
+      if (result !== void 0) {
+        console.log(JSON.stringify(result, null, 2));
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      const errorStack = error instanceof Error ? error.stack : void 0;
+      console.error(`
+Error executing ${objectName}.${methodName}():`);
+      console.error(`  ${errorMessage}`);
+      if (errorStack && process.env.DEBUG) {
+        console.error("\nStack trace:");
+        console.error(errorStack);
+      }
+      const schemaGuidance = errorMessage.includes("Run 'smrt db:migrate'");
+      console.error(
+        schemaGuidance ? "\nTip: Prepare the database schema before running generated CLI commands." : "\nTip: Set DEBUG=1 for full stack trace, or check the method implementation."
+      );
+      this.exitWithError(errorMessage);
+    }
+  }
+  /**
+   * Get or create collection for an object
+   * Uses database configuration from smrt.config.js or defaults to :memory:
+   */
+  async getCollection(objectName) {
+    if (!this.collections.has(objectName)) {
+      const classInfo = ObjectRegistry.getClass(objectName);
+      if (!classInfo || !classInfo.collectionConstructor) {
+        const availableObjects = Array.from(
+          ObjectRegistry.getAllClasses().values()
+        ).map((info) => info.name);
+        throw new Error(
+          `Object '${objectName}' not found or has no collection constructor.
+
+Available objects:
+  ${availableObjects.join("\n  ")}
+
+Troubleshooting:
+1. If from external package, ensure it's installed:
+   npm install <package-name>
+
+2. Rebuild your project to regenerate manifest:
+   npm run build
+
+3. Check .smrt/manifest.json contains the object
+
+4. Verify package exports classes correctly
+5. Run with verbose mode for more details:
+   SMRT_CLI_VERBOSE=true npx smrt ${objectName}:list
+`
+        );
+      }
+      let db = this.context.db;
+      if (!db) {
+        const { getPackageConfig } = await import("@happyvertical/smrt-config");
+        const { DEFAULT_CLI_CONFIG } = await import("./config-C8pQD-tk.js");
+        const config = getPackageConfig("cli", DEFAULT_CLI_CONFIG);
+        const { getDatabase } = await import("@happyvertical/sql");
+        db = await getDatabase({
+          type: config.database.type,
+          url: config.database.url
+        });
+        if (config.verbose) {
+          console.log(`[CLI] Using database: ${config.database.url}`);
+        }
+      }
+      const collection2 = new classInfo.collectionConstructor({
+        ai: this.context.ai,
+        db
+      });
+      await collection2.initialize();
+      this.collections.set(objectName, collection2);
+    }
+    const collection = this.collections.get(objectName);
+    if (!collection) throw new Error(`Collection ${objectName} not found`);
+    return collection;
+  }
+  /**
+   * Interactive field prompts
+   */
+  async promptForFields(objectName, current) {
+    const fields = ObjectRegistry.getFields(objectName);
+    const result = {};
+    for (const [fieldName, field] of fields) {
+      const currentValue = current[fieldName];
+      let message = `${fieldName}`;
+      if (field.options?.description) {
+        message += ` (${field.options.description})`;
+      }
+      if (currentValue !== void 0) {
+        message += ` [${currentValue}]`;
+      }
+      message += ": ";
+      if (field.type === "boolean") {
+        result[fieldName] = await this.confirm(message);
+      } else {
+        const input = await this.prompt(message);
+        if (input.trim()) {
+          result[fieldName] = this.parseFieldValue(input);
+        } else if (currentValue !== void 0) {
+          result[fieldName] = currentValue;
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Parse field value from string
+   */
+  parseFieldValue(value) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  /**
+   * Display results as table
+   */
+  displayTable(results, objectName) {
+    if (results.length === 0) {
+      console.log(`No ${objectName} objects found`);
+      return;
+    }
+    const keys = ["id", "name", "slug", "created_at"];
+    const rows = results.map(
+      (item) => keys.map((key) => String(item[key] || "").substring(0, 30))
+    );
+    console.log();
+    console.log(keys.join("	"));
+    console.log("-".repeat(80));
+    rows.forEach((row) => {
+      console.log(row.join("	"));
+    });
+    console.log();
+  }
+  /**
+   * Convert object to YAML-like string
+   */
+  toYamlString(obj, indent = 0) {
+    const spaces = "  ".repeat(indent);
+    let result = "";
+    for (const [key, value] of Object.entries(obj)) {
+      if (value === null || value === void 0) {
+        result += `${spaces}${key}: null
+`;
+      } else if (typeof value === "object" && !Array.isArray(value)) {
+        result += `${spaces}${key}:
+${this.toYamlString(value, indent + 1)}`;
+      } else if (Array.isArray(value)) {
+        result += `${spaces}${key}:
+`;
+        value.forEach((item) => {
+          result += `${spaces}  - ${item}
+`;
+        });
+      } else {
+        result += `${spaces}${key}: ${value}
+`;
+      }
+    }
+    return result;
+  }
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const timingEnabled = args.includes("--timing");
+  const timing = {};
+  const startTime = timingEnabled ? performance.now() : 0;
+  {
+    const fs = await import("node:fs");
+    const path = await import("node:path");
+    const configNames = [
+      "smrt.config.js",
+      "smrt.config.mjs",
+      "smrt.config.cjs",
+      "smrt.config.json"
+    ];
+    let dir = process.cwd();
+    const { root } = path.parse(dir);
+    while (dir !== root) {
+      if (configNames.some((name) => fs.existsSync(path.join(dir, name)))) {
+        try {
+          const { loadEnvFile } = await import("node:process");
+          loadEnvFile(path.join(dir, ".env"));
+        } catch {
+        }
+        break;
+      }
+      dir = path.dirname(dir);
+    }
+  }
+  const configStart = timingEnabled ? performance.now() : 0;
+  const { loadConfig } = await import("@happyvertical/smrt-config");
+  await loadConfig({ cache: true });
+  if (timingEnabled) {
+    timing.config = performance.now() - configStart;
+  }
+  const config = {
+    name: "smrt",
+    version: CLI_VERSION,
+    description: "Admin CLI for smrt objects",
+    prompt: !process.env.CI,
+    // Disable prompts in CI
+    colors: !process.env.NO_COLOR && process.stdout.isTTY
+  };
+  const context = {
+    // db and ai can be configured via environment or initialized here
+    timing: timingEnabled ? timing : void 0
+  };
+  const cli = new CLIGenerator(config, context);
+  const handler = cli.generateHandler();
+  const filteredArgs = args.filter((arg) => arg !== "--timing");
+  try {
+    await handler(filteredArgs);
+  } catch (error) {
+    console.error(
+      "CLI Error:",
+      error instanceof Error ? error.message : "Unknown error"
+    );
+    process.exit(1);
+  }
+  if (timingEnabled) {
+    timing.total = performance.now() - startTime;
+    console.log("\n⏱  Startup Timing:");
+    console.log(`   Config load:      ${timing.config?.toFixed(0) ?? "N/A"}ms`);
+    console.log(
+      `   Class loading:    ${timing.classLoading?.toFixed(0) ?? "N/A"}ms`
+    );
+    console.log(
+      `   Command gen:      ${timing.commandGen?.toFixed(0) ?? "N/A"}ms`
+    );
+    console.log(`   Total startup:    ${timing.total.toFixed(0)}ms`);
+  }
+}
+const cliEntryGlobal = globalThis;
+if (!cliEntryGlobal.__SMRT_CLI_ENTRY_RUNNING__) {
+  cliEntryGlobal.__SMRT_CLI_ENTRY_RUNNING__ = true;
+  main().catch((error) => {
+    console.error(
+      "CLI Error:",
+      error instanceof Error ? error.message : "Unknown error"
+    );
+    process.exit(1);
+  });
+}