create-cmp-cli 0.2.0

package/src/commands/verify.mjs

@@ -0,0 +1,94 @@
+// `create-cmp verify` — run the green-build gate against an EXISTING project
+// directory (the same north-star gate the scaffold ends on, exposed
+// standalone). Usage: create-cmp verify [--target-dir .] [--no-ios] [--dry-run]
+//
+// Command resolution order:
+//   1. <project>/manifest.json `verify` block (rare — the scaffold deletes it)
+//   2. the bundled template's manifest.json `verify` block
+//   3. hard fallbacks (./gradlew :composeApp:assembleDebug)
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { flagBool } from "../lib/args.mjs";
+import { runVerify, printVerifyVerdict } from "../lib/verify.mjs";
+import { colors } from "../lib/log.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(__dirname, "..", "..");
+
+const FALLBACK_VERIFY = {
+  android: "./gradlew :composeApp:assembleDebug",
+};
+
+/** Resolve the verify command block for a project dir. */
+export function resolveVerifyCommands(projectDir) {
+  for (const candidate of [
+    path.join(projectDir, "manifest.json"),
+    path.join(REPO_ROOT, "template", "manifest.json"),
+  ]) {
+    try {
+      const manifest = JSON.parse(fs.readFileSync(candidate, "utf8"));
+      if (manifest && manifest.verify && manifest.verify.android) {
+        return { verify: manifest.verify, source: candidate };
+      }
+    } catch {
+      // keep falling through
+    }
+  }
+  return { verify: FALLBACK_VERIFY, source: "built-in fallback" };
+}
+
+/**
+ * @param {Record<string,string|boolean>} flags
+ * @param {string|undefined} positional optional target dir positional
+ */
+export async function runVerifyCommand(flags, positional) {
+  const targetDir =
+    (typeof flags["target-dir"] === "string" && flags["target-dir"]) || positional || ".";
+  const projectDir = path.resolve(targetDir);
+
+  if (!fs.existsSync(projectDir)) {
+    process.stderr.write(`Error: ${projectDir} does not exist.\n`);
+    process.exit(1);
+  }
+  const looksGradle =
+    fs.existsSync(path.join(projectDir, "settings.gradle.kts")) ||
+    fs.existsSync(path.join(projectDir, "settings.gradle")) ||
+    fs.existsSync(path.join(projectDir, "gradlew"));
+  if (!looksGradle) {
+    process.stderr.write(
+      `Error: ${projectDir} does not look like a Gradle project (no settings.gradle[.kts] or gradlew).\n`
+    );
+    process.exit(1);
+  }
+
+  const { verify, source } = resolveVerifyCommands(projectDir);
+
+  // iOS leg runs only when the project actually has an iOS shell (and the user
+  // didn't opt out); runVerify additionally gates on macOS.
+  const hasIosShell = fs.existsSync(path.join(projectDir, "iosApp"));
+  const ios = flagBool(flags, "ios", true) && hasIosShell;
+
+  process.stdout.write(
+    `${colors.bold("create-cmp verify")} — green-build gate\n` +
+      `  project:  ${colors.cyan(projectDir)}\n` +
+      `  commands: ${colors.dim(source)}\n\n`
+  );
+
+  const dryRun = flags["dry-run"] === true;
+  const verdict = await runVerify({
+    projectDir,
+    manifest: { verify },
+    config: { platforms: { ios } },
+    dryRun,
+  });
+  printVerifyVerdict(verdict);
+  if (dryRun) {
+    process.stdout.write(
+      `${colors.yellow("Dry run")} — commands printed, nothing executed; the build is NOT proven.\n`
+    );
+  }
+  process.exit(verdict.green ? 0 : 1);
+}

package/src/doctor.mjs

