create-cmp-cli 0.2.0

package/src/commands/create.mjs

@@ -0,0 +1,223 @@
+// `create-cmp create` (the DEFAULT command) — scaffold a new project.
+// Moved verbatim from bin/create-cmp.mjs when the bin became a thin
+// dispatcher; behavior and flags are unchanged.
+
+import { flagBool } from "../lib/args.mjs";
+
+// --- name helpers ------------------------------------------------------------
+
+function parseTabs(str) {
+  if (!str || str === true) return null;
+  const tabs = String(str)
+    .split(",")
+    .map((pair) => pair.trim())
+    .filter(Boolean)
+    .map((pair) => {
+      const [label, icon] = pair.split(":").map((s) => s.trim());
+      return { label, icon: icon || label.toLowerCase() };
+    });
+  return tabs.length ? tabs : null;
+}
+
+function pascalFromName(name) {
+  return (name || "App")
+    .replace(/[^A-Za-z0-9 ]/g, " ")
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((w) => w[0].toUpperCase() + w.slice(1))
+    .join("") || "App";
+}
+
+function slugFromName(name) {
+  return (name || "app").toLowerCase().replace(/[^a-z0-9]/g, "") || "app";
+}
+
+// --- config builders -------------------------------------------------------
+
+function buildConfigFromFlags(flags, positional) {
+  const name = typeof flags.name === "string" ? flags.name : "MyApp";
+  const pkg = typeof flags.package === "string" ? flags.package : `com.${slugFromName(name)}.app`;
+  const ios = flagBool(flags, "ios", true);
+  const firebase = flagBool(flags, "firebase", true);
+  const targetDir =
+    (typeof flags["target-dir"] === "string" && flags["target-dir"]) ||
+    positional ||
+    `./${slugFromName(name)}`;
+
+  return {
+    appName: name,
+    package: pkg,
+    iosBundleId: typeof flags["bundle-id"] === "string" ? flags["bundle-id"] : pkg,
+    region: typeof flags.region === "string" ? flags.region : "us-central1",
+    themePrefix:
+      typeof flags["theme-prefix"] === "string" ? flags["theme-prefix"] : pascalFromName(name),
+    platforms: { android: true, ios },
+    firebase: {
+      enabled: firebase,
+      auth: typeof flags.auth === "string" ? flags.auth : "both",
+      firestore: flagBool(flags, "firestore", firebase),
+      storage: flagBool(flags, "storage", firebase),
+      functions: flagBool(flags, "functions", firebase),
+      fcm: flagBool(flags, "fcm", firebase),
+    },
+    room: flagBool(flags, "room", true),
+    appium: flagBool(flags, "appium", true),
+    inspector: flagBool(flags, "inspector", true),
+    devClient: flagBool(flags, "dev-client", true),
+    tabs: parseTabs(flags.tabs) || [
+      { label: "Home", icon: "home" },
+      { label: "Profile", icon: "person" },
+    ],
+    targetDir,
+  };
+}
+
+async function interactiveConfig(positional) {
+  let prompts;
+  try {
+    prompts = (await import("prompts")).default;
+  } catch {
+    process.stderr.write(
+      "Interactive mode needs the 'prompts' package. Re-run with flags + --yes for non-interactive use.\n"
+    );
+    process.exit(1);
+  }
+
+  const onCancel = () => {
+    process.stdout.write("Cancelled.\n");
+    process.exit(1);
+  };
+
+  const base = await prompts(
+    [
+      { type: "text", name: "appName", message: "App display name", initial: "MyApp" },
+      {
+        type: "text",
+        name: "package",
+        message: "Package (reverse-DNS)",
+        initial: (prev) => `com.${slugFromName(prev)}.app`,
+      },
+      { type: "confirm", name: "ios", message: "Enable iOS target?", initial: true },
+      { type: "text", name: "region", message: "Firebase region", initial: "us-central1" },
+      { type: "confirm", name: "firebase", message: "Wire Firebase (GitLive)?", initial: true },
+    ],
+    { onCancel }
+  );
+
+  let auth = "none";
+  let firestore = false, storage = false, functions = false, fcm = false;
+  if (base.firebase) {
+    const fb = await prompts(
+      [
+        {
+          type: "select",
+          name: "auth",
+          message: "Auth type",
+          choices: [
+            { title: "Email + Phone (both)", value: "both" },
+            { title: "Email only", value: "email" },
+            { title: "Phone/OTP only", value: "phone" },
+            { title: "None", value: "none" },
+          ],
+          initial: 0,
+        },
+        { type: "confirm", name: "firestore", message: "Firestore?", initial: true },
+        { type: "confirm", name: "storage", message: "Storage?", initial: true },
+        { type: "confirm", name: "functions", message: "Cloud Functions?", initial: true },
+        { type: "confirm", name: "fcm", message: "FCM (push)?", initial: true },
+      ],
+      { onCancel }
+    );
+    auth = fb.auth; firestore = fb.firestore; storage = fb.storage;
+    functions = fb.functions; fcm = fb.fcm;
+  }
+
+  const extras = await prompts(
+    [
+      { type: "confirm", name: "room", message: "Room local cache?", initial: true },
+      { type: "confirm", name: "appium", message: "Appium test harness?", initial: true },
+      {
+        type: "confirm",
+        name: "inspector",
+        message: "Live on-device inspector (debug builds only)?",
+        initial: true,
+      },
+      {
+        type: "confirm",
+        name: "devClient",
+        message: "Desktop dev-client (JVM window + Compose Hot Reload)?",
+        initial: true,
+      },
+      {
+        type: "text",
+        name: "tabs",
+        message: "Bottom-nav tabs (label:icon, comma-separated)",
+        initial: "Home:home,Profile:person",
+      },
+      {
+        type: "text",
+        name: "targetDir",
+        message: "Target directory",
+        initial: positional || `./${slugFromName(base.appName)}`,
+      },
+    ],
+    { onCancel }
+  );
+
+  return {
+    appName: base.appName,
+    package: base.package,
+    iosBundleId: base.package,
+    region: base.region,
+    themePrefix: pascalFromName(base.appName),
+    platforms: { android: true, ios: base.ios },
+    firebase: { enabled: base.firebase, auth, firestore, storage, functions, fcm },
+    room: extras.room,
+    appium: extras.appium,
+    inspector: extras.inspector,
+    devClient: extras.devClient,
+    tabs: parseTabs(extras.tabs) || [{ label: "Home", icon: "home" }],
+    targetDir: extras.targetDir,
+  };
+}
+
+// --- command ----------------------------------------------------------------
+
+/**
+ * Run the scaffold (default) command.
+ * @param {Record<string,string|boolean>} flags
+ * @param {string|undefined} positional first non-subcommand positional (target dir)
+ */
+export async function runCreate(flags, positional) {
+  const { scaffold } = await import("../scaffold.mjs");
+
+  const nonInteractive =
+    flags.yes === true ||
+    typeof flags.name === "string" ||
+    typeof flags.package === "string" ||
+    !process.stdin.isTTY;
+
+  const config = nonInteractive
+    ? buildConfigFromFlags(flags, positional)
+    : await interactiveConfig(positional);
+
+  const verify = flagBool(flags, "verify", true);
+
+  try {
+    const { verdict } = await scaffold(config, {
+      verify,
+      dryRunVerify: flags["dry-run-verify"] === true,
+      force: flags.force === true,
+    });
+
+    if (verify && verdict && !verdict.green) {
+      process.stderr.write("\nScaffold produced files but the verify gate did NOT go green.\n");
+      process.exit(1);
+    }
+    process.stdout.write(`\nDone. cd ${config.targetDir}\n`);
+    process.exit(0);
+  } catch (err) {
+    process.stderr.write(`\nError: ${err.message}\n`);
+    process.exit(1);
+  }
+}

