create-mobile 0.1.0

package/README.md

@@ -0,0 +1,76 @@
+# create-mobile
+
+> **The honest front door to a new mobile app.** `npm create mobile` doesn't silently
+> pick a framework for you — it opens with Kotlin/Compose Multiplatform as the modern
+> default, states the real trade-offs vs React Native and Flutter, and lets you choose.
+> Continue, and it scaffolds a green-building Android + iOS app via
+> [`create-cmp-cli`](https://www.npmjs.com/package/create-cmp-cli).
+
+```bash
+npm create mobile@latest my-app
+```
+
+## Why this package exists — a fit check, not a redirect
+
+"mobile" is framework-neutral, so a package under that name that quietly stamped one
+stack would be a bait-and-switch. This one is built to earn the generic name. Launch it
+and it opens with an honest positioning:
+
+> Here's Compose Multiplatform as the modern default — one statically-typed codebase,
+> real native Android + iOS UI, Google-backed, iOS stable since May 2025 — and here are
+> the real trade-offs vs React Native/Flutter (bigger RN/Flutter ecosystems and hiring
+> pools; a JS bridge or Dart's non-native render layer; CMP is the youngest of the three).
+> **You choose.**
+
+That's the same step-0 fit check the create-cmp Claude Code plugin's `cmp-new` skill runs,
+brought to the command line. The generic name raises the honesty bar; this is how it's
+cleared — you become the honest front door to mobile, not a redirect. The full sourced case
+for choosing CMP (with its weaknesses named, not just its strengths) is
+[docs/WHY-CMP.md](https://github.com/kvdm-co-pilot/create-cmp/blob/main/docs/WHY-CMP.md).
+
+- **Interactive run:** you get the positioning **and a real prompt** —
+  `Continue with Compose Multiplatform? [Y/n]`. Decline and nothing is written; it points
+  you at `npm create expo` (React Native) or `flutter create` and exits cleanly.
+- **Scripts / CI / agents (`--yes` or piped):** you've already chosen by how you invoked
+  it, so it prints the honest note and proceeds — no blocking prompt.
+- **`--help` / `--version`:** pass straight through to the real CLI.
+
+## What you get if you continue
+
+One command stamps a **frozen, CI-verified template** — deterministic output, never
+LLM-freehanded project code:
+
+- Android + iOS shells (XcodeGen + CocoaPods pre-wired), Clean Architecture with a worked
+  example feature, Koin DI, bottom navigation with insets solved.
+- A **proven-green version set** (Kotlin/KSP/Compose/Room/AGP pinned to a combination that
+  actually builds together — including the iOS/KSP2 path).
+- Optional features by flag: Firebase (GitLive) with auth, Room, Maestro on-device E2E, a
+  live UI inspector, a desktop hot-reload dev client. `--verify` builds the app before
+  reporting success; the CLI exits non-zero on failure.
+- The **delivery harness** in every generated project: specs with stable clause ids, an
+  8-gate verify lane (`node qa/verify.mjs`), evidence receipts bound to a content hash, a
+  device-free preview loop so coding agents see what they build, and CI that refuses "done"
+  without proof. See it working in the
+  [public showcase repo](https://github.com/kvdm-co-pilot/create-cmp-showcase) — including
+  [a PR the harness refuses](https://github.com/kvdm-co-pilot/create-cmp-showcase/pull/1).
+
+## About this package
+
+An **official alias** for `create-cmp-cli`, published by the same maintainer so the
+conventional `npm create mobile` invocation works. It adds exactly one thing of its own —
+the honest fit check above — then delegates to the installed `create-cmp-cli`, forwarding
+all arguments, stdio, and the exit code. After the choice, either name runs the same tool
+with the same flags.
+
+Fully non-interactive (scripts and AI agents):
+
+```bash
+npx create-mobile my-app --name Acme --package com.acme.app --yes --verify
+```
+
+## Docs
+
+- Repository, full README and issues: <https://github.com/kvdm-co-pilot/create-cmp>
+- Why Compose Multiplatform (sourced, honest): [docs/WHY-CMP.md](https://github.com/kvdm-co-pilot/create-cmp/blob/main/docs/WHY-CMP.md)
+- Every flag: [options.schema.json](https://github.com/kvdm-co-pilot/create-cmp/blob/main/options.schema.json) or `npx create-mobile --help`
+- Usage guide (commands, skills, workflows): [docs/USAGE.md](https://github.com/kvdm-co-pilot/create-cmp/blob/main/docs/USAGE.md)

package/bin/create-mobile.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// create-mobile — the honest front door to a new mobile app.
+//
+// The other create-cmp aliases (create-kmp, create-compose-multiplatform) are pure
+// pass-throughs: their name already names the framework, so they just re-exec
+// create-cmp-cli. This one is deliberately NOT a silent pass-through. "mobile" is
+// framework-neutral, so a package that quietly scaffolds Compose Multiplatform under
+// that name would be a bait-and-switch. Instead it opens with an HONEST fit check —
+// CMP as the modern default, the real trade-offs vs React Native / Flutter, and a
+// genuine choice — and only then delegates to create-cmp-cli. The generic name
+// raises the honesty bar; this is how it's earned (the CLI analogue of the cmp-new
+// skill's step-0 fit check). Everything after the choice is create-cmp-cli, verbatim.
+
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { stdin, stdout } from "node:process";
+
+const require = createRequire(import.meta.url);
+const argv = process.argv.slice(2);
+
+// --help / --version: pure info passthrough — no banner, no prompt.
+const INFO = new Set(["--help", "-h", "--version", "-v"]);
+const infoOnly = argv.some((a) => INFO.has(a));
+
+function resolveCliPath() {
+  let pkgJsonPath;
+  try {
+    // package.json is always resolvable, even behind an "exports" map.
+    pkgJsonPath = require.resolve("create-cmp-cli/package.json");
+  } catch {
+    process.stderr.write(
+      "create-mobile: could not find its dependency create-cmp-cli.\n" +
+        "Your install may be broken — reinstall, or run the real CLI directly:\n\n" +
+        "  npx create-cmp-cli@latest\n",
+    );
+    process.exit(1);
+  }
+  const pkg = require(pkgJsonPath);
+  const bin = pkg.bin;
+  const relBinPath = typeof bin === "string" ? bin : (bin["create-cmp"] ?? Object.values(bin)[0]);
+  if (!relBinPath) {
+    process.stderr.write(
+      "create-mobile: create-cmp-cli declares no bin entry.\n" +
+        "Run the real CLI directly instead:  npx create-cmp-cli@latest\n",
+    );
+    process.exit(1);
+  }
+  return join(dirname(pkgJsonPath), relBinPath);
+}
+
+// Re-exec create-cmp-cli: block until it finishes, inherit stdio so interactive
+// prompts keep working, propagate the exit code. Never returns (calls process.exit).
+function delegate() {
+  const cliPath = resolveCliPath();
+  const result = spawnSync(process.execPath, [cliPath, ...argv], { stdio: "inherit" });
+  if (result.error) {
+    process.stderr.write(`create-mobile: failed to launch create-cmp-cli: ${result.error.message}\n`);
+    process.exit(1);
+  }
+  if (result.signal) process.kill(process.pid, result.signal);
+  process.exit(result.status ?? 1);
+}
+
+if (infoOnly) delegate(); // exits
+
+// The honest positioning. To stderr so a piped stdout stays clean; both stream to
+// the terminal in an interactive run, so the user always sees it.
+const banner = [
+  "",
+  "  create-mobile — the honest front door to a new mobile app.",
+  "",
+  "  Recommended default: Kotlin / Compose Multiplatform (KMP)",
+  "    - one statically-typed codebase, REAL native Android + iOS UI, no JS bridge",
+  "    - Google-backed; Compose for iOS stable since May 2025",
+  "",
+  "  The real trade-offs — know these before you choose:",
+  "    - React Native / Expo: bigger ecosystem, more libraries and hiring pool,",
+  "      but a JS<->native bridge and two languages at the edges",
+  "    - Flutter: mature tooling and widgets, but Dart and a non-native render layer",
+  "    - CMP is the youngest of the three: smaller community, newer iOS story",
+  "",
+  "  Full sourced case: https://github.com/kvdm-co-pilot/create-cmp/blob/main/docs/WHY-CMP.md",
+  "",
+].join("\n");
+
+process.stderr.write(banner + "\n");
+
+// Flags-driven / --yes / no TTY => the caller already chose by how they invoked it
+// (scripts, CI, an agent passing flags). Print the banner and proceed. A real
+// interactive run gets a real choice.
+const nonInteractive = argv.includes("--yes") || argv.includes("-y") || !stdin.isTTY || !stdout.isTTY;
+
+if (nonInteractive) {
+  delegate(); // exits
+}
+
+const { createInterface } = await import("node:readline/promises");
+const rl = createInterface({ input: stdin, output: stdout });
+const answer = (await rl.question("  Continue with Compose Multiplatform? [Y/n] ")).trim().toLowerCase();
+rl.close();
+
+if (answer === "" || answer === "y" || answer === "yes") {
+  delegate(); // exits
+}
+
+process.stdout.write(
+  "\n  No problem — nothing was written.\n" +
+    "  Prefer another stack? React Native: npm create expo@latest  ·  Flutter: flutter create my_app\n\n",
+);
+process.exit(0);

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "create-mobile",
+  "version": "0.1.0",
+  "description": "The honest front door to a new mobile app. `npm create mobile` recommends Kotlin/Compose Multiplatform as the modern default, states the real trade-offs vs React Native/Flutter, and lets you choose — then, if you continue, scaffolds a green-building Android + iOS app (one Kotlin codebase) with a machine-enforced verify lane and evidence receipts. Official alias for create-cmp-cli; not a redirect — a fit check first.",
+  "type": "module",
+  "bin": {
+    "create-mobile": "bin/create-mobile.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin"
+  ],
+  "keywords": [
+    "mobile app",
+    "create mobile app",
+    "new mobile app",
+    "cross-platform",
+    "app generator",
+    "react native alternative",
+    "flutter alternative",
+    "android",
+    "ios",
+    "compose-multiplatform",
+    "kotlin-multiplatform",
+    "kmp",
+    "cmp",
+    "scaffold",
+    "project-generator",
+    "claude-code",
+    "ai-agent"
+  ],
+  "license": "MIT",
+  "author": "Karel van der Merwe",
+  "homepage": "https://github.com/kvdm-co-pilot/create-cmp#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kvdm-co-pilot/create-cmp.git",
+    "directory": "packages/aliases/create-mobile"
+  },
+  "bugs": {
+    "url": "https://github.com/kvdm-co-pilot/create-cmp/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "create-cmp-cli": ">=0.7.1"
+  }
+}