@@ -0,0 +1,109 @@
+// doctor → bootstrap → verify toolchain installer.
+//
+// Detects the CMP toolchain (JDK 17, Android SDK/cmdline-tools/system-image/AVD,
+// Xcode+CLT, CocoaPods, XcodeGen, Node, Appium 3.x + uiautomator2/xcuitest, adb).
+// For each missing dep: prints the EXACT install command and asks consent
+// (--yes skips prompts for CI). Idempotent (safe to re-run). OS-aware
+// (Linux → Android-only, said explicitly). Xcode can't be CLI-installed — the
+// App Store step is surfaced as the one manual action. Ends with a
+// per-dependency GREEN/FAIL verdict table.
+
+import { checksForHost, hostInfo } from "./bootstrap/checks.mjs";
+import { runInstall } from "./bootstrap/exec.mjs";
+import { colors } from "./lib/log.mjs";
+
+/**
+ * @param {object} opts
+ * @param {boolean} [opts.assumeYes] --yes: auto-approve installs (CI)
+ * @param {boolean} [opts.dryRun] print install commands, don't run them
+ * @param {boolean} [opts.ios] whether iOS support is wanted (gates iOS checks)
+ * @param {boolean} [opts.installMissing=true] attempt installs for missing deps
+ * @returns {Promise<{green:boolean, rows:Array}>}
+ */
+export async function doctor(opts = {}) {
+  const {
+    assumeYes = false,
+    dryRun = false,
+    ios = true,
+    installMissing = true,
+  } = opts;
+
+  process.stdout.write(`\n${colors.bold("create-cmp doctor")} — toolchain preflight\n`);
+  if (hostInfo.isLinux) {
+    process.stdout.write(
+      `${colors.yellow("Linux detected")}: scoping to Android-only (iOS toolchain is macOS-only).\n`
+    );
+  } else if (!hostInfo.isMac) {
+    process.stdout.write(
+      `${colors.yellow("Non-macOS host")}: iOS checks are skipped.\n`
+    );
+  }
+  process.stdout.write("\n");
+
+  const hostChecks = checksForHost({ iosWanted: ios });
+  const rows = [];
+
+  for (const check of hostChecks) {
+    let { present, detail } = check.detect();
+    const cmd = present ? null : check.installCommand({});
+
+    if (present) {
+      process.stdout.write(`${colors.green("✓")} ${check.label} — ${colors.dim(detail)}\n`);
+    } else {
+      process.stdout.write(`${colors.red("✗")} ${check.label} — ${colors.dim(detail)}\n`);
+      if (check.manual && cmd === null) {
+        process.stdout.write(`    ${colors.yellow("manual:")} ${check.manual}\n`);
+      } else if (cmd) {
+        process.stdout.write(`    ${colors.cyan("fix:")} ${cmd}\n`);
+        if (installMissing) {
+          const res = await runInstall({ command: cmd, assumeYes, dryRun });
+          if (res.ran && res.code === 0) {
+            // Re-detect after install (idempotent verify).
+            const after = check.detect();
+            present = after.present;
+            detail = after.detail;
+            if (present) {
+              process.stdout.write(`    ${colors.green("→ now present")} (${detail})\n`);
+            } else {
+              process.stdout.write(
+                `    ${colors.yellow("→ still not detected")} (may need a new shell / PATH export)\n`
+              );
+            }
+          } else if (res.ran && res.code !== 0) {
+            process.stdout.write(`    ${colors.red(`install exited ${res.code}`)}\n`);
+          }
+        }
+      }
+    }
+
+    rows.push({
+      id: check.id,
+      label: check.label,
+      present,
+      detail,
+      manual: !present && check.installCommand({}) === null,
+    });
+  }
+
+  // Verdict table.
+  process.stdout.write(`\n${colors.bold("Verdict")}\n`);
+  let green = true;
+  for (const r of rows) {
+    if (r.present) {
+      process.stdout.write(`  ${colors.green("GREEN")}  ${r.label}\n`);
+    } else if (r.manual) {
+      process.stdout.write(`  ${colors.yellow("MANUAL")} ${r.label}\n`);
+      green = false;
+    } else {
+      process.stdout.write(`  ${colors.red("FAIL ")}  ${r.label}\n`);
+      green = false;
+    }
+  }
+  process.stdout.write(
+    green
+      ? `\n${colors.green("GREEN — toolchain ready.")}\n`
+      : `\n${colors.red("FAIL — toolchain incomplete.")} Re-run after addressing the items above (idempotent).\n`
+  );
+
+  return { green, rows };
+}

package/src/lib/args.mjs

