create-bht-component-registry 0.0.0-stage → 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Behive Tech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,118 @@
-# Temporary Holding Version
+# create-bht-component-registry
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Scaffold a [bht-component-registry](https://github.com/behivetech/bht-component-registry) — a
+component registry that stays in git: docs generated from source, live examples,
+versions via Changesets, a static site you can deploy anywhere — and keep it current with `update`.
+
+Hosted & expanded version, guides and consulting: https://platform.behivetech.com
+
+## Create a registry
+
+```bash
+npx create-bht-component-registry my-registry
+# or
+npm create bht-component-registry my-registry
+```
+
+You are asked for your npm scope (the `acme` in `@acme/*`), the registry you publish to and the
+starter categories; pass them as flags to skip the questions. The command downloads the template
+release matching its own version, renames the shipped `example` scope to yours, writes
+`registry.config.json`, runs `pnpm install` and a first `pnpm build`, and prints what to do next.
+
+The example packages are unpublishable in the template (`"private": true`, so the template repo's
+own release workflow can never publish `@example/*`); yours are publishable — the rename sets
+`"private": false` in every `registry/<scope>/<category>/<name>/package.json`.
+
+```bash
+npx create-bht-component-registry my-registry --scope acme --yes
+```
+
+| Flag | Default | What it does |
+| --- | --- | --- |
+| `--scope <name>` | prompted | Your npm scope without the `@`. Required. Lowercase letters, digits and hyphens, 1–40 chars, not a reserved word. Create the matching org on npmjs before your first `pnpm release`. |
+| `--registry <url>` | `https://registry.npmjs.org` | Where `pnpm release` publishes. GitHub Packages is `https://npm.pkg.github.com`. |
+| `--categories <a,b,c>` | `atoms,molecules,organisms,templates,forms` | Starter folders under `registry/<scope>/`. Empty ones get a `.gitkeep`. |
+| `--template-version <x.y.z>` | this CLI's version | Which template release to download. |
+| `--no-install` | off | Skip `pnpm install` and `pnpm build`. |
+| `-y`, `--yes` | off | Accept defaults instead of prompting (`--scope` is still required). |
+| `--from <path>` | — | Dev mode, see below. |
+
+The target directory must not exist or must be empty. If `pnpm install` or `pnpm build` fails, the
+command prints which step failed and exits 1, leaving the directory in place for you to fix.
+
+Some paths exist only in the template repo and are never materialised in yours: this CLI's own
+source (`packages/create-bht-component-registry/**`) and the template repo's contributor files
+(`.github/ISSUE_TEMPLATE/**`, `.github/PULL_REQUEST_TEMPLATE.md`). They are listed under
+`templateOnly` in the template's `template.manifest.json`.
+
+## Update a registry
+
+Run inside a registry you created earlier:
+
+```bash
+npx create-bht-component-registry update
+npx create-bht-component-registry update --dry-run
+```
+
+`update` needs a clean git tree, because it replaces whole files and `git diff` is how you review
+the result. It reads `templateVersion` from `registry.config.json`, fetches the newer template,
+and replaces only **template-owned** paths — the ones listed in the target release's
+`template.manifest.json` (the docs app, `packages/**`, the generator, workflows, root config,
+`docs/**`, …). It never touches:
+
+- `registry/**` — your components
+- `registry.config.json` — your settings (only `templateVersion` is bumped)
+- `.changeset/*.md` — your pending changesets
+- `README.md` below the line `<!-- your notes below this line are kept by update -->`; the part
+  above it is refreshed from the template. A README without that line is left untouched.
+
+`templateOnly` paths (see above) are never copied, and any left in your repo by an older template
+that still shipped them are removed and reported under "Removed". The check order is
+`templateOnly`, then `never`, then `owned`.
+
+Files that mention the template's `example` scope (the e2e spec, the docs app's dependency list)
+get your scope re-applied after the copy, so the rename from `create` survives. Finally it prints
+the added, replaced and removed files and tells you to review with `git diff` and run
+`pnpm install && pnpm verify`.
+
+| Flag | Default | What it does |
+| --- | --- | --- |
+| `--to <x.y.z>` | this CLI's version | Template version to update to. Nothing happens if you are already at or past it. |
+| `--dry-run` | off | Print the plan and change nothing. |
+| `-y`, `--yes` | off | Apply without the confirmation prompt. |
+| `--from <path>` | — | Dev mode, see below. |
+
+Because the root `package.json` is template-owned, add dependencies to the workspace package that
+needs them (your component, `apps/docs`) rather than to the root.
+
+## Dev mode: `--from <path>`
+
+Both commands accept `--from <path>` pointing at a local checkout of the template repo. Nothing is
+downloaded; the checkout is used as-is (minus `node_modules`, build output, `.git` and generated
+data). This is how the template is developed and tested:
+
+```bash
+pnpm --filter create-bht-component-registry build
+node packages/create-bht-component-registry/dist/cli.js create /tmp/demo --scope testco --from .
+node packages/create-bht-component-registry/dist/cli.js update --from . --to 0.2.0 --dry-run
+```
+
+With `--from` and no `--to`, `update` takes the target version from the checkout's
+`registry.config.json`.
+
+## Where the template comes from
+
+The template is the public repo itself, at the tag `changeset publish` creates for this package:
+`https://github.com/behivetech/bht-component-registry/archive/refs/tags/create-bht-component-registry@<version>.tar.gz`.
+If that tag does not exist yet the CLI falls back to the `main` branch with a warning. No separate
+template store exists, so there is nothing else to keep in sync.
+
+## Development
+
+```bash
+pnpm --filter create-bht-component-registry test     # vitest, offline, no pnpm needed
+pnpm --filter create-bht-component-registry build    # tsup → dist/cli.js
+```
+
+Tests inject the template fetcher and the pnpm runner through each command's options object, so
+the suite never touches the network or spawns pnpm.

