@goldencomm/create-baseline 0.0.1 → 0.1.0

package/README.md

@@ -1,88 +1,27 @@
 # @goldencomm/create-baseline
 
-Scaffolds a **standalone project** from a Baseline template — copies the template,
-then rewires it into its own project (names, README, the design-system deps, and
-platform-specific fixups). Zero dependencies; Node built-ins only.
-
-## Usage
-
-### Standalone (npm)
-
-Because the package is named `@goldencomm/create-baseline`, npm's `create` prefix
-mapping means the exact command is:
-
-```bash
-npm create @goldencomm/baseline <platform> <name>
-# flags need a `--` separator so npm doesn't eat them:
-npm create @goldencomm/baseline <platform> <name> -- --dir ../my-app --ds-version ^0.0.1
-```
-
-(`pnpm create @goldencomm/baseline …` and `npx @goldencomm/create-baseline …` work too.)
-
-### Inside the monorepo
+Scaffolds a GC Baseline project for one platform (ADR-0035):
 
 ```bash
-pnpm create-baseline <platform> <name> [options]
-# or directly:
-node tools/create-baseline/index.mjs <platform> <name> [options]
+npm create @goldencomm/baseline@latest next      my-site  [--figma-file <client library key or URL>]
+npm create @goldencomm/baseline@latest wordpress my-site
+npm create @goldencomm/baseline@latest shopify   my-theme
 ```
 
-| Platform | Produces |
-|---|---|
-| `next` | Next.js App Router app (React + `ds-core`/`ds-react`) |
-| `shopify` | Shopify OS 2.0 theme (vendored `baseline.css`) |
-| `wordpress` | WordPress site scaffold (Composer + DDEV) |
-| `dotnet` | *(no scaffold)* — prints how to consume `ds-html` + `baseline.css` (Q-005) |
-
-**Options**
-
-| Flag | Default | Meaning |
-|---|---|---|
-| `--dir <path>` | `./<name>` | Target directory |
-| `--ds-version <ver>` | `^0.0.1` | Version pinned for the `@goldencomm/ds-*` deps |
-| `--force` | — | Allow scaffolding into a non-empty directory |
-
-```bash
-pnpm create-baseline shopify acme-store
-pnpm create-baseline next acme-proto --dir ../acme-proto --ds-version ^0.1.0
-pnpm create-baseline wordpress acme-site
-```
-
-## What it does
-
-1. **Copies** the template. Two auto-detected source modes:
-   - **monorepo** — inside the design-system repo it copies the committed files of
-     `baselines/<platform>` via `git ls-files` (so `node_modules`, `dist`, `.next`,
-     `.turbo`, `vendor` are excluded automatically);
-   - **bundled** — installed from npm it copies the `templates/` snapshot that the
-     `prepack` script (`scripts/bundle-templates.mjs`) baked into the package at
-     publish time from the same `git ls-files` listing. (npm strips `.gitignore`/
-     `.npmrc`/`.npmignore` from tarballs, so those are stored renamed —
-     `_gitignore` etc. — and restored on scaffold.)
-2. **Rewires** identifiers: `package.json`/`composer.json` name + description, the
-   README title, and the Shopify `theme_name`.
-3. **Rewrites DS deps** — any `workspace:*` (`@goldencomm/ds-core`, `ds-react`) becomes
-   `--ds-version` so the project resolves them from npm.
-4. **Platform fixups:**
-   - **shopify** — repoints the `dev` token-watch at `node_modules/@goldencomm/ds-core`.
-   - **wordpress** — removes the monorepo bind-mount (`.ddev/docker-compose.packages.yaml`),
-     adds Composer `require` + VCS repos for `goldencomm/wp-theme` and
-     `goldencomm/wp-blocks-plugin`, renames the DDEV project, and updates `seed.sh`
-     (theme slug → `wp-theme`, site host → `<name>.ddev.site`).
-
-## Standalone readiness
+- **next:** `create-next-app` (App Router, Tailwind v4), `shadcn init` with GC Baseline's base, then **every component and
+  block** from `@goldencomm/baseline-registry` at this version (default looks), the Code Connect templates beside them,
+  `app/globals.css` importing the project's own token build, and a starter page made of blocks.
+- **wordpress:** the DDEV project and the GC Baseline theme (`theme/`) from `platforms/wordpress` at this version.
+- **shopify:** the GC Baseline theme from `platforms/shopify/theme` at this version.
 
