nymbal 0.2.0 → 1.1.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { defineCommand as defineCommand8, runMain } from "citty";
+import { defineCommand as defineCommand10, runMain } from "citty";
 
 // src/utils/version.ts
 import { readFileSync } from "fs";
@@ -26,8 +26,10 @@ function getCliVersion() {
 }
 
 // src/commands/dev.ts
+import { resolve as resolve4 } from "path";
 import { defineCommand as defineCommand2 } from "citty";
 import pc from "picocolors";
+import { KNOWN_PROVIDERS } from "@nymbalhq/config";
 
 // src/utils/project.ts
 import { existsSync } from "fs";
@@ -43,22 +45,22 @@ async function loadProject(startDir = process.cwd()) {
 }
 
 // src/commands/dev.ts
-import { createApp, runSeed } from "@nymbalhq/platform";
+import { createApp, createLogger, runSeed, sqliteFile } from "@nymbalhq/platform";
 import { createHttpServer } from "@nymbalhq/http";
 
 // src/utils/spawn.ts
 import { spawn } from "child_process";
 function run(command, args, options = {}) {
-  const child = spawn(command, args, {
+  const child2 = spawn(command, args, {
     stdio: "inherit",
     shell: false,
     ...options
   });
-  const done = new Promise((resolve4, reject) => {
-    child.on("error", reject);
-    child.on("exit", (code) => resolve4(code ?? 0));
+  const done = new Promise((resolve6, reject) => {
+    child2.on("error", reject);
+    child2.on("exit", (code) => resolve6(code ?? 0));
   });
-  return { child, done };
+  return { child: child2, done };
 }
 async function runOrFail(command, args, options = {}) {
   const { done } = run(command, args, options);
@@ -71,16 +73,16 @@ async function runOrFail(command, args, options = {}) {
 // src/utils/port.ts
 import { createServer } from "net";
 async function isPortFree(port, host) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve6) => {
     const server = createServer();
-    server.once("error", (err) => {
-      if (err.code !== "EADDRINUSE" && err.code !== "EACCES") {
-        console.error(`[dev] unexpected error probing port ${port}:`, err.message);
+    server.once("error", (err2) => {
+      if (err2.code !== "EADDRINUSE" && err2.code !== "EACCES") {
+        console.error(`[dev] unexpected error probing port ${port}:`, err2.message);
       }
-      resolve4(false);
+      resolve6(false);
     });
     server.once("listening", () => {
-      server.close(() => resolve4(true));
+      server.close(() => resolve6(true));
     });
     if (host) {
       server.listen(port, host);
@@ -217,6 +219,102 @@ function resolveAdminRoot() {
   }
 }
 
+// src/utils/shutdown.ts
+var SHUTDOWN_BOUND_MS = 3e3;
+var running = false;
+async function runShutdown(steps, opts) {
+  if (running) {
+    opts.logger.error({}, "Shutdown already running; exiting now");
+    return opts.exit(1);
+  }
+  running = true;
+  let pending;
+  let failed = false;
+  const work = (async () => {
+    for (const step of steps) {
+      pending = step.name;
+      try {
+        await step.run();
+      } catch (err2) {
+        failed = true;
+        opts.logger.error({ err: err2, step: step.name }, `Shutdown step "${step.name}" failed`);
+      }
+    }
+    pending = void 0;
+  })();
+  let timer;
+  const bound = new Promise((resolve6) => {
+    timer = setTimeout(() => resolve6("bound"), opts.boundMs);
+  });
+  const outcome = await Promise.race([work.then(() => "done"), bound]);
+  clearTimeout(timer);
+  if (outcome === "bound") {
+    opts.logger.error(
+      { step: pending, boundMs: opts.boundMs },
+      `Shutdown step "${pending}" did not finish within ${opts.boundMs} ms; exiting`
+    );
+    return opts.exit(1);
+  }
+  return opts.exit(failed ? 1 : 0);
+}
+
+// src/commands/dev-summary.ts
+import { displayUrl } from "@nymbalhq/types";
+var WIDTH = 100;
+var LABEL = 14;
+var NAME_COLUMN = 20;
+var columns = (text2) => [...text2].length;
+function fit(text2, width = WIDTH) {
+  return columns(text2) <= width ? text2 : `${[...text2].slice(0, width - 1).join("")}\u2026`;
+}
+function row(label, value) {
+  return fit(`  ${label.padEnd(LABEL)} ${value}`);
+}
+function capabilityList(capabilities, width) {
+  if (capabilities.length === 0) return "\u2014";
+  const all = capabilities.join(", ");
+  if (columns(all) <= width) return all;
+  for (let shown = capabilities.length - 1; shown > 0; shown--) {
+    const text2 = `${capabilities.slice(0, shown).join(", ")}, \u2026 (+${capabilities.length - shown})`;
+    if (columns(text2) <= width) return text2;
+  }
+  return `\u2026 (+${capabilities.length})`;
+}
+function renderDevSummary(info) {
+  const slotWidth = Math.min(NAME_COLUMN, Math.max(...info.slots.map((s) => columns(s.slot)), 0));
+  const providerWidth = Math.min(
+    NAME_COLUMN,
+    Math.max(...info.slots.map((s) => columns(s.provider)), 0)
+  );
+  const slotLines = info.slots.map(({ slot, provider, capabilities }) => {
+    const lead = `  ${slot.padEnd(slotWidth)}  ${provider.padEnd(providerWidth)}  `;
+    return fit(`${lead}${capabilityList(capabilities, WIDTH - columns(lead))}`);
+  });
+  const commandStore = info.commandStore.kind === "sqlite" ? `sqlite  ${info.commandStore.path}` : `postgres  ${displayUrl(info.commandStore.url)}`;
+  const lines = [
+    fit(`  ${info.store}`),
+    "",
+    row("API", info.apiUrl),
+    row(
+      "storefront",
+      info.storefront === null ? "not started (--api-only)" : `${info.storefront.url}  (${info.storefront.template})`
+    ),
+    row(
+      "admin",
+      info.admin === null ? "not built \u2014 run pnpm --filter @nymbalhq/admin build" : info.admin.url
+    ),
+    row("command store", commandStore),
+    "",
+    ...slotLines,
+    "",
+    ...info.primitives.map(({ name, provider }) => row(name, provider)),
+    "",
+    "  Debug logs: run with --verbose (or LOG_LEVEL=debug)."
+  ];
+  return `${lines.join("\n")}
+`;
+}
+
 // src/commands/dev.ts
 function defaultStorefrontPort(template) {
   return template === "astro" ? 4321 : 3e3;
@@ -230,13 +328,7 @@ function preferredStorefrontPort(template, flagPort, env) {
   }
   return defaultStorefrontPort(template);
 }
-function storefrontEnv(config, apiUrl, storefrontPort, baseEnv = process.env) {
-  const stubPayments = config.commerce.payments.provider === "stripe" ? {} : {
-    PUBLIC_NYMBAL_PAYMENTS_PROVIDER: "native-stub",
-    // Astro
-    NEXT_PUBLIC_NYMBAL_PAYMENTS_PROVIDER: "native-stub"
-    // Next.js
-  };
+function storefrontEnv(_config, apiUrl, storefrontPort, baseEnv = process.env) {
   return {
     ...baseEnv,
     NYMBAL_API_URL: apiUrl,
@@ -246,10 +338,41 @@ function storefrontEnv(config, apiUrl, storefrontPort, baseEnv = process.env) {
     // Next.js
     // The framework also reads the port flag; the env var keeps the scaffold
     // config (astro.config.mjs) in sync when it honours NYMBAL_STOREFRONT_PORT.
-    NYMBAL_STOREFRONT_PORT: String(storefrontPort),
-    ...stubPayments
+    NYMBAL_STOREFRONT_PORT: String(storefrontPort)
   };
 }
+function devLogLevel(verbose, env) {
+  const fromEnv = env["LOG_LEVEL"];
+  if (fromEnv !== void 0 && fromEnv !== "") return fromEnv;
+  return verbose ? "debug" : "info";
+}
+function summaryInfo(config, app, apiUrl, storefront, adminBuilt) {
+  const report = app.capabilities();
+  return {
+    store: config.store.name,
+    apiUrl,
+    storefront,
+    admin: adminBuilt ? { url: `${apiUrl}/admin/` } : null,
+    commandStore: config.infrastructure.commandStore === "sqlite" ? { kind: "sqlite", path: resolve4(sqliteFile()) } : { kind: "postgres", url: process.env["DATABASE_URL"] ?? "" },
+    slots: Object.keys(KNOWN_PROVIDERS).map((slot) => ({
+      slot,
+      provider: report[slot].provider,
+      capabilities: report[slot].capabilities
+    })),
+    primitives: ["documentStore", "eventBus", "media"].map((name) => ({
+      name,
+      provider: report[name].provider
+    }))
+  };
+}
+function apiPort(config, flagPort) {
+  if (flagPort === void 0 || flagPort.trim() === "") return config.http.port;
+  const port = Number(flagPort);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`--port must be an integer from 1 to 65535, got "${flagPort}"`);
+  }
+  return port;
+}
 var devCommand = defineCommand2({
   meta: {
     name: "dev",
@@ -273,17 +396,37 @@ var devCommand = defineCommand2({
       description: "Start only the API server (skip template dev server)",
       default: false
     },
+    port: {
+      type: "string",
+      description: "Port for the API server (default: the config's http.port)"
+    },
     storefrontPort: {
       type: "string",
       alias: "storefront-port",
       description: "Port for the storefront dev server (default: 4321 Astro / 3000 Next.js). If busy, the next free port is used. Also settable via NYMBAL_STOREFRONT_PORT."
+    },
+    verbose: {
+      type: "boolean",
+      description: "Log at debug (LOG_LEVEL, when set, wins)",
+      default: false
     }
   },
   async run({ args }) {
-    const { config, projectRoot } = await loadProject();
+    const loaded = await loadProject();
+    const { projectRoot } = loaded;
+    const port = apiPort(loaded.config, args.port);
+    const config = { ...loaded.config, http: { ...loaded.config.http, port } };
     const version = getCliVersion();
     await migrateProject(config, projectRoot);
-    const app = await createApp(config, { version });
+    const logger = createLogger({
+      base: { store: config.store.name },
+      level: devLogLevel(args.verbose, process.env)
+    });
+    const app = await createApp(config, {
+      version,
+      logger,
+      ...loaded.adapters !== void 0 && { adapters: loaded.adapters }
+    });
     const { platform } = app;
     if (args.seed) {
       const existing = await platform.documentStore.query("products", {
@@ -309,23 +452,26 @@ var devCommand = defineCommand2({
       version
     });
     const adminRoot = resolveAdminRoot();
-    if (adminRoot === null) {
-      console.log(
-        pc.yellow(
-          "\u2192 The admin is not built, so /admin/ answers 404: run `pnpm --filter @nymbalhq/admin build`."
-        )
-      );
-    }
     await app.attachHttp(http.adapter, { adminRoot });
     await http.start();
+    const apiUrl = `http://localhost:${config.http.port}`;
+    const printSummary = (storefront) => {
+      console.log(renderDevSummary(summaryInfo(config, app, apiUrl, storefront, adminRoot !== null)));
+    };
+    const stopApi = [
+      { name: "http.stop", run: () => http.stop() },
+      { name: "app.stop", run: () => app.stop() }
+    ];
+    const shutdownWith = (steps) => runShutdown(steps, {
+      boundMs: SHUTDOWN_BOUND_MS,
+      logger: platform.logger,
+      exit: (code) => process.exit(code)
+    });
     if (args.apiOnly) {
-      const shutdown2 = async (signal) => {
+      printSummary(null);
+      const shutdown2 = (signal) => {
         platform.logger.info({ signal }, "Shutting down API");
-        await http.stop().catch(() => {
-        });
-        await app.stop().catch(() => {
-        });
-        process.exit(0);
+        return shutdownWith(stopApi);
       };
       process.on("SIGINT", () => void shutdown2("SIGINT"));
       process.on("SIGTERM", () => void shutdown2("SIGTERM"));
@@ -343,34 +489,31 @@ var devCommand = defineCommand2({
       );
     }
     const launch = planTemplateLaunch(projectRoot, config.template, storefrontPort);
-    const apiUrl = `http://localhost:${config.http.port}`;
     const storefrontUrl = `http://localhost:${storefrontPort}`;
-    console.log(
-      pc.cyan(
-        `\u2192 Starting storefront (${pc.bold(config.template)}, ${launch.mode}) on ${pc.bold(storefrontUrl)}`
-      )
-    );
-    console.log(pc.dim(`  API: ${apiUrl}`));
     const templateProc = run(launch.command, launch.args, {
       cwd: launch.cwd,
       env: storefrontEnv(config, apiUrl, storefrontPort)
     });
-    const shutdown = async (signal) => {
+    printSummary({ template: `${config.template}, ${launch.mode}`, url: storefrontUrl });
+    let shuttingDown = false;
+    const shutdown = (signal) => {
+      shuttingDown = true;
       platform.logger.info({ signal }, "Shutting down");
-      try {
-        templateProc.child.kill("SIGINT");
-      } catch {
-      }
-      await http.stop().catch(() => {
-      });
-      await app.stop().catch(() => {
-      });
-      process.exit(0);
+      return shutdownWith([
+        {
+          name: "storefront.kill",
+          run: async () => {
+            templateProc.child.kill("SIGINT");
+          }
+        },
+        ...stopApi
+      ]);
     };
     process.on("SIGINT", () => void shutdown("SIGINT"));
     process.on("SIGTERM", () => void shutdown("SIGTERM"));
     const templateExit = await templateProc.done;
     platform.logger.info({ code: templateExit }, "Template process exited");
+    if (shuttingDown) return;
     await shutdown("template-exit");
   }
 });
@@ -400,13 +543,13 @@ var buildCommand = defineCommand3({
 
 // src/commands/seed.ts
 import { defineCommand as defineCommand4 } from "citty";
-import { createPlatform, runSeed as runSeed2 } from "@nymbalhq/platform";
+import { createPlatform, resolvePrimitives, runSeed as runSeed2 } from "@nymbalhq/platform";
 var seedCommand = defineCommand4({
   meta: { name: "seed", description: "Re-seed demo content (products, categories)" },
   async run() {
     const { config, projectRoot } = await loadProject();
     await migrateProject(config, projectRoot);
-    const platform = createPlatform(config);
+    const platform = createPlatform(config, await resolvePrimitives(config));
     try {
       const result = await runSeed2({
         config,
@@ -428,7 +571,7 @@ var seedCommand = defineCommand4({
 // src/commands/import.ts
 import { defineCommand as defineCommand5 } from "citty";
 import { intro, outro, text, select, spinner, isCancel, cancel } from "@clack/prompts";
-import * as p from "picocolors";
+import p from "picocolors";
 import { createApp as createApp2 } from "@nymbalhq/platform";
 import { runWooCommerceImport, writeReport } from "@nymbalhq/importers";
 import { join as join3 } from "path";
@@ -573,6 +716,7 @@ var importCommand = defineCommand5({
           services: app.services,
           repos: app.repos,
           adapters: { ai: app.adapters.ai, reviews: app.adapters.reviews },
+          media: app.platform.media,
           onProgress(event) {
             if (event.kind === "phase") {
               console.log(p.cyan(`  \u2192 ${event.phase}`));
@@ -618,34 +762,815 @@ var configValidateCommand = defineCommand6({
       const { config, path } = await loadProject();
       console.log(pc2.green(`\u2713 config valid`) + ` (${path})`);
       console.log(
-        `  template: ${config.template}, cloud: ${config.infrastructure.cloud}, commandStore: ${config.infrastructure.commandStore}`
+        `  template: ${config.template}, commandStore: ${config.infrastructure.commandStore}, documentStore: ${config.infrastructure.documentStore}, eventBus: ${config.infrastructure.eventBus}`
       );
       process.exit(0);
-    } catch (err) {
-      if (err instanceof NymbalError) {
+    } catch (err2) {
+      if (err2 instanceof NymbalError) {
         console.error(pc2.red("\u2717 config invalid"));
-        console.error(err.message);
+        console.error(err2.message);
       } else {
-        console.error(err);
+        console.error(err2);
       }
       process.exit(1);
     }
   }
 });
 
-// src/commands/test.ts
+// src/commands/add.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync6, mkdtempSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
+import { dirname as dirname6, join as join5 } from "path";
+import { parseEnv } from "util";
 import { defineCommand as defineCommand7 } from "citty";
-import { loadConfig as loadConfig2 } from "@nymbalhq/config";
-var testCommand = defineCommand7({
+import pc3 from "picocolors";
+import { findConfigFile as findConfigFile2, loadConfig as loadConfig2 } from "@nymbalhq/config";
+import { installLine } from "@nymbalhq/platform";
+
+// src/recipes/holders.ts
+import { existsSync as existsSync5 } from "fs";
+import { readFile } from "fs/promises";
+import { createRequire as createRequire2 } from "module";
+import { dirname as dirname5, join as join4, resolve as resolve5 } from "path";
+var RECIPE_HOLDERS = {
+  postgres: "@nymbalhq/platform",
+  redis: "@nymbalhq/doc-store-redis",
+  s3: "@nymbalhq/media-s3",
+  stripe: "@nymbalhq/adapter-stripe"
+};
+function knownRecipes() {
+  return Object.keys(RECIPE_HOLDERS).sort();
+}
+function isKnownRecipe(name) {
+  return Object.hasOwn(RECIPE_HOLDERS, name);
+}
+function unknownRecipe(name) {
+  return new Error(`unknown recipe '${name}': the recipes are ${knownRecipes().join(", ")}`);
+}
+function packageDir(pkg, projectRoot) {
+  let dir = resolve5(projectRoot);
+  while (true) {
+    const candidate = join4(dir, "node_modules", pkg);
+    if (existsSync5(join4(candidate, "package.json"))) return candidate;
+    const parent = dirname5(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function recipeFile(name, projectRoot) {
+  const holder = RECIPE_HOLDERS[name];
+  if (holder === void 0 || !isKnownRecipe(name)) throw unknownRecipe(name);
+  const dir = packageDir(holder, projectRoot);
+  if (dir === null) return null;
+  try {
+    return createRequire2(join4(dir, "package.json")).resolve(`${holder}/recipes/${name}.json`);
+  } catch (error) {
+    const code = error.code;
+    if (code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED") return null;
+    throw error;
+  }
+}
+function isInstalled(pkg, projectRoot) {
+  return packageDir(pkg, projectRoot) !== null;
+}
+async function readRecipe(name, projectRoot) {
+  const file = recipeFile(name, projectRoot);
+  if (file === null) {
+    throw new Error(
+      `${RECIPE_HOLDERS[name]} is not installed in ${projectRoot}, so its ${name} recipe cannot be read`
+    );
+  }
+  const recipe = JSON.parse(await readFile(file, "utf8"));
+  const malformed = recipe === null || typeof recipe !== "object" || recipe.name !== name || !Array.isArray(recipe.install) || !Array.isArray(recipe.set) || !Array.isArray(recipe.env) || !Array.isArray(recipe.next);
+  if (malformed) throw new Error(`${file} is not a ${name} recipe`);
+  return recipe;
+}
+
+// src/recipes/config-edit.ts
+import { parseModule } from "magicast";
+var SCAFFOLD_DEFAULTS = [
+  "sqlite",
+  "in-memory",
+  "in-process",
+  "local-fs",
+  "native"
+];
+var CONFIG_MODULE = "@nymbalhq/config";
+var child = (node, key) => node[key];
+var children = (node, key) => node[key];
+function parse(lf) {
+  return parseModule(lf, { tabWidth: 1 }).$ast;
+}
+var lfCopy = (source) => source.replace(/\r\n/g, "\n");
+function unwrap(node) {
+  let at = node;
+  while (at !== void 0 && (at.type === "TSAsExpression" || at.type === "TSSatisfiesExpression" || at.type === "TSNonNullExpression" || at.type === "ParenthesizedExpression")) {
+    at = child(at, "expression");
+  }
+  return at;
+}
+function nameOf(node) {
+  if (node.type === "Identifier") return node["name"];
+  if (node.type === "StringLiteral") return node["value"];
+  if (node.type === "NumericLiteral") return String(node["value"]);
+  return void 0;
+}
+function configImports(program) {
+  return children(program, "body").filter(
+    (n) => n.type === "ImportDeclaration" && child(n, "source")["value"] === CONFIG_MODULE && n["importKind"] !== "type"
+  );
+}
+function importedAs(program, imported) {
+  for (const decl of configImports(program)) {
+    for (const spec of children(decl, "specifiers")) {
+      if (spec.type !== "ImportSpecifier" || spec["importKind"] === "type") continue;
+      if (nameOf(child(spec, "imported")) === imported)
+        return child(spec, "local")["name"];
+    }
+  }
+  return void 0;
+}
+function bindsEnv(program) {
+  const bound = (id) => id?.type === "Identifier" && id["name"] === "env";
+  return children(program, "body").some((n) => {
+    const decl = n.type === "ExportNamedDeclaration" ? child(n, "declaration") : n;
+    if (decl === null || decl === void 0) return false;
+    if (decl.type === "ImportDeclaration")
+      return children(decl, "specifiers").some((s) => bound(child(s, "local")));
+    if (decl.type === "VariableDeclaration")
+      return children(decl, "declarations").some((d) => bound(child(d, "id")));
+    return bound(child(decl, "id"));
+  });
+}
+function locate(source) {
+  const program = parse(source);
+  const exported = children(program, "body").find((n) => n.type === "ExportDefaultDeclaration");
+  if (exported === void 0) return void 0;
+  let config = unwrap(child(exported, "declaration"));
+  if (config?.type === "CallExpression") {
+    const callee = child(config, "callee");
+    const define = importedAs(program, "defineConfig") ?? "defineConfig";
+    if (callee.type !== "Identifier" || callee["name"] !== define) return void 0;
+    config = unwrap(children(config, "arguments")[0]);
+  }
+  if (config?.type !== "ObjectExpression") return void 0;
+  if (source[config.start] !== "{" || source[config.end - 1] !== "}") return void 0;
+  return {
+    program,
+    config,
+    envName: importedAs(program, "env"),
+    envBound: bindsEnv(program),
+    namedImport: configImports(program).find(
+      (d) => children(d, "specifiers").some((s) => s.type === "ImportSpecifier")
+    )
+  };
+}
+function isEnvRef(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const keys = Object.keys(value);
+  return typeof value.env === "string" && keys.every((k) => k === "env" || k === "default");
+}
+function evaluate(node, envName) {
+  const at = unwrap(node);
+  switch (at.type) {
+    case "StringLiteral":
+    case "NumericLiteral":
+    case "BooleanLiteral":
+      return at["value"];
+    case "TemplateLiteral": {
+      const quasis = children(at, "quasis");
+      return children(at, "expressions").length === 0 ? (quasis[0]?.["value"]).cooked : void 0;
+    }
+    case "ObjectExpression": {
+      const out2 = {};
+      for (const prop of children(at, "properties")) {
+        const key = prop.type === "ObjectProperty" && !prop["computed"] ? nameOf(child(prop, "key")) : void 0;
+        const value = key === void 0 ? void 0 : evaluate(child(prop, "value"), envName);
+        if (key === void 0 || value === void 0) return void 0;
+        out2[key] = value;
+      }
+      return out2;
+    }
+    case "CallExpression": {
+      const callee = child(at, "callee");
+      const args = children(at, "arguments");
+      if (callee.type !== "Identifier" || callee["name"] !== (envName ?? "env")) return void 0;
+      if (args.length < 1 || args.length > 2 || args.some((a) => a.type !== "StringLiteral"))
+        return void 0;
+      return {
+        env: args[0]["value"],
+        ...args[1] !== void 0 && { default: args[1]["value"] }
+      };
+    }
+    default:
+      return void 0;
+  }
+}
+function sameValue(a, b) {
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return a === b;
+  const ka = Object.keys(a).sort();
+  const kb = Object.keys(b).sort();
+  return ka.length === kb.length && ka.every(
+    (k, i) => k === kb[i] && sameValue(a[k], b[k])
+  );
+}
+function isScaffoldDefault(value) {
+  if (typeof value === "string") return SCAFFOLD_DEFAULTS.includes(value);
+  const provider = value?.provider;
+  return typeof provider === "string" && SCAFFOLD_DEFAULTS.includes(provider);
+}
+function styleOf(source, mod) {
+  const firstString = /(['"])(?:(?!\1)[^\\\r\n]|\\.)*\1/.exec(source.slice(mod.config.start));
+  const indented = /\n([ \t]+)\S/.exec(source.slice(mod.config.start));
+  return {
+    quote: firstString?.[1] ?? "'",
+    unit: indented?.[1] ?? "  ",
+    envName: mod.envName ?? "env"
+  };
+}
+function quoted(text2, style) {
+  const q = style.quote;
+  const body = text2.replace(/\\/g, "\\\\").replace(new RegExp(q, "g"), `\\${q}`).replace(/\r/g, "\\r").replace(/\n/g, "\\n");
+  return `${q}${body}${q}`;
+}
+function renderKey(key, style) {
+  return /^[A-Za-z_$][\w$]*$/.test(key) ? key : quoted(key, style);
+}
+function render(value, indent, style) {
+  if (typeof value === "string") return quoted(value, style);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (isEnvRef(value)) {
+    const fallback = value.default === void 0 ? "" : `, ${quoted(value.default, style)}`;
+    return `${style.envName}(${quoted(value.env, style)}${fallback})`;
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 0) return "{}";
+  const inner = indent + style.unit;
+  const lines = entries.map(
+    ([k, v]) => `${inner}${renderKey(k, style)}: ${render(v, inner, style)},`
+  );
+  return `{
+${lines.join("\n")}
+${indent}}`;
+}
+function writesEnv(value) {
+  if (isEnvRef(value)) return true;
+  return typeof value === "object" && Object.values(value).some(writesEnv);
+}
+function indentAt(source, offset) {
+  const lineStart = source.lastIndexOf("\n", offset - 1) + 1;
+  return /^[ \t]*/.exec(source.slice(lineStart))[0];
+}
+function spliced(source, edits) {
+  const crlf = [];
+  for (const m of source.matchAll(/\r\n/g)) crlf.push(m.index - crlf.length);
+  const at = (lf) => lf + crlf.filter((p2) => p2 < lf).length;
+  const lastBreak = /\r?\n(?![\s\S]*\n)/.exec(source)?.[0] ?? "\n";
+  return edits.map((e) => {
+    const start = at(e.at);
+    const end = at(e.at + e.remove);
+    const eol = /\r?\n/.exec(source.slice(end))?.[0] ?? lastBreak;
+    return { start, end, text: e.text.replace(/\n/g, eol) };
+  }).sort((a, b) => b.start - a.start).reduce((s, e) => s.slice(0, e.start) + e.text + s.slice(e.end), source);
+}
+function addProperty(source, object, key, value, style) {
+  const props = children(object, "properties");
+  const close = object.end - 1;
+  const last = props.at(-1);
+  if (last === void 0) {
+    const indent2 = indentAt(source, object.start);
+    const inside = source.slice(object.start + 1, close);
+    const text2 = `${indent2}${style.unit}${renderKey(key, style)}: ${render(value, indent2 + style.unit, style)},`;
+    return inside.trim() === "" ? [
+      {
+        at: object.start + 1,
+        remove: inside.length,
+        text: `
+${text2}
+${indent2}`
+      }
+    ] : [{ at: close, remove: 0, text: `
+${text2}
+${indent2}` }];
+  }
+  const after = /^[ \t]*,/.exec(source.slice(last.end, close));
+  const comma = after === null ? void 0 : last.end + after[0].length;
+  const lineEnd = source.slice(last.end, close).indexOf("\n");
+  const property = (indent2) => `${renderKey(key, style)}: ${render(value, indent2, style)}`;
+  if (lineEnd === -1) {
+    return comma === void 0 ? [{ at: last.end, remove: 0, text: `, ${property(indentAt(source, last.start))}` }] : [{ at: comma, remove: 0, text: ` ${property(indentAt(source, last.start))},` }];
+  }
+  const indent = indentAt(source, last.start);
+  const edits = [
+    {
+      at: last.end + lineEnd,
+      remove: 0,
+      text: `
+${indent}${property(indent)}${comma === void 0 ? "" : ","}`
+    }
+  ];
+  if (comma === void 0) edits.push({ at: last.end, remove: 0, text: "," });
+  return edits;
+}
+function findProperty(object, key) {
+  return children(object, "properties").findLast(
+    (p2) => p2.type === "ObjectProperty" && !p2["computed"] && nameOf(child(p2, "key")) === key
+  );
+}
+function editByHand(recipe, why) {
+  const wanted = recipe.set.map(({ path, value }) => `${path} = ${JSON.stringify(value)}`);
+  return new Error(
+    `nymbal.config.ts ${why}, so the ${recipe.name} recipe cannot edit it: edit by hand and set ${wanted.join("; ")}`
+  );
+}
+function setPath(source, recipe, path, value, force) {
+  const lf = lfCopy(source);
+  const mod = locate(lf);
+  if (mod === void 0)
+    throw editByHand(recipe, "does not export a defineConfig({...}) object literal");
+  const style = styleOf(lf, mod);
+  const keys = path.split(".");
+  let object = mod.config;
+  for (const [i, key] of keys.entries()) {
+    const prop = findProperty(object, key);
+    if (prop === void 0) {
+      const nested = keys.slice(i + 1).reduceRight((v, k) => ({ [k]: v }), value);
+      return {
+        source: spliced(source, addProperty(lf, object, key, nested, style)),
+        wrote: true
+      };
+    }
+    const held = child(prop, "value");
+    if (i === keys.length - 1) {
+      const current = evaluate(held, mod.envName);
+      if (current !== void 0 && sameValue(current, value)) return { source, wrote: false };
+      if (!force && !isScaffoldDefault(current)) {
+        return {
+          conflict: { path, current: current ?? lf.slice(held.start, held.end), wanted: value }
+        };
+      }
+      const text2 = render(value, indentAt(lf, prop.start), style);
+      return {
+        source: spliced(source, [{ at: held.start, remove: held.end - held.start, text: text2 }]),
+        wrote: true
+      };
+    }
+    const inner = unwrap(held);
+    if (inner?.type !== "ObjectExpression") {
+      throw editByHand(
+        recipe,
+        `holds ${keys.slice(0, i + 1).join(".")} as something other than an object literal`
+      );
+    }
+    object = inner;
+  }
+  return { source, wrote: false };
+}
+function importEnv(source, recipe) {
+  const lf = lfCopy(source);
+  const mod = locate(lf);
+  if (mod.envName !== void 0) return source;
+  if (mod.envBound)
+    throw editByHand(recipe, "binds `env` to something other than the env of @nymbalhq/config");
+  const style = styleOf(lf, mod);
+  if (mod.namedImport !== void 0) {
+    const last = children(mod.namedImport, "specifiers").filter((s) => s.type === "ImportSpecifier").at(-1);
+    return spliced(source, [{ at: last.end, remove: 0, text: ", env" }]);
+  }
+  const imports = children(mod.program, "body").filter((n) => n.type === "ImportDeclaration");
+  const line = `import { env } from ${quoted(CONFIG_MODULE, style)}
+`;
+  const lastImport = imports.at(-1);
+  const lineEnd = lastImport === void 0 ? -1 : lf.indexOf("\n", lastImport.end);
+  const edit = lastImport === void 0 ? { at: 0, remove: 0, text: line } : lineEnd === -1 ? { at: lf.length, remove: 0, text: `
+${line}` } : { at: lineEnd + 1, remove: 0, text: line };
+  return spliced(source, [edit]);
+}
+function applyRecipeToConfig(source, recipe, opts) {
+  if (locate(lfCopy(source)) === void 0) {
+    throw editByHand(recipe, "does not export a defineConfig({...}) object literal");
+  }
+  let current = source;
+  const changed = [];
+  let envWritten = false;
+  for (const { path, value } of recipe.set) {
+    const step = setPath(current, recipe, path, value, opts.force);
+    if ("conflict" in step) return step;
+    if (!step.wrote) continue;
+    current = step.source;
+    changed.push(path);
+    envWritten ||= writesEnv(value);
+  }
+  if (envWritten) current = importEnv(current, recipe);
+  return { source: current, changed };
+}
+function envCalls(source) {
+  const lf = lfCopy(source);
+  const mod = locate(lf);
+  const envName = mod === void 0 ? importedAs(parse(lf), "env") : mod.envName;
+  if (envName === void 0) return [];
+  const defaulted = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    if (Array.isArray(node)) return node.forEach(visit);
+    if (typeof node !== "object" || node === null || typeof node.type !== "string") return;
+    const n = node;
+    if (n.type === "CallExpression") {
+      const callee = child(n, "callee");
+      const args = children(n, "arguments");
+      const first = args[0];
+      if (callee.type === "Identifier" && callee["name"] === envName && first?.type === "StringLiteral") {
+        const name = first["value"];
+        defaulted.set(name, (defaulted.get(name) ?? true) && args.length > 1);
+      }
+    }
+    for (const [key, value] of Object.entries(n)) {
+      if (key !== "loc" && key !== "comments" && key !== "extra" && key !== "original") visit(value);
+    }
+  };
+  visit(mod?.program ?? parse(lf));
+  return [...defaulted].map(([name, all]) => ({ name, defaulted: all }));
+}
+
+// src/recipes/env-example.ts
+var escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+function declares(lines, name) {
+  const re = new RegExp(`^(#\\s*)?${escapeRegExp(name)}=`);
+  return lines.some((line) => re.test(line.trim()));
+}
+function missingEnv(example, recipe) {
+  const lines = example.split(/\r?\n/);
+  return recipe.env.filter(
+    (v, i) => !declares(lines, v.name) && recipe.env.findIndex((w) => w.name === v.name) === i
+  );
+}
+function appendRecipeEnv(example, recipe) {
+  const eol = example.includes("\r\n") ? "\r\n" : "\n";
+  const missing = missingEnv(example, recipe);
+  if (missing.length === 0) return example;
+  const block = [`# ${recipe.name} (nymbal add ${recipe.name})`];
+  for (const v of missing) {
+    if (v.comment !== "") block.push(`# ${v.comment}`);
+    block.push(`${v.required ? "" : "# "}${v.name}=${v.example}`);
+  }
+  let head = example;
+  if (head !== "" && !head.endsWith("\n")) head += eol;
+  const last = head.split(/\r?\n/).at(-2);
+  const gap = last === void 0 || last.trim() === "" ? "" : eol;
+  return `${head}${gap}${block.join(eol)}${eol}`;
+}
+
+// src/commands/add.ts
+var out = (line = "") => void process.stdout.write(`${line}
+`);
+var err = (line) => void process.stderr.write(`${line}
+`);
+function fail(message) {
+  err(pc3.red(`\u2717 ${message}`));
+  return 1;
+}
+function runInstall(line, root) {
+  out(pc3.dim(`$ ${line}`));
+  const [command, ...args] = line.split(" ");
+  const result = spawnSync(command, args, {
+    cwd: root,
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  return result.status === 0;
+}
+function dotEnv(root) {
+  const file = join5(root, ".env");
+  return existsSync6(file) ? parseEnv(readFileSync2(file, "utf8")) : {};
+}
+var isSet = (name, fromFile) => (process.env[name] ?? "") !== "" || (fromFile[name] ?? "") !== "";
+async function problemsWith(candidate, recipe, root, fromFile) {
+  const problems = [];
+  const missing = recipe.install.filter((pkg) => !isInstalled(pkg, root));
+  if (missing.length > 0) {
+    problems.push(
+      `${missing.join(", ")} ${missing.length === 1 ? "is" : "are"} not installed: ${installLine(missing, process.env, root)}`
+    );
+  }
+  const saved = /* @__PURE__ */ new Map();
+  for (const { name, defaulted } of envCalls(candidate)) {
+    if ((process.env[name] ?? "") !== "") continue;
+    const value = fromFile[name] || (defaulted ? void 0 : `nymbal-add-placeholder-${name}`);
+    if (value === void 0) continue;
+    saved.set(name, process.env[name]);
+    process.env[name] = value;
+  }
+  const dir = mkdtempSync(join5(root, ".nymbal-add-"));
+  try {
+    writeFileSync(join5(dir, "nymbal.config.ts"), candidate);
+    await loadConfig2(dir);
+  } catch (error) {
+    problems.push(error.message);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+    for (const [name, value] of saved) {
+      if (value === void 0) delete process.env[name];
+      else process.env[name] = value;
+    }
+  }
+  return problems;
+}
+function lineDiff(before, after) {
+  const a = before.split("\n");
+  const b = after.split("\n");
+  const t = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+  for (let i2 = a.length - 1; i2 >= 0; i2--)
+    for (let j2 = b.length - 1; j2 >= 0; j2--)
+      t[i2][j2] = a[i2] === b[j2] ? t[i2 + 1][j2 + 1] + 1 : Math.max(t[i2 + 1][j2], t[i2][j2 + 1]);
+  const lines = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length || j < b.length) {
+    if (i < a.length && j < b.length && a[i] === b[j]) {
+      i++;
+      j++;
+    } else if (j < b.length && (i === a.length || t[i][j + 1] >= t[i + 1][j])) {
+      lines.push(pc3.green(`+ ${b[j++]}`));
+    } else {
+      lines.push(pc3.red(`- ${a[i++]}`));
+    }
+  }
+  return lines;
+}
+var show = (value) => typeof value === "string" ? `'${value}'` : JSON.stringify(value);
+async function add(opts, cwd = process.cwd()) {
+  const name = opts.recipe;
+  if (!isKnownRecipe(name)) {
+    return fail(`unknown recipe '${name}'. The recipes are: ${knownRecipes().join(", ")}`);
+  }
+  const configPath = findConfigFile2(cwd);
+  if (configPath === null) return fail(`no nymbal.config.ts in ${cwd} or any parent directory`);
+  const root = dirname6(configPath);
+  const holder = RECIPE_HOLDERS[name];
+  const installed = [];
+  if (recipeFile(name, root) === null) {
+    const line = installLine([holder], process.env, root);
+    if (!opts.install || opts.dryRun) {
+      return fail(
+        `the ${name} recipe ships in ${holder}, which is not installed. Install it: ${line}`
+      );
+    }
+    if (!runInstall(line, root)) return fail(`${line} failed`);
+    installed.push(holder);
+  }
+  const recipe = await readRecipe(name, root);
+  const source = readFileSync2(configPath, "utf8");
+  let edited;
+  try {
+    const applied = applyRecipeToConfig(source, recipe, { force: opts.force });
+    if ("conflict" in applied) {
+      const { path, current, wanted } = applied.conflict;
+      return fail(
+        `${path} is ${show(current)} in nymbal.config.ts, and the ${name} recipe sets it to ${show(wanted)}. nymbal.config.ts is unchanged: edit it by hand, or re-run with --force to overwrite it.`
+      );
+    }
+    edited = applied;
+  } catch (error) {
+    return fail(error.message);
+  }
+  const examplePath = join5(root, ".env.example");
+  const example = existsSync6(examplePath) ? readFileSync2(examplePath, "utf8") : "";
+  const nextExample = appendRecipeEnv(example, recipe);
+  if (opts.dryRun) {
+    out(pc3.bold(`nymbal add ${name} --dry-run: nothing is written`));
+    out();
+    out(
+      recipe.install.length > 0 ? `install: ${installLine(recipe.install, process.env, root)}` : "install: nothing"
+    );
+    out();
+    out("nymbal.config.ts:");
+    const diff = lineDiff(source, edited.source);
+    for (const line of diff.length > 0 ? diff : ["(already set)"]) out(`  ${line}`);
+    out();
+    out(".env.example:");
+    const added = nextExample.slice(example.length).split(/\r?\n/).filter((l) => l !== "");
+    for (const line of added.length > 0 ? added : ["(every variable already listed)"])
+      out(`  ${line}`);
+    return 0;
+  }
+  const pending = recipe.install.filter((pkg) => !isInstalled(pkg, root));
+  if (pending.length > 0 && opts.install) {
+    const line = installLine(pending, process.env, root);
+    if (!runInstall(line, root)) return fail(`${line} failed`);
+    installed.push(...pending);
+  }
+  const fromFile = dotEnv(root);
+  const problems = await problemsWith(edited.source, recipe, root, fromFile);
+  if (problems.length > 0) {
+    return fail(
+      `the ${name} recipe would leave a config that does not load, so nymbal.config.ts is unchanged:
+  ${problems.join("\n  ")}`
+    );
+  }
+  const written = [];
+  if (installed.length > 0) written.push(`package.json and its lockfile (${installed.join(", ")})`);
+  if (edited.source !== source) {
+    writeFileSync(configPath, edited.source);
+    written.push(`nymbal.config.ts (${edited.changed.join(", ")})`);
+  }
+  if (nextExample !== example) {
+    writeFileSync(examplePath, nextExample);
+    written.push(
+      `.env.example (${missingEnv(example, recipe).map((v) => v.name).join(", ")})`
+    );
+  }
+  out(pc3.green(`\u2713 ${name}: ${recipe.summary}`));
+  out(written.length > 0 ? `  changed ${written.join(", ")}` : "  already added: nothing changed");
+  const unset = recipe.env.filter((v) => v.required && !isSet(v.name, fromFile));
+  if (unset.length > 0 || recipe.next.length > 0) {
+    out();
+    out("Next:");
+    for (const v of unset) out(`  - set ${v.name} in .env`);
+    for (const line of recipe.next) out(`  - ${line}`);
+  }
+  return 0;
+}
+var addCommand = defineCommand7({
+  meta: {
+    name: "add",
+    description: `Put the store on a service: ${knownRecipes().join(", ")}`
+  },
+  args: {
+    recipe: { type: "positional", required: true, description: knownRecipes().join(", ") },
+    install: {
+      type: "boolean",
+      default: true,
+      description: "Install the packages (--no-install: they must already be installed)"
+    },
+    force: {
+      type: "boolean",
+      default: false,
+      description: "Overwrite a config value the recipe conflicts with"
+    },
+    "dry-run": {
+      type: "boolean",
+      default: false,
+      description: "Print the config change, the .env.example lines and the install line, and write nothing"
+    }
+  },
+  async run({ args }) {
+    process.exitCode = await add({
+      recipe: args.recipe,
+      install: args.install,
+      force: args.force,
+      dryRun: args["dry-run"]
+    });
+  }
+});
+
+// src/commands/doctor.ts
+import { existsSync as existsSync7 } from "fs";
+import { defineCommand as defineCommand8 } from "citty";
+import { createLogger as createLogger2, diagnose } from "@nymbalhq/platform";
+import { errorText, HEALTH_CHECK_TIMEOUT_MS } from "@nymbalhq/types";
+
+// src/commands/doctor-report.ts
+import pc4 from "picocolors";
+import { connectionSecrets, displayUrl as displayUrl2, SECRET_MIN_LENGTH } from "@nymbalhq/types";
+var TEXT_STATUS = {
+  ok: "ok",
+  healthy: "ok",
+  degraded: "warn",
+  down: "down"
+};
+var JSON_STATUS = {
+  ok: "ok",
+  healthy: "ok",
+  degraded: "degraded",
+  down: "down"
+};
+var COLOUR = { ok: pc4.green, warn: pc4.yellow, down: pc4.red };
+var SECRET_KEY = /secret|passw(?:or)?d|^pass$|token|api[-_]?key|private[-_]?key|credential|access[-_]?key/i;
+var SECRET_ENV = /SECRET|PASSWORD|PASSWD|(?:^|_)PASS(?:$|_)|TOKEN|API_KEY|PRIVATE_KEY|CREDENTIAL|ACCESS_KEY/i;
+var URL_IN_TEXT = /\b[a-z][a-z0-9+.-]*:\/\/[^\s'"`<>]+/gi;
+var TRAILING_PUNCTUATION = /[.,;:)\]}]+$/;
+function addSecret(into, value) {
+  if (value.length >= SECRET_MIN_LENGTH) into.add(value);
+}
+function collectFromConfig(value, key, into, seen) {
+  if (typeof value === "string") {
+    if (SECRET_KEY.test(key)) addSecret(into, value);
+    if (value.includes("://")) for (const s of connectionSecrets(value, { user: false })) addSecret(into, s);
+    return;
+  }
+  if (value === null || typeof value !== "object" || seen.has(value)) return;
+  seen.add(value);
+  for (const [k, v] of Object.entries(value)) collectFromConfig(v, k, into, seen);
+}
+function secretsOf(config, env) {
+  const found = /* @__PURE__ */ new Set();
+  collectFromConfig(config, "", found, /* @__PURE__ */ new WeakSet());
+  for (const [name, value] of Object.entries(env)) {
+    if (value === void 0) continue;
+    if (SECRET_ENV.test(name)) addSecret(found, value);
+    if (value.includes("://")) for (const s of connectionSecrets(value, { user: false })) addSecret(found, s);
+  }
+  return [...found].sort((a, b) => b.length - a.length);
+}
+function scrub(detail, secrets) {
+  let text2 = detail.replace(URL_IN_TEXT, (match) => {
+    const trailing = TRAILING_PUNCTUATION.exec(match)?.[0] ?? "";
+    return displayUrl2(match.slice(0, match.length - trailing.length)) + trailing;
+  });
+  for (const secret of secrets) text2 = text2.split(secret).join("***");
+  return text2.replace(/\s*\n\s*(?:•\s*)?/g, " ").trim();
+}
+function formatDoctorReport(report, options) {
+  const secrets = secretsOf(options.config, options.env ?? {});
+  const checks = report.checks.map((check) => ({
+    name: check.name,
+    status: check.status,
+    detail: scrub(check.detail, secrets)
+  }));
+  if (options.json) {
+    return JSON.stringify(
+      {
+        checks: checks.map((c) => ({ name: c.name, status: JSON_STATUS[c.status], detail: c.detail }))
+      },
+      null,
+      2
+    );
+  }
+  const width = Math.max(...checks.map((c) => c.name.length), 0);
+  const lines = checks.map((c) => {
+    const status = TEXT_STATUS[c.status];
+    return `${COLOUR[status](status.padEnd(4))}  ${c.name.padEnd(width)}  ${c.detail}`.trimEnd();
+  });
+  const count = (s) => checks.filter((c) => TEXT_STATUS[c.status] === s).length;
+  return [...lines, "", `${count("down")} down, ${count("warn")} warn, ${count("ok")} ok`].join("\n");
+}
+
+// src/commands/doctor.ts
+function timeoutOf(flag2) {
+  if (flag2 === void 0 || flag2.trim() === "") return HEALTH_CHECK_TIMEOUT_MS;
+  const ms = Number(flag2);
+  if (!Number.isInteger(ms) || ms < 1) {
+    throw new Error(`--timeout must be a whole number of milliseconds, got "${flag2}"`);
+  }
+  return ms;
+}
+function migrationsOf(projectRoot) {
+  const root = resolveMigrations(projectRoot);
+  return existsSync7(root) ? { migrationsRoot: root } : {};
+}
+var doctorCommand = defineCommand8({
+  meta: {
+    name: "doctor",
+    description: "Check the project without changing it: config, packages, command store, migrations, slots and primitives"
+  },
+  args: {
+    json: { type: "boolean", description: "Print the checks as one JSON document", default: false },
+    timeout: {
+      type: "string",
+      description: `How long each check may take, in ms (default ${HEALTH_CHECK_TIMEOUT_MS})`
+    }
+  },
+  async run({ args }) {
+    const timeoutMs = timeoutOf(args.timeout);
+    let loaded;
+    try {
+      loaded = await loadProject();
+    } catch (error) {
+      loaded = { error };
+    }
+    const report = "error" in loaded ? (
+      // Nothing else can be checked without a config, so it is the only line.
+      { checks: [{ name: "config", status: "down", detail: errorText(loaded.error) }] }
+    ) : await diagnose(loaded.config, {
+      ...loaded.adapters !== void 0 && { adapters: loaded.adapters },
+      // The report carries every failure; a log line would only repeat one, and break `--json`.
+      logger: createLogger2({ level: "silent", pretty: false }),
+      timeoutMs,
+      ...migrationsOf(loaded.projectRoot)
+    });
+    const text2 = formatDoctorReport(report, {
+      json: args.json,
+      config: "error" in loaded ? void 0 : loaded.config,
+      env: process.env
+    });
+    const down = report.checks.some((check) => check.status === "down");
+    process.stdout.write(`${text2}
+`, () => process.exit(down ? 1 : 0));
+  }
+});
+
+// src/commands/test.ts
+import { defineCommand as defineCommand9 } from "citty";
+import { loadConfig as loadConfig3 } from "@nymbalhq/config";
+var testCommand = defineCommand9({
   meta: { name: "test", description: "Run unit + integration tests (vitest)" },
   async run() {
     await runOrFail("pnpm", ["vitest", "run"]);
   }
 });
-var testE2eCommand = defineCommand7({
+var testE2eCommand = defineCommand9({
   meta: { name: "test:e2e", description: "Run Playwright E2E against the configured template" },
   async run() {
-    const { config } = await loadConfig2();
+    const { config } = await loadConfig3();
     await runOrFail("pnpm", [
       "--filter",
       "@nymbalhq/e2e",
@@ -659,7 +1584,7 @@ var testE2eCommand = defineCommand7({
     ]);
   }
 });
-var testVisualCommand = defineCommand7({
+var testVisualCommand = defineCommand9({
   meta: { name: "test:visual", description: "Run visual regression tests (Playwright toHaveScreenshot)" },
   args: {
     "update-baselines": {
@@ -669,7 +1594,7 @@ var testVisualCommand = defineCommand7({
     }
   },
   async run({ args }) {
-    const { config } = await loadConfig2();
+    const { config } = await loadConfig3();
     const isCI = !!process.env.CI;
     const updateBaselines = args["update-baselines"];
     if (updateBaselines && !isCI) {
@@ -704,7 +1629,7 @@ var testVisualCommand = defineCommand7({
     }
   }
 });
-var testContractsCommand = defineCommand7({
+var testContractsCommand = defineCommand9({
   meta: { name: "test:contracts", description: "Run adapter contract tests" },
   args: {
     adapter: { type: "string", description: "Run only contracts for a specific adapter (e.g. payments, email)" }
@@ -722,10 +1647,10 @@ var testContractsCommand = defineCommand7({
     await runOrFail("pnpm", vArgs);
   }
 });
-var testPerformanceCommand = defineCommand7({
+var testPerformanceCommand = defineCommand9({
   meta: { name: "test:performance", description: "Run Lighthouse CI against the configured template" },
   async run() {
-    const { config } = await loadConfig2();
+    const { config } = await loadConfig3();
     const port = config.template === "nextjs" ? 3e3 : 4321;
     await runOrFail("pnpm", ["lhci", "autorun"], {
       env: {
@@ -736,7 +1661,7 @@ var testPerformanceCommand = defineCommand7({
     });
   }
 });
-var testAllCommand = defineCommand7({
+var testAllCommand = defineCommand9({
   meta: { name: "test:all", description: "Run unit, contract, e2e, visual, and performance tests" },
   async run() {
     const steps = [
@@ -751,7 +1676,7 @@ var testAllCommand = defineCommand7({
         process.exit(code);
       }
     }
-    const { config } = await loadConfig2();
+    const { config } = await loadConfig3();
     await runOrFail("pnpm", [
       "--filter",
       "@nymbalhq/e2e",
@@ -781,7 +1706,7 @@ var testAllCommand = defineCommand7({
 });
 
 // src/index.ts
-var main = defineCommand8({
+var main = defineCommand10({
   meta: {
     name: "nymbal",
     version: getCliVersion(),
@@ -794,6 +1719,8 @@ var main = defineCommand8({
     seed: seedCommand,
     import: importCommand,
     "config:validate": configValidateCommand,
+    add: addCommand,
+    doctor: doctorCommand,
     test: testCommand,
     "test:e2e": testE2eCommand,
     "test:visual": testVisualCommand,