create-cmp-cli 0.2.0

package/src/lib/toggle.mjs

@@ -0,0 +1,130 @@
+// Feature toggling: strip `cmp:feature <name>` marker blocks for DISABLED
+// features from file contents, and delete the feature's manifest `paths`.
+//
+// Marker syntax (CONTRACT.md):
+//   // >>> cmp:feature ios
+//   ...lines to remove when `ios` is disabled...
+//   // <<< cmp:feature ios
+//
+// The comment leader is language-agnostic — we match the `>>> cmp:feature` /
+// `<<< cmp:feature` tokens anywhere on the line, so `//`, `#`, `<!--`, `;` etc.
+// all work. Blocks may nest for different features; we strip per-feature.
+
+import fs from "node:fs";
+import path from "node:path";
+
+// The captured name may carry a leading `!` (negation): a `!foo` block is kept
+// ONLY when feature `foo` is DISABLED (and removed when enabled) — the inverse
+// of a plain `foo` block. The `!` is part of the capture so both open and close
+// markers agree on the same token.
+const OPEN_RE = />>>\s*cmp:feature\s+(!?[A-Za-z0-9_-]+)/;
+const CLOSE_RE = /<<<\s*cmp:feature\s+(!?[A-Za-z0-9_-]+)/;
+
+/**
+ * Strip marker blocks for the given disabled feature names from a single
+ * text body. Lines containing the open/close markers for those features are
+ * removed along with their enclosed content. Markers for STILL-ENABLED
+ * features are left untouched (their marker comment lines are also removed,
+ * so the shipped output has no leftover marker noise).
+ *
+ * @param {string} content
+ * @param {Set<string>|string[]} disabledFeatures features to strip
+ * @returns {{content: string, changed: boolean}}
+ */
+export function stripFeatureBlocks(content, disabledFeatures) {
+  const disabled = disabledFeatures instanceof Set
+    ? disabledFeatures
+    : new Set(disabledFeatures);
+
+  const lines = content.split("\n");
+  const out = [];
+  // Stack of {feature, dropping} for currently-open blocks.
+  const stack = [];
+  let changed = false;
+
+  for (const line of lines) {
+    const open = line.match(OPEN_RE);
+    const close = line.match(CLOSE_RE);
+
+    if (open) {
+      const token = open[1];
+      const negated = token.startsWith("!");
+      const feature = negated ? token.slice(1) : token;
+      const parentDropping = stack.some((f) => f.dropping);
+      // Plain block: drop when the feature is disabled.
+      // Negated (!feature) block: drop when the feature is ENABLED.
+      const selfDropping = negated ? !disabled.has(feature) : disabled.has(feature);
+      const dropping = parentDropping || selfDropping;
+      stack.push({ token, dropping });
+      changed = true; // marker comment line itself is always removed
+      continue; // never emit the marker line
+    }
+
+    if (close) {
+      const token = close[1];
+      // Pop the matching frame (search from top for safety).
+      for (let i = stack.length - 1; i >= 0; i--) {
+        if (stack[i].token === token) {
+          stack.splice(i, 1);
+          break;
+        }
+      }
+      changed = true; // marker comment line removed
+      continue;
+    }
+
+    const dropping = stack.some((f) => f.dropping);
+    if (dropping) {
+      changed = true;
+      continue; // drop enclosed line
+    }
+    out.push(line);
+  }
+
+  return { content: out.join("\n"), changed };
+}
+
+/**
+ * Map an engine config object to the set of DISABLED feature names that the
+ * manifest understands: ios, firebase, room, appium, inspector, dev-client.
+ * @param {object} config
+ * @returns {Set<string>}
+ */
+export function disabledFeaturesFromConfig(config) {
+  const disabled = new Set();
+  if (!config.platforms?.ios) disabled.add("ios");
+  if (!config.firebase?.enabled) disabled.add("firebase");
+  if (!config.room) disabled.add("room");
+  if (!config.appium) disabled.add("appium");
+  if (!config.inspector) disabled.add("inspector");
+  if (!config.devClient) disabled.add("dev-client");
+  return disabled;
+}
+
+/**
+ * Delete the filesystem paths declared for each disabled feature in the
+ * manifest. Paths are relative to projectDir; missing paths are ignored.
+ * @param {string} projectDir
+ * @param {object} manifest
+ * @param {Set<string>} disabledFeatures
+ * @param {(msg:string)=>void} [log]
+ * @returns {string[]} deleted relative paths
+ */
+export function deleteDisabledFeaturePaths(projectDir, manifest, disabledFeatures, log = () => {}) {
+  const deleted = [];
+  const features = manifest.features || {};
+  for (const name of disabledFeatures) {
+    const feature = features[name];
+    if (!feature || !Array.isArray(feature.paths)) continue;
+    for (const rel of feature.paths) {
+      if (rel === "..." || !rel) continue; // contract placeholder, skip
+      const abs = path.join(projectDir, rel);
+      if (fs.existsSync(abs)) {
+        fs.rmSync(abs, { recursive: true, force: true });
+        deleted.push(rel);
+        log(`  removed ${rel} (feature '${name}' disabled)`);
+      }
+    }
+  }
+  return deleted;
+}