-- **Shopify** — works **now**; `baseline.css` is vendored into `assets/`.
-- **Next** — needs `@goldencomm/ds-core` + `ds-react` on npm before `npm install`
-  resolves (they ship at `0.0.1`).
-- **WordPress** — `goldencomm/wp-theme` + `wp-blocks-plugin` are **not published as
-  Composer packages yet**; `composer install` currently requires monorepo/Bitbucket
-  VCS access and your own gitignored `auth.json` for the ACF/Gravity/Bitbucket
-  credentials (never copied by the scaffolder). The scaffolder prints this caveat.
+Every project gets `client.tokens.json` (empty: GC Baseline core values) with an `npm run tokens` script on
+`@goldencomm/baseline-tokens`, the `baseline-client-tokens` Claude skill that fills it from the client's Figma library,
+`baseline.json` (platform, version, Figma file), and a Bitbucket pipeline that publishes Code Connect against the
+client's library from master.
 
-## Publishing notes
+Fonts are the project's decision (ADR-0017): the Next.js scaffold loads none, so text falls back to the system face
+until the client's font is added in `app/layout.tsx` (for example with `next/font`).
 
-- `templates/` is generated by `prepack` and gitignored — never commit it; it is
-  rebuilt from the committed baselines on every `pnpm pack` / `npm publish`.
-- Packing/publishing must therefore happen from a monorepo checkout (prepack runs
-  `git ls-files`).
+The packages release in lockstep: create-baseline installs the registry items and the tokens package at its own
+version. Options for testing a release before it is published: `--registry <url to an r/ folder>`, `--tokens <path to
+a packed tokens tarball>`.

package/index.mjs

@@ -1,296 +1,188 @@
 #!/usr/bin/env node
-/**
- * create-baseline — scaffold a standalone project from a Baseline template.
- *
- *   create-baseline <platform> <name> [--dir <path>] [--ds-version <ver>] [--force]
- *   npm create @goldencomm/baseline <platform> <name>       (outside the monorepo)
- *
- * Platforms: next | wordpress | shopify   (dotnet prints guidance — see Q-005).
- *
- * Template source (auto-detected):
- *   - monorepo mode — inside the design-system repo, copies the committed files
- *     of `baselines/<platform>` (via `git ls-files`, so node_modules/dist/vendor/
- *     .next/.turbo are excluded for free);
- *   - bundled mode — standalone (installed from npm), copies the `templates/`
- *     snapshot bundled into the package at prepack time.
- *
- * Either way it then rewires the copy into a standalone project: package/composer
- * names, README title, the DS `workspace:*` deps (-> --ds-version), and
- * platform-specific fixups (e.g. the WP monorepo bind-mount -> a Composer require).
- *
- * Zero dependencies — Node built-ins only.
- */
-import { execFileSync } from "node:child_process";
-import {
-  existsSync, mkdirSync, copyFileSync, readFileSync, writeFileSync, readdirSync, rmSync,
-} from "node:fs";
-import { dirname, resolve, join } from "node:path";
+// @goldencomm/create-baseline (ADR-0035): scaffolds a GC Baseline project for one platform.
+//
+//   npm create @goldencomm/baseline@latest <next|wordpress|shopify> <directory> [options]
+//
+//   --figma-file <key|url>   the client's Figma library (a copy of GC Baseline Core); recorded in baseline.json
+//   --registry <url>         where the registry items are (default: this version of @goldencomm/baseline-registry on jsDelivr)
+//   --tokens <spec>          the tokens package to install (default: @goldencomm/baseline-tokens@<this version>)
+//   --skip-install           write the files only (next: still needs installs, so it is refused)
+//
+// Every GC Baseline package releases in lockstep, so this scaffolder installs the registry items and the tokens package
+// at its own version. No runtime dependencies beyond Node.
+import { spawnSync } from "node:child_process";
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
-const HERE = dirname(fileURLToPath(import.meta.url));
-const REPO_ROOT = resolve(HERE, "../..");
+const here = dirname(fileURLToPath(import.meta.url));
+const self = JSON.parse(readFileSync(join(here, "package.json"), "utf8"));
+const VERSION = self.version;
+const NEXT_VERSION = "16"; // the Next.js major the registry is built and tested with (registry/package.json)
+const SHADCN = "shadcn@4.21.0"; // the shadcn CLI version the registry is built with
 