@@ -0,0 +1,38 @@
+// Tiny shared arg parser for the CLI (moved verbatim from bin/create-cmp.mjs
+// when the bin became a thin subcommand dispatcher). No new behavior.
+
+/**
+ * Parse argv into positionals + flags. `--flag value` captures the value;
+ * `--flag` followed by another `--flag` (or nothing) is boolean true.
+ * @param {string[]} argv
+ * @returns {{_: string[], flags: Record<string, string|boolean>}}
+ */
+export function parseArgs(argv) {
+  const args = { _: [], flags: {} };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      const next = argv[i + 1];
+      if (next === undefined || next.startsWith("--")) {
+        args.flags[key] = true; // boolean flag
+      } else {
+        args.flags[key] = next;
+        i++;
+      }
+    } else {
+      args._.push(a);
+    }
+  }
+  return args;
+}
+
+/**
+ * Tri-state boolean flag: `--name`/`--name true` → true, `--no-name`/`--name false`
+ * → false, otherwise the default.
+ */
+export function flagBool(flags, name, dflt) {
+  if (flags[name] === true || flags[name] === "true") return true;
+  if (flags[`no-${name}`] === true || flags[name] === "false") return false;
+  return dflt;
+}

package/src/lib/clean.mjs

@@ -0,0 +1,72 @@
+// Pure selection logic for `create-cmp clean`. The command layer does the
+// listing/sizing/deleting; this module decides WHAT is safe to remove, so the
+// policy is unit-testable against fake directory listings.
+//
+// Policy (deliberately conservative):
+//   - ~/.konan: only "clearly stale" entries — kotlin-native toolchain dirs
+//     whose trailing version does NOT match the project's kotlin version.
+//     Shared dirs (dependencies/, cache/, kotlin-native-prebuilt-<current>)
+//     are never selected. No known project kotlin version → nothing is stale.
+//   - project: only `build/` dirs that sit next to a build.gradle(.kts) (i.e.
+//     real Gradle module outputs) plus the root `.gradle/` dir.
+//   - ~/.gradle/caches: REPORT ONLY, never auto-deleted.
+
+/** kotlin-native toolchain dir with a trailing version, e.g.
+ *  kotlin-native-prebuilt-macos-aarch64-2.1.20 */
+const KONAN_TOOLCHAIN_RE = /^kotlin-native(?:-prebuilt)?(?:-[a-z0-9_]+)*?-(\d+\.\d+(?:\.\d+)?(?:-[A-Za-z0-9.]+)?)$/;
+
+/**
+ * Which ~/.konan entries are clearly stale?
+ * @param {string[]} entries directory names inside ~/.konan
+ * @param {string|null|undefined} projectKotlinVersion the project's kotlin version
+ * @returns {{stale:string[], kept:Array<{name:string, reason:string}>}}
+ */
+export function selectStaleKonan(entries, projectKotlinVersion) {
+  const stale = [];
+  const kept = [];
+  for (const name of entries) {
+    const m = name.match(KONAN_TOOLCHAIN_RE);
+    if (!m) {
+      kept.push({ name, reason: "not a versioned kotlin-native toolchain dir (shared cache — never touched)" });
+      continue;
+    }
+    if (!projectKotlinVersion) {
+      kept.push({ name, reason: "project kotlin version unknown — cannot prove staleness" });
+      continue;
+    }
+    if (m[1] === projectKotlinVersion) {
+      kept.push({ name, reason: `matches the project's kotlin ${projectKotlinVersion}` });
+    } else {
+      stale.push(name);
+    }
+  }
+  return { stale, kept };
+}
+
+/**
+ * Which project-relative paths are safe Gradle outputs to delete?
+ * @param {object} input
+ * @param {string[]} input.dirs   ALL directory paths in the project, RELATIVE with "/" separators
+ * @param {string[]} input.files  ALL file paths in the project, RELATIVE with "/" separators
+ * @returns {string[]} relative dir paths safe to delete (root `.gradle` + module `build` dirs)
+ */
+export function selectProjectCleanDirs({ dirs, files }) {
+  const fileSet = new Set(files);
+  const out = [];
+  for (const dir of dirs) {
+    if (dir === ".gradle") {
+      out.push(dir);
+      continue;
+    }
+    const segments = dir.split("/");
+    if (segments[segments.length - 1] !== "build") continue;
+    // Never reach inside another build dir or hidden/vendored trees.
+    if (segments.slice(0, -1).some((s) => s === "build" || s === "node_modules" || s.startsWith("."))) continue;
+    const parent = segments.slice(0, -1).join("/");
+    const sibling = (name) => (parent ? `${parent}/${name}` : name);
+    if (fileSet.has(sibling("build.gradle.kts")) || fileSet.has(sibling("build.gradle")) || fileSet.has(sibling("settings.gradle.kts")) || fileSet.has(sibling("settings.gradle"))) {
+      out.push(dir);
+    }
+  }
+  return out;
+}