package/src/lib/tokens.mjs

@@ -0,0 +1,96 @@
+// Token derivation + replacement for file CONTENTS and PATHS.
+//
+// Per CONTRACT.md, the engine replaces these placeholder tokens:
+//   __APP_NAME__ · __PACKAGE__ · __PACKAGE_PATH__ · __IOS_BUNDLE_ID__ · __REGION__ · __THEME_PREFIX__
+//
+// The replacement is applied to both the bytes of every text file and to path
+// segments. Path replacement deliberately handles __PACKAGE_PATH__ even though
+// the actual package-source directory rename (com/example/app → com/acme/app) is
+// done separately by lib/rename.mjs against manifest.packageSourceRoots — see
+// CONTRACT note that source dirs use the literal `com/example/app` segment.
+
+/**
+ * Build the ordered token map from an engine config object.
+ * @param {object} config
+ * @returns {Array<[string,string]>} ordered [token, value] pairs
+ */
+export function buildTokenMap(config) {
+  const packagePath = config.package.replace(/\./g, "/");
+  return [
+    ["__APP_NAME__", config.appName],
+    ["__PACKAGE_PATH__", packagePath],
+    ["__PACKAGE__", config.package],
+    ["__IOS_BUNDLE_ID__", config.iosBundleId],
+    ["__REGION__", config.region],
+    ["__THEME_PREFIX__", config.themePrefix],
+  ];
+}
+
+/**
+ * Slugify an app display name into a Gradle/npm-safe identifier.
+ * Gradle's `rootProject.name` must match [a-zA-Z]([A-Za-z0-9\-_])* (no spaces);
+ * npm package names must be lowercase with no spaces. We collapse runs of
+ * non-[A-Za-z0-9] to a single dash, trim leading/trailing dashes, and guarantee
+ * a leading letter. e.g. "Demo App" -> "Demo-App", "42 Things!" -> "x42-Things".
+ * @param {string} name
+ * @returns {string}
+ */
+export function slugifyAppName(name) {
+  let slug = String(name)
+    .trim()
+    .replace(/[^A-Za-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  if (slug === "") slug = "app";
+  if (!/^[A-Za-z]/.test(slug)) slug = `x${slug}`;
+  return slug;
+}
+
+/**
+ * Replace every token occurrence in a string.
+ * Tokens are literal (`__FOO__`) so a global string split/join is safe and
+ * avoids regex-escaping pitfalls. Order matters only when one token is a
+ * substring of another; our tokens are disjoint, but we still apply in the
+ * given order for determinism.
+ * @param {string} input
+ * @param {Array<[string,string]>} tokenMap
+ * @returns {string}
+ */
+export function replaceTokens(input, tokenMap) {
+  let out = input;
+  for (const [token, value] of tokenMap) {
+    if (out.includes(token)) {
+      out = out.split(token).join(value);
+    }
+  }
+  return out;
+}
+
+/**
+ * Replace tokens within a single path string. Identical to replaceTokens but
+ * named for intent + future divergence (e.g. OS path separators).
+ * @param {string} p
+ * @param {Array<[string,string]>} tokenMap
+ * @returns {string}
+ */
+export function replacePathTokens(p, tokenMap) {
+  return replaceTokens(p, tokenMap);
+}
+
+// Heuristic: skip binary files when doing content replacement.
+const BINARY_EXTENSIONS = new Set([
+  ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".icns",
+  ".ttf", ".otf", ".woff", ".woff2", ".eot",
+  ".jar", ".keystore", ".jks", ".so", ".dylib", ".a", ".zip",
+  ".class", ".bin", ".pdf", ".aar",
+]);
+
+/**
+ * @param {string} filename
+ * @returns {boolean} true if the file should be treated as binary (skip content replace)
+ */
+export function isBinaryPath(filename) {
+  const lower = filename.toLowerCase();
+  const dot = lower.lastIndexOf(".");
+  if (dot === -1) return false;
+  return BINARY_EXTENSIONS.has(lower.slice(dot));
+}

package/src/lib/toml.mjs

@@ -0,0 +1,137 @@
+// Tolerant, line-based reader/writer for TOML *sections* as used by Gradle
+// version catalogs (gradle/libs.versions.toml).
+//
+// This is deliberately NOT a general TOML parser — the dependency ethos of this
+// CLI is "prompts + picocolors, nothing else". It handles exactly what a
+// version catalog's `[versions]` table contains: `key = "value"` string entries
+// with comments and blank lines, and it can rewrite values SURGICALLY (only the
+// quoted value on the matched line changes; every other byte of the file —
+// comments, spacing, ordering, line endings — is preserved).
+
+/** Matches `key = "value"` (or 'value') with optional whitespace. */
+const ENTRY_RE = /^(\s*)([A-Za-z0-9_][A-Za-z0-9_.-]*)(\s*=\s*)(["'])([^"']*)\4/;
+
+/**
+ * Split content on "\n" ONLY, so any "\r" stays attached to its line and a
+ * join("\n") reproduces the input byte-for-byte.
+ */
+function splitLines(content) {
+  return content.split("\n");
+}
+
+/**
+ * Parse one `[section]` table out of a TOML document.
+ * @param {string} content
+ * @param {string} section e.g. "versions"
+ * @returns {Map<string, {value:string, line:number, quote:string}>}
+ *   Ordered map of key → { value, line index (0-based), quote char }.
+ */
+export function parseTomlSection(content, section) {
+  const lines = splitLines(content);
+  const entries = new Map();
+  let inSection = false;
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed.startsWith("[")) {
+      inSection = trimmed.replace(/\r$/, "") === `[${section}]`;
+      continue;
+    }
+    if (!inSection || !trimmed || trimmed.startsWith("#")) continue;
+    const m = lines[i].match(ENTRY_RE);
+    if (!m) continue; // tolerate inline tables / anything exotic: skip, don't throw
+    entries.set(m[2], { value: m[5], line: i, quote: m[4] });
+  }
+  return entries;
+}
+
+/**
+ * Parse the `[versions]` table of a libs.versions.toml.
+ * @param {string} content
+ * @returns {Map<string, {value:string, line:number, quote:string}>}
+ */
+export function parseVersions(content) {
+  return parseTomlSection(content, "versions");
+}
+
+/**
+ * Surgically rewrite values in one section. Only the quoted value on each
+ * matched line is replaced; all other bytes (including trailing comments on
+ * the same line) are untouched.
+ * @param {string} content
+ * @param {string} section
+ * @param {Record<string,string>} changes key → new value
+ * @returns {{content:string, applied:string[], missing:string[]}}
+ */
+export function updateTomlValues(content, section, changes) {
+  const entries = parseTomlSection(content, section);
+  const lines = splitLines(content);
+  const applied = [];
+  const missing = [];
+  for (const [key, newValue] of Object.entries(changes)) {
+    const e = entries.get(key);
+    if (!e) {
+      missing.push(key);
+      continue;
+    }
+    const line = lines[e.line];
+    const m = line.match(ENTRY_RE);
+    if (!m) {
+      missing.push(key);
+      continue;
+    }
+    const before = m[1] + m[2] + m[3] + m[4];
+    const rest = line.slice(m[0].length); // closing-quote onward is inside m[0]; rest = after value's closing quote
+    lines[e.line] = `${before}${newValue}${m[4]}${rest}`;
+    applied.push(key);
+  }
+  return { content: lines.join("\n"), applied, missing };
+}
+
+/**
+ * Read a `key=value` java-properties-style file into an ordered map (used for
+ * gradle.properties / gradle-wrapper.properties / local.properties).
+ * Escaped chars in values are left as-is (raw text).
+ * @param {string} content
+ * @returns {Map<string, {value:string, line:number}>}
+ */
+export function parseProperties(content) {
+  const lines = splitLines(content);
+  const entries = new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("!")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq <= 0) continue;
+    const key = trimmed.slice(0, eq).trim();
+    const value = trimmed.slice(eq + 1).trim().replace(/\r$/, "");
+    entries.set(key, { value, line: i });
+  }
+  return entries;
+}
+
+/**
+ * Set (replace or append) one key in a properties file, preserving every other
+ * line byte-for-byte.
+ * @param {string} content
+ * @param {string} key
+ * @param {string} value raw value text (caller escapes if needed)
+ * @returns {{content:string, changed:boolean, previous:string|null}}
+ */
+export function upsertProperty(content, key, value) {
+  const entries = parseProperties(content);
+  const lines = splitLines(content);
+  const existing = entries.get(key);
+  if (existing) {
+    if (existing.value === value) {
+      return { content, changed: false, previous: existing.value };
+    }
+    const hadCr = lines[existing.line].endsWith("\r");
+    lines[existing.line] = `${key}=${value}${hadCr ? "\r" : ""}`;
+    return { content: lines.join("\n"), changed: true, previous: existing.value };
+  }
+  // Append, keeping a single trailing newline.
+  let out = content;
+  if (out.length > 0 && !out.endsWith("\n")) out += "\n";
+  out += `${key}=${value}\n`;
+  return { content: out, changed: true, previous: null };
+}