package/src/commands/doctor.mjs

@@ -0,0 +1,256 @@
+// `create-cmp doctor` — toolchain preflight (existing behavior, preserved) PLUS
+// a project-diagnosis section that activates when run inside (or pointed at,
+// via --target-dir) a directory with Gradle files. The project section works on
+// ANY KMP project — not just ones we scaffolded.
+//
+//   create-cmp doctor [--yes] [--dry-run] [--no-ios] [--no-install]
+//                     [--target-dir <dir>] [--fix]
+//
+// --fix applies only SAFE heals (write local.properties from ANDROID_HOME, add
+// ksp.useKSP2=true); everything else prints the exact manual step.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { flagBool } from "../lib/args.mjs";
+import { colors, ok } from "../lib/log.mjs";
+import { probe } from "../bootstrap/exec.mjs";
+import { doctor as toolchainDoctor } from "../doctor.mjs";
+import { diagnoseProject } from "../lib/project-doctor.mjs";
+import { parseProperties, upsertProperty, parseVersions } from "../lib/toml.mjs";
+import { loadRegistry } from "../lib/registry.mjs";
+import { listFiles } from "../lib/fsutil.mjs";
+
+function readIfExists(p) {
+  try {
+    return fs.readFileSync(p, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+/** Does this dir look like a Gradle project? (activates project diagnosis) */
+export function isGradleProjectDir(dir) {
+  return (
+    fs.existsSync(path.join(dir, "settings.gradle.kts")) ||
+    fs.existsSync(path.join(dir, "settings.gradle")) ||
+    fs.existsSync(path.join(dir, "build.gradle.kts")) ||
+    fs.existsSync(path.join(dir, "build.gradle")) ||
+    fs.existsSync(path.join(dir, "gradle", "libs.versions.toml"))
+  );
+}
+
+function androidHomeDir() {
+  const envHome = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT;
+  if (envHome && fs.existsSync(envHome)) return envHome;
+  const conventional = path.join(os.homedir(), "Library", "Android", "sdk");
+  if (fs.existsSync(conventional)) return conventional;
+  const linux = path.join(os.homedir(), "Android", "Sdk");
+  if (fs.existsSync(linux)) return linux;
+  return null;
+}
+
+/** ~/.konan size in bytes via `du -sk` (null when absent/unknown). */
+function konanSizeBytes() {
+  const konan = path.join(os.homedir(), ".konan");
+  if (!fs.existsSync(konan)) return null;
+  const r = probe("du", ["-sk", konan]);
+  if (!r.ok) return null;
+  const kb = parseInt(r.stdout.split(/\s+/)[0], 10);
+  return Number.isFinite(kb) ? kb * 1024 : null;
+}
+
+/** Free disk bytes for the home volume (null when undeterminable). */
+function freeDiskBytes() {
+  try {
+    const s = fs.statfsSync(os.homedir());
+    return Number(s.bavail) * Number(s.bsize);
+  } catch {
+    return null;
+  }
+}
+
+/** Gather filesystem/env inputs for the pure diagnosis. */
+export function gatherProjectInputs(projectDir) {
+  const toml = readIfExists(path.join(projectDir, "gradle", "libs.versions.toml"));
+  const gradleProperties = readIfExists(path.join(projectDir, "gradle.properties"));
+  const localProperties = readIfExists(path.join(projectDir, "local.properties"));
+
+  let sdkDirExists = null;
+  if (localProperties !== null) {
+    const sdkDir = parseProperties(localProperties).get("sdk.dir");
+    if (sdkDir) {
+      // local.properties escapes ':' and '\' on some platforms.
+      const raw = sdkDir.value.replace(/\\(.)/g, "$1");
+      sdkDirExists = fs.existsSync(raw);
+    }
+  }
+
+  const hasIos =
+    fs.existsSync(path.join(projectDir, "iosApp")) ||
+    fs.existsSync(path.join(projectDir, "composeApp", "src", "iosMain"));
+
+  let registry = null;
+  try {
+    registry = loadRegistry();
+  } catch {
+    // corrupt registry should not break doctor — drift check is skipped
+  }
+
+  const { inspectorHits, inspectorCatalog } = scanInspectorSources(projectDir);
+
+  return {
+    toml,
+    gradleProperties,
+    localProperties,
+    sdkDirExists,
+    androidHomeSet: androidHomeDir() !== null,
+    hasIos,
+    registry,
+    konanBytes: konanSizeBytes(),
+    freeDiskBytes: freeDiskBytes(),
+    inspectorHits,
+    inspectorCatalog,
+  };
+}
+
+/**
+ * Static scan for the live-inspector release-safety check: which Kotlin sources
+ * reference the inspector endpoint, and (for the catalog drift tripwire) the
+ * stamped InspectorCatalog.kt + theme sources. Purely filesystem — doctor never
+ * probes the network for this (the release guarantee is structural).
+ */
+function scanInspectorSources(projectDir) {
+  const srcRoot = path.join(projectDir, "composeApp", "src");
+  if (!fs.existsSync(srcRoot)) return { inspectorHits: null, inspectorCatalog: null };
+
+  const hits = [];
+  let catalog = null;
+  let theme = "";
+  for (const file of listFiles(srcRoot)) {
+    if (!file.endsWith(".kt")) continue;
+    const content = readIfExists(file);
+    if (content === null) continue;
+    const rel = path.relative(projectDir, file).split(path.sep).join("/");
+    if (content.includes("/inspect/") || content.includes("InspectorHttpServer")) {
+      hits.push(rel);
+    }
+    if (path.basename(file) === "InspectorCatalog.kt") catalog = content;
+    if (/\/presentation\/theme\/(Tokens|Theme)\.kt$/.test(rel)) theme += `${content}\n`;
+  }
+  return {
+    inspectorHits: hits,
+    inspectorCatalog: catalog && theme ? { catalog, theme } : null,
+  };
+}
+
+/** Apply the SAFE auto-heals for --fix. Returns ids of findings it fixed. */
+function applySafeFixes(projectDir, findings, inputs) {
+  const fixed = [];
+  for (const f of findings) {
+    if (!f.fix || !f.fix.auto || f.level === "ok") continue;
+
+    if (f.id === "local-properties") {
+      const sdk = androidHomeDir();
+      if (!sdk) continue;
+      const target = path.join(projectDir, "local.properties");
+      const existing = readIfExists(target) ?? "";
+      const { content, changed } = upsertProperty(existing, "sdk.dir", sdk);
+      if (changed) {
+        fs.writeFileSync(target, content);
+        ok(`--fix: wrote sdk.dir=${sdk} to local.properties`);
+        fixed.push(f.id);
+      }
+    }
+
+    if (f.id === "ksp2-flag") {
+      const target = path.join(projectDir, "gradle.properties");
+      const existing = inputs.gradleProperties ?? "";
+      const { content, changed } = upsertProperty(existing, "ksp.useKSP2", "true");
+      if (changed) {
+        fs.writeFileSync(target, content);
+        ok(`--fix: set ksp.useKSP2=true in gradle.properties`);
+        fixed.push(f.id);
+      }
+    }
+  }
+  return fixed;
+}
+
+function printFindings(findings) {
+  for (const f of findings) {
+    if (f.level === "ok") {
+      process.stdout.write(`${colors.green("✓")} ${f.title} — ${colors.dim(f.detail)}\n`);
+    } else if (f.level === "warn") {
+      process.stdout.write(`${colors.yellow("!")} ${f.title}\n    ${colors.dim(f.detail)}\n`);
+      if (f.fix) process.stdout.write(`    ${colors.cyan(f.fix.auto ? "fix (--fix):" : "fix:")} ${f.fix.description}\n`);
+    } else {
+      process.stdout.write(`${colors.red("✗")} ${f.title}\n    ${colors.dim(f.detail)}\n`);
+      if (f.fix) process.stdout.write(`    ${colors.cyan(f.fix.auto ? "fix (--fix):" : "fix:")} ${f.fix.description}\n`);
+    }
+  }
+}
+
+/**
+ * @param {Record<string,string|boolean>} flags
+ * @param {string|undefined} positional optional target dir positional
+ */
+export async function runDoctor(flags, positional) {
+  // 1) Toolchain preflight — unchanged existing behavior.
+  const toolchain = await toolchainDoctor({
+    assumeYes: flags.yes === true,
+    dryRun: flags["dry-run"] === true,
+    ios: flagBool(flags, "ios", true),
+    installMissing: flags["no-install"] !== true,
+  });
+
+  // 2) Project diagnosis — only when pointed at / run inside a Gradle project.
+  const targetDir =
+    (typeof flags["target-dir"] === "string" && flags["target-dir"]) || positional || ".";
+  const projectDir = path.resolve(targetDir);
+
+  let projectGreen = true;
+  if (isGradleProjectDir(projectDir)) {
+    process.stdout.write(
+      `\n${colors.bold("Project diagnosis")} — ${colors.cyan(projectDir)}\n` +
+        `${colors.dim("(works on any KMP project — not only create-cmp-scaffolded ones)")}\n\n`
+    );
+
+    let inputs = gatherProjectInputs(projectDir);
+    let findings = diagnoseProject(inputs);
+
+    if (flags.fix === true) {
+      const fixed = applySafeFixes(projectDir, findings, inputs);
+      if (fixed.length > 0) {
+        // Re-diagnose so the report reflects the healed state.
+        inputs = gatherProjectInputs(projectDir);
+        findings = diagnoseProject(inputs);
+      } else {
+        process.stdout.write(`${colors.dim("--fix: nothing auto-fixable found.")}\n`);
+      }
+    }
+
+    printFindings(findings);
+    projectGreen = !findings.some((f) => f.level === "fail");
+
+    if (!flags.fix && findings.some((f) => f.fix?.auto && f.level !== "ok")) {
+      process.stdout.write(
+        `\n${colors.cyan("Tip:")} re-run with ${colors.bold("--fix")} to apply the safe heals above automatically.\n`
+      );
+    }
+    if (inputs.toml) {
+      const kotlin = parseVersions(inputs.toml).get("kotlin");
+      if (kotlin) {
+        process.stdout.write(`${colors.dim(`Project kotlin: ${kotlin.value}`)}\n`);
+      }
+    }
+    process.stdout.write(
+      projectGreen
+        ? `\n${colors.green("Project diagnosis: no blocking issues.")}\n`
+        : `\n${colors.red("Project diagnosis: blocking issues found (see ✗ above).")}\n`
+    );
+  }
+
+  process.exit(toolchain.green && projectGreen ? 0 : 1);
+}

package/src/commands/upgrade.mjs

@@ -0,0 +1,196 @@
+// `create-cmp upgrade` — migrate an existing Gradle/KMP project to the next
+// PROVEN-GREEN version set.
+//
+//   create-cmp upgrade [--target-dir .] [--set <id>] [--dry-run] [--yes] [--verify]
+//
+// Behavior:
+//   - Parses gradle/libs.versions.toml [versions], diffs against the target
+//     registry set (default: latest), prints a change table.
+//   - Default is a DRY RUN unless confirmed: applying requires --yes or an
+//     interactive "y". --dry-run never applies.
+//   - Applying rewrites ONLY the changed version values in-place (surgical
+//     line edits — formatting/comments preserved), updates gradle.properties
+//     flags the set requires (ksp.useKSP2), and the wrapper distributionUrl.
+//   - Every touched file gets a `<file>.bak-upgrade` backup first, and the
+//     revert commands are printed.
+//   - Lockstep guardrail: refuses to write a file where ksp is not
+//     `<kotlin>-…`.
+//   - Works on ANY project with a libs.versions.toml — template markers only
+//     soften/strengthen messaging, never refuse.
+
+import fs from "node:fs";
+import path from "node:path";
+
+import { flagBool } from "../lib/args.mjs";
+import { colors, ok, warn, fail, step } from "../lib/log.mjs";
+import { consent } from "../bootstrap/exec.mjs";
+import { loadRegistry, latestSet, getSet } from "../lib/registry.mjs";
+import { planUpgrade, BACKUP_SUFFIX } from "../lib/upgrade.mjs";
+
+function readIfExists(p) {
+  try {
+    return fs.readFileSync(p, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+function printDiffTable(changes) {
+  const keyWidth = Math.max(...changes.map((c) => c.key.length), 7);
+  const fromWidth = Math.max(...changes.map((c) => c.from.length), 7);
+  process.stdout.write(
+    `  ${colors.bold("version".padEnd(keyWidth))}  ${colors.bold("current".padEnd(fromWidth))}     ${colors.bold("target")}\n`
+  );
+  for (const c of changes) {
+    process.stdout.write(
+      `  ${c.key.padEnd(keyWidth)}  ${colors.red(c.from.padEnd(fromWidth))}  ${colors.dim("→")}  ${colors.green(c.to)}\n`
+    );
+  }
+}
+
+/**
+ * @param {Record<string,string|boolean>} flags
+ * @param {string|undefined} positional optional target dir positional
+ */
+export async function runUpgrade(flags, positional) {
+  const targetDir =
+    (typeof flags["target-dir"] === "string" && flags["target-dir"]) || positional || ".";
+  const projectDir = path.resolve(targetDir);
+
+  const tomlPath = path.join(projectDir, "gradle", "libs.versions.toml");
+  const tomlContent = readIfExists(tomlPath);
+  if (tomlContent === null) {
+    process.stderr.write(
+      `Error: no gradle/libs.versions.toml under ${projectDir}.\n` +
+        `\`create-cmp upgrade\` works on any Gradle project that uses a version catalog — run it from the project root or pass --target-dir.\n`
+    );
+    process.exit(1);
+  }
+
+  const registry = loadRegistry();
+  let set;
+  if (typeof flags.set === "string") {
+    set = getSet(registry, flags.set);
+    if (!set) {
+      process.stderr.write(
+        `Error: unknown version set "${flags.set}". Available: ${registry.sets.map((s) => s.id).join(", ")}\n`
+      );
+      process.exit(1);
+    }
+  } else {
+    set = latestSet(registry);
+  }
+
+  const gradlePropsPath = path.join(projectDir, "gradle.properties");
+  const wrapperPropsPath = path.join(projectDir, "gradle", "wrapper", "gradle-wrapper.properties");
+  const plan = planUpgrade({
+    tomlContent,
+    gradlePropertiesContent: readIfExists(gradlePropsPath),
+    wrapperPropertiesContent: readIfExists(wrapperPropsPath),
+    set,
+  });
+
+  process.stdout.write(
+    `\n${colors.bold("create-cmp upgrade")} — proven-green version set ${colors.cyan(set.id)}` +
+      (set.label ? ` ${colors.dim(`(${set.label})`)}` : "") +
+      `\n  project: ${colors.cyan(projectDir)}\n` +
+      (plan.fromOurTemplate
+        ? `  ${colors.dim("catalog carries the create-cmp frozen-set marker — this project was stamped by create-cmp.")}\n`
+        : `  ${colors.dim("not a create-cmp-stamped catalog — that's fine, upgrade works on any version catalog; review the diff extra carefully.")}\n`) +
+      "\n"
+  );
+
+  // Guardrail FIRST — never even offer to write a broken pairing.
+  if (plan.lockstepError) {
+    fail(`Lockstep guardrail: ${plan.lockstepError}`);
+    process.exit(1);
+  }
+
+  const { changes, unmanaged, notInProject } = plan.diff;
+  if (changes.length === 0) {
+    ok(`Catalog already matches set ${set.id} — nothing to change.`);
+  } else {
+    printDiffTable(changes);
+  }
+  if (plan.propertyChanges.length > 0) {
+    process.stdout.write("\n");
+    for (const p of plan.propertyChanges) {
+      step(
+        `gradle.properties: ${p.key}=${p.to}` +
+          (p.from === null ? colors.dim(" (new)") : colors.dim(` (was ${p.from})`))
+      );
+    }
+  }
+  if (plan.wrapperChange) {
+    step(`gradle wrapper: ${plan.wrapperChange.from} ${colors.dim("→")} ${plan.wrapperChange.to}`);
+  }
+  if (unmanaged.length > 0) {
+    warn(
+      `Left untouched (not in set ${set.id}): ${unmanaged.map((u) => `${u.key} ${u.value}`).join(", ")}`
+    );
+  }
+  if (notInProject.length > 0) {
+    process.stdout.write(
+      colors.dim(`  (set pins ${notInProject.join(", ")} — not declared by this project, nothing added)\n`)
+    );
+  }
+  if (Array.isArray(set.notes) && set.notes.length > 0) {
+    process.stdout.write(`\n${colors.bold("Set notes")}\n`);
+    for (const n of set.notes) process.stdout.write(`  ${colors.dim("·")} ${n}\n`);
+  }
+
+  const anythingToWrite =
+    plan.newTomlContent !== null ||
+    plan.newGradlePropertiesContent !== null ||
+    plan.newWrapperPropertiesContent !== null;
+  if (!anythingToWrite) {
+    ok("Project is fully aligned — nothing to apply.");
+    process.exit(0);
+  }
+
+  if (flags["dry-run"] === true) {
+    process.stdout.write(`\n${colors.yellow("Dry run")} — nothing written. Re-run with --yes to apply.\n`);
+    process.exit(0);
+  }
+
+  const approved = await consent(`\nApply these changes (backups written as *${BACKUP_SUFFIX})?`, {
+    assumeYes: flags.yes === true,
+  });
+  if (!approved) {
+    process.stdout.write(`${colors.yellow("Not applied")} — dry run only. Re-run with --yes to apply.\n`);
+    process.exit(0);
+  }
+
+  // Apply, backing up each file before its first write.
+  const touched = [];
+  const writes = [
+    { path: tomlPath, content: plan.newTomlContent },
+    { path: gradlePropsPath, content: plan.newGradlePropertiesContent },
+    { path: wrapperPropsPath, content: plan.newWrapperPropertiesContent },
+  ];
+  for (const w of writes) {
+    if (w.content === null) continue;
+    fs.copyFileSync(w.path, w.path + BACKUP_SUFFIX);
+    fs.writeFileSync(w.path, w.content);
+    touched.push(w.path);
+    ok(`wrote ${path.relative(projectDir, w.path)} ${colors.dim(`(backup: ${path.relative(projectDir, w.path)}${BACKUP_SUFFIX})`)}`);
+  }
+
+  process.stdout.write(`\n${colors.bold("To revert")}\n`);
+  for (const t of touched) {
+    process.stdout.write(`  mv "${t}${BACKUP_SUFFIX}" "${t}"\n`);
+  }
+
+  if (flagBool(flags, "verify", false)) {
+    process.stdout.write("\n");
+    const { runVerifyCommand } = await import("./verify.mjs");
+    // runVerifyCommand exits the process with the gate's verdict.
+    await runVerifyCommand({ "target-dir": projectDir }, undefined);
+    return;
+  }
+
+  process.stdout.write(
+    `\n${colors.green("Applied.")} Prove the build: ${colors.cyan(`create-cmp verify --target-dir ${targetDir}`)}\n`
+  );
+  process.exit(0);
+}