@happyvertical/smrt-core 0.30.0

package/dist/vite-plugin/index.js

@@ -0,0 +1,1400 @@
+import { readFileSync, existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildDomainKnowledgeManifest } from "../knowledge.js";
+import { discoverSmrtPackages } from "../manifest/discover-smrt-packages.js";
+import { importWorkspaceModule } from "../utils/import-workspace-module.js";
+import { importBuildAwareModule } from "./import-build-aware.js";
+import { generateSvelteKitRoutes, validateCliIncludeAgainstApi, resolveApiActionSet, findCliApiCoherenceViolations, methodNameToKebab } from "./sveltekit-generator.js";
+const VIRTUAL_MODULES = {
+  "@happyvertical/smrt-virt-routes": "smrt:routes",
+  "@happyvertical/smrt-virt-client": "smrt:client",
+  "@happyvertical/smrt-virt-mcp": "smrt:mcp",
+  "@happyvertical/smrt-virt-types": "smrt:types",
+  "@happyvertical/smrt-virt-manifest": "smrt:manifest",
+  "@happyvertical/smrt-virt-schema": "smrt:schema",
+  "@happyvertical/smrt-virt-ui": "smrt:ui",
+  "@happyvertical/smrt-virt-cli": "smrt:cli"
+};
+async function importScanner() {
+  return importWorkspaceModule({
+    packageName: "@happyvertical/smrt-scanner",
+    distEntry: "packages/scanner/dist/index.js",
+    sourceEntry: "packages/scanner/src/index.ts",
+    purpose: "Vite manifest scanning"
+  });
+}
+function smrtPlugin(options = {}) {
+  const {
+    include = ["src/**/*.ts", "src/**/*.js"],
+    exclude = ["**/*.test.ts", "**/*.spec.ts", "**/node_modules/**"],
+    hmr = true,
+    watch = true,
+    generateTypes = true,
+    baseClasses = ["SmrtObject", "SmartObject"],
+    followImports = true,
+    // Default true: needed for multi-package inheritance
+    typeDeclarationsPath = "src/types",
+    mode = "auto",
+    svelteKit = {
+      enabled: false,
+      routesDir: "src/routes/api",
+      objectsDir: "src/lib/objects",
+      configPath: "src/lib/server",
+      configFileName: "smrt.ts"
+    },
+    knowledge,
+    validateCliApiCoherence = true
+  } = options;
+  function warnCliApiCoherenceViolations(m) {
+    if (!validateCliApiCoherence) return;
+    const violations = findCliApiCoherenceViolations(m);
+    if (violations.length === 0) return;
+    for (const { className, unreachable } of violations) {
+      for (const action of unreachable) {
+        console.warn(
+          `[smrt] ${className}.${action} is declared in cli.include but is not exposed via the api. Build will fail until this is resolved.
+  Either:
+    - Add '${action}' to api.include, or
+    - Remove '${action}' from cli.include.
+  The CLI invokes methods over HTTP; methods without API routes are unreachable.
+  If this CLI is intentionally invoked in-process (no HTTP), set
+  \`cli: { skipApiCheck: true }\` on the @smrt() decorator to acknowledge.`
+        );
+      }
+    }
+  }
+  let server;
+  let manifest = null;
+  let pluginMode = "server";
+  let projectRoot = process.cwd();
+  let config = null;
+  let resolvedPluginNames = [];
+  async function writeLocalManifest(m, rootDir) {
+    try {
+      const { writeFileSync, mkdirSync } = await import("node:fs");
+      const { resolve } = await import("node:path");
+      const smrtDir = resolve(rootDir, ".smrt");
+      mkdirSync(smrtDir, { recursive: true });
+      const manifestPath = resolve(smrtDir, "manifest.json");
+      writeFileSync(manifestPath, JSON.stringify(m, null, 2), "utf-8");
+      await writeDomainKnowledgeArtifact(
+        m,
+        rootDir,
+        resolve(smrtDir, "smrt-knowledge.json"),
+        manifestPath
+      );
+      const objectCount = Object.keys(m.objects).length;
+      console.log(
+        `[smrt] Wrote local manifest with ${objectCount} objects to .smrt/manifest.json`
+      );
+    } catch (error) {
+      console.error("[smrt] Error writing local manifest:", error);
+    }
+  }
+  async function writeDomainKnowledgeArtifact(m, rootDir, outputPath, manifestPath) {
+    const resolvedKnowledge = await resolveKnowledgeConfig(rootDir, m);
+    if (resolvedKnowledge.enabled === false) {
+      return;
+    }
+    const { mkdirSync, writeFileSync } = await import("node:fs");
+    const { dirname: dirname2 } = await import("node:path");
+    mkdirSync(dirname2(outputPath), { recursive: true });
+    const artifact = buildDomainKnowledgeManifest({
+      manifest: m,
+      rootDir,
+      manifestPath,
+      config: resolvedKnowledge
+    });
+    writeFileSync(
+      outputPath,
+      JSON.stringify(
+        preserveKnowledgeGeneratedAt(outputPath, artifact),
+        null,
+        2
+      ),
+      "utf-8"
+    );
+  }
+  async function resolveKnowledgeConfig(rootDir, m) {
+    if (knowledge === false) return { enabled: false };
+    const packageName = m.packageName ?? readPackageName(rootDir);
+    const defaults = {
+      enabled: true,
+      api: {
+        enabled: false,
+        basePath: "/__smrt/knowledge",
+        requireAdmin: true,
+        includeDocs: false,
+        includePrompts: false
+      },
+      includeDocs: true,
+      includePrompts: true
+    };
+    let fileKnowledge = {};
+    let packageKnowledge = {};
+    try {
+      const previousCwd = process.cwd();
+      process.chdir(rootDir);
+      try {
+        const { loadConfig } = await import("@happyvertical/smrt-config");
+        const config2 = await loadConfig({ cache: false });
+        fileKnowledge = config2.knowledge ?? {};
+        packageKnowledge = packageName ? config2.packages?.[packageName]?.knowledge ?? {} : {};
+      } finally {
+        process.chdir(previousCwd);
+      }
+    } catch {
+      fileKnowledge = {};
+      packageKnowledge = {};
+    }
+    return mergeKnowledgeConfig(
+      defaults,
+      fileKnowledge,
+      packageKnowledge,
+      knowledge || {}
+    );
+  }
+  function mergeKnowledgeConfig(...configs) {
+    const merged = {};
+    for (const next of configs) {
+      if (!next) continue;
+      const hasApi = Boolean(merged.api || next.api);
+      const api = hasApi ? { ...merged.api ?? {}, ...next.api ?? {} } : void 0;
+      Object.assign(merged, next);
+      if (api) merged.api = api;
+    }
+    return merged;
+  }
+  function preserveKnowledgeGeneratedAt(outputPath, nextKnowledge) {
+    if (!existsSync(outputPath)) return nextKnowledge;
+    try {
+      const current = JSON.parse(readFileSync(outputPath, "utf8"));
+      if (semanticKnowledgeJson(current) === semanticKnowledgeJson(nextKnowledge)) {
+        return {
+          ...nextKnowledge,
+          generatedAt: current.generatedAt
+        };
+      }
+    } catch {
+    }
+    return nextKnowledge;
+  }
+  function semanticKnowledgeJson(artifact) {
+    const { generatedAt: _generatedAt, ...rest } = artifact ?? {};
+    return JSON.stringify(sortJson(rest));
+  }
+  function sortJson(value) {
+    if (Array.isArray(value)) return value.map(sortJson);
+    if (value && typeof value === "object") {
+      return Object.fromEntries(
+        Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => [key, sortJson(entry)])
+      );
+    }
+    return value;
+  }
+  function readPackageName(rootDir) {
+    try {
+      const pkg = JSON.parse(
+        readFileSync(join(rootDir, "package.json"), "utf8")
+      );
+      return typeof pkg.name === "string" ? pkg.name : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  function validateConsumerPluginSetup(m, context) {
+    if (config?.mode === "test") {
+      return;
+    }
+    if (config?.build?.lib) {
+      return;
+    }
+    const consumerDependencies = (m.smrtDependencies || []).filter(
+      (dependency) => dependency !== "@happyvertical/smrt-core"
+    );
+    if (consumerDependencies.length === 0) {
+      return;
+    }
+    const hasConsumerPlugin = resolvedPluginNames.some(
+      (name) => name === "smrt-consumer"
+    );
+    if (hasConsumerPlugin) {
+      return;
+    }
+    const dependencySummary = consumerDependencies.length <= 4 ? consumerDependencies.join(", ") : `${consumerDependencies.slice(0, 4).join(", ")}, +${consumerDependencies.length - 4} more`;
+    throw new Error(
+      `[smrt] Consumer project misconfiguration detected during ${context}: found external SMRT dependencies (${dependencySummary}) but vite.config is missing smrtConsumer(). Add "import { smrtConsumer } from '@happyvertical/smrt-core/consumer-plugin'" and register it alongside smrtPlugin() so .smrt/register.js is generated for CLI/runtime class loading.`
+    );
+  }
+  function validateLibraryMinifySetup(m, context) {
+    if (!config?.build?.lib) {
+      return;
+    }
+    if (Object.keys(m.objects || {}).length === 0) {
+      return;
+    }
+    if (config.build.minify === false) {
+      return;
+    }
+    throw new Error(
+      `[smrt] Library package misconfiguration detected during ${context}: packages that publish SMRT objects must set Vite build.minify = false. Minification rewrites runtime class names and breaks manifest registration, STI resolution, and collection queries in downstream apps.`
+    );
+  }
+  return {
+    name: "smrt-auto-service",
+    // Expose options for external access (e.g., test manifest generation)
+    api: {
+      options: {
+        baseClasses,
+        followImports,
+        include,
+        exclude
+      }
+    },
+    async configResolved(resolvedConfig) {
+      config = resolvedConfig;
+      resolvedPluginNames = (resolvedConfig.plugins || []).map(
+        (plugin) => plugin?.name || ""
+      );
+      projectRoot = resolvedConfig.root;
+      if (mode === "auto") {
+        const isSSRBuild = resolvedConfig.build?.ssr;
+        const isFederationBuild = resolvedConfig.plugins.some(
+          (p) => p.name?.includes("federation")
+        );
+        const isClientBuild = isFederationBuild || !isSSRBuild && resolvedConfig.build?.target === "esnext";
+        pluginMode = isClientBuild ? "client" : "server";
+      } else {
+        pluginMode = mode;
+      }
+      console.log(`[smrt] Running in ${pluginMode} mode`);
+      manifest = await scanAndGenerateManifest(projectRoot);
+      if (manifest) {
+        await writeLocalManifest(manifest, projectRoot);
+        validateLibraryMinifySetup(manifest, "configResolved");
+        validateConsumerPluginSetup(manifest, "configResolved");
+        if (validateCliApiCoherence) {
+          validateCliIncludeAgainstApi(manifest);
+        }
+      }
+      if (svelteKit.enabled && manifest) {
+        await generateSvelteKitRoutes(resolvedConfig.root, manifest, {
+          enabled: svelteKit.enabled,
+          routesDir: svelteKit.routesDir || "src/routes/api",
+          objectsDir: svelteKit.objectsDir || "src/lib/objects",
+          configPath: svelteKit.configPath || "src/lib/server",
+          configFileName: svelteKit.configFileName || "smrt.ts",
+          kebabRoutes: svelteKit.kebabRoutes ?? false,
+          knowledge: await resolveKnowledgeConfig(
+            resolvedConfig.root,
+            manifest
+          )
+        });
+      }
+    },
+    async buildStart() {
+      manifest = await scanAndGenerateManifest(projectRoot);
+      if (manifest) {
+        await writeLocalManifest(manifest, projectRoot);
+        validateLibraryMinifySetup(manifest, "buildStart");
+        validateConsumerPluginSetup(manifest, "buildStart");
+        if (validateCliApiCoherence) {
+          validateCliIncludeAgainstApi(manifest);
+        }
+      }
+    },
+    configureServer(devServer) {
+      server = devServer;
+      devServer.middlewares.use(async (req, res, next) => {
+        if (svelteKit.enabled) {
+          return next();
+        }
+        if (req.url === "/" || req.url === "/index.html") {
+          try {
+            const { existsSync: existsSync2 } = await import("node:fs");
+            const { join: join2 } = await import("node:path");
+            const projectRoot2 = devServer.config.root;
+            const indexPath = join2(projectRoot2, "index.html");
+            if (existsSync2(indexPath)) {
+              return next();
+            }
+            console.log("[smrt] Serving default UI (no index.html found)");
+            let html = getDefaultHTML();
+            html = await devServer.transformIndexHtml("/", html);
+            res.setHeader("Content-Type", "text/html");
+            res.end(html);
+            return;
+          } catch (error) {
+            console.error("[smrt] Error serving default HTML:", error);
+            return next();
+          }
+        }
+        next();
+      });
+      if (watch && hmr) {
+        const watcher = devServer.watcher;
+        watcher.on("change", async (file) => {
+          try {
+            if (await shouldRescan(file)) {
+              console.log(`[smrt] Rescanning due to change in ${file}`);
+              manifest = await scanAndGenerateManifest(projectRoot);
+              if (manifest) {
+                await writeLocalManifest(manifest, projectRoot);
+                warnCliApiCoherenceViolations(manifest);
+              }
+              if (svelteKit.enabled && manifest && server) {
+                await generateSvelteKitRoutes(server.config.root, manifest, {
+                  enabled: svelteKit.enabled,
+                  routesDir: svelteKit.routesDir || "src/routes/api",
+                  objectsDir: svelteKit.objectsDir || "src/lib/objects",
+                  configPath: svelteKit.configPath || "src/lib/server",
+                  configFileName: svelteKit.configFileName || "smrt.ts",
+                  kebabRoutes: svelteKit.kebabRoutes ?? false,
+                  knowledge: await resolveKnowledgeConfig(
+                    server.config.root,
+                    manifest
+                  )
+                });
+              }
+              Object.values(VIRTUAL_MODULES).forEach((id) => {
+                const module = server?.moduleGraph.getModuleById(id);
+                if (module) {
+                  server?.reloadModule(module);
+                }
+              });
+            }
+          } catch (error) {
+            console.error(
+              `[smrt] Failed to rescan after change in ${file}:`,
+              error
+            );
+          }
+        });
+        watcher.on("add", async (file) => {
+          try {
+            if (await shouldRescan(file)) {
+              console.log(`[smrt] Rescanning due to new file ${file}`);
+              manifest = await scanAndGenerateManifest(projectRoot);
+              if (manifest) {
+                await writeLocalManifest(manifest, projectRoot);
+                warnCliApiCoherenceViolations(manifest);
+              }
+              if (svelteKit.enabled && manifest && server) {
+                await generateSvelteKitRoutes(server.config.root, manifest, {
+                  enabled: svelteKit.enabled,
+                  routesDir: svelteKit.routesDir || "src/routes/api",
+                  objectsDir: svelteKit.objectsDir || "src/lib/objects",
+                  configPath: svelteKit.configPath || "src/lib/server",
+                  configFileName: svelteKit.configFileName || "smrt.ts",
+                  kebabRoutes: svelteKit.kebabRoutes ?? false,
+                  knowledge: await resolveKnowledgeConfig(
+                    server.config.root,
+                    manifest
+                  )
+                });
+              }
+            }
+          } catch (error) {
+            console.error(
+              `[smrt] Failed to rescan after adding ${file}:`,
+              error
+            );
+          }
+        });
+        watcher.on("unlink", async (file) => {
+          try {
+            if (await shouldRescan(file)) {
+              console.log(`[smrt] Rescanning due to removed file ${file}`);
+              manifest = await scanAndGenerateManifest(projectRoot);
+              if (manifest) {
+                await writeLocalManifest(manifest, projectRoot);
+                warnCliApiCoherenceViolations(manifest);
+              }
+              if (svelteKit.enabled && manifest && server) {
+                await generateSvelteKitRoutes(server.config.root, manifest, {
+                  enabled: svelteKit.enabled,
+                  routesDir: svelteKit.routesDir || "src/routes/api",
+                  objectsDir: svelteKit.objectsDir || "src/lib/objects",
+                  configPath: svelteKit.configPath || "src/lib/server",
+                  configFileName: svelteKit.configFileName || "smrt.ts",
+                  kebabRoutes: svelteKit.kebabRoutes ?? false,
+                  knowledge: await resolveKnowledgeConfig(
+                    server.config.root,
+                    manifest
+                  )
+                });
+              }
+            }
+          } catch (error) {
+            console.error(
+              `[smrt] Failed to rescan after removing ${file}:`,
+              error
+            );
+          }
+        });
+      }
+    },
+    resolveId(id) {
+      if (id in VIRTUAL_MODULES) {
+        return `\0${VIRTUAL_MODULES[id]}`;
+      }
+      if (id === "/index.html" && server) {
+        return `\0smrt:index-html`;
+      }
+      return null;
+    },
+    async load(id) {
+      const cleanId = id.startsWith("\0") ? id.slice(1) : id;
+      if (!manifest) {
+        manifest = await scanAndGenerateManifest(projectRoot);
+      }
+      switch (cleanId) {
+        case "smrt:routes":
+          return await generateRoutesModule(manifest);
+        case "smrt:client":
+          return generateClientModule(manifest, {
+            kebabRoutes: svelteKit.kebabRoutes ?? false
+          });
+        case "smrt:mcp":
+          return await generateMCPModule(manifest);
+        case "smrt:types":
+          return await generateTypesModule(manifest, pluginMode);
+        case "smrt:manifest":
+          return generateManifestModule(manifest);
+        case "smrt:schema":
+          return await generateSchemaModule(manifest);
+        case "smrt:ui":
+          return await loadDefaultUI();
+        case "smrt:index-html":
+          return await loadDefaultHTML();
+        case "smrt:cli":
+          return await generateCLIModule(manifest);
+        default:
+          return null;
+      }
+    },
+    transformIndexHtml: {
+      order: "pre",
+      handler: async (html, _ctx) => {
+        if (!server) return html;
+        try {
+          const { existsSync: existsSync2 } = await import("node:fs");
+          const { join: join2 } = await import("node:path");
+          const projectRoot2 = server.config.root;
+          const indexPath = join2(projectRoot2, "index.html");
+          if (existsSync2(indexPath)) {
+            return html;
+          }
+          return await loadDefaultHTML();
+        } catch (error) {
+          console.error("[smrt] Error checking for index.html:", error);
+          return html;
+        }
+      }
+    },
+    async closeBundle() {
+      if (!manifest || !config.build?.lib) {
+        return;
+      }
+      try {
+        const { writeFileSync, mkdirSync } = await import("node:fs");
+        const { resolve, dirname: dirname2 } = await import("node:path");
+        const outDir = config.build?.rollupOptions?.output?.dir || config.build?.outDir || "dist";
+        const manifestPath = resolve(projectRoot, outDir, "manifest.json");
+        const knowledgePath = resolve(
+          projectRoot,
+          outDir,
+          "smrt-knowledge.json"
+        );
+        mkdirSync(dirname2(manifestPath), { recursive: true });
+        writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+        await writeDomainKnowledgeArtifact(
+          manifest,
+          projectRoot,
+          knowledgePath,
+          manifestPath
+        );
+        const objectCount = Object.keys(manifest.objects).length;
+        console.log(
+          `[smrt] Wrote manifest with ${objectCount} objects to ${manifestPath}`
+        );
+      } catch (error) {
+        console.error("[smrt] Error writing manifest file:", error);
+      }
+    }
+  };
+  async function scanAndGenerateManifest(rootDir) {
+    try {
+      return await scanWithOxc(rootDir);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("Cannot find package")) {
+        console.error(
+          "[smrt] @happyvertical/smrt-scanner is required but not installed."
+        );
+        console.error(
+          "[smrt] Install it: pnpm add @happyvertical/smrt-scanner"
+        );
+      }
+      console.error("[smrt] Error scanning files:", error);
+      throw error;
+    }
+  }
+  async function scanWithOxc(rootDir) {
+    const startTime = performance.now();
+    try {
+      const { OxcScanner, ManifestAdapter } = await importScanner();
+      console.log(`[smrt] Using experimental OXC scanner for faster builds`);
+      const safeExclude = [...exclude || [], "**/*.svelte"];
+      const scanner = new OxcScanner({
+        cwd: rootDir,
+        include,
+        exclude: safeExclude
+      });
+      const { results, resolved } = await scanner.scanAndResolve();
+      if (results.errors.length > 0) {
+        console.error(
+          `
+[smrt] ❌ Build failed: ${results.errors.length} error(s) during scanning:
+`
+        );
+        for (const error of results.errors) {
+          console.error(
+            `  ${error.filePath}:${error.line || "?"}: ${error.message}
+`
+          );
+        }
+        throw new Error(
+          "[smrt] Build aborted due to scan errors. See above for details."
+        );
+      }
+      let packageName;
+      let packageVersion;
+      let packageJson;
+      try {
+        const { readFileSync: readFileSync2 } = await import("node:fs");
+        const { join: join2 } = await import("node:path");
+        const pkgPath = join2(rootDir, "package.json");
+        const pkgContent = readFileSync2(pkgPath, "utf-8");
+        packageJson = JSON.parse(pkgContent);
+        packageName = packageJson.name || void 0;
+        packageVersion = packageJson.version || void 0;
+      } catch {
+        console.warn(
+          "[smrt] Warning: package.json not found. Qualified names will not be generated."
+        );
+      }
+      const adapter = new ManifestAdapter();
+      const newManifest = adapter.toManifest(resolved, {
+        packageName,
+        packageVersion,
+        typeAliases: results.typeAliases
+      });
+      newManifest.moduleType = "smrt";
+      const smrtDependencies = discoverSmrtPackages({ baseDir: rootDir });
+      if (smrtDependencies.length > 0) {
+        newManifest.smrtDependencies = smrtDependencies;
+        console.log(
+          `[smrt] Found ${smrtDependencies.length} SMRT dependencies: ${smrtDependencies.join(", ")}`
+        );
+      }
+      const { ManifestGenerator } = await importBuildAwareModule({
+        source: "../scanner/index.ts",
+        dist: "../scanner.js"
+      });
+      const manifestGen = new ManifestGenerator();
+      manifestGen.injectTenantScopedFields(newManifest);
+      manifestGen.mergeInheritedFields(newManifest);
+      manifestGen.generateValidationRules(newManifest);
+      manifestGen.generateSchemas(newManifest);
+      manifestGen.assertTenantScopedSchemaContract(newManifest);
+      manifestGen.generateAgentManifests(newManifest, packageName, packageJson);
+      const elapsed = performance.now() - startTime;
+      const objectCount = Object.keys(newManifest.objects).length;
+      if (objectCount > 0) {
+        const names = Object.keys(newManifest.objects).join(", ");
+        console.log(`[smrt] Found ${objectCount} SMRT objects: ${names}`);
+      } else {
+        console.log("[smrt] No SMRT objects found");
+      }
+      console.log(`[smrt] OXC scan completed in ${elapsed.toFixed(2)}ms`);
+      if (generateTypes && server) {
+        await generateTypeDeclarationFile(
+          newManifest,
+          rootDir,
+          typeDeclarationsPath
+        );
+      }
+      return newManifest;
+    } catch (error) {
+      console.error("[smrt] Error in OXC scanner:", error);
+      throw error;
+    }
+  }
+  async function shouldRescan(file) {
+    if (pluginMode === "client") {
+      return false;
+    }
+    try {
+      const { minimatch } = await import("../node_modules/.pnpm/minimatch@10.2.3/node_modules/minimatch/dist/esm/index.js");
+      const isIncluded = include.some((pattern) => minimatch(file, pattern));
+      const isExcluded = exclude.some((pattern) => minimatch(file, pattern));
+      return isIncluded && !isExcluded;
+    } catch (error) {
+      console.warn("[smrt] Error checking file patterns:", error);
+      return false;
+    }
+  }
+}
+async function generateRoutesModule(manifest) {
+  try {
+    const { ManifestGenerator } = await importBuildAwareModule({
+      source: "../scanner/index.ts",
+      dist: "../scanner.js"
+    });
+    const generator = new ManifestGenerator();
+    const routes = generator.generateRestEndpoints(manifest);
+    return `
+// Auto-generated REST routes from SMRT objects
+// This file is generated automatically - do not edit
+
+/**
+ * Setup routes on an Express-like app
+ *
+ * NOTE: This virtual module function is for documentation only.
+ * For actual route registration, use:
+ * - import { startRestServer } from '@happyvertical/smrt-core'
+ * - Or APIGenerator from '@happyvertical/smrt-core/generators'
+ *
+ * @param app - Express-like app instance
+ * @param options - Route configuration options
+ * @param options.basePath - Base path for all routes (default: '/api/v1')
+ */
+export function setupRoutes(app, options = {}) {
+  const basePath = options.basePath || '/api/v1';
+
+  console.warn('[smrt] setupRoutes is a documentation function only.');
+  console.warn('[smrt] Use startRestServer() or APIGenerator for actual route registration.');
+  console.warn('[smrt] Available endpoints:');
+${routes.split("\\n").map((line) => `  console.warn(\`  \${basePath}${line.trim()}\`);`).join("\\n")}
+}
+
+export { setupRoutes as default };
+`;
+  } catch (error) {
+    console.warn("[smrt] Error generating routes module:", error);
+    return 'export function setupRoutes(app, options = {}) { console.warn("Routes generation failed"); }';
+  }
+}
+function lowerFirst(value) {
+  return value ? value[0].toLowerCase() + value.slice(1) : value;
+}
+function uniqueApiClientEntries(objects) {
+  const usedKeys = /* @__PURE__ */ new Set();
+  return objects.map(([objectName, obj]) => {
+    let clientKey = obj.collection;
+    if (usedKeys.has(clientKey)) {
+      clientKey = lowerFirst(obj.className);
+    }
+    const baseClientKey = clientKey;
+    let suffix = 2;
+    while (usedKeys.has(clientKey)) {
+      clientKey = `${baseClientKey}${suffix}`;
+      suffix += 1;
+    }
+    usedKeys.add(clientKey);
+    return { objectName, obj, clientKey };
+  });
+}
+function generateClientModule(manifest, options = {}) {
+  const objects = uniqueApiClientEntries(Object.entries(manifest.objects));
+  const clientMethods = objects.map(({ obj, clientKey }) => {
+    const { collection, methods = {} } = obj;
+    const exposedActions = resolveApiActionSet(obj);
+    const apiConfig = obj.decoratorConfig?.api;
+    const apiRoutes = apiConfig && typeof apiConfig === "object" ? apiConfig.routes ?? {} : {};
+    const customMethods = Object.entries(methods).filter(
+      ([name, method]) => method.isPublic && exposedActions.has(name)
+    );
+    const segmentFor = (methodName) => {
+      const overridePath = apiRoutes[methodName]?.path;
+      if (overridePath) {
+        const trimmed = overridePath.split("/").map((s) => s.trim()).filter(Boolean).join("/");
+        if (trimmed.length > 0) return trimmed;
+      }
+      return options.kebabRoutes ? methodNameToKebab(methodName) : methodName;
+    };
+    const customMethodImpls = customMethods.map(([methodName, _method]) => {
+      const urlSegment = segmentFor(methodName);
+      return `    ${methodName}: (id, options) => fetch(basePath + '/${collection}/' + id + '/${urlSegment}', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(options || {})
+    }).then(r => r.json())`;
+    }).join(",\n");
+    const customMethodsBlock = customMethods.length > 0 ? `,
+${customMethodImpls}` : "";
+    return `
+  ${clientKey}: {
+    list: (params) => fetch(basePath + '/${collection}', {
+      method: 'GET',
+      headers: { 'Content-Type': 'application/json' }
+    }).then(r => r.json()),
+
+    get: (id) => fetch(basePath + '/${collection}/' + id, {
+      method: 'GET',
+      headers: { 'Content-Type': 'application/json' }
+    }).then(r => r.json()),
+
+    create: (data) => fetch(basePath + '/${collection}', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data)
+    }).then(r => r.json()),
+
+    update: (id, data) => fetch(basePath + '/${collection}/' + id, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data)
+    }).then(r => r.json()),
+
+    delete: (id) => fetch(basePath + '/${collection}/' + id, {
+      method: 'DELETE',
+      headers: { 'Content-Type': 'application/json' }
+    }).then(r => r.ok),
+
+    search: (query) => fetch(basePath + '/${collection}/search?q=' + encodeURIComponent(query), {
+      method: 'GET',
+      headers: { 'Content-Type': 'application/json' }
+    }).then(r => r.json())${customMethodsBlock}
+  }`;
+  }).join(",");
+  return `
+// Auto-generated API client from SMRT objects
+// This file is generated automatically - do not edit
+
+export function createClient(basePath = '/api/v1') {
+  return {${clientMethods}
+  };
+}
+
+export { createClient as default };
+`;
+}
+async function generateMCPModule(manifest) {
+  try {
+    const { ManifestGenerator } = await importBuildAwareModule({
+      source: "../scanner/index.ts",
+      dist: "../scanner.js"
+    });
+    const generator = new ManifestGenerator();
+    const tools = generator.generateMCPTools(manifest);
+    return `
+// Auto-generated MCP tools from SMRT objects
+// This file is generated automatically - do not edit
+
+import { SmrtMCPServer } from '@happyvertical/smrt-core/runtime';
+
+export const tools = ${tools};
+
+export function createMCPServer(options = {}) {
+  const server = new SmrtMCPServer({
+    name: options.name || 'smrt-auto-generated',
+    version: options.version || '1.0.0',
+    ...options
+  });
+
+  // Add all generated tools to the server
+  for (const tool of tools) {
+    server.addTool(tool, async (params) => {
+      // Tool execution will be handled by the application
+      throw new Error(\`Tool '\${tool.name}' handler must be provided by application\`);
+    });
+  }
+
+  return server;
+}
+
+export { createMCPServer as default };
+`;
+  } catch (error) {
+    console.warn("[smrt] Error generating MCP module:", error);
+    return `
+import { SmrtMCPServer } from '@happyvertical/smrt-core/runtime';
+export const tools = [];
+export function createMCPServer(options = {}) {
+  console.warn("MCP generation failed");
+  return new SmrtMCPServer({
+    name: options.name || 'smrt-client',
+    version: options.version || '1.0.0',
+    ...options
+  });
+}
+`;
+  }
+}
+function generateClientModeTypes(manifest) {
+  const typeDefinitions = [];
+  for (const [objectName, objectMeta] of Object.entries(manifest.objects)) {
+    const fields = objectMeta.fields || {};
+    const propertyLines = [];
+    for (const [fieldName, fieldDef] of Object.entries(fields)) {
+      let type = "any";
+      switch (fieldDef.type) {
+        case "text":
+          type = "string";
+          break;
+        case "decimal":
+        case "integer":
+          type = "number";
+          break;
+        case "boolean":
+          type = "boolean";
+          break;
+        case "datetime":
+          type = "string";
+          break;
+        case "json":
+          type = "any";
+          break;
+        case "foreignKey":
+          type = "string";
+          break;
+        default:
+          type = "any";
+      }
+      const optional = !fieldDef.required ? "?" : "";
+      propertyLines.push(`  ${fieldName}${optional}: ${type};`);
+    }
+    propertyLines.unshift(
+      "  id?: string;",
+      "  created_at?: string;",
+      "  updated_at?: string;"
+    );
+    const interfaceDef = `export interface ${objectName}Data {
+${propertyLines.join("\n")}
+}`;
+    typeDefinitions.push(interfaceDef);
+  }
+  return typeDefinitions.join("\n\n");
+}
+async function generateTypesModule(manifest, mode = "server") {
+  let interfaces = "";
+  try {
+    if (mode !== "client") {
+      const { ManifestGenerator } = await importBuildAwareModule({
+        source: "../scanner/index.ts",
+        dist: "../scanner.js"
+      });
+      const generator = new ManifestGenerator();
+      interfaces = generator.generateTypeDefinitions(manifest);
+    } else {
+      interfaces = generateClientModeTypes(manifest);
+    }
+    return `
+// Auto-generated TypeScript types from SMRT objects
+// This file is generated automatically - do not edit
+
+${interfaces}
+
+export interface Request {
+  params: Record<string, string>;
+  query: Record<string, any>;
+  json(): Promise<any>;
+}
+
+export interface Response {
+  json(data: any, init?: { status?: number }): Response;
+  status(code: number): Response;
+}
+`;
+  } catch (error) {
+    console.warn("[smrt] Error generating types module:", error);
+    return `
+// Auto-generated TypeScript types from SMRT objects (fallback)
+// This file is generated automatically - do not edit
+
+export interface Request {
+  params: Record<string, string>;
+  query: Record<string, any>;
+  json(): Promise<any>;
+}
+
+export interface Response {
+  json(data: any, init?: { status?: number }): Response;
+  status(code: number): Response;
+}
+`;
+  }
+}
+function generateManifestModule(manifest) {
+  return `
+// Auto-generated manifest from SMRT objects
+// This file is generated automatically - do not edit
+
+export const manifest = ${JSON.stringify(manifest, null, 2)};
+
+export { manifest as default };
+`;
+}
+async function generateTypeDeclarationFile(manifest, projectRoot, typeDeclarationsPath) {
+  try {
+    const [{ join: join2 }, { existsSync: existsSync2, mkdirSync, writeFileSync }] = await Promise.all([import("node:path"), import("node:fs")]);
+    const declarationsDir = join2(projectRoot, typeDeclarationsPath);
+    const declarationsFile = join2(declarationsDir, "virtual-modules.d.ts");
+    if (!existsSync2(declarationsDir)) {
+      mkdirSync(declarationsDir, { recursive: true });
+    }
+    const objectInterfaces = Object.entries(manifest.objects).map(([_name, obj]) => {
+      const interfaceName = `${obj.className}Data`;
+      const fields = Object.entries(obj.fields).map(([fieldName, field]) => {
+        const optional = field.required === false ? "?" : "";
+        const type = mapTypeScriptType(field.type);
+        return `    ${fieldName}${optional}: ${type};`;
+      }).join("\n");
+      return `  export interface ${interfaceName} {
+    id?: string;
+${fields}
+    createdAt?: string;
+    updatedAt?: string;
+  }`;
+    }).join("\n\n");
+    const apiClientInterface = uniqueApiClientEntries(
+      Object.entries(manifest.objects)
+    ).map(({ obj, clientKey }) => {
+      const { className, methods = {} } = obj;
+      const interfaceName = `${className}Data`;
+      const exposedActions = resolveApiActionSet(obj);
+      const customMethods = Object.entries(methods).filter(
+        ([name, method]) => method.isPublic && exposedActions.has(name)
+      );
+      const customMethodSignatures = customMethods.map(([methodName, method]) => {
+        const params = method.parameters || [];
+        const optionsSignature = params.length > 0 ? `, options?: { ${params.map((p) => `${p.name}?: ${mapTypeScriptType(p.type)}`).join("; ")} }` : "";
+        return `      ${methodName}(id: string${optionsSignature}): Promise<any>;`;
+      }).join("\n");
+      if (customMethods.length > 0) {
+        return `    ${clientKey}: CrudOperations<${interfaceName}> & {
+${customMethodSignatures}
+    };`;
+      } else {
+        return `    ${clientKey}: CrudOperations<${interfaceName}>;`;
+      }
+    }).join("\n");
+    const _mcpTools = Object.entries(manifest.objects).flatMap(
+      ([_name, obj]) => Object.entries(obj.methods).map(([methodName, method]) => ({
+        name: `${methodName}_${obj.collection}`,
+        description: `${method.name} operation on ${obj.collection}`,
+        inputSchema: {
+          type: "object",
+          properties: Object.fromEntries(
+            method.parameters.map((param) => [
+              param.name,
+              { type: mapJsonSchemaType(param.type) }
+            ])
+          ),
+          required: method.parameters.filter((p) => p.optional !== true).map((p) => p.name)
+        }
+      }))
+    );
+    const typeDeclarations = `/**
+ * Auto-generated TypeScript declarations for SMRT virtual modules
+ * Generated from discovered @smrt() decorated classes
+ * 
+ * DO NOT EDIT THIS FILE MANUALLY
+ * This file is automatically regenerated when SMRT objects change
+ */
+
+// Manifest module - Contains discovered SMRT objects metadata
+declare module '@happyvertical/smrt-virt-manifest' {
+  export interface SmrtObjectField {
+    type: string;
+    required?: boolean;
+    default?: any;
+  }
+
+  export interface SmrtObjectMethod {
+    name: string;
+    parameters: Array<{
+      name: string;
+      type: string;
+      required?: boolean;
+    }>;
+    returnType: string;
+    isAsync: boolean;
+  }
+
+  export interface SmrtObjectDefinition {
+    className: string;
+    collection: string;
+    fields: Record<string, SmrtObjectField>;
+    methods: Record<string, SmrtObjectMethod>;
+    decoratorConfig: any;
+  }
+
+  export interface SmrtManifest {
+    version: string;
+    timestamp: number;
+    objects: Record<string, SmrtObjectDefinition>;
+  }
+
+  export const manifest: SmrtManifest;
+}
+
+// Routes module - Auto-generated REST route setup
+declare module '@happyvertical/smrt-virt-routes' {
+  export interface RouteApp {
+    get(path: string, handler: (req: any, res: any) => void): void;
+    post(path: string, handler: (req: any, res: any) => void): void;
+    put(path: string, handler: (req: any, res: any) => void): void;
+    delete(path: string, handler: (req: any, res: any) => void): void;
+  }
+
+  export interface RouteOptions {
+    basePath?: string;
+    [key: string]: any;
+  }
+
+  export function setupRoutes(app: RouteApp, options?: RouteOptions): void;
+  export default setupRoutes;
+}
+
+// Client module - Auto-generated API client  
+declare module '@happyvertical/smrt-virt-client' {
+  export interface ApiResponse<T = any> {
+    id?: string;
+    data?: T;
+    error?: string;
+    message?: string;
+  }
+
+  export interface CrudOperations<T = any> {
+    list(params?: Record<string, any>): Promise<T[]>;
+    get(id: string): Promise<T>;
+    create(data: Partial<T>): Promise<T>;
+    update(id: string, data: Partial<T>): Promise<T>;
+    delete(id: string): Promise<boolean>;
+    search(query: string): Promise<T[]>;
+  }
+
+  export interface ApiClient {
+${apiClientInterface}
+  }
+
+  export function createClient(basePath?: string): ApiClient;
+  export default createClient;
+}
+
+// MCP module - Auto-generated Model Context Protocol tools
+declare module '@happyvertical/smrt-virt-mcp' {
+  import type { SmrtMCPServer, MCPServerOptions } from '@happyvertical/smrt-core/runtime';
+
+  export interface McpTool {
+    name: string;
+    description: string;
+    inputSchema: {
+      type: string;
+      properties: Record<string, any>;
+      required?: string[];
+    };
+  }
+
+  export const tools: McpTool[];
+  export function createMCPServer(options?: MCPServerOptions): SmrtMCPServer;
+  export default createMCPServer;
+}
+
+// Types module - Auto-generated TypeScript interfaces
+declare module '@happyvertical/smrt-virt-types' {
+  export const types: string;
+
+  // Auto-generated interfaces for discovered SMRT objects
+${objectInterfaces}
+
+  export default types;
+}
+
+// CLI module - Auto-generated command-line interface
+declare module '@happyvertical/smrt-virt-cli' {
+  export interface CLIConfig {
+    name?: string;
+    version?: string;
+    description?: string;
+    prompt?: boolean;
+    colors?: boolean;
+  }
+
+  export interface CLIContext {
+    db?: any;
+    ai?: any;
+    user?: {
+      id: string;
+      roles?: string[];
+    };
+  }
+
+  export interface CLICommandMap {
+    [objectName: string]: {
+      collection: string;
+      commands: string[];
+    };
+  }
+
+  export const cliCommands: CLICommandMap;
+
+  export function setupCLI(config?: CLIConfig, context?: CLIContext): {
+    run: (argv: string[]) => Promise<void>;
+    generator: any;
+  };
+
+  export function getCLIHandler(config?: CLIConfig, context?: CLIContext): (argv: string[]) => Promise<void>;
+
+  export default setupCLI;
+}`;
+    writeFileSync(declarationsFile, typeDeclarations);
+    console.log(
+      `[smrt] Generated TypeScript declarations: ${declarationsFile}`
+    );
+  } catch (error) {
+    console.error("[smrt] Error generating TypeScript declarations:", error);
+  }
+}
+function mapTypeScriptType(smrtType) {
+  const typeMap = {
+    string: "string",
+    number: "number",
+    boolean: "boolean",
+    array: "any[]",
+    object: "Record<string, any>",
+    date: "string",
+    Date: "string"
+  };
+  return typeMap[smrtType] || "any";
+}
+function mapJsonSchemaType(tsType) {
+  const typeMap = {
+    string: "string",
+    number: "number",
+    boolean: "boolean",
+    array: "array",
+    object: "object",
+    any: "string"
+  };
+  return typeMap[tsType] || "string";
+}
+function getDefaultHTML() {
+  const uiScript = getDefaultUIModule();
+  return '<!DOCTYPE html>\n<html lang="en">\n<head>\n  <meta charset="UTF-8">\n  <meta name="viewport" content="width=device-width, initial-scale=1.0">\n  <title>SMRT Development UI</title>\n  <style>\n    * { margin: 0; padding: 0; box-sizing: border-box; }\n    body {\n      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;\n      background: #f5f5f5;\n      color: #333;\n    }\n    .container { max-width: 1200px; margin: 0 auto; padding: 20px; }\n    header {\n      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);\n      color: white;\n      padding: 40px 0;\n      margin-bottom: 40px;\n      box-shadow: 0 4px 6px rgba(0,0,0,0.1);\n    }\n    header h1 { font-size: 2.5em; font-weight: 700; margin-bottom: 10px; }\n    .subtitle { font-size: 1.1em; opacity: 0.9; }\n    .stats {\n      display: grid;\n      grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));\n      gap: 20px;\n      margin-bottom: 40px;\n    }\n    .stat-card {\n      background: white;\n      padding: 20px;\n      border-radius: 8px;\n      box-shadow: 0 2px 4px rgba(0,0,0,0.1);\n      text-align: center;\n    }\n    .stat-value { font-size: 2.5em; font-weight: 700; color: #667eea; margin-bottom: 5px; }\n    .stat-label { font-size: 0.9em; color: #666; text-transform: uppercase; letter-spacing: 1px; }\n    .collections { display: grid; gap: 30px; }\n    .collection-card {\n      background: white;\n      border-radius: 8px;\n      box-shadow: 0 2px 4px rgba(0,0,0,0.1);\n      overflow: hidden;\n    }\n    .collection-header {\n      background: #667eea;\n      color: white;\n      padding: 15px 20px;\n      display: flex;\n      justify-content: space-between;\n      align-items: center;\n    }\n    .collection-title { font-size: 1.3em; font-weight: 600; }\n    .collection-count {\n      background: rgba(255,255,255,0.2);\n      padding: 5px 15px;\n      border-radius: 20px;\n      font-size: 0.9em;\n    }\n    .collection-body { padding: 20px; }\n    .field-list {\n      display: grid;\n      grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));\n      gap: 15px;\n      margin-bottom: 20px;\n    }\n    .field {\n      padding: 10px;\n      background: #f8f9fa;\n      border-radius: 4px;\n      border-left: 3px solid #667eea;\n    }\n    .field-name { font-weight: 600; color: #333; margin-bottom: 3px; }\n    .field-type { font-size: 0.85em; color: #666; }\n    .actions { display: flex; gap: 10px; flex-wrap: wrap; }\n    .btn {\n      padding: 10px 20px;\n      border: none;\n      border-radius: 4px;\n      font-size: 0.9em;\n      cursor: pointer;\n      transition: all 0.2s;\n      text-decoration: none;\n      display: inline-block;\n    }\n    .btn-primary { background: #667eea; color: white; }\n    .btn-primary:hover { background: #5568d3; transform: translateY(-1px); }\n    .btn-secondary { background: #e0e0e0; color: #333; }\n    .btn-secondary:hover { background: #d0d0d0; }\n    .loading { text-align: center; padding: 40px; color: #666; }\n    .error {\n      background: #fee;\n      border: 1px solid #fcc;\n      color: #c33;\n      padding: 15px;\n      border-radius: 4px;\n      margin-bottom: 20px;\n    }\n    .empty-state { text-align: center; padding: 60px 20px; color: #999; }\n    .empty-state svg { width: 100px; height: 100px; margin-bottom: 20px; opacity: 0.3; }\n  </style>\n</head>\n<body>\n  <div id="app">\n    <div class="loading">Loading SMRT UI...</div>\n  </div>\n  <script type="module">\n' + uiScript + "\n  <\/script>\n</body>\n</html>";
+}
+function getDefaultUIModule() {
+  try {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const templatePath = join(__dirname, "templates/default-ui.js");
+    return readFileSync(templatePath, "utf-8").trim();
+  } catch (error) {
+    console.error("[smrt] Error loading UI template:", error);
+    return `
+async function createUI() {
+  const app = document.getElementById('app');
+  if (!app) return;
+  app.innerHTML = '<div class="container" style="padding:40px;text-align:center;"><h1>🎯 SMRT Development UI</h1><p>Template file not found. UI code could not be loaded.</p></div>';
+}
+createUI();
+`;
+  }
+}
+async function loadDefaultHTML() {
+  return getDefaultHTML();
+}
+async function loadDefaultUI() {
+  return getDefaultUIModule();
+}
+async function generateCLIModule(manifest) {
+  try {
+    const commands = [];
+    const objectImports = [];
+    for (const [className, objectDef] of Object.entries(manifest.objects)) {
+      const config = objectDef.decoratorConfig;
+      const cliConfig = config?.cli;
+      if (cliConfig === false) continue;
+      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;
+      };
+      const collectionName = objectDef.collection;
+      const commandName = (objectDef.className || className).toLowerCase();
+      objectImports.push(
+        `// Import ${className} and ${className}Collection for CLI operations`
+      );
+      const availableCommands = [];
+      if (shouldInclude("list"))
+        availableCommands.push(`'${commandName}:list'`);
+      if (shouldInclude("get")) availableCommands.push(`'${commandName}:get'`);
+      if (shouldInclude("create"))
+        availableCommands.push(`'${commandName}:create'`);
+      if (shouldInclude("update"))
+        availableCommands.push(`'${commandName}:update'`);
+      if (shouldInclude("delete"))
+        availableCommands.push(`'${commandName}:delete'`);
+      for (const [methodName, _method] of Object.entries(objectDef.methods)) {
+        if (methodName.startsWith("_") || ["list", "get", "create", "update", "delete", "save"].includes(
+          methodName
+        ))
+          continue;
+        if (shouldInclude(methodName)) {
+          availableCommands.push(`'${commandName}:${methodName}'`);
+        }
+      }
+      if (availableCommands.length > 0) {
+        commands.push(`
+  // ${className} commands
+  ${className}: {
+    collection: '${collectionName}',
+    commands: [${availableCommands.join(", ")}]
+  }`);
+      }
+    }
+    return `
+// Auto-generated CLI module from SMRT objects
+// This file is generated automatically - do not edit
+
+import { CLIGenerator } from '@happyvertical/smrt-core/generators/cli';
+
+/**
+ * @typedef {import('@happyvertical/smrt-core/generators/cli').CLIConfig} CLIConfig
+ * @typedef {import('@happyvertical/smrt-core/generators/cli').CLIContext} CLIContext
+ */
+
+${objectImports.join("\n")}
+
+/**
+ * Available CLI commands by object
+ */
+export const cliCommands = {${commands.join(",\n")}
+};
+
+/**
+ * Setup CLI with auto-generated commands
+ *
+ * @param {CLIConfig} [config={}] - CLI configuration
+ * @param {CLIContext} [context={}] - CLI context
+ * @returns {{run: function(string[]): Promise<void>, generator: *}}
+ *
+ * @example
+ * import { setupCLI } from '@happyvertical/smrt-virt-cli';
+ *
+ * const cli = setupCLI({
+ *   name: 'my-app',
+ *   version: '1.0.0'
+ * });
+ *
+ * cli.run(process.argv);
+ */
+export function setupCLI(config = {}, context = {}) {
+  const generator = new CLIGenerator(config, context);
+  return {
+    run: async (argv) => {
+      const handler = generator.generateHandler();
+      await handler(argv.slice(2)); // Remove 'node' and script name
+    },
+    generator
+  };
+}
+
+/**
+ * Get CLI handler directly
+ *
+ * @param {CLIConfig} [config={}] - CLI configuration
+ * @param {CLIContext} [context={}] - CLI context
+ * @returns {function(string[]): Promise<void>}
+ */
+export function getCLIHandler(config = {}, context = {}) {
+  const generator = new CLIGenerator(config, context);
+  return generator.generateHandler();
+}
+
+export default setupCLI;
+`;
+  } catch (error) {
+    console.warn("[smrt] Error generating CLI module:", error);
+    return `
+// Error generating CLI module
+export const cliCommands = {};
+export function setupCLI() {
+  console.warn("CLI generation failed");
+  return { run: async () => {} };
+}
+export function getCLIHandler() {
+  return async () => console.warn("CLI generation failed");
+}
+export default setupCLI;
+`;
+  }
+}
+async function generateSchemaModule(manifest) {
+  try {
+    const { SchemaGenerator } = await importBuildAwareModule({
+      source: "../schema/generator.ts",
+      dist: "../schema/generator.js"
+    });
+    const schemaGenerator = new SchemaGenerator();
+    const schemas = {};
+    for (const [className, objectDef] of Object.entries(manifest.objects)) {
+      const schema = schemaGenerator.generateSchema(objectDef);
+      schemas[className] = schema;
+    }
+    const schemaManifest = {
+      version: "1.0.0",
+      timestamp: Date.now(),
+      packageName: manifest.packageName || "unknown",
+      schemas,
+      dependencies: Array.from(
+        new Set(
+          Object.values(schemas).flatMap((s) => s.dependencies || [])
+        )
+      )
+    };
+    return `// Auto-generated schema manifest from SMRT objects
+// This file is generated automatically - do not edit
+
+// Schema manifest as JSON for SQL adapters
+export const schemaManifest = ${JSON.stringify(schemaManifest, null, 2)};
+
+// Schema registry for runtime access
+export const schemas = schemaManifest.schemas;
+
+// Schema lookup function
+export function getSchema(className: string) {
+  return schemas[className];
+}
+
+// All schemas as array for dependency resolution
+export const allSchemas = Object.values(schemas);
+
+// Package information
+export const packageName = schemaManifest.packageName;
+export const dependencies = schemaManifest.dependencies;
+
+export default schemaManifest;`;
+  } catch (error) {
+    console.error("[smrt] Error generating schema module:", error);
+    return `// Error generating schema module
+export const schemaManifest = { schemas: {}, dependencies: [] };
+export const schemas = {};
+export function getSchema() { return null; }
+export const allSchemas = [];
+export default {};`;
+  }
+}
+export {
+  findCliApiCoherenceViolations,
+  generateSvelteKitRoutes,
+  methodNameToKebab,
+  resolveApiActionSet,
+  smrtPlugin,
+  validateCliIncludeAgainstApi
+};
+//# sourceMappingURL=index.js.map