@multiplatform.one/cli 6.1.0 → 6.4.0

package/src/commands/updateApp.ts

@@ -0,0 +1,277 @@
+/**
+ * `mpo update` for scaffolded consumer projects — the modern successor of
+ * the old cookiecutter flow (init a fresh project, swap your .git in, merge
+ * your changes on top), rebuilt with a TRUE three-way merge:
+ *
+ *   base  = the ORIGINAL scaffold, regenerated from the CLI version recorded
+ *           in .mpo.json at init time (published CLIs ship their templates,
+ *           so `pnpm dlx @multiplatform.one/cli@<old> init` reproduces it)
+ *   ours  = the project's HEAD (all your custom changes)
+ *   theirs= a fresh scaffold from the CURRENT CLI version
+ *
+ * `git merge-tree --write-tree --merge-base=<base>` merges template
+ * evolution with your customizations; conflicts land in the worktree with
+ * normal conflict markers. An `.updateignore` file (one pathspec per line)
+ * pins matching paths to your HEAD version, exactly like the old script.
+ */
+
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import spawn from "nano-spawn";
+import { cliVersion, initApp, readProvenance, writeProvenance } from "./initApp";
+
+export interface UpdateAppOptions {
+  /** Skip pnpm install after the merge. */
+  skipInstall?: boolean;
+  /** Override the semver range written for @multiplatform.one/* deps. */
+  version?: string;
+}
+
+async function git(projectDir: string, args: string[], env?: Record<string, string>) {
+  return spawn("git", args, {
+    cwd: projectDir,
+    env: env ? { ...process.env, ...env } : undefined,
+  });
+}
+
+async function gitOut(projectDir: string, args: string[], env?: Record<string, string>) {
+  const result = await git(projectDir, args, env);
+  return result.stdout.trim();
+}
+
+/** Import a directory tree into the project's object database and return a
+ *  root-less commit for it (temp index; the worktree is never touched). */
+async function commitTreeFromDir(
+  projectDir: string,
+  dir: string,
+  message: string,
+  parent?: string,
+): Promise<string> {
+  const indexFile = join(mkdtempSync(join(tmpdir(), "mpo-index-")), "index");
+  const env = { GIT_INDEX_FILE: indexFile, GIT_WORK_TREE: dir };
+  await git(projectDir, ["add", "-A", "--force", "--", "."], env);
+  const tree = await gitOut(projectDir, ["write-tree"], env);
+  const commitArgs = parent
+    ? ["commit-tree", tree, "-p", parent, "-m", message]
+    : ["commit-tree", tree, "-m", message];
+  const commit = await gitOut(projectDir, commitArgs);
+  rmSync(indexFile, { force: true });
+  return commit;
+}
+
+/** Scaffold a project with a specific published CLI version into tmp and
+ *  return the generated project dir. Falls back to the local generator when
+ *  the requested version matches the running CLI (or dlx fails). */
+async function scaffoldBaseline(
+  version: string,
+  name: string,
+  template: "universal" | "app",
+  mpoVersion: string,
+): Promise<{ dir: string; cleanup: () => void }> {
+  const parent = mkdtempSync(join(tmpdir(), "mpo-update-"));
+  const cleanup = () => rmSync(parent, { recursive: true, force: true });
+  const current = cliVersion();
+  const templateFlag = template === "app" ? ["--web"] : ["--universal"];
+  if (version !== current) {
+    try {
+      await spawn(
+        "pnpm",
+        [
+          "--package",
+          `@multiplatform.one/cli@${version}`,
+          "dlx",
+          "mpo",
+          "init",
+          name,
+          "--yes",
+          "--skip-install",
+          "--mpo-version",
+          mpoVersion,
+          ...templateFlag,
+        ],
+        { cwd: parent, stdio: "inherit" },
+      );
+      const dir = join(parent, name);
+      if (existsSync(join(dir, "package.json"))) return { dir, cleanup };
+      console.warn(`⚠️  dlx scaffold for @multiplatform.one/cli@${version} produced no project;`);
+    } catch {
+      console.warn(
+        `⚠️  could not scaffold baseline with @multiplatform.one/cli@${version} (network?);`,
+      );
+    }
+    console.warn("   falling back to the current CLI's template as the merge base.");
+  }
+  const previousCwd = process.cwd();
+  process.chdir(parent);
+  try {
+    await initApp(name, {
+      skipInstall: true,
+      yes: true,
+      template,
+      version: mpoVersion,
+    });
+  } finally {
+    process.chdir(previousCwd);
+  }
+  return { dir: join(parent, name), cleanup };
+}
+
+export async function updateApp(options: UpdateAppOptions = {}): Promise<void> {
+  const projectDir = await gitOut(process.cwd(), ["rev-parse", "--show-toplevel"]).catch(() => {
+    throw new Error("mpo update must run inside a git repository");
+  });
+
+  // Clean tree required — the merge lands in the worktree.
+  await git(projectDir, ["diff", "--quiet"]).catch(() => {
+    throw new Error("mpo update requires a clean working tree (unstaged changes present)");
+  });
+  await git(projectDir, ["diff", "--cached", "--quiet"]).catch(() => {
+    throw new Error("mpo update requires a clean working tree (staged changes present)");
+  });
+
+  const provenance = readProvenance(projectDir);
+  if (!provenance) {
+    throw new Error(
+      ".mpo.json not found — this project predates scaffold provenance. " +
+        "Create it with { template, cliVersion, name } matching how the project " +
+        "was generated (cliVersion = the @multiplatform.one/cli that scaffolded it), " +
+        "then re-run `mpo update`.",
+    );
+  }
+
+  const currentVersion = cliVersion() ?? "0.0.0";
+  const targetMpoRange = options.version
+    ? options.version.startsWith("^") || options.version.startsWith("~")
+      ? options.version
+      : `^${options.version}`
+    : `^${currentVersion}`;
+
+  console.log(`\nmpo update: ${provenance.cliVersion} → ${currentVersion}`);
+  console.log(`  template: ${provenance.template}`);
+  console.log(`  project:  ${provenance.name}\n`);
+
+  // 1. Regenerate the ORIGINAL scaffold (merge base).
+  console.log(`Scaffolding merge base (cli@${provenance.cliVersion})...`);
+  const base = await scaffoldBaseline(
+    provenance.cliVersion,
+    provenance.name,
+    provenance.template,
+    provenance.mpoVersion,
+  );
+
+  // 2. Generate the CURRENT scaffold (theirs).
+  console.log(`Scaffolding update target (cli@${currentVersion})...`);
+  const next = await scaffoldBaseline(
+    currentVersion,
+    provenance.name,
+    provenance.template,
+    targetMpoRange,
+  );
+  writeProvenance(next.dir, {
+    template: provenance.template,
+    cliVersion: currentVersion,
+    name: provenance.name,
+    mpoVersion: targetMpoRange,
+  });
+
+  try {
+    // 3. Three-way merge: base → HEAD (ours) vs base → next (theirs).
+    const head = await gitOut(projectDir, ["rev-parse", "HEAD"]);
+    const baseCommit = await commitTreeFromDir(
+      projectDir,
+      base.dir,
+      `mpo scaffold ${provenance.template}@${provenance.cliVersion}`,
+    );
+    const nextCommit = await commitTreeFromDir(
+      projectDir,
+      next.dir,
+      `mpo scaffold ${provenance.template}@${currentVersion}`,
+      baseCommit,
+    );
+
+    let mergedTree: string;
+    let conflicts: string[] = [];
+    try {
+      const out = await gitOut(projectDir, [
+        "merge-tree",
+        "--write-tree",
+        "--name-only",
+        `--merge-base=${baseCommit}`,
+        head,
+        nextCommit,
+      ]);
+      mergedTree = out.split("\n")[0]!.trim();
+    } catch (err) {
+      // Exit code 1 = conflicts; stdout still carries tree + conflict names.
+      const stdout = (err as { stdout?: string }).stdout ?? "";
+      const lines = stdout.split("\n").filter(Boolean);
+      if (!lines.length) throw err;
+      mergedTree = lines[0]!.trim();
+      conflicts = lines.slice(1).map((line) => line.trim());
+    }
+
+    // The merged .mpo.json can interleave ours/theirs lines (add/add
+    // two-way merge) — the post-merge provenance is always written
+    // authoritatively below.
+    const finalProvenance = {
+      template: provenance.template,
+      cliVersion: currentVersion,
+      name: provenance.name,
+      mpoVersion: targetMpoRange,
+    };
+
+    if (!conflicts.length) {
+      const message = `chore: mpo update ${provenance.cliVersion} → ${currentVersion}`;
+      const mergeCommit = await gitOut(projectDir, [
+        "commit-tree",
+        mergedTree,
+        "-p",
+        head,
+        "-p",
+        nextCommit,
+        "-m",
+        message,
+      ]);
+      await git(projectDir, ["update-ref", "HEAD", mergeCommit]);
+      await git(projectDir, ["reset", "--hard", "HEAD"]);
+      writeProvenance(projectDir, finalProvenance);
+      await git(projectDir, ["add", "--", ".mpo.json"]);
+      await git(projectDir, ["commit", "--amend", "--no-edit", "--quiet"]);
+      const amended = await gitOut(projectDir, ["rev-parse", "--short", "HEAD"]);
+      console.log(`\n✅ merged cleanly → ${amended} ("${message}")`);
+    } else {
+      // Land the merged tree (with conflict markers) in index + worktree for
+      // manual resolution.
+      await git(projectDir, ["read-tree", "-u", "--reset", mergedTree]);
+      writeProvenance(projectDir, finalProvenance);
+      console.log("\n⚠️  merge conflicts — resolve the markers, then commit:");
+      for (const file of conflicts) console.log(`   ${file}`);
+      console.log(
+        `\n   git add -A && git commit -m "chore: mpo update ${provenance.cliVersion} → ${currentVersion}"`,
+      );
+    }
+
+    // 4. .updateignore: pin matching paths to the pre-update HEAD (always
+    // includes pnpm-lock.yaml — the install below regenerates it).
+    const pins = ["pnpm-lock.yaml"];
+    const updateignore = join(projectDir, ".updateignore");
+    if (existsSync(updateignore)) {
+      for (const line of readFileSync(updateignore, "utf-8").split("\n")) {
+        const pattern = line.trim();
+        if (pattern && !pattern.startsWith("#")) pins.push(pattern);
+      }
+    }
+    for (const pin of pins) {
+      await git(projectDir, ["checkout", head, "--", pin]).catch(() => {});
+    }
+
+    if (!options.skipInstall) {
+      console.log("\nInstalling dependencies...");
+      await spawn("pnpm", ["install"], { cwd: projectDir, stdio: "inherit" });
+    }
+  } finally {
+    base.cleanup();
+    next.cleanup();
+  }
+}