package/src/lib/fsutil.mjs

@@ -0,0 +1,90 @@
+// Filesystem helpers: recursive copy and a text-file walker.
+
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Recursively copy srcDir → destDir, creating dest dirs as needed.
+ * Symlinks are copied as symlinks. Existing dest files are overwritten.
+ * @param {string} srcDir
+ * @param {string} destDir
+ */
+export function copyDir(srcDir, destDir) {
+  fs.mkdirSync(destDir, { recursive: true });
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    const s = path.join(srcDir, entry.name);
+    const d = path.join(destDir, entry.name);
+    if (entry.isSymbolicLink()) {
+      const link = fs.readlinkSync(s);
+      try { fs.unlinkSync(d); } catch {}
+      fs.symlinkSync(link, d);
+    } else if (entry.isDirectory()) {
+      copyDir(s, d);
+    } else {
+      fs.copyFileSync(s, d);
+    }
+  }
+}
+
+/**
+ * Yield absolute paths of every regular file under dir (recursive).
+ * @param {string} dir
+ * @returns {string[]}
+ */
+export function listFiles(dir) {
+  const out = [];
+  const stack = [dir];
+  while (stack.length) {
+    const cur = stack.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(cur, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      const full = path.join(cur, e.name);
+      if (e.isDirectory()) stack.push(full);
+      else if (e.isFile()) out.push(full);
+    }
+  }
+  return out;
+}
+
+/**
+ * Yield absolute paths of every directory under dir (recursive), DEEPEST FIRST
+ * (so path-token renames of nested dirs are safe to apply bottom-up).
+ * @param {string} dir
+ * @returns {string[]}
+ */
+export function listDirsDeepestFirst(dir) {
+  const out = [];
+  const stack = [dir];
+  while (stack.length) {
+    const cur = stack.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(cur, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (e.isDirectory()) {
+        const full = path.join(cur, e.name);
+        out.push(full);
+        stack.push(full);
+      }
+    }
+  }
+  // Deepest first = longest path first.
+  out.sort((a, b) => b.length - a.length);
+  return out;
+}
+
+export function isMacOS() {
+  return process.platform === "darwin";
+}
+
+export function isLinux() {
+  return process.platform === "linux";
+}

package/src/lib/log.mjs

@@ -0,0 +1,40 @@
+// Thin logging helper with optional color. Falls back gracefully if picocolors
+// isn't installed (so the engine still works zero-dep in a pinch).
+
+let pc;
+try {
+  pc = (await import("picocolors")).default;
+} catch {
+  const identity = (s) => s;
+  pc = {
+    green: identity, red: identity, yellow: identity, cyan: identity,
+    dim: identity, bold: identity, blue: identity, magenta: identity,
+    gray: identity,
+  };
+}
+
+export const colors = pc;
+
+export function info(msg) {
+  process.stdout.write(`${msg}\n`);
+}
+
+export function ok(msg) {
+  process.stdout.write(`${pc.green("✓")} ${msg}\n`);
+}
+
+export function warn(msg) {
+  process.stdout.write(`${pc.yellow("!")} ${msg}\n`);
+}
+
+export function fail(msg) {
+  process.stdout.write(`${pc.red("✗")} ${msg}\n`);
+}
+
+export function step(msg) {
+  process.stdout.write(`${pc.cyan("›")} ${msg}\n`);
+}
+
+export function dim(msg) {
+  process.stdout.write(`${pc.dim(msg)}\n`);
+}