@multiplatform.one/cli 7.10.0 → 7.15.0

package/src/commands/initApp.ts

@@ -1,706 +0,0 @@
-import {
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  readdirSync,
-  writeFileSync,
-} from "node:fs";
-import { dirname, extname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import inquirer from "inquirer";
-import spawn from "nano-spawn";
-
-/**
- * Consumer project templates:
- *   - "universal": one-based app serving web + iOS + Android from one codebase
- *     (apps/<name> + features/<name> + packages/{config,i18n,themes})
- *   - "app": web-only Vite + React shell
- *     (apps/<name> + features/<name> + packages/config)
- */
-export type InitAppTemplate = "universal" | "app";
-
-/**
- * The provenance template domain: the scaffold templates plus "none" for
- * ADOPTED projects (`mpo adopt`) — existing repos that were never scaffolded.
- * A "none" scaffold is the selected piece fragments overlaid on an EMPTY
- * tree (no universal/app base), which is exactly the tool-owned surface of
- * an adopted project.
- */
-export type ProvenanceTemplate = InitAppTemplate | "none";
-
-/**
- * Optional composable pieces overlaid onto the base template (additive
- * fragments under templates/pieces/<piece>/ — the inverse of the old
- * cookiecutter KEEP_SERVICES/KEEP_PLATFORMS removal hook). Keep sorted:
- * pieces are recorded sorted in provenance and overlaid in this order.
- */
-export const INIT_APP_PIECES = [
-  "frappe",
-  "gnome",
-  "keycloak",
-  "tauri",
-  "vscode",
-  "webext",
-] as const;
-export type InitAppPiece = (typeof INIT_APP_PIECES)[number];
-
-const PIECE_DESCRIPTIONS: Record<InitAppPiece, string> = {
-  frappe: "Frappe backend wiring (env keys, provider, docker compose bench)",
-  gnome: "GNOME desktop target (GTK4/GJS via react-gnome — native widgets, no webview)",
-  keycloak: "Keycloak auth wiring (env keys, provider, docker compose + realm)",
-  tauri: "Tauri desktop target (src-tauri skeleton — webview shell, Rust toolchain)",
-  vscode: "VS Code extension target (extension host + Tamagui webview)",
-  webext: "Browser extension target (MV3 popup + background)",
-};
-
-export interface InitAppOptions {
-  /** Skip pnpm install (useful for CI / dry scaffolding). */
-  skipInstall?: boolean;
-  /** Skip git init + scaffold commit (mpo update baselines, nested dirs). */
-  skipGit?: boolean;
-  /** Pin @multiplatform.one/* to this semver range. Default: ^<cli version>. */
-  version?: string;
-  /**
-   * Project template. When omitted: prompt (interactive) or "universal".
-   * "none" scaffolds ONLY the selected pieces onto an empty tree (the
-   * `--pieces-only` flag) — `mpo update` uses it to rebuild the merge
-   * baselines of adopted projects.
-   */
-  template?: ProvenanceTemplate;
-  /** Accept defaults instead of prompting (non-interactive / CI). */
-  yes?: boolean;
-  /**
-   * Composable pieces overlaid onto the base template. When omitted:
-   * checkbox prompt (interactive) or none (--yes / non-TTY).
-   */
-  pieces?: InitAppPiece[];
-}
-
-type TemplateVars = {
-  NAME: string;
-  NAME_PASCAL: string;
-  /** Lowercase alphanumeric form for iOS bundle ids / Android packages. */
-  NAME_APPID: string;
-  MPO_VERSION: string;
-  YEAR: string;
-};
-
-function toPascalCase(name: string): string {
-  return name
-    .split(/[-_\s]+/)
-    .filter(Boolean)
-    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-    .join("");
-}
-
-export function validateName(name: string): string {
-  const trimmed = name.trim();
-  if (!trimmed) {
-    throw new Error("Project name is required");
-  }
-  if (!/^[a-z][a-z0-9-]*$/.test(trimmed)) {
-    throw new Error(
-      `Invalid project name "${trimmed}". Use lowercase letters, numbers, and hyphens (e.g. my-app).`,
-    );
-  }
-  return trimmed;
-}
-
-/** Root package.json name with any @scope/ prefix stripped (adopt +
- *  update-bootstrap provenance name derivation). */
-export function packageJsonName(projectDir: string): string | undefined {
-  try {
-    const pkg = JSON.parse(readFileSync(join(projectDir, "package.json"), "utf-8")) as {
-      name?: string;
-    };
-    return pkg.name?.replace(/^@[^/]+\//u, "");
-  } catch {
-    return undefined;
-  }
-}
-
-function resolveMpoVersion(explicit?: string): string {
-  if (explicit) {
-    return explicit.startsWith("^") || explicit.startsWith("~") || explicit === "*"
-      ? explicit
-      : `^${explicit}`;
-  }
-  const version = cliVersion();
-  return version ? `^${version}` : "^6.1.0";
-}
-
-export function cliVersion(): string | undefined {
-  try {
-    const pkgPath = resolve(dirname(fileURLToPath(import.meta.url)), "../../package.json");
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8")) as { version?: string };
-    return pkg.version;
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * Scaffold provenance (the copier-answers equivalent): which template, which
- * CLI version and which vars produced this project. `mpo update` regenerates
- * the ORIGINAL scaffold from this record to use as the merge base for a
- * three-way template update.
- */
-export interface MpoProvenance {
-  /** "none" = adopted project (`mpo adopt`): pieces only, no base template. */
-  template: ProvenanceTemplate;
-  cliVersion: string;
-  name: string;
-  mpoVersion: string;
-  /** Composable pieces overlaid at init time (sorted). */
-  pieces: InitAppPiece[];
-  /**
-   * false = adopted but never reconciled: `mpo adopt` wrote provenance
-   * without touching any project file, so no tool-owned content exists yet.
-   * The first `mpo update` merges the piece baseline from an EMPTY base
-   * (surfacing real diffs against hand-copied files) and then clears the
-   * flag. Absent/true = the tree carries the recorded scaffold.
-   */
-  reconciled?: boolean;
-}
-
-export const PROVENANCE_FILE = ".mpo.json";
-
-export function writeProvenance(targetDir: string, provenance: MpoProvenance): void {
-  writeFileSync(
-    join(targetDir, PROVENANCE_FILE),
-    `${JSON.stringify({ ...provenance, pieces: [...provenance.pieces].sort() }, null, 2)}\n`,
-  );
-}
-
-export function readProvenance(projectDir: string): MpoProvenance | undefined {
-  const file = join(projectDir, PROVENANCE_FILE);
-  if (!existsSync(file)) return undefined;
-  try {
-    const raw = JSON.parse(readFileSync(file, "utf-8")) as Partial<MpoProvenance>;
-    if (!raw.template || !raw.cliVersion || !raw.name) return undefined;
-    return {
-      template: raw.template,
-      cliVersion: raw.cliVersion,
-      name: raw.name,
-      mpoVersion: raw.mpoVersion ?? `^${raw.cliVersion}`,
-      // Scaffolds from pre-piece CLIs (≤6.4.x) have no pieces field.
-      pieces: Array.isArray(raw.pieces) ? [...(raw.pieces as InitAppPiece[])].sort() : [],
-      // Only adopted-but-unreconciled provenance carries the flag.
-      ...(raw.reconciled === false ? { reconciled: false } : {}),
-    };
-  } catch {
-    return undefined;
-  }
-}
-
-function templatesRoot(template: InitAppTemplate): string {
-  return resolve(dirname(fileURLToPath(import.meta.url)), "../../templates", template);
-}
-
-function piecesRoot(piece: InitAppPiece): string {
-  return resolve(dirname(fileURLToPath(import.meta.url)), "../../templates/pieces", piece);
-}
-
-/**
- * Fragment source dirs for a piece + template: shared/ applies to every
- * template, <template>/ only to that one. A piece supports a template when
- * at least one of the two exists. Adopted projects (template "none") use the
- * universal fragment set — pieces ship universal-layout fragments
- * (apps/<name>/…), which is the layout adopted repos follow.
- */
-function pieceFragmentDirs(piece: InitAppPiece, template: ProvenanceTemplate): string[] {
-  const effective: InitAppTemplate = template === "none" ? "universal" : template;
-  return [join(piecesRoot(piece), "shared"), join(piecesRoot(piece), effective)].filter((dir) =>
-    existsSync(dir),
-  );
-}
-
-/**
- * npm always strips .gitignore / .npmrc (and newer npms .env*) from published
- * tarballs, so the template stores them without the leading dot; restore it
- * at scaffold time.
- */
-const DOTFILE_NAMES: Record<string, string> = {
-  gitignore: ".gitignore",
-  npmrc: ".npmrc",
-  "env.example": ".env.example",
-};
-
-function render(content: string, vars: TemplateVars): string {
-  return content
-    .replaceAll("__NAME_PASCAL__", vars.NAME_PASCAL)
-    .replaceAll("__NAME_APPID__", vars.NAME_APPID)
-    .replaceAll("__NAME__", vars.NAME)
-    .replaceAll("__MPO_VERSION__", vars.MPO_VERSION)
-    .replaceAll("__YEAR__", vars.YEAR);
-}
-
-/**
- * Assets copied byte-for-byte — running them through the utf-8 render pass
- * would corrupt them (fonts ship in the templates for LC-33 stable mount).
- */
-const BINARY_EXTENSIONS = new Set([
-  ".woff2",
-  ".woff",
-  ".ttf",
-  ".otf",
-  ".png",
-  ".jpg",
-  ".ico",
-  ".icns",
-]);
-
-function writeTree(srcDir: string, destDir: string, vars: TemplateVars): void {
-  if (!existsSync(srcDir)) {
-    throw new Error(`Project template missing at ${srcDir}`);
-  }
-  mkdirSync(destDir, { recursive: true });
-  for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
-    const from = join(srcDir, entry.name);
-    // Template files may use __NAME__ in path segments.
-    const toName = render(DOTFILE_NAMES[entry.name] ?? entry.name, vars);
-    const to = join(destDir, toName);
-    if (entry.isDirectory()) {
-      writeTree(from, to, vars);
-      continue;
-    }
-    if (BINARY_EXTENSIONS.has(extname(entry.name).toLowerCase())) {
-      copyFileSync(from, to);
-      continue;
-    }
-    const raw = readFileSync(from, "utf-8");
-    writeFileSync(to, render(raw, vars));
-  }
-}
-
-// ── piece fragment overlay ─────────────────────────────────────────
-
-type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };
-
-function isJsonObject(value: JsonValue | undefined): value is { [key: string]: JsonValue } {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-/**
- * Deep-merge for JSON partials: objects merge recursively (fragment keys
- * append after base keys, so e.g. package.json script order stays stable),
- * arrays union (base order first — config.json public keys accumulate
- * across pieces), scalars/type-mismatches take the fragment value.
- */
-export function mergeJsonValues(base: JsonValue, fragment: JsonValue): JsonValue {
-  if (Array.isArray(base) && Array.isArray(fragment)) {
-    const merged = [...base];
-    const seen = new Set(base.map((item) => JSON.stringify(item)));
-    for (const item of fragment) {
-      const key = JSON.stringify(item);
-      if (seen.has(key)) continue;
-      seen.add(key);
-      merged.push(item);
-    }
-    return merged;
-  }
-  if (isJsonObject(base) && isJsonObject(fragment)) {
-    const merged: { [key: string]: JsonValue } = { ...base };
-    for (const [key, value] of Object.entries(fragment)) {
-      merged[key] = key in merged ? mergeJsonValues(merged[key]!, value) : value;
-    }
-    return merged;
-  }
-  return fragment;
-}
-
-/** Dependency maps stay alphabetically sorted after fragment merges (the
- *  base templates are sorted; multiple pieces appending must not depend on
- *  overlay order for the final byte content). */
-const SORTED_DEPENDENCY_FIELDS = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies",
-];
-
-function sortDependencyFields(value: JsonValue): JsonValue {
-  if (!isJsonObject(value)) return value;
-  const result = { ...value };
-  for (const field of SORTED_DEPENDENCY_FIELDS) {
-    const deps = result[field];
-    if (!isJsonObject(deps)) continue;
-    result[field] = Object.fromEntries(
-      Object.entries(deps).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)),
-    );
-  }
-  return result;
-}
-
-/**
- * Apply a rendered `<target>.partial` fragment onto the target file:
- *   - `.json` targets deep-merge (see mergeJsonValues); package.json-style
- *     dependency maps are re-sorted for deterministic output
- *   - everything else appends as a text block separated by a blank line
- * Missing targets are created from the fragment alone.
- */
-function applyPartial(targetPath: string, renderedFragment: string): void {
-  if (targetPath.endsWith(".json")) {
-    const fragment = JSON.parse(renderedFragment) as JsonValue;
-    const base = existsSync(targetPath)
-      ? (JSON.parse(readFileSync(targetPath, "utf-8")) as JsonValue)
-      : undefined;
-    const merged = sortDependencyFields(
-      base === undefined ? fragment : mergeJsonValues(base, fragment),
-    );
-    writeFileSync(targetPath, `${JSON.stringify(merged, null, 2)}\n`);
-    return;
-  }
-  const block = `${renderedFragment.replace(/^\n+/u, "").replace(/\n+$/u, "")}\n`;
-  if (!existsSync(targetPath)) {
-    writeFileSync(targetPath, block);
-    return;
-  }
-  const existing = readFileSync(targetPath, "utf-8").replace(/\n+$/u, "");
-  writeFileSync(targetPath, `${existing}\n\n${block}`);
-}
-
-const PARTIAL_SUFFIX = ".partial";
-
-/**
- * Overlay a piece fragment tree onto the scaffold: regular files render and
- * overwrite, `<target>.partial` files merge into (or create) their target
- * (deep-merge for .json, append for text — see applyPartial).
- */
-function overlayTree(srcDir: string, destDir: string, vars: TemplateVars): void {
-  mkdirSync(destDir, { recursive: true });
-  for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
-    const from = join(srcDir, entry.name);
-    if (entry.isDirectory()) {
-      overlayTree(from, join(destDir, render(DOTFILE_NAMES[entry.name] ?? entry.name, vars)), vars);
-      continue;
-    }
-    if (entry.name.endsWith(PARTIAL_SUFFIX)) {
-      const targetName = entry.name.slice(0, -PARTIAL_SUFFIX.length);
-      const toName = render(DOTFILE_NAMES[targetName] ?? targetName, vars);
-      applyPartial(join(destDir, toName), render(readFileSync(from, "utf-8"), vars));
-      continue;
-    }
-    const toName = render(DOTFILE_NAMES[entry.name] ?? entry.name, vars);
-    const to = join(destDir, toName);
-    if (BINARY_EXTENSIONS.has(extname(entry.name).toLowerCase())) {
-      copyFileSync(from, to);
-      continue;
-    }
-    writeFileSync(to, render(readFileSync(from, "utf-8"), vars));
-  }
-}
-
-/**
- * Validate + canonicalize a piece selection for a template: unknown names
- * throw, duplicates collapse, order is always sorted (provenance and overlay
- * order must be deterministic), and every piece must ship a fragment for the
- * chosen template.
- */
-export function normalizePieces(pieces: string[], template: ProvenanceTemplate): InitAppPiece[] {
-  const known = new Set<string>(INIT_APP_PIECES);
-  const normalized = [...new Set(pieces)].sort() as InitAppPiece[];
-  for (const piece of normalized) {
-    if (!known.has(piece)) {
-      throw new Error(`Unknown piece "${piece}". Available pieces: ${INIT_APP_PIECES.join(", ")}`);
-    }
-    if (pieceFragmentDirs(piece, template).length === 0) {
-      throw new Error(
-        `Piece "${piece}" is not available for the ${template} template ` +
-          "(pieces currently target the universal template)",
-      );
-    }
-  }
-  return normalized;
-}
-
-/** Pieces that can be offered for a template (fragment exists for it). */
-export function availablePieces(template: ProvenanceTemplate): InitAppPiece[] {
-  return INIT_APP_PIECES.filter((piece) => pieceFragmentDirs(piece, template).length > 0);
-}
-
-/** Human-readable piece summaries (adopt + init prompts). */
-export function pieceDescription(piece: InitAppPiece): string {
-  return PIECE_DESCRIPTIONS[piece];
-}
-
-async function resolvePieces(
-  options: InitAppOptions,
-  template: ProvenanceTemplate,
-): Promise<InitAppPiece[]> {
-  if (options.pieces) return normalizePieces(options.pieces, template);
-  if (options.yes || !process.stdout.isTTY) return [];
-  const choices = availablePieces(template);
-  if (choices.length === 0) return [];
-  const result = await inquirer.prompt([
-    {
-      message: "Add optional pieces? (space to toggle, enter to confirm)",
-      name: "pieces",
-      type: "checkbox",
-      choices: choices.map((piece) => ({
-        name: `${piece} — ${PIECE_DESCRIPTIONS[piece]}`,
-        value: piece,
-        checked: false,
-      })),
-    },
-  ]);
-  return normalizePieces(result.pieces as string[], template);
-}
-
-// ── app.ts composition (frappe / keycloak provider wiring) ─────────
-
-/**
- * Generate apps/<name>/src/app.ts for the selected backend pieces instead of
- * storing 2^n template variants: each selected provider adds one createApp
- * key (frappe/keycloak read their runtime settings from the packages/config
- * public env keys their fragments register). Only called when at least one
- * provider piece is selected — the base template file stays otherwise.
- */
-export function composeAppTs(pieces: InitAppPiece[]): string {
-  const frappe = pieces.includes("frappe");
-  const keycloak = pieces.includes("keycloak");
-  const lines: string[] = ['import { createApp } from "@multiplatform.one/core";'];
-  if (frappe || keycloak) {
-    lines.push('import { config } from "@multiplatform.one/platform";');
-  }
-  lines.push('import { themeConfig } from "@package/themes";');
-  lines.push(
-    "",
-    "/**",
-    " * App-wide provider stack. Providers below were enabled by the pieces",
-    " * selected at `mpo init` time — see CreateAppConfig in",
-    " * @multiplatform.one/core for everything else that can be wired here",
-    " * (tanstack, web3, custom providers).",
-    " */",
-    "export const { AppProvider, useAppConfig, withApp } = createApp({",
-    "  theme: themeConfig,",
-  );
-  if (frappe) {
-    lines.push(
-      "  // Frappe backend (mpo init --frappe): FrappeProvider mounts when",
-      "  // FRAPPE_ENABLED=1 (a packages/config public env key, loaded from",
-      "  // .env — see .env.example). FRAPPE_URL overrides the bench URL",
-      "  // (default: BASE_URL, then http://localhost:8000);",
-      "  // docker/compose.frappe.yaml runs a dev bench.",
-      '  frappe: { baseURL: config.get("FRAPPE_URL") },',
-    );
-  }
-  if (keycloak) {
-    lines.push(
-      "  // Keycloak auth (mpo init --keycloak): KeycloakProvider mounts when",
-      "  // KEYCLOAK_ENABLED=1. Realm/client settings come from the KEYCLOAK_*",
-      "  // env keys (packages/config, .env.example);",
-      "  // docker/compose.keycloak.yaml runs a dev server with an imported",
-      "  // realm.",
-      '  keycloak: { baseUrl: config.get("KEYCLOAK_BASE_URL") },',
-    );
-  }
-  lines.push("});", "");
-  return lines.join("\n");
-}
-
-async function resolveTemplate(options: InitAppOptions): Promise<ProvenanceTemplate> {
-  if (options.template) return options.template;
-  if (options.yes || !process.stdout.isTTY) return "universal";
-  const result = await inquirer.prompt([
-    {
-      message: "Which platforms should this project target?",
-      name: "template",
-      type: "list",
-      choices: [
-        { name: "Universal — web + iOS + Android (one)", value: "universal" },
-        { name: "Web only — Vite + React", value: "app" },
-      ],
-      default: "universal",
-    },
-  ]);
-  return result.template as InitAppTemplate;
-}
-
-/**
- * Scaffold a consumer project (universal by default, web-only with
- * template: "app") that depends on @multiplatform.one/* at semver ranges
- * (never workspace:*). This is NOT a monorepo fork.
- */
-export async function initApp(
-  nameArg: string | undefined,
-  options: InitAppOptions = {},
-): Promise<void> {
-  let projectName = nameArg;
-  if (!projectName) {
-    if (options.yes || !process.stdout.isTTY) {
-      projectName = "my-app";
-    } else {
-      const result = await inquirer.prompt([
-        {
-          message: "What is the app name?",
-          name: "name",
-          type: "input",
-          default: "my-app",
-        },
-      ]);
-      projectName = result.name as string;
-    }
-  }
-
-  const name = validateName(projectName);
-  const template = await resolveTemplate(options);
-  const pieces = await resolvePieces(options, template);
-  if (template === "none" && pieces.length === 0) {
-    throw new Error(
-      "A pieces-only scaffold needs at least one piece " +
-        `(${INIT_APP_PIECES.map((piece) => `--${piece}`).join(", ")})`,
-    );
-  }
-  const targetDir = resolve(name);
-
-  if (existsSync(targetDir)) {
-    const entries = readdirSync(targetDir);
-    if (entries.length > 0) {
-      throw new Error(`Directory "${targetDir}" already exists and is not empty`);
-    }
-  }
-
-  const vars: TemplateVars = {
-    NAME: name,
-    NAME_PASCAL: toPascalCase(name),
-    NAME_APPID: name.replaceAll("-", ""),
-    MPO_VERSION: resolveMpoVersion(options.version),
-    YEAR: String(new Date().getFullYear()),
-  };
-
-  const label =
-    template === "universal"
-      ? "universal (web + iOS + Android)"
-      : template === "app"
-        ? "web-only"
-        : "pieces-only (adopted-project baseline)";
-  console.log(`\nScaffolding ${label} project at ${targetDir}`);
-  if (template !== "none") {
-    console.log(`  apps/${name}`);
-    console.log(`  features/${name}`);
-    console.log(`  packages/config`);
-  }
-  if (template === "universal") {
-    console.log(`  packages/i18n`);
-    console.log(`  packages/themes`);
-  }
-  if (pieces.length) {
-    console.log(`  pieces: ${pieces.join(", ")}`);
-  }
-  console.log(`  @multiplatform.one/* → ${vars.MPO_VERSION}\n`);
-
-  // "none" (adopted-project baselines) overlays pieces on an EMPTY tree —
-  // there is no base template to write.
-  if (template === "none") {
-    mkdirSync(targetDir, { recursive: true });
-  } else {
-    writeTree(templatesRoot(template), targetDir, vars);
-  }
-  // Pieces overlay AFTER the base template, in sorted order (normalizePieces)
-  // so repeated scaffolds are byte-identical — mpo update regenerates these
-  // exact trees as merge baselines.
-  for (const piece of pieces) {
-    for (const fragmentDir of pieceFragmentDirs(piece, template)) {
-      overlayTree(fragmentDir, targetDir, vars);
-    }
-  }
-  // Backend providers are wired by generating src/app.ts from the selection
-  // (not by stacking file overwrites per combination).
-  if (pieces.includes("frappe") || pieces.includes("keycloak")) {
-    // Pieces-only trees have no base template dirs — create the path.
-    mkdirSync(join(targetDir, "apps", name, "src"), { recursive: true });
-    writeFileSync(join(targetDir, "apps", name, "src/app.ts"), composeAppTs(pieces));
-  }
-  writeProvenance(targetDir, {
-    template,
-    cliVersion: cliVersion() ?? "0.0.0",
-    name,
-    mpoVersion: vars.MPO_VERSION,
-    pieces,
-  });
-
-  // Initialize git with a scaffold commit (unless already inside a repo —
-  // e.g. scaffolding into an existing project dir). `mpo update` needs the
-  // scaffold as a committed baseline to merge on top of.
-  let scaffoldCommitted = false;
-  if (!options.skipGit) {
-    const insideRepo = await spawn("git", ["rev-parse", "--is-inside-work-tree"], {
-      cwd: targetDir,
-    }).then(
-      () => true,
-      () => false,
-    );
-    if (!insideRepo) {
-      const label =
-        template === "universal" ? "universal" : template === "app" ? "web-only" : "pieces-only";
-      await spawn("git", ["init", "--quiet"], { cwd: targetDir });
-      await spawn("git", ["add", "-A"], { cwd: targetDir });
-      scaffoldCommitted = await spawn(
-        "git",
-        ["commit", "--quiet", "-m", `feat: scaffold ${label} multiplatform.one app (mpo init)`],
-        { cwd: targetDir },
-      ).then(
-        () => true,
-        () => {
-          console.warn("⚠️  git commit failed (missing git identity?) — repo left staged.");
-          return false;
-        },
-      );
-    }
-  }
-
-  // Pieces-only trees are merge baselines, not runnable projects — never
-  // install into them.
-  if (!options.skipInstall && template !== "none") {
-    console.log("Installing dependencies...");
-    await spawn("pnpm", ["install"], {
-      cwd: targetDir,
-      stdio: "inherit",
-    });
-    // The lockfile belongs to the scaffold — fold it into the scaffold
-    // commit so a fresh init is immediately clean.
-    if (scaffoldCommitted) {
-      await spawn("git", ["add", "--", "pnpm-lock.yaml"], { cwd: targetDir })
-        .then(() => spawn("git", ["commit", "--amend", "--no-edit", "--quiet"], { cwd: targetDir }))
-        .catch(() => {});
-    }
-  } else if (options.skipInstall) {
-    console.log("Skipped pnpm install (--skip-install).");
-  }
-
-  console.log(`\n✅ Project created at ${targetDir}`);
-  if (template === "none") {
-    console.log("\nPieces-only tree (adopted-project baseline) — not a runnable project.");
-    return;
-  }
-  console.log("\nNext steps:");
-  console.log(`  cd ${name}`);
-  if (options.skipInstall) console.log("  pnpm install");
-  console.log("  pnpm dev        # web dev server");
-  if (template === "universal") {
-    console.log("  pnpm ios        # iOS (requires pnpm dev in another terminal)");
-    console.log("  pnpm android    # Android");
-  }
-  if (pieces.includes("frappe")) {
-    console.log("  docker compose -f docker/compose.frappe.yaml up -d   # dev bench (see README)");
-  }
-  if (pieces.includes("keycloak")) {
-    console.log("  docker compose -f docker/compose.keycloak.yaml up -d # dev keycloak");
-  }
-  if (pieces.includes("gnome")) {
-    console.log("  pnpm gnome       # GTK4 desktop app (requires gjs + gtk4 — see README)");
-  }
-  if (pieces.includes("tauri")) {
-    console.log("  pnpm tauri:dev   # Tauri desktop app (requires the Rust toolchain)");
-  }
-  if (pieces.includes("vscode")) {
-    console.log("  pnpm build:vscode  # stage the VS Code extension into apps dist-vscode/");
-  }
-  if (pieces.includes("webext")) {
-    console.log("  pnpm build:webext  # stage the browser extension into apps dist-webext/");
-  }
-  console.log("\nThis project consumes published @multiplatform.one/* packages.");
-  console.log("It is not a fork of the multiplatform.one monorepo.");
-}