@multiplatform.one/cli 6.1.0 → 6.4.0

package/src/commands/initApp.spec.ts

@@ -0,0 +1,210 @@
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { initApp } from "./initApp";
+
+const readJson = (path: string) => JSON.parse(readFileSync(path, "utf-8"));
+
+/** Collect dependency ranges by scope for leakage assertions. */
+function depRanges(pkg: {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+}): Record<string, string> {
+  return { ...pkg.dependencies, ...pkg.devDependencies };
+}
+
+describe("initApp generator", () => {
+  let sandbox: string;
+  let previousCwd: string;
+
+  beforeAll(() => {
+    sandbox = mkdtempSync(join(tmpdir(), "mpo-initapp-spec-"));
+    previousCwd = process.cwd();
+    process.chdir(sandbox);
+  });
+
+  afterAll(() => {
+    process.chdir(previousCwd);
+    rmSync(sandbox, { recursive: true, force: true });
+  });
+
+  describe("universal template", () => {
+    const name = "uni-demo";
+    let root: string;
+
+    beforeAll(async () => {
+      await initApp(name, {
+        template: "universal",
+        skipInstall: true,
+        version: "6.1.0",
+        yes: true,
+      });
+      root = join(sandbox, name);
+    });
+
+    it("writes the workspace tree", () => {
+      for (const file of [
+        "package.json",
+        "pnpm-workspace.yaml",
+        "tsconfig.base.json",
+        "oxlintrc.json",
+        "AGENTS.md",
+        "README.md",
+        ".gitignore",
+        ".npmrc",
+        `apps/${name}/package.json`,
+        `apps/${name}/vite.config.ts`,
+        `apps/${name}/app.config.js`,
+        `apps/${name}/tamagui.css`,
+        `apps/${name}/types.d.ts`,
+        `apps/${name}/config/tamagui.config.ts`,
+        `apps/${name}/routes/_layout.tsx`,
+        `apps/${name}/routes/_layout.web.tsx`,
+        `apps/${name}/routes/index.tsx`,
+        `apps/${name}/routes/about.tsx`,
+        `apps/${name}/src/app.ts`,
+        `apps/${name}/polyfills.ts`,
+        `apps/${name}/polyfills.native.ts`,
+        `features/${name}/package.json`,
+        `features/${name}/vitest.config.mjs`,
+        `features/${name}/src/HomeScreen.tsx`,
+        `features/${name}/src/AboutScreen.tsx`,
+        `features/${name}/src/AppLayout.tsx`,
+        `features/${name}/src/ContactForm.tsx`,
+        `features/${name}/src/ContactForm.spec.tsx`,
+        "packages/config/package.json",
+        "packages/i18n/en/common.json",
+        "packages/i18n/es/common.json",
+        "packages/i18n/resources.ts",
+        "packages/themes/tamagui.config.ts",
+        "packages/themes/fonts.ts",
+        "packages/themes/base.ts",
+        "packages/themes/accent.ts",
+        "types/env.d.ts",
+      ]) {
+        expect(existsSync(join(root, file)), `missing ${file}`).toBe(true);
+      }
+    });
+
+    it("restores dotfile names stripped by npm pack", () => {
+      expect(readFileSync(join(root, ".npmrc"), "utf-8")).toContain("node-linker=hoisted");
+      expect(readFileSync(join(root, ".gitignore"), "utf-8")).toContain("node_modules");
+      expect(existsSync(join(root, "npmrc"))).toBe(false);
+      expect(existsSync(join(root, "gitignore"))).toBe(false);
+    });
+
+    it("pins @multiplatform.one/* to semver and locals to workspace:*", () => {
+      for (const pkgPath of [
+        `apps/${name}/package.json`,
+        `features/${name}/package.json`,
+        "packages/i18n/package.json",
+        "packages/themes/package.json",
+      ]) {
+        const ranges = depRanges(readJson(join(root, pkgPath)));
+        for (const [dep, range] of Object.entries(ranges)) {
+          if (dep.startsWith("@multiplatform.one/")) {
+            expect(range, `${pkgPath} ${dep}`).toBe("^6.1.0");
+          } else if (dep.startsWith("@features/") || dep.startsWith("@package/")) {
+            expect(range, `${pkgPath} ${dep}`).toBe("workspace:*");
+          } else {
+            expect(range, `${pkgPath} ${dep} leaked a workspace range`).not.toMatch(/^workspace:/u);
+          }
+        }
+      }
+    });
+
+    it("renders template vars (no placeholders left)", () => {
+      const appPkg = readJson(join(root, `apps/${name}/package.json`));
+      expect(appPkg.name).toBe(`@app/${name}`);
+      const rootPkg = readJson(join(root, "package.json"));
+      expect(rootPkg.name).toBe(name);
+      const appConfig = readFileSync(join(root, `apps/${name}/app.config.js`), "utf-8");
+      expect(appConfig).toContain('name: "UniDemo"');
+      expect(appConfig).toContain("com.unidemo.app");
+      const viteConfig = readFileSync(join(root, `apps/${name}/vite.config.ts`), "utf-8");
+      expect(viteConfig).toContain('key: "UniDemo"');
+      for (const file of [
+        "package.json",
+        "README.md",
+        `apps/${name}/app.config.js`,
+        `features/${name}/src/HomeScreen.tsx`,
+        "packages/i18n/en/common.json",
+      ]) {
+        expect(readFileSync(join(root, file), "utf-8")).not.toMatch(/__NAME(_PASCAL|_APPID)?__/u);
+      }
+    });
+
+    it("wires universal scripts", () => {
+      const rootPkg = readJson(join(root, "package.json"));
+      for (const script of [
+        "dev",
+        "build",
+        "native",
+        "ios",
+        "android",
+        "test",
+        "lint",
+        "typecheck",
+      ]) {
+        expect(rootPkg.scripts[script], `root script ${script}`).toBeDefined();
+      }
+      const appPkg = readJson(join(root, `apps/${name}/package.json`));
+      expect(appPkg.scripts.dev).toContain("one dev");
+      expect(appPkg.scripts.build).toBe("one build");
+      expect(appPkg.scripts["prebuild:native"]).toBe("one prebuild");
+    });
+  });
+
+  describe("app (web-only) template regression", () => {
+    const name = "web-demo";
+    let root: string;
+
+    beforeAll(async () => {
+      await initApp(name, {
+        template: "app",
+        skipInstall: true,
+        version: "6.1.0",
+        yes: true,
+      });
+      root = join(sandbox, name);
+    });
+
+    it("keeps the web-only tree (no universal extras)", () => {
+      for (const file of [
+        "package.json",
+        ".npmrc",
+        ".gitignore",
+        `apps/${name}/vite.config.ts`,
+        `apps/${name}/src/main.tsx`,
+        `features/${name}/src/HomeScreen.tsx`,
+        "packages/config/package.json",
+      ]) {
+        expect(existsSync(join(root, file)), `missing ${file}`).toBe(true);
+      }
+      expect(existsSync(join(root, "packages/i18n"))).toBe(false);
+      expect(existsSync(join(root, "packages/themes"))).toBe(false);
+      expect(existsSync(join(root, `apps/${name}/routes`))).toBe(false);
+    });
+
+    it("keeps semver deps and web scripts", () => {
+      const appPkg = readJson(join(root, `apps/${name}/package.json`));
+      expect(appPkg.dependencies["@multiplatform.one/components"]).toBe("^6.1.0");
+      expect(appPkg.dependencies[`@features/${name}`]).toBe("workspace:*");
+      expect(appPkg.scripts.dev).toBe("vite");
+    });
+  });
+
+  it("rejects invalid names", async () => {
+    await expect(
+      initApp("Bad Name", { template: "app", skipInstall: true, yes: true }),
+    ).rejects.toThrow(/Invalid project name/u);
+  });
+
+  it("refuses to scaffold into a non-empty directory", async () => {
+    await initApp("occupied", { template: "app", skipInstall: true, yes: true });
+    await expect(
+      initApp("occupied", { template: "app", skipInstall: true, yes: true }),
+    ).rejects.toThrow(/already exists and is not empty/u);
+  });
+});