package/src/generateVscode.ts

@@ -61,15 +61,36 @@ function launchConfigForApp(app: AppInfo): LaunchConfig[] {
   const configs: LaunchConfig[] = [];
   const wf = "${workspaceFolder}";
 
-  if (name === "vscode" && scripts.dev) {
+  // vscode + webext are delivery targets of the One platform app
+  // (apps/<name>/vscode, apps/<name>/webext) — their dev flows hang off the
+  // app's dev:vscode / dev:webext scripts, staging into dist-vscode /
+  // dist-webext.
+  if (scripts["dev:vscode"]) {
     configs.push({
       name: "vscode dev",
       type: "extensionHost",
       request: "launch",
-      args: ["--disable-extensions", `--extensionDevelopmentPath=${wf}/${relPath}`],
+      args: ["--disable-extensions", `--extensionDevelopmentPath=${wf}/${relPath}/dist-vscode`],
       cwd: `${wf}/${relPath}`,
-      outFiles: [`${wf}/${relPath}/dist/extension/*.js`],
-      preLaunchTask: "npm: dev",
+      outFiles: [`${wf}/${relPath}/dist-vscode/extension/*.js`],
+      preLaunchTask: "npm: dev:vscode",
+    });
+    configs.push({
+      name: "vscode dev",
+      type: "node-terminal",
+      request: "launch",
+      cwd: `${wf}/${relPath}`,
+      command: "pnpm dev:vscode",
+    });
+  }
+
+  if (scripts["dev:webext"]) {
+    configs.push({
+      name: "webext dev",
+      type: "node-terminal",
+      request: "launch",
+      cwd: `${wf}/${relPath}`,
+      command: "pnpm dev:webext",
     });
   }
 
@@ -159,8 +180,9 @@ interface TasksJson {
 }
 
 async function generateTasksJson(apps: AppInfo[]): Promise<TasksJson | null> {
-  const vscodeApp = apps.find((a) => a.name === "vscode");
-  if (!vscodeApp?.scripts?.dev) {
+  // The vscode target lives inside the platform app (dev:vscode script).
+  const hostApp = apps.find((a) => a.scripts?.["dev:vscode"]);
+  if (!hostApp) {
     return null;
   }
 
@@ -169,7 +191,7 @@ async function generateTasksJson(apps: AppInfo[]): Promise<TasksJson | null> {
     tasks: [
       {
         type: "npm",
-        script: "dev",
+        script: "dev:vscode",
         problemMatcher: {
           owner: "typescript",
           fileLocation: "relative",
@@ -190,7 +212,7 @@ async function generateTasksJson(apps: AppInfo[]): Promise<TasksJson | null> {
         isBackground: true,
         presentation: { reveal: "never" },
         group: { kind: "build", isDefault: true },
-        options: { cwd: "${workspaceFolder}/apps/vscode" },
+        options: { cwd: `\${workspaceFolder}/${hostApp.path}` },
       },
     ],
   };
@@ -211,6 +233,6 @@ export async function generateVscodeConfig(root: string): Promise<void> {
     await fs.writeFile(path.join(vsCodeDir, "tasks.json"), JSON.stringify(tasks, null, 2), "utf8");
     console.log("Wrote .vscode/tasks.json");
   } else {
-    console.log("Skipped .vscode/tasks.json (no apps/vscode with dev script)");
+    console.log("Skipped .vscode/tasks.json (no app with a dev:vscode script)");
   }
 }

package/templates/app/AGENTS.md

@@ -0,0 +1,142 @@
+# AGENTS.md — multiplatform.one conventions
+
+Machine-readable house rules for humans and coding agents. Prefer this file over
+reconstructing conventions from meeting notes. Detailed standards live under
+`agent-os/standards/`; the living UX rulebook is linked below.
+
+## Workspace layout
+
+| Path               | Role                                                                |
+| ------------------ | ------------------------------------------------------------------- |
+| `apps/<name>/`     | Private applications (not published)                                |
+| `features/<name>/` | Feature modules for the matching app (screens, stories, playground) |
+| `packages/`        | Private app-integration packages (`@package/*`)                     |
+| `public/`          | Published `@multiplatform.one/*` packages                           |
+
+**App ↔ features twin:** every product app `apps/<name>` MUST have `features/<name>`.
+Platform/tooling shells (frappe, keycloak, storybook\*, vocs, vscode, webext, chain
+shells) are exempt in the convention linter; consumer apps from `mpo init --app`
+are not. Prefer feature code in `features/`, thin wiring in `apps/`.
+
+**Internal deps:** monorepo packages use `workspace:*`. Consumer / app-only
+templates use semver ranges from npm (`@multiplatform.one/*`).
+
+## Package boundaries
+
+| Package                         | Owns                                                 | Must not                               |
+| ------------------------------- | ---------------------------------------------------- | -------------------------------------- |
+| `@multiplatform.one/theme`      | Knobs, presets, intents, recipes, `useResolvedKnobs` | App screens                            |
+| `@multiplatform.one/components` | Catalog UI (layouts, surfaces, feedback, …)          | Frappe/API assumptions                 |
+| `@multiplatform.one/forms`      | Fields, Form, InputParts, field contracts            | Table chrome / Frappe fetch            |
+| `@multiplatform.one/table`      | DataTable, cells, filters, URL table state           | Frappe/API assumptions                 |
+| `@multiplatform.one/frappe-ui`  | Frappe adapters (`FrappeTable`, field registry)      | Re-implementing table/forms primitives |
+| `@multiplatform.one/frappe`     | Frappe client / live query                           | UI                                     |
+
+Dependency direction: `frappe-ui` → `table` / `forms` / `components` / `theme`.
+`table` and `forms` do not depend on `frappe-ui` or `frappe`.
+
+### Import rules (enforced)
+
+1. **No raw `tamagui` outside `public/`** — apps, features, and packages import
+   `@multiplatform.one/components`, `@multiplatform.one/forms`, or
+   `@multiplatform.one/theme` instead.
+2. **Apps never relative-import `public/`** — use package names
+   (`@multiplatform.one/…`), never `../../../public/…`.
+3. **No `.css` files in `apps/*`** (except ignored bench/vendor trees) — styling
+   goes through Tamagui + knobs.
+4. **No hex color literals in `features/**`** — use theme tokens (`$color10`,
+   semantic ramps, knob recipes).
+
+Run: `pnpm lint` (oxlint + `scripts/lint-conventions.mjs`).
+
+## Knobs system (canonical)
+
+Structural styling (radius, space, elevation, typography, animation) is independent
+of Tamagui color themes. Full standard: `agent-os/standards/frontend/knobs-system.md`.
+
+```tsx
+const { knobProps, control, text, elevation } = useResolvedKnobs({
+  intent, // "error" | "accent" | "warning" | "success"
+  component: "Button",
+  compact,
+});
+
+<View
+  {...knobProps.surface}
+  {...knobProps.borderRadius}
+  {...knobProps.panelPadding}
+  {...knobProps.gap}
+  {...knobProps.body}
+  hoverStyle={{ ...control.hoverKnobProps }}
+  pressStyle={{ ...control.pressKnobProps }}
+  focusVisibleStyle={{ ...control.focusVisibleKnobProps }}
+/>;
+```
+
+Rules:
+
+- Always spread complete `knobProps.*` fragments — never cherry-pick resolved tokens.
+- `resolveKnobs()` is the only canonical mapping from abstract knobs → Tamagui props.
+- Consumer `{...props}` come last (explicit eject), not internal defaults that fight recipes.
+- Presets cascade (`<Preset preset="…" theme="…">`); nested `overrides` merge by key.
+- One knob flip restyles the screen (LC-18 KNOB-TOTALITY), or the knob is broken.
+
+## Forms contract
+
+Standard refs: `agent-os/standards/frontend/field-architecture.md`,
+`field-layout.md`, `form-colors.md`, `input-parts.md`.
+
+- Initialize with `useFormField()` + `useResolvedValidators()`.
+- Three-branch render: skeleton → standalone → form-integrated (`<Field>`).
+- Canonical change prop is `onChange(value)` (LC-14). Deprecated aliases may fire
+  but must not be the only path.
+- Field slot order: Label → Hint → Error → Control; error replaces helper in one slot.
+- Use form color ramps from `shared/colorRamps.ts` — no hardcoded color tokens.
+- Fields auto-detect `useIsInTableCell()` and render chromeless inside cells.
+- Capability surfaces (camera, geo, …) MUST preflight before mount (LC-19).
+
+## Table contract
+
+Standard ref: `public/table/README.md` (package boundaries), cell/editor anatomy in
+the living rulebook.
+
+- `@multiplatform.one/table` is framework-agnostic display/filter/sort/paginate.
+- Cell editors larger than the anchor use popover (web) / sheet (native) — never
+  grow the row (LC-06). Editor popups dismiss only on dismissal intent (LC-21).
+- Frappe integration belongs in `@multiplatform.one/frappe-ui` (`FrappeTable`,
+  registry adapters), not in `table`.
+- Child-table / TableInput follow the same field `onChange` contract as forms.
+
+## Living rulebook
+
+**Normative UX + composition rules (LC-\* and recipe taxonomy):**
+
+→ [`docs/theme-propagation-spec.md`](./docs/theme-propagation-spec.md)
+
+That document is the living rulebook: every owner-reported spacing/UX issue is
+adjudicated there in-session as VIOLATION or GAP (new LC-\* rule + VERIFY). Agents
+changing catalog components MUST read it first; a contradicting change updates the
+spec in the same change. Companion docs:
+
+- Catalog guidelines: `docs/design-guidelines.md` + `docs/design-guidelines-blueprint.md`
+- Click-matrix / VERIFY arm: `docs/storybook-knob-edge-cases.md`
+- Agent OS standards index: `agent-os/standards/index.yml`
+
+## Tooling
+
+| Command                 | Purpose                                                        |
+| ----------------------- | -------------------------------------------------------------- |
+| `pnpm lint`             | oxlint (incl. convention rules) + structural convention checks |
+| `pnpm lint:conventions` | Structural checks only (css twin, features twin)               |
+| `pnpm format`           | oxfmt                                                          |
+| `pnpm ci:local`         | format + lint + typecheck + build + test + tree-clean          |
+
+Use **oxlint / oxfmt**, not ESLint / Prettier
+(`agent-os/standards/global/linting-formatting.md`).
+
+## Coding defaults
+
+- Named exports only; cut dead/legacy aliases unless a task explicitly needs them.
+- Cross-platform: shared code first; `.native.tsx` / `.web.tsx` only when required.
+- Stories and tests live next to the component / feature they cover.
+- Deeper style rules: `agent-os/standards/global/coding-style.md`.

package/templates/app/README.md

@@ -0,0 +1,62 @@
+# **NAME**
+
+App-only project scaffolded by [`@multiplatform.one/cli`](https://www.npmjs.com/package/@multiplatform.one/cli)
+(`mpo init --app` / `create-multiplatform-app`).
+
+This is **not** a fork of the multiplatform.one monorepo. Framework packages come from npm at
+semver ranges (`@multiplatform.one/*`: `__MPO_VERSION__`), never `workspace:*`.
+
+## Layout
+
+| Path                 | Role                                                      |
+| -------------------- | --------------------------------------------------------- |
+| `apps/__NAME__/`     | App shell (Vite + React web stub)                         |
+| `features/__NAME__/` | Feature screens / UI — import from here, not from `apps/` |
+| `packages/config/`   | Shared app config (`@package/config`)                     |
+
+Convention: every `apps/<name>` has a matching `features/<name>`.
+
+## Commands
+
+```bash
+pnpm install
+pnpm dev       # start the web stub
+pnpm build
+pnpm lint
+pnpm typecheck
+```
+
+## Dependencies
+
+Feature and app packages depend on published framework packages, for example:
+
+```json
+{
+  "@multiplatform.one/components": "__MPO_VERSION__",
+  "@multiplatform.one/theme": "__MPO_VERSION__",
+  "@multiplatform.one/platform": "__MPO_VERSION__"
+}
+```
+
+Upgrade with your usual package manager (`pnpm update @multiplatform.one/*`).
+
+## Conventions
+
+See [`AGENTS.md`](./AGENTS.md) for package boundaries, the apps ↔ features twin,
+import rules (no raw `tamagui` outside framework packages, no relative `public/`
+imports, no hex literals in features), and knobs/forms/table contracts.
+
+## Next steps
+
+1. Replace the stub `HomeScreen` in `features/__NAME__/src/HomeScreen.tsx`.
+2. Add routes / screens under `features/__NAME__/`.
+3. When you need native (Expo / one), extend `apps/__NAME__/` — keep business UI in `features/`.
+4. Do **not** copy `public/` from the framework monorepo into this project.
+
+## Create another app
+
+```bash
+mpo init --app another-app
+# or
+npx --package=@multiplatform.one/cli create-multiplatform-app another-app
+```

package/templates/app/apps/__NAME__/index.html

@@ -0,0 +1,36 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>__NAME_PASCAL__</title>
+    <!--
+      LC-33 FONT-STABLE-MOUNT: the shell owns Inter (the theme package does
+      not inject @font-face as a CSS side effect). Preload + a head face with
+      font-display: optional means first paint already renders Inter and the
+      face never swaps after mount. The binaries live in public/fonts/.
+    -->
+    <link rel="preload" href="/fonts/inter-400.woff2" as="font" type="font/woff2" crossorigin />
+    <link rel="preload" href="/fonts/inter-700.woff2" as="font" type="font/woff2" crossorigin />
+    <style data-font-inter>
+      @font-face {
+        font-family: "Inter";
+        font-style: normal;
+        font-weight: 400;
+        font-display: optional;
+        src: url("/fonts/inter-400.woff2") format("woff2");
+      }
+      @font-face {
+        font-family: "Inter";
+        font-style: normal;
+        font-weight: 700;
+        font-display: optional;
+        src: url("/fonts/inter-700.woff2") format("woff2");
+      }
+    </style>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/templates/app/apps/__NAME__/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@app/__NAME__",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@features/__NAME__": "workspace:*",
+    "@multiplatform.one/components": "__MPO_VERSION__",
+    "@multiplatform.one/platform": "__MPO_VERSION__",
+    "@multiplatform.one/theme": "__MPO_VERSION__",
+    "@package/config": "workspace:*",
+    "react": "^19.2.5",
+    "react-dom": "^19.2.5",
+    "react-native-web": "^0.21.2",
+    "tamagui": "2.0.0-rc.41"
+  },
+  "devDependencies": {
+    "@types/react": "~19.2.14",
+    "@types/react-dom": "~19.2.3",
+    "@vitejs/plugin-react": "^6.0.2",
+    "typescript": "~5.9.3",
+    "vite": "^8.0.10"
+  }
+}

package/templates/app/apps/__NAME__/src/App.tsx

@@ -0,0 +1,9 @@
+import { HomeScreen } from "@features/__NAME__";
+
+/**
+ * App shell for __NAME__.
+ * Wire providers / routing here; keep screens in features/__NAME__.
+ */
+export function App() {
+  return <HomeScreen />;
+}

package/templates/app/apps/__NAME__/src/main.tsx

@@ -0,0 +1,14 @@
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import { App } from "./App";
+
+const root = document.getElementById("root");
+if (!root) {
+  throw new Error("#root element missing");
+}
+
+createRoot(root).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+);

package/templates/app/apps/__NAME__/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "types": ["vite/client"]
+  },
+  "include": ["./src/**/*"],
+  "exclude": ["**/node_modules/**"]
+}