package/src/lib/upgrade.mjs

@@ -0,0 +1,159 @@
+// Core logic for `create-cmp upgrade`: diff a project's [versions] table
+// against a proven-green registry set, guard the kotlin↔ksp lockstep, and
+// apply the changes SURGICALLY (line edits via lib/toml.mjs — formatting,
+// comments, and unrelated lines are preserved byte-for-byte). Pure functions
+// here; filesystem orchestration lives in src/commands/upgrade.mjs.
+
+import { parseVersions, updateTomlValues, upsertProperty, parseProperties } from "./toml.mjs";
+
+export const BACKUP_SUFFIX = ".bak-upgrade";
+
+/** Marker comment the golden template ships in libs.versions.toml. */
+const TEMPLATE_MARKER = "Frozen, CI-verified version set";
+
+/** Was this catalog stamped by create-cmp? (Messaging only — never a refusal.) */
+export function looksLikeOurTemplate(tomlContent) {
+  return tomlContent.includes(TEMPLATE_MARKER);
+}
+
+/**
+ * Diff a parsed [versions] table against a registry set.
+ * @param {Map<string,{value:string}>} projectVersions from parseVersions()
+ * @param {object} set registry set ({versions: {...}})
+ * @returns {{changes:Array<{key,from,to}>, same:string[],
+ *            unmanaged:Array<{key,value}>, notInProject:string[]}}
+ *  - changes: keys the set pins to a different value (would be rewritten)
+ *  - same: keys already at the set's value
+ *  - unmanaged: keys in the project the set doesn't know — LEFT UNTOUCHED, warned
+ *  - notInProject: set keys the project doesn't declare — nothing is added
+ */
+export function diffAgainstSet(projectVersions, set) {
+  const changes = [];
+  const same = [];
+  const unmanaged = [];
+  const notInProject = [];
+  for (const [key, entry] of projectVersions) {
+    if (Object.prototype.hasOwnProperty.call(set.versions, key)) {
+      if (set.versions[key] !== entry.value) {
+        changes.push({ key, from: entry.value, to: set.versions[key] });
+      } else {
+        same.push(key);
+      }
+    } else {
+      unmanaged.push({ key, value: entry.value });
+    }
+  }
+  for (const key of Object.keys(set.versions)) {
+    if (!projectVersions.has(key)) notInProject.push(key);
+  }
+  return { changes, same, unmanaged, notInProject };
+}
+
+/**
+ * The [versions] values the file WOULD contain after applying `changes`.
+ * @param {Map<string,{value:string}>} projectVersions
+ * @param {Array<{key,to}>} changes
+ * @returns {Record<string,string>}
+ */
+export function resultingVersions(projectVersions, changes) {
+  const out = {};
+  for (const [key, entry] of projectVersions) out[key] = entry.value;
+  for (const c of changes) out[c.key] = c.to;
+  return out;
+}
+
+/**
+ * Lockstep guardrail: ksp must be `<kotlin>-<kspVersion>`. Returns a
+ * human-readable violation string, or null when consistent (or when either
+ * key is absent — nothing to check).
+ * @param {Record<string,string>} versions
+ * @returns {string|null}
+ */
+export function lockstepViolation(versions) {
+  const kotlin = versions.kotlin;
+  const ksp = versions.ksp;
+  if (!kotlin || !ksp) return null;
+  if (!ksp.startsWith(`${kotlin}-`)) {
+    return (
+      `kotlin ${kotlin} and ksp ${ksp} are OUT OF LOCKSTEP — ksp must be ` +
+      `"${kotlin}-<kspVersion>" (e.g. "${kotlin}-2.0.4"). Refusing to write a broken pairing.`
+    );
+  }
+  return null;
+}
+
+/**
+ * Compute the full upgrade plan for one catalog + optional gradle.properties +
+ * optional wrapper properties. Pure — no filesystem.
+ * @param {object} params
+ * @param {string} params.tomlContent gradle/libs.versions.toml text
+ * @param {string|null} params.gradlePropertiesContent gradle.properties text (null = absent)
+ * @param {string|null} params.wrapperPropertiesContent gradle-wrapper.properties text (null = absent)
+ * @param {object} params.set registry set
+ * @returns {{
+ *   diff: ReturnType<typeof diffAgainstSet>,
+ *   lockstepError: string|null,
+ *   newTomlContent: string|null,
+ *   propertyChanges: Array<{key,from,to}>,
+ *   newGradlePropertiesContent: string|null,
+ *   wrapperChange: {from:string,to:string}|null,
+ *   newWrapperPropertiesContent: string|null,
+ *   fromOurTemplate: boolean
+ * }}
+ */
+export function planUpgrade({ tomlContent, gradlePropertiesContent, wrapperPropertiesContent, set }) {
+  const projectVersions = parseVersions(tomlContent);
+  const diff = diffAgainstSet(projectVersions, set);
+  const resulting = resultingVersions(projectVersions, diff.changes);
+  const lockstepError = lockstepViolation(resulting);
+
+  let newTomlContent = null;
+  if (!lockstepError && diff.changes.length > 0) {
+    const changeMap = Object.fromEntries(diff.changes.map((c) => [c.key, c.to]));
+    newTomlContent = updateTomlValues(tomlContent, "versions", changeMap).content;
+  }
+
+  // gradle.properties flags the set requires (e.g. ksp.useKSP2=true).
+  const propertyChanges = [];
+  let newGradlePropertiesContent = null;
+  if (!lockstepError && set.gradleProperties && gradlePropertiesContent !== null) {
+    let content = gradlePropertiesContent;
+    const existing = parseProperties(gradlePropertiesContent);
+    for (const [key, value] of Object.entries(set.gradleProperties)) {
+      const cur = existing.get(key);
+      if (!cur || cur.value !== value) {
+        const r = upsertProperty(content, key, value);
+        content = r.content;
+        propertyChanges.push({ key, from: cur ? cur.value : null, to: value });
+      }
+    }
+    if (propertyChanges.length > 0) newGradlePropertiesContent = content;
+  }
+
+  // Gradle wrapper distributionUrl, when the set pins one.
+  let wrapperChange = null;
+  let newWrapperPropertiesContent = null;
+  if (!lockstepError && set.gradleWrapper?.distributionUrl && wrapperPropertiesContent !== null) {
+    const props = parseProperties(wrapperPropertiesContent);
+    const cur = props.get("distributionUrl");
+    const targetRaw = set.gradleWrapper.distributionUrl;
+    const targetEscaped = targetRaw.replace(/:/g, "\\:");
+    const curUnescaped = cur ? cur.value.replace(/\\:/g, ":") : null;
+    if (cur && curUnescaped !== targetRaw) {
+      const r = upsertProperty(wrapperPropertiesContent, "distributionUrl", targetEscaped);
+      newWrapperPropertiesContent = r.content;
+      wrapperChange = { from: curUnescaped, to: targetRaw };
+    }
+  }
+
+  return {
+    diff,
+    lockstepError,
+    newTomlContent,
+    propertyChanges,
+    newGradlePropertiesContent,
+    wrapperChange,
+    newWrapperPropertiesContent,
+    fromOurTemplate: looksLikeOurTemplate(tomlContent),
+  };
+}