package/src/commands/initApp.ts

@@ -0,0 +1,274 @@
+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";
+
+export interface InitAppOptions {
+  /** Skip pnpm install (useful for CI / dry scaffolding). */
+  skipInstall?: boolean;
+  /** Pin @multiplatform.one/* to this semver range. Default: ^<cli version>. */
+  version?: string;
+  /** Project template. When omitted: prompt (interactive) or "universal". */
+  template?: InitAppTemplate;
+  /** Accept defaults instead of prompting (non-interactive / CI). */
+  yes?: boolean;
+}
+
+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("");
+}
+
+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;
+}
+
+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 {
+  template: InitAppTemplate;
+  cliVersion: string;
+  name: string;
+  mpoVersion: string;
+}
+
+export const PROVENANCE_FILE = ".mpo.json";
+
+export function writeProvenance(targetDir: string, provenance: MpoProvenance): void {
+  writeFileSync(join(targetDir, PROVENANCE_FILE), `${JSON.stringify(provenance, 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}`,
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+function templatesRoot(template: InitAppTemplate): string {
+  return resolve(dirname(fileURLToPath(import.meta.url)), "../../templates", template);
+}
+
+/**
+ * npm always strips .gitignore / .npmrc 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",
+};
+
+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"]);
+
+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));
+  }
+}
+
+async function resolveTemplate(options: InitAppOptions): Promise<InitAppTemplate> {
+  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 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)" : "web-only";
+  console.log(`\nScaffolding ${label} project at ${targetDir}`);
+  console.log(`  apps/${name}`);
+  console.log(`  features/${name}`);
+  console.log(`  packages/config`);
+  if (template === "universal") {
+    console.log(`  packages/i18n`);
+    console.log(`  packages/themes`);
+  }
+  console.log(`  @multiplatform.one/* → ${vars.MPO_VERSION}\n`);
+
+  writeTree(templatesRoot(template), targetDir, vars);
+  writeProvenance(targetDir, {
+    template,
+    cliVersion: cliVersion() ?? "0.0.0",
+    name,
+    mpoVersion: vars.MPO_VERSION,
+  });
+
+  if (!options.skipInstall) {
+    console.log("Installing dependencies...");
+    await spawn("pnpm", ["install"], {
+      cwd: targetDir,
+      stdio: "inherit",
+    });
+  } else {
+    console.log("Skipped pnpm install (--skip-install).");
+  }
+
+  console.log(`\n✅ Project created at ${targetDir}`);
+  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");
+  }
+  console.log("\nThis project consumes published @multiplatform.one/* packages.");
+  console.log("It is not a fork of the multiplatform.one monorepo.");
+}