@quyentran93/servercn-cli 1.1.10

package/dist/cli.js

@@ -0,0 +1,2778 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/add/index.ts
+import fs9 from "fs-extra";
+import path10 from "path";
+
+// src/lib/copy.ts
+import fs from "fs-extra";
+import path from "path";
+
+// src/utils/highlighter.ts
+import kleur from "kleur";
+var highlighter = {
+  error: kleur.red,
+  warn: kleur.yellow,
+  info: kleur.cyan,
+  success: kleur.green,
+  create: kleur.blue,
+  mute: kleur.dim,
+  magenta: kleur.magenta
+};
+
+// src/utils/logger.ts
+var logger = {
+  error(...args) {
+    console.log(highlighter.error(args.join(" ")));
+  },
+  warn(...args) {
+    console.log(highlighter.warn(args.join(" ")));
+  },
+  info(...args) {
+    console.log(highlighter.info(args.join(" ")));
+  },
+  success(...args) {
+    console.log(highlighter.success(args.join(" ")));
+  },
+  log(...args) {
+    console.log(args.join(" "));
+  },
+  break() {
+    console.log("");
+  },
+  section: (title) => {
+    console.log("\n" + title);
+  },
+  muted: (msg) => console.log(highlighter.mute(msg)),
+  create: (msg) => console.log(`${highlighter.create("CREATE:")} ${msg}`),
+  skip: (msg) => console.log(`${highlighter.warn("SKIP:")} ${msg} (exists)`),
+  overwrite: (msg) => console.log(`${highlighter.info("OVERWRITE:")} ${msg}`)
+};
+
+// src/utils/file.ts
+function findFilesByPath(component, templatePath, selectedProvider) {
+  const parts = templatePath.split("/");
+  const [type] = parts;
+  if (type === "tooling" && "templates" in component) {
+    const templates = component.templates;
+    for (const tmpl of Object.values(templates || {})) {
+      if (tmpl.files) return tmpl.files;
+    }
+    return null;
+  } else {
+    const [runtime, framework, type2] = parts;
+    const archKey = parts[parts.length - 1];
+    if (!("runtimes" in component)) return null;
+    const runtimes = component.runtimes;
+    const fw = runtimes[runtime]?.frameworks?.[framework];
+    if (!fw) return null;
+    if (fw.architectures && fw.architectures[archKey]) {
+      return fw.architectures[archKey].files;
+    }
+    if (fw.variants && selectedProvider !== void 0) {
+      return fw?.variants[selectedProvider]?.architectures[archKey].files;
+    }
+    if (fw.databases) {
+      if (type2 === "blueprint") {
+        const [, , , db, orm, arch] = parts;
+        const database = fw.databases?.[db];
+        if (!database) return null;
+        const ormConfig = database.orms?.[orm];
+        if (!ormConfig || !ormConfig.architectures) return null;
+        const architecture = ormConfig.architectures?.[arch];
+        if (!architecture) return null;
+        return architecture.files ?? null;
+      } else if (type2 === "schema") {
+        const [, , , db, orm, variant, arch] = parts;
+        const database = fw.databases?.[db];
+        if (!database) return null;
+        const ormConfig = database.orms?.[orm];
+        if (!ormConfig || !ormConfig.templates) return null;
+        const template = ormConfig.templates?.[variant];
+        if (!template) return null;
+        const architecture = template.architectures?.[arch];
+        if (!architecture) return null;
+        return architecture.files ?? null;
+      }
+    }
+    return null;
+  }
+}
+
+// src/utils/normalize-eol.ts
+function normalizeEol(content) {
+  return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+// src/lib/merge-marker.ts
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function markerBeginLine(slug) {
+  return `// @servercn:begin ${slug}`;
+}
+function markerEndLine(slug) {
+  return `// @servercn:end ${slug}`;
+}
+function isMergeOnlyFragment(content, slug) {
+  const n = normalizeEol(content).trim();
+  const begin = markerBeginLine(slug);
+  const end = markerEndLine(slug);
+  if (!n.startsWith(`${begin}
+`) || !n.endsWith(end)) {
+    return false;
+  }
+  const inner = n.slice(begin.length + 1, n.length - end.length).trimEnd();
+  return !inner.includes("\n// @servercn:begin ");
+}
+function extractMarkerInner(content, slug) {
+  const n = normalizeEol(content).trim();
+  const begin = markerBeginLine(slug);
+  const end = markerEndLine(slug);
+  const re = new RegExp(
+    `^${escapeRegExp(begin)}\\s*\\n([\\s\\S]*?)\\n${escapeRegExp(end)}\\s*$`
+  );
+  const m = n.match(re);
+  return m ? m[1] : null;
+}
+function applyMarkerMerge(dest, template, slug) {
+  const inner = extractMarkerInner(template, slug);
+  if (inner === null) {
+    return { ok: false, reason: "missing_marker_in_template" };
+  }
+  const normalizedDest = normalizeEol(dest);
+  const begin = markerBeginLine(slug);
+  const end = markerEndLine(slug);
+  const blockRe = new RegExp(
+    `${escapeRegExp(begin)}\\s*\\n([\\s\\S]*?)\\n${escapeRegExp(end)}`,
+    "m"
+  );
+  if (!blockRe.test(normalizedDest)) {
+    return { ok: false, reason: "missing_marker_in_dest" };
+  }
+  const next = normalizedDest.replace(
+    blockRe,
+    `${begin}
+${inner}
+${end}`
+  );
+  return { ok: true, content: next };
+}
+
+// src/lib/copy.ts
+async function copyTemplate({
+  templateDir,
+  targetDir,
+  registryItemName,
+  conflict = "skip",
+  dryRun = false,
+  merge = false
+}) {
+  await fs.ensureDir(targetDir);
+  const entries = await fs.readdir(templateDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(templateDir, entry.name);
+    const rawName = entry.name === "_gitignore" ? ".gitignore" : entry.name;
+    const finalName = rawName;
+    const destPath = path.join(targetDir, finalName);
+    const relativeDestPath = path.relative(process.cwd(), destPath);
+    if (entry.isDirectory()) {
+      await copyTemplate({
+        templateDir: srcPath,
+        targetDir: destPath,
+        registryItemName,
+        conflict,
+        dryRun,
+        merge
+      });
+      continue;
+    }
+    const exists = await fs.pathExists(destPath);
+    if (exists) {
+      if (conflict === "skip") {
+        if (merge && registryItemName) {
+          const peek = await fs.readFile(srcPath);
+          if (!peek.includes(0)) {
+            const srcText = normalizeEol(peek.toString("utf8"));
+            if (isMergeOnlyFragment(srcText, registryItemName)) {
+              const destText = normalizeEol(
+                await fs.readFile(destPath, "utf8")
+              );
+              const merged = applyMarkerMerge(
+                destText,
+                srcText,
+                registryItemName
+              );
+              if (!merged.ok) {
+                logger.error(
+                  `Merge failed for ${relativeDestPath}: destination is missing // @servercn:begin/end ${registryItemName} markers. Add them or use --force.`
+                );
+                process.exit(1);
+              }
+              if (!dryRun) {
+                await fs.writeFile(destPath, merged.content, "utf8");
+                logger.info(`MERGE: ${relativeDestPath}`);
+              } else {
+                logger.info(`[dry-run] merge: ${relativeDestPath}`);
+              }
+              continue;
+            }
+          }
+        }
+        logger.skip(relativeDestPath);
+        continue;
+      }
+      if (conflict === "error") {
+        throw new Error(`File already exists: ${relativeDestPath}`);
+      }
+    }
+    if (dryRun) {
+      logger.info(
+        `[dry-run] ${exists ? "overwrite" : "create"}: ${relativeDestPath}`
+      );
+      continue;
+    }
+    const buffer = await fs.readFile(srcPath);
+    const isBinary = buffer.includes(0);
+    if (!exists && !isBinary && merge && registryItemName && isMergeOnlyFragment(normalizeEol(buffer.toString("utf8")), registryItemName)) {
+      logger.muted(
+        `SKIP (merge-only fragment, target missing): ${relativeDestPath}`
+      );
+      continue;
+    }
+    await fs.ensureDir(path.dirname(destPath));
+    if (isBinary) {
+      await fs.copyFile(srcPath, destPath);
+    } else {
+      const content = normalizeEol(buffer.toString("utf8"));
+      await fs.writeFile(destPath, content, "utf8");
+    }
+    if (exists) {
+      logger.overwrite(relativeDestPath);
+    } else {
+      logger.create(relativeDestPath);
+    }
+  }
+}
+async function cloneServercnRegistry({
+  component,
+  templatePath,
+  targetDir,
+  selectedProvider,
+  options
+}) {
+  logger.break();
+  try {
+    const files = findFilesByPath(component, templatePath, selectedProvider);
+    if (!files || files.length === 0) {
+      return false;
+    }
+    const slug = "slug" in component && typeof component.slug === "string" ? component.slug : "";
+    const useMerge = Boolean(options.merge && !options.force && slug);
+    for (const file of files) {
+      const destPath = path.join(targetDir, file.path);
+      const exists = await fs.pathExists(destPath);
+      const templateContent = normalizeEol(file.content);
+      if (options.force) {
+        await fs.ensureDir(path.dirname(destPath));
+        await fs.writeFile(destPath, templateContent, "utf8");
+        if (exists) {
+          logger.overwrite(file.path);
+        } else {
+          logger.create(file.path);
+        }
+        continue;
+      }
+      if (useMerge && isMergeOnlyFragment(templateContent, slug)) {
+        if (!exists) {
+          logger.muted(
+            `SKIP (merge-only fragment, target missing): ${file.path}`
+          );
+          continue;
+        }
+        const destText = normalizeEol(await fs.readFile(destPath, "utf8"));
+        const merged = applyMarkerMerge(destText, templateContent, slug);
+        if (!merged.ok) {
+          logger.error(
+            `Merge failed for ${file.path}: destination is missing // @servercn:begin/end ${slug} markers. Add them or use --force.`
+          );
+          process.exit(1);
+        }
+        await fs.ensureDir(path.dirname(destPath));
+        await fs.writeFile(destPath, merged.content, "utf8");
+        logger.info(`MERGE: ${file.path}`);
+        continue;
+      }
+      if (exists) {
+        logger.skip(file.path);
+        continue;
+      }
+      await fs.ensureDir(path.dirname(destPath));
+      await fs.writeFile(destPath, templateContent, "utf8");
+      logger.create(file.path);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/registry.ts
+import fs4 from "fs-extra";
+import path4 from "path";
+
+// src/lib/paths.ts
+import path2 from "path";
+import { fileURLToPath } from "url";
+import fs2 from "fs";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.dirname(__filename);
+function getMonorepoRoot() {
+  let current = __dirname;
+  while (current !== path2.parse(current).root) {
+    if (fs2.existsSync(path2.join(current, "packages")) && fs2.existsSync(path2.join(current, "apps"))) {
+      return current;
+    }
+    current = path2.join(current, "..");
+  }
+  return path2.resolve(
+    __dirname,
+    __dirname.includes("dist") ? "../../" : "../../../../"
+  );
+}
+function resolveTargetDir(folderName) {
+  const cwd = process.cwd();
+  return path2.join(cwd, folderName);
+}
+var paths = {
+  root: getMonorepoRoot(),
+  // Registry-build related paths
+  registryBase: path2.join(getMonorepoRoot(), "packages/registry"),
+  templateBase: path2.join(getMonorepoRoot(), "packages/templates"),
+  outputBase: path2.join(getMonorepoRoot(), "apps/web/public/sr"),
+  localRegistry: (f) => path2.join(getMonorepoRoot(), "packages/registry", f ? `${f}` : ""),
+  remoteRegistry: path2.join(
+    getMonorepoRoot(),
+    "apps/web/public/sr",
+    "index.json"
+  ),
+  templates: () => path2.join(getMonorepoRoot(), "packages/templates"),
+  targets: (folderName) => resolveTargetDir(folderName)
+};
+
+// src/utils/capitalize.ts
+function capitalize(name = "") {
+  return name?.split("")[0]?.toUpperCase() + name.split("")?.slice(1)?.join("")?.toLowerCase();
+}
+
+// package.json
+var package_default = {
+  name: "@quyentran93/servercn-cli",
+  version: "1.1.10",
+  description: "Backend components CLI for Node.js & Typescript",
+  main: "dist/cli.js",
+  readme: "README.md",
+  bin: {
+    servercn: "dist/cli.js"
+  },
+  scripts: {
+    dev: "tsup --watch",
+    build: "tsup",
+    typecheck: "tsc --noEmit",
+    "test:merge-marker": "tsx src/lib/merge-marker.selftest.ts",
+    prepublishOnly: "npm run build",
+    pub: "npm publish"
+  },
+  keywords: [
+    "servercn",
+    "cli",
+    "backend",
+    "typescript",
+    "node.js",
+    "express",
+    "nodejs",
+    "scaffold",
+    "boilerplate",
+    "component"
+  ],
+  author: {
+    name: "Akkal Dhami",
+    github: "https://github.com/QuyenTran93",
+    url: "https://x.com/AavashDhami2127"
+  },
+  license: "MIT",
+  files: [
+    "dist",
+    "README.md"
+  ],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/QuyenTran93/servercn.git",
+    directory: "packages/cli"
+  },
+  type: "module",
+  dependencies: {
+    "cli-table3": "^0.6.5",
+    commander: "^14.0.2",
+    execa: "^9.6.1",
+    "fs-extra": "^11.3.3",
+    glob: "^10.5.0",
+    kleur: "^3.0.3",
+    ora: "^9.3.0",
+    prompts: "^2.4.2"
+  },
+  devDependencies: {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.0.3",
+    "@types/prompts": "^2.4.9",
+    tsup: "^8.5.1",
+    tsx: "^4.21.0",
+    typescript: "^5.9.3"
+  }
+};
+
+// src/constants/app.constants.ts
+var SERVERCN_URL = "https://servercn.vercel.app";
+var SERVERCN_CONFIG_FILE = "servercn.config.json";
+var APP_NAME = "servercn";
+var LATEST_VERSION = package_default.version || "1.0.0";
+var RegistryTypeList = [
+  "component",
+  "blueprint",
+  "schema",
+  "foundation",
+  "tooling"
+];
+
+// src/lib/registry-list.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+async function loadRegistryItems(type, local = false) {
+  if (local) {
+    const registryDir = paths.localRegistry(type);
+    const files = await fs3.readdir(registryDir);
+    const items = [];
+    for (const file of files) {
+      let nestedFiles = [];
+      if (!file.endsWith(".json")) {
+        nestedFiles = await fs3.readdir(path3.join(registryDir, file));
+        for (const nestedFile of nestedFiles) {
+          if (!nestedFile.endsWith(".json")) continue;
+          const fullPath = path3.join(registryDir, file, nestedFile);
+          const data = await fs3.readJSON(fullPath);
+          items.push(data);
+        }
+      } else {
+        const fullPath = path3.join(registryDir, file);
+        const data = await fs3.readJSON(fullPath);
+        items.push(data);
+      }
+    }
+    const mappedItems = items.map((item) => {
+      return {
+        slug: item.slug,
+        type
+      };
+    });
+    return mappedItems;
+  } else {
+    const url = `${SERVERCN_URL}/sr/index.json`;
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        if (response.status === 404) {
+          logger.error(`
+${capitalize(type)} not found in registry.
+`);
+        } else {
+          logger.error(
+            `
+Failed to fetch registry item: ${response.statusText}`
+          );
+        }
+        process.exit(1);
+      }
+      const data = await response.json();
+      const mappedItems = data.items.filter((item) => item.type === type);
+      return mappedItems;
+    } catch {
+      logger.error(`
+Failed to fetch registry item
+`);
+      process.exit(1);
+    }
+  }
+}
+
+// src/commands/list/list.handlers.ts
+import Table from "cli-table3";
+async function listOverview(options) {
+  const components = await loadRegistryItems("component", options.local);
+  const blueprints = await loadRegistryItems("blueprint", options.local);
+  const foundations = await loadRegistryItems("foundation", options.local);
+  const toolings = await loadRegistryItems("tooling", options.local);
+  const schemas = await loadRegistryItems("schema", options.local);
+  if (options.all) {
+    return await getRegistryLists("blueprint", options);
+  }
+  const data = {
+    command: "npx servercn-cli list <type>",
+    types: [
+      {
+        type: "component",
+        alias: "cp",
+        total: components.length,
+        command: "npx servercn-cli list cp"
+      },
+      {
+        type: "blueprint",
+        alias: "bp",
+        total: blueprints.length,
+        command: "npx servercn-cli list bp"
+      },
+      {
+        type: "foundation",
+        alias: "fd",
+        total: foundations.length,
+        command: "npx servercn-cli list fd"
+      },
+      {
+        type: "tooling",
+        alias: "tl",
+        total: toolings.length,
+        command: "npx servercn-cli list tl"
+      },
+      {
+        type: "schema",
+        alias: "sc",
+        total: schemas.length,
+        command: "npx servercn-cli list sc"
+      }
+    ]
+  };
+  const table = new Table({
+    head: [
+      highlighter.error("type"),
+      highlighter.error("total"),
+      highlighter.error("alias"),
+      highlighter.error("command")
+    ],
+    colWidths: [12, 8, 8, 28]
+  });
+  data.types.forEach((type) => {
+    table.push([
+      highlighter.create(type.type),
+      type.total,
+      highlighter.warn(type.alias),
+      highlighter.info(type.command)
+    ]);
+  });
+  if (options?.json) {
+    logger.break();
+    process.stdout.write(JSON.stringify(data, null, 2));
+    logger.break();
+    return;
+  }
+  logger.break();
+  logger.log(table.toString());
+  logger.log(`
+ ${highlighter.create("Explore:")}
+ npx servercn-cli ls <type | alias>
+ npx servercn-cli ls <type | alias> --json
+
+ ${highlighter.create("Examples:")}
+ npx servercn-cli ls component
+ npx servercn-cli ls cp
+ npx servercn-cli ls foundation
+ npx servercn-cli ls fd --json
+ npx servercn-cli ls schema
+ npx servercn-cli ls sc --json
+`);
+  logger.break();
+}
+async function listComponents(options) {
+  const components = await loadRegistryItems(
+    "component",
+    options.local
+  );
+  const data = {
+    type: "component",
+    command: `npx servercn-cli add <component-name>`,
+    total: components.length,
+    items: components.map((c) => ({
+      name: c.slug,
+      command: `npx servercn-cli add ${c.slug}`,
+      ...c?.frameworks && c.frameworks.length > 0 && { framework: c.frameworks }
+    }))
+  };
+  if (options?.json) {
+    process.stdout.write(JSON.stringify(data, null, 2));
+    logger.break();
+    return;
+  }
+  const table = new Table({
+    head: [
+      highlighter.create("s.no"),
+      highlighter.create("name"),
+      highlighter.create("command"),
+      highlighter.create("frameworks")
+    ],
+    colWidths: [6, 26, 46, 26]
+  });
+  logger.break();
+  logger.log(highlighter.create("Available Component"));
+  components.map((c, i) => {
+    table.push([
+      i + 1,
+      c.slug,
+      `npx servercn-cli add ${c.slug}`,
+      c?.frameworks && c.frameworks.join(", ") || ""
+    ]);
+  });
+  logger.log(table.toString());
+  logger.info(` Learn more: ${SERVERCN_URL}/components`);
+  logger.break();
+}
+async function listFoundations(options) {
+  const foundations = await loadRegistryItems("foundation", options.local);
+  const data = {
+    type: "foundation",
+    command: `npx servercn-cli init <foundation-name>`,
+    total: foundations.length,
+    items: foundations.sort((a, b) => a.slug.localeCompare(b.slug)).map((c) => ({
+      name: c.slug,
+      command: `npx servercn-cli init ${c.slug}`,
+      ...c?.frameworks && c.frameworks.length > 0 && { frameworks: c.frameworks }
+    }))
+  };
+  if (options?.json) {
+    process.stdout.write(JSON.stringify(data, null, 2));
+    logger.break();
+    return;
+  }
+  const table = new Table({
+    head: [
+      highlighter.create("s.no"),
+      highlighter.create("name"),
+      highlighter.create("command"),
+      highlighter.create("frameworks")
+    ],
+    colWidths: [6, 26, 46, 26]
+  });
+  logger.break();
+  logger.log(highlighter.create("Available Foundation"));
+  foundations.map((c, i) => {
+    table.push([
+      i + 1,
+      c.slug,
+      `npx servercn-cli init ${c.slug}`,
+      c?.frameworks && c.frameworks.join(", ") || ""
+    ]);
+  });
+  logger.log(table.toString());
+  logger.info(`Learn more: ${SERVERCN_URL}/foundations`);
+  logger.break();
+}
+async function listTooling(options) {
+  const toolings = await loadRegistryItems("tooling", options.local);
+  const data = {
+    type: "tooling",
+    alias: "tl",
+    command: `npx servercn-cli add tooling <tooling-name>`,
+    total: toolings.length,
+    items: toolings.map((c) => ({
+      name: c.slug,
+      command: `npx servercn-cli add tl ${c.slug}`
+    }))
+  };
+  if (options?.json) {
+    process.stdout.write(JSON.stringify(data, null, 2));
+    logger.break();
+    return;
+  }
+  const table = new Table({
+    head: [
+      highlighter.create("s.no"),
+      highlighter.create("name"),
+      highlighter.create("command")
+    ],
+    colWidths: [6, 26, 46]
+  });
+  logger.break();
+  logger.log(highlighter.create("Available Tooling"));
+  toolings.map((c, i) => {
+    table.push([i + 1, c.slug, `npx servercn-cli add tl ${c.slug}`]);
+  });
+  logger.log(table.toString());
+  logger.info(`Learn more: ${SERVERCN_URL}/docs`);
+  logger.break();
+}
+async function listSchemas(options) {
+  const schemas = await loadRegistryItems("schema", options.local);
+  const data = {
+    type: "schema",
+    alias: "sc",
+    command: `npx servercn-cli add schema <schema-name>`,
+    total: schemas.length,
+    items: schemas.sort((a, b) => a.slug.localeCompare(b.slug)).map((c) => ({
+      name: c.slug,
+      command: `npx servercn-cli add sc ${c.slug}`,
+      ...c?.frameworks && c.frameworks.length > 0 && { frameworks: c.frameworks }
+    }))
+  };
+  if (options?.json) {
+    process.stdout.write(JSON.stringify(data, null, 2));
+    logger.break();
+    return;
+  }
+  const table = new Table({
+    head: [
+      highlighter.create("s.no"),
+      highlighter.create("name"),
+      highlighter.create("command"),
+      highlighter.create("frameworks")
+    ],
+    colWidths: [6, 26, 46, 26]
+  });
+  logger.break();
+  logger.log(highlighter.create("Available Schemas"));
+  schemas.map((c, i) => {
+    table.push([
+      i + 1,
+      c.slug,
+      `npx servercn-cli add sc ${c.slug}`,
+      c?.frameworks && c.frameworks.join(", ") || ""
+    ]);
+  });
+  logger.log(table.toString());
+  logger.info(`Learn more: ${SERVERCN_URL}/schemas`);
+  logger.break();
+}
+async function listBlueprints(options) {
+  const blueprints = await loadRegistryItems("blueprint", options.local);
+  const data = {
+    type: "blueprint",
+    alias: "bp",
+    command: `npx servercn-cli add blueprint <blueprint-name>`,
+    total: blueprints.length,
+    items: blueprints.map((c) => ({
+      name: c.slug,
+      command: `npx servercn-cli add bp ${c.slug}`,
+      ...c?.frameworks && c.frameworks.length > 0 && { frameworks: c.frameworks }
+    }))
+  };
+  if (options?.json) {
+    process.stdout.write(JSON.stringify(data, null, 2));
+    logger.break();
+    return;
+  }
+  const table = new Table({
+    head: [
+      highlighter.create("s.no"),
+      highlighter.create("name"),
+      highlighter.create("command"),
+      highlighter.create("frameworks")
+    ],
+    colWidths: [6, 26, 46, 26]
+  });
+  logger.break();
+  logger.log(highlighter.create("Available Blueprints"));
+  blueprints.map((c, i) => {
+    table.push([
+      i + 1,
+      c.slug,
+      `npx servercn-cli add bp ${c.slug}`,
+      c?.frameworks && c.frameworks.join(", ") || ""
+    ]);
+  });
+  logger.log(table.toString());
+  logger.info(`Learn more: ${SERVERCN_URL}/blueprints`);
+  logger.break();
+}
+async function getRegistryLists(type, options) {
+  if (options?.all && options.json) {
+    await listComponents({ json: true, local: options.local });
+    await listSchemas({ json: true, local: options.local });
+    await listBlueprints({ json: true, local: options.local });
+    await listTooling({ json: true, local: options.local });
+    await listFoundations({ json: true, local: options.local });
+  } else if (options?.all) {
+    await listComponents({ json: false, local: options.local });
+    await listSchemas({ json: false, local: options.local });
+    await listBlueprints({ json: false, local: options.local });
+    await listTooling({ json: false, local: options.local });
+    await listFoundations({ json: false, local: options.local });
+  } else {
+    switch (type) {
+      case "component":
+        return await listComponents(options ?? { json: false });
+      case "blueprint":
+        return await listBlueprints(options ?? { json: false });
+      case "schema":
+        return await listSchemas(options ?? { json: false });
+      case "tooling":
+        return listTooling(options ?? { json: false });
+      case "foundation":
+        return await listFoundations(options ?? { json: false });
+      default:
+        return await listComponents(options ?? { json: false });
+    }
+  }
+}
+
+// src/lib/registry.ts
+async function getRegistry(name, type, local) {
+  const registryItemName = name.includes("/") ? name.split("/").shift() || name : name;
+  if (local) {
+    const registryPath = paths.localRegistry(type);
+    if (!await fs4.pathExists(registryPath)) {
+      logger.break();
+      logger.error(
+        "Something went wrong. Please check the error below for more details."
+      );
+      logger.error(`
+Registry path not found`);
+      logger.error("\nCheck if the item name is correct.");
+      logger.break();
+      process.exit(1);
+    }
+    const filePath = path4.join(registryPath, `${registryItemName}.json`);
+    if (!await fs4.pathExists(filePath)) {
+      logger.break();
+      logger.error(
+        "Something went wrong. Please check the error below for more details."
+      );
+      logger.error(`
+${capitalize(type)} '${name}' not found!`);
+      logger.break();
+      await getRegistryLists(type);
+      process.exit(1);
+    }
+    return fs4.readJSON(filePath);
+  } else {
+    const url = `${SERVERCN_URL}/sr/${type}/${registryItemName}.json`;
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        if (response.status === 404) {
+          logger.error(
+            `
+${capitalize(type)} '${name}' not found in registry.
+`
+          );
+        } else {
+          logger.error(
+            `
+Failed to fetch registry item: ${response.statusText}`
+          );
+        }
+        process.exit(1);
+      }
+      return await response.json();
+    } catch {
+      logger.error(`
+Failed to fetch registry item
+`);
+      process.exit(1);
+    }
+  }
+}
+
+// src/lib/install-deps.ts
+import { execa } from "execa";
+
+// src/lib/detect.ts
+import fs5 from "fs";
+import path5 from "path";
+function detectPackageManager(cwd = process.cwd()) {
+  if (fs5.existsSync(path5.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs5.existsSync(path5.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs5.existsSync(path5.join(cwd, "bun.lock"))) return "bun";
+  return "npm";
+}
+
+// src/utils/spinner.ts
+import ora from "ora";
+function spinner(text, options) {
+  return ora({
+    text,
+    isSilent: options?.silent
+  });
+}
+
+// src/lib/install-deps.ts
+var clean = (arr) => arr.filter((dep) => typeof dep === "string" && dep.trim().length > 0);
+async function installDependencies({
+  runtime = [],
+  dev = [],
+  cwd,
+  packageManager
+}) {
+  const runtimeDeps = clean(runtime);
+  const devDeps = clean(dev);
+  if (runtimeDeps.length === 0 && devDeps.length === 0) return;
+  if (runtimeDeps.length > 0) {
+    logger.log("\nInstalling dependencies:");
+    runtimeDeps.forEach((dep) => logger.info(`- ${dep}`));
+  }
+  if (devDeps.length > 0) {
+    logger.log("\nInstalling devDependencies:");
+    devDeps.forEach((dep) => logger.info(`- ${dep}`));
+  }
+  if (runtimeDeps.length > 0 || devDeps.length > 0) {
+    logger.break();
+  }
+  const pm = packageManager ?? detectPackageManager();
+  const run = async (packages, isDev) => {
+    const label = isDev ? "devDependencies" : "dependencies";
+    if (packages.length === 0) return;
+    const spin = spinner(`Installing ${label} with ${pm}`)?.start();
+    try {
+      await execa(pm, getInstallArgs(pm, packages, isDev), {
+        cwd,
+        stdio: "pipe"
+      });
+      spin?.succeed(`Successfully installed ${packages.length} ${label}`);
+    } catch (error) {
+      spin?.fail(`Failed to install ${label}`);
+      logger.error(error.stderr || error.message);
+      throw error;
+    }
+  };
+  await run(runtimeDeps, false);
+  logger.break();
+  await run(devDeps, true);
+}
+function getInstallArgs(pm, packages, isDev) {
+  switch (pm) {
+    case "pnpm":
+      return ["add", ...isDev ? ["-D"] : [], ...packages];
+    case "yarn":
+      return ["add", ...isDev ? ["-D"] : [], ...packages];
+    case "bun":
+      return ["add", ...isDev ? ["-d"] : [], ...packages];
+    case "npm":
+    default:
+      return ["install", ...isDev ? ["--save-dev"] : [], ...packages];
+  }
+}
+
+// src/lib/package.ts
+import fs6 from "fs";
+import path6 from "path";
+import { execSync } from "child_process";
+function ensurePackageJson(dir) {
+  const pkgPath = path6.join(dir, "package.json");
+  if (fs6.existsSync(pkgPath)) return;
+  logger.info("Initializing package.json");
+  execSync("npm init -y", {
+    cwd: dir,
+    stdio: "ignore"
+  });
+}
+function ensureTsConfig(dir) {
+  const tsconfigPath = path6.join(dir, "tsconfig.json");
+  if (fs6.existsSync(tsconfigPath)) return;
+  const tsConfig2 = {
+    compilerOptions: {
+      target: "ES2021",
+      module: "es2022",
+      moduleResolution: "bundler",
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      outDir: "dist",
+      rootDir: "src",
+      sourceMap: true,
+      alwaysStrict: true,
+      useUnknownInCatchVariables: true,
+      forceConsistentCasingInFileNames: true,
+      paths: {
+        "@/*": ["./src/*"]
+      }
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules"]
+  };
+  fs6.writeFileSync(tsconfigPath, JSON.stringify(tsConfig2, null, 2));
+}
+
+// src/lib/assert-initialized.ts
+import fs7 from "fs-extra";
+import path7 from "path";
+async function assertInitialized() {
+  const configPath = path7.resolve(process.cwd(), SERVERCN_CONFIG_FILE);
+  if (!await fs7.pathExists(configPath)) {
+    logger.break();
+    logger.error(`${APP_NAME} is not initialized in this project.`);
+    logger.break();
+    logger.log("Run the following command first:");
+    logger.log(`> ${highlighter.create("npx servercn-cli init")}`);
+    logger.break();
+    logger.log(
+      `For express starter:
+> ${highlighter.create("npx servercn-cli init express-server")}`
+    );
+    logger.break();
+    logger.log(
+      `For (express + mongoose) starter:
+> ${highlighter.create("npx servercn-cli init mongoose-starter")}`
+    );
+    logger.break();
+    logger.log(
+      `For (drizzle + mysql) starter:
+> ${highlighter.create("npx servercn-cli init drizzle-mysql-starter")}`
+    );
+    logger.break();
+    logger.log(
+      `For (drizzle + postgresql) starter:
+> ${highlighter.create("npx servercn-cli init drizzle-pg-starter")}`
+    );
+    logger.break();
+    logger.info(`Visit ${SERVERCN_URL}/docs/installation for more information`);
+    logger.break();
+    process.exit(1);
+  }
+}
+
+// src/lib/config.ts
+import fs8 from "fs-extra";
+import path8 from "path";
+async function getServerCNConfig() {
+  const cwd = process.cwd();
+  const configPath = path8.resolve(cwd, SERVERCN_CONFIG_FILE);
+  if (!await fs8.pathExists(configPath)) {
+    logger.warn(
+      "\nServerCN is not initialized. Run `npx servercn-cli init` first.\n"
+    );
+    process.exit(1);
+  }
+  return fs8.readJSON(configPath);
+}
+function getDatabaseConfig(foundation) {
+  switch (foundation) {
+    case "mongoose-starter":
+      return {
+        engine: "mongodb",
+        adapter: "mongoose"
+      };
+    case "drizzle-mysql-starter":
+      return {
+        engine: "mysql",
+        adapter: "drizzle"
+      };
+    case "drizzle-pg-starter":
+      return {
+        engine: "postgresql",
+        adapter: "drizzle"
+      };
+    case "prisma-mongodb-starter":
+      return {
+        engine: "mongodb",
+        adapter: "prisma"
+      };
+    default:
+      return null;
+  }
+}
+
+// src/commands/add/add.handlers.ts
+import prompts from "prompts";
+async function resolveTemplateResolution({
+  registryItemName,
+  component,
+  config,
+  options
+}) {
+  const type = options.type || "component";
+  const framework = config.stack.framework;
+  const architecture = config.stack.architecture;
+  const runtime = config.stack.runtime;
+  const isBuilt = !options.local;
+  if (type === "tooling") {
+    const selectedPath = registryItemName;
+    return {
+      templatePath: `tooling/${selectedPath}/base`,
+      additionalRuntimeDeps: [],
+      additionalDevDeps: []
+    };
+  }
+  const templateConfig = component.runtimes?.[runtime]?.frameworks?.[framework];
+  if (!templateConfig) {
+    logger.break();
+    logger.error(
+      `Unsupported framework '${framework}' for ${type}: '${component.slug}'.`
+    );
+    logger.error(
+      `This ${type} does not provide templates for the selected framework.`
+    );
+    logger.break();
+    process.exit(1);
+  }
+  if (templateConfig.variants) {
+    return resolvePromptVariants({
+      component,
+      runtime,
+      architecture,
+      framework,
+      type,
+      isBuilt
+    });
+  }
+  let selectedSubPath;
+  switch (type) {
+    case "component":
+    case "foundation":
+      if (isBuilt) {
+        if (templateConfig.architectures?.[architecture]) {
+          selectedSubPath = architecture;
+        }
+      } else {
+        const haveTemplates = templateConfig.templates;
+        selectedSubPath = typeof templateConfig === "string" ? templateConfig : haveTemplates?.[architecture];
+      }
+      break;
+    case "schema":
+    case "blueprint":
+      selectedSubPath = resolveDatabaseTemplate({
+        templateConfig,
+        config,
+        architecture,
+        options,
+        registryItemName: type === "blueprint" ? component.slug : registryItemName
+      });
+      break;
+    default:
+      if (!isBuilt) {
+        const haveTemplates = templateConfig.templates;
+        selectedSubPath = typeof templateConfig === "string" ? templateConfig : haveTemplates && templateConfig.templates[architecture];
+      }
+      break;
+  }
+  if (!selectedSubPath) {
+    logger.break();
+    logger.error(
+      `Architecture '${architecture}' is not supported for '${type}:${component.slug}'.`
+    );
+    logger.break();
+    process.exit(1);
+  }
+  let runtimeDeps = [];
+  let devDeps = [];
+  if (type === "schema" || type === "blueprint") {
+    const db = config.database?.engine;
+    const orm = config.database?.adapter;
+    const deps = resolveDependencies({
+      component,
+      framework,
+      db,
+      orm,
+      runtime
+    });
+    runtimeDeps = deps.runtime || [];
+    devDeps = deps.dev || [];
+  }
+  return {
+    templatePath: `${runtime}/${framework}/${type}/${selectedSubPath}`,
+    additionalRuntimeDeps: runtimeDeps,
+    additionalDevDeps: devDeps
+  };
+}
+function resolveDatabaseTemplate({
+  templateConfig,
+  config,
+  architecture,
+  options,
+  registryItemName
+}) {
+  const formattedRegistryItemName = registryItemName.includes("/") ? registryItemName.split("/").pop() || "index" : options.type == "schema" ? "index" : registryItemName;
+  const dbType = config?.database?.engine;
+  const orm = config?.database?.adapter;
+  if (!dbType || !orm) {
+    logger.break();
+    logger.error(
+      "Database or ORM not configured.\nPlease add database:type or database:orm in `servercn.config.json` file"
+    );
+    logger.break();
+    process.exit(1);
+  }
+  const dbConfig = templateConfig?.databases[dbType];
+  const dbOrm = dbConfig?.orms[orm];
+  if (!dbConfig || !dbOrm) {
+    logger.break();
+    logger.error(
+      `Database stack '${dbType}:${orm}' is not supported by ${options.type}:'${formattedRegistryItemName}'.`
+    );
+    logger.break();
+    process.exit(1);
+  }
+  const archOptions = dbOrm?.templates;
+  if (options.type === "blueprint") {
+    const path15 = options?.local ? archOptions[architecture] : `${config.database?.engine}/${config.database?.adapter}/${config.stack.architecture}`;
+    return path15;
+  }
+  if (options.type == "schema") {
+    const path15 = options?.local ? archOptions[formattedRegistryItemName][architecture] : `${config.database?.engine}/${config.database?.adapter}/${formattedRegistryItemName}/${config.stack.architecture}`;
+    return path15;
+  }
+}
+async function resolvePromptVariants({
+  component,
+  runtime,
+  architecture,
+  framework,
+  type,
+  isBuilt
+}) {
+  const variantConfig = component.runtimes[runtime].frameworks[framework];
+  const choices = Object.entries(variantConfig?.variants || {}).map(
+    ([key, value]) => {
+      return {
+        title: value.label,
+        value: key
+      };
+    }
+  );
+  const { variant } = await prompts({
+    type: "select",
+    name: "variant",
+    message: variantConfig?.prompt || "Select",
+    choices
+  });
+  if (!variant) {
+    logger.break();
+    logger.warn("Operation cancelled.");
+    logger.break();
+    process.exit(0);
+  }
+  const selectedTemplate = isBuilt ? variantConfig?.variants?.[variant]?.architectures?.[architecture] ? architecture : "" : variantConfig?.variants?.[variant]?.templates[architecture] || "";
+  if (!selectedTemplate) {
+    logger.break();
+    logger.error(
+      `Architecture '${architecture}' is not supported for variant "${variant}".`
+    );
+    logger.break();
+    process.exit(1);
+  }
+  const subPath = isBuilt ? `${variant}/${selectedTemplate}` : selectedTemplate;
+  return {
+    templatePath: `${runtime}/${framework}/${type}/${subPath}`,
+    additionalRuntimeDeps: variantConfig?.variants?.[variant]?.dependencies?.runtime ?? [],
+    additionalDevDeps: variantConfig?.variants?.[variant]?.dependencies?.dev ?? [],
+    selectedProvider: variant
+  };
+}
+function resolveDependencies({
+  component,
+  framework,
+  db,
+  orm,
+  runtime
+}) {
+  const sets = component.runtimes[runtime].frameworks[framework].databases[db].orms[orm].dependencies;
+  return sets;
+}
+
+// src/commands/add/index.ts
+import { execa as execa2 } from "execa";
+
+// src/utils/update-env.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import path9 from "path";
+function updateEnvKeys({
+  envFile,
+  envKeys,
+  cwd = process.cwd(),
+  label
+}) {
+  if (envKeys.length < 1) return;
+  const envFilePath = path9.join(cwd, envFile);
+  const existing = normalizeEol(
+    existsSync(envFilePath) ? readFileSync(envFilePath, "utf8") : ""
+  );
+  const existingKeys = new Set(
+    existing.split(/\r?\n/).map(
+      (line) => line.replace(/^export\s+/, "").split("=")[0]?.trim()
+    ).filter((key) => key && !key.startsWith("#"))
+  );
+  const newEnvVars = envKeys.filter((key) => !existingKeys.has(key)).map((key) => `
+${key}='${key.split("_").join("_").toLowerCase()}'`);
+  logger.break();
+  if (!newEnvVars.length) {
+    logger.log(
+      `All env keys already exist in ${highlighter.info(envFile)} \u2014 nothing to add`
+    );
+    return;
+  }
+  const envSpinner = spinner(
+    `Adding ${newEnvVars.length} environment key(s) to ${highlighter.info(envFile)}`
+  );
+  envSpinner?.start();
+  const header = `# ${label} environment variables`;
+  const block = `${header}
+` + newEnvVars.join("\n") + "\n";
+  const content = normalizeEol(
+    existing.trim().length > 0 ? `${existing.trim()}
+
+${block}` : block
+  );
+  writeFileSync(envFilePath, content, "utf8");
+  envSpinner?.succeed(`Env keys added to ${highlighter.info(envFile)}`);
+}
+
+// src/utils/tooling.ts
+import prompts2 from "prompts";
+var TOOLING_MAP = {
+  prettier: ["prettier"],
+  eslint: [
+    "eslint",
+    "@typescript-eslint/parser",
+    "@typescript-eslint/eslint-plugin",
+    "eslint-plugin-prettier"
+  ],
+  typescript: ["typescript", "tsx", "tsc-alias", "@types/node"],
+  husky: ["husky"],
+  "lint-staged": ["lint-staged"],
+  commitlint: ["@commitlint/cli", "@commitlint/config-conventional"]
+};
+var TOOLING_CHOICES = [
+  { title: "Prettier", value: "prettier" },
+  { title: "ESLint", value: "eslint" },
+  { title: "TypeScript", value: "typescript" },
+  { title: "Husky", value: "husky" },
+  { title: "Lint Staged", value: "lint-staged" },
+  { title: "Commitlint", value: "commitlint" }
+];
+var RECOMMENDED_TOOLING = ["prettier", "eslint", "typescript"];
+async function getToolingChoices() {
+  const { enable } = await prompts2({
+    type: "toggle",
+    name: "enable",
+    message: "Would you like to set up development tooling?",
+    initial: true,
+    active: "yes",
+    inactive: "no"
+  });
+  if (!enable) return [];
+  const { mode } = await prompts2({
+    type: "select",
+    name: "mode",
+    message: "Choose tooling setup:",
+    choices: [
+      {
+        title: "Prettier + ESLint + TypeScript",
+        value: "recommended"
+      },
+      {
+        title: "All (Prettier + ESLint + TypeScript + Husky + Lint Staged + Commitlint)",
+        value: "all"
+      },
+      { title: "Custom", value: "custom" }
+    ]
+  });
+  if (mode === "recommended") {
+    return RECOMMENDED_TOOLING;
+  }
+  if (mode === "all") {
+    return Object.keys(TOOLING_MAP);
+  }
+  const { tooling } = await prompts2({
+    type: "multiselect",
+    name: "tooling",
+    message: "Select the tooling you want to use:",
+    choices: TOOLING_CHOICES,
+    hint: "- Space to select. Return to submit"
+  });
+  return tooling ?? [];
+}
+function getToolingDepsFromChoices(choices = []) {
+  const deps = /* @__PURE__ */ new Set();
+  choices.forEach((tool) => {
+    TOOLING_MAP[tool]?.forEach((dep) => deps.add(dep));
+  });
+  return Array.from(deps);
+}
+
+// src/commands/add/index.ts
+async function add(registryItemName, options = {}) {
+  await assertInitialized();
+  validateInput(registryItemName);
+  if (options.merge && options.force) {
+    logger.warn("--merge is ignored when --force is set.");
+  }
+  const effectiveMerge = Boolean(options.merge && !options.force);
+  const config = await getServerCNConfig();
+  validateStack(config);
+  let toolingDeps;
+  if (["blueprint"].includes(options?.type || "")) {
+    const toolingChoices = await getToolingChoices();
+    toolingDeps = getToolingDepsFromChoices(toolingChoices);
+  }
+  const type = options.type ?? "component";
+  const component = await getRegistry(registryItemName, type, options.local);
+  validateCompatibility(component, config);
+  const resolution = await resolveTemplateResolution({
+    component,
+    config,
+    options,
+    registryItemName
+  });
+  await scaffoldFiles({
+    registryItemName,
+    templatePath: resolution.templatePath,
+    options: { ...options, merge: effectiveMerge },
+    component,
+    selectedProvider: resolution.selectedProvider
+  });
+  ensureProjectFiles();
+  const { runtimeDeps, devDeps } = resolveDependencies2({
+    component,
+    config,
+    additionalRuntimeDeps: resolution.additionalRuntimeDeps,
+    additionalDevDeps: resolution.additionalDevDeps
+  });
+  if (runtimeDeps.length > 0 || devDeps.length > 0) {
+    await installDependencies({
+      runtime: runtimeDeps,
+      dev: [...toolingDeps || [], ...devDeps],
+      cwd: process.cwd(),
+      packageManager: config.project.packageManager
+    });
+  }
+  await runPostInstallHooks({
+    registryItemName,
+    type,
+    component,
+    framework: config.stack.framework,
+    runtime: config.stack.runtime,
+    selectedProvider: resolution.selectedProvider ?? "",
+    dbEngine: config.database?.engine,
+    dbAdapter: config.database?.adapter
+  });
+  logger.break();
+  logger.success(`${capitalize(type)}: ${component.slug} added successfully`);
+  logger.break();
+}
+function validateInput(name) {
+  if (!name) {
+    logger.error("Component name is required.");
+    process.exit(1);
+  }
+}
+function validateStack(config) {
+  if (!config.stack.runtime || !config.stack.framework) {
+    logger.error(
+      "Stack configuration is missing. Run `npx servercn-cli init` first."
+    );
+    process.exit(1);
+  }
+}
+function validateCompatibility(component, config) {
+  if ("runtimes" in component) {
+    const runtime = component.runtimes[config.stack.runtime];
+    if (!runtime) {
+      logger.error(
+        `Runtime ${config.stack.runtime} is not supported by ${component.slug}`
+      );
+      process.exit(1);
+    }
+    const framework = runtime.frameworks[config.stack.framework];
+    if (!framework) {
+      logger.break();
+      logger.error(
+        `Unsupported framework '${config.stack.framework}' for component '${component.slug}'.`
+      );
+      logger.error(
+        `This '${component.slug}' does not provide templates for the selected framework.`
+      );
+      logger.error(
+        `Please choose one of the supported frameworks and try again.`
+      );
+      logger.break();
+      process.exit(1);
+    }
+  }
+}
+async function scaffoldFiles({
+  registryItemName,
+  templatePath,
+  options,
+  component,
+  selectedProvider
+}) {
+  const IS_LOCAL = options.local ?? false;
+  const targetDir = paths.targets(".");
+  const spin = spinner("Scaffolding files...")?.start();
+  if (IS_LOCAL) {
+    const templateDir = path10.resolve(paths.templates(), templatePath);
+    if (!await fs9.pathExists(templateDir)) {
+      logger.error(
+        `
+Template not found: ${templateDir}
+Check your servercn configuration.
+`
+      );
+      process.exit(1);
+    }
+    logger.break();
+    await copyTemplate({
+      templateDir,
+      targetDir,
+      registryItemName,
+      conflict: options.force ? "overwrite" : "skip",
+      merge: options.merge
+    });
+  } else {
+    const ok = await cloneServercnRegistry({
+      component,
+      templatePath,
+      targetDir,
+      options,
+      selectedProvider
+    });
+    if (!ok) {
+      logger.error("\nSomething went wrong. Failed to scaffold template\n");
+      process.exit(1);
+    }
+  }
+  logger.break();
+  spin?.succeed("Scaffolding files successfully!");
+}
+function ensureProjectFiles() {
+  ensurePackageJson(process.cwd());
+  ensureTsConfig(process.cwd());
+}
+function resolveDependencies2({
+  component,
+  config,
+  additionalDevDeps,
+  additionalRuntimeDeps
+}) {
+  if (!("runtimes" in component)) {
+    return {
+      runtimeDeps: [
+        ...component.dependencies?.runtime ?? [],
+        ...additionalRuntimeDeps
+      ],
+      devDeps: [...component.dependencies?.dev ?? [], ...additionalDevDeps]
+    };
+  }
+  const framework = component.runtimes[config.stack.runtime].frameworks[config.stack.framework];
+  return {
+    runtimeDeps: [
+      ...framework && "dependencies" in framework ? framework.dependencies?.runtime ?? [] : [],
+      ...additionalRuntimeDeps
+    ],
+    devDeps: [
+      ...framework && "dependencies" in framework ? framework?.dependencies?.dev ?? [] : [],
+      ...additionalDevDeps
+    ]
+  };
+}
+async function runPostInstallHooks({
+  component,
+  registryItemName,
+  type,
+  runtime,
+  framework,
+  selectedProvider,
+  dbEngine,
+  dbAdapter
+}) {
+  if (type === "tooling" && registryItemName === "husky") {
+    try {
+      await execa2("npx", ["husky", "init"], { stdio: "inherit" });
+    } catch {
+      logger.warn(
+        "Could not initialize husky automatically. Please run 'npx husky init' manually."
+      );
+    }
+  } else {
+    let filterEnvs = [];
+    switch (type) {
+      case "component":
+        const registry = component?.runtimes[runtime]?.frameworks[framework];
+        if (registry?.prompt) {
+          filterEnvs = registry?.variants[selectedProvider]?.env?.filter(
+            (env) => env !== ""
+          );
+        } else {
+          filterEnvs = registry?.env?.filter((env) => env !== "");
+        }
+        break;
+      case "blueprint":
+        const registryBlueprint = component?.runtimes[runtime]?.frameworks[framework]?.databases[dbEngine].orms[dbAdapter]?.env ?? [];
+        filterEnvs = registryBlueprint?.filter((env) => env !== "");
+        break;
+      default:
+        break;
+    }
+    if (filterEnvs?.length > 0) {
+      updateEnvKeys({
+        envFile: ".env.example",
+        envKeys: filterEnvs,
+        label: registryItemName
+      });
+      updateEnvKeys({
+        envFile: ".env",
+        envKeys: filterEnvs,
+        label: registryItemName
+      });
+    }
+  }
+}
+
+// src/commands/init.ts
+import fs10 from "fs-extra";
+import path11 from "path";
+import prompts3 from "prompts";
+import { execa as execa3 } from "execa";
+
+// src/configs/ts.config.ts
+var tsConfig = {
+  compilerOptions: {
+    target: "ES2021",
+    module: "es2022",
+    moduleResolution: "bundler",
+    strict: true,
+    esModuleInterop: true,
+    skipLibCheck: true,
+    outDir: "dist",
+    rootDir: "src",
+    sourceMap: true,
+    alwaysStrict: true,
+    useUnknownInCatchVariables: true,
+    forceConsistentCasingInFileNames: true,
+    paths: {
+      "@/*": ["./src/*"],
+      "@/shared/*": ["../../shared/*"]
+    }
+  },
+  "tsc-alias": {
+    resolveFullPaths: true,
+    verbose: false
+  },
+  include: ["src/**/*"],
+  exclude: ["node_modules"]
+};
+
+// src/configs/commitlint.config.ts
+var commitlintConfig = {
+  extends: ["@commitlint/config-conventional"],
+  rules: {
+    "type-enum": [
+      2,
+      "always",
+      [
+        "feat",
+        "fix",
+        "docs",
+        "style",
+        "refactor",
+        "test",
+        "chore",
+        "ci",
+        "perf",
+        "build",
+        "release",
+        "workflow",
+        "security"
+      ]
+    ],
+    "subject-case": [2, "always", ["lower-case"]]
+  }
+};
+
+// src/configs/prettier.config.ts
+var prettierConfig = {
+  singleQuote: false,
+  semi: true,
+  tabWidth: 2,
+  trailingComma: "none",
+  bracketSameLine: false,
+  arrowParens: "avoid",
+  endOfLine: "lf"
+};
+var prettierIgnore = `# dependencies
+node_modules
+
+# build outputs
+dist
+build
+coverage
+
+# lock files
+package-lock.json
+pnpm-lock.yaml
+yarn.lock
+
+# environment
+.env
+
+# generated files
+*.min.js
+*.bundle.js
+
+# logs
+*.log
+
+# git
+.git
+.gitignore
+`;
+
+// src/configs/servercn.config.ts
+var servercnConfig = (config) => {
+  return {
+    $schema: `${SERVERCN_URL}/schema/servercn.config.json`,
+    version: LATEST_VERSION,
+    project: {
+      rootDir: config.project.rootDir,
+      type: config.project.type,
+      packageManager: config.project.packageManager
+    },
+    stack: config.stack,
+    database: config.database,
+    meta: {
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      createdBy: `servercn@${LATEST_VERSION}`
+    }
+  };
+};
+
+// src/configs/gitignore.config.ts
+var gitignore = `# dependencies
+node_modules
+.pnpm-store
+
+# build output
+dist
+build
+coverage
+
+# environment variables
+.env
+.env.local
+.env.*.local
+
+# logs
+logs
+*.log
+npm-debug.log*
+pnpm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# IDE
+.vscode
+.idea
+
+# temp
+tmp
+temp
+.cache
+
+# misc
+*.tsbuildinfo
+`;
+
+// src/configs/eslint.config.ts
+var eslintConfig = `
+import tseslint from "@typescript-eslint/eslint-plugin";
+import tsparser from "@typescript-eslint/parser";
+import prettierPlugin from "eslint-plugin-prettier";
+
+export default [
+  {
+    files: ["**/*.ts"],
+
+    languageOptions: {
+      parser: tsparser,
+      sourceType: "module"
+    },
+
+    plugins: {
+      "@typescript-eslint": tseslint,
+      prettier: prettierPlugin
+    },
+
+    rules: {
+      ...tseslint.configs.recommended.rules,
+      "@typescript-eslint/no-unused-vars": "off",
+      "@typescript-eslint/no-unused-expressions": "off",
+      "no-console": "warn",
+      semi: ["error", "always"],
+      quotes: ["error", "double"],
+      "prettier/prettier": "error"
+    }
+  },
+];
+`;
+
+// src/commands/init.ts
+async function init(foundation, options = {}) {
+  const cwd = process.cwd();
+  const configPath = path11.join(cwd, SERVERCN_CONFIG_FILE);
+  if (!foundation) {
+    const fd = await prompts3({
+      type: "select",
+      name: "foundation",
+      message: "Select a project foundation: ",
+      choices: [
+        {
+          title: "Express Starter",
+          description: "Minimal Express server setup",
+          value: "express-starter"
+        },
+        {
+          title: "Express + Mongoose",
+          description: "MongoDB with Mongoose ODM",
+          value: "mongoose-starter"
+        },
+        {
+          title: "Express + MongoDB (Prisma)",
+          description: "MongoDB database with Prisma ORM",
+          value: "prisma-mongodb-starter"
+        },
+        {
+          title: "Express + MySQL (Drizzle)",
+          description: "MySQL database with Drizzle ORM",
+          value: "drizzle-mysql-starter"
+        },
+        {
+          title: "Express + PostgreSQL (Drizzle)",
+          description: "PostgreSQL database with Drizzle ORM",
+          value: "drizzle-pg-starter"
+        },
+        {
+          title: "Existing Project",
+          description: `Generate ${SERVERCN_CONFIG_FILE} for an existing project`,
+          value: null
+        }
+      ]
+    });
+    foundation = fd.foundation;
+  }
+  if (await fs10.pathExists(configPath) && !foundation) {
+    logger.break();
+    logger.break();
+    logger.warn(`${APP_NAME} is already initialized in this project.`);
+    logger.info(
+      "You can now add components: npx servercn-cli add <component-name>"
+    );
+    logger.break();
+    process.exit(1);
+  }
+  if (foundation) {
+    try {
+      logger.break();
+      const response2 = await prompts3([
+        {
+          type: "text",
+          name: "root",
+          message: "Project root directory",
+          initial: ".",
+          format: (val) => val.trim() || "."
+        },
+        {
+          type: "select",
+          name: "architecture",
+          message: "Select architecture",
+          choices: [
+            { title: "MVC (controllers, services, models)", value: "mvc" },
+            { title: "Feature (modules, shared)", value: "feature" },
+            { title: "Modular Architecture (NestJS)", value: "modular" }
+          ]
+        },
+        {
+          type: "select",
+          name: "packageManager",
+          message: "Select package manager",
+          choices: [
+            { title: "npm", value: "npm" },
+            { title: "pnpm", value: "pnpm" },
+            { title: "yarn", value: "yarn" },
+            { title: "bun", value: "bun" }
+          ],
+          initial: Math.max(
+            0,
+            ["npm", "pnpm", "yarn", "bun"].indexOf(detectPackageManager())
+          )
+        },
+        {
+          type: "confirm",
+          name: "initGit",
+          message: "Initialize git repository?",
+          initial: false
+        }
+      ]);
+      logger.break();
+      const toolingChoices = await getToolingChoices();
+      const devDeps = getToolingDepsFromChoices(toolingChoices);
+      const rootPath2 = path11.resolve(cwd, response2.root);
+      if (response2.root !== "." && fs10.pathExistsSync(rootPath2)) {
+        logger.break();
+        logger.error(`Cannot create '${response2.root}' \u2014 file already exists!`);
+        logger.break();
+        process.exit(1);
+      }
+      await fs10.ensureDir(rootPath2);
+      if (!fs10.pathExistsSync(rootPath2)) {
+        logger.error(`Failed to create project directory: ${rootPath2}`);
+        process.exit(1);
+      }
+      if (response2.initGit) {
+        try {
+          await execa3("git", ["init"], { cwd: rootPath2 });
+          logger.info("Initialized git repository.");
+        } catch {
+          logger.warn("Failed to initialize git repository. is git installed?");
+        }
+      }
+      try {
+        const component = await getRegistry(
+          foundation,
+          "foundation",
+          options.local
+        );
+        const baseConfig = component.runtimes["node"].frameworks[getFramework(options.fw ?? "express")];
+        if (options.local) {
+          const targetDir = paths.targets(response2.root ?? ".");
+          const localTemplatePath = `node/${getFramework(options.fw ?? "express")}/foundation/${baseConfig?.templates[response2.architecture]}` || "";
+          const templateDir = path11.resolve(
+            paths.templates(),
+            localTemplatePath
+          );
+          if (!await fs10.pathExists(templateDir)) {
+            logger.error(
+              `
+Template not found: ${templateDir}
+Check your servercn configuration.
+`
+            );
+            process.exit(1);
+          }
+          logger.break();
+          await copyTemplate({
+            templateDir,
+            targetDir,
+            registryItemName: foundation,
+            conflict: options.force ? "overwrite" : "skip"
+          });
+        } else {
+          const templatePath = `node/${getFramework(options.fw ?? "express")}/${response2.architecture}`;
+          if (!templatePath) {
+            logger.error(
+              `Template not found for ${foundation?.toLowerCase()} (${response2.architecture})`
+            );
+            fs10.removeSync(rootPath2);
+            return;
+          }
+          const ok = await cloneServercnRegistry({
+            templatePath,
+            targetDir: response2.root,
+            component,
+            options
+          });
+          if (!ok) {
+            logger.error(`Failed to initialize foundation:${foundation}.
+`);
+            fs10.removeSync(rootPath2);
+            return;
+          }
+        }
+        await fs10.writeJson(
+          path11.join(rootPath2, SERVERCN_CONFIG_FILE),
+          servercnConfig({
+            project: {
+              rootDir: response2.root,
+              type: "backend",
+              packageManager: response2.packageManager
+            },
+            stack: {
+              runtime: "node",
+              language: "typescript",
+              framework: getFramework(options.fw ?? "express"),
+              architecture: response2.architecture
+            },
+            database: getDatabaseConfig(foundation)
+          }),
+          {
+            spaces: 2
+          }
+        );
+        await fs10.writeJson(path11.join(rootPath2, ".prettierrc"), prettierConfig, {
+          spaces: 2
+        });
+        await fs10.writeFile(
+          path11.join(rootPath2, ".prettierignore"),
+          prettierIgnore
+        );
+        await fs10.writeFile(path11.join(rootPath2, ".gitignore"), gitignore);
+        await fs10.writeJson(path11.join(rootPath2, "tsconfig.json"), tsConfig, {
+          spaces: 2
+        });
+        await fs10.writeFile(
+          path11.join(rootPath2, "commitlint.config.ts"),
+          `export default ${JSON.stringify(commitlintConfig, null, 2)}`
+        );
+        await fs10.writeFile(
+          path11.join(rootPath2, "eslint.config.mjs"),
+          eslintConfig
+        );
+        const filterEnvs = baseConfig?.env?.filter((env) => env !== "") || [];
+        if (filterEnvs?.length > 0) {
+          updateEnvKeys({
+            envFile: ".env.example",
+            envKeys: filterEnvs,
+            label: foundation,
+            cwd: rootPath2
+          });
+          updateEnvKeys({
+            envFile: ".env",
+            envKeys: filterEnvs,
+            label: foundation,
+            cwd: rootPath2
+          });
+        }
+        await installDependencies({
+          runtime: baseConfig?.dependencies?.runtime || [],
+          dev: [...devDeps, baseConfig?.dependencies?.dev || []].flat(),
+          cwd: rootPath2,
+          packageManager: response2.packageManager
+        });
+        logger.break();
+        logger.success(
+          `${APP_NAME} initialized with 'foundation:${foundation}'.`
+        );
+        logger.break();
+        logger.info("Configure environment variables in .env file.");
+        logger.break();
+        logger.log("Run the following commands:");
+        if (response2.root === ".") {
+          logger.muted(`1. ${response2.packageManager || "npm"} run dev
+`);
+        } else {
+          logger.muted(`1. cd ${response2.root}`);
+          logger.muted(`2. ${response2.packageManager || "npm"} run dev
+`);
+        }
+        process.exit(1);
+      } catch (e) {
+        fs10.removeSync(rootPath2);
+        logger.error(`Failed to initialize foundation: ${e}`);
+        process.exit(1);
+      }
+    } catch {
+      logger.error(`
+Failed to initialize foundation
+`);
+      process.exit(1);
+    }
+  }
+  logger.break();
+  const response = await prompts3([
+    {
+      type: "text",
+      name: "root",
+      message: "Project root directory",
+      initial: ".",
+      format: (val) => val.trim() || "."
+    },
+    {
+      type: "select",
+      name: "language",
+      message: "Programming language",
+      choices: [
+        {
+          title: "Typescript (recommended)",
+          value: "typescript"
+        }
+      ]
+    },
+    {
+      type: "select",
+      name: "framework",
+      message: "Backend framework",
+      choices: [
+        {
+          title: "Express.js",
+          value: "express"
+        },
+        {
+          title: "NestJS",
+          value: "nestjs"
+        }
+      ],
+      initial: 0
+    },
+    {
+      type: "select",
+      name: "architecture",
+      message: "Select architecture",
+      choices: [
+        { title: "MVC (controllers, services, models)", value: "mvc" },
+        { title: "Feature-based (modules, shared)", value: "feature" },
+        { title: "Modular Architecture (NestJS)", value: "modular" }
+      ]
+    },
+    {
+      type: "select",
+      name: "databaseType",
+      message: "Select database",
+      choices: [
+        {
+          title: "Mongodb",
+          value: "mongodb"
+        },
+        {
+          title: "PostgreSQL",
+          value: "postgresql"
+        },
+        {
+          title: "MySQL",
+          value: "mysql"
+        }
+      ]
+    },
+    {
+      type: (prev) => prev === "mongodb" ? "select" : null,
+      name: "orm",
+      message: "Mongodb library",
+      choices: [
+        { title: "Mongoose", value: "mongoose" },
+        { title: "Prisma", value: "prisma" }
+      ]
+    },
+    {
+      type: (_prev, values) => ["postgresql", "mysql"].includes(values.databaseType) ? "select" : null,
+      name: "orm",
+      message: "Orm / query builder",
+      choices: [
+        { title: "Drizzle", value: "drizzle" },
+        { title: "Prisma", value: "prisma" }
+      ]
+    },
+    {
+      type: "select",
+      name: "packageManager",
+      message: "Select package manager",
+      choices: [
+        { title: "npm", value: "npm" },
+        { title: "pnpm", value: "pnpm" },
+        { title: "yarn", value: "yarn" },
+        { title: "bun", value: "bun" }
+      ],
+      initial: Math.max(
+        0,
+        ["npm", "pnpm", "yarn", "bun"].indexOf(detectPackageManager())
+      )
+    }
+  ]);
+  if (!response.architecture || !response.databaseType || !response.framework || !response.language || !response.orm || !response.root || !response.packageManager) {
+    logger.break();
+    logger.warn("Initialization cancelled.");
+    logger.break();
+    return;
+  }
+  const rootPath = path11.resolve(cwd, response.root);
+  if (response.root !== "." && fs10.pathExistsSync(rootPath)) {
+    logger.break();
+    logger.error(`Cannot create '${response.root}' \u2014 file already exists!`);
+    logger.break();
+    process.exit(1);
+  }
+  await fs10.ensureDir(rootPath);
+  await fs10.writeJson(
+    path11.join(rootPath, SERVERCN_CONFIG_FILE),
+    servercnConfig({
+      project: {
+        rootDir: response.root,
+        type: "backend",
+        packageManager: response.packageManager
+      },
+      stack: {
+        runtime: "node",
+        language: response.language,
+        framework: response.framework,
+        architecture: response.architecture
+      },
+      database: {
+        engine: response.databaseType,
+        adapter: response.orm
+      }
+    }),
+    {
+      spaces: 2
+    }
+  );
+  logger.success(`
+${APP_NAME} initialized successfully.`);
+  logger.break();
+  logger.log("You may now add components by running:");
+  if (response.root === ".") {
+    logger.muted("1. npx servercn-cli add <component>");
+  } else {
+    logger.muted(`1. cd ${response.root}`);
+    logger.muted("2. npx servercn-cli add <component>");
+  }
+  logger.muted(
+    "ex: npx servercn-cli add jwt-utils error-handler http-status-codes"
+  );
+  logger.break();
+}
+function getFramework(fw) {
+  switch (fw) {
+    case "express":
+    case "expressjs":
+      return "express";
+    case "nestjs":
+    case "nest":
+      return "nestjs";
+    default:
+      return "express";
+  }
+}
+
+// src/commands/list/index.ts
+function registryListCommands(program2) {
+  const list = program2.command("list").alias("ls").description("List available ServerCN resources").option("--json", "Output resources as JSON").option("--all", "Display all available registries").option("--local", "Display only local registries").enablePositionalOptions().action((options) => {
+    listOverview(options);
+  });
+  function resolveOptions(cmd) {
+    return cmd.parent?.opts();
+  }
+  list.command("component").alias("cp").description("List available components").action((_, cmd) => {
+    listComponents(resolveOptions(cmd));
+  });
+  list.command("foundation").alias("fd").description("List available foundations").action((_, cmd) => {
+    listFoundations(resolveOptions(cmd));
+  });
+  list.command("tooling").alias("tl").description("List available tooling").action((_, cmd) => {
+    listTooling(resolveOptions(cmd));
+  });
+  list.command("schema").alias("sc").description("List available schemas").action((_, cmd) => {
+    listSchemas(resolveOptions(cmd));
+  });
+  list.command("blueprint").alias("bp").description("List available blueprints").action((_, cmd) => {
+    listBlueprints(resolveOptions(cmd));
+  });
+}
+
+// src/commands/_build/index.ts
+import path13 from "path";
+import fs12 from "fs-extra";
+import { glob as glob2 } from "glob";
+
+// src/commands/_build/build.handlers.ts
+import path12 from "path";
+import fs11 from "fs-extra";
+import { glob } from "glob";
+async function processRegistryItem(item, type) {
+  switch (type) {
+    case "component":
+      return await buildComponent(item);
+    case "blueprint":
+      return await buildBlueprint(item);
+    case "foundation":
+      return await buildFoundation(item);
+    case "schema":
+      return await buildSchema(item);
+    case "tooling":
+      return await buildTooling(item);
+    default:
+      throw new Error(`Unsupported registry type: ${type}`);
+  }
+}
+async function buildComponent(component) {
+  const built = { ...component, runtimes: {} };
+  delete built["$schema"];
+  for (const [runtimeKey, runtime] of Object.entries(component.runtimes)) {
+    const rt = runtime;
+    built.runtimes[runtimeKey] = { frameworks: {} };
+    for (const [frameworkKey, framework] of Object.entries(rt.frameworks)) {
+      const fw = framework;
+      if ("variants" in fw && fw.variants) {
+        const builtVariants = {};
+        for (const [variantKey, variant] of Object.entries(fw.variants)) {
+          const v = variant;
+          builtVariants[variantKey] = {
+            ...v,
+            architectures: await processArchitectureSet(
+              v.templates,
+              path12.join(runtimeKey, frameworkKey, "component")
+            )
+          };
+          delete builtVariants[variantKey].templates;
+        }
+        built.runtimes[runtimeKey].frameworks[frameworkKey] = {
+          prompt: fw.prompt,
+          variants: builtVariants
+        };
+      } else if ("templates" in fw && fw.templates) {
+        built.runtimes[runtimeKey].frameworks[frameworkKey] = {
+          ...fw,
+          architectures: await processArchitectureSet(
+            fw.templates,
+            path12.join(runtimeKey, frameworkKey, "component")
+          )
+        };
+        delete built.runtimes[runtimeKey].frameworks[frameworkKey].templates;
+      }
+    }
+  }
+  return built;
+}
+async function buildFoundation(foundation) {
+  const built = { ...foundation, runtimes: {} };
+  delete built["$schema"];
+  for (const [runtimeKey, runtime] of Object.entries(foundation.runtimes)) {
+    built.runtimes[runtimeKey] = { frameworks: {} };
+    for (const [frameworkKey, framework] of Object.entries(
+      runtime.frameworks
+    )) {
+      if (framework) {
+        built.runtimes[runtimeKey].frameworks[frameworkKey] = {
+          ...framework,
+          architectures: await processArchitectureSet(
+            framework?.templates,
+            path12.join(runtimeKey, frameworkKey, "foundation")
+          )
+        };
+        delete built.runtimes[runtimeKey].frameworks[frameworkKey].templates;
+      }
+    }
+  }
+  return built;
+}
+async function buildBlueprint(blueprint) {
+  const built = { ...blueprint, runtimes: {} };
+  delete built["$schema"];
+  for (const [runtimeKey, runtime] of Object.entries(blueprint.runtimes)) {
+    built.runtimes[runtimeKey] = { frameworks: {} };
+    for (const [frameworkKey, framework] of Object.entries(
+      runtime.frameworks
+    )) {
+      const builtDatabases = {};
+      for (const [dbKey, db] of Object.entries(framework.databases)) {
+        const builtOrms = {};
+        for (const [ormKey, orm] of Object.entries(db.orms)) {
+          builtOrms[ormKey] = {
+            ...orm,
+            architectures: await processArchitectureSet(
+              orm.templates,
+              path12.join(runtimeKey, frameworkKey, "blueprint")
+            )
+          };
+          delete builtOrms[ormKey].templates;
+        }
+        builtDatabases[dbKey] = { orms: builtOrms };
+      }
+      built.runtimes[runtimeKey].frameworks[frameworkKey] = {
+        databases: builtDatabases
+      };
+    }
+  }
+  return built;
+}
+async function buildSchema(schema) {
+  const built = { ...schema, runtimes: {} };
+  delete built["$schema"];
+  for (const [runtimeKey, runtime] of Object.entries(schema.runtimes)) {
+    built.runtimes[runtimeKey] = { frameworks: {} };
+    for (const [frameworkKey, framework] of Object.entries(
+      runtime.frameworks
+    )) {
+      const builtDatabases = {};
+      for (const [dbKey, db] of Object.entries(framework.databases)) {
+        const builtOrms = {};
+        for (const [ormKey, orm] of Object.entries(db.orms)) {
+          const builtMultiTemplates = {};
+          for (const [tmplKey, archSet] of Object.entries(orm.templates)) {
+            builtMultiTemplates[tmplKey] = {
+              architectures: await processArchitectureSet(
+                archSet,
+                path12.join(runtimeKey, frameworkKey, "schema")
+              )
+            };
+          }
+          builtOrms[ormKey] = {
+            ...orm,
+            templates: builtMultiTemplates
+          };
+        }
+        builtDatabases[dbKey] = { orms: builtOrms };
+      }
+      built.runtimes[runtimeKey].frameworks[frameworkKey] = {
+        databases: builtDatabases
+      };
+    }
+  }
+  return built;
+}
+async function buildTooling(tooling) {
+  const built = { ...tooling };
+  delete built["$schema"];
+  const builtTemplates = {};
+  for (const [tmplKey, tmplPath] of Object.entries(tooling.templates)) {
+    const absolutePath = path12.join(paths.templateBase, "tooling", tmplPath);
+    builtTemplates[tmplKey] = {
+      files: await extractFiles(absolutePath, "tooling")
+    };
+  }
+  built.templates = builtTemplates;
+  return built;
+}
+async function processArchitectureSet(archSet, baseRelPath) {
+  const architectures = {};
+  for (const [archKey, relTemplatePath] of Object.entries(archSet)) {
+    if (!relTemplatePath) continue;
+    const absoluteTemplatePath = path12.join(
+      paths.templateBase,
+      baseRelPath,
+      relTemplatePath
+    );
+    architectures[archKey] = {
+      files: await extractFiles(absoluteTemplatePath, "file")
+    };
+  }
+  return architectures;
+}
+async function extractFiles(templateDir, type) {
+  if (!await fs11.pathExists(templateDir)) {
+    const msg = `Template directory not found: ${templateDir}`;
+    logger.error(msg);
+    throw new Error(msg);
+  }
+  const pattern = "**/*";
+  const filePaths = await glob(pattern, {
+    cwd: templateDir,
+    nodir: true,
+    dot: true
+  });
+  const files = [];
+  for (const relativePath of filePaths) {
+    const absolutePath = path12.join(templateDir, relativePath);
+    const content = normalizeEol(await fs11.readFile(absolutePath, "utf8"));
+    files.push({
+      type,
+      path: normalizePath(relativePath),
+      content
+    });
+  }
+  return files;
+}
+function normalizePath(p) {
+  return p.split(path12.sep).join("/");
+}
+
+// src/commands/_build/index.ts
+async function build(options) {
+  const buildSpin = spinner("Building ServerCN registry...").start();
+  const index = {
+    name: options.name ?? APP_NAME.toLowerCase(),
+    homepage: options.url ?? SERVERCN_URL,
+    items: []
+  };
+  let totalItems = 0;
+  let builtItems = 0;
+  let updatedItems = 0;
+  let skippedItems = 0;
+  for (const type of RegistryTypeList) {
+    const sourceDir = path13.join(paths.registryBase, type);
+    const targetDir = path13.join(paths.outputBase, type);
+    if (!await fs12.pathExists(sourceDir)) {
+      continue;
+    }
+    await fs12.ensureDir(targetDir);
+    const files = await glob2("*.json", { cwd: sourceDir });
+    for (const file of files) {
+      totalItems++;
+      const sourcePath = path13.join(sourceDir, file);
+      const item = await fs12.readJson(sourcePath);
+      const outputPath = path13.join(targetDir, `${item.slug}.json`);
+      const buildStatus = await getBuildStatus(
+        sourcePath,
+        outputPath,
+        item,
+        type
+      );
+      if (buildStatus === "skip") {
+        skippedItems++;
+        if (type === "tooling" || !item.runtimes?.["node"]?.frameworks) {
+          index.items.push({
+            type,
+            slug: item.slug
+          });
+        } else {
+          index.items.push({
+            type,
+            slug: item.slug,
+            frameworks: Object.keys(
+              item.runtimes["node"].frameworks
+            )
+          });
+        }
+        continue;
+      }
+      buildSpin.text = `${buildStatus === "rebuild" ? "Building" : "Updating"} ${type}: ${item.slug}`;
+      try {
+        const builtItem = await processRegistryItem(item, type);
+        await fs12.writeJson(outputPath, builtItem, { spaces: 2 });
+        if (type === "tooling" || !builtItem.runtimes?.["node"]?.frameworks) {
+          index.items.push({
+            type,
+            slug: item.slug
+          });
+        } else {
+          index.items.push({
+            type,
+            slug: item.slug,
+            frameworks: Object.keys(
+              builtItem.runtimes["node"].frameworks
+            )
+          });
+        }
+        if (buildStatus === "rebuild") {
+          builtItems++;
+        } else {
+          updatedItems++;
+        }
+      } catch (error) {
+        console.error(error);
+        buildSpin.fail(`Failed to build ${item.slug}`);
+        logger.error(error);
+        buildSpin.start("Resuming build...");
+      }
+    }
+  }
+  await fs12.writeJson(path13.join(paths.outputBase, "index.json"), index, {
+    spaces: 2
+  });
+  buildSpin.succeed(
+    `${highlighter.success("Registry build completed")}
+Total: ${totalItems}, Built: ${builtItems}, Updated: ${updatedItems}, Skipped: ${skippedItems}`
+  );
+}
+async function getBuildStatus(sourcePath, outputPath, item, type) {
+  if (!await fs12.pathExists(outputPath)) return "rebuild";
+  const sourceStat = await fs12.stat(sourcePath);
+  const targetStat = await fs12.stat(outputPath);
+  const templatePaths = getTemplatePathsForItem(item, type);
+  for (const tp of templatePaths) {
+    const absoluteTp = path13.join(paths.templateBase, tp);
+    if (!await fs12.pathExists(absoluteTp)) continue;
+    const tpStat = await fs12.stat(absoluteTp);
+    if (tpStat.isDirectory()) {
+      const files = await glob2("**/*", {
+        cwd: absoluteTp,
+        nodir: true,
+        absolute: true
+      });
+      for (const f of files) {
+        const fStat = await fs12.stat(f);
+        if (fStat.mtime > targetStat.mtime) return "rebuild";
+      }
+    } else {
+      if (tpStat.mtime > targetStat.mtime) return "rebuild";
+    }
+  }
+  if (sourceStat.mtime > targetStat.mtime) return "update";
+  return "skip";
+}
+function getTemplatePathsForItem(item, type) {
+  const templatePaths = [];
+  const itemAny = item;
+  if (type === "tooling") {
+    if (itemAny.templates) {
+      for (const tPath of Object.values(itemAny.templates)) {
+        templatePaths.push(path13.join("tooling", tPath));
+      }
+    }
+    return templatePaths;
+  }
+  if (!itemAny.runtimes) return templatePaths;
+  for (const [runtimeKey, runtime] of Object.entries(itemAny.runtimes)) {
+    for (const [frameworkKey, framework] of Object.entries(
+      runtime.frameworks
+    )) {
+      const baseRelPath = path13.join(runtimeKey, frameworkKey, type);
+      if (framework.variants) {
+        for (const variant of Object.values(framework.variants)) {
+          if (variant.templates) {
+            for (const tPath of Object.values(variant.templates)) {
+              templatePaths.push(path13.join(baseRelPath, tPath));
+            }
+          }
+        }
+      } else if (framework.templates) {
+        for (const tPath of Object.values(framework.templates)) {
+          if (typeof tPath === "string") {
+            templatePaths.push(path13.join(baseRelPath, tPath));
+          } else if (typeof tPath === "object" && tPath !== null) {
+            for (const archSet of Object.values(tPath)) {
+              if (typeof archSet === "string") {
+                templatePaths.push(path13.join(baseRelPath, archSet));
+              } else if (typeof archSet === "object" && archSet !== null) {
+                for (const p of Object.values(archSet)) {
+                  templatePaths.push(path13.join(baseRelPath, p));
+                }
+              }
+            }
+          }
+        }
+      } else if (framework.databases) {
+        for (const db of Object.values(framework.databases)) {
+          for (const orm of Object.values(db.orms)) {
+            if (orm.templates) {
+              for (const val of Object.values(orm.templates)) {
+                if (typeof val === "string") {
+                  templatePaths.push(path13.join(baseRelPath, val));
+                } else if (typeof val === "object" && val !== null) {
+                  for (const p of Object.values(val)) {
+                    templatePaths.push(path13.join(baseRelPath, p));
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return templatePaths;
+}
+
+// src/commands/doctor.ts
+import fs13 from "fs-extra";
+import path14 from "path";
+var README_UPGRADE_ANCHOR = "https://github.com/AkkalDhami/servercn/blob/main/packages/cli/README.md#existing-projects-upgrades--template-drift";
+function printStaticGuide() {
+  logger.section("Post-init projects & upstream changes");
+  logger.log(
+    "Your scaffold is a snapshot from when you ran `init`. The CLI and registry evolve separately."
+  );
+  logger.break();
+  logger.log("Typical situations:");
+  logger.log(
+    "  \u2022 CLI-only bump (bugfixes): usually no repo changes unless you hit a specific fix."
+  );
+  logger.log(
+    "  \u2022 Registry/template updates (new markers, `--merge`, paths): read release notes; then copy markers from docs, use `add --merge`, or `--force` / new project."
+  );
+  logger.log(
+    "  \u2022 Foundation changes: no automatic sync \u2014 diff manually or start a fresh project."
+  );
+  logger.break();
+  logger.info(`Full matrix: ${README_UPGRADE_ANCHOR}`);
+  logger.info(`Installation / upgrades: ${SERVERCN_URL}/docs/installation`);
+  logger.break();
+}
+async function checkMergeMarkers(config, projectRoot) {
+  const arch = config.stack?.architecture ?? "mvc";
+  const appPath = path14.join(projectRoot, "src", "app.ts");
+  const appSlugs = arch === "feature" ? ["rate-limiter", "security-header"] : ["rate-limiter", "security-header", "async-handler"];
+  if (await fs13.pathExists(appPath)) {
+    const text = await fs13.readFile(appPath, "utf8");
+    for (const slug of appSlugs) {
+      const line = markerBeginLine(slug);
+      if (!text.includes(line)) {
+        logger.warn(
+          `Missing ${line} in src/app.ts \u2014 add it (see README) before using add ${slug} --merge.`
+        );
+      }
+    }
+  } else {
+    logger.muted("No src/app.ts found; skipping app marker checks.");
+  }
+  if (arch === "feature") {
+    const routesPath = path14.join(projectRoot, "src", "routes", "index.ts");
+    if (await fs13.pathExists(routesPath)) {
+      const text = await fs13.readFile(routesPath, "utf8");
+      const line = markerBeginLine("async-handler");
+      if (!text.includes(line)) {
+        logger.warn(
+          `Missing ${line} in src/routes/index.ts \u2014 required for async-handler --merge (feature architecture).`
+        );
+      }
+    }
+  }
+}
+async function doctor() {
+  printStaticGuide();
+  const configPath = path14.resolve(process.cwd(), SERVERCN_CONFIG_FILE);
+  if (!await fs13.pathExists(configPath)) {
+    logger.muted("No servercn.config.json in this directory \u2014 marker checks skipped.");
+    logger.break();
+    return;
+  }
+  const config = await fs13.readJSON(configPath);
+  const rootDir = config.project?.rootDir ?? ".";
+  const projectRoot = path14.resolve(process.cwd(), rootDir);
+  logger.section("Merge marker sanity (optional)");
+  await checkMergeMarkers(config, projectRoot);
+  logger.break();
+}
+
+// src/cli.ts
+var program = new Command();
+process.on("SIGINT", () => process.exit(0));
+process.on("SIGTERM", () => process.exit(0));
+async function main() {
+  program.name("servercn-cli").description("Scaffold and manage backend components for Node.js projects").version(LATEST_VERSION, "-v, --version", "output the current version");
+  program.command("init [foundation]").description("Initialize ServerCN in the current project").option("-f, --force", "Overwrite existing files if they exist").option("--fw <framework>", "Framework type: express or nestjs", "express").option(
+    "--local",
+    "Add registry items from local environment(development runtime)"
+  ).action(init);
+  registryListCommands(program);
+  program.command("doctor").description(
+    "Print upgrade guidance and optional merge-marker checks for this project"
+  ).action(doctor);
+  program.command("build").description("Build the project").option("--name <name>", "App name, website name").option("--url <url>", "App URL, website URL").action(async (options) => await build(options));
+  program.command("add <components...>").description("Add one or more backend components to your project").option("--arch <arch>", "Project architecture: mvc or feature", "mvc").option("-f, --force", "Force overwrite existing files").option(
+    "--merge",
+    "Merge merge-only fragments (// @servercn:begin/end <slug>) into existing files"
+  ).option(
+    "--local",
+    "Add registry items from local environment(development runtime)"
+  ).action(
+    async (components, options) => {
+      let type = "component";
+      let items = components;
+      if (["schema", "sc"].includes(components[0])) {
+        type = "schema";
+        items = components.slice(1).map((item) => {
+          return item;
+        });
+      } else if (["blueprint", "bp"].includes(components[0])) {
+        type = "blueprint";
+        items = components.slice(1);
+      } else if (["tooling", "tl"].includes(components[0])) {
+        type = "tooling";
+        items = components.slice(1);
+      }
+      for (const item of items) {
+        await add(item, {
+          arch: options.arch,
+          type,
+          force: options.force,
+          merge: options.merge,
+          local: options.local
+        });
+      }
+    }
+  );
+  program.parse(process.argv);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map