-const PLATFORMS = {
-  next: { dir: "next", kind: "npm" },
-  shopify: { dir: "shopify-theme", kind: "npm" },
-  wordpress: { dir: "wordpress", kind: "composer" },
+const fail = (msg) => {
+  console.error(`create-baseline: ${msg}`);
+  process.exit(1);
 };
-
-// ---- arg parsing -----------------------------------------------------------
+const VALUE_OPTIONS = new Set(["figma-file", "registry", "tokens"]);
+const positional = [];
+const options = {};
+const flags = new Set();
 const argv = process.argv.slice(2);
-function takeFlag(name, hasValue = true) {
-  const i = argv.indexOf(name);
-  if (i === -1) return undefined;
-  const val = hasValue ? argv[i + 1] : true;
-  argv.splice(i, hasValue ? 2 : 1);
-  return val;
-}
-const force = takeFlag("--force", false);
-const dirFlag = takeFlag("--dir");
-const dsVersion = takeFlag("--ds-version") || "^0.0.1";
-const [platform, nameArg] = argv;
-
-function die(msg) {
-  console.error(`\n✖ ${msg}\n`);
-  process.exit(1);
-}
-function usage() {
-  console.log(`
-create-baseline — scaffold a standalone project from a Baseline baseline
-
-Usage:
-  create-baseline <platform> <name> [options]
-
-Platforms:
-  next        Next.js App Router app (React + ds-core/ds-react)
-  shopify     Shopify OS 2.0 theme (vendored baseline.css)
-  wordpress   WordPress site scaffold (Composer + DDEV)
-  dotnet      (no scaffold — prints how to consume ds-html + baseline.css)
-
-Options:
-  --dir <path>         target directory (default: ./<name>)
-  --ds-version <ver>   version for @goldencomm/ds-* deps (default: ^0.0.1)
-  --force              allow scaffolding into a non-empty directory
-`);
-}
-
-if (!platform || platform === "--help" || platform === "-h") {
-  usage();
-  process.exit(platform ? 0 : 1);
-}
-
-if (platform === "dotnet") {
-  console.log(`
-.NET has no scaffolded baseline (decision Q-005). Consume the shared contract:
-
-  1. Vendor @goldencomm/ds-core's baseline.css into your app's wwwroot and link it.
-  2. Render components with the gcds-* markup from packages/ds-html
-     (e.g. <button class="gcds-button gcds-button--primary gcds-button--md">),
-     directly or via a Razor partial.
-
-See packages/ds-html/README.md for the full guide.
-`);
-  process.exit(0);
-}
-
-const cfg = PLATFORMS[platform];
-if (!cfg) die(`Unknown platform "${platform}". Use: next | wordpress | shopify | dotnet`);
-if (!nameArg) die(`Missing <name>. Try: create-baseline ${platform} my-project`);
-
-// name derivations
-const name = nameArg.trim();
-const slug = (name.includes("/") ? name.split("/").pop() : name).toLowerCase();
-if (!/^[a-z0-9][a-z0-9._-]*$/.test(slug)) {
-  die(`"${name}" isn't a safe project slug. Use lowercase letters, digits, - . _`);
-}
-const npmName = name.toLowerCase();
-const composerName = name.includes("/") ? name.toLowerCase() : `goldencomm/${slug}`;
-const description = `${slug} — scaffolded from the Baseline ${platform} baseline.`;
-
-// ---- template source: monorepo baselines/ or bundled templates/ -------------
-// prepack stores npm-packlist-hostile basenames renamed; restore them on copy.
-// Keep in sync with PACK_SAFE_NAMES in scripts/bundle-templates.mjs.
-const RESTORE_NAMES = {
-  _gitignore: ".gitignore",
-  _npmrc: ".npmrc",
-  _npmignore: ".npmignore",
+for (let i = 0; i < argv.length; i++) {
+  const a = argv[i];
+  if (!a.startsWith("--")) positional.push(a);
+  else if (VALUE_OPTIONS.has(a.slice(2))) options[a.slice(2)] = argv[++i];
+  else flags.add(a.slice(2));
+}
+const opt = (key) => options[key];
+const flag = (key) => flags.has(key);
+const [platform, dirArg] = positional;
+if (!["next", "wordpress", "shopify"].includes(platform) || !dirArg) {
+  console.log(`Usage: npm create @goldencomm/baseline@latest <next|wordpress|shopify> <directory> [--figma-file <key|url>]`);
+  process.exit(platform ? 1 : 0);
+}
+const dir = resolve(dirArg);
+const name = basename(dir).toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+if (existsSync(dir) && readdirSync(dir).length) fail(`${dir} exists and is not empty`);
+const registry = (opt("registry") ?? `https://cdn.jsdelivr.net/npm/@goldencomm/baseline-registry@${VERSION}/r`).replace(/\/$/, "");
+const tokensSpec = opt("tokens") ?? `@goldencomm/baseline-tokens@${VERSION}`;
+const figmaFile = opt("figma-file") ?? null;
+const skipInstall = flag("skip-install");
+
+const run = (cmd, cmdArgs, cwd) => {
+  console.log(`\n> ${cmd} ${cmdArgs.join(" ")}`);
+  const r = spawnSync(cmd, cmdArgs, { cwd, stdio: "inherit", shell: process.platform === "win32" });
+  if (r.status !== 0) fail(`${cmd} ${cmdArgs[0]} failed (exit ${r.status})`);
+};
+const npx = process.platform === "win32" ? "npx.cmd" : "npx";
+const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+const readJson = (f) => JSON.parse(readFileSync(f, "utf8"));
+const writeJson = (f, o) => writeFileSync(f, JSON.stringify(o, null, 2) + "\n");
+const template = (sub) => {
+  const p = join(here, "templates", sub);
+  if (!existsSync(p)) fail(`template ${sub} is missing from this package (run its prepack to build templates/)`);
+  return p;
+};
+// workdir: where the project's package.json is (theme/ for WordPress), so CI installs and runs Code Connect there
+const writeCi = (root, workdir) => {
+  const ci = readFileSync(join(template("ci"), "bitbucket-pipelines.yml"), "utf8")
+    .replaceAll("{{PLATFORM}}", platform)
+    .replaceAll("{{WORKDIR}}", workdir);
+  writeFileSync(join(root, "bitbucket-pipelines.yml"), ci);
+};
+const writeBaselineJson = (root, extra = {}) =>
+  writeJson(join(root, "baseline.json"), { name, platform, version: VERSION, figmaFile, ...extra });
+const addScripts = (pkgFile, scripts, devDeps = {}) => {
+  const pkg = readJson(pkgFile);
+  pkg.scripts = { ...(pkg.scripts ?? {}), ...scripts };
+  pkg.devDependencies = { ...(pkg.devDependencies ?? {}), ...devDeps };
+  writeJson(pkgFile, pkg);
+};
+// The icon build needs the active icon set's Iconify package; Core's choice is in the tokens package's Primitives
+// (icons/<set>/active). A client that switches sets installs its package (the CLI names it if it is missing).
+const installActiveIconSet = (projectRoot) => {
+  const prim = join(projectRoot, "node_modules", "@goldencomm", "baseline-tokens", "src", "figma", "primitives.mode-1.json");
+  const icons = readJson(prim).icons ?? {};
+  const set = Object.keys(icons).find((s) => icons[s]?.active?.$value === true);
+  if (!set) fail("no active icon set in the tokens package (icons/<set>/active)");
+  const ICONIFY = { lucide: "lucide", "material-symbols": "material-symbols", phosphor: "ph", remix: "ri", tabler: "tabler" };
+  run(npm, ["install", "--save-dev", `@iconify-json/${ICONIFY[set] ?? set}`], projectRoot);
+};
+const tokensDevDep = () => {
+  // "@goldencomm/baseline-tokens@0.1.0" -> { name: version }; a path or tarball (testing) -> file: spec
+  const m = tokensSpec.match(/^(@goldencomm\/baseline-tokens)@(.+)$/);
+  return m ? { [m[1]]: m[2] } : { "@goldencomm/baseline-tokens": `file:${resolve(tokensSpec)}` };
 };
 
-/** Monorepo mode: the committed files of baselines/<dir>, or null if unavailable. */
-function monorepoSource() {
-  const root = join(REPO_ROOT, "baselines", cfg.dir);
-  if (!existsSync(root)) return null;
-  try {
-    const tracked = execFileSync("git", ["-C", REPO_ROOT, "ls-files", `baselines/${cfg.dir}`], {
-      encoding: "utf8", stdio: ["ignore", "pipe", "ignore"],
-    }).split("\n").filter(Boolean);
-    if (tracked.length === 0) return null;
-    const prefix = `baselines/${cfg.dir}/`;
-    return {
-      mode: "monorepo", root,
-      files: tracked.map((f) => ({ src: f.slice(prefix.length), dest: f.slice(prefix.length) })),
-    };
-  } catch {
-    return null;
+// ---------------------------------------------------------------------------------------------------------------
+if (platform === "next") {
+  if (skipInstall) fail("--skip-install is not available for next: the components are installed with the shadcn CLI");
+  mkdirSync(dirname(dir), { recursive: true });
+  run(npx, ["--yes", `create-next-app@${NEXT_VERSION}`, dir, "--ts", "--tailwind", "--eslint", "--app", "--no-src-dir", "--import-alias", "@/*", "--use-npm", "--yes"], dirname(dir));
+
+  // base: components.json, lib/utils and the dependencies every item needs; its inline token values are replaced below
+  run(npx, ["--yes", SHADCN, "init", `${registry}/base.json`, "--yes", "--no-monorepo"], dir);
+  const cj = join(dir, "components.json");
+  const components = readJson(cj);
+  components.registries = { ...(components.registries ?? {}), "@baseline": `${registry}/{name}.json` };
+  writeJson(cj, components);
+
+  // globals.css imports the project's own token build; shadcn add appends component keyframes after it
+  cpSync(template("next"), dir, { recursive: true });
+
+  // every component and block, default looks only (an extra look would overwrite the default's file, ADR-0031)
+  const index = await (await fetch(`${registry}/registry.json`)).json();
+  const items = index.items.filter((i) => i.name !== "base" && !i.meta?.look).map((i) => `@baseline/${i.name}`);
+  run(npx, ["--yes", SHADCN, "add", ...items, "--yes", "--overwrite"], dir);
+
+  // Code Connect templates beside the components, kept out of the TypeScript build (they import the figma runtime)
+  cpSync(template("code-connect"), join(dir, "components", "ui"), { recursive: true });
+  const tsconfigFile = join(dir, "tsconfig.json");
+  const tsconfig = readJson(tsconfigFile);
+  tsconfig.exclude = [...new Set([...(tsconfig.exclude ?? []), "**/*.figma.ts"])];
+  writeJson(tsconfigFile, tsconfig);
+
+  // tokens: GC Baseline core + this client's overrides -> app/tokens.css, app/text-styles.css, the icon map
+  writeJson(join(dir, "client.tokens.json"), {});
+  addScripts(join(dir, "package.json"), {
+    tokens: "baseline-tokens build --platform next --out app --client client.tokens.json && baseline-tokens icons --platform next --out . --client client.tokens.json",
+  }, tokensDevDep());
+  run(npm, ["install"], dir);
+  run(npm, ["run", "tokens"], dir);
+
+  cpSync(template("skills"), join(dir, ".claude", "skills"), { recursive: true });
+  writeBaselineJson(dir, { registry: `${registry}/{name}.json` });
+  writeCi(dir, ".");
+}
+
+// ---------------------------------------------------------------------------------------------------------------
+if (platform === "wordpress") {
+  cpSync(template("wordpress"), dir, { recursive: true });
+  // the DDEV project takes the site's name
+  const ddev = join(dir, ".ddev", "config.yaml");
+  writeFileSync(ddev, readFileSync(ddev, "utf8").replace(/^name: .*$/m, `name: ${name}`));
+  writeJson(join(dir, "client.tokens.json"), {});
+  addScripts(join(dir, "theme", "package.json"), {
+    tokens: "baseline-tokens build --platform wordpress --out . --client ../client.tokens.json && baseline-tokens icons --platform wordpress --out . --client ../client.tokens.json && npm run build",
+  }, tokensDevDep());
+  if (!skipInstall) {
+    run(npm, ["install"], join(dir, "theme"));
+    installActiveIconSet(join(dir, "theme"));
+    run(npm, ["run", "tokens"], join(dir, "theme"));
   }
-}
-
-/** Bundled mode: the templates/<dir> snapshot shipped in the npm package. */
-function bundledSource() {
-  const root = join(HERE, "templates", cfg.dir);
-  if (!existsSync(root)) return null;
-  const files = [];
-  (function walk(sub) {
-    for (const e of readdirSync(join(root, sub), { withFileTypes: true })) {
-      const rel = sub ? `${sub}/${e.name}` : e.name;
-      if (e.isDirectory()) walk(rel);
-      else files.push({ src: rel, dest: RESTORE_NAMES[e.name] ? rel.slice(0, rel.length - e.name.length) + RESTORE_NAMES[e.name] : rel });
-    }
-  })("");
-  return files.length > 0 ? { mode: "bundled", root, files } : null;
-}
-
-const source = monorepoSource() || bundledSource();
-if (!source) {
-  die(`No template found for "${platform}" — neither the monorepo's baselines/${cfg.dir} nor a bundled templates/${cfg.dir}. If running from a git checkout, run \`node scripts/bundle-templates.mjs\` or use the published @goldencomm/create-baseline package.`);
-}
-
-const target = resolve(process.cwd(), dirFlag || slug);
-if (existsSync(target) && readdirSync(target).length > 0 && !force) {
-  die(`Target ${target} exists and is not empty. Pass --force to scaffold anyway.`);
-}
-
-// ---- helpers ---------------------------------------------------------------
-const tFile = (rel) => join(target, rel);
-const has = (rel) => existsSync(tFile(rel));
-function editJson(rel, fn) {
-  const p = tFile(rel);
-  const json = JSON.parse(readFileSync(p, "utf8"));
-  fn(json);
-  writeFileSync(p, JSON.stringify(json, null, 2) + "\n");
-}
-function patch(rel, replacers) {
-  const p = tFile(rel);
-  let s = readFileSync(p, "utf8");
-  for (const [find, repl] of replacers) s = s.replace(find, repl);
-  writeFileSync(p, s);
-}
-function setReadmeTitle(rel, title) {
-  if (has(rel)) patch(rel, [[/^#[^\n]*/, `# ${title}`]]);
-}
-function rewriteWorkspaceDeps(pkg) {
-  for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
-    const deps = pkg[field];
-    if (!deps) continue;
-    for (const k of Object.keys(deps)) {
-      if (typeof deps[k] === "string" && deps[k].startsWith("workspace:")) deps[k] = dsVersion;
-    }
+  cpSync(template("skills"), join(dir, ".claude", "skills"), { recursive: true });
+  writeBaselineJson(dir);
+  writeCi(dir, "theme");
+}
+
+// ---------------------------------------------------------------------------------------------------------------
+if (platform === "shopify") {
+  cpSync(template("shopify"), dir, { recursive: true });
+  writeJson(join(dir, "client.tokens.json"), {});
+  addScripts(join(dir, "package.json"), {
+    tokens: "baseline-tokens build --platform shopify --out . --client client.tokens.json && baseline-tokens icons --platform shopify --out . --client client.tokens.json",
+  }, tokensDevDep());
+  // repo files Shopify must not upload
+  const ignore = join(dir, ".shopifyignore");
+  writeFileSync(ignore, readFileSync(ignore, "utf8") + "\n# GC Baseline project files\nclient.tokens.json\nbaseline.json\nbitbucket-pipelines.yml\n/^\\.claude\\//\n");
+  if (!skipInstall) {
+    run(npm, ["install"], dir);
+    installActiveIconSet(dir);
+    run(npm, ["run", "tokens"], dir);
   }
+  cpSync(template("skills"), join(dir, ".claude", "skills"), { recursive: true });
+  writeBaselineJson(dir);
+  writeCi(dir, ".");
 }
 
-// ---- copy ------------------------------------------------------------------
-mkdirSync(target, { recursive: true });
-for (const { src, dest } of source.files) {
-  const out = tFile(dest);
-  mkdirSync(dirname(out), { recursive: true });
-  copyFileSync(join(source.root, src), out);
-}
-
-// ---- rewire ----------------------------------------------------------------
-const nextSteps = [];
-
-if (cfg.kind === "npm") {
-  editJson("package.json", (pkg) => {
-    pkg.name = npmName;
-    pkg.description = description;
-    rewriteWorkspaceDeps(pkg);
-    if (platform === "shopify" && pkg.scripts?.dev) {
-      // monorepo watch path no longer exists standalone
-      pkg.scripts.dev = "node --watch-path=node_modules/@goldencomm/ds-core/dist scripts/sync-tokens.mjs";
-    }
-  });
-  setReadmeTitle("README.md", npmName);
-}
-
-if (platform === "shopify" && has("config/settings_schema.json")) {
-  editJson("config/settings_schema.json", (schema) => {
-    const info = Array.isArray(schema) ? schema.find((s) => s.name === "theme_info") : null;
-    if (info) info.theme_name = slug;
-  });
-  nextSteps.push(
-    "Shopify theme works immediately — baseline.css is vendored.",
-    "  Run:  cd " + target + "  &&  shopify theme dev --store your-store.myshopify.com",
-    `  (Once @goldencomm/ds-core is published, 'npm i' enables re-syncing tokens; until then assets/baseline.css is the pinned copy.)`,
-  );
-}
-
-if (platform === "next") {
-  nextSteps.push(
-    `Next.js app depends on @goldencomm/ds-core@${dsVersion} + ds-react@${dsVersion} (npm).`,
-    "  cd " + target + "  &&  npm install  &&  npm run dev",
-  );
-}
-
-if (cfg.kind === "composer") {
-  // 1) drop the monorepo-only bind-mount
-  const bindMount = ".ddev/docker-compose.packages.yaml";
-  if (has(bindMount)) rmSync(tFile(bindMount));
-
-  // 2) composer.json — name/description + require the theme & blocks plugin from VCS
-  editJson("composer.json", (c) => {
-    c.name = composerName;
-    c.description = description;
-    c.repositories = c.repositories || [];
-    c.repositories.push(
-      {
-        type: "package",
-        package: {
-          name: "goldencomm/wp-theme", type: "wordpress-theme", version: "dev-master",
-          source: { url: "https://bitbucket.org/goldencomm/wp-theme.git", type: "git", reference: "master" },
-        },
-      },
-      {
-        type: "package",
-        package: {
-          name: "goldencomm/wp-blocks-plugin", type: "wordpress-plugin", version: "dev-master",
-          source: { url: "https://bitbucket.org/goldencomm/wp-blocks-plugin.git", type: "git", reference: "master" },
-        },
-      },
-    );
-    c.require = c.require || {};
-    c.require["goldencomm/wp-theme"] = "dev-master";
-    c.require["goldencomm/wp-blocks-plugin"] = "dev-master";
-  });
+console.log(`
+GC Baseline ${VERSION}: ${platform} project in ${dir}
 
-  // 3) .ddev project name
-  if (has(".ddev/config.yaml")) patch(".ddev/config.yaml", [[/^name:\s*.*$/m, `name: ${slug}`]]);
-
-  // 4) seed.sh — Composer installs the theme as "wp-theme"; site host follows the ddev name
-  if (has("scripts/seed.sh")) {
-    patch("scripts/seed.sh", [
-      [/baseline-wordpress\.ddev\.site/g, `${slug}.ddev.site`],
-      [/wp theme activate baseline\b/, "wp theme activate wp-theme"],
-    ]);
-  }
-
-  setReadmeTitle("README.md", slug);
-
-  nextSteps.push(
-    "WordPress scaffold rewired to install the theme + blocks plugin via Composer.",
-    "",
-    "  IMPORTANT: goldencomm/wp-theme and goldencomm/wp-blocks-plugin are NOT published",
-    "  as Composer packages yet — `composer install` currently requires monorepo/Bitbucket",
-    "  VCS access (the Phase 6 repo split is still pending). Until then this scaffold only",
-    "  resolves for GoldenComm developers with Bitbucket access + their own auth.json with",
-    "  Composer creds (never copied by the scaffolder — add your own).",
-    "",
-    "  Then:  cd " + target + "  &&  ddev start  &&  ddev composer install  &&  ddev exec bash scripts/seed.sh",
-  );
-}
-
-// ---- report ----------------------------------------------------------------
-console.log(`\n✓ Scaffolded ${platform} baseline → ${target}`);
-console.log(`  name: ${cfg.kind === "composer" ? composerName : npmName}   ds-version: ${dsVersion}   files: ${source.files.length}   (templates: ${source.mode})\n`);
-console.log("Next steps:");
-for (const line of nextSteps) console.log("  " + line);
-console.log("");
+Next steps
+  1. Point client.tokens.json at the client's Figma library: open the project in Claude Code and run the
+     baseline-client-tokens skill with the library URL, then \`npm run tokens\`${platform === "wordpress" ? " (in theme/)" : ""}.
+  2. Set FIGMA_ACCESS_TOKEN (secured) and FIGMA_FILE_KEY in the repository's pipeline variables for Code Connect.
+${platform === "next" ? "  3. npm run dev" : platform === "wordpress" ? "  3. cp auth.json.example auth.json (ACF Pro), ddev start, ddev seed" : "  3. shopify theme dev --store <store>"}
+`);