package/src/lib/verify.mjs

@@ -0,0 +1,97 @@
+// North-star gate: run manifest.verify commands and return GREEN/FAIL.
+//
+// verify.android runs always; verify.ios runs only on macOS when iOS is
+// enabled. Success is PROVEN by a build, not assumed — the CLI refuses to
+// claim success without this (unless --no-verify).
+
+import { spawn } from "node:child_process";
+import { isMacOS } from "./fsutil.mjs";
+import { colors } from "./log.mjs";
+
+/**
+ * Run a single shell command in `cwd`, streaming output. Resolves with the
+ * exit code.
+ * @param {string} command
+ * @param {string} cwd
+ * @returns {Promise<{code:number, command:string}>}
+ */
+function runCommand(command, cwd) {
+  return new Promise((resolve) => {
+    const child = spawn(command, {
+      cwd,
+      shell: true,
+      stdio: "inherit",
+      env: process.env,
+    });
+    child.on("close", (code) => resolve({ code: code ?? 1, command }));
+    child.on("error", () => resolve({ code: 127, command }));
+  });
+}
+
+/**
+ * Run the verify gate for the stamped project.
+ * @param {object} params
+ * @param {string} params.projectDir
+ * @param {object} params.manifest manifest.json (must have .verify)
+ * @param {object} params.config engine config (uses platforms.ios)
+ * @param {boolean} [params.dryRun] when true, print commands but don't run
+ * @returns {Promise<{green:boolean, results:Array<{platform:string,command:string,code:number,ran:boolean}>}>}
+ */
+export async function runVerify({ projectDir, manifest, config, dryRun = false }) {
+  const verify = (manifest && manifest.verify) || {};
+  const results = [];
+
+  const plan = [];
+  if (verify.android) plan.push({ platform: "android", command: verify.android, eligible: true });
+  if (verify.ios) {
+    const eligible = isMacOS() && !!config?.platforms?.ios;
+    plan.push({ platform: "ios", command: verify.ios, eligible });
+  }
+
+  if (plan.length === 0) {
+    return { green: false, results, reason: "no verify commands in manifest" };
+  }
+
+  let green = true;
+  for (const item of plan) {
+    if (!item.eligible) {
+      results.push({ platform: item.platform, command: item.command, code: 0, ran: false });
+      process.stdout.write(
+        `${colors.yellow("skip")} verify.${item.platform} (not eligible on this host/config)\n`
+      );
+      continue;
+    }
+    process.stdout.write(`${colors.cyan("›")} verify.${item.platform}: ${item.command}\n`);
+    if (dryRun) {
+      results.push({ platform: item.platform, command: item.command, code: 0, ran: false });
+      continue;
+    }
+    const { code } = await runCommand(item.command, projectDir);
+    results.push({ platform: item.platform, command: item.command, code, ran: true });
+    if (code !== 0) green = false;
+  }
+
+  return { green, results };
+}
+
+/**
+ * Pretty-print the verify verdict table.
+ * @param {{green:boolean, results:Array}} verdict
+ */
+export function printVerifyVerdict(verdict) {
+  process.stdout.write("\n");
+  for (const r of verdict.results) {
+    if (!r.ran) {
+      process.stdout.write(`  ${colors.dim("·")} ${r.platform.padEnd(8)} ${colors.dim("skipped")}\n`);
+    } else if (r.code === 0) {
+      process.stdout.write(`  ${colors.green("GREEN")} ${r.platform}\n`);
+    } else {
+      process.stdout.write(`  ${colors.red("FAIL ")} ${r.platform} (exit ${r.code})\n`);
+    }
+  }
+  process.stdout.write(
+    verdict.green
+      ? `\n${colors.green("GREEN — build proven.")}\n`
+      : `\n${colors.red("FAIL — build did not go green.")}\n`
+  );
+}