package/dist/cli.js

@@ -0,0 +1,1093 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { parseArgs } from "util";
+
+// src/commands/create.ts
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir3, readdir as readdir3 } from "fs/promises";
+import { join as join7, resolve as resolve2 } from "path";
+
+// src/lib/config.ts
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+
+// ../scope/src/index.ts
+var RESERVED_SLUGS = /* @__PURE__ */ new Set([
+  "www",
+  "app",
+  "api",
+  "admin",
+  "dashboard",
+  "docs",
+  "sites",
+  "scopes",
+  "registry",
+  "tokens",
+  "sign-in",
+  "sign-up",
+  "onboarding",
+  "static",
+  "assets",
+  "mail",
+  "status",
+  "node_modules",
+  "npm",
+  "pnpm",
+  "example"
+]);
+var SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,38}[a-z0-9])?$/;
+function slugProblem(slug) {
+  if (!slug) return "empty";
+  if (!SLUG_PATTERN.test(slug)) return "format";
+  if (RESERVED_SLUGS.has(slug)) return "reserved";
+  return null;
+}
+
+// src/lib/fs.ts
+import { existsSync } from "fs";
+import { copyFile, cp, mkdir, readdir, readFile, rm, stat, writeFile } from "fs/promises";
+import { basename, dirname, extname, isAbsolute, join, relative, sep } from "path";
+var SKIP_SEGMENTS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".turbo",
+  ".next",
+  "out",
+  "dist",
+  "coverage",
+  "test-results",
+  "playwright-report"
+]);
+var SKIP_PREFIXES = ["apps/docs/src/generated"];
+var GENERATED_DOCS_JSON = /^registry\/.+\/docs\.json$/;
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".json",
+  ".ts",
+  ".tsx",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".md",
+  ".mdx",
+  ".scss",
+  ".css",
+  ".yaml",
+  ".yml",
+  ".hbs",
+  ".txt",
+  ".html"
+]);
+var TEXT_BASENAMES = /* @__PURE__ */ new Set([".gitignore", ".npmrc", ".gitkeep", "LICENSE"]);
+function toPosix(path) {
+  return path.split(sep).join("/");
+}
+function shouldSkip(relPath) {
+  if (relPath === "") return false;
+  if (relPath.split("/").some((segment) => SKIP_SEGMENTS.has(segment))) return true;
+  if (SKIP_PREFIXES.some((prefix) => relPath === prefix || relPath.startsWith(`${prefix}/`))) return true;
+  return GENERATED_DOCS_JSON.test(relPath);
+}
+function isTextFile(path) {
+  return TEXT_EXTENSIONS.has(extname(path).toLowerCase()) || TEXT_BASENAMES.has(basename(path));
+}
+async function listFiles(root) {
+  const found = [];
+  async function walk(dir) {
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+      const abs = join(dir, entry.name);
+      const rel = toPosix(relative(root, abs));
+      if (shouldSkip(rel)) continue;
+      if (entry.isDirectory()) await walk(abs);
+      else if (entry.isFile() || entry.isSymbolicLink()) found.push(rel);
+    }
+  }
+  if (!existsSync(root)) return found;
+  await walk(root);
+  return found.sort();
+}
+async function copyTree(src, dest, skip) {
+  await cp(src, dest, {
+    recursive: true,
+    filter: (source) => {
+      const rel = toPosix(relative(src, source));
+      return !shouldSkip(rel) && !(skip?.(rel) ?? false);
+    }
+  });
+}
+function readText(path) {
+  return readFile(path, "utf8");
+}
+async function writeText(path, text) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, text, "utf8");
+}
+async function writeBytes(path, content) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, content);
+}
+async function isDirEmpty(path) {
+  if (!existsSync(path)) return true;
+  const info = await stat(path);
+  if (!info.isDirectory()) return false;
+  return (await readdir(path)).length === 0;
+}
+async function removeFile(root, relPath) {
+  await rm(join(root, relPath), { force: true });
+  let dir = dirname(join(root, relPath));
+  while (dir !== root && dir.startsWith(root)) {
+    if (!existsSync(dir) || (await readdir(dir)).length > 0) break;
+    await rm(dir, { recursive: true });
+    dir = dirname(dir);
+  }
+}
+function isInside(parent, child) {
+  const rel = relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+
+// src/lib/config.ts
+var CONFIG_FILE = "registry.config.json";
+var VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireString(record, key, source) {
+  const value = record[key];
+  if (typeof value !== "string" || value === "") {
+    throw new Error(`${source}: "${key}" must be a non-empty string.`);
+  }
+  return value;
+}
+function parseRegistryConfig(text, source = CONFIG_FILE) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`${source} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!isRecord(raw)) throw new Error(`${source} must be a JSON object.`);
+  if (!isRecord(raw.site)) throw new Error(`${source}: "site" must be an object.`);
+  return {
+    ...raw,
+    scope: requireString(raw, "scope", source),
+    npmRegistry: requireString(raw, "npmRegistry", source),
+    templateVersion: requireString(raw, "templateVersion", source),
+    site: { ...raw.site, title: requireString(raw.site, "title", `${source} site`) }
+  };
+}
+async function readRegistryConfig(dir) {
+  return parseRegistryConfig(await readText(join2(dir, CONFIG_FILE)));
+}
+function serializeRegistryConfig(config) {
+  return `${JSON.stringify(config, null, 2)}
+`;
+}
+async function writeRegistryConfig(dir, config) {
+  await writeText(join2(dir, CONFIG_FILE), serializeRegistryConfig(config));
+}
+function findRegistryRoot(start) {
+  let dir = start;
+  for (; ; ) {
+    if (existsSync2(join2(dir, CONFIG_FILE))) return dir;
+    const parent = dirname2(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function scopeProblemMessage(scope) {
+  switch (slugProblem(scope)) {
+    case "empty":
+      return "Scope is required: the npm scope your components publish under, e.g. acme \u2192 @acme/*.";
+    case "format":
+      return "Scope must be lowercase letters, digits and hyphens, 1\u201340 chars, e.g. acme \u2192 @acme/*.";
+    case "reserved":
+      return `'${scope}' is reserved; pick another scope.`;
+    default:
+      return null;
+  }
+}
+function titleCaseScope(scope) {
+  return scope.split("-").filter((part) => part !== "").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function isVersion(value) {
+  return VERSION_PATTERN.test(value);
+}
+function compareVersions(a, b) {
+  for (const value of [a, b]) {
+    if (!isVersion(value)) throw new Error(`"${value}" is not a version of the form x.y.z.`);
+  }
+  const left = a.split(".").map(Number);
+  const right = b.split(".").map(Number);
+  for (let i = 0; i < 3; i += 1) {
+    const l = left[i] ?? 0;
+    const r = right[i] ?? 0;
+    if (l < r) return -1;
+    if (l > r) return 1;
+  }
+  return 0;
+}
+
+// src/lib/log.ts
+import pc from "picocolors";
+var log = {
+  info: (message) => console.log(`  ${message}`),
+  success: (message) => console.log(`  ${pc.green("\u2713")} ${message}`),
+  warn: (message) => console.warn(`  ${pc.yellow("!")} ${message}`),
+  error: (message) => console.error(`  ${pc.red("\u2717")} ${message}`),
+  blank: () => console.log()
+};
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/lib/manifest.ts
+import { join as join3 } from "path";
+var MANIFEST_FILE = "template.manifest.json";
+var DEFAULT_README_MARKER = "<!-- your notes below this line are kept by update -->";
+var DEFAULT_MANIFEST = {
+  owned: [
+    "apps/docs/**",
+    "packages/**",
+    "scripts/**",
+    // Shipped by pre-release templates (their task runner). Still owned so `update`
+    // removes them from repos created from those.
+    "turbo/generators/**",
+    ".github/workflows/**",
+    ".changeset/config.json",
+    "turbo.json",
+    "pnpm-workspace.yaml",
+    "package.json",
+    "registry.config.schema.json",
+    "template.manifest.json",
+    "template.manifest.schema.json",
+    ".gitignore",
+    "Dockerfile",
+    "nginx.conf",
+    "CLAUDE.md",
+    "CONTRIBUTING.md",
+    "SECURITY.md",
+    "LICENSE",
+    "docs/**"
+  ],
+  never: ["registry/**", "registry.config.json", ".changeset/*.md", "apps/docs/src/generated/**"],
+  templateOnly: ["packages/create-bht-component-registry/**", ".github/ISSUE_TEMPLATE/**", ".github/PULL_REQUEST_TEMPLATE.md"],
+  readmeMarker: DEFAULT_README_MARKER,
+  rewriteScope: ["apps/docs/e2e/public.spec.ts", "apps/docs/package.json"]
+};
+function stringArray(value, key, source) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(`${source}: "${key}" must be an array of strings.`);
+  }
+  return value;
+}
+function parseManifest(text, source = MANIFEST_FILE) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`${source} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new Error(`${source} must be a JSON object.`);
+  }
+  const record = raw;
+  const marker = record.readmeMarker ?? DEFAULT_README_MARKER;
+  if (typeof marker !== "string" || marker.trim() === "") {
+    throw new Error(`${source}: "readmeMarker" must be a non-empty string.`);
+  }
+  return {
+    owned: stringArray(record.owned, "owned", source),
+    never: stringArray(record.never ?? [], "never", source),
+    templateOnly: stringArray(record.templateOnly ?? [], "templateOnly", source),
+    readmeMarker: marker,
+    rewriteScope: stringArray(record.rewriteScope ?? [], "rewriteScope", source)
+  };
+}
+async function readManifest(dir) {
+  return parseManifest(await readText(join3(dir, MANIFEST_FILE)));
+}
+function globToRegExp(glob) {
+  let pattern = "";
+  for (let i = 0; i < glob.length; i += 1) {
+    const char = glob.charAt(i);
+    if (char === "*") {
+      if (glob.charAt(i + 1) === "*") {
+        if (glob.charAt(i + 2) === "/") {
+          pattern += "(?:.*/)?";
+          i += 2;
+        } else {
+          pattern += ".*";
+          i += 1;
+        }
+      } else {
+        pattern += "[^/]*";
+      }
+    } else if (char === "?") {
+      pattern += "[^/]";
+    } else {
+      pattern += char.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+  }
+  return new RegExp(`^${pattern}$`);
+}
+function matchesAny(path, globs) {
+  return globs.some((glob) => globToRegExp(glob).test(path));
+}
+function isTemplateOnly(path, manifest) {
+  return matchesAny(path, manifest.templateOnly);
+}
+function isTemplateOwned(path, manifest) {
+  if (isTemplateOnly(path, manifest)) return false;
+  return matchesAny(path, manifest.owned) && !matchesAny(path, manifest.never);
+}
+function splitReadme(text, marker) {
+  const index = text.indexOf(marker);
+  if (index === -1) return null;
+  return { above: text.slice(0, index), below: text.slice(index) };
+}
+function mergeReadme(local, target, marker) {
+  const localParts = splitReadme(local, marker);
+  if (!localParts) return null;
+  const targetParts = splitReadme(target, marker);
+  const above = targetParts ? targetParts.above : `${target.trimEnd()}
+
+`;
+  return above + localParts.below;
+}
+
+// src/lib/prompt.ts
+import prompts from "prompts";
+var interactivePrompter = {
+  async text({ message, initial, validate }) {
+    let cancelled2 = false;
+    const answers = await prompts(
+      {
+        type: "text",
+        name: "value",
+        message,
+        initial,
+        validate: validate ? (value2) => validate(value2) : void 0
+      },
+      {
+        onCancel: () => {
+          cancelled2 = true;
+        }
+      }
+    );
+    const value = answers.value;
+    return cancelled2 || typeof value !== "string" ? void 0 : value;
+  },
+  async confirm({ message, initial = false }) {
+    let cancelled2 = false;
+    const answers = await prompts(
+      { type: "confirm", name: "value", message, initial },
+      {
+        onCancel: () => {
+          cancelled2 = true;
+        }
+      }
+    );
+    const value = answers.value;
+    return cancelled2 || typeof value !== "boolean" ? void 0 : value;
+  }
+};
+
+// src/lib/rename.ts
+import { existsSync as existsSync3 } from "fs";
+import { readdir as readdir2, rename } from "fs/promises";
+import { join as join4 } from "path";
+var TEMPLATE_SCOPE = "example";
+function scopeRename(toScope, fromScope = TEMPLATE_SCOPE) {
+  return { fromScope, toScope, fromName: titleCaseScope(fromScope), toName: titleCaseScope(toScope) };
+}
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function rewritePackageRefs(text, r) {
+  if (r.fromScope === r.toScope) return text;
+  const pathPattern = new RegExp(`registry/${escapeRegExp(r.fromScope)}(?![A-Za-z0-9-])`, "g");
+  return text.replaceAll(`@${r.fromScope}/`, `@${r.toScope}/`).replace(pathPattern, `registry/${r.toScope}`);
+}
+function rewriteScopeMentions(text, r) {
+  if (r.fromScope === r.toScope) return text;
+  const slug = new RegExp(`(?<![A-Za-z0-9_-])${escapeRegExp(r.fromScope)}(?![A-Za-z0-9_-])`, "g");
+  const name = new RegExp(
+    `(?<![\\w<])(?<!\\b(?:const|let|var|function|class|type|interface|enum)\\s+)${escapeRegExp(r.fromName)}(?!\\w)`,
+    "g"
+  );
+  return text.replace(slug, r.toScope).replace(name, r.toName);
+}
+function markPublishable(text) {
+  const pkg = JSON.parse(text);
+  if (pkg.private === false) return text;
+  if ("private" in pkg) {
+    pkg.private = false;
+    return `${JSON.stringify(pkg, null, 2)}
+`;
+  }
+  const ordered = {};
+  const anchor = "version" in pkg ? "version" : "name";
+  let inserted = false;
+  for (const [key, value] of Object.entries(pkg)) {
+    ordered[key] = value;
+    if (key === anchor) {
+      ordered.private = false;
+      inserted = true;
+    }
+  }
+  if (!inserted) ordered.private = false;
+  return `${JSON.stringify(ordered, null, 2)}
+`;
+}
+function isComponentPackageJson(relToScope) {
+  const parts = relToScope.split("/");
+  return parts.length === 3 && parts[2] === "package.json";
+}
+async function renameScopeTree(root, r) {
+  const from = join4(root, "registry", r.fromScope);
+  const to = join4(root, "registry", r.toScope);
+  if (!existsSync3(from) || r.fromScope === r.toScope) return [];
+  if (existsSync3(to) && (await readdir2(to)).length > 0) {
+    throw new Error(`registry/${r.toScope} already exists in the template; cannot rename registry/${r.fromScope} onto it.`);
+  }
+  await rename(from, to);
+  const changed = [];
+  for (const rel of await listFiles(to)) {
+    if (!isTextFile(rel)) continue;
+    const path = join4(to, rel);
+    const before = await readText(path);
+    let after = rewritePackageRefs(before, r);
+    if (isComponentPackageJson(rel)) after = markPublishable(after);
+    if (after !== before) {
+      await writeText(path, after);
+      changed.push(`registry/${r.toScope}/${rel}`);
+    }
+  }
+  const scopeJson = join4(to, "scope.json");
+  const meta = existsSync3(scopeJson) ? JSON.parse(await readText(scopeJson)) : {};
+  await writeText(scopeJson, `${JSON.stringify({ ...meta, name: r.toName }, null, 2)}
+`);
+  changed.push(`registry/${r.toScope}/scope.json`);
+  return changed;
+}
+async function rewriteChangesets(root, r) {
+  const dir = join4(root, ".changeset");
+  if (!existsSync3(dir)) return [];
+  const changed = [];
+  for (const entry of await readdir2(dir)) {
+    if (!entry.endsWith(".md")) continue;
+    const path = join4(dir, entry);
+    const before = await readText(path);
+    const after = rewritePackageRefs(before, r);
+    if (after !== before) {
+      await writeText(path, after);
+      changed.push(`.changeset/${entry}`);
+    }
+  }
+  return changed;
+}
+async function rewriteLockfile(root, r) {
+  const path = join4(root, "pnpm-lock.yaml");
+  if (!existsSync3(path)) return [];
+  const before = await readText(path);
+  const after = rewritePackageRefs(before, r);
+  if (after === before) return [];
+  await writeText(path, after);
+  return ["pnpm-lock.yaml"];
+}
+async function rewriteScopeFiles(root, files, r) {
+  const changed = [];
+  for (const rel of files) {
+    const path = join4(root, rel);
+    if (!existsSync3(path)) continue;
+    const before = await readText(path);
+    const after = rewriteScopeMentions(before, r);
+    if (after !== before) {
+      await writeText(path, after);
+      changed.push(rel);
+    }
+  }
+  return changed;
+}
+
+// src/lib/run.ts
+import { spawn } from "child_process";
+var runPnpm = (args, cwd) => new Promise((resolve3, reject) => {
+  const child = spawn("pnpm", args, { cwd, stdio: "inherit", shell: process.platform === "win32" });
+  child.on("error", (error) => {
+    reject(
+      error.code === "ENOENT" ? new Error(
+        "pnpm was not found on your PATH. Enable it with `corepack enable` (ships with Node) or see https://pnpm.io/installation."
+      ) : error
+    );
+  });
+  child.on("close", (code) => resolve3(code ?? 1));
+});
+function capture(command, args, cwd) {
+  return new Promise((resolve3, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: process.platform === "win32"
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve3({ code: code ?? 1, stdout, stderr }));
+  });
+}
+async function isGitTreeClean(cwd) {
+  try {
+    const result = await capture("git", ["status", "--porcelain"], cwd);
+    return result.code === 0 && result.stdout.trim() === "";
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/template.ts
+import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir2, mkdtemp, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join5, resolve } from "path";
+import { extract } from "tar";
+var TEMPLATE_REPO = "behivetech/bht-component-registry";
+var TEMPLATE_PACKAGE = "create-bht-component-registry";
+function templateTag(version) {
+  return `${TEMPLATE_PACKAGE}@${version}`;
+}
+function tagTarballUrl(version) {
+  return `https://github.com/${TEMPLATE_REPO}/archive/refs/tags/${encodeURIComponent(templateTag(version))}.tar.gz`;
+}
+function mainTarballUrl() {
+  return `https://github.com/${TEMPLATE_REPO}/archive/refs/heads/main.tar.gz`;
+}
+async function download(version, log2) {
+  let url = tagTarballUrl(version);
+  log2.info(`Downloading template ${templateTag(version)} from GitHub...`);
+  let response = await fetch(url, { redirect: "follow" });
+  if (response.status === 404) {
+    log2.warn(`No release tag ${templateTag(version)} on GitHub; falling back to the main branch.`);
+    url = mainTarballUrl();
+    response = await fetch(url, { redirect: "follow" });
+  }
+  if (!response.ok) {
+    throw new Error(`Template download failed: ${url} returned HTTP ${response.status}.`);
+  }
+  return { bytes: Buffer.from(await response.arrayBuffer()), url };
+}
+var fetchTemplate = async (request, log2) => {
+  if (request.from !== void 0) {
+    const dir = resolve(request.from);
+    if (!existsSync4(join5(dir, CONFIG_FILE))) {
+      throw new Error(`--from ${request.from} is not a bht-component-registry checkout (no ${CONFIG_FILE} in it).`);
+    }
+    log2.info(`Using local template checkout ${dir}`);
+    return { dir, source: dir, cleanup: async () => void 0 };
+  }
+  const tmp = await mkdtemp(join5(tmpdir(), "bht-template-"));
+  const cleanup = () => rm2(tmp, { recursive: true, force: true });
+  try {
+    const { bytes, url } = await download(request.version, log2);
+    const tarball = join5(tmp, "template.tar.gz");
+    await writeFile2(tarball, bytes);
+    const dir = join5(tmp, "template");
+    await mkdir2(dir);
+    await extract({ file: tarball, cwd: dir, strip: 1 });
+    await rm2(tarball, { force: true });
+    if (!existsSync4(join5(dir, CONFIG_FILE))) {
+      throw new Error(`The downloaded template has no ${CONFIG_FILE}; ${url} does not look like a bht-component-registry release.`);
+    }
+    return { dir, source: url, cleanup };
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+};
+
+// src/lib/version.ts
+import { existsSync as existsSync5, readFileSync } from "fs";
+import { dirname as dirname3, join as join6 } from "path";
+import { fileURLToPath } from "url";
+var CLI_NAME = "create-bht-component-registry";
+function readOwnVersion() {
+  let dir = dirname3(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 5; depth += 1) {
+    const candidate = join6(dir, "package.json");
+    if (existsSync5(candidate)) {
+      const pkg = JSON.parse(readFileSync(candidate, "utf8"));
+      if (pkg.name === CLI_NAME && typeof pkg.version === "string") return pkg.version;
+    }
+    const parent = dirname3(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(`Cannot find ${CLI_NAME}'s package.json to read its version.`);
+}
+
+// src/commands/create.ts
+var DEFAULT_REGISTRY = "https://registry.npmjs.org";
+var DEFAULT_CATEGORIES = ["atoms", "molecules", "organisms", "templates", "forms"];
+var DEFAULT_DIR = "my-registry";
+var CATEGORY_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+function defaultDeps() {
+  return { fetchTemplate, runPnpm, prompt: interactivePrompter, cwd: process.cwd(), log };
+}
+async function resolveDir(options, deps) {
+  if (options.dir) return options.dir;
+  if (options.yes) return DEFAULT_DIR;
+  const value = await deps.prompt.text({
+    message: "Directory for the new registry",
+    initial: DEFAULT_DIR,
+    validate: (v) => v.trim() === "" ? "A directory name is required." : true
+  });
+  return value?.trim();
+}
+async function resolveScope(options, deps) {
+  if (options.scope !== void 0) {
+    const scope = options.scope.trim();
+    const problem = scopeProblemMessage(scope);
+    if (problem) {
+      deps.log.error(problem);
+      return void 0;
+    }
+    return scope;
+  }
+  if (options.yes) {
+    deps.log.error(`--yes needs --scope. ${scopeProblemMessage("")}`);
+    return void 0;
+  }
+  const value = await deps.prompt.text({
+    message: "npm scope, without the @ (your components publish as @<scope>/<category>.<name>)",
+    validate: (v) => scopeProblemMessage(v.trim()) ?? true
+  });
+  return value?.trim();
+}
+function registryProblem(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "https:" && url.protocol !== "http:") return "The registry must be an http(s) URL.";
+    return null;
+  } catch {
+    return `"${value}" is not a URL. Example: ${DEFAULT_REGISTRY}`;
+  }
+}
+async function resolveRegistry(options, deps) {
+  if (options.registry !== void 0) {
+    const problem = registryProblem(options.registry);
+    if (problem) {
+      deps.log.error(problem);
+      return void 0;
+    }
+    return options.registry.replace(/\/+$/, "");
+  }
+  if (options.yes) return DEFAULT_REGISTRY;
+  const value = await deps.prompt.text({
+    message: "npm registry to publish to",
+    initial: DEFAULT_REGISTRY,
+    validate: (v) => registryProblem(v.trim()) ?? true
+  });
+  return value?.trim().replace(/\/+$/, "");
+}
+function parseCategories(value) {
+  const list = Array.isArray(value) ? value : value.split(",");
+  return [...new Set(list.map((item) => item.trim()).filter((item) => item !== ""))];
+}
+function categoriesProblem(categories) {
+  if (categories.length === 0) return "At least one category is required, e.g. atoms.";
+  const bad = categories.find((category) => !CATEGORY_PATTERN.test(category));
+  return bad ? `"${bad}" is not a valid category: lowercase letters, digits and hyphens only.` : null;
+}
+async function resolveCategories(options, deps) {
+  if (options.categories !== void 0) {
+    const categories = parseCategories(options.categories);
+    const problem = categoriesProblem(categories);
+    if (problem) {
+      deps.log.error(problem);
+      return void 0;
+    }
+    return categories;
+  }
+  if (options.yes) return DEFAULT_CATEGORIES;
+  const value = await deps.prompt.text({
+    message: "Starter categories, comma-separated",
+    initial: DEFAULT_CATEGORIES.join(","),
+    validate: (v) => categoriesProblem(parseCategories(v)) ?? true
+  });
+  return value === void 0 ? void 0 : parseCategories(value);
+}
+async function writeConfig(target, choices) {
+  const path = join7(target, CONFIG_FILE);
+  const base = existsSync6(path) ? parseRegistryConfig(await readText(path)) : {
+    $schema: "./registry.config.schema.json",
+    scope: choices.scope,
+    npmRegistry: choices.registry,
+    templateVersion: choices.templateVersion,
+    site: { title: "" }
+  };
+  await writeRegistryConfig(target, {
+    ...base,
+    scope: choices.scope,
+    npmRegistry: choices.registry,
+    templateVersion: choices.templateVersion,
+    site: {
+      ...base.site,
+      title: `${titleCaseScope(choices.scope)} Component Registry`,
+      links: (base.site.links ?? []).filter((link) => link.label !== "GitHub")
+    }
+  });
+}
+async function ensureCategories(target, scope, categories) {
+  for (const category of categories) {
+    const dir = join7(target, "registry", scope, category);
+    await mkdir3(dir, { recursive: true });
+    if ((await readdir3(dir)).length === 0) await writeText(join7(dir, ".gitkeep"), "");
+  }
+}
+async function readManifestOrDefault(dir) {
+  return existsSync6(join7(dir, MANIFEST_FILE)) ? readManifest(dir) : DEFAULT_MANIFEST;
+}
+function skipTemplateOnly(manifest) {
+  return (relPath) => isTemplateOnly(relPath, manifest) || isTemplateOnly(`${relPath}/`, manifest);
+}
+async function applyScope(target, choices) {
+  const rename2 = scopeRename(choices.scope);
+  await renameScopeTree(target, rename2);
+  await rewriteChangesets(target, rename2);
+  await rewriteLockfile(target, rename2);
+  await ensureCategories(target, choices.scope, choices.categories);
+  await writeConfig(target, choices);
+  const manifest = await readManifestOrDefault(target);
+  await rewriteScopeFiles(target, manifest.rewriteScope, rename2);
+}
+function printNextSteps(dir, scope, installed, log2) {
+  log2.blank();
+  log2.success(`Created ${dir} for @${scope}/*`);
+  log2.blank();
+  log2.info("Next steps:");
+  log2.blank();
+  log2.info(`  cd ${dir}`);
+  if (!installed) log2.info("  pnpm install");
+  log2.info("  pnpm dev");
+  log2.blank();
+  log2.info(`Create the npm org for @${scope} at https://www.npmjs.com/org/create before your first \`pnpm release\`.`);
+  log2.info("Guides: docs/getting-started.md");
+  log2.info("Hosted & expanded version: https://platform.behivetech.com/expanded");
+  log2.blank();
+}
+async function create(options, overrides = {}) {
+  const deps = { ...defaultDeps(), ...overrides };
+  const { log: log2 } = deps;
+  try {
+    const dir = await resolveDir(options, deps);
+    if (dir === void 0) return cancelled(log2);
+    const target = resolve2(deps.cwd, dir);
+    if (!await isDirEmpty(target)) {
+      log2.error(`${dir} already exists and is not empty. Pick a new directory.`);
+      return 1;
+    }
+    const scope = await resolveScope(options, deps);
+    if (scope === void 0) return options.scope === void 0 && !options.yes ? cancelled(log2) : 1;
+    const registry = await resolveRegistry(options, deps);
+    if (registry === void 0) return options.registry === void 0 && !options.yes ? cancelled(log2) : 1;
+    const categories = await resolveCategories(options, deps);
+    if (categories === void 0) return options.categories === void 0 && !options.yes ? cancelled(log2) : 1;
+    const templateVersion = options.templateVersion ?? readOwnVersion();
+    if (!isVersion(templateVersion)) {
+      log2.error(`--template-version must be x.y.z, got "${templateVersion}".`);
+      return 1;
+    }
+    log2.blank();
+    log2.info(`Creating ${dir} for @${scope}/* ...`);
+    const template = await deps.fetchTemplate({ version: templateVersion, from: options.from }, log2);
+    try {
+      if (isInside(template.dir, target)) {
+        log2.error(`${dir} is inside the template checkout; pick a directory outside ${template.dir}.`);
+        return 1;
+      }
+      const manifest = await readManifestOrDefault(template.dir);
+      await copyTree(template.dir, target, skipTemplateOnly(manifest));
+    } finally {
+      await template.cleanup();
+    }
+    await applyScope(target, { scope, registry, categories, templateVersion });
+    log2.success(`Scaffolded registry/${scope} and registry.config.json`);
+    if (options.install) {
+      for (const step of ["install", "build"]) {
+        log2.blank();
+        log2.info(`Running pnpm ${step}...`);
+        const code = await deps.runPnpm([step], target);
+        if (code !== 0) {
+          log2.blank();
+          log2.error(`pnpm ${step} failed (exit code ${code}). The project is in ${dir}; fix the error above and rerun \`pnpm ${step}\` there.`);
+          return 1;
+        }
+      }
+    }
+    printNextSteps(dir, scope, options.install, log2);
+    return 0;
+  } catch (error) {
+    log2.error(errorMessage(error));
+    return 1;
+  }
+}
+function cancelled(log2) {
+  log2.info("Cancelled; nothing was created.");
+  return 1;
+}
+
+// src/commands/update.ts
+import { existsSync as existsSync7 } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { join as join8 } from "path";
+function defaultDeps2() {
+  return { fetchTemplate, isTreeClean: isGitTreeClean, prompt: interactivePrompter, cwd: process.cwd(), log };
+}
+function sameBytes(local, content) {
+  return typeof content === "string" ? local.equals(Buffer.from(content, "utf8")) : local.equals(content);
+}
+async function planReadme(root, templateDir, marker) {
+  const targetPath = join8(templateDir, "README.md");
+  if (!existsSync7(targetPath)) return { status: "absent" };
+  const target = await readText(targetPath);
+  const localPath = join8(root, "README.md");
+  if (!existsSync7(localPath)) return { status: "added", content: target };
+  const local = await readText(localPath);
+  if (!splitReadme(local, marker)) return { status: "no-marker" };
+  const merged = mergeReadme(local, target, marker);
+  if (merged === null || merged === local) return { status: "unchanged" };
+  return { status: "merged", content: merged };
+}
+async function planUpdate(root, templateDir, manifest, rename2) {
+  const owned = (file) => file !== "README.md" && isTemplateOwned(file, manifest);
+  const targetFiles = (await listFiles(templateDir)).filter(owned);
+  const allLocal = await listFiles(root);
+  const localFiles = allLocal.filter(owned);
+  const strayTemplateOnly = allLocal.filter((file) => isTemplateOnly(file, manifest));
+  const targetSet = new Set(targetFiles);
+  const localSet = new Set(localFiles);
+  const rewriteSet = new Set(manifest.rewriteScope);
+  const added = [];
+  const replaced = [];
+  const rewritten = [];
+  for (const file of targetFiles) {
+    let content = await readFile2(join8(templateDir, file));
+    if (rewriteSet.has(file)) {
+      const original = content.toString("utf8");
+      content = rewriteScopeMentions(original, rename2);
+      if (content !== original) rewritten.push(file);
+    }
+    if (!localSet.has(file)) {
+      added.push({ path: file, content });
+      continue;
+    }
+    if (!sameBytes(await readFile2(join8(root, file)), content)) replaced.push({ path: file, content });
+  }
+  const removed = [...localFiles.filter((file) => !targetSet.has(file)), ...strayTemplateOnly].sort();
+  const readme = await planReadme(root, templateDir, manifest.readmeMarker);
+  return { added, replaced, removed, readme, rewritten };
+}
+async function applyPlan(root, plan) {
+  for (const change of [...plan.added, ...plan.replaced]) {
+    await writeBytes(join8(root, change.path), change.content);
+  }
+  for (const file of plan.removed) await removeFile(root, file);
+  if (plan.readme.content !== void 0) await writeText(join8(root, "README.md"), plan.readme.content);
+}
+function printList(title, files, log2) {
+  if (files.length === 0) return;
+  log2.info(`${title} (${files.length}):`);
+  for (const file of files) log2.info(`  ${file}`);
+  log2.blank();
+}
+function planIsEmpty(plan) {
+  return plan.added.length === 0 && plan.replaced.length === 0 && plan.removed.length === 0 && plan.readme.content === void 0;
+}
+function printPlan(plan, manifest, scope, log2) {
+  printList("Added", plan.added.map((change) => change.path), log2);
+  printList("Replaced", plan.replaced.map((change) => change.path), log2);
+  printList("Removed", plan.removed, log2);
+  switch (plan.readme.status) {
+    case "added":
+      log2.info("README.md: added from the template.");
+      break;
+    case "merged":
+      log2.info("README.md: the part above the marker is replaced; your notes below it are kept.");
+      break;
+    case "no-marker":
+      log2.warn(`README.md has no "${manifest.readmeMarker}" line, so it is left untouched. Put that line above your own notes to let update refresh the template's part.`);
+      break;
+    default:
+      break;
+  }
+  if (plan.rewritten.length > 0) {
+    log2.info(`Scope "${scope}" re-applied in: ${plan.rewritten.join(", ")}`);
+  }
+  if (planIsEmpty(plan)) log2.info("Every template-owned file already matches the target.");
+}
+function isBehind(current, target, log2) {
+  if (compareVersions(current, target) >= 0) {
+    log2.info(`Already at template ${current} (target ${target}); nothing to do.`);
+    return false;
+  }
+  return true;
+}
+async function update(options, overrides = {}) {
+  const deps = { ...defaultDeps2(), ...overrides };
+  const { log: log2 } = deps;
+  try {
+    const root = findRegistryRoot(deps.cwd);
+    if (!root) {
+      log2.error(`No ${CONFIG_FILE} found in ${deps.cwd} or any parent directory. Run update inside a registry created with create-bht-component-registry.`);
+      return 1;
+    }
+    if (!await deps.isTreeClean(root)) {
+      log2.error("Commit or stash your changes first; update replaces template-owned files and you'll want a clean diff.");
+      return 1;
+    }
+    const config = await readRegistryConfig(root);
+    const requested = options.to ?? readOwnVersion();
+    if (!isVersion(requested)) {
+      log2.error(`--to must be x.y.z, got "${requested}".`);
+      return 1;
+    }
+    if (options.from === void 0 && !isBehind(config.templateVersion, requested, log2)) return 0;
+    const template = await deps.fetchTemplate({ version: requested, from: options.from }, log2);
+    try {
+      const targetVersion = options.from !== void 0 && options.to === void 0 ? (await readRegistryConfig(template.dir)).templateVersion : requested;
+      if (options.from !== void 0 && !isBehind(config.templateVersion, targetVersion, log2)) return 0;
+      const manifest = await readManifest(template.dir);
+      const rename2 = scopeRename(config.scope);
+      const plan = await planUpdate(root, template.dir, manifest, rename2);
+      const prefix = options.dryRun ? "[dry run] " : "";
+      log2.blank();
+      log2.info(`${prefix}Updating template ${config.templateVersion} \u2192 ${targetVersion} in ${root}`);
+      log2.blank();
+      printPlan(plan, manifest, config.scope, log2);
+      if (options.dryRun) {
+        log2.info("Dry run: nothing was changed.");
+        return 0;
+      }
+      if (!options.yes) {
+        const ok = await deps.prompt.confirm({ message: "Apply these changes?", initial: true });
+        if (!ok) {
+          log2.info("Cancelled; nothing was changed.");
+          return 1;
+        }
+      }
+      await applyPlan(root, plan);
+      await writeRegistryConfig(root, { ...config, templateVersion: targetVersion });
+      log2.blank();
+      log2.success(`Updated to template ${targetVersion}.`);
+      log2.info("Review with `git diff`, then run `pnpm install && pnpm verify`.");
+      log2.blank();
+      return 0;
+    } finally {
+      await template.cleanup();
+    }
+  } catch (error) {
+    log2.error(errorMessage(error));
+    return 1;
+  }
+}
+
+// src/cli.ts
+var HELP = `
+  ${CLI_NAME} \u2014 scaffold a component registry that stays in git, and keep it current.
+
+  Usage
+    npx ${CLI_NAME} <dir> [options]            scaffold a new registry
+    npx ${CLI_NAME} create <dir> [options]     same, spelled out
+    npx ${CLI_NAME} update [options]           run inside an existing registry
+
+  create options
+    --scope <name>               npm scope without the @ (required; prompted if missing)
+    --registry <url>             registry to publish to (default: https://registry.npmjs.org)
+    --categories <a,b,c>         starter categories (default: atoms,molecules,organisms,templates,forms)
+    --template-version <x.y.z>   template release to download (default: this CLI's version)
+    --no-install                 skip \`pnpm install\` and \`pnpm build\`
+    -y, --yes                    accept defaults instead of prompting
+
+  update options
+    --to <x.y.z>                 template version to update to (default: this CLI's version)
+    --dry-run                    list what would change and change nothing
+    -y, --yes                    apply without asking
+
+  both
+    --from <path>                dev mode: use a local checkout of the template instead of downloading
+    -h, --help                   show this help
+    -v, --version                print the version
+
+  Hosted & expanded version: https://platform.behivetech.com
+`;
+async function main(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args: argv,
+      allowPositionals: true,
+      options: {
+        scope: { type: "string" },
+        registry: { type: "string" },
+        categories: { type: "string" },
+        "template-version": { type: "string" },
+        to: { type: "string" },
+        from: { type: "string" },
+        "no-install": { type: "boolean" },
+        "dry-run": { type: "boolean" },
+        yes: { type: "boolean", short: "y" },
+        help: { type: "boolean", short: "h" },
+        version: { type: "boolean", short: "v" }
+      }
+    });
+  } catch (error) {
+    log.error(`${errorMessage(error)} Run with --help for usage.`);
+    return 1;
+  }
+  const { values, positionals } = parsed;
+  const string = (key) => {
+    const value = values[key];
+    return typeof value === "string" ? value : void 0;
+  };
+  const flag = (key) => values[key] === true;
+  if (flag("version")) {
+    console.log(readOwnVersion());
+    return 0;
+  }
+  if (flag("help") || positionals.length === 0) {
+    console.log(HELP);
+    return flag("help") ? 0 : 1;
+  }
+  const [command, ...rest] = positionals;
+  if (command === "update") {
+    return update({ to: string("to"), from: string("from"), dryRun: flag("dry-run"), yes: flag("yes") });
+  }
+  const dir = command === "create" ? rest[0] : command;
+  const categories = string("categories");
+  return create({
+    dir,
+    scope: string("scope"),
+    registry: string("registry"),
+    categories: categories === void 0 ? void 0 : categories.split(","),
+    templateVersion: string("template-version"),
+    from: string("from"),
+    install: !flag("no-install"),
+    yes: flag("yes")
+  });
+}
+main(process.argv.slice(2)).then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (error) => {
+    log.error(errorMessage(error));
+    process.exitCode = 1;
+  }
+);

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "create-bht-component-registry",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.1",
+  "description": "Scaffold a bht-component-registry — a component registry that stays in git — and keep it up to date with `update`.",
+  "keywords": [
+    "component-registry",
+    "design-system",
+    "create",
+    "scaffold",
+    "nextjs",
+    "pnpm-workspace",
+    "changesets"
+  ],
+  "homepage": "https://platform.behivetech.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/behivetech/bht-component-registry.git",
+    "directory": "packages/create-bht-component-registry"
+  },
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "create-bht-component-registry": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "picocolors": "^1.1.1",
+    "prompts": "^2.4.2",
+    "tar": "^7.5.22"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.4",
+    "@types/prompts": "^2.4.9",
+    "eslint": "^9.39.5",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.10",
+    "@bht-component-registry/eslint-config": "0.1.0",
+    "@bht-component-registry/scope": "0.1.0",
+    "@bht-component-registry/typescript-config": "0.0.2"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint . --max-warnings 0",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run"
+